Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
600 | CWE-000 void checkstalker ( ) { float maxspeed ; int running ; if ( self != stalker ) { return ; } if ( ! firstplayer ) { stalker = NULL ; return ; } if ( stalking ) { <S2SV_StartBug> if ( self -> stalltime <= time ) <S2SV_EndBug> { stalker = NULL ; } return ; } running = validanim ( self , ANI_RUN ) ; maxspeed = running ? self -> modeldata . runspeed : self -> modeldata . speed ; self -> velocity . x = maxspeed ; self -> velocity . z = 0 ; if ( self -> position . x > firstplayer -> position . x ) { self -> velocity . x = - self -> velocity . x ; } self -> running = running ; <S2SV_StartBug> self -> stalltime = time + ( diff ( self -> position . x , firstplayer -> position . x ) + 150 ) / maxspeed * THINK_SPEED ; <S2SV_EndBug> adjust_walk_animation ( firstplayer ) ; stalking = 1 ; } | <S2SV_ModStart> -> stalltime <= _time <S2SV_ModEnd> ) { stalker <S2SV_ModStart> -> stalltime = _time <S2SV_ModEnd> + ( diff |
601 | CWE-000 int kni_loop ( void * arg ) { struct usiw_context_handle * h , * * h_prev ; struct usiw_context * ctx ; struct usiw_driver * driver ; struct usiw_qp * qp , * * qp_prev ; void * ctxs_to_add [ NEW_CTX_MAX ] ; unsigned int i , count ; int portid , ret ; driver = arg ; sem_wait ( & driver -> go ) ; while ( 1 ) { count = rte_ring_dequeue_burst ( driver -> new_ctxs , ctxs_to_add , NEW_CTX_MAX ) ; for ( i = 0 ; i < count ; ++ i ) { h = ( struct usiw_context_handle * ) ctxs_to_add [ i ] ; LIST_INSERT_HEAD ( & driver -> ctxs , h , driver_entry ) ; } LIST_FOR_EACH ( h , & driver -> ctxs , driver_entry , h_prev ) { ctx = ( void * ) atomic_load ( & h -> ctxp ) ; if ( unlikely ( ! ctx ) ) { LIST_REMOVE ( h , driver_entry ) ; free ( h ) ; continue ; } LIST_FOR_EACH ( qp , & ctx -> qp_active , ctx_entry , qp_prev ) { switch ( atomic_load ( & qp -> shm_qp -> conn_state ) ) { case usiw_qp_connected : start_qp ( qp ) ; <S2SV_StartBug> case usiw_qp_running : <S2SV_EndBug> progress_qp ( qp ) ; break ; case usiw_qp_shutdown : qp_shutdown ( qp ) ; case usiw_qp_error : LIST_REMOVE ( qp , ctx_entry ) ; if ( atomic_fetch_sub ( & qp -> refcnt , 1 ) == 1 ) { usiw_do_destroy_qp ( qp ) ; } break ; default : break ; } } } } return EXIT_FAILURE ; } | <S2SV_ModStart> qp ) ; if ( atomic_load ( & qp -> shm_qp -> conn_state ) == usiw_qp_error ) { break ; } |
602 | CWE-000 void freeProductDatabase ( ProductDatabase * productDatabase ) { for ( int i = 0 ; i < productDatabase -> productMaxCapacity ; i ++ ) { if ( productDatabase -> productBooleanArray [ i ] != 0 ) { freeProduct ( productDatabase -> productArray [ i ] ) ; } } <S2SV_StartBug> free ( productDatabase -> productCounter ) ; <S2SV_EndBug> free ( productDatabase -> productBooleanArray ) ; free ( productDatabase -> productArray ) ; } | <S2SV_ModStart> ( productDatabase -> <S2SV_ModEnd> productBooleanArray ) ; |
603 | CWE-000 static void do_block_fast ( int lda , int M , int N , int K , double * A , double * B , double * C ) { static unsigned int prod1 = 1 ; static unsigned int prod2 = 1 ; static unsigned int res1 = 0 ; static unsigned int res2 = 0 ; <S2SV_StartBug> prod1 = BLOCK_SIZE * BLOCK_SIZE ; <S2SV_EndBug> static double a [ prod1 ] __attribute__ ( ( aligned ( 32 ) ) ) ; static double temp [ 4 ] __attribute__ ( ( aligned ( 32 ) ) ) ; __m256d vec1A ; __m256d vec1B ; __m256d vec1C ; __m256d vec2A ; __m256d vec2B ; __m256d vec2C ; __m256d vecCtmp ; __m256d vecCtmp2 ; for ( int j = 0 ; j < K ; j ++ ) { prod2 = j * lda ; for ( int i = 0 ; i < M ; i ++ ) { prod1 = i * BLOCK_SIZE ; res1 = prod1 + j ; res2 = prod2 + i ; a [ res1 ] = A [ res2 ] ; } } for ( int i = 0 ; i < M ; ++ i ) { prod1 = i * BLOCK_SIZE ; for ( int j = 0 ; j < N ; ++ j ) { prod2 = j * lda ; res2 = i + prod2 ; double cij = C [ res2 ] ; for ( int k = 0 ; k < K ; k = k + 8 ) { res1 = k + prod1 ; vec1A = _mm256_load_pd ( & a [ res1 ] ) ; res2 = k + prod2 ; vec1B = _mm256_loadu_pd ( & B [ res2 ] ) ; res1 = ( k + 4 ) + prod1 ; vec2A = _mm256_load_pd ( & a [ res1 ] ) ; res2 = ( k + 4 ) + prod2 ; vec2B = _mm256_loadu_pd ( & B [ res2 ] ) ; vec1C = _mm256_mul_pd ( vec1A , vec1B ) ; vec2C = _mm256_mul_pd ( vec2A , vec2B ) ; vecCtmp = _mm256_add_pd ( vec1C , vec2C ) ; _mm256_store_pd ( & temp [ 0 ] , vecCtmp ) ; cij += temp [ 0 ] ; cij += temp [ 1 ] ; cij += temp [ 2 ] ; cij += temp [ 3 ] ; } res2 = i + prod2 ; C [ res2 ] = cij ; } } } | <S2SV_ModStart> = 0 ; static double a [ <S2SV_ModEnd> BLOCK_SIZE * BLOCK_SIZE <S2SV_ModStart> BLOCK_SIZE * BLOCK_SIZE <S2SV_ModEnd> ] __attribute__ ( |
604 | CWE-000 int sloth_verification ( const unsigned char witness [ ] , size_t witness_size , const unsigned char final_hash [ ] , const char input_string [ ] , int bits , int iterations ) { size_t final_hash_size = 64 ; mpz_t p , seed_mpz ; mpz_init ( p ) ; mpz_init ( seed_mpz ) ; unsigned char * witness_hash = malloc ( final_hash_size ) ; sloth_digest ( witness_hash , witness , witness_size ) ; int res = memcmp ( witness_hash , final_hash , final_hash_size ) ; <S2SV_StartBug> free ( witness_hash ) ; <S2SV_EndBug> if ( res != 0 ) { puts ( "HASHED<S2SV_blank>DOES<S2SV_blank>NOT<S2SV_blank>MATCH!" ) ; puts ( "Final<S2SV_blank>hash" ) ; <S2SV_StartBug> for ( int i = 0 ; i < final_hash_size ; ++ i ) { <S2SV_EndBug> printf ( "%02x<S2SV_blank>" , final_hash [ i ] ) ; } puts ( "\\nWitness<S2SV_blank>hash" ) ; <S2SV_StartBug> for ( int i = 0 ; i < final_hash_size ; ++ i ) { <S2SV_EndBug> printf ( "%02x<S2SV_blank>" , witness_hash [ i ] ) ; } puts ( "\\nRAW<S2SV_blank>Witness" ) ; <S2SV_StartBug> for ( int i = 0 ; i < witness_size ; ++ i ) { <S2SV_EndBug> printf ( "%02x<S2SV_blank>" , witness [ i ] ) ; } puts ( "" ) ; return 0 ; <S2SV_StartBug> } <S2SV_EndBug> sloth_preprocessing ( p , seed_mpz , input_string , bits ) ; return sloth_verification_core ( witness , witness_size , seed_mpz , iterations , p ) ; } | <S2SV_ModStart> final_hash_size ) ; <S2SV_ModEnd> if ( res <S2SV_ModStart> ; for ( size_t <S2SV_ModEnd> i = 0 <S2SV_ModStart> ; for ( size_t <S2SV_ModEnd> i = 0 <S2SV_ModStart> ; for ( size_t <S2SV_ModEnd> i = 0 <S2SV_ModStart> 0 ; } free ( witness_hash ) ; |
605 | CWE-000 static int wlan_hdd_change_station ( struct wiphy * wiphy , struct net_device * dev , u8 * mac , struct station_parameters * params ) { VOS_STATUS status = VOS_STATUS_SUCCESS ; hdd_adapter_t * pAdapter = WLAN_HDD_GET_PRIV_PTR ( dev ) ; hdd_context_t * pHddCtx ; hdd_station_ctx_t * pHddStaCtx ; v_MACADDR_t STAMacAddress ; # ifdef FEATURE_WLAN_TDLS tCsrStaParams StaParams = { 0 } ; tANI_U8 isBufSta = 0 ; # endif ENTER ( ) ; if ( ( NULL == pAdapter ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "invalid<S2SV_blank>adapter<S2SV_blank>" ) ; return - EINVAL ; } pHddCtx = WLAN_HDD_GET_CTX ( pAdapter ) ; pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR ( pAdapter ) ; if ( ( NULL == pHddCtx ) || ( NULL == pHddStaCtx ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_FATAL , "invalid<S2SV_blank>HDD<S2SV_blank>state<S2SV_blank>or<S2SV_blank>HDD<S2SV_blank>station<S2SV_blank>context" ) ; return - EINVAL ; } if ( pHddCtx -> isLogpInProgress ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:LOGP<S2SV_blank>in<S2SV_blank>Progress.<S2SV_blank>Ignore!!!" , __func__ ) ; return - EAGAIN ; } vos_mem_copy ( STAMacAddress . bytes , mac , sizeof ( v_MACADDR_t ) ) ; if ( ( pAdapter -> device_mode == WLAN_HDD_SOFTAP ) || ( pAdapter -> device_mode == WLAN_HDD_P2P_GO ) ) { if ( params -> sta_flags_set & BIT ( NL80211_STA_FLAG_AUTHORIZED ) ) { status = hdd_softap_change_STA_state ( pAdapter , & STAMacAddress , WLANTL_STA_AUTHENTICATED ) ; if ( status != VOS_STATUS_SUCCESS ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_INFO , "%s:<S2SV_blank>Not<S2SV_blank>able<S2SV_blank>to<S2SV_blank>change<S2SV_blank>TL<S2SV_blank>state<S2SV_blank>to<S2SV_blank>AUTHENTICATED" , __func__ ) ; return - EINVAL ; } } } else if ( ( pAdapter -> device_mode == WLAN_HDD_INFRA_STATION ) || ( pAdapter -> device_mode == WLAN_HDD_P2P_CLIENT ) ) { # ifdef FEATURE_WLAN_TDLS if ( params -> sta_flags_set & BIT ( NL80211_STA_FLAG_TDLS_PEER ) ) { StaParams . capability = params -> capability ; StaParams . uapsd_queues = params -> uapsd_queues ; StaParams . max_sp = params -> max_sp ; <S2SV_StartBug> if ( 0 != params -> ext_capab_len ) <S2SV_EndBug> vos_mem_copy ( StaParams . extn_capability , params -> ext_capab , <S2SV_StartBug> sizeof ( StaParams . extn_capability ) ) ; <S2SV_EndBug> if ( NULL != params -> ht_capa ) { StaParams . htcap_present = 1 ; vos_mem_copy ( & StaParams . HTCap , params -> ht_capa , sizeof ( tSirHTCap ) ) ; } StaParams . supported_rates_len = params -> supported_rates_len ; if ( StaParams . supported_rates_len > SIR_MAC_MAX_SUPP_RATES ) StaParams . supported_rates_len = SIR_MAC_MAX_SUPP_RATES ; if ( 0 != StaParams . supported_rates_len ) { int i = 0 ; vos_mem_copy ( StaParams . supported_rates , params -> supported_rates , StaParams . supported_rates_len ) ; VOS_TRACE ( VOS_MODULE_ID_HDD , TDLS_LOG_LEVEL , "Supported<S2SV_blank>Rates<S2SV_blank>with<S2SV_blank>Length<S2SV_blank>%d" , StaParams . supported_rates_len ) ; for ( i = 0 ; i < StaParams . supported_rates_len ; i ++ ) VOS_TRACE ( VOS_MODULE_ID_HDD , TDLS_LOG_LEVEL , "[%d]:<S2SV_blank>%0x" , i , StaParams . supported_rates [ i ] ) ; } if ( NULL != params -> vht_capa ) { StaParams . vhtcap_present = 1 ; vos_mem_copy ( & StaParams . VHTCap , params -> vht_capa , sizeof ( tSirVHTCap ) ) ; } if ( 0 != params -> ext_capab_len ) { if ( ( 1 << 4 ) & StaParams . extn_capability [ 3 ] ) { isBufSta = 1 ; } } status = wlan_hdd_tdls_add_station ( wiphy , dev , mac , 1 , & StaParams ) ; if ( VOS_STATUS_SUCCESS != status ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>sme_ChangeTdlsPeerSta<S2SV_blank>failed!" , __func__ ) ; return - EINVAL ; } } # endif } EXIT ( ) ; return status ; } | <S2SV_ModStart> ; if ( params -> ext_capab_len > sizeof ( StaParams . extn_capability ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_INFO , "received<S2SV_blank>extn<S2SV_blank>capabilities:<S2SV_blank>%d,<S2SV_blank>reset<S2SV_blank>to<S2SV_blank>max<S2SV_blank>supported" , params -> ext_capab_len ) ; params -> ext_capab_len = sizeof ( StaParams . extn_capability ) ; } if ( <S2SV_ModStart> -> ext_capab , params -> ext_capab_len <S2SV_ModEnd> ) ; if |
606 | CWE-000 int ipv4_del_nameservers_from_resolv_conf ( struct tunnel * tunnel ) { int ret = - 1 ; FILE * file ; struct stat stat ; char ns1 [ 27 ] , ns2 [ 27 ] ; char * buffer , * line ; if ( ! tunnel -> ipv4 . ns_are_new ) return 0 ; if ( tunnel -> ipv4 . ns1_addr . s_addr == 0 ) return 1 ; file = fopen ( "/etc/resolv.conf" , "r+" ) ; if ( file == NULL ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>/etc/resolv.conf<S2SV_blank>(%s).\\n" , strerror ( errno ) ) ; return 1 ; } if ( fstat ( fileno ( file ) , & stat ) == - 1 ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>stat<S2SV_blank>/etc/resolv.conf<S2SV_blank>(%s).\\n" , strerror ( errno ) ) ; goto err_close ; } <S2SV_StartBug> buffer = malloc ( stat . st_size ) ; <S2SV_EndBug> if ( buffer == NULL ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>/etc/resolv.conf<S2SV_blank>(%s).\\n" , "Not<S2SV_blank>enough<S2SV_blank>memory" ) ; goto err_close ; } if ( fread ( buffer , stat . st_size , 1 , file ) != 1 ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>/etc/resolv.conf.\\n" ) ; goto err_free ; } <S2SV_StartBug> strcpy ( ns1 , "nameserver<S2SV_blank>" ) ; <S2SV_EndBug> strncat ( ns1 , inet_ntoa ( tunnel -> ipv4 . ns1_addr ) , 15 ) ; strcpy ( ns2 , "nameserver<S2SV_blank>" ) ; strncat ( ns2 , inet_ntoa ( tunnel -> ipv4 . ns2_addr ) , 15 ) ; file = freopen ( "/etc/resolv.conf" , "w" , file ) ; if ( file == NULL ) { log_warn ( "Could<S2SV_blank>not<S2SV_blank>reopen<S2SV_blank>/etc/resolv.conf<S2SV_blank>(%s).\\n" , strerror ( errno ) ) ; goto err_free ; } for ( line = strtok ( buffer , "\\n" ) ; line != NULL ; line = strtok ( NULL , "\\n" ) ) { if ( strcmp ( line , ns1 ) == 0 ) { log_debug ( "Deleting<S2SV_blank>\\"%s\\"<S2SV_blank>from<S2SV_blank>/etc/resolv.conf.\\n" , ns1 ) ; } else if ( strcmp ( line , ns2 ) == 0 ) { log_debug ( "Deleting<S2SV_blank>\\"%s\\"<S2SV_blank>from<S2SV_blank>/etc/resolv.conf.\\n" , ns1 ) ; } else { fputs ( line , file ) ; fputs ( "\\n" , file ) ; } } ret = 0 ; err_free : free ( buffer ) ; err_close : if ( file ) fclose ( file ) ; return ret ; } | <S2SV_ModStart> stat . st_size + 1 <S2SV_ModStart> err_free ; } buffer [ stat . st_size ] = '\\0' ; |
607 | CWE-000 void hierarchy_init_workshare_hetprobe_ull ( int nid , const void * ident , unsigned long long lb , unsigned long long ub , unsigned long long incr , unsigned long long chunk ) { struct gomp_thread * thr = gomp_thread ( ) ; struct gomp_team * team = thr -> ts . team ; int nthreads = team ? team -> nthreads : 1 ; struct gomp_work_share * ws , * global ; # ifdef _CACHE_HETPROBE bool new_ent ; hash_entry_type ent = NULL ; # endif if ( popcorn_global . popcorn_killswitch ) { if ( nid == popcorn_preferred_node ) hierarchy_init_workshare_static_ull ( nid , lb , ub , incr , chunk ) ; else hierarchy_init_workshare_static_ull ( nid , ub + incr , ub , incr , chunk ) ; thr -> ts . static_trip = 0 ; return ; } ws = gomp_ptrlock_get ( & popcorn_node [ nid ] . ws_lock ) ; if ( ws == NULL ) { <S2SV_StartBug> ws = popcorn_malloc ( sizeof ( struct gomp_work_share ) , nid ) ; <S2SV_EndBug> gomp_init_work_share ( ws , false , popcorn_global . threads_per_node [ nid ] ) ; loop_init_ull ( ws , true , lb , lb , incr , GFS_HETPROBE , chunk , nid ) ; global = gomp_ptrlock_get ( & popcorn_global . ws_lock ) ; if ( global == NULL ) { <S2SV_StartBug> global = malloc ( sizeof ( struct gomp_work_share ) ) ; <S2SV_EndBug> gomp_init_work_share ( global , false , nthreads ) ; loop_init_ull ( global , true , lb , ub , incr , GFS_HETPROBE , chunk , nid ) ; # ifdef _CACHE_HETPROBE ent = get_or_create_entry ( ident , & new_ent ) ; ent -> chunk_size_ull = chunk ; if ( ! new_ent ) { if ( ent -> trips >= popcorn_max_probes ) { calculate_splits_ull ( ent , global ) ; global -> sched = GFS_HIERARCHY_DYNAMIC ; } else ent -> trips ++ ; } # endif gomp_ptrlock_set ( & popcorn_global . ws_lock , global ) ; } # ifdef _CACHE_HETPROBE if ( global -> sched == GFS_HIERARCHY_DYNAMIC ) { if ( ! ent ) ent = get_entry ( ident ) ; assert ( ent && "Missing<S2SV_blank>cache<S2SV_blank>entry" ) ; init_workshare_from_splits_ull ( nid , ent , ws ) ; if ( popcorn_log_statistics ) init_statistics ( nid ) ; } else init_statistics ( nid ) ; # else init_statistics ( nid ) ; # endif gomp_ptrlock_set ( & popcorn_node [ nid ] . ws_lock , ws ) ; } thr -> ts . work_share = ws ; thr -> ts . static_trip = 0 ; clock_gettime ( CLOCK_MONOTONIC , & thr -> probe_start ) ; } | <S2SV_ModStart> { ws = & popcorn_node [ nid ] . ws <S2SV_ModEnd> ; gomp_init_work_share ( <S2SV_ModStart> { global = & popcorn_global . ws <S2SV_ModEnd> ; gomp_init_work_share ( |
608 | CWE-000 static void scan_alias_to_id ( ShellAppSystem * self ) { ShellAppSystemPrivate * priv = self -> priv ; GList * apps , * l ; g_hash_table_remove_all ( priv -> alias_to_id ) ; apps = g_app_info_get_all ( ) ; for ( l = apps ; l != NULL ; l = l -> next ) <S2SV_StartBug> { <S2SV_EndBug> GAppInfo * info = l -> data ; const char * id = g_app_info_get_id ( info ) ; <S2SV_StartBug> add_aliases ( self , id , G_DESKTOP_APP_INFO ( info ) ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> g_list_free_full ( apps , g_object_unref ) ; } | <S2SV_ModStart> -> next ) <S2SV_ModEnd> add_aliases ( self <S2SV_ModStart> ( self , G_DESKTOP_APP_INFO ( l -> data <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ) ) ; <S2SV_ModEnd> g_list_free_full ( apps |
609 | CWE-000 <S2SV_StartBug> ChainElement chain_element_new ( void ) { <S2SV_EndBug> <S2SV_StartBug> ChainElement element = calloc ( 1 , sizeof ( * element ) ) ; <S2SV_EndBug> if ( ! element ) { return NULL ; } <S2SV_StartBug> pthread_mutex_init ( & element -> lock , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> return element ; <S2SV_EndBug> } | <S2SV_ModStart> ChainElement chain_element_new ( int is_threadsafe <S2SV_ModEnd> ) { ChainElement <S2SV_ModStart> ( * element ) + ( is_threadsafe * sizeof ( pthread_mutex_t ) <S2SV_ModStart> NULL ; } if ( is_threadsafe ) { element -> lock = ( pthread_mutex_t * ) ( element + 1 ) ; pthread_mutex_init ( <S2SV_ModEnd> element -> lock <S2SV_ModStart> NULL ) ; } |
610 | CWE-000 void freeObject ( Obj * obj , bool unlink ) { if ( obj == NULL ) return ; if ( obj -> type == OBJ_T_NONE ) { GC_TRACE_DEBUG ( 5 , "freeObject<S2SV_blank>called<S2SV_blank>on<S2SV_blank>OBJ_T_NONE:<S2SV_blank>%p" , obj ) ; return ; } ASSERT ( ! obj -> noGC ) ; TRACE_GC_FUNC_START ( 4 , "freeObject" ) ; if ( vm . inited ) { int stackObjFoundIdx = - 1 ; vec_find ( & vm . stackObjects , obj , stackObjFoundIdx ) ; if ( stackObjFoundIdx != - 1 ) { if ( inGC ) { GC_TRACE_DEBUG ( 4 , "Skipped<S2SV_blank>freeing<S2SV_blank>stack<S2SV_blank>object:<S2SV_blank>p=%p<S2SV_blank>(in<S2SV_blank>GC)" , obj ) ; return ; } GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>stack<S2SV_blank>object:<S2SV_blank>p=%p<S2SV_blank>(must<S2SV_blank>be<S2SV_blank>manual<S2SV_blank>call<S2SV_blank>" "to<S2SV_blank>freeObject(),<S2SV_blank>not<S2SV_blank>in<S2SV_blank>GC)" , obj ) ; vec_splice ( & vm . stackObjects , stackObjFoundIdx , 1 ) ; } } GC_TRACE_FREE ( 4 , obj ) ; if ( unlink ) { ASSERT ( obj -> isLinked ) ; GC_TRACE_DEBUG ( 5 , "Unlinking<S2SV_blank>object<S2SV_blank>p=%p" , obj ) ; Obj * next = obj -> next ; Obj * prev = obj -> prev ; if ( next ) { next -> prev = prev ; obj -> next = NULL ; } if ( prev ) { prev -> next = next ; obj -> prev = NULL ; } else { GC_TRACE_DEBUG ( 5 , "<S2SV_blank><S2SV_blank>unlinked<S2SV_blank>first<S2SV_blank>object" ) ; vm . objects = next ; } obj -> isLinked = false ; if ( next == NULL && prev == NULL ) { GC_TRACE_DEBUG ( 5 , "<S2SV_blank><S2SV_blank>unlinked<S2SV_blank>last<S2SV_blank>object" ) ; vm . objects = NULL ; } } switch ( obj -> type ) { case OBJ_T_BOUND_METHOD : { GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>bound<S2SV_blank>method:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjBoundMethod , obj ) ; memset ( obj , 0 , sizeof ( ObjBoundMethod ) ) ; break ; } case OBJ_T_CLASS : { ObjClass * klass = ( ObjClass * ) obj ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>class<S2SV_blank>methods/getters/setters<S2SV_blank>tables" ) ; <S2SV_StartBug> freeTable ( & klass -> fields ) ; <S2SV_EndBug> freeTable ( & klass -> hiddenFields ) ; freeTable ( & klass -> methods ) ; freeTable ( & klass -> getters ) ; freeTable ( & klass -> setters ) ; vec_deinit ( & klass -> v_includedMods ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>class:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjClass , obj ) ; break ; } case OBJ_T_MODULE : { ObjModule * mod = ( ObjModule * ) obj ; <S2SV_StartBug> GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>module<S2SV_blank>methods/getters/setters<S2SV_blank>tables" ) ; <S2SV_EndBug> freeTable ( & mod -> fields ) ; freeTable ( & mod -> hiddenFields ) ; freeTable ( & mod -> methods ) ; freeTable ( & mod -> getters ) ; freeTable ( & mod -> setters ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>module:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjModule , obj ) ; break ; } case OBJ_T_FUNCTION : { ObjFunction * func = ( ObjFunction * ) obj ; ( void ) func ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjFunction<S2SV_blank>chunk:<S2SV_blank>p=%p" , & func -> chunk ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjFunction:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjFunction , obj ) ; break ; } case OBJ_T_CLOSURE : { ObjClosure * closure = ( ObjClosure * ) obj ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjClosure:<S2SV_blank>p=%p" , closure ) ; FREE_ARRAY ( Value , closure -> upvalues , closure -> upvalueCount ) ; FREE ( ObjClosure , obj ) ; break ; } case OBJ_T_NATIVE_FUNCTION : { GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjNative:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjNative , obj ) ; break ; } case OBJ_T_INSTANCE : { ObjInstance * instance = ( ObjInstance * ) obj ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>instance<S2SV_blank>fields<S2SV_blank>table:<S2SV_blank>p=%p" , & instance -> fields ) ; freeTable ( & instance -> fields ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>instance<S2SV_blank>hidden<S2SV_blank>fields<S2SV_blank>table:<S2SV_blank>p=%p" , & instance -> hiddenFields ) ; freeTable ( & instance -> hiddenFields ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjInstance:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjInstance , obj ) ; break ; } case OBJ_T_INTERNAL : { ObjInternal * internal = ( ObjInternal * ) obj ; if ( internal -> freeFunc ) { GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>internal<S2SV_blank>object\'s<S2SV_blank>references:<S2SV_blank>p=%p,<S2SV_blank>datap=%p" , internal , internal -> data ) ; internal -> freeFunc ( obj ) ; } else if ( internal -> data ) { GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>internal<S2SV_blank>object<S2SV_blank>data:<S2SV_blank>p=%p" , internal -> data ) ; ASSERT ( internal -> dataSz > 0 ) ; FREE_SIZE ( internal -> dataSz , internal -> data ) ; } else { ASSERT ( 0 ) ; } GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>internal<S2SV_blank>object:<S2SV_blank>p=%p" , internal ) ; FREE ( ObjInternal , internal ) ; break ; } case OBJ_T_UPVALUE : { GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>upvalue:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjUpvalue , obj ) ; break ; } case OBJ_T_STRING : { ObjString * string = ( ObjString * ) obj ; ASSERT ( string -> chars ) ; <S2SV_StartBug> GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>p=%p" , string -> chars ) ; <S2SV_EndBug> GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>s=\'%s\'" , string -> chars ) ; FREE_ARRAY ( char , string -> chars , string -> capacity + 1 ) ; string -> chars = NULL ; string -> hash = 0 ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>ObjString:<S2SV_blank>p=%p" , obj ) ; FREE ( ObjString , obj ) ; memset ( obj , 0 , sizeof ( ObjString ) ) ; break ; } default : { UNREACHABLE ( "Unknown<S2SV_blank>object<S2SV_blank>type:<S2SV_blank>%d" , obj -> type ) ; } } TRACE_GC_FUNC_END ( 4 , "freeObject" ) ; } | <S2SV_ModStart> "Freeing<S2SV_blank>class<S2SV_blank>methods/getters/setters<S2SV_blank>tables" ) ; klass -> name = NULL ; <S2SV_ModStart> , "Freeing<S2SV_blank>module<S2SV_blank>methods/getters/setters<S2SV_blank>tables" ) ; mod -> name = NULL <S2SV_ModStart> ( 5 , "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>p=%p,<S2SV_blank>interned=%s,static=%s" , <S2SV_ModEnd> string -> chars <S2SV_ModStart> string -> chars , string -> isInterned ? "t" : "f" , string -> isStatic ? "t" : "f" ) ; GC_TRACE_DEBUG ( 5 , "Freeing<S2SV_blank>string<S2SV_blank>chars:<S2SV_blank>s=\'%s\'<S2SV_blank>(len=%d,<S2SV_blank>capa=%d)" , string -> chars , string -> length , string -> capacity <S2SV_ModEnd> ) ; FREE_ARRAY |
611 | CWE-000 bool read_archive_member_header ( u8 * * cursor , u32 * cursor_length , u8 * * member , u32 * member_length ) { if ( * cursor_length < sizeof ( Archive_Member_Header ) ) { return false ; } Archive_Member_Header * header = ( void * ) * cursor ; if ( header -> end [ 0 ] != 0x60 || header -> end [ 1 ] != 0x0a ) { return false ; } u64 member_size ; if ( ! parse_ascii_integer ( header -> size , 10 , & member_size ) ) { return false ; } if ( * cursor_length < sizeof ( Archive_Member_Header ) + member_size ) { return false ; } if ( member != null ) { * member = ( * cursor + sizeof ( Archive_Member_Header ) ) ; * member_length = member_size ; } u32 total_size = sizeof ( Archive_Member_Header ) + member_size ; * cursor += total_size ; * cursor_length -= total_size ; <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> -= total_size ; if ( * cursor_length > 0 && ( member_size & 1 == 1 ) ) { assert ( * * cursor == '\\n' ) ; * cursor += 1 ; * cursor_length -= 1 ; } |
612 | CWE-000 <S2SV_StartBug> int calculateEnergyFromNeighbours ( Node * node , int n_edges ) <S2SV_EndBug> { int sum = 0 ; for ( int i = 0 ; i < n_edges ; i ++ ) sum += node -> spin * node -> edges [ i ] -> spin ; return - sum ; } | <S2SV_ModStart> int calculateEnergyFromNeighbours ( NODE <S2SV_ModEnd> * node , |
613 | CWE-000 static inline int log_vsay ( struct log * log , int level , const char * filename , int line , const char * error , const char * format , va_list ap ) { int errsv = errno ; if ( level > log -> level ) { return 0 ; } int total = log -> format_func ( log , buf , sizeof ( buf ) , level , filename , line , error , format , ap ) ; switch ( log -> type ) { case SAY_LOGGER_FILE : case SAY_LOGGER_PIPE : case SAY_LOGGER_STDERR : write_to_file ( log , total ) ; break ; case SAY_LOGGER_SYSLOG : write_to_syslog ( log , total ) ; <S2SV_StartBug> if ( level == S_FATAL && log -> fd != STDERR_FILENO ) <S2SV_EndBug> <S2SV_StartBug> ( void ) safe_write ( STDERR_FILENO , buf , total ) ; <S2SV_EndBug> <S2SV_StartBug> break ; <S2SV_EndBug> case SAY_LOGGER_BOOT : { ssize_t r = safe_write ( STDERR_FILENO , buf , total ) ; ( void ) r ; break ; } default : unreachable ( ) ; } errno = errsv ; return total ; } | <S2SV_ModStart> != STDERR_FILENO ) { ssize_t r = safe_write ( STDERR_FILENO , buf , total ) ; <S2SV_ModStart> ( void ) r ; } break ; case SAY_LOGGER_BOOT : { ssize_t r = <S2SV_ModStart> total ) ; ( void ) r ; break ; <S2SV_ModEnd> } default : |
614 | CWE-000 static void phar_do_404 ( phar_archive_data * phar , char * fname , size_t fname_len , char * f404 , size_t f404_len , char * entry , size_t entry_len ) { sapi_header_line ctr = { 0 } ; phar_entry_info * info ; if ( phar && f404_len ) { info = phar_get_entry_info ( phar , f404 , f404_len , NULL , 1 ) ; if ( info ) { phar_file_action ( phar , info , "text/html" , PHAR_MIME_PHP , f404 , f404_len , fname , NULL , NULL , 0 ) ; return ; } } ctr . response_code = 404 ; ctr . line_len = sizeof ( "HTTP/1.0<S2SV_blank>404<S2SV_blank>Not<S2SV_blank>Found" ) - 1 ; ctr . line = "HTTP/1.0<S2SV_blank>404<S2SV_blank>Not<S2SV_blank>Found" ; sapi_header_op ( SAPI_HEADER_REPLACE , & ctr ) ; sapi_send_headers ( ) ; PHPWRITE ( "<html>\\n<S2SV_blank><head>\\n<S2SV_blank><S2SV_blank><title>File<S2SV_blank>Not<S2SV_blank>Found</title>\\n<S2SV_blank></head>\\n<S2SV_blank><body>\\n<S2SV_blank><S2SV_blank><h1>404<S2SV_blank>-<S2SV_blank>File<S2SV_blank>" , sizeof ( "<html>\\n<S2SV_blank><head>\\n<S2SV_blank><S2SV_blank><title>File<S2SV_blank>Not<S2SV_blank>Found</title>\\n<S2SV_blank></head>\\n<S2SV_blank><body>\\n<S2SV_blank><S2SV_blank><h1>404<S2SV_blank>-<S2SV_blank>File<S2SV_blank>" ) - 1 ) ; <S2SV_StartBug> PHPWRITE ( entry , entry_len ) ; <S2SV_EndBug> <S2SV_StartBug> PHPWRITE ( "<S2SV_blank>Not<S2SV_blank>Found</h1>\\n<S2SV_blank></body>\\n</html>" , sizeof ( "<S2SV_blank>Not<S2SV_blank>Found</h1>\\n<S2SV_blank></body>\\n</html>" ) - 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; PHPWRITE ( "Not<S2SV_blank>Found</h1>\\n<S2SV_blank></body>\\n</html>" <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> , sizeof ( "Not<S2SV_blank>Found</h1>\\n<S2SV_blank></body>\\n</html>" <S2SV_ModEnd> ) - 1 |
615 | CWE-000 <S2SV_StartBug> bool wall ( struct Wall * w ) { <S2SV_EndBug> return ( w -> wall & wall_mask ) != 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> wall ( struct |
616 | CWE-000 ctr_object * ctr_array_min ( ctr_object * myself , ctr_argument * argumentList ) { double min = 0 ; double v = 0 ; ctr_object * el ; ctr_size i = 0 ; <S2SV_StartBug> for ( i = 0 ; i < myself -> value . avalue -> head ; i ++ ) { <S2SV_EndBug> el = * ( myself -> value . avalue -> elements + i ) ; <S2SV_StartBug> v = ctr_internal_cast2number ( el ) -> value . bvalue ; <S2SV_EndBug> if ( i == 0 || v < min ) { min = v ; } } return ctr_build_number_from_float ( min ) ; } | <S2SV_ModStart> ( i = myself -> value . avalue -> tail <S2SV_ModEnd> ; i < <S2SV_ModStart> -> value . nvalue <S2SV_ModEnd> ; if ( |
617 | CWE-000 static Buffer UsegGetBufferForRecord ( Relation relation , Size len ) { Buffer buffer = InvalidBuffer ; Page page ; Size pageFreeSpace = 0 ; BlockNumber currentBlock , targetBlock ; ULogRecPtr current_recptr = GetULogInsertRecPtr ( ) ; if ( IsBootstrapProcessingMode ( ) ) { buffer = ReadBuffer ( relation , 1 ) ; LockBuffer ( buffer , BUFFER_LOCK_EXCLUSIVE ) ; page = BufferGetPage ( buffer ) ; ULogPageSetXid ( page , GetTopTransactionIdIfAny ( ) ) ; return buffer ; } len = MAXALIGN ( len ) ; if ( len > MaxHeapTupleSize ) ereport ( ERROR , ( errcode ( ERRCODE_PROGRAM_LIMIT_EXCEEDED ) , errmsg ( "record<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big:<S2SV_blank>size<S2SV_blank>%zu,<S2SV_blank>maximum<S2SV_blank>size<S2SV_blank>%zu" , len , MaxHeapTupleSize ) ) ) ; currentBlock = current_recptr . blknum ; <S2SV_StartBug> if ( currentBlock != lastUsedBlock ) <S2SV_EndBug> targetBlock = currentBlock ; if ( targetBlock == InvalidBlockNumber ) { targetBlock = GetFreeUlogPage ( relation , currentBlock ) ; if ( targetBlock == InvalidBlockNumber ) { BlockNumber nblocks = RelationGetNumberOfBlocks ( relation ) ; <S2SV_StartBug> if ( nblocks > 0 ) <S2SV_EndBug> <S2SV_StartBug> targetBlock = nblocks - 1 ; <S2SV_EndBug> } } loop : while ( targetBlock != InvalidBlockNumber ) { buffer = ReadBuffer ( relation , targetBlock ) ; LockBuffer ( buffer , BUFFER_LOCK_EXCLUSIVE ) ; page = BufferGetPage ( buffer ) ; pageFreeSpace = PageGetHeapFreeSpace ( page ) ; if ( len <= pageFreeSpace ) { RelationSetTargetBlock ( relation , targetBlock ) ; return buffer ; } LockBuffer ( buffer , BUFFER_LOCK_UNLOCK ) ; ReleaseBuffer ( buffer ) ; targetBlock = GetFreeUlogPage ( relation , currentBlock ) ; } if ( ! ConditionalLockRelationForExtension ( relation , ExclusiveLock ) ) { LockRelationForExtension ( relation , ExclusiveLock ) ; targetBlock = GetFreeUlogPage ( relation , currentBlock ) ; if ( targetBlock != InvalidBlockNumber ) { UnlockRelationForExtension ( relation , ExclusiveLock ) ; goto loop ; } UlogsegAddExtraBlocks ( relation , - 1 ) ; } buffer = ReadBuffer ( relation , P_NEW ) ; LockBuffer ( buffer , BUFFER_LOCK_EXCLUSIVE ) ; UnlockRelationForExtension ( relation , ExclusiveLock ) ; page = BufferGetPage ( buffer ) ; if ( ! PageIsNew ( page ) ) elog ( ERROR , "page<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>\\"%s\\"<S2SV_blank>should<S2SV_blank>be<S2SV_blank>empty<S2SV_blank>but<S2SV_blank>is<S2SV_blank>not" , BufferGetBlockNumber ( buffer ) , RelationGetRelationName ( relation ) ) ; PageInit ( page , BufferGetPageSize ( buffer ) , 0 , BLKTYPE_ULOG , 1 ) ; if ( len > PageGetHeapFreeSpace ( page ) ) { elog ( PANIC , "record<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big:<S2SV_blank>size<S2SV_blank>%zu" , len ) ; } RelationSetTargetBlock ( relation , BufferGetBlockNumber ( buffer ) ) ; return buffer ; } | <S2SV_ModStart> if ( currentBlock == lastUsedBlock ) targetBlock = InvalidBlockNumber ; else <S2SV_ModEnd> targetBlock = currentBlock <S2SV_ModStart> nblocks > 0 && <S2SV_ModEnd> nblocks - 1 <S2SV_ModStart> nblocks - 1 != lastUsedBlock ) targetBlock = nblocks - 1 |
618 | CWE-000 static void heap_consolidate ( heap_t * h ) { uint32_t i ; heap_node_t * x , * y , * n ; heap_node_t * a [ 64 ] ; memset ( a , 0 , sizeof ( a ) ) ; h -> min -> prev -> next = NULL ; for ( x = n = h -> min ; n ; x = n ) { n = n -> next ; while ( a [ x -> degree ] ) { y = a [ x -> degree ] ; if ( h -> compare ( x -> datum , y -> datum ) > 0 ) { <S2SV_StartBug> swap ( x , y ) ; <S2SV_EndBug> } a [ x -> degree ] = NULL ; heap_link ( h , y , x ) ; } a [ x -> degree ] = x ; } for ( h -> min = NULL , i = 0 ; i < 64 ; i ++ ) { if ( a [ i ] ) { if ( h -> min ) { insert_heap_node_in_list ( a [ i ] , h -> min ) ; if ( h -> compare ( a [ i ] -> datum , h -> min -> datum ) < 0 ) { h -> min = a [ i ] ; } } else { h -> min = a [ i ] ; a [ i ] -> next = a [ i ] -> prev = a [ i ] ; } } } } | <S2SV_ModStart> 0 ) { c_swap <S2SV_ModEnd> ( x , |
619 | CWE-000 static int vmci_transport_recv_listen ( struct sock * sk , struct vmci_transport_packet * pkt ) { struct sock * pending ; struct vsock_sock * vpending ; int err ; u64 qp_size ; bool old_request = false ; bool old_pkt_proto = false ; err = 0 ; pending = vmci_transport_get_pending ( sk , pkt ) ; if ( pending ) { lock_sock ( pending ) ; vsock_sk ( pending ) -> local_addr . svm_cid = pkt -> dg . dst . context ; switch ( pending -> sk_state ) { case SS_CONNECTING : err = vmci_transport_recv_connecting_server ( sk , pending , pkt ) ; break ; default : vmci_transport_send_reset ( pending , pkt ) ; err = - EINVAL ; } if ( err < 0 ) vsock_remove_pending ( sk , pending ) ; release_sock ( pending ) ; vmci_transport_release_pending ( pending ) ; return err ; } if ( ! ( pkt -> type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST || pkt -> type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2 ) ) { vmci_transport_reply_reset ( pkt ) ; return - EINVAL ; } if ( pkt -> u . size == 0 ) { vmci_transport_reply_reset ( pkt ) ; return - EINVAL ; } if ( sk -> sk_ack_backlog >= sk -> sk_max_ack_backlog ) { vmci_transport_reply_reset ( pkt ) ; return - ECONNREFUSED ; } pending = __vsock_create ( sock_net ( sk ) , NULL , sk , GFP_KERNEL , sk -> sk_type ) ; if ( ! pending ) { vmci_transport_send_reset ( sk , pkt ) ; return - ENOMEM ; } vpending = vsock_sk ( pending ) ; vsock_addr_init ( & vpending -> local_addr , pkt -> dg . dst . context , pkt -> dst_port ) ; vsock_addr_init ( & vpending -> remote_addr , pkt -> dg . src . context , pkt -> src_port ) ; if ( pkt -> u . size >= vmci_trans ( vpending ) -> queue_pair_min_size && pkt -> u . size <= vmci_trans ( vpending ) -> queue_pair_max_size ) { qp_size = pkt -> u . size ; } else { qp_size = vmci_trans ( vpending ) -> queue_pair_size ; } if ( vmci_transport_old_proto_override ( & old_pkt_proto ) ) { old_request = old_pkt_proto ; } else { if ( pkt -> type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST ) old_request = true ; else if ( pkt -> type == VMCI_TRANSPORT_PACKET_TYPE_REQUEST2 ) old_request = false ; } if ( old_request ) { u16 version = VSOCK_PROTO_INVALID ; if ( vmci_transport_proto_to_notify_struct ( pending , & version , true ) ) err = vmci_transport_send_negotiate ( pending , qp_size ) ; else err = - EINVAL ; } else { int proto_int = pkt -> proto ; int pos ; u16 active_proto_version = 0 ; proto_int &= vmci_transport_new_proto_supported_versions ( ) ; pos = fls ( proto_int ) ; if ( pos ) { active_proto_version = ( 1 << ( pos - 1 ) ) ; if ( vmci_transport_proto_to_notify_struct ( pending , & active_proto_version , false ) ) err = vmci_transport_send_negotiate2 ( pending , qp_size , active_proto_version ) ; else err = - EINVAL ; } else { err = - EINVAL ; } } if ( err < 0 ) { vmci_transport_send_reset ( sk , pkt ) ; sock_put ( pending ) ; err = vmci_transport_error_to_vsock_error ( err ) ; goto out ; } vsock_add_pending ( sk , pending ) ; sk -> sk_ack_backlog ++ ; pending -> sk_state = SS_CONNECTING ; vmci_trans ( vpending ) -> produce_size = vmci_trans ( vpending ) -> consume_size = qp_size ; vmci_trans ( vpending ) -> queue_pair_size = qp_size ; vmci_trans ( vpending ) -> notify_ops -> process_request ( pending ) ; vpending -> listener = sk ; sock_hold ( sk ) ; sock_hold ( pending ) ; <S2SV_StartBug> INIT_DELAYED_WORK ( & vpending -> dwork , vsock_pending_work ) ; <S2SV_EndBug> schedule_delayed_work ( & vpending -> dwork , HZ ) ; out : return err ; } | <S2SV_ModStart> pending ) ; schedule_delayed_work <S2SV_ModEnd> ( & vpending <S2SV_ModStart> & vpending -> pending_work <S2SV_ModEnd> , HZ ) |
620 | CWE-000 static char * mkreadable ( char * buffer , long blen , const char * src , u_long srclen , int hex ) { static const char ellipsis [ ] = "..." ; char * b = buffer ; char * endb = NULL ; if ( blen < 4 ) return NULL ; endb = buffer + blen - sizeof ( ellipsis ) ; blen -- ; while ( blen && srclen -- ) { if ( ! hex && ( * src != '\\\\' ) && ( * src != \'"\' ) && isprint ( ( unsigned char ) * src ) ) { * buffer ++ = * src ++ ; blen -- ; } else { if ( blen < 4 ) { while ( blen -- ) { * buffer ++ = '.' ; } * buffer = '\\0' ; return b ; } else { if ( * src == '\\\\' ) { memcpy ( buffer , "\\\\\\\\" , 2 ) ; buffer += 2 ; blen -= 2 ; src ++ ; } else { snprintf ( buffer , ( size_t ) blen , <S2SV_StartBug> "\\\\x%02x" , * src ++ ) ; <S2SV_EndBug> blen -= 4 ; buffer += 4 ; } } } if ( srclen && ! blen && endb ) memcpy ( endb , ellipsis , sizeof ( ellipsis ) ) ; } * buffer = '\\0' ; return b ; } | <S2SV_ModStart> , "\\\\x%02x" , ( unsigned ) ( * src ++ ) <S2SV_ModEnd> ) ; blen |
621 | CWE-000 <S2SV_StartBug> int piksi_open ( const char * port ) <S2SV_EndBug> { int fd = open ( port , O_RDWR | O_NOCTTY | O_NDELAY ) ; if ( fd < 0 ) return PIKSI_ERROR_NO_DEVICE ; fcntl ( fd , F_SETFL , 0 ) ; struct termios options ; cfmakeraw ( & options ) ; <S2SV_StartBug> if ( cfsetispeed ( & options , B1000000 ) < 0 ) <S2SV_EndBug> { close ( fd ) ; return PIKSI_ERROR_IO ; } options . c_cflag &= ~ HUPCL ; options . c_lflag &= ~ ICANON ; options . c_cc [ VTIME ] = 2 ; options . c_cc [ VMIN ] = 0 ; if ( tcsetattr ( fd , TCSANOW , & options ) < 0 ) { close ( fd ) ; return PIKSI_ERROR_IO ; } int mydev = next_available_handle ( ) ; if ( mydev < 0 ) goto close_mem_error ; piksi_list [ mydev ] = malloc ( sizeof ( struct piksi_priv ) ) ; if ( ! piksi_list [ mydev ] ) goto null_struct ; memset ( piksi_list [ mydev ] , 0 , sizeof ( struct piksi_priv ) ) ; piksi_list [ mydev ] -> port = malloc ( strlen ( port ) + 1 ) ; if ( ! piksi_list [ mydev ] -> port ) goto free_struct ; memcpy ( piksi_list [ mydev ] -> port , port , strlen ( port ) + 1 ) ; piksi_list [ mydev ] -> fd = fd ; <S2SV_StartBug> piksi_list [ mydev ] -> baud = baud2term ( 1000000 ) ; <S2SV_EndBug> return mydev ; free_struct : free ( piksi_list [ mydev ] ) ; null_struct : piksi_list [ mydev ] = NULL ; close_mem_error : close ( fd ) ; return PIKSI_ERROR_NO_MEM ; } | <S2SV_ModStart> char * port , int baud ) { printf ( "Baud<S2SV_blank>%d\\n" , baud ) ; <S2SV_ModEnd> int fd = <S2SV_ModStart> & options , baud2term ( baud ) <S2SV_ModEnd> ) < 0 <S2SV_ModStart> = baud2term ( baud <S2SV_ModEnd> ) ; return |
622 | CWE-000 <S2SV_StartBug> bool parse_message ( char * message , bool parse_bomb , void * type ) { <S2SV_EndBug> int offset = USERNAME_LENGTH + PADDING_LENGTH ; int i = offset ; <S2SV_StartBug> if ( parse_bomb ) { <S2SV_EndBug> bomb_t * bomb = ( bomb_t * ) type ; bomb -> x = message [ i ++ ] ; bomb -> y = message [ i ] ; return true ; } <S2SV_StartBug> ship_t * ships = ( ship * ) type ; <S2SV_EndBug> for ( int j = 0 ; j < NUMBER_SHIPS ; j ++ ) { <S2SV_StartBug> ships [ j ] -> x = extract_int ( message [ i ++ ] , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> ships [ j ] -> y = extract_int ( message [ i ++ ] , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> ships [ j ] -> orientation = extract_int ( message [ i ++ ] , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> ships [ j ++ ] -> size = extract_int ( message [ i ++ ] , 1 ) ; <S2SV_EndBug> i ++ ; } return true ; } | <S2SV_ModStart> * message , bomb_t * bomb , ship_t * ships <S2SV_ModEnd> ) { int <S2SV_ModStart> ; if ( bomb != NULL ) { <S2SV_ModEnd> bomb -> x <S2SV_ModStart> true ; } <S2SV_ModEnd> for ( int <S2SV_ModStart> extract_int ( message , i ++ <S2SV_ModEnd> , 1 ) <S2SV_ModStart> extract_int ( message , i ++ <S2SV_ModEnd> , 1 ) <S2SV_ModStart> extract_int ( message , i ++ <S2SV_ModEnd> , 1 ) <S2SV_ModStart> extract_int ( message , i ++ <S2SV_ModEnd> , 1 ) |
623 | CWE-000 struct ion_heap * ion_chunk_heap_create ( struct ion_platform_heap * heap_data ) { struct ion_chunk_heap * chunk_heap ; struct vm_struct * vm_struct ; pgprot_t pgprot = pgprot_writecombine ( PAGE_KERNEL ) ; int i , ret ; chunk_heap = kzalloc ( sizeof ( struct ion_chunk_heap ) , GFP_KERNEL ) ; if ( ! chunk_heap ) return ERR_PTR ( - ENOMEM ) ; chunk_heap -> chunk_size = ( unsigned long ) heap_data -> priv ; chunk_heap -> pool = gen_pool_create ( get_order ( chunk_heap -> chunk_size ) + PAGE_SHIFT , - 1 ) ; if ( ! chunk_heap -> pool ) { ret = - ENOMEM ; goto error_gen_pool_create ; } chunk_heap -> base = heap_data -> base ; chunk_heap -> size = heap_data -> size ; chunk_heap -> allocated = 0 ; vm_struct = get_vm_area ( PAGE_SIZE , VM_ALLOC ) ; if ( ! vm_struct ) { ret = - ENOMEM ; goto error ; } for ( i = 0 ; i < chunk_heap -> size ; i += PAGE_SIZE ) { struct page * page = phys_to_page ( chunk_heap -> base + i ) ; struct page * * pages = & page ; <S2SV_StartBug> ret = map_vm_area ( vm_struct , pgprot , pages ) ; <S2SV_EndBug> if ( ret ) goto error_map_vm_area ; memset ( vm_struct -> addr , 0 , PAGE_SIZE ) ; unmap_kernel_range ( ( unsigned long ) vm_struct -> addr , PAGE_SIZE ) ; } free_vm_area ( vm_struct ) ; # ifdef CONFIG_64BIT dma_sync_single_for_device ( NULL , ( dma_addr_t ) page_to_phys ( phys_to_page ( heap_data -> base ) ) , heap_data -> size , DMA_BIDIRECTIONAL ) ; # else arm_dma_ops . sync_single_for_device ( NULL , pfn_to_dma ( NULL , page_to_pfn ( phys_to_page ( heap_data -> base ) ) ) , heap_data -> size , DMA_BIDIRECTIONAL ) ; # endif gen_pool_add ( chunk_heap -> pool , chunk_heap -> base , heap_data -> size , - 1 ) ; chunk_heap -> heap . ops = & chunk_heap_ops ; chunk_heap -> heap . type = ION_HEAP_TYPE_CHUNK ; chunk_heap -> heap . flags = ION_HEAP_FLAG_DEFER_FREE ; pr_info ( "%s:<S2SV_blank>base<S2SV_blank>%lu<S2SV_blank>size<S2SV_blank>%u<S2SV_blank>align<S2SV_blank>%ld\\n" , __func__ , chunk_heap -> base , heap_data -> size , heap_data -> align ) ; return & chunk_heap -> heap ; error_map_vm_area : free_vm_area ( vm_struct ) ; error : gen_pool_destroy ( chunk_heap -> pool ) ; error_gen_pool_create : kfree ( chunk_heap ) ; return ERR_PTR ( ret ) ; } | <S2SV_ModStart> , pgprot , & |
624 | CWE-000 int main ( int argc , char * * argv ) { struct sockaddr_in si_me , si_other ; int i , slen = sizeof ( si_other ) , recv_len ; int s ; unsigned int udp_port = PORT ; char * buf = NULL ; bool dump_flag = false ; char * raw_file_name = NULL ; parse_args ( argc , argv , & udp_port , & dump_flag , & raw_file_name ) ; if ( dump_flag ) printf ( "Will<S2SV_blank>dump<S2SV_blank>UDP<S2SV_blank>packages.\\n" ) ; else printf ( "Won\'t<S2SV_blank>dump<S2SV_blank>UDP<S2SV_blank>packages.\\n" ) ; printf ( "UDP<S2SV_blank>Port:<S2SV_blank>%d\\n" , udp_port ) ; if ( raw_file_name ) printf ( "Output<S2SV_blank>RAW<S2SV_blank>file:<S2SV_blank>%s\\n" , raw_file_name ) ; else printf ( "Output<S2SV_blank>RAW<S2SV_blank>file<S2SV_blank>doesn\'t<S2SV_blank>set.\\n" ) ; if ( ( s = socket ( AF_INET , SOCK_DGRAM , IPPROTO_UDP ) ) == - 1 ) { die ( "socket" ) ; } memset ( ( char * ) & si_me , 0 , sizeof ( si_me ) ) ; si_me . sin_family = AF_INET ; si_me . sin_port = htons ( udp_port ) ; si_me . sin_addr . s_addr = htonl ( INADDR_ANY ) ; if ( bind ( s , ( struct sockaddr * ) & si_me , sizeof ( si_me ) ) == - 1 ) { die ( "bind" ) ; } signal ( SIGINT , terminate ) ; printf ( "Waiting<S2SV_blank>for<S2SV_blank>UDP<S2SV_blank>data,<S2SV_blank>port<S2SV_blank>%d...\\n" , udp_port ) ; fflush ( stdout ) ; init_table ( ) ; fd = open ( "/dev/null" , O_WRONLY ) ; if ( raw_file_name ) fd = open ( raw_file_name , O_WRONLY | O_CREAT | O_TRUNC , 0666 ) ; if ( fd == - 1 ) { printf ( "Can\'t<S2SV_blank>create<S2SV_blank>file<S2SV_blank>%s\\n" , raw_file_name ) ; } while ( no_exit_flag ) { create_buffer ( & buf ) ; if ( ( recv_len = recvfrom ( s , buf , BUFLEN , 0 , ( struct sockaddr * ) & si_other , & slen ) ) == - 1 ) { die ( "recvfrom()" ) ; } <S2SV_StartBug> if ( ( get_chunk_id ( buf , recv_len ) == 0 ) && ( factual_table_size != 0 ) ) <S2SV_EndBug> { store_table ( fd ) ; free_buffers ( ) ; } add_buf_in_table ( buf , recv_len ) ; if ( dump_flag ) { printf ( "Received<S2SV_blank>packet<S2SV_blank>from<S2SV_blank>%s:%d\\n" , inet_ntoa ( si_other . sin_addr ) , ntohs ( si_other . sin_port ) ) ; printf ( "Received:<S2SV_blank>%d<S2SV_blank>Bytes\\n" , recv_len ) ; dump_buffer ( buf , recv_len ) ; } } store_table ( fd ) ; return 0 ; } | <S2SV_ModStart> if ( ( ! is_chunk ( buf , recv_len ) <S2SV_ModEnd> ) && ( |
625 | CWE-000 bool lwmac_update ( gnrc_netdev2_t * gnrc_netdev2 ) { gnrc_netdev2 -> lwmac . needs_rescheduling = false ; switch ( gnrc_netdev2 -> lwmac . state ) { case SLEEPING : if ( gnrc_netdev2 -> lwmac . quit_tx == true ) { return false ; } if ( ! lwmac_timeout_is_running ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAIT_FOR_DEST_WAKEUP ) ) { if ( gnrc_priority_pktqueue_length ( & ( gnrc_netdev2 -> tx . neighbors [ 0 ] . queue ) ) > 0 ) { gnrc_netdev2 -> tx . current_neighbor = & ( gnrc_netdev2 -> tx . neighbors [ 0 ] ) ; lwmac_set_state ( gnrc_netdev2 , TRANSMITTING ) ; break ; } gnrc_mac_tx_neighbor_t * neighbour = _next_tx_neighbour ( gnrc_netdev2 ) ; if ( neighbour != NULL ) { if ( neighbour -> phase >= RTT_TICKS_TO_US ( LWMAC_WAKEUP_INTERVAL_US ) ) { gnrc_netdev2 -> tx . current_neighbor = neighbour ; gnrc_netdev2 -> lwmac . extend_tx = false ; gnrc_netdev2 -> lwmac . max_tx_num = 0 ; lwmac_set_state ( gnrc_netdev2 , TRANSMITTING ) ; break ; } int time_until_tx = RTT_TICKS_TO_US ( _ticks_until_phase ( neighbour -> phase ) ) ; if ( time_until_tx < LWMAC_WR_PREPARATION_US ) { time_until_tx += LWMAC_WAKEUP_INTERVAL_US ; } time_until_tx -= LWMAC_WR_PREPARATION_US ; lwmac_set_timeout ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAIT_FOR_DEST_WAKEUP , time_until_tx ) ; gnrc_netdev2 -> tx . current_neighbor = neighbour ; rtt_handler ( LWMAC_EVENT_RTT_PAUSE , gnrc_netdev2 ) ; } else { } } else { if ( lwmac_timeout_is_expired ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAIT_FOR_DEST_WAKEUP ) ) { LOG_DEBUG ( "Got<S2SV_blank>timeout<S2SV_blank>for<S2SV_blank>dest<S2SV_blank>wakeup,<S2SV_blank>ticks:<S2SV_blank>%" PRIu32 "\\n" , rtt_get_counter ( ) ) ; gnrc_netdev2 -> lwmac . extend_tx = false ; gnrc_netdev2 -> lwmac . max_tx_num = 0 ; lwmac_set_state ( gnrc_netdev2 , TRANSMITTING ) ; } else { } } break ; case LISTENING : if ( _next_tx_neighbour ( gnrc_netdev2 ) != NULL ) { rtt_handler ( LWMAC_EVENT_RTT_PAUSE , gnrc_netdev2 ) ; } if ( gnrc_netdev2 -> lwmac . extend_wakeup == true ) { gnrc_netdev2 -> lwmac . extend_wakeup = false ; lwmac_clear_timeout ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD ) ; } if ( ! lwmac_timeout_is_running ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD ) ) { lwmac_set_timeout ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD , LWMAC_WAKEUP_DURATION_US ) ; } else if ( lwmac_timeout_is_expired ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD ) ) { _dispatch ( gnrc_netdev2 -> rx . dispatch_buffer ) ; gnrc_netdev2 -> lwmac . state = SLEEPING ; rtt_handler ( LWMAC_EVENT_RTT_RESUME , gnrc_netdev2 ) ; _set_netdev_state ( gnrc_netdev2 , NETOPT_STATE_SLEEP ) ; lwmac_clear_timeout ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD ) ; gnrc_mac_tx_neighbor_t * neighbour = _next_tx_neighbour ( gnrc_netdev2 ) ; if ( neighbour != NULL ) { lwmac_schedule_update ( gnrc_netdev2 ) ; break ; } else { puts ( "quit" ) ; gnrc_netdev2 -> lwmac . quit_tx = true ; } } if ( gnrc_priority_pktqueue_length ( & gnrc_netdev2 -> rx . queue ) > 0 ) { <S2SV_StartBug> lwmac_set_state ( gnrc_netdev2 , RECEIVING ) ; <S2SV_EndBug> } break ; case RECEIVING : { lwmac_rx_state_t state_rx = gnrc_netdev2 -> rx . state ; switch ( state_rx ) { case RX_STATE_STOPPED : { lwmac_rx_start ( gnrc_netdev2 ) ; lwmac_rx_update ( gnrc_netdev2 ) ; break ; } case RX_STATE_FAILED : LOG_DEBUG ( "Reception<S2SV_blank>was<S2SV_blank>NOT<S2SV_blank>successful\\n" ) ; lwmac_rx_stop ( gnrc_netdev2 ) ; gnrc_netdev2 -> lwmac . extend_wakeup = true ; lwmac_set_state ( gnrc_netdev2 , LISTENING ) ; break ; case RX_STATE_SUCCESSFUL : LOG_INFO ( "Reception<S2SV_blank>was<S2SV_blank>successful\\n" ) ; lwmac_rx_stop ( gnrc_netdev2 ) ; _dispatch ( gnrc_netdev2 -> rx . dispatch_buffer ) ; gnrc_netdev2 -> lwmac . extend_wakeup = true ; lwmac_set_state ( gnrc_netdev2 , LISTENING ) ; break ; default : lwmac_rx_update ( gnrc_netdev2 ) ; } if ( state_rx != gnrc_netdev2 -> rx . state ) { lwmac_schedule_update ( gnrc_netdev2 ) ; } break ; } case TRANSMITTING : { char * tx_success = "" ; lwmac_tx_state_t state_tx = gnrc_netdev2 -> tx . state ; switch ( state_tx ) { case TX_STATE_STOPPED : { gnrc_pktsnip_t * pkt ; if ( ( pkt = gnrc_priority_pktqueue_pop ( & gnrc_netdev2 -> tx . current_neighbor -> queue ) ) ) { lwmac_tx_start ( gnrc_netdev2 , pkt , gnrc_netdev2 -> tx . current_neighbor ) ; lwmac_tx_update ( gnrc_netdev2 ) ; } else { int id = ( gnrc_netdev2 -> tx . current_neighbor - gnrc_netdev2 -> tx . neighbors ) ; id /= sizeof ( gnrc_netdev2 -> tx . current_neighbor ) ; LOG_ERROR ( "Packet<S2SV_blank>from<S2SV_blank>neighbour\'s<S2SV_blank>queue<S2SV_blank>(#%d)<S2SV_blank>invalid\\n" , id ) ; lwmac_schedule_update ( gnrc_netdev2 ) ; } break ; } case TX_STATE_FAILED : gnrc_netdev2 -> lwmac . quit_tx = true ; gnrc_netdev2 -> lwmac . extend_tx = false ; tx_success = "NOT<S2SV_blank>" ; case TX_STATE_SUCCESSFUL : if ( gnrc_netdev2 -> tx . current_neighbor == & ( gnrc_netdev2 -> tx . neighbors [ 0 ] ) ) { LOG_INFO ( "Broadcast<S2SV_blank>transmission<S2SV_blank>done\\n" ) ; } else { LOG_INFO ( "Transmission<S2SV_blank>was<S2SV_blank>%ssuccessful<S2SV_blank>(%" PRIu32 "<S2SV_blank>WRs<S2SV_blank>sent)\\n" , tx_success , gnrc_netdev2 -> tx . wr_sent ) ; } lwmac_tx_stop ( gnrc_netdev2 ) ; if ( gnrc_netdev2 -> lwmac . max_tx_num >= LWMAC_MAX_TX_BURST_PKT_NUM ) { gnrc_netdev2 -> lwmac . quit_tx = true ; lwmac_set_state ( gnrc_netdev2 , SLEEPING ) ; break ; } if ( gnrc_netdev2 -> lwmac . extend_tx == true ) { lwmac_schedule_update ( gnrc_netdev2 ) ; } else { gnrc_netdev2 -> lwmac . quit_tx = true ; lwmac_set_state ( gnrc_netdev2 , SLEEPING ) ; } break ; default : lwmac_tx_update ( gnrc_netdev2 ) ; } if ( state_tx != gnrc_netdev2 -> tx . state ) { lwmac_schedule_update ( gnrc_netdev2 ) ; } break ; } default : LOG_DEBUG ( "No<S2SV_blank>actions<S2SV_blank>in<S2SV_blank>state<S2SV_blank>%u\\n" , gnrc_netdev2 -> lwmac . state ) ; } return gnrc_netdev2 -> lwmac . needs_rescheduling ; } | <S2SV_ModStart> 0 ) { lwmac_clear_timeout ( & gnrc_netdev2 -> lwmac , TIMEOUT_WAKEUP_PERIOD ) ; |
626 | CWE-000 <S2SV_StartBug> inline calculation_parameters_t <S2SV_EndBug> new_calculation_parameters4 ( double fajrAngle , int ishaInterval , calculation_method method ) { madhab_t madhab = SHAFI ; high_latitude_rule_t highLatitudeRule = TWILIGHT_ANGLE ; calculation_parameters_t calculation_parameters = ( calculation_parameters_t ) { method , fajrAngle , 0 , ishaInterval , madhab , highLatitudeRule , INIT_PRAYER_ADJUSTMENTS ( ) } ; return calculation_parameters ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> calculation_parameters_t new_calculation_parameters4 ( |
627 | CWE-000 static int diag_cmd_set_all_msg_mask ( unsigned char * src_buf , int src_len , unsigned char * dest_buf , int dest_len ) { int i ; int write_len = 0 ; int header_len = sizeof ( struct diag_msg_config_rsp_t ) ; struct diag_msg_config_rsp_t rsp ; struct diag_msg_config_rsp_t * req = NULL ; struct diag_msg_mask_t * mask = ( struct diag_msg_mask_t * ) msg_mask . ptr ; if ( ! src_buf || ! dest_buf || src_len <= 0 || dest_len <= 0 ) { pr_err ( "diag:<S2SV_blank>Invalid<S2SV_blank>input<S2SV_blank>in<S2SV_blank>%s,<S2SV_blank>src_buf:<S2SV_blank>%p,<S2SV_blank>src_len:<S2SV_blank>%d,<S2SV_blank>dest_buf:<S2SV_blank>%p,<S2SV_blank>dest_len:<S2SV_blank>%d" , __func__ , src_buf , src_len , dest_buf , dest_len ) ; return - EINVAL ; } req = ( struct diag_msg_config_rsp_t * ) src_buf ; <S2SV_StartBug> mutex_lock ( & msg_mask . lock ) ; <S2SV_EndBug> msg_mask . status = ( req -> rt_mask ) ? DIAG_CTRL_MASK_ALL_ENABLED : DIAG_CTRL_MASK_ALL_DISABLED ; for ( i = 0 ; i < driver -> msg_mask_tbl_count ; i ++ , mask ++ ) { memset ( mask -> ptr , req -> rt_mask , mask -> range * sizeof ( uint32_t ) ) ; } mutex_unlock ( & msg_mask . lock ) ; <S2SV_StartBug> diag_update_userspace_clients ( MSG_MASKS_TYPE ) ; <S2SV_EndBug> rsp . cmd_code = DIAG_CMD_MSG_CONFIG ; rsp . sub_cmd = DIAG_CMD_OP_SET_ALL_MSG_MASK ; rsp . status = MSG_STATUS_SUCCESS ; rsp . padding = 0 ; rsp . rt_mask = req -> rt_mask ; memcpy ( dest_buf , & rsp , header_len ) ; write_len += header_len ; for ( i = 0 ; i < NUM_SMD_CONTROL_CHANNELS ; i ++ ) { diag_send_msg_mask_update ( & driver -> smd_cntl [ i ] , ALL_SSID , ALL_SSID ) ; } return write_len ; } | <S2SV_ModStart> mutex_lock ( & driver -> msg_mask_lock ) ; mutex_lock ( & <S2SV_ModStart> lock ) ; mutex_unlock ( & driver -> msg_mask_lock ) ; |
628 | CWE-000 struct mbv_surface * avbox_video_glinit ( struct mbv_drv_funcs * const funcs , int width , const int height ) { GLenum err ; <S2SV_StartBug> init_func_table ( funcs ) ; <S2SV_EndBug> glEnable ( GL_TEXTURE_2D ) ; glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ; glViewport ( 0 , 0 , width , height ) ; glMatrixMode ( GL_PROJECTION ) ; glLoadIdentity ( ) ; glOrtho ( 0.0 , width , height , 0.0 , 1.0 , - 1.0 ) ; glMatrixMode ( GL_MODELVIEW ) ; glLoadIdentity ( ) ; glClearColor ( 0.5 , 0.5 , 0.5 , 1.0 ) ; glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ; if ( ( err = glGetError ( ) ) != GL_NO_ERROR ) { LOG_PRINT_ERROR ( "GL<S2SV_blank>setup<S2SV_blank>failed" ) ; return NULL ; } else { DEBUG_PRINT ( LOG_MODULE , "GL<S2SV_blank>Context<S2SV_blank>Initialized" ) ; } if ( ( root_surface = surface_new ( NULL , 0 , 0 , width , height ) ) == NULL ) { LOG_PRINT_ERROR ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>root<S2SV_blank>surface" ) ; } if ( ( root_framebuffer = surface_framebuffer ( root_surface ) ) == 0 ) { LOG_PRINT_ERROR ( "Could<S2SV_blank>not<S2SV_blank>change<S2SV_blank>fbo.<S2SV_blank>Blit<S2SV_blank>failed" ) ; surface_destroy ( root_surface ) ; root_surface = NULL ; } LOG_PRINT_INFO ( "OpenGL<S2SV_blank>Compositor<S2SV_blank>Initialized" ) ; LOG_VPRINT_INFO ( "Vendor:\\t%s" , glGetString ( GL_VENDOR ) ) ; LOG_VPRINT_INFO ( "Renderer:\\t%s" , glGetString ( GL_RENDERER ) ) ; LOG_VPRINT_INFO ( "Version:\\t%s" , glGetString ( GL_VERSION ) ) ; LOG_VPRINT_INFO ( "GLSL:\\t%s" , glGetString ( GL_SHADING_LANGUAGE_VERSION ) ) ; # if 0 char * gl_exts ; LOG_PRINT_INFO ( "Extensions:" ) ; if ( ( gl_exts = strdup ( ( const char * ) glGetString ( GL_EXTENSIONS ) ) ) != NULL ) { char * next , * current = gl_exts ; while ( current != NULL ) { if ( ( next = strstr ( current , "<S2SV_blank>" ) ) != NULL ) { * next ++ = '\\0' ; } LOG_VPRINT_INFO ( "\\t%s" , current ) ; current = next ; } free ( gl_exts ) ; } # endif return root_surface ; } | <S2SV_ModStart> GLenum err ; # ifndef NDEBUG gl_thread = pthread_self ( ) ; # endif |
629 | CWE-000 void init_header ( uint8_t * header , uint8_t type ) { uint32_t curr_ptr ; <S2SV_StartBug> curr_ptr = eeprom_read_dword ( pointer ( type ) ) ; <S2SV_EndBug> mem_write_multibyte ( curr_ptr , header , HEADER_SIZE * FIELD_SIZE ) ; } | <S2SV_ModStart> = eeprom_read_dword ( SCI_CURR_PTR_ADDR <S2SV_ModEnd> ) ; mem_write_multibyte |
630 | CWE-000 void test_api_conversation ( void ) { OTR4_INIT ; otr4_client_state_t * alice_state = otr4_client_state_new ( NULL ) ; otr4_client_state_t * bob_state = otr4_client_state_new ( NULL ) ; uint8_t alice_sym [ ED448_PRIVATE_BYTES ] = { 1 } ; otr4_client_state_add_private_key_v4 ( alice_state , alice_sym ) ; uint8_t bob_sym [ ED448_PRIVATE_BYTES ] = { 2 } ; otr4_client_state_add_private_key_v4 ( bob_state , bob_sym ) ; otrv4_policy_t policy = { . allows = OTRV4_ALLOW_V3 | OTRV4_ALLOW_V4 } ; otrv4_t * alice = otrv4_new ( alice_state , policy ) ; otrv4_assert ( ! alice -> keys -> old_mac_keys ) ; otrv4_t * bob = otrv4_new ( bob_state , policy ) ; otrv4_assert ( ! bob -> keys -> old_mac_keys ) ; do_ake_fixture ( alice , bob ) ; int message_id ; otrv4_response_t * response_to_bob = NULL ; otrv4_response_t * response_to_alice = NULL ; string_t to_send = NULL ; for ( message_id = 2 ; message_id < 5 ; message_id ++ ) { to_send = send_data_msg ( to_send , "hi" , alice , NULL ) ; otrv4_assert ( ! alice -> keys -> old_mac_keys ) ; g_assert_cmpint ( alice -> keys -> i , == , 0 ) ; g_assert_cmpint ( alice -> keys -> j , == , message_id ) ; response_to_alice = otrv4_response_new ( ) ; to_send = rec_data_msg ( response_to_alice , to_send , bob , "hi" ) ; otrv4_assert ( bob -> keys -> old_mac_keys ) ; <S2SV_StartBug> g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , message_id - 1 ) ; <S2SV_EndBug> g_assert_cmpint ( bob -> keys -> i , == , 0 ) ; g_assert_cmpint ( bob -> keys -> j , == , 0 ) ; } for ( message_id = 1 ; message_id < 4 ; message_id ++ ) { to_send = send_data_msg ( to_send , "hello" , bob , NULL ) ; g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , 0 ) ; g_assert_cmpint ( bob -> keys -> i , == , 1 ) ; g_assert_cmpint ( bob -> keys -> j , == , message_id ) ; response_to_bob = otrv4_response_new ( ) ; to_send = rec_data_msg ( response_to_bob , to_send , alice , "hello" ) ; <S2SV_StartBug> g_assert_cmpint ( list_len ( alice -> keys -> old_mac_keys ) , == , message_id ) ; <S2SV_EndBug> g_assert_cmpint ( alice -> keys -> i , == , 1 ) ; g_assert_cmpint ( alice -> keys -> j , == , 0 ) ; } tlv_t * tlvs = otrv4_padding_tlv_new ( 10 ) ; otrv4_assert ( tlvs ) ; to_send = send_data_msg ( to_send , "hi" , bob , tlvs ) ; g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , 0 ) ; otrv4_tlv_free ( tlvs ) ; response_to_bob = otrv4_response_new ( ) ; otrv4_assert ( otrv4_receive_message ( response_to_bob , to_send , alice ) == OTR4_SUCCESS ) ; g_assert_cmpint ( list_len ( alice -> keys -> old_mac_keys ) , == , 4 ) ; free ( to_send ) ; to_send = NULL ; otrv4_assert ( response_to_bob -> tlvs ) ; g_assert_cmpint ( response_to_bob -> tlvs -> type , == , OTRV4_TLV_PADDING ) ; g_assert_cmpint ( response_to_bob -> tlvs -> len , == , 10 ) ; otrv4_response_free ( response_to_bob ) ; response_to_bob = NULL ; otr4_client_state_free ( alice_state ) ; otr4_client_state_free ( bob_state ) ; otrv4_free ( bob ) ; otrv4_free ( alice ) ; OTR4_FREE ; } | <S2SV_ModStart> old_mac_keys ) ; free ( to_send ) ; to_send = NULL ; <S2SV_ModStart> , message_id ) ; free ( to_send ) ; to_send = NULL |
631 | CWE-000 static void test_fmemopen ( void * * state ) { size_t len = strlen ( test_string ) + 1 ; FILE * f = fmemopen ( ( char * ) test_string , len , "r" ) ; fseek ( f , 0 , SEEK_END ) ; long pos = ftell ( f ) ; assert_int_equal ( pos , len ) ; fseek ( f , 0 , SEEK_SET ) ; pos = ftell ( f ) ; assert_int_equal ( pos , 0 ) ; char s [ len ] ; <S2SV_StartBug> ( void ) fread ( s , sizeof ( char ) , len , f ) ; <S2SV_EndBug> assert_int_equal ( 0 , strcmp ( s , test_string ) ) ; rewind ( f ) ; fclose ( f ) ; char s1 [ len ] ; f = fmemopen ( s1 , len , "w" ) ; fwrite ( s , sizeof ( char ) , len , f ) ; fflush ( f ) ; assert_int_equal ( 0 , strcmp ( s , s1 ) ) ; fclose ( f ) ; } | <S2SV_ModStart> len ] ; size_t bytes_read = <S2SV_ModEnd> fread ( s <S2SV_ModStart> len , f ) ; assert_int_equal ( bytes_read , sizeof ( char ) * len |
632 | CWE-000 void simplify_gscc ( ) { GState * s ; GTrans * t ; int i , * * scc_final ; rank = 1 ; scc_stack = 0 ; scc_id = 1 ; if ( gstates == gstates -> nxt ) return ; for ( s = gstates -> nxt ; s != gstates ; s = s -> nxt ) s -> incoming = 0 ; for ( i = 0 ; i < init_size ; i ++ ) <S2SV_StartBug> if ( init [ i ] && init [ i ] -> incoming == 0 ) <S2SV_EndBug> <S2SV_StartBug> gdfs ( init [ i ] ) ; <S2SV_EndBug> scc_final = ( int * * ) tl_emalloc ( scc_id * sizeof ( int * ) ) ; for ( i = 0 ; i < scc_id ; i ++ ) scc_final [ i ] = make_set ( - 1 , 0 ) ; for ( s = gstates -> nxt ; s != gstates ; s = s -> nxt ) if ( s -> incoming == 0 ) s = remove_gstate ( s , 0 ) ; else for ( t = s -> trans -> nxt ; t != s -> trans ; t = t -> nxt ) if ( t -> to -> incoming == s -> incoming ) merge_sets ( scc_final [ s -> incoming ] , t -> final , 0 ) ; scc_size = ( scc_id + 1 ) / ( 8 * sizeof ( int ) ) + 1 ; bad_scc = make_set ( - 1 , 2 ) ; for ( i = 0 ; i < scc_id ; i ++ ) if ( ! included_set ( final_set , scc_final [ i ] , 0 ) ) add_set ( bad_scc , i ) ; for ( i = 0 ; i < scc_id ; i ++ ) tfree ( scc_final [ i ] ) ; tfree ( scc_final ) ; } | <S2SV_ModStart> ) if ( init_state <S2SV_ModEnd> [ i ] <S2SV_ModStart> i ] && init_state <S2SV_ModEnd> [ i ] <S2SV_ModStart> ) gdfs ( init_state <S2SV_ModEnd> [ i ] |
633 | CWE-000 static void remove_sessions_for_connection ( CkManager * manager , const gchar * service_name ) { RemoveLeaderData data ; <S2SV_StartBug> data . service_name = service_name ; <S2SV_EndBug> data . manager = manager ; g_debug ( "Removing<S2SV_blank>sessions<S2SV_blank>for<S2SV_blank>service<S2SV_blank>name:<S2SV_blank>%s" , service_name ) ; <S2SV_StartBug> g_hash_table_foreach_remove ( manager -> priv -> leaders , <S2SV_EndBug> ( GHRFunc ) remove_leader_for_connection , & data ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> RemoveLeaderData data ; guint n <S2SV_ModEnd> ; g_debug ( <S2SV_ModStart> service_name ) ; data . manager = manager ; data . service_name = service_name ; data . entities = g_ptr_array_new_with_free_func ( destroy_entity ) ; n = g_hash_table_foreach_steal <S2SV_ModEnd> ( manager -> <S2SV_ModStart> data ) ; while ( n -- > 0 ) { g_ptr_array_remove_index_fast ( data . entities , 0 ) ; } g_assert ( data . entities -> len == 0 ) ; g_ptr_array_free ( data . entities , TRUE ) ; |
634 | CWE-000 static PgfAbsProduction * pgf_lookup_new_production ( PgfAbsFun * fun , GuPool * pool ) { <S2SV_StartBug> size_t n_hypos = gu_seq_length ( fun -> type -> hypos ) ; <S2SV_EndBug> PgfAbsProduction * prod = gu_new_flex ( pool , PgfAbsProduction , args , n_hypos ) ; prod -> fun = fun ; prod -> count = 0 ; for ( size_t i = 0 ; i < n_hypos ; i ++ ) { prod -> args [ i ] = 0 ; } return prod ; } | <S2SV_ModStart> size_t n_hypos = fun -> type -> hypos ? <S2SV_ModStart> -> hypos ) : 0 |
635 | CWE-000 int PIOc_put_vars_long ( int ncid , int varid , const PIO_Offset * start , const PIO_Offset * count , const PIO_Offset * stride , const long * op ) { <S2SV_StartBug> return PIOc_put_vars_tc ( ncid , varid , start , count , stride , NC_INT , op ) ; <S2SV_EndBug> } | <S2SV_ModStart> , stride , PIO_LONG_INTERNAL <S2SV_ModEnd> , op ) |
636 | CWE-000 ssize_t ne_write ( ne_handle handle , const void * buffer , size_t nbytes ) { int N ; int E ; unsigned int bsz ; int counter ; int ecounter ; ssize_t ret_out ; unsigned long long totsize ; int mtot ; u32 readsize ; u32 writesize ; u32 crc ; TimingData * timing = handle -> timing_data_ptr ; if ( nbytes > UINT_MAX ) { PRINTerr ( "ne_write:<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>validated<S2SV_blank>for<S2SV_blank>write-sizes<S2SV_blank>above<S2SV_blank>%lu\\n" , UINT_MAX ) ; errno = EFBIG ; return - 1 ; } if ( handle -> mode != NE_WRONLY && handle -> mode != NE_REBUILD ) { PRINTerr ( "ne_write:<S2SV_blank>handle<S2SV_blank>is<S2SV_blank>in<S2SV_blank>improper<S2SV_blank>mode<S2SV_blank>for<S2SV_blank>writing!<S2SV_blank>%d\\n" , handle -> mode ) ; errno = EPERM ; return - 1 ; } N = handle -> erasure_state -> N ; E = handle -> erasure_state -> E ; bsz = handle -> erasure_state -> bsz ; <S2SV_StartBug> mtot = N + E ; <S2SV_EndBug> int nerr = 0 ; totsize = 0 ; while ( 1 ) { counter = handle -> buff_rem / bsz ; while ( counter < N ) { writesize = ( handle -> buff_rem % bsz ) ; readsize = bsz - writesize ; if ( totsize + readsize > nbytes ) { readsize = nbytes - totsize ; } if ( readsize < 1 ) { PRINTdbg ( "ne_write:<S2SV_blank>reading<S2SV_blank>of<S2SV_blank>input<S2SV_blank>is<S2SV_blank>now<S2SV_blank>complete\\n" ) ; break ; } PRINTdbg ( "ne_write:<S2SV_blank>reading<S2SV_blank>input<S2SV_blank>for<S2SV_blank>%lu<S2SV_blank>bytes<S2SV_blank>with<S2SV_blank>offset<S2SV_blank>of<S2SV_blank>%llu<S2SV_blank>" "and<S2SV_blank>writing<S2SV_blank>to<S2SV_blank>offset<S2SV_blank>of<S2SV_blank>%lu<S2SV_blank>in<S2SV_blank>handle<S2SV_blank>buffer\\n" , ( unsigned long ) readsize , totsize , handle -> buff_rem ) ; int queue_result = bq_enqueue ( & handle -> blocks [ counter ] , buffer + totsize , readsize ) ; if ( queue_result == - 1 ) { return - 1 ; } PRINTdbg ( "ne_write:<S2SV_blank><S2SV_blank><S2SV_blank>...copy<S2SV_blank>complete.\\n" ) ; totsize += readsize ; writesize = readsize + ( handle -> buff_rem % bsz ) ; handle -> buff_rem += readsize ; if ( writesize < bsz ) { PRINTdbg ( "ne_write:<S2SV_blank>reading<S2SV_blank>of<S2SV_blank>input<S2SV_blank>is<S2SV_blank>complete,<S2SV_blank>stashed<S2SV_blank>%lu<S2SV_blank>bytes<S2SV_blank>in<S2SV_blank>handle<S2SV_blank>buffer\\n" , ( unsigned long ) readsize ) ; break ; } counter ++ ; } if ( counter != N ) { break ; } if ( timing -> flags & TF_ERASURE ) fast_timer_start ( & timing -> erasure ) ; if ( handle -> e_ready == 0 ) { PRINTdbg ( "ne_write:<S2SV_blank>initializing<S2SV_blank>erasure<S2SV_blank>matricies...\\n" ) ; gf_gen_rs_matrix ( handle -> encode_matrix , mtot , N ) ; ec_init_tables ( N , E , & ( handle -> encode_matrix [ N * N ] ) , handle -> g_tbls ) ; handle -> e_ready = 1 ; } int i ; int buffer_index ; for ( i = N ; i < handle -> erasure_state -> N + handle -> erasure_state -> E ; i ++ ) { BufferQueue * bq = & handle -> blocks [ i ] ; if ( pthread_mutex_lock ( & bq -> qlock ) != 0 ) { PRINTerr ( "Failed<S2SV_blank>to<S2SV_blank>acquire<S2SV_blank>lock<S2SV_blank>for<S2SV_blank>erasure<S2SV_blank>blocks\\n" ) ; return - 1 ; } while ( bq -> qdepth == MAX_QDEPTH ) { pthread_cond_wait ( & bq -> master_resume , & bq -> qlock ) ; } if ( i == N ) { buffer_index = bq -> tail ; } else { assert ( buffer_index == bq -> tail ) ; } } PRINTdbg ( "ne_write:<S2SV_blank>calculating<S2SV_blank>%d<S2SV_blank>erasure<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>data<S2SV_blank>blocks<S2SV_blank>at<S2SV_blank>queue<S2SV_blank>position<S2SV_blank>%d\\n" , E , N , buffer_index ) ; handle -> erasure_state -> nsz += bsz ; ec_encode_data ( bsz , N , E , handle -> g_tbls , ( unsigned char * * ) handle -> block_buffs [ buffer_index ] , ( unsigned char * * ) & ( handle -> block_buffs [ buffer_index ] [ N ] ) ) ; if ( timing -> flags & TF_ERASURE ) { fast_timer_stop ( & timing -> erasure ) ; log_histo_add_interval ( & timing -> erasure_h , & timing -> erasure ) ; } <S2SV_StartBug> nerr = 0 ; <S2SV_EndBug> for ( i = N ; i < handle -> erasure_state -> N + handle -> erasure_state -> E ; i ++ ) { <S2SV_StartBug> if ( handle -> erasure_state -> manifest_status [ i ] || handle -> erasure_state -> data_status [ i ] ) <S2SV_EndBug> nerr ++ ; BufferQueue * bq = & handle -> blocks [ i ] ; bq -> qdepth ++ ; bq -> tail = ( bq -> tail + 1 ) % MAX_QDEPTH ; pthread_cond_signal ( & bq -> thread_resume ) ; pthread_mutex_unlock ( & bq -> qlock ) ; } handle -> buff_rem = 0 ; } handle -> erasure_state -> totsz += totsize ; <S2SV_StartBug> if ( UNSAFE ( handle , nerr ) ) { <S2SV_EndBug> PRINTerr ( "ne_write:<S2SV_blank>errors<S2SV_blank>exceed<S2SV_blank>minimum<S2SV_blank>protection<S2SV_blank>level<S2SV_blank>(%d)\\n" , MIN_PROTECTION ) ; errno = EIO ; return - 1 ; } else { return totsize ; } } | <S2SV_ModStart> N + E <S2SV_ModEnd> ; totsize = <S2SV_ModStart> ) ; } <S2SV_ModEnd> for ( i <S2SV_ModStart> ++ ) { <S2SV_ModEnd> BufferQueue * bq <S2SV_ModStart> += totsize ; int nerr = 0 ; for ( counter = 0 ; counter < N + E ; counter ++ ) { if ( handle -> erasure_state -> manifest_status [ counter ] || handle -> erasure_state -> data_status [ counter ] ) nerr ++ ; } |
637 | CWE-000 VAMessageCallback vaSetInfoCallback ( VADisplay dpy , VAMessageCallback callback , void * user_context ) { VADisplayContextP dctx ; VAMessageCallback old_callback ; if ( ! vaDisplayIsValid ( dpy ) ) return NULL ; dctx = ( VADisplayContextP ) dpy ; <S2SV_StartBug> old_callback = dctx -> error_callback ; <S2SV_EndBug> dctx -> info_callback = callback ; dctx -> info_callback_user_context = user_context ; return old_callback ; } | <S2SV_ModStart> = dctx -> info_callback <S2SV_ModEnd> ; dctx -> |
638 | CWE-000 void save_rest_processor_state ( void ) { <S2SV_StartBug> vcpu_save_fpu ( current ) ; <S2SV_EndBug> asm volatile ( "movw<S2SV_blank>%%ds,(%0);<S2SV_blank>movw<S2SV_blank>%%es,2(%0);<S2SV_blank>movw<S2SV_blank>%%fs,4(%0);<S2SV_blank>movw<S2SV_blank>%%gs,6(%0)" : : "r" ( saved_segs ) : "memory" ) ; saved_fs_base = rdfsbase ( ) ; saved_gs_base = rdgsbase ( ) ; rdmsrl ( MSR_SHADOW_GS_BASE , saved_kernel_gs_base ) ; rdmsrl ( MSR_CSTAR , saved_cstar ) ; rdmsrl ( MSR_LSTAR , saved_lstar ) ; if ( boot_cpu_data . x86_vendor == X86_VENDOR_INTEL || boot_cpu_data . x86_vendor == X86_VENDOR_CENTAUR ) { rdmsrl ( MSR_IA32_SYSENTER_ESP , saved_sysenter_esp ) ; rdmsrl ( MSR_IA32_SYSENTER_EIP , saved_sysenter_eip ) ; } if ( cpu_has_xsave ) saved_xcr0 = get_xcr0 ( ) ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> saved_fs_base = rdfsbase |
639 | CWE-000 int get_first_day_over_thres_from_middle ( double * values , double thres , int N , double NoData , DATE_STRUCT firstdate ) { <S2SV_StartBug> int index ; <S2SV_EndBug> for ( index = N / 2 ; index < N ; index ++ ) { if ( values [ index ] != NoData ) if ( values [ index ] > thres ) break ; <S2SV_StartBug> firstdate = get_next_day ( firstdate ) ; <S2SV_EndBug> } if ( index == N ) return ( ( int ) NoData ) ; <S2SV_StartBug> else return ( calc_doy ( firstdate ) ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { int index , idx <S2SV_ModStart> ) break ; <S2SV_ModEnd> } if ( <S2SV_ModStart> ) ; else { for ( idx = 0 ; idx < index ; idx ++ ) firstdate = get_next_day ( firstdate ) ; <S2SV_ModStart> ) ; } } |
640 | CWE-000 int ntfs_close_r ( struct _reent * r , int fd ) { <S2SV_StartBug> ntfs_log_trace ( "fd<S2SV_blank>%p\\n" , fd ) ; <S2SV_EndBug> ntfs_file_state * file = STATE ( fd ) ; if ( ! file || ! file -> vd ) { r -> _errno = EBADF ; return - 1 ; } ntfsLock ( file -> vd ) ; ntfsCloseFile ( file ) ; file -> vd -> openFileCount -- ; if ( file -> nextOpenFile ) file -> nextOpenFile -> prevOpenFile = file -> prevOpenFile ; if ( file -> prevOpenFile ) file -> prevOpenFile -> nextOpenFile = file -> nextOpenFile ; else file -> vd -> firstOpenFile = file -> nextOpenFile ; ntfsUnlock ( file -> vd ) ; return 0 ; } | <S2SV_ModStart> ( "fd<S2SV_blank>%p\\n" , ( void * ) |
641 | CWE-000 static gboolean add_dbus_proxy_args ( GPtrArray * argv_array , GPtrArray * session_dbus_proxy_argv , gboolean enable_session_logging , GPtrArray * system_dbus_proxy_argv , gboolean enable_system_logging , GPtrArray * a11y_dbus_proxy_argv , gboolean enable_a11y_logging , int sync_fds [ 2 ] , const char * app_info_path , GError * * error ) { char x = 'x' ; const char * proxy ; g_autofree char * commandline = NULL ; DbusProxySpawnData spawn_data ; glnx_autofd int app_info_fd = - 1 ; glnx_autofd int bwrap_args_fd = - 1 ; g_autoptr ( GPtrArray ) dbus_proxy_argv = NULL ; if ( ! has_args ( session_dbus_proxy_argv ) && ! has_args ( system_dbus_proxy_argv ) && ! has_args ( a11y_dbus_proxy_argv ) ) return TRUE ; if ( sync_fds [ 0 ] == - 1 ) { <S2SV_StartBug> if ( pipe ( sync_fds ) < 0 ) <S2SV_EndBug> { g_set_error_literal ( error , G_IO_ERROR , g_io_error_from_errno ( errno ) , _ ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>sync<S2SV_blank>pipe" ) ) ; return FALSE ; } add_args_data_fd ( argv_array , NULL , "--sync-fd" , sync_fds [ 0 ] , NULL ) ; } proxy = g_getenv ( "FLATPAK_DBUSPROXY" ) ; if ( proxy == NULL ) proxy = DBUSPROXY ; dbus_proxy_argv = g_ptr_array_new_with_free_func ( g_free ) ; g_ptr_array_add ( dbus_proxy_argv , g_strdup ( proxy ) ) ; g_ptr_array_add ( dbus_proxy_argv , g_strdup_printf ( "--fd=%d" , sync_fds [ 1 ] ) ) ; append_proxy_args ( dbus_proxy_argv , session_dbus_proxy_argv , enable_session_logging ) ; append_proxy_args ( dbus_proxy_argv , system_dbus_proxy_argv , enable_system_logging ) ; append_proxy_args ( dbus_proxy_argv , a11y_dbus_proxy_argv , enable_a11y_logging ) ; g_ptr_array_add ( dbus_proxy_argv , NULL ) ; app_info_fd = open ( app_info_path , O_RDONLY ) ; if ( app_info_fd == - 1 ) { int errsv = errno ; g_set_error ( error , G_IO_ERROR , g_io_error_from_errno ( errsv ) , _ ( "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>app<S2SV_blank>info<S2SV_blank>file:<S2SV_blank>%s" ) , g_strerror ( errsv ) ) ; return FALSE ; } if ( ! prepend_bwrap_argv_wrapper ( dbus_proxy_argv , app_info_fd , & bwrap_args_fd , error ) ) return FALSE ; commandline = flatpak_quote_argv ( ( const char * * ) dbus_proxy_argv -> pdata ) ; flatpak_debug2 ( "Running<S2SV_blank>\'%s\'" , commandline ) ; spawn_data . sync_fd = sync_fds [ 1 ] ; spawn_data . app_info_fd = app_info_fd ; spawn_data . bwrap_args_fd = bwrap_args_fd ; if ( ! g_spawn_async ( NULL , ( char * * ) dbus_proxy_argv -> pdata , NULL , G_SPAWN_SEARCH_PATH , dbus_spawn_child_setup , & spawn_data , NULL , error ) ) { close ( sync_fds [ 0 ] ) ; close ( sync_fds [ 1 ] ) ; return FALSE ; } if ( read ( sync_fds [ 0 ] , & x , 1 ) != 1 ) { g_set_error_literal ( error , G_IO_ERROR , g_io_error_from_errno ( errno ) , _ ( "Failed<S2SV_blank>to<S2SV_blank>sync<S2SV_blank>with<S2SV_blank>dbus<S2SV_blank>proxy" ) ) ; close ( sync_fds [ 0 ] ) ; close ( sync_fds [ 1 ] ) ; return FALSE ; } return TRUE ; } | <S2SV_ModStart> 1 ) { access ( "sync_fds" , 0 ) ; |
642 | CWE-000 static int rankCompare ( const void * a , const void * b ) { <S2SV_StartBug> return * ( ( int * ) a ) - * ( ( int * ) b ) ; <S2SV_EndBug> } | <S2SV_ModStart> * ( ( const <S2SV_ModStart> * ( ( const |
643 | CWE-000 static int ricci_proj2 ( Projectile * p , int t ) { TIMER ( & t ) ; AT ( EVENT_BIRTH ) { play_sound ( "shot3" ) ; } AT ( EVENT_DEATH ) { Enemy * e = ( Enemy * ) REF ( p -> args [ 1 ] ) ; if ( ! e ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } play_sound ( "shot_special1" ) ; double rad = SAFE_RADIUS_MAX * ( 0.6 - 0.2 * ( double ) ( D_Lunatic - global . diff ) / 3 ) ; create_laser ( p -> pos , 12 , 60 , rgb ( 0.2 , 1 , 0.5 ) , las_circle , ricci_laser_logic , 6 * M_PI + 0 * I , rad , add_ref ( e ) , p -> pos - e -> pos ) ; create_laser ( p -> pos , 12 , 60 , rgb ( 0.2 , 0.4 , 1 ) , las_circle , ricci_laser_logic , 6 * M_PI + 30 * I , rad , add_ref ( e ) , p -> pos - e -> pos ) ; create_laser ( p -> pos , 1 , 60 , rgb ( 1.0 , 0.0 , 0 ) , las_circle , ricci_laser_logic , - 6 * M_PI + 0 * I , rad , add_ref ( e ) , p -> pos - e -> pos ) -> width = 10 ; create_laser ( p -> pos , 1 , 60 , rgb ( 1.0 , 0.0 , 0 ) , las_circle , ricci_laser_logic , - 6 * M_PI + 30 * I , rad , add_ref ( e ) , p -> pos - e -> pos ) -> width = 10 ; free_ref ( p -> args [ 1 ] ) ; return ACTION_ACK ; } if ( t < 0 ) { return ACTION_ACK ; } Enemy * e = ( Enemy * ) REF ( p -> args [ 1 ] ) ; if ( ! e ) { return ACTION_DESTROY ; } p -> pos = e -> pos + p -> pos0 ; if ( t > 30 ) return ACTION_DESTROY ; return ACTION_NONE ; } | <S2SV_ModStart> ) { return ACTION_ACK <S2SV_ModEnd> ; } play_sound |
644 | CWE-000 struct obj * oname ( obj , name ) struct obj * obj ; const char * name ; { int lth ; char buf [ PL_PSIZ ] ; lth = * name ? ( int ) ( strlen ( name ) + 1 ) : 0 ; if ( lth > PL_PSIZ ) { lth = PL_PSIZ ; name = strncpy ( buf , name , PL_PSIZ - 1 ) ; buf [ PL_PSIZ - 1 ] = '\\0' ; } if ( obj -> oartifact || ( lth && exist_artifact ( obj -> otyp , name ) ) ) return obj ; new_oname ( obj , lth ) ; if ( lth ) Strcpy ( ONAME ( obj ) , name ) ; if ( lth ) artifact_exists ( obj , name , TRUE ) ; if ( obj -> oartifact ) { if ( obj == uswapwep ) untwoweapon ( ) ; if ( obj == uwep ) set_artifact_intrinsic ( obj , TRUE , W_WEP ) ; if ( obj -> unpaid ) <S2SV_StartBug> alter_cost ( obj , 0L ) ; <S2SV_EndBug> u . uconduct . literate ++ ; } <S2SV_StartBug> if ( carried ( obj ) ) <S2SV_EndBug> update_inventory ( ) ; return obj ; } | <S2SV_ModStart> 0L ) ; if ( via_naming ) { <S2SV_ModStart> ++ ; } } |
645 | CWE-000 bool isPermPalin ( char * str ) { int i = 0 ; int countArr [ 256 ] = { 0 } ; bool flag = true ; while ( * str ) { <S2SV_StartBug> countArr [ * str ] ++ ; <S2SV_EndBug> str ++ ; } for ( i = 0 ; i < 256 ; i ++ ) { if ( countArr [ i ] % 2 != 0 ) { if ( ! flag ) return flag ; <S2SV_StartBug> if ( flag ) { <S2SV_EndBug> flag = false ; <S2SV_StartBug> } <S2SV_EndBug> } } return true ; } | <S2SV_ModStart> str ) { if ( ! isspace ( * str ) ) { <S2SV_ModStart> ] ++ ; } <S2SV_ModStart> return flag ; else <S2SV_ModEnd> flag = false <S2SV_ModStart> = false ; <S2SV_ModEnd> } } return |
646 | CWE-000 int app_generate_fix ( const struct oscap_action * action ) { struct xccdf_session * session = NULL ; struct ds_rds_session * arf_session = NULL ; if ( ! oscap_set_verbose ( action -> verbosity_level , action -> f_verbose_log , false ) ) { return OSCAP_ERROR ; } int ret = OSCAP_ERROR ; struct oscap_source * source = oscap_source_new_from_file ( action -> f_xccdf ) ; oscap_document_type_t document_type = oscap_source_get_scap_type ( source ) ; if ( document_type == OSCAP_DOCUMENT_ARF ) { arf_session = ds_rds_session_new_from_source ( source ) ; if ( arf_session == NULL ) { goto cleanup ; } struct oscap_source * report_source = ds_rds_session_select_report ( arf_session , NULL ) ; if ( report_source == NULL ) { goto cleanup ; } struct oscap_source * report_request_source = ds_rds_session_select_report_request ( arf_session , NULL ) ; if ( report_request_source == NULL ) { goto cleanup ; } session = xccdf_session_new_from_source ( oscap_source_clone ( report_request_source ) ) ; if ( action -> id != NULL ) { if ( xccdf_session_add_report_from_source ( session , oscap_source_clone ( report_source ) ) ) { goto cleanup ; } } oscap_source_free ( source ) ; } else { session = xccdf_session_new_from_source ( source ) ; } if ( session == NULL ) goto cleanup ; xccdf_session_set_validation ( session , action -> validate , getenv ( "OSCAP_FULL_VALIDATION" ) != NULL ) ; xccdf_session_set_user_cpe ( session , action -> cpe ) ; xccdf_session_set_remote_resources ( session , action -> remote_resources , download_reporting_callback ) ; xccdf_session_set_custom_oval_files ( session , action -> f_ovals ) ; xccdf_session_set_user_tailoring_file ( session , action -> tailoring_file ) ; xccdf_session_set_user_tailoring_cid ( session , action -> tailoring_id ) ; if ( xccdf_session_is_sds ( session ) ) { xccdf_session_set_component_id ( session , action -> f_xccdf_id ) ; xccdf_session_set_benchmark_id ( session , action -> f_benchmark_id ) ; } if ( xccdf_session_load ( session ) != 0 ) goto cleanup ; int output_fd = STDOUT_FILENO ; if ( action -> f_results != NULL ) { if ( ( output_fd = open ( action -> f_results , O_CREAT | O_TRUNC | O_NOFOLLOW | O_WRONLY , 0700 ) ) < 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>%s:<S2SV_blank>%s" , action -> f_results , strerror ( errno ) ) ; goto cleanup ; } } <S2SV_StartBug> if ( action -> id != NULL ) { <S2SV_EndBug> if ( xccdf_session_build_policy_from_testresult ( session , action -> id ) != 0 ) goto cleanup2 ; struct xccdf_policy * policy = xccdf_session_get_xccdf_policy ( session ) ; struct xccdf_result * result = xccdf_policy_get_result_by_id ( policy , xccdf_session_get_result_id ( session ) ) ; <S2SV_StartBug> if ( xccdf_policy_generate_fix ( policy , result , action -> tmpl , output_fd ) == 0 ) <S2SV_EndBug> ret = OSCAP_OK ; } else { if ( ! xccdf_session_set_profile_id ( session , action -> profile ) ) { if ( action -> profile != NULL ) { const int suffix_match_result = xccdf_session_set_profile_id_by_suffix ( session , action -> profile ) ; if ( suffix_match_result == 1 ) { report_missing_profile ( action ) ; goto cleanup2 ; } else if ( suffix_match_result == 2 ) { report_multiple_profile_matches ( action ) ; goto cleanup2 ; } } else { fprintf ( stderr , "No<S2SV_blank>Policy<S2SV_blank>was<S2SV_blank>found<S2SV_blank>for<S2SV_blank>default<S2SV_blank>profile.\\n" ) ; goto cleanup2 ; } } struct xccdf_policy * policy = xccdf_session_get_xccdf_policy ( session ) ; <S2SV_StartBug> if ( xccdf_policy_generate_fix ( policy , NULL , action -> tmpl , output_fd ) == 0 ) <S2SV_EndBug> ret = OSCAP_OK ; } cleanup2 : if ( output_fd != STDOUT_FILENO ) close ( output_fd ) ; cleanup : ds_rds_session_free ( arf_session ) ; xccdf_session_free ( session ) ; oscap_print_error ( ) ; return ret ; } | <S2SV_ModStart> ; } } const char * template = action -> tmpl == NULL ? "urn:xccdf:fix:script:sh" : action -> tmpl ; <S2SV_ModStart> , result , template <S2SV_ModEnd> , output_fd ) <S2SV_ModStart> , NULL , template <S2SV_ModEnd> , output_fd ) |
647 | CWE-000 void output_workers ( char * filename ) { worker_ptr scan = all_workers ; char * path = cut_pos ( filename ) ; u1_int pl = ( PATH ) ? strlen ( PATH ) : 0u ; worker_flag = 1 ; javab_out ( 2 , "<S2SV_blank>++<S2SV_blank>workers<S2SV_blank>placed<S2SV_blank>in<S2SV_blank>%s*.class" , ( pl ) ? path : "" ) ; for ( ; scan ; scan = scan -> next ) { char * simple = cut_pre ( scan -> qualified_name ) ; u2_int len = 11u + strlen ( simple ) ; char * filen = ( char * ) make_mem ( len * sizeof ( char ) ) ; FILE * newfile = NULL ; sprintf ( filen , "/tmp/%s.class" , simple ) ; if ( num_workers == 0 ) <S2SV_StartBug> worker_array = ( char * * ) malloc ( 500 ) ; <S2SV_EndBug> worker_array [ num_workers ] = ( char * ) make_mem ( len * sizeof ( char ) ) ; strcpy ( worker_array [ num_workers ] , filen ) ; num_workers ++ ; javab_out ( 2 , "<S2SV_blank><S2SV_blank>+<S2SV_blank>worker<S2SV_blank>`%s\'<S2SV_blank>(simple<S2SV_blank>`%s\')" , scan -> qualified_name , simple ) ; newfile = fopen ( filen , "w" ) ; if ( newfile ) { worker_dump ( newfile , scan ) ; fclose ( newfile ) ; } else javab_out ( 0 , "cannot<S2SV_blank>open<S2SV_blank>%s" , filen ) ; if ( filen ) free ( filen ) ; } if ( path ) free ( path ) ; del_workers ( ) ; worker_flag = 0 ; } | <S2SV_ModStart> ) malloc ( 2000 <S2SV_ModEnd> ) ; worker_array |
648 | CWE-000 static int usb_serial_device_probe ( struct device * dev ) { struct usb_serial_driver * driver ; struct usb_serial_port * port ; int retval = 0 ; int minor ; port = to_usb_serial_port ( dev ) ; if ( ! port ) { retval = - ENODEV ; goto exit ; } retval = usb_autopm_get_interface ( port -> serial -> interface ) ; if ( retval ) goto exit ; driver = port -> serial -> type ; if ( driver -> port_probe ) { retval = driver -> port_probe ( port ) ; if ( retval ) goto exit_with_autopm ; } retval = device_create_file ( dev , & dev_attr_port_number ) ; if ( retval ) { if ( driver -> port_remove ) <S2SV_StartBug> retval = driver -> port_remove ( port ) ; <S2SV_EndBug> goto exit_with_autopm ; } minor = port -> number ; tty_register_device ( usb_serial_tty_driver , minor , dev ) ; dev_info ( & port -> serial -> dev -> dev , "%s<S2SV_blank>converter<S2SV_blank>now<S2SV_blank>attached<S2SV_blank>to<S2SV_blank>ttyUSB%d\\n" , driver -> description , minor ) ; exit_with_autopm : usb_autopm_put_interface ( port -> serial -> interface ) ; exit : return retval ; } | <S2SV_ModStart> -> port_remove ) <S2SV_ModEnd> driver -> port_remove |
649 | CWE-000 void intel_enable_gt_powersave ( struct drm_i915_private * dev_priv ) { if ( intel_vgpu_active ( dev_priv ) ) return ; <S2SV_StartBug> mutex_lock ( & dev_priv -> pcu_lock ) ; <S2SV_EndBug> intel_enable_rc6 ( dev_priv ) ; intel_enable_rps ( dev_priv ) ; if ( HAS_LLC ( dev_priv ) ) intel_enable_llc_pstate ( dev_priv ) ; mutex_unlock ( & dev_priv -> pcu_lock ) ; } | <S2SV_ModStart> pcu_lock ) ; if ( HAS_RC6 ( dev_priv ) ) |
650 | CWE-000 static void delete_bucket_callback ( uv_work_t * work_req , int status ) { assert ( status == 0 ) ; json_request_t * req = work_req -> data ; <S2SV_StartBug> if ( req -> status_code == 200 ) { <S2SV_EndBug> printf ( "Bucket<S2SV_blank>was<S2SV_blank>successfully<S2SV_blank>removed<S2SV_blank>destroyed.\\n" ) ; } else { <S2SV_StartBug> printf ( "Failed<S2SV_blank>to<S2SV_blank>destroy<S2SV_blank>bucket.\\n" ) ; <S2SV_EndBug> } free ( req ) ; free ( work_req ) ; } | <S2SV_ModStart> status_code == 200 || req -> status_code == 204 <S2SV_ModStart> { printf ( "Failed<S2SV_blank>to<S2SV_blank>destroy<S2SV_blank>bucket.<S2SV_blank>(%i)\\n" , req -> status_code <S2SV_ModEnd> ) ; } |
651 | CWE-000 int hlua_server_check_enable ( lua_State * L ) { struct server * sv ; sv = hlua_check_server ( L , 1 ) ; if ( sv -> check . state & CHK_ST_CONFIGURED ) { <S2SV_StartBug> sv -> check . state &= ~ CHK_ST_ENABLED ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> check . state |= <S2SV_ModEnd> CHK_ST_ENABLED ; } |
652 | CWE-000 void unmap_page_range ( struct mmu_gather * tlb , struct vm_area_struct * vma , unsigned long addr , unsigned long end , struct zap_details * details ) { pgd_t * pgd ; unsigned long next ; <S2SV_StartBug> BUG_ON ( addr >= end ) ; <S2SV_EndBug> tlb_start_vma ( tlb , vma ) ; pgd = pgd_offset ( vma -> vm_mm , addr ) ; do { next = pgd_addr_end ( addr , end ) ; if ( pgd_none_or_clear_bad ( pgd ) ) continue ; next = zap_pud_range ( tlb , vma , pgd , addr , next , details ) ; } while ( pgd ++ , addr = next , addr != end ) ; tlb_end_vma ( tlb , vma ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> addr >= end ) ; vm_write_begin ( vma <S2SV_ModStart> vma ) ; vm_write_end ( vma ) ; |
653 | CWE-000 static int wlan_hdd_execute_remain_on_channel ( hdd_adapter_t * pAdapter , hdd_remain_on_chan_ctx_t * pRemainChanCtx ) { hdd_cfg80211_state_t * cfgState = WLAN_HDD_GET_CFG_STATE_PTR ( pAdapter ) ; VOS_STATUS vos_status = VOS_STATUS_E_FAILURE ; hdd_context_t * pHddCtx = WLAN_HDD_GET_CTX ( pAdapter ) ; hdd_adapter_list_node_t * pAdapterNode = NULL , * pNext = NULL ; hdd_adapter_t * pAdapter_temp ; VOS_STATUS status ; v_BOOL_t isGoPresent = VOS_FALSE ; unsigned int duration ; mutex_lock ( & cfgState -> remain_on_chan_ctx_lock ) ; if ( pAdapter -> is_roc_inprogress == TRUE ) { mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "remain<S2SV_blank>on<S2SV_blank>channel<S2SV_blank>request<S2SV_blank>is<S2SV_blank>in<S2SV_blank>execution" ) ) ; return - EBUSY ; } cfgState -> remain_on_chan_ctx = pRemainChanCtx ; cfgState -> current_freq = pRemainChanCtx -> chan . center_freq ; pAdapter -> is_roc_inprogress = TRUE ; mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; vos_status = vos_timer_init ( & pRemainChanCtx -> hdd_remain_on_chan_timer , VOS_TIMER_TYPE_SW , wlan_hdd_remain_on_chan_timeout , pAdapter ) ; if ( vos_status != VOS_STATUS_SUCCESS ) { hddLog ( VOS_TRACE_LEVEL_ERROR , FL ( "Not<S2SV_blank>able<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>remain_on_chan<S2SV_blank>timer" ) ) ; mutex_lock ( & cfgState -> remain_on_chan_ctx_lock ) ; cfgState -> remain_on_chan_ctx = NULL ; pAdapter -> is_roc_inprogress = FALSE ; mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; vos_mem_free ( pRemainChanCtx ) ; return - EINVAL ; } status = hdd_get_front_adapter ( pHddCtx , & pAdapterNode ) ; while ( NULL != pAdapterNode && VOS_STATUS_SUCCESS == status ) { pAdapter_temp = pAdapterNode -> pAdapter ; if ( pAdapter_temp -> device_mode == WLAN_HDD_P2P_GO ) { isGoPresent = VOS_TRUE ; } status = hdd_get_next_adapter ( pHddCtx , pAdapterNode , & pNext ) ; pAdapterNode = pNext ; } duration = pRemainChanCtx -> duration ; if ( isGoPresent == VOS_TRUE ) duration = P2P_ROC_DURATION_MULTIPLIER_GO_PRESENT * duration ; else duration = P2P_ROC_DURATION_MULTIPLIER_GO_ABSENT * duration ; hdd_prevent_suspend ( WIFI_POWER_EVENT_WAKELOCK_ROC ) ; INIT_COMPLETION ( pAdapter -> rem_on_chan_ready_event ) ; if ( ( WLAN_HDD_INFRA_STATION == pAdapter -> device_mode ) || ( WLAN_HDD_P2P_CLIENT == pAdapter -> device_mode ) || ( WLAN_HDD_P2P_DEVICE == pAdapter -> device_mode ) ) { tANI_U8 sessionId = pAdapter -> sessionId ; if ( eHAL_STATUS_SUCCESS != sme_RemainOnChannel ( WLAN_HDD_GET_HAL_CTX ( pAdapter ) , sessionId , pRemainChanCtx -> chan . hw_value , duration , wlan_hdd_remain_on_channel_callback , pAdapter , ( tANI_U8 ) ( pRemainChanCtx -> rem_on_chan_request == REMAIN_ON_CHANNEL_REQUEST ) ? TRUE : FALSE ) ) { hddLog ( LOGE , FL ( "sme_RemainOnChannel<S2SV_blank>returned<S2SV_blank>failure" ) ) ; mutex_lock ( & cfgState -> remain_on_chan_ctx_lock ) ; cfgState -> remain_on_chan_ctx = NULL ; pAdapter -> is_roc_inprogress = FALSE ; mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; vos_mem_free ( pRemainChanCtx ) ; hdd_allow_suspend ( WIFI_POWER_EVENT_WAKELOCK_ROC ) ; return - EINVAL ; } <S2SV_StartBug> if ( REMAIN_ON_CHANNEL_REQUEST == pRemainChanCtx -> rem_on_chan_request ) { <S2SV_EndBug> if ( eHAL_STATUS_SUCCESS != sme_RegisterMgmtFrame ( WLAN_HDD_GET_HAL_CTX ( pAdapter ) , sessionId , ( SIR_MAC_MGMT_FRAME << 2 ) | ( SIR_MAC_MGMT_PROBE_REQ << 4 ) , NULL , 0 ) ) hddLog ( LOGE , FL ( "sme_RegisterMgmtFrame<S2SV_blank>returned<S2SV_blank>failure" ) ) ; <S2SV_StartBug> } <S2SV_EndBug> } else if ( ( WLAN_HDD_SOFTAP == pAdapter -> device_mode ) || ( WLAN_HDD_P2P_GO == pAdapter -> device_mode ) ) { if ( VOS_STATUS_SUCCESS != WLANSAP_RemainOnChannel ( # ifdef WLAN_FEATURE_MBSSID WLAN_HDD_GET_SAP_CTX_PTR ( pAdapter ) , # else ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> pvosContext , # endif pRemainChanCtx -> chan . hw_value , duration , wlan_hdd_remain_on_channel_callback , pAdapter ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>WLANSAP_RemainOnChannel<S2SV_blank>returned<S2SV_blank>fail" , __func__ ) ; mutex_lock ( & cfgState -> remain_on_chan_ctx_lock ) ; cfgState -> remain_on_chan_ctx = NULL ; pAdapter -> is_roc_inprogress = FALSE ; mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; vos_mem_free ( pRemainChanCtx ) ; hdd_allow_suspend ( WIFI_POWER_EVENT_WAKELOCK_ROC ) ; return - EINVAL ; } if ( VOS_STATUS_SUCCESS != WLANSAP_RegisterMgmtFrame ( # ifdef WLAN_FEATURE_MBSSID WLAN_HDD_GET_SAP_CTX_PTR ( pAdapter ) , # else ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> pvosContext , # endif ( SIR_MAC_MGMT_FRAME << 2 ) | ( SIR_MAC_MGMT_PROBE_REQ << 4 ) , NULL , 0 ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>WLANSAP_RegisterMgmtFrame<S2SV_blank>returned<S2SV_blank>fail" , __func__ ) ; WLANSAP_CancelRemainOnChannel ( # ifdef WLAN_FEATURE_MBSSID WLAN_HDD_GET_SAP_CTX_PTR ( pAdapter ) ) ; # else ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> pvosContext ) ; # endif hdd_allow_suspend ( WIFI_POWER_EVENT_WAKELOCK_ROC ) ; return - EINVAL ; } } return 0 ; } | <S2SV_ModStart> EINVAL ; } mutex_lock ( & cfgState -> remain_on_chan_ctx_lock ) ; pRemainChanCtx = cfgState -> remain_on_chan_ctx ; if ( ( pRemainChanCtx ) && <S2SV_ModEnd> ( REMAIN_ON_CHANNEL_REQUEST == <S2SV_ModStart> -> rem_on_chan_request ) ) { mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; <S2SV_ModEnd> if ( eHAL_STATUS_SUCCESS <S2SV_ModStart> ) ; } else { mutex_unlock ( & cfgState -> remain_on_chan_ctx_lock ) ; } |
654 | CWE-000 static void DRW_gpencil_vfx_swirl ( ModifierData * md , int ob_idx , GPENCIL_e_data * e_data , GPENCIL_Data * vedata , Object * ob , tGPencilObjectCache * cache ) { if ( md == NULL ) { return ; } GpencilSwirlModifierData * mmd = ( GpencilSwirlModifierData * ) md ; if ( mmd -> object == NULL ) { return ; } GPENCIL_StorageList * stl = ( ( GPENCIL_Data * ) vedata ) -> stl ; GPENCIL_PassList * psl = ( ( GPENCIL_Data * ) vedata ) -> psl ; DRWShadingGroup * vfx_shgrp ; bGPdata * gpd = ( bGPdata * ) ob -> data ; stl -> vfx [ ob_idx ] . vfx_swirl . radius = mmd -> radius ; stl -> vfx [ ob_idx ] . vfx_swirl . angle = mmd -> angle ; stl -> vfx [ ob_idx ] . vfx_swirl . transparent = ( int ) mmd -> flag & GP_SWIRL_MAKE_TRANSPARENT ; struct Gwn_Batch * vfxquad = DRW_cache_fullscreen_quad_get ( ) ; vfx_shgrp = DRW_shgroup_create ( e_data -> gpencil_vfx_swirl_sh , psl -> vfx_swirl_pass ) ; ++ stl -> g_data -> tot_sh ; DRW_shgroup_call_add ( vfx_shgrp , vfxquad , NULL ) ; DRW_shgroup_uniform_buffer ( vfx_shgrp , "strokeColor" , & e_data -> vfx_fbcolor_color_tx_a ) ; DRW_shgroup_uniform_buffer ( vfx_shgrp , "strokeDepth" , & e_data -> vfx_fbcolor_depth_tx_a ) ; <S2SV_StartBug> const float * viewport_size = DRW_viewport_size_get ( ) ; <S2SV_EndBug> copy_v2_v2 ( stl -> vfx [ ob_idx ] . vfx_light . wsize , viewport_size ) ; DRW_shgroup_uniform_vec2 ( vfx_shgrp , "Viewport" , stl -> vfx [ ob_idx ] . vfx_light . wsize , 1 ) ; copy_v3_v3 ( stl -> vfx [ ob_idx ] . vfx_swirl . loc , & mmd -> object -> loc [ 0 ] ) ; DRW_shgroup_uniform_vec3 ( vfx_shgrp , "loc" , stl -> vfx [ ob_idx ] . vfx_swirl . loc , 1 ) ; DRW_shgroup_uniform_float ( vfx_shgrp , "radius" , & stl -> vfx [ ob_idx ] . vfx_swirl . radius , 1 ) ; DRW_shgroup_uniform_float ( vfx_shgrp , "angle" , & stl -> vfx [ ob_idx ] . vfx_swirl . angle , 1 ) ; DRW_shgroup_uniform_int ( vfx_shgrp , "transparent" , & stl -> vfx [ ob_idx ] . vfx_swirl . transparent , 1 ) ; DRW_shgroup_uniform_float ( vfx_shgrp , "pixsize" , DRW_viewport_pixelsize_get ( ) , 1 ) ; DRW_shgroup_uniform_float ( vfx_shgrp , "pixelsize" , & U . pixelsize , 1 ) ; DRW_shgroup_uniform_int ( vfx_shgrp , "pixfactor" , & gpd -> pixfactor , 1 ) ; if ( cache -> init_vfx_swirl_sh == NULL ) { cache -> init_vfx_swirl_sh = vfx_shgrp ; } cache -> end_vfx_swirl_sh = vfx_shgrp ; } | <S2SV_ModStart> vfx_fbcolor_depth_tx_a ) ; DRW_shgroup_uniform_vec2 ( vfx_shgrp , "Viewport" , <S2SV_ModEnd> DRW_viewport_size_get ( ) <S2SV_ModStart> DRW_viewport_size_get ( ) <S2SV_ModEnd> , 1 ) |
655 | CWE-000 int vcc_sendmsg ( struct socket * sock , struct msghdr * m , size_t size ) { struct sock * sk = sock -> sk ; DEFINE_WAIT ( wait ) ; struct atm_vcc * vcc ; struct sk_buff * skb ; int eff , error ; lock_sock ( sk ) ; if ( sock -> state != SS_CONNECTED ) { error = - ENOTCONN ; goto out ; } if ( m -> msg_name ) { error = - EISCONN ; goto out ; } vcc = ATM_SD ( sock ) ; if ( test_bit ( ATM_VF_RELEASED , & vcc -> flags ) || test_bit ( ATM_VF_CLOSE , & vcc -> flags ) || ! test_bit ( ATM_VF_READY , & vcc -> flags ) ) { error = - EPIPE ; send_sig ( SIGPIPE , current , 0 ) ; goto out ; } if ( ! size ) { error = 0 ; goto out ; } if ( size > vcc -> qos . txtp . max_sdu ) { error = - EMSGSIZE ; goto out ; } eff = ( size + 3 ) & ~ 3 ; prepare_to_wait ( sk_sleep ( sk ) , & wait , TASK_INTERRUPTIBLE ) ; error = 0 ; while ( ! vcc_tx_ready ( vcc , eff ) ) { if ( m -> msg_flags & MSG_DONTWAIT ) { error = - EAGAIN ; break ; } schedule ( ) ; if ( signal_pending ( current ) ) { error = - ERESTARTSYS ; break ; } if ( test_bit ( ATM_VF_RELEASED , & vcc -> flags ) || test_bit ( ATM_VF_CLOSE , & vcc -> flags ) || ! test_bit ( ATM_VF_READY , & vcc -> flags ) ) { error = - EPIPE ; send_sig ( SIGPIPE , current , 0 ) ; break ; } prepare_to_wait ( sk_sleep ( sk ) , & wait , TASK_INTERRUPTIBLE ) ; } finish_wait ( sk_sleep ( sk ) , & wait ) ; if ( error ) goto out ; skb = alloc_skb ( eff , GFP_KERNEL ) ; if ( ! skb ) { error = - ENOMEM ; goto out ; } pr_debug ( "%d<S2SV_blank>+=<S2SV_blank>%d\\n" , sk_wmem_alloc_get ( sk ) , skb -> truesize ) ; <S2SV_StartBug> refcount_add ( skb -> truesize , & sk -> sk_wmem_alloc ) ; <S2SV_EndBug> <S2SV_StartBug> skb -> dev = NULL ; <S2SV_EndBug> ATM_SKB ( skb ) -> atm_options = vcc -> atm_options ; if ( ! copy_from_iter_full ( skb_put ( skb , size ) , size , & m -> msg_iter ) ) { kfree_skb ( skb ) ; error = - EFAULT ; goto out ; } if ( eff != size ) memset ( skb -> data + size , 0 , eff - size ) ; error = vcc -> dev -> ops -> send ( vcc , skb ) ; error = error ? error : size ; out : release_sock ( sk ) ; return error ; } | <S2SV_ModStart> truesize ) ; atm_account_tx ( vcc , skb <S2SV_ModEnd> ) ; skb <S2SV_ModStart> dev = NULL <S2SV_ModEnd> ; if ( |
656 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc < 2 || argc > 3 ) { puts ( "Invalid<S2SV_blank>usage.<S2SV_blank>Please<S2SV_blank>specify<S2SV_blank>an<S2SV_blank>input<S2SV_blank>file<S2SV_blank>as<S2SV_blank>the<S2SV_blank>first<S2SV_blank>argument<S2SV_blank>and<S2SV_blank>an<S2SV_blank>output<S2SV_blank>file<S2SV_blank>as<S2SV_blank>the<S2SV_blank>second<S2SV_blank>argument." ) ; return 1 ; } FILE * input = fopen ( argv [ 1 ] , "r" ) ; if ( input == NULL ) { perror ( "ERROR" ) ; fprintf ( stderr , "ID:<S2SV_blank>%d\\n" , errno ) ; return 1 ; } <S2SV_StartBug> char specials [ ] = ";,[]{}()?><=+-*/%!&|^~@\\\\.:" ; <S2SV_EndBug> size_t processed_input_size = 256 ; char * processed_input = malloc ( processed_input_size ) ; preprocess ( & input , & processed_input , processed_input_size , argv , NULL , NULL , NULL ) ; fclose ( input ) ; puts ( "[DEBUG]<S2SV_blank>Read<S2SV_blank>and<S2SV_blank>preprocessed<S2SV_blank>file." ) ; <S2SV_StartBug> size_t keywords_size = sizeof ( char * ) * 32 ; <S2SV_EndBug> size_t pointers_size = sizeof ( char * ) * 32 ; char * * keywords = malloc ( keywords_size ) ; char * * pointers = malloc ( pointers_size ) ; size_t key = 0 ; size_t pkey = 0 ; <S2SV_StartBug> lex_parse ( processed_input , & keywords , keywords_size , & key , & pointers , pointers_size , & pkey , specials ) ; <S2SV_EndBug> puts ( "[DEBUG]<S2SV_blank>Lex-parsed<S2SV_blank>input." ) ; <S2SV_StartBug> size_t pos = 0 ; <S2SV_EndBug> <S2SV_StartBug> char * parsed_output = parse ( keywords , key , & pos , specials ) ; <S2SV_EndBug> free ( processed_input ) ; puts ( "[DEBUG]<S2SV_blank>Parsed<S2SV_blank>input." ) ; FILE * output ; if ( argc < 3 ) { size_t file_length = strlen ( argv [ 1 ] ) ; char filename [ file_length ] ; strcpy ( filename , argv [ 1 ] ) ; size_t c = file_length - 1 ; while ( filename [ c ] != '.' ) { c -- ; } memset ( & filename [ c + 1 ] , 'c' , 1 ) ; memset ( & filename [ c + 2 ] , '\\0' , 1 ) ; while ( filename [ c ] != '/' && c > 0 ) { c -- ; } char finalname [ strlen ( filename ) + 4 ] ; char success ; if ( c == 0 ) { success = mkdir ( "bin" , 0777 ) ; strcpy ( finalname , "bin/" ) ; strcat ( finalname , filename ) ; } else { strncpy ( finalname , filename , c + 1 ) ; finalname [ c + 1 ] = '\\0' ; strcat ( finalname , "bin/" ) ; success = mkdir ( finalname , 0777 ) ; strcat ( finalname , & filename [ c + 1 ] ) ; } if ( success != 0 && errno != 17 ) { perror ( "ERROR" ) ; fprintf ( stderr , "ID:<S2SV_blank>%d\\n" , errno ) ; return 1 ; } output = fopen ( finalname , "w" ) ; } else { output = fopen ( argv [ 2 ] , "w" ) ; } fprintf ( output , "int<S2SV_blank>main(int<S2SV_blank>argc,char<S2SV_blank>*argv[]){" ) ; for ( size_t i = 0 ; i < pos ; i ++ ) { if ( parsed_output [ i ] == '$' ) continue ; fprintf ( output , "%c" , parsed_output [ i ] ) ; printf ( "[DEBUG]<S2SV_blank>Printing<S2SV_blank>output...<S2SV_blank>%.2Lf%%\\r" , ( ( ( long double ) i + 1 ) / key ) * 100 ) ; } fprintf ( output , "}" ) ; fclose ( output ) ; puts ( "[DEBUG]<S2SV_blank>Printing<S2SV_blank>output...<S2SV_blank>100.00%" ) ; free ( parsed_output ) ; for ( size_t i = 0 ; i < pkey ; i ++ ) { free ( pointers [ i ] ) ; } free ( keywords ) ; free ( pointers ) ; return 0 ; } | <S2SV_ModStart> 1 ; } <S2SV_ModEnd> size_t processed_input_size = <S2SV_ModStart> "[DEBUG]<S2SV_blank>Read<S2SV_blank>and<S2SV_blank>preprocessed<S2SV_blank>file." ) ; char * * keywords = malloc ( keywords_size ) ; char * * pointers = malloc ( pointers_size ) <S2SV_ModEnd> ; lex_parse ( <S2SV_ModStart> & keywords , & pointers <S2SV_ModEnd> ) ; puts <S2SV_ModStart> "[DEBUG]<S2SV_blank>Lex-parsed<S2SV_blank>input." ) ; <S2SV_ModEnd> char * parsed_output <S2SV_ModStart> parse ( keywords <S2SV_ModEnd> ) ; free |
657 | CWE-000 static size_t animfilter_action ( bAnimContext * ac , ListBase * anim_data , bDopeSheet * ads , bAction * act , int filter_mode , ID * owner_id ) { bActionGroup * agrp ; FCurve * lastchan = NULL ; size_t items = 0 ; if ( ( filter_mode & ANIMFILTER_FOREDIT ) && ID_IS_LINKED ( act ) ) return 0 ; for ( agrp = act -> groups . first ; agrp ; agrp = agrp -> next ) { if ( agrp -> channels . last ) lastchan = agrp -> channels . last ; items += animfilter_act_group ( ac , anim_data , ads , act , agrp , filter_mode , owner_id ) ; } if ( ! ( filter_mode & ANIMFILTER_ACTGROUPED ) ) { FCurve * firstfcu = ( lastchan ) ? ( lastchan -> next ) : ( act -> curves . first ) ; <S2SV_StartBug> items += animfilter_fcurves ( anim_data , ads , firstfcu , NULL , filter_mode , owner_id ) ; <S2SV_EndBug> } return items ; } | <S2SV_ModStart> , firstfcu , ANIMTYPE_FCURVE , filter_mode , NULL <S2SV_ModEnd> , owner_id ) |
658 | CWE-000 static int signal_session_msg_receipt ( enum command_response cmd , struct msm_vidc_inst * inst ) { if ( ! inst ) { <S2SV_StartBug> dprintk ( VIDC_ERR , "Invalid(%p)<S2SV_blank>instance<S2SV_blank>id\\n" , inst ) ; <S2SV_EndBug> return - EINVAL ; } complete ( & inst -> completions [ SESSION_MSG_INDEX ( cmd ) ] ) ; return 0 ; } | <S2SV_ModStart> ( VIDC_ERR , "Invalid(%pK)<S2SV_blank>instance<S2SV_blank>id\\n" <S2SV_ModEnd> , inst ) |
659 | CWE-000 void consume_item ( struct item * i ) { int old_score = g . p ; switch ( i -> t ) { case FOOD : switch ( i -> v ) { case FOOD_5 : g . p += 5 ; break ; case FOOD_10 : g . p += 10 ; break ; case FOOD_20 : g . p += 20 ; break ; } snake_append ( & g . s , - 1 , - 1 ) ; break ; case BONUS : switch ( i -> v ) { case BONUS_SNIP : for ( int i = 5 ; i && g . s -> next -> next ; i -- ) { struct snake * p = g . s ; while ( p -> next -> next ) p = p -> next ; free ( p -> next ) ; p -> next = NULL ; } show_playfield ( ) ; break ; case BONUS_GROW : for ( int i = 5 ; i ; i -- ) snake_append ( & g . s , - 1 , - 1 ) ; break ; case BONUS_SLOW : if ( g . v > 1 ) g . v -- ; timer_setup ( 1 ) ; break ; case BONUS_FAST : g . v ++ ; timer_setup ( 1 ) ; break ; } break ; } if ( i -> next ) i -> next -> prev = i -> prev ; if ( i -> prev ) i -> prev -> next = i -> next ; else g . i = i -> next ; <S2SV_StartBug> if ( g . p / SPEEDUP_AFTER - old_score / SPEEDUP_AFTER ) g . v ++ ; <S2SV_EndBug> } | <S2SV_ModStart> . v ++ , timer_setup ( 1 ) |
660 | CWE-000 void process_token ( char * token , TokenStack * stack , FuncHashMap * function_map ) { if ( could_be_num ( token ) ) { char * err = NULL ; value val = strtod ( token , & err ) ; push_token ( stack , val ) ; } else { CalcFunc * func_ptr = NULL ; func_ptr = hash_get ( function_map , token ) ; if ( func_ptr != NULL ) { call_calc_func ( func_ptr , stack ) ; } else { <S2SV_StartBug> printf ( "Undefined<S2SV_blank>symbol:<S2SV_blank>%s" , token ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> { printf ( "Undefined<S2SV_blank>symbol:<S2SV_blank>%s\\n" <S2SV_ModEnd> , token ) |
661 | CWE-000 char * ws_read ( ws_client_t * client , ws_header_t * header ) { char * ret ; char * append ; err_t err ; struct netbuf * inbuf ; struct netbuf * inbuf2 ; char * buf ; char * buf2 ; uint16_t len ; uint16_t len2 ; uint64_t pos ; uint64_t cont_len ; uint64_t cont_pos ; if ( client -> unfinished ) { client -> unfinished -- ; return NULL ; } err = netconn_recv ( client -> conn , & inbuf ) ; if ( err != ERR_OK ) return NULL ; netbuf_data ( inbuf , ( void * * ) & buf , & len ) ; if ( ! buf ) return NULL ; header -> param . pos . ZERO = buf [ 0 ] ; header -> param . pos . ONE = buf [ 1 ] ; pos = 2 ; <S2SV_StartBug> if ( header -> param . bit . LEN < 125 ) { <S2SV_EndBug> header -> length = header -> param . bit . LEN ; } else if ( header -> param . bit . LEN == 126 ) { header -> length = buf [ 2 ] << 8 | buf [ 3 ] ; pos = 4 ; } else { header -> length = ( uint64_t ) buf [ 2 ] << 56 | ( uint64_t ) buf [ 3 ] << 48 | ( uint64_t ) buf [ 4 ] << 40 | ( uint64_t ) buf [ 5 ] << 32 | ( uint64_t ) buf [ 6 ] << 24 | ( uint64_t ) buf [ 7 ] << 16 | ( uint64_t ) buf [ 8 ] << 8 | ( uint64_t ) buf [ 9 ] ; pos = 10 ; } if ( header -> param . bit . MASK ) { memcpy ( & ( header -> key . full ) , & buf [ pos ] , 4 ) ; pos += 4 ; } ret = malloc ( header -> length + 1 ) ; if ( ! ret ) { netbuf_delete ( inbuf ) ; header -> received = 0 ; return NULL ; } cont_len = len - pos ; memcpy ( ret , & buf [ pos ] , header -> length ) ; cont_pos = cont_len ; while ( cont_len < header -> length ) { err = netconn_recv ( client -> conn , & inbuf2 ) ; if ( err != ERR_OK ) { netbuf_delete ( inbuf2 ) ; free ( ret ) ; client -> unfinished = 0 ; header -> received = 0 ; return NULL ; } netbuf_data ( inbuf2 , ( void * * ) & buf2 , & len2 ) ; memcpy ( & ret [ cont_pos ] , buf2 , len2 ) ; cont_pos += len2 ; if ( ! buf2 ) { client -> unfinished = 0 ; header -> received = 0 ; } netbuf_delete ( inbuf2 ) ; client -> unfinished ++ ; cont_len += len2 ; } ret [ header -> length ] = '\\0' ; ws_encrypt_decrypt ( ret , * header ) ; if ( header -> param . bit . FIN == 0 ) { if ( ( header -> param . bit . OPCODE == WEBSOCKET_OPCODE_CONT ) && ( ( client -> last_opcode == WEBSOCKET_OPCODE_BIN ) || ( client -> last_opcode == WEBSOCKET_OPCODE_TEXT ) ) ) { cont_len = header -> length + client -> len ; append = malloc ( cont_len ) ; memcpy ( append , client -> contin , client -> len ) ; memcpy ( & append [ client -> len ] , ret , header -> length ) ; free ( client -> contin ) ; client -> contin = malloc ( cont_len ) ; client -> len = cont_len ; free ( append ) ; free ( ret ) ; netbuf_delete ( inbuf ) ; return NULL ; } else if ( ( header -> param . bit . OPCODE == WEBSOCKET_OPCODE_BIN ) || ( header -> param . bit . OPCODE == WEBSOCKET_OPCODE_TEXT ) ) { if ( client -> len ) { free ( client -> contin ) ; } client -> contin = malloc ( header -> length ) ; memcpy ( client -> contin , ret , header -> length ) ; client -> len = header -> length ; client -> last_opcode = header -> param . bit . OPCODE ; free ( ret ) ; netbuf_delete ( inbuf ) ; return NULL ; } else { free ( ret ) ; netbuf_delete ( inbuf ) ; return NULL ; } } client -> last_opcode = header -> param . bit . OPCODE ; if ( inbuf ) netbuf_delete ( inbuf ) ; header -> received = 1 ; return ret ; } | <S2SV_ModStart> bit . LEN <= <S2SV_ModEnd> 125 ) { |
662 | CWE-000 int main ( ) { <S2SV_StartBug> if ( ! elev_init ( ) ) { <S2SV_EndBug> printf ( "Unable<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>elevator<S2SV_blank>hardware!\\n" ) ; return 1 ; } printf ( "Press<S2SV_blank>STOP<S2SV_blank>button<S2SV_blank>to<S2SV_blank>stop<S2SV_blank>elevator<S2SV_blank>and<S2SV_blank>exit<S2SV_blank>program.\\n" ) ; elev_set_motor_direction ( DIRN_UP ) ; while ( 1 ) { if ( elev_get_floor_sensor_signal ( ) == N_FLOORS - 2 ) { elev_set_motor_direction ( DIRN_DOWN ) ; } else if ( elev_get_floor_sensor_signal ( ) == 1 ) { elev_set_motor_direction ( DIRN_UP ) ; } if ( elev_get_stop_signal ( ) ) { elev_set_motor_direction ( DIRN_STOP ) ; break ; } } return 0 ; } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> return 0 ; |
663 | CWE-000 void setupNetForXOR ( CLAnn * net ) { CLString name = "XOR" ; CLUInt nPattern = 4 ; CLUInt nInputs = 2 ; CLUInt nHiddenLayers = 1 ; CLUInt nNeuronsPerLayer = 10 ; CLUInt nOutputs = 1 ; CLFloat _inputs [ ] = { 0.0 , 0.0 , 0.0 , 1.0 , 1.0 , 0.0 , 1.0 , 1.0 } ; CLFloat _outputs [ ] = { 0.0 , 1.0 , 1.0 , 0.0 } ; <S2SV_StartBug> CLAnnInit ( net , 0.7f , nPattern , nInputs , nHiddenLayers , nNeuronsPerLayer , nOutputs , name ) ; <S2SV_EndBug> CLMatrixUpdateValues ( net -> inputs , _inputs ) ; CLMatrixUpdateValues ( net -> targets , _outputs ) ; CLAnnUpdateWithRandomWeights ( net ) ; } | <S2SV_ModStart> ( net , <S2SV_ModEnd> nPattern , nInputs |
664 | CWE-000 SAVEDInternalContext * saved_internal_alloc ( ) { SAVEDInternalContext * ctx = ( SAVEDInternalContext * ) malloc ( sizeof ( SAVEDInternalContext ) ) ; if ( ctx == NULL ) { SAVLOGE ( "no<S2SV_blank>mem" ) ; return NULL ; } <S2SV_StartBug> ctx -> fmt = NULL ; <S2SV_EndBug> ctx -> savctx = NULL ; ctx -> isencoder = 0 ; return ctx ; } | <S2SV_ModStart> } ctx -> <S2SV_ModEnd> savctx = NULL |
665 | CWE-000 static void modulemd_component_class_init ( ModulemdComponentClass * klass ) { GObjectClass * object_class = G_OBJECT_CLASS ( klass ) ; object_class -> set_property = modulemd_component_set_property ; object_class -> get_property = modulemd_component_get_property ; object_class -> finalize = modulemd_component_finalize ; klass -> set_buildorder = modulemd_component_default_set_buildorder ; klass -> peek_buildorder = modulemd_component_default_get_buildorder ; klass -> set_name = modulemd_component_default_set_name ; klass -> peek_name = modulemd_component_default_peek_name ; klass -> dup_name = modulemd_component_default_dup_name ; klass -> set_rationale = modulemd_component_default_set_rationale ; klass -> peek_rationale = modulemd_component_default_peek_rationale ; klass -> dup_rationale = modulemd_component_default_dup_rationale ; klass -> copy = NULL ; component_properties [ COMPONENT_PROP_BUILDORDER ] = <S2SV_StartBug> g_param_spec_uint64 ( "buildorder" , <S2SV_EndBug> "Build<S2SV_blank>order" , "The<S2SV_blank>buildorder<S2SV_blank>index<S2SV_blank>for<S2SV_blank>this<S2SV_blank>component." , <S2SV_StartBug> 0 , <S2SV_EndBug> G_MAXUINT64 , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ; component_properties [ COMPONENT_PROP_NAME ] = g_param_spec_string ( "name" , "Component<S2SV_blank>name" , "The<S2SV_blank>component<S2SV_blank>name." , NULL , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ; component_properties [ COMPONENT_PROP_RATIONALE ] = g_param_spec_string ( "rationale" , "Component<S2SV_blank>rationale" , "The<S2SV_blank>rationale<S2SV_blank>for<S2SV_blank>including<S2SV_blank>this<S2SV_blank>component<S2SV_blank>in<S2SV_blank>" "the<S2SV_blank>module." , NULL , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ; g_object_class_install_properties ( object_class , COMPONENT_N_PROPS , component_properties ) ; } | <S2SV_ModStart> COMPONENT_PROP_BUILDORDER ] = g_param_spec_int64 <S2SV_ModEnd> ( "buildorder" , <S2SV_ModStart> , "The<S2SV_blank>buildorder<S2SV_blank>index<S2SV_blank>for<S2SV_blank>this<S2SV_blank>component." , G_MININT64 , G_MAXINT64 <S2SV_ModEnd> , 0 , |
666 | CWE-000 static void gnc_main_window_setup_window ( GncMainWindow * window ) { GncMainWindowPrivate * priv ; GtkWidget * main_vbox ; guint merge_id ; GncPluginManager * manager ; GList * plugins ; GError * error = NULL ; gchar * filename ; ENTER ( "<S2SV_blank>" ) ; g_signal_connect ( G_OBJECT ( window ) , "delete-event" , G_CALLBACK ( gnc_main_window_delete_event ) , window ) ; main_vbox = gtk_box_new ( GTK_ORIENTATION_VERTICAL , 0 ) ; gtk_box_set_homogeneous ( GTK_BOX ( main_vbox ) , FALSE ) ; gtk_widget_show ( main_vbox ) ; gtk_container_add ( GTK_CONTAINER ( window ) , main_vbox ) ; priv = GNC_MAIN_WINDOW_GET_PRIVATE ( window ) ; priv -> menu_dock = gtk_box_new ( GTK_ORIENTATION_VERTICAL , 0 ) ; gtk_box_set_homogeneous ( GTK_BOX ( priv -> menu_dock ) , FALSE ) ; gtk_widget_show ( priv -> menu_dock ) ; gtk_box_pack_start ( GTK_BOX ( main_vbox ) , priv -> menu_dock , FALSE , TRUE , 0 ) ; priv -> notebook = gtk_notebook_new ( ) ; g_object_set ( G_OBJECT ( priv -> notebook ) , "scrollable" , TRUE , "enable-popup" , TRUE , ( char * ) NULL ) ; gtk_widget_show ( priv -> notebook ) ; g_signal_connect ( G_OBJECT ( priv -> notebook ) , "switch-page" , G_CALLBACK ( gnc_main_window_switch_page ) , window ) ; g_signal_connect ( G_OBJECT ( priv -> notebook ) , "page-reordered" , G_CALLBACK ( gnc_main_window_page_reordered ) , window ) ; g_signal_connect ( G_OBJECT ( priv -> notebook ) , "focus-in-event" , G_CALLBACK ( gnc_main_window_page_focus_in ) , window ) ; gtk_box_pack_start ( GTK_BOX ( main_vbox ) , priv -> notebook , TRUE , TRUE , 0 ) ; priv -> statusbar = gtk_statusbar_new ( ) ; gtk_widget_show ( priv -> statusbar ) ; gtk_box_pack_start ( GTK_BOX ( main_vbox ) , priv -> statusbar , FALSE , TRUE , 0 ) ; priv -> progressbar = gtk_progress_bar_new ( ) ; gtk_progress_bar_set_text ( GTK_PROGRESS_BAR ( priv -> progressbar ) , "<S2SV_blank>" ) ; gtk_widget_show ( priv -> progressbar ) ; gtk_box_pack_start ( GTK_BOX ( priv -> statusbar ) , priv -> progressbar , FALSE , TRUE , 0 ) ; gtk_progress_bar_set_pulse_step ( GTK_PROGRESS_BAR ( priv -> progressbar ) , 0.01 ) ; window -> ui_merge = gtk_ui_manager_new ( ) ; priv -> action_group = gtk_action_group_new ( "MainWindowActions" ) ; <S2SV_StartBug> gnc_gtk_action_group_set_translation_domain ( priv -> action_group , GETTEXT_PACKAGE ) ; <S2SV_EndBug> gtk_action_group_add_actions ( priv -> action_group , gnc_menu_actions , gnc_menu_n_actions , window ) ; gtk_action_group_add_toggle_actions ( priv -> action_group , toggle_actions , n_toggle_actions , window ) ; gnc_plugin_update_actions ( priv -> action_group , initially_insensitive_actions , "sensitive" , FALSE ) ; gnc_plugin_update_actions ( priv -> action_group , always_insensitive_actions , "sensitive" , FALSE ) ; gnc_plugin_update_actions ( priv -> action_group , always_hidden_actions , "visible" , FALSE ) ; gnc_plugin_set_important_actions ( priv -> action_group , gnc_menu_important_actions ) ; gtk_ui_manager_insert_action_group ( window -> ui_merge , priv -> action_group , 0 ) ; g_signal_connect ( G_OBJECT ( window -> ui_merge ) , "add_widget" , G_CALLBACK ( gnc_main_window_add_widget ) , window ) ; g_signal_connect ( G_OBJECT ( window -> ui_merge ) , "connect-proxy" , G_CALLBACK ( connect_proxy ) , priv -> statusbar ) ; filename = gnc_filepath_locate_ui_file ( "gnc-main-window-ui.xml" ) ; g_assert ( filename ) ; merge_id = gtk_ui_manager_add_ui_from_file ( window -> ui_merge , filename , & error ) ; g_assert ( merge_id || error ) ; if ( merge_id ) { gtk_window_add_accel_group ( GTK_WINDOW ( window ) , gtk_ui_manager_get_accel_group ( window -> ui_merge ) ) ; gtk_ui_manager_ensure_update ( window -> ui_merge ) ; } else { g_critical ( "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>ui<S2SV_blank>file.\\n<S2SV_blank><S2SV_blank>Filename<S2SV_blank>%s\\n<S2SV_blank><S2SV_blank>Error<S2SV_blank>%s" , filename , error -> message ) ; g_error_free ( error ) ; g_assert ( merge_id != 0 ) ; } g_free ( filename ) ; gnc_main_window_window_menu ( window ) ; gnc_prefs_register_cb ( GNC_PREFS_GROUP_GENERAL , GNC_PREF_TAB_POSITION_TOP , gnc_main_window_update_tab_position , window ) ; gnc_prefs_register_cb ( GNC_PREFS_GROUP_GENERAL , GNC_PREF_TAB_POSITION_BOTTOM , gnc_main_window_update_tab_position , window ) ; gnc_prefs_register_cb ( GNC_PREFS_GROUP_GENERAL , GNC_PREF_TAB_POSITION_LEFT , gnc_main_window_update_tab_position , window ) ; gnc_prefs_register_cb ( GNC_PREFS_GROUP_GENERAL , GNC_PREF_TAB_POSITION_RIGHT , gnc_main_window_update_tab_position , window ) ; gnc_main_window_update_tab_position ( NULL , NULL , window ) ; gnc_main_window_init_menu_updaters ( window ) ; if ( ! gnc_prefs_is_extra_enabled ( ) ) { GtkAction * action ; action = gtk_action_group_get_action ( priv -> action_group , "ExtensionsAction" ) ; gtk_action_set_visible ( action , FALSE ) ; } manager = gnc_plugin_manager_get ( ) ; plugins = gnc_plugin_manager_get_plugins ( manager ) ; g_list_foreach ( plugins , gnc_main_window_add_plugin , window ) ; g_list_free ( plugins ) ; g_signal_connect ( G_OBJECT ( manager ) , "plugin-added" , G_CALLBACK ( gnc_main_window_plugin_added ) , window ) ; g_signal_connect ( G_OBJECT ( manager ) , "plugin-removed" , G_CALLBACK ( gnc_main_window_plugin_removed ) , window ) ; LEAVE ( "<S2SV_blank>" ) ; } | <S2SV_ModStart> "MainWindowActions" ) ; gtk_action_group_set_translation_domain <S2SV_ModEnd> ( priv -> |
667 | CWE-000 static errno_t sysdb_sudo_store_rule ( struct sss_domain_info * domain , struct sysdb_attrs * rule , int cache_timeout , time_t now ) { const char * name ; errno_t ret ; name = sysdb_sudo_get_rule_name ( rule ) ; if ( name == NULL ) { return EINVAL ; } DEBUG ( SSSDBG_TRACE_FUNC , "Adding<S2SV_blank>sudo<S2SV_blank>rule<S2SV_blank>%s\\n" , name ) ; ret = sysdb_sudo_add_lowered_users ( domain , rule ) ; if ( ret != EOK ) { return ret ; } ret = sysdb_sudo_add_sss_attrs ( rule , name , cache_timeout , now ) ; if ( ret != EOK ) { return ret ; } <S2SV_StartBug> ret = sysdb_store_custom ( domain , name , SUDORULE_SUBDIR , rule ) ; <S2SV_EndBug> if ( ret != EOK ) { DEBUG ( SSSDBG_OP_FAILURE , "Unable<S2SV_blank>to<S2SV_blank>store<S2SV_blank>rule<S2SV_blank>%s<S2SV_blank>[%d]:<S2SV_blank>%s\\n" , name , ret , strerror ( ret ) ) ; return ret ; } return EOK ; } | <S2SV_ModStart> SUDORULE_SUBDIR , rule , true |
668 | CWE-000 corto_int16 corto_fromcontent ( corto_object o , corto_string contentType , corto_string fmt , ... ) { corto_contentType type ; va_list args ; corto_string content ; corto_int16 result ; corto_assertObject ( o ) ; va_start ( args , fmt ) ; <S2SV_StartBug> corto_asprintf ( & content , fmt , args ) ; <S2SV_EndBug> va_end ( args ) ; if ( ! ( type = corto_loadContentType ( contentType ) ) ) { goto error ; } corto_value v = corto_value_object ( o , NULL ) ; result = type -> toValue ( & v , ( corto_word ) content ) ; corto_dealloc ( content ) ; return result ; error : return - 1 ; } | <S2SV_ModStart> fmt ) ; corto_vasprintf <S2SV_ModEnd> ( & content |
669 | CWE-000 int FileSystem_GetFileSize ( FSContext * pContext , const char * pFile ) { # ifdef LINUX return - 1 ; # else FileSystem_Close ( pContext ) ; FileSystem_BuildPath ( buffer , pContext -> m_Path , pFile ) ; if ( NULL == ( pFile = FileSystem_ClassifyPath ( pContext , buffer ) ) ) return - 1 ; switch ( pContext -> m_eType ) { case FS_IODEVICE : { iox_stat_t stat ; memset ( & stat , 0 , sizeof ( stat ) ) ; <S2SV_StartBug> if ( ! strcmp ( pContext -> m_kFile . device -> name , "pfs" ) ) <S2SV_EndBug> break ; if ( pContext -> m_kFile . device -> ops -> getstat ( & ( pContext -> m_kFile ) , pFile , & stat ) < 0 ) break ; if ( ! stat . mode ) break ; if ( ( pContext -> m_kFile . device -> type & 0xf0000000 ) != IOP_DT_FSEXT ) { if ( ! FIO_SO_ISREG ( stat . mode ) ) break ; pContext -> m_kFile . device = NULL ; pContext -> m_eType = FS_INVALID ; return stat . size ; } else { if ( ! FIO_S_ISREG ( stat . mode ) ) break ; pContext -> m_kFile . device = NULL ; pContext -> m_eType = FS_INVALID ; return stat . size ; } } break ; default : break ; } pContext -> m_kFile . device = NULL ; pContext -> m_eType = FS_INVALID ; return - 1 ; # endif } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> pContext -> m_kFile |
670 | CWE-000 static void migration_success_pre_commit ( struct dm_cache_migration * mg ) { unsigned long flags ; struct cache * cache = mg -> cache ; if ( mg -> writeback ) { <S2SV_StartBug> cell_defer ( cache , mg -> old_ocell , false ) ; <S2SV_EndBug> clear_dirty ( cache , mg -> old_oblock , mg -> cblock ) ; cleanup_migration ( mg ) ; return ; } else if ( mg -> demote ) { if ( dm_cache_remove_mapping ( cache -> cmd , mg -> cblock ) ) { DMWARN_LIMIT ( "demotion<S2SV_blank>failed;<S2SV_blank>couldn\'t<S2SV_blank>update<S2SV_blank>on<S2SV_blank>disk<S2SV_blank>metadata" ) ; policy_force_mapping ( cache -> policy , mg -> new_oblock , mg -> old_oblock ) ; if ( mg -> promote ) cell_defer ( cache , mg -> new_ocell , true ) ; cleanup_migration ( mg ) ; return ; } } else { if ( dm_cache_insert_mapping ( cache -> cmd , mg -> cblock , mg -> new_oblock ) ) { DMWARN_LIMIT ( "promotion<S2SV_blank>failed;<S2SV_blank>couldn\'t<S2SV_blank>update<S2SV_blank>on<S2SV_blank>disk<S2SV_blank>metadata" ) ; policy_remove_mapping ( cache -> policy , mg -> new_oblock ) ; cleanup_migration ( mg ) ; return ; } } spin_lock_irqsave ( & cache -> lock , flags ) ; list_add_tail ( & mg -> list , & cache -> need_commit_migrations ) ; cache -> commit_requested = true ; spin_unlock_irqrestore ( & cache -> lock , flags ) ; } | <S2SV_ModStart> writeback ) { clear_dirty ( cache , mg -> old_oblock , mg -> cblock ) ; <S2SV_ModStart> old_ocell , false <S2SV_ModEnd> ) ; cleanup_migration |
671 | CWE-000 void print_colorized_input ( char * input_str , t_lexeme * lexemes , char * unmatched_quote_err_ptr ) { t_lexeme * cur_lexeme ; <S2SV_StartBug> char * ptr ; <S2SV_EndBug> t_environ * env ; env = get_shell_vars ( ) -> env ; cur_lexeme = lexemes ; ptr = input_str ; while ( ptr && cur_lexeme && * ptr ) { print_lexeme_colorized ( cur_lexeme -> lexeme_begin_ptr , cur_lexeme -> lexeme_end_ptr , ptr , cur_lexeme ) ; if ( cur_lexeme -> lexeme_end_ptr ) ptr = cur_lexeme -> lexeme_end_ptr ; cur_lexeme = cur_lexeme -> next ; } print_input_string_end ( ptr , unmatched_quote_err_ptr ) ; } | <S2SV_ModStart> char * ptr <S2SV_ModEnd> ; cur_lexeme = |
672 | CWE-000 int item_amount ( char * str ) { struct dirent * d ; DIR * dir ; int i ; struct stat items ; i = 0 ; dir = opendir ( str ) ; stat ( str , & items ) ; if ( S_ISREG ( items . st_mode ) ) { ft_printf ( "%s\\n" , str ) ; return ( 0 ) ; } <S2SV_StartBug> if ( dir == NULL ) <S2SV_EndBug> { ft_printf ( "ft_ls:<S2SV_blank>%s:<S2SV_blank>No<S2SV_blank>such<S2SV_blank>file<S2SV_blank>or<S2SV_blank>directory\\n" , str ) ; return ( 0 ) ; } while ( ( d = readdir ( dir ) ) ) i ++ ; closedir ( dir ) ; return ( i + 1 ) ; } | <S2SV_ModStart> ) ; } else |
673 | CWE-000 void u_perm ( struct stat * file_stat , char * perm ) { int i ; unsigned int bin_perm ; i = 0 ; bin_perm = 1023 & file_stat -> st_mode ; <S2SV_StartBug> ft_ltoa_base ( bin_perm , perm , 2 ) ; <S2SV_EndBug> <S2SV_StartBug> while ( perm [ i ] ) <S2SV_EndBug> { if ( perm [ i ] == '0' ) perm [ i ] = '-' ; else if ( i % 3 == 0 ) perm [ i ] = 'r' ; else if ( i % 3 == 1 ) perm [ i ] = 'w' ; else perm [ i ] = 'x' ; i ++ ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> st_mode ; ft_memset ( perm , '0' , 10 ) ; <S2SV_ModStart> 2 ) ; perm [ ft_strlen ( perm ) ] = '0' ; perm [ ft_strlen ( perm ) + 1 ] = '\\0' ; while ( i < 9 <S2SV_ModEnd> ) { if <S2SV_ModStart> ++ ; } perm [ i ] = '\\0' ; |
674 | CWE-000 static gint64 get_boot_time ( void ) { # if defined ( HAVE_SYS_PARAM_H ) && defined ( KERN_BOOTTIME ) int mib [ 2 ] ; size_t size ; time_t now ; struct timeval boottime ; ( void ) time ( & now ) ; mib [ 0 ] = CTL_KERN ; mib [ 1 ] = KERN_BOOTTIME ; size = sizeof ( boottime ) ; if ( sysctl ( mib , 2 , & boottime , & size , NULL , 0 ) != - 1 ) return ( gint64 ) ( ( now - boottime . tv_sec ) * MTICKS_PER_SEC ) ; # else FILE * uptime = fopen ( "/proc/uptime" , "r" ) ; if ( uptime ) { double upt ; if ( fscanf ( uptime , "%lf" , & upt ) == 1 ) { <S2SV_StartBug> gint64 now = mono_100ns_datetime ( ) ; <S2SV_EndBug> fclose ( uptime ) ; return now - ( gint64 ) ( upt * MTICKS_PER_SEC ) ; } fclose ( uptime ) ; } # endif return ( gint64 ) 300 * MTICKS_PER_SEC ; } | <S2SV_ModStart> gint64 now = mono_100ns_ticks <S2SV_ModEnd> ( ) ; |
675 | CWE-000 unsigned char sgetU1 ( unsigned char * * bp ) { unsigned char c ; if ( flen == FLEN_ERROR ) return 0 ; c = * * bp ; flen += 1 ; <S2SV_StartBug> * bp ++ ; <S2SV_EndBug> return c ; } | <S2SV_ModStart> += 1 ; ( * bp ) <S2SV_ModEnd> ++ ; return |
676 | CWE-000 u32 LoadNcchFromGameFile ( const char * path , NcchHeader * ncch ) { <S2SV_StartBug> u64 filetype = IdentifyFileType ( path ) ; <S2SV_EndBug> UINT br ; if ( filetype & GAME_NCCH ) { if ( ( fvx_qread ( path , ncch , 0 , sizeof ( NcchHeader ) , NULL ) == FR_OK ) && ( ValidateNcchHeader ( ncch ) == 0 ) ) return 0 ; } else if ( filetype & GAME_NCSD ) { if ( ( fvx_qread ( path , ncch , NCSD_CNT0_OFFSET , sizeof ( NcchHeader ) , NULL ) == FR_OK ) && ( ValidateNcchHeader ( ncch ) == 0 ) ) return 0 ; } else if ( filetype & GAME_CIA ) { CiaStub * cia = ( CiaStub * ) malloc ( sizeof ( CiaStub ) ) ; CiaInfo info ; if ( ( LoadCiaStub ( cia , path ) != 0 ) || ( GetCiaInfo ( & info , & ( cia -> header ) ) != 0 ) ) { free ( cia ) ; return 1 ; } u32 ret = 1 ; if ( getbe16 ( cia -> tmd . content_count ) ) { TmdContentChunk * chunk = cia -> content_list ; if ( ( getbe64 ( chunk -> size ) < sizeof ( NcchHeader ) ) || ( fvx_qread ( path , ncch , info . offset_content , sizeof ( NcchHeader ) , NULL ) != FR_OK ) ) { free ( cia ) ; return 1 ; } if ( getbe16 ( chunk -> type ) & 0x1 ) { u8 titlekey [ 16 ] ; u8 ctr [ 16 ] ; GetTmdCtr ( ctr , chunk ) ; if ( GetTitleKey ( titlekey , & ( cia -> ticket ) ) != 0 ) { free ( cia ) ; return 1 ; } DecryptCiaContentSequential ( ( void * ) ncch , sizeof ( NcchHeader ) , ctr , titlekey ) ; } if ( ValidateNcchHeader ( ncch ) == 0 ) ret = 0 ; } free ( cia ) ; return ret ; } return 1 ; } | <S2SV_ModStart> ( path ) <S2SV_ModEnd> ; if ( |
677 | CWE-000 static esp_err_t mdf_device_ota_status ( device_data_t * device_data ) { esp_err_t ret = 0 ; ssize_t ota_bin_len = 0 ; ssize_t ota_package_len = 0 ; char ota_bin_version [ 64 ] = { 0 } ; uint8_t * ota_progress_array = NULL ; ssize_t ota_package_num = 0 ; ssize_t ota_write_num = 0 ; char * ota_progress_array_str = NULL ; uint8_t loss_package_flag = false ; ret = mdf_json_parse ( device_data -> request , "ota_bin_version" , ota_bin_version ) ; MDF_ERROR_CHECK ( ret < 0 , ESP_FAIL , "mdf_json_parse<S2SV_blank>ota_bin_version,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ret = mdf_json_parse ( device_data -> request , "ota_bin_len" , & ota_bin_len ) ; MDF_ERROR_CHECK ( ret < 0 , ESP_FAIL , "mdf_json_parse<S2SV_blank>ota_bin_len,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ret = mdf_json_parse ( device_data -> request , "package_length" , & ota_package_len ) ; MDF_ERROR_CHECK ( ret < 0 , ESP_FAIL , "mdf_json_parse<S2SV_blank>package_length,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ret = mdf_upgrade_init ( ota_bin_len , ota_package_len , ota_bin_version ) ; MDF_ERROR_CHECK ( ret < 0 , ESP_FAIL , "mdf_upgrade_init,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; ret = mdf_upgrade_status ( & ota_progress_array , & ota_write_num , & ota_package_num , & ota_package_len ) ; MDF_ERROR_CHECK ( ret < 0 , ESP_FAIL , "mdf_ota_get_status,<S2SV_blank>ret:<S2SV_blank>%d" , ret ) ; MDF_LOGD ( "ota_progress_array:<S2SV_blank>%p,<S2SV_blank>ota_package_num:<S2SV_blank>%d,<S2SV_blank>ota_bin_version:<S2SV_blank>%s,<S2SV_blank>ota_write_num:<S2SV_blank>%d" , ota_progress_array , ota_package_num , ota_bin_version , ota_write_num ) ; ota_progress_array_str = mdf_malloc ( OTA_PROGRESS_ARRAY_LEN ) ; if ( ! ota_write_num ) { loss_package_flag = true ; strcpy ( ota_progress_array_str , "[0,<S2SV_blank>-1]" ) ; } else { for ( int i = 0 ; i < ota_package_num ; ++ i ) { if ( ota_progress_array [ i ] == true ) { continue ; } loss_package_flag = true ; <S2SV_StartBug> if ( mdf_json_pack ( ota_progress_array_str , "[]" , i ) > OTA_PROGRESS_ARRAY_LEN ) { <S2SV_EndBug> MDF_LOGV ( "ota_progress_array_str:<S2SV_blank>%s" , ota_progress_array_str ) ; break ; } } } if ( loss_package_flag ) { device_data -> response_size = mdf_json_pack ( device_data -> response , "package_length" , ota_package_len ) ; device_data -> response_size = mdf_json_pack ( device_data -> response , "package_sequence" , ota_progress_array_str ) ; } MDF_LOGD ( "ota_progress_array_str:<S2SV_blank>%s" , ota_progress_array_str ) ; mdf_free ( ota_progress_array_str ) ; return loss_package_flag ; } | <S2SV_ModStart> ) > OTA_PROGRESS_ARRAY_LEN - 16 |
678 | CWE-000 static void pmemobjfs_ioctl ( struct pmemobjfs * objfs ) { switch ( objfs -> ioctl_cmd ) { case PMEMOBJFS_CTL_TX_BEGIN : <S2SV_StartBug> pmemobj_tx_begin ( objfs -> pop , NULL , TX_PARAM_NONE ) ; <S2SV_EndBug> break ; case PMEMOBJFS_CTL_TX_ABORT : pmemobj_tx_abort ( - 1 ) ; <S2SV_StartBug> pmemobj_tx_end ( ) ; <S2SV_EndBug> break ; case PMEMOBJFS_CTL_TX_COMMIT : pmemobj_tx_commit ( ) ; <S2SV_StartBug> pmemobj_tx_end ( ) ; <S2SV_EndBug> break ; default : break ; } objfs -> ioctl_cmd = 0 ; objfs -> ioctl_off = 0 ; } | <S2SV_ModStart> case PMEMOBJFS_CTL_TX_BEGIN : ( void ) <S2SV_ModStart> 1 ) ; ( void ) <S2SV_ModStart> ( ) ; ( void ) |
679 | CWE-000 static int rx_osm_handler ( struct ring_info * ring_data , struct RxD_t * rxdp ) { struct s2io_nic * sp = ring_data -> nic ; struct net_device * dev = ( struct net_device * ) ring_data -> dev ; struct sk_buff * skb = ( struct sk_buff * ) ( ( unsigned long ) rxdp -> Host_Control ) ; int ring_no = ring_data -> ring_no ; u16 l3_csum , l4_csum ; unsigned long long err = rxdp -> Control_1 & RXD_T_CODE ; struct lro * lro ; u8 err_mask ; skb -> dev = dev ; if ( err ) { if ( err & 0x1 ) { sp -> mac_control . stats_info -> sw_stat . parity_err_cnt ++ ; } err_mask = err >> 48 ; switch ( err_mask ) { case 1 : sp -> mac_control . stats_info -> sw_stat . rx_parity_err_cnt ++ ; break ; case 2 : sp -> mac_control . stats_info -> sw_stat . rx_abort_cnt ++ ; break ; case 3 : sp -> mac_control . stats_info -> sw_stat . rx_parity_abort_cnt ++ ; break ; case 4 : sp -> mac_control . stats_info -> sw_stat . rx_rda_fail_cnt ++ ; break ; case 5 : sp -> mac_control . stats_info -> sw_stat . rx_unkn_prot_cnt ++ ; break ; case 6 : sp -> mac_control . stats_info -> sw_stat . rx_fcs_err_cnt ++ ; break ; case 7 : sp -> mac_control . stats_info -> sw_stat . rx_buf_size_err_cnt ++ ; break ; case 8 : sp -> mac_control . stats_info -> sw_stat . rx_rxd_corrupt_cnt ++ ; break ; case 15 : sp -> mac_control . stats_info -> sw_stat . rx_unkn_err_cnt ++ ; break ; } if ( err_mask != 0x5 ) { DBG_PRINT ( ERR_DBG , "%s:<S2SV_blank>Rx<S2SV_blank>error<S2SV_blank>Value:<S2SV_blank>0x%x\\n" , dev -> name , err_mask ) ; <S2SV_StartBug> sp -> stats . rx_crc_errors ++ ; <S2SV_EndBug> sp -> mac_control . stats_info -> sw_stat . mem_freed += skb -> truesize ; dev_kfree_skb ( skb ) ; ring_data -> rx_bufs_left -= 1 ; rxdp -> Host_Control = 0 ; return 0 ; } } ring_data -> rx_packets ++ ; rxdp -> Host_Control = 0 ; if ( sp -> rxd_mode == RXD_MODE_1 ) { int len = RXD_GET_BUFFER0_SIZE_1 ( rxdp -> Control_2 ) ; ring_data -> rx_bytes += len ; skb_put ( skb , len ) ; } else if ( sp -> rxd_mode == RXD_MODE_3B ) { int get_block = ring_data -> rx_curr_get_info . block_index ; int get_off = ring_data -> rx_curr_get_info . offset ; int buf0_len = RXD_GET_BUFFER0_SIZE_3 ( rxdp -> Control_2 ) ; int buf2_len = RXD_GET_BUFFER2_SIZE_3 ( rxdp -> Control_2 ) ; unsigned char * buff = skb_push ( skb , buf0_len ) ; struct buffAdd * ba = & ring_data -> ba [ get_block ] [ get_off ] ; ring_data -> rx_bytes += buf0_len + buf2_len ; memcpy ( buff , ba -> ba_0 , buf0_len ) ; skb_put ( skb , buf2_len ) ; } if ( ( rxdp -> Control_1 & TCP_OR_UDP_FRAME ) && ( ( ! ring_data -> lro ) || ( ring_data -> lro && ( ! ( rxdp -> Control_1 & RXD_FRAME_IP_FRAG ) ) ) ) && ( sp -> rx_csum ) ) { l3_csum = RXD_GET_L3_CKSUM ( rxdp -> Control_1 ) ; l4_csum = RXD_GET_L4_CKSUM ( rxdp -> Control_1 ) ; if ( ( l3_csum == L3_CKSUM_OK ) && ( l4_csum == L4_CKSUM_OK ) ) { skb -> ip_summed = CHECKSUM_UNNECESSARY ; if ( ring_data -> lro ) { u32 tcp_len ; u8 * tcp ; int ret = 0 ; ret = s2io_club_tcp_session ( ring_data , skb -> data , & tcp , & tcp_len , & lro , rxdp , sp ) ; switch ( ret ) { case 3 : lro -> parent = skb ; goto aggregate ; case 1 : { lro_append_pkt ( sp , lro , skb , tcp_len ) ; goto aggregate ; } case 4 : { lro_append_pkt ( sp , lro , skb , tcp_len ) ; queue_rx_frame ( lro -> parent , lro -> vlan_tag ) ; clear_lro_session ( lro ) ; sp -> mac_control . stats_info -> sw_stat . flush_max_pkts ++ ; goto aggregate ; } case 2 : lro -> parent -> data_len = lro -> frags_len ; sp -> mac_control . stats_info -> sw_stat . sending_both ++ ; queue_rx_frame ( lro -> parent , lro -> vlan_tag ) ; clear_lro_session ( lro ) ; goto send_up ; case 0 : case - 1 : case 5 : break ; default : DBG_PRINT ( ERR_DBG , "%s:<S2SV_blank>Samadhana!!\\n" , __FUNCTION__ ) ; BUG ( ) ; } } } else { skb -> ip_summed = CHECKSUM_NONE ; } } else skb -> ip_summed = CHECKSUM_NONE ; sp -> mac_control . stats_info -> sw_stat . mem_freed += skb -> truesize ; send_up : queue_rx_frame ( skb , RXD_GET_VLAN_TAG ( rxdp -> Control_2 ) ) ; dev -> last_rx = jiffies ; aggregate : sp -> mac_control . rings [ ring_no ] . rx_bufs_left -= 1 ; return SUCCESS ; } | <S2SV_ModStart> err_mask ) ; dev <S2SV_ModEnd> -> stats . |
680 | CWE-000 wpt_status WLANDXE_SetPowerState ( void * pDXEContext , WDTS_PowerStateType powerState , WDTS_SetPSCbType cBack ) { wpt_status status = eWLAN_PAL_STATUS_SUCCESS ; WLANDXE_CtrlBlkType * pDxeCtrlBlk ; WLANDXE_PowerStateType hostPowerState ; wpt_msg * rxCompMsg ; wpt_msg * txDescReSyncMsg ; <S2SV_StartBug> HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_INFO_LOW , <S2SV_EndBug> "%s<S2SV_blank>Enter" , __func__ ) ; if ( NULL == pDXEContext ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "NULL<S2SV_blank>pDXEContext<S2SV_blank>passed<S2SV_blank>by<S2SV_blank>caller" ) ; return eWLAN_PAL_STATUS_E_FAILURE ; } pDxeCtrlBlk = ( WLANDXE_CtrlBlkType * ) pDXEContext ; switch ( powerState ) { case WDTS_POWER_STATE_FULL : <S2SV_StartBug> if ( WLANDXE_POWER_STATE_IMPS == pDxeCtrlBlk -> hostPowerState ) <S2SV_EndBug> { txDescReSyncMsg = ( wpt_msg * ) wpalMemoryAllocate ( sizeof ( wpt_msg ) ) ; if ( NULL == txDescReSyncMsg ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "WLANDXE_SetPowerState,<S2SV_blank>TX<S2SV_blank>Resync<S2SV_blank>MSG<S2SV_blank>MEM<S2SV_blank>alloc<S2SV_blank>Fail" ) ; } else { txDescReSyncMsg -> callback = dxeTXReSyncDesc ; txDescReSyncMsg -> pContext = pDxeCtrlBlk ; status = wpalPostTxMsg ( WDI_GET_PAL_CTX ( ) , txDescReSyncMsg ) ; if ( eWLAN_PAL_STATUS_SUCCESS != status ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "WLANDXE_SetPowerState,<S2SV_blank>Post<S2SV_blank>TX<S2SV_blank>re-sync<S2SV_blank>MSG<S2SV_blank>fail" ) ; } } } hostPowerState = WLANDXE_POWER_STATE_FULL ; break ; case WDTS_POWER_STATE_BMPS : pDxeCtrlBlk -> hostPowerState = WLANDXE_POWER_STATE_BMPS ; hostPowerState = WLANDXE_POWER_STATE_BMPS ; break ; case WDTS_POWER_STATE_IMPS : hostPowerState = WLANDXE_POWER_STATE_IMPS ; break ; case WDTS_POWER_STATE_DOWN : pDxeCtrlBlk -> hostPowerState = WLANDXE_POWER_STATE_DOWN ; hostPowerState = WLANDXE_POWER_STATE_DOWN ; break ; default : hostPowerState = WLANDXE_POWER_STATE_MAX ; } if ( cBack ) { rxCompMsg = ( wpt_msg * ) wpalMemoryAllocate ( sizeof ( wpt_msg ) ) ; if ( NULL == rxCompMsg ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "WLANDXE_SetPowerState,<S2SV_blank>MSG<S2SV_blank>MEM<S2SV_blank>alloc<S2SV_blank>Fail" ) ; return eWLAN_PAL_STATUS_E_RESOURCES ; } rxCompMsg -> callback = dxeRxThreadSetPowerStateEventHandler ; rxCompMsg -> pContext = pDxeCtrlBlk ; rxCompMsg -> val = hostPowerState ; rxCompMsg -> ptr = cBack ; status = wpalPostRxMsg ( WDI_GET_PAL_CTX ( ) , rxCompMsg ) ; if ( eWLAN_PAL_STATUS_SUCCESS != status ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "Rx<S2SV_blank>thread<S2SV_blank>Set<S2SV_blank>power<S2SV_blank>state<S2SV_blank>req<S2SV_blank>serialize<S2SV_blank>fail<S2SV_blank>status=%d" , status ) ; } } else { if ( WLANDXE_POWER_STATE_FULL == hostPowerState ) { if ( WLANDXE_POWER_STATE_BMPS == pDxeCtrlBlk -> hostPowerState ) { dxeNotifySmsm ( eWLAN_PAL_FALSE , eWLAN_PAL_TRUE ) ; } else if ( WLANDXE_POWER_STATE_IMPS == pDxeCtrlBlk -> hostPowerState ) { if ( eWLAN_PAL_TRUE == pDxeCtrlBlk -> rxIntDisabledByIMPS ) { pDxeCtrlBlk -> rxIntDisabledByIMPS = eWLAN_PAL_FALSE ; status = wpalEnableInterrupt ( DXE_INTERRUPT_RX_READY ) ; if ( eWLAN_PAL_STATUS_SUCCESS != status ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "%s<S2SV_blank>Enable<S2SV_blank>RX<S2SV_blank>ready<S2SV_blank>interrupt<S2SV_blank>fail" , __func__ ) ; return status ; } } if ( eWLAN_PAL_TRUE == pDxeCtrlBlk -> txIntDisabledByIMPS ) { pDxeCtrlBlk -> txIntDisabledByIMPS = eWLAN_PAL_FALSE ; pDxeCtrlBlk -> txIntEnable = eWLAN_PAL_TRUE ; status = wpalEnableInterrupt ( DXE_INTERRUPT_TX_COMPLE ) ; if ( eWLAN_PAL_STATUS_SUCCESS != status ) { HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_ERROR , "%s<S2SV_blank>Enable<S2SV_blank>TX<S2SV_blank>comp<S2SV_blank>interrupt<S2SV_blank>fail" , __func__ ) ; return status ; } } } pDxeCtrlBlk -> hostPowerState = hostPowerState ; pDxeCtrlBlk -> rivaPowerState = WLANDXE_RIVA_POWER_STATE_ACTIVE ; } else if ( hostPowerState == WLANDXE_POWER_STATE_BMPS ) { pDxeCtrlBlk -> hostPowerState = hostPowerState ; pDxeCtrlBlk -> rivaPowerState = WLANDXE_RIVA_POWER_STATE_BMPS_UNKNOWN ; } else if ( hostPowerState == WLANDXE_POWER_STATE_IMPS ) { pDxeCtrlBlk -> hostPowerState = WLANDXE_POWER_STATE_IMPS ; } else { HDXE_ASSERT ( 0 ) ; } } <S2SV_StartBug> HDXE_MSG ( eWLAN_MODULE_DAL_DATA , eWLAN_PAL_TRACE_LEVEL_INFO_LOW , <S2SV_EndBug> "%s<S2SV_blank>Exit" , __func__ ) ; return status ; } | <S2SV_ModStart> * txDescReSyncMsg ; int state ; <S2SV_ModStart> case WDTS_POWER_STATE_FULL : dxeEnvBlk . dxe_prev_ps = pDxeCtrlBlk -> hostPowerState ; <S2SV_ModStart> ; } } if ( WLANDXE_POWER_STATE_FULL == pDxeCtrlBlk -> hostPowerState ) { state = wpal_get_int_state ( DXE_INTERRUPT_RX_READY ) ; if ( 0 == state && eWLAN_PAL_TRUE == pDxeCtrlBlk -> rxIntDisabledByIMPS ) { dxeEnvBlk . rx_imps_set_fp = 1 ; WARN_ON ( 1 ) ; } } |
681 | CWE-000 struct page * follow_trans_huge_pmd ( struct vm_area_struct * vma , unsigned long addr , pmd_t * pmd , unsigned int flags ) { struct mm_struct * mm = vma -> vm_mm ; struct page * page = NULL ; assert_spin_locked ( pmd_lockptr ( mm , pmd ) ) ; if ( flags & FOLL_WRITE && ! can_follow_write_pmd ( * pmd , flags ) ) goto out ; if ( ( flags & FOLL_DUMP ) && is_huge_zero_pmd ( * pmd ) ) return ERR_PTR ( - EFAULT ) ; if ( ( flags & FOLL_NUMA ) && pmd_numa ( * pmd ) ) goto out ; page = pmd_page ( * pmd ) ; VM_BUG_ON_PAGE ( ! PageHead ( page ) , page ) ; if ( flags & FOLL_TOUCH ) { pmd_t _pmd ; <S2SV_StartBug> _pmd = pmd_mkyoung ( pmd_mkdirty ( * pmd ) ) ; <S2SV_EndBug> if ( pmdp_set_access_flags ( vma , addr & HPAGE_PMD_MASK , <S2SV_StartBug> pmd , _pmd , 1 ) ) <S2SV_EndBug> update_mmu_cache_pmd ( vma , addr , pmd ) ; } if ( ( flags & FOLL_MLOCK ) && ( vma -> vm_flags & VM_LOCKED ) ) { if ( page -> mapping && trylock_page ( page ) ) { lru_add_drain ( ) ; if ( page -> mapping ) mlock_vma_page ( page ) ; unlock_page ( page ) ; } } page += ( addr & ~ HPAGE_PMD_MASK ) >> PAGE_SHIFT ; VM_BUG_ON_PAGE ( ! PageCompound ( page ) , page ) ; if ( flags & FOLL_GET ) get_page_foll ( page ) ; out : return page ; } | <S2SV_ModStart> = pmd_mkyoung ( * pmd ) ; if ( flags & FOLL_WRITE ) _pmd = pmd_mkdirty ( _pmd <S2SV_ModEnd> ) ; if <S2SV_ModStart> , _pmd , flags & FOLL_WRITE <S2SV_ModEnd> ) ) update_mmu_cache_pmd |
682 | CWE-000 int chunk_wait_for ( struct chunk * c , uint8_t * * data ) { pthread_mutex_lock ( & chunk_mutex ) ; if ( c -> io ) { pthread_mutex_unlock ( & chunk_mutex ) ; return - EBUSY ; } c -> io = calloc ( 1 , sizeof ( struct io ) ) ; <S2SV_StartBug> pthread_mutex_unlock ( & chunk_mutex ) ; <S2SV_EndBug> c -> io -> owner = OWNER_NET ; pthread_cond_init ( & c -> io -> fs_cond , NULL ) ; pthread_cond_init ( & c -> io -> net_cond , NULL ) ; <S2SV_StartBug> pthread_mutex_init ( & c -> io -> mutex , NULL ) ; <S2SV_EndBug> pthread_mutex_lock ( & c -> io -> mutex ) ; while ( c -> io -> owner != OWNER_FS ) { int res ; struct timespec ts ; clock_gettime ( CLOCK_REALTIME , & ts ) ; ts . tv_sec += timeout ; res = pthread_cond_timedwait ( & c -> io -> fs_cond , & c -> io -> mutex , & ts ) ; if ( res ) { pthread_mutex_unlock ( & c -> io -> mutex ) ; pthread_mutex_lock ( & chunk_mutex ) ; free ( c -> io ) ; c -> io = NULL ; pthread_mutex_unlock ( & chunk_mutex ) ; return 0 ; } } * data = c -> io -> data ; return c -> io -> len ; } | <S2SV_ModStart> ) ) ; if ( ! c -> io ) { pthread_mutex_unlock ( & chunk_mutex ) ; return - ENOMEM ; } <S2SV_ModStart> NULL ) ; if ( <S2SV_ModStart> , NULL ) ) { pthread_mutex_unlock ( & chunk_mutex ) ; free ( c -> io ) ; return - errno ; } <S2SV_ModEnd> pthread_mutex_lock ( & |
683 | CWE-000 void m68k_write_memory_32 ( unsigned int addr , unsigned int val ) { # ifdef DPRINT_MEM_ACCESS printf ( "write32<S2SV_blank>a:%x<S2SV_blank>v:%x\\n" , addr , val ) ; # endif <S2SV_StartBug> MEM_SetByte ( addr , val ) ; <S2SV_EndBug> <S2SV_StartBug> MEM_SetByte ( addr + 1 , val >> 8 ) ; <S2SV_EndBug> MEM_SetByte ( addr + 2 , val >> 16 ) ; <S2SV_StartBug> MEM_SetByte ( addr + 3 , val >> 24 ) ; <S2SV_EndBug> } | <S2SV_ModStart> MEM_SetByte ( addr + 3 , val ) ; MEM_SetByte ( addr + 2 , val >> 8 <S2SV_ModEnd> ) ; MEM_SetByte <S2SV_ModStart> , val >> <S2SV_ModEnd> 16 ) ; <S2SV_ModStart> ( addr + 0 <S2SV_ModEnd> , val >> |
684 | CWE-000 int dev_read_buf ( struct device * dev , uint64_t offset , size_t len , dev_io_reason_t reason , void * retbuf ) { <S2SV_StartBug> if ( ! dev_read_callback ( dev , offset , len , reason , 0 , NULL , NULL ) ) { <S2SV_EndBug> log_error ( "Read<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>failed" , dev_name ( dev ) ) ; return 0 ; } memcpy ( retbuf , DEV_DEVBUF_DATA ( dev , reason ) , len ) ; return 1 ; } | <S2SV_ModStart> if ( ! _dev_read_callback <S2SV_ModEnd> ( dev , |
685 | CWE-000 static int cw_battery_get_property ( struct power_supply * psy , enum power_supply_property psp , union power_supply_propval * val ) { int ret = 0 ; struct cw_battery * cw_bat ; cw_bat = container_of ( psy , struct cw_battery , cw_bat ) ; switch ( psp ) { case POWER_SUPPLY_PROP_CAPACITY : <S2SV_StartBug> val -> intval = cw_bat -> capacity ; <S2SV_EndBug> break ; case POWER_SUPPLY_PROP_HEALTH : val -> intval = POWER_SUPPLY_HEALTH_GOOD ; break ; case POWER_SUPPLY_PROP_PRESENT : val -> intval = cw_bat -> voltage <= 0 ? 0 : 1 ; break ; case POWER_SUPPLY_PROP_VOLTAGE_NOW : val -> intval = cw_bat -> voltage ; break ; case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW : val -> intval = cw_bat -> time_to_empty ; break ; case POWER_SUPPLY_PROP_TECHNOLOGY : val -> intval = POWER_SUPPLY_TECHNOLOGY_LION ; break ; <S2SV_StartBug> default : <S2SV_EndBug> break ; } return ret ; } | <S2SV_ModStart> cw_bat -> capacity ; break ; case POWER_SUPPLY_PROP_STATUS : cw_update_status ( cw_bat ) ; val -> intval = cw_bat -> status <S2SV_ModStart> ; break ; case POWER_SUPPLY_PROP_TEMP : val -> intval = cw2015_read_temp ( cw_bat ) * 10 ; break ; |
686 | CWE-000 static int modify_qp ( struct ib_uverbs_file * file , struct ib_uverbs_ex_modify_qp * cmd , struct ib_udata * udata ) { struct ib_qp_attr * attr ; struct ib_qp * qp ; int ret ; attr = kmalloc ( sizeof * attr , GFP_KERNEL ) ; if ( ! attr ) return - ENOMEM ; qp = idr_read_qp ( cmd -> base . qp_handle , file -> ucontext ) ; if ( ! qp ) { ret = - EINVAL ; goto out ; } <S2SV_StartBug> attr -> qp_state = cmd -> base . qp_state ; <S2SV_EndBug> attr -> cur_qp_state = cmd -> base . cur_qp_state ; attr -> path_mtu = cmd -> base . path_mtu ; attr -> path_mig_state = cmd -> base . path_mig_state ; attr -> qkey = cmd -> base . qkey ; attr -> rq_psn = cmd -> base . rq_psn ; attr -> sq_psn = cmd -> base . sq_psn ; attr -> dest_qp_num = cmd -> base . dest_qp_num ; attr -> qp_access_flags = cmd -> base . qp_access_flags ; attr -> pkey_index = cmd -> base . pkey_index ; attr -> alt_pkey_index = cmd -> base . alt_pkey_index ; attr -> en_sqd_async_notify = cmd -> base . en_sqd_async_notify ; attr -> max_rd_atomic = cmd -> base . max_rd_atomic ; attr -> max_dest_rd_atomic = cmd -> base . max_dest_rd_atomic ; attr -> min_rnr_timer = cmd -> base . min_rnr_timer ; attr -> port_num = cmd -> base . port_num ; attr -> timeout = cmd -> base . timeout ; attr -> retry_cnt = cmd -> base . retry_cnt ; attr -> rnr_retry = cmd -> base . rnr_retry ; attr -> alt_port_num = cmd -> base . alt_port_num ; attr -> alt_timeout = cmd -> base . alt_timeout ; attr -> rate_limit = cmd -> rate_limit ; memcpy ( attr -> ah_attr . grh . dgid . raw , cmd -> base . dest . dgid , 16 ) ; attr -> ah_attr . grh . flow_label = cmd -> base . dest . flow_label ; attr -> ah_attr . grh . sgid_index = cmd -> base . dest . sgid_index ; attr -> ah_attr . grh . hop_limit = cmd -> base . dest . hop_limit ; attr -> ah_attr . grh . traffic_class = cmd -> base . dest . traffic_class ; attr -> ah_attr . dlid = cmd -> base . dest . dlid ; attr -> ah_attr . sl = cmd -> base . dest . sl ; attr -> ah_attr . src_path_bits = cmd -> base . dest . src_path_bits ; attr -> ah_attr . static_rate = cmd -> base . dest . static_rate ; attr -> ah_attr . ah_flags = cmd -> base . dest . is_global ? IB_AH_GRH : 0 ; attr -> ah_attr . port_num = cmd -> base . dest . port_num ; memcpy ( attr -> alt_ah_attr . grh . dgid . raw , cmd -> base . alt_dest . dgid , 16 ) ; attr -> alt_ah_attr . grh . flow_label = cmd -> base . alt_dest . flow_label ; attr -> alt_ah_attr . grh . sgid_index = cmd -> base . alt_dest . sgid_index ; attr -> alt_ah_attr . grh . hop_limit = cmd -> base . alt_dest . hop_limit ; attr -> alt_ah_attr . grh . traffic_class = cmd -> base . alt_dest . traffic_class ; attr -> alt_ah_attr . dlid = cmd -> base . alt_dest . dlid ; attr -> alt_ah_attr . sl = cmd -> base . alt_dest . sl ; attr -> alt_ah_attr . src_path_bits = cmd -> base . alt_dest . src_path_bits ; attr -> alt_ah_attr . static_rate = cmd -> base . alt_dest . static_rate ; attr -> alt_ah_attr . ah_flags = cmd -> base . alt_dest . is_global ? IB_AH_GRH : 0 ; attr -> alt_ah_attr . port_num = cmd -> base . alt_dest . port_num ; if ( qp -> real_qp == qp ) { if ( cmd -> base . attr_mask & IB_QP_AV ) { ret = ib_resolve_eth_dmac ( qp -> device , & attr -> ah_attr ) ; if ( ret ) goto release_qp ; } ret = qp -> device -> modify_qp ( qp , attr , modify_qp_mask ( qp -> qp_type , cmd -> base . attr_mask ) , udata ) ; } else { ret = ib_modify_qp ( qp , attr , modify_qp_mask ( qp -> qp_type , cmd -> base . attr_mask ) ) ; } release_qp : put_qp_read ( qp ) ; out : kfree ( attr ) ; return ret ; } | <S2SV_ModStart> out ; } if ( ! rdma_is_port_valid ( qp -> device , cmd -> base . port_num ) ) { ret = - EINVAL ; goto release_qp ; } |
687 | CWE-000 int main ( int argc , char * * argv ) { test_disabled_rules ( ) ; test_file_descriptor ( ) ; test_max_string_per_rules ( ) ; test_max_match_data ( ) ; test_include_callback ( ) ; test_save_load_rules ( ) ; test_scanner ( ) ; test_ast_callback ( ) ; <S2SV_StartBug> test_issue_834 ( ) ; <S2SV_EndBug> <S2SV_StartBug> test_rules_stats ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( ) ; test_rules_stats ( ) ; <S2SV_ModStart> ( ) ; test_issue_920 <S2SV_ModEnd> ( ) ; |
688 | CWE-000 static inline void m25p_pagewrite ( struct m25p_dev_s * priv , FAR const uint8_t * buffer , off_t page ) { off_t offset = page << priv -> pageshift ; finfo ( "page:<S2SV_blank>%08lx<S2SV_blank>offset:<S2SV_blank>%08lx\\n" , ( long ) page , ( long ) offset ) ; m25p_waitwritecomplete ( priv ) ; <S2SV_StartBug> m25p_writeenable ( priv ) ; <S2SV_EndBug> SPI_SELECT ( priv -> dev , SPIDEV_FLASH ( 0 ) , true ) ; ( void ) SPI_SEND ( priv -> dev , M25P_PP ) ; ( void ) SPI_SEND ( priv -> dev , ( offset >> 16 ) & 0xff ) ; ( void ) SPI_SEND ( priv -> dev , ( offset >> 8 ) & 0xff ) ; ( void ) SPI_SEND ( priv -> dev , offset & 0xff ) ; SPI_SNDBLOCK ( priv -> dev , buffer , 1 << priv -> pageshift ) ; SPI_SELECT ( priv -> dev , SPIDEV_FLASH ( 0 ) , false ) ; <S2SV_StartBug> finfo ( "Written\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> m25p_writeenable ( priv ) ; m25p_lock ( priv -> dev <S2SV_ModStart> false ) ; m25p_unlock ( priv -> dev ) ; |
689 | CWE-000 void vic_image_init ( void ) { extern dmy_struct * dmy ; extern global_param_struct global_param ; extern filenames_struct filenames ; <S2SV_StartBug> initialize_time ( ) ; <S2SV_EndBug> dmy = make_dmy ( & global_param ) ; vic_init ( ) ; <S2SV_StartBug> close_nc ( filenames . params ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> filenames_struct filenames ; extern int mpi_rank ; <S2SV_ModStart> ( ) ; if ( mpi_rank == VIC_MPI_ROOT ) { <S2SV_ModStart> ) ; } } |
690 | CWE-000 pmix_status_t pmix_server_commit ( pmix_peer_t * peer , pmix_buffer_t * buf ) { int32_t cnt ; pmix_status_t rc ; pmix_buffer_t * b2 ; pmix_kval_t * kp ; pmix_scope_t scope ; pmix_hash_table_t * ht ; pmix_nspace_t * nptr ; pmix_rank_info_t * info ; pmix_dmdx_remote_t * dcd , * dcdnext ; pmix_buffer_t * pbkt ; pmix_value_t * val ; char * data ; size_t sz ; info = peer -> info ; nptr = info -> nptr ; pmix_output_verbose ( 2 , pmix_globals . debug_output , "%s:%d<S2SV_blank>EXECUTE<S2SV_blank>COMMIT<S2SV_blank>FOR<S2SV_blank>%s:%d" , pmix_globals . myid . nspace , pmix_globals . myid . rank , nptr -> nspace , info -> rank ) ; cnt = 1 ; while ( PMIX_SUCCESS == ( rc = pmix_bfrop . unpack ( buf , & scope , & cnt , PMIX_SCOPE ) ) ) { if ( PMIX_LOCAL == scope ) { ht = & nptr -> server -> mylocal ; } else if ( PMIX_REMOTE == scope ) { ht = & nptr -> server -> myremote ; } else { PMIX_ERROR_LOG ( PMIX_ERR_BAD_PARAM ) ; rc = PMIX_ERR_BAD_PARAM ; return rc ; } cnt = 1 ; if ( PMIX_SUCCESS != ( rc = pmix_bfrop . unpack ( buf , & b2 , & cnt , PMIX_BUFFER ) ) ) { PMIX_ERROR_LOG ( rc ) ; return rc ; } kp = PMIX_NEW ( pmix_kval_t ) ; kp -> key = strdup ( "modex" ) ; PMIX_VALUE_CREATE ( kp -> value , 1 ) ; kp -> value -> type = PMIX_BYTE_OBJECT ; # if defined ( PMIX_ENABLE_DSTORE ) && ( PMIX_ENABLE_DSTORE == 1 ) if ( PMIX_LOCAL == scope ) { PMIX_UNLOAD_BUFFER ( b2 , kp -> value -> data . bo . bytes , kp -> value -> data . bo . size ) ; if ( PMIX_SUCCESS != ( rc = pmix_dstore_store ( nptr -> nspace , info -> rank , kp ) ) ) { PMIX_ERROR_LOG ( rc ) ; } <S2SV_StartBug> PMIX_RELEASE ( kp ) ; <S2SV_EndBug> kp = PMIX_NEW ( pmix_kval_t ) ; kp -> key = strdup ( "modex" ) ; PMIX_VALUE_CREATE ( kp -> value , 1 ) ; kp -> value -> type = PMIX_BYTE_OBJECT ; } # endif if ( PMIX_SUCCESS == pmix_hash_fetch ( ht , info -> rank , "modex" , & val ) && NULL != val ) { kp -> value -> data . bo . bytes = ( char * ) malloc ( b2 -> bytes_used + val -> data . bo . size ) ; memcpy ( kp -> value -> data . bo . bytes , val -> data . bo . bytes , val -> data . bo . size ) ; memcpy ( kp -> value -> data . bo . bytes + val -> data . bo . size , b2 -> base_ptr , b2 -> bytes_used ) ; kp -> value -> data . bo . size = val -> data . bo . size + b2 -> bytes_used ; PMIX_VALUE_FREE ( val , 1 ) ; } else { PMIX_UNLOAD_BUFFER ( b2 , kp -> value -> data . bo . bytes , kp -> value -> data . bo . size ) ; } if ( PMIX_SUCCESS != ( rc = pmix_hash_store ( ht , info -> rank , kp ) ) ) { PMIX_ERROR_LOG ( rc ) ; } PMIX_RELEASE ( kp ) ; PMIX_RELEASE ( b2 ) ; cnt = 1 ; } if ( PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER != rc ) { PMIX_ERROR_LOG ( rc ) ; return rc ; } rc = PMIX_SUCCESS ; info -> modex_recvd = true ; PMIX_LIST_FOREACH_SAFE ( dcd , dcdnext , & pmix_server_globals . remote_pnd , pmix_dmdx_remote_t ) { if ( 0 != strncmp ( dcd -> cd -> proc . nspace , nptr -> nspace , PMIX_MAX_NSLEN ) ) { continue ; } if ( dcd -> cd -> proc . rank == info -> rank ) { pbkt = PMIX_NEW ( pmix_buffer_t ) ; if ( PMIX_SUCCESS == pmix_hash_fetch ( & nptr -> server -> myremote , info -> rank , "modex" , & val ) && NULL != val ) { PMIX_LOAD_BUFFER ( pbkt , val -> data . bo . bytes , val -> data . bo . size ) ; PMIX_VALUE_RELEASE ( val ) ; } PMIX_UNLOAD_BUFFER ( pbkt , data , sz ) ; PMIX_RELEASE ( pbkt ) ; dcd -> cd -> cbfunc ( PMIX_SUCCESS , data , sz , dcd -> cd -> cbdata ) ; if ( NULL != data ) { free ( data ) ; } pmix_list_remove_item ( & pmix_server_globals . remote_pnd , & dcd -> super ) ; PMIX_RELEASE ( dcd ) ; } } return pmix_pending_resolve ( nptr , info -> rank , PMIX_SUCCESS , NULL ) ; } | <S2SV_ModStart> ) ; } PMIX_LOAD_BUFFER ( b2 , kp -> value -> data . bo . bytes , kp -> value -> data . bo . size ) ; kp -> value -> data . bo . bytes = NULL ; kp -> value -> data . bo . size = 0 <S2SV_ModEnd> ; } # |
691 | CWE-000 static void fpf_presspwr ( struct work_struct * fpf_presspwr_work ) { unsigned int squeeze_reg_diff = 0 ; if ( ! mutex_trylock ( & pwrkeyworklock ) ) return ; if ( wait_for_squeeze_power ) { wait_for_squeeze_power = 0 ; if ( screen_on ) { msleep ( 30 ) ; squeeze_reg_diff = jiffies - last_squeeze_power_registration_jiffies ; pr_info ( "%s<S2SV_blank>squeeze_reg_diff<S2SV_blank>%u\\n" , __func__ , squeeze_reg_diff ) ; <S2SV_StartBug> if ( squeeze_reg_diff < 4 ) goto exit ; <S2SV_EndBug> } } input_event ( fpf_pwrdev , EV_KEY , KEY_POWER , 1 ) ; input_event ( fpf_pwrdev , EV_SYN , 0 , 0 ) ; msleep ( fpf_PWRKEY_DUR ) ; input_event ( fpf_pwrdev , EV_KEY , KEY_POWER , 0 ) ; input_event ( fpf_pwrdev , EV_SYN , 0 , 0 ) ; msleep ( fpf_PWRKEY_DUR / 2 ) ; do_home_button_off_too_in_work_func = 0 ; exit : mutex_unlock ( & pwrkeyworklock ) ; return ; } | <S2SV_ModStart> squeeze_reg_diff < 4 * JIFFY_MUL |
692 | CWE-000 static void test_iterator_initial_restore ( ) { header ( ) ; plan ( 3 ) ; uint32_t fields [ ] = { 0 } ; uint32_t types [ ] = { FIELD_TYPE_UNSIGNED } ; struct key_def * key_def = box_key_def_new ( fields , types , 1 ) ; assert ( key_def != NULL ) ; struct tuple_format * format = tuple_format_new ( & vy_tuple_format_vtab , & key_def , 1 , 0 ) ; assert ( format != NULL ) ; struct tuple_format * format_with_colmask = vy_tuple_format_new_with_colmask ( format ) ; assert ( format_with_colmask != NULL ) ; struct tuple_format * format_upsert = vy_tuple_format_new_upsert ( format ) ; assert ( format_upsert != NULL ) ; struct lsregion lsregion ; struct slab_cache * slab_cache = cord_slab_cache ( ) ; lsregion_create ( & lsregion , slab_cache -> arena ) ; int64_t generation = 1 ; struct vy_mem * mem = vy_mem_new ( & lsregion , generation , key_def , format , format_with_colmask , format_upsert , 0 ) ; const uint64_t count = 100 ; for ( uint64_t i = 0 ; i < count ; i ++ ) { const struct vy_stmt_template stmts [ 2 ] = { STMT_TEMPLATE ( 200 , REPLACE , i * 2 + 1 ) , STMT_TEMPLATE ( 300 , REPLACE , i * 2 + 1 ) } ; vy_mem_insert_template ( mem , & stmts [ 0 ] ) ; vy_mem_insert_template ( mem , & stmts [ 1 ] ) ; } bool wrong_rc = false ; bool wrong_lsn = false ; bool wrong_value = false ; int i_fail = 0 ; for ( uint64_t i = 0 ; i < ( count * 2 + 1 ) * 3 ; i ++ ) { uint64_t key = i % ( count * 2 + 1 ) ; int64_t lsn = ( i / ( count * 2 + 1 ) ) * 100 + 100 ; bool value_is_expected = lsn != 100 && ( key % 2 == 1 ) ; char data [ 16 ] ; char * end = data ; end = mp_encode_uint ( end , key ) ; assert ( end <= data + sizeof ( data ) ) ; struct tuple * stmt = vy_stmt_new_select ( mem -> format , data , 1 ) ; struct vy_mem_iterator itr ; <S2SV_StartBug> struct vy_mem_iterator_stat stats = { 0 } ; <S2SV_EndBug> struct vy_read_view rv ; rv . vlsn = lsn ; const struct vy_read_view * prv = & rv ; vy_mem_iterator_open ( & itr , & stats , mem , ITER_EQ , stmt , & prv , NULL ) ; struct tuple * t ; bool stop = false ; int rc = itr . base . iface -> restore ( & itr . base , NULL , & t , & stop ) ; if ( rc != 0 ) { wrong_rc = true ; i_fail = i ; itr . base . iface -> cleanup ( & itr . base ) ; itr . base . iface -> close ( & itr . base ) ; continue ; } if ( value_is_expected ) { if ( t == NULL ) { wrong_value = true ; i_fail = i ; itr . base . iface -> cleanup ( & itr . base ) ; itr . base . iface -> close ( & itr . base ) ; continue ; } if ( vy_stmt_lsn ( t ) != lsn ) { wrong_lsn = true ; i_fail = i ; } uint32_t got_val ; if ( tuple_field_u32 ( t , 0 , & got_val ) || got_val != key ) { wrong_value = true ; i_fail = i ; } } else { if ( t != NULL ) { wrong_value = true ; i_fail = i ; } } itr . base . iface -> cleanup ( & itr . base ) ; itr . base . iface -> close ( & itr . base ) ; tuple_unref ( stmt ) ; } ok ( ! wrong_rc , "check<S2SV_blank>rc<S2SV_blank>%d" , i_fail ) ; ok ( ! wrong_lsn , "check<S2SV_blank>lsn<S2SV_blank>%d" , i_fail ) ; ok ( ! wrong_value , "check<S2SV_blank>value<S2SV_blank>%d" , i_fail ) ; vy_mem_delete ( mem ) ; lsregion_destroy ( & lsregion ) ; box_key_def_delete ( key_def ) ; fiber_gc ( ) ; check_plan ( ) ; footer ( ) ; } | <S2SV_ModStart> = { 0 , { 0 , 0 } |
693 | CWE-000 <S2SV_StartBug> void readyQueuePush ( thread_t thread ) { <S2SV_EndBug> calcNewPriority ( thread ) ; int priority = thread -> priority ; uint32_t cpuIndex = thread -> cpuAffinity ; if ( cpuInfos [ thread -> cpuAffinity ] . threadLoad ) { for ( unsigned int i = 0 ; i < nrofCPUs ; i ++ ) { if ( cpuInfos [ i ] . active && cpuInfos [ i ] . threadLoad == 0 ) { cpuIndex = i ; thread -> cpuAffinity = i ; break ; } } } acquireSpinlock ( & cpuInfos [ cpuIndex ] . readyListLock ) ; cpuInfos [ cpuIndex ] . threadLoad += NROF_QUEUE_PRIORITIES - priority ; cpuInfos [ cpuIndex ] . nrofReadyThreads ++ ; threadQueuePush ( & cpuInfos [ cpuIndex ] . readyList [ priority ] , thread ) ; releaseSpinlock ( & cpuInfos [ cpuIndex ] . readyListLock ) ; if ( pcpuRead32 ( cpuInfosIndex ) != cpuIndex ) { lapicSendIPI ( cpuInfos [ cpuIndex ] . apicID , RESCHED_VEC , IPI_FIXED ) ; } } | <S2SV_ModStart> thread ) { thread -> state = THREADSTATE_SCHEDWAIT ; |
694 | CWE-000 int main ( int argc , char * * argv ) { pcap_t * in_handle ; pcap_dumper_t * out_handle ; const unsigned char * packet ; char errbuf [ PCAP_ERRBUF_SIZE ] ; struct pcap_pkthdr * pcap_hdr ; int ret ; ++ argv ; -- argc ; if ( argc != 1 ) { <S2SV_StartBug> usage ( ) ; <S2SV_EndBug> fprintf ( stderr , "The<S2SV_blank>input<S2SV_blank>trace<S2SV_blank>file<S2SV_blank>is<S2SV_blank>missing." "Expected<S2SV_blank>.pcap<S2SV_blank>file<S2SV_blank>as<S2SV_blank>input<S2SV_blank>argument.\\n" ) ; return EXIT_FAILURE ; } struct bpf_map_def * current = tables ; while ( current -> name != 0 ) { registry_add ( current ) ; current ++ ; } in_handle = pcap_open_offline ( argv [ 0 ] , errbuf ) ; if ( in_handle == NULL ) { pcap_perror ( in_handle , "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>pcap<S2SV_blank>file<S2SV_blank>" ) ; return EXIT_FAILURE ; } char * in_file = strdup ( argv [ 0 ] ) ; char * in_dir = dirname ( in_file ) ; int in_dir_len = strlen ( in_dir ) ; char * out_file = calloc ( in_dir_len + strlen ( "/pcapxxxx_out.pcap" ) , 1 ) ; memcpy ( out_file , in_dir , in_dir_len ) ; memcpy ( out_file + in_dir_len , "/pcap0_out.pcap" , strlen ( "/pcap0_out.pcap" ) ) ; out_handle = pcap_dump_open ( in_handle , out_file ) ; if ( out_handle == NULL ) { pcap_perror ( in_handle , "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>pcap<S2SV_blank>file<S2SV_blank>" ) ; pcap_close ( in_handle ) ; free ( out_file ) ; return EXIT_FAILURE ; } while ( ( ret = pcap_next_ex ( in_handle , & pcap_hdr , & packet ) ) == 1 ) { struct sk_buff skb ; skb . data = ( void * ) packet ; skb . len = pcap_hdr -> len ; int result = ebpf_filter ( & skb ) ; if ( result ) pcap_dump ( ( unsigned char * ) out_handle , pcap_hdr , packet ) ; printf ( "\\nResult<S2SV_blank>of<S2SV_blank>the<S2SV_blank>eBPF<S2SV_blank>parsing<S2SV_blank>is:<S2SV_blank>%d\\n" , result ) ; } if ( ret == - 1 ) pcap_perror ( in_handle , "Error:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>" ) ; pcap_close ( in_handle ) ; pcap_dump_close ( out_handle ) ; free ( out_file ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> { usage ( <S2SV_ModEnd> ) ; return |
695 | CWE-000 void * CONNECTION_dataListener ( void * arg ) { char * buffer = NULL ; Packet packet ; char convert [ 10 ] ; arg = arg ; if ( ( socketData = NETWORK_createConnectionClient ( atoi ( enterprise . config . data_port ) , enterprise . config . data_ip ) ) < 0 ) { write ( 1 , ERR_CONNECTION , strlen ( ERR_CONNECTION ) ) ; raise ( SIGUSR1 ) ; } else { if ( CONNECTION_connectData ( ) > 0 ) { while ( 1 ) { <S2SV_StartBug> sleep ( ( unsigned int ) enterprise . restaurant . seconds ) ; <S2SV_EndBug> if ( ( socketData = NETWORK_createConnectionClient ( atoi ( enterprise . config . data_port ) , enterprise . config . data_ip ) ) < 0 ) { write ( 1 , UPDATE_ERR , strlen ( UPDATE_ERR ) ) ; break ; } else { memset ( convert , 0 , 10 ) ; pthread_mutex_lock ( & mtx ) ; sprintf ( convert , "%d" , enterprise . clients . elements ) ; pthread_mutex_unlock ( & mtx ) ; buffer = UTILS_createBuffer ( 2 , enterprise . config . picard_port , convert ) ; packet = NETWORK_createPacket ( UPDATE , HEADER_EUPDATE , ( unsigned short ) strlen ( buffer ) , buffer ) ; if ( buffer != NULL ) free ( buffer ) ; NETWORK_sendSerialized ( socketData , packet ) ; NETWORK_freePacket ( & packet ) ; packet = NETWORK_extractIncomingFrame ( socketData ) ; if ( packet . type != ( UPDATE ) ) { write ( 1 , UPDATE_ERR , strlen ( UPDATE_ERR ) ) ; close ( socketData ) ; break ; } NETWORK_freePacket ( & packet ) ; <S2SV_StartBug> close ( socketData ) ; <S2SV_EndBug> } } } } pthread_exit ( EXIT_SUCCESS ) ; } | <S2SV_ModStart> 1 ) { if ( socketData > 0 ) close ( socketData ) ; <S2SV_ModStart> packet ) ; <S2SV_ModEnd> } } } |
696 | CWE-000 int drm_agp_free ( struct drm_device * dev , struct drm_agp_buffer * request ) { struct drm_agp_mem * entry ; if ( ! dev -> agp || ! dev -> agp -> acquired ) return - EINVAL ; <S2SV_StartBug> if ( ! ( entry = drm_agp_lookup_entry ( dev , request -> handle ) ) ) <S2SV_EndBug> return - EINVAL ; if ( entry -> bound ) drm_unbind_agp ( entry -> memory ) ; list_del ( & entry -> head ) ; drm_free_agp ( entry -> memory , entry -> pages ) ; kfree ( entry ) ; return 0 ; } | <S2SV_ModStart> - EINVAL ; <S2SV_ModEnd> entry = drm_agp_lookup_entry <S2SV_ModStart> -> handle ) ; if ( ! entry <S2SV_ModEnd> ) return - |
697 | CWE-000 static void handle_req ( struct daemon_remote * rc , struct rc_state * s , RES * res ) { int r ; char pre [ 10 ] ; char magic [ 7 ] ; char buf [ 1024 ] ; # ifdef USE_WINSOCK WSAEventSelect ( s -> c -> fd , NULL , 0 ) ; # endif fd_set_block ( s -> c -> fd ) ; if ( res -> ssl ) { ERR_clear_error ( ) ; if ( ( r = SSL_read ( res -> ssl , magic , ( int ) sizeof ( magic ) - 1 ) ) <= 0 ) { if ( SSL_get_error ( res -> ssl , r ) == SSL_ERROR_ZERO_RETURN ) return ; log_crypto_err ( "could<S2SV_blank>not<S2SV_blank>SSL_read" ) ; return ; } } else { while ( 1 ) { <S2SV_StartBug> ssize_t rr = read ( res -> fd , magic , sizeof ( magic ) - 1 ) ; <S2SV_EndBug> if ( rr <= 0 ) { if ( rr == 0 ) return ; if ( errno == EINTR || errno == EAGAIN ) continue ; <S2SV_StartBug> log_err ( "could<S2SV_blank>not<S2SV_blank>read:<S2SV_blank>%s" , strerror ( errno ) ) ; <S2SV_EndBug> return ; } r = ( int ) rr ; break ; } } magic [ 6 ] = 0 ; if ( r != 6 || strncmp ( magic , "UBCT" , 4 ) != 0 ) { verbose ( VERB_QUERY , "control<S2SV_blank>connection<S2SV_blank>has<S2SV_blank>bad<S2SV_blank>magic<S2SV_blank>string" ) ; return ; } if ( ! ssl_read_line ( res , buf , sizeof ( buf ) ) ) { return ; } snprintf ( pre , sizeof ( pre ) , "UBCT%d<S2SV_blank>" , UNBOUND_CONTROL_VERSION ) ; if ( strcmp ( magic , pre ) != 0 ) { verbose ( VERB_QUERY , "control<S2SV_blank>connection<S2SV_blank>had<S2SV_blank>bad<S2SV_blank>" "version<S2SV_blank>%s,<S2SV_blank>cmd:<S2SV_blank>%s" , magic , buf ) ; ssl_printf ( res , "error<S2SV_blank>version<S2SV_blank>mismatch\\n" ) ; return ; } verbose ( VERB_DETAIL , "control<S2SV_blank>cmd:<S2SV_blank>%s" , buf ) ; execute_cmd ( rc , res , buf , rc -> worker ) ; } | <S2SV_ModStart> ssize_t rr = recv <S2SV_ModEnd> ( res -> <S2SV_ModStart> ) - 1 , 0 <S2SV_ModStart> ) continue ; # ifndef USE_WINSOCK log_err ( "could<S2SV_blank>not<S2SV_blank>recv:<S2SV_blank>%s" <S2SV_ModEnd> , strerror ( <S2SV_ModStart> ) ) ; # else log_err ( "could<S2SV_blank>not<S2SV_blank>recv:<S2SV_blank>%s" , wsa_strerror ( WSAGetLastError ( ) ) ) ; # endif |
698 | CWE-000 ssize_t UNIFYCR_WRAP ( write ) ( int fd , const void * buf , size_t count ) { ssize_t ret ; if ( unifycr_intercept_fd ( & fd ) ) { unifycr_fd_t * filedesc = unifycr_get_filedesc_from_fd ( fd ) ; if ( filedesc == NULL ) { errno = EBADF ; return ( ssize_t ) ( - 1 ) ; } if ( fs_type != UNIFYCR_LOG ) { int write_rc = unifycr_fd_write ( fd , filedesc -> pos , buf , count ) ; if ( write_rc != UNIFYCR_SUCCESS ) { errno = unifycr_err_map_to_errno ( write_rc ) ; return ( ssize_t ) ( - 1 ) ; } } else { fd += unifycr_fd_limit ; <S2SV_StartBug> pwrite ( fd , buf , count , filedesc -> pos ) ; <S2SV_EndBug> } filedesc -> pos += count ; ret = count ; } else { MAP_OR_FAIL ( write ) ; ret = UNIFYCR_REAL ( write ) ( fd , buf , count ) ; } return ret ; } | <S2SV_ModStart> += unifycr_fd_limit ; if ( <S2SV_ModStart> -> pos ) < 0 ) return - 1 |
699 | CWE-000 size_t pn_delivery_pending ( pn_delivery_t * delivery ) <S2SV_StartBug> { <S2SV_EndBug> return pn_buffer_size ( delivery -> bytes ) ; } | <S2SV_ModStart> delivery ) { if ( delivery -> aborted ) return 1 ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.