Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
2,200 | CWE-000 unsigned int get_winer ( t_env * env ) { unsigned int win ; win = env -> no - 1 ; while ( -- env -> no >= 0 ) { if ( env -> players [ env -> no ] . num_players == env -> winer ) { win = env -> no ; break ; } } <S2SV_StartBug> message_cw ( env , "Contestant<S2SV_blank>%d,<S2SV_blank>\\"%s\\",<S2SV_blank>has<S2SV_blank>won<S2SV_blank>!" , <S2SV_EndBug> env -> players [ win ] . num_players , env -> players [ win ] . header . prog_name ) ; <S2SV_StartBug> return ( win ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( env , "Contestant<S2SV_blank>%d,<S2SV_blank>\\"%.20s...\\",<S2SV_blank>has<S2SV_blank>won<S2SV_blank>!" <S2SV_ModEnd> , env -> <S2SV_ModStart> prog_name ) ; message_cw2 ( env , "Pres<S2SV_blank>Esc<S2SV_blank>to<S2SV_blank>quit." ) ; |
2,201 | CWE-000 static struct drm_master * drm_lease_create ( struct drm_master * lessor , struct idr * leases ) { struct drm_device * dev = lessor -> dev ; int error ; struct drm_master * lessee ; int object ; int id ; void * entry ; DRM_DEBUG_LEASE ( "lessor<S2SV_blank>%d\\n" , lessor -> lessee_id ) ; lessee = drm_master_create ( lessor -> dev ) ; if ( ! lessee ) { DRM_DEBUG_LEASE ( "drm_master_create<S2SV_blank>failed\\n" ) ; return ERR_PTR ( - ENOMEM ) ; } mutex_lock ( & dev -> mode_config . idr_mutex ) ; <S2SV_StartBug> id = idr_alloc ( & ( drm_lease_owner ( lessor ) -> lessee_idr ) , lessee , 1 , 0 , GFP_KERNEL ) ; <S2SV_EndBug> if ( id < 0 ) { error = id ; goto out_lessee ; } lessee -> lessee_id = id ; lessee -> lessor = drm_master_get ( lessor ) ; list_add_tail ( & lessee -> lessee_list , & lessor -> lessees ) ; idr_for_each_entry ( leases , entry , object ) { error = 0 ; if ( ! idr_find ( & dev -> mode_config . crtc_idr , object ) ) error = - ENOENT ; else if ( ! _drm_lease_held_master ( lessor , object ) ) error = - EACCES ; else if ( _drm_has_leased ( lessor , object ) ) error = - EBUSY ; if ( error != 0 ) { DRM_DEBUG_LEASE ( "object<S2SV_blank>%d<S2SV_blank>failed<S2SV_blank>%d\\n" , object , error ) ; goto out_lessee ; } } <S2SV_StartBug> lessee -> leases = * leases ; <S2SV_EndBug> DRM_DEBUG_LEASE ( "new<S2SV_blank>lessee<S2SV_blank>%d<S2SV_blank>%p,<S2SV_blank>lessor<S2SV_blank>%d<S2SV_blank>%p\\n" , lessee -> lessee_id , lessee , lessor -> lessee_id , lessor ) ; mutex_unlock ( & dev -> mode_config . idr_mutex ) ; return lessee ; out_lessee : mutex_unlock ( & dev -> mode_config . idr_mutex ) ; drm_master_put ( & lessee ) ; return ERR_PTR ( error ) ; } | <S2SV_ModStart> idr_mutex ) ; <S2SV_ModEnd> idr_for_each_entry ( leases <S2SV_ModStart> ; } } id = idr_alloc ( & ( drm_lease_owner ( lessor ) -> lessee_idr ) , lessee , 1 , 0 , GFP_KERNEL ) ; if ( id < 0 ) { error = id ; goto out_lessee ; } lessee -> lessee_id = id ; lessee -> lessor = drm_master_get ( lessor ) ; list_add_tail ( & lessee -> lessee_list , & lessor -> lessees ) ; |
2,202 | CWE-000 int main ( int argc , char * argv [ ] ) { int i , cc , fd ; u32 rootino , inum , off ; struct dirent de ; char buf [ BSIZE ] ; struct dinode din ; int nblocks ; if ( argc < 2 ) { fprintf ( stderr , "Usage:<S2SV_blank>mkfs<S2SV_blank>fs.img<S2SV_blank>files...\\n" ) ; exit ( 1 ) ; } assert ( ( BSIZE % sizeof ( struct dinode ) ) == 0 ) ; assert ( ( BSIZE % sizeof ( struct dirent ) ) == 0 ) ; fsfd = open ( argv [ 1 ] , O_RDWR | O_CREAT | O_TRUNC , 0666 ) ; if ( fsfd < 0 ) { perror ( argv [ 1 ] ) ; exit ( 1 ) ; } <S2SV_StartBug> bitblocks = ( size + BSIZE * 8 - 1 ) / ( BSIZE * 8 ) ; <S2SV_EndBug> usedblocks = ninodes / IPB + 3 + bitblocks ; freeblock = usedblocks ; nblocks = size - usedblocks ; printf ( "used<S2SV_blank>%d<S2SV_blank>(bit<S2SV_blank>%d<S2SV_blank>ninode<S2SV_blank>%zu)<S2SV_blank>free<S2SV_blank>%u<S2SV_blank>total<S2SV_blank>%d\\n" , usedblocks , bitblocks , ninodes / IPB + 1 , freeblock , nblocks + usedblocks ) ; for ( i = 0 ; i < nblocks + usedblocks ; i ++ ) wsect ( i , zeroes ) ; sb . size = xint ( size ) ; sb . nblocks = xint ( nblocks ) ; sb . ninodes = xint ( ninodes ) ; memset ( buf , 0 , sizeof ( buf ) ) ; memmove ( buf , & sb , sizeof ( sb ) ) ; wsect ( 1 , buf ) ; rootino = ialloc ( T_DIR ) ; assert ( rootino == ROOTINO ) ; bzero ( & de , sizeof ( de ) ) ; de . inum = xshort ( rootino ) ; strcpy ( de . name , "." ) ; iappend ( rootino , & de , sizeof ( de ) ) ; bzero ( & de , sizeof ( de ) ) ; de . inum = xshort ( rootino ) ; strcpy ( de . name , ".." ) ; iappend ( rootino , & de , sizeof ( de ) ) ; for ( i = 2 ; i < argc ; i ++ ) { if ( ( fd = open ( argv [ i ] , 0 ) ) < 0 ) { perror ( argv [ i ] ) ; exit ( 1 ) ; } if ( index ( argv [ i ] , '/' ) ) argv [ i ] = rindex ( argv [ i ] , '/' ) + 1 ; if ( argv [ i ] [ 0 ] == '_' ) ++ argv [ i ] ; inum = ialloc ( T_FILE ) ; bzero ( & de , sizeof ( de ) ) ; de . inum = xshort ( inum ) ; strncpy ( de . name , argv [ i ] , DIRSIZ ) ; iappend ( rootino , & de , sizeof ( de ) ) ; while ( ( cc = read ( fd , buf , sizeof ( buf ) ) ) > 0 ) iappend ( inum , buf , cc ) ; close ( fd ) ; } rinode ( rootino , & din ) ; off = xint ( din . size ) ; off = ( ( off / BSIZE ) + 1 ) * BSIZE ; din . size = xint ( off ) ; winode ( rootino , & din ) ; balloc ( usedblocks ) ; exit ( 0 ) ; } | <S2SV_ModStart> ) ; } ftruncate ( fsfd , 128 * 1024 * 1024 ) ; |
2,203 | CWE-000 void count_syscall ( struct tcb * tcp , const struct timeval * syscall_exiting_tv ) { struct timeval wtv ; struct timeval * tv = & wtv ; struct call_counts * cc ; if ( ! scno_in_range ( tcp -> scno ) ) return ; if ( ! counts ) counts = xcalloc ( nsyscalls , sizeof ( * counts ) ) ; cc = & counts [ tcp -> scno ] ; cc -> calls ++ ; if ( syserror ( tcp ) ) cc -> errors ++ ; tv_sub ( tv , syscall_exiting_tv , & tcp -> etime ) ; if ( tv_cmp ( tv , & tcp -> dtime ) > 0 ) { static struct timeval one_tick = { - 1 , 0 } ; if ( one_tick . tv_sec == - 1 ) { struct itimerval it ; <S2SV_StartBug> memset ( & it , 0 , sizeof it ) ; <S2SV_EndBug> it . it_interval . tv_usec = 1 ; setitimer ( ITIMER_REAL , & it , NULL ) ; getitimer ( ITIMER_REAL , & it ) ; one_tick = it . it_interval ; } if ( tv_nz ( & tcp -> dtime ) ) tv = & tcp -> dtime ; else if ( tv_cmp ( tv , & one_tick ) > 0 ) { if ( tv_cmp ( & shortest , & one_tick ) < 0 ) tv = & shortest ; else tv = & one_tick ; } } if ( tv_cmp ( tv , & shortest ) < 0 ) shortest = * tv ; tv_add ( & cc -> time , & cc -> time , count_wallclock ? & wtv : tv ) ; } | <S2SV_ModStart> 0 , sizeof ( it ) <S2SV_ModEnd> ) ; it |
2,204 | CWE-000 void setUp ( void ) { FFF_RESET_HISTORY ( ) ; RESET_FAKE ( read_some ) ; RESET_FAKE ( write_some ) ; RESET_FAKE ( close ) ; RESET_FAKE ( dummy_read_handler ) ; RESET_FAKE ( second_dummy_read_handler ) ; RESET_FAKE ( dummy_write_handler ) ; memset ( first_check_buffer , 0xaf , sizeof ( first_check_buffer ) ) ; first_check_buffer_pos = 0 ; memset ( second_check_buffer , 0xaf , sizeof ( second_check_buffer ) ) ; second_check_buffer_pos = 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; chunk_bytes_written = 0 ; |
2,205 | CWE-000 <S2SV_StartBug> int esp108_apptrace_write_ctrl_reg ( struct target * target , uint32_t block_id , uint32_t len , int conn , int data ) <S2SV_EndBug> { int res = ERROR_OK ; uint32_t tmp = ( conn ? ESP_APPTRACE_HOST_CONNECT : 0 ) | ( data ? ESP_APPTRACE_HOST_DATA : 0 ) | ESP_APPTRACE_BLOCK_ID ( block_id ) | ESP_APPTRACE_BLOCK_LEN ( len ) ; esp108_queue_nexus_reg_write ( target , ESP_APPTRACE_TRAX_CTRL_REG , tmp ) ; esp108_queue_tdi_idle ( target ) ; res = jtag_execute_queue ( ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>exec<S2SV_blank>JTAG<S2SV_blank>queue!" ) ; return res ; } return ERROR_OK ; } | <S2SV_ModStart> uint32_t len , bool conn , bool <S2SV_ModEnd> data ) { |
2,206 | CWE-000 PROCESS_THREAD ( maintenance_process , ev , data ) { PROCESS_BEGIN ( ) ; <S2SV_StartBug> static struct etimer maintenance_timer ; <S2SV_EndBug> PROCESS_PAUSE ( ) ; while ( 1 ) { if ( node_mode == MODE_NORMAL ) { led_off ( LED_A ) ; if ( process_is_running ( & status_send_process ) == 0 ) process_start ( & status_send_process , NULL ) ; if ( process_is_running ( & root_find_process ) == 1 ) process_exit ( & root_find_process ) ; <S2SV_StartBug> if ( non_answered_ping > MAX_NON_ANSWERED_PINGS ) <S2SV_EndBug> { printf ( "DAG<S2SV_blank>Node:<S2SV_blank>Root<S2SV_blank>not<S2SV_blank>available,<S2SV_blank>reboot\\n" ) ; watchdog_reboot ( ) ; } } if ( node_mode == MODE_NOTROOT ) { if ( CLASS == CLASS_B ) { led_off ( LED_A ) ; printf ( "DAG<S2SV_blank>Node:<S2SV_blank>Root<S2SV_blank>not<S2SV_blank>found,<S2SV_blank>sleep\\n" ) ; if ( process_is_running ( & dag_node_button_process ) == 1 ) process_exit ( & dag_node_button_process ) ; if ( process_is_running ( & root_find_process ) == 1 ) process_exit ( & root_find_process ) ; if ( process_is_running ( & status_send_process ) == 1 ) process_exit ( & status_send_process ) ; if ( process_is_running ( & maintenance_process ) == 1 ) process_exit ( & maintenance_process ) ; net_off ( NOW ) ; } if ( CLASS == CLASS_C ) { printf ( "DAG<S2SV_blank>Node:<S2SV_blank>Root<S2SV_blank>not<S2SV_blank>found,<S2SV_blank>reboot\\n" ) ; watchdog_reboot ( ) ; } } if ( node_mode == MODE_JOIN_PROGRESS ) { net_on ( ) ; led_on ( LED_A ) ; if ( process_is_running ( & root_find_process ) == 0 ) process_start ( & root_find_process , NULL ) ; if ( process_is_running ( & status_send_process ) == 1 ) process_exit ( & status_send_process ) ; } etimer_set ( & maintenance_timer , SHORT_STATUS_INTERVAL ) ; PROCESS_WAIT_EVENT_UNTIL ( etimer_expired ( & maintenance_timer ) && node_mode == MODE_NORMAL ) ; } PROCESS_END ( ) ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> PROCESS_PAUSE ( ) <S2SV_ModStart> ; if ( non_answered_packet <S2SV_ModEnd> > MAX_NON_ANSWERED_PINGS ) |
2,207 | CWE-000 int main ( int argc , char * * argv ) { char * manufacturerCostString ; char * markupCostString ; char * salesTaxString ; char * discountString ; printf ( "Enter<S2SV_blank>Manufacturer\'s<S2SV_blank>Cost:<S2SV_blank>\\n" ) ; <S2SV_StartBug> scanf ( "%s" , & manufacturerCostString ) ; <S2SV_EndBug> printf ( "Enter<S2SV_blank>Dealer\'s<S2SV_blank>Markup<S2SV_blank>Cost:<S2SV_blank>\\n" ) ; <S2SV_StartBug> scanf ( "%s" , & markupCostString ) ; <S2SV_EndBug> printf ( "Enter<S2SV_blank>Local<S2SV_blank>Sales<S2SV_blank>Tax<S2SV_blank>Percentage<S2SV_blank>(0.0<S2SV_blank>-<S2SV_blank>100.0):<S2SV_blank>\\n" ) ; <S2SV_StartBug> scanf ( "%s" , & salesTaxString ) ; <S2SV_EndBug> printf ( "Enter<S2SV_blank>Pre<S2SV_blank>Tax<S2SV_blank>Discount<S2SV_blank>Percentage<S2SV_blank>(0.0<S2SV_blank>-<S2SV_blank>100.0):<S2SV_blank>\\n" ) ; <S2SV_StartBug> scanf ( "%s" , & discountString ) ; <S2SV_EndBug> printf ( "\\n" ) ; if ( ! isInteger ( manufacturerCostString ) ) { <S2SV_StartBug> return EXIT_FAILURE ; <S2SV_EndBug> } <S2SV_StartBug> if ( ! isInteger ( markupCostString ) ) { <S2SV_EndBug> return EXIT_FAILURE ; } int manufacturerCost = atoi ( manufacturerCostString ) ; int markupCost = atoi ( markupCostString ) ; double salesTax = atof ( salesTaxString ) ; double discount = atof ( discountString ) ; double finalPrice ; finalPrice = ( manufacturerCost + markupCost ) * ( 1.0 - ( discount / 100.0 ) ) * ( 1.0 + ( salesTax / 100.0 ) ) ; printf ( "Final<S2SV_blank>Estimated<S2SV_blank>Price:<S2SV_blank>%f<S2SV_blank>\\n" , finalPrice ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ( "%s" , <S2SV_ModEnd> manufacturerCostString ) ; <S2SV_ModStart> ( "%s" , <S2SV_ModEnd> markupCostString ) ; <S2SV_ModStart> ( "%s" , <S2SV_ModEnd> salesTaxString ) ; <S2SV_ModStart> ( "%s" , <S2SV_ModEnd> discountString ) ; <S2SV_ModStart> ) ) { printf ( "Manufacturer<S2SV_blank>cost<S2SV_blank>must<S2SV_blank>be<S2SV_blank>an<S2SV_blank>integer!\\n" ) <S2SV_ModStart> ) ) { printf ( "Markup<S2SV_blank>cost<S2SV_blank>must<S2SV_blank>be<S2SV_blank>an<S2SV_blank>integer!\\n" ) |
2,208 | CWE-000 int execute ( char * command ) { char * * argv ; if ( ( command [ 0 ] == '\\0' ) || command [ 0 ] == '\\n' ) return 0 ; pid_t pid ; int status ; int argc ; int fd ; if ( ( pid = fork ( ) ) < 0 ) { perror ( "CRYsh<S2SV_blank>unalbe<S2SV_blank>to<S2SV_blank>fork" ) ; } <S2SV_StartBug> else if ( pid > 0 ) { <S2SV_EndBug> <S2SV_StartBug> argv = get_parse_options ( command , & argc ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ( fd = redirection ( argv [ argc ] ) ) == 0 ) { <S2SV_EndBug> argv [ argc ] = '\\0' ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> else if ( ( fd = redirection ( argv [ argc - 1 ] ) ) == 0 ) { <S2SV_EndBug> argv [ argc - 1 ] = '\\0' ; } <S2SV_StartBug> execvp ( argv [ 0 ] , argv ) ; <S2SV_EndBug> fprintf ( stderr , "crysh:<S2SV_blank>couldn\'t<S2SV_blank>exex<S2SV_blank>%s:<S2SV_blank>%s\\n" , command , strerror ( errno ) ) ; exit ( EX_DATAERR ) ; } if ( ( pid = waitpid ( pid , & status , 0 ) ) < 0 ) fprintf ( stderr , "CRYsh:<S2SV_blank>waitpid<S2SV_blank>error:<S2SV_blank>%s<S2SV_blank>\\n" , strerror ( errno ) ) ; return 0 ; } | <S2SV_ModStart> if ( pid == 0 ) { argv = get_parse_options ( command , & argc ) ; if ( argc <S2SV_ModStart> 0 ) { <S2SV_ModEnd> if ( ( <S2SV_ModStart> ] ) ) != <S2SV_ModEnd> 0 ) { <S2SV_ModStart> = '\\0' ; if ( argc > 1 ) { <S2SV_ModEnd> if ( ( <S2SV_ModStart> ] ) ) != <S2SV_ModEnd> 0 ) { <S2SV_ModStart> '\\0' ; } } } } |
2,209 | CWE-000 static int flt_init_all ( ) { struct proxy * px ; int err_code = 0 ; <S2SV_StartBug> for ( px = proxy ; px ; px = px -> next ) { <S2SV_EndBug> err_code |= flt_init ( px ) ; if ( err_code & ( ERR_ABORT | ERR_FATAL ) ) { ha_alert ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>filters<S2SV_blank>for<S2SV_blank>proxy<S2SV_blank>\'%s\'.\\n" , px -> id ) ; return err_code ; } } return 0 ; } | <S2SV_ModStart> ( px = proxies_list <S2SV_ModEnd> ; px ; |
2,210 | CWE-000 static struct yang_data * ripd_state_routes_route_prefix_get_elem ( const char * xpath , const void * list_entry ) { <S2SV_StartBug> const struct rip_info * rinfo = list_entry ; <S2SV_EndBug> return yang_data_new_ipv4p ( xpath , & rinfo -> rp -> p ) ; } | <S2SV_ModStart> { const struct route_node * rn = list_entry ; const struct <S2SV_ModStart> * rinfo = listnode_head ( rn -> info ) <S2SV_ModEnd> ; return yang_data_new_ipv4p |
2,211 | CWE-000 INT MCUBurstWrite ( PRTMP_ADAPTER pAd , UINT32 Offset , UINT32 * Data , UINT32 Cnt ) { # ifdef RTMP_USB_SUPPORT <S2SV_StartBug> RTUSBMultiWrite_nBytes ( pAd , Offset , Data , Cnt * 4 , 64 ) ; <S2SV_EndBug> # endif } | <S2SV_ModStart> , Offset , ( PUCHAR ) |
2,212 | CWE-000 static void * ngx_rtmp_core_create_main_conf ( ngx_conf_t * cf ) { ngx_rtmp_core_main_conf_t * cmcf ; cmcf = ngx_pcalloc ( cf -> pool , sizeof ( ngx_rtmp_core_main_conf_t ) ) ; if ( cmcf == NULL ) { return NULL ; } ngx_rtmp_core_main_conf = cmcf ; if ( ngx_array_init ( & cmcf -> servers , cf -> pool , 4 , sizeof ( ngx_rtmp_core_srv_conf_t * ) ) != NGX_OK ) { return NULL ; } if ( ngx_array_init ( & cmcf -> listen , cf -> pool , 4 , sizeof ( ngx_rtmp_listen_opt_t ) ) != NGX_OK ) { return NULL ; } <S2SV_StartBug> return cmcf ; <S2SV_EndBug> } | <S2SV_ModStart> NULL ; } cmcf -> host_names_hash_max_size = NGX_CONF_UNSET_UINT ; cmcf -> host_names_hash_bucket_size = NGX_CONF_UNSET_UINT ; |
2,213 | CWE-000 <S2SV_StartBug> char * get_history_brief ( void ) { <S2SV_EndBug> int fd ; char * buf = malloc ( 2048 ) ; if ( ( fd = open ( HISTORY_PATH , O_RDONLY ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>History\\n" ) ; return NULL ; } unsigned int count = 0 ; if ( ( count = countlines ( HISTORY_PATH ) ) == 0 ) { return NULL ; } for ( unsigned int i = count - HISTORY_LINE_SAMPLE ; i != count ; ++ i ) { <S2SV_StartBug> realloc ( buf , strlen ( buf ) + strlen ( get_line ( fd , i ) ) + 1 ) ; <S2SV_EndBug> concat ( buf , get_line ( fd , i ) ) ; } <S2SV_StartBug> return buf ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { sem_t semhistory ; sem_init ( & semhistory , 0 , 1 ) ; sem_wait ( & semhistory ) ; <S2SV_ModStart> i ) { if ( <S2SV_ModStart> + 1 ) == ( void * ) - 1 ) return NULL <S2SV_ModStart> ) ; } sem_post ( & semhistory ) ; sem_destroy ( & semhistory ) ; |
2,214 | CWE-000 void phFriNfc_ISO15693_Process ( void * pContext , NFCSTATUS Status ) { phFriNfc_NdefMap_t * psNdefMap = ( phFriNfc_NdefMap_t * ) pContext ; if ( ( NFCSTATUS_SUCCESS & PHNFCSTBLOWER ) == ( Status & PHNFCSTBLOWER ) ) { switch ( psNdefMap -> State ) { <S2SV_StartBug> case ISO15693_CHECK_NDEF : <S2SV_EndBug> { Status = phFriNfc_ISO15693_H_ProcessCheckNdef ( psNdefMap ) ; break ; } case ISO15693_READ_NDEF : { Status = phFriNfc_ISO15693_H_ProcessReadNdef ( psNdefMap ) ; break ; } case ISO15693_WRITE_NDEF : { Status = phFriNfc_ISO15693_H_ProcessWriteNdef ( psNdefMap ) ; break ; } case ISO15693_READ_ONLY_NDEF : { Status = phFriNfc_ISO15693_H_ProcessReadOnly ( psNdefMap ) ; break ; } default : { break ; } } } if ( NFCSTATUS_PENDING != Status ) { phFriNfc_ISO15693_H_Complete ( psNdefMap , Status ) ; } } | <S2SV_ModStart> ) { case ISO15693_CHECK_NDEF_FIRST_BLOCK : case ISO15693_CHECK_NDEF_SECOND_BLOCK <S2SV_ModEnd> : { Status |
2,215 | CWE-000 void * raycasting ( void * tab ) { t_app a ; a = * ( t_app * ) tab ; while ( a . p . x < a . p . xx ) { raycasting_init ( & a , a . p . x ) ; a . lineheight = ( int ) ( WIN_H / a . dist_wall ) ; a . start = - a . lineheight / 2 + WIN_H / 2 ; a . end = a . lineheight / 2 + WIN_H / 2 ; if ( a . start < 0 ) a . start = 0 ; if ( a . end > WIN_H ) <S2SV_StartBug> a . end = WIN_H ; <S2SV_EndBug> a . clr_intensity = ( a . dist_wall < 1 ) ? 1 : 1 / a . dist_wall ; draw_wall ( a . p . x , a . start , a . end , & a ) ; a . p . x ++ ; } return ( tab ) ; } | <S2SV_ModStart> = WIN_H ; if ( a . t == 1 ) a . clr_intensity = ( a . dist_wall < 0.2 ) ? 1 : 0.2 / a . dist_wall ; else |
2,216 | CWE-000 static int vr_interface_change ( struct vr_interface * vif , vr_interface_req * req ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> if ( req -> vifr_flags & VIF_FLAG_SERVICE_IF && ! ( vif -> vif_flags & VIF_FLAG_SERVICE_IF ) ) { ret = vr_interface_service_enable ( vif ) ; if ( ret ) return ret ; } else if ( ( vif -> vif_flags & VIF_FLAG_SERVICE_IF ) && ! ( req -> vifr_flags & VIF_FLAG_SERVICE_IF ) ) { vr_interface_service_disable ( vif ) ; } vif_set_flags ( vif , req ) ; vif -> vif_mirror_id = req -> vifr_mir_id ; if ( ! ( vif -> vif_flags & VIF_FLAG_MIRROR_RX ) && ! ( vif -> vif_flags & VIF_FLAG_MIRROR_TX ) ) { vif -> vif_mirror_id = VR_MAX_MIRROR_INDICES ; } if ( req -> vifr_vrf >= 0 ) vif -> vif_vrf = req -> vifr_vrf ; if ( req -> vifr_mtu ) vif -> vif_mtu = req -> vifr_mtu ; vif -> vif_nh_id = ( unsigned short ) req -> vifr_nh_id ; vif -> vif_qos_map_index = req -> vifr_qos_map_index ; <S2SV_StartBug> ret = vr_interface_mirror_md_set ( vif , req ) ; <S2SV_EndBug> if ( ret ) return ret ; if ( ( ret = vif_fat_flow_add ( vif , req ) ) ) return ret ; return 0 ; } | <S2SV_ModStart> ret = 0 ; uint64_t * ip6 <S2SV_ModStart> -> vifr_qos_map_index ; vif -> vif_ip = req -> vifr_ip ; ip6 = ( uint64_t * ) ( vif -> vif_ip6 ) ; * ip6 = req -> vifr_ip6_u ; * ( ip6 + 1 ) = req -> vifr_ip6_l ; |
2,217 | CWE-000 static void clearline ( TMT * vt , TMTLINE * l , size_t s , size_t e ) { vt -> dirty = l -> dirty = true ; for ( size_t i = s ; i < e && i < vt -> screen . ncol ; i ++ ) { <S2SV_StartBug> l -> chars [ i ] . a = vt -> attrs ; <S2SV_EndBug> l -> chars [ i ] . c = L'<S2SV_blank>' ; } } | <S2SV_ModStart> . a = defattrs <S2SV_ModEnd> ; l -> |
2,218 | CWE-000 void * enlarge_shmem_struct ( char type ) { SharedMemory sharedMemory ; size_t sizeofobj ; int * counter ; <S2SV_StartBug> char * typ ; <S2SV_EndBug> switch ( type ) { case 'q' : <S2SV_StartBug> typ = "queries" ; <S2SV_EndBug> sharedMemory = shm_queries ; sizeofobj = sizeof ( queriesDataStruct ) ; counter = & counters . queries_MAX ; break ; case 'c' : <S2SV_StartBug> typ = "clients" ; <S2SV_EndBug> sharedMemory = shm_clients ; sizeofobj = sizeof ( clientsDataStruct ) ; counter = & counters . clients_MAX ; break ; case 'd' : <S2SV_StartBug> typ = "domains" ; <S2SV_EndBug> sharedMemory = shm_domains ; sizeofobj = sizeof ( domainsDataStruct ) ; counter = & counters . domains_MAX ; break ; case 'f' : <S2SV_StartBug> typ = "forwarded" ; <S2SV_EndBug> sharedMemory = shm_forwarded ; sizeofobj = sizeof ( forwardedDataStruct ) ; counter = & counters . forwarded_MAX ; break ; default : logg ( "Invalid<S2SV_blank>argument<S2SV_blank>in<S2SV_blank>enlarge_shmem_struct():<S2SV_blank>%c<S2SV_blank>(%i)" , type , type ) ; return 0 ; } <S2SV_StartBug> logg ( "Reallocating<S2SV_blank>%s<S2SV_blank>struct<S2SV_blank>(increasing<S2SV_blank>%zu<S2SV_blank>by<S2SV_blank>%zu)" , typ , sharedMemory . size , pagesize * sizeofobj ) ; <S2SV_EndBug> realloc_shm ( & sharedMemory , sharedMemory . size + pagesize * sizeofobj ) ; * counter += pagesize ; return sharedMemory . ptr ; } | <S2SV_ModStart> * counter ; <S2SV_ModEnd> switch ( type <S2SV_ModStart> case 'q' : <S2SV_ModEnd> sharedMemory = shm_queries <S2SV_ModStart> case 'c' : <S2SV_ModEnd> sharedMemory = shm_clients <S2SV_ModStart> case 'd' : <S2SV_ModEnd> sharedMemory = shm_domains <S2SV_ModStart> case 'f' : <S2SV_ModEnd> sharedMemory = shm_forwarded <S2SV_ModStart> 0 ; } <S2SV_ModEnd> realloc_shm ( & |
2,219 | CWE-000 int get_size ( const char * pkgname , const char * apkpath , const char * fwdlock_apkpath , int * _codesize , int * _datasize , int * _cachesize , int encrypted_fs_flag ) { DIR * d ; int dfd ; struct dirent * de ; struct stat s ; char path [ PKG_PATH_MAX ] ; int codesize = 0 ; int datasize = 0 ; int cachesize = 0 ; <S2SV_StartBug> if ( strncmp ( apkpath , "/system" , 7 ) != 0 ) { <S2SV_EndBug> if ( stat ( apkpath , & s ) == 0 ) { codesize += stat_size ( & s ) ; } } if ( fwdlock_apkpath != NULL && fwdlock_apkpath [ 0 ] != '!' ) { if ( stat ( fwdlock_apkpath , & s ) == 0 ) { codesize += stat_size ( & s ) ; } } <S2SV_StartBug> if ( strncmp ( apkpath , SDCARD_DIR_PREFIX , 7 ) != 0 ) { <S2SV_EndBug> if ( stat ( apkpath , & s ) == 0 ) { codesize += stat_size ( & s ) ; } } if ( ! create_cache_path ( path , apkpath ) ) { if ( stat ( path , & s ) == 0 ) { codesize += stat_size ( & s ) ; } } if ( encrypted_fs_flag == 0 ) { if ( create_pkg_path ( path , PKG_DIR_PREFIX , pkgname , PKG_DIR_POSTFIX ) ) { goto done ; } } else { if ( create_pkg_path ( path , PKG_SEC_DIR_PREFIX , pkgname , PKG_DIR_POSTFIX ) ) { goto done ; } } d = opendir ( path ) ; if ( d == NULL ) { goto done ; } dfd = dirfd ( d ) ; while ( ( de = readdir ( d ) ) ) { const char * name = de -> d_name ; if ( de -> d_type == DT_DIR ) { int subfd ; if ( name [ 0 ] == '.' ) { if ( name [ 1 ] == 0 ) continue ; if ( ( name [ 1 ] == '.' ) && ( name [ 2 ] == 0 ) ) continue ; } subfd = openat ( dfd , name , O_RDONLY | O_DIRECTORY ) ; if ( subfd >= 0 ) { int size = calculate_dir_size ( subfd ) ; if ( ! strcmp ( name , "lib" ) ) { codesize += size ; } else if ( ! strcmp ( name , "cache" ) ) { cachesize += size ; } else { datasize += size ; } } } else { if ( fstatat ( dfd , name , & s , AT_SYMLINK_NOFOLLOW ) == 0 ) { datasize += stat_size ( & s ) ; } } } closedir ( d ) ; done : * _codesize = codesize ; * _datasize = datasize ; * _cachesize = cachesize ; return 0 ; } | <S2SV_ModStart> apkpath , "/system" , 7 ) != 0 && strncmp ( apkpath , SDCARD_DIR_PREFIX <S2SV_ModStart> } if ( <S2SV_ModEnd> ! create_cache_path ( |
2,220 | CWE-000 static void authgss_destroy_context ( AUTH * auth ) { struct rpc_gss_data * gd ; OM_uint32 min_stat ; <S2SV_StartBug> log_debug ( "in<S2SV_blank>authgss_destroy_context()" ) ; <S2SV_EndBug> gd = AUTH_PRIVATE ( auth ) ; if ( gd -> gc . gc_ctx . length != 0 ) { if ( gd -> established ) { gd -> gc . gc_proc = RPCSEC_GSS_DESTROY ; clnt_call ( gd -> clnt , auth , NULLPROC , ( xdrproc_t ) xdr_void , NULL , ( xdrproc_t ) xdr_void , NULL , AUTH_TIMEOUT ) ; } gss_release_buffer ( & min_stat , & gd -> gc . gc_ctx ) ; memset ( & gd -> gc . gc_ctx , 0 , sizeof ( gd -> gc . gc_ctx ) ) ; } if ( gd -> ctx != GSS_C_NO_CONTEXT ) { gss_delete_sec_context ( & min_stat , & gd -> ctx , NULL ) ; gd -> ctx = GSS_C_NO_CONTEXT ; } mem_free ( gd -> gc_wire_verf . value , gd -> gc_wire_verf . length ) ; gd -> gc_wire_verf . value = NULL ; gd -> gc_wire_verf . length = 0 ; gd -> established = false ; } | <S2SV_ModStart> OM_uint32 min_stat ; __warnx ( TIRPC_DEBUG_FLAG_RPCSEC_GSS , "%s()" , __func__ <S2SV_ModEnd> ) ; gd |
2,221 | CWE-000 S * reverse ( S * expr ) { S * root ; <S2SV_StartBug> if ( isNilC ( expr ) ) <S2SV_EndBug> return nil ; if ( expr -> Cons . type != Cons ) return Error_new ( "reverse:<S2SV_blank>Illegal<S2SV_blank>argument<S2SV_blank>exception." ) ; root = nil ; <S2SV_StartBug> while ( ! isNilC ( expr ) ) { <S2SV_EndBug> root = Cons_new ( expr -> Cons . car , root ) ; expr = expr -> Cons . cdr ; } return root ; } | <S2SV_ModStart> ; if ( S_isNil <S2SV_ModEnd> ( expr ) <S2SV_ModStart> while ( ! S_isNil <S2SV_ModEnd> ( expr ) |
2,222 | CWE-000 static bool try_seek_cache ( struct demux_internal * in , double pts , int flags ) { if ( ( flags & SEEK_FACTOR ) || ! in -> seekable_cache ) return false ; if ( in -> seeking ) return false ; struct demux_ctrl_reader_state rstate ; if ( cached_demux_control ( in , DEMUXER_CTRL_GET_READER_STATE , & rstate ) < 0 ) return false ; double start = MP_ADD_PTS ( rstate . ts_min , - in -> ts_offset ) ; double end = MP_ADD_PTS ( rstate . ts_max , - in -> ts_offset ) ; MP_VERBOSE ( in , "in-cache<S2SV_blank>seek<S2SV_blank>range<S2SV_blank>=<S2SV_blank>%f<S2SV_blank><-><S2SV_blank>%f<S2SV_blank>(%f)\\n" , start , end , pts ) ; if ( pts < start || pts > end ) return false ; MP_VERBOSE ( in , "in-cache<S2SV_blank>seek<S2SV_blank>is<S2SV_blank>possible..\\n" ) ; clear_reader_state ( in ) ; if ( ! ( flags & SEEK_HR ) ) { for ( int n = 0 ; n < in -> num_streams ; n ++ ) { struct demux_stream * ds = in -> streams [ n ] -> ds ; if ( ds -> selected && ds -> type == STREAM_VIDEO ) { struct demux_packet * target = find_seek_target ( ds , pts , flags ) ; if ( target ) { double target_pts = recompute_keyframe_target_pts ( target ) ; if ( target_pts != MP_NOPTS_VALUE ) { MP_VERBOSE ( in , "adjust<S2SV_blank>seek<S2SV_blank>target<S2SV_blank>%f<S2SV_blank>-><S2SV_blank>%f\\n" , pts , target_pts ) ; pts = target_pts ; flags &= ~ SEEK_FORWARD ; } } break ; } } } for ( int n = 0 ; n < in -> num_streams ; n ++ ) { struct demux_stream * ds = in -> streams [ n ] -> ds ; struct demux_packet * target = find_seek_target ( ds , pts , flags ) ; ds -> reader_head = target ; <S2SV_StartBug> recompute_buffers ( ds ) ; <S2SV_EndBug> MP_VERBOSE ( in , "seeking<S2SV_blank>stream<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>to<S2SV_blank>" , n , stream_type_name ( ds -> type ) ) ; if ( target ) { MP_VERBOSE ( in , "packet<S2SV_blank>%f/%f\\n" , target -> pts , target -> dts ) ; } else { MP_VERBOSE ( in , "nothing\\n" ) ; } } return true ; } | <S2SV_ModStart> = target ; ds -> skip_to_keyframe = ! target ; |
2,223 | CWE-000 int sel_stop_timer ( sel_timer_t * timer ) { selector_t * sel = timer -> val . sel ; sel_timer_lock ( sel ) ; if ( timer -> val . stopped ) { sel_timer_unlock ( sel ) ; return ETIMEDOUT ; } if ( timer -> val . in_heap ) { volatile sel_timer_t * top = theap_get_top ( & sel -> timer_heap ) ; theap_remove ( & sel -> timer_heap , timer ) ; timer -> val . in_heap = 0 ; wake_timer_sel_thread ( sel , top ) ; } timer -> val . stopped = 1 ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> = 1 ; sel_timer_unlock ( sel ) ; |
2,224 | CWE-000 static int sock_alert ( tor_socket_t fd ) { ssize_t r = send_ni ( fd , "x" , 1 , 0 ) ; <S2SV_StartBug> if ( r < 0 && ! ERRNO_IS_EAGAIN ( tor_socket_errno ( fd ) ) ) <S2SV_EndBug> <S2SV_StartBug> return - 1 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ! ERRNO_IS_EAGAIN ( - r <S2SV_ModEnd> ) ) return <S2SV_ModStart> ) ) return r <S2SV_ModEnd> ; return 0 |
2,225 | CWE-000 FILE * get_next_battery_file ( DIR * battery_dir , enum BATTERY_INFO_TYPE battery_info_type ) { FILE * file = 0 ; struct dirent * dir_entries ; <S2SV_StartBug> char file_name [ 32 ] ; <S2SV_EndBug> do { dir_entries = readdir ( battery_dir ) ; if ( ! dir_entries ) return 0 ; if ( strlen ( dir_entries -> d_name ) < 4 ) continue ; if ( battery_info_type == BIF ) <S2SV_StartBug> snprintf ( file_name , 32 , BATTERY_INFO_FILE_PATH , <S2SV_EndBug> dir_entries -> d_name ) ; else <S2SV_StartBug> snprintf ( file_name , 32 , BATTERY_STATE_FILE_PATH , <S2SV_EndBug> dir_entries -> d_name ) ; file = fopen ( file_name , "r" ) ; } while ( ! file ) ; return file ; } | <S2SV_ModStart> char file_name [ 284 <S2SV_ModEnd> ] ; do <S2SV_ModStart> ( file_name , sizeof ( file_name ) <S2SV_ModEnd> , BATTERY_INFO_FILE_PATH , <S2SV_ModStart> ( file_name , sizeof ( file_name ) <S2SV_ModEnd> , BATTERY_STATE_FILE_PATH , |
2,226 | CWE-000 static struct mv_xor_v2_sw_desc * mv_xor_v2_prep_sw_desc ( struct mv_xor_v2_device * xor_dev ) { <S2SV_StartBug> struct mv_xor_v2_sw_desc * sw_desc ; <S2SV_EndBug> spin_lock_bh ( & xor_dev -> lock ) ; if ( list_empty ( & xor_dev -> free_sw_desc ) ) { spin_unlock_bh ( & xor_dev -> lock ) ; tasklet_schedule ( & xor_dev -> irq_tasklet ) ; return NULL ; } <S2SV_StartBug> sw_desc = list_first_entry ( & xor_dev -> free_sw_desc , <S2SV_EndBug> <S2SV_StartBug> struct mv_xor_v2_sw_desc , free_list ) ; <S2SV_EndBug> list_del ( & sw_desc -> free_list ) ; spin_unlock_bh ( & xor_dev -> lock ) ; <S2SV_StartBug> dma_async_tx_descriptor_init ( & sw_desc -> async_tx , & xor_dev -> dmachan ) ; <S2SV_EndBug> sw_desc -> async_tx . tx_submit = mv_xor_v2_tx_submit ; async_tx_ack ( & sw_desc -> async_tx ) ; return sw_desc ; } | <S2SV_ModStart> mv_xor_v2_sw_desc * sw_desc ; bool found = false <S2SV_ModStart> NULL ; } list_for_each_entry ( sw_desc , <S2SV_ModEnd> & xor_dev -> <S2SV_ModStart> -> free_sw_desc , free_list ) { if ( async_tx_test_ack ( & sw_desc -> async_tx ) ) { found = true ; break ; } } if ( ! found ) { spin_unlock_bh ( & xor_dev -> lock ) ; return NULL ; } <S2SV_ModEnd> list_del ( & <S2SV_ModStart> lock ) ; <S2SV_ModEnd> return sw_desc ; |
2,227 | CWE-000 int save_snapshot ( const char * name , Error * * errp ) { BlockDriverState * bs , * bs1 ; QEMUSnapshotInfo sn1 , * sn = & sn1 , old_sn1 , * old_sn = & old_sn1 ; int ret = - 1 ; QEMUFile * f ; int saved_vm_running ; uint64_t vm_state_size ; qemu_timeval tv ; struct tm tm ; AioContext * aio_context ; if ( ! bdrv_all_can_snapshot ( & bs ) ) { error_setg ( errp , "Device<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>writable<S2SV_blank>but<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>" "snapshots" , bdrv_get_device_name ( bs ) ) ; return ret ; } if ( name ) { ret = bdrv_all_delete_snapshot ( name , & bs1 , errp ) ; if ( ret < 0 ) { error_prepend ( errp , "Error<S2SV_blank>while<S2SV_blank>deleting<S2SV_blank>snapshot<S2SV_blank>on<S2SV_blank>device<S2SV_blank>" "\'%s\':<S2SV_blank>" , bdrv_get_device_name ( bs1 ) ) ; return ret ; } } bs = bdrv_all_find_vmstate_bs ( ) ; if ( bs == NULL ) { error_setg ( errp , "No<S2SV_blank>block<S2SV_blank>device<S2SV_blank>can<S2SV_blank>accept<S2SV_blank>snapshots" ) ; return ret ; } aio_context = bdrv_get_aio_context ( bs ) ; saved_vm_running = runstate_is_running ( ) ; ret = global_state_store ( ) ; if ( ret ) { error_setg ( errp , "Error<S2SV_blank>saving<S2SV_blank>global<S2SV_blank>state" ) ; return ret ; } vm_stop ( RUN_STATE_SAVE_VM ) ; <S2SV_StartBug> aio_context_acquire ( aio_context ) ; <S2SV_EndBug> memset ( sn , 0 , sizeof ( * sn ) ) ; qemu_gettimeofday ( & tv ) ; sn -> date_sec = tv . tv_sec ; sn -> date_nsec = tv . tv_usec * 1000 ; sn -> vm_clock_nsec = qemu_clock_get_ns ( QEMU_CLOCK_VIRTUAL ) ; if ( name ) { ret = bdrv_snapshot_find ( bs , old_sn , name ) ; if ( ret >= 0 ) { pstrcpy ( sn -> name , sizeof ( sn -> name ) , old_sn -> name ) ; pstrcpy ( sn -> id_str , sizeof ( sn -> id_str ) , old_sn -> id_str ) ; } else { pstrcpy ( sn -> name , sizeof ( sn -> name ) , name ) ; } } else { localtime_r ( ( const time_t * ) & tv . tv_sec , & tm ) ; strftime ( sn -> name , sizeof ( sn -> name ) , "vm-%Y%m%d%H%M%S" , & tm ) ; } f = qemu_fopen_bdrv ( bs , 1 ) ; if ( ! f ) { error_setg ( errp , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>VM<S2SV_blank>state<S2SV_blank>file" ) ; goto the_end ; } ret = qemu_savevm_state ( f , errp ) ; vm_state_size = qemu_ftell ( f ) ; qemu_fclose ( f ) ; if ( ret < 0 ) { goto the_end ; } aio_context_release ( aio_context ) ; aio_context = NULL ; ret = bdrv_all_create_snapshot ( sn , bs , vm_state_size , & bs ) ; if ( ret < 0 ) { error_setg ( errp , "Error<S2SV_blank>while<S2SV_blank>creating<S2SV_blank>snapshot<S2SV_blank>on<S2SV_blank>\'%s\'" , bdrv_get_device_name ( bs ) ) ; goto the_end ; } ret = 0 ; the_end : if ( aio_context ) { aio_context_release ( aio_context ) ; } <S2SV_StartBug> if ( saved_vm_running ) { <S2SV_EndBug> vm_start ( ) ; } return ret ; } | <S2SV_ModStart> RUN_STATE_SAVE_VM ) ; bdrv_drain_all_begin ( ) ; <S2SV_ModStart> ) ; } bdrv_drain_all_end ( ) ; |
2,228 | CWE-000 static void unlock_all_outputs ( struct audio_device * adev , struct stream_out * except ) { pthread_mutex_unlock ( & adev -> lock ) ; enum output_type type = OUTPUT_TOTAL ; do { struct stream_out * out = adev -> outputs [ -- type ] ; <S2SV_StartBug> if ( out && out != except ) <S2SV_EndBug> pthread_mutex_unlock ( & out -> lock ) ; } while ( type != ( enum output_type ) 0 ) ; pthread_mutex_unlock ( & adev -> lock_outputs ) ; } | <S2SV_ModStart> != except ) { unlock_output_stream ( out ) ; } <S2SV_ModEnd> } while ( |
2,229 | CWE-000 struct f2fs_dir_entry * find_target_dentry ( struct fscrypt_name * fname , f2fs_hash_t namehash , int * max_slots , struct f2fs_dentry_ptr * d ) { struct f2fs_dir_entry * de ; unsigned long bit_pos = 0 ; int max_len = 0 ; struct fscrypt_str de_name = FSTR_INIT ( NULL , 0 ) ; struct fscrypt_str * name = & fname -> disk_name ; if ( max_slots ) * max_slots = 0 ; while ( bit_pos < d -> max ) { if ( ! test_bit_le ( bit_pos , d -> bitmap ) ) { bit_pos ++ ; max_len ++ ; continue ; } de = & d -> dentry [ bit_pos ] ; if ( de -> hash_code != namehash ) goto not_match ; if ( unlikely ( ! de -> name_len ) ) { bit_pos ++ ; continue ; } de_name . name = d -> filename [ bit_pos ] ; de_name . len = le16_to_cpu ( de -> name_len ) ; <S2SV_StartBug> # ifdef CONFIG_F2FS_FS_ENCRYPTION <S2SV_EndBug> if ( unlikely ( ! name -> name ) ) { <S2SV_StartBug> if ( fname -> usr_fname -> name [ 0 ] == '_' ) { <S2SV_EndBug> if ( de_name . len > 32 && ! memcmp ( de_name . name + ( ( de_name . len - 17 ) & ~ 15 ) , fname -> crypto_buf . name + 8 , 16 ) ) goto found ; <S2SV_StartBug> goto not_match ; <S2SV_EndBug> } name -> name = fname -> crypto_buf . name ; name -> len = fname -> crypto_buf . len ; } # endif if ( de_name . len == name -> len && <S2SV_StartBug> ! memcmp ( de_name . name , name -> name , name -> len ) ) <S2SV_EndBug> goto found ; <S2SV_StartBug> not_match : <S2SV_EndBug> if ( max_slots && max_len > * max_slots ) * max_slots = max_len ; max_len = 0 ; bit_pos += GET_DENTRY_SLOTS ( le16_to_cpu ( de -> name_len ) ) ; } de = NULL ; found : if ( max_slots && max_len > * max_slots ) * max_slots = max_len ; return de ; } | <S2SV_ModStart> name_len ) ; <S2SV_ModEnd> if ( fname <S2SV_ModStart> ( fname -> hash ) { if ( de -> hash_code == cpu_to_le32 ( fname -> hash <S2SV_ModEnd> ) ) goto <S2SV_ModStart> goto found ; } else <S2SV_ModEnd> if ( de_name <S2SV_ModStart> -> len && de -> hash_code == namehash && <S2SV_ModStart> goto found ; <S2SV_ModEnd> if ( max_slots |
2,230 | CWE-000 void wm_event_do_depsgraph ( bContext * C ) { wmWindowManager * wm = CTX_wm_manager ( C ) ; uint64_t win_combine_v3d_datamask = 0 ; for ( wmWindow * win = wm -> windows . first ; win ; win = win -> next ) { const Scene * scene = WM_window_get_active_scene ( win ) ; const bScreen * screen = WM_window_get_active_screen ( win ) ; win_combine_v3d_datamask |= ED_view3d_screen_datamask ( scene , screen ) ; } for ( wmWindow * win = wm -> windows . first ; win ; win = win -> next ) { Scene * scene = WM_window_get_active_scene ( win ) ; ViewLayer * view_layer = WM_window_get_active_view_layer ( win ) ; <S2SV_StartBug> if ( G . is_rendering == false ) { <S2SV_EndBug> Main * bmain = CTX_data_main ( C ) ; scene -> customdata_mask = win_combine_v3d_datamask ; scene -> customdata_mask |= scene -> customdata_mask_modal ; Depsgraph * depsgraph = BKE_scene_get_depsgraph ( scene , view_layer , true ) ; DEG_make_active ( depsgraph ) ; BKE_scene_graph_update_tagged ( depsgraph , bmain ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> win ) ; <S2SV_ModEnd> Main * bmain <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,231 | CWE-000 void functionMCSensor ( void ) { sock_udp_ep_t gw = { . family = AF_INET6 , . port = EMCUTE_PORT } ; puts ( "MQTT-SN<S2SV_blank>example<S2SV_blank>application\\n" ) ; puts ( "Type<S2SV_blank>\'help\'<S2SV_blank>to<S2SV_blank>get<S2SV_blank>started.<S2SV_blank>Have<S2SV_blank>a<S2SV_blank>look<S2SV_blank>at<S2SV_blank>the<S2SV_blank>README.md<S2SV_blank>for<S2SV_blank>more" "information." ) ; if ( ipv6_addr_from_str ( ( ipv6_addr_t * ) & gw . addr . ipv6 , BROKER_IP ) == NULL ) { printf ( "error<S2SV_blank>parsing<S2SV_blank>IPv6<S2SV_blank>address\\n" ) ; return ; } if ( gpio_init ( GPIO_PIN ( 0 , 23 ) , GPIO_OUT ) < 0 ) { printf ( "Error<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>GPIO_PIN(%i,<S2SV_blank>%02i)\\n" , 0 , 23 ) ; return ; } if ( gpio_init ( GPIO_PIN ( 0 , 28 ) , GPIO_OUT ) < 0 ) { printf ( "Error<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>GPIO_PIN(%i,<S2SV_blank>%02i)\\n" , 0 , 28 ) ; return ; } gpio_clear ( GPIO_PIN ( 0 , 23 ) ) ; gpio_clear ( GPIO_PIN ( 0 , 28 ) ) ; msg_init_queue ( queue , ( sizeof ( queue ) / sizeof ( msg_t ) ) ) ; memset ( subscriptions , 0 , ( NUMOFSUBS * sizeof ( emcute_sub_t ) ) ) ; thread_create ( publisherStack , sizeof ( publisherStack ) , EMCUTE_PRIO , 0 , emcute_thread , NULL , "emcute" ) ; int notConnected = 1 ; xtimer_sleep ( 5 ) ; while ( notConnected ) { if ( emcute_con ( & gw , true , NULL , NULL , 0 , 0 ) != EMCUTE_OK ) { printf ( "error:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>Gateway\\n" ) ; } else { notConnected = 0 ; printf ( "Successfully<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>Gateway\\n" ) ; <S2SV_StartBug> } } <S2SV_EndBug> return ; } | <S2SV_ModStart> "Successfully<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>Gateway\\n" ) ; char * message [ ] = { "pub" , "publisher/communication" , "\\"The<S2SV_blank>SHD<S2SV_blank>microcontroller<S2SV_blank>is<S2SV_blank>live,<S2SV_blank>and<S2SV_blank>ready<S2SV_blank>to<S2SV_blank>communicate.\\"" } ; cmd_pub ( 3 , message ) ; thread_create ( mainStack , sizeof ( mainStack ) , THREAD_PRIORITY_MAIN - 1 , THREAD_CREATE_STACKTEST , adc , NULL , "mainThread" ) ; |
2,232 | CWE-000 bool game_move ( Game * game , int x , int y ) { if ( ( x < 0 ) || ( x > 7 ) || ( y < 0 ) || ( y > 7 ) ) { return false ; } if ( game -> movable [ x ] [ y ] == false ) { return false ; } game -> cur = board_move ( game -> cur , x , y , ( game -> turn ? game -> prob : ( 1 - game -> prob ) ) , game -> bp ) ; game -> turn = ! ( game -> turn ) ; <S2SV_StartBug> game_update_history ( game ) ; <S2SV_EndBug> game -> isover = false ; game_update_probtable ( game ) ; if ( game_can_move ( game ) == false ) { game -> turn = ! ( game -> turn ) ; game_update_probtable ( game ) ; if ( game_can_move ( game ) == false ) { game -> turn = ! ( game -> turn ) ; game -> isover = true ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> game_update_history ( game ) ; <S2SV_EndBug> game -> turn = ! ( game -> turn ) ; game_undo ( game ) ; <S2SV_StartBug> } <S2SV_EndBug> } return true ; } | <S2SV_ModStart> turn ) ; <S2SV_ModEnd> game -> isover <S2SV_ModStart> = true ; game_update_history ( game ) ; <S2SV_ModStart> } else { game -> turn = ! ( game -> turn ) ; game_update_history ( game ) ; game -> turn = ! ( game -> turn ) ; game_update_history ( game <S2SV_ModEnd> ) ; game_undo <S2SV_ModStart> ) ; } } else { game_update_history ( game ) ; |
2,233 | CWE-000 static void ota_example_task ( void * pvParameter ) { esp_err_t err ; esp_ota_handle_t update_handle = 0 ; const esp_partition_t * update_partition = NULL ; ESP_LOGI ( TAG , "Starting<S2SV_blank>OTA<S2SV_blank>example..." ) ; const esp_partition_t * configured = esp_ota_get_boot_partition ( ) ; const esp_partition_t * running = esp_ota_get_running_partition ( ) ; if ( configured != running ) { ESP_LOGW ( TAG , "Configured<S2SV_blank>OTA<S2SV_blank>boot<S2SV_blank>partition<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>0x%08x,<S2SV_blank>but<S2SV_blank>running<S2SV_blank>from<S2SV_blank>offset<S2SV_blank>0x%08x" , configured -> address , running -> address ) ; ESP_LOGW ( TAG , "(This<S2SV_blank>can<S2SV_blank>happen<S2SV_blank>if<S2SV_blank>either<S2SV_blank>the<S2SV_blank>OTA<S2SV_blank>boot<S2SV_blank>data<S2SV_blank>or<S2SV_blank>preferred<S2SV_blank>boot<S2SV_blank>image<S2SV_blank>become<S2SV_blank>corrupted<S2SV_blank>somehow.)" ) ; } ESP_LOGI ( TAG , "Running<S2SV_blank>partition<S2SV_blank>type<S2SV_blank>%d<S2SV_blank>subtype<S2SV_blank>%d<S2SV_blank>(offset<S2SV_blank>0x%08x)" , running -> type , running -> subtype , running -> address ) ; xEventGroupWaitBits ( wifi_event_group , CONNECTED_BIT , false , true , portMAX_DELAY ) ; ESP_LOGI ( TAG , "Connect<S2SV_blank>to<S2SV_blank>Wifi<S2SV_blank>!<S2SV_blank>Start<S2SV_blank>to<S2SV_blank>Connect<S2SV_blank>to<S2SV_blank>Server...." ) ; if ( connect_to_http_server ( ) ) { ESP_LOGI ( TAG , "Connected<S2SV_blank>to<S2SV_blank>http<S2SV_blank>server" ) ; } else { ESP_LOGE ( TAG , "Connect<S2SV_blank>to<S2SV_blank>http<S2SV_blank>server<S2SV_blank>failed!" ) ; task_fatal_error ( ) ; } <S2SV_StartBug> int res = - 1 ; <S2SV_EndBug> res = send ( socket_id , http_request , strlen ( http_request ) , 0 ) ; if ( res == - 1 ) { ESP_LOGE ( TAG , "Send<S2SV_blank>GET<S2SV_blank>request<S2SV_blank>to<S2SV_blank>server<S2SV_blank>failed" ) ; task_fatal_error ( ) ; } else { ESP_LOGI ( TAG , "Send<S2SV_blank>GET<S2SV_blank>request<S2SV_blank>to<S2SV_blank>server<S2SV_blank>succeeded" ) ; } update_partition = esp_ota_get_next_update_partition ( NULL ) ; ESP_LOGI ( TAG , "Writing<S2SV_blank>to<S2SV_blank>partition<S2SV_blank>subtype<S2SV_blank>%d<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>0x%x" , update_partition -> subtype , update_partition -> address ) ; assert ( update_partition != NULL ) ; err = esp_ota_begin ( update_partition , OTA_SIZE_UNKNOWN , & update_handle ) ; if ( err != ESP_OK ) { ESP_LOGE ( TAG , "esp_ota_begin<S2SV_blank>failed,<S2SV_blank>error=%d" , err ) ; task_fatal_error ( ) ; } ESP_LOGI ( TAG , "esp_ota_begin<S2SV_blank>succeeded" ) ; bool resp_body_start = false , flag = true ; while ( flag ) { memset ( text , 0 , TEXT_BUFFSIZE ) ; memset ( ota_write_data , 0 , BUFFSIZE ) ; int buff_len = recv ( socket_id , text , TEXT_BUFFSIZE , 0 ) ; if ( buff_len < 0 ) { ESP_LOGE ( TAG , "Error:<S2SV_blank>receive<S2SV_blank>data<S2SV_blank>error!<S2SV_blank>errno=%d" , errno ) ; task_fatal_error ( ) ; } else if ( buff_len > 0 && ! resp_body_start ) { memcpy ( ota_write_data , text , buff_len ) ; resp_body_start = read_past_http_header ( text , buff_len , update_handle ) ; } else if ( buff_len > 0 && resp_body_start ) { memcpy ( ota_write_data , text , buff_len ) ; err = esp_ota_write ( update_handle , ( const void * ) ota_write_data , buff_len ) ; if ( err != ESP_OK ) { ESP_LOGE ( TAG , "Error:<S2SV_blank>esp_ota_write<S2SV_blank>failed!<S2SV_blank>err=0x%x" , err ) ; task_fatal_error ( ) ; } binary_file_length += buff_len ; ESP_LOGI ( TAG , "Have<S2SV_blank>written<S2SV_blank>image<S2SV_blank>length<S2SV_blank>%d" , binary_file_length ) ; } else if ( buff_len == 0 ) { flag = false ; ESP_LOGI ( TAG , "Connection<S2SV_blank>closed,<S2SV_blank>all<S2SV_blank>packets<S2SV_blank>received" ) ; close ( socket_id ) ; } else { ESP_LOGE ( TAG , "Unexpected<S2SV_blank>recv<S2SV_blank>result" ) ; } } ESP_LOGI ( TAG , "Total<S2SV_blank>Write<S2SV_blank>binary<S2SV_blank>data<S2SV_blank>length<S2SV_blank>:<S2SV_blank>%d" , binary_file_length ) ; if ( esp_ota_end ( update_handle ) != ESP_OK ) { ESP_LOGE ( TAG , "esp_ota_end<S2SV_blank>failed!" ) ; task_fatal_error ( ) ; } err = esp_ota_set_boot_partition ( update_partition ) ; if ( err != ESP_OK ) { ESP_LOGE ( TAG , "esp_ota_set_boot_partition<S2SV_blank>failed!<S2SV_blank>err=0x%x" , err ) ; task_fatal_error ( ) ; } ESP_LOGI ( TAG , "Prepare<S2SV_blank>to<S2SV_blank>restart<S2SV_blank>system!" ) ; esp_restart ( ) ; return ; } | <S2SV_ModStart> ) ; } const char * GET_FORMAT = "GET<S2SV_blank>%s<S2SV_blank>HTTP/1.0\\r\\n" "Host:<S2SV_blank>%s:%s\\r\\n" "User-Agent:<S2SV_blank>esp-idf/1.0<S2SV_blank>esp32\\r\\n\\r\\n" ; char * http_request = NULL ; int get_len = asprintf ( & http_request , GET_FORMAT , EXAMPLE_FILENAME , EXAMPLE_SERVER_IP , EXAMPLE_SERVER_PORT ) ; if ( get_len < 0 ) { ESP_LOGE ( TAG , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>GET<S2SV_blank>request<S2SV_blank>buffer" ) ; task_fatal_error ( ) ; } <S2SV_ModStart> int res = send ( socket_id , http_request , get_len , 0 ) ; free ( http_request ) ; if ( res < 0 <S2SV_ModEnd> ) { ESP_LOGE |
2,234 | CWE-000 void ft_putstr ( const char * s ) { while ( * s != '\\0' ) <S2SV_StartBug> write ( 1 , * s ++ , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> != '\\0' ) ft_putchar ( <S2SV_ModEnd> * s ++ <S2SV_ModStart> * s ++ <S2SV_ModEnd> ) ; } |
2,235 | CWE-000 int main ( ) { MTUserArray * arr = mtRandInit ( NULL ) ; mtDefRand ( ) ; <S2SV_StartBug> for ( int i = 0 ; i < arr -> len ; i ++ ) <S2SV_EndBug> <S2SV_StartBug> printf ( "\\n%d" , arr -> ptr [ i ] ) ; <S2SV_EndBug> mtDefKill ( NULL ) ; return ( 0 ) ; } | <S2SV_ModStart> ( ) ; printf ( "Ваша<S2SV_blank>послідовність:<S2SV_blank>\\n" ) ; <S2SV_ModStart> i ++ ) { if ( i % 4 == 0 ) printf ( "\\n" ) ; printf ( "%" PRId32 "<S2SV_blank><S2SV_blank><S2SV_blank>" <S2SV_ModEnd> , arr -> <S2SV_ModStart> ] ) ; } |
2,236 | CWE-000 static rsRetVal createSocket ( instanceConf_t * info , void * * sock ) { int rv ; sublist * sub ; * sock = zsocket_new ( s_context , info -> type ) ; if ( ! sock ) { errmsg . LogError ( 0 , RS_RET_INVALID_PARAMS , "zsocket_new<S2SV_blank>failed:<S2SV_blank>%s,<S2SV_blank>for<S2SV_blank>type<S2SV_blank>%d" , zmq_strerror ( errno ) , info -> type ) ; return RS_RET_INVALID_PARAMS ; } DBGPRINTF ( "imzmq3:<S2SV_blank>socket<S2SV_blank>of<S2SV_blank>type<S2SV_blank>%d<S2SV_blank>created<S2SV_blank>successfully\\n" , info -> type ) if ( info -> identity ) zsocket_set_identity ( * sock , info -> identity ) ; if ( info -> sndBuf > - 1 ) zsocket_set_sndbuf ( * sock , info -> sndBuf ) ; if ( info -> rcvBuf > - 1 ) zsocket_set_rcvbuf ( * sock , info -> rcvBuf ) ; if ( info -> linger > - 1 ) zsocket_set_linger ( * sock , info -> linger ) ; if ( info -> backlog > - 1 ) zsocket_set_backlog ( * sock , info -> backlog ) ; if ( info -> sndTimeout > - 1 ) zsocket_set_sndtimeo ( * sock , info -> sndTimeout ) ; if ( info -> rcvTimeout > - 1 ) zsocket_set_rcvtimeo ( * sock , info -> rcvTimeout ) ; if ( info -> maxMsgSize > - 1 ) zsocket_set_maxmsgsize ( * sock , info -> maxMsgSize ) ; if ( info -> rate > - 1 ) zsocket_set_rate ( * sock , info -> rate ) ; if ( info -> recoveryIVL > - 1 ) zsocket_set_recovery_ivl ( * sock , info -> recoveryIVL ) ; if ( info -> multicastHops > - 1 ) zsocket_set_multicast_hops ( * sock , info -> multicastHops ) ; if ( info -> reconnectIVL > - 1 ) zsocket_set_reconnect_ivl ( * sock , info -> reconnectIVL ) ; if ( info -> reconnectIVLMax > - 1 ) zsocket_set_reconnect_ivl_max ( * sock , info -> reconnectIVLMax ) ; if ( info -> ipv4Only > - 1 ) zsocket_set_ipv4only ( * sock , info -> ipv4Only ) ; if ( info -> affinity > - 1 ) zsocket_set_affinity ( * sock , info -> affinity ) ; if ( info -> sndHWM > - 1 ) zsocket_set_sndhwm ( * sock , info -> sndHWM ) ; if ( info -> rcvHWM > - 1 ) zsocket_set_rcvhwm ( * sock , info -> rcvHWM ) ; if ( info -> type == ZMQ_SUB ) { for ( sub = info -> subscriptions ; sub != NULL ; sub = sub -> next ) { zsocket_set_subscribe ( * sock , sub -> subscribe ) ; } } if ( info -> action == ACTION_CONNECT ) { <S2SV_StartBug> rv = zsocket_connect ( * sock , info -> description ) ; <S2SV_EndBug> if ( rv == - 1 ) { errmsg . LogError ( 0 , RS_RET_INVALID_PARAMS , "zmq_connect<S2SV_blank>using<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%s" , info -> description , zmq_strerror ( errno ) ) ; return RS_RET_INVALID_PARAMS ; } DBGPRINTF ( "imzmq3:<S2SV_blank>connect<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>successful\\n" , info -> description ) ; } else { <S2SV_StartBug> rv = zsocket_bind ( * sock , info -> description ) ; <S2SV_EndBug> if ( rv == - 1 ) { errmsg . LogError ( 0 , RS_RET_INVALID_PARAMS , "zmq_bind<S2SV_blank>using<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%s" , info -> description , zmq_strerror ( errno ) ) ; return RS_RET_INVALID_PARAMS ; } DBGPRINTF ( "imzmq3:<S2SV_blank>bind<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>successful\\n" , info -> description ) ; } return RS_RET_OK ; } | <S2SV_ModStart> * sock , "%s" , <S2SV_ModStart> * sock , "%s" , |
2,237 | CWE-000 void pkt_seq_init ( struct pkt_seq_info * info ) { int i = 0 ; <S2SV_StartBug> for ( i = 0 ; i < 5 ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> info -> src_mac . addr_bytes [ i ] = ETHER_LOCAL_ADMIN_ADDR ; <S2SV_EndBug> <S2SV_StartBug> info -> dst_mac . addr_bytes [ i ] = ETHER_LOCAL_ADMIN_ADDR ; <S2SV_EndBug> } <S2SV_StartBug> info -> src_mac . addr_bytes [ 5 ] = PKT_SEQ_MAC_SRC ; <S2SV_EndBug> info -> dst_mac . addr_bytes [ 5 ] = PKT_SEQ_MAC_DST ; info -> src_ip = PKT_SEQ_IP_SRC ; info -> dst_ip = PKT_SEQ_IP_DST ; info -> src_port = PKT_SEQ_PORT_SRC ; info -> dst_port = PKT_SEQ_PORT_DST ; info -> pkt_len = PKT_SEQ_PKT_LEN ; info -> seq_cnt = PKT_SEQ_CNT ; } | <S2SV_ModStart> ; i < 6 <S2SV_ModEnd> ; i ++ <S2SV_ModStart> i ] = 0 <S2SV_ModEnd> ; info -> <S2SV_ModStart> i ] = 0 <S2SV_ModEnd> ; } info <S2SV_ModStart> ] = PKT_SEQ_MAC_SRC <S2SV_ModEnd> ; info -> |
2,238 | CWE-000 static void destroy_vdpau_window_sized_objects ( struct MPGLContext * ctx ) { struct priv * p = ctx -> priv ; struct vdp_functions * vdp = & p -> vdp -> vdp ; VdpStatus vdp_st ; GL * gl = ctx -> gl ; for ( int n = 0 ; n < p -> num_surfaces ; n ++ ) { struct surface * surface = & p -> surfaces [ n ] ; <S2SV_StartBug> if ( surface -> registered ) { <S2SV_EndBug> <S2SV_StartBug> gl -> VDPAUUnmapSurfacesNV ( 1 , & surface -> registered ) ; <S2SV_EndBug> gl -> VDPAUUnregisterSurfaceNV ( surface -> registered ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( surface -> surface != VDP_INVALID_HANDLE ) { vdp_st = vdp -> output_surface_destroy ( surface -> surface ) ; CHECK_VDP_WARNING ( ctx , "destroying<S2SV_blank>vdpau<S2SV_blank>surface" ) ; } <S2SV_StartBug> gl -> DeleteFramebuffers ( 1 , & surface -> fbo ) ; <S2SV_EndBug> gl -> DeleteTextures ( 1 , & surface -> texture ) ; } p -> num_surfaces = 0 ; p -> current_surface = - 1 ; ctx -> gl -> main_fb = 0 ; } | <S2SV_ModStart> ( surface -> mapped ) gl -> VDPAUUnmapSurfacesNV ( 1 , & surface -> registered ) ; gl -> DeleteFramebuffers ( 1 , & surface -> fbo ) ; gl -> DeleteTextures ( 1 , & surface -> texture ) ; if ( <S2SV_ModEnd> surface -> registered <S2SV_ModStart> -> registered ) <S2SV_ModEnd> gl -> VDPAUUnregisterSurfaceNV <S2SV_ModStart> registered ) ; <S2SV_ModEnd> if ( surface <S2SV_ModStart> ) ; } <S2SV_ModEnd> } p -> |
2,239 | CWE-000 int SendMSGtoSCK ( int queue , const char * message , const char * locmsg , char loc , logsocket * * sockets ) { int __mq_rcode ; char tmpstr [ OS_MAXSTR + 1 ] ; int i = 0 ; while ( sockets [ i ] && sockets [ i ] -> name ) { if ( strcmp ( sockets [ i ] -> name , "agent" ) == 0 ) { SendMSG ( queue , message , locmsg , loc ) ; } else { tmpstr [ OS_MAXSTR ] = '\\0' ; int sock_type ; if ( strcmp ( "udp" , sockets [ i ] -> mode ) == 0 ) { sock_type = SOCK_DGRAM ; } else if ( strcmp ( "tcp" , sockets [ i ] -> mode ) == 0 ) { sock_type = SOCK_STREAM ; } else { merror ( "Socket<S2SV_blank>type<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>valid." , sockets [ i ] -> mode ) ; return ( - 1 ) ; } if ( sockets [ i ] -> socket == 0 ) { if ( ( sockets [ i ] -> socket = OS_ConnectUnixDomain ( sockets [ i ] -> location , sock_type , OS_MAXSTR + 256 ) ) < 0 ) { sleep ( 1 ) ; if ( ( sockets [ i ] -> socket = OS_ConnectUnixDomain ( sockets [ i ] -> location , sock_type , OS_MAXSTR + 256 ) ) < 0 ) { sleep ( 2 ) ; if ( ( sockets [ i ] -> socket = OS_ConnectUnixDomain ( sockets [ i ] -> location , sock_type , OS_MAXSTR + 256 ) ) < 0 ) { SendMSG ( queue , "Socket<S2SV_blank>not<S2SV_blank>available." , locmsg , loc ) ; merror ( QUEUE_ERROR , sockets [ i ] -> location , strerror ( errno ) ) ; return ( - 1 ) ; } } } } if ( sockets [ i ] -> socket == 0 ) { SendMSG ( queue , "Socket<S2SV_blank>not<S2SV_blank>available." , locmsg , loc ) ; merror ( QUEUE_ERROR , sockets [ i ] -> location , strerror ( errno ) ) ; return ( - 1 ) ; } <S2SV_StartBug> if ( sockets [ i ] -> prefix ) { <S2SV_EndBug> snprintf ( tmpstr , OS_MAXSTR , "%s:%s" , sockets [ i ] -> prefix , message ) ; } else { snprintf ( tmpstr , OS_MAXSTR , "%s" , message ) ; } mdebug2 ( "Sending<S2SV_blank>(%s)<S2SV_blank>to<S2SV_blank>socket<S2SV_blank>\'%s\'" , tmpstr , sockets [ i ] -> name ) ; if ( ( __mq_rcode = OS_SendUnix ( sockets [ i ] -> socket , tmpstr , 0 ) ) < 0 ) { if ( __mq_rcode == OS_SOCKTERR ) { merror ( "Socket<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>available." , sockets [ i ] -> name ) ; close ( sockets [ i ] -> socket ) ; return ( - 1 ) ; } mwarn ( "Socket<S2SV_blank>busy,<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>1<S2SV_blank>second." ) ; sleep ( 1 ) ; if ( OS_SendUnix ( sockets [ i ] -> socket , tmpstr , 0 ) < 0 ) { mwarn ( "Socket<S2SV_blank>busy,<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>3<S2SV_blank>seconds." ) ; sleep ( 3 ) ; if ( OS_SendUnix ( sockets [ i ] -> socket , tmpstr , 0 ) < 0 ) { merror ( "Socket<S2SV_blank>busy,<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>5<S2SV_blank>seconds." ) ; sleep ( 5 ) ; if ( OS_SendUnix ( sockets [ i ] -> socket , tmpstr , 0 ) < 0 ) { merror ( "socket<S2SV_blank>busy,<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>10<S2SV_blank>seconds." ) ; sleep ( 10 ) ; if ( OS_SendUnix ( sockets [ i ] -> socket , tmpstr , 0 ) < 0 ) { SendMSG ( queue , "Cannot<S2SV_blank>send<S2SV_blank>message<S2SV_blank>to<S2SV_blank>socket." , locmsg , loc ) ; close ( sockets [ i ] -> socket ) ; return ( - 1 ) ; } } } } } } i ++ ; } return ( 0 ) ; } | <S2SV_ModStart> ] -> prefix && * sockets [ i ] -> prefix |
2,240 | CWE-000 int btrfs_insert_delayed_dir_index ( struct btrfs_trans_handle * trans , struct btrfs_fs_info * fs_info , const char * name , int name_len , struct inode * dir , struct btrfs_disk_key * disk_key , u8 type , u64 index ) { struct btrfs_delayed_node * delayed_node ; struct btrfs_delayed_item * delayed_item ; struct btrfs_dir_item * dir_item ; int ret ; delayed_node = btrfs_get_or_create_delayed_node ( dir ) ; if ( IS_ERR ( delayed_node ) ) return PTR_ERR ( delayed_node ) ; delayed_item = btrfs_alloc_delayed_item ( sizeof ( * dir_item ) + name_len ) ; if ( ! delayed_item ) { ret = - ENOMEM ; goto release_node ; } <S2SV_StartBug> delayed_item -> key . objectid = btrfs_ino ( dir ) ; <S2SV_EndBug> delayed_item -> key . type = BTRFS_DIR_INDEX_KEY ; delayed_item -> key . offset = index ; dir_item = ( struct btrfs_dir_item * ) delayed_item -> data ; dir_item -> location = * disk_key ; btrfs_set_stack_dir_transid ( dir_item , trans -> transid ) ; btrfs_set_stack_dir_data_len ( dir_item , 0 ) ; btrfs_set_stack_dir_name_len ( dir_item , name_len ) ; btrfs_set_stack_dir_type ( dir_item , type ) ; memcpy ( ( char * ) ( dir_item + 1 ) , name , name_len ) ; ret = btrfs_delayed_item_reserve_metadata ( trans , fs_info , delayed_item ) ; BUG_ON ( ret ) ; mutex_lock ( & delayed_node -> mutex ) ; ret = __btrfs_add_delayed_insertion_item ( delayed_node , delayed_item ) ; if ( unlikely ( ret ) ) { btrfs_err ( fs_info , "err<S2SV_blank>add<S2SV_blank>delayed<S2SV_blank>dir<S2SV_blank>index<S2SV_blank>item(name:<S2SV_blank>%.*s)<S2SV_blank>into<S2SV_blank>the<S2SV_blank>insertion<S2SV_blank>tree<S2SV_blank>of<S2SV_blank>the<S2SV_blank>delayed<S2SV_blank>node(root<S2SV_blank>id:<S2SV_blank>%llu,<S2SV_blank>inode<S2SV_blank>id:<S2SV_blank>%llu,<S2SV_blank>errno:<S2SV_blank>%d)" , name_len , name , delayed_node -> root -> objectid , delayed_node -> inode_id , ret ) ; BUG ( ) ; } mutex_unlock ( & delayed_node -> mutex ) ; release_node : btrfs_release_delayed_node ( delayed_node ) ; return ret ; } | <S2SV_ModStart> = btrfs_ino ( BTRFS_I ( dir ) <S2SV_ModEnd> ) ; delayed_item |
2,241 | CWE-000 Block * Next_Switch_Block ( Switch * S , char type , int dir , int level ) { struct rail_link next ; if ( type == 's' ) { next = S -> app ; } else { if ( S -> state == 0 ) { next = S -> str ; } else { next = S -> div ; } } <S2SV_StartBug> printf ( "Next<S2SV_blank><S2SV_blank><S2SV_blank>Sw:<S2SV_blank>dir:%i\\t%i:%i<S2SV_blank>=><S2SV_blank>%i:%i:%c\\t%i\\n" , dir , S -> module , S -> id , next . module , next . id , next . type , level ) ; <S2SV_EndBug> if ( ! next . p ) { loggerf ( ERROR , "NO<S2SV_blank>POINTERS" ) ; return 0 ; } if ( next . type == 'R' ) { if ( ! block_cmp ( S -> Detection , next . p ) ) { level -- ; } if ( level <= 0 ) { return ( Block * ) next . p ; } else { return Next ( ( Block * ) next . p , dir , level ) ; } } else if ( next . type == 'S' || next . type == 's' ) { return Next_Switch_Block ( ( Switch * ) next . p , next . type , dir , level ) ; } <S2SV_StartBug> else if ( next . type == 'M' ) { <S2SV_EndBug> } else if ( next . type == 'm' ) { <S2SV_StartBug> } <S2SV_EndBug> else if ( next . type == 'e' ) { return 0 ; } return 0 ; } | <S2SV_ModStart> ; } } <S2SV_ModEnd> if ( ! <S2SV_ModStart> type == 'M' || <S2SV_ModEnd> next . type <S2SV_ModStart> 'm' ) { return Next_MSSwitch_Block ( ( MSSwitch * ) next . p , next . type , dir , level ) ; |
2,242 | CWE-000 static int fbsd_fill_info ( struct pci_dev * d , int flags ) { struct pci_conf_io conf ; struct pci_bar_io bar ; struct pci_match_conf pattern ; struct pci_conf match ; int i ; if ( d -> access -> fd_rw >= 0 ) return pci_generic_fill_info ( d , flags ) ; conf . pat_buf_len = sizeof ( struct pci_match_conf ) ; conf . num_patterns = 1 ; conf . patterns = & pattern ; conf . match_buf_len = sizeof ( struct pci_conf ) ; conf . num_matches = 1 ; conf . matches = & match ; conf . offset = 0 ; conf . generation = 0 ; conf . status = 0 ; pattern . pc_sel . pc_domain = d -> domain ; pattern . pc_sel . pc_bus = d -> bus ; pattern . pc_sel . pc_dev = d -> dev ; pattern . pc_sel . pc_func = d -> func ; pattern . flags = PCI_GETCONF_MATCH_DOMAIN | PCI_GETCONF_MATCH_BUS | PCI_GETCONF_MATCH_DEV | PCI_GETCONF_MATCH_FUNC ; if ( ioctl ( d -> access -> fd , PCIOCGETCONF , & conf ) < 0 ) { if ( errno == ENODEV ) return 0 ; d -> access -> error ( "fbsd_fill_info:<S2SV_blank>ioctl(PCIOCGETCONF)<S2SV_blank>failed:<S2SV_blank>%s" , strerror ( errno ) ) ; } if ( flags & PCI_FILL_IDENT ) { d -> vendor_id = match . pc_vendor ; d -> device_id = match . pc_device ; } if ( flags & PCI_FILL_CLASS ) { <S2SV_StartBug> d -> device_class = match . pc_class | ( match . pc_subclass << 8 ) ; <S2SV_EndBug> } if ( flags & ( PCI_FILL_BASES | PCI_FILL_SIZES ) ) { d -> rom_base_addr = 0 ; d -> rom_size = 0 ; for ( i = 0 ; i < 6 ; i ++ ) { bar . pbi_sel . pc_domain = d -> domain ; bar . pbi_sel . pc_bus = d -> bus ; bar . pbi_sel . pc_dev = d -> dev ; bar . pbi_sel . pc_func = d -> func ; bar . pbi_reg = 0x10 + 4 * i ; bar . pbi_enabled = 0 ; bar . pbi_base = 0 ; bar . pbi_length = 0 ; if ( ioctl ( d -> access -> fd , PCIOCGETBAR , & bar ) < 0 ) { if ( errno == ENODEV ) return 0 ; if ( errno == EINVAL ) { d -> base_addr [ i ] = 0 ; d -> size [ i ] = 0 ; } else d -> access -> error ( "fbsd_fill_info:<S2SV_blank>ioctl(PCIOCGETBAR)<S2SV_blank>failed:<S2SV_blank>%s" , strerror ( errno ) ) ; } else { d -> base_addr [ i ] = bar . pbi_base ; d -> size [ i ] = bar . pbi_length ; } } } return flags & ( PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_BASES | PCI_FILL_SIZES ) ; } | <S2SV_ModStart> -> device_class = ( <S2SV_ModStart> match . pc_class <S2SV_ModEnd> << 8 ) <S2SV_ModStart> << 8 ) | match . pc_subclass |
2,243 | CWE-000 static void _new_sensor_value_acc_shake ( sensor_h sensor , sensor_event_s * sensor_data , void * user_data ) { appdata_s * ad = user_data ; float x = sensor_data -> values [ 0 ] ; float y = sensor_data -> values [ 1 ] ; float z = sensor_data -> values [ 2 ] ; char buf [ 1024 ] ; if ( sensor_data -> value_count < 3 ) { elm_object_text_set ( ad -> sensor_label [ 0 ] , "Gathering<S2SV_blank>data..." ) ; return ; } Evas_Object * bug ; if ( shake_detect == 0 && shake_flag == 1 ) { snprintf ( buf , sizeof ( buf ) , "<font_size<S2SV_blank>=<S2SV_blank>10><align=center>Bugs:%d</align></font_size>" , bug_num ) ; elm_object_text_set ( ad -> title , buf ) ; char img_path [ PATH_MAX ] = "" ; app_get_resource ( "shake.png" , img_path , PATH_MAX ) ; bug = evas_object_image_filled_add ( ad -> canvas ) ; evas_object_image_file_set ( bug , img_path , NULL ) ; elm_grid_pack ( ad -> grid , bug , 15 , 25 , 75 , 75 ) ; evas_object_show ( bug ) ; if ( fabsf ( x ) > 20 || fabsf ( y ) > 20 || fabsf ( z ) > 20 ) { bug_num -- ; shake_cnt ++ ; snprintf ( buf , sizeof ( buf ) , "<font_size<S2SV_blank>=<S2SV_blank>10><align=center>Bugs:%d</align></font_size>" , bug_num ) ; elm_object_text_set ( ad -> title , buf ) ; } } if ( shake_cnt >= 10 && shake_flag == 1 ) { snprintf ( buf , sizeof ( buf ) , "<font_size<S2SV_blank>=<S2SV_blank>10><align=center>Shake<S2SV_blank>complete!</align></font_size>" ) ; elm_object_text_set ( ad -> title , buf ) ; shake_detect = 1 ; shake_cnt = 0 ; shake_flag = 0 ; is_obstacle = 0 ; ad -> user_state [ 2 ] ++ ; <S2SV_StartBug> start_acceleration_sensor ( ad ) ; <S2SV_EndBug> draw_map ( ad ) ; } } | <S2SV_ModStart> ] ++ ; ad -> grid_state [ ad -> user_state [ 0 ] ] [ ad -> user_state [ 1 ] ] [ 5 ] = 0 ; |
2,244 | CWE-000 int oilsAuthComplete ( osrfMethodContext * ctx ) { OSRF_METHOD_VERIFY_CONTEXT ( ctx ) ; const jsonObject * args = jsonObjectGetIndex ( ctx -> params , 0 ) ; const char * uname = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "username" ) ) ; const char * identifier = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "identifier" ) ) ; const char * password = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "password" ) ) ; const char * type = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "type" ) ) ; int orgloc = ( int ) jsonObjectGetNumber ( jsonObjectGetKeyConst ( args , "org" ) ) ; const char * workstation = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "workstation" ) ) ; const char * barcode = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "barcode" ) ) ; const char * ewho = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "agent" ) ) ; const char * nonce = jsonObjectGetString ( jsonObjectGetKeyConst ( args , "nonce" ) ) ; const char * ws = ( workstation ) ? workstation : "" ; if ( ! nonce ) nonce = "" ; if ( ! identifier ) { if ( uname ) { identifier = uname ; } else if ( barcode ) { identifier = barcode ; } } if ( ! identifier ) { return osrfAppRequestRespondException ( ctx -> session , ctx -> request , "username/barcode<S2SV_blank>and<S2SV_blank>password<S2SV_blank>required<S2SV_blank>for<S2SV_blank>method:<S2SV_blank>%s" , ctx -> method -> name ) ; } osrfLogInfo ( OSRF_LOG_MARK , "Patron<S2SV_blank>completing<S2SV_blank>authentication<S2SV_blank>with<S2SV_blank>identifer<S2SV_blank>%s" , identifier ) ; int harmless_line_number = __LINE__ ; if ( ! type ) type = OILS_AUTH_STAFF ; oilsEvent * response = NULL ; jsonObject * userObj = NULL ; int card_active = 1 ; char * cache_key = va_list_to_string ( "%s%s%s" , OILS_AUTH_CACHE_PRFX , identifier , nonce ) ; jsonObject * cacheObj = osrfCacheGetObject ( cache_key ) ; if ( ! cacheObj ) { return osrfAppRequestRespondException ( ctx -> session , ctx -> request , "No<S2SV_blank>authentication<S2SV_blank>seed<S2SV_blank>found.<S2SV_blank>" "open-ils.auth.authenticate.init<S2SV_blank>must<S2SV_blank>be<S2SV_blank>called<S2SV_blank>first<S2SV_blank>" "<S2SV_blank>(check<S2SV_blank>that<S2SV_blank>memcached<S2SV_blank>is<S2SV_blank>running<S2SV_blank>and<S2SV_blank>can<S2SV_blank>be<S2SV_blank>connected<S2SV_blank>to)<S2SV_blank>" ) ; } int user_id = jsonObjectGetNumber ( jsonObjectGetKeyConst ( cacheObj , "user_id" ) ) ; if ( user_id == - 1 ) { response = oilsNewEvent ( __FILE__ , harmless_line_number , OILS_EVENT_AUTH_FAILED ) ; osrfAppRespondComplete ( ctx , oilsEventToJSON ( response ) ) ; oilsEventFree ( response ) ; osrfCacheRemove ( cache_key ) ; jsonObjectFree ( cacheObj ) ; return 0 ; } jsonObject * param = jsonNewNumberObject ( user_id ) ; userObj = oilsUtilsCStoreReqCtx ( ctx , "open-ils.cstore.direct.actor.user.retrieve" , param ) ; jsonObjectFree ( param ) ; char * freeable_uname = NULL ; if ( ! uname ) { uname = freeable_uname = oilsFMGetString ( userObj , "usrname" ) ; } jsonObject * params = jsonNewObject ( NULL ) ; jsonObjectSetKey ( params , "user_id" , jsonNewNumberObject ( oilsFMGetObjectId ( userObj ) ) ) ; jsonObjectSetKey ( params , "org_unit" , jsonNewNumberObject ( orgloc ) ) ; jsonObjectSetKey ( params , "login_type" , jsonNewObject ( type ) ) ; if ( barcode ) jsonObjectSetKey ( params , "barcode" , jsonNewObject ( barcode ) ) ; jsonObject * authEvt = oilsUtilsQuickReqCtx ( <S2SV_StartBug> ctx <S2SV_EndBug> "open-ils.auth_internal" , "open-ils.auth_internal.user.validate" , params ) ; jsonObjectFree ( params ) ; if ( ! authEvt ) { jsonObjectFree ( userObj ) ; if ( freeable_uname ) free ( freeable_uname ) ; return - 1 ; } const char * authEvtCode = jsonObjectGetString ( jsonObjectGetKey ( authEvt , "textcode" ) ) ; if ( ! strcmp ( authEvtCode , OILS_EVENT_AUTH_FAILED ) ) { osrfLogInfo ( OSRF_LOG_MARK , "failed<S2SV_blank>login:<S2SV_blank>username=%s,<S2SV_blank>barcode=%s,<S2SV_blank>workstation=%s" , uname , ( barcode ? barcode : "(none)" ) , ws ) ; response = oilsNewEvent ( __FILE__ , harmless_line_number , OILS_EVENT_AUTH_FAILED ) ; } int passOK = 0 ; if ( ! response ) { passOK = oilsAuthVerifyPassword ( ctx , user_id , identifier , password , nonce ) ; if ( ! passOK ) { response = oilsNewEvent ( __FILE__ , harmless_line_number , OILS_EVENT_AUTH_FAILED ) ; osrfLogInfo ( OSRF_LOG_MARK , "failed<S2SV_blank>login:<S2SV_blank>username=%s,<S2SV_blank>barcode=%s,<S2SV_blank>workstation=%s" , uname , ( barcode ? barcode : "(none)" ) , ws ) ; } } if ( ! response && ( ! strcmp ( authEvtCode , "PATRON_INACTIVE" ) || ! strcmp ( authEvtCode , "PATRON_CARD_INACTIVE" ) ) ) { response = oilsNewEvent2 ( OSRF_LOG_MARK , authEvtCode , jsonObjectGetKey ( authEvt , "payload" ) ) ; } if ( ! response && strcmp ( authEvtCode , OILS_EVENT_SUCCESS ) ) { response = oilsNewEvent ( __FILE__ , harmless_line_number , OILS_EVENT_AUTH_FAILED ) ; } if ( ! response ) { char * ewhat = "login" ; if ( 0 == strcmp ( ctx -> method -> name , "open-ils.auth.authenticate.verify" ) ) { response = oilsNewEvent ( OSRF_LOG_MARK , OILS_EVENT_SUCCESS ) ; ewhat = "verify" ; } else { response = oilsAuthHandleLoginOK ( ctx , userObj , uname , type , orgloc , workstation ) ; } oilsUtilsTrackUserActivity ( ctx , oilsFMGetObjectId ( userObj ) , ewho , ewhat , osrfAppSessionGetIngress ( ) ) ; } osrfAppRespondComplete ( ctx , oilsEventToJSON ( response ) ) ; oilsEventFree ( response ) ; jsonObjectFree ( userObj ) ; jsonObjectFree ( authEvt ) ; jsonObjectFree ( cacheObj ) ; if ( freeable_uname ) free ( freeable_uname ) ; return 0 ; } | <S2SV_ModStart> oilsUtilsQuickReqCtx ( ctx , |
2,245 | CWE-000 <S2SV_StartBug> static int copy_bit_to_buffer ( unsigned char * dest , int dest_byte , <S2SV_EndBug> unsigned char * src , int src_byte , int shift , bool big_endian ) { unsigned int value ; switch ( src_byte ) { case 2 : value = src [ 0 ] << 8 | src [ 1 ] ; break ; case 3 : value = src [ 0 ] << 16 | src [ 1 ] << 8 | src [ 2 ] ; break ; case 4 : value = src [ 0 ] << 24 | src [ 1 ] << 16 | src [ 2 ] << 8 | src [ 3 ] ; break ; default : <S2SV_StartBug> mse_err ( "format<S2SV_blank>error<S2SV_blank>%d\\n" , src_byte ) ; <S2SV_EndBug> return - 1 ; } if ( shift > 0 ) value >>= shift ; else value <<= - shift ; if ( dest_byte == 4 && src_byte == 3 ) { if ( value & 0x800000 ) value |= 0xFF000000 ; } if ( big_endian ) { value = htonl ( value ) ; memcpy ( dest , ( ( unsigned char * ) & value ) + 4 - dest_byte , dest_byte ) ; } else { memcpy ( dest , & value , dest_byte ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static void <S2SV_ModEnd> copy_bit_to_buffer ( unsigned <S2SV_ModStart> ; default : break <S2SV_ModEnd> ; } if <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
2,246 | CWE-000 int FTI_FlushPosix ( FTIT_configuration * FTI_Conf , FTIT_execution * FTI_Exec , FTIT_topology * FTI_Topo , FTIT_checkpoint * FTI_Ckpt , int level ) { FTI_Print ( "Starting<S2SV_blank>checkpoint<S2SV_blank>post-processing<S2SV_blank>L4<S2SV_blank>using<S2SV_blank>Posix<S2SV_blank>IO." , FTI_DBUG ) ; int startProc , endProc , proc ; if ( FTI_Topo -> amIaHead ) { startProc = 1 ; endProc = FTI_Topo -> nodeSize ; } else { startProc = 0 ; endProc = 1 ; } for ( proc = startProc ; proc < endProc ; proc ++ ) { char str [ FTI_BUFS ] ; sprintf ( str , "Post-processing<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d<S2SV_blank>started." , proc ) ; FTI_Print ( str , FTI_DBUG ) ; char lfn [ FTI_BUFS ] , gfn [ FTI_BUFS ] ; sprintf ( gfn , "%s/%s" , FTI_Conf -> gTmpDir , & FTI_Exec -> meta [ level ] . ckptFile [ proc * FTI_BUFS ] ) ; sprintf ( str , "Global<S2SV_blank>temporary<S2SV_blank>file<S2SV_blank>name<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d:<S2SV_blank>%s" , proc , gfn ) ; FTI_Print ( str , FTI_DBUG ) ; FILE * gfd = fopen ( gfn , "wb" ) ; if ( gfd == NULL ) { FTI_Print ( "L4<S2SV_blank>cannot<S2SV_blank>open<S2SV_blank>ckpt.<S2SV_blank>file<S2SV_blank>in<S2SV_blank>the<S2SV_blank>PFS." , FTI_EROR ) ; return FTI_NSCS ; } if ( level == 0 ) { sprintf ( lfn , "%s/%s" , FTI_Conf -> lTmpDir , & FTI_Exec -> meta [ 0 ] . ckptFile [ proc * FTI_BUFS ] ) ; } else { sprintf ( lfn , "%s/%s" , FTI_Ckpt [ level ] . dir , & FTI_Exec -> meta [ level ] . ckptFile [ proc * FTI_BUFS ] ) ; } sprintf ( str , "Local<S2SV_blank>file<S2SV_blank>name<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d:<S2SV_blank>%s" , proc , lfn ) ; FTI_Print ( str , FTI_DBUG ) ; FILE * lfd = fopen ( lfn , "rb" ) ; if ( lfd == NULL ) { FTI_Print ( "L4<S2SV_blank>cannot<S2SV_blank>open<S2SV_blank>the<S2SV_blank>checkpoint<S2SV_blank>file." , FTI_EROR ) ; fclose ( gfd ) ; return FTI_NSCS ; } char * readData = talloc ( char , FTI_Conf -> transferSize ) ; long bSize = FTI_Conf -> transferSize ; long fs = FTI_Exec -> meta [ level ] . fs [ proc ] ; <S2SV_StartBug> printf ( "filesize:<S2SV_blank>%ld\\n" , fs ) ; <S2SV_EndBug> sprintf ( str , "Local<S2SV_blank>file<S2SV_blank>size<S2SV_blank>for<S2SV_blank>proc<S2SV_blank>%d:<S2SV_blank>%ld" , proc , fs ) ; FTI_Print ( str , FTI_DBUG ) ; long pos = 0 ; while ( pos < fs ) { if ( ( fs - pos ) < FTI_Conf -> transferSize ) bSize = fs - pos ; size_t bytes = fread ( readData , sizeof ( char ) , bSize , lfd ) ; if ( ferror ( lfd ) ) { FTI_Print ( "L4<S2SV_blank>cannot<S2SV_blank>read<S2SV_blank>from<S2SV_blank>the<S2SV_blank>ckpt.<S2SV_blank>file." , FTI_EROR ) ; free ( readData ) ; fclose ( lfd ) ; fclose ( gfd ) ; return FTI_NSCS ; } fwrite ( readData , sizeof ( char ) , bytes , gfd ) ; if ( ferror ( gfd ) ) { FTI_Print ( "L4<S2SV_blank>cannot<S2SV_blank>write<S2SV_blank>to<S2SV_blank>the<S2SV_blank>ckpt.<S2SV_blank>file<S2SV_blank>in<S2SV_blank>the<S2SV_blank>PFS." , FTI_EROR ) ; free ( readData ) ; fclose ( lfd ) ; fclose ( gfd ) ; return FTI_NSCS ; } pos = pos + bytes ; } free ( readData ) ; fclose ( lfd ) ; fclose ( gfd ) ; } return FTI_SCES ; } | <S2SV_ModStart> proc ] ; <S2SV_ModEnd> sprintf ( str |
2,247 | CWE-000 float sourceIPsEntropy ( char * sourceIPs , int len ) { int i , j ; float result = 0.0 ; float total = 0.0 ; <S2SV_StartBug> qsort ( sourceIPs , len - 1 , 18 , strcmp ) ; <S2SV_EndBug> result = prob1 ( sourceIPs , sourceIPs , len ) ; total += result ; for ( i = 1 ; i < ( len - 1 ) ; i ++ ) { if ( strcmp ( sourceIPs + 18 * ( i - 1 ) , sourceIPs + 18 * i ) ) { result = prob1 ( sourceIPs + 18 * i , sourceIPs + 18 * i , len ) ; total += result * Log2 ( result ) ; } } return total ; } | <S2SV_ModStart> sourceIPs , len , sizeof ( char * ) , cstring_cmp ) ; printf ( "chamando<S2SV_blank>prob1" <S2SV_ModEnd> ) ; result |
2,248 | CWE-000 int uptime ( int argc , char * * argv ) { int ticks , days , hours , minutes , seconds , tick_rate ; struct tms tbuf ; ticks = times ( & tbuf ) ; tick_rate = sysconf ( _SC_CLK_TCK ) ; seconds = ticks / tick_rate ; minutes = seconds / 60 ; hours = minutes / 60 ; days = hours / 24 ; seconds %= 60 ; minutes %= 60 ; hours %= 24 ; printf ( "Uptime<S2SV_blank>is<S2SV_blank>%dd<S2SV_blank>%dh<S2SV_blank>%dm<S2SV_blank>%d.%ds\\n" , days , hours , minutes , seconds , ticks % 100 ) ; <S2SV_StartBug> printf ( "utime<S2SV_blank>%d<S2SV_blank>stime<S2SV_blank>%d\\n" , tbuf . tms_utime , tbuf . tms_stime ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; printf ( "user<S2SV_blank>time<S2SV_blank>%d.%d<S2SV_blank>seconds,<S2SV_blank>system<S2SV_blank>time<S2SV_blank>%d.%d<S2SV_blank>seconds\\n" , tbuf . tms_utime / tick_rate <S2SV_ModEnd> , tbuf . <S2SV_ModStart> tbuf . tms_utime % 100 , tbuf . tms_stime / tick_rate <S2SV_ModStart> tbuf . tms_stime % 100 |
2,249 | CWE-000 static inline s32 op_xastore_impl ( u8 * * opCode , Runtime * runtime , u8 isReference ) { RuntimeStack * stack = runtime -> stack ; StackEntry entry ; s32 ret = 0 ; pop_entry ( stack , & entry ) ; s32 index = pop_int ( stack ) ; Instance * jarr = ( Instance * ) pop_ref ( stack ) ; if ( jarr == NULL ) { Instance * exception = exception_create ( JVM_EXCEPTION_NULLPOINTER , runtime ) ; push_ref ( runtime -> stack , ( __refer ) exception ) ; ret = RUNTIME_STATUS_EXCEPTION ; } else { s32 tidx = ( jarr -> mb . clazz -> arr_type_index ) ; s32 bytes = data_type_bytes [ tidx ] ; Long2Double l2d ; l2d . l = 0 ; if ( isDataReferByIndex ( tidx ) ) { l2d . r = entry_2_refer ( & entry ) ; <S2SV_StartBug> ( ( Instance * ) l2d . r ) -> mb . run_count = refer_method_count ; <S2SV_EndBug> } else { if ( bytes > 4 ) { l2d . l = entry_2_long ( & entry ) ; } else { l2d . i2l . i1 = entry_2_int ( & entry ) ; } } jarray_set_field ( jarr , index , & l2d ) ; # if _JVM_DEBUG_BYTECODE_DETAIL > 5 invoke_deepth ( runtime ) ; jvm_printf ( "(icbfald)astore:<S2SV_blank>save<S2SV_blank>array[%llx]{%d<S2SV_blank>bytes}.(%d)=%d:%llx:%lf)\\n" , ( s64 ) ( long ) jarr , bytes , index , l2d . i2l . i1 , ( s64 ) ( long ) l2d . r , l2d . d ) ; # endif } * opCode = * opCode + 1 ; return ret ; } | <S2SV_ModStart> entry ) ; <S2SV_ModEnd> } else { |
2,250 | CWE-000 int cardRead ( u32 * cacheStruct ) { <S2SV_StartBug> REG_SCFG_EXT = 0x83008000 ; <S2SV_EndBug> setExceptionHandler2 ( ) ; accessCounter ++ ; u8 * cacheBuffer = ( u8 * ) ( cacheStruct + 8 ) ; u32 * cachePage = cacheStruct + 2 ; u32 commandRead ; u32 src = cardStruct [ 0 ] ; u8 * dst = ( u8 * ) ( cardStruct [ 1 ] ) ; u32 len = cardStruct [ 2 ] ; u32 page = ( src / 512 ) * 512 ; u32 sector = ( src / READ_SIZE_ARM7 ) * READ_SIZE_ARM7 ; # ifdef DEBUG commandRead = 0x026ff800 ; sharedAddr [ 0 ] = dst ; sharedAddr [ 1 ] = len ; sharedAddr [ 2 ] = src ; sharedAddr [ 3 ] = commandRead ; IPC_SendSync ( 0xEE24 ) ; while ( sharedAddr [ 3 ] != ( vu32 ) 0 ) ; <S2SV_StartBug> # endif <S2SV_EndBug> if ( page == src && len > READ_SIZE_ARM7 && dst < 0x02700000 && dst > 0x02000000 && ( ( u32 ) dst ) % 4 == 0 ) { commandRead = 0x025FFB08 ; cacheFlush ( ) ; sharedAddr [ 0 ] = dst ; sharedAddr [ 1 ] = len ; sharedAddr [ 2 ] = src ; sharedAddr [ 3 ] = commandRead ; IPC_SendSync ( 0xEE24 ) ; while ( sharedAddr [ 3 ] != ( vu32 ) 0 ) ; } else { while ( len > 0 ) { int slot = getSlotForSector ( sector ) ; vu8 * buffer = getCacheAddress ( slot ) ; if ( slot == - 1 ) { commandRead = 0x025FFB08 ; slot = allocateCacheSlot ( ) ; buffer = getCacheAddress ( slot ) ; if ( needFlushDCCache ) DC_FlushRange ( buffer , READ_SIZE_ARM7 ) ; sharedAddr [ 0 ] = buffer ; sharedAddr [ 1 ] = READ_SIZE_ARM7 ; sharedAddr [ 2 ] = sector ; sharedAddr [ 3 ] = commandRead ; IPC_SendSync ( 0xEE24 ) ; while ( sharedAddr [ 3 ] != ( vu32 ) 0 ) ; } updateDescriptor ( slot , sector ) ; u32 len2 = len ; if ( ( src - sector ) + len2 > READ_SIZE_ARM7 ) { len2 = sector - src + READ_SIZE_ARM7 ; } if ( len2 > 512 ) { len2 -= src % 4 ; len2 -= len2 % 32 ; } if ( len2 >= 512 && len2 % 32 == 0 && ( ( u32 ) dst ) % 4 == 0 && src % 4 == 0 ) { # ifdef DEBUG commandRead = 0x026ff800 ; sharedAddr [ 0 ] = dst ; sharedAddr [ 1 ] = len2 ; sharedAddr [ 2 ] = buffer + src - sector ; sharedAddr [ 3 ] = commandRead ; IPC_SendSync ( 0xEE24 ) ; while ( sharedAddr [ 3 ] != ( vu32 ) 0 ) ; # endif fastCopy32 ( buffer + ( src - sector ) , dst , len2 ) ; cardStruct [ 0 ] = src + len2 ; cardStruct [ 1 ] = dst + len2 ; cardStruct [ 2 ] = len - len2 ; } else { # ifdef DEBUG commandRead = 0x026ff800 ; sharedAddr [ 0 ] = page ; sharedAddr [ 1 ] = len2 ; sharedAddr [ 2 ] = buffer + page - sector ; sharedAddr [ 3 ] = commandRead ; IPC_SendSync ( 0xEE24 ) ; while ( sharedAddr [ 3 ] != ( vu32 ) 0 ) ; # endif fastCopy32 ( buffer + ( page - sector ) , cacheBuffer , 512 ) ; * cachePage = page ; ( * readCachedRef ) ( cacheStruct ) ; } len = cardStruct [ 2 ] ; if ( len > 0 ) { src = cardStruct [ 0 ] ; dst = cardStruct [ 1 ] ; page = ( src / 512 ) * 512 ; sector = ( src / READ_SIZE_ARM7 ) * READ_SIZE_ARM7 ; accessCounter ++ ; } } } REG_SCFG_EXT = 0x83000000 ; return 0 ; } | <S2SV_ModStart> cacheStruct ) { <S2SV_ModEnd> setExceptionHandler2 ( ) <S2SV_ModStart> ; # endif REG_SCFG_EXT = 0x83008000 ; |
2,251 | CWE-000 CK_RV SC_Logout ( STDLL_TokData_t * tokdata , ST_SESSION_HANDLE * sSession ) { SESSION * sess = NULL ; CK_RV rc = CKR_OK ; if ( tokdata -> initialized == FALSE ) { TRACE_ERROR ( "%s\\n" , ock_err ( ERR_CRYPTOKI_NOT_INITIALIZED ) ) ; rc = CKR_CRYPTOKI_NOT_INITIALIZED ; goto done ; } sess = session_mgr_find ( sSession -> sessionh ) ; if ( ! sess ) { TRACE_ERROR ( "%s\\n" , ock_err ( ERR_SESSION_HANDLE_INVALID ) ) ; rc = CKR_SESSION_HANDLE_INVALID ; goto done ; } if ( session_mgr_public_session_exists ( ) ) { TRACE_ERROR ( "%s\\n" , ock_err ( ERR_USER_NOT_LOGGED_IN ) ) ; rc = CKR_USER_NOT_LOGGED_IN ; goto done ; } rc = session_mgr_logout_all ( tokdata ) ; if ( rc != CKR_OK ) TRACE_DEVEL ( "session_mgr_logout_all<S2SV_blank>failed.\\n" ) ; if ( token_specific . t_logout ) { rc = token_specific . t_logout ( ) ; goto done ; } memset ( tokdata -> user_pin_md5 , 0x0 , MD5_HASH_SIZE ) ; <S2SV_StartBug> memset ( tokdata -> nv_token_data -> so_pin_md5 , 0x0 , MD5_HASH_SIZE ) ; <S2SV_EndBug> object_mgr_purge_private_token_objects ( tokdata ) ; done : TRACE_INFO ( "C_Logout:<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>0x%08lx\\n" , rc ) ; return rc ; } | <S2SV_ModStart> ( tokdata -> <S2SV_ModEnd> so_pin_md5 , 0x0 |
2,252 | CWE-000 char * _strcpy ( char * dest , char * src ) { int i ; i = 0 ; while ( src [ i ] != '\\0' ) { dest [ i ] = src [ i ] ; <S2SV_StartBug> ++ i ; <S2SV_EndBug> } dest [ i ] = '\\0' ; return ( dest ) ; } | <S2SV_ModStart> i ] ; i ++ <S2SV_ModEnd> ; } dest |
2,253 | CWE-000 void removeGameComponent ( Item * item , GameComponent type ) { if ( item == NULL ) return ; switch ( type ) { case POSITION : { Position * posComp = ( Position * ) getGameComponent ( item , type ) ; if ( posComp != NULL ) { ListElement * e = getListElement ( positions , posComp ) ; if ( e != NULL ) push ( posPool , removeElement ( positions , e ) ) ; item -> components [ type ] = NULL ; } } break ; case GRAPHICS : { Graphics * graComp = ( Graphics * ) getGameComponent ( item , type ) ; <S2SV_StartBug> if ( graComp == NULL ) return ; <S2SV_EndBug> ListElement * e = getListElement ( graphics , graComp ) ; if ( e != NULL ) push ( graphicsPool , removeElement ( graphics , e ) ) ; item -> components [ type ] = NULL ; <S2SV_StartBug> } break ; <S2SV_EndBug> default : break ; } } | <S2SV_ModStart> if ( graComp != NULL ) { <S2SV_ModEnd> ListElement * e <S2SV_ModStart> NULL ; } } |
2,254 | CWE-000 int finalize_add_table ( struct ireq * iq , struct schema_change_type * s , tran_type * tran ) { int rc , bdberr ; struct dbtable * db = s -> db ; <S2SV_StartBug> sc_printf ( s , "Start<S2SV_blank>add<S2SV_blank>table<S2SV_blank>transaction<S2SV_blank>ok\\n" ) ; <S2SV_EndBug> rc = load_new_table_schema_tran ( thedb , tran , s -> table , s -> newcsc2 ) ; if ( rc != 0 ) { sc_errf ( s , "error<S2SV_blank>recording<S2SV_blank>new<S2SV_blank>table<S2SV_blank>schema\\n" ) ; return rc ; } db -> instant_schema_change = db -> odh && s -> instant_sc ; rc = add_db ( db ) ; if ( rc ) { sc_errf ( s , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>db<S2SV_blank>to<S2SV_blank>thedb->dbs,<S2SV_blank>rc<S2SV_blank>%d\\n" , rc ) ; return rc ; } s -> addonly = SC_DONE_ADD ; if ( ( rc = set_header_and_properties ( tran , db , s , 0 , gbl_init_with_bthash ) ) ) return rc ; if ( llmeta_set_tables ( tran , thedb ) ) { sc_errf ( s , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>table<S2SV_blank>names<S2SV_blank>in<S2SV_blank>low<S2SV_blank>level<S2SV_blank>meta\\n" ) ; return rc ; } if ( ( rc = bdb_table_version_select ( db -> tablename , tran , & db -> tableversion , & bdberr ) ) != 0 ) { sc_errf ( s , "Failed<S2SV_blank>fetching<S2SV_blank>table<S2SV_blank>version<S2SV_blank>bdberr<S2SV_blank>%d\\n" , bdberr ) ; return rc ; } if ( ( rc = mark_schemachange_over_tran ( db -> tablename , tran ) ) ) return rc ; if ( db -> odh && db -> instant_schema_change ) { struct schema * ver_one ; if ( ( rc = prepare_table_version_one ( tran , db , & ver_one ) ) ) return rc ; add_tag_schema ( db -> tablename , ver_one ) ; } gbl_sc_commit_count ++ ; fix_lrl_ixlen_tran ( tran ) ; if ( s -> finalize ) { if ( create_sqlmaster_records ( tran ) ) { sc_errf ( s , "create_sqlmaster_records<S2SV_blank>failed\\n" ) ; return - 1 ; } create_sqlite_master ( ) ; } db -> sc_to = NULL ; update_dbstore ( db ) ; sc_printf ( s , "Add<S2SV_blank>table<S2SV_blank>ok\\n" ) ; if ( gbl_init_with_bthash ) { logmsg ( LOGMSG_INFO , "Init<S2SV_blank>table<S2SV_blank>with<S2SV_blank>bthash<S2SV_blank>size<S2SV_blank>%dkb<S2SV_blank>per<S2SV_blank>stripe\\n" , gbl_init_with_bthash ) ; if ( put_db_bthash ( db , tran , gbl_init_with_bthash ) != 0 ) { logmsg ( LOGMSG_ERROR , "Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>bthash<S2SV_blank>to<S2SV_blank>meta<S2SV_blank>table\\n" ) ; return - 1 ; } bdb_handle_dbp_add_hash ( db -> handle , gbl_init_with_bthash ) ; } sc_printf ( s , "Schema<S2SV_blank>change<S2SV_blank>ok\\n" ) ; return 0 ; } | <S2SV_ModStart> -> db ; if ( iq && iq -> tranddl > 1 && verify_constraints_exist ( db , NULL , NULL , s ) != 0 ) { sc_errf ( s , "error<S2SV_blank>verifying<S2SV_blank>constraints\\n" ) ; return - 1 ; } if ( iq && iq -> tranddl > 1 && populate_reverse_constraints ( db ) ) { sc_errf ( s , "error<S2SV_blank>populating<S2SV_blank>reverse<S2SV_blank>constraints\\n" ) ; return - 1 ; } |
2,255 | CWE-000 void Compile_Peek ( Compiler * compiler , Boolean stackReg ) { int64 optFlag = Compiler_CheckOptimize ( compiler , 0 ) ; if ( optFlag & OPTIMIZE_DONE ) return ; <S2SV_StartBug> else if ( ! optFlag ) Compile_Move_Rm_To_Reg ( ACC , stackReg , 0 ) ; <S2SV_EndBug> Compile_Move_Rm_To_Reg ( ACC , ACC , 0 ) ; Compile_Move_Reg_To_Rm ( stackReg , ACC , 0 ) ; } | <S2SV_ModStart> ! optFlag ) { Word * one = CfrTil_WordList ( 1 ) ; if ( ( ! ( one -> CAttribute & OBJECT ) ) && one -> StackPushRegisterCode ) { SetHere ( one -> StackPushRegisterCode , 1 ) ; Compile_Move_Rm_To_Reg ( ACC , ACC , 0 ) ; Compile_ADDI ( REG , DSP , 0 , sizeof ( int64 ) , 0 ) ; Compile_Move_Reg_To_Rm ( stackReg , ACC , 0 ) ; return ; } else <S2SV_ModStart> 0 ) ; } |
2,256 | CWE-000 void core_destroy ( ) { if ( e_cpu_context . memory ) { free ( e_cpu_context . memory ) ; } if ( e_cpu_context . color_basic ) { free ( e_cpu_context . color_basic ) ; } if ( e_cpu_context . extended_basic ) { free ( e_cpu_context . extended_basic ) ; } <S2SV_StartBug> e_cpu_context . memory = NULL ; <S2SV_EndBug> e_cpu_context . color_basic = NULL ; <S2SV_StartBug> e_cpu_context . extended_basic = NULL ; <S2SV_EndBug> if ( e_cpu_context . memory ) { free ( e_cpu_context . breakpoints ) ; } vdg_destroy ( ) ; } | <S2SV_ModStart> ) ; } if ( e_cpu_context . disk_basic ) { free ( e_cpu_context . disk_basic ) ; } <S2SV_ModStart> e_cpu_context . extended_basic = NULL ; e_cpu_context . disk_basic |
2,257 | CWE-000 void display_update ( ) { <S2SV_StartBug> int j ; <S2SV_EndBug> set_disp_data ( ) ; <S2SV_StartBug> for ( j = 0 ; j < 512 ; j ++ ) { <S2SV_EndBug> spi_send_recv ( pixels [ j ] ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { send_to_screen <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; send_to_screen ( <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
2,258 | CWE-000 int main ( ) { int x = 0 ; int y = 0 ; printf ( "x:%d" , x ) ; <S2SV_StartBug> int y = 9 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ) ; int z <S2SV_ModEnd> = 9 ; |
2,259 | CWE-000 static void data_source_thread ( void * data ) { napi_threadsafe_function ts_fn = data ; int index ; void * hint ; ts_fn_hint * ts_fn_info ; napi_status status ; bool queue_was_full = false ; bool queue_was_closing = false ; if ( napi_get_threadsafe_function_context ( ts_fn , & hint ) != napi_ok ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "napi_get_threadsafe_function_context<S2SV_blank>failed" , NAPI_AUTO_LENGTH ) ; } ts_fn_info = ( ts_fn_hint * ) hint ; if ( ts_fn_info != & ts_info ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "thread-safe<S2SV_blank>function<S2SV_blank>hint<S2SV_blank>is<S2SV_blank>not<S2SV_blank>as<S2SV_blank>expected" , NAPI_AUTO_LENGTH ) ; } if ( ts_fn_info -> start_secondary ) { if ( napi_acquire_threadsafe_function ( ts_fn ) != napi_ok ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "napi_acquire_threadsafe_function<S2SV_blank>failed" , NAPI_AUTO_LENGTH ) ; } if ( uv_thread_create ( & uv_threads [ 1 ] , secondary_thread , ts_fn ) != 0 ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>secondary<S2SV_blank>thread" , NAPI_AUTO_LENGTH ) ; } } for ( index = ARRAY_LENGTH - 1 ; index > - 1 && ! queue_was_closing ; index -- ) { status = napi_call_threadsafe_function ( ts_fn , & ints [ index ] , ts_fn_info -> block_on_full ) ; <S2SV_StartBug> switch ( status ) { <S2SV_EndBug> case napi_queue_full : queue_was_full = true ; index ++ ; case napi_ok : continue ; case napi_closing : queue_was_closing = true ; break ; default : napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "napi_call_threadsafe_function<S2SV_blank>failed" , NAPI_AUTO_LENGTH ) ; } } if ( ! ts_fn_info -> block_on_full && ! queue_was_full ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "queue<S2SV_blank>was<S2SV_blank>never<S2SV_blank>full" , NAPI_AUTO_LENGTH ) ; } if ( ts_fn_info -> abort == napi_tsfn_abort && ! queue_was_closing ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "queue<S2SV_blank>was<S2SV_blank>never<S2SV_blank>closing" , NAPI_AUTO_LENGTH ) ; } if ( ! queue_was_closing && napi_release_threadsafe_function ( ts_fn , napi_tsfn_release ) != napi_ok ) { napi_fatal_error ( "data_source_thread" , NAPI_AUTO_LENGTH , "napi_release_threadsafe_function<S2SV_blank>failed" , NAPI_AUTO_LENGTH ) ; } } | <S2SV_ModStart> block_on_full ) ; if ( ts_fn_info -> max_queue_size == 0 ) { uint64_t start = uv_hrtime ( ) ; for ( ; uv_hrtime ( ) - start < 200000000 ; ) ; } |
2,260 | CWE-000 <S2SV_StartBug> int power_hint_override ( struct power_module * module , power_hint_t hint , void * data ) <S2SV_EndBug> { int ret_val = HINT_NONE ; switch ( hint ) { case POWER_HINT_VIDEO_ENCODE : ret_val = process_video_encode_hint ( data ) ; break ; case POWER_HINT_SUSTAINED_PERFORMANCE : ret_val = process_perf_hint ( data , SUSTAINED_MODE ) ; break ; case POWER_HINT_VR_MODE : ret_val = process_perf_hint ( data , VR_MODE ) ; break ; case POWER_HINT_INTERACTION : pthread_mutex_lock ( & perf_mode_switch_lock ) ; if ( current_mode != NORMAL_MODE ) { ret_val = HINT_HANDLED ; } pthread_mutex_unlock ( & perf_mode_switch_lock ) ; break ; default : break ; } return ret_val ; } | <S2SV_ModStart> struct power_module * UNUSED ( module ) <S2SV_ModEnd> , power_hint_t hint |
2,261 | CWE-000 char * discover_nic_dirver ( char * nic_name ) { char * cmd = xasprintf ( "ethtool<S2SV_blank>-i<S2SV_blank>%s<S2SV_blank>|<S2SV_blank>grep<S2SV_blank>driver" , nic_name ) ; FILE * pp = popen ( cmd , "r" ) ; char buffer [ 100 ] ; int j = 0 ; <S2SV_StartBug> bool find = false ; <S2SV_EndBug> char * nic_driver = xzalloc ( 100 * sizeof ( char ) ) ; memset ( buffer , 0 , sizeof ( buffer ) ) ; while ( fgets ( buffer , sizeof ( buffer ) , pp ) != NULL ) { <S2SV_StartBug> for ( int i = 0 ; i < sizeof ( buffer ) ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> if ( buffer [ i ] == 'i' ) { <S2SV_EndBug> find = true ; } if ( find ) { nic_driver [ j ++ ] = buffer [ i ] ; } } } free ( cmd ) ; return nic_driver ; } | <S2SV_ModStart> find = false , pre_find = false <S2SV_ModStart> ( buffer ) && buffer [ i ] != '\\n' <S2SV_ModStart> ++ ) { if ( buffer [ i ] == ':' ) { pre_find = true ; } <S2SV_ModStart> ] == 'i' && pre_find |
2,262 | CWE-000 bool ubsan_expand_bounds_ifn ( gimple_stmt_iterator * gsi ) { gimple * stmt = gsi_stmt ( * gsi ) ; location_t loc = gimple_location ( stmt ) ; gcc_assert ( gimple_call_num_args ( stmt ) == 3 ) ; tree type = TREE_TYPE ( TREE_TYPE ( gimple_call_arg ( stmt , 0 ) ) ) ; tree index = gimple_call_arg ( stmt , 1 ) ; tree orig_index = index ; tree bound = gimple_call_arg ( stmt , 2 ) ; gimple_stmt_iterator gsi_orig = * gsi ; basic_block then_bb , fallthru_bb ; gimple_stmt_iterator cond_insert_point = create_cond_insert_point ( gsi , false , false , true , & then_bb , & fallthru_bb ) ; index = fold_convert ( TREE_TYPE ( bound ) , index ) ; index = force_gimple_operand_gsi ( & cond_insert_point , index , true , NULL_TREE , false , GSI_NEW_STMT ) ; gimple * g = gimple_build_cond ( GT_EXPR , index , bound , NULL_TREE , NULL_TREE ) ; gimple_set_location ( g , loc ) ; gsi_insert_after ( & cond_insert_point , g , GSI_NEW_STMT ) ; * gsi = gsi_after_labels ( then_bb ) ; if ( flag_sanitize_undefined_trap_on_error ) g = gimple_build_call ( builtin_decl_explicit ( BUILT_IN_TRAP ) , 0 ) ; else { tree data = ubsan_create_data ( "__ubsan_out_of_bounds_data" , 1 , & loc , ubsan_type_descriptor ( type , UBSAN_PRINT_ARRAY ) , ubsan_type_descriptor ( TREE_TYPE ( orig_index ) ) , NULL_TREE , NULL_TREE ) ; data = build_fold_addr_expr_loc ( loc , data ) ; enum built_in_function bcode = ( flag_sanitize_recover & SANITIZE_BOUNDS ) ? BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS : BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS_ABORT ; tree fn = builtin_decl_explicit ( bcode ) ; tree val <S2SV_StartBug> = force_gimple_operand_gsi ( gsi , ubsan_encode_value ( orig_index ) , true , <S2SV_EndBug> NULL_TREE , true , GSI_SAME_STMT ) ; g = gimple_build_call ( fn , 2 , data , val ) ; } gimple_set_location ( g , loc ) ; gsi_insert_before ( gsi , g , GSI_SAME_STMT ) ; unlink_stmt_vdef ( stmt ) ; gsi_remove ( & gsi_orig , true ) ; * gsi = gsi_start_bb ( fallthru_bb ) ; return true ; } | <S2SV_ModStart> ; tree val = ubsan_encode_value ( orig_index , UBSAN_ENCODE_VALUE_GIMPLE ) ; val <S2SV_ModStart> ( gsi , val , true , NULL_TREE , true , <S2SV_ModEnd> GSI_SAME_STMT ) ; |
2,263 | CWE-000 int __wt_bt_rebalance ( WT_SESSION_IMPL * session , const char * cfg [ ] ) { WT_BTREE * btree ; WT_DECL_RET ; WT_REBALANCE_STUFF * rs , _rstuff ; <S2SV_StartBug> bool evict_reset ; <S2SV_EndBug> WT_UNUSED ( cfg ) ; <S2SV_StartBug> btree = S2BT ( session ) ; <S2SV_EndBug> evict_reset = false ; if ( btree -> root . page -> dsk == NULL ) return ( 0 ) ; if ( btree -> modified ) WT_RET_MSG ( session , EINVAL , "tree<S2SV_blank>is<S2SV_blank>modified,<S2SV_blank>only<S2SV_blank>clean<S2SV_blank>trees<S2SV_blank>may<S2SV_blank>be<S2SV_blank>rebalanced" ) ; WT_CLEAR ( _rstuff ) ; rs = & _rstuff ; WT_ERR ( __wt_scr_alloc ( session , 0 , & rs -> tmp1 ) ) ; WT_ERR ( __wt_scr_alloc ( session , 0 , & rs -> tmp2 ) ) ; rs -> type = btree -> root . page -> type ; <S2SV_StartBug> WT_ERR ( __wt_evict_file_exclusive_on ( session ) ) ; <S2SV_EndBug> evict_reset = true ; switch ( rs -> type ) { case WT_PAGE_ROW_INT : WT_ERR ( __rebalance_row_walk ( session , btree -> root . page -> dsk , rs ) ) ; break ; case WT_PAGE_COL_INT : WT_ERR ( __rebalance_col_walk ( session , btree -> root . page -> dsk , rs ) ) ; break ; WT_ILLEGAL_VALUE_ERR ( session ) ; } WT_ERR ( __rebalance_internal ( session , rs ) ) ; WT_ERR ( __rebalance_free_original ( session , rs ) ) ; __wt_page_out ( session , & btree -> root . page ) ; btree -> root . page = rs -> root ; rs -> root = NULL ; <S2SV_StartBug> err : if ( evict_reset ) <S2SV_EndBug> __wt_evict_file_exclusive_off ( session ) ; if ( rs -> root != NULL ) { __wt_page_modify_clear ( session , rs -> root ) ; __wt_page_out ( session , & rs -> root ) ; } __rebalance_discard ( session , rs ) ; __wt_scr_free ( session , & rs -> tmp1 ) ; __wt_scr_free ( session , & rs -> tmp2 ) ; return ( ret ) ; } | <S2SV_ModStart> , _rstuff ; <S2SV_ModEnd> WT_UNUSED ( cfg <S2SV_ModStart> ( session ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> -> type ; <S2SV_ModEnd> switch ( rs <S2SV_ModStart> ; err : <S2SV_ModEnd> if ( rs |
2,264 | CWE-000 void ide_irq_update ( IDE * ide ) { int pending = 0 ; int mask = 0 ; if ( ide -> board > 3 ) { return ; } ide_log ( "Updating<S2SV_blank>IRQ<S2SV_blank>%i<S2SV_blank>(board<S2SV_blank>%i)\\n" , ide_irq [ ide -> board ] , ide -> board ) ; mask = ide_irq [ ide -> board ] ; mask &= 7 ; pending = ( pic2 . pend | pic2 . ins ) ; pending &= ( 1 << mask ) ; if ( ide -> irqstat && ! pending && ! ( ide -> fdisk & 2 ) ) { <S2SV_StartBug> if ( pci_use_mirq ( 0 ) && ( ide -> board < 2 ) ) <S2SV_EndBug> { pci_set_mirq ( 0 , ide -> board ) ; } else { picint ( 1 << ide_irq [ ide -> board ] ) ; } if ( ide -> board < 2 ) { if ( ide_bus_master_set_irq ) { <S2SV_StartBug> ide_bus_master_set_irq ( ide -> board | 0x40 ) ; <S2SV_EndBug> } } } else if ( pending ) { if ( pci_use_mirq ( 0 ) && ( ide -> board < 2 ) ) { pci_clear_mirq ( 0 , ide -> board ) ; } else { picintc ( 1 << ide_irq [ ide -> board ] ) ; } if ( ide -> board < 2 ) { if ( ide_bus_master_set_irq ) { ide_bus_master_set_irq ( ide -> board ) ; } } } } | <S2SV_ModStart> ide -> board == 1 ) ) { pci_set_mirq ( 0 ) ; } else { picint ( 1 << ide_irq [ ide -> board ] ) ; } if ( ide -> board <S2SV_ModStart> < 2 ) { if ( ide_bus_master_set_irq ) { ide_bus_master_set_irq ( ide -> board | 0x40 ) ; } } } else if ( pending ) { if ( pci_use_mirq ( 0 ) && ( ide -> board == 1 ) ) { pci_clear_mirq ( 0 ) ; } else { picintc <S2SV_ModEnd> ( 1 << <S2SV_ModStart> ide -> board <S2SV_ModEnd> ) ; } |
2,265 | CWE-000 <S2SV_StartBug> struct Item * show_contents ( struct Monster * mons , uint32_t accepted , char * msg ) <S2SV_EndBug> { struct Pack * pack = mons -> pack ; struct String * fmt = str_dinit ( ) ; <S2SV_StartBug> Vector contents = v_init ( sizeof ( struct Item * ) , 52 ) ; <S2SV_EndBug> str_catf ( fmt , "#nFFF00000#c%s#nBBB00000\\n\\n" , msg ) ; int i ; for ( i = 0 ; it_displayorder [ i ] != - 1 ; ++ i ) { if ( accepted & ( 1 << it_displayorder [ i ] ) ) add_desc ( fmt , pack , it_displayorder [ i ] , mons , contents ) ; } if ( contents -> len == 0 ) { str_free ( fmt ) ; v_free ( contents ) ; p_msg ( "No<S2SV_blank>items<S2SV_blank>to<S2SV_blank>show." ) ; <S2SV_StartBug> return NULL ; <S2SV_EndBug> } int num = p_flines ( str_data ( fmt ) ) ; str_free ( fmt ) ; if ( num == - 1 ) { v_free ( contents ) ; <S2SV_StartBug> return NULL ; <S2SV_EndBug> } <S2SV_StartBug> struct Item * ret = * ( struct Item * * ) v_at ( contents , num ) ; <S2SV_EndBug> v_free ( contents ) ; return ret ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> TID <S2SV_ModEnd> show_contents ( struct <S2SV_ModStart> ( sizeof ( TID <S2SV_ModEnd> ) , 52 <S2SV_ModStart> ) ; return - 1 <S2SV_ModEnd> ; } int <S2SV_ModStart> ) ; return - 1 ; } TID <S2SV_ModEnd> ret = * <S2SV_ModStart> = * ( TID <S2SV_ModEnd> * ) v_at |
2,266 | CWE-000 static apt_bool_t demo_framework_cmdline_process ( demo_framework_t * framework , char * cmdline ) { apt_bool_t running = TRUE ; char * name ; char * last ; name = apr_strtok ( cmdline , "<S2SV_blank>" , & last ) ; <S2SV_StartBug> if ( strcasecmp ( name , "run" ) == 0 ) { <S2SV_EndBug> char * app_name = apr_strtok ( NULL , "<S2SV_blank>" , & last ) ; if ( app_name ) { char * profile_name = apr_strtok ( NULL , "<S2SV_blank>" , & last ) ; if ( ! profile_name ) { profile_name = "uni2" ; } demo_framework_app_run ( framework , app_name , profile_name ) ; } } else if ( strcasecmp ( name , "loglevel" ) == 0 ) { char * priority = apr_strtok ( NULL , "<S2SV_blank>" , & last ) ; if ( priority ) { apt_log_priority_set ( atol ( priority ) ) ; } } else if ( strcasecmp ( name , "exit" ) == 0 || strcmp ( name , "quit" ) == 0 ) { running = FALSE ; } else if ( strcasecmp ( name , "help" ) == 0 ) { printf ( "usage:\\n" "\\n-<S2SV_blank>run<S2SV_blank>[app_name]<S2SV_blank>[profile_name]<S2SV_blank>(run<S2SV_blank>demo<S2SV_blank>application)\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>app_name<S2SV_blank>is<S2SV_blank>one<S2SV_blank>of<S2SV_blank>\'synth\',<S2SV_blank>\'recog\',<S2SV_blank>\'bypass\',<S2SV_blank>\'discover\'\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>profile_name<S2SV_blank>is<S2SV_blank>one<S2SV_blank>of<S2SV_blank>\'uni2\',<S2SV_blank>\'uni1\',<S2SV_blank>...\\n" "\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>examples:<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>run<S2SV_blank>synth\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>run<S2SV_blank>recog\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>run<S2SV_blank>synth<S2SV_blank>uni1\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>run<S2SV_blank>recog<S2SV_blank>uni1\\n" "\\n-<S2SV_blank>loglevel<S2SV_blank>[level]<S2SV_blank>(set<S2SV_blank>loglevel,<S2SV_blank>one<S2SV_blank>of<S2SV_blank>0,1...7)\\n" "\\n-<S2SV_blank>quit,<S2SV_blank>exit\\n" ) ; } else { printf ( "unknown<S2SV_blank>command:<S2SV_blank>%s<S2SV_blank>(input<S2SV_blank>help<S2SV_blank>for<S2SV_blank>usage)\\n" , name ) ; } return running ; } | <S2SV_ModStart> ; if ( ! name ) return running ; if ( |
2,267 | CWE-000 void microdesc_note_outdated_dirserver ( const char * relay_digest ) { char relay_hexdigest [ HEX_DIGEST_LEN + 1 ] ; <S2SV_StartBug> if ( ! networkstatus_get_live_consensus ( approx_time ( ) ) ) { <S2SV_EndBug> return ; } if ( ! outdated_dirserver_list ) { outdated_dirserver_list = smartlist_new ( ) ; } tor_assert ( outdated_dirserver_list ) ; if ( BUG ( smartlist_len ( outdated_dirserver_list ) > TOO_MANY_OUTDATED_DIRSERVERS ) ) { microdesc_reset_outdated_dirservers_list ( ) ; } base16_encode ( relay_hexdigest , sizeof ( relay_hexdigest ) , relay_digest , DIGEST_LEN ) ; if ( router_get_trusteddirserver_by_digest ( relay_digest ) ) { log_info ( LD_GENERAL , "Auth<S2SV_blank>%s<S2SV_blank>gave<S2SV_blank>us<S2SV_blank>outdated<S2SV_blank>dirinfo." , relay_hexdigest ) ; return ; } if ( smartlist_contains_string ( outdated_dirserver_list , relay_hexdigest ) ) { return ; } smartlist_add_strdup ( outdated_dirserver_list , relay_hexdigest ) ; log_info ( LD_GENERAL , "Noted<S2SV_blank>%s<S2SV_blank>as<S2SV_blank>outdated<S2SV_blank>md<S2SV_blank>dirserver" , relay_hexdigest ) ; } | <S2SV_ModStart> if ( ! networkstatus_get_reasonably_live_consensus <S2SV_ModEnd> ( approx_time ( <S2SV_ModStart> approx_time ( ) , FLAV_MICRODESC |
2,268 | CWE-000 static int graft_tree ( struct mount * mnt , struct mount * p , struct mountpoint * mp ) { <S2SV_StartBug> if ( mnt -> mnt . mnt_sb -> s_flags & MS_NOUSER ) <S2SV_EndBug> return - EINVAL ; if ( d_is_dir ( mp -> m_dentry ) != d_is_dir ( mnt -> mnt . mnt_root ) ) return - ENOTDIR ; return attach_recursive_mnt ( mnt , p , mp , NULL ) ; } | <S2SV_ModStart> -> s_flags & SB_NOUSER <S2SV_ModEnd> ) return - |
2,269 | CWE-000 static struct sk_buff * * gre_gro_receive ( struct sk_buff * * head , struct sk_buff * skb ) { struct sk_buff * * pp = NULL ; struct sk_buff * p ; const struct gre_base_hdr * greh ; unsigned int hlen , grehlen ; unsigned int off ; int flush = 1 ; struct packet_offload * ptype ; <S2SV_StartBug> __be16 type ; <S2SV_EndBug> off = skb_gro_offset ( skb ) ; hlen = off + sizeof ( * greh ) ; greh = skb_gro_header_fast ( skb , off ) ; if ( skb_gro_header_hard ( skb , hlen ) ) { greh = skb_gro_header_slow ( skb , hlen , off ) ; if ( unlikely ( ! greh ) ) goto out ; } if ( ( greh -> flags & ~ ( GRE_KEY | GRE_CSUM ) ) != 0 ) goto out ; type = greh -> protocol ; rcu_read_lock ( ) ; ptype = gro_find_receive_by_type ( type ) ; if ( ptype == NULL ) goto out_unlock ; grehlen = GRE_HEADER_SECTION ; if ( greh -> flags & GRE_KEY ) grehlen += GRE_HEADER_SECTION ; if ( greh -> flags & GRE_CSUM ) grehlen += GRE_HEADER_SECTION ; hlen = off + grehlen ; if ( skb_gro_header_hard ( skb , hlen ) ) { greh = skb_gro_header_slow ( skb , hlen , off ) ; if ( unlikely ( ! greh ) ) goto out_unlock ; } if ( ( greh -> flags & GRE_CSUM ) && ! NAPI_GRO_CB ( skb ) -> flush ) { if ( skb_gro_checksum_simple_validate ( skb ) ) goto out_unlock ; skb_gro_checksum_try_convert ( skb , IPPROTO_GRE , 0 , null_compute_pseudo ) ; } flush = 0 ; for ( p = * head ; p ; p = p -> next ) { const struct gre_base_hdr * greh2 ; if ( ! NAPI_GRO_CB ( p ) -> same_flow ) continue ; greh2 = ( struct gre_base_hdr * ) ( p -> data + off ) ; if ( greh2 -> flags != greh -> flags || greh2 -> protocol != greh -> protocol ) { NAPI_GRO_CB ( p ) -> same_flow = 0 ; continue ; } if ( greh -> flags & GRE_KEY ) { if ( * ( __be32 * ) ( greh2 + 1 ) != * ( __be32 * ) ( greh + 1 ) ) { NAPI_GRO_CB ( p ) -> same_flow = 0 ; continue ; } } } skb_gro_pull ( skb , grehlen ) ; skb_gro_postpull_rcsum ( skb , greh , grehlen ) ; pp = ptype -> callbacks . gro_receive ( head , skb ) ; out_unlock : rcu_read_unlock ( ) ; out : NAPI_GRO_CB ( skb ) -> flush |= flush ; return pp ; } | <S2SV_ModStart> ; __be16 type ; if ( NAPI_GRO_CB ( skb ) -> encap_mark ) goto out ; NAPI_GRO_CB ( skb ) -> encap_mark = 1 |
2,270 | CWE-000 static AbstractInstruction * NoDbgRegParms compilePerformMethodCacheProbeForwithShiftbaseRegOrNone ( sqInt selectorReg , sqInt shift , sqInt baseRegOrNone ) { AbstractInstruction * anInstruction ; AbstractInstruction * anInstruction1 ; AbstractInstruction * anInstruction2 ; AbstractInstruction * anInstruction3 ; AbstractInstruction * anInstruction4 ; AbstractInstruction * jumpSelectorMiss ; sqInt offset ; sqInt offset1 ; genoperandoperand ( MoveRR , SendNumArgsReg , ClassReg ) ; maybeShiftClassTagRegisterForMethodCacheProbe ( ClassReg ) ; genoperandoperand ( XorRR , selectorReg , ClassReg ) ; assert ( shift <= ( shiftForWord ( ) ) ) ; if ( shift < ( shiftForWord ( ) ) ) { genoperandoperand ( LogicalShiftLeftCqR , ( shiftForWord ( ) ) - shift , ClassReg ) ; } <S2SV_StartBug> anInstruction = genoperandoperand ( AndCqR , ( ( sqInt ) ( ( usqInt ) ( MethodCacheMask ) << ( shiftForWord ( ) ) ) ) , ClassReg ) ; <S2SV_EndBug> if ( baseRegOrNone == NoReg ) { offset = ( ( ( usqInt ) ( methodCacheAddress ( ) ) ) ) + ( ( ( sqInt ) ( ( usqInt ) ( MethodCacheSelector ) << ( shiftForWord ( ) ) ) ) ) ; <S2SV_StartBug> anInstruction1 = genoperandoperandoperand ( MoveMwrR , offset , ClassReg , TempReg ) ; <S2SV_EndBug> } else { genoperandoperand ( AddRR , baseRegOrNone , ClassReg ) ; anInstruction2 = genoperandoperandoperand ( MoveMwrR , ( ( sqInt ) ( ( usqInt ) ( MethodCacheSelector ) << ( shiftForWord ( ) ) ) ) , ClassReg , TempReg ) ; } genoperandoperand ( CmpRR , selectorReg , TempReg ) ; jumpSelectorMiss = genConditionalBranchoperand ( JumpNonZero , ( ( sqInt ) 0 ) ) ; if ( baseRegOrNone == NoReg ) { offset1 = ( ( ( usqInt ) ( methodCacheAddress ( ) ) ) ) + ( ( ( sqInt ) ( ( usqInt ) ( MethodCacheClass ) << ( shiftForWord ( ) ) ) ) ) ; <S2SV_StartBug> anInstruction3 = genoperandoperandoperand ( MoveMwrR , offset1 , ClassReg , TempReg ) ; <S2SV_EndBug> } else { anInstruction4 = genoperandoperandoperand ( MoveMwrR , ( ( sqInt ) ( ( usqInt ) ( MethodCacheClass ) << ( shiftForWord ( ) ) ) ) , ClassReg , TempReg ) ; } genoperandoperand ( CmpRR , SendNumArgsReg , TempReg ) ; return jumpSelectorMiss ; } | <S2SV_ModStart> ) ; } anInstruction4 <S2SV_ModEnd> = genoperandoperand ( <S2SV_ModStart> ) ) ; anInstruction = genoperandoperandoperand ( MoveMwrR , offset , ClassReg , TempReg ) ; } else { genoperandoperand ( AddRR , baseRegOrNone , ClassReg ) ; anInstruction1 <S2SV_ModEnd> = genoperandoperandoperand ( <S2SV_ModStart> ) ) ; anInstruction2 = genoperandoperandoperand ( MoveMwrR , offset1 , ClassReg , TempReg ) ; } else { anInstruction3 <S2SV_ModEnd> = genoperandoperandoperand ( |
2,271 | CWE-000 void addSVDisownNonNullG ( IRSB * sbOut , IRExpr * guard , IRExpr * sv ) { IRExpr * refCountAddr = runArrowAddr ( sbOut , sv , ShadowValue , ref_count ) ; IRExpr * prevRefCount = runLoadG64 ( sbOut , refCountAddr , guard ) ; IRExpr * newRefCount = runBinop ( sbOut , Iop_Sub64 , prevRefCount , mkU64 ( 1 ) ) ; addStoreG ( sbOut , guard , newRefCount , refCountAddr ) ; IRExpr * lastRef = runBinop ( sbOut , Iop_CmpEQ64 , prevRefCount , mkU64 ( 1 ) ) ; IRStmt * freeVal = mkDirtyG_0_1 ( freeShadowValue , sv , lastRef ) ; addStmtToIRSB ( sbOut , freeVal ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> freeVal ) ; if ( PRINT_VALUE_MOVES ) { addPrintG ( guard , "disowning<S2SV_blank>value.\\n" ) ; } |
2,272 | CWE-000 static void crng_reseed ( struct crng_state * crng , struct entropy_store * r ) { unsigned long flags ; int i , num ; union { <S2SV_StartBug> __u32 block [ CHACHA20_BLOCK_WORDS ] ; <S2SV_EndBug> __u32 key [ 8 ] ; } buf ; if ( r ) { num = extract_entropy ( r , & buf , 32 , 16 , 0 ) ; if ( num == 0 ) return ; } else { _extract_crng ( & primary_crng , buf . block ) ; _crng_backtrack_protect ( & primary_crng , buf . block , CHACHA20_KEY_SIZE ) ; } spin_lock_irqsave ( & crng -> lock , flags ) ; for ( i = 0 ; i < 8 ; i ++ ) { unsigned long rv ; if ( ! arch_get_random_seed_long ( & rv ) && ! arch_get_random_long ( & rv ) ) rv = random_get_entropy ( ) ; crng -> state [ i + 4 ] ^= buf . key [ i ] ^ rv ; } memzero_explicit ( & buf , sizeof ( buf ) ) ; crng -> init_time = jiffies ; if ( crng == & primary_crng && crng_init < 2 ) { numa_crng_init ( ) ; crng_init = 2 ; process_random_ready_list ( ) ; wake_up_interruptible ( & crng_init_wait ) ; pr_notice ( "random:<S2SV_blank>crng<S2SV_blank>init<S2SV_blank>done\\n" ) ; if ( unseeded_warning . missed ) { pr_notice ( "random:<S2SV_blank>%d<S2SV_blank>get_random_xx<S2SV_blank>warning(s)<S2SV_blank>missed<S2SV_blank>" "due<S2SV_blank>to<S2SV_blank>ratelimiting\\n" , unseeded_warning . missed ) ; unseeded_warning . missed = 0 ; } if ( urandom_warning . missed ) { pr_notice ( "random:<S2SV_blank>%d<S2SV_blank>urandom<S2SV_blank>warning(s)<S2SV_blank>missed<S2SV_blank>" "due<S2SV_blank>to<S2SV_blank>ratelimiting\\n" , urandom_warning . missed ) ; urandom_warning . missed = 0 ; } } spin_unlock_irqrestore ( & crng -> lock , flags ) ; } | <S2SV_ModStart> ; union { __u8 block [ CHACHA20_BLOCK_SIZE <S2SV_ModEnd> ] ; __u32 |
2,273 | CWE-000 int parseInput ( int nargs , char * * args , struct inputParameters * inpp ) { memset ( inpp , 0 , sizeof ( struct inputParameters ) ) ; if ( nargs == 2 && ( strcmp ( args [ 1 ] , "--help" ) == 0 || strcmp ( args [ 1 ] , "-h" ) ) ) { printhelp ( ) ; <S2SV_StartBug> } <S2SV_EndBug> int arg = 1 ; while ( arg < nargs ) { char * cmd = args [ arg ++ ] ; if ( strcmp ( cmd , "-w" ) == 0 ) inpp -> width = atoll ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "-h" ) == 0 ) inpp -> height = atoll ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "-d" ) == 0 ) inpp -> density = atof ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "-s" ) == 0 ) inpp -> steps = atoll ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "-l" ) == 0 ) inpp -> simulateTillStill = 1 ; if ( strcmp ( cmd , "-t" ) == 0 ) inpp -> time = atof ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "r" ) == 0 ) strcpy ( inpp -> reportfile , args [ arg ++ ] ) ; if ( strcmp ( cmd , "--seed" ) == 0 ) inpp -> seed = atol ( args [ arg ++ ] ) ; if ( strcmp ( cmd , "-N" ) == 0 ) inpp -> width = inpp -> height = atoll ( args [ arg ++ ] ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; return 1 ; <S2SV_ModStart> ) ; } return 0 ; |
2,274 | CWE-000 bool ponyint_thread_create ( pony_thread_id_t * thread , thread_fn start , uint32_t cpu , void * arg ) { ( void ) cpu ; # if defined ( PLATFORM_IS_WINDOWS ) uintptr_t p = _beginthreadex ( NULL , 0 , start , arg , 0 , NULL ) ; if ( ! p ) return false ; * thread = ( HANDLE ) p ; # elif defined ( PLATFORM_IS_LINUX ) pthread_attr_t attr ; pthread_attr_init ( & attr ) ; if ( cpu != ( uint32_t ) - 1 ) { cpu_set_t set ; CPU_ZERO ( & set ) ; CPU_SET ( cpu , & set ) ; <S2SV_StartBug> pthread_attr_setaffinity_np ( & attr , sizeof ( cpu_set_t ) , & set ) ; <S2SV_EndBug> if ( use_numa ) { struct rlimit limit ; if ( getrlimit ( RLIMIT_STACK , & limit ) == 0 ) { int node = _numa_node_of_cpu ( cpu ) ; void * stack = _numa_alloc_onnode ( ( size_t ) limit . rlim_cur , node ) ; if ( stack != NULL ) { pthread_attr_setstack ( & attr , stack , ( size_t ) limit . rlim_cur ) ; } } } } if ( pthread_create ( thread , & attr , start , arg ) ) return false ; pthread_attr_destroy ( & attr ) ; # else if ( pthread_create ( thread , NULL , start , arg ) ) return false ; # endif return true ; } | <S2SV_ModStart> set ) ; <S2SV_ModEnd> if ( use_numa |
2,275 | CWE-000 static int __vxlan_dev_create ( struct net * net , struct net_device * dev , struct vxlan_config * conf , struct netlink_ext_ack * extack ) { struct vxlan_net * vn = net_generic ( net , vxlan_net_id ) ; struct vxlan_dev * vxlan = netdev_priv ( dev ) ; struct vxlan_fdb * f = NULL ; <S2SV_StartBug> int err ; <S2SV_EndBug> err = vxlan_dev_configure ( net , dev , conf , false , extack ) ; if ( err ) return err ; dev -> ethtool_ops = & vxlan_ethtool_ops ; if ( ! vxlan_addr_any ( & vxlan -> default_dst . remote_ip ) ) { err = vxlan_fdb_create ( vxlan , all_zeros_mac , & vxlan -> default_dst . remote_ip , NUD_REACHABLE | NUD_PERMANENT , vxlan -> cfg . dst_port , vxlan -> default_dst . remote_vni , vxlan -> default_dst . remote_vni , vxlan -> default_dst . remote_ifindex , NTF_SELF , & f ) ; if ( err ) return err ; } err = register_netdevice ( dev ) ; if ( err ) goto errout ; <S2SV_StartBug> err = rtnl_configure_link ( dev , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> if ( err ) { <S2SV_EndBug> unregister_netdevice ( dev ) ; goto errout ; <S2SV_StartBug> } <S2SV_EndBug> if ( f ) vxlan_fdb_notify ( vxlan , f , first_remote_rtnl ( f ) , RTM_NEWNEIGH ) ; list_add ( & vxlan -> next , & vn -> vxlan_list ) ; return 0 ; errout : if ( f ) vxlan_fdb_destroy ( vxlan , f , false ) ; <S2SV_StartBug> return err ; <S2SV_EndBug> } | <S2SV_ModStart> = NULL ; bool unregister = false ; <S2SV_ModStart> goto errout ; unregister = true ; <S2SV_ModStart> ( err ) <S2SV_ModEnd> goto errout ; <S2SV_ModStart> goto errout ; <S2SV_ModEnd> if ( f <S2SV_ModStart> false ) ; if ( unregister ) unregister_netdevice ( dev ) ; |
2,276 | CWE-000 void __conn ( void ) { <S2SV_StartBug> PGconn * conn = nil ; <S2SV_EndBug> <S2SV_StartBug> Error * e = nil ; <S2SV_EndBug> So ( 1 , postgres . conn_checker ( PG_CONN_INFO ) ) ; __check_fatal ( e , postgres . conn ( PG_CONN_INFO , & conn ) ) ; SoN ( nil , conn ) ; postgres . conn_drop ( conn ) ; } | <S2SV_ModStart> void ) { Error * e <S2SV_ModEnd> = nil ; <S2SV_ModStart> = nil ; PGconn * conn <S2SV_ModEnd> = nil ; |
2,277 | CWE-000 int xfs_set_acl ( struct inode * inode , struct posix_acl * acl , int type ) { int error = 0 ; if ( ! acl ) goto set_acl ; error = - E2BIG ; if ( acl -> a_count > XFS_ACL_MAX_ENTRIES ( XFS_M ( inode -> i_sb ) ) ) return error ; if ( type == ACL_TYPE_ACCESS ) { umode_t mode ; <S2SV_StartBug> struct posix_acl * old_acl = acl ; <S2SV_EndBug> <S2SV_StartBug> error = posix_acl_update_mode ( inode , & mode , & acl ) ; <S2SV_EndBug> if ( ! acl ) posix_acl_release ( old_acl ) ; if ( error ) return error ; error = xfs_set_mode ( inode , mode ) ; if ( error ) return error ; } set_acl : return __xfs_set_acl ( inode , type , acl ) ; } | <S2SV_ModStart> umode_t mode ; <S2SV_ModEnd> error = posix_acl_update_mode <S2SV_ModStart> , & acl <S2SV_ModEnd> ) ; if |
2,278 | CWE-000 int send_msg ( int socket , int id , char * payMsg ) { if ( payMsg == NULL ) { payMsg = prepare_msg ( ) ; } if ( id == noid ) { printf ( "Defina<S2SV_blank>el<S2SV_blank>ID<S2SV_blank>del<S2SV_blank>mensaje<S2SV_blank>con<S2SV_blank>un<S2SV_blank>numero:\\n1:<S2SV_blank>numero\\n2:<S2SV_blank>cadena\\n" ) ; scanf ( "%d" , & id ) ; switch ( id ) { case numero : ; id = numero ; break ; case cadena : ; id = cadena ; break ; default : ; } } int len = strlen ( payMsg ) ; printf ( "estado<S2SV_blank>actual:<S2SV_blank>id:<S2SV_blank>%d,<S2SV_blank>len:<S2SV_blank>%d,<S2SV_blank>payMsg:<S2SV_blank>%s\\n" , id , len , payMsg ) ; <S2SV_StartBug> void * content = malloc ( sizeof ( int ) * 2 + sizeof ( char ) * strlen ( payMsg ) ) ; <S2SV_EndBug> memcpy ( content , & id , sizeof ( int ) ) ; memcpy ( content + sizeof ( int ) , & len , sizeof ( int ) ) ; strcpy ( content + 2 * sizeof ( int ) , payMsg ) ; log_info ( logger , "send_msg:<S2SV_blank>enviando<S2SV_blank>mensaje" ) ; int result = send ( socket , content , sizeof ( int ) * 2 + sizeof ( char ) * strlen ( payMsg ) , 0 ) ; if ( result <= 0 ) { log_error ( logger , "send_msg:<S2SV_blank>no<S2SV_blank>se<S2SV_blank>pudo<S2SV_blank>enviar<S2SV_blank>el<S2SV_blank>mensaje" ) ; return 0 ; } log_info ( logger , "send_msg:<S2SV_blank>mensaje<S2SV_blank>de<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>enviado" , result ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> char ) * ( len + 1 <S2SV_ModEnd> ) ) ; <S2SV_ModStart> result ) ; free ( content ) ; free ( payMsg ) ; |
2,279 | CWE-000 int parse_inode_from_beginning_block ( ) { printf ( "InodeBeginBlock:\\t%d\\n" , InodesBeginBlock ) ; get_block ( fd , InodesBeginBlock , char_buf ) ; ip = ( INODE * ) char_buf + 1 ; <S2SV_StartBug> printf ( "\\tMode:\\t%4x" , ip -> i_mode ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "\\tMid:\\t%d\\tgid=%d\\n" , ip -> i_uid , ip -> i_gid ) ; <S2SV_EndBug> printf ( "\\tSize:\\t%d\\n" , ip -> i_size ) ; printf ( "\\tTime:\\t%s" , ctime ( & ip -> i_ctime ) ) ; printf ( "\\tLink:\\t%d\\n" , ip -> i_links_count ) ; printf ( "\\ti_block[0]:\\t%d\\n" , ip -> i_block [ 0 ] ) ; } | <S2SV_ModStart> ; printf ( "\\tMode:\\t%4x\\n" <S2SV_ModEnd> , ip -> <S2SV_ModStart> ; printf ( "\\tMid:\\t%d\\n\\tgid=%d\\n" <S2SV_ModEnd> , ip -> |
2,280 | CWE-000 static bool note_outside_basic_block_p ( enum insn_note subtype , bool on_bb_boundary_p ) { switch ( subtype ) { case NOTE_INSN_SWITCH_TEXT_SECTIONS : return true ; case NOTE_INSN_VAR_LOCATION : <S2SV_StartBug> case NOTE_INSN_CALL_ARG_LOCATION : <S2SV_EndBug> case NOTE_INSN_EH_REGION_BEG : case NOTE_INSN_EH_REGION_END : return on_bb_boundary_p ; default : return false ; } } | <S2SV_ModStart> NOTE_INSN_VAR_LOCATION : case <S2SV_ModEnd> NOTE_INSN_EH_REGION_BEG : case |
2,281 | CWE-000 static int bin_realloc ( bin_packet_t * packet , int size ) { int required ; if ( size < 0 || packet -> buffer . len > MAX_BUF_LEN - size ) { LM_ERR ( "cannot<S2SV_blank>make<S2SV_blank>the<S2SV_blank>buffer<S2SV_blank>bigger\\n" ) ; return - 1 ; } required = packet -> buffer . len + size ; if ( required > MAX_BUF_LEN - required ) packet -> size = MAX_BUF_LEN ; else packet -> size = 2 * required ; packet -> buffer . s = pkg_realloc ( packet -> buffer . s , packet -> size ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> size ) ; if ( ! packet -> buffer . s ) { LM_ERR ( "pkg<S2SV_blank>realloc<S2SV_blank>failed\\n" ) ; return - 1 ; } |
2,282 | CWE-000 struct pipe_screen * <S2SV_StartBug> vc4_screen_create ( int fd ) <S2SV_EndBug> { struct vc4_screen * screen = rzalloc ( NULL , struct vc4_screen ) ; struct pipe_screen * pscreen ; pscreen = & screen -> base ; pscreen -> destroy = vc4_screen_destroy ; pscreen -> get_param = vc4_screen_get_param ; pscreen -> get_paramf = vc4_screen_get_paramf ; pscreen -> get_shader_param = vc4_screen_get_shader_param ; pscreen -> context_create = vc4_context_create ; pscreen -> is_format_supported = vc4_screen_is_format_supported ; <S2SV_StartBug> screen -> fd = fd ; <S2SV_EndBug> list_inithead ( & screen -> bo_cache . time_list ) ; ( void ) mtx_init ( & screen -> bo_handles_mutex , mtx_plain ) ; screen -> bo_handles = util_hash_table_create ( handle_hash , handle_compare ) ; screen -> has_control_flow = vc4_has_feature ( screen , DRM_VC4_PARAM_SUPPORTS_BRANCHES ) ; screen -> has_etc1 = vc4_has_feature ( screen , DRM_VC4_PARAM_SUPPORTS_ETC1 ) ; screen -> has_threaded_fs = vc4_has_feature ( screen , DRM_VC4_PARAM_SUPPORTS_THREADED_FS ) ; if ( ! vc4_get_chip_info ( screen ) ) goto fail ; util_cpu_detect ( ) ; slab_create_parent ( & screen -> transfer_pool , sizeof ( struct vc4_transfer ) , 16 ) ; vc4_fence_init ( screen ) ; vc4_debug = debug_get_option_vc4_debug ( ) ; if ( vc4_debug & VC4_DEBUG_SHADERDB ) vc4_debug |= VC4_DEBUG_NORAST ; # if USE_VC4_SIMULATOR vc4_simulator_init ( screen ) ; # endif vc4_resource_screen_init ( pscreen ) ; pscreen -> get_name = vc4_screen_get_name ; pscreen -> get_vendor = vc4_screen_get_vendor ; pscreen -> get_device_vendor = vc4_screen_get_vendor ; pscreen -> get_compiler_options = vc4_screen_get_compiler_options ; return pscreen ; fail : close ( fd ) ; ralloc_free ( pscreen ) ; return NULL ; } | <S2SV_ModStart> ( int fd , struct renderonly * ro <S2SV_ModStart> = fd ; if ( ro ) { screen -> ro = renderonly_dup ( ro ) ; if ( ! screen -> ro ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>dup<S2SV_blank>renderonly<S2SV_blank>object\\n" ) ; ralloc_free ( screen ) ; return NULL ; } } |
2,283 | CWE-000 static void scheduleProcessInbox ( Capability * * pcap USED_IF_THREADS ) { # if defined ( THREADED_RTS ) Message * m , * next ; PutMVar * p , * pnext ; int r ; Capability * cap = * pcap ; while ( ! emptyInbox ( cap ) ) { <S2SV_StartBug> if ( cap -> r . rCurrentNursery -> link == NULL || <S2SV_EndBug> g0 -> n_new_large_words >= large_alloc_lim ) { scheduleDoGC ( pcap , cap -> running_task , false ) ; cap = * pcap ; } r = TRY_ACQUIRE_LOCK ( & cap -> lock ) ; if ( r != 0 ) return ; m = cap -> inbox ; p = cap -> putMVars ; cap -> inbox = ( Message * ) END_TSO_QUEUE ; cap -> putMVars = NULL ; RELEASE_LOCK ( & cap -> lock ) ; while ( m != ( Message * ) END_TSO_QUEUE ) { next = m -> link ; executeMessage ( cap , m ) ; m = next ; } while ( p != NULL ) { pnext = p -> link ; performTryPutMVar ( cap , ( StgMVar * ) deRefStablePtr ( p -> mvar ) , Unit_closure ) ; freeStablePtr ( p -> mvar ) ; stgFree ( p ) ; p = pnext ; } } # endif } | <S2SV_ModStart> { if ( doYouWantToGC ( cap ) <S2SV_ModEnd> ) { scheduleDoGC |
2,284 | CWE-000 EFI_STATUS IScsiDhcp6ExtractRootPath ( IN CHAR8 * RootPath , IN UINT16 Length , IN OUT ISCSI_ATTEMPT_CONFIG_NVDATA * ConfigData ) { EFI_STATUS Status ; UINT16 IScsiRootPathIdLen ; CHAR8 * TmpStr ; ISCSI_ROOT_PATH_FIELD Fields [ RP_FIELD_IDX_MAX ] ; ISCSI_ROOT_PATH_FIELD * Field ; UINT32 FieldIndex ; UINT8 Index ; ISCSI_SESSION_CONFIG_NVDATA * ConfigNvData ; EFI_IP_ADDRESS Ip ; UINT8 IpMode ; ConfigNvData = & ConfigData -> SessionConfigData ; <S2SV_StartBug> IScsiRootPathIdLen = ( UINT16 ) AsciiStrLen ( ISCSI_ROOT_PATH_ID ) ; <S2SV_EndBug> if ( ( Length <= IScsiRootPathIdLen ) || ( CompareMem ( RootPath , ISCSI_ROOT_PATH_ID , IScsiRootPathIdLen ) != 0 ) ) { return EFI_NOT_FOUND ; } RootPath = RootPath + IScsiRootPathIdLen ; Length = ( UINT16 ) ( Length - IScsiRootPathIdLen ) ; TmpStr = ( CHAR8 * ) AllocatePool ( Length + 1 ) ; if ( TmpStr == NULL ) { return EFI_OUT_OF_RESOURCES ; } CopyMem ( TmpStr , RootPath , Length ) ; TmpStr [ Length ] = '\\0' ; Index = 0 ; FieldIndex = 0 ; ZeroMem ( & Fields [ 0 ] , sizeof ( Fields ) ) ; if ( TmpStr [ Index ] != ISCSI_ROOT_PATH_ADDR_START_DELIMITER ) { <S2SV_StartBug> Status = EFI_INVALID_PARAMETER ; <S2SV_EndBug> goto ON_EXIT ; } else { Index ++ ; } <S2SV_StartBug> Fields [ RP_FIELD_IDX_SERVERNAME ] . Str = & TmpStr [ Index ] ; <S2SV_EndBug> while ( ( TmpStr [ Index ] != ISCSI_ROOT_PATH_ADDR_END_DELIMITER ) && ( Index < Length ) ) { Index ++ ; } TmpStr [ Index ] = '\\0' ; <S2SV_StartBug> Index += 2 ; <S2SV_EndBug> Fields [ RP_FIELD_IDX_SERVERNAME ] . Len = ( UINT8 ) AsciiStrLen ( Fields [ RP_FIELD_IDX_SERVERNAME ] . Str ) ; for ( FieldIndex = 1 ; ( FieldIndex < RP_FIELD_IDX_MAX ) && ( Index < Length ) ; FieldIndex ++ ) { if ( TmpStr [ Index ] != ISCSI_ROOT_PATH_FIELD_DELIMITER ) { Fields [ FieldIndex ] . Str = & TmpStr [ Index ] ; } while ( ( TmpStr [ Index ] != ISCSI_ROOT_PATH_FIELD_DELIMITER ) && ( Index < Length ) ) { Index ++ ; } if ( TmpStr [ Index ] == ISCSI_ROOT_PATH_FIELD_DELIMITER ) { if ( FieldIndex != RP_FIELD_IDX_TARGETNAME ) { TmpStr [ Index ] = '\\0' ; Index ++ ; } if ( Fields [ FieldIndex ] . Str != NULL ) { Fields [ FieldIndex ] . Len = ( UINT8 ) AsciiStrLen ( Fields [ FieldIndex ] . Str ) ; } } } if ( FieldIndex != RP_FIELD_IDX_MAX ) { Status = EFI_INVALID_PARAMETER ; goto ON_EXIT ; } if ( ( Fields [ RP_FIELD_IDX_SERVERNAME ] . Str == NULL ) || ( Fields [ RP_FIELD_IDX_TARGETNAME ] . Str == NULL ) || ( Fields [ RP_FIELD_IDX_PROTOCOL ] . Len > 1 ) ) { Status = EFI_INVALID_PARAMETER ; goto ON_EXIT ; } Field = & Fields [ RP_FIELD_IDX_SERVERNAME ] ; if ( ConfigNvData -> IpMode < IP_MODE_AUTOCONFIG ) { IpMode = ConfigNvData -> IpMode ; } else { IpMode = ConfigData -> AutoConfigureMode ; } <S2SV_StartBug> if ( ( ! NET_IS_DIGIT ( * ( Field -> Str ) ) ) && ( * ( Field -> Str ) != '[' ) ) { <S2SV_EndBug> <S2SV_StartBug> ConfigNvData -> DnsMode = TRUE ; <S2SV_EndBug> if ( Field -> Len > sizeof ( ConfigNvData -> TargetUrl ) ) { return EFI_INVALID_PARAMETER ; } CopyMem ( & ConfigNvData -> TargetUrl , Field -> Str , Field -> Len ) ; ConfigNvData -> TargetUrl [ Field -> Len + 1 ] = '\\0' ; } else { ZeroMem ( & ConfigNvData -> TargetUrl , sizeof ( ConfigNvData -> TargetUrl ) ) ; Status = IScsiAsciiStrToIp ( Field -> Str , IpMode , & Ip ) ; CopyMem ( & ConfigNvData -> TargetIp , & Ip , sizeof ( EFI_IP_ADDRESS ) ) ; if ( EFI_ERROR ( Status ) ) { goto ON_EXIT ; } } Field = & Fields [ RP_FIELD_IDX_PROTOCOL ] ; if ( ( Field -> Str != NULL ) && ( ( * ( Field -> Str ) - '0' ) != EFI_IP_PROTO_TCP ) ) { Status = EFI_INVALID_PARAMETER ; goto ON_EXIT ; } Field = & Fields [ RP_FIELD_IDX_PORT ] ; if ( Field -> Str != NULL ) { ConfigNvData -> TargetPort = ( UINT16 ) AsciiStrDecimalToUintn ( Field -> Str ) ; } else { ConfigNvData -> TargetPort = ISCSI_WELL_KNOWN_PORT ; } Field = & Fields [ RP_FIELD_IDX_LUN ] ; if ( Field -> Str != NULL ) { Status = IScsiAsciiStrToLun ( Field -> Str , ConfigNvData -> BootLun ) ; if ( EFI_ERROR ( Status ) ) { goto ON_EXIT ; } } else { ZeroMem ( ConfigNvData -> BootLun , sizeof ( ConfigNvData -> BootLun ) ) ; } Field = & Fields [ RP_FIELD_IDX_TARGETNAME ] ; if ( AsciiStrLen ( Field -> Str ) > ISCSI_NAME_MAX_SIZE - 1 ) { Status = EFI_INVALID_PARAMETER ; goto ON_EXIT ; } Status = IScsiNormalizeName ( Field -> Str , AsciiStrLen ( Field -> Str ) ) ; if ( EFI_ERROR ( Status ) ) { goto ON_EXIT ; } AsciiStrCpyS ( ConfigNvData -> TargetName , ISCSI_NAME_MAX_SIZE , Field -> Str ) ; ON_EXIT : FreePool ( TmpStr ) ; return Status ; } | <S2SV_ModStart> -> SessionConfigData ; ConfigNvData -> DnsMode = FALSE ; <S2SV_ModStart> ISCSI_ROOT_PATH_ADDR_START_DELIMITER ) { ConfigNvData -> DnsMode = TRUE <S2SV_ModEnd> ; } else <S2SV_ModStart> Index ] ; if ( ! ConfigNvData -> DnsMode ) { <S2SV_ModStart> += 2 ; } else { while ( ( TmpStr [ Index ] != ISCSI_ROOT_PATH_FIELD_DELIMITER ) && ( Index < Length ) ) { Index ++ ; } TmpStr [ Index ] = '\\0' ; Index += 1 ; } <S2SV_ModStart> } if ( <S2SV_ModEnd> ConfigNvData -> DnsMode <S2SV_ModStart> ConfigNvData -> DnsMode ) { <S2SV_ModEnd> if ( Field |
2,285 | CWE-000 void str_seq ( char * nucl_seq , int length ) { <S2SV_StartBug> int i , j , weak_counter = 0 ; <S2SV_EndBug> char c ; for ( i = 0 ; i < length ; i ++ ) { if ( * ( nucl_seq + i ) == 'c' || * ( nucl_seq + i ) == 'r' ) weak_counter = 0 ; else weak_counter ++ ; if ( weak_counter >= 5 ) { for ( j = i ; j >= 0 ; j -- ) { c = * ( nucl_seq + j ) ; <S2SV_StartBug> if ( c != 't' && c != 'c' ) { <S2SV_EndBug> * ( nucl_seq + j ) = 'r' ; weak_counter = i - j ; break ; } } } } } | <S2SV_ModStart> { int i ; int j ; int <S2SV_ModEnd> weak_counter = 0 <S2SV_ModStart> if ( c == 'a' || c == 'g' <S2SV_ModEnd> ) { * |
2,286 | CWE-000 void smp_destroy_apboot ( ) { <S2SV_StartBug> for ( page_t page = 0 ; page <= memInfo . kernelEnd - memInfo . kernelVirtualOffset ; page += PAGE_SIZE_4K ) <S2SV_EndBug> paging_unmap_virtual ( page ) ; } | <S2SV_ModStart> { for ( uintptr_t <S2SV_ModEnd> page = 0 |
2,287 | CWE-000 <S2SV_StartBug> int ffpatched_handleSDLKeyEvent ( Uint8 sdlKey ) { <S2SV_EndBug> switch ( sdlKey ) { case SDLK_n : IS_AUDIO_COMPRESS_ENABLED = ! IS_AUDIO_COMPRESS_ENABLED ; av_log ( NULL , AV_LOG_WARNING , "\\nIS_AUDIO_COMPRESS_ENABLED<S2SV_blank>=<S2SV_blank>%d\\n\\n" , IS_AUDIO_COMPRESS_ENABLED ) ; break ; case SDLK_b : if ( DURATION_IS_KNOWN ) { IS_BITRATE_BAR_ENABLED = ! IS_BITRATE_BAR_ENABLED ; av_log ( NULL , AV_LOG_WARNING , "\\nIS_BITRATE_BAR_ENABLED<S2SV_blank>=<S2SV_blank>%d\\n\\n" , IS_BITRATE_BAR_ENABLED ) ; } else { av_log ( NULL , AV_LOG_WARNING , "\\nBITRATE<S2SV_blank>BAR<S2SV_blank>NOT<S2SV_blank>AVAILABLE\\n\\n" ) ; } break ; case SDLK_h : IS_VIDEO_NORMALIZER_ENABLED = ! IS_VIDEO_NORMALIZER_ENABLED ; av_log ( NULL , AV_LOG_WARNING , "\\nIS_VIDEO_NORMALIZER_ENABLED<S2SV_blank>=<S2SV_blank>%d\\n\\n" , IS_VIDEO_NORMALIZER_ENABLED ) ; break ; default : break ; } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static void <S2SV_ModEnd> ffpatched_handleSDLKeyEvent ( Uint8 |
2,288 | CWE-000 Test ( rdm_rma_scalable , inject_writedata ) <S2SV_StartBug> { <S2SV_EndBug> xfer_for_each_size ( do_inject_writedata , 8 , INJECT_SIZE ) ; } | <S2SV_ModStart> inject_writedata ) { cr_skip_test ( "intermittent<S2SV_blank>test<S2SV_blank>failures" ) ; |
2,289 | CWE-000 int merge_trees ( struct merge_options * o , struct tree * head , struct tree * merge , struct tree * common , struct tree * * result ) { int code , clean ; if ( o -> subtree_shift ) { merge = shift_tree_object ( head , merge , o -> subtree_shift ) ; common = shift_tree_object ( head , common , o -> subtree_shift ) ; } if ( oid_eq ( & common -> object . oid , & merge -> object . oid ) ) { output ( o , 0 , _ ( "Already<S2SV_blank>up<S2SV_blank>to<S2SV_blank>date!" ) ) ; * result = head ; return 1 ; } code = git_merge_trees ( o -> call_depth , common , head , merge ) ; if ( code != 0 ) { if ( show ( o , 4 ) || o -> call_depth ) err ( o , _ ( "merging<S2SV_blank>of<S2SV_blank>trees<S2SV_blank>%s<S2SV_blank>and<S2SV_blank>%s<S2SV_blank>failed" ) , oid_to_hex ( & head -> object . oid ) , oid_to_hex ( & merge -> object . oid ) ) ; return - 1 ; } if ( unmerged_cache ( ) ) { struct string_list * entries , * re_head , * re_merge ; int i ; hashmap_init ( & o -> current_file_dir_set , path_hashmap_cmp , NULL , 512 ) ; get_files_dirs ( o , head ) ; get_files_dirs ( o , merge ) ; entries = get_unmerged ( ) ; <S2SV_StartBug> record_df_conflict_files ( o , entries ) ; <S2SV_EndBug> re_head = get_renames ( o , head , common , head , merge , entries ) ; re_merge = get_renames ( o , merge , common , head , merge , entries ) ; clean = process_renames ( o , re_head , re_merge ) ; if ( clean < 0 ) goto cleanup ; for ( i = entries -> nr - 1 ; 0 <= i ; i -- ) { const char * path = entries -> items [ i ] . string ; struct stage_data * e = entries -> items [ i ] . util ; if ( ! e -> processed ) { int ret = process_entry ( o , path , e ) ; if ( ! ret ) clean = 0 ; else if ( ret < 0 ) { clean = ret ; goto cleanup ; } } } for ( i = 0 ; i < entries -> nr ; i ++ ) { struct stage_data * e = entries -> items [ i ] . util ; if ( ! e -> processed ) die ( "BUG:<S2SV_blank>unprocessed<S2SV_blank>path???<S2SV_blank>%s" , entries -> items [ i ] . string ) ; } cleanup : string_list_clear ( re_merge , 0 ) ; string_list_clear ( re_head , 0 ) ; string_list_clear ( entries , 1 ) ; hashmap_free ( & o -> current_file_dir_set , 1 ) ; free ( re_merge ) ; free ( re_head ) ; free ( entries ) ; if ( clean < 0 ) return clean ; } else clean = 1 ; if ( o -> call_depth && ! ( * result = write_tree_from_memory ( o ) ) ) return - 1 ; return clean ; } | <S2SV_ModStart> ( ) ; re_head = get_renames ( o , head , common , head , merge , entries ) ; re_merge = get_renames ( o , merge , common , head , merge , entries ) ; clean = process_renames ( o , re_head , re_merge ) ; <S2SV_ModStart> o , entries <S2SV_ModEnd> ) ; if |
2,290 | CWE-000 double xx_MIXED ( double * x , int nr , int nc , int i1 , int i2 , int * vtype , double * weights , double * R , double wsum , double * T , double * Trange ) { double dist , dev ; int count , j ; count = 0 ; dist = 0.0 ; wsum = 0.0 ; for ( j = 0 ; j < nc ; j ++ ) { if ( R_FINITE ( x [ i1 ] ) && R_FINITE ( x [ i2 ] ) ) { if ( vtype [ j ] == 1 ) { dev = allEqual ( x [ i1 ] , x [ i2 ] ) ? 1 : 0 ; dist += dev * weights [ j ] ; } if ( vtype [ j ] == 2 ) { if ( ( x [ i1 ] != 0 ) || ( x [ i2 ] != 0 ) ) { dev = allEqual ( x [ i1 ] , x [ i2 ] ) ? 1 : 0 ; dist += dev * weights [ j ] ; } else { wsum -= weights [ j ] ; } } if ( vtype [ j ] == 3 ) { dev = allEqual ( x [ i1 ] , x [ i2 ] ) ? 1 : 0 ; dist += dev * weights [ j ] ; } if ( vtype [ j ] == 4 ) { if ( allEqual ( x [ i1 ] , x [ i2 ] ) ) { dev = 1 ; } else { dev = 1 - ( ( fabs ( x [ i1 ] - x [ i2 ] ) - T [ i1 ] - T [ i2 ] ) / ( R [ j ] - Trange [ j ] ) ) ; } dist += dev * weights [ j ] ; <S2SV_StartBug> break ; <S2SV_EndBug> } if ( vtype [ j ] == 5 ) { dev = 1 - ( fabs ( x [ i1 ] - x [ i2 ] ) / R [ j ] ) ; dist += dev * weights [ j ] ; } count ++ ; wsum += weights [ j ] ; } i1 += nr ; i2 += nr ; } if ( count == 0 ) return NA_REAL ; return 1 - ( dist / wsum ) ; } | <S2SV_ModStart> j ] ; <S2SV_ModEnd> } if ( |
2,291 | CWE-000 LinkedList LinkedListCreate ( elemtype x ) { int i = 1 ; int keep ; Node * head , * p , * q ; head = ( Node * ) malloc ( sizeof ( Node ) ) ; if ( head == NULL ) printf ( "Failed<S2SV_blank>to<S2SV_blank>apply<S2SV_blank>memory<S2SV_blank>space!\\n" ) ; head -> next = NULL ; head -> prior = NULL ; if ( x > 0 ) { scanf ( "%d" , & keep ) ; head -> data = keep ; q = head ; } for ( ; i < x ; i ++ ) { p = ( Node * ) malloc ( sizeof ( Node ) ) ; p -> prior = NULL ; scanf ( "%d" , & keep ) ; p -> data = keep ; p -> next = q ; <S2SV_StartBug> q -> next = p ; <S2SV_EndBug> q = p ; } return head ; } | <S2SV_ModStart> = q ; head <S2SV_ModEnd> -> next = |
2,292 | CWE-000 static int pci_mmap_resource ( struct kobject * kobj , struct bin_attribute * attr , struct vm_area_struct * vma , int sparse ) { struct pci_dev * pdev = to_pci_dev ( container_of ( kobj , struct device , kobj ) ) ; struct resource * res = attr -> private ; enum pci_mmap_state mmap_type ; struct pci_bus_region bar ; int i ; for ( i = 0 ; i < PCI_ROM_RESOURCE ; i ++ ) if ( res == & pdev -> resource [ i ] ) break ; if ( i >= PCI_ROM_RESOURCE ) return - ENODEV ; <S2SV_StartBug> if ( ! __pci_mmap_fits ( pdev , i , vma , sparse ) ) <S2SV_EndBug> return - EINVAL ; if ( iomem_is_exclusive ( res -> start ) ) return - EINVAL ; pcibios_resource_to_bus ( pdev -> bus , & bar , res ) ; vma -> vm_pgoff += bar . start >> ( PAGE_SHIFT - ( sparse ? 5 : 0 ) ) ; mmap_type = res -> flags & IORESOURCE_MEM ? pci_mmap_mem : pci_mmap_io ; return hose_mmap_page_range ( pdev -> sysdata , vma , mmap_type , sparse ) ; } | <S2SV_ModStart> ; if ( res -> flags & IORESOURCE_MEM && iomem_is_exclusive ( res -> start ) ) return - EINVAL ; if ( <S2SV_ModStart> vma , sparse <S2SV_ModEnd> ) ) return |
2,293 | CWE-000 void rpc_warnx ( char * fmt , ... ) { va_list ap ; <S2SV_StartBug> if ( component_log_level [ COMPONENT_TIRPC ] < NIV_DEBUG ) <S2SV_EndBug> return ; va_start ( ap , fmt ) ; display_log_component_level ( COMPONENT_TIRPC , "<no-file>" , 0 , "rpc" , <S2SV_StartBug> NIV_DEBUG , fmt , ap ) ; <S2SV_EndBug> va_end ( ap ) ; } | <S2SV_ModStart> [ COMPONENT_TIRPC ] <= NIV_FATAL <S2SV_ModEnd> ) return ; <S2SV_ModStart> , "rpc" , component_log_level [ COMPONENT_TIRPC ] <S2SV_ModEnd> , fmt , |
2,294 | CWE-000 static void close_connection ( struct xdag_rpc_connection * conn ) { <S2SV_StartBug> shutdown ( conn -> fd . fd , SHUT_RDWR ) ; <S2SV_EndBug> close ( conn -> fd . fd ) ; free ( conn ) ; } | <S2SV_ModStart> . fd , SHUT_WR ) ; recv ( conn -> fd . fd , NULL , 0 , 0 <S2SV_ModEnd> ) ; close |
2,295 | CWE-000 PyLiteObject * pylt_obj_float_floordiv ( PyLiteInterpreter * I , PyLiteFloatObject * self , PyLiteObject * other ) { switch ( other -> ob_type ) { <S2SV_StartBug> case PYLT_OBJ_TYPE_INT : <S2SV_EndBug> return castobj ( pylt_obj_int_new ( I , ( uint32_t ) ( self -> ob_val / ( uint32_t ) castint ( other ) -> ob_val ) ) ) ; <S2SV_StartBug> case PYLT_OBJ_TYPE_FLOAT : <S2SV_EndBug> return castobj ( pylt_obj_int_new ( I , ( uint32_t ) ( self -> ob_val / ( uint32_t ) castfloat ( other ) -> ob_val ) ) ) ; default : return NULL ; } } | <S2SV_ModStart> case PYLT_OBJ_TYPE_INT : if ( castint ( other ) -> ob_val == 0 ) { pl_error ( I , pl_static . str . ZeroDivisionError , "float<S2SV_blank>division<S2SV_blank>by<S2SV_blank>zero" ) ; return NULL ; } <S2SV_ModStart> case PYLT_OBJ_TYPE_FLOAT : if ( castfloat ( other ) -> ob_val == 0 ) { pl_error ( I , pl_static . str . ZeroDivisionError , "float<S2SV_blank>division<S2SV_blank>by<S2SV_blank>zero" ) ; return NULL ; } |
2,296 | CWE-000 <S2SV_StartBug> static int send_dump_request ( int fd , int family , int type ) <S2SV_EndBug> { struct get_req req ; memset ( & req , 0 , sizeof ( req ) ) ; req . n . nlmsg_len = sizeof ( req ) ; req . n . nlmsg_type = type ; <S2SV_StartBug> req . n . nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT | NLM_F_MATCH ; <S2SV_EndBug> req . n . nlmsg_pid = 0 ; req . n . nlmsg_seq = 0 ; <S2SV_StartBug> req . g . rtgen_family = family ; <S2SV_EndBug> return send ( fd , ( void * ) & req , sizeof ( req ) , 0 ) ; } | <S2SV_ModStart> ( int fd , const char * name <S2SV_ModStart> nlmsg_flags = NLM_F_REQUEST <S2SV_ModEnd> ; req . <S2SV_ModStart> ; req . i . ifi_family <S2SV_ModEnd> = family ; <S2SV_ModStart> = family ; if ( name == NULL ) { req . n . nlmsg_flags |= NLM_F_DUMP ; } else { req . i . ifi_index = if_nametoindex ( name ) ; if ( req . i . ifi_index == 0 ) { fprintf ( stderr , "Cannot<S2SV_blank>find<S2SV_blank>device<S2SV_blank>\\"%s\\"\\n" , name ) ; return - 1 ; } } |
2,297 | CWE-000 void pthreads_streams_api_file_popen ( char * command , char * mode , int mode_len , zval * return_value ) { pthreads_stream_t * threaded_stream ; FILE * fp ; char * posix_mode ; posix_mode = estrndup ( mode , mode_len ) ; # ifndef PHP_WIN32 { char * z = memchr ( posix_mode , 'b' , mode_len ) ; if ( z ) { memmove ( z , z + 1 , mode_len - ( z - posix_mode ) ) ; } } # endif fp = VCWD_POPEN ( command , posix_mode ) ; if ( ! fp ) { php_error_docref2 ( NULL , command , posix_mode , E_WARNING , "%s" , strerror ( errno ) ) ; efree ( posix_mode ) ; RETURN_NULL ( ) ; } <S2SV_StartBug> threaded_stream = _pthreads_stream_fopen_from_pipe ( fp , mode , NULL , pthreads_file_stream_entry ) ; <S2SV_EndBug> if ( threaded_stream == NULL ) { php_error_docref2 ( NULL , command , mode , E_WARNING , "%s" , strerror ( errno ) ) ; RETVAL_NULL ( ) ; } else { pthreads_stream_to_zval ( threaded_stream , return_value ) ; } efree ( posix_mode ) ; } | <S2SV_ModStart> , mode , <S2SV_ModEnd> pthreads_file_stream_entry ) ; |
2,298 | CWE-000 void wcmEvent ( WacomCommonPtr common , unsigned int channel , const WacomDeviceState * pState ) { WacomDeviceState ds ; <S2SV_StartBug> WacomChannelPtr pChannel ; <S2SV_EndBug> enum WacomSuppressMode suppress ; InputInfoPtr pInfo ; WacomToolPtr tool ; WacomDevicePtr priv ; pChannel = common -> wcmChannel + channel ; DBG ( 10 , common , "channel<S2SV_blank>=<S2SV_blank>%d\\n" , channel ) ; if ( channel >= MAX_CHANNELS ) return ; ds = * pState ; DBG ( 10 , common , "c=%d<S2SV_blank>i=%d<S2SV_blank>t=%d<S2SV_blank>s=%u<S2SV_blank>x=%d<S2SV_blank>y=%d<S2SV_blank>b=%d<S2SV_blank>" "p=%d<S2SV_blank>rz=%d<S2SV_blank>tx=%d<S2SV_blank>ty=%d<S2SV_blank>aw=%d<S2SV_blank>aw2=%d<S2SV_blank>rw=%d<S2SV_blank>" "t=%d<S2SV_blank>px=%d<S2SV_blank>st=%d<S2SV_blank>cs=%d<S2SV_blank>\\n" , channel , ds . device_id , ds . device_type , ds . serial_num , ds . x , ds . y , ds . buttons , ds . pressure , ds . rotation , ds . tiltx , ds . tilty , ds . abswheel , ds . abswheel2 , ds . relwheel , ds . throttle , ds . proximity , ds . sample , pChannel -> nSamples ) ; tool = findTool ( common , & ds ) ; if ( ! tool || ! tool -> device ) { DBG ( 11 , common , "no<S2SV_blank>device<S2SV_blank>matches<S2SV_blank>with<S2SV_blank>id=%d,<S2SV_blank>serial=%u\\n" , ds . device_type , ds . serial_num ) ; return ; } if ( ! tool -> enabled ) { LogMessageVerbSigSafe ( X_ERROR , 0 , "tool<S2SV_blank>not<S2SV_blank>initialized<S2SV_blank>yet.<S2SV_blank>Skipping<S2SV_blank>event.<S2SV_blank>\\n" ) ; return ; } pInfo = tool -> device ; priv = pInfo -> private ; DBG ( 11 , common , "tool<S2SV_blank>id=%d<S2SV_blank>for<S2SV_blank>%s\\n" , ds . device_type , pInfo -> name ) ; if ( TabletHasFeature ( common , WCM_ROTATION ) && TabletHasFeature ( common , WCM_RING ) && ds . device_type == CURSOR_ID ) { ds . rotation = wcmTilt2R ( ds . tiltx , ds . tilty , INTUOS4_CURSOR_ROTATION_OFFSET ) ; ds . tiltx = 0 ; ds . tilty = 0 ; } memmove ( pChannel -> valid . states + 1 , pChannel -> valid . states , sizeof ( WacomDeviceState ) * ( common -> wcmRawSample - 1 ) ) ; pChannel -> valid . state = ds ; if ( pChannel -> nSamples < common -> wcmRawSample ) ++ pChannel -> nSamples ; if ( check_arbitrated_control ( pInfo , & ds ) ) { if ( WACOM_DRIVER . active != NULL && priv != WACOM_DRIVER . active ) { wcmSoftOutEvent ( WACOM_DRIVER . active -> pInfo ) ; wcmCancelGesture ( WACOM_DRIVER . active -> pInfo ) ; } if ( ds . proximity ) WACOM_DRIVER . active = priv ; else WACOM_DRIVER . active = NULL ; } else if ( ! IsPad ( priv ) ) { return ; } if ( ( ds . device_type == TOUCH_ID ) && common -> wcmTouch ) { wcmGestureFilter ( priv , ds . serial_num - 1 ) ; # if GET_ABI_MAJOR ( ABI_XINPUT_VERSION ) >= 16 if ( ! common -> wcmGesture && TabletHasFeature ( common , WCM_LCD ) ) return ; # endif } if ( ( common -> wcmTouch && ds . device_type == TOUCH_ID && ds . serial_num == 1 ) || ( ds . device_type != TOUCH_ID ) ) <S2SV_StartBug> commonDispatchDevice ( pInfo , pChannel , suppress ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; WacomChannelPtr pChannel <S2SV_ModEnd> ; InputInfoPtr pInfo <S2SV_ModStart> pInfo , pChannel <S2SV_ModEnd> ) ; } |
2,299 | CWE-000 AST * TransformCaseExprList ( AST * var , AST * ast ) { AST * listexpr = NULL ; AST * node ; <S2SV_StartBug> while ( ast ) { <S2SV_EndBug> if ( ast -> kind == AST_OTHER ) { return AstInteger ( 1 ) ; } else { if ( ast -> left -> kind == AST_RANGE ) { node = NewAST ( AST_ISBETWEEN , var , ast -> left ) ; } else { node = AstOperator ( T_EQ , var , ast -> left ) ; } } if ( listexpr ) { listexpr = AstOperator ( T_OR , listexpr , node ) ; } else { listexpr = node ; } ast = ast -> right ; } return listexpr ; } | <S2SV_ModStart> ast ) { AstReportAs ( ast ) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.