Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,600 | CWE-000 static int virNWFilterDetermineMissingVarsRec ( virNWFilterDefPtr filter , virNWFilterHashTablePtr vars , virNWFilterHashTablePtr missing_vars , int useNewFilter , virNWFilterDriverStatePtr driver ) { virNWFilterObjPtr obj ; int rc = 0 ; size_t i , j ; virNWFilterDefPtr next_filter ; virNWFilterDefPtr newNext_filter ; virNWFilterVarValuePtr val ; virNWFilterHashTablePtr tmpvars ; for ( i = 0 ; i < filter -> nentries ; i ++ ) { virNWFilterRuleDefPtr rule = filter -> filterEntries [ i ] -> rule ; virNWFilterIncludeDefPtr inc = filter -> filterEntries [ i ] -> include ; if ( rule ) { for ( j = 0 ; j < rule -> nVarAccess ; j ++ ) { if ( ! virNWFilterVarAccessIsAvailable ( rule -> varAccess [ j ] , vars ) ) { char * varAccess ; virBuffer buf = VIR_BUFFER_INITIALIZER ; virNWFilterVarAccessPrint ( rule -> varAccess [ j ] , & buf ) ; if ( virBufferError ( & buf ) ) { virReportOOMError ( ) ; return - 1 ; } val = virNWFilterVarValueCreateSimpleCopyValue ( "1" ) ; if ( ! val ) { virBufferFreeAndReset ( & buf ) ; return - 1 ; } varAccess = virBufferContentAndReset ( & buf ) ; <S2SV_StartBug> virNWFilterHashTablePut ( missing_vars , varAccess , <S2SV_EndBug> val ) ; <S2SV_StartBug> VIR_FREE ( varAccess ) ; <S2SV_EndBug> } } } else if ( inc ) { VIR_DEBUG ( "Following<S2SV_blank>filter<S2SV_blank>%s" , inc -> filterref ) ; if ( ! ( obj = virNWFilterObjListFindInstantiateFilter ( driver -> nwfilters , inc -> filterref ) ) ) return - 1 ; if ( ! ( tmpvars = virNWFilterCreateVarsFrom ( inc -> params , vars ) ) ) { virNWFilterObjUnlock ( obj ) ; return - 1 ; } next_filter = virNWFilterObjGetDef ( obj ) ; switch ( useNewFilter ) { case INSTANTIATE_FOLLOW_NEWFILTER : newNext_filter = virNWFilterObjGetNewDef ( obj ) ; if ( newNext_filter ) next_filter = newNext_filter ; break ; case INSTANTIATE_ALWAYS : break ; } rc = virNWFilterDetermineMissingVarsRec ( next_filter , tmpvars , missing_vars , useNewFilter , driver ) ; virNWFilterHashTableFree ( tmpvars ) ; virNWFilterObjUnlock ( obj ) ; if ( rc < 0 ) return - 1 ; } } return 0 ; } | <S2SV_ModStart> buf ) ; rc = <S2SV_ModStart> varAccess ) ; if ( rc < 0 ) { virNWFilterVarValueFree ( val ) ; return - 1 ; } |
2,601 | CWE-000 bool isMyKingSafe ( boardGame * board ) { assert ( board != NULL ) ; bool safe = false ; int position = - 1 ; if ( board -> curPlayer == 1 ) { position = trackKingPosition ( board , WhiteKing ) ; if ( position == - 1 ) { <S2SV_StartBug> printf ( "ERROR:<S2SV_blank>whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found" ) ; <S2SV_EndBug> return true ; } safe = safeArea ( board , position , WhiteKing ) ; } else if ( board -> curPlayer == 0 ) { position = trackKingPosition ( board , BlackKing ) ; if ( position == - 1 ) { <S2SV_StartBug> printf ( "ERROR:<S2SV_blank>whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found" ) ; <S2SV_EndBug> return true ; } safe = safeArea ( board , position , BlackKing ) ; } return safe ; } | <S2SV_ModStart> { printf ( "ERROR:<S2SV_blank>whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> { printf ( "ERROR:<S2SV_blank>whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found\\n" <S2SV_ModEnd> ) ; return |
2,602 | CWE-000 static bool match ( const char expected ) { if ( isAtEnd ( ) || peek ( ) != expected ) return false ; advance ( ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; return true <S2SV_ModEnd> ; } <S2SV_null> |
2,603 | CWE-000 static int webclient_sethttpheader ( lua_State * l ) { struct webclient * webclient = ( struct webclient * ) luaL_checkudata ( l , 1 , LUA_WEB_CLIENT_MT ) ; if ( ! webclient ) return luaL_argerror ( l , 1 , "parameter<S2SV_blank>self<S2SV_blank>invalid" ) ; struct webrequest * webrequest = ( struct webrequest * ) lua_touserdata ( l , 2 ) ; if ( ! webrequest ) return luaL_argerror ( l , 2 , "parameter<S2SV_blank>index<S2SV_blank>invalid" ) ; <S2SV_StartBug> int top = lua_gettop ( l ) ; <S2SV_EndBug> <S2SV_StartBug> for ( int i = 3 ; i <= top ; ++ i ) { <S2SV_EndBug> const char * str = lua_tostring ( l , i ) ; webrequest -> header = curl_slist_append ( webrequest -> header , str ) ; } if ( webrequest -> header ) { curl_easy_setopt ( webrequest -> curl , CURLOPT_HTTPHEADER , webrequest -> header ) ; } return 0 ; } | <S2SV_ModStart> ) ; int i ; int <S2SV_ModStart> ; for ( <S2SV_ModEnd> i = 3 |
2,604 | CWE-000 static struct vdev * alloc_and_init_vdev ( struct vm * vm , char * class , char * args ) { int len , ret ; static int vdev_id = 0 ; struct vdev * pdev ; struct vdev_ops * plat_ops = NULL ; char buf [ 32 ] ; plat_ops = get_vdev_ops ( class ) ; if ( ! plat_ops ) { pr_err ( "can<S2SV_blank>not<S2SV_blank>find<S2SV_blank>such<S2SV_blank>vdev<S2SV_blank>%s\\n" , class ) ; return NULL ; } pdev = malloc ( sizeof ( struct vdev ) ) ; if ( ! pdev ) return NULL ; memset ( pdev , 0 , sizeof ( struct vdev ) ) ; pdev -> ops = plat_ops ; <S2SV_StartBug> pdev -> vm = vm ; <S2SV_EndBug> memset ( buf , 0 , 32 ) ; len = strlen ( class ) ; if ( len > PDEV_NAME_SIZE - 2 ) strncpy ( buf , class , PDEV_NAME_SIZE - 2 ) ; else strcpy ( buf , class ) ; sprintf ( pdev -> name , "%s%2d" , buf , vdev_id ) ; vdev_id ++ ; ret = plat_ops -> init ( pdev , args ) ; if ( ret ) { free ( pdev ) ; pdev = NULL ; } return pdev ; } | <S2SV_ModStart> vm = vm ; pthread_mutex_init ( & pdev -> lock , NULL ) |
2,605 | CWE-000 static stmt * <S2SV_StartBug> value_list ( backend * be , list * vals ) <S2SV_EndBug> { node * n ; stmt * s ; s = stmt_temp ( be , exp_subtype ( vals -> h -> data ) ) ; for ( n = vals -> h ; n ; n = n -> next ) { sql_exp * e = n -> data ; <S2SV_StartBug> stmt * i = exp_bin ( be , e , NULL , NULL , NULL , NULL , NULL , NULL ) ; <S2SV_EndBug> if ( list_length ( vals ) == 1 ) return i ; s = stmt_append ( be , s , i ) ; } return s ; } | <S2SV_ModStart> list * vals , stmt * left , stmt * sel <S2SV_ModStart> , e , left <S2SV_ModEnd> , NULL , <S2SV_ModStart> , NULL , sel <S2SV_ModEnd> ) ; if |
2,606 | CWE-000 void XLogSetAsyncXactLSN ( XLogRecPtr asyncXactLSN ) { <S2SV_StartBug> XLogRecPtr WriteRqstPtr = asyncXactLSN ; <S2SV_EndBug> volatile XLogCtlData * xlogctl = XLogCtl ; SpinLockAcquire ( & xlogctl -> info_lck ) ; <S2SV_StartBug> LogwrtResult = xlogctl -> LogwrtResult ; <S2SV_EndBug> if ( XLByteLT ( xlogctl -> asyncXactLSN , asyncXactLSN ) ) xlogctl -> asyncXactLSN = asyncXactLSN ; SpinLockRelease ( & xlogctl -> info_lck ) ; <S2SV_StartBug> WriteRqstPtr . xrecoff -= WriteRqstPtr . xrecoff % XLOG_BLCKSZ ; <S2SV_EndBug> if ( XLByteLE ( WriteRqstPtr , LogwrtResult . Flush ) ) return ; <S2SV_StartBug> if ( ProcGlobal -> walwriterLatch ) <S2SV_EndBug> SetLatch ( ProcGlobal -> walwriterLatch ) ; } | <S2SV_ModStart> WriteRqstPtr = asyncXactLSN ; bool sleeping <S2SV_ModStart> xlogctl -> LogwrtResult ; sleeping = xlogctl -> WalWriterSleeping <S2SV_ModStart> info_lck ) ; if ( ! sleeping ) { <S2SV_ModStart> ) return ; } |
2,607 | CWE-000 void anglePIDControl ( WheelPid * wheels , int wheelCmd [ ] [ 2 ] , enum dir direction , ImuDir * curImu ) { double error_new = angleToValue ( curImu -> Rx ) ; double pow ; curImu -> curError += error_new ; <S2SV_StartBug> pow = KP_ANGLE * error_new + KI_ANGLE * dt_sec * ( curImu -> curError ) ; <S2SV_EndBug> double wheelPower = ( ( wheelCmd [ FR ] [ 1 ] == 0 ) ? wheelCmd [ FR ] [ 0 ] : ( 2000 - wheelCmd [ FR ] [ 0 ] ) ) / 2000 ; wheelPower = max ( wheelPower , .3 ) ; <S2SV_StartBug> printf ( "angle:<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank><S2SV_blank>angle<S2SV_blank>correction<S2SV_blank>power:<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank><S2SV_blank>wheelPowerCorectionFactor:<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank>BeforeAnglePIDWheelPower:<S2SV_blank>,<S2SV_blank>%d<S2SV_blank>,<S2SV_blank>" , error_new , pow , wheelPower , wheelCmd [ FL ] [ 0 ] ) ; <S2SV_EndBug> switch ( direction ) { case Forward : wheelCmd [ FL ] [ 0 ] -= ( wheelPower ) * pow * ( ( wheelCmd [ FL ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ BL ] [ 0 ] -= ( wheelPower ) * pow * ( ( wheelCmd [ BL ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ FR ] [ 0 ] += ( wheelPower ) * pow * ( ( wheelCmd [ FR ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ BR ] [ 0 ] += ( wheelPower ) * pow * ( ( wheelCmd [ BR ] [ 1 ] == 0 ) ? 1 : - 1 ) ; break ; case Backward : wheelCmd [ FL ] [ 0 ] += ( wheelPower ) * pow * ( ( wheelCmd [ FL ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ BL ] [ 0 ] += ( wheelPower ) * pow * ( ( wheelCmd [ BL ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ FR ] [ 0 ] -= ( wheelPower ) * pow * ( ( wheelCmd [ FR ] [ 1 ] == 0 ) ? 1 : - 1 ) ; wheelCmd [ BR ] [ 0 ] -= ( wheelPower ) * pow * ( ( wheelCmd [ BR ] [ 1 ] == 0 ) ? 1 : - 1 ) ; break ; case Left : case Right : break ; } for ( int i = 0 ; i < 4 ; i ++ ) { if ( wheelCmd [ i ] [ 0 ] > MAX_SPEED ) { wheelCmd [ i ] [ 0 ] = MAX_SPEED ; } else if ( wheelCmd [ i ] [ 0 ] < MIN_SPEED ) { wheelCmd [ i ] [ 0 ] = 0 ; } } } | <S2SV_ModStart> + KI_ANGLE * <S2SV_ModEnd> ( curImu -> <S2SV_ModStart> ; printf ( "angle,angleCorrectionPower:<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank><S2SV_blank>wheelPowerCorectionFactor:<S2SV_blank>,<S2SV_blank>%g<S2SV_blank>,<S2SV_blank>BeforeAnglePIDWheelPower:<S2SV_blank>,<S2SV_blank>%d<S2SV_blank>,<S2SV_blank>" <S2SV_ModEnd> , error_new , <S2SV_ModStart> error_new , pow / 500 |
2,608 | CWE-000 void jsonrpc_client_call_async ( JsonrpcClient * self , const gchar * method , GVariant * params , GCancellable * cancellable , GAsyncReadyCallback callback , gpointer user_data ) { JsonrpcClientPrivate * priv = jsonrpc_client_get_instance_private ( self ) ; g_autoptr ( GVariant ) message = NULL ; g_autoptr ( GTask ) task = NULL ; g_autoptr ( GError ) error = NULL ; GVariantDict dict ; gint64 id ; g_return_if_fail ( JSONRPC_IS_CLIENT ( self ) ) ; g_return_if_fail ( method != NULL ) ; g_return_if_fail ( ! cancellable || G_IS_CANCELLABLE ( cancellable ) ) ; task = g_task_new ( self , cancellable , callback , user_data ) ; g_task_set_source_tag ( task , jsonrpc_client_call_async ) ; if ( ! jsonrpc_client_check_ready ( self , & error ) ) { g_task_return_error ( task , g_steal_pointer ( & error ) ) ; return ; } <S2SV_StartBug> g_signal_connect ( task , <S2SV_EndBug> "notify::completed" , G_CALLBACK ( jsonrpc_client_call_notify_completed ) , <S2SV_StartBug> NULL ) ; <S2SV_EndBug> id = ++ priv -> sequence ; g_task_set_task_data ( task , GINT_TO_POINTER ( id ) , NULL ) ; if ( params == NULL ) params = g_variant_new_maybe ( G_VARIANT_TYPE_VARIANT , NULL ) ; g_variant_dict_init ( & dict , NULL ) ; g_variant_dict_insert ( & dict , "jsonrpc" , "s" , "2.0" ) ; g_variant_dict_insert ( & dict , "id" , "x" , id ) ; g_variant_dict_insert ( & dict , "method" , "s" , method ) ; g_variant_dict_insert_value ( & dict , "params" , params ) ; message = g_variant_dict_end ( & dict ) ; g_hash_table_insert ( priv -> invocations , GINT_TO_POINTER ( id ) , g_object_ref ( task ) ) ; jsonrpc_output_stream_write_message_async ( priv -> output_stream , message , cancellable , jsonrpc_client_call_write_cb , g_steal_pointer ( & task ) ) ; if ( priv -> is_first_call ) jsonrpc_client_start_listening ( self ) ; } | <S2SV_ModStart> return ; } g_signal_connect_object <S2SV_ModEnd> ( task , <S2SV_ModStart> jsonrpc_client_call_notify_completed ) , self , G_CONNECT_SWAPPED <S2SV_ModEnd> ) ; id |
2,609 | CWE-000 <S2SV_StartBug> void <S2SV_EndBug> rb_vm_pop_frame ( rb_execution_context_t * ec ) { vm_pop_frame ( ec , ec -> cfp , ec -> cfp -> ep ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> MJIT_STATIC |
2,610 | CWE-000 static void WatchdogHandleExpiry ( le_timer_Ref_t timerRef ) { char appName [ LIMIT_MAX_APP_NAME_BYTES ] ; <S2SV_StartBug> pid_t procId = ( intptr_t ) le_timer_GetContextPtr ( timerRef ) ; <S2SV_EndBug> <S2SV_StartBug> if ( procId == NO_PROC ) <S2SV_EndBug> { <S2SV_StartBug> LE_CRIT ( "A<S2SV_blank>mandatory<S2SV_blank>watchdog<S2SV_blank>expired" ) ; <S2SV_EndBug> pa_wdog_Shutdown ( ) ; } <S2SV_StartBug> WatchdogObj_t * expiredDog = LookupClientWatchdogPtrById ( procId ) ; <S2SV_EndBug> if ( expiredDog != NULL ) { uid_t appId = expiredDog -> appId ; <S2SV_StartBug> if ( LE_OK == GetAppNameFromPid ( procId , appName , sizeof ( appName ) ) ) <S2SV_EndBug> { <S2SV_StartBug> LE_CRIT ( "app<S2SV_blank>%s,<S2SV_blank>proc<S2SV_blank>%d<S2SV_blank>timed<S2SV_blank>out" , appName , procId ) ; <S2SV_EndBug> } else { <S2SV_StartBug> LE_CRIT ( "app<S2SV_blank>%d,<S2SV_blank>proc<S2SV_blank>%d<S2SV_blank>timed<S2SV_blank>out" , appId , procId ) ; <S2SV_EndBug> } <S2SV_StartBug> DeleteWatchdog ( procId ) ; <S2SV_EndBug> <S2SV_StartBug> wdog_WatchdogTimedOut ( appId , procId ) ; <S2SV_EndBug> } else { <S2SV_StartBug> LE_CRIT ( "Processing<S2SV_blank>watchdog<S2SV_blank>timeout<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d<S2SV_blank>but<S2SV_blank>watchdog<S2SV_blank>already<S2SV_blank>freed." , procId ) ; <S2SV_EndBug> } } | <S2SV_ModStart> LIMIT_MAX_APP_NAME_BYTES ] ; WatchdogObj_t * watchDogPtr = <S2SV_ModEnd> le_timer_GetContextPtr ( timerRef <S2SV_ModStart> timerRef ) ; LE_DEBUG ( "Watchdog<S2SV_blank>expired<S2SV_blank>[appuid:<S2SV_blank>%d]<S2SV_blank>[procid:<S2SV_blank>%d]" , watchDogPtr -> appId , watchDogPtr -> procId ) ; if ( watchDogPtr -> <S2SV_ModEnd> procId == NO_PROC <S2SV_ModStart> LE_CRIT ( "A<S2SV_blank>mandatory<S2SV_blank>watchdog<S2SV_blank>expired" ) ; le_timer_Stop ( DefaultExternalWdogTimer <S2SV_ModStart> = LookupClientWatchdogPtrById ( watchDogPtr -> <S2SV_ModStart> == GetAppNameFromPid ( watchDogPtr -> <S2SV_ModStart> , appName , watchDogPtr -> <S2SV_ModStart> , appId , watchDogPtr -> <S2SV_ModStart> } DeleteWatchdog ( watchDogPtr -> <S2SV_ModStart> ( appId , watchDogPtr -> <S2SV_ModStart> ( "Processing<S2SV_blank>watchdog<S2SV_blank>timeout<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d<S2SV_blank>but<S2SV_blank>watchdog<S2SV_blank>already<S2SV_blank>freed." , watchDogPtr -> |
2,611 | CWE-000 static int nldev_get_doit ( struct sk_buff * skb , struct nlmsghdr * nlh , struct netlink_ext_ack * extack ) { struct nlattr * tb [ RDMA_NLDEV_ATTR_MAX ] ; struct ib_device * device ; struct sk_buff * msg ; u32 index ; int err ; err = nlmsg_parse ( nlh , 0 , tb , RDMA_NLDEV_ATTR_MAX - 1 , nldev_policy , extack ) ; if ( err || ! tb [ RDMA_NLDEV_ATTR_DEV_INDEX ] ) return - EINVAL ; index = nla_get_u32 ( tb [ RDMA_NLDEV_ATTR_DEV_INDEX ] ) ; <S2SV_StartBug> device = __ib_device_get_by_index ( index ) ; <S2SV_EndBug> if ( ! device ) return - EINVAL ; msg = nlmsg_new ( NLMSG_DEFAULT_SIZE , GFP_KERNEL ) ; if ( ! msg ) <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> nlh = nlmsg_put ( msg , NETLINK_CB ( skb ) . portid , nlh -> nlmsg_seq , RDMA_NL_GET_TYPE ( RDMA_NL_NLDEV , RDMA_NLDEV_CMD_GET ) , 0 , 0 ) ; err = fill_dev_info ( msg , device ) ; <S2SV_StartBug> if ( err ) { <S2SV_EndBug> nlmsg_free ( msg ) ; return err ; } <S2SV_StartBug> nlmsg_end ( msg , nlh ) ; <S2SV_EndBug> return rdma_nl_unicast ( msg , NETLINK_CB ( skb ) . portid ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; device = ib_device_get_by_index <S2SV_ModEnd> ( index ) <S2SV_ModStart> ! msg ) { err = <S2SV_ModEnd> - ENOMEM ; <S2SV_ModStart> - ENOMEM ; goto err ; } <S2SV_ModStart> ( err ) goto err_free ; <S2SV_ModEnd> nlmsg_end ( msg <S2SV_ModStart> msg , nlh ) ; put_device ( & device -> dev <S2SV_ModStart> portid ) ; err_free : nlmsg_free ( msg ) ; err : put_device ( & device -> dev ) ; return err ; |
2,612 | CWE-000 int logix_tag_create ( tag_p tag ) { char * plc_name = NULL ; logix_plc_p plc = NULL ; attr attribs = tag_get_attribs ( tag ) ; const char * path = NULL ; bytebuf_p data = NULL ; int rc = PLCTAG_STATUS_OK ; pdebug ( DEBUG_INFO , "Starting" ) ; if ( ! attribs ) { pdebug ( DEBUG_WARN , "Tag<S2SV_blank>has<S2SV_blank>no<S2SV_blank>attributes!" ) ; return PLCTAG_ERR_NO_DATA ; } path = attr_get_str ( attribs , "path" , NULL ) ; <S2SV_StartBug> if ( ! path || str_length ( path ) ) { <S2SV_EndBug> pdebug ( DEBUG_WARN , "PLC<S2SV_blank>path<S2SV_blank>is<S2SV_blank>missing<S2SV_blank>or<S2SV_blank>empty!" ) ; return PLCTAG_ERR_BAD_PARAM ; } data = bytebuf_create ( 1 , AB_BYTE_ORDER_INT16 , AB_BYTE_ORDER_INT32 , AB_BYTE_ORDER_INT64 , AB_BYTE_ORDER_FLOAT32 , AB_BYTE_ORDER_FLOAT64 ) ; if ( ! data ) { pdebug ( DEBUG_ERROR , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>byte<S2SV_blank>buffer<S2SV_blank>for<S2SV_blank>tag<S2SV_blank>data!" ) ; return PLCTAG_ERR_NO_MEM ; } rc = tag_set_bytebuf ( tag , data ) ; if ( rc != PLCTAG_STATUS_OK ) { pdebug ( DEBUG_WARN , "Unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>tag<S2SV_blank>byte<S2SV_blank>buffer!" ) ; return rc ; } rc = tag_set_impl_op_func ( tag , dispatch_function ) ; if ( rc != PLCTAG_STATUS_OK ) { pdebug ( DEBUG_WARN , "Unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>tag<S2SV_blank>byte<S2SV_blank>buffer!" ) ; return rc ; } plc_name = str_concat ( SESSION_RESOURCE_PREFIX , path ) ; if ( ! plc_name ) { pdebug ( DEBUG_WARN , "Unable<S2SV_blank>to<S2SV_blank>make<S2SV_blank>PLC<S2SV_blank>name!" ) ; return PLCTAG_ERR_NO_MEM ; } if ( str_length ( plc_name ) == 0 ) { pdebug ( DEBUG_WARN , "PLC<S2SV_blank>name<S2SV_blank>is<S2SV_blank>null<S2SV_blank>or<S2SV_blank>zero<S2SV_blank>length!" ) ; mem_free ( plc_name ) ; return PLCTAG_ERR_BAD_PARAM ; } pdebug ( DEBUG_INFO , "Starting<S2SV_blank>with<S2SV_blank>path<S2SV_blank>%s" , path ) ; plc = resource_get ( plc_name ) ; if ( ! plc ) { pdebug ( DEBUG_DETAIL , "Might<S2SV_blank>need<S2SV_blank>to<S2SV_blank>create<S2SV_blank>new<S2SV_blank>plc." ) ; plc = create_plc ( path ) ; if ( plc ) { if ( resource_put ( plc_name , plc ) == PLCTAG_ERR_DUPLICATE ) { pdebug ( DEBUG_DETAIL , "Oops!<S2SV_blank>Someone<S2SV_blank>else<S2SV_blank>created<S2SV_blank>plc<S2SV_blank>already!" ) ; plc = rc_dec ( plc ) ; plc = resource_get ( plc_name ) ; } else { plc -> monitor = rc_thread_create ( plc_monitor , plc ) ; if ( ! plc -> monitor ) { pdebug ( DEBUG_ERROR , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>plc<S2SV_blank>monitor<S2SV_blank>thread!" ) ; plc = rc_dec ( plc ) ; rc = PLCTAG_ERR_CREATE ; } } } } if ( plc_name ) { mem_free ( plc_name ) ; } if ( ! plc ) { pdebug ( DEBUG_WARN , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>or<S2SV_blank>get<S2SV_blank>PLC!" ) ; rc = PLCTAG_ERR_CREATE ; } rc = tag_set_impl_data ( tag , plc ) ; if ( rc != PLCTAG_STATUS_OK ) { pdebug ( DEBUG_WARN , "Unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>implementation<S2SV_blank>data<S2SV_blank>on<S2SV_blank>tag!" ) ; rc_dec ( plc ) ; } pdebug ( DEBUG_INFO , "Done." ) ; return rc ; } | <S2SV_ModStart> ! path || ! |
2,613 | CWE-000 <S2SV_StartBug> int release_job ( int id ) { <S2SV_EndBug> if ( id > MAX_JOBS || shell -> jobs [ id ] == NULL ) { return - 1 ; } <S2SV_StartBug> struct job * job = shell -> jobs [ id ] ; <S2SV_EndBug> struct process * proc , * tmp ; for ( proc = job -> root ; proc != NULL ; ) { tmp = proc -> next ; free ( proc -> command ) ; free ( proc -> argv ) ; free ( proc -> input_path ) ; free ( proc -> output_path ) ; free ( proc ) ; proc = tmp ; } free ( job -> command ) ; free ( job ) ; return 0 ; } | <S2SV_ModStart> id ) { struct job * job = shell -> jobs [ id ] ; struct process * proc , * tmp ; <S2SV_ModStart> 1 ; } <S2SV_ModEnd> for ( proc |
2,614 | CWE-000 static void ttyrub ( int c , struct tty * tp ) { <S2SV_StartBug> char * cp ; <S2SV_EndBug> int savecol ; int tabc ; ASSERT_LWKT_TOKEN_HELD ( & tp -> t_token ) ; if ( ! ISSET ( tp -> t_lflag , ECHO ) || ISSET ( tp -> t_lflag , EXTPROC ) ) return ; CLR ( tp -> t_lflag , FLUSHO ) ; if ( ISSET ( tp -> t_lflag , ECHOE ) ) { if ( tp -> t_rocount == 0 ) { ttyretype ( tp ) ; return ; } if ( c == ( '\\t' | TTY_QUOTE ) || c == ( '\\n' | TTY_QUOTE ) ) ttyrubo ( tp , 2 ) ; else { CLR ( c , ~ TTY_CHARMASK ) ; switch ( CCLASS ( c ) ) { case ORDINARY : ttyrubo ( tp , 1 ) ; break ; case BACKSPACE : case CONTROL : case NEWLINE : case RETURN : case VTAB : if ( ISSET ( tp -> t_lflag , ECHOCTL ) ) ttyrubo ( tp , 2 ) ; break ; case TAB : if ( tp -> t_rocount < tp -> t_rawq . c_cc ) { ttyretype ( tp ) ; return ; } savecol = tp -> t_column ; SET ( tp -> t_state , TS_CNTTB ) ; SET ( tp -> t_lflag , FLUSHO ) ; tp -> t_column = tp -> t_rocol ; <S2SV_StartBug> cp = tp -> t_rawq . c_cf ; <S2SV_EndBug> if ( cp ) <S2SV_StartBug> tabc = * cp ; <S2SV_EndBug> <S2SV_StartBug> for ( ; cp ; cp = nextc ( & tp -> t_rawq , cp , & tabc ) ) <S2SV_EndBug> ttyecho ( tabc , tp ) ; CLR ( tp -> t_lflag , FLUSHO ) ; CLR ( tp -> t_state , TS_CNTTB ) ; savecol -= tp -> t_column ; tp -> t_column += savecol ; if ( savecol > 8 ) savecol = 8 ; while ( -- savecol >= 0 ) ( void ) ttyoutput ( '\\b' , tp ) ; break ; default : # define PANICSTR "ttyrub:<S2SV_blank>would<S2SV_blank>panic<S2SV_blank>c<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>val<S2SV_blank>=<S2SV_blank>%d\\n" ( void ) kprintf ( PANICSTR , c , CCLASS ( c ) ) ; # ifdef notdef panic ( PANICSTR , c , CCLASS ( c ) ) ; # endif } } } else if ( ISSET ( tp -> t_lflag , ECHOPRT ) ) { if ( ! ISSET ( tp -> t_state , TS_ERASE ) ) { SET ( tp -> t_state , TS_ERASE ) ; ( void ) ttyoutput ( '\\\\' , tp ) ; } ttyecho ( c , tp ) ; } else { ttyecho ( tp -> t_cc [ VERASE ] , tp ) ; } -- tp -> t_rocount ; } | <S2SV_ModStart> tp ) { void <S2SV_ModEnd> * cp ; <S2SV_ModStart> ; cp = clist_nextc ( & <S2SV_ModStart> tp -> t_rawq , NULL , & tabc ) ; while <S2SV_ModEnd> ( cp ) <S2SV_ModStart> ( cp ) { ttyecho ( tabc , tp ) ; cp = clist_nextc <S2SV_ModEnd> ( & tp <S2SV_ModStart> & tabc ) ; } <S2SV_ModEnd> CLR ( tp |
2,615 | CWE-000 suscan_inspector_t * suscan_inspector_new ( const suscan_analyzer_t * analyzer , const struct sigutils_channel * channel ) { suscan_inspector_t * new ; struct sigutils_channel_detector_params params = sigutils_channel_detector_params_INITIALIZER ; struct su_agc_params agc_params = su_agc_params_INITIALIZER ; SUFLOAT tau ; SU_TRYCATCH ( new = calloc ( 1 , sizeof ( suscan_inspector_t ) ) , goto fail ) ; new -> state = SUSCAN_ASYNC_STATE_CREATED ; <S2SV_StartBug> su_channel_params_adjust_to_channel ( & params , channel ) ; <S2SV_EndBug> params . samp_rate = analyzer -> source . detector -> params . samp_rate ; params . window_size = SUSCAN_SOURCE_DEFAULT_BUFSIZ ; params . alpha = 1e-4 ; new -> interval_psd = .1 ; params . mode = SU_CHANNEL_DETECTOR_MODE_AUTOCORRELATION ; SU_TRYCATCH ( new -> fac_baud_det = su_channel_detector_new ( & params ) , goto fail ) ; params . mode = SU_CHANNEL_DETECTOR_MODE_NONLINEAR_DIFF ; SU_TRYCATCH ( new -> nln_baud_det = su_channel_detector_new ( & params ) , goto fail ) ; SU_TRYCATCH ( su_clock_detector_init ( & new -> cd , 1. , .5 * SU_ABS2NORM_BAUD ( params . samp_rate , params . bw ) , 32 ) , goto fail ) ; su_ncqo_init ( & new -> lo , 0 ) ; new -> phase = 1. ; tau = params . samp_rate / params . bw ; agc_params . fast_rise_t = tau * SUSCAN_INSPECTOR_FAST_RISE_FRAC ; agc_params . fast_fall_t = tau * SUSCAN_INSPECTOR_FAST_FALL_FRAC ; agc_params . slow_rise_t = tau * SUSCAN_INSPECTOR_SLOW_RISE_FRAC ; agc_params . slow_fall_t = tau * SUSCAN_INSPECTOR_SLOW_FALL_FRAC ; agc_params . hang_max = tau * SUSCAN_INSPECTOR_HANG_MAX_FRAC ; agc_params . delay_line_size = tau * SUSCAN_INSPECTOR_DELAY_LINE_FRAC ; agc_params . mag_history_size = tau * SUSCAN_INSPECTOR_MAG_HISTORY_FRAC ; SU_TRYCATCH ( su_agc_init ( & new -> agc , & agc_params ) , goto fail ) ; SU_TRYCATCH ( su_costas_init ( & new -> costas_2 , SU_COSTAS_KIND_BPSK , 0 , SU_ABS2NORM_FREQ ( params . samp_rate , params . bw ) , 3 , 1e-2 * SU_ABS2NORM_FREQ ( params . samp_rate , params . bw ) ) , goto fail ) ; SU_TRYCATCH ( su_costas_init ( & new -> costas_4 , SU_COSTAS_KIND_QPSK , 0 , SU_ABS2NORM_FREQ ( params . samp_rate , params . bw ) , 3 , 1e-2 * SU_ABS2NORM_FREQ ( params . samp_rate , params . bw ) ) , goto fail ) ; return new ; fail : if ( new != NULL ) suscan_inspector_destroy ( new ) ; return NULL ; } | <S2SV_ModStart> = SUSCAN_ASYNC_STATE_CREATED ; suscan_inspector_params_initialize ( & new -> params ) ; |
2,616 | CWE-000 static inline adf_nbuf_t ol_tx_hl_base ( ol_txrx_vdev_handle vdev , enum ol_tx_spec tx_spec , adf_nbuf_t msdu_list , int tx_comp_req , bool call_sched ) { struct ol_txrx_pdev_t * pdev = vdev -> pdev ; adf_nbuf_t msdu = msdu_list ; adf_nbuf_t msdu_drop_list = NULL ; adf_nbuf_t prev_drop = NULL ; struct ol_txrx_msdu_info_t tx_msdu_info ; struct ocb_tx_ctrl_hdr_t tx_ctrl ; htt_pdev_handle htt_pdev = pdev -> htt_pdev ; uint8_t rtap [ MAX_RADIOTAP_LEN ] ; uint8_t rtap_len = 0 ; tx_msdu_info . peer = NULL ; while ( msdu ) { adf_nbuf_t next ; struct ol_tx_frms_queue_t * txq ; struct ol_tx_desc_t * tx_desc = NULL ; adf_os_mem_zero ( & tx_ctrl , sizeof ( tx_ctrl ) ) ; tx_msdu_info . peer = NULL ; next = adf_nbuf_next ( msdu ) ; if ( VOS_MONITOR_MODE == vos_get_conparam ( ) ) { struct ieee80211_radiotap_header * rthdr ; rthdr = ( struct ieee80211_radiotap_header * ) ( adf_nbuf_data ( msdu ) ) ; rtap_len = rthdr -> it_len ; if ( rtap_len > MAX_RADIOTAP_LEN ) { TXRX_PRINT ( TXRX_PRINT_LEVEL_ERR , "radiotap<S2SV_blank>length<S2SV_blank>exceeds<S2SV_blank>%d,<S2SV_blank>drop<S2SV_blank>it!\\n" , MAX_RADIOTAP_LEN ) ; adf_nbuf_set_next ( msdu , NULL ) ; if ( ! msdu_drop_list ) msdu_drop_list = msdu ; else adf_nbuf_set_next ( prev_drop , msdu ) ; prev_drop = msdu ; msdu = next ; continue ; } adf_os_mem_copy ( rtap , rthdr , rtap_len ) ; adf_nbuf_pull_head ( msdu , rtap_len ) ; } # if defined ( CONFIG_TX_DESC_HI_PRIO_RESERVE ) if ( adf_os_atomic_read ( & pdev -> tx_queue . rsrc_cnt ) > TXRX_HL_TX_DESC_HI_PRIO_RESERVED ) { tx_desc = ol_tx_desc_hl ( pdev , vdev , msdu , & tx_msdu_info ) ; } else if ( ADF_NBUF_GET_IS_DHCP ( msdu ) || ADF_NBUF_GET_IS_EAPOL ( msdu ) ) { tx_desc = ol_tx_desc_hl ( pdev , vdev , msdu , & tx_msdu_info ) ; TXRX_PRINT ( TXRX_PRINT_LEVEL_ERR , "Provided<S2SV_blank>tx<S2SV_blank>descriptor<S2SV_blank>from<S2SV_blank>reserve<S2SV_blank>pool<S2SV_blank>for<S2SV_blank>DHCP/EAPOL\\n" ) ; } # else tx_desc = ol_tx_desc_hl ( pdev , vdev , msdu , & tx_msdu_info ) ; # endif if ( ! tx_desc ) { TXRX_STATS_MSDU_LIST_INCR ( pdev , tx . dropped . host_reject , msdu ) ; if ( ! msdu_drop_list ) msdu_drop_list = msdu ; else adf_nbuf_set_next ( prev_drop , msdu ) ; return msdu_drop_list ; } tx_desc -> rtap_len = rtap_len ; adf_os_mem_copy ( tx_desc -> rtap , rtap , rtap_len ) ; if ( tx_spec != ol_tx_spec_std ) { # if defined ( CONFIG_HL_SUPPORT ) && defined ( FEATURE_WLAN_TDLS ) if ( tx_spec & ol_tx_spec_no_free ) { tx_desc -> pkt_type = ol_tx_frm_no_free ; } else if ( tx_spec & ol_tx_spec_tso ) { # else if ( tx_spec & ol_tx_spec_tso ) { # endif tx_desc -> pkt_type = ol_tx_frm_tso ; } if ( OL_TXRX_TX_IS_RAW ( tx_spec ) ) { u_int8_t sub_type = OL_TXRX_TX_RAW_SUBTYPE ( tx_spec ) ; htt_tx_desc_type ( htt_pdev , tx_desc -> htt_tx_desc , htt_pkt_type_raw , sub_type ) ; } } tx_msdu_info . htt . info . ext_tid = adf_nbuf_get_tid ( msdu ) ; tx_msdu_info . htt . info . vdev_id = vdev -> vdev_id ; tx_msdu_info . htt . info . frame_type = htt_frm_type_data ; tx_msdu_info . htt . info . l2_hdr_type = pdev -> htt_pkt_type ; tx_msdu_info . htt . action . tx_comp_req = tx_comp_req ; if ( vdev -> opmode == wlan_op_mode_ocb ) { bool tx_ctrl_header_found = false ; if ( ! parse_ocb_tx_header ( msdu , & tx_ctrl , & tx_ctrl_header_found ) ) { goto MSDU_LOOP_BOTTOM ; } if ( tx_ctrl_header_found && vdev -> ocb_def_tx_param ) merge_ocb_tx_ctrl_hdr ( & tx_ctrl , vdev -> ocb_def_tx_param , vdev -> ocb_channel_count ) ; <S2SV_StartBug> if ( tx_ctrl_header_found ) <S2SV_EndBug> dsrc_update_broadcast_frame_sa ( vdev , & tx_ctrl , msdu ) ; <S2SV_StartBug> if ( adf_nbuf_headroom ( msdu ) >= <S2SV_EndBug> sizeof ( struct htt_tx_msdu_desc_ext_t ) ) { ol_collect_per_pkt_tx_stats ( vdev , & tx_ctrl , tx_desc -> id ) ; } } txq = ol_tx_classify ( vdev , tx_desc , msdu , & tx_msdu_info ) ; if ( ( ! txq ) || TX_FILTER_CHECK ( & tx_msdu_info ) ) { adf_os_atomic_inc ( & pdev -> tx_queue . rsrc_cnt ) ; ol_tx_desc_frame_free_nonstd ( pdev , tx_desc , 1 ) ; if ( tx_msdu_info . peer ) { ol_txrx_peer_unref_delete ( tx_msdu_info . peer ) ; } goto MSDU_LOOP_BOTTOM ; } if ( tx_msdu_info . peer ) { if ( tx_msdu_info . peer -> state == ol_txrx_peer_state_disc ) { adf_os_atomic_inc ( & pdev -> tx_queue . rsrc_cnt ) ; ol_tx_desc_frame_free_nonstd ( pdev , tx_desc , 1 ) ; ol_txrx_peer_unref_delete ( tx_msdu_info . peer ) ; msdu = next ; continue ; } else if ( tx_msdu_info . peer -> state != ol_txrx_peer_state_auth ) { if ( tx_msdu_info . htt . info . ethertype != ETHERTYPE_PAE && tx_msdu_info . htt . info . ethertype != ETHERTYPE_WAI ) { adf_os_atomic_inc ( & pdev -> tx_queue . rsrc_cnt ) ; ol_tx_desc_frame_free_nonstd ( pdev , tx_desc , 1 ) ; ol_txrx_peer_unref_delete ( tx_msdu_info . peer ) ; msdu = next ; continue ; } } } htt_tx_desc_mpdu_header ( tx_desc -> htt_tx_desc , 0 ) ; OL_TX_ENCAP_WRAPPER ( pdev , vdev , tx_desc , msdu , tx_msdu_info ) ; htt_tx_desc_init ( pdev -> htt_pdev , tx_desc -> htt_tx_desc , tx_desc -> htt_tx_desc_paddr , ol_tx_desc_id ( pdev , tx_desc ) , msdu , & tx_msdu_info . htt , & tx_ctrl , vdev -> opmode == wlan_op_mode_ocb ) ; htt_tx_desc_display ( tx_desc -> htt_tx_desc ) ; if ( VOS_MONITOR_MODE == vos_get_conparam ( ) ) { adf_nbuf_frag_push_head ( msdu , tx_desc -> rtap_len , ( uint8_t * ) tx_desc -> rtap , 0 , 0 ) ; adf_nbuf_set_frag_is_wordstream ( msdu , 1 , 1 ) ; } ol_tx_enqueue ( pdev , txq , tx_desc , & tx_msdu_info ) ; if ( tx_msdu_info . peer ) { OL_TX_PEER_STATS_UPDATE ( tx_msdu_info . peer , msdu ) ; ol_txrx_peer_unref_delete ( tx_msdu_info . peer ) ; } MSDU_LOOP_BOTTOM : msdu = next ; } if ( call_sched == true ) ol_tx_sched ( pdev ) ; return msdu_drop_list ; } | <S2SV_ModStart> ( tx_ctrl_header_found ) { <S2SV_ModStart> msdu ) ; <S2SV_ModEnd> ol_collect_per_pkt_tx_stats ( vdev |
2,617 | CWE-000 static void cleanup ( struct sr_input * in ) { <S2SV_StartBug> struct context * inc ; <S2SV_EndBug> <S2SV_StartBug> inc = in -> priv ; <S2SV_EndBug> g_variant_unref ( options [ 0 ] . def ) ; g_variant_unref ( options [ 1 ] . def ) ; g_variant_unref ( options [ 2 ] . def ) ; g_slist_free_full ( options [ 2 ] . values , ( GDestroyNotify ) g_variant_unref ) ; <S2SV_StartBug> g_free ( inc ) ; <S2SV_EndBug> in -> priv = NULL ; } | <S2SV_ModStart> in ) { g_free ( <S2SV_ModEnd> in -> priv <S2SV_ModStart> in -> priv ) ; in -> priv = NULL <S2SV_ModStart> g_variant_unref ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,618 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc <= 1 || strncmp ( argv [ 1 ] , "-f" , 2 ) != 0 ) { usage ( argv [ 0 ] ) ; return - 1 ; } char * conf_path ; if ( argc == 2 ) conf_path = argv [ 1 ] + 2 ; else conf_path = argv [ 2 ] ; FILE * conf_file ; if ( ( conf_file = fopen ( conf_path , "r" ) ) == NULL ) { perror ( conf_path ) ; exit ( EXIT_FAILURE ) ; } int ThreadsInPool = 8 ; int MaxHistMsgs = 16 ; char * UnixPath = "/tmp/chatty_socket" ; fclose ( conf_file ) ; struct sigaction s ; memset ( & s , 0 , sizeof ( s ) ) ; s . sa_handler = SIG_IGN ; if ( sigaction ( SIGPIPE , & s , NULL ) < 0 ) { perror ( "sigaction" ) ; return - 1 ; } sigset_t worker_signalmask ; if ( sigemptyset ( & worker_signalmask ) < 0 || sigaddset ( & worker_signalmask , SIGUSR1 ) < 0 || sigaddset ( & worker_signalmask , SIGUSR2 ) < 0 || sigaddset ( & worker_signalmask , SIGINT ) < 0 || sigaddset ( & worker_signalmask , SIGTERM ) < 0 || sigaddset ( & worker_signalmask , SIGQUIT ) < 0 ) { perror ( "creando<S2SV_blank>la<S2SV_blank>bitmap<S2SV_blank>per<S2SV_blank>mascherare<S2SV_blank>i<S2SV_blank>segnali<S2SV_blank>nel<S2SV_blank>main" ) ; exit ( EXIT_FAILURE ) ; } if ( pthread_sigmask ( SIG_SETMASK , & worker_signalmask , NULL ) == - 1 ) { perror ( "pthread_sigmask<S2SV_blank>nel<S2SV_blank>main" ) ; exit ( EXIT_FAILURE ) ; } int listener_params [ 2 ] ; queue = create_fifo ( ) ; nickname_htable = hash_create ( NICKNAME_HASH_BUCKETS_N , MaxHistMsgs ) ; listener_params [ 0 ] = createSocket ( UnixPath ) ; pthread_t pool [ ThreadsInPool ] ; freefd = malloc ( ThreadsInPool * sizeof ( int ) ) ; freefd_ack = calloc ( ThreadsInPool , sizeof ( char ) ) ; pthread_mutex_init ( & connected_mutex , NULL ) ; <S2SV_StartBug> listener_params [ 1 ] = ThreadsInPool ; <S2SV_EndBug> pthread_create ( & listener , NULL , & listener_thread , ( void * ) listener_params ) ; for ( unsigned int i = 0 ; i < ThreadsInPool ; ++ i ) { freefd [ i ] = i ; pthread_create ( pool + i , NULL , & worker_thread , ( void * ) ( freefd + i ) ) ; } signal_handler_thread ( ) ; unlink ( UnixPath ) ; clear_fifo ( & queue ) ; free ( freefd ) ; free ( freefd_ack ) ; <S2SV_StartBug> ts_hash_destroy ( nickname_htable ) ; <S2SV_EndBug> pthread_mutex_lock ( & connected_mutex ) ; pthread_mutex_unlock ( & connected_mutex ) ; pthread_mutex_destroy ( & connected_mutex ) ; return 0 ; } | <S2SV_ModStart> NULL ) ; fdnum = listener_params [ 0 ] ; assert ( INITIAL_CONNECTED_SIZE >= fdnum ) ; fd_to_nickname = calloc ( INITIAL_CONNECTED_SIZE + 1 , sizeof ( char * ) ) ; <S2SV_ModStart> freefd_ack ) ; for ( int i = 0 ; i < fdnum ; ++ i ) { if ( fd_to_nickname [ i ] != NULL ) { free ( fd_to_nickname [ i ] ) ; } } free ( fd_to_nickname ) ; |
2,619 | CWE-000 static int tusb320_reset_device ( struct tusb320_chip * chip , int mode ) { struct device * cdev = & chip -> client -> dev ; int rc = 0 ; dev_dbg ( cdev , "%s:<S2SV_blank>mode(%d)\\n" , __func__ , mode ) ; switch ( mode ) { case TUBS320_I2C_RESET : rc = tusb320_i2c_reset_device ( chip ) ; <S2SV_StartBug> if ( ! IS_ERR_VALUE ( rc ) ) <S2SV_EndBug> break ; case TUBS320_GPIO_I2C_RESET : tusb320_gpio_reset_device ( chip ) ; rc = tusb320_i2c_reset_device ( chip ) ; <S2SV_StartBug> if ( IS_ERR_VALUE ( rc ) ) <S2SV_EndBug> dev_err ( cdev , "%s:<S2SV_blank>TUBS320_GPIO_I2C_RESET<S2SV_blank>fails\\n" , __func__ ) ; break ; default : rc = - EINVAL ; dev_err ( cdev , "%s:<S2SV_blank>Invaild<S2SV_blank>mode\\n" , __func__ ) ; break ; } return rc ; } | <S2SV_ModStart> ; if ( rc >= 0 <S2SV_ModEnd> ) break ; <S2SV_ModStart> ; if ( rc < 0 <S2SV_ModEnd> ) dev_err ( |
2,620 | CWE-000 static int bch2_btree_insert_keys_interior ( struct btree_update * as , struct btree * b , struct btree_iter * iter , struct keylist * keys ) { struct bch_fs * c = as -> c ; struct btree_iter * linked ; struct btree_node_iter node_iter ; struct bkey_i * insert = bch2_keylist_front ( keys ) ; struct bkey_packed * k ; BUG_ON ( ! btree_node_intent_locked ( iter , btree_node_root ( c , b ) -> level ) ) ; BUG_ON ( ! b -> level ) ; BUG_ON ( ! as || as -> b ) ; bch2_verify_keylist_sorted ( keys ) ; bch2_btree_node_lock_for_insert ( c , b , iter ) ; <S2SV_StartBug> if ( bch_keylist_u64s ( keys ) > bch_btree_keys_u64s_remaining ( c , b ) ) { <S2SV_EndBug> bch2_btree_node_unlock_write ( b , iter ) ; return - 1 ; } node_iter = iter -> node_iters [ b -> level ] ; while ( ( k = bch2_btree_node_iter_prev_all ( & node_iter , b ) ) && ( bkey_cmp_packed ( b , k , & insert -> k ) >= 0 ) ) ; while ( ! bch2_keylist_empty ( keys ) ) { insert = bch2_keylist_front ( keys ) ; bch2_insert_fixup_btree_ptr ( as , b , iter , insert , & node_iter ) ; bch2_keylist_pop_front ( keys ) ; } btree_update_updated_node ( as , b ) ; for_each_linked_btree_node ( iter , b , linked ) bch2_btree_node_iter_peek ( & linked -> node_iters [ b -> level ] , b ) ; bch2_btree_node_iter_peek ( & iter -> node_iters [ b -> level ] , b ) ; bch2_btree_iter_verify ( iter , b ) ; if ( bch2_maybe_compact_whiteouts ( c , b ) ) bch2_btree_iter_reinit_node ( iter , b ) ; bch2_btree_node_unlock_write ( b , iter ) ; btree_node_interior_verify ( b ) ; return 0 ; } | <S2SV_ModStart> ; if ( ! bch2_btree_node_insert_fits ( c , b , <S2SV_ModStart> ( keys ) <S2SV_ModEnd> ) ) { |
2,621 | CWE-000 static boolean rrefcech ( square i1 , int x , validator_id evaluate ) { square const sq_target = move_generation_stack [ CURRMOVE_OF_PLY ( nbply ) ] . capture ; vec_index_type k ; <S2SV_StartBug> square sq_departure ; <S2SV_EndBug> if ( x ) { for ( k = vec_knight_start ; k <= vec_knight_end ; k ++ ) <S2SV_StartBug> sq_departure = i1 + vec [ k ] ; <S2SV_EndBug> if ( is_square_empty ( sq_departure ) ) { if ( ! NoEdge ( sq_departure ) ) { if ( rrefcech ( sq_departure , x - 1 , evaluate ) ) return true ; } } else if ( EVALUATE_OBSERVATION ( evaluate , sq_departure , sq_target ) ) return true ; } <S2SV_StartBug> else <S2SV_EndBug> { for ( k = vec_knight_start ; k <= vec_knight_end ; k ++ ) { <S2SV_StartBug> sq_departure = i1 + vec [ k ] ; <S2SV_EndBug> if ( EVALUATE_OBSERVATION ( evaluate , sq_departure , sq_target ) ) return true ; } } return false ; } | <S2SV_ModStart> vec_index_type k ; <S2SV_ModEnd> if ( x <S2SV_ModStart> k ++ ) { square const <S2SV_ModStart> true ; } } <S2SV_ModStart> ++ ) { square const |
2,622 | CWE-000 LIST * CreateHashTable ( ) { <S2SV_StartBug> LIST hashTable [ HASHLENGTH ] ; <S2SV_EndBug> return hashTable ; } | <S2SV_ModStart> ) { LIST * hashTable = calloc ( HASHLENGTH , sizeof ( * hashTable ) ) ; if ( ! hashTable ) { for ( int index = 0 ; index < HASHCHAR ; index ++ ) { hashTable [ index ] = CreateList ( ) ; } } <S2SV_ModEnd> return hashTable ; |
2,623 | CWE-000 unsigned int select_port ( camogm_state * state ) { unsigned int chn = 0 ; off_t free_sz ; off_t file_pos ; off_t min_sz = - 1 ; for ( int i = 0 ; i < SENSOR_PORTS ; i ++ ) { if ( is_chn_active ( state , i ) ) { chn = i ; break ; } } if ( state -> prog_state == STATE_STARTING || state -> prog_state == STATE_RUNNING ) D6 ( fprintf ( debug_file , "Selecting<S2SV_blank>sensor<S2SV_blank>port,<S2SV_blank>buffer<S2SV_blank>free<S2SV_blank>size:<S2SV_blank>" ) ) ; for ( int i = 0 ; i < SENSOR_PORTS ; i ++ ) { if ( is_chn_active ( state , i ) ) { file_pos = lseek ( state -> fd_circ [ i ] , 0 , SEEK_CUR ) ; if ( file_pos != - 1 ) { free_sz = lseek ( state -> fd_circ [ i ] , LSEEK_CIRC_FREE , SEEK_END ) ; lseek ( state -> fd_circ [ i ] , file_pos , SEEK_SET ) ; if ( state -> prog_state == STATE_STARTING || state -> prog_state == STATE_RUNNING ) D6 ( fprintf ( debug_file , "port<S2SV_blank>%i<S2SV_blank>=<S2SV_blank>%i,<S2SV_blank>" , i , free_sz ) ) ; if ( ( free_sz < min_sz && free_sz >= 0 ) || min_sz == - 1 ) { min_sz = free_sz ; chn = i ; } } <S2SV_StartBug> } else { <S2SV_EndBug> if ( state -> prog_state == STATE_STARTING || state -> prog_state == STATE_RUNNING ) D6 ( fprintf ( debug_file , "port<S2SV_blank>%i<S2SV_blank>is<S2SV_blank>inactive,<S2SV_blank>" , i ) ) ; } } if ( state -> prog_state == STATE_STARTING || state -> prog_state == STATE_RUNNING ) D6 ( fprintf ( debug_file , "selected<S2SV_blank>port:<S2SV_blank>%i\\n" , chn ) ) ; return chn ; } | <S2SV_ModStart> ; } } else { chn = i ; break ; } } else { <S2SV_ModEnd> if ( state |
2,624 | CWE-000 static void process_definitions ( Context * ctx ) { determine_constants_arrays ( ctx ) ; RegisterList * uitem = & ctx -> uniforms ; RegisterList * prev = & ctx -> used_registers ; RegisterList * item = prev -> next ; while ( item != NULL ) { RegisterList * next = item -> next ; const RegisterType regtype = item -> regtype ; const int regnum = item -> regnum ; if ( ! get_defined_register ( ctx , regtype , regnum ) ) { switch ( regtype ) { case REG_TYPE_RASTOUT : case REG_TYPE_ATTROUT : case REG_TYPE_TEXCRDOUT : case REG_TYPE_COLOROUT : case REG_TYPE_DEPTHOUT : if ( shader_is_vertex ( ctx ) && shader_version_atleast ( ctx , 3 , 0 ) ) { fail ( ctx , "vs_3<S2SV_blank>can\'t<S2SV_blank>use<S2SV_blank>output<S2SV_blank>registers" "<S2SV_blank>without<S2SV_blank>declaring<S2SV_blank>them<S2SV_blank>first." ) ; return ; } add_attribute_register ( ctx , regtype , regnum , MOJOSHADER_USAGE_UNKNOWN , 0 , 0xF , 0 ) ; break ; case REG_TYPE_ADDRESS : case REG_TYPE_PREDICATE : case REG_TYPE_TEMP : case REG_TYPE_LOOP : case REG_TYPE_LABEL : ctx -> profile -> global_emitter ( ctx , regtype , regnum ) ; break ; case REG_TYPE_CONST : case REG_TYPE_CONSTINT : case REG_TYPE_CONSTBOOL : prev -> next = next ; item -> next = NULL ; uitem -> next = item ; uitem = item ; item = prev ; break ; case REG_TYPE_INPUT : if ( shader_is_pixel ( ctx ) && ! shader_version_atleast ( ctx , 2 , 0 ) ) { add_attribute_register ( ctx , regtype , regnum , MOJOSHADER_USAGE_COLOR , regnum , 0xF , 0 ) ; break ; } default : fail ( ctx , "BUG:<S2SV_blank>we<S2SV_blank>used<S2SV_blank>a<S2SV_blank>register<S2SV_blank>we<S2SV_blank>don\'t<S2SV_blank>know<S2SV_blank>how<S2SV_blank>to<S2SV_blank>define." ) ; } } prev = item ; item = next ; } VariableList * var ; for ( var = ctx -> variables ; var != NULL ; var = var -> next ) { if ( var -> used ) { if ( var -> constant ) { ctx -> profile -> const_array_emitter ( ctx , var -> constant , var -> index , var -> count ) ; } else { ctx -> profile -> array_emitter ( ctx , var ) ; ctx -> uniform_float4_count += var -> count ; <S2SV_StartBug> ctx -> uniform_count ++ ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> } } for ( item = ctx -> uniforms . next ; item != NULL ; item = item -> next ) { int arraysize = - 1 ; if ( item -> regtype == REG_TYPE_CONST ) { for ( var = ctx -> variables ; var != NULL ; var = var -> next ) { if ( ! var -> used ) continue ; const int regnum = item -> regnum ; const int lo = var -> index ; if ( ( regnum >= lo ) && ( regnum < ( lo + var -> count ) ) ) { assert ( ! var -> constant ) ; item -> array = var ; arraysize = var -> count ; break ; } } } ctx -> profile -> uniform_emitter ( ctx , item -> regtype , item -> regnum , var ) ; if ( arraysize < 0 ) { ctx -> uniform_count ++ ; switch ( item -> regtype ) { case REG_TYPE_CONST : ctx -> uniform_float4_count ++ ; break ; case REG_TYPE_CONSTINT : ctx -> uniform_int4_count ++ ; break ; case REG_TYPE_CONSTBOOL : ctx -> uniform_bool_count ++ ; break ; default : break ; } } } for ( item = ctx -> samplers . next ; item != NULL ; item = item -> next ) { ctx -> sampler_count ++ ; ctx -> profile -> sampler_emitter ( ctx , item -> regnum , ( TextureType ) item -> index , item -> misc != 0 ) ; } for ( item = ctx -> attributes . next ; item != NULL ; item = item -> next ) { ctx -> attribute_count ++ ; ctx -> profile -> attribute_emitter ( ctx , item -> regtype , item -> regnum , item -> usage , item -> index , item -> writemask , item -> misc ) ; } } | <S2SV_ModStart> -> count ; } <S2SV_ModStart> uniform_count ++ ; <S2SV_ModEnd> } } for |
2,625 | CWE-000 static int type_max ( check_ctx_t * ctx , int idx ) { model_t model = ctx -> parent ; lts_type_t ltstype = GBgetLTStype ( model ) ; int typeno = lts_type_get_state_typeno ( ltstype , idx ) ; int c ; switch ( lts_type_get_format ( ltstype , typeno ) ) { case LTStypeDirect : GBgetInitialState ( model , ctx -> src2 ) ; c = ctx -> src2 [ idx ] ; return c == 0 ? 1 : c ; case LTStypeRange : return lts_type_get_min ( ltstype , typeno ) ; case LTStypeEnum : c = pins_chunk_count ( model , typeno ) ; HREassert ( c > 0 , "Empty<S2SV_blank>enum<S2SV_blank>table<S2SV_blank>for<S2SV_blank>slot:<S2SV_blank>%d<S2SV_blank>--<S2SV_blank>%s" , idx , str_slot ( ctx , NULL , idx ) ) ; return c ; case LTStypeChunk : c = pins_chunk_count ( model , typeno ) ; return c == 0 ? 1 : c ; case LTStypeBool : return 1 ; case LTStypeTrilean : return 2 ; case LTStypeSInt32 : return ( 1UL << 31 ) - 1 ; <S2SV_StartBug> default : HREassert ( false ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ; default : { <S2SV_ModStart> false ) ; return - 1 ; } |
2,626 | CWE-000 int vmbus_teardown_gpadl ( struct vmbus_channel * channel , u32 gpadl_handle ) { struct vmbus_channel_gpadl_teardown * msg ; struct vmbus_channel_msginfo * info ; unsigned long flags ; int ret ; info = kmalloc ( sizeof ( * info ) + sizeof ( struct vmbus_channel_gpadl_teardown ) , GFP_KERNEL ) ; if ( ! info ) return - ENOMEM ; init_completion ( & info -> waitevent ) ; <S2SV_StartBug> msg = ( struct vmbus_channel_gpadl_teardown * ) info -> msg ; <S2SV_EndBug> msg -> header . msgtype = CHANNELMSG_GPADL_TEARDOWN ; msg -> child_relid = channel -> offermsg . child_relid ; msg -> gpadl = gpadl_handle ; spin_lock_irqsave ( & vmbus_connection . channelmsg_lock , flags ) ; list_add_tail ( & info -> msglistentry , & vmbus_connection . chn_msg_list ) ; spin_unlock_irqrestore ( & vmbus_connection . channelmsg_lock , flags ) ; ret = vmbus_post_msg ( msg , sizeof ( struct vmbus_channel_gpadl_teardown ) , true ) ; if ( ret ) goto post_msg_err ; wait_for_completion ( & info -> waitevent ) ; <S2SV_StartBug> post_msg_err : <S2SV_EndBug> spin_lock_irqsave ( & vmbus_connection . channelmsg_lock , flags ) ; list_del ( & info -> msglistentry ) ; spin_unlock_irqrestore ( & vmbus_connection . channelmsg_lock , flags ) ; kfree ( info ) ; return ret ; } | <S2SV_ModStart> waitevent ) ; info -> waiting_channel = channel ; <S2SV_ModStart> waitevent ) ; if ( channel -> rescind ) { ret = - ENODEV ; goto post_msg_err ; } |
2,627 | CWE-000 void addFunctions ( ulong * matrix , ulong * constants , CubePolynomial * bufferMatrix , ulong * funcMatrix ) { for ( uint i = 0 ; i < size - 1 ; i ++ ) { for ( uint j = i + 1 ; j < size ; j ++ ) { CubePolynomial buffer ; ulong polynom [ size + 1 ] ; for ( uint k = 0 ; k < size + 1 ; k ++ ) { polynom [ k ] = 0 ; } for ( uint k = 0 ; k < 2 * AMOUNT_OF_VAR_IN_LINE_FIRST ; ) { ulong index = matrix [ j * 2 * AMOUNT_OF_VAR_IN_LINE_FIRST + k ] ; ulong number = matrix [ j * 2 * AMOUNT_OF_VAR_IN_LINE_FIRST + k + 1 ] ; polynom [ index ] = number ; k += 2 ; } polynom [ size ] = constants [ j ] ; polynomialDeg ( polynom , & buffer , funcMatrix [ j + i * size ] % 6 ) ; # ifdef PRINT printCubePolynomial ( buffer ) ; # endif uint cur = 0 ; while ( ( buffer . factor [ cur ] != 0 ) && ( cur < MAX_TERMS_IN_POLY ) ) { uint k ; for ( k = 0 ; k < MAX_TERMS_IN_POLY ; k ++ ) { if ( ( bufferMatrix [ i ] . factor [ k ] == 0 ) && ( get5Vars ( bufferMatrix [ i ] . vars , k ) == 0 ) ) { if ( k == MAX_TERMS_IN_POLY - 1 ) { write5Vars ( buffer . vars , bufferMatrix [ i ] . vars , cur , k ) ; break ; } else { if ( get5Vars ( bufferMatrix [ i ] . vars , k + 1 ) == 0 ) { write5Vars ( buffer . vars , bufferMatrix [ i ] . vars , cur , k ) ; break ; } <S2SV_StartBug> continue ; <S2SV_EndBug> } } if ( get5Vars ( bufferMatrix [ i ] . vars , k ) == get5Vars ( buffer . vars , cur ) ) { break ; } } bufferMatrix [ i ] . factor [ k ] = modularAdd ( bufferMatrix [ i ] . factor [ k ] , buffer . factor [ cur ] ) ; cur ++ ; } # ifdef PRINT printf ( "bufferMatrix\\n" ) ; printCubePolynomial ( bufferMatrix [ i ] ) ; printf ( "\\n" ) ; # endif } } } | <S2SV_ModStart> break ; } if ( get5Vars ( bufferMatrix [ i ] . vars , k ) == get5Vars ( buffer . vars , cur ) ) { break ; } |
2,628 | CWE-000 void freeStructTmodel ( tmodel * * tmodel ) { <S2SV_StartBug> int i = 0 , rc = ( * tmodel ) -> count ; <S2SV_EndBug> freeStructValues ( ( * tmodel ) -> _v ) ; <S2SV_StartBug> for ( ; i < rc ; i ++ ) <S2SV_EndBug> { free ( tmodel [ i ] ) ; <S2SV_StartBug> } <S2SV_EndBug> free ( tmodel ) ; } | <S2SV_ModStart> i = 0 <S2SV_ModEnd> ; freeStructValues ( <S2SV_ModStart> _v ) ; do <S2SV_ModEnd> { free ( <S2SV_ModStart> ] ) ; ++ i ; } while ( tmodel [ i ] ) ; <S2SV_ModEnd> free ( tmodel |
2,629 | CWE-000 <S2SV_StartBug> static bool query_dec_mode ( int mode ) <S2SV_EndBug> { char * s = NULL ; printf ( "\\x1b[?%d$p" , mode ) ; do { int reply_mode , reply_value ; char reply_cmd ; if ( s ) free ( s ) ; s = read_csi ( ) ; if ( sscanf ( s , "?%d;%d$%c" , & reply_mode , & reply_value , & reply_cmd ) < 3 ) continue ; if ( reply_cmd != 'y' ) continue ; if ( reply_mode != mode ) continue ; free ( s ) ; if ( reply_value == 1 || reply_value == 3 ) <S2SV_StartBug> return true ; <S2SV_EndBug> if ( reply_value == 2 || reply_value == 4 ) <S2SV_StartBug> return false ; <S2SV_EndBug> printf ( "Unrecognised<S2SV_blank>reply<S2SV_blank>to<S2SV_blank>DECRQM:<S2SV_blank>%d\\n" , reply_value ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } while ( 1 ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> query_dec_mode ( int <S2SV_ModStart> 3 ) return TRUE <S2SV_ModEnd> ; if ( <S2SV_ModStart> 4 ) return FALSE <S2SV_ModEnd> ; printf ( <S2SV_ModStart> ) ; return FALSE <S2SV_ModEnd> ; } while |
2,630 | CWE-000 void __texture_widget_render_copy ( void * __widget , RenderData * data ) { TextureWidget * t_widget = __widget ; if ( t_widget -> texture == NULL ) { return ; } <S2SV_StartBug> SDL_Rect bounds ; <S2SV_EndBug> SDL_Rect draw_area = widget_get_drawable_area ( t_widget , & bounds , data -> camera ) ; border_draw ( t_widget -> widget . border , data ) ; SDL_RenderCopy ( data -> renderer , t_widget -> texture , & draw_area , & bounds ) ; } | <S2SV_ModStart> } SDL_Rect bounds = widget_get_bounds_camera ( t_widget , data -> camera ) ; |
2,631 | CWE-000 int asn1_do_lock ( ASN1_VALUE * * pval , int op , const ASN1_ITEM * it ) { const ASN1_AUX * aux ; <S2SV_StartBug> CRYPTO_REF_COUNT * lck ; <S2SV_EndBug> <S2SV_StartBug> CRYPTO_RWLOCK * * lock ; <S2SV_EndBug> int ret = - 1 ; if ( ( it -> itype != ASN1_ITYPE_SEQUENCE ) && ( it -> itype != ASN1_ITYPE_NDEF_SEQUENCE ) ) return 0 ; aux = it -> funcs ; if ( ! aux || ! ( aux -> flags & ASN1_AFLG_REFCOUNT ) ) return 0 ; lck = offset2ptr ( * pval , aux -> ref_offset ) ; lock = offset2ptr ( * pval , aux -> ref_lock ) ; <S2SV_StartBug> switch ( op ) { <S2SV_EndBug> case 0 : * lck = ret = 1 ; * lock = CRYPTO_THREAD_lock_new ( ) ; if ( * lock == NULL ) { ASN1err ( ASN1_F_ASN1_DO_LOCK , ERR_R_MALLOC_FAILURE ) ; return - 1 ; } <S2SV_StartBug> break ; <S2SV_EndBug> case 1 : <S2SV_StartBug> if ( ! CRYPTO_UP_REF ( lck , & ret , * lock ) ) <S2SV_EndBug> return - 1 ; break ; case - 1 : if ( ! CRYPTO_DOWN_REF ( lck , & ret , * lock ) ) return - 1 ; # ifdef REF_PRINT <S2SV_StartBug> fprintf ( stderr , "%p:%4d:%s\\n" , it , ret , it -> sname ) ; <S2SV_EndBug> # endif REF_ASSERT_ISNT ( ret < 0 ) ; if ( ret == 0 ) { CRYPTO_THREAD_lock_free ( * lock ) ; * lock = NULL ; } <S2SV_StartBug> break ; <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> * aux ; int * lck , ret <S2SV_ModEnd> ; CRYPTO_RWLOCK * <S2SV_ModStart> * * lock <S2SV_ModEnd> ; if ( <S2SV_ModStart> ref_lock ) ; if ( op == 0 ) { * lck <S2SV_ModEnd> = 1 ; <S2SV_ModStart> 1 ; } return 1 ; } if ( CRYPTO_atomic_add ( lck , op <S2SV_ModEnd> , & ret <S2SV_ModStart> * lock ) < 0 <S2SV_ModEnd> ) return - <S2SV_ModStart> , it , * lck <S2SV_ModEnd> , it -> <S2SV_ModStart> NULL ; } <S2SV_ModEnd> return ret ; |
2,632 | CWE-000 module_ret_code module_tell ( const self_t * self , const char * recipient , const char * message ) { MOD_ASSERT ( self , "NULL<S2SV_blank>self<S2SV_blank>handler." , MOD_NO_SELF ) ; MOD_ASSERT ( message , "NULL<S2SV_blank>message." , MOD_ERR ) ; MOD_ASSERT ( recipient , "NULL<S2SV_blank>recipient." , MOD_ERR ) ; GET_CTX ( self -> ctx ) ; CTX_GET_MOD ( recipient , c ) ; pubsub_msg_t m = { . topic = NULL , . message = message , . sender = self , . type = USER } ; <S2SV_StartBug> return tell_pubsub_msg ( & m , mod , NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> , mod , c <S2SV_ModEnd> ) ; } |
2,633 | CWE-000 int main ( ) { mbedtls_mpi p , q , n , s , m , k , tmp , c , c2 , op ; mbedtls_mpi_init ( & n ) ; mbedtls_mpi_init ( & p ) ; mbedtls_mpi_init ( & q ) ; mbedtls_mpi_init ( & k ) ; mbedtls_mpi_init ( & s ) ; mbedtls_mpi_init ( & m ) ; mbedtls_mpi_init ( & c ) ; mbedtls_mpi_init ( & c2 ) ; mbedtls_mpi_init ( & op ) ; mbedtls_mpi_init ( & tmp ) ; pick_key ( & p , & q , & n ) ; do { mbedtls_mpi_fill_random ( & s , SIZE_M , myrand , NULL ) ; } while ( jacobi ( & s , & n ) != - 1 ) ; char msg [ 2048 ] ; scanf ( "%s" , msg ) ; mbedtls_mpi_read_string ( & m , 16 , msg ) ; int c1 ; switch ( jacobi ( & m , & n ) ) { case ( 1 ) : c1 = 0 ; break ; case ( - 1 ) : c1 = 1 ; break ; } calculate_k ( & k , & p , & q ) ; <S2SV_StartBug> tmp . p = & c1 ; <S2SV_EndBug> encoding ( & c , & c2 , & s , & tmp , & m , & n ) ; <S2SV_StartBug> printf ( "Encoding<S2SV_blank>message:<S2SV_blank><S2SV_blank>" ) ; <S2SV_EndBug> <S2SV_StartBug> mbedtls_mpi_write_file ( NULL , & c , 16 , NULL ) ; <S2SV_EndBug> printf ( "C1:<S2SV_blank>%i\\n" , c1 ) ; printf ( "C2:<S2SV_blank>" ) ; mbedtls_mpi_write_file ( NULL , & c2 , 16 , NULL ) ; return 0 ; } | <S2SV_ModStart> q ) ; sprintf ( msg , "%d" , c1 ) ; mbedtls_mpi_read_string ( & tmp , 10 , msg ) <S2SV_ModEnd> ; encoding ( <S2SV_ModStart> n ) ; decoding ( & op , & k , & c , & c1 , & c2 , & n ) ; <S2SV_ModStart> NULL , & op <S2SV_ModEnd> , 16 , |
2,634 | CWE-000 void update_display ( ) { <S2SV_StartBug> if ( delta_Z >= 8 && delta_Z < 16 ) P1OUT = BIT6 ; <S2SV_EndBug> <S2SV_StartBug> else if ( delta_Z >= 0 ) P1OUT = ( BIT0 + BIT6 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( delta_Z >= - 8 ) P1OUT = BIT0 ; <S2SV_EndBug> else P1OUT = 0 ; } | <S2SV_ModStart> { if ( delta_H <S2SV_ModEnd> >= 8 && <S2SV_ModStart> else if ( delta_H <S2SV_ModEnd> >= 0 ) <S2SV_ModStart> else if ( delta_H <S2SV_ModEnd> >= - 8 |
2,635 | CWE-000 static void tc_timer_timer_initialize ( void ) { <S2SV_StartBug> timer_t timer_id ; <S2SV_EndBug> clockid_t clockid = CLOCK_REALTIME ; struct sigevent st_sigevent ; FAR struct posix_timer_s * timer ; FAR struct posix_timer_s * next ; int initalloc_cnt = 0 ; int initfree_cnt = 0 ; int createalloc_cnt = 0 ; int createfree_cnt = 0 ; int finalalloc_cnt = 0 ; int finalfree_cnt = 0 ; st_sigevent . sigev_notify = SIGEV_SIGNAL ; st_sigevent . sigev_signo = sig_no ; st_sigevent . sigev_value . sival_ptr = & timer_id ; timer_initialize ( ) ; for ( timer = ( FAR struct posix_timer_s * ) g_alloctimers . head ; timer ; timer = next ) { next = timer -> flink ; initalloc_cnt ++ ; } for ( timer = ( FAR struct posix_timer_s * ) g_freetimers . head ; timer ; timer = next ) { next = timer -> flink ; initfree_cnt ++ ; } <S2SV_StartBug> timer_create ( clockid , & st_sigevent , & timer_id ) ; <S2SV_EndBug> <S2SV_StartBug> for ( timer = ( FAR struct posix_timer_s * ) g_alloctimers . head ; timer ; timer = next ) { <S2SV_EndBug> next = timer -> flink ; createalloc_cnt ++ ; } for ( timer = ( FAR struct posix_timer_s * ) g_freetimers . head ; timer ; timer = next ) { next = timer -> flink ; createfree_cnt ++ ; } timer_initialize ( ) ; for ( timer = ( FAR struct posix_timer_s * ) g_alloctimers . head ; timer ; timer = next ) { next = timer -> flink ; finalalloc_cnt ++ ; } for ( timer = ( FAR struct posix_timer_s * ) g_freetimers . head ; timer ; timer = next ) { next = timer -> flink ; finalfree_cnt ++ ; } TC_ASSERT_EQ_CLEANUP ( "timer_initialise" , initalloc_cnt , finalalloc_cnt , timer_delete ( timer_id ) ) ; TC_ASSERT_EQ_CLEANUP ( "timer_initialise" , initfree_cnt , finalfree_cnt , timer_delete ( timer_id ) ) ; TC_ASSERT_NEQ_CLEANUP ( "timer_initialise" , createalloc_cnt , finalalloc_cnt , timer_delete ( timer_id ) ) ; TC_ASSERT_NEQ_CLEANUP ( "timer_initialise" , createfree_cnt , finalfree_cnt , timer_delete ( timer_id ) ) ; timer_delete ( timer_id ) ; TC_SUCCESS_RESULT ( ) ; } | <S2SV_ModStart> void ) { int ret_chk ; <S2SV_ModStart> ++ ; } ret_chk = <S2SV_ModStart> timer_id ) ; TC_ASSERT_NEQ ( "timer_create" , ret_chk , ERROR ) ; TC_ASSERT_NEQ ( "timer_create" , timer_id , NULL ) ; |
2,636 | CWE-000 void generate_node_name ( FILE * out , tac_list * start , tac_list * end ) { assert ( out ) ; assert ( start ) ; assert ( end ) ; <S2SV_StartBug> char label [ 2048 ] = { 0 } ; <S2SV_EndBug> while ( start != end ) { <S2SV_StartBug> print_tac_elem ( out , start ) ; <S2SV_EndBug> fprintf ( out , "\\\\n" ) ; start = start -> next ; } print_tac_elem ( out , start ) ; } | <S2SV_ModStart> end ) ; <S2SV_ModEnd> while ( start <S2SV_ModStart> out , start <S2SV_ModEnd> ) ; start |
2,637 | CWE-000 void app_main ( ) { bt_setup ( ) ; setDHTPin ( 18 ) ; for ( ; ; ) { <S2SV_StartBug> vTaskDelay ( 10000 / portTICK_PERIOD_MS ) ; <S2SV_EndBug> temp_humidity ( ) ; } } | <S2SV_ModStart> { vTaskDelay ( 5000 <S2SV_ModEnd> / portTICK_PERIOD_MS ) |
2,638 | CWE-000 UINTN Create4GPageTablesIa32Pae ( IN EFI_PHYSICAL_ADDRESS StackBase , IN UINTN StackSize ) { UINT8 PhysicalAddressBits ; EFI_PHYSICAL_ADDRESS PhysicalAddress ; UINTN IndexOfPdpEntries ; UINTN IndexOfPageDirectoryEntries ; UINT32 NumberOfPdpEntriesNeeded ; PAGE_MAP_AND_DIRECTORY_POINTER * PageMap ; PAGE_MAP_AND_DIRECTORY_POINTER * PageDirectoryPointerEntry ; PAGE_TABLE_ENTRY * PageDirectoryEntry ; UINTN TotalPagesNum ; UINTN PageAddress ; UINT64 AddressEncMask ; AddressEncMask = PcdGet64 ( PcdPteMemoryEncryptionAddressOrMask ) & PAGING_1G_ADDRESS_MASK_64 ; PhysicalAddressBits = 32 ; NumberOfPdpEntriesNeeded = ( UINT32 ) LShiftU64 ( 1 , ( PhysicalAddressBits - 30 ) ) ; TotalPagesNum = NumberOfPdpEntriesNeeded + 1 ; <S2SV_StartBug> PageAddress = ( UINTN ) AllocatePages ( TotalPagesNum ) ; <S2SV_EndBug> ASSERT ( PageAddress != 0 ) ; PageMap = ( VOID * ) PageAddress ; PageAddress += SIZE_4KB ; PageDirectoryPointerEntry = PageMap ; PhysicalAddress = 0 ; for ( IndexOfPdpEntries = 0 ; IndexOfPdpEntries < NumberOfPdpEntriesNeeded ; IndexOfPdpEntries ++ , PageDirectoryPointerEntry ++ ) { PageDirectoryEntry = ( VOID * ) PageAddress ; PageAddress += SIZE_4KB ; PageDirectoryPointerEntry -> Uint64 = ( UINT64 ) ( UINTN ) PageDirectoryEntry | AddressEncMask ; PageDirectoryPointerEntry -> Bits . Present = 1 ; for ( IndexOfPageDirectoryEntries = 0 ; IndexOfPageDirectoryEntries < 512 ; IndexOfPageDirectoryEntries ++ , PageDirectoryEntry ++ , PhysicalAddress += SIZE_2MB ) { if ( ( IsNullDetectionEnabled ( ) && PhysicalAddress == 0 ) || ( ( PhysicalAddress < StackBase + StackSize ) && ( ( PhysicalAddress + SIZE_2MB ) > StackBase ) ) ) { Split2MPageTo4K ( PhysicalAddress , ( UINT64 * ) PageDirectoryEntry , StackBase , StackSize ) ; } else { PageDirectoryEntry -> Uint64 = ( UINT64 ) PhysicalAddress | AddressEncMask ; PageDirectoryEntry -> Bits . ReadWrite = 1 ; PageDirectoryEntry -> Bits . Present = 1 ; PageDirectoryEntry -> Bits . MustBe1 = 1 ; } } } for ( ; IndexOfPdpEntries < 512 ; IndexOfPdpEntries ++ , PageDirectoryPointerEntry ++ ) { ZeroMem ( PageDirectoryPointerEntry , sizeof ( PAGE_MAP_AND_DIRECTORY_POINTER ) ) ; } <S2SV_StartBug> return ( UINTN ) PageMap ; <S2SV_EndBug> } | <S2SV_ModStart> ( UINTN ) AllocatePageTableMemory <S2SV_ModEnd> ( TotalPagesNum ) <S2SV_ModStart> ) ; } EnablePageTableProtection ( ( UINTN ) PageMap , FALSE ) ; |
2,639 | CWE-000 static int ocfs2_lock_allocators_move_extents ( struct inode * inode , struct ocfs2_extent_tree * et , u32 clusters_to_move , u32 extents_to_split , struct ocfs2_alloc_context * * meta_ac , struct ocfs2_alloc_context * * data_ac , int extra_blocks , int * credits ) { int ret , num_free_extents ; unsigned int max_recs_needed = 2 * extents_to_split + clusters_to_move ; struct ocfs2_super * osb = OCFS2_SB ( inode -> i_sb ) ; num_free_extents = ocfs2_num_free_extents ( et ) ; if ( num_free_extents < 0 ) { ret = num_free_extents ; mlog_errno ( ret ) ; goto out ; } if ( ! num_free_extents || ( ocfs2_sparse_alloc ( osb ) && num_free_extents < max_recs_needed ) ) extra_blocks += ocfs2_extend_meta_needed ( et -> et_root_el ) ; ret = ocfs2_reserve_new_metadata_blocks ( osb , extra_blocks , meta_ac ) ; if ( ret ) { mlog_errno ( ret ) ; goto out ; } <S2SV_StartBug> if ( data_ac ) { <S2SV_EndBug> ret = ocfs2_reserve_clusters ( osb , clusters_to_move , data_ac ) ; if ( ret ) { mlog_errno ( ret ) ; goto out ; } } * credits += ocfs2_calc_extend_credits ( osb -> sb , et -> et_root_el ) ; mlog ( 0 , "reserve<S2SV_blank>metadata_blocks:<S2SV_blank>%d,<S2SV_blank>data_clusters:<S2SV_blank>%u,<S2SV_blank>credits:<S2SV_blank>%d\\n" , extra_blocks , clusters_to_move , * credits ) ; out : if ( ret ) { if ( * meta_ac ) { ocfs2_free_alloc_context ( * meta_ac ) ; * meta_ac = NULL ; } } return ret ; } | <S2SV_ModStart> out ; } <S2SV_ModEnd> * credits += |
2,640 | CWE-000 static int conf_set_sym_val ( struct symbol * sym , int def , int def_flags , char * p ) { char * p2 ; switch ( sym -> type ) { case S_TRISTATE : if ( p [ 0 ] == 'm' ) { sym -> def [ def ] . tri = mod ; sym -> flags |= def_flags ; break ; } case S_BOOLEAN : if ( p [ 0 ] == 'y' ) { sym -> def [ def ] . tri = yes ; sym -> flags |= def_flags ; break ; } if ( p [ 0 ] == 'n' ) { sym -> def [ def ] . tri = no ; sym -> flags |= def_flags ; break ; } if ( def != S_DEF_AUTO ) conf_warning ( "symbol<S2SV_blank>value<S2SV_blank>\'%s\'<S2SV_blank>invalid<S2SV_blank>for<S2SV_blank>%s" , p , sym -> name ) ; return 1 ; case S_OTHER : if ( * p != \'"\' ) { for ( p2 = p ; * p2 && ! isspace ( * p2 ) ; p2 ++ ) ; sym -> type = S_STRING ; goto done ; } case S_STRING : if ( * p ++ != \'"\' ) break ; for ( p2 = p ; ( p2 = strpbrk ( p2 , "\\"\\\\" ) ) ; p2 ++ ) { if ( * p2 == \'"\' ) { * p2 = 0 ; break ; } memmove ( p2 , p2 + 1 , strlen ( p2 ) ) ; } if ( ! p2 ) { if ( def != S_DEF_AUTO ) conf_warning ( "invalid<S2SV_blank>string<S2SV_blank>found" ) ; return 1 ; } case S_INT : case S_HEX : done : if ( sym_string_valid ( sym , p ) ) { <S2SV_StartBug> sym -> def [ def ] . val = strdup ( p ) ; <S2SV_EndBug> sym -> flags |= def_flags ; } else { if ( def != S_DEF_AUTO ) conf_warning ( "symbol<S2SV_blank>value<S2SV_blank>\'%s\'<S2SV_blank>invalid<S2SV_blank>for<S2SV_blank>%s" , p , sym -> name ) ; return 1 ; } break ; default : ; } return 0 ; } | <S2SV_ModStart> . val = xstrdup <S2SV_ModEnd> ( p ) |
2,641 | CWE-000 void pcnet_driver_setup ( void ) { pcnet_list = list_create ( ) ; list_t * list = device_query ( DEVICE_CLASS_PCI ) ; list_for_each ( node , list ) { device_entry_t * entry = node -> value ; pci_device_t * pci = entry -> device ; <S2SV_StartBug> if ( pci -> vendor_id == 0x8086 && pci -> device_id == 0x7010 ) { <S2SV_EndBug> pcnet_init ( entry , pci ) ; } } } | <S2SV_ModStart> -> vendor_id == 0x1022 <S2SV_ModEnd> && pci -> <S2SV_ModStart> -> device_id == 0x2000 <S2SV_ModEnd> ) { pcnet_init |
2,642 | CWE-000 int fuse_dev_release ( struct inode * inode , struct file * file ) { struct fuse_dev * fud = fuse_get_dev ( file ) ; if ( fud ) { struct fuse_conn * fc = fud -> fc ; struct fuse_pqueue * fpq = & fud -> pq ; WARN_ON ( ! list_empty ( & fpq -> io ) ) ; end_requests ( fc , & fpq -> processing ) ; if ( atomic_dec_and_test ( & fc -> dev_count ) ) { WARN_ON ( fc -> iq . fasync != NULL ) ; <S2SV_StartBug> fuse_abort_conn ( fc ) ; <S2SV_EndBug> } fuse_dev_free ( fud ) ; } return 0 ; } | <S2SV_ModStart> fuse_abort_conn ( fc , false |
2,643 | CWE-000 VALUE rb_ldap_entry_new ( LDAP * ldap , LDAPMessage * msg ) { VALUE val ; RB_LDAPENTRY_DATA * edata ; <S2SV_StartBug> char * c_dn ; <S2SV_EndBug> val = Data_Make_Struct ( rb_cLDAP_Entry , RB_LDAPENTRY_DATA , rb_ldap_entry_mark , rb_ldap_entry_free , edata ) ; <S2SV_StartBug> edata -> ldap = ldap ; <S2SV_EndBug> <S2SV_StartBug> edata -> msg = msg ; <S2SV_EndBug> c_dn = ldap_get_dn ( ldap , msg ) ; if ( c_dn ) { edata -> dn = rb_tainted_str_new2 ( c_dn ) ; ldap_memfree ( c_dn ) ; } else { edata -> dn = Qnil ; } edata -> attr = rb_ldap_entry_load_attr ( ldap , msg ) ; <S2SV_StartBug> return val ; <S2SV_EndBug> } | <S2SV_ModStart> * edata ; # if RUBY_VERSION_CODE >= 190 <S2SV_ModStart> * c_dn ; # endif # if RUBY_VERSION_CODE >= 190 <S2SV_ModStart> edata ) ; # else val = Data_Make_Struct ( rb_cLDAP_Entry , RB_LDAPENTRY_DATA , 0 , rb_ldap_entry_free , edata ) ; # endif <S2SV_ModStart> = msg ; # if RUBY_VERSION_CODE >= 190 <S2SV_ModStart> msg ) ; # endif |
2,644 | CWE-000 int msm_bam_dmux_open ( uint32_t id , void * priv , void ( * notify ) ( void * , int , unsigned long ) ) { struct bam_mux_hdr * hdr ; unsigned long flags ; int rc = 0 ; DBG ( "%s:<S2SV_blank>opening<S2SV_blank>ch<S2SV_blank>%d\\n" , __func__ , id ) ; if ( ! bam_mux_initialized ) { DBG ( "%s:<S2SV_blank>not<S2SV_blank>inititialized\\n" , __func__ ) ; return - ENODEV ; } if ( id >= BAM_DMUX_NUM_CHANNELS ) { pr_err ( "%s:<S2SV_blank>invalid<S2SV_blank>channel<S2SV_blank>id<S2SV_blank>%d\\n" , __func__ , id ) ; return - EINVAL ; } if ( notify == NULL ) { pr_err ( "%s:<S2SV_blank>notify<S2SV_blank>function<S2SV_blank>is<S2SV_blank>NULL\\n" , __func__ ) ; return - EINVAL ; } hdr = kmalloc ( sizeof ( struct bam_mux_hdr ) , GFP_KERNEL ) ; if ( hdr == NULL ) { pr_err ( "%s:<S2SV_blank>hdr<S2SV_blank>kmalloc<S2SV_blank>failed.<S2SV_blank>ch:<S2SV_blank>%d\\n" , __func__ , id ) ; return - ENOMEM ; } spin_lock_irqsave ( & bam_ch [ id ] . lock , flags ) ; if ( bam_ch_is_open ( id ) ) { DBG ( "%s:<S2SV_blank>Already<S2SV_blank>opened<S2SV_blank>%d\\n" , __func__ , id ) ; spin_unlock_irqrestore ( & bam_ch [ id ] . lock , flags ) ; kfree ( hdr ) ; goto open_done ; } if ( ! bam_ch_is_remote_open ( id ) ) { DBG ( "%s:<S2SV_blank>Remote<S2SV_blank>not<S2SV_blank>open;<S2SV_blank>ch:<S2SV_blank>%d\\n" , __func__ , id ) ; spin_unlock_irqrestore ( & bam_ch [ id ] . lock , flags ) ; kfree ( hdr ) ; return - ENODEV ; } bam_ch [ id ] . notify = notify ; bam_ch [ id ] . priv = priv ; bam_ch [ id ] . status |= BAM_CH_LOCAL_OPEN ; bam_ch [ id ] . num_tx_pkts = 0 ; bam_ch [ id ] . use_wm = 0 ; spin_unlock_irqrestore ( & bam_ch [ id ] . lock , flags ) ; notify ( priv , BAM_DMUX_TRANSMIT_SIZE , ul_mtu ) ; read_lock ( & ul_wakeup_lock ) ; if ( ! bam_is_connected ) { <S2SV_StartBug> read_unlock ( & ul_wakeup_lock ) ; <S2SV_EndBug> ul_wakeup ( ) ; if ( unlikely ( in_global_reset == 1 ) ) { <S2SV_StartBug> kfree ( hdr ) ; <S2SV_EndBug> return - EFAULT ; } read_lock ( & ul_wakeup_lock ) ; notify_all ( BAM_DMUX_UL_CONNECTED , ( unsigned long ) ( NULL ) ) ; <S2SV_StartBug> } <S2SV_EndBug> hdr -> magic_num = BAM_MUX_HDR_MAGIC_NO ; hdr -> cmd = BAM_MUX_HDR_CMD_OPEN ; hdr -> signal = create_open_signal ( ) ; hdr -> ch_id = id ; hdr -> pkt_len = 0 ; hdr -> pad_len = 0 ; rc = bam_mux_write_cmd ( ( void * ) hdr , sizeof ( struct bam_mux_hdr ) ) ; read_unlock ( & ul_wakeup_lock ) ; open_done : DBG ( "%s:<S2SV_blank>opened<S2SV_blank>ch<S2SV_blank>%d\\n" , __func__ , id ) ; return rc ; } | <S2SV_ModStart> bam_is_connected ) { atomic_inc ( & ul_ondemand_vote ) ; <S2SV_ModStart> ) ) { atomic_dec ( & ul_ondemand_vote ) ; <S2SV_ModStart> ) ) ; atomic_dec ( & ul_ondemand_vote ) ; |
2,645 | CWE-000 <S2SV_StartBug> int btree_find ( struct btree * btree , void * key , size_t keylen , <S2SV_EndBug> btree_iter_t iter ) { struct btree_node * node = btree -> root ; uint32_t depth ; uint32_t pos ; int found = 0 ; iter -> tree = ( struct btree * ) btree ; iter -> record = NULL ; depth = node -> depth ; while ( 1 ) { int f = 0 ; pos = btree -> search ( key , keylen , node -> recs , node -> count , & f ) ; if ( f ) { iter -> record = node -> recs [ pos ] ; found = 1 ; } if ( ! depth -- ) break ; node = node -> branches [ pos ] ; } iter -> node = node ; iter -> pos = pos ; return found ; } | <S2SV_ModStart> * btree , unsigned char <S2SV_ModEnd> * key , |
2,646 | CWE-000 cpl_polynomial * cr2res_wave_etalon ( cpl_bivector * spectrum , cpl_bivector * spectrum_err , cpl_polynomial * wavesol_init , int degree , cpl_array * * wavelength_error ) { cpl_bivector * is_should ; cpl_vector * xi ; cpl_vector * li ; cpl_vector * mi ; cpl_vector * li_true ; <S2SV_StartBug> double l0 , trueD ; <S2SV_EndBug> int nxi , i ; <S2SV_StartBug> xi = cr2res_wave_etalon_measure_fringes ( <S2SV_EndBug> cpl_bivector_get_y ( spectrum ) ) ; nxi = cpl_vector_get_size ( xi ) ; li = cr2res_polynomial_eval_vector ( wavesol_init , xi ) ; mi = cpl_vector_new ( nxi ) ; l0 = cpl_vector_get ( li , 0 ) ; for ( i = 0 ; i < nxi ; i ++ ) { cpl_vector_set ( mi , i , cpl_vector_get ( li , i ) / l0 ) ; } if ( cpl_msg_get_level ( ) == CPL_MSG_DEBUG ) { cpl_vector_dump ( mi , stdout ) ; } trueD = cr2res_wave_etalon_get_D ( li ) ; cpl_msg_debug ( __func__ , "trueD:<S2SV_blank>%e" , trueD ) ; li_true = cpl_vector_new ( nxi ) ; for ( i = 0 ; i < nxi ; i ++ ) { cpl_vector_set ( li_true , i , l0 + ( trueD * i ) ) ; } <S2SV_StartBug> is_should = cr2res_wave_etalon_assign_fringes ( xi , li_true ) ; <S2SV_EndBug> cpl_bivector_dump ( is_should , stdout ) ; <S2SV_StartBug> cpl_matrix * px = cpl_matrix_wrap ( nxi , 1 , cpl_vector_get_data ( xi ) ) ; <S2SV_EndBug> <S2SV_StartBug> cpl_polynomial * result = polyfit_1d ( px , li_true , NULL , <S2SV_EndBug> degree , wavesol_init , wavelength_error , NULL , NULL ) ; cpl_matrix_unwrap ( px ) ; cpl_vector_delete ( li_true ) ; cpl_bivector_delete ( is_should ) ; cpl_vector_delete ( xi ) ; cpl_vector_delete ( li ) ; cpl_vector_delete ( mi ) ; return result ; } | <S2SV_ModStart> * li_true ; cpl_matrix * px ; cpl_polynomial * result ; <S2SV_ModStart> , i ; if ( spectrum == NULL | spectrum_err == NULL | wavesol_init == NULL | degree < 0 | wavelength_error == NULL ) return NULL ; <S2SV_ModStart> = cr2res_wave_etalon_assign_fringes ( li <S2SV_ModEnd> , li_true ) <S2SV_ModStart> stdout ) ; <S2SV_ModEnd> px = cpl_matrix_wrap <S2SV_ModStart> ) ) ; <S2SV_ModEnd> result = polyfit_1d <S2SV_ModStart> ( px , cpl_bivector_get_y ( is_should ) <S2SV_ModEnd> , NULL , |
2,647 | CWE-000 int main ( int argc , char * * argv ) { int fd ; t_asm * file ; g_tab = init_tab ( ) ; if ( argc != 2 ) ft_error ( "\\nusage:<S2SV_blank>./asm<S2SV_blank>file.s" ) ; if ( ( fd = open ( argv [ 1 ] , O_RDONLY , 0 ) ) == - 1 ) ft_error ( "invalid<S2SV_blank>file" ) ; file = init_file ( ) ; read_filename ( fd , argv [ 1 ] , file ) ; read_file ( fd , file ) ; ft_parse_lines ( file -> code ) ; make_cor ( file ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> file ) ; ft_printf ( "Writing<S2SV_blank>output<S2SV_blank>program<S2SV_blank>to<S2SV_blank>%s.cor\\n" , file -> filename ) ; |
2,648 | CWE-000 static void * do_cond_signal ( void * arg ) { struct thread_args * t = ( struct thread_args * ) arg ; struct locks * lock = D_RW ( t -> lock ) ; if ( t -> t_id == 0 ) { pmemobj_mutex_lock ( lock -> pop , & lock -> mtx ) ; while ( lock -> data < ( NUM_THREADS - 1 ) ) pmemobj_cond_wait ( lock -> pop , & lock -> cond , & lock -> mtx ) ; lock -> data ++ ; <S2SV_StartBug> pmemobj_mutex_unlock ( lock -> pop , & lock -> mtx ) ; <S2SV_EndBug> } else { pmemobj_mutex_lock ( lock -> pop , & lock -> mtx ) ; lock -> data ++ ; <S2SV_StartBug> pmemobj_cond_signal ( lock -> pop , & lock -> cond ) ; <S2SV_EndBug> pmemobj_mutex_unlock ( lock -> pop , & lock -> mtx ) ; } return NULL ; } | <S2SV_ModStart> data ++ ; pmemobj_persist ( lock -> pop , & lock -> data , sizeof ( lock -> data ) ) ; <S2SV_ModStart> data ++ ; pmemobj_persist ( lock -> pop , & lock -> data , sizeof ( lock -> data ) ) ; |
2,649 | CWE-000 int mdss_create_xlog_debug ( struct mdss_debug_data * mdd ) { <S2SV_StartBug> spin_lock_init ( & mdss_dbg_xlog . xlock ) ; <S2SV_EndBug> mdss_dbg_xlog . xlog = debugfs_create_dir ( "xlog" , mdd -> root ) ; if ( IS_ERR_OR_NULL ( mdss_dbg_xlog . xlog ) ) { pr_err ( "debugfs_create_dir<S2SV_blank>fail,<S2SV_blank>error<S2SV_blank>%ld\\n" , PTR_ERR ( mdss_dbg_xlog . xlog ) ) ; mdss_dbg_xlog . xlog = NULL ; return - ENODEV ; } debugfs_create_file ( "dump" , 0644 , mdss_dbg_xlog . xlog , NULL , & mdss_xlog_fops ) ; debugfs_create_u32 ( "enable" , 0644 , mdss_dbg_xlog . xlog , & mdss_dbg_xlog . xlog_enable ) ; debugfs_create_bool ( "panic" , 0644 , mdss_dbg_xlog . xlog , & mdss_dbg_xlog . panic_on_err ) ; debugfs_create_u32 ( "reg_dump" , 0644 , mdss_dbg_xlog . xlog , & mdss_dbg_xlog . enable_reg_dump ) ; return 0 ; } | <S2SV_ModStart> mdd ) { <S2SV_ModEnd> mdss_dbg_xlog . xlog |
2,650 | CWE-000 struct dev_t * mappa_create_dev ( struct mappa_t * m , struct ctlra_dev_t * ctlra_dev , const struct ctlra_dev_info_t * info ) { struct dev_t * dev = calloc ( 1 , sizeof ( * dev ) ) ; if ( ! dev ) return 0 ; TAILQ_INIT ( & dev -> lut_list ) ; int32_t ret = lut_create_add_to_dev ( dev , info ) ; if ( ret ) printf ( "error<S2SV_blank>ret<S2SV_blank>from<S2SV_blank>lut_create_add_to_dev:<S2SV_blank>%d\\n" , ret ) ; dev -> self = m ; <S2SV_StartBug> return dev ; <S2SV_EndBug> } | <S2SV_ModStart> = m ; m -> dev = dev ; |
2,651 | CWE-000 <S2SV_StartBug> void place_layer_update_time ( place_layer * place , time_t * time ) { <S2SV_EndBug> place -> watch_str [ 0 ] = '\\0' ; struct tm * tick_time = gmtime ( time ) ; bool hour_24 = clock_is_24h_style ( ) ; uint16_t pos = 0 ; if ( place -> settings -> show_dow ) { strftime ( place -> watch_str , sizeof ( place -> watch_str ) , "%w" , tick_time ) ; pos = str_change_to_dow_abbr ( place -> watch_str ) ; hour_24 = true ; } APP_LOG ( APP_LOG_LEVEL_DEBUG , "digits<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>" , sizeof ( & place -> watch_str [ pos ] ) ) ; strftime ( & place -> watch_str [ pos ] , sizeof ( place -> watch_str ) - pos , hour_24 ? "%H:%M" : "%I:%M" , tick_time ) ; if ( ! hour_24 ) { char tmp [ 5 ] ; strftime ( & place -> watch_str [ pos ] , sizeof ( tmp ) , "%P" , tick_time ) ; strcat ( place -> watch_str , tmp ) ; } APP_LOG ( APP_LOG_LEVEL_DEBUG , "Time<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>updated<S2SV_blank>to<S2SV_blank>%s" , place -> place -> place_name , place -> watch_str ) ; layer_mark_dirty ( text_layer_get_layer ( place -> place_time_layer ) ) ; } | <S2SV_ModStart> time ) { APP_LOG ( APP_LOG_LEVEL_DEBUG , "Time<S2SV_blank>update<S2SV_blank>place" ) ; |
2,652 | CWE-000 static int process_contacts_by_ct ( struct sip_msg * msg , urecord_t * urec , unsigned int flags ) { int e , ret , cflags ; struct mid_reg_info * mri ; ucontact_info_t * ci ; ucontact_t * c ; contact_t * ct ; LM_DBG ( "processing<S2SV_blank>contacts...\\n" ) ; cflags = ( flags & REG_SAVE_MEMORY_FLAG ) ? FL_MEM : FL_NONE ; if ( ( ci = pack_ci ( msg , 0 , 0 , 0 , ul_api . nat_flag , cflags ) ) == 0 ) { LM_ERR ( "failed<S2SV_blank>to<S2SV_blank>initial<S2SV_blank>pack<S2SV_blank>contact<S2SV_blank>info\\n" ) ; return - 1 ; } for ( ct = get_first_contact ( msg ) ; ct ; ct = get_next_contact ( ct ) ) { calc_contact_expires ( msg , ct -> expires , & e , NULL ) ; if ( e == 0 ) { LM_DBG ( "FWD<S2SV_blank>1\\n" ) ; return 1 ; } ret = ul_api . get_ucontact ( urec , & ct -> uri , ci -> callid , ci -> cseq , & c ) ; if ( ret == - 1 ) { LM_ERR ( "invalid<S2SV_blank>cseq<S2SV_blank>for<S2SV_blank>aor<S2SV_blank><%.*s>\\n" , urec -> aor . len , urec -> aor . s ) ; rerrno = R_INV_CSEQ ; return - 1 ; } else if ( ret == - 2 ) { continue ; } else if ( ret == 0 ) { LM_DBG ( "found<S2SV_blank>>><S2SV_blank>%d<S2SV_blank>---<S2SV_blank>[<S2SV_blank>%ld,<S2SV_blank>%ld<S2SV_blank>]\\n" , e , c -> expires_in , c -> expires_out ) ; mri = c -> attached_data [ ucontact_data_idx ] ; if ( get_act_time ( ) - mri -> last_reg_ts >= mri -> expires_out - e ) { LM_DBG ( "FWD<S2SV_blank>2\\n" ) ; return 1 ; } else { ci = pack_ci ( msg , ct , e + get_act_time ( ) , 0 , ul_api . nat_flag , cflags ) ; if ( ! ci ) { LM_ERR ( "failed<S2SV_blank>to<S2SV_blank>pack<S2SV_blank>contact<S2SV_blank>specific<S2SV_blank>info\\n" ) ; rerrno = R_UL_UPD_C ; return - 1 ; } ci -> expires_out = c -> expires_out ; <S2SV_StartBug> if ( ul_api . update_ucontact ( urec , c , ci , 0 ) < 0 ) { <S2SV_EndBug> rerrno = R_UL_UPD_C ; LM_ERR ( "failed<S2SV_blank>to<S2SV_blank>update<S2SV_blank>contact\\n" ) ; return - 1 ; } continue ; } } return 1 ; } return 2 ; } | <S2SV_ModStart> -> expires_out ; mri -> last_cseq = ci -> cseq ; |
2,653 | CWE-000 void core_init ( struct core_config * _config ) { config = * _config ; screen_init ( ) ; plugin_init ( ) ; <S2SV_StartBug> rdram_init ( ) ; <S2SV_EndBug> rdp_init ( & config ) ; vi_init ( & config ) ; num_workers = config . num_workers ; parallel = config . parallel ; if ( config . parallel ) { parallel_init ( num_workers ) ; } <S2SV_StartBug> screenshot_index = 0 ; <S2SV_EndBug> trace_index = 0 ; } | <S2SV_ModStart> ; rdram_init ( <S2SV_ModEnd> ) ; num_workers <S2SV_ModStart> ) ; } rdp_init ( & config ) ; vi_init ( & config ) ; |
2,654 | CWE-000 static void sugov_update_shared ( struct update_util_data * hook , u64 time , unsigned int flags ) { struct sugov_cpu * sg_cpu = container_of ( hook , struct sugov_cpu , update_util ) ; struct sugov_policy * sg_policy = sg_cpu -> sg_policy ; unsigned long util , max , hs_util ; unsigned int next_f ; if ( ! sg_policy -> tunables -> pl && flags & SCHED_CPUFREQ_PL ) return ; sugov_get_util ( & util , & max , sg_cpu -> cpu ) ; flags &= ~ SCHED_CPUFREQ_RT_DL ; raw_spin_lock ( & sg_policy -> update_lock ) ; if ( sg_policy -> max != max ) { sg_policy -> max = max ; hs_util = freq_to_util ( sg_policy , sg_policy -> tunables -> hispeed_freq ) ; hs_util = mult_frac ( hs_util , TARGET_LOAD , 100 ) ; sg_policy -> hispeed_util = hs_util ; } sg_cpu -> util = util ; sg_cpu -> max = max ; sg_cpu -> flags = flags ; sugov_set_iowait_boost ( sg_cpu , time , flags ) ; sg_cpu -> last_update = time ; sugov_calc_avg_cap ( sg_policy , sg_cpu -> walt_load . ws , sg_policy -> policy -> cur ) ; trace_sugov_util_update ( sg_cpu -> cpu , sg_cpu -> util , sg_policy -> avg_cap , max , sg_cpu -> walt_load . nl , sg_cpu -> walt_load . pl , flags ) ; if ( sugov_should_update_freq ( sg_policy , time ) ) { if ( flags & SCHED_CPUFREQ_RT_DL ) next_f = sg_policy -> policy -> cpuinfo . max_freq ; else <S2SV_StartBug> next_f = sugov_next_freq_shared ( sg_cpu ) ; <S2SV_EndBug> sugov_update_commit ( sg_policy , time , next_f ) ; } raw_spin_unlock ( & sg_policy -> update_lock ) ; } | <S2SV_ModStart> sugov_next_freq_shared ( sg_cpu , time |
2,655 | CWE-000 int openTCPSock ( char * IP , unsigned short port ) { int sock_fd ; <S2SV_StartBug> struct sockaddr_in addr ; <S2SV_EndBug> initSockList ( ) ; if ( ( sock_fd = socket ( AF_INET , SOCK_STREAM , 0 ) ) == - 1 ) { printf ( "%s<S2SV_blank>:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>socket\\n" , __FUNCTION__ ) ; return - 1 ; } <S2SV_StartBug> memset ( & addr , 0x00 , sizeof ( addr ) ) ; <S2SV_EndBug> addr . sin_family = AF_INET ; addr . sin_port = htons ( port ) ; if ( inet_pton ( AF_INET , IP , & addr . sin_addr ) != 1 ) { printf ( "%s:<S2SV_blank>Failed<S2SV_blank>in<S2SV_blank>inet_pton()\\n" , __FUNCTION__ ) ; close ( sock_fd ) ; return - 1 ; } <S2SV_StartBug> if ( connect ( sock_fd , ( struct sockaddr * ) & addr , sizeof ( addr ) ) < 0 ) <S2SV_EndBug> { close ( sock_fd ) ; return - 1 ; } resizeSockList ( sock_fd ) ; sockList [ sock_fd ] . type = TCP ; <S2SV_StartBug> return sock_fd ; <S2SV_EndBug> } | <S2SV_ModStart> ; struct sockaddr_in * <S2SV_ModStart> 1 ; } addr = calloc ( sizeof ( struct sockaddr_in ) , 1 ) ; addr -> sin_family = AF_INET ; addr -> sin_port = htons ( port ) ; if ( inet_pton ( AF_INET , IP , & addr -> <S2SV_ModEnd> sin_addr ) != <S2SV_ModStart> sockaddr * ) <S2SV_ModEnd> addr , sizeof <S2SV_ModStart> , sizeof ( struct sockaddr_in <S2SV_ModEnd> ) ) < <S2SV_ModStart> = TCP ; sockList [ sock_fd ] . addr = addr ; |
2,656 | CWE-000 static void gst_entropy_event_emitter_init ( GstEntropyEventEmitter * object_handle ) { object_handle -> number_of_bins = 200 ; object_handle -> samples_per_fft = gst_fft_next_fast_length ( ( 2 * object_handle -> number_of_bins ) - 2 ) ; object_handle -> entropy_min = 10000 ; object_handle -> low_threshold = 10000 ; object_handle -> high_threshold = 10000 ; object_handle -> in_event_state = FALSE ; object_handle -> sinkpad = gst_pad_new_from_static_template ( & sink_factory , "sink" ) ; gst_pad_set_chain_function ( object_handle -> sinkpad , GST_DEBUG_FUNCPTR ( gst_entropy_event_emitter_chain ) ) ; GST_PAD_SET_PROXY_CAPS ( object_handle -> sinkpad ) ; gst_element_add_pad ( GST_ELEMENT ( object_handle ) , object_handle -> sinkpad ) ; object_handle -> srcpad = gst_pad_new_from_static_template ( & src_factory , "src" ) ; GST_PAD_SET_PROXY_CAPS ( object_handle -> srcpad ) ; gst_element_add_pad ( GST_ELEMENT ( object_handle ) , object_handle -> srcpad ) ; if ( object_handle -> fft_ctx ) gst_fft_s16_free ( object_handle -> fft_ctx ) ; <S2SV_StartBug> g_free ( object_handle -> freq_data ) ; <S2SV_EndBug> object_handle -> fft_ctx = gst_fft_s16_new ( object_handle -> samples_per_fft , FALSE ) ; object_handle -> freq_data = g_new ( GstFFTS16Complex , ( object_handle -> samples_per_fft / 2 ) + 1 ) ; } | <S2SV_ModStart> fft_ctx ) ; object_handle -> fft_ctx = gst_fft_s16_new ( object_handle -> samples_per_fft , FALSE ) ; if ( object_handle -> freq_data ) <S2SV_ModStart> object_handle -> freq_data <S2SV_ModEnd> ) ; object_handle |
2,657 | CWE-000 rc_trigger_t * rc_parse_trigger ( int * ret , void * buffer , const char * memaddr , lua_State * L , int funcs_ndx ) { rc_trigger_t dummy ; <S2SV_StartBug> rc_trigger_t * self ; <S2SV_EndBug> self = ( rc_trigger_t * ) rc_alloc ( buffer , ret , sizeof ( rc_trigger_t ) , & dummy ) ; rc_parse_trigger_internal ( self , ret , buffer , & memaddr , L , funcs_ndx ) ; return self ; } | <S2SV_ModStart> rc_trigger_t * self ; * ret = 0 |
2,658 | CWE-000 static void get_unpriv_disabled ( ) { char buf [ 2 ] ; FILE * fd ; fd = fopen ( "/proc/sys/" UNPRIV_SYSCTL , "r" ) ; <S2SV_StartBug> if ( fgets ( buf , 2 , fd ) == buf && atoi ( buf ) ) <S2SV_EndBug> unpriv_disabled = true ; fclose ( fd ) ; } | <S2SV_ModStart> ; if ( ! fd ) { perror ( "fopen<S2SV_blank>/proc/sys/" UNPRIV_SYSCTL ) ; unpriv_disabled = true ; return ; } if ( |
2,659 | CWE-000 static int xts_aesni_setkey ( struct crypto_tfm * tfm , const u8 * key , unsigned int keylen ) { struct aesni_xts_ctx * ctx = crypto_tfm_ctx ( tfm ) ; <S2SV_StartBug> u32 * flags = & tfm -> crt_flags ; <S2SV_EndBug> int err ; <S2SV_StartBug> if ( keylen % 2 ) { <S2SV_EndBug> * flags |= CRYPTO_TFM_RES_BAD_KEY_LEN ; return - EINVAL ; } err = aes_set_key_common ( tfm , ctx -> raw_crypt_ctx , key , keylen / 2 ) ; if ( err ) return err ; return aes_set_key_common ( tfm , ctx -> raw_tweak_ctx , key + keylen / 2 , keylen / 2 ) ; } | <S2SV_ModStart> tfm ) ; <S2SV_ModEnd> int err ; <S2SV_ModStart> int err ; err = xts_check_key ( tfm , key , keylen ) ; if ( err ) return err ; <S2SV_ModEnd> err = aes_set_key_common |
2,660 | CWE-000 unsigned long session_table_get_cnt ( session_table * t , bool is_rw ) { session_table_lock ( t ) ; <S2SV_StartBug> unsigned long tmp = is_rw ? t -> rw_cnt : t -> cnt ; <S2SV_EndBug> session_table_unlock ( t ) ; return tmp ; } | <S2SV_ModStart> long tmp = session_table_get_cnt_unlocked ( t , is_rw ) <S2SV_ModEnd> ; session_table_unlock ( |
2,661 | CWE-000 static void update_procedure_variables_forall ( ID ids , TYPE_DESC struct_decls , BLOCK_ENV block , <S2SV_StartBug> const ID targets , int is_final ) <S2SV_EndBug> { ID id ; ID target ; TYPE_DESC stp ; BLOCK_ENV bp ; FOREACH_ID ( id , ids ) { if ( ID_USEASSOC_INFO ( id ) && current_module_name != ID_MODULE_NAME ( id ) ) { continue ; } if ( IS_PROCEDURE_POINTER ( ID_TYPE ( id ) ) ) { if ( VAR_REF_PROC ( id ) == NULL ) continue ; <S2SV_StartBug> target = find_ident_head ( ID_SYM ( VAR_REF_PROC ( id ) ) , targets ) ; <S2SV_EndBug> update_procedure_variable ( id , target , is_final ) ; } } FOREACH_STRUCTDECLS ( stp , struct_decls ) { if ( TYPE_TAGNAME ( stp ) && ID_USEASSOC_INFO ( TYPE_TAGNAME ( stp ) ) && current_module_name != ID_MODULE_NAME ( TYPE_TAGNAME ( stp ) ) ) { continue ; } update_procedure_variables_forall ( TYPE_MEMBER_LIST ( stp ) , NULL , NULL , <S2SV_StartBug> targets , is_final ) ; <S2SV_EndBug> } FOREACH_BLOCKS ( bp , block ) { update_procedure_variables_forall ( BLOCK_LOCAL_SYMBOLS ( bp ) , BLOCK_LOCAL_STRUCT_DECLS ( bp ) , BLOCK_CHILDREN ( bp ) , <S2SV_StartBug> targets , is_final ) ; <S2SV_EndBug> } } | <S2SV_ModStart> const ID targets , int forall_target <S2SV_ModStart> ) continue ; if ( ID_IS_DECLARED ( VAR_REF_PROC ( id ) ) ) continue ; if ( forall_target ) { <S2SV_ModStart> targets ) ; } else { target = targets ; if ( ID_SYM ( target ) != ID_SYM ( VAR_REF_PROC ( id ) ) ) { continue ; } } <S2SV_ModStart> , targets , forall_target , <S2SV_ModStart> , targets , forall_target , |
2,662 | CWE-000 void * handle_client_t ( void * socket ) { while ( 1 ) { <S2SV_StartBug> char recv_buffer [ MAX_BUFFER_SIZE ] = { 0 } ; <S2SV_EndBug> int status ; int client_socket = * ( ( int * ) socket ) ; if ( ( status = recv ( client_socket , recv_buffer , sizeof recv_buffer , 0 ) ) == - 1 ) { diep ( "router<S2SV_blank>-<S2SV_blank>recv()<S2SV_blank>in<S2SV_blank>handle_request_t" ) ; } if ( status == 0 ) { pthread_exit ( NULL ) ; } <S2SV_StartBug> if ( is_not_corrupt ( recv_buffer [ CHECK_OFFSET ] ) ) <S2SV_EndBug> { route_message ( recv_buffer ) ; printf ( "Source<S2SV_blank>-<S2SV_blank>%c,<S2SV_blank>Destination<S2SV_blank>-<S2SV_blank>%c,<S2SV_blank>Message<S2SV_blank>-<S2SV_blank>%d%d\\n" , recv_buffer [ SOURCE_OFFSET ] , recv_buffer [ DEST_OFFSET ] , recv_buffer [ DATA_OFFSET ] , recv_buffer [ DATA_OFFSET + 1 ] ) ; } printf ( "Message<S2SV_blank>corrupted.\\n" ) ; } } | <S2SV_ModStart> 1 ) { unsigned <S2SV_ModStart> is_not_corrupt ( recv_buffer <S2SV_ModEnd> ) ) { |
2,663 | CWE-000 static void write_color_profile ( GString * outstr , gint indent ) { gint i ; # ifndef HAVE_LCMS g_string_append_printf ( outstr , "<!--<S2SV_blank>NOTICE:<S2SV_blank>%s<S2SV_blank>was<S2SV_blank>not<S2SV_blank>built<S2SV_blank>with<S2SV_blank>support<S2SV_blank>for<S2SV_blank>color<S2SV_blank>profiles,\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>color<S2SV_blank>profile<S2SV_blank>options<S2SV_blank>will<S2SV_blank>have<S2SV_blank>no<S2SV_blank>effect.\\n-->\\n" , GQ_APPNAME ) ; # endif WRITE_NL ( ) ; WRITE_STRING ( "<color_profiles<S2SV_blank>" ) ; WRITE_CHAR ( options -> color_profile , screen_file ) ; WRITE_BOOL ( options -> color_profile , enabled ) ; WRITE_BOOL ( options -> color_profile , use_image ) ; WRITE_INT ( options -> color_profile , input_type ) ; WRITE_BOOL ( options -> color_profile , use_x11_screen_profile ) ; <S2SV_StartBug> WRITE_STRING ( ">" ) ; <S2SV_EndBug> indent ++ ; for ( i = 0 ; i < COLOR_PROFILE_INPUTS ; i ++ ) { WRITE_NL ( ) ; WRITE_STRING ( "<profile<S2SV_blank>" ) ; write_char_option ( outstr , indent , "input_file" , options -> color_profile . input_file [ i ] ) ; write_char_option ( outstr , indent , "input_name" , options -> color_profile . input_name [ i ] ) ; WRITE_STRING ( "/>" ) ; } indent -- ; WRITE_NL ( ) ; WRITE_STRING ( "</color_profiles>" ) ; } | <S2SV_ModStart> use_x11_screen_profile ) ; WRITE_INT ( options -> color_profile , render_intent ) ; |
2,664 | CWE-000 void convert_p ( t_format * format , va_list ap , int * count ) { unsigned long long nbr ; int left_adjusted ; nbr = va_arg ( ap , unsigned long long ) ; * count += ( ft_digits ( nbr , 16 ) + 2 ) ; <S2SV_StartBug> format -> min_w -= * count ; <S2SV_EndBug> left_adjusted = ft_haschar ( format -> flag , '-' ) ; while ( ! left_adjusted && format -> min_w -- > 0 && ++ ( * count ) ) ft_putchar ( '<S2SV_blank>' ) ; ft_putstr ( "0x" ) ; ft_putnbr_base ( nbr , 16 , 0 , 0 ) ; while ( left_adjusted && format -> min_w -- > 0 && ++ ( * count ) ) ft_putchar ( '<S2SV_blank>' ) ; } | <S2SV_ModStart> -> min_w -= ( ft_digits ( nbr , 16 ) + 2 ) <S2SV_ModEnd> ; left_adjusted = |
2,665 | CWE-000 static int moveToRightmost ( BtCursor * pCur ) { Pgno pgno ; int rc = SQLITE_OK ; MemPage * pPage = 0 ; <S2SV_StartBug> assert ( cursorHoldsMutex ( pCur ) ) ; <S2SV_EndBug> assert ( pCur -> eState == CURSOR_VALID ) ; while ( ! ( pPage = pCur -> apPage [ pCur -> iPage ] ) -> leaf ) { pgno = get4byte ( & pPage -> aData [ pPage -> hdrOffset + 8 ] ) ; pCur -> aiIdx [ pCur -> iPage ] = pPage -> nCell ; rc = moveToChild ( pCur , pgno ) ; if ( rc ) return rc ; } pCur -> aiIdx [ pCur -> iPage ] = pPage -> nCell - 1 ; assert ( pCur -> info . nSize == 0 ) ; assert ( ( pCur -> curFlags & BTCF_ValidNKey ) == 0 ) ; return SQLITE_OK ; } | <S2SV_ModStart> ; assert ( cursorOwnsBtShared <S2SV_ModEnd> ( pCur ) |
2,666 | CWE-000 int mc_get_platform_info ( mlnx_platform_info_t * mlnx_platform ) { <S2SV_StartBug> strncpy ( mlnx_platform -> onl_platform_name , ONL_PLATFORM_NAME , PLATFORM_NAME_MAX_LEN ) ; <S2SV_EndBug> strncpy ( mlnx_platform -> onie_platform_name , ONIE_PLATFORM_NAME , PLATFORM_NAME_MAX_LEN ) ; mlnx_platform -> sfp_num = SFP_PORT_COUNT ; mlnx_platform -> led_num = CHASSIS_LED_COUNT ; mlnx_platform -> psu_num = CHASSIS_PSU_COUNT ; mlnx_platform -> fan_num = CHASSIS_FAN_COUNT ; mlnx_platform -> thermal_num = CHASSIS_THERMAL_COUNT ; mlnx_platform -> cpld_num = CPLD_COUNT ; mlnx_platform -> psu_fixed = true ; mlnx_platform -> fan_fixed = true ; mlnx_platform -> psu_type = PSU_TYPE_1 ; mlnx_platform -> led_type = LED_TYPE_1 ; return ONLP_STATUS_OK ; } | <S2SV_ModStart> onl_platform_name , ONL_PLATFORM_NAME <S2SV_ModEnd> , PLATFORM_NAME_MAX_LEN ) |
2,667 | CWE-000 int smithyRef ( int currentPlayer , struct gameState * state , int handPos ) { int i ; for ( i = 0 ; i < 3 ; i ++ ) { drawCard ( currentPlayer , state ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } discardCard ( handPos , currentPlayer , state , 0 ) ; |
2,668 | CWE-000 static buffer_t FUZ_createDictionary ( const void * src , size_t srcSize , size_t blockSize , size_t requestedDictSize ) { <S2SV_StartBug> buffer_t dict = { NULL , 0 , 0 } ; <S2SV_EndBug> size_t const nbBlocks = ( srcSize + ( blockSize - 1 ) ) / blockSize ; size_t * const blockSizes = ( size_t * ) malloc ( nbBlocks * sizeof ( size_t ) ) ; <S2SV_StartBug> if ( ! blockSizes ) return dict ; <S2SV_EndBug> dict . start = malloc ( requestedDictSize ) ; <S2SV_StartBug> if ( ! dict . start ) { free ( blockSizes ) ; return dict ; } <S2SV_EndBug> { size_t nb ; for ( nb = 0 ; nb < nbBlocks - 1 ; nb ++ ) blockSizes [ nb ] = blockSize ; blockSizes [ nbBlocks - 1 ] = srcSize - ( blockSize * ( nbBlocks - 1 ) ) ; } { size_t const dictSize = ZDICT_trainFromBuffer ( dict . start , requestedDictSize , src , blockSizes , ( unsigned ) nbBlocks ) ; free ( blockSizes ) ; <S2SV_StartBug> if ( ZDICT_isError ( dictSize ) ) { free ( dict . start ) ; return g_nullBuffer ; } <S2SV_EndBug> dict . size = requestedDictSize ; dict . filled = dictSize ; return dict ; } } | <S2SV_ModStart> buffer_t dict = kBuffNull <S2SV_ModEnd> ; size_t const <S2SV_ModStart> blockSizes ) return kBuffNull <S2SV_ModEnd> ; dict . <S2SV_ModStart> ) ; return kBuffNull <S2SV_ModEnd> ; } { <S2SV_ModStart> ) ) { FUZ_freeDictionary ( dict ) ; return kBuffNull <S2SV_ModEnd> ; } dict |
2,669 | CWE-000 LIBXSMM_INTERNAL_API_DEFINITION void libxsmm_sparse_csc_reader ( libxsmm_generated_code * io_generated_code , const char * i_csc_file_in , unsigned int * * o_row_idx , unsigned int * * o_column_idx , double * * o_values , unsigned int * o_row_count , unsigned int * o_column_count , unsigned int * o_element_count ) { FILE * l_csc_file_handle ; const unsigned int l_line_length = 512 ; char l_line [ 512 + 1 ] ; unsigned int l_header_read = 0 ; unsigned int * l_column_idx_id = NULL ; unsigned int l_i = 0 ; l_csc_file_handle = fopen ( i_csc_file_in , "r" ) ; if ( l_csc_file_handle == NULL ) { libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_INPUT ) ; return ; } while ( fgets ( l_line , l_line_length , l_csc_file_handle ) != NULL ) { if ( strlen ( l_line ) == l_line_length ) { libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_READ_LEN ) ; return ; } if ( l_line [ 0 ] == '%' ) { continue ; } else { if ( l_header_read == 0 ) { if ( sscanf ( l_line , "%u<S2SV_blank>%u<S2SV_blank>%u" , o_row_count , o_column_count , o_element_count ) == 3 ) { * o_row_idx = ( unsigned int * ) malloc ( sizeof ( unsigned int ) * ( * o_element_count ) ) ; * o_column_idx = ( unsigned int * ) malloc ( sizeof ( unsigned int ) * ( * o_column_count + 1 ) ) ; * o_values = ( double * ) malloc ( sizeof ( double ) * ( * o_element_count ) ) ; l_column_idx_id = ( unsigned int * ) malloc ( sizeof ( unsigned int ) * ( * o_column_count ) ) ; if ( ( * o_row_idx == NULL ) || ( * o_column_idx == NULL ) || ( * o_values == NULL ) || ( l_column_idx_id == NULL ) ) { <S2SV_StartBug> libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_ALLOC_DATA ) ; <S2SV_EndBug> return ; } memset ( * o_row_idx , 0 , sizeof ( unsigned int ) * ( * o_element_count ) ) ; memset ( * o_column_idx , 0 , sizeof ( unsigned int ) * ( * o_column_count + 1 ) ) ; memset ( * o_values , 0 , sizeof ( double ) * ( * o_element_count ) ) ; memset ( l_column_idx_id , 0 , sizeof ( unsigned int ) * ( * o_column_count ) ) ; for ( l_i = 0 ; l_i < ( * o_column_count + 1 ) ; l_i ++ ) ( * o_column_idx ) [ l_i ] = ( * o_element_count ) ; ( * o_column_idx ) [ 0 ] = 0 ; l_i = 0 ; l_header_read = 1 ; } else { libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_READ_DESC ) ; return ; } } else { unsigned int l_row = 0 , l_column = 0 ; double l_value = 0 ; if ( sscanf ( l_line , "%u<S2SV_blank>%u<S2SV_blank>%lf" , & l_row , & l_column , & l_value ) != 3 ) { libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_READ_ELEMS ) ; return ; } l_row -- ; l_column -- ; ( * o_row_idx ) [ l_i ] = l_row ; ( * o_values ) [ l_i ] = l_value ; l_i ++ ; l_column_idx_id [ l_column ] = 1 ; ( * o_column_idx ) [ l_column + 1 ] = l_i ; } } } fclose ( l_csc_file_handle ) ; if ( l_i != ( * o_element_count ) ) { <S2SV_StartBug> libxsmm_handle_error ( io_generated_code , LIBXSMM_ERR_CSC_LEN ) ; <S2SV_EndBug> return ; } <S2SV_StartBug> assert ( NULL != l_column_idx_id ) ; <S2SV_EndBug> for ( l_i = 0 ; l_i < ( * o_column_count ) ; l_i ++ ) { if ( l_column_idx_id [ l_i ] == 0 ) { ( * o_column_idx ) [ l_i + 1 ] = ( * o_column_idx ) [ l_i ] ; } } <S2SV_StartBug> if ( l_column_idx_id != NULL ) { <S2SV_EndBug> free ( l_column_idx_id ) ; } } | <S2SV_ModStart> ) ) { free ( * o_row_idx ) ; free ( * o_column_idx ) ; free ( * o_values ) ; free ( l_column_idx_id ) ; <S2SV_ModStart> ) ) { free ( * o_row_idx ) ; free ( * o_column_idx ) ; free ( * o_values ) ; free ( l_column_idx_id ) ; <S2SV_ModStart> return ; } if ( l_column_idx_id != NULL ) { <S2SV_ModEnd> for ( l_i <S2SV_ModStart> ; } } <S2SV_ModEnd> free ( l_column_idx_id |
2,670 | CWE-000 <S2SV_StartBug> int parse_directional ( const char * directional_string , <S2SV_EndBug> struct mako_directional * out ) { int error = 0 ; char * components = strdup ( directional_string ) ; int32_t values [ ] = { 0 , 0 , 0 , 0 } ; size_t count ; char * saveptr = NULL ; char * token = strtok_r ( components , "," , & saveptr ) ; for ( count = 0 ; count < 4 ; count ++ ) { if ( token == NULL ) { break ; } errno = 0 ; char * endptr = NULL ; int32_t number = strtol ( token , & endptr , 10 ) ; if ( errno || endptr == token ) { error = - 1 ; break ; } values [ count ] = number ; token = strtok_r ( NULL , "," , & saveptr ) ; } if ( error == 0 ) { switch ( count ) { case 1 : out -> top = out -> right = out -> bottom = out -> left = values [ 0 ] ; break ; case 2 : out -> top = out -> bottom = values [ 0 ] ; out -> right = out -> left = values [ 1 ] ; break ; case 3 : out -> top = values [ 0 ] ; out -> right = out -> left = values [ 1 ] ; out -> bottom = values [ 2 ] ; break ; case 4 : out -> top = values [ 0 ] ; out -> right = values [ 1 ] ; out -> bottom = values [ 2 ] ; out -> left = values [ 3 ] ; break ; } } free ( components ) ; return error ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
2,671 | CWE-000 <S2SV_StartBug> static struct sw_flow_actions * nla_alloc_flow_actions ( int size , bool log ) <S2SV_EndBug> { struct sw_flow_actions * sfa ; <S2SV_StartBug> if ( size > MAX_ACTIONS_BUFSIZE ) { <S2SV_EndBug> OVS_NLERR ( log , "Flow<S2SV_blank>action<S2SV_blank>size<S2SV_blank>%u<S2SV_blank>bytes<S2SV_blank>exceeds<S2SV_blank>max" , size ) ; return ERR_PTR ( - EINVAL ) ; } sfa = kmalloc ( sizeof ( * sfa ) + size , GFP_KERNEL ) ; if ( ! sfa ) return ERR_PTR ( - ENOMEM ) ; sfa -> actions_len = 0 ; return sfa ; } | <S2SV_ModStart> ( int size <S2SV_ModEnd> ) { struct <S2SV_ModStart> * sfa ; WARN_ON_ONCE <S2SV_ModEnd> ( size > <S2SV_ModStart> > MAX_ACTIONS_BUFSIZE ) ; <S2SV_ModEnd> sfa = kmalloc |
2,672 | CWE-000 channel_op_res_t channel_get_file ( void * data ) { assert ( data != NULL ) ; assert ( channel_curl . handle != NULL ) ; channel_op_res_t result = CHANNEL_OK ; channel_data_t * channel_data = ( channel_data_t * ) data ; # ifdef CONFIG_SURICATTA_SSL memset ( channel_data -> sha1hash , 0x0 , SHA_DIGEST_LENGTH * 2 + 1 ) ; if ( SHA1_Init ( & checksum_ctx ) != 1 ) { result = CHANNEL_EINIT ; ERROR ( "Cannot<S2SV_blank>initialize<S2SV_blank>sha1<S2SV_blank>checksum<S2SV_blank>context.\\n" ) ; goto cleanup ; } # endif if ( channel_data -> debug ) { curl_easy_setopt ( channel_curl . handle , CURLOPT_VERBOSE , 1L ) ; } if ( ( ( channel_curl . header = curl_slist_append ( channel_curl . header , "Content-Type:<S2SV_blank>application/octet-stream" ) ) == NULL ) || ( ( channel_curl . header = curl_slist_append ( channel_curl . header , "Accept:<S2SV_blank>application/octet-stream" ) ) == NULL ) ) { result = CHANNEL_EINIT ; ERROR ( "Set<S2SV_blank>channel<S2SV_blank>header<S2SV_blank>failed.\\n" ) ; goto cleanup_header ; } if ( ( result = channel_set_options ( channel_data , CHANNEL_GET ) ) != CHANNEL_OK ) { ERROR ( "Set<S2SV_blank>channel<S2SV_blank>option<S2SV_blank>failed.\\n" ) ; goto cleanup_header ; } int file_handle = 0 ; for ( int retries = 3 ; retries >= 0 ; retries -- ) { if ( ( file_handle = ipc_inst_start ( ) ) > 0 ) { break ; } sleep ( 1 ) ; } if ( file_handle < 0 ) { ERROR ( "Cannot<S2SV_blank>open<S2SV_blank>SWUpdate<S2SV_blank>IPC<S2SV_blank>stream:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; result = CHANNEL_EIO ; goto cleanup_header ; } result_channel_callback_write_file = CHANNEL_OK ; if ( ( curl_easy_setopt ( channel_curl . handle , CURLOPT_WRITEFUNCTION , channel_callback_write_file ) != CURLE_OK ) || ( curl_easy_setopt ( channel_curl . handle , CURLOPT_WRITEDATA , & file_handle ) != CURLE_OK ) ) { ERROR ( "Cannot<S2SV_blank>setup<S2SV_blank>file<S2SV_blank>writer<S2SV_blank>callback<S2SV_blank>function.\\n" ) ; result = CHANNEL_EINIT ; goto cleanup_file ; } unsigned long long int total_bytes_downloaded = 0 ; unsigned char try_count = 0 ; CURLcode curlrc = CURLE_OK ; do { if ( try_count > 0 ) { if ( channel_data -> retries == 0 ) { ERROR ( "Channel<S2SV_blank>get<S2SV_blank>operation<S2SV_blank>failed<S2SV_blank>(%d):<S2SV_blank>\'%s\'\\n" , curlrc , curl_easy_strerror ( curlrc ) ) ; result = channel_map_curl_error ( curlrc ) ; goto cleanup_file ; } if ( try_count > channel_data -> retries ) { ERROR ( "Channel<S2SV_blank>get<S2SV_blank>operation<S2SV_blank>aborted<S2SV_blank>because<S2SV_blank>" "of<S2SV_blank>too<S2SV_blank>many<S2SV_blank>failed<S2SV_blank>download<S2SV_blank>attempts<S2SV_blank>" "(%d).\\n" , channel_data -> retries ) ; result = CHANNEL_ELOOP ; goto cleanup_file ; } DEBUG ( "Channel<S2SV_blank>connection<S2SV_blank>interrupted,<S2SV_blank>trying<S2SV_blank>resume<S2SV_blank>" "after<S2SV_blank>%llu<S2SV_blank>bytes." , total_bytes_downloaded ) ; if ( curl_easy_setopt ( channel_curl . handle , CURLOPT_RESUME_FROM_LARGE , total_bytes_downloaded ) != CURLE_OK ) { ERROR ( "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>Channel<S2SV_blank>resume<S2SV_blank>seek<S2SV_blank>(%d):<S2SV_blank>" "\'%s\'\\n" , curlrc , curl_easy_strerror ( curlrc ) ) ; result = channel_map_curl_error ( curlrc ) ; goto cleanup_file ; } TRACE ( "Channel<S2SV_blank>sleeps<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>now." , channel_data -> retry_sleep ) ; if ( sleep ( channel_data -> retry_sleep ) > 0 ) { TRACE ( "Channel\'s<S2SV_blank>sleep<S2SV_blank>got<S2SV_blank>interrupted,<S2SV_blank>" "retrying<S2SV_blank>nonetheless<S2SV_blank>now." ) ; } TRACE ( "Channel<S2SV_blank>awakened<S2SV_blank>from<S2SV_blank>sleep." ) ; } curlrc = curl_easy_perform ( channel_curl . handle ) ; result = channel_map_curl_error ( curlrc ) ; if ( ( result != CHANNEL_OK ) && ( result != CHANNEL_EAGAIN ) ) { ERROR ( "Channel<S2SV_blank>operation<S2SV_blank>returned<S2SV_blank>error<S2SV_blank>(%d):<S2SV_blank>\'%s\'\\n" , curlrc , curl_easy_strerror ( curlrc ) ) ; goto cleanup_file ; } double bytes_downloaded ; CURLcode resdlprogress = curl_easy_getinfo ( channel_curl . handle , CURLINFO_SIZE_DOWNLOAD , & bytes_downloaded ) ; if ( resdlprogress != CURLE_OK ) { ERROR ( "Channel<S2SV_blank>does<S2SV_blank>not<S2SV_blank>report<S2SV_blank>bytes<S2SV_blank>downloaded<S2SV_blank>(%d):<S2SV_blank>" "\'%s\'\\n" , resdlprogress , curl_easy_strerror ( resdlprogress ) ) ; result = channel_map_curl_error ( resdlprogress ) ; goto cleanup_file ; } total_bytes_downloaded += bytes_downloaded ; } while ( ++ try_count && ( result != CHANNEL_OK ) ) ; channel_log_effective_url ( ) ; DEBUG ( "Channel<S2SV_blank>downloaded<S2SV_blank>%llu<S2SV_blank>bytes<S2SV_blank>~<S2SV_blank>%llu<S2SV_blank>MiB.\\n" , total_bytes_downloaded , total_bytes_downloaded / 1024 / 1024 ) ; long http_response_code ; if ( ( result = channel_map_http_code ( <S2SV_StartBug> channel_curl . proxy == NULL ? false : true , <S2SV_EndBug> & http_response_code ) ) != CHANNEL_OK ) { ERROR ( "Channel<S2SV_blank>operation<S2SV_blank>returned<S2SV_blank>HTTP<S2SV_blank>error<S2SV_blank>code<S2SV_blank>%ld.\\n" , http_response_code ) ; goto cleanup_file ; } TRACE ( "Channel<S2SV_blank>operation<S2SV_blank>returned<S2SV_blank>HTTP<S2SV_blank>status<S2SV_blank>code<S2SV_blank>%ld.\\n" , http_response_code ) ; if ( result_channel_callback_write_file != CHANNEL_OK ) { result = CHANNEL_EIO ; goto cleanup_file ; } # ifdef CONFIG_SURICATTA_SSL unsigned char sha1hash [ SHA_DIGEST_LENGTH ] ; if ( SHA1_Final ( sha1hash , & checksum_ctx ) != 1 ) { ERROR ( "Cannot<S2SV_blank>compute<S2SV_blank>checksum.\\n" ) ; goto cleanup_file ; } char sha1hexchar [ 3 ] ; for ( int i = 0 ; i < SHA_DIGEST_LENGTH ; i ++ ) { sprintf ( sha1hexchar , "%02x" , sha1hash [ i ] ) ; strcat ( channel_data -> sha1hash , sha1hexchar ) ; } # endif cleanup_file : if ( close ( file_handle ) != 0 ) { ERROR ( "Channel<S2SV_blank>error<S2SV_blank>while<S2SV_blank>closing<S2SV_blank>SWUpdate<S2SV_blank>IPC<S2SV_blank>stream:<S2SV_blank>\'%s\'\\n" , strerror ( errno ) ) ; } cleanup_header : curl_easy_reset ( channel_curl . handle ) ; curl_slist_free_all ( channel_curl . header ) ; channel_curl . header = NULL ; # ifdef CONFIG_SURICATTA_SSL cleanup : # endif return result ; } | <S2SV_ModStart> = channel_map_http_code ( <S2SV_ModEnd> & http_response_code ) |
2,673 | CWE-000 uint8_t MCP23017_GetIODIR ( uint8_t * iodir , uint8_t port ) { <S2SV_StartBug> return value_read ( Bank_Addr [ IODIRA_B0 + ( port != 0 ) ] [ ( Bank != 0 ) ] , iodir ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return mcp23017_value_read <S2SV_ModEnd> ( Bank_Addr [ |
2,674 | CWE-000 int PrepRadialBasisMBPT ( int nk , int * nkm , int n , int * ng , int * * bas ) { int nb , k , j , k2 , i , m , ka ; ORBITAL * orb ; nb = 2 * nk * n ; * bas = malloc ( sizeof ( int ) * nb ) ; m = 0 ; for ( k = 0 ; k < nk ; k ++ ) { k2 = 2 * k ; for ( j = k2 - 1 ; j <= k2 + 1 ; j += 2 ) { if ( j < 0 ) continue ; ka = GetKappaFromJL ( j , k2 ) ; for ( i = 0 ; i < n ; i ++ ) { if ( ng [ i ] <= k ) continue ; if ( nkm && nkm [ k ] > 0 ) { if ( ng [ i ] > nkm [ k ] ) continue ; } <S2SV_StartBug> if ( mbpt_maxn > 0 && ng [ i ] > mbpt_maxn ) continue ; <S2SV_EndBug> int ix = OrbitalExistsNoLock ( ng [ i ] , ka , 0 ) ; if ( ix < 0 ) { orb = GetNewOrbitalNoLock ( ng [ i ] , ka , 0 ) ; ix = orb -> idx ; } ( * bas ) [ m ] = ix ; m ++ ; } } } nb = m ; * bas = realloc ( * bas , sizeof ( int ) * nb ) ; return nb ; } | <S2SV_ModStart> } if ( mbpt_maxm > 0 && |
2,675 | CWE-000 PyMODINIT_FUNC initGPIO ( void ) # endif { int i ; PyObject * module = NULL ; # if PY_MAJOR_VERSION > 2 if ( ( module = PyModule_Create ( & asuspigpiomodule ) ) == NULL ) return NULL ; # else if ( ( module = Py_InitModule3 ( "ASUS.GPIO" , asuspi_gpio_methods , moduledocstring ) ) == NULL ) return ; # endif define_constants ( module ) ; for ( i = 0 ; i < 200 ; i ++ ) gpio_direction [ i ] = - 1 ; if ( get_asuspi_info ( & asuspiinfo ) ) { PyErr_SetString ( PyExc_RuntimeError , "This<S2SV_blank>module<S2SV_blank>can<S2SV_blank>only<S2SV_blank>be<S2SV_blank>run<S2SV_blank>on<S2SV_blank>a<S2SV_blank>ASUS<S2SV_blank>Pi!" ) ; setup_error = 1 ; # if PY_MAJOR_VERSION > 2 return NULL ; # else return ; # endif } board_info = Py_BuildValue ( "{sissssssssss}" , "P1_REVISION" , asuspiinfo . p1_revision , "REVISION" , & asuspiinfo . revision , "TYPE" , asuspiinfo . type , "MANUFACTURER" , asuspiinfo . manufacturer , "PROCESSOR" , asuspiinfo . processor , "RAM" , asuspiinfo . ram ) ; PyModule_AddObject ( module , "ASUSPI_INFO" , board_info ) ; pin_to_gpio = & pin_to_gpio_rev ; <S2SV_StartBug> asuspi_revision = Py_BuildValue ( "i" , asuspiinfo . revision ) ; <S2SV_EndBug> PyModule_AddObject ( module , "ASUSPI_REVISION" , asuspi_revision ) ; if ( PWM_init_PWMType ( ) == NULL ) # if PY_MAJOR_VERSION > 2 return NULL ; # else return ; # endif Py_INCREF ( & PWMType ) ; PyModule_AddObject ( module , "PWM" , ( PyObject * ) & PWMType ) ; if ( ! PyEval_ThreadsInitialized ( ) ) PyEval_InitThreads ( ) ; if ( Py_AtExit ( cleanup ) != 0 ) { printf ( "exit<S2SV_blank>1\\n" ) ; setup_error = 1 ; cleanup ( ) ; # if PY_MAJOR_VERSION > 2 return NULL ; # else return ; # endif } if ( Py_AtExit ( event_cleanup_all ) != 0 ) { printf ( "exit<S2SV_blank>2\\n" ) ; setup_error = 1 ; cleanup ( ) ; # if PY_MAJOR_VERSION > 2 return NULL ; # else return ; # endif } # if PY_MAJOR_VERSION > 2 return module ; # else return ; # endif } | <S2SV_ModStart> , asuspiinfo . p1_revision <S2SV_ModEnd> ) ; PyModule_AddObject |
2,676 | CWE-000 int push ( stack * s , int val ) { if ( ! s ) return NULLSTACK ; if ( s -> top == MAX_SIZE ) return MAXREACHED ; s -> top ++ ; <S2SV_StartBug> ( ( int * ) s -> area ) [ s -> top ] = val ; <S2SV_EndBug> return SUCCESS ; } | <S2SV_ModStart> top ++ ; <S2SV_ModEnd> s -> area <S2SV_ModStart> s -> area <S2SV_ModEnd> [ s -> |
2,677 | CWE-000 int main ( void ) { const struct CMUnitTest tests [ ] = { cmocka_unit_test ( test_getParodusConfig ) , cmocka_unit_test ( test_setParodusConfig ) , cmocka_unit_test ( test_loadParodusCfg ) , cmocka_unit_test ( test_loadParodusCfgNull ) , cmocka_unit_test ( err_loadParodusCfg ) , cmocka_unit_test ( test_parse_num_arg ) , cmocka_unit_test ( test_parse_mac_address ) , cmocka_unit_test ( test_get_algo_mask ) , cmocka_unit_test ( test_server_is_http ) , cmocka_unit_test ( test_parse_webpa_url ) , cmocka_unit_test ( test_parseCommandLine ) , cmocka_unit_test ( test_parseCommandLineNull ) , cmocka_unit_test ( err_parseCommandLine ) , <S2SV_StartBug> cmocka_unit_test ( test_parodusGitVersion ) , <S2SV_EndBug> cmocka_unit_test ( test_setDefaultValuesToCfg ) , cmocka_unit_test ( err_setDefaultValuesToCfg ) , } ; return cmocka_run_group_tests ( tests , NULL , NULL ) ; } | <S2SV_ModStart> , cmocka_unit_test ( <S2SV_ModEnd> test_setDefaultValuesToCfg ) , |
2,678 | CWE-000 Time Time_duration_rollover ( Time now , Time since ) { Time duration ; if ( now . ms < since . ms ) { duration . ms = now . ms + ( 0xFFFFFFFF - since . ms ) ; } else { duration . ms = now . ms - since . ms ; } duration . ticks = now . ticks + ( Time_maxTicks - since . ticks ) ; <S2SV_StartBug> return duration ; <S2SV_EndBug> } | <S2SV_ModStart> ticks ) ; if ( duration . ticks >= Time_maxTicks ) { duration . ms ++ ; duration . ticks -= Time_maxTicks ; } |
2,679 | CWE-000 static void analogix_dp_psr_work ( struct work_struct * work ) { struct rockchip_dp_device * dp = container_of ( work , typeof ( * dp ) , psr_work ) ; <S2SV_StartBug> int ret ; <S2SV_EndBug> unsigned long flags ; ret = rockchip_drm_wait_vact_end ( dp -> encoder . crtc , PSR_WAIT_LINE_FLAG_TIMEOUT_MS ) ; if ( ret ) { dev_err ( dp -> dev , "line<S2SV_blank>flag<S2SV_blank>interrupt<S2SV_blank>did<S2SV_blank>not<S2SV_blank>arrive\\n" ) ; return ; } <S2SV_StartBug> spin_lock_irqsave ( & dp -> psr_lock , flags ) ; <S2SV_EndBug> if ( dp -> psr_state == EDP_VSC_PSR_STATE_ACTIVE ) analogix_dp_enable_psr ( dp -> dev ) ; else analogix_dp_disable_psr ( dp -> dev ) ; <S2SV_StartBug> spin_unlock_irqrestore ( & dp -> psr_lock , flags ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; int ret <S2SV_ModEnd> ; ret = <S2SV_ModStart> return ; } mutex_lock <S2SV_ModEnd> ( & dp <S2SV_ModStart> dp -> psr_lock <S2SV_ModEnd> ) ; if <S2SV_ModStart> dev ) ; mutex_unlock <S2SV_ModEnd> ( & dp <S2SV_ModStart> dp -> psr_lock <S2SV_ModEnd> ) ; } |
2,680 | CWE-000 static int check_devdesc ( struct devdesc * currdev ) { static const char * paths [ ] = { "/boot/loader.conf" , "/boot/kernel" , NULL } ; struct stat sb ; int i , err ; for ( i = 0 ; paths [ i ] != NULL ; i ++ ) { <S2SV_StartBug> if ( ( err = stat ( paths [ i ] , & sb ) ) != ENOENT ) <S2SV_EndBug> return ( err ) ; } <S2SV_StartBug> return ( ENOENT ) ; <S2SV_EndBug> } | <S2SV_ModStart> ++ ) { <S2SV_ModEnd> err = stat <S2SV_ModStart> & sb ) ; if ( errno <S2SV_ModEnd> != ENOENT ) <S2SV_ModStart> != ENOENT ) { <S2SV_ModStart> ) ; } } return ( err <S2SV_ModEnd> ) ; } |
2,681 | CWE-000 static struct netmdev_driver_ops * netmdev_get_driver_ops ( struct device_driver * driver ) { int i ; <S2SV_StartBug> printk ( KERN_INFO "netmdev_get_driver_ops(%p)\\n" , driver ) ; <S2SV_EndBug> for ( i = 0 ; i < netmdev_known_drivers_count ; i ++ ) { <S2SV_StartBug> if ( netmdev_known_drivers [ i ] . driver == driver ) { <S2SV_EndBug> printk ( KERN_INFO "found<S2SV_blank>driver(%p,<S2SV_blank>%p)\\n" , driver , netmdev_known_drivers [ i ] . driver ) ; return netmdev_known_drivers [ i ] . drv_ops ; <S2SV_StartBug> } <S2SV_EndBug> } printk ( KERN_ERR "netmdev_get_driver_ops<S2SV_blank>could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>driver\\n" ) ; return NULL ; } | <S2SV_ModStart> int i ; <S2SV_ModEnd> for ( i <S2SV_ModStart> == driver ) <S2SV_ModEnd> return netmdev_known_drivers [ <S2SV_ModStart> . drv_ops ; <S2SV_ModEnd> } printk ( |
2,682 | CWE-000 <S2SV_StartBug> static void set_changed_fdevents_locked ( struct fdevents_worker_info * worker_info ) <S2SV_EndBug> { <S2SV_StartBug> worker_info -> changed = 1 ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> set_changed_fdevents_locked ( struct <S2SV_ModStart> worker_info ) { int wake ; if ( ! has_changed_fdevents_locked ( worker_info ) ) wake = 1 ; else wake = 0 ; <S2SV_ModStart> = 1 ; if ( wake ) { if ( wake_fdevents_worker_locked ( worker_info ) != 0 ) return - 1 ; } return 0 ; |
2,683 | CWE-000 BOOL HandleEvents ( struct LayoutData * ld , struct AslReqInfo * reqinfo , struct AslBase_intern * AslBase ) { <S2SV_StartBug> struct IntReq * intreq = ld -> ld_IntReq ; <S2SV_EndBug> APTR req = ld -> ld_Req ; struct IntuiMessage * imsg ; struct MsgPort * port ; BOOL success = TRUE ; BOOL terminated = FALSE ; EnterFunc ( bug ( "HandleEvents(ld=%p,<S2SV_blank>reqinfo=%p)\\n" , ld , reqinfo ) ) ; port = ld -> ld_Window -> UserPort ; if ( ! port ) port = ld -> ld_Window -> WindowPort ; while ( ! terminated ) { if ( ld -> ld_AppMsgPort ) Wait ( ( 1L << port -> mp_SigBit ) | ( 1L << ld -> ld_AppMsgPort -> mp_SigBit ) ) ; else Wait ( ( 1L << port -> mp_SigBit ) ) ; while ( ( imsg = ( struct IntuiMessage * ) GetMsg ( port ) ) ) { if ( ( imsg -> IDCMPWindow == ld -> ld_Window ) || ( imsg -> IDCMPWindow == ld -> ld_Window2 ) ) { switch ( imsg -> Class ) { case IDCMP_MOUSEMOVE : break ; case IDCMP_NEWSIZE : ld -> ld_Command = LDCMD_LAYOUT ; CallHookPkt ( & ( reqinfo -> GadgetryHook ) , ld , ASLB ( AslBase ) ) ; break ; case IDCMP_REFRESHWINDOW : BeginRefresh ( imsg -> IDCMPWindow ) ; EndRefresh ( imsg -> IDCMPWindow , TRUE ) ; break ; default : ld -> ld_Command = LDCMD_HANDLEEVENTS ; ld -> ld_Event = imsg ; success = CallHookPkt ( & ( reqinfo -> GadgetryHook ) , ld , ASLB ( AslBase ) ) ; if ( success == LDRET_FINISHED ) { success = TRUE ; terminated = TRUE ; } if ( ! success ) { success = FALSE ; terminated = TRUE ; } break ; } } else if ( intreq -> ir_IntuiMsgFunc ) { # ifdef __MORPHOS__ REG_A4 = ( ULONG ) intreq -> ir_BasePtr ; REG_A0 = ( ULONG ) intreq -> ir_IntuiMsgFunc ; REG_A2 = ( ULONG ) req ; REG_A1 = ( ULONG ) imsg ; ( * MyEmulHandle -> EmulCallDirect68k ) ( intreq -> ir_IntuiMsgFunc -> h_Entry ) ; # else CallHookPkt ( intreq -> ir_IntuiMsgFunc , req , imsg ) ; # endif } <S2SV_StartBug> ReplyMsg ( ( struct Message * ) imsg ) ; <S2SV_EndBug> } while ( ( ld -> ld_AppMsgPort ) && ( ld -> ld_AppMsg = ( struct AppMessage * ) GetMsg ( ld -> ld_AppMsgPort ) ) ) { ld -> ld_Command = LDCMD_HANDLEAPPWINDOW ; success = CallHookPkt ( & ( reqinfo -> GadgetryHook ) , ld , ASLB ( AslBase ) ) ; ReplyMsg ( ( struct Message * ) ld -> ld_AppMsg ) ; RefreshGadgets ( ( ( struct Gadget * ) ( ( struct FRUserData * ) ld -> ld_UserData ) -> Listview ) , ld -> ld_Window , ( struct Requester * ) ld -> ld_Req ) ; ActivateWindow ( ld -> ld_Window ) ; if ( ld -> ld_ForeignerFiles ) { FRDropFromDifferentDrawersRequester ( ld , AslBase ) ; MyFreeVecPooled ( ld -> ld_ForeignerFiles , AslBase ) ; ld -> ld_ForeignerFiles = NULL ; } if ( success == LDRET_FINISHED ) { success = TRUE ; terminated = TRUE ; } if ( ! success ) { success = FALSE ; terminated = TRUE ; } } } ReturnBool ( "HandleEvents" , success ) ; } | <S2SV_ModStart> * intreq = ld -> ld_IntReq ; struct IntFileReq * ifreq = ( struct IntFileReq * ) <S2SV_ModStart> # endif } else if ( ( intreq -> ir_ReqType == ASL_FileRequest ) && ifreq -> ifr_HookFunc && ( ifreq -> ifr_Flags1 & FRF_INTUIFUNC ) ) { ifreq -> ifr_HookFunc ( FRF_INTUIFUNC , imsg , req ) ; } |
2,684 | CWE-000 int main ( ) { sqrl_init ( ) ; char txtBuffer [ 1024 ] = { 0 } ; Sqrl_Client_Callbacks cbs ; memset ( & cbs , 0 , sizeof ( Sqrl_Client_Callbacks ) ) ; cbs . onAuthenticationRequired = onAuthenticationRequired ; cbs . onProgress = onProgress ; cbs . onTransactionComplete = onTransactionComplete ; cbs . onSaveSuggested = onSaveSuggested ; sqrl_client_set_callbacks ( & cbs ) ; if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_LOAD , NULL , "file://test1.sqrl" , 17 ) ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>Load<S2SV_blank>Identity!\\n" ) ; exit ( 1 ) ; } sqrl_user_unique_id ( t1_user , txtBuffer ) ; PC ( "USER" , txtBuffer ) ; if ( 0 != strcmp ( txtBuffer , t1_uid ) ) { PC ( "EXPCTD" , t1_uid ) ; exit ( 1 ) ; } password = gen_password ; rescueCode = gen_rescue_code ; if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_GENERATE , NULL , NULL , 0 ) ) { PC ( "FAIL" , "Generate<S2SV_blank>Identity" ) ; exit ( 1 ) ; } else { PC ( "PASS" , "Generate<S2SV_blank>Identity" ) ; } if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_LOAD , NULL , gen_data , strlen ( gen_data ) ) ) { PC ( "FAIL" , "Load<S2SV_blank>Generated<S2SV_blank>Identity" ) ; exit ( 1 ) ; } if ( 0 != strcmp ( gen_uid , load_uid ) ) { PC ( "FAIL" , "gen_uid<S2SV_blank>==<S2SV_blank>load_uid" ) ; exit ( 1 ) ; } PC ( "PASS" , "Reload<S2SV_blank>Generated<S2SV_blank>Identity" ) ; free ( gen_data ) ; gen_data = NULL ; if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_CHANGE_PASSWORD , load_user , NULL , 0 ) ) { PC ( "FAIL" , "Change<S2SV_blank>Password" ) ; } if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_export_user ( load_user , NULL , SQRL_EXPORT_ALL , SQRL_ENCODING_BASE64 ) ) { PC ( "FAIL" , "Save<S2SV_blank>Changed<S2SV_blank>Identity" ) ; } load_user = sqrl_user_release ( load_user ) ; password = new_password ; if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_LOAD , NULL , gen_data , strlen ( gen_data ) ) ) { PC ( "FAIL" , "Load<S2SV_blank>Changed<S2SV_blank>Identity" ) ; exit ( 1 ) ; } PC ( "PASS" , "Change<S2SV_blank>Password" ) ; password = gen_password ; if ( SQRL_TRANSACTION_STATUS_SUCCESS != sqrl_client_begin_transaction ( SQRL_TRANSACTION_IDENTITY_RESCUE , load_user , NULL , 0 ) ) { PC ( "FAIL" , "Rescue<S2SV_blank>Identity" ) ; exit ( 1 ) ; } PC ( "PASS" , "Rescue<S2SV_blank>Identity" ) ; gen_user = sqrl_user_release ( gen_user ) ; t1_user = sqrl_user_release ( t1_user ) ; <S2SV_StartBug> load_user = sqrl_user_release ( load_user ) ; <S2SV_EndBug> PC ( "ALL" , "PASS" ) ; <S2SV_StartBug> return sqrl_stop ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> t1_user ) ; if ( 0 == sqrl_stop ( ) ) { PC ( "STOP" , "PASS" ) ; } else { PC ( "STOP" , "FAIL" ) ; exit ( 1 ) ; } <S2SV_ModEnd> PC ( "ALL" <S2SV_ModStart> "PASS" ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,685 | CWE-000 void Cvar_Register ( vmCvar_t * vmCvar , const char * varName , const char * defaultValue , int flags ) { cvar_t * cv ; if ( ( flags & ( CVAR_ARCHIVE | CVAR_ROM ) ) == ( CVAR_ARCHIVE | CVAR_ROM ) ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>Unsetting<S2SV_blank>CVAR_ROM<S2SV_blank>from<S2SV_blank>cvar<S2SV_blank>\'%s\',<S2SV_blank>" "since<S2SV_blank>it<S2SV_blank>is<S2SV_blank>also<S2SV_blank>CVAR_ARCHIVE\\n" , varName ) ; flags &= ~ CVAR_ROM ; } if ( flags & CVAR_USER_CREATED ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>set<S2SV_blank>CVAR_USER_CREATED<S2SV_blank>on<S2SV_blank>cvar<S2SV_blank>\'%s\'\\n" , varName ) ; flags &= ~ CVAR_USER_CREATED ; } if ( flags & CVAR_SERVER_CREATED ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>set<S2SV_blank>CVAR_SERVER_CREATED<S2SV_blank>on<S2SV_blank>cvar<S2SV_blank>\'%s\'\\n" , varName ) ; flags &= ~ CVAR_SERVER_CREATED ; } if ( flags & CVAR_PROTECTED ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>set<S2SV_blank>CVAR_PROTECTED<S2SV_blank>on<S2SV_blank>cvar<S2SV_blank>\'%s\'\\n" , varName ) ; flags &= ~ CVAR_PROTECTED ; } if ( flags & CVAR_MODIFIED ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>set<S2SV_blank>CVAR_MODIFIED<S2SV_blank>on<S2SV_blank>cvar<S2SV_blank>\'%s\'\\n" , varName ) ; flags &= ~ CVAR_MODIFIED ; } if ( flags & CVAR_NONEXISTENT ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>set<S2SV_blank>CVAR_NONEXISTENT<S2SV_blank>on<S2SV_blank>cvar<S2SV_blank>\'%s\'\\n" , varName ) ; flags &= ~ CVAR_NONEXISTENT ; } cv = Cvar_FindVar ( varName ) ; if ( cv && ( cv -> flags & CVAR_PROTECTED ) ) { Com_DPrintf ( S_COLOR_YELLOW "WARNING:<S2SV_blank>VM<S2SV_blank>tried<S2SV_blank>to<S2SV_blank>register<S2SV_blank>protected<S2SV_blank>cvar<S2SV_blank>\'%s\'<S2SV_blank>with<S2SV_blank>value<S2SV_blank>\'%s\'%s\\n" , varName , defaultValue , ( flags & ~ cv -> flags ) != 0 ? "<S2SV_blank>and<S2SV_blank>new<S2SV_blank>flags" : "" ) ; } <S2SV_StartBug> else if ( cv && ( cv -> flags & CVAR_LATCH ) && ! ( cv -> flags & CVAR_VM_CREATED ) ) { <S2SV_EndBug> cv -> flags |= flags ; cvar_modifiedFlags |= flags ; } else { cv = Cvar_Get ( varName , defaultValue , flags | CVAR_VM_CREATED ) ; } if ( ! vmCvar ) return ; vmCvar -> handle = cv - cvar_indexes ; vmCvar -> modificationCount = - 1 ; Cvar_Update ( vmCvar ) ; } | <S2SV_ModStart> ) ; } <S2SV_ModEnd> else { cv |
2,686 | CWE-000 ipsec_audit ipsec_update_replay_window ( __u32 seq , __u32 * lastSeq , __u32 * bitField ) { __u32 diff ; if ( seq == 0 ) return IPSEC_AUDIT_SEQ_MISMATCH ; if ( seq > * lastSeq ) { diff = seq - * lastSeq ; if ( diff < IPSEC_SEQ_MAX_WINDOW ) { * bitField <<= diff ; <S2SV_StartBug> * bitField |= IPSEC_AUDIT_SUCCESS ; <S2SV_EndBug> <S2SV_StartBug> } else * bitField = IPSEC_AUDIT_SUCCESS ; <S2SV_EndBug> * lastSeq = seq ; return IPSEC_AUDIT_SUCCESS ; } diff = * lastSeq - seq ; if ( diff >= IPSEC_SEQ_MAX_WINDOW ) return IPSEC_AUDIT_SEQ_MISMATCH ; if ( * bitField & ( ( __u32 ) 1 << diff ) ) return IPSEC_AUDIT_SEQ_MISMATCH ; * bitField |= ( ( __u32 ) 1 << diff ) ; return IPSEC_AUDIT_SUCCESS ; } | <S2SV_ModStart> * bitField |= 1 <S2SV_ModEnd> ; } else <S2SV_ModStart> * bitField = 1 <S2SV_ModEnd> ; * lastSeq |
2,687 | CWE-000 static void __attribute__ ( ( optimize ( "O0" ) ) ) remoteP2P_SendRecv_Finish ( int callerId , struct shared_basic * info , char * recvbuf ) { info -> core_ctrl [ callerId ] . data [ 10 ] = recvbuf [ callerId * 15 + 14 ] ; if ( info -> core_ctrl [ callerId ] . data [ 10 ] == REAL_TYPE ) { <S2SV_StartBug> float var_float ; <S2SV_EndBug> memcpy ( & var_float , & recvbuf [ callerId * 15 + 4 ] , sizeof ( float ) ) ; printf ( "[node<S2SV_blank>%d]data<S2SV_blank>received<S2SV_blank>has<S2SV_blank>a<S2SV_blank>real<S2SV_blank>value:%f\\n" , info -> nodeId , val_float ) ; memcpy ( & ( info -> core_ctrl [ callerId ] . data [ 11 ] ) , & recvbuf [ callerId * 15 + 4 ] , sizeof ( float ) ) ; } else if ( info -> core_ctrl [ callerId ] . data [ 10 ] == INT_TYPE ) { <S2SV_StartBug> float var_int ; <S2SV_EndBug> memcpy ( & var_int , & recvbuf [ callerId * 15 + 4 ] , sizeof ( int ) ) ; printf ( "[node<S2SV_blank>%d]data<S2SV_blank>received<S2SV_blank>has<S2SV_blank>a<S2SV_blank>integer<S2SV_blank>value:%d\\n" , info -> nodeId , val_int ) ; memcpy ( & ( info -> core_ctrl [ callerId ] . data [ 11 ] ) , & recvbuf [ callerId * 15 + 4 ] , sizeof ( int ) ) ; } else { printf ( "[node<S2SV_blank>%d]unknown<S2SV_blank>data<S2SV_blank>type<S2SV_blank>for<S2SV_blank>received<S2SV_blank>data\\n" , ) ; } } | <S2SV_ModStart> ) { float val_float ; memcpy ( & val_float <S2SV_ModEnd> , & recvbuf <S2SV_ModStart> ) { float val_int ; memcpy ( & val_int <S2SV_ModEnd> , & recvbuf |
2,688 | CWE-000 static void new_tag ( xmlNode * n ) { struct tag * t = xcalloc ( 1 , sizeof ( struct tag ) ) ; struct tag * parent = get_parent_tag ( n ) ; char * label = ( char * ) xmlGetProp ( n , ( const xmlChar * ) "label" ) ; char * id = ( char * ) xmlGetProp ( n , ( const xmlChar * ) "id" ) ; <S2SV_StartBug> if ( ! id && ! label ) <S2SV_EndBug> die ( "cannot<S2SV_blank>create<S2SV_blank>new<S2SV_blank>tag<S2SV_blank>without<S2SV_blank>ID<S2SV_blank>and<S2SV_blank>LABEL" ) ; t -> label = label ; t -> id = id ; t -> parent = parent ; INIT_LIST_HEAD ( & t -> items ) ; list_add_tail ( & t -> list , & tags ) ; curtag = t ; <S2SV_StartBug> if ( parent && strcmp ( id , root_menu ) ) { <S2SV_EndBug> new_item ( n ) ; curitem -> label = label ; curitem -> cmd = id ; curitem -> checkout = 1 ; list_add_tail ( & curitem -> list , & curtag -> parent -> items ) ; } } | <S2SV_ModStart> ; if ( id ) t -> id = id ; else t -> id = strdup ( root_menu ) ; t -> label = label <S2SV_ModEnd> ; t -> <S2SV_ModStart> , root_menu ) != 0 |
2,689 | CWE-000 ValvulaState bwl_check_status ( ValvulaCtx * _ctx , ValvulaRequest * request , ValvulaModBwlLevel level , const char * level_label , char * * message , const char * format , ... ) { ValvuladRes result = NULL ; char * query ; va_list args ; ValvulaState state ; va_start ( args , format ) ; query = axl_strdup_printfv ( format , args ) ; va_end ( args ) ; if ( query == NULL ) { error ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>query<S2SV_blank>to<S2SV_blank>check<S2SV_blank>black/white<S2SV_blank>lists,<S2SV_blank>reporting<S2SV_blank>dunno" ) ; return VALVULA_STATE_DUNNO ; } if ( __mod_bwl_enable_debug ) msg ( "(bwl)<S2SV_blank>Running<S2SV_blank>query:<S2SV_blank>%s" , query ) ; result = valvulad_db_run_query_s ( ctx , query ) ; axl_free ( query ) ; if ( ! result ) { valvulad_db_release_result ( result ) ; return VALVULA_STATE_DUNNO ; } if ( __mod_bwl_enable_debug ) msg ( "(bwl)<S2SV_blank>Checking<S2SV_blank>request<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>-><S2SV_blank>%s" , request -> sender , request -> recipient ) ; state = bwl_check_status_rules ( _ctx , request , level , level_label , message , result , axl_true ) ; <S2SV_StartBug> if ( state != VALVULA_STATE_DUNNO ) { <S2SV_EndBug> valvulad_db_release_result ( result ) ; return state ; } state = bwl_check_status_rules ( _ctx , request , level , level_label , message , result , axl_false ) ; <S2SV_StartBug> if ( state != VALVULA_STATE_DUNNO ) { <S2SV_EndBug> valvulad_db_release_result ( result ) ; return state ; } valvulad_db_release_result ( result ) ; return state ; } | <S2SV_ModStart> ; if ( __mod_bwl_enable_debug ) msg ( "(bwl)<S2SV_blank>bwl_check_setatus_rules<S2SV_blank>[source=%s,<S2SV_blank>destination=%s,<S2SV_blank>sasl-username=%s],<S2SV_blank>reported<S2SV_blank>status=%s<S2SV_blank><S2SV_blank>(specific<S2SV_blank>rules)" , request -> sender , request -> recipient , request -> sasl_username ? request -> sasl_username : "" , valvula_support_state_str ( state ) ) ; if ( <S2SV_ModStart> ; if ( __mod_bwl_enable_debug ) msg ( "(bwl)<S2SV_blank>bwl_check_setatus_rules<S2SV_blank>[source=%s,<S2SV_blank>destination=%s,<S2SV_blank>sasl-username=%s],<S2SV_blank>reported<S2SV_blank>status=%s<S2SV_blank><S2SV_blank>(generic<S2SV_blank>rules)" , request -> sender , request -> recipient , request -> sasl_username ? request -> sasl_username : "" , valvula_support_state_str ( state ) ) ; if ( |
2,690 | CWE-000 <S2SV_StartBug> static uint64_t map_ioapic ( <S2SV_EndBug> uint64_t ioapic_paddr ) { <S2SV_StartBug> return ( vaddr_t ) ioapic_paddr ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static vaddr_t <S2SV_ModEnd> map_ioapic ( uint64_t <S2SV_ModStart> ) { return HPA2HVA ( ioapic_paddr ) <S2SV_ModEnd> ; } <S2SV_null> |
2,691 | CWE-000 static void tcp_server_task ( void * pvParameters ) { char rx_buffer [ 128 ] ; char addr_str [ 128 ] ; int addr_family ; int ip_protocol ; while ( 1 ) { # ifdef CONFIG_EXAMPLE_IPV4 struct sockaddr_in destAddr ; destAddr . sin_addr . s_addr = htonl ( INADDR_ANY ) ; destAddr . sin_family = AF_INET ; destAddr . sin_port = htons ( PORT ) ; addr_family = AF_INET ; ip_protocol = IPPROTO_IP ; inet_ntoa_r ( destAddr . sin_addr , addr_str , sizeof ( addr_str ) - 1 ) ; # else struct sockaddr_in6 destAddr ; bzero ( & destAddr . sin6_addr . un , sizeof ( destAddr . sin6_addr . un ) ) ; destAddr . sin6_family = AF_INET6 ; destAddr . sin6_port = htons ( PORT ) ; addr_family = AF_INET6 ; ip_protocol = IPPROTO_IPV6 ; inet6_ntoa_r ( destAddr . sin6_addr , addr_str , sizeof ( addr_str ) - 1 ) ; # endif int listen_sock = socket ( addr_family , SOCK_STREAM , ip_protocol ) ; if ( listen_sock < 0 ) { ESP_LOGE ( TAG , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>socket:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } ESP_LOGI ( TAG , "Socket<S2SV_blank>created" ) ; int err = bind ( listen_sock , ( struct sockaddr * ) & destAddr , sizeof ( destAddr ) ) ; if ( err != 0 ) { ESP_LOGE ( TAG , "Socket<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>bind:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } ESP_LOGI ( TAG , "Socket<S2SV_blank>binded" ) ; err = listen ( listen_sock , 1 ) ; if ( err != 0 ) { ESP_LOGE ( TAG , "Error<S2SV_blank>occured<S2SV_blank>during<S2SV_blank>listen:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } ESP_LOGI ( TAG , "Socket<S2SV_blank>listening" ) ; struct sockaddr_in6 sourceAddr ; uint addrLen = sizeof ( sourceAddr ) ; int sock = accept ( listen_sock , ( struct sockaddr * ) & sourceAddr , & addrLen ) ; if ( sock < 0 ) { ESP_LOGE ( TAG , "Unable<S2SV_blank>to<S2SV_blank>accept<S2SV_blank>connection:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } ESP_LOGI ( TAG , "Socket<S2SV_blank>accepted" ) ; while ( 1 ) { int len = recv ( sock , rx_buffer , sizeof ( rx_buffer ) - 1 , 0 ) ; if ( len < 0 ) { ESP_LOGE ( TAG , "recv<S2SV_blank>failed:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } else if ( len == 0 ) { ESP_LOGI ( TAG , "Connection<S2SV_blank>closed" ) ; break ; } else { if ( sourceAddr . sin6_family == PF_INET ) { inet_ntoa_r ( ( ( struct sockaddr_in * ) & sourceAddr ) -> sin_addr . s_addr , addr_str , sizeof ( addr_str ) - 1 ) ; } else if ( sourceAddr . sin6_family == PF_INET6 ) { inet6_ntoa_r ( sourceAddr . sin6_addr , addr_str , sizeof ( addr_str ) - 1 ) ; } rx_buffer [ len ] = 0 ; ESP_LOGI ( TAG , "Received<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>from<S2SV_blank>%s:" , len , addr_str ) ; ESP_LOGI ( TAG , "%s" , rx_buffer ) ; int err = send ( sock , rx_buffer , len , 0 ) ; if ( err < 0 ) { ESP_LOGE ( TAG , "Error<S2SV_blank>occured<S2SV_blank>during<S2SV_blank>sending:<S2SV_blank>errno<S2SV_blank>%d" , errno ) ; break ; } } } if ( sock != - 1 ) { ESP_LOGE ( TAG , "Shutting<S2SV_blank>down<S2SV_blank>socket<S2SV_blank>and<S2SV_blank>restarting..." ) ; shutdown ( sock , 0 ) ; close ( sock ) ; <S2SV_StartBug> } <S2SV_EndBug> } vTaskDelete ( NULL ) ; } | <S2SV_ModStart> sock ) ; close ( listen_sock ) ; |
2,692 | CWE-000 void add_note ( int pos , int len ) { TBL . n [ TBL . n_idx ] . flag = 1 ; TBL . n [ TBL . n_idx ] . pos = pos ; TBL . n [ TBL . n_idx ] . len = len ; <S2SV_StartBug> TBL . n [ TBL . n_idx ] . x = POS_MAP [ pos ] + 20 + 3 ; <S2SV_EndBug> TBL . n [ TBL . n_idx ] . y = - 4 ; TBL . n [ TBL . n_idx ] . fy = TBL . n [ TBL . n_idx ] . y * 256 ; switch ( pos ) { case 1 : case 3 : case 6 : case 8 : case 10 : case 1 + 12 : case 3 + 12 : case 6 + 12 : case 8 + 12 : case 10 + 12 : TBL . n [ TBL . n_idx ] . gx = 16 ; break ; default : TBL . n [ TBL . n_idx ] . gx = 0 ; } TBL . n_idx ++ ; TBL . n_idx &= MAX_NOTE - 1 ; } | <S2SV_ModStart> + 20 + 2 <S2SV_ModEnd> ; TBL . |
2,693 | CWE-000 void ft_read_map ( int fd ) { char * line ; char * * map = NULL ; int i ; <S2SV_StartBug> i = 0 ; <S2SV_EndBug> <S2SV_StartBug> map = ( char * ) malloc ( sizeof ( char * ) * size_y_cnt ) ; <S2SV_EndBug> while ( get_next_line ( fd , & line ) ) { printf ( "%d\\n" , i ) ; map [ i ] = ft_strdup ( line ) ; printf ( "%d\\n" , i ) ; printf ( "%s" , map [ i ] ) ; free ( line ) ; i ++ ; } while ( -- i >= 0 ) { if ( map [ i ] ) free ( map [ i ] ) ; } if ( map ) free ( map ) ; } | <S2SV_ModStart> int i ; t_map * s_map = NULL ; <S2SV_ModStart> ( char * * <S2SV_ModStart> * ) * s_map -> y_count <S2SV_ModEnd> ) ; while |
2,694 | CWE-000 int vmenu ( ) { <S2SV_StartBug> clear ( ) ; <S2SV_EndBug> WINDOW * menu_win ; int height , width , starty , startx , lines , cols ; int input ; int hlight = 0 ; char * smenu [ 3 ] ; smenu [ 0 ] = "#<S2SV_blank>1<S2SV_blank>-<S2SV_blank>two<S2SV_blank>player<S2SV_blank><S2SV_blank>#" ; smenu [ 1 ] = "#<S2SV_blank>2<S2SV_blank>-<S2SV_blank>one<S2SV_blank>player<S2SV_blank><S2SV_blank>#" ; smenu [ 2 ] = "#<S2SV_blank>3<S2SV_blank>-<S2SV_blank>quit<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>#" ; height = 5 ; width = 19 ; getmaxyx ( stdscr , lines , cols ) ; starty = ( lines - height ) / 2 ; startx = ( cols - width ) / 2 ; menu_win = newwin ( height , width , starty , startx ) ; keypad ( menu_win , TRUE ) ; while ( 1 ) { wmove ( menu_win , 0 , 0 ) ; wprintw ( menu_win , "###################" ) ; for ( int l = 0 ; l < 3 ; l ++ ) { if ( hlight == l ) { wattron ( menu_win , A_STANDOUT ) ; wprintw ( menu_win , "%s" , smenu [ l ] ) ; wattroff ( menu_win , A_STANDOUT ) ; } else wprintw ( menu_win , "%s" , smenu [ l ] ) ; } wprintw ( menu_win , "###################" ) ; wrefresh ( menu_win ) ; input = wgetch ( menu_win ) ; switch ( input ) { case KEY_UP : if ( hlight == 0 ) { break ; } else hlight -- ; break ; case KEY_DOWN : if ( hlight == 2 ) { break ; } else hlight ++ ; break ; case 10 : return hlight + 1 ; break ; } } delwin ( menu_win ) ; } | <S2SV_ModStart> ) { clear ( ) ; refresh |
2,695 | CWE-000 static void qxl_crtc_atomic_disable ( struct drm_crtc * crtc , struct drm_crtc_state * old_state ) { <S2SV_StartBug> struct qxl_crtc * qcrtc = to_qxl_crtc ( crtc ) ; <S2SV_EndBug> struct qxl_device * qdev = crtc -> dev -> dev_private ; qxl_monitors_config_set ( qdev , qcrtc -> index , 0 , 0 , 0 , 0 , 0 ) ; qxl_send_monitors_config ( qdev ) ; } | <S2SV_ModStart> old_state ) { qxl_crtc_update_monitors_config ( crtc , "disable" <S2SV_ModEnd> ) ; } |
2,696 | CWE-000 void kiss_free ( void * address ) { uintptr_t offset ; nvm_block_header_t block = ( nvm_block_header_t ) kiss_alloc_block -> base_addr ; unsigned index = 0 ; unsigned long long bit = 0 ; unsigned long long current , update ; nvm_block_header_t bh = ( nvm_block_header_t ) kiss_alloc_block -> base_addr ; while ( NULL != address ) { assert ( ( uintptr_t ) address >= ( ( uintptr_t ) kiss_alloc_block -> base_addr + offsetof ( struct nvm_block_header , Bitset ) + kiss_alloc_block -> bitset_length ) ) ; offset = ( uintptr_t ) address - ( uintptr_t ) kiss_alloc_block -> base_addr ; assert ( offset < kiss_alloc_block -> length ) ; index = offset / ( kiss_alloc_block -> unit_size * BITS_PER_ULL ) ; bit = offset - ( index * kiss_alloc_block -> unit_size * BITS_PER_ULL ) ; bit /= kiss_alloc_block -> unit_size ; assert ( bit < BITS_PER_ULL ) ; while ( 1 ) { current = bh -> Bitset [ index ] ; update = current & ~ ( ( ( unsigned long long ) 1 ) << bit ) ; assert ( update != current ) ; <S2SV_StartBug> if ( __sync_val_compare_and_swap ( & bh -> Bitset [ index ] , current , update ) ) { <S2SV_EndBug> kiss_alloc_block -> free_blocks ++ ; break ; } assert ( 0 ) ; } break ; } return ; } | <S2SV_ModStart> , update ) == current |
2,697 | CWE-000 static int ms_motd ( struct Client * source_p , int parc , char * parv [ ] ) { <S2SV_StartBug> if ( server_hunt ( source_p , ":%s<S2SV_blank>MOTD<S2SV_blank>:%s" , 1 , parc , parv ) != HUNTED_ISME ) <S2SV_EndBug> return 0 ; do_motd ( source_p ) ; return 0 ; } | <S2SV_ModStart> , parv ) -> ret |
2,698 | CWE-000 static int wacom_graphire_irq ( struct wacom_wac * wacom ) { struct wacom_features * features = & wacom -> features ; unsigned char * data = wacom -> data ; struct input_dev * input = wacom -> input ; int prox ; int rw = 0 ; int retval = 0 ; if ( data [ 0 ] != WACOM_REPORT_PENABLED ) { dbg ( "wacom_graphire_irq:<S2SV_blank>received<S2SV_blank>unknown<S2SV_blank>report<S2SV_blank>#%d" , data [ 0 ] ) ; goto exit ; } prox = data [ 1 ] & 0x80 ; if ( prox || wacom -> id [ 0 ] ) { if ( prox ) { switch ( ( data [ 1 ] >> 5 ) & 3 ) { case 0 : wacom -> tool [ 0 ] = BTN_TOOL_PEN ; wacom -> id [ 0 ] = STYLUS_DEVICE_ID ; break ; case 1 : wacom -> tool [ 0 ] = BTN_TOOL_RUBBER ; wacom -> id [ 0 ] = ERASER_DEVICE_ID ; break ; case 2 : input_report_key ( input , BTN_MIDDLE , data [ 1 ] & 0x04 ) ; case 3 : wacom -> tool [ 0 ] = BTN_TOOL_MOUSE ; wacom -> id [ 0 ] = CURSOR_DEVICE_ID ; break ; } } input_report_abs ( input , ABS_X , le16_to_cpup ( ( __le16 * ) & data [ 2 ] ) ) ; input_report_abs ( input , ABS_Y , le16_to_cpup ( ( __le16 * ) & data [ 4 ] ) ) ; if ( wacom -> tool [ 0 ] != BTN_TOOL_MOUSE ) { <S2SV_StartBug> input_report_abs ( input , ABS_PRESSURE , data [ 6 ] | ( ( data [ 7 ] & 0x01 ) << 8 ) ) ; <S2SV_EndBug> input_report_key ( input , BTN_TOUCH , data [ 1 ] & 0x01 ) ; input_report_key ( input , BTN_STYLUS , data [ 1 ] & 0x02 ) ; input_report_key ( input , BTN_STYLUS2 , data [ 1 ] & 0x04 ) ; } else { input_report_key ( input , BTN_LEFT , data [ 1 ] & 0x01 ) ; input_report_key ( input , BTN_RIGHT , data [ 1 ] & 0x02 ) ; if ( features -> type == WACOM_G4 || features -> type == WACOM_MO ) { input_report_abs ( input , ABS_DISTANCE , data [ 6 ] & 0x3f ) ; rw = ( data [ 7 ] & 0x04 ) - ( data [ 7 ] & 0x03 ) ; } else { input_report_abs ( input , ABS_DISTANCE , data [ 7 ] & 0x3f ) ; rw = - ( signed char ) data [ 6 ] ; } input_report_rel ( input , REL_WHEEL , rw ) ; } if ( ! prox ) wacom -> id [ 0 ] = 0 ; input_report_abs ( input , ABS_MISC , wacom -> id [ 0 ] ) ; input_report_key ( input , wacom -> tool [ 0 ] , prox ) ; input_event ( input , EV_MSC , MSC_SERIAL , 1 ) ; input_sync ( input ) ; } switch ( features -> type ) { case WACOM_G4 : prox = data [ 7 ] & 0xf8 ; if ( prox || wacom -> id [ 1 ] ) { wacom -> id [ 1 ] = PAD_DEVICE_ID ; input_report_key ( input , BTN_BACK , ( data [ 7 ] & 0x40 ) ) ; input_report_key ( input , BTN_FORWARD , ( data [ 7 ] & 0x80 ) ) ; rw = ( ( data [ 7 ] & 0x18 ) >> 3 ) - ( ( data [ 7 ] & 0x20 ) >> 3 ) ; input_report_rel ( input , REL_WHEEL , rw ) ; if ( ! prox ) wacom -> id [ 1 ] = 0 ; input_report_abs ( input , ABS_MISC , wacom -> id [ 1 ] ) ; input_event ( input , EV_MSC , MSC_SERIAL , 0xf0 ) ; retval = 1 ; } break ; case WACOM_MO : prox = ( data [ 7 ] & 0xf8 ) || data [ 8 ] ; if ( prox || wacom -> id [ 1 ] ) { wacom -> id [ 1 ] = PAD_DEVICE_ID ; input_report_key ( input , BTN_BACK , ( data [ 7 ] & 0x08 ) ) ; input_report_key ( input , BTN_LEFT , ( data [ 7 ] & 0x20 ) ) ; input_report_key ( input , BTN_FORWARD , ( data [ 7 ] & 0x10 ) ) ; input_report_key ( input , BTN_RIGHT , ( data [ 7 ] & 0x40 ) ) ; input_report_abs ( input , ABS_WHEEL , ( data [ 8 ] & 0x7f ) ) ; if ( ! prox ) wacom -> id [ 1 ] = 0 ; input_report_abs ( input , ABS_MISC , wacom -> id [ 1 ] ) ; input_event ( input , EV_MSC , MSC_SERIAL , 0xf0 ) ; retval = 1 ; } break ; } exit : return retval ; } | <S2SV_ModStart> 7 ] & 0x03 <S2SV_ModEnd> ) << 8 |
2,699 | CWE-000 int SoundDevice_PlaySound ( SoundDevice * soundDevice ) { <S2SV_StartBug> int error ; <S2SV_EndBug> ALuint sourceState ; <S2SV_StartBug> alSourcePlay ( soundDevice -> outSource ) ; <S2SV_EndBug> alGetSourcei ( soundDevice -> outSource , AL_SOURCE_STATE , & sourceState ) ; switch ( sourceState ) { case AL_INITIAL : printf ( "AL_INITIAL\\n" ) ; break ; case AL_PAUSED : printf ( "AL_PAUSED\\n" ) ; break ; case AL_STOPPED : printf ( "AL_STOPPED\\n" ) ; break ; case AL_PLAYING : printf ( "AL_PLAYING\\n" ) ; break ; } ; error = alGetError ( ) ; if ( error != AL_NO_ERROR ) { printf ( "error<S2SV_blank>playSound<S2SV_blank>%x\\n" , error ) ; return 0 ; } return - 1 ; } | <S2SV_ModStart> soundDevice ) { ALuint error <S2SV_ModEnd> ; alSourcePlay ( <S2SV_ModStart> -> outSource ) <S2SV_ModEnd> ; error = |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.