Datasets:
xin1997
/
bugfix_pretraining

Dataset card Data Studio Files Community
Unnamed: 0
int64
0
535k
source
stringlengths
50
89.8k
target
stringlengths
23
37.7k
3,900
CWE-000 int dsi_display_set_power ( struct drm_connector * connector , int power_mode , void * disp ) { struct dsi_display * display = disp ; int rc = 0 ; struct msm_drm_notifier notifier_data ; int blank ; int aod_mode = 0 ; if ( ! display || ! display -> panel ) { pr_err ( "invalid<S2SV_blank>display/panel\\n" ) ; return - EINVAL ; } switch ( power_mode ) { case SDE_MODE_DPMS_LP1 : printk ( KERN_ERR "SDE_MODE_DPMS_LP1\\n" ) ; <S2SV_StartBug> rc = dsi_panel_set_lp1 ( display -> panel ) ; <S2SV_EndBug> aod_mode = display -> panel -> aod_mode ; printk ( KERN_ERR "When<S2SV_blank>on<S2SV_blank>doze<S2SV_blank>state<S2SV_blank>AOD_MODE<S2SV_blank>=<S2SV_blank>%d\\n" , aod_mode ) ; if ( aod_mode != 0 ) { <S2SV_StartBug> dsi_panel_set_aod_mode ( display -> panel , aod_mode ) ; <S2SV_EndBug> } break ; case SDE_MODE_DPMS_LP2 : printk ( KERN_ERR "SDE_MODE_DPMS_LP2\\n" ) ; rc = dsi_panel_set_lp2 ( display -> panel ) ; break ; default : printk ( KERN_ERR "SDE_MODE_DPMS<S2SV_blank>default\\n" ) ; rc = dsi_panel_set_nolp ( display -> panel ) ; if ( ( power_mode == SDE_MODE_DPMS_ON ) && display -> panel -> aod_status ) { aod_mode = 0 ; printk ( KERN_ERR "Turn<S2SV_blank>off<S2SV_blank>AOD<S2SV_blank>MODE<S2SV_blank>aod_mode<S2SV_blank>=<S2SV_blank>%d\\n" , aod_mode ) ; dsi_panel_set_aod_mode ( display -> panel , aod_mode ) ; rc = dsi_panel_enable ( display -> panel ) ; } else if ( ( power_mode == SDE_MODE_DPMS_OFF ) && display -> panel -> aod_status ) { display -> panel -> aod_status = 0 ; display -> panel -> aod_curr_mode = 0 ; } break ; } if ( power_mode == SDE_MODE_DPMS_ON ) { blank = MSM_DRM_BLANK_UNBLANK_CUST ; notifier_data . data = & blank ; notifier_data . id = connector_state_crtc_index ; msm_drm_notifier_call_chain ( MSM_DRM_EARLY_EVENT_BLANK , & notifier_data ) ; } else if ( power_mode == SDE_MODE_DPMS_LP1 ) { blank = MSM_DRM_BLANK_NORMAL ; notifier_data . data = & blank ; notifier_data . id = connector_state_crtc_index ; msm_drm_notifier_call_chain ( MSM_DRM_EARLY_EVENT_BLANK , & notifier_data ) ; } else if ( power_mode == SDE_MODE_DPMS_OFF ) { blank = MSM_DRM_BLANK_POWERDOWN_CUST ; notifier_data . data = & blank ; notifier_data . id = connector_state_crtc_index ; msm_drm_notifier_call_chain ( MSM_DRM_EARLY_EVENT_BLANK , & notifier_data ) ; } return rc ; }
<S2SV_ModStart> "SDE_MODE_DPMS_LP1\\n" ) ; if ( strcmp ( display -> panel -> name , "samsung<S2SV_blank>s6e3fc2x01<S2SV_blank>cmd<S2SV_blank>mode<S2SV_blank>dsi<S2SV_blank>panel" ) == 0 ) { display -> panel -> aod_mode = 2 ; } else display -> panel -> aod_mode = 0 ; if ( display -> panel -> <S2SV_ModEnd> aod_mode != 0 <S2SV_ModStart> -> panel , display -> panel -> aod_mode ) ; display -> panel -> aod_status = 1 <S2SV_ModEnd> ; } break
3,901
CWE-000 void underline_misspelled ( char * word , char * underline ) { int j = strlen ( word ) ; <S2SV_StartBug> int i ; <S2SV_EndBug> <S2SV_StartBug> for ( i = 0 ; i < j ; i ++ ) { <S2SV_EndBug> strcat ( underline , "^" ) ; } strcat ( underline , "<S2SV_blank>" ) ; }
<S2SV_ModStart> ; int i = 0 <S2SV_ModStart> ; for ( <S2SV_ModEnd> ; i <
3,902
CWE-000 void make_matrix_system ( image ref , image sci , int w , int fwhm , int d , int nstars , int * xc , int * yc , double * C , double * D ) { int naxes = ref . n ; double * Ref = ref . data ; double * Sci = sci . data ; int L = 2 * w + 1 ; int nk = L * L ; int stax = 2 * fwhm + 1 ; int S = stax * stax ; int deg = ( d + 1 ) * ( d + 2 ) / 2 ; int Q = nk * deg ; int cent = ( nk - 1 ) / 2 ; double * Rs = ( double * ) malloc ( sizeof ( double ) * S ) ; double * Ss = ( double * ) malloc ( sizeof ( double ) * S ) ; double * CRKq = ( double * ) malloc ( sizeof ( double ) * S ) ; double * CRKn = ( double * ) malloc ( sizeof ( double ) * S ) ; double * Kn = ( double * ) malloc ( sizeof ( double ) * nk ) ; double * Kq = ( double * ) malloc ( sizeof ( double ) * nk ) ; int qrs = 0 ; for ( int q = 0 ; q < nk ; q ++ ) { <S2SV_StartBug> memset ( Kq , 0 , nk ) ; <S2SV_EndBug> Kq [ q ] = 1.0 ; if ( q != cent ) Kq [ cent ] = - 1.0 ; for ( int r = 0 ; r <= d ; r ++ ) { for ( int s = 0 ; s <= d - r ; s ++ ) { for ( int n = 0 ; n < nk ; n ++ ) { <S2SV_StartBug> memset ( Kn , 0 , nk ) ; <S2SV_EndBug> Kn [ n ] = 1.0 ; if ( n != cent ) Kn [ cent ] = - 1.0 ; int ml = 0 ; for ( int m = 0 ; m <= d ; m ++ ) { for ( int l = 0 ; l <= d - m ; l ++ ) { D [ qrs ] = 0 ; for ( int k = 0 ; k < nstars ; k ++ ) { int xcent = xc [ k ] ; int ycent = yc [ k ] ; for ( int i = 0 ; i < stax ; i ++ ) { for ( int j = 0 ; j < stax ; j ++ ) { Rs [ i + j * stax ] = Ref [ ( i + xcent - fwhm ) + ( j + ycent - fwhm ) * naxes ] ; Ss [ i + j * stax ] = Sci [ ( i + xcent - fwhm ) + ( j + ycent - fwhm ) * naxes ] ; } } <S2SV_StartBug> memset ( CRKn , 0 , S ) ; <S2SV_EndBug> <S2SV_StartBug> memset ( CRKq , 0 , S ) ; <S2SV_EndBug> for ( int i = 0 ; i < stax ; i ++ ) { for ( int j = 0 ; j < stax ; j ++ ) { for ( int mm = 0 ; mm < L ; mm ++ ) { for ( int nn = 0 ; nn < L ; nn ++ ) { int ii = i + ( mm - w ) ; int jj = j + ( nn - w ) ; if ( ii >= 0 && ii < stax && jj >= 0 && jj < stax ) { CRKn [ i + j * stax ] += Rs [ ii + jj * stax ] * Kn [ mm + nn * L ] ; CRKq [ i + j * stax ] += Rs [ ii + jj * stax ] * Kq [ mm + nn * L ] ; } } } } } int mr = m + r ; int ls = l + s ; for ( int i = 0 ; i < S ; i ++ ) { C [ n * deg + ml + qrs * Q ] += pow ( xcent , mr ) * pow ( ycent , ls ) * CRKn [ i ] * CRKq [ i ] ; } for ( int i = 0 ; i < S ; i ++ ) { D [ qrs ] += pow ( xcent , r ) * pow ( ycent , s ) * Ss [ i ] * CRKq [ i ] ; } } ml ++ ; } } } qrs ++ ; } } } free ( CRKn ) ; free ( CRKq ) ; free ( Kn ) ; free ( Kq ) ; free ( Ss ) ; free ( Rs ) ; }
<S2SV_ModStart> 0 , nk * sizeof ( * Kq ) <S2SV_ModStart> 0 , nk * sizeof ( * Kn ) <S2SV_ModStart> 0 , S * sizeof ( * CRKn ) <S2SV_ModStart> 0 , S * sizeof ( * CRKq )
3,903
CWE-000 static int remote_spawn ( void ) { int node_name_index1 ; int proc_vpid_index ; char * * argv = NULL ; char * prefix , * hostname , * var ; int argc ; int rc = ORTE_SUCCESS ; bool failed_launch = true ; orte_process_name_t target ; orte_plm_rsh_caddy_t * caddy ; orte_job_t * daemons ; opal_list_t coll ; orte_namelist_t * child ; char * rtmod ; OPAL_OUTPUT_VERBOSE ( ( 1 , orte_plm_base_framework . framework_output , "%s<S2SV_blank>plm:rsh:<S2SV_blank>remote<S2SV_blank>spawn<S2SV_blank>called" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) ) ) ; target . vpid = ORTE_PROC_MY_NAME -> vpid ; if ( ( bool ) ORTE_WANT_ORTERUN_PREFIX_BY_DEFAULT ) { prefix = strdup ( opal_install_dirs . prefix ) ; } else { prefix = NULL ; } rtmod = orte_rml . get_routed ( orte_coll_conduit ) ; OBJ_CONSTRUCT ( & coll , opal_list_t ) ; orte_routed . get_routing_list ( rtmod , & coll ) ; if ( 0 == opal_list_get_size ( & coll ) ) { OPAL_OUTPUT_VERBOSE ( ( 1 , orte_plm_base_framework . framework_output , "%s<S2SV_blank>plm:rsh:<S2SV_blank>remote<S2SV_blank>spawn<S2SV_blank>-<S2SV_blank>have<S2SV_blank>no<S2SV_blank>children!" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) ) ) ; failed_launch = false ; rc = ORTE_SUCCESS ; OBJ_DESTRUCT ( & coll ) ; goto cleanup ; } if ( ORTE_SUCCESS != ( rc = setup_launch ( & argc , & argv , orte_process_info . nodename , & node_name_index1 , & proc_vpid_index , prefix ) ) ) { ORTE_ERROR_LOG ( rc ) ; OBJ_DESTRUCT ( & coll ) ; goto cleanup ; } if ( NULL == ( daemons = orte_get_job_data_object ( ORTE_PROC_MY_NAME -> jobid ) ) ) { ORTE_ERROR_LOG ( ORTE_ERR_NOT_FOUND ) ; rc = ORTE_ERR_NOT_FOUND ; OBJ_DESTRUCT ( & coll ) ; goto cleanup ; } target . jobid = ORTE_PROC_MY_NAME -> jobid ; OPAL_LIST_FOREACH ( child , & coll , orte_namelist_t ) { target . vpid = child -> name . vpid ; if ( NULL == ( hostname = orte_get_proc_hostname ( & target ) ) ) { opal_output ( 0 , "%s<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>hostname<S2SV_blank>for<S2SV_blank>daemon<S2SV_blank>%s" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) , ORTE_VPID_PRINT ( child -> name . vpid ) ) ; rc = ORTE_ERR_NOT_FOUND ; OBJ_DESTRUCT ( & coll ) ; goto cleanup ; } free ( argv [ node_name_index1 ] ) ; argv [ node_name_index1 ] = strdup ( hostname ) ; rc = orte_util_convert_vpid_to_string ( & var , target . vpid ) ; if ( ORTE_SUCCESS != rc ) { opal_output ( 0 , "orte_plm_rsh:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>daemon<S2SV_blank>vpid<S2SV_blank>as<S2SV_blank>string" ) ; exit ( - 1 ) ; } free ( argv [ proc_vpid_index ] ) ; argv [ proc_vpid_index ] = strdup ( var ) ; free ( var ) ; caddy = OBJ_NEW ( orte_plm_rsh_caddy_t ) ; caddy -> argc = argc ; caddy -> argv = opal_argv_copy ( argv ) ; caddy -> daemon = OBJ_NEW ( orte_proc_t ) ; caddy -> daemon -> name . jobid = ORTE_PROC_MY_NAME -> jobid ; caddy -> daemon -> name . vpid = target . vpid ; opal_list_append ( & launch_list , & caddy -> super ) ; } OPAL_LIST_DESTRUCT ( & coll ) ; <S2SV_StartBug> OPAL_OUTPUT_VERBOSE ( ( 1 , orte_plm_base_framework . framework_output , <S2SV_EndBug> "%s<S2SV_blank>plm:rsh:<S2SV_blank>activating<S2SV_blank>launch<S2SV_blank>event" , ORTE_NAME_PRINT ( ORTE_PROC_MY_NAME ) ) ) ; opal_event_active ( & launch_event , EV_WRITE , 1 ) ; failed_launch = false ; cleanup : if ( NULL != argv ) { opal_argv_free ( argv ) ; } if ( failed_launch ) { opal_buffer_t * buf ; buf = OBJ_NEW ( opal_buffer_t ) ; opal_dss . pack ( buf , & target . vpid , 1 , ORTE_VPID ) ; opal_dss . pack ( buf , & rc , 1 , OPAL_INT ) ; orte_rml . send_buffer_nb ( orte_coll_conduit , ORTE_PROC_MY_HNP , buf , ORTE_RML_TAG_REPORT_REMOTE_LAUNCH , orte_rml_send_callback , NULL ) ; } return rc ; }
<S2SV_ModStart> coll ) ; mca_plm_rsh_component . no_tree_spawn = true ;
3,904
CWE-000 static int mdss_fb_blank_blank ( struct msm_fb_data_type * mfd , int req_power_state ) { int ret = 0 ; int cur_power_state ; if ( ! mfd ) return - EINVAL ; if ( ! mdss_fb_is_power_on ( mfd ) || ! mfd -> mdp . off_fnc ) return 0 ; cur_power_state = mfd -> panel_power_state ; pr_debug ( "Transitioning<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>--><S2SV_blank>%d\\n" , cur_power_state , req_power_state ) ; if ( cur_power_state == req_power_state ) { pr_debug ( "No<S2SV_blank>change<S2SV_blank>in<S2SV_blank>power<S2SV_blank>state\\n" ) ; return 0 ; } mutex_lock ( & mfd -> update . lock ) ; mfd -> update . type = NOTIFY_TYPE_SUSPEND ; mfd -> update . is_suspend = 1 ; mutex_unlock ( & mfd -> update . lock ) ; complete ( & mfd -> update . comp ) ; del_timer ( & mfd -> no_update . timer ) ; mfd -> no_update . value = NOTIFY_TYPE_SUSPEND ; complete ( & mfd -> no_update . comp ) ; mfd -> op_enable = false ; if ( mdss_panel_is_power_off ( req_power_state ) ) { <S2SV_StartBug> if ( mfd -> disp_thread ) <S2SV_EndBug> mdss_fb_stop_disp_thread ( mfd ) ; mutex_lock ( & mfd -> bl_lock ) ; mdss_fb_set_backlight ( mfd , 0 ) ; <S2SV_StartBug> mfd -> bl_updated = 0 ; <S2SV_EndBug> mutex_unlock ( & mfd -> bl_lock ) ; } mfd -> panel_power_state = req_power_state ; ret = mfd -> mdp . off_fnc ( mfd ) ; if ( ret ) mfd -> panel_power_state = cur_power_state ; else if ( mdss_panel_is_power_off ( req_power_state ) ) mdss_fb_release_fences ( mfd ) ; mfd -> op_enable = true ; complete ( & mfd -> power_off_comp ) ; return ret ; }
<S2SV_ModStart> ) ) { int current_bl = mfd -> bl_level ; <S2SV_ModStart> bl_updated = 0 ; mfd -> unset_bl_level = current_bl
3,905
CWE-000 static gboolean keyboard_repeat ( gpointer data ) { ClutterSeatEvdev * seat = data ; <S2SV_StartBug> GSource * source ; <S2SV_EndBug> g_return_val_if_fail ( seat -> repeat_device != NULL , G_SOURCE_REMOVE ) ; source = g_main_context_find_source_by_id ( NULL , seat -> repeat_timer ) ; clutter_seat_evdev_notify_key ( seat , seat -> repeat_device , g_source_get_time ( source ) , seat -> repeat_key , AUTOREPEAT_VALUE , FALSE ) ; return G_SOURCE_CONTINUE ; }
<S2SV_ModStart> GSource * source ; _clutter_device_manager_evdev_dispatch ( seat -> manager_evdev ) ; if ( ! seat -> repeat_timer ) return G_SOURCE_REMOVE
3,906
CWE-000 void aes_print_status ( ataes_transaction_status_t * status ) { printf ( "device_ready?\\t\\t%s\\n\\r" , ! status -> device_ready ? "True" : "false" ) ; printf ( "i2c_mode?\\t\\t%s\\n\\r" , ! status -> i2c_mode ? "True" : "false" ) ; printf ( "sleep_standby_mode?\\t%s\\n\\r" , status -> sleep_standby_mode ? "True" : "false" ) ; printf ( "checksum_error?\\t\\t%s\\n\\r" , status -> checksum_error ? "True" : "false" ) ; printf ( "memory_buffer_changed?\\t%s\\n\\r" , status -> memory_buffer_changed ? "True" : "false" ) ; printf ( "error?\\t\\t\\t%s\\n\\r" , status -> error ? "True" : "false" ) ; printf ( "AES<S2SV_blank>Transaction<S2SV_blank>Status:\\t" ) ; switch ( status -> aes_transaction_status ) { case SUCCESS : printf ( "SUCCESS" ) ; break ; case BOUNDRY_ERROR : printf ( "BOUNDRY_ERROR" ) ; break ; case RW_CONFING : printf ( "RW_CONFING" ) ; break ; case BAD_ADDRESS : printf ( "BAD_ADDRESS" ) ; break ; case COUNT_ERROR : printf ( "COUNT_ERROR" ) ; break ; case NONCE_ERROR : printf ( "NONCE_ERROR" ) ; break ; case MAC_ERROR : printf ( "MAC_ERROR" ) ; break ; case PARSE_ERROR : printf ( "PARSE_ERROR" ) ; break ; case DARA_MATCH : printf ( "DARA_MATCH" ) ; break ; <S2SV_StartBug> case UNKNOWN_ERROR : <S2SV_EndBug> printf ( "UNKNOWN_ERROR" ) ; break ; case INVALID_DATA_LENGTH : printf ( "INVALID_DATA_LENGTH" ) ; break ; default : printf ( "unknown<S2SV_blank>error<S2SV_blank>%d<S2SV_blank>\\n\\r" , status -> aes_transaction_status ) ; break ; } printf ( "\\n\\r" ) ; }
<S2SV_ModStart> break ; case LOCK_ERROR : printf ( "LOCK_ERROR" ) ; break ; case KEY_ERROR : printf ( "KEY_ERROR" <S2SV_ModEnd> ) ; break
3,907
CWE-000 static ssize_t lpfc_fcp_imax_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t count ) { struct Scsi_Host * shost = class_to_shost ( dev ) ; struct lpfc_vport * vport = ( struct lpfc_vport * ) shost -> hostdata ; struct lpfc_hba * phba = vport -> phba ; int val = 0 , i ; if ( phba -> sli_rev != LPFC_SLI_REV4 ) return - EINVAL ; if ( ! isdigit ( buf [ 0 ] ) ) return - EINVAL ; if ( sscanf ( buf , "%i" , & val ) != 1 ) return - EINVAL ; if ( val && ( val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX ) ) return - EINVAL ; phba -> cfg_fcp_imax = ( uint32_t ) val ; <S2SV_StartBug> for ( i = 0 ; i < phba -> io_channel_irqs ; i ++ ) <S2SV_EndBug> lpfc_modify_hba_eq_delay ( phba , i ) ; return strlen ( buf ) ; }
<S2SV_ModStart> io_channel_irqs ; i += LPFC_MAX_EQ_DELAY_EQID_CNT <S2SV_ModEnd> ) lpfc_modify_hba_eq_delay (
3,908
CWE-000 void gpio_write ( gpio_t pin , int value ) { _check ( pin ) ; char gpio_file_path [ 30 ] ; sprintf ( gpio_file_path , "/sys/class/gpio/gpio%d/value" , pin ) ; FILE * fptr ; fptr = fopen ( gpio_file_path , "w" ) ; if ( fptr == NULL ) { printf ( "[gpio.c]<S2SV_blank>Error:<S2SV_blank>Reading<S2SV_blank>gpio_file_path:<S2SV_blank>%s<S2SV_blank>\\n" , gpio_file_path ) ; return ; } <S2SV_StartBug> # ifdef DEBUG <S2SV_EndBug> printf ( "[gpio.c]<S2SV_blank>gpio_write:<S2SV_blank>Writing<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>file<S2SV_blank>%p<S2SV_blank>\\n" , value , gpio_file_path ) ; # endif fprintf ( fptr , "%d" , value ) ; fclose ( fptr ) ; }
<S2SV_ModStart> } # ifdef GPIODEBUG <S2SV_ModEnd> printf ( "[gpio.c]<S2SV_blank>gpio_write:<S2SV_blank>Writing<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>file<S2SV_blank>%p<S2SV_blank>\\n"
3,909
CWE-000 int main ( int argc , char * * argv ) { _unused_ ( argc ) ; _unused_ ( argv ) ; # if defined ( NM_HAVE_STRN__FN ) const char * xxx = "xxxxxxxx" ; size_t len = strnlen ( xxx , 16 ) ; char * x = malloc ( sizeof ( char ) * ( len + 1 ) ) ; char * s = strncpy ( x , xxx , len + 1 ) ; assert ( ( 0 == strncmp ( s , xxx , len ) ) || "strncpy()<S2SV_blank>failed" ) ; <S2SV_StartBug> memset ( x , 0 , len + 1 ) ; <S2SV_EndBug> assert ( ( 0 == x [ 8 ] ) || "0<S2SV_blank>not<S2SV_blank>at<S2SV_blank>end" ) ; x [ 3 ] = 'Z' ; strncpy ( x , xxx , 3 ) ; assert ( ( 'Z' == x [ 3 ] ) || "copied<S2SV_blank>0<S2SV_blank>at<S2SV_blank>end" ) ; memset ( x , 'z' , len + 1 ) ; assert ( ( 'z' == x [ len + 1 ] ) || "\'z\'<S2SV_blank>not<S2SV_blank>at<S2SV_blank>end" ) ; strncpy ( x , "xxx" , len + 1 ) ; assert ( ( 0 == x [ len + 1 ] ) || "0<S2SV_blank>not<S2SV_blank>at<S2SV_blank>end" ) ; free ( x ) ; # endif }
<S2SV_ModStart> "strncpy()<S2SV_blank>failed" ) ; # if NDEBUG _unused_ ( s ) ; # endif
3,910
CWE-000 void dpif_close ( struct dpif * dpif ) { if ( dpif ) { struct registered_dpif_class * rc ; <S2SV_StartBug> struct dpif_port_dump port_dump ; <S2SV_EndBug> struct dpif_port dpif_port ; rc = shash_find_data ( & dpif_classes , dpif -> dpif_class -> type ) ; <S2SV_StartBug> DPIF_PORT_FOR_EACH ( & dpif_port , & port_dump , dpif ) { <S2SV_EndBug> if ( ! dpif_is_internal_port ( dpif_port . type ) ) { netdev_ports_remove ( dpif_port . port_no , dpif -> dpif_class ) ; } } dpif_uninit ( dpif , true ) ; dp_class_unref ( rc ) ; } }
<S2SV_ModStart> * rc ; <S2SV_ModEnd> rc = shash_find_data <S2SV_ModStart> type ) ; if ( rc -> refcount == 1 ) { dpif_remove_netdev_ports ( dpif ) ; <S2SV_ModEnd> } dpif_uninit (
3,911
CWE-000 unsigned long alarm ( unsigned long seconds ) { int response = 0 ; message_t m ; m . type = SYSCALL_ALARM ; <S2SV_StartBug> m . i1 = seconds * 60 ; <S2SV_EndBug> response = winix_send ( SYSTEM_TASK , & m ) ; return 0 ; }
<S2SV_ModStart> i1 = seconds <S2SV_ModEnd> ; response =
3,912
CWE-000 static inline void perform_remove_min_with_lock ( acdelete_min_write_back_mem_type * mem ) { while ( achelp_info . last_locked_node_parent != NULL && skiplist_is_empty ( achelp_info . last_locked_node -> baseOrRoute . base . root ) ) { achelp_info . last_locked_node = low_contention_join_force_left_child ( achelp_info . last_locked_node , achelp_info . last_locked_node_parent , achelp_info . set , & achelp_info . last_locked_node_parent ) ; } CATreeBaseNode * base_node = & achelp_info . last_locked_node -> baseOrRoute . base ; unsigned long key_value ; unsigned long result_value = skiplist_remove_min ( base_node -> root , & key_value ) ; unsigned long pos = 1 ; mem -> key_value_array [ 0 ] . key = key_value ; mem -> key_value_array [ 0 ] . value = result_value ; while ( key_value != ( ( unsigned long ) - 1 ) && key_value <= mem -> current_put_cache_min_key && pos < ( mem -> current_relaxation ) ) { result_value = skiplist_remove_min ( base_node -> root , & key_value ) ; if ( key_value == ( ( unsigned long ) - 1 ) ) { break ; } mem -> key_value_array [ pos ] . key = key_value ; mem -> key_value_array [ pos ] . value = result_value ; pos ++ ; } mem -> current_remove_min_cache_max_key = mem -> key_value_array [ pos - 1 ] . key ; if ( mem -> key_value_array [ pos - 1 ] . key == ( ( unsigned long ) - 1 ) ) { mem -> current_remove_min_cache_max_key = 0 ; mem -> current_relaxation = 0 ; } else if ( mem -> current_put_cache_min_key < mem -> key_value_array [ pos - 1 ] . key ) { skiplist_put ( base_node -> root , mem -> key_value_array [ pos - 1 ] . key , mem -> key_value_array [ pos - 1 ] . value ) ; pos -- ; if ( pos == 0 ) { mem -> key_value_array [ 0 ] . key = ( ( unsigned long ) - 1 ) ; mem -> key_value_array [ 0 ] . value = 0 ; <S2SV_StartBug> pos ++ ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> mem -> current_relaxation = 0 ; } mem -> size = pos ; atomic_store_explicit ( & mem -> pos , 0 , memory_order_release ) ; }
<S2SV_ModStart> = 0 ; mem -> current_remove_min_cache_max_key = 0 ; <S2SV_ModStart> ++ ; } else { mem -> current_remove_min_cache_max_key = mem -> key_value_array [ pos - 1 ] . key ; }
3,913
CWE-000 int APPLY_SPECIFIC ( conv_gw ) ( CudaNdarray * input , CudaNdarray * output , CudaNdarray * km , cudnnConvolutionDescriptor_t desc , float alpha , float beta , CudaNdarray * * kerns ) { cudnnStatus_t err = CUDNN_STATUS_SUCCESS ; if ( CudaNdarray_HOST_DIMS ( input ) [ 1 ] != CudaNdarray_HOST_DIMS ( km ) [ 1 ] ) { PyErr_SetString ( PyExc_ValueError , "GpuDnnConv<S2SV_blank>images<S2SV_blank>and<S2SV_blank>kernel<S2SV_blank>must<S2SV_blank>have<S2SV_blank>the<S2SV_blank>same<S2SV_blank>stack<S2SV_blank>size\\n" ) ; return 1 ; } if ( c_set_tensorNd ( input , APPLY_SPECIFIC ( input ) ) == - 1 ) return 1 ; if ( c_set_tensorNd ( output , APPLY_SPECIFIC ( output ) ) == - 1 ) return 1 ; int nb_dim = CudaNdarray_NDIM ( output ) ; # ifdef CONV_INPLACE Py_XDECREF ( * kerns ) ; * kerns = km ; Py_INCREF ( * kerns ) ; # else if ( CudaNdarray_prep_output ( kerns , nb_dim , CudaNdarray_HOST_DIMS ( km ) ) != 0 ) return 1 ; if ( beta != 0.0 && CudaNdarray_CopyFromCudaNdarray ( * kerns , km ) ) return 1 ; # endif if ( c_set_filterNd ( * kerns , APPLY_SPECIFIC ( kerns ) ) == - 1 ) return 1 ; { size_t worksize ; void * workspace ; cudnnConvolutionBwdFilterAlgo_t chosen_algo ; if ( CHOOSE_ALGO ) { <S2SV_StartBug> bool reuse_previous_algo ; <S2SV_EndBug> if ( CHOOSE_ALGO_ONCE ) { reuse_previous_algo = APPLY_SPECIFIC ( previous_algo_set ) ; } else { bool same_shapes = true ; for ( int i = 0 ; ( i < nb_dim ) && same_shapes ; i ++ ) { same_shapes &= ( CudaNdarray_HOST_DIMS ( input ) [ i ] == APPLY_SPECIFIC ( previous_input_shape ) [ i ] ) ; same_shapes &= ( CudaNdarray_HOST_DIMS ( output ) [ i ] == APPLY_SPECIFIC ( previous_output_shape ) [ i ] ) ; } reuse_previous_algo = same_shapes ; } if ( ! reuse_previous_algo ) { if ( CHOOSE_ALGO_TIME ) { int requestedCount = 1 ; int count ; cudnnConvolutionBwdFilterAlgoPerf_t choosen_algo_perf ; err = cudnnFindConvolutionBackwardFilterAlgorithm ( _handle , APPLY_SPECIFIC ( input ) , APPLY_SPECIFIC ( output ) , desc , APPLY_SPECIFIC ( kerns ) , requestedCount , & count , & choosen_algo_perf ) ; if ( err != CUDNN_STATUS_SUCCESS ) { PyErr_Format ( PyExc_RuntimeError , "GpuDnnConvGradW:<S2SV_blank>error<S2SV_blank>selecting<S2SV_blank>convolution<S2SV_blank>algo:<S2SV_blank>" "%s" , cudnnGetErrorString ( err ) ) ; return 1 ; } chosen_algo = choosen_algo_perf . algo ; } else { size_t free = 0 , total = 0 ; cudaError_t err2 = cudaMemGetInfo ( & free , & total ) ; if ( err2 != cudaSuccess ) { cudaGetLastError ( ) ; fprintf ( stderr , "Error<S2SV_blank>when<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>find<S2SV_blank>the<S2SV_blank>memory<S2SV_blank>information" "<S2SV_blank>on<S2SV_blank>the<S2SV_blank>GPU:<S2SV_blank>%s\\n" , cudaGetErrorString ( err2 ) ) ; return 1 ; } <S2SV_StartBug> err = cudnnGetConvolutionBackwardFilterAlgorithm ( _handle , <S2SV_EndBug> APPLY_SPECIFIC ( input ) , APPLY_SPECIFIC ( output ) , desc , APPLY_SPECIFIC ( kerns ) , CUDNN_CONVOLUTION_BWD_FILTER_SPECIFY_WORKSPACE_LIMIT , free , & chosen_algo ) ; if ( err != CUDNN_STATUS_SUCCESS ) { PyErr_Format ( PyExc_RuntimeError , "GpuDnnConvGradW:<S2SV_blank>error<S2SV_blank>selecting<S2SV_blank>convolution<S2SV_blank>algo:<S2SV_blank>%s" , cudnnGetErrorString ( err ) ) ; return 1 ; } } APPLY_SPECIFIC ( previous_bwd_f_algo ) = chosen_algo ; APPLY_SPECIFIC ( previous_algo_set ) = true ; for ( int i = 0 ; i < nb_dim ; i ++ ) { APPLY_SPECIFIC ( previous_input_shape ) [ i ] = CudaNdarray_HOST_DIMS ( input ) [ i ] ; APPLY_SPECIFIC ( previous_output_shape ) [ i ] = CudaNdarray_HOST_DIMS ( output ) [ i ] ; } } else { chosen_algo = APPLY_SPECIFIC ( previous_bwd_f_algo ) ; } } else { <S2SV_StartBug> chosen_algo = CONV_ALGO ; <S2SV_EndBug> } <S2SV_StartBug> if ( 0 ) { <S2SV_EndBug> char * a ; switch ( chosen_algo ) { case CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0 : a = "algo<S2SV_blank>0<S2SV_blank>(0)" ; break ; case CUDNN_CONVOLUTION_BWD_FILTER_ALGO_1 : a = "algo<S2SV_blank>1<S2SV_blank>(1)" ; break ; case CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT : a = "fft<S2SV_blank>(2)" ; break ; case CUDNN_CONVOLUTION_BWD_FILTER_ALGO_3 : a = "algo<S2SV_blank>3<S2SV_blank>(3)" ; break ; <S2SV_StartBug> } <S2SV_EndBug> printf ( "GpuDNNConvGW:<S2SV_blank>algo<S2SV_blank>%s\\n" , a ) ; } if ( chosen_algo == CUDNN_CONVOLUTION_BWD_FILTER_ALGO_FFT && nb_dim == 4 ) { int nd ; int pad [ 2 ] ; int stride [ 2 ] ; int upscale [ 2 ] ; cudnnConvolutionMode_t mode ; cudnnDataType_t data_type ; err = cudnnGetConvolutionNdDescriptor ( desc , 2 , & nd , pad , stride , upscale , & mode , & data_type ) ; if ( err != CUDNN_STATUS_SUCCESS ) { PyErr_Format ( PyExc_RuntimeError , "GpuDnnConvGradW:<S2SV_blank>error<S2SV_blank>getting<S2SV_blank>convolution<S2SV_blank>properties:<S2SV_blank>%s" , cudnnGetErrorString ( err ) ) ; return 1 ; } int filter_h = CudaNdarray_HOST_DIMS ( * kerns ) [ 2 ] ; int filter_w = CudaNdarray_HOST_DIMS ( * kerns ) [ 3 ] ; int input_h = CudaNdarray_HOST_DIMS ( input ) [ 2 ] ; int input_w = CudaNdarray_HOST_DIMS ( input ) [ 3 ] ; if ( stride [ 0 ] != 1 || stride [ 1 ] != 1 || input_h > 1024 || input_w > 1024 || ( filter_h == 1 && filter_w == 1 ) ) { chosen_algo = CUDNN_CONVOLUTION_BWD_FILTER_ALGO_0 ; } } err = cudnnGetConvolutionBackwardFilterWorkspaceSize ( _handle , APPLY_SPECIFIC ( input ) , APPLY_SPECIFIC ( output ) , desc , APPLY_SPECIFIC ( kerns ) , chosen_algo , & worksize ) ; if ( err != CUDNN_STATUS_SUCCESS ) { PyErr_Format ( PyExc_RuntimeError , "GpuDnnConvGradW:<S2SV_blank>error<S2SV_blank>getting<S2SV_blank>worksize:<S2SV_blank>%s" , cudnnGetErrorString ( err ) ) ; return 1 ; } workspace = get_work_mem ( worksize ) ; if ( workspace == NULL && worksize != 0 ) return 1 ; err = cudnnConvolutionBackwardFilter ( _handle , ( void * ) & alpha , APPLY_SPECIFIC ( input ) , CudaNdarray_DEV_DATA ( input ) , APPLY_SPECIFIC ( output ) , CudaNdarray_DEV_DATA ( output ) , desc , chosen_algo , workspace , worksize , ( void * ) & beta , APPLY_SPECIFIC ( kerns ) , CudaNdarray_DEV_DATA ( * kerns ) ) ; } if ( err != CUDNN_STATUS_SUCCESS ) { PyErr_Format ( PyExc_RuntimeError , "GpuDnnConvGradW:<S2SV_blank>error<S2SV_blank>doing<S2SV_blank>operation:<S2SV_blank>%s" , cudnnGetErrorString ( err ) ) ; return 1 ; } return 0 ; }
<S2SV_ModStart> CHOOSE_ALGO ) { fprintf ( stderr , "\\nALGO<S2SV_blank>TO<S2SV_blank>CHOOSE\\n" ) ; <S2SV_ModStart> 1 ; } fprintf ( stderr , "Available<S2SV_blank>memory:<S2SV_blank>%f<S2SV_blank>Mo<S2SV_blank>on<S2SV_blank>%f<S2SV_blank>Mo\\n" , free / ( 1024 * 1024.0 ) , total / ( 1024 * 1024.0 ) ) ; <S2SV_ModStart> } else { fprintf ( stderr , "\\nALGO<S2SV_blank>EVER<S2SV_blank>CHOSEN\\n" ) ; <S2SV_ModStart> } if ( 1 <S2SV_ModEnd> ) { char <S2SV_ModStart> ; break ; default : a = "other" ; break ; } fprintf ( stderr , <S2SV_ModEnd> "GpuDNNConvGW:<S2SV_blank>algo<S2SV_blank>%s\\n" , a
3,914
CWE-000 <S2SV_StartBug> DEFUN ( no_ip_lcommunity_list_expanded , <S2SV_EndBug> no_ip_lcommunity_list_expanded_cmd , "no<S2SV_blank>ip<S2SV_blank>large-community-list<S2SV_blank>(100-500)<S2SV_blank><deny|permit><S2SV_blank>LINE..." , NO_STR IP_STR LCOMMUNITY_LIST_STR <S2SV_StartBug> "Large<S2SV_blank>Community<S2SV_blank>list<S2SV_blank>number<S2SV_blank>(expanded)\\n" <S2SV_EndBug> "Specify<S2SV_blank>large<S2SV_blank>community<S2SV_blank>to<S2SV_blank>reject\\n" "Specify<S2SV_blank>large<S2SV_blank>community<S2SV_blank>to<S2SV_blank>accept\\n" "An<S2SV_blank>ordered<S2SV_blank>list<S2SV_blank>as<S2SV_blank>a<S2SV_blank>regular-expression\\n" ) { return lcommunity_list_unset_vty ( vty , argc , argv , LARGE_COMMUNITY_LIST_EXPANDED ) ; }
<S2SV_ModStart> <S2SV_null> DEFUN ( no_ip_lcommunity_list_name_expanded_all , no_ip_lcommunity_list_name_expanded_all_cmd , "no<S2SV_blank>ip<S2SV_blank>large-community-list<S2SV_blank>expanded<S2SV_blank>WORD" <S2SV_ModEnd> , NO_STR IP_STR <S2SV_ModStart> NO_STR IP_STR LCOMMUNITY_LIST_STR "Specify<S2SV_blank>expanded<S2SV_blank>large-community-list\\n" "Large<S2SV_blank>Community<S2SV_blank>list<S2SV_blank>name\\n" <S2SV_ModEnd> ) { return
3,915
CWE-000 static int qseecom_unregister_listener ( struct qseecom_dev_handle * data ) { int ret = 0 ; unsigned long flags ; uint32_t unmap_mem = 0 ; struct qseecom_register_listener_ireq req ; struct qseecom_registered_listener_list * ptr_svc = NULL ; struct qseecom_command_scm_resp resp ; struct ion_handle * ihandle = NULL ; req . qsee_cmd_id = QSEOS_DEREGISTER_LISTENER ; req . listener_id = data -> listener . id ; resp . result = QSEOS_RESULT_INCOMPLETE ; ret = scm_call ( SCM_SVC_TZSCHEDULER , 1 , & req , sizeof ( req ) , & resp , sizeof ( resp ) ) ; if ( ret ) { pr_err ( "scm_call()<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>err:<S2SV_blank>%d<S2SV_blank>(lstnr<S2SV_blank>id=%d)\\n" , ret , data -> listener . id ) ; return ret ; } if ( resp . result != QSEOS_RESULT_SUCCESS ) { pr_err ( "Failed<S2SV_blank>resp.result=%d,(lstnr<S2SV_blank>id=%d)\\n" , resp . result , data -> listener . id ) ; return - EPERM ; } data -> abort = 1 ; spin_lock_irqsave ( & qseecom . registered_listener_list_lock , flags ) ; list_for_each_entry ( ptr_svc , & qseecom . registered_listener_list_head , list ) { if ( ptr_svc -> svc . listener_id == data -> listener . id ) { wake_up_all ( & ptr_svc -> rcv_req_wq ) ; break ; } } spin_unlock_irqrestore ( & qseecom . registered_listener_list_lock , flags ) ; while ( atomic_read ( & data -> ioctl_count ) > 1 ) { <S2SV_StartBug> if ( wait_event_freezable ( data -> abort_wq , <S2SV_EndBug> atomic_read ( & data -> ioctl_count ) <= 1 ) ) { pr_err ( "Interrupted<S2SV_blank>from<S2SV_blank>abort\\n" ) ; ret = - ERESTARTSYS ; break ; } } spin_lock_irqsave ( & qseecom . registered_listener_list_lock , flags ) ; list_for_each_entry ( ptr_svc , & qseecom . registered_listener_list_head , list ) { if ( ptr_svc -> svc . listener_id == data -> listener . id ) { if ( ptr_svc -> sb_virt ) { unmap_mem = 1 ; ihandle = ptr_svc -> ihandle ; } list_del ( & ptr_svc -> list ) ; kzfree ( ptr_svc ) ; break ; } } spin_unlock_irqrestore ( & qseecom . registered_listener_list_lock , flags ) ; if ( unmap_mem ) { if ( ! IS_ERR_OR_NULL ( ihandle ) ) { ion_unmap_kernel ( qseecom . ion_clnt , ihandle ) ; ion_free ( qseecom . ion_clnt , ihandle ) ; } } data -> released = true ; return ret ; }
<S2SV_ModStart> { if ( wait_io_event_freezable <S2SV_ModEnd> ( data ->
3,916
CWE-000 void Thermostats_System_Run ( void ) { if ( Return_True == Thermostats_Timer_IsNotTick ( & g_ThermostatsSystem . timer_ConfirmRunStatus ) ) { <S2SV_StartBug> Thermostats_Timer_Stop ( & g_ThermostatsSystem . timer_ConfirmRunStatus ) ; <S2SV_EndBug> switch ( g_ThermostatsSystem . curWorkModel ) { case Model_Cool : { Thermostats_AirConditioner_Model_Run_Cool ( ) ; } break ; case Model_Heat : { Thermostats_AirConditioner_Model_Run_Heat ( ) ; } break ; case Model_Dry : { Thermostats_AirConditioner_Model_Run_Dry ( ) ; } break ; case Model_Auto : { Thermostats_AirConditioner_Model_Run_Auto ( ) ; } break ; } Thermostats_Relay_Control_Fan ( ) ; Thermostats_Energy_Consumption_Metering ( ) ; } }
<S2SV_ModStart> ) ) { <S2SV_ModEnd> switch ( g_ThermostatsSystem
3,917
CWE-000 bool netdev_flow_dump_next ( struct netdev_flow_dump * dump , struct match * match , struct nlattr * * actions , struct dpif_flow_stats * stats , <S2SV_StartBug> ovs_u128 * ufid , struct ofpbuf * rbuffer , <S2SV_EndBug> struct ofpbuf * wbuffer ) { const struct netdev_class * class = dump -> netdev -> netdev_class ; return ( class -> flow_dump_next <S2SV_StartBug> ? class -> flow_dump_next ( dump , match , actions , stats , ufid , <S2SV_EndBug> rbuffer , wbuffer ) : false ) ; }
<S2SV_ModStart> * stats , struct dpif_flow_attrs * attrs , <S2SV_ModStart> , stats , attrs ,
3,918
CWE-000 int f2 ( ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> }
<S2SV_ModStart> ) { return 2 <S2SV_ModEnd> ; } <S2SV_null>
3,919
CWE-000 void gaussjor ( float co [ MAX ] [ MAX + 1 ] , float con [ MAX ] , int n ) { int i , j , k = 0 ; float sol [ MAX ] ; float val ; for ( i = 0 ; i < n ; i ++ ) { co [ i ] [ n ] = con [ i ] ; } while ( k < n ) { for ( i = 0 ; i < n ; i ++ ) { if ( i == k ) { continue ; } val = co [ i ] [ k ] / co [ k ] [ k ] ; for ( j = 0 ; j < n + 1 ; j ++ ) { co [ i ] [ j ] = ( co [ i ] [ j ] - val * co [ k ] [ j ] ) ; } } k ++ ; } for ( i = 0 ; i < n ; i ++ ) { <S2SV_StartBug> sol [ i ] = co [ i ] [ 3 ] / co [ i ] [ i ] ; <S2SV_EndBug> printf ( "Value<S2SV_blank>of<S2SV_blank>x%d<S2SV_blank>is<S2SV_blank>%f\\n" , i + 1 , sol [ i ] ) ; } return ; }
<S2SV_ModStart> ++ ) { if ( co [ i ] [ i ] == 0 ) { printf ( "The<S2SV_blank>given<S2SV_blank>system<S2SV_blank>of<S2SV_blank>equations<S2SV_blank>have<S2SV_blank>no<S2SV_blank>" ) ; printf ( "or<S2SV_blank>infinitely<S2SV_blank>many<S2SV_blank>solutions.\\n" ) ; exit ( 1 ) ; } } for ( i = 0 ; i < n ; i ++ ) {
3,920
CWE-000 static int fs_write ( Chan * chan , Fcall * f , Fcall * r ) { Iobuf * p , * p1 ; Dentry * d ; File * file ; Tlock * t ; Off offset , addr , qpath ; Timet tim ; int count , error , nwrite , o , n ; error = 0 ; offset = f -> offset ; count = f -> count ; nwrite = 0 ; p = nil ; if ( ( file = filep ( chan , f -> fid , 0 ) ) == nil ) { error = Efid ; goto out ; } if ( ! ( file -> open & FWRITE ) ) { error = Eopen ; goto out ; } if ( count < 0 || count > chan -> msize - IOHDRSZ ) { error = Ecount ; goto out ; } if ( offset < 0 ) { error = Eoffset ; goto out ; } if ( file -> qid . type & QTAUTH ) { <S2SV_StartBug> nwrite = authwrite ( file , ( uchar * ) f -> data , count ) ; <S2SV_EndBug> if ( nwrite < 0 ) error = Eauth2 ; goto out ; } else if ( file -> fs -> dev -> type == Devro ) { error = Eronly ; goto out ; } if ( ( p = getbuf ( file -> fs -> dev , file -> addr , Brd | Bmod ) ) == nil || ( d = getdir ( p , file -> slot ) ) == nil || ! ( d -> mode & DALLOC ) ) { error = Ealloc ; goto out ; } if ( error = mkqidcmp ( & file -> qid , d ) ) goto out ; if ( t = file -> tlock ) { tim = toytime ( ) ; if ( t -> time < tim || t -> file != file ) { error = Ebroken ; goto out ; } t -> time = tim + TLOCK ; } accessdir ( p , d , FWRITE , file -> uid ) ; if ( d -> mode & DAPND ) offset = d -> size ; if ( offset + count > d -> size ) d -> size = offset + count ; while ( count > 0 ) { if ( p == nil ) { p = getbuf ( file -> fs -> dev , file -> addr , Brd | Bmod ) ; if ( p == nil ) { error = Ealloc ; goto out ; } d = getdir ( p , file -> slot ) ; if ( d == nil || ! ( d -> mode & DALLOC ) ) { error = Ealloc ; goto out ; } } addr = offset / BUFSIZE ; o = offset % BUFSIZE ; n = BUFSIZE - o ; if ( n > count ) n = count ; qpath = d -> qid . path ; p1 = dnodebuf1 ( p , d , addr , Tfile , file -> uid ) ; p = nil ; if ( p1 == nil ) { error = Efull ; goto out ; } if ( checktag ( p1 , Tfile , qpath ) ) { putbuf ( p1 ) ; error = Ephase ; goto out ; } memmove ( p1 -> iobuf + o , f -> data + nwrite , n ) ; p1 -> flags |= Bmod ; putbuf ( p1 ) ; count -= n ; nwrite += n ; offset += n ; } out : if ( p != nil ) putbuf ( p ) ; if ( file != nil ) qunlock ( file ) ; r -> count = nwrite ; return error ; }
<S2SV_ModStart> = authwrite ( chan ,
3,921
CWE-000 static void logger_initializemem ( void ) { uint8_t preparesig [ 4 ] = { 'L' , 'o' , 'g' , 0 } ; uint8_t preparesigcheck [ 4 ] ; char buffer [ DEBUG_CHARS + 1 ] ; buffer [ DEBUG_CHARS ] = '\\0' ; i2ceep_writeblock ( 0 , preparesig , 4 ) ; i2ceep_readblock ( 0 , preparesigcheck , 4 ) ; if ( memcmp ( preparesig , preparesigcheck , 4 ) ) { snprintf_P ( buffer , DEBUG_CHARS , PSTR ( "R/W<S2SV_blank>I2C<S2SV_blank>EEPROM<S2SV_blank>failed\\r\\n" ) ) ; rs232_sendstring ( buffer ) ; return ; } uint16_t taddr = 2048 ; uint8_t sizeindex = 1 ; while ( taddr ) { if ( g_settings . debugRs232 == 0xC ) { snprintf_P ( buffer , DEBUG_CHARS , PSTR ( "taddr:<S2SV_blank>%u<S2SV_blank>index:<S2SV_blank>%u\\r\\n" ) , taddr , sizeindex ) ; rs232_sendstring ( buffer ) ; } i2ceep_writebyte ( taddr + 3 , sizeindex ) ; uint8_t first = i2ceep_readbyte ( 3 ) ; if ( g_settings . debugRs232 == 0xC ) { snprintf_P ( buffer , DEBUG_CHARS , PSTR ( "got<S2SV_blank>%u\\r\\n" ) , first ) ; rs232_sendstring ( buffer ) ; } if ( first != 0 ) { break ; } taddr *= 2 ; sizeindex ++ ; } g_state . logger . ksize = 1 << sizeindex ; <S2SV_StartBug> snprintf_P ( buffer , DEBUG_CHARS , PSTR ( "New<S2SV_blank>log<S2SV_blank>in<S2SV_blank>EEPROM<S2SV_blank>with<S2SV_blank>%ikB\\r\\n" ) , g_state . logger . ksize ) ; <S2SV_EndBug> rs232_sendstring ( buffer ) ; }
<S2SV_ModStart> << sizeindex ; if ( g_state . logger . ksize >= 64 ) { i2ceep_writebyte ( 3 , sizeindex ) ; } g_state . logger . maxentries = ( ( 1024 * g_state . logger . ksize ) - LOGGER_BASE_OFFSET ) / sizeof ( logmessage_t ) ;
3,922
CWE-000 int drv_bo_from_format ( struct bo * bo , uint32_t stride , uint32_t aligned_height , uint32_t format ) { <S2SV_StartBug> size_t p , num_planes ; <S2SV_EndBug> uint32_t offset = 0 ; num_planes = drv_num_planes_from_format ( format ) ; assert ( num_planes ) ; bo -> total_size = 0 ; for ( p = 0 ; p < num_planes ; p ++ ) { bo -> strides [ p ] = subsample_stride ( stride , format , p ) ; bo -> sizes [ p ] = drv_size_from_format ( format , bo -> strides [ p ] , bo -> height , p ) ; <S2SV_StartBug> bo -> offsets [ p ] = offset ; <S2SV_EndBug> offset += bo -> sizes [ p ] ; bo -> total_size += drv_size_from_format ( format , bo -> strides [ p ] , aligned_height , p ) ; } return 0 ; }
<S2SV_ModStart> p , num_planes <S2SV_ModEnd> ; num_planes = <S2SV_ModStart> p ] = bo -> total_size <S2SV_ModEnd> ; bo ->
3,923
CWE-000 void nitro_wait ( struct kvm_vcpu * vcpu ) { printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>called" ) ; up ( & ( vcpu -> nitro . n_wait_sem ) ) ; printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>past<S2SV_blank>up" ) ; wait_for_completion ( & ( vcpu -> nitro . k_wait_cv ) ) ; printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>past<S2SV_blank>wait_for_completion" ) ; <S2SV_StartBug> if ( ! ( is_syscall ( vcpu ) || is_sysret ( vcpu ) || is_sysenter ( vcpu ) || is_sysexit ( vcpu ) ) ) { <S2SV_EndBug> <S2SV_StartBug> printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>processing<S2SV_blank>continuation<S2SV_blank>event<S2SV_blank>on<S2SV_blank>an<S2SV_blank>uknown<S2SV_blank>instruction" ) ; <S2SV_EndBug> } switch ( vcpu -> nitro . cont ) { case NITRO_CONTINUATION_CONTINUE : printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>received<S2SV_blank>continue<S2SV_blank>event" ) ; nitro_do_continue ( vcpu ) ; break ; case NITRO_CONTINUATION_STEP_OVER : printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>received<S2SV_blank>step<S2SV_blank>over<S2SV_blank>event" ) ; nitro_do_continue_step_over ( vcpu ) ; break ; } <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> ; if ( vcpu -> nitro . event . direction == ENTER ) { if ( likely ( is_syscall <S2SV_ModEnd> ( vcpu ) <S2SV_ModStart> ( vcpu ) <S2SV_ModEnd> ) ) { <S2SV_ModStart> ) ) { <S2SV_ModEnd> switch ( vcpu <S2SV_ModStart> ; } } else { printk ( KERN_DEBUG "nitro_wait:<S2SV_blank>processing<S2SV_blank>continuation<S2SV_blank>event<S2SV_blank>on<S2SV_blank>an<S2SV_blank>unknown<S2SV_blank>instruction" ) ; } } }
3,924
CWE-000 static void nfs_zap_caches_locked ( struct inode * inode ) { struct nfs_inode * nfsi = NFS_I ( inode ) ; int mode = inode -> i_mode ; nfs_inc_stats ( inode , NFSIOS_ATTRINVALIDATE ) ; nfsi -> attrtimeo = NFS_MINATTRTIMEO ( inode ) ; nfsi -> attrtimeo_timestamp = jiffies ; memset ( NFS_I ( inode ) -> cookieverf , 0 , sizeof ( NFS_I ( inode ) -> cookieverf ) ) ; if ( S_ISREG ( mode ) || S_ISDIR ( mode ) || S_ISLNK ( mode ) ) { nfs_fscache_invalidate ( inode ) ; nfsi -> cache_validity |= NFS_INO_INVALID_ATTR <S2SV_StartBug> | NFS_INO_INVALID_LABEL <S2SV_EndBug> | NFS_INO_INVALID_DATA | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL | NFS_INO_REVAL_PAGECACHE ; } else nfsi -> cache_validity |= NFS_INO_INVALID_ATTR <S2SV_StartBug> | NFS_INO_INVALID_LABEL <S2SV_EndBug> | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL | NFS_INO_REVAL_PAGECACHE ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> |= NFS_INO_INVALID_ATTR | <S2SV_ModEnd> NFS_INO_INVALID_DATA | NFS_INO_INVALID_ACCESS <S2SV_ModStart> |= NFS_INO_INVALID_ATTR | <S2SV_ModEnd> NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL <S2SV_ModStart> | NFS_INO_REVAL_PAGECACHE ; nfs_zap_label_cache_locked ( nfsi ) ;
3,925
CWE-000 int main ( void ) { map myMap = { 0 , 0 , NULL } ; loadMapSize ( & myMap ) ; loadMapValues ( & myMap ) ; behaviorCalc ( & myMap ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
<S2SV_ModStart> myMap ) ; for ( int i = 0 ; i < myMap . length ; i ++ ) { free ( myMap . fieldPrice [ i ] ) ; } free ( myMap . fieldPrice ) ;
3,926
CWE-000 static int bif_iso_get_code_2 ( tpl_query * q ) { node * args = get_args ( q ) ; node * term1 = get_atom_or_stream ( term1 ) ; node * term2 = get_int_or_var ( term2 ) ; <S2SV_StartBug> int ch = getc_utf8 ( get_input ( term1 ) ) ; <S2SV_EndBug> return unify_int ( q , term2 , ch ) ; }
<S2SV_ModStart> = getc_utf8 ( get_input_stream <S2SV_ModEnd> ( term1 )
3,927
CWE-000 void PM_DebugLegsAnim ( int anim ) { int oldAnim = ( pm -> ps -> legsAnim & ~ ANIM_TOGGLEBIT ) ; int newAnim = ( anim & ~ ANIM_TOGGLEBIT ) ; if ( oldAnim < MAX_TOTALANIMATIONS && oldAnim >= BOTH_DEATH1 && newAnim < MAX_TOTALANIMATIONS && newAnim >= BOTH_DEATH1 ) { <S2SV_StartBug> Com_Printf ( "OLD:<S2SV_blank>%s\\n" , animTable [ oldAnim ] ) ; <S2SV_EndBug> <S2SV_StartBug> Com_Printf ( "NEW:<S2SV_blank>%s\\n" , animTable [ newAnim ] ) ; <S2SV_EndBug> } }
<S2SV_ModStart> [ oldAnim ] . name <S2SV_ModStart> [ newAnim ] . name
3,928
CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> if ( argc == 10 ) <S2SV_EndBug> { BatchId = atoi ( argv [ 1 ] ) ; UserId = atoi ( argv [ 2 ] ) ; TraceId = atoi ( argv [ 3 ] ) ; WriteOnly = atoi ( argv [ 4 ] ) ; StartLBA = atol ( argv [ 5 ] ) ; NBLOCK_SSD_CACHE = NTABLE_SSD_CACHE = atol ( argv [ 6 ] ) ; NBLOCK_SMR_FIFO = atol ( argv [ 7 ] ) ; <S2SV_StartBug> EvictStrategy = ( atoi ( argv [ 8 ] ) == 0 ) ? PORE_PLUS_V2 : LRU_private ; <S2SV_EndBug> <S2SV_StartBug> PeriodLenth = atoi ( argv [ 9 ] ) * ZONESZ / 4096 ; <S2SV_EndBug> } else { printf ( "parameters<S2SV_blank>are<S2SV_blank>wrong<S2SV_blank>%d\\n" , argc ) ; exit ( - 1 ) ; } # ifdef CG_THROTTLE init_cgdev ( ) ; # endif initRuntimeInfo ( ) ; STT -> trace_req_amount = trace_req_total [ TraceId ] ; initSSD ( ) ; ssd_fd = open ( ssd_device , O_RDWR | O_DIRECT ) ; # ifdef SIMULATION fd_fifo_part = open ( simu_smr_fifo_device , O_RDWR | O_DIRECT ) ; fd_smr_part = open ( simu_smr_smr_device , O_RDWR | O_DIRECT | O_FSYNC ) ; printf ( "Simulator<S2SV_blank>Device:<S2SV_blank>fifo<S2SV_blank>part=%d,<S2SV_blank>smr<S2SV_blank>part=%d\\n" , fd_fifo_part , fd_smr_part ) ; if ( fd_fifo_part < 0 || fd_smr_part < 0 ) exit ( - 1 ) ; InitSimulator ( ) ; # else hdd_fd = open ( smr_device , O_RDWR | O_DIRECT ) ; printf ( "Device<S2SV_blank>ID:<S2SV_blank>hdd=%d,<S2SV_blank>ssd=%d\\n" , hdd_fd , ssd_fd ) ; # endif # ifdef DAEMON_PROC pthread_t tid ; int err = pthread_create ( & tid , NULL , daemon_proc , NULL ) ; if ( err != 0 ) { printf ( "[ERROR]<S2SV_blank>initSSD:<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>create<S2SV_blank>thread:<S2SV_blank>%s\\n" , strerror ( err ) ) ; exit ( - 1 ) ; } # endif trace_to_iocall ( tracefile [ TraceId ] , WriteOnly , StartLBA ) ; # ifdef SIMULATION PrintSimulatorStatistic ( ) ; # endif close ( hdd_fd ) ; close ( ssd_fd ) ; return 0 ; }
<S2SV_ModStart> ( argc == 11 <S2SV_ModEnd> ) { BatchId <S2SV_ModStart> ? PORE_PLUS_V2 : LRU_rw <S2SV_ModEnd> ; PeriodLenth = <S2SV_ModStart> / 4096 ; # ifdef CACHE_PROPORTIOIN_STATIC Proportion_Dirty = atof ( argv [ 10 ] ) ; # endif
3,929
CWE-000 int close_id ( struct cifssrv_sess * sess , uint64_t id , uint64_t p_id ) { struct cifssrv_file * fp ; struct file * filp ; struct dentry * dir , * dentry ; int err ; fp = get_id_from_fidtable ( sess , id ) ; if ( ! fp ) { cifssrv_debug ( "Invalid<S2SV_blank>id<S2SV_blank>for<S2SV_blank>close:<S2SV_blank>%llu\\n" , id ) ; return - EINVAL ; } if ( fp -> is_durable && fp -> persistent_id != p_id ) { cifssrv_err ( "persistent<S2SV_blank>id<S2SV_blank>mismatch<S2SV_blank>:<S2SV_blank>%llu,<S2SV_blank>%llu\\n" , fp -> persistent_id , p_id ) ; return - ENOENT ; } close_id_del_oplock ( sess -> server , fp , id ) ; if ( fp -> islink ) filp = fp -> lfilp ; else filp = fp -> filp ; if ( fp -> delete_on_close ) { dentry = filp -> f_path . dentry ; dir = dentry -> d_parent ; <S2SV_StartBug> dget ( dentry ) ; <S2SV_EndBug> # if LINUX_VERSION_CODE > KERNEL_VERSION ( 4 , 1 , 10 ) inode_lock ( dir -> d_inode ) ; # else mutex_lock ( & dir -> d_inode -> i_mutex ) ; # endif if ( ! dentry -> d_inode || ! dentry -> d_inode -> i_nlink ) { err = - ENOENT ; goto out ; } if ( S_ISDIR ( dentry -> d_inode -> i_mode ) ) err = vfs_rmdir ( dir -> d_inode , dentry ) ; else # if LINUX_VERSION_CODE > KERNEL_VERSION ( 3 , 10 , 30 ) err = vfs_unlink ( dir -> d_inode , dentry , NULL ) ; # else err = vfs_unlink ( dir -> d_inode , dentry ) ; # endif out : # if LINUX_VERSION_CODE > KERNEL_VERSION ( 4 , 1 , 10 ) inode_unlock ( dir -> d_inode ) ; # else mutex_unlock ( & dir -> d_inode -> i_mutex ) ; # endif dput ( dentry ) ; if ( err ) cifssrv_debug ( "failed<S2SV_blank>to<S2SV_blank>delete,<S2SV_blank>err<S2SV_blank>%d\\n" , err ) ; } filp_close ( filp , ( struct files_struct * ) filp ) ; delete_id_from_fidtable ( sess , id ) ; cifssrv_close_id ( & sess -> fidtable , id ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
<S2SV_ModStart> -> d_parent ; if ( fp -> is_stream ) { err = vfs_removexattr ( dentry , fp -> stream_name ) ; if ( err ) cifssrv_err ( "remove<S2SV_blank>xattr<S2SV_blank>failed<S2SV_blank>:<S2SV_blank>%s\\n" , fp -> stream_name ) ; goto out2 ; } <S2SV_ModStart> id ) ; out2 :
3,930
CWE-000 int tp_send ( struct transport * net , const char * buf , const int len ) { int ret = 0 ; char * send_buf = ( char * ) buf ; int send_len = ( int ) len ; struct msghdr msg ; struct kvec iov ; sigset_t blocked , oldset ; unsigned long pflags = current -> flags ; siginitsetinv ( & blocked , sigmask ( SIGKILL ) ) ; sigprocmask ( SIG_SETMASK , & blocked , & oldset ) ; current -> flags |= PF_MEMALLOC ; while ( send_len > 0 ) { if ( net -> sock -> state != SS_CONNECTED ) { ret = - EPIPE ; <S2SV_StartBug> LOG_ERR ( "socket<S2SV_blank>not<S2SV_blank>connected" ) ; <S2SV_EndBug> break ; } net -> sock -> sk -> sk_allocation = GFP_NOIO | __GFP_MEMALLOC ; iov . iov_base = ( void * ) send_buf , iov . iov_len = send_len , memset ( & msg , 0 , sizeof ( msg ) ) ; ret = kernel_sendmsg ( net -> sock , & msg , & iov , 1 , send_len ) ; if ( ret == - EAGAIN || ret == - EINTR ) { LOG_INFO ( "send<S2SV_blank>busy<S2SV_blank>eagain" ) ; msleep ( 10 ) ; continue ; } if ( ret <= 0 ) { LOG_INFO ( "send<S2SV_blank>failed<S2SV_blank>ret:%d,<S2SV_blank>len:%d" , ret , send_len ) ; <S2SV_StartBug> break ; <S2SV_EndBug> } send_len -= ret ; <S2SV_StartBug> send_buf += ret ; <S2SV_EndBug> } sigprocmask ( SIG_SETMASK , & oldset , NULL ) ; tsk_restore_flags ( current , pflags , PF_MEMALLOC ) ; return ( send_len == 0 ) ? 0 : - 1 ; }
<S2SV_ModStart> LOG_ERR ( "socket<S2SV_blank>not<S2SV_blank>connected" ) ; atomic_set ( & net -> isok , 0 <S2SV_ModStart> send_len ) ; atomic_set ( & net -> isok , 0 ) ; <S2SV_ModStart> send_buf += ret ; } if ( send_len == 0 ) { atomic_set ( & net -> isok , 1 )
3,931
CWE-000 static int lfs_commit_globals ( lfs_t * lfs , struct lfs_commit * commit , const lfs_globals_t * source , const lfs_globals_t * diff ) { <S2SV_StartBug> lfs_globals_t res = lfs_globals_xor ( source , diff ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! lfs_globals_iszero ( & res ) ) { <S2SV_EndBug> int err = lfs_commit_commit ( lfs , commit , ( lfs_mattr_t ) { lfs_mktag ( LFS_TYPE_IDELETE , res . move . id , sizeof ( res . move . pair ) ) , . u . buffer = res . move . pair } ) ; if ( err ) { return err ; } <S2SV_StartBug> } <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> diff ) { if ( lfs_globals_iszero ( diff ) ) { return 0 ; } <S2SV_ModStart> diff ) ; <S2SV_ModEnd> int err = <S2SV_ModStart> err ; } <S2SV_ModEnd> return 0 ;
3,932
CWE-000 int main ( int argc , char * * argv ) { int passed_tests = 0 ; int failed_tests = 0 ; int total_tests = 0 ; bl_init ( ) ; TEST ( "Simple<S2SV_blank>s-expression<S2SV_blank>parse<S2SV_blank>to<S2SV_blank>AST<S2SV_blank>list<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_sexp_parse_list ) TEST ( "Serialise<S2SV_blank>an<S2SV_blank>s-expression<S2SV_blank>from<S2SV_blank>AST<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_ser_sexp ) TEST ( "Transform<S2SV_blank>AST<S2SV_blank>list<S2SV_blank>into<S2SV_blank>pure<S2SV_blank>expression<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_ast_pure_sexp ) TEST ( "Serialise<S2SV_blank>a<S2SV_blank>pure<S2SV_blank>expression<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_ser_pure_sexp ) TEST ( "List<S2SV_blank>ops:<S2SV_blank>first,<S2SV_blank>second<S2SV_blank>and<S2SV_blank>rest<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_first_second_rest ) TEST ( "List<S2SV_blank>ops:<S2SV_blank>prepend<S2SV_blank>to<S2SV_blank>NULL<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_prepend_null ) TEST ( "List<S2SV_blank>ops:<S2SV_blank>get<S2SV_blank>list<S2SV_blank>length<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_list_len ) TEST ( "Create<S2SV_blank>an<S2SV_blank>empty<S2SV_blank>context<S2SV_blank>and<S2SV_blank>get/set<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_empty_ctx ) TEST ( "Create<S2SV_blank>a<S2SV_blank>child<S2SV_blank>context<S2SV_blank>and<S2SV_blank>lookup<S2SV_blank>in<S2SV_blank>parent" , test_child_ctx ) TEST ( "Simple<S2SV_blank>arithmetic<S2SV_blank>(addition)<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_simple_arithmetic ) TEST ( "Nested<S2SV_blank>addition<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_nested_addition ) TEST ( "Addition<S2SV_blank>and<S2SV_blank>subtraction<S2SV_blank>in<S2SV_blank>one<S2SV_blank>expression<S2SV_blank>" , test_sub_add ) TEST ( "Multiplication<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_mult ) TEST ( "Division<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_div ) TEST ( "Set<S2SV_blank>operator<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_set_oper ) TEST ( "Simple<S2SV_blank>function<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_simple_func ) <S2SV_StartBug> fprintf ( stderr , "Ran<S2SV_blank>%d<S2SV_blank>tests,<S2SV_blank>%d<S2SV_blank>passed,<S2SV_blank>%d<S2SV_blank>failed\\n" , total_tests , passed_tests , failed_tests ) ; <S2SV_EndBug> if ( failed_tests > 0 ) { return 1 ; } else { return 0 ; } }
<S2SV_ModStart> , test_simple_func ) TEST ( "Multi-expression<S2SV_blank>function<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" , test_multiexpr_func )
3,933
CWE-000 void pmm_init ( void ) { init_pmm_manager ( ) ; page_init ( ) ; check_alloc_page ( ) ; boot_pgdir = boot_alloc_page ( ) ; memset ( boot_pgdir , 0 , PGSIZE ) ; boot_cr3 = PADDR ( boot_pgdir ) ; check_pgdir ( ) ; static_assert ( KERNBASE % PTSIZE == 0 && KERNTOP % PTSIZE == 0 ) ; boot_pgdir [ PDX ( VPT ) ] = <S2SV_StartBug> pte_create ( page2ppn ( kva2page ( boot_pgdir ) ) , READ_WRITE ) ; <S2SV_EndBug> boot_map_segment ( boot_pgdir , KERNBASE , KMEMSIZE , PADDR ( KERNBASE ) , READ_WRITE_EXEC ) ; pde_t * sptbr = KADDR ( read_csr ( sptbr ) << PGSHIFT ) ; pte_t * sbi_pte = get_pte ( sptbr , 0xFFFFFFFF , 0 ) ; boot_map_segment ( boot_pgdir , ( uintptr_t ) ( - PGSIZE ) , PGSIZE , PTE_ADDR ( * sbi_pte ) , READ_EXEC ) ; enable_paging ( ) ; check_boot_pgdir ( ) ; print_pgdir ( ) ; }
<S2SV_ModStart> = pte_create ( PPN ( boot_cr3 ) , PAGE_TABLE_DIR ) ; boot_pgdir [ PDX ( VPT ) + 1 ] = pte_create ( PPN ( boot_cr3 <S2SV_ModEnd> ) , READ_WRITE
3,934
CWE-000 int SimpleFS_readDir ( char * * names , DirectoryHandle * d ) { if ( names == NULL || d == NULL ) { printf ( "Bad<S2SV_blank>parameters<S2SV_blank>on<S2SV_blank>input\\n" ) ; return - 1 ; } int total_blocks = 0 ; int ret = 0 ; FirstDirectoryBlock * fdb = d -> dcb ; DiskDriver * disk = d -> sfs -> disk ; int max_free_space_fdb = ( BLOCK_SIZE - sizeof ( BlockHeader ) - sizeof ( FileControlBlock ) - sizeof ( int ) ) / sizeof ( int ) ; int max_free_space_db = ( BLOCK_SIZE - sizeof ( BlockHeader ) ) / sizeof ( int ) ; if ( fdb -> num_entries > 0 ) { int i ; FirstFileBlock to_check ; int * blocks = fdb -> file_blocks ; for ( i = 0 ; i < max_free_space_fdb ; i ++ ) { if ( blocks [ i ] > 0 && DiskDriver_readBlock ( disk , & to_check , blocks [ i ] ) != - 1 ) { names [ total_blocks ] = strndup ( to_check . fcb . name , 128 ) ; total_blocks ++ ; } } if ( fdb -> num_entries > i ) { <S2SV_StartBug> int next = fdb . header . next_block ; <S2SV_EndBug> DirectoryBlock db ; while ( next != - 1 ) { ret = DiskDriver_readBlock ( disk , & db , next ) ; if ( ret == - 1 ) { printf ( "Cannot<S2SV_blank>read<S2SV_blank>the<S2SV_blank>next<S2SV_blank>block:<S2SV_blank>SimpleFS_read\\n" ) ; return - 1 ; } <S2SV_StartBug> int * blocks = db -> file_blocks ; <S2SV_EndBug> for ( i = 0 ; i < max_free_space_db ; i ++ ) { if ( blocks [ i ] > 0 && DiskDriver_readBlock ( disk , & to_check , blocks [ i ] ) != - 1 ) { <S2SV_StartBug> names [ num_tot ] = strndup ( to_check . fcb . name , 128 ) ; <S2SV_EndBug> <S2SV_StartBug> num_tot ++ ; <S2SV_EndBug> } } next = db . header . next_block ; } } } return 0 ; }
<S2SV_ModStart> next = fdb -> <S2SV_ModEnd> header . next_block <S2SV_ModStart> blocks = db . <S2SV_ModEnd> file_blocks ; for <S2SV_ModStart> { names [ total_blocks <S2SV_ModEnd> ] = strndup <S2SV_ModStart> 128 ) ; total_blocks <S2SV_ModEnd> ++ ; }
3,935
CWE-000 Sdl xsetup ( const int xres , const int yres , const int fps ) { <S2SV_StartBug> const uint32_t format = SDL_PIXELFORMAT_ARGB8888 ; <S2SV_EndBug> SDL_Init ( SDL_INIT_VIDEO ) ; SDL_SetRelativeMouseMode ( SDL_TRUE ) ; Sdl sdl ; xzero ( sdl ) ; sdl . window = SDL_CreateWindow ( "water" , 0 , 0 , xres , yres , SDL_WINDOW_SHOWN ) ; if ( ! sdl . window ) xbomb ( "error:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>window\\n" ) ; sdl . renderer = SDL_CreateRenderer ( sdl . window , - 1 , SDL_RENDERER_ACCELERATED ) ; <S2SV_StartBug> sdl . texture = SDL_CreateTexture ( sdl . renderer , format , SDL_TEXTUREACCESS_STREAMING , yres , xres ) ; <S2SV_EndBug> <S2SV_StartBug> sdl . surfaces = xpull ( format ) ; <S2SV_EndBug> sdl . textures = xcache ( sdl . surfaces , sdl . renderer ) ; sdl . xres = xres ; sdl . yres = yres ; sdl . fps = fps ; return sdl ; }
<S2SV_ModStart> fps ) { <S2SV_ModEnd> SDL_Init ( SDL_INIT_VIDEO <S2SV_ModStart> ; sdl . canvas <S2SV_ModEnd> = SDL_CreateTexture ( <S2SV_ModStart> . renderer , SDL_PIXELFORMAT_ARGB8888 <S2SV_ModEnd> , SDL_TEXTUREACCESS_STREAMING , <S2SV_ModStart> = xpull ( <S2SV_ModEnd> ) ; sdl
3,936
CWE-000 PHP_METHOD ( Sanitizer_Sanitizers_Strings , trim ) { zval _1 ; zend_long ZEPHIR_LAST_CALL_STATUS ; zval * value_param = NULL , _0 , _2 , _3 , _4 , _5 ; zval value ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & value ) ; ZVAL_UNDEF ( & _0 ) ; ZVAL_UNDEF ( & _2 ) ; ZVAL_UNDEF ( & _3 ) ; ZVAL_UNDEF ( & _4 ) ; ZVAL_UNDEF ( & _5 ) ; ZVAL_UNDEF ( & _1 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & value_param ) ; if ( UNEXPECTED ( Z_TYPE_P ( value_param ) != IS_STRING && Z_TYPE_P ( value_param ) != IS_NULL ) ) { zephir_throw_exception_string ( spl_ce_InvalidArgumentException , SL ( "Parameter<S2SV_blank>\'value\'<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>string" ) TSRMLS_CC ) ; RETURN_MM_NULL ( ) ; } if ( EXPECTED ( Z_TYPE_P ( value_param ) == IS_STRING ) ) { zephir_get_strval ( & value , value_param ) ; } else { ZEPHIR_INIT_VAR ( & value ) ; ZVAL_EMPTY_STRING ( & value ) ; } ZEPHIR_INIT_VAR ( & _0 ) ; ZEPHIR_INIT_VAR ( & _1 ) ; zephir_create_array ( & _1 , 3 , 0 TSRMLS_CC ) ; ZEPHIR_INIT_VAR ( & _2 ) ; ZVAL_STRING ( & _2 , "\\\\" ) ; zephir_array_fast_append ( & _1 , & _2 ) ; ZEPHIR_INIT_NVAR ( & _2 ) ; ZVAL_STRING ( & _2 , "\\"" ) ; zephir_array_fast_append ( & _1 , & _2 ) ; ZEPHIR_INIT_NVAR ( & _2 ) ; ZVAL_STRING ( & _2 , "\'" ) ; zephir_array_fast_append ( & _1 , & _2 ) ; ZEPHIR_INIT_NVAR ( & _2 ) ; ZVAL_STRING ( & _2 , "" ) ; zephir_fast_str_replace ( & _0 , & _1 , & _2 , & value TSRMLS_CC ) ; zephir_get_strval ( & value , & _0 ) ; ZVAL_LONG ( & _3 , 513 ) ; <S2SV_StartBug> ZEPHIR_CALL_FUNCTION ( & _4 , "filter_var" , NULL , 7 , & value , & _3 ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; zephir_get_strval ( & value , & _4 ) ; <S2SV_StartBug> ZEPHIR_CALL_FUNCTION ( & _5 , "strip_tags" , NULL , 10 , & value ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; zephir_fast_trim ( return_value , & _5 , NULL , ZEPHIR_TRIM_BOTH TSRMLS_CC ) ; RETURN_MM ( ) ; }
<S2SV_ModStart> , NULL , 9 <S2SV_ModEnd> , & value <S2SV_ModStart> , NULL , 12 <S2SV_ModEnd> , & value
3,937
CWE-000 int try_launch_path ( char * * args , char * * envp ) { char * path ; char * * path_list ; int i ; int found ; t_env * list ; list = ft_load_list ( envp ) ; path = ft_get_env ( "PATH" , list ) ; <S2SV_StartBug> path_list = ft_strsplit ( path , ':' ) ; <S2SV_EndBug> i = 0 ; found = 0 ; if ( path != NULL ) free ( path ) ; while ( path_list [ i ] ) { path_list [ i ] = ft_strjoin ( path_list [ i ] , "/" ) ; path_list [ i ] = ft_strjoin ( path_list [ i ] , args [ 0 ] ) ; path_list [ i ] = remove_quotes ( path_list [ i ] ) ; printf ( "Attempting<S2SV_blank>to<S2SV_blank>launch<S2SV_blank>[%s],<S2SV_blank>at<S2SV_blank>%s\\n" , args [ 0 ] , path_list [ i ] ) ; if ( ( execve ( path_list [ i ] , args , envp ) != - 1 ) ) { found = 1 ; } i ++ ; } if ( ! found ) { ft_putstr ( "Command<S2SV_blank>invalid.\\n" ) ; exit ( 0 ) ; } }
<S2SV_ModStart> path , ':' ) ; debug_path_list ( path_list
3,938
CWE-000 int TermWrite ( char * buff , int bsize , int unit_id , int * nwrite ) { if ( DEBUG4 && debugflag4 ) { USLOSS_Console ( "TermWrite():<S2SV_blank>called.\\n" ) ; } USLOSS_Sysargs sysArg ; CHECKMODE ; sysArg . number = SYS_TERMWRITE ; sysArg . arg1 = ( void * ) buff ; <S2SV_StartBug> sysArg . arg2 = ( void * ) ( ( long ) ( nwrite ) ) ; <S2SV_EndBug> sysArg . arg3 = ( void * ) ( ( long ) unit_id ) ; USLOSS_Syscall ( & sysArg ) ; * nwrite = ( int ) ( ( long ) sysArg . arg2 ) ; int returnStatus = ( int ) ( ( long ) sysArg . arg4 ) ; return returnStatus ; }
<S2SV_ModStart> long ) ( bsize <S2SV_ModEnd> ) ) ;
3,939
CWE-000 <S2SV_StartBug> const char * wiiu_gca_get_name ( void * data ) <S2SV_EndBug> { gca_pad_t * pad = ( gca_pad_t * ) data ; return "GameCube<S2SV_blank>Controller" ; }
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static
3,940
CWE-000 static void ap_remove_sta ( struct sta_state * sta ) { if ( ! l_queue_remove ( sta -> ap -> sta_states , sta ) ) { <S2SV_StartBug> l_error ( "tried<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>station<S2SV_blank>that<S2SV_blank>doesnt<S2SV_blank>exist" ) ; <S2SV_EndBug> return ; } ap_sta_free ( sta ) ; }
<S2SV_ModStart> { l_error ( "tried<S2SV_blank>to<S2SV_blank>remove<S2SV_blank>station<S2SV_blank>that<S2SV_blank>doesn\'t<S2SV_blank>exist" <S2SV_ModEnd> ) ; return
3,941
CWE-000 size_t llvm_regerror ( int errcode , const llvm_regex_t * preg , _Out_writes_all_ ( errbuf_size ) char * errbuf , size_t errbuf_size ) { struct rerr * r ; size_t len ; int target = errcode & ~ REG_ITOA ; const char * s ; char convbuf [ 50 ] ; _Analysis_assume_nullterminated_ ( convbuf ) ; if ( errcode == REG_ATOI ) s = regatoi ( preg , convbuf , sizeof convbuf ) ; else { for ( r = rerrs ; r -> code != 0 ; r ++ ) if ( r -> code == target ) break ; if ( errcode & REG_ITOA ) { if ( r -> code != 0 ) { assert ( strlen ( r -> name ) < sizeof ( convbuf ) ) ; ( void ) llvm_strlcpy ( convbuf , r -> name , sizeof convbuf ) ; } else # ifndef _WIN32 ( void ) snprintf ( convbuf , sizeof convbuf , <S2SV_StartBug> # else <S2SV_EndBug> <S2SV_StartBug> ( void ) _snprintf_s ( convbuf , _countof ( convbuf ) , _countof ( convbuf ) , <S2SV_EndBug> # endif "REG_0x%x" , target ) ; s = convbuf ; } else s = r -> explain ; } len = strlen ( s ) + 1 ; if ( errbuf_size > 0 ) { llvm_strlcpy ( errbuf , s , errbuf_size ) ; } return ( len ) ; }
<S2SV_ModStart> sizeof convbuf , "REG_0x%x" , target ) ; <S2SV_ModStart> convbuf ) , "REG_0x%x" , target ) ; # endif <S2SV_ModEnd> s = convbuf
3,942
CWE-000 int find_mac ( mon ) struct monst * mon ; { struct obj * obj ; int base = mon -> data -> ac , armac = 0 ; long mwflags = mon -> misc_worn_check ; <S2SV_StartBug> if ( mon -> data == & mons [ PM_ASMODEUS ] && base < - 9 ) base = - 9 + AC_VALUE ( base + 9 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_PALE_NIGHT ] && base < - 6 ) base = - 6 + AC_VALUE ( base + 6 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_BAALPHEGOR ] && base < - 8 ) base = - 8 + AC_VALUE ( base + 8 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_ZAPHKIEL ] && base < - 8 ) base = - 8 + AC_VALUE ( base + 8 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_QUEEN_OF_STARS ] && base < - 6 ) base = - 6 + AC_VALUE ( base + 6 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_ETERNAL_LIGHT ] && base < - 6 ) base = - 6 + AC_VALUE ( base + 6 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_STRANGE_CORPSE ] && base < - 5 ) base = - 5 + AC_VALUE ( base + 5 ) ; <S2SV_EndBug> <S2SV_StartBug> else if ( mon -> data == & mons [ PM_ANCIENT_OF_DEATH ] && base < - 4 ) base = - 4 + AC_VALUE ( base + 4 ) ; <S2SV_EndBug> else if ( mon -> data == & mons [ PM_CHOKHMAH_SEPHIRAH ] ) { base -= u . chokhmah ; } else if ( is_weeping ( mon -> data ) ) { if ( mon -> mvar2 & 0x4L ) base = - 125 ; if ( mon -> mvar2 & 0x2L ) base = - 20 ; } else if ( mon -> data == & mons [ PM_GIANT_TURTLE ] && mon -> mflee ) { base -= 15 ; } else if ( mon -> data == & mons [ PM_MARILITH ] || mon -> data == & mons [ PM_SHAKTARI ] ) { struct obj * mwep = ( mon == & youmonst ) ? uwep : MON_WEP ( mon ) ; if ( mwep ) { base -= rnd ( 20 ) ; } } if ( mon -> mfaction == ZOMBIFIED ) base -= 2 ; if ( mon -> mfaction == SKELIFIED ) base -= 6 ; if ( mon -> mfaction == CRYSTALFIED ) base -= 16 ; if ( mon -> mtame ) { base -= rnd ( def_beastmastery ( ) ) ; if ( u . specialSealsActive & SEAL_COSMOS ) base -= spiritDsize ( ) ; if ( u . usteed && mon == u . usteed ) base -= rnd ( def_mountedCombat ( ) ) ; } if ( mon -> data == & mons [ PM_HOD_SEPHIRAH ] ) { if ( uarm ) armac += ARM_BONUS ( uarm ) ; if ( uarmf ) armac += ARM_BONUS ( uarmf ) ; if ( uarmg ) armac += ARM_BONUS ( uarmg ) ; if ( uarmu ) armac += ARM_BONUS ( uarmu ) ; if ( uarms ) armac += ARM_BONUS ( uarms ) ; if ( uarmh ) armac += ARM_BONUS ( uarmh ) ; if ( uarmc ) armac += ARM_BONUS ( uarmc ) ; if ( armac < 0 ) armac *= - 1 ; } else for ( obj = mon -> minvent ; obj ; obj = obj -> nobj ) { if ( obj -> owornmask & mwflags ) { armac += ARM_BONUS ( obj ) ; if ( is_shield ( obj ) ) armac += max ( 0 , obj -> objsize - mon -> data -> msize ) ; } } if ( armac > 11 ) armac = rnd ( armac - 10 ) + 10 ; base -= armac ; return base ; }
<S2SV_ModStart> - 9 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 6 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 8 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 8 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 6 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 6 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 5 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base + <S2SV_ModStart> - 4 + MONSTER_AC_VALUE <S2SV_ModEnd> ( base +
3,943
CWE-000 int avr_write ( PROGRAMMER * pgm , AVRPART * p , char * memtype , int size , int auto_erase ) { int rc ; int newpage , page_tainted , flush_page , do_write ; int wsize ; unsigned int i , lastaddr ; unsigned char data ; int werror ; unsigned char cmd [ 4 ] ; AVRMEM * m ; m = avr_locate_mem ( p , memtype ) ; if ( m == NULL ) { avrdude_message ( MSG_INFO , "No<S2SV_blank>\\"%s\\"<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>part<S2SV_blank>%s\\n" , memtype , p -> desc ) ; return - 1 ; } pgm -> err_led ( pgm , OFF ) ; werror = 0 ; wsize = m -> size ; if ( size < wsize ) { wsize = size ; } else if ( size > wsize ) { avrdude_message ( MSG_INFO , "%s:<S2SV_blank>WARNING:<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>requested,<S2SV_blank>but<S2SV_blank>memory<S2SV_blank>region<S2SV_blank>is<S2SV_blank>only<S2SV_blank>%d" "bytes\\n" "%sOnly<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>will<S2SV_blank>actually<S2SV_blank>be<S2SV_blank>written\\n" , progname , size , wsize , progbuf , wsize ) ; } if ( ( p -> flags & AVRPART_HAS_TPI ) && m -> page_size != 0 && pgm -> cmd_tpi != NULL ) { while ( avr_tpi_poll_nvmbsy ( pgm ) ) ; avr_tpi_setup_rw ( pgm , m , 0 , TPI_NVMCMD_WORD_WRITE ) ; if ( wsize & 0x1 ) { wsize ++ ; } for ( lastaddr = i = 0 ; i < wsize ; i += 2 ) { if ( ( m -> tags [ i ] & TAG_ALLOCATED ) != 0 || ( m -> tags [ i + 1 ] & TAG_ALLOCATED ) != 0 ) { if ( lastaddr != i ) { avr_tpi_setup_rw ( pgm , m , i , TPI_NVMCMD_WORD_WRITE ) ; lastaddr = i ; } cmd [ 0 ] = TPI_CMD_SST_PI ; cmd [ 1 ] = m -> buf [ i ] ; rc = pgm -> cmd_tpi ( pgm , cmd , 2 , NULL , 0 ) ; cmd [ 1 ] = m -> buf [ i + 1 ] ; rc = pgm -> cmd_tpi ( pgm , cmd , 2 , NULL , 0 ) ; lastaddr += 2 ; while ( avr_tpi_poll_nvmbsy ( pgm ) ) ; } report_progress ( i , wsize , NULL ) ; } return i ; } if ( pgm -> paged_write != NULL && m -> page_size != 0 ) { int need_write , failure ; unsigned int pageaddr ; unsigned int npages , nwritten ; for ( pageaddr = 0 , npages = 0 ; pageaddr < wsize ; pageaddr += m -> page_size ) { for ( i = pageaddr ; i < pageaddr + m -> page_size ; i ++ ) if ( ( m -> tags [ i ] & TAG_ALLOCATED ) != 0 ) { npages ++ ; break ; } } for ( pageaddr = 0 , failure = 0 , nwritten = 0 ; ! failure && pageaddr < wsize ; pageaddr += m -> page_size ) { for ( i = pageaddr , need_write = 0 ; i < pageaddr + m -> page_size ; i ++ ) if ( ( m -> tags [ i ] & TAG_ALLOCATED ) != 0 ) { need_write = 1 ; break ; } if ( need_write ) { rc = 0 ; if ( auto_erase ) rc = pgm -> page_erase ( pgm , p , m , pageaddr ) ; if ( rc >= 0 ) rc = pgm -> paged_write ( pgm , p , m , m -> page_size , pageaddr , m -> page_size ) ; if ( rc < 0 ) failure = 1 ; } else { avrdude_message ( MSG_DEBUG , "%s:<S2SV_blank>avr_write():<S2SV_blank>skipping<S2SV_blank>page<S2SV_blank>%u:<S2SV_blank>no<S2SV_blank>interesting<S2SV_blank>data\\n" , progname , pageaddr / m -> page_size ) ; } nwritten ++ ; report_progress ( nwritten , npages , NULL ) ; } if ( ! failure ) return wsize ; } if ( pgm -> write_setup ) { pgm -> write_setup ( pgm , p , m ) ; } newpage = 1 ; page_tainted = 0 ; flush_page = 0 ; for ( i = 0 ; i < wsize ; i ++ ) { data = m -> buf [ i ] ; report_progress ( i , wsize , NULL ) ; do_write = ( m -> tags [ i ] & TAG_ALLOCATED ) != 0 ; if ( m -> paged ) { if ( newpage ) { page_tainted = do_write ; } else { page_tainted |= do_write ; } if ( i % m -> page_size == m -> page_size - 1 || i == wsize - 1 ) { flush_page = page_tainted ; newpage = 1 ; } else { flush_page = newpage = 0 ; } } if ( ! do_write && ! flush_page ) { continue ; } if ( do_write ) { rc = avr_write_byte ( pgm , p , m , i , data ) ; if ( rc ) { avrdude_message ( MSG_INFO , "<S2SV_blank>***failed;<S2SV_blank><S2SV_blank>" ) ; avrdude_message ( MSG_INFO , "\\n" ) ; pgm -> err_led ( pgm , ON ) ; werror = 1 ; } } if ( flush_page ) { rc = avr_write_page ( pgm , p , m , i ) ; if ( rc ) { avrdude_message ( MSG_INFO , "<S2SV_blank>***<S2SV_blank>page<S2SV_blank>%d<S2SV_blank>(addresses<S2SV_blank>0x%04x<S2SV_blank>-<S2SV_blank>0x%04x)<S2SV_blank>failed<S2SV_blank>" "to<S2SV_blank>write\\n" , i % m -> page_size , i - m -> page_size + 1 , i ) ; avrdude_message ( MSG_INFO , "\\n" ) ; pgm -> err_led ( pgm , ON ) ; werror = 1 ; } } if ( werror ) { pgm -> err_led ( pgm , ON ) ; <S2SV_StartBug> } <S2SV_EndBug> } return i ; }
<S2SV_ModStart> ON ) ; return - 1 ; } } return <S2SV_ModEnd> i ; }
3,944
CWE-000 void taskqgroup_attach ( struct taskqgroup * qgroup , struct grouptask * gtask , void * uniq , int irq , char * name ) { cpuset_t mask ; int qid , error ; gtask -> gt_uniq = uniq ; snprintf ( gtask -> gt_name , GROUPTASK_NAMELEN , "%s" , name ? name : "grouptask" ) ; gtask -> gt_irq = irq ; gtask -> gt_cpu = - 1 ; mtx_lock ( & qgroup -> tqg_lock ) ; qid = taskqgroup_find ( qgroup , uniq ) ; qgroup -> tqg_queue [ qid ] . tgc_cnt ++ ; LIST_INSERT_HEAD ( & qgroup -> tqg_queue [ qid ] . tgc_tasks , gtask , gt_list ) ; gtask -> gt_taskqueue = qgroup -> tqg_queue [ qid ] . tgc_taskq ; if ( irq != - 1 && tqg_smp_started ) { gtask -> gt_cpu = qgroup -> tqg_queue [ qid ] . tgc_cpu ; CPU_ZERO ( & mask ) ; CPU_SET ( qgroup -> tqg_queue [ qid ] . tgc_cpu , & mask ) ; mtx_unlock ( & qgroup -> tqg_lock ) ; error = intr_setaffinity ( irq , CPU_WHICH_IRQ , & mask ) ; if ( error ) <S2SV_StartBug> printf ( "%s:<S2SV_blank>setaffinity<S2SV_blank>failed:<S2SV_blank>%d\\n" , __func__ , error ) ; <S2SV_EndBug> } else mtx_unlock ( & qgroup -> tqg_lock ) ; }
<S2SV_ModStart> ) printf ( "%s:<S2SV_blank>setaffinity<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>%d\\n" , __func__ , gtask -> gt_name <S2SV_ModEnd> , error )
3,945
CWE-000 int capture_core ( const struct core_capture_config * config ) { struct rte_mbuf * bufs [ DPDKCAP_CAPTURE_BURST_SIZE ] ; uint16_t nb_rx ; int nb_rx_enqueued ; RTE_LOG ( INFO , DPDKCAP , "Core<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>capturing<S2SV_blank>packets<S2SV_blank>for<S2SV_blank>port<S2SV_blank>%u\\n" , rte_lcore_id ( ) , config -> port ) ; * ( config -> stats ) = ( struct core_capture_stats ) { . core_id = rte_lcore_id ( ) , . packets = 0 , . missed_packets = 0 , } ; for ( ; ; ) { if ( unlikely ( * ( config -> stop_condition ) ) ) { break ; } nb_rx = rte_eth_rx_burst ( config -> port , config -> queue , bufs , DPDKCAP_CAPTURE_BURST_SIZE ) ; if ( likely ( nb_rx > 0 ) ) { nb_rx_enqueued = rte_ring_enqueue_bulk ( config -> ring , ( void * ) bufs , nb_rx ) ; <S2SV_StartBug> if ( nb_rx_enqueued == 0 ) { <S2SV_EndBug> config -> stats -> packets += nb_rx ; } else { config -> stats -> missed_packets += nb_rx ; for ( nb_rx_enqueued = 0 ; nb_rx_enqueued < nb_rx ; nb_rx_enqueued ++ ) { rte_pktmbuf_free ( bufs [ nb_rx_enqueued ] ) ; } } } } RTE_LOG ( INFO , DPDKCAP , "Closed<S2SV_blank>capture<S2SV_blank>core<S2SV_blank>%d<S2SV_blank>(port<S2SV_blank>%d)\\n" , rte_lcore_id ( ) , config -> port ) ; return 0 ; }
<S2SV_ModStart> nb_rx_enqueued == 0 && nb_rx_enqueued == - EDQUOT
3,946
CWE-000 static int bif_iso_halt_1 ( tpl_query * q ) { node * args = get_args ( q ) ; node * term1 = get_int ( term1 ) ; q -> halt_code = term1 -> val_i ; q -> halt = ABORT_HALT ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
<S2SV_ModStart> = ABORT_HALT ; q -> did_halt = 1 ;
3,947
CWE-000 int btrfs_log_new_name ( struct btrfs_trans_handle * trans , struct btrfs_inode * inode , struct btrfs_inode * old_dir , struct dentry * parent ) { struct btrfs_fs_info * fs_info = btrfs_sb ( inode -> vfs_inode . i_sb ) ; struct btrfs_root * root = inode -> root ; <S2SV_StartBug> if ( S_ISREG ( inode -> vfs_inode . i_mode ) ) <S2SV_EndBug> inode -> last_unlink_trans = trans -> transid ; if ( inode -> logged_trans <= fs_info -> last_trans_committed && ( ! old_dir || old_dir -> logged_trans <= fs_info -> last_trans_committed ) ) return 0 ; return btrfs_log_inode_parent ( trans , root , inode , parent , 0 , LLONG_MAX , LOG_INODE_EXISTS , NULL ) ; }
<S2SV_ModStart> ; if ( ! S_ISDIR <S2SV_ModEnd> ( inode ->
3,948
CWE-000 static inline void update_screen ( ) { <S2SV_StartBug> clock_event ( SYS_MSG_RTC_YEAR | SYS_MSG_RTC_MONTH | SYS_MSG_RTC_DAY <S2SV_EndBug> <S2SV_StartBug> | SYS_MSG_RTC_HOUR | SYS_MSG_RTC_MINUTE ) ; <S2SV_EndBug> }
<S2SV_ModStart> SYS_MSG_RTC_MONTH | SYS_MSG_RTC_DAY | <S2SV_ModEnd> SYS_MSG_RTC_HOUR | SYS_MSG_RTC_MINUTE <S2SV_ModStart> SYS_MSG_RTC_HOUR | SYS_MSG_RTC_MINUTE | SYS_MSG_RTC_SECOND
3,949
CWE-000 GBytes * gkm_data_der_write_public_key_ecdsa ( gcry_sexp_t s_key ) { <S2SV_StartBug> GNode * asn = NULL ; <S2SV_EndBug> gcry_mpi_t d = NULL ; GBytes * result = NULL , * q ; gchar * q_data = NULL ; GQuark oid ; gchar * curve = NULL ; gsize q_size ; <S2SV_StartBug> asn = egg_asn1x_create ( pk_asn1_tab , "ECPublicKey" ) ; <S2SV_EndBug> g_return_val_if_fail ( asn , NULL ) ; if ( ! gkm_sexp_extract_buffer ( s_key , & q_data , & q_size , "ecdsa" , "q" , NULL ) || <S2SV_StartBug> ! gkm_sexp_extract_buffer ( s_key , & curve , NULL , "ecdsa" , "namedCurve" , NULL ) ) <S2SV_EndBug> goto done ; oid = gkm_data_der_curve_to_oid ( curve ) ; g_free ( curve ) ; if ( oid == - 1 ) goto done ; q = g_bytes_new_take ( q_data , q_size ) ; if ( q == NULL ) goto done ; <S2SV_StartBug> if ( ! gkm_data_asn1_write_bit_string ( egg_asn1x_node ( asn , "q" , NULL ) , q ) || <S2SV_EndBug> <S2SV_StartBug> ! gkm_data_asn1_write_oid ( egg_asn1x_node ( asn , "namedCurve" , NULL ) , oid ) ) <S2SV_EndBug> goto done ; egg_asn1x_set_integer_as_ulong ( egg_asn1x_node ( asn , "version" , NULL ) , 0 ) ; result = egg_asn1x_encode ( asn , egg_secure_realloc ) ; if ( result == NULL ) g_warning ( "couldn\'t<S2SV_blank>encode<S2SV_blank>public<S2SV_blank>ecdsa<S2SV_blank>key:<S2SV_blank>%s" , egg_asn1x_message ( asn ) ) ; done : egg_asn1x_destroy ( asn ) ; gcry_mpi_release ( d ) ; <S2SV_StartBug> g_free ( q ) ; <S2SV_EndBug> return result ; }
<S2SV_ModStart> asn = NULL , * named_curve <S2SV_ModStart> gsize q_size ; init_quarks ( ) ; <S2SV_ModStart> ) || ! gkm_sexp_extract_string <S2SV_ModEnd> ( s_key , <S2SV_ModStart> & curve , "ecdsa" , "curve" <S2SV_ModEnd> , NULL ) <S2SV_ModStart> goto done ; named_curve = egg_asn1x_node ( asn , "parameters" , "namedCurve" , NULL ) ; <S2SV_ModStart> ! gkm_data_asn1_write_oid ( named_curve , oid ) ) goto done ; if ( ! egg_asn1x_set_choice ( <S2SV_ModStart> ( asn , "parameters" , NULL ) , named_curve ) ) goto done <S2SV_ModEnd> ; result = <S2SV_ModStart> d ) ; g_bytes_unref <S2SV_ModEnd> ( q )
3,950
CWE-000 static int hda_suspend ( struct snd_sof_dev * sdev , int state ) { const struct sof_intel_dsp_desc * chip = sdev -> hda -> desc ; struct hdac_bus * bus = sof_to_bus ( sdev ) ; int ret = 0 ; # if IS_ENABLED ( CONFIG_SND_SOC_SOF_HDA ) snd_hdac_ext_bus_link_power_down_all ( bus ) ; # endif ret = hda_dsp_core_reset_power_down ( sdev , chip -> cores_mask ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>power<S2SV_blank>down<S2SV_blank>core<S2SV_blank>during<S2SV_blank>suspend\\n" ) ; return ret ; } # if IS_ENABLED ( CONFIG_SND_SOC_SOF_HDA ) snd_hdac_ext_bus_ppcap_int_enable ( bus , false ) ; snd_hdac_ext_bus_ppcap_enable ( bus , false ) ; snd_hdac_bus_stop_chip ( bus ) ; # endif <S2SV_StartBug> snd_sof_pci_update_bits ( sdev , PCI_TCSEL , <S2SV_EndBug> PCI_CGCTL_LSRMD_MASK , PCI_CGCTL_LSRMD_MASK ) ; return 0 ; }
<S2SV_ModStart> ( sdev , PCI_PGCTL , PCI_PGCTL_LSRMD_MASK , PCI_PGCTL_LSRMD_MASK <S2SV_ModEnd> ) ; return
3,951
CWE-000 int glusterd_get_default_val_for_volopt ( dict_t * ctx , gf_boolean_t all_opts , char * input_key , char * orig_key , glusterd_volinfo_t * volinfo , char * * op_errstr ) { struct volopt_map_entry * vme = NULL ; int ret = - 1 ; int count = 0 ; char err_str [ PATH_MAX ] = "" ; xlator_t * this = NULL ; char * def_val = NULL ; char dict_key [ 50 ] = { 0 , } ; gf_boolean_t key_found = _gf_false ; glusterd_conf_t * priv = NULL ; dict_t * vol_dict = NULL ; this = THIS ; GF_ASSERT ( this ) ; priv = this -> private ; GF_VALIDATE_OR_GOTO ( this -> name , priv , out ) ; vol_dict = volinfo -> dict ; GF_VALIDATE_OR_GOTO ( this -> name , vol_dict , out ) ; if ( ! all_opts && ! input_key ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , GD_MSG_KEY_NULL , "Key<S2SV_blank>is<S2SV_blank>NULL" ) ; goto out ; } for ( vme = & glusterd_volopt_map [ 0 ] ; vme -> key ; vme ++ ) { if ( ! all_opts && strcmp ( vme -> key , input_key ) ) continue ; key_found = _gf_true ; ret = dict_get_str ( priv -> opts , vme -> key , & def_val ) ; if ( ! def_val ) { ret = dict_get_str ( vol_dict , vme -> key , & def_val ) ; if ( ret == - ENOENT ) def_val = glusterd_get_option_value ( volinfo , vme -> key ) ; if ( ! def_val ) { if ( vme -> value ) { def_val = vme -> value ; } else { ret = glusterd_get_value_for_vme_entry ( vme , & def_val ) ; if ( ! all_opts && ret ) goto out ; else if ( ret == - 2 ) continue ; } } } count ++ ; sprintf ( dict_key , "key%d" , count ) ; ret = dict_set_str ( ctx , dict_key , vme -> key ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , GD_MSG_DICT_SET_FAILED , "Failed<S2SV_blank>to<S2SV_blank>" "set<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>dictionary" , vme -> key ) ; goto out ; } sprintf ( dict_key , "value%d" , count ) ; ret = dict_set_dynstr_with_alloc ( ctx , dict_key , def_val ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , GD_MSG_DICT_SET_FAILED , "Failed<S2SV_blank>to<S2SV_blank>" "set<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>key<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>dictionary" , def_val , vme -> key ) ; goto out ; } def_val = NULL ; if ( ! all_opts ) break ; } if ( ! all_opts && ! key_found ) goto out ; ret = dict_set_int32 ( ctx , "count" , count ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , GD_MSG_DICT_SET_FAILED , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>count<S2SV_blank>" "in<S2SV_blank>dictionary" ) ; } out : if ( ret && ! all_opts && ! key_found ) { snprintf ( err_str , sizeof ( err_str ) , "option<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , orig_key ) ; * op_errstr = gf_strdup ( err_str ) ; } <S2SV_StartBug> gf_msg_debug ( this -> name , 0 , "Returning<S2SV_blank>%d" , ret ) ; <S2SV_EndBug> return ret ; }
<S2SV_ModStart> ) ; } if ( def_val ) GF_FREE ( def_val ) ;
3,952
CWE-000 const char * lookup_get_namespace ( lookup_t * lh ) { <S2SV_StartBug> if ( lh && lh -> magic == LOOKUP_MAGIC ) <S2SV_EndBug> return lh -> namespace ; return NULL ; }
<S2SV_ModStart> if ( lh <S2SV_ModEnd> ) return lh
3,953
CWE-000 union IR * p2_push ( union IR * seq , union IR * elem ) { int idx = seq -> seq . count ++ ; if ( seq -> seq . count > seq -> seq . cap ) { seq -> seq . elems = realloc ( seq -> seq . elems , ( seq -> seq . cap *= 2 ) * sizeof ( union IR * ) ) ; } seq -> seq . elems [ idx ] = elem ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> = elem ; return seq ;
3,954
CWE-000 void GeoHBInsert ( struct GeoHashedBvh * bvh , int n , struct GeoBoundingBox * volumes , void * * data ) { bvh -> bbox = find_enclosing_box ( bvh -> bbox , n , volumes ) ; uint64_t * new_hashes ; new_hashes = malloc ( n * sizeof ( * new_hashes ) ) ; ComputeHashes ( & bvh -> bbox , volumes , n , new_hashes ) ; int level_begin [ GEO_HASHED_BVH_MAX_DEPTH + 1 ] ; level_begin [ 0 ] = 0 ; for ( int i = 0 ; i < GEO_HASHED_BVH_MAX_DEPTH ; ++ i ) { level_begin [ i + 1 ] = level_partition ( i , new_hashes , level_begin [ i ] , n ) ; } <S2SV_StartBug> for ( int i = 0 ; i < GEO_HASHED_BVH_MAX_DEPTH ; ++ i ) { <S2SV_EndBug> GeoQsort ( new_hashes + level_begin [ i ] , level_begin [ i + 1 ] - level_begin [ i ] ) ; } struct GeoHashedBvh merged_bvh ; GeoHBInitialize ( & merged_bvh , bvh -> bbox ) ; reserve_space ( & merged_bvh , bvh -> size + level_begin [ GEO_HASHED_BVH_MAX_DEPTH ] ) ; for ( int i = 0 ; i < GEO_HASHED_BVH_MAX_DEPTH ; ++ i ) { merge_level ( & merged_bvh , bvh , i , level_begin , new_hashes , volumes , data ) ; } <S2SV_StartBug> GeoHBDestroy ( bvh ) ; <S2SV_EndBug> * bvh = merged_bvh ; free ( new_hashes ) ; }
<S2SV_ModStart> ) ; } assert ( level_begin [ GEO_HASHED_BVH_MAX_DEPTH ] == n ) ; <S2SV_ModStart> ) ; } for ( int i = 0 ; i < GEO_HASHED_BVH_MAX_DEPTH + 1 ; ++ i ) { merged_bvh . level_begin [ i ] += bvh -> level_begin [ i ] + level_begin [ i ] ; }
3,955
CWE-000 FREE_FUNC ( mod_setenv_free ) { plugin_data * p = p_d ; UNUSED ( srv ) ; if ( ! p ) return HANDLER_GO_ON ; if ( p -> config_storage ) { size_t i ; for ( i = 0 ; i < srv -> config_context -> used ; i ++ ) { plugin_config * s = p -> config_storage [ i ] ; if ( NULL == s ) continue ; array_free ( s -> request_header ) ; array_free ( s -> response_header ) ; array_free ( s -> environment ) ; <S2SV_StartBug> free ( s ) ; <S2SV_EndBug> } free ( p -> config_storage ) ; } free ( p ) ; return HANDLER_GO_ON ; }
<S2SV_ModStart> environment ) ; array_free ( s -> set_request_header ) ; array_free ( s -> set_response_header ) ; array_free ( s -> set_environment ) ;
3,956
CWE-000 void opt_init ( ) { printf ( "init\\n" ) ; pg_address = NULL ; ht = malloc ( PTRS_PER_PGDIR * sizeof ( struct hash_table ) ) ; for ( int i = 0 ; i < PTRS_PER_PGDIR ; i ++ ) { ht [ i ] . head = NULL ; } FILE * tfp ; if ( ( tfp = fopen ( tracefile , "r" ) ) == NULL ) { perror ( "Error<S2SV_blank>opening<S2SV_blank>tracefile:" ) ; exit ( 1 ) ; } char buf [ MAXLINE ] ; addr_t vaddr = 0 ; char type ; struct opt_page * pg = NULL ; struct page_time * pgt = NULL ; int time_count = 0 ; int index = 0 ; while ( fgets ( buf , MAXLINE , tfp ) != NULL ) { if ( buf [ 0 ] != '=' ) { sscanf ( buf , "%c<S2SV_blank>%lx" , & type , & vaddr ) ; struct linked_list * node = malloc ( sizeof ( struct linked_list ) ) ; node -> vaddr = vaddr ; node -> next = NULL ; <S2SV_StartBug> struct linked_list * curr_node = pg_address ; <S2SV_EndBug> struct linked_list * prev_node = NULL ; while ( curr_node != NULL ) { prev_node = curr_node ; curr_node = curr_node -> next ; } if ( prev_node == NULL ) { pg_address = node ; } else { prev_node -> next = node ; } unsigned int dir = PGDIR_INDEX ( vaddr ) ; pg = malloc ( sizeof ( struct opt_page ) ) ; pgt = malloc ( sizeof ( struct page_time ) ) ; pgt -> t = time_count ; pgt -> next_time = NULL ; struct opt_page * curr = ht [ dir ] . head ; int exist = 0 ; while ( curr != NULL && ! exist ) { if ( curr -> vaddr == vaddr ) { <S2SV_StartBug> printf ( "same\\n" ) ; <S2SV_EndBug> exist = 1 ; free ( pg ) ; add_new_time ( curr , pgt ) ; } curr = curr -> next_page ; } if ( ! exist ) { pg -> next_page = ht [ dir ] . head ; ht [ dir ] . head = pg ; pg -> vaddr = vaddr ; <S2SV_StartBug> pg -> start_time = NULL ; <S2SV_EndBug> <S2SV_StartBug> pg -> end_time = NULL ; <S2SV_EndBug> if ( index < memsize ) { <S2SV_StartBug> printf ( "%d.vaddr:<S2SV_blank>%lx<S2SV_blank>in<S2SV_blank>dir<S2SV_blank>%d<S2SV_blank>in<S2SV_blank>pg<S2SV_blank>%p\\n" , index , vaddr , dir , pg ) ; <S2SV_EndBug> coremap [ index ] . vaddr = vaddr ; } index ++ ; } time_count ++ ; } } printf ( "finished<S2SV_blank>init\\n" ) ; }
<S2SV_ModStart> = NULL ; if ( pg_address == NULL ) { pg_address = node ; last_vaddr = pg_address ; } else { last_vaddr -> next = node ; last_vaddr <S2SV_ModEnd> = node ; <S2SV_ModStart> vaddr ) { <S2SV_ModEnd> exist = 1 <S2SV_ModStart> -> start_time = pgt <S2SV_ModEnd> ; pg -> <S2SV_ModStart> -> end_time = pgt <S2SV_ModEnd> ; if ( <S2SV_ModStart> memsize ) { <S2SV_ModEnd> coremap [ index
3,957
CWE-000 CO_ReturnError_t CO_CANmodule_init ( CO_CANmodule_t * CANmodule , uint16_t CANbaseAddress , CO_CANrx_t rxArray [ ] , uint16_t rxSize , CO_CANtx_t txArray [ ] , uint16_t txSize , uint16_t CANbitRate ) { uint16_t i ; if ( CANmodule == NULL || rxArray == NULL || txArray == NULL ) { return CO_ERROR_ILLEGAL_ARGUMENT ; } CANmodule -> CANbaseAddress = CANbaseAddress ; CANmodule -> CANmsgBuffSize = 33 ; CANmodule -> rxArray = rxArray ; CANmodule -> rxSize = rxSize ; CANmodule -> txArray = txArray ; CANmodule -> txSize = txSize ; CANmodule -> CANnormal = false ; <S2SV_StartBug> CANmodule -> useCANrxFilters = ( rxSize <= 32U ) ? true : false ; <S2SV_EndBug> CANmodule -> bufferInhibitFlag = false ; CANmodule -> firstCANtxMessage = true ; CANmodule -> CANtxCount = 0U ; CANmodule -> errOld = 0U ; CANmodule -> em = NULL ; for ( i = 0U ; i < rxSize ; i ++ ) { rxArray [ i ] . ident = 0U ; rxArray [ i ] . pFunct = NULL ; } for ( i = 0U ; i < txSize ; i ++ ) { txArray [ i ] . bufferFull = false ; } if ( sizeof ( CO_CANrxMsg_t ) != 16 ) while ( 1 ) ; uint32_t * f = ( uint32_t * ) CANmodule -> CANmsgBuff ; for ( i = 0 ; i < ( CANmodule -> CANmsgBuffSize * 4 ) ; i ++ ) { * ( f ++ ) = 0 ; } CAN_REG ( CANbaseAddress , C_CON ) = 0x04108000 ; CAN_REG ( CANbaseAddress , C_FIFOBA ) = CO_KVA_TO_PA ( CANmodule -> CANmsgBuff ) ; <S2SV_StartBug> CAN_REG ( CANbaseAddress , C_FIFOCON ) = 0x001F0000 ; <S2SV_EndBug> CAN_REG ( CANbaseAddress , C_FIFOCON + 0x40 ) = 0x00000080 ; switch ( CANbitRate ) { case 10 : i = 0 ; break ; case 20 : i = 1 ; break ; case 50 : i = 2 ; break ; default : case 125 : i = 3 ; break ; case 250 : i = 4 ; break ; case 500 : i = 5 ; break ; case 800 : i = 6 ; break ; case 1000 : i = 7 ; break ; } CAN_REG ( CANbaseAddress , C_CFG ) = ( ( uint32_t ) ( CO_CANbitRateData [ i ] . phSeg2 - 1 ) ) << 16 | 0x00008000 | ( ( uint32_t ) ( CO_CANbitRateData [ i ] . phSeg1 - 1 ) ) << 11 | ( ( uint32_t ) ( CO_CANbitRateData [ i ] . PROP - 1 ) ) << 8 | ( ( uint32_t ) ( CO_CANbitRateData [ i ] . SJW - 1 ) ) << 6 | ( ( uint32_t ) ( CO_CANbitRateData [ i ] . BRP - 1 ) ) ; <S2SV_StartBug> for ( i = 0 ; i < 8 ; i ++ ) <S2SV_EndBug> CAN_REG ( CANbaseAddress , C_FLTCON + i * 0x10 ) = 0x00000000 ; if ( CANmodule -> useCANrxFilters ) { CAN_REG ( CANbaseAddress , C_RXM ) = 0xFFE80000 ; CAN_REG ( CANbaseAddress , C_RXM + 0x10 ) = 0xFFE80000 ; CAN_REG ( CANbaseAddress , C_RXM + 0x20 ) = 0xFFE80000 ; CAN_REG ( CANbaseAddress , C_RXM + 0x30 ) = 0xFFE80000 ; } else { CAN_REG ( CANbaseAddress , C_RXM ) = 0x00080000 ; CAN_REG ( CANbaseAddress , C_RXF ) = 0x00000000 ; CAN_REG ( CANbaseAddress , C_FLTCON ) = 0x00000080 ; } CAN_REG ( CANbaseAddress , C_FIFOINT ) = 0x00010000 ; CAN_REG ( CANbaseAddress , C_FIFOINT + 0x40 ) = 0x00000000 ; CAN_REG ( CANbaseAddress , C_INT ) = 0x00030000 ; return CO_ERROR_NO ; }
<S2SV_ModStart> ( rxSize <= NO_CAN_RXF <S2SV_ModEnd> ) ? true <S2SV_ModStart> C_FIFOCON ) = ( NO_CAN_RXF == 32 ) ? 0x001F0000 : 0x000F0000 <S2SV_ModEnd> ; CAN_REG ( <S2SV_ModStart> ; i < ( NO_CAN_RXF / 4 ) <S2SV_ModEnd> ; i ++
3,958
CWE-000 void * client_run ( void * client ) { struct client_info * client_inf = ( struct client_info * ) client ; int client_socket = client_inf -> socketnum ; fd_set socks ; FD_ZERO ( & socks ) ; FD_SET ( client_socket , & socks ) ; char * recieved = "Recieved<S2SV_blank>record." ; char * ack = "Recording" ; char * sorts = "Sorting" ; char * ret = "Returning" ; int condition = 0 ; int readvalue = 0 ; char buffer [ 7 ] ; int exit = 0 ; char filename [ 100 ] ; while ( exit == 0 ) { select ( client_socket + 1 , & socks , NULL , NULL , NULL ) ; buffer [ recv ( client_socket , buffer , 6 , 0 ) ] = '\\0' ; printf ( "buffer<S2SV_blank>\'%s\'\\n" , buffer ) ; if ( ! strcmp ( buffer , "record" ) ) { condition = 0 ; while ( condition == 0 ) { send ( client_socket , ack , strlen ( ack ) , 0 ) ; int headerLength ; int messageLength ; char * tempRec ; headerLength = headerDigitCount ( client_socket , socks ) ; if ( headerLength <= 0 ) { condition = - 1 ; exit = 1 ; } else { messageLength = byteCount ( client_socket , headerLength , socks ) ; tempRec = malloc ( sizeof ( char ) * messageLength ) ; getRecord ( tempRec , client_socket , messageLength , socks ) ; puts ( "got<S2SV_blank>record" ) ; send ( client_socket , recieved , strlen ( recieved ) , 0 ) ; if ( ! parse_line ( tempRec ) ) { ctotal ++ ; } } } } else if ( ! strcmp ( buffer , "sort" ) ) { puts ( "sort" ) ; char * sF_buffer = ( char * ) malloc ( sizeof ( char ) * 4 ) ; int receive_sF = recv ( client_socket , sF_buffer , 4 , 0 ) ; int sF ; if ( receive_sF > 0 ) { sF = atoi ( sF_buffer ) ; } else { printf ( "error<S2SV_blank>getting<S2SV_blank>the<S2SV_blank>sorting<S2SV_blank>field.\\n" ) ; } send ( client_socket , sorts , strlen ( sorts ) , 0 ) ; quickSort ( records , 0 , ctotal , sF ) ; char * n = "\\n" ; char buffer [ 4 ] ; strcpy ( filename , "file" ) ; printf ( "%s\\n" , filename ) ; sprintf ( buffer , "%d" , sF ) ; strcat ( filename , buffer ) ; printf ( "New<S2SV_blank>filename:<S2SV_blank>%s\\n" , filename ) ; FILE * nf ; nf = fopen ( filename , "w+" ) ; if ( nf != 0 ) { printf ( "Error<S2SV_blank>creating<S2SV_blank>file<S2SV_blank>for<S2SV_blank>storing<S2SV_blank>sorted<S2SV_blank>results!\\n" ) ; } strcpy ( fnames [ fcount ] . name , filename ) ; fcount ++ ; pthread_mutex_lock ( & lock ) ; print2file ( nf , records , ctotal ) ; fprintf ( nf , "%s" , n ) ; pthread_mutex_unlock ( & lock ) ; fclose ( nf ) ; } else if ( ! strcmp ( buffer , "return" ) ) { puts ( "return" ) ; char * buffer = malloc ( sizeof ( char ) * 1000 ) ; if ( ! buffer ) { return 0 ; } send ( client_socket , ret , strlen ( ret ) , 0 ) ; FILE * reader ; reader = fopen ( filename , "r" ) ; if ( reader ) { char * buffer = malloc ( sizeof ( char ) * 1000 ) ; if ( ! buffer ) { return 0 ; } char * message ; size_t s = 999 ; reader = fopen ( "test.csv" , "r" ) ; if ( reader ) { int size ; size = getline ( & buffer , & s , reader ) - 3 ; char buff [ 9 ] ; while ( size > 0 ) { size = getline ( & buffer , & s , reader ) - 3 ; int digit = getHeaderCount ( size ) ; if ( digit > 0 ) { message = ( char * ) malloc ( sizeof ( char ) * ( size + digit - 2 ) ) ; sprintf ( buff , "%d" , digit ) ; strcpy ( message , buff ) ; strcat ( message , "@" ) ; sprintf ( buff , "%d" , size - 3 ) ; strcat ( message , buff ) ; strcat ( message , buffer ) ; } else { message = "0@" ; } send ( client_socket , message , strlen ( message ) , 0 ) ; } fclose ( reader ) ; } fclose ( reader ) ; } else { printf ( "Error<S2SV_blank>file<S2SV_blank>DNE" ) ; } exit = 1 ; } else { puts ( buffer ) ; exit = 1 ; } } <S2SV_StartBug> close ( client_socket ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> ; } } Print ( records , ctotal ) ;
3,959
CWE-000 <S2SV_StartBug> void obd_sysctl_init ( void ) <S2SV_EndBug> { # ifdef CONFIG_SYSCTL if ( ! obd_table_header ) obd_table_header = register_sysctl_table ( parent_table ) ; # endif <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> obd_sysctl_init ( void <S2SV_ModStart> ; # endif return sysfs_create_group ( lustre_kobj , & lustre_attr_group ) ;
3,960
CWE-000 static ssize_t raid5_store_group_thread_cnt ( struct mddev * mddev , const char * page , size_t len ) { struct r5conf * conf ; <S2SV_StartBug> unsigned long new ; <S2SV_EndBug> int err ; struct r5worker_group * new_groups , * old_groups ; int group_cnt , worker_cnt_per_group ; if ( len >= PAGE_SIZE ) return - EINVAL ; <S2SV_StartBug> if ( kstrtoul ( page , 10 , & new ) ) <S2SV_EndBug> return - EINVAL ; err = mddev_lock ( mddev ) ; if ( err ) return err ; conf = mddev -> private ; if ( ! conf ) err = - ENODEV ; else if ( new != conf -> worker_cnt_per_group ) { mddev_suspend ( mddev ) ; old_groups = conf -> worker_groups ; if ( old_groups ) flush_workqueue ( raid5_wq ) ; err = alloc_thread_groups ( conf , new , & group_cnt , & worker_cnt_per_group , & new_groups ) ; if ( ! err ) { spin_lock_irq ( & conf -> device_lock ) ; conf -> group_cnt = group_cnt ; conf -> worker_cnt_per_group = worker_cnt_per_group ; conf -> worker_groups = new_groups ; spin_unlock_irq ( & conf -> device_lock ) ; if ( old_groups ) kfree ( old_groups [ 0 ] . workers ) ; kfree ( old_groups ) ; } mddev_resume ( mddev ) ; } mddev_unlock ( mddev ) ; return err ? : len ; }
<S2SV_ModStart> conf ; unsigned int <S2SV_ModEnd> new ; int <S2SV_ModStart> ; if ( kstrtouint <S2SV_ModEnd> ( page , <S2SV_ModStart> & new ) ) return - EINVAL ; if ( new > 8192
3,961
CWE-000 static ssize_t rt700_index_cmd_show ( struct device * dev , struct device_attribute * attr , char * buf ) { struct rt700_priv * rt700 = dev_get_drvdata ( dev ) ; <S2SV_StartBug> unsigned int sdw_addr_h , sdw_addr_l ; <S2SV_EndBug> unsigned int sdw_data_3 , sdw_data_2 , sdw_data_1 , sdw_data_0 ; int i , cnt = 0 ; for ( i = 0 ; i <= 0xa0 ; i ++ ) { rt700_index_read ( rt700 -> regmap , i , & sdw_data_0 ) ; cnt += snprintf ( buf + cnt , 12 , "%02x<S2SV_blank>=<S2SV_blank>%04x\\n" , i , sdw_data_0 ) ; } if ( cnt >= PAGE_SIZE ) cnt = PAGE_SIZE - 1 ; return cnt ; }
<S2SV_ModStart> ; unsigned int <S2SV_ModEnd> sdw_data_0 ; int
3,962
CWE-000 static xmlChar * xmlSecCryptoDLLibraryConstructGetFunctionsName ( const xmlChar * name ) { <S2SV_StartBug> static xmlChar tmpl [ ] = "xmlSecCryptoGetFunctions_%s" ; <S2SV_EndBug> xmlChar * res ; <S2SV_StartBug> int len ; <S2SV_EndBug> xmlSecAssert2 ( name != NULL , NULL ) ; <S2SV_StartBug> len = xmlStrlen ( name ) + xmlStrlen ( tmpl ) + 1 ; <S2SV_EndBug> res = ( xmlChar * ) xmlMalloc ( len + 1 ) ; if ( res == NULL ) { xmlSecMallocError ( len + 1 , NULL ) ; return ( NULL ) ; } <S2SV_StartBug> xmlSecStrPrintf ( res , len , tmpl , name ) ; <S2SV_EndBug> <S2SV_StartBug> return ( res ) ; <S2SV_EndBug> }
<S2SV_ModStart> ) { static char <S2SV_ModEnd> tmpl [ ] <S2SV_ModStart> ; int len ; int ret <S2SV_ModStart> name ) + strlen <S2SV_ModEnd> ( tmpl ) <S2SV_ModStart> ) ; } ret = xmlStrPrintf <S2SV_ModEnd> ( res , <S2SV_ModStart> name ) ; if ( ret < 0 ) { xmlSecXmlError ( "xmlStrPrintf" , NULL ) ; xmlFree ( res ) ; return ( NULL ) ; }
3,963
CWE-000 static int __change_page_attr_set_clr ( struct cpa_data * cpa , int checkalias ) { int ret , numpages = cpa -> numpages ; while ( numpages ) { cpa -> numpages = numpages ; if ( cpa -> flags & ( CPA_ARRAY | CPA_PAGES_ARRAY ) ) cpa -> numpages = 1 ; if ( ! debug_pagealloc ) spin_lock ( & cpa_lock ) ; ret = __change_page_attr ( cpa , checkalias ) ; if ( ! debug_pagealloc ) spin_unlock ( & cpa_lock ) ; if ( ret ) return ret ; if ( checkalias ) { ret = cpa_process_alias ( cpa ) ; if ( ret ) return ret ; } <S2SV_StartBug> BUG_ON ( cpa -> numpages > numpages ) ; <S2SV_EndBug> numpages -= cpa -> numpages ; if ( cpa -> flags & ( CPA_PAGES_ARRAY | CPA_ARRAY ) ) cpa -> curpage ++ ; else * cpa -> vaddr += cpa -> numpages * PAGE_SIZE ; } return 0 ; }
<S2SV_ModStart> numpages > numpages || ! cpa -> numpages
3,964
CWE-000 static void window_menu_plugin_menu ( GtkWidget * button , WindowMenuPlugin * plugin ) { GtkWidget * menu ; panel_return_if_fail ( XFCE_IS_WINDOW_MENU_PLUGIN ( plugin ) ) ; panel_return_if_fail ( button == NULL || plugin -> button == button ) ; if ( button != NULL && ! gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( button ) ) ) return ; menu = window_menu_plugin_menu_new ( plugin ) ; g_signal_connect ( G_OBJECT ( menu ) , "deactivate" , G_CALLBACK ( window_menu_plugin_menu_selection_done ) , button ) ; # if GTK_CHECK_VERSION ( 3 , 22 , 0 ) gtk_menu_popup_at_widget ( GTK_MENU ( menu ) , button , <S2SV_StartBug> GDK_GRAVITY_SOUTH , <S2SV_EndBug> GDK_GRAVITY_NORTH_WEST , NULL ) ; # else gtk_menu_popup ( GTK_MENU ( menu ) , NULL , NULL , button != NULL ? xfce_panel_plugin_position_menu : NULL , plugin , 1 , gtk_get_current_event_time ( ) ) ; # endif }
<S2SV_ModStart> , button , xfce_panel_plugin_get_orientation ( XFCE_PANEL_PLUGIN ( plugin ) ) == GTK_ORIENTATION_VERTICAL ? GDK_GRAVITY_WEST : GDK_GRAVITY_NORTH , xfce_panel_plugin_get_orientation ( XFCE_PANEL_PLUGIN ( plugin ) ) == GTK_ORIENTATION_VERTICAL ? GDK_GRAVITY_EAST : GDK_GRAVITY_SOUTH <S2SV_ModEnd> , NULL )
3,965
CWE-000 int xdag_initialize_mining ( int pool_on , const char * pool_arg , const char * miner_address ) { <S2SV_StartBug> pthread_t th ; <S2SV_EndBug> int res ; g_xdag_pool = pool_on ; g_miner_address = miner_address ; for ( int i = 0 ; i < 2 ; ++ i ) { g_xdag_pool_task [ i ] . ctx0 = malloc ( xdag_hash_ctx_size ( ) ) ; g_xdag_pool_task [ i ] . ctx = malloc ( xdag_hash_ctx_size ( ) ) ; if ( ! g_xdag_pool_task [ i ] . ctx0 || ! g_xdag_pool_task [ i ] . ctx ) { return - 1 ; } } if ( ! pool_on && ! pool_arg ) return 0 ; if ( crypt_start ( ) ) return - 1 ; if ( ! pool_on ) { return xdag_initialize_miner ( pool_arg ) ; } else { return xdag_initialize_pool ( pool_arg ) ; } }
<S2SV_ModStart> miner_address ) { <S2SV_ModEnd> g_miner_address = miner_address
3,966
CWE-000 static bool _reg_perfcount_get_instance_info ( struct PERF_INSTANCE_DEFINITION * inst , TALLOC_CTX * mem_ctx , int instId , struct PERF_OBJECT_TYPE * obj , TDB_CONTEXT * names ) { TDB_DATA key , data ; <S2SV_StartBug> char buf [ PERFCOUNT_MAX_LEN ] , temp [ PERFCOUNT_MAX_LEN ] ; <S2SV_EndBug> smb_ucs2_t * name = NULL ; int pad ; <S2SV_StartBug> memset ( temp , 0 , PERFCOUNT_MAX_LEN ) ; <S2SV_EndBug> snprintf ( temp , PERFCOUNT_MAX_LEN , "i%d" , instId ) ; _reg_perfcount_make_key ( & key , buf , PERFCOUNT_MAX_LEN , obj -> ObjectNameTitleIndex , temp ) ; if ( ! _reg_perfcount_get_counter_data ( key , & data ) ) { DEBUG ( 3 , ( "_reg_perfcount_get_counter_data<S2SV_blank>failed\\n" ) ) ; return false ; } if ( data . dptr == NULL ) { DEBUG ( 3 , ( "_reg_perfcount_get_instance_info:<S2SV_blank>No<S2SV_blank>instance<S2SV_blank>data<S2SV_blank>for<S2SV_blank>instance<S2SV_blank>[%s].\\n" , buf ) ) ; return False ; } inst -> counter_data . ByteLength = data . dsize + sizeof ( inst -> counter_data . ByteLength ) ; inst -> counter_data . data = talloc_realloc ( mem_ctx , inst -> counter_data . data , uint8_t , data . dsize ) ; if ( inst -> counter_data . data == NULL ) return False ; memset ( inst -> counter_data . data , 0 , data . dsize ) ; memcpy ( inst -> counter_data . data , data . dptr , data . dsize ) ; SAFE_FREE ( data . dptr ) ; <S2SV_StartBug> memset ( temp , 0 , PERFCOUNT_MAX_LEN ) ; <S2SV_EndBug> snprintf ( temp , PERFCOUNT_MAX_LEN , "i%dname" , instId ) ; _reg_perfcount_make_key ( & key , buf , PERFCOUNT_MAX_LEN , obj -> ObjectNameTitleIndex , temp ) ; data = tdb_fetch ( names , key ) ; if ( data . dptr == NULL ) { DEBUG ( 3 , ( "_reg_perfcount_get_instance_info:<S2SV_blank>No<S2SV_blank>instance<S2SV_blank>name<S2SV_blank>for<S2SV_blank>instance<S2SV_blank>[%s].\\n" , buf ) ) ; inst -> NameLength = 0 ; } else { memset ( buf , 0 , PERFCOUNT_MAX_LEN ) ; memcpy ( buf , data . dptr , MIN ( PERFCOUNT_MAX_LEN - 1 , data . dsize ) ) ; buf [ PERFCOUNT_MAX_LEN - 1 ] = '\\0' ; inst -> NameLength = rpcstr_push_talloc ( mem_ctx , & name , buf ) ; if ( inst -> NameLength == ( uint32_t ) - 1 || ! name ) { SAFE_FREE ( data . dptr ) ; return False ; } inst -> data = talloc_realloc ( mem_ctx , inst -> data , uint8_t , inst -> NameLength ) ; if ( inst -> data == NULL ) { SAFE_FREE ( data . dptr ) ; return False ; } memcpy ( inst -> data , name , inst -> NameLength ) ; SAFE_FREE ( data . dptr ) ; } inst -> ParentObjectTitleIndex = 0 ; inst -> ParentObjectTitlePointer = 0 ; inst -> UniqueID = PERF_NO_UNIQUE_ID ; inst -> NameOffset = 6 * sizeof ( uint32_t ) ; inst -> ByteLength = inst -> NameOffset + inst -> NameLength ; if ( ( pad = ( inst -> ByteLength % 8 ) ) ) { pad = 8 - pad ; inst -> data = talloc_realloc ( mem_ctx , inst -> data , uint8_t , inst -> NameLength + pad ) ; memset ( inst -> data + inst -> NameLength , 0 , pad ) ; inst -> ByteLength += pad ; } return True ; }
<S2SV_ModStart> [ PERFCOUNT_MAX_LEN ] = { 0 } ; char temp [ 32 ] = { 0 } <S2SV_ModEnd> ; smb_ucs2_t * <S2SV_ModStart> int pad ; snprintf <S2SV_ModEnd> ( temp , <S2SV_ModStart> ( temp , sizeof ( temp ) <S2SV_ModEnd> , "i%d" , <S2SV_ModStart> dptr ) ; snprintf <S2SV_ModEnd> ( temp , <S2SV_ModStart> ( temp , sizeof ( temp ) <S2SV_ModEnd> , "i%dname" ,
3,967
CWE-000 tSirRetStatus lim_p2p_oper_chan_change_confirm_action_frame ( tpAniSirGlobal mac_ctx , tSirMacAddr peer , tpPESession session_entry ) { tDot11fp2p_oper_chan_change_confirm frm ; uint8_t * frame ; tpSirMacMgmtHdr mac_hdr ; uint32_t num_bytes , n_payload , status ; void * packet ; QDF_STATUS qdf_status ; uint8_t tx_flag = 0 ; uint8_t sme_session_id = 0 ; if ( session_entry == NULL ) { lim_log ( mac_ctx , LOGE , FL ( "Session<S2SV_blank>entry<S2SV_blank>is<S2SV_blank>NULL!!!" ) ) ; return eSIR_FAILURE ; } sme_session_id = session_entry -> smeSessionId ; qdf_mem_set ( & frm , sizeof ( frm ) , 0 ) ; frm . Category . category = SIR_MAC_ACTION_VENDOR_SPECIFIC_CATEGORY ; qdf_mem_copy ( frm . p2p_action_oui . oui_data , SIR_MAC_P2P_OUI , SIR_MAC_P2P_OUI_SIZE ) ; frm . p2p_action_subtype . subtype = 0x04 ; frm . DialogToken . token = 0x0 ; if ( session_entry -> htCapability ) { lim_log ( mac_ctx , LOG1 , FL ( "Populate<S2SV_blank>HT<S2SV_blank>Caps<S2SV_blank>in<S2SV_blank>Assoc<S2SV_blank>Request" ) ) ; populate_dot11f_ht_caps ( mac_ctx , session_entry , & frm . HTCaps ) ; } if ( session_entry -> vhtCapability ) { lim_log ( mac_ctx , LOG1 , FL ( "Populate<S2SV_blank>VHT<S2SV_blank>Caps<S2SV_blank>in<S2SV_blank>Assoc<S2SV_blank>Request" ) ) ; populate_dot11f_vht_caps ( mac_ctx , session_entry , & frm . VHTCaps ) ; populate_dot11f_operating_mode ( mac_ctx , & frm . OperatingMode , session_entry ) ; } status = dot11f_get_packed_p2p_oper_chan_change_confirmSize ( mac_ctx , & frm , & n_payload ) ; if ( DOT11F_FAILED ( status ) ) { lim_log ( mac_ctx , LOGP , FL ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>packed<S2SV_blank>size<S2SV_blank>0x%08x." ) , status ) ; n_payload = sizeof ( tDot11fp2p_oper_chan_change_confirm ) ; } else if ( DOT11F_WARNED ( status ) ) { lim_log ( mac_ctx , LOGW , FL ( "There<S2SV_blank>were<S2SV_blank>warnings<S2SV_blank>while<S2SV_blank>calculating<S2SV_blank>the<S2SV_blank>packed<S2SV_blank>size<S2SV_blank>(0x%08x)." ) , status ) ; } num_bytes = n_payload + sizeof ( tSirMacMgmtHdr ) ; qdf_status = cds_packet_alloc ( ( uint16_t ) num_bytes , ( void * * ) & frame , ( void * * ) & packet ) ; if ( ! QDF_IS_STATUS_SUCCESS ( qdf_status ) ) { lim_log ( mac_ctx , LOGP , FL ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes." ) , num_bytes ) ; return eSIR_FAILURE ; } qdf_mem_set ( frame , num_bytes , 0 ) ; lim_populate_mac_header ( mac_ctx , frame , SIR_MAC_MGMT_FRAME , SIR_MAC_MGMT_ACTION , peer , session_entry -> selfMacAddr ) ; mac_hdr = ( tpSirMacMgmtHdr ) frame ; qdf_mem_copy ( ( uint8_t * ) mac_hdr -> bssId , ( uint8_t * ) session_entry -> bssId , sizeof ( tSirMacAddr ) ) ; status = dot11f_pack_p2p_oper_chan_change_confirm ( mac_ctx , & frm , frame + sizeof ( tSirMacMgmtHdr ) , n_payload , & n_payload ) ; if ( DOT11F_FAILED ( status ) ) { lim_log ( mac_ctx , LOGE , FL ( "Failed<S2SV_blank>to<S2SV_blank>pack<S2SV_blank>0x%08x." ) , status ) ; cds_packet_free ( ( void * ) packet ) ; return eSIR_FAILURE ; } else if ( DOT11F_WARNED ( status ) ) { lim_log ( mac_ctx , LOGW , FL ( "There<S2SV_blank>were<S2SV_blank>warnings<S2SV_blank>while<S2SV_blank>packing<S2SV_blank>0x%08x." ) , status ) ; } if ( ( SIR_BAND_5_GHZ == lim_get_rf_band ( session_entry -> currentOperChannel ) ) || ( session_entry -> pePersona == QDF_P2P_CLIENT_MODE ) || ( session_entry -> pePersona == QDF_P2P_GO_MODE ) ) { tx_flag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME ; } lim_log ( mac_ctx , LOG1 , FL ( "Send<S2SV_blank>frame<S2SV_blank>on<S2SV_blank>channel<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>mac<S2SV_blank>" MAC_ADDRESS_STR ) , session_entry -> currentOperChannel , MAC_ADDR_ARRAY ( peer ) ) ; MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_MGMT , session_entry -> peSessionId , mac_hdr -> fc . subType ) ) ; qdf_status = wma_tx_frameWithTxComplete ( mac_ctx , packet , ( uint16_t ) num_bytes , TXRX_FRM_802_11_MGMT , ANI_TXDIR_TODS , 7 , lim_tx_complete , frame , lim_oper_chan_change_confirm_tx_complete_cnf , <S2SV_StartBug> tx_flag , sme_session_id , false , 0 ) ; <S2SV_EndBug> MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_COMPLETE , session_entry -> peSessionId , qdf_status ) ) ; if ( ! QDF_IS_STATUS_SUCCESS ( qdf_status ) ) { lim_log ( mac_ctx , LOGE , FL ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>status<S2SV_blank>%X!" ) , qdf_status ) ; return eSIR_FAILURE ; } return eSIR_SUCCESS ; }
<S2SV_ModStart> false , 0 , RATEID_DEFAULT
3,968
CWE-000 static void draw_cursor ( struct dc_capture * capture , HDC hdc , HWND window ) { HICON icon ; ICONINFO ii ; CURSORINFO * ci = & capture -> ci ; POINT win_pos = { capture -> x , capture -> y } ; if ( ! ( capture -> ci . flags & CURSOR_SHOWING ) ) return ; icon = CopyIcon ( capture -> ci . hCursor ) ; if ( ! icon ) return ; if ( GetIconInfo ( icon , & ii ) ) { POINT pos ; if ( window ) ClientToScreen ( window , & win_pos ) ; pos . x = ci -> ptScreenPos . x - ( int ) ii . xHotspot - win_pos . x ; pos . y = ci -> ptScreenPos . y - ( int ) ii . yHotspot - win_pos . y ; <S2SV_StartBug> DrawIcon ( hdc , pos . x , pos . y , icon ) ; <S2SV_EndBug> DeleteObject ( ii . hbmColor ) ; DeleteObject ( ii . hbmMask ) ; } DestroyIcon ( icon ) ; }
<S2SV_ModStart> . y ; DrawIconEx <S2SV_ModEnd> ( hdc , <S2SV_ModStart> y , icon , 0 , 0 , 0 , NULL , DI_NORMAL
3,969
CWE-000 void printExtDateTime ( void ) { <S2SV_StartBug> if ( 0 == appData . i2c_current_time . mday && 0 == appData . i2c_current_time . mon && 0 == appData . i2c_current_time . year_s ) <S2SV_EndBug> { printf ( "--/--/----<S2SV_blank>--:--:--" ) ; } else { printf ( "%02u/%02u/20%02u<S2SV_blank>%02u:%02u:%02u" , appData . i2c_current_time . mday , appData . i2c_current_time . mon , appData . i2c_current_time . year_s , appData . i2c_current_time . hour , appData . i2c_current_time . min , appData . i2c_current_time . sec ) ; } }
<S2SV_ModStart> void ) { if ( 0 == APP_I2CMasterSeeksSlaveDevice ( DS3231_I2C_ADDR , DS3231_I2C_ADDR ) ) { printf ( "--/--/----<S2SV_blank>--:--:--" ) ; } else
3,970
CWE-000 void get_key_event ( int c ) { <S2SV_StartBug> pthread_mutex_lock ( & locInfo ) ; <S2SV_EndBug> if ( c > 0 ) -- current . x ; switch ( c ) { case KEY_MOVE_LEFT : shape_move ( - EXP_FACT ) ; break ; case KEY_MOVE_RIGHT : shape_move ( EXP_FACT ) ; break ; case KEY_MOVE_DOWN : ++ current . x ; ++ score ; DRAW_SCORE ( ) ; break ; case KEY_CHANGE_POSITION_NEXT : shape_set_position ( N_POS ) ; break ; case KEY_DROP_SHAPE : shape_drop ( ) ; break ; case KEY_PAUSE : while ( getchar ( ) != KEY_PAUSE ) ; break ; case KEY_QUIT : running = False ; break ; case 'Q' : running = False ; break ; case 'r' : if ( lifes != 0 ) revive ( ) ; break ; } pthread_mutex_unlock ( & locInfo ) ; return ; }
<S2SV_ModStart> & locInfo ) <S2SV_ModEnd> ; switch (
3,971
CWE-000 int buddy_write_packet ( hid_device * handle , unsigned char * buffer , int length ) { static int count = 0 ; int res ; res = hid_write ( handle , buffer , length ) ; if ( res < 0 ) { printf ( "buddy_write_packet:<S2SV_blank>hid_write<S2SV_blank>call<S2SV_blank>failed,<S2SV_blank>error<S2SV_blank>=<S2SV_blank>%ls<S2SV_blank>handle<S2SV_blank>=<S2SV_blank>%p\\n" , hid_error ( handle ) , handle ) ; return BUDDY_ERROR_GENERAL ; } else { <S2SV_StartBug> printf ( "buddy_write_packet<S2SV_blank>successful,<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%d\\n" , count ++ ) ; <S2SV_EndBug> } return BUDDY_ERROR_OK ; }
<S2SV_ModStart> } else { <S2SV_ModEnd> } return BUDDY_ERROR_OK
3,972
CWE-000 int main ( void ) { sysclk_init ( ) ; board_init ( ) ; SCB_DisableDCache ( ) ; InitHardware ( ) ; while ( 1 ) { char * pcBuffer ; while ( ! cNewDataReceved ) { } ; cNewDataReceved = 0 ; pcBuffer = ( char * ) memchr ( ( void * ) acRxBuffer , SYNC_CHAR , BUFFER_SIZE ) + 1 ; if ( pcBuffer && ! memcmp ( acTxBuffer + SYNC_SEQ_LEN , pcBuffer , BUFFER_SIZE - SYNC_SEQ_LEN ) ) { cLastRxSuccess = 1 ; ioport_set_pin_level ( LED0_GPIO , LED0_ACTIVE_LEVEL ) ; } else { cLastRxSuccess = 0 ; ioport_set_pin_level ( LED0_GPIO , LED0_INACTIVE_LEVEL ) ; } <S2SV_StartBug> { <S2SV_EndBug> uint32_t dummy ; usart_read ( USART1 , & dummy ) ; UNUSED ( dummy ) ; } memset ( ( void * ) acRxBuffer , 0 , BUFFER_SIZE ) ; xdmac_configure_transfer ( XDMAC , DMA_CHANNEL_RX , & stRxConfig ) ; xdmac_channel_enable ( XDMAC , DMA_CHANNEL_RX ) ; # if USB_ENABLE { unsigned int i ; <S2SV_StartBug> for ( i = 0 ; i < BUFFER_SIZE - 3 ; i ++ ) <S2SV_EndBug> { while ( ! udi_cdc_is_tx_ready ( ) ) { } ; if ( pcBuffer [ i ] != '\\0' ) { udi_cdc_putc ( pcBuffer [ i ] ) ; } } } # endif <S2SV_StartBug> } <S2SV_EndBug> return 1 ; }
<S2SV_ModStart> ) ; } <S2SV_ModEnd> # if USB_ENABLE <S2SV_ModStart> < BUFFER_SIZE - SYNC_SEQ_LEN <S2SV_ModEnd> ; i ++ <S2SV_ModStart> } # endif { uint32_t dummy ; usart_read ( USART1 , & dummy ) ; UNUSED ( dummy ) ; } memset ( ( void * ) acRxBuffer , 0 , BUFFER_SIZE ) ; xdmac_configure_transfer ( XDMAC , DMA_CHANNEL_RX , & stRxConfig ) ; xdmac_channel_enable ( XDMAC , DMA_CHANNEL_RX ) ;
3,973
CWE-000 static void bd_flush ( struct bufdomain * bd , struct bufqueue * bq ) { struct buf * bp ; BQ_ASSERT_LOCKED ( bq ) ; if ( bq != bd -> bd_cleanq ) { BD_LOCK ( bd ) ; while ( ( bp = TAILQ_FIRST ( & bq -> bq_queue ) ) != NULL ) { TAILQ_REMOVE ( & bq -> bq_queue , bp , b_freelist ) ; TAILQ_INSERT_TAIL ( & bd -> bd_cleanq -> bq_queue , bp , b_freelist ) ; <S2SV_StartBug> bp -> b_subqueue = mp_ncpus ; <S2SV_EndBug> } bd -> bd_cleanq -> bq_len += bq -> bq_len ; bq -> bq_len = 0 ; } if ( bd -> bd_wanted ) { bd -> bd_wanted = 0 ; wakeup ( & bd -> bd_wanted ) ; } if ( bq != bd -> bd_cleanq ) BD_UNLOCK ( bd ) ; }
<S2SV_ModStart> -> b_subqueue = bd -> bd_cleanq -> bq_subqueue <S2SV_ModEnd> ; } bd
3,974
CWE-000 void btc_to_bta_uuid ( tBT_UUID * p_dest , esp_bt_uuid_t * p_src ) { p_dest -> len = p_src -> len ; if ( p_src -> len == LEN_UUID_16 ) { p_dest -> uu . uuid16 = p_src -> uuid . uuid16 ; } else if ( p_src -> len == LEN_UUID_32 ) { p_dest -> uu . uuid32 = p_src -> uuid . uuid32 ; } else if ( p_src -> len == LEN_UUID_128 ) { memcpy ( & p_dest -> uu . uuid128 , p_src -> uuid . uuid128 , p_dest -> len ) ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> LOG_ERROR ( "%s<S2SV_blank>UUID<S2SV_blank>len<S2SV_blank>is<S2SV_blank>invalid<S2SV_blank>%d\\n" , __func__ , p_dest -> len ) ; <S2SV_EndBug> } }
<S2SV_ModStart> ; } else if ( p_src -> len == 0 ) { } else <S2SV_ModStart> , __func__ , p_src <S2SV_ModEnd> -> len )
3,975
CWE-000 static CborError encode_string ( CborEncoder * encoder , size_t length , uint8_t shiftedMajorType , const void * string ) { CborError err = encode_number ( encoder , length , shiftedMajorType ) ; <S2SV_StartBug> if ( err && ! isOomError ( err ) ) <S2SV_EndBug> return err ; return append_to_buffer ( encoder , string , length ) ; }
<S2SV_ModStart> ( err && <S2SV_ModEnd> isOomError ( err
3,976
CWE-000 long get_hex_value ( long row , long col , long slen ) { long return_value = 0 ; char tmp_str [ 82 ] ; if ( get_string ( tmp_str , row , col , slen ) ) { if ( strlen ( tmp_str ) <= 8 ) { <S2SV_StartBug> sscanf ( tmp_str , "%lx" , & return_value ) ; <S2SV_EndBug> } } return return_value ; }
<S2SV_ModStart> ( tmp_str , "%ld" <S2SV_ModEnd> , & return_value
3,977
CWE-000 static PyObject * Radare_plugin_bin ( Radare * self , PyObject * args ) { void * ptr = NULL ; PyObject * arglist = Py_BuildValue ( "(i)" , 0 ) ; PyObject * o = PyEval_CallObject ( args , arglist ) ; RBinPlugin * bp = R_NEW0 ( RBinPlugin ) ; bp -> name = getS ( o , "name" ) ; bp -> desc = getS ( o , "desc" ) ; bp -> license = getS ( o , "license" ) ; ptr = getF ( o , "load" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_load_cb = ptr ; bp -> load = py_load ; } ptr = getF ( o , "load_bytes" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_load_bytes_cb = ptr ; bp -> load_bytes = py_load_bytes ; } ptr = getF ( o , "destroy" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_destroy_cb = ptr ; bp -> destroy = py_destroy ; } ptr = getF ( o , "check_bytes" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_check_bytes_cb = ptr ; bp -> check_bytes = py_check_bytes ; } ptr = getF ( o , "baddr" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_baddr_cb = ptr ; bp -> baddr = py_baddr ; } ptr = getF ( o , "entries" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_entries_cb = ptr ; bp -> entries = py_entries ; } ptr = getF ( o , "sections" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_sections_cb = ptr ; bp -> sections = py_sections ; } ptr = getF ( o , "imports" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_imports_cb = ptr ; bp -> imports = py_imports ; } ptr = getF ( o , "symbols" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_symbols_cb = ptr ; bp -> symbols = py_symbols ; } ptr = getF ( o , "relocs" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_relocs_cb = ptr ; bp -> relocs = py_relocs ; } ptr = getF ( o , "binsym" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_binsym_cb = ptr ; bp -> binsym = py_binsym ; } ptr = getF ( o , "info" ) ; if ( ptr ) { Py_INCREF ( ptr ) ; py_info_cb = ptr ; bp -> info = py_info ; } RLibStruct * lp = R_NEW0 ( RLibStruct ) ; <S2SV_StartBug> lp -> type = R_LIB_TYPE_ANAL ; <S2SV_EndBug> lp -> data = bp ; r_lib_open_ptr ( core -> lib , "python.py" , NULL , lp ) ; return Py_True ; }
<S2SV_ModStart> -> type = R_LIB_TYPE_BIN <S2SV_ModEnd> ; lp ->
3,978
CWE-000 int wmain ( int argc , const wchar_t * * wargv ) { int i , maxlen , exit_status ; char * buffer , * * save ; const char * * argv ; # ifdef _MSC_VER # ifdef _DEBUG _CrtSetReportMode ( _CRT_ASSERT , _CRTDBG_MODE_DEBUG ) ; # endif # ifdef USE_MSVC_CRTDBG _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ) ; # endif # endif maybe_redirect_std_handles ( ) ; maxlen = wcslen ( wargv [ 0 ] ) ; for ( i = 1 ; i < argc ; i ++ ) maxlen = max ( maxlen , wcslen ( wargv [ i ] ) ) ; maxlen = 3 * maxlen + 1 ; buffer = malloc_startup ( maxlen ) ; ALLOC_ARRAY ( argv , argc + 1 ) ; ALLOC_ARRAY ( save , argc + 1 ) ; for ( i = 0 ; i < argc ; i ++ ) argv [ i ] = save [ i ] = wcstoutfdup_startup ( buffer , wargv [ i ] , maxlen ) ; argv [ i ] = save [ i ] = NULL ; free ( buffer ) ; setup_windows_environment ( ) ; unset_environment_variables = xstrdup ( "PERL5LIB" ) ; InitializeCriticalSection ( & pinfo_cs ) ; _fmode = _O_BINARY ; _setmode ( _fileno ( stdin ) , _O_BINARY ) ; _setmode ( _fileno ( stdout ) , _O_BINARY ) ; _setmode ( _fileno ( stderr ) , _O_BINARY ) ; winansi_init ( ) ; <S2SV_StartBug> exit_status = main ( argc , argv ) ; <S2SV_EndBug> for ( i = 0 ; i < argc ; i ++ ) free ( save [ i ] ) ; free ( save ) ; free ( argv ) ; return exit_status ; }
<S2SV_ModStart> ( ) ; current_directory_len = GetCurrentDirectoryW ( 0 , NULL ) ;
3,979
CWE-000 static void ecore_iov_send_response ( struct ecore_hwfn * p_hwfn , struct ecore_ptt * p_ptt , struct ecore_vf_info * p_vf , u16 length , u8 status ) { struct ecore_iov_vf_mbx * mbx = & p_vf -> vf_mbx ; struct ecore_dmae_params params ; u8 eng_vf_id ; mbx -> reply_virt -> default_resp . hdr . status = status ; ecore_dp_tlv_list ( p_hwfn , mbx -> reply_virt ) ; # ifdef CONFIG_ECORE_SW_CHANNEL mbx -> sw_mbx . response_size = length + sizeof ( struct channel_list_end_tlv ) ; if ( ! p_hwfn -> p_dev -> b_hw_channel ) return ; # endif eng_vf_id = p_vf -> abs_vf_id ; OSAL_MEMSET ( & params , 0 , sizeof ( struct ecore_dmae_params ) ) ; params . flags = ECORE_DMAE_FLAG_VF_DST ; params . dst_vfid = eng_vf_id ; ecore_dmae_host2host ( p_hwfn , p_ptt , mbx -> reply_phys + sizeof ( u64 ) , mbx -> req_virt -> first_tlv . reply_address + sizeof ( u64 ) , ( sizeof ( union pfvf_tlvs ) - sizeof ( u64 ) ) / 4 , & params ) ; <S2SV_StartBug> ecore_dmae_host2host ( p_hwfn , p_ptt , mbx -> reply_phys , <S2SV_EndBug> mbx -> req_virt -> first_tlv . reply_address , sizeof ( u64 ) / 4 , & params ) ; <S2SV_StartBug> REG_WR ( p_hwfn , <S2SV_EndBug> GTT_BAR0_MAP_REG_USDM_RAM + USTORM_VF_PF_CHANNEL_READY_OFFSET ( eng_vf_id ) , 1 ) ; }
<S2SV_ModStart> params ) ; REG_WR ( p_hwfn , GTT_BAR0_MAP_REG_USDM_RAM + USTORM_VF_PF_CHANNEL_READY_OFFSET ( eng_vf_id ) , 1 ) ; <S2SV_ModStart> params ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
3,980
CWE-000 int THCState_getCurrentStreamIndex ( THCState * state ) { THCStream * stream = THCState_getStream ( state ) ; <S2SV_StartBug> if ( ! stream ) { <S2SV_EndBug> return 0 ; } int device ; THCudaCheck ( cudaGetDevice ( & device ) ) ; THCCudaResourcesPerDevice * res = THCState_getDeviceResourcePtr ( state , device ) ; for ( int i = 0 ; i <= state -> numUserStreams ; ++ i ) { if ( res -> streams [ i ] == stream ) { return i ; } } return - 1 ; }
<S2SV_ModStart> state ) ; <S2SV_ModEnd> int device ;
3,981
CWE-000 void DrawCurrentColorGradient ( ) { <S2SV_StartBug> int i ; <S2SV_EndBug> dword hitch_color = system . color . work ; int hitch_x = b_color_gradient . x + lmax - 1 ; if ( lmax > b_color_gradient . w - 2 ) hitch_x = b_color_gradient . x + b_color_gradient . w - 3 ; for ( i = 0 ; i < b_color_gradient . w ; i ++ ) { DrawBar ( b_color_gradient . x + i , b_color_gradient . y , 1 , b_color_gradient . h , linear_gradient [ i ] ) ; } <S2SV_StartBug> DrawBar ( b_color_gradient . x - 1 , b_color_gradient . y - 2 , b_color_gradient . w + 4 , 2 , system . color . work ) ; <S2SV_EndBug> <S2SV_StartBug> if ( bg_dark ) hitch_color = 0xFFFfff ; else hitch_color = 0 ; <S2SV_EndBug> DrawBar ( hitch_x , b_color_gradient . y - 2 , 3 , 2 , hitch_color ) ; }
<S2SV_ModStart> { int i <S2SV_ModEnd> ; for ( <S2SV_ModStart> ) ; } DrawGradientMarker ( old_marker_pos <S2SV_ModEnd> , system . <S2SV_ModStart> work ) ; old_marker_pos = DrawGradientMarker ( lmax , 0xFFFfff * bg_dark <S2SV_ModEnd> ) ; }
3,982
CWE-000 <S2SV_StartBug> int notify_change2 ( struct vfsmount * mnt , struct dentry * dentry , struct iattr * attr ) <S2SV_EndBug> { struct inode * inode = dentry -> d_inode ; umode_t mode = inode -> i_mode ; int error ; struct timespec now ; unsigned int ia_valid = attr -> ia_valid ; WARN_ON_ONCE ( ! mutex_is_locked ( & inode -> i_mutex ) ) ; if ( ia_valid & ( ATTR_MODE | ATTR_UID | ATTR_GID | ATTR_TIMES_SET ) ) { if ( IS_IMMUTABLE ( inode ) || IS_APPEND ( inode ) ) return - EPERM ; } if ( ( ia_valid & ATTR_MODE ) ) { umode_t amode = attr -> ia_mode ; if ( is_sxid ( amode ) ) inode -> i_flags &= ~ S_NOSEC ; } now = current_fs_time ( inode -> i_sb ) ; attr -> ia_ctime = now ; if ( ! ( ia_valid & ATTR_ATIME_SET ) ) attr -> ia_atime = now ; if ( ! ( ia_valid & ATTR_MTIME_SET ) ) attr -> ia_mtime = now ; if ( ia_valid & ATTR_KILL_PRIV ) { attr -> ia_valid &= ~ ATTR_KILL_PRIV ; ia_valid &= ~ ATTR_KILL_PRIV ; error = security_inode_need_killpriv ( dentry ) ; if ( error > 0 ) error = security_inode_killpriv ( dentry ) ; if ( error ) return error ; } if ( ( ia_valid & ( ATTR_KILL_SUID | ATTR_KILL_SGID ) ) && ( ia_valid & ATTR_MODE ) ) BUG ( ) ; if ( ia_valid & ATTR_KILL_SUID ) { if ( mode & S_ISUID ) { ia_valid = attr -> ia_valid |= ATTR_MODE ; attr -> ia_mode = ( inode -> i_mode & ~ S_ISUID ) ; } } if ( ia_valid & ATTR_KILL_SGID ) { if ( ( mode & ( S_ISGID | S_IXGRP ) ) == ( S_ISGID | S_IXGRP ) ) { if ( ! ( ia_valid & ATTR_MODE ) ) { ia_valid = attr -> ia_valid |= ATTR_MODE ; attr -> ia_mode = inode -> i_mode ; } attr -> ia_mode &= ~ S_ISGID ; } } if ( ! ( attr -> ia_valid & ~ ( ATTR_KILL_SUID | ATTR_KILL_SGID ) ) ) return 0 ; error = security_inode_setattr ( dentry , attr ) ; if ( error ) return error ; error = try_break_deleg ( inode , delegated_inode ) ; if ( error ) return error ; if ( mnt && inode -> i_op -> setattr2 ) error = inode -> i_op -> setattr2 ( mnt , dentry , attr ) ; else if ( inode -> i_op -> setattr ) error = inode -> i_op -> setattr ( dentry , attr ) ; else error = simple_setattr ( dentry , attr ) ; if ( ! error ) { fsnotify_change ( dentry , ia_valid ) ; ima_inode_post_setattr ( dentry ) ; evm_inode_post_setattr ( dentry , ia_valid ) ; } return error ; }
<S2SV_ModStart> iattr * attr , struct inode * * delegated_inode
3,983
CWE-000 static int sysMapFD ( int fd , MemMapping * pMap ) { off_t start ; size_t length ; void * memPtr ; assert ( pMap != NULL ) ; if ( getFileStartAndLength ( fd , & start , & length ) < 0 ) return - 1 ; memPtr = mmap ( NULL , length , PROT_READ , MAP_PRIVATE , fd , start ) ; if ( memPtr == MAP_FAILED ) { LOGW ( "mmap(%d,<S2SV_blank>R,<S2SV_blank>PRIVATE,<S2SV_blank>%d,<S2SV_blank>%d)<S2SV_blank>failed:<S2SV_blank>%s\\n" , ( int ) length , fd , ( int ) start , strerror ( errno ) ) ; return - 1 ; } pMap -> addr = memPtr ; pMap -> length = length ; pMap -> range_count = 1 ; <S2SV_StartBug> pMap -> ranges = malloc ( sizeof ( MappedRange ) ) ; <S2SV_EndBug> pMap -> ranges [ 0 ] . addr = memPtr ; pMap -> ranges [ 0 ] . length = length ; return 0 ; }
<S2SV_ModStart> ) ) ; if ( pMap -> ranges == NULL ) { LOGE ( "malloc<S2SV_blank>failed:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; munmap ( memPtr , length ) ; return - 1 ; }
3,984
CWE-000 static void params_add ( struct wl_client * client , struct wl_resource * params_resource , int32_t fd , uint32_t plane_idx , uint32_t offset , uint32_t stride , uint32_t modifier_hi , uint32_t modifier_lo ) { struct wlr_dmabuf_buffer * buffer = wlr_dmabuf_buffer_from_params_resource ( params_resource ) ; if ( ! buffer ) { wl_resource_post_error ( params_resource , ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ALREADY_USED , "params<S2SV_blank>was<S2SV_blank>already<S2SV_blank>used<S2SV_blank>to<S2SV_blank>create<S2SV_blank>a<S2SV_blank>wl_buffer" ) ; close ( fd ) ; return ; } if ( plane_idx >= WLR_DMABUF_MAX_PLANES ) { wl_resource_post_error ( params_resource , ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX , "plane<S2SV_blank>index<S2SV_blank>%u<S2SV_blank>><S2SV_blank>%u" , plane_idx , WLR_DMABUF_MAX_PLANES ) ; close ( fd ) ; return ; } if ( buffer -> attributes . fd [ plane_idx ] != - 1 ) { wl_resource_post_error ( params_resource , ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET , "a<S2SV_blank>dmabuf<S2SV_blank>with<S2SV_blank>FD<S2SV_blank>%d<S2SV_blank>has<S2SV_blank>already<S2SV_blank>been<S2SV_blank>added<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%u" , buffer -> attributes . fd [ plane_idx ] , plane_idx ) ; close ( fd ) ; return ; } uint64_t modifier = ( ( uint64_t ) modifier_hi << 32 ) | modifier_lo ; if ( buffer -> has_modifier && modifier != buffer -> attributes . modifier ) { wl_resource_post_error ( params_resource , ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_FORMAT , <S2SV_StartBug> "sent<S2SV_blank>modifier<S2SV_blank>%lu<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%u,<S2SV_blank>expected<S2SV_blank>modifier<S2SV_blank>%lu<S2SV_blank>like<S2SV_blank>other<S2SV_blank>planes" , <S2SV_EndBug> modifier , plane_idx , buffer -> attributes . modifier ) ; close ( fd ) ; return ; } buffer -> attributes . modifier = modifier ; buffer -> has_modifier = true ; buffer -> attributes . fd [ plane_idx ] = fd ; buffer -> attributes . offset [ plane_idx ] = offset ; buffer -> attributes . stride [ plane_idx ] = stride ; buffer -> attributes . n_planes ++ ; }
<S2SV_ModStart> , ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_FORMAT , "sent<S2SV_blank>modifier<S2SV_blank>%" PRIu64 "<S2SV_blank>for<S2SV_blank>plane<S2SV_blank>%u,<S2SV_blank>expected" "<S2SV_blank>modifier<S2SV_blank>%" PRIu64 "<S2SV_blank>like<S2SV_blank>other<S2SV_blank>planes" <S2SV_ModEnd> , modifier ,
3,985
CWE-000 static int qexec_clear_analytic_function_list ( XASL_NODE * xasl_p , THREAD_ENTRY * thread_p , ANALYTIC_EVAL_TYPE * list , int final ) { ANALYTIC_EVAL_TYPE * e ; ANALYTIC_TYPE * p ; int pg_cnt ; pg_cnt = 0 ; for ( e = list ; e ; e = e -> next ) { for ( p = e -> head ; p ; p = p -> next ) { ( void ) pr_clear_value ( p -> value ) ; ( void ) pr_clear_value ( p -> value2 ) ; <S2SV_StartBug> } <S2SV_EndBug> } return pg_cnt ; }
<S2SV_ModStart> value2 ) ; p -> domain = p -> original_domain ; p -> opr_dbtype = p -> original_opr_dbtype ; pg_cnt += qexec_clear_regu_var ( xasl_p , & p -> operand , final ) ;
3,986
CWE-000 static struct page * __get_node_page ( struct f2fs_sb_info * sbi , pgoff_t nid , struct page * parent , int start ) { struct page * page ; int err ; if ( ! nid ) return ERR_PTR ( - ENOENT ) ; f2fs_bug_on ( sbi , check_nid_range ( sbi , nid ) ) ; repeat : page = f2fs_grab_cache_page ( NODE_MAPPING ( sbi ) , nid , false ) ; if ( ! page ) return ERR_PTR ( - ENOMEM ) ; err = read_node_page ( page , READ_SYNC ) ; if ( err < 0 ) { f2fs_put_page ( page , 1 ) ; return ERR_PTR ( err ) ; <S2SV_StartBug> } else if ( err == LOCKED_PAGE ) { <S2SV_EndBug> goto page_hit ; } if ( parent ) ra_node_pages ( parent , start + 1 , MAX_RA_NODE ) ; lock_page ( page ) ; if ( unlikely ( page -> mapping != NODE_MAPPING ( sbi ) ) ) { f2fs_put_page ( page , 1 ) ; goto repeat ; } <S2SV_StartBug> if ( unlikely ( ! PageUptodate ( page ) ) ) <S2SV_EndBug> goto out_err ; <S2SV_StartBug> page_hit : <S2SV_EndBug> if ( unlikely ( nid != nid_of_node ( page ) ) ) { <S2SV_StartBug> f2fs_bug_on ( sbi , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> ClearPageUptodate ( page ) ; <S2SV_EndBug> out_err : f2fs_put_page ( page , 1 ) ; <S2SV_StartBug> return ERR_PTR ( - EIO ) ; <S2SV_EndBug> } mark_page_accessed ( page ) ; return page ; }
<S2SV_ModStart> LOCKED_PAGE ) { err = 0 ; <S2SV_ModStart> ) ) ) { err = - EIO ; <S2SV_ModStart> goto out_err ; } <S2SV_ModStart> ) ) { f2fs_msg ( sbi -> sb , KERN_WARNING , "inconsistent<S2SV_blank>node<S2SV_blank>block,<S2SV_blank>" "nid:%lu,<S2SV_blank>node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]" , nid , nid_of_node ( page ) , ino_of_node ( page ) , ofs_of_node ( page ) , cpver_of_node ( page ) , next_blkaddr_of_node ( page ) <S2SV_ModEnd> ) ; ClearPageUptodate <S2SV_ModStart> ( page ) ; err = - EINVAL <S2SV_ModStart> return ERR_PTR ( err <S2SV_ModEnd> ) ; }
3,987
CWE-000 void process_packet ( const unsigned char * const buffer , const size_t bufsize , struct client * src ) { ( void ) ( buffer ) ; ( void ) ( bufsize ) ; if ( buffer [ 0 ] == ACK ) { pthread_mutex_lock ( & clientLock ) ; uint16_t ackVal ; memcpy ( & ackVal , buffer + 3 , sizeof ( uint16_t ) ) ; debug_print ( "\\nReceived<S2SV_blank>ack<S2SV_blank>packet<S2SV_blank>with<S2SV_blank>ack<S2SV_blank>value<S2SV_blank>%d\\n" , ackVal ) ; if ( ackVal == src -> seq ) { debug_print ( "\\nAck<S2SV_blank>value<S2SV_blank>is<S2SV_blank>good,<S2SV_blank>signalling<S2SV_blank>cv\\n\\n" ) ; ackReceived = true ; pthread_cond_broadcast ( & cv ) ; } else { debug_print ( "\\nAck<S2SV_blank>value<S2SV_blank>was<S2SV_blank>not<S2SV_blank>the<S2SV_blank>one<S2SV_blank>we<S2SV_blank>were<S2SV_blank>looking<S2SV_blank>for,<S2SV_blank>ignoring...\\n\\n" ) ; } pthread_mutex_unlock ( & clientLock ) ; } <S2SV_StartBug> uint16_t seqVal ; <S2SV_EndBug> memcpy ( & seqVal , buffer + 1 , sizeof ( uint16_t ) ) ; if ( seqVal <= src -> seq ) { debug_print ( "Got<S2SV_blank>duplicate<S2SV_blank>packet<S2SV_blank>with<S2SV_blank>%d\\n" , seqVal ) ; return ; } write ( outputFD , buffer + HEADER_SIZE - sizeof ( uint16_t ) , bufsize - HEADER_SIZE + sizeof ( uint16_t ) ) ; # ifndef NDEBUG printf ( "Received<S2SV_blank>packet<S2SV_blank>of<S2SV_blank>size<S2SV_blank>%zu\\n" , bufsize ) ; debug_print_buffer ( "Raw<S2SV_blank>hex<S2SV_blank>output:<S2SV_blank>" , buffer , bufsize ) ; printf ( "\\nText<S2SV_blank>output:<S2SV_blank>" ) ; for ( size_t i = 0 ; i < bufsize ; ++ i ) { printf ( "%c" , buffer [ i ] ) ; } printf ( "\\n" ) ; PacketType type = * buffer ; uint16_t seq = ( ( uint16_t * ) ( buffer + 1 ) ) [ 0 ] ; uint16_t ack = ( ( uint16_t * ) ( buffer + 1 ) ) [ 1 ] ; uint16_t winSize = ( ( uint16_t * ) ( buffer + 1 ) ) [ 2 ] ; printf ( "Packet<S2SV_blank>Control<S2SV_blank>Values:\\n" ) ; printf ( "Type:<S2SV_blank>%d\\nSeq:<S2SV_blank>%d\\nAck:<S2SV_blank>%d\\nWindow<S2SV_blank>Size:<S2SV_blank>%d\\n" , type , seq , ack , winSize ) ; printf ( "Packet<S2SV_blank>contents<S2SV_blank>stripped<S2SV_blank>of<S2SV_blank>headers:<S2SV_blank>" ) ; for ( size_t i = 0 ; i < bufsize - 7 ; ++ i ) { printf ( "%c" , buffer [ i + 7 ] ) ; } printf ( "\\n" ) ; # endif }
<S2SV_ModStart> ) ; } <S2SV_ModEnd> write ( outputFD
3,988
CWE-000 void defaultVector ( ) { uint32_t Maddr = 0 ; uint32_t Paddr = 0 ; uint32_t psr = 0 ; asm ( "mrs<S2SV_blank>%[ma],<S2SV_blank>msp\\n" "mrs<S2SV_blank>%[pa],<S2SV_blank>psp\\n" "mrs<S2SV_blank>%[psr],<S2SV_blank>psr\\n" : [ ma ] "=r" ( Maddr ) , [ pa ] "=r" ( Paddr ) , [ psr ] "=r" ( psr ) : : ) ; printf ( "---CRASH<S2SV_blank>DUMP---\\n" ) ; printf ( "PSR:<S2SV_blank>%x\\n" , psr ) ; printf ( "---MAIN<S2SV_blank>STACK---\\n" ) ; dumpHex ( ( uint8_t * ) Maddr , 100 ) ; <S2SV_StartBug> printf ( "---PROC<S2SV_blank>STACK---\\n" ) ; <S2SV_EndBug> dumpHex ( ( uint8_t * ) Paddr , 100 ) ; <S2SV_StartBug> printf ( "###CRASH<S2SV_blank>DUMP###\\n" ) ; <S2SV_EndBug> while ( 1 ) { sleep ( 1000 ) ; REG_PIOB_SODR |= PIO_PB27 ; sleep ( 1000 ) ; REG_PIOB_CODR |= PIO_PB27 ; } }
<S2SV_ModStart> 100 ) ; if ( Paddr > 0x20070000 && Paddr < 0x20089999 ) { <S2SV_ModStart> 100 ) ; } <S2SV_ModStart> printf ( "###CRASH<S2SV_blank>DUMP###\\n" ) ; dumpHex ( ( uint8_t * ) 0x20071b09 , 200
3,989
CWE-000 void motionnotify ( XEvent * e ) { static Monitor * mon = NULL ; Monitor * m ; XMotionEvent * ev = & e -> xmotion ; if ( ev -> window != root ) return ; m = recttomon ( ev -> x_root , ev -> y_root , 1 , 1 ) ; if ( m != mon && mon ) { unfocus ( selmon -> sel , 1 ) ; selmon = m ; <S2SV_StartBug> focus ( NULL ) ; <S2SV_EndBug> } mon = m ; }
<S2SV_ModStart> focus ( NULL , 0
3,990
CWE-000 static int compiler_annassign ( struct compiler * c , stmt_ty s ) { expr_ty targ = s -> v . AnnAssign . target ; PyObject * mangled ; assert ( s -> kind == AnnAssign_kind ) ; if ( s -> v . AnnAssign . value ) { VISIT ( c , expr , s -> v . AnnAssign . value ) ; VISIT ( c , expr , targ ) ; } switch ( targ -> kind ) { case Name_kind : if ( s -> v . AnnAssign . simple && ( c -> u -> u_scope_type == COMPILER_SCOPE_MODULE || c -> u -> u_scope_type == COMPILER_SCOPE_CLASS ) ) { <S2SV_StartBug> mangled = _Py_Mangle ( c -> u -> u_private , targ -> v . Name . id ) ; <S2SV_EndBug> if ( ! mangled ) { return 0 ; } <S2SV_StartBug> if ( c -> c_future -> ff_features & CO_FUTURE_ANNOTATIONS ) { <S2SV_EndBug> VISIT ( c , annexpr , s -> v . AnnAssign . annotation ) } else { VISIT ( c , expr , s -> v . AnnAssign . annotation ) ; } ADDOP_NAME ( c , LOAD_NAME , __annotations__ , names ) ; <S2SV_StartBug> ADDOP_O ( c , LOAD_CONST , mangled , consts ) ; <S2SV_EndBug> Py_DECREF ( mangled ) ; ADDOP ( c , STORE_SUBSCR ) ; } break ; case Attribute_kind : if ( ! s -> v . AnnAssign . value && ! check_ann_expr ( c , targ -> v . Attribute . value ) ) { return 0 ; } break ; case Subscript_kind : if ( ! s -> v . AnnAssign . value && ( ! check_ann_expr ( c , targ -> v . Subscript . value ) || ! check_ann_subscr ( c , targ -> v . Subscript . slice ) ) ) { return 0 ; } break ; default : PyErr_Format ( PyExc_SystemError , "invalid<S2SV_blank>node<S2SV_blank>type<S2SV_blank>(%d)<S2SV_blank>for<S2SV_blank>annotated<S2SV_blank>assignment" , targ -> kind ) ; return 0 ; } if ( ! s -> v . AnnAssign . simple && ! check_annotation ( c , s ) ) { return 0 ; } return 1 ; }
<S2SV_ModStart> ) ) { if ( c -> c_future -> ff_features & CO_FUTURE_ANNOTATIONS ) { VISIT ( c , annexpr , s -> v . AnnAssign . annotation ) } else { VISIT ( c , expr , s -> v . AnnAssign . annotation ) ; } ADDOP_NAME ( c , LOAD_NAME , __annotations__ , names ) ; <S2SV_ModStart> 0 ; } ADDOP_N <S2SV_ModEnd> ( c , <S2SV_ModStart> mangled , consts <S2SV_ModEnd> ) ; ADDOP
3,991
CWE-000 struct siw_qp * siw_qp_id2obj ( struct siw_dev * sdev , int id ) { struct siw_objhdr * obj = siw_get_obj ( & sdev -> qp_idr , id ) ; if ( obj ) { pr_debug ( DBG_OBJ "(QP%d):<S2SV_blank>New<S2SV_blank>refcount:<S2SV_blank>%d\\n" , <S2SV_StartBug> obj -> id , atomic_read ( & obj -> ref . refcount ) ) ; <S2SV_EndBug> return container_of ( obj , struct siw_qp , hdr ) ; } return NULL ; }
<S2SV_ModStart> -> id , kref_read <S2SV_ModEnd> ( & obj <S2SV_ModStart> obj -> ref <S2SV_ModEnd> ) ) ;
3,992
CWE-000 void orbit_vmInit ( OrbitVM * vm ) { OASSERT ( vm != NULL , "Null<S2SV_blank>instance<S2SV_blank>error" ) ; vm -> task = NULL ; vm -> gcHead = NULL ; vm -> allocated = 0 ; vm -> dispatchTable = orbit_gcMapNew ( vm ) ; vm -> classes = orbit_gcMapNew ( vm ) ; vm -> gcStackSize = 0 ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> = 0 ; orbit_registerStandardLib ( vm ) ;
3,993
CWE-000 static void linear_scan ( MVMThreadContext * tc , RegisterAllocator * alc , MVMJitTileList * list ) { <S2SV_StartBug> MVMint32 i , j ; <S2SV_EndBug> while ( alc -> worklist_num > 0 ) { MVMint32 v = live_range_heap_pop ( alc -> values , alc -> worklist , & alc -> worklist_num ) ; MVMint32 pos = first_ref ( alc -> values + v ) ; MVMint8 reg ; if ( live_range_is_empty ( alc -> values + v ) ) continue ; active_set_expire ( tc , alc , pos ) ; if ( MVM_JIT_REGISTER_HAS_REQUIREMENT ( alc -> values [ v ] . register_spec ) ) { reg = MVM_JIT_REGISTER_REQUIREMENT ( alc -> values [ v ] . register_spec ) ; if ( NVR_GPR_BITMAP & ( 1 << reg ) ) { assign_register ( tc , alc , list , v , MVM_JIT_STORAGE_NVR , reg ) ; } else { NYI ( general_purpose_register_spec ) ; } } else { while ( ( reg = get_register ( tc , alc , MVM_JIT_STORAGE_GPR ) ) < 0 ) { spill_register ( tc , alc , list , pos ) ; } assign_register ( tc , alc , list , v , MVM_JIT_STORAGE_GPR , reg ) ; active_set_add ( tc , alc , v ) ; } } active_set_expire ( tc , alc , list -> items_num + 1 ) ; }
<S2SV_ModStart> list ) { MVM_VECTOR_INIT ( alc -> retired , alc -> worklist_num ) <S2SV_ModEnd> ; while (
3,994
CWE-000 <S2SV_StartBug> void list_add_back ( const list_content value , const list_node * * list ) { <S2SV_EndBug> list_node * current_node = ( list_node * ) * ( list ) ; while ( current_node -> next ) { current_node = current_node -> next ; } list_node * new_node = list_create ( value ) ; if ( new_node ) { current_node -> next = new_node ; } }
<S2SV_ModStart> list_content value , <S2SV_ModEnd> list_node * *
3,995
CWE-000 bool listTSConfigs ( const char * pattern , bool verbose ) { PQExpBufferData buf ; PGresult * res ; printQueryOpt myopt = pset . popt ; if ( pset . sversion < 80300 ) { <S2SV_StartBug> psql_error ( "The<S2SV_blank>server<S2SV_blank>(version<S2SV_blank>%d.%d)<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>full<S2SV_blank>text<S2SV_blank>search.\\n" , <S2SV_EndBug> <S2SV_StartBug> pset . sversion / 10000 , ( pset . sversion / 100 ) % 100 ) ; <S2SV_EndBug> return true ; } if ( verbose ) return listTSConfigsVerbose ( pattern ) ; initPQExpBuffer ( & buf ) ; printfPQExpBuffer ( & buf , "SELECT<S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>n.nspname<S2SV_blank>as<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>c.cfgname<S2SV_blank>as<S2SV_blank>\\"%s\\",\\n" "<S2SV_blank><S2SV_blank><S2SV_blank>pg_catalog.obj_description(c.oid,<S2SV_blank>\'pg_ts_config\')<S2SV_blank>as<S2SV_blank>\\"%s\\"\\n" "FROM<S2SV_blank>pg_catalog.pg_ts_config<S2SV_blank>c\\n" "LEFT<S2SV_blank>JOIN<S2SV_blank>pg_catalog.pg_namespace<S2SV_blank>n<S2SV_blank>ON<S2SV_blank>n.oid<S2SV_blank>=<S2SV_blank>c.cfgnamespace<S2SV_blank>\\n" , gettext_noop ( "Schema" ) , gettext_noop ( "Name" ) , gettext_noop ( "Description" ) ) ; processSQLNamePattern ( pset . db , & buf , pattern , false , false , "n.nspname" , "c.cfgname" , NULL , "pg_catalog.pg_ts_config_is_visible(c.oid)" ) ; appendPQExpBufferStr ( & buf , "ORDER<S2SV_blank>BY<S2SV_blank>1,<S2SV_blank>2;" ) ; res = PSQLexec ( buf . data ) ; termPQExpBuffer ( & buf ) ; if ( ! res ) return false ; myopt . nullPrint = NULL ; myopt . title = _ ( "List<S2SV_blank>of<S2SV_blank>text<S2SV_blank>search<S2SV_blank>configurations" ) ; myopt . translate_header = true ; printQuery ( res , & myopt , pset . queryFout , false , pset . logfile ) ; PQclear ( res ) ; return true ; }
<S2SV_ModStart> 80300 ) { char sverbuf [ 32 ] ; psql_error ( "The<S2SV_blank>server<S2SV_blank>(version<S2SV_blank>%s)<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>full<S2SV_blank>text<S2SV_blank>search.\\n" , formatPGVersionNumber ( <S2SV_ModEnd> pset . sversion <S2SV_ModStart> pset . sversion , false , sverbuf , sizeof ( sverbuf ) ) <S2SV_ModEnd> ) ; return
3,996
CWE-000 static void ciaaMobile_sendSMS_f ( void ) { static uint8_t runState = 0 ; static uint8_t smsCmd [ 30 ] ; static uint8_t smsText [ 150 ] ; switch ( frmState ) { case INIT : smsCmd [ 0 ] = '\\0' ; smsText [ 0 ] = '\\0' ; strncat ( smsCmd , "AT+CMGS=\\"" , 9 ) ; strncat ( smsCmd , ( ( SMS_send * ) frmInput ) -> dest , strlen ( ( ( SMS_send * ) frmInput ) -> dest ) ) ; strncat ( smsCmd , "\\"\\r" , 2 ) ; strncpy ( smsText , ( ( SMS_send * ) frmInput ) -> text , strlen ( ( ( SMS_send * ) frmInput ) -> text ) ) ; smsText [ strlen ( ( ( SMS_send * ) frmInput ) -> text ) ] = '\\0' ; frmState = PROC ; dbgPrint ( "\\r\\nsmsCmd:<S2SV_blank>" ) ; dbgPrint ( smsCmd ) ; dbgPrint ( "\\nsmsText:<S2SV_blank>" ) ; dbgPrint ( smsText ) ; dbgPrint ( "\\r\\n" ) ; break ; case PROC : switch ( runState ) { case 0 : sendATcmd ( smsCmd ) ; runState = 1 ; break ; case 1 : <S2SV_StartBug> if ( cmdClosed == processToken ( ) ) { runState = 2 ; } <S2SV_EndBug> break ; case 2 : sendATcmd ( smsText ) ; runState = 3 ; break ; case 3 : <S2SV_StartBug> if ( cmdClosed == processToken ( ) ) { runState = 0 ; frmState = WRAP ; } <S2SV_EndBug> break ; } break ; case WRAP : frmCback ( 0 ) ; frmState = IDLE ; break ; } return ; }
<S2SV_ModStart> : if ( OK_CLOSE <S2SV_ModEnd> == processToken ( <S2SV_ModStart> : if ( OK_CLOSE <S2SV_ModEnd> == processToken (
3,997
CWE-000 static int uvc_video_alloc_requests ( struct uvc_video * video ) { unsigned int req_size ; unsigned int i ; int ret = - ENOMEM ; BUG_ON ( video -> req_size ) ; <S2SV_StartBug> req_size = video -> ep -> maxpacket <S2SV_EndBug> * max_t ( unsigned int , video -> ep -> maxburst , 1 ) <S2SV_StartBug> * ( video -> ep -> mult + 1 ) ; <S2SV_EndBug> for ( i = 0 ; i < UVC_NUM_REQUESTS ; ++ i ) { video -> req_buffer [ i ] = kmalloc ( req_size , GFP_KERNEL ) ; if ( video -> req_buffer [ i ] == NULL ) goto error ; video -> req [ i ] = usb_ep_alloc_request ( video -> ep , GFP_KERNEL ) ; if ( video -> req [ i ] == NULL ) goto error ; video -> req [ i ] -> buf = video -> req_buffer [ i ] ; video -> req [ i ] -> length = 0 ; video -> req [ i ] -> complete = uvc_video_complete ; video -> req [ i ] -> context = video ; list_add_tail ( & video -> req [ i ] -> list , & video -> req_free ) ; } video -> req_size = req_size ; return 0 ; error : uvc_video_free_requests ( video ) ; return ret ; }
<S2SV_ModStart> ; req_size = ( <S2SV_ModStart> ep -> maxpacket & 0x7FF ) <S2SV_ModStart> ) * ( max_t ( unsigned int , ( video -> ep -> maxpacket >> 11 ) & 0x3 , <S2SV_ModStart> ep -> mult )
3,998
CWE-000 static bool light_ctl_setunack ( struct bt_mesh_model * model , struct bt_mesh_msg_ctx * ctx , struct net_buf_simple * buf ) { u8_t tid ; <S2SV_StartBug> u16_t lightness , temp , delta_uv ; <S2SV_EndBug> struct net_buf_simple * msg = model -> pub -> msg ; struct light_ctl_state * state = model -> user_data ; lightness = net_buf_simple_pull_le16 ( buf ) ; <S2SV_StartBug> temp = net_buf_simple_pull_le16 ( buf ) ; <S2SV_EndBug> delta_uv = ( int16_t ) net_buf_simple_pull_le16 ( buf ) ; <S2SV_StartBug> tid = net_buf_simple_pull_u8 ( buf ) ; <S2SV_EndBug> if ( state -> last_tid == tid && state -> last_tx_addr == ctx -> addr ) { <S2SV_StartBug> if ( temp < TEMP_MIN || temp > TEMP_MAX ) { <S2SV_EndBug> return false ; } return true ; } if ( temp < TEMP_MIN || temp > TEMP_MAX ) { return false ; } state -> last_tid = tid ; state -> last_tx_addr = ctx -> addr ; if ( temp < state -> temp_range_min ) { temp = state -> temp_range_min ; } else if ( temp > state -> temp_range_max ) { temp = state -> temp_range_max ; } state -> lightness = lightness ; state -> temp = temp ; state -> delta_uv = delta_uv ; state_binding ( CTL , CTL_TEMP ) ; update_light_state ( ) ; if ( model -> pub -> addr != BT_MESH_ADDR_UNASSIGNED ) { int err ; bt_mesh_model_msg_init ( msg , BT_MESH_MODEL_OP_2 ( 0x82 , 0x60 ) ) ; net_buf_simple_add_le16 ( msg , state -> lightness ) ; net_buf_simple_add_le16 ( msg , state -> temp ) ; err = bt_mesh_model_publish ( model ) ; if ( err ) { printk ( "bt_mesh_model_publish<S2SV_blank>err<S2SV_blank>%d\\n" , err ) ; } } return true ; }
<S2SV_ModStart> u8_t tid ; s16_t delta_uv ; <S2SV_ModStart> lightness , temp ; struct net_buf_simple * msg = model -> pub -> msg ; struct light_ctl_state * state = model -> user_data ; lightness = net_buf_simple_pull_le16 ( buf ) ; temp = net_buf_simple_pull_le16 ( buf ) ; delta_uv = ( s16_t ) <S2SV_ModEnd> net_buf_simple_pull_le16 ( buf <S2SV_ModStart> buf ) ; <S2SV_ModEnd> tid = net_buf_simple_pull_u8 <S2SV_ModStart> buf ) ; if ( temp < TEMP_MIN || temp > TEMP_MAX ) { return false ; } <S2SV_ModStart> addr ) { return true <S2SV_ModEnd> ; } state
3,999
CWE-000 static PHP_METHOD ( Phalcon_Flash , setEscaperService ) { <S2SV_StartBug> zval * escaperService , escaperService_sub ; <S2SV_EndBug> zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & escaperService_sub ) ; zephir_fetch_params ( 0 , 1 , 0 , & escaperService ) ; <S2SV_StartBug> zephir_update_property_zval ( this_ptr , SL ( "_escaperService" ) , escaperService ) ; <S2SV_EndBug> RETURN_THISW ( ) ; }
<S2SV_ModStart> zval * escaperService <S2SV_ModEnd> ; zephir_fetch_params ( <S2SV_ModStart> escaperService ) ; zephir_update_property_this ( getThis ( ) <S2SV_ModEnd> , SL ( <S2SV_ModStart> ) , escaperService TSRMLS_CC