Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,400 | CWE-000 BAP_RESULT_E BAP_FuncInit ( BAP_DiscreteFunction_S * func , int plusnum , int minusnum , float dT ) { if ( func == NULL ) { return BAP_FAILED_NULL_PTR ; } if ( plusnum <= 0 || minusnum <= 0 || dT == 0 ) { return BAP_FAILED_WRONG_PAR ; } <S2SV_StartBug> memset ( func , 0 , sizeof ( func ) ) ; <S2SV_EndBug> func -> num_of_plus_samples = plusnum ; func -> num_of_minus_samples = minusnum ; func -> dT = dT ; return BAP_SUCCESS ; } | <S2SV_ModStart> , sizeof ( BAP_DiscreteFunction_S <S2SV_ModEnd> ) ) ; |
6,401 | CWE-000 static bool test_new_var ( const char * name , const char * val ) { char buf [ 128 ] ; char path [ 128 ] ; int fd , ret ; ret = snprintf ( path , sizeof ( path ) , "#vars/%s" , name ) ; <S2SV_StartBug> if ( snprintf_overflow ( ret , path , sizeof ( path ) ) ) <S2SV_EndBug> UT_ASSERT_FMT ( "snprintf<S2SV_blank>failed!" , FALSE ) ; fd = open ( path , O_READ | O_CREATE , S_IRUSR ) ; UT_ASSERT_FMT ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>vars<S2SV_blank>file<S2SV_blank>%s,<S2SV_blank>check<S2SV_blank>CONFIG_DEVVARS_TEST" , fd >= 0 , path ) ; ret = read ( fd , buf , sizeof ( buf ) ) ; UT_ASSERT_FMT ( "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>vars<S2SV_blank>file<S2SV_blank>%s" , ret > 0 , path ) ; UT_ASSERT_FMT ( "Value<S2SV_blank>differs,<S2SV_blank>got<S2SV_blank>%s,<S2SV_blank>wanted<S2SV_blank>%s" , strcmp ( buf , val ) == 0 , buf , val ) ; ret = unlink ( path ) ; UT_ASSERT_FMT ( "Could<S2SV_blank>not<S2SV_blank>remove<S2SV_blank>%s" , ret == 0 , path ) ; return TRUE ; } | <S2SV_ModStart> ; if ( snprintf_error ( ret <S2SV_ModEnd> , sizeof ( |
6,402 | CWE-000 static void run ( const gchar * name , gint nparams , const GimpParam * param , gint * nreturn_vals , GimpParam * * return_vals ) { static GimpParam values [ 2 ] ; GimpRunMode run_mode ; GimpPDBStatusType status = GIMP_PDB_SUCCESS ; gint image_ID ; GError * error = NULL ; run_mode = param [ 0 ] . data . d_int32 ; INIT_I18N ( ) ; gegl_init ( NULL , NULL ) ; * nreturn_vals = 1 ; * return_vals = values ; values [ 0 ] . type = GIMP_PDB_STATUS ; values [ 0 ] . data . d_status = GIMP_PDB_EXECUTION_ERROR ; if ( strcmp ( name , LOAD_JP2_PROC ) == 0 || strcmp ( name , LOAD_J2K_PROC ) == 0 ) { gboolean interactive ; switch ( run_mode ) { case GIMP_RUN_INTERACTIVE : case GIMP_RUN_WITH_LAST_VALS : gimp_ui_init ( PLUG_IN_BINARY , FALSE ) ; interactive = TRUE ; break ; default : interactive = FALSE ; break ; } if ( strcmp ( name , LOAD_JP2_PROC ) == 0 ) <S2SV_StartBug> image_ID = load_image ( param [ 1 ] . data . d_string , OPJ_CODEC_JP2 , & error ) ; <S2SV_EndBug> else <S2SV_StartBug> image_ID = load_image ( param [ 1 ] . data . d_string , OPJ_CODEC_J2K , & error ) ; <S2SV_EndBug> if ( image_ID != - 1 ) { GFile * file = g_file_new_for_path ( param [ 1 ] . data . d_string ) ; GimpMetadata * metadata ; metadata = gimp_image_metadata_load_prepare ( image_ID , "image/jp2" , file , NULL ) ; if ( metadata ) { GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL ; gimp_image_metadata_load_finish ( image_ID , "image/jp2" , metadata , flags , interactive ) ; g_object_unref ( metadata ) ; } g_object_unref ( file ) ; * nreturn_vals = 2 ; values [ 1 ] . type = GIMP_PDB_IMAGE ; values [ 1 ] . data . d_image = image_ID ; } <S2SV_StartBug> else <S2SV_EndBug> { <S2SV_StartBug> status = GIMP_PDB_EXECUTION_ERROR ; <S2SV_EndBug> } } else { status = GIMP_PDB_CALLING_ERROR ; } if ( status != GIMP_PDB_SUCCESS && error ) { * nreturn_vals = 2 ; values [ 1 ] . type = GIMP_PDB_STRING ; values [ 1 ] . data . d_string = error -> message ; } values [ 0 ] . data . d_status = status ; } | <S2SV_ModStart> , OPJ_CODEC_JP2 , interactive , <S2SV_ModStart> d_string , OPJ_CODEC_J2K , interactive <S2SV_ModStart> ; } else if ( error ) <S2SV_ModStart> status = GIMP_PDB_EXECUTION_ERROR ; } else { status = GIMP_PDB_CANCEL |
6,403 | CWE-000 void snapshot_handler ( int signum ) { <S2SV_StartBug> fprintf ( stderr , "Snapshot<S2SV_blank>creating..." ) ; <S2SV_EndBug> snapshot ( ) ; fprintf ( stderr , "Snapshot<S2SV_blank>done\\n" ) ; } | <S2SV_ModStart> ( stderr , "Snapshot<S2SV_blank>creating...\\n" <S2SV_ModEnd> ) ; snapshot |
6,404 | CWE-000 void ecrireArbre ( FILE * stream , Arbre a ) { if ( a != NULL ) { if ( a -> lettre == '\\0' ) fprintf ( stream , "n%p<S2SV_blank>[label=\\"<gauche><S2SV_blank>|<S2SV_blank>/0<S2SV_blank>|<S2SV_blank><droit>\\"];\\n" , a ) ; else fprintf ( stream , "n%p<S2SV_blank>[label=\\"<gauche><S2SV_blank>|<S2SV_blank>%c<S2SV_blank>|<S2SV_blank><droit>\\"];\\n" , a , a -> lettre ) ; if ( a -> frered ) { <S2SV_StartBug> fprintf ( stream , "n%p:droit:c<S2SV_blank>-><S2SV_blank>n%p[color=blue];\\n" , a , a -> frered ) ; <S2SV_EndBug> ecrireArbre ( stream , a -> frered ) ; } if ( a -> filsg ) { <S2SV_StartBug> fprintf ( stream , "n%p:s<S2SV_blank>-><S2SV_blank>n%p<S2SV_blank>[color=blue];\\n" , a , a -> filsg ) ; <S2SV_EndBug> ecrireArbre ( stream , a -> filsg ) ; } } } | <S2SV_ModStart> ( stream , "n%p:droit:c<S2SV_blank>-><S2SV_blank>n%p[color=orange];\\n" <S2SV_ModEnd> , a , <S2SV_ModStart> ( stream , "n%p:s<S2SV_blank>-><S2SV_blank>n%p<S2SV_blank>[color=pink];\\n" <S2SV_ModEnd> , a , |
6,405 | CWE-000 void add_topic ( HashTable * ht , char * topic , int fd ) { struct list_entry * entry = ( struct list_entry * ) malloc ( sizeof ( struct list_entry ) ) ; entry -> fd = fd ; entry -> topic = ( char * ) malloc ( sizeof ( strlen ( topic ) ) ) ; strcpy ( entry -> topic , topic ) ; struct hash_node * node = NULL ; hash_find ( ht , topic , & node ) ; if ( node == NULL ) { node = ( struct hash_node * ) malloc ( sizeof ( struct hash_node ) ) ; TGAP_LIST_HEAD_INIT ( & ( node -> fd_list_head ) ) ; TGAP_LIST_LOCK ( & ( node -> fd_list_head ) ) ; TGAP_LIST_INSERT_TAIL ( & ( node -> fd_list_head ) , entry , field ) ; TGAP_LIST_UNLOCK ( & ( node -> fd_list_head ) ) ; <S2SV_StartBug> pthread_mutex_lock ( & msg_queue_mutex ) ; <S2SV_EndBug> hash_add ( ht , topic , node ) ; <S2SV_StartBug> pthread_mutex_unlock ( & msg_queue_mutex ) ; <S2SV_EndBug> } else { TGAP_LIST_LOCK ( & ( node -> fd_list_head ) ) ; TGAP_LIST_INSERT_TAIL ( & ( node -> fd_list_head ) , entry , field ) ; TGAP_LIST_UNLOCK ( & ( node -> fd_list_head ) ) ; } } | <S2SV_ModStart> pthread_mutex_lock ( & hash_mutext <S2SV_ModEnd> ) ; hash_add <S2SV_ModStart> pthread_mutex_unlock ( & hash_mutext <S2SV_ModEnd> ) ; } |
6,406 | CWE-000 static inline unsigned int sata_fsl_tag ( unsigned int tag , void __iomem * hcr_base ) { <S2SV_StartBug> if ( ata_tag_internal ( tag ) ) { <S2SV_EndBug> DPRINTK ( "mapping<S2SV_blank>internal<S2SV_blank>cmds<S2SV_blank>to<S2SV_blank>tag#0\\n" ) ; return 0 ; } if ( unlikely ( tag >= SATA_FSL_QUEUE_DEPTH ) ) { DPRINTK ( "tag<S2SV_blank>%d<S2SV_blank>invalid<S2SV_blank>:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , tag ) ; return 0 ; } if ( unlikely ( ( ioread32 ( hcr_base + CQ ) ) & ( 1 << tag ) ) ) { DPRINTK ( "tag<S2SV_blank>%d<S2SV_blank>invalid<S2SV_blank>:<S2SV_blank>in<S2SV_blank>use!!\\n" , tag ) ; return 0 ; } return tag ; } | <S2SV_ModStart> hcr_base ) { <S2SV_ModEnd> if ( unlikely |
6,407 | CWE-000 static int _sha1_hmac_setkey ( struct crypto_ahash * tfm , const u8 * key , unsigned int len ) { <S2SV_StartBug> struct qcrypto_sha_ctx * sha_ctx = crypto_tfm_ctx ( & tfm -> base ) ; <S2SV_EndBug> if ( len <= SHA1_BLOCK_SIZE ) memcpy ( & sha_ctx -> authkey [ 0 ] , key , len ) ; else { _sha_init ( sha_ctx ) ; sha_ctx -> alg = QCE_HASH_SHA1 ; memcpy ( & sha_ctx -> digest [ 0 ] , & _std_init_vector_sha1_uint8 [ 0 ] , SHA1_DIGEST_SIZE ) ; sha_ctx -> diglen = SHA1_DIGEST_SIZE ; <S2SV_StartBug> _sha_hmac_setkey ( tfm , key , len ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> -> base ) ; int ret = 0 <S2SV_ModStart> = SHA1_DIGEST_SIZE ; ret = <S2SV_ModStart> len ) ; if ( ret ) pr_err ( "SHA1<S2SV_blank>hmac<S2SV_blank>setkey<S2SV_blank>failed\\n" ) ; } return ret <S2SV_ModEnd> ; } <S2SV_null> |
6,408 | CWE-000 int rules_init_from_stream ( FILE * fi , int * ret_n_rules , int * ret_n_samples , rule_data_t * * rules_ret , int add_default_rule ) { <S2SV_StartBug> char * cp , * features , * rulestr ; <S2SV_EndBug> int rule_cnt ; int n_rules = 0 , n_samples = 0 , i ; long tmpl ; int ret ; rule_data_t * rules = NULL ; unsigned buffer_size = 64 ; char * buffer = calloc ( buffer_size , sizeof ( char ) ) ; char * end ; char delim = '<S2SV_blank>' , delim2 = '\\t' ; <S2SV_StartBug> rule_cnt = add_default_rule != 0 ? 1 : 0 ; <S2SV_EndBug> if ( fgets ( buffer , buffer_size , fi ) == NULL || strncmp ( buffer , "n_items:" , 8 ) != 0 ) { fprintf ( stderr , "Error:<S2SV_blank>data<S2SV_blank>file<S2SV_blank>mal-format!<S2SV_blank>The<S2SV_blank>first<S2SV_blank>line<S2SV_blank>should<S2SV_blank>be<S2SV_blank>n_items:<S2SV_blank>xxx\\n" ) ; goto err ; } tmpl = strtol ( buffer + 8 , & end , 10 ) ; if ( errno == ERANGE || tmpl > INT_MAX ) { fprintf ( stderr , "Error:<S2SV_blank>n_items<S2SV_blank>range<S2SV_blank>error,<S2SV_blank>got<S2SV_blank>%ld" , tmpl ) ; goto err ; } n_rules = ( int ) tmpl ; if ( fgets ( buffer , buffer_size , fi ) == NULL || strncmp ( buffer , "n_samples:" , 10 ) != 0 ) { fprintf ( stderr , "Error:<S2SV_blank>data<S2SV_blank>file<S2SV_blank>mal-format!<S2SV_blank>The<S2SV_blank>first<S2SV_blank>line<S2SV_blank>should<S2SV_blank>be<S2SV_blank>n_samples:<S2SV_blank>xxx\\n" ) ; goto err ; } tmpl = strtol ( buffer + 10 , & end , 10 ) ; if ( errno == ERANGE ) { fprintf ( stderr , "Error:<S2SV_blank>n_samples<S2SV_blank>range<S2SV_blank>error,<S2SV_blank>got<S2SV_blank>%ld" , tmpl ) ; goto err ; } n_samples = ( int ) tmpl ; <S2SV_StartBug> rules = calloc ( ( unsigned long ) n_rules , sizeof ( rule_data_t ) ) ; <S2SV_EndBug> buffer_size = ( unsigned ) n_samples * 3 + 100 ; buffer = realloc ( buffer , buffer_size * sizeof ( char ) ) ; for ( i = 0 ; i < n_rules ; i ++ ) { if ( fgets ( buffer , buffer_size , fi ) == NULL ) { if ( feof ( fi ) ) fprintf ( stderr , "Error:<S2SV_blank>Unexpected<S2SV_blank>end<S2SV_blank>of<S2SV_blank>file<S2SV_blank>at<S2SV_blank>line<S2SV_blank>%d,<S2SV_blank>expected<S2SV_blank>%d<S2SV_blank>lines\\n" , i + 2 , n_rules + 2 ) ; if ( ferror ( fi ) ) fprintf ( stderr , "Error:<S2SV_blank>fgets<S2SV_blank>error!\\n" ) ; errno = ENOEXEC ; goto err ; } end = buffer ; while ( ( * end ) != delim && ( * end ) != delim2 && ( * end ) != '\\0' ) { end ++ ; } if ( * end == '\\0' ) { fprintf ( stderr , "%s" , buffer ) ; fprintf ( stderr , "Error:<S2SV_blank>cannot<S2SV_blank>find<S2SV_blank>\'%c\'<S2SV_blank>or<S2SV_blank>\'%c\'<S2SV_blank>to<S2SV_blank>split<S2SV_blank>the<S2SV_blank>line!\\n" , delim , delim2 ) ; errno = ENOEXEC ; goto err ; } features = end + 1 ; * end = '\\0' ; rulestr = buffer ; <S2SV_StartBug> if ( ( rules [ rule_cnt ] . feature_str = _strdup ( rulestr ) ) == NULL ) <S2SV_EndBug> goto err ; <S2SV_StartBug> if ( ( rules [ rule_cnt ] . truthtable = bit_vector_from_str ( features ) ) == NULL ) <S2SV_EndBug> goto err ; <S2SV_StartBug> rules [ rule_cnt ] . cardinality = 1 ; <S2SV_EndBug> for ( cp = rulestr ; * cp != '\\0' ; cp ++ ) if ( * cp == ',' ) <S2SV_StartBug> rules [ rule_cnt ] . cardinality ++ ; <S2SV_EndBug> <S2SV_StartBug> rule_cnt ++ ; <S2SV_EndBug> } if ( add_default_rule ) { rules [ 0 ] . cardinality = 0 ; if ( ( rules [ 0 ] . truthtable = bit_vector_init ( ( bit_size_t ) n_samples ) ) == NULL ) goto err ; rules [ 0 ] . feature_str = _strdup ( "default" ) ; bit_vector_flip_all ( rules [ 0 ] . truthtable ) ; } * rules_ret = rules ; <S2SV_StartBug> * ret_n_rules = n_rules ; <S2SV_EndBug> * ret_n_samples = n_samples ; return ( 0 ) ; err : ret = errno ; free ( buffer ) ; if ( rules != NULL ) { rules_free ( rules , n_rules ) ; } return ( ret ) ; } | <S2SV_ModStart> , * rulestr <S2SV_ModEnd> ; int n_rules <S2SV_ModStart> = '\\t' ; add_default_rule = add_default_rule <S2SV_ModEnd> ? 1 : <S2SV_ModStart> unsigned long ) ( n_rules + add_default_rule ) <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> ( rules [ i + add_default_rule <S2SV_ModEnd> ] . feature_str <S2SV_ModStart> ( rules [ i + add_default_rule <S2SV_ModEnd> ] . truthtable <S2SV_ModStart> ; rules [ i + add_default_rule <S2SV_ModEnd> ] . cardinality <S2SV_ModStart> ) rules [ i + add_default_rule <S2SV_ModEnd> ] . cardinality <S2SV_ModStart> cardinality ++ ; <S2SV_ModEnd> } if ( <S2SV_ModStart> ret_n_rules = n_rules + add_default_rule |
6,409 | CWE-000 int shoes_init_load_yaml ( char * path ) { yaml_parser_t parser ; yaml_token_t token ; if ( ! yaml_parser_initialize ( & parser ) ) { fputs ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>yaml<S2SV_blank>parser!\\n" , stderr ) ; return 0 ; } shoes_config_yaml = malloc ( sizeof ( shoes_yaml_init ) ) ; shoes_config_yaml -> app_name = "Shoes" ; shoes_config_yaml -> icon_path = "static/app-icon.png" ; shoes_config_yaml -> theme_name = NULL ; shoes_config_yaml -> active = FALSE ; shoes_config_yaml -> rdomain = "com.shoesrb.shoes" ; shoes_config_yaml -> use_menus = "false" ; shoes_config_yaml -> mdi = "false" ; shoes_config_yaml -> extra1 = NULL ; shoes_config_yaml -> extra2 = NULL ; shoes_config_yaml -> osx_menutrim = "false" ; FILE * fh = fopen ( "startup.yaml" , "r" ) ; if ( fh == NULL ) { char buf [ 200 ] ; sprintf ( buf , "File.expand_path(File.dirname(%%q<%s>));" , path ) ; VALUE dpv = rb_eval_string ( buf ) ; char * dp = RSTRING_PTR ( dpv ) ; strcpy ( buf , dp ) ; strcat ( buf , "/startup.yaml" ) ; fh = fopen ( buf , "r" ) ; } if ( fh != NULL ) { yaml_parser_set_input_file ( & parser , fh ) ; int state = 0 ; char * * datap ; char * tk ; do { yaml_parser_scan ( & parser , & token ) ; switch ( token . type ) { case YAML_KEY_TOKEN : state = 0 ; break ; case YAML_VALUE_TOKEN : state = 1 ; break ; case YAML_SCALAR_TOKEN : <S2SV_StartBug> tk = token . data . scalar . value ; <S2SV_EndBug> if ( state == 0 ) { if ( ! strcmp ( tk , "App_Name" ) ) { datap = & shoes_config_yaml -> app_name ; } else if ( ! strcmp ( tk , "Icon_Path" ) ) { datap = & shoes_config_yaml -> icon_path ; } else if ( ! strcmp ( tk , "Theme" ) ) { datap = & shoes_config_yaml -> theme_name ; } else if ( ! strcmp ( tk , "RDomain" ) ) { datap = & shoes_config_yaml -> rdomain ; } else if ( ! strcmp ( tk , "Use_Menus" ) ) { datap = & shoes_config_yaml -> use_menus ; } else if ( ! strcmp ( tk , "MDI" ) ) { datap = & shoes_config_yaml -> mdi ; } else if ( ! strcmp ( tk , "Extra1" ) ) { datap = & shoes_config_yaml -> extra1 ; } else if ( ! strcmp ( tk , "Extra2" ) ) { datap = & shoes_config_yaml -> extra2 ; } else if ( ! strcmp ( tk , "OSX_Menu_Trim" ) ) { datap = & shoes_config_yaml -> osx_menutrim ; } else { printf ( "Unrecognised<S2SV_blank>key:<S2SV_blank>%s\\n" , tk ) ; return 0 ; } } else { * datap = strdup ( tk ) ; } break ; default : break ; } if ( token . type != YAML_STREAM_END_TOKEN ) yaml_token_delete ( & token ) ; } while ( token . type != YAML_STREAM_END_TOKEN ) ; yaml_token_delete ( & token ) ; yaml_parser_delete ( & parser ) ; fclose ( fh ) ; } shoes_config_yaml -> active = TRUE ; shoes_settings_new ( shoes_config_yaml ) ; return 1 ; } | <S2SV_ModStart> : tk = ( char * ) |
6,410 | CWE-000 int main ( int ac , char * * av ) { <S2SV_StartBug> s_sockaddr_in server ; <S2SV_EndBug> int socket_fd ; if ( ac != 3 ) { ft_printf ( "Invalid<S2SV_blank>argument\\nUsage:<S2SV_blank>./client<S2SV_blank><IP><S2SV_blank><PORT>\\n" ) ; return ( 0 ) ; } if ( ! connect_socket ( & server , & socket_fd , av ) ) return ( 0 ) ; communicate ( socket_fd ) ; close ( socket_fd ) ; return ( 0 ) ; } | <S2SV_ModStart> av ) { t_sockaddr_in <S2SV_ModEnd> server ; int |
6,411 | CWE-000 int copy_unicodez ( wchar_t * to , const wchar_t * from ) <S2SV_StartBug> { <S2SV_EndBug> uint32_t length = MAX_PATH_W ; tls_copy_t * tls = copy_get_tls ( ) ; tls -> active = 1 ; if ( setjmp ( tls -> jb ) == 0 ) { while ( length -- != 0 && ( * to ++ = * from ++ ) != 0 ) ; * to = 0 ; tls -> active = 0 ; return 0 ; } tls -> active = 0 ; return - 1 ; } | <S2SV_ModStart> from ) { if ( to == NULL || from == NULL ) { return 0 ; } |
6,412 | CWE-000 static pa_hook_result_t sink_unlink_hook_callback ( pa_core * c , pa_sink * sink , struct userdata * u ) { pa_sink_input * si ; uint32_t idx ; pa_assert ( c ) ; pa_assert ( sink ) ; pa_assert ( u ) ; pa_assert ( u -> on_rescue && u -> restore_device ) ; if ( c -> state == PA_CORE_SHUTDOWN ) return PA_HOOK_OK ; PA_IDXSET_FOREACH ( si , sink -> inputs , idx ) { char * name ; struct entry * e ; if ( ! si -> sink ) continue ; if ( si -> origin_sink ) continue ; if ( ! ( name = pa_proplist_get_stream_group ( si -> proplist , "sink-input" , IDENTIFICATION_PROPERTY ) ) ) continue ; if ( ( e = entry_read ( u , name ) ) ) { if ( e -> device_valid ) { pa_sink * d ; if ( ( d = pa_namereg_get ( c , e -> device , PA_NAMEREG_SINK ) ) && d != sink && <S2SV_StartBug> PA_SINK_IS_LINKED ( pa_sink_get_state ( d ) ) ) <S2SV_EndBug> pa_sink_input_move_to ( si , d , true ) ; } entry_free ( e ) ; } pa_xfree ( name ) ; } return PA_HOOK_OK ; } | <S2SV_ModStart> && PA_SINK_IS_LINKED ( d -> state <S2SV_ModEnd> ) ) pa_sink_input_move_to |
6,413 | CWE-000 int manager_reload ( Manager * m ) { int r , q ; _cleanup_fclose_ FILE * f = NULL ; _cleanup_fdset_free_ FDSet * fds = NULL ; assert ( m ) ; r = manager_open_serialization ( m , & f ) ; if ( r < 0 ) return r ; m -> n_reloading ++ ; bus_manager_send_reloading ( m , true ) ; fds = fdset_new ( ) ; if ( ! fds ) { m -> n_reloading -- ; return - ENOMEM ; } r = manager_serialize ( m , f , fds , false ) ; if ( r < 0 ) { m -> n_reloading -- ; return r ; } if ( fseeko ( f , 0 , SEEK_SET ) < 0 ) { m -> n_reloading -- ; return - errno ; } manager_clear_jobs_and_units ( m ) ; lookup_paths_flush_generator ( & m -> lookup_paths ) ; lookup_paths_free ( & m -> lookup_paths ) ; <S2SV_StartBug> dynamic_user_vacuum ( m , false ) ; <S2SV_EndBug> m -> uid_refs = hashmap_free ( m -> uid_refs ) ; m -> gid_refs = hashmap_free ( m -> gid_refs ) ; q = lookup_paths_init ( & m -> lookup_paths , m -> unit_file_scope , 0 , NULL ) ; if ( q < 0 && r >= 0 ) r = q ; q = manager_run_environment_generators ( m ) ; if ( q < 0 && r >= 0 ) r = q ; q = manager_run_generators ( m ) ; if ( q < 0 && r >= 0 ) r = q ; lookup_paths_reduce ( & m -> lookup_paths ) ; manager_build_unit_path_cache ( m ) ; manager_enumerate ( m ) ; q = manager_deserialize ( m , f , fds ) ; if ( q < 0 ) { log_error_errno ( q , "Deserialization<S2SV_blank>failed:<S2SV_blank>%m" ) ; if ( r >= 0 ) r = q ; } fclose ( f ) ; f = NULL ; q = manager_setup_notify ( m ) ; if ( q < 0 && r >= 0 ) r = q ; q = manager_setup_cgroups_agent ( m ) ; if ( q < 0 && r >= 0 ) r = q ; q = manager_setup_user_lookup_fd ( m ) ; if ( q < 0 && r >= 0 ) r = q ; manager_coldplug ( m ) ; dynamic_user_vacuum ( m , true ) ; manager_vacuum_uid_refs ( m ) ; <S2SV_StartBug> manager_vacuum_gid_refs ( m ) ; <S2SV_EndBug> manager_recheck_journal ( m ) ; if ( m -> api_bus ) manager_sync_bus_names ( m , m -> api_bus ) ; assert ( m -> n_reloading > 0 ) ; m -> n_reloading -- ; m -> send_reloading_done = true ; return r ; } | <S2SV_ModStart> lookup_paths ) ; exec_runtime_vacuum ( m ) ; <S2SV_ModStart> ) ; manager_vacuum_gid_refs ( m ) ; exec_runtime_vacuum |
6,414 | CWE-000 static int cpufreq_stats_create_table ( struct cpufreq_policy * policy , struct cpufreq_frequency_table * table ) { unsigned int i , j , count = 0 , ret = 0 ; struct cpufreq_stats * stat ; struct cpufreq_policy * data ; unsigned int alloc_size ; unsigned int cpu = policy -> cpu ; if ( per_cpu ( cpufreq_stats_table , cpu ) ) <S2SV_StartBug> return - EBUSY ; <S2SV_EndBug> stat = kzalloc ( sizeof ( struct cpufreq_stats ) , GFP_KERNEL ) ; if ( ( stat ) == NULL ) return - ENOMEM ; data = cpufreq_cpu_get ( cpu ) ; if ( data == NULL ) { ret = - EINVAL ; goto error_get_fail ; } ret = sysfs_create_group ( & data -> kobj , & stats_attr_group ) ; if ( ret ) goto error_out ; stat -> cpu = cpu ; per_cpu ( cpufreq_stats_table , cpu ) = stat ; for ( i = 0 ; table [ i ] . frequency != CPUFREQ_TABLE_END ; i ++ ) { unsigned int freq = table [ i ] . frequency ; if ( freq == CPUFREQ_ENTRY_INVALID ) continue ; count ++ ; } alloc_size = count * sizeof ( int ) + count * sizeof ( cputime64_t ) ; # ifdef CONFIG_CPU_FREQ_STAT_DETAILS alloc_size += count * count * sizeof ( int ) ; # endif stat -> max_state = count ; stat -> time_in_state = kzalloc ( alloc_size , GFP_KERNEL ) ; if ( ! stat -> time_in_state ) { ret = - ENOMEM ; goto error_out ; } stat -> freq_table = ( unsigned int * ) ( stat -> time_in_state + count ) ; # ifdef CONFIG_CPU_FREQ_STAT_DETAILS stat -> trans_table = stat -> freq_table + count ; # endif j = 0 ; for ( i = 0 ; table [ i ] . frequency != CPUFREQ_TABLE_END ; i ++ ) { unsigned int freq = table [ i ] . frequency ; if ( freq == CPUFREQ_ENTRY_INVALID ) continue ; if ( freq_table_get_index ( stat , freq ) == - 1 ) stat -> freq_table [ j ++ ] = freq ; } stat -> state_num = j ; spin_lock ( & cpufreq_stats_lock ) ; stat -> last_time = get_jiffies_64 ( ) ; stat -> last_index = freq_table_get_index ( stat , policy -> cur ) ; spin_unlock ( & cpufreq_stats_lock ) ; cpufreq_cpu_put ( data ) ; return 0 ; error_out : cpufreq_cpu_put ( data ) ; error_get_fail : kfree ( stat ) ; per_cpu ( cpufreq_stats_table , cpu ) = NULL ; return ret ; } | <S2SV_ModStart> ) ) return 0 <S2SV_ModEnd> ; stat = |
6,415 | CWE-000 bool setglobalbond ( scope_t * scope , bond_t * bond , bool isglobal ) { if ( scope -> parent == NULL ) { <S2SV_StartBug> sexpr_t * s = bond -> sexpr ; <S2SV_EndBug> setglobal ( s , isglobal ) ; <S2SV_StartBug> if ( islambda ( s ) ) { <S2SV_EndBug> s -> l -> gci . isglobal = isglobal ; setglobal ( s -> l -> args , isglobal ) ; setglobal ( s -> l -> body , isglobal ) ; } } return scope -> parent == NULL ; } | <S2SV_ModStart> NULL ) { setglobal ( <S2SV_ModEnd> bond -> sexpr <S2SV_ModStart> bond -> sexpr <S2SV_ModEnd> , isglobal ) <S2SV_ModStart> isglobal ) ; <S2SV_ModEnd> } return scope |
6,416 | CWE-000 static int shell_cpuid ( int argc , char * * argv ) { char str [ MAX_STR_SIZE ] = { 0 } ; uint32_t leaf , subleaf = 0 ; uint32_t eax , ebx , ecx , edx ; if ( argc == 2 ) { <S2SV_StartBug> leaf = strtoul_hex ( argv [ 1 ] ) ; <S2SV_EndBug> } else if ( argc == 3 ) { <S2SV_StartBug> leaf = strtoul_hex ( argv [ 1 ] ) ; <S2SV_EndBug> <S2SV_StartBug> subleaf = strtoul_hex ( argv [ 2 ] ) ; <S2SV_EndBug> } else { shell_puts ( "Please<S2SV_blank>enter<S2SV_blank>correct<S2SV_blank>cmd<S2SV_blank>with<S2SV_blank>" "cpuid<S2SV_blank><leaf><S2SV_blank>[subleaf]\\r\\n" ) ; return - EINVAL ; } cpuid_subleaf ( leaf , subleaf , & eax , & ebx , & ecx , & edx ) ; snprintf ( str , MAX_STR_SIZE , "cpuid<S2SV_blank>leaf:<S2SV_blank>0x%x,<S2SV_blank>subleaf:<S2SV_blank>0x%x,<S2SV_blank>0x%x:0x%x:0x%x:0x%x\\r\\n" , leaf , subleaf , eax , ebx , ecx , edx ) ; shell_puts ( str ) ; return 0 ; } | <S2SV_ModStart> { leaf = ( uint32_t ) <S2SV_ModStart> { leaf = ( uint32_t ) <S2SV_ModStart> ; subleaf = ( uint32_t ) |
6,417 | CWE-000 static PT_NODE * pt_apply_attr_def ( PARSER_CONTEXT * parser , PT_NODE * p , PT_NODE_FUNCTION g , void * arg ) { p -> info . attr_def . attr_name = g ( parser , p -> info . attr_def . attr_name , arg ) ; p -> info . attr_def . data_default = g ( parser , p -> info . attr_def . data_default , arg ) ; <S2SV_StartBug> p -> info . attr_def . on_update = g ( parser , p -> info . attr_def . on_update , arg ) ; <S2SV_EndBug> p -> info . attr_def . auto_increment = g ( parser , p -> info . attr_def . auto_increment , arg ) ; p -> info . attr_def . ordering_info = g ( parser , p -> info . attr_def . ordering_info , arg ) ; return p ; } | <S2SV_ModStart> . attr_def . <S2SV_ModEnd> auto_increment = g |
6,418 | CWE-000 void * saunaTicket ( void * arg ) { <S2SV_StartBug> int duration = * ( int * ) arg ; <S2SV_EndBug> <S2SV_StartBug> usleep ( duration ) ; <S2SV_EndBug> pthread_exit ( NULL ) ; } | <S2SV_ModStart> arg ) { Request * r = ( Request <S2SV_ModEnd> * ) arg <S2SV_ModStart> ) arg ; printf ( "Serving<S2SV_blank>user<S2SV_blank>#%d<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>ms.\\n" , r -> id , r -> duration ) ; usleep ( r -> duration ) ; printf ( "User<S2SV_blank>#%d<S2SV_blank>leaving<S2SV_blank>sauna.\\n" , r -> id <S2SV_ModEnd> ) ; pthread_exit |
6,419 | CWE-000 HotplugHandler * qdev_get_hotplug_handler ( DeviceState * dev ) { <S2SV_StartBug> HotplugHandler * hotplug_ctrl = NULL ; <S2SV_EndBug> if ( dev -> parent_bus && dev -> parent_bus -> hotplug_handler ) { hotplug_ctrl = dev -> parent_bus -> hotplug_handler ; <S2SV_StartBug> } else if ( object_dynamic_cast ( qdev_get_machine ( ) , TYPE_MACHINE ) ) { <S2SV_EndBug> MachineState * machine = MACHINE ( qdev_get_machine ( ) ) ; MachineClass * mc = MACHINE_GET_CLASS ( machine ) ; if ( mc -> get_hotplug_handler ) { <S2SV_StartBug> hotplug_ctrl = mc -> get_hotplug_handler ( machine , dev ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> } return hotplug_ctrl ; } | <S2SV_ModStart> HotplugHandler * hotplug_ctrl <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; } else <S2SV_ModEnd> { hotplug_ctrl = <S2SV_ModStart> { hotplug_ctrl = qdev_get_machine_hotplug_handler ( <S2SV_ModEnd> dev ) ; <S2SV_ModStart> dev ) ; <S2SV_ModEnd> } return hotplug_ctrl |
6,420 | CWE-000 void _x86_mmu_get_flags ( void * addr , u32_t * pde_flags , u32_t * pte_flags ) { * pde_flags = X86_MMU_GET_PDE ( addr ) -> value & ~ MMU_PDE_PAGE_TABLE_MASK ; <S2SV_StartBug> * pte_flags = X86_MMU_GET_PTE ( addr ) -> value & ~ MMU_PTE_PAGE_MASK ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ~ MMU_PDE_PAGE_TABLE_MASK ; if ( * pde_flags & MMU_ENTRY_PRESENT ) { <S2SV_ModStart> MMU_PTE_PAGE_MASK ; } else { * pte_flags = 0 ; } } |
6,421 | CWE-000 int fluid_synth_all_notes_off ( fluid_synth_t * synth , int chan ) { int result ; fluid_return_val_if_fail ( synth != NULL , FLUID_FAILED ) ; fluid_return_val_if_fail ( chan >= - 1 , FLUID_FAILED ) ; fluid_synth_api_enter ( synth ) ; if ( chan >= synth -> midi_channels ) result = FLUID_FAILED ; else { <S2SV_StartBug> FLUID_API_RETURN_IF_CHAN_DISABLED ( FLUID_FAILED ) ; <S2SV_EndBug> result = fluid_synth_all_notes_off_LOCAL ( synth , chan ) ; } FLUID_API_RETURN ( result ) ; } | <S2SV_ModStart> ; else { <S2SV_ModEnd> result = fluid_synth_all_notes_off_LOCAL |
6,422 | CWE-000 static int lua__rank_range ( lua_State * L ) { int n ; sl_t * sl = CHECK_SL ( L , 1 ) ; slNode_t * node ; int rankMin = luaL_optinteger ( L , 2 , 1 ) ; <S2SV_StartBug> int rankMax = luaL_optinteger ( L , 3 , INT_MAX ) ; <S2SV_EndBug> <S2SV_StartBug> rankMax = rankMax >= sl -> size ? sl -> size : rankMax ; <S2SV_EndBug> if ( sl -> size == 0 ) { lua_createtable ( L , 0 , 0 ) ; return 1 ; } <S2SV_StartBug> if ( rankMin < 0 || rankMin > rankMax ) <S2SV_EndBug> return luaL_error ( L , "range<S2SV_blank>error!" ) ; lua_getuservalue ( L , 1 ) ; lua_getfield ( L , - 1 , "value_map" ) ; lua_createtable ( L , rankMax - rankMin + 1 , 0 ) ; SL_FOREACH_RANGE ( sl , rankMin , rankMax , node , n ) { lua_pushlightuserdata ( L , ( void * ) node ) ; lua_rawget ( L , - 3 ) ; lua_rawseti ( L , - 2 , n + 1 ) ; } return 1 ; } | <S2SV_ModStart> , 3 , <S2SV_ModEnd> sl -> size <S2SV_ModStart> sl -> size ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> if ( rankMin <= <S2SV_ModEnd> 0 || rankMin <S2SV_ModStart> rankMin > rankMax || rankMax > sl -> size |
6,423 | CWE-000 void ospf_sh_state ( struct proto * P , int verbose , int reachable ) { struct ospf_proto * p = ( struct ospf_proto * ) P ; int ospf2 = ospf_is_v2 ( p ) ; int af = ospf_get_af ( p ) ; uint i , ix , j1 , jx ; u32 last_area = 0xFFFFFFFF ; if ( p -> p . proto_state != PS_UP ) { cli_msg ( - 1016 , "%s:<S2SV_blank>is<S2SV_blank>not<S2SV_blank>up" , p -> p . name ) ; cli_msg ( 0 , "" ) ; return ; } <S2SV_StartBug> int num = p -> gr -> hash_entries ; <S2SV_EndBug> struct top_hash_entry * hea [ num ] ; struct top_hash_entry * hex [ verbose ? num : 0 ] ; struct top_hash_entry * he ; struct top_hash_entry * cnode = NULL ; j1 = jx = 0 ; WALK_SLIST ( he , p -> lsal ) { int accept ; if ( he -> lsa . age == LSA_MAXAGE ) continue ; switch ( he -> lsa_type ) { case LSA_T_RT : case LSA_T_NET : accept = 1 ; break ; case LSA_T_SUM_NET : case LSA_T_SUM_RT : case LSA_T_NSSA : case LSA_T_PREFIX : accept = verbose ; break ; case LSA_T_EXT : if ( verbose ) { he -> domain = 1 ; hex [ jx ++ ] = he ; } default : accept = 0 ; } if ( accept ) hea [ j1 ++ ] = he ; } ASSERT ( j1 <= num && jx <= num ) ; lsa_compare_ospf3 = ! ospf2 ; qsort ( hea , j1 , sizeof ( struct top_hash_entry * ) , lsa_compare_for_state ) ; qsort ( hex , jx , sizeof ( struct top_hash_entry * ) , ext_compare_for_state ) ; ix = 0 ; for ( i = 0 ; i < j1 ; i ++ ) { he = hea [ i ] ; if ( ! cnode ) { if ( ( ( he -> lsa_type == LSA_T_RT ) || ( he -> lsa_type == LSA_T_NET ) ) && ( ( he -> color == INSPF ) || ! reachable ) ) { cnode = he ; if ( he -> domain != last_area ) { cli_msg ( - 1016 , "" ) ; cli_msg ( - 1016 , "area<S2SV_blank>%R" , he -> domain ) ; last_area = he -> domain ; ix = 0 ; } } else continue ; } ASSERT ( cnode && ( he -> domain == last_area ) && ( he -> lsa . rt == cnode -> lsa . rt ) ) ; switch ( he -> lsa_type ) { case LSA_T_RT : if ( he -> lsa . id == cnode -> lsa . id ) show_lsa_router ( p , he , verbose ) ; break ; case LSA_T_NET : show_lsa_network ( he , ospf2 ) ; break ; case LSA_T_SUM_NET : if ( cnode -> lsa_type == LSA_T_RT ) show_lsa_sum_net ( he , ospf2 , af ) ; break ; case LSA_T_SUM_RT : if ( cnode -> lsa_type == LSA_T_RT ) show_lsa_sum_rt ( he , ospf2 ) ; break ; case LSA_T_EXT : case LSA_T_NSSA : show_lsa_external ( he , ospf2 , af ) ; break ; case LSA_T_PREFIX : show_lsa_prefix ( he , cnode , af ) ; break ; } if ( ( i + 1 == j1 ) || ( hea [ i + 1 ] -> domain != last_area ) || ( hea [ i + 1 ] -> lsa . rt != cnode -> lsa . rt ) || ( hea [ i + 1 ] -> lsa_type == LSA_T_NET ) ) { while ( ( ix < jx ) && ( hex [ ix ] -> lsa . rt < cnode -> lsa . rt ) ) ix ++ ; while ( ( ix < jx ) && ( hex [ ix ] -> lsa . rt == cnode -> lsa . rt ) ) show_lsa_external ( hex [ ix ++ ] , ospf2 , af ) ; cnode = NULL ; } } int hdr = 0 ; u32 last_rt = 0xFFFFFFFF ; for ( ix = 0 ; ix < jx ; ix ++ ) { he = hex [ ix ] ; if ( he -> domain ) { he -> domain = 0 ; if ( ( he -> color != INSPF ) && reachable ) continue ; if ( ! hdr ) { cli_msg ( - 1016 , "" ) ; cli_msg ( - 1016 , "other<S2SV_blank>ASBRs" ) ; hdr = 1 ; } if ( he -> lsa . rt != last_rt ) { cli_msg ( - 1016 , "" ) ; cli_msg ( - 1016 , "\\trouter<S2SV_blank>%R" , he -> lsa . rt ) ; last_rt = he -> lsa . rt ; } show_lsa_external ( he , ospf2 , af ) ; } } cli_msg ( 0 , "" ) ; } | <S2SV_ModStart> return ; } uint <S2SV_ModEnd> num = p |
6,424 | CWE-000 static int acm_port_activate ( struct tty_port * port , struct tty_struct * tty ) { struct acm * acm = container_of ( port , struct acm , port ) ; int retval = - ENODEV ; int i ; dev_dbg ( & acm -> control -> dev , "%s\\n" , __func__ ) ; mutex_lock ( & acm -> mutex ) ; if ( acm -> disconnected ) goto disconnected ; retval = usb_autopm_get_interface ( acm -> control ) ; if ( retval ) goto error_get_interface ; set_bit ( TTY_NO_WRITE_SPLIT , & tty -> flags ) ; acm -> control -> needs_remote_wakeup = 1 ; acm -> ctrlurb -> dev = acm -> dev ; if ( usb_submit_urb ( acm -> ctrlurb , GFP_KERNEL ) ) { dev_err ( & acm -> control -> dev , "%s<S2SV_blank>-<S2SV_blank>usb_submit_urb(ctrl<S2SV_blank>irq)<S2SV_blank>failed\\n" , __func__ ) ; <S2SV_StartBug> goto error_submit_urb ; <S2SV_EndBug> } acm -> ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS ; if ( acm_set_control ( acm , acm -> ctrlout ) < 0 && <S2SV_StartBug> ( acm -> ctrl_caps & USB_CDC_CAP_LINE ) ) <S2SV_EndBug> <S2SV_StartBug> goto error_set_control ; <S2SV_EndBug> usb_autopm_put_interface ( acm -> control ) ; spin_lock_irq ( & acm -> read_lock ) ; acm -> throttled = 0 ; acm -> throttle_req = 0 ; spin_unlock_irq ( & acm -> read_lock ) ; if ( acm_submit_read_urbs ( acm , GFP_KERNEL ) ) goto error_submit_read_urbs ; mutex_unlock ( & acm -> mutex ) ; return 0 ; error_submit_read_urbs : for ( i = 0 ; i < acm -> rx_buflimit ; i ++ ) usb_kill_urb ( acm -> read_urbs [ i ] ) ; acm -> ctrlout = 0 ; acm_set_control ( acm , acm -> ctrlout ) ; error_set_control : usb_kill_urb ( acm -> ctrlurb ) ; error_submit_urb : <S2SV_StartBug> usb_autopm_put_interface ( acm -> control ) ; <S2SV_EndBug> error_get_interface : disconnected : mutex_unlock ( & acm -> mutex ) ; return retval ; } | <S2SV_ModStart> __func__ ) ; usb_autopm_put_interface ( acm -> control ) ; <S2SV_ModStart> USB_CDC_CAP_LINE ) ) { usb_autopm_put_interface ( acm -> control ) ; <S2SV_ModStart> goto error_set_control ; } <S2SV_ModStart> ; error_submit_urb : <S2SV_ModEnd> error_get_interface : disconnected |
6,425 | CWE-000 void generateOptions ( int * DEBUG_A_MATRIX , int * DEBUG_LINEAR_SYSTEM , int * UMF_SOLVE , int * PRINT_SOLUTION , int * PLOT_SOLUTION , int * SGS_SOLVE , int * PREC_DEBUG , int * NORM_RESIDUE , int * MAT_MG_DEBUG , int * MG_PREC_DEBUG , int * MG_SOLVE , int argc , char * * argv ) { * DEBUG_A_MATRIX = 0 ; * DEBUG_LINEAR_SYSTEM = 0 ; * UMF_SOLVE = 0 ; * PRINT_SOLUTION = 0 ; * PLOT_SOLUTION = 0 ; * SGS_SOLVE = 0 ; * PREC_DEBUG = 0 ; * NORM_RESIDUE = 0 ; * MAT_MG_DEBUG = 0 ; * MG_PREC_DEBUG = 0 ; * MG_SOLVE = 0 ; for ( int i = 1 ; i < argc ; i ++ ) { if ( strcmp ( argv [ i ] , "-a" ) == 0 ) { * DEBUG_A_MATRIX = 1 ; } else if ( strcmp ( argv [ i ] , "-linsys" ) == 0 ) { * DEBUG_LINEAR_SYSTEM = 1 ; } else if ( strcmp ( argv [ i ] , "-umf-solve" ) == 0 ) { * UMF_SOLVE = 1 ; <S2SV_StartBug> } else if ( strcmp ( argv [ i ] , "-print-s" ) == 0 ) { <S2SV_EndBug> * PRINT_SOLUTION = 1 ; } else if ( strcmp ( argv [ i ] , "-plot" ) == 0 ) { * PLOT_SOLUTION = 1 ; } else if ( strcmp ( argv [ i ] , "-sgs-solve" ) == 0 ) { * SGS_SOLVE = 1 ; } else if ( strcmp ( argv [ i ] , "-sgs-prec-debug" ) == 0 ) { * PREC_DEBUG = 1 ; } else if ( strcmp ( argv [ i ] , "-plot-residue" ) == 0 ) { * NORM_RESIDUE = 1 ; } else if ( strcmp ( argv [ i ] , "-mg-solve" ) == 0 ) { * MG_SOLVE = 1 ; } else if ( strcmp ( argv [ i ] , "-mg-smooth-debug" ) == 0 ) { * MG_PREC_DEBUG = 1 ; } else if ( strcmp ( argv [ i ] , "-mg-mat-debug" ) == 0 ) { * MAT_MG_DEBUG = 1 ; } } } | <S2SV_ModStart> i ] , "-print" <S2SV_ModEnd> ) == 0 |
6,426 | CWE-000 int get_next_line ( const int fd , char * * line ) { char * tmp ; static t_struct l ; int j ; tmp = ft_strnew ( 1 ) ; if ( fd < 0 || line == NULL || BUFF_SIZE < 1 ) return ( - 1 ) ; if ( l . str ) { if ( ( l . str [ 0 ] == '\\n' && l . str [ 1 ] == '\\n' && l . str [ 2 ] == '\\0' ) ) { <S2SV_StartBug> * line = NULL ; <S2SV_EndBug> l . str = ft_strsub ( l . str , 1 , ( ft_strlen ( l . str ) - 2 ) ) ; return ( 1 ) ; } if ( ( j = ft_find_last_char ( l . str , '\\n' ) ) > 0 ) l . str = ft_strsub ( l . str , j , ( ft_strlen ( l . str ) - j ) ) ; if ( ft_strchr ( l . str , '\\n' ) ) return ( ft_return ( line , & l , tmp ) ) ; tmp = ft_strdup ( l . str ) ; ft_strdel ( & l . str ) ; } return ( ft_read ( & l , tmp , line , fd ) ) ; } | <S2SV_ModStart> * line = "" <S2SV_ModEnd> ; l . |
6,427 | CWE-000 static int char_navigate_proc ( struct menu_item * item , enum menu_navigation nav ) { int n = strchr ( charset , item -> text [ 0 ] ) - charset ; <S2SV_StartBug> if ( nav == MENU_NAVIGATE_UP ) <S2SV_EndBug> <S2SV_StartBug> ++ n ; <S2SV_EndBug> else if ( nav == MENU_NAVIGATE_DOWN ) <S2SV_StartBug> -- n ; <S2SV_EndBug> else return 0 ; n = ( n + charset_size ) % charset_size ; item -> text [ 0 ] = charset [ n ] ; return 1 ; } | <S2SV_ModStart> - charset ; int d = ( input_pad ( ) & BUTTON_Z ) ? 3 : 1 ; <S2SV_ModStart> == MENU_NAVIGATE_UP ) n += d <S2SV_ModEnd> ; else if <S2SV_ModStart> == MENU_NAVIGATE_DOWN ) n -= d <S2SV_ModEnd> ; else return |
6,428 | CWE-000 static void <S2SV_StartBug> gpuMemCopyFromSSDWaitRaw ( unsigned long dma_task_id ) <S2SV_EndBug> { StromCmd__MemCopyWait cmd ; memset ( & cmd , 0 , sizeof ( StromCmd__MemCopyWait ) ) ; cmd . dma_task_id = dma_task_id ; <S2SV_StartBug> if ( nvme_strom_ioctl ( STROM_IOCTL__MEMCPY_WAIT , & cmd ) != 0 ) <S2SV_EndBug> <S2SV_StartBug> werror ( "failed<S2SV_blank>on<S2SV_blank>nvme_strom_ioctl(STROM_IOCTL__MEMCPY_WAIT):<S2SV_blank>%m" ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> void gpuMemCopyFromSSDWaitRaw ( GpuContext * gcontext , <S2SV_ModStart> = dma_task_id ; retry : <S2SV_ModStart> != 0 ) { if ( errno != EINTR ) <S2SV_ModStart> "failed<S2SV_blank>on<S2SV_blank>nvme_strom_ioctl(STROM_IOCTL__MEMCPY_WAIT):<S2SV_blank>%m" ) ; if ( pg_atomic_read_u32 ( & gcontext -> terminate_workers ) != 0 ) werror ( "termination<S2SV_blank>of<S2SV_blank>GpuContext<S2SV_blank>worker" ) ; goto retry ; } |
6,429 | CWE-000 <S2SV_StartBug> static inline void init_first_anchor ( linked_list_t * list ) { <S2SV_EndBug> <S2SV_StartBug> list -> first_anchor_ -> prev = NULL ; <S2SV_EndBug> <S2SV_StartBug> list -> first_anchor_ -> next = get_last_anchor ; <S2SV_EndBug> <S2SV_StartBug> list -> first_anchor_ -> list = list ; <S2SV_EndBug> <S2SV_StartBug> list -> first_anchor_ -> key = INT_MIN ; <S2SV_EndBug> init_node_locks ( list -> first_anchor_ ) ; } | <S2SV_ModStart> void init_first_anchor ( linked_list <S2SV_ModEnd> list ) { <S2SV_ModStart> -> first_anchor_ -> prev_ <S2SV_ModEnd> = NULL ; <S2SV_ModStart> -> first_anchor_ -> next_ = get_last_anchor ( list ) <S2SV_ModEnd> ; list -> <S2SV_ModStart> -> first_anchor_ -> list_ <S2SV_ModEnd> = list ; <S2SV_ModStart> -> first_anchor_ -> key_ <S2SV_ModEnd> = INT_MIN ; |
6,430 | CWE-000 fofNode * new_fofNode ( char * name , NODE_TYPE type , StringInt val ) { fofNode * node = ( fofNode * ) calloc ( 1 , sizeof ( fofNode ) ) ; node -> pszName = ( char * ) malloc ( strlen ( name ) + 1 ) ; <S2SV_StartBug> strcpy ( node -> pszName , name ) ; <S2SV_EndBug> node -> pszName [ strlen ( name ) ] = '\\0' ; node -> nodeCount = - 1 ; if ( type == FOLDER_NODE ) { node -> nodeCount = 0 ; } else if ( type == STRING_NODE ) { node -> val_c = ( char * ) malloc ( strlen ( val . c ) + 1 ) ; strcpy ( node -> val_c , val . c ) ; <S2SV_StartBug> node -> val_c [ strlen ( val . c ) ] = '\\0' ; <S2SV_EndBug> node -> nodeCount = - 1 ; } else { node -> val_i = val . i ; node -> nodeCount = - 1 ; } return node ; } | <S2SV_ModStart> , name ) <S2SV_ModEnd> ; node -> <S2SV_ModStart> ; node -> <S2SV_ModEnd> nodeCount = - |
6,431 | CWE-000 int epf_trigger ( char * buf , unsigned int size , ep_act_type type , ep_op_type op ) { ep_t_hdr * h = ( ep_t_hdr * ) ( buf ) ; if ( size < sizeof ( ep_t_hdr ) ) { ep_dbg_log ( "F<S2SV_blank>-<S2SV_blank>TRIG:<S2SV_blank>Not<S2SV_blank>enough<S2SV_blank>space!\\n" ) ; return - 1 ; } <S2SV_StartBug> h -> type = ( uint8_t ) type ; <S2SV_EndBug> h -> op = ( uint8_t ) op ; ep_dbg_dump ( "F<S2SV_blank>-<S2SV_blank>TRIG:<S2SV_blank>" , buf , sizeof ( ep_t_hdr ) ) ; return sizeof ( ep_t_hdr ) ; } | <S2SV_ModStart> -> type = htons ( type ) <S2SV_ModEnd> ; h -> |
6,432 | CWE-000 void mca_pml_ob1_recv_request_progress_rndv ( mca_pml_ob1_recv_request_t * recvreq , mca_btl_base_module_t * btl , mca_btl_base_segment_t * segments , size_t num_segments ) { size_t bytes_received = 0 ; size_t bytes_delivered __opal_attribute_unused__ ; size_t data_offset = 0 ; mca_pml_ob1_hdr_t * hdr = ( mca_pml_ob1_hdr_t * ) segments -> seg_addr . pval ; bytes_received = mca_pml_ob1_compute_segment_length_base ( segments , num_segments , sizeof ( mca_pml_ob1_rendezvous_hdr_t ) ) ; recvreq -> req_recv . req_bytes_packed = hdr -> hdr_rndv . hdr_msg_length ; recvreq -> remote_req_send = hdr -> hdr_rndv . hdr_src_req ; recvreq -> req_rdma_offset = bytes_received ; MCA_PML_OB1_RECV_REQUEST_MATCHED ( recvreq , & hdr -> hdr_match ) ; mca_pml_ob1_recv_request_ack ( recvreq , & hdr -> hdr_rndv , bytes_received ) ; if ( 0 < bytes_received ) { MEMCHECKER ( memchecker_call ( & opal_memchecker_base_mem_defined , recvreq -> req_recv . req_base . req_addr , recvreq -> req_recv . req_base . req_count , recvreq -> req_recv . req_base . req_datatype ) ; ) ; MCA_PML_OB1_RECV_REQUEST_UNPACK ( recvreq , segments , num_segments , sizeof ( mca_pml_ob1_rendezvous_hdr_t ) , data_offset , bytes_received , bytes_delivered ) ; MEMCHECKER ( memchecker_call ( & opal_memchecker_base_mem_noaccess , recvreq -> req_recv . req_base . req_addr , recvreq -> req_recv . req_base . req_count , recvreq -> req_recv . req_base . req_datatype ) ; ) ; OPAL_THREAD_ADD_FETCH_SIZE_T ( & recvreq -> req_bytes_received , bytes_received ) ; <S2SV_StartBug> SW_EVENT_USER_OR_MPI ( recvreq -> req_recv . req_base . req_tag , ( long long ) bytes_received , OMPI_BYTES_RECEIVED_USER , OMPI_BYTES_RECEIVED_MPI ) ; <S2SV_EndBug> } if ( recv_request_pml_complete_check ( recvreq ) == false && recvreq -> req_rdma_offset < recvreq -> req_send_offset ) { mca_pml_ob1_recv_request_schedule ( recvreq , NULL ) ; } # if OPAL_CUDA_SUPPORT if ( ( recvreq -> req_recv . req_base . req_convertor . flags & CONVERTOR_CUDA ) && ( btl -> btl_flags & MCA_BTL_FLAGS_CUDA_COPY_ASYNC_RECV ) ) { void * strm = mca_common_cuda_get_htod_stream ( ) ; opal_cuda_set_copy_function_async ( & recvreq -> req_recv . req_base . req_convertor , strm ) ; } # endif } | <S2SV_ModStart> bytes_received ) ; SPC_USER_OR_MPI <S2SV_ModEnd> ( recvreq -> |
6,433 | CWE-000 void rtw_wep_encrypt ( _adapter * padapter , u8 * pxmitframe ) { unsigned char crc [ 4 ] ; struct arc4context mycontext ; sint curfragnum , length ; u32 keylength ; u8 * pframe , * payload , * iv ; u8 wepkey [ 16 ] ; u8 hw_hdr_offset = 0 ; struct pkt_attrib * pattrib = & ( ( struct xmit_frame * ) pxmitframe ) -> attrib ; struct security_priv * psecuritypriv = & padapter -> securitypriv ; struct xmit_priv * pxmitpriv = & padapter -> xmitpriv ; if ( ( ( struct xmit_frame * ) pxmitframe ) -> buf_addr == NULL ) return ; # ifdef CONFIG_USB_TX_AGGREGATION hw_hdr_offset = TXDESC_SIZE + ( ( ( struct xmit_frame * ) pxmitframe ) -> pkt_offset * PACKET_OFFSET_SZ ) ; # else # ifdef CONFIG_TX_EARLY_MODE hw_hdr_offset = TXDESC_OFFSET + EARLY_MODE_INFO_SIZE ; # else hw_hdr_offset = TXDESC_OFFSET ; # endif # endif pframe = ( ( struct xmit_frame * ) pxmitframe ) -> buf_addr + hw_hdr_offset ; if ( ( pattrib -> encrypt == _WEP40_ ) || ( pattrib -> encrypt == _WEP104_ ) ) { keylength = psecuritypriv -> dot11DefKeylen [ psecuritypriv -> dot11PrivacyKeyIndex ] ; for ( curfragnum = 0 ; curfragnum < pattrib -> nr_frags ; curfragnum ++ ) { iv = pframe + pattrib -> hdrlen ; _rtw_memcpy ( & wepkey [ 0 ] , iv , 3 ) ; _rtw_memcpy ( & wepkey [ 3 ] , & psecuritypriv -> dot11DefKey [ psecuritypriv -> dot11PrivacyKeyIndex ] . skey [ 0 ] , keylength ) ; payload = pframe + pattrib -> iv_len + pattrib -> hdrlen ; if ( ( curfragnum + 1 ) == pattrib -> nr_frags ) { length = pattrib -> last_txcmdsz - pattrib -> hdrlen - pattrib -> iv_len - pattrib -> icv_len ; <S2SV_StartBug> * ( ( u32 * ) crc ) = cpu_to_le32 ( getcrc32 ( payload , length ) ) ; <S2SV_EndBug> arcfour_init ( & mycontext , wepkey , 3 + keylength ) ; arcfour_encrypt ( & mycontext , payload , payload , length ) ; arcfour_encrypt ( & mycontext , payload + length , crc , 4 ) ; } else { length = pxmitpriv -> frag_len - pattrib -> hdrlen - pattrib -> iv_len - pattrib -> icv_len ; <S2SV_StartBug> * ( ( u32 * ) crc ) = cpu_to_le32 ( getcrc32 ( payload , length ) ) ; <S2SV_EndBug> arcfour_init ( & mycontext , wepkey , 3 + keylength ) ; arcfour_encrypt ( & mycontext , payload , payload , length ) ; arcfour_encrypt ( & mycontext , payload + length , crc , 4 ) ; pframe += pxmitpriv -> frag_len ; pframe = ( u8 * ) RND4 ( ( SIZE_PTR ) ( pframe ) ) ; } } WEP_SW_ENC_CNT_INC ( psecuritypriv , pattrib -> ra ) ; } } | <S2SV_ModStart> * ( ( __le32 <S2SV_ModEnd> * ) crc <S2SV_ModStart> * ( ( __le32 <S2SV_ModEnd> * ) crc |
6,434 | CWE-000 char * itoa_helper ( t_info * var , long long n , char * new , int num_len ) { <S2SV_StartBug> long long original ; <S2SV_EndBug> original = n ; <S2SV_StartBug> while ( n ) <S2SV_EndBug> { if ( n >= 0 ) new [ num_len ] = '0' + n % 10 ; else new [ num_len ] = '0' - n % 10 ; n /= 10 ; num_len -- ; } while ( num_len >= 0 ) { new [ num_len ] = '0' ; num_len -- ; } <S2SV_StartBug> if ( original < 0 ) <S2SV_EndBug> new [ 0 ] = '-' ; else if ( var -> fl . plus_f == 1 ) new [ 0 ] = '+' ; else if ( var -> fl . sp_f == 1 ) new [ 0 ] = '<S2SV_blank>' ; return ( new ) ; } | <S2SV_ModStart> num_len ) { <S2SV_ModEnd> while ( n <S2SV_ModStart> while ( n && var <S2SV_ModStart> -- ; } <S2SV_ModEnd> return ( new |
6,435 | CWE-000 static int mr_data_lengthval_json ( DB_VALUE * value , int disk ) { DB_VALUE json_body , schema_raw ; unsigned int json_body_length ; unsigned int raw_schema_length ; if ( ! disk ) { <S2SV_StartBug> return sizeof ( DB_JSON ) ; <S2SV_EndBug> } db_make_string ( & json_body , value -> data . json . json_body ) ; if ( value -> data . json . schema_raw != NULL ) { db_make_string ( & schema_raw , value -> data . json . schema_raw ) ; } else { db_make_string ( & schema_raw , "" ) ; } json_body_length = mr_data_lengthval_string ( & json_body , disk ) ; raw_schema_length = mr_data_lengthval_string ( & schema_raw , disk ) ; pr_clear_value ( & json_body ) ; pr_clear_value ( & schema_raw ) ; return json_body_length + raw_schema_length ; } | <S2SV_ModStart> ) { return tp_Json . size <S2SV_ModEnd> ; } db_make_string |
6,436 | CWE-000 static void test_worst_case ( void ) { AVLTree * tree ; const unsigned long count = 10000 ; avl_tree_new ( & tree , compare_numbers , NULL ) ; for ( unsigned long i = 0 ; i < count ; i += 1 ) avl_tree_insert ( tree , ( void * ) i , ( void * ) i ) ; assert ( avl_tree_get_n_elements ( tree ) == count ) ; <S2SV_StartBug> assert ( avl_tree_get_height ( tree ) == ( unsigned long ) log2 ( count ) + 1 ) ; <S2SV_EndBug> assert ( avl_tree_free ( tree ) == NULL ) ; avl_tree_new ( & tree , compare_numbers , NULL ) ; for ( unsigned long i = count ; i > 0 ; i -= 1 ) avl_tree_insert ( tree , ( void * ) i , ( void * ) i ) ; assert ( avl_tree_get_n_elements ( tree ) == count ) ; assert ( avl_tree_get_height ( tree ) == ( unsigned long ) log2 ( count ) + 1 ) ; assert ( avl_tree_free ( tree ) == NULL ) ; } | <S2SV_ModStart> ) + 1 ) ; for ( unsigned long i = 0 ; i < count ; i += 1 ) avl_tree_remove ( tree , ( void * ) i ) ; assert ( avl_tree_get_n_elements ( tree ) == 0 |
6,437 | CWE-000 static int yy_get_next_buffer ( ) { char * dest = YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf ; char * source = ( yytext_ptr ) ; yy_size_t number_to_move , i ; int ret_val ; if ( ( yy_c_buf_p ) > & YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf [ ( yy_n_chars ) + 1 ] ) YY_FATAL_ERROR ( "fatal<S2SV_blank>flex<S2SV_blank>scanner<S2SV_blank>internal<S2SV_blank>error--end<S2SV_blank>of<S2SV_blank>buffer<S2SV_blank>missed" ) ; if ( YY_CURRENT_BUFFER_LVALUE -> yy_fill_buffer == 0 ) { if ( ( yy_c_buf_p ) - ( yytext_ptr ) - YY_MORE_ADJ == 1 ) { return EOB_ACT_END_OF_FILE ; } else { return EOB_ACT_LAST_MATCH ; } } number_to_move = ( yy_size_t ) ( ( yy_c_buf_p ) - ( yytext_ptr ) ) - 1 ; for ( i = 0 ; i < number_to_move ; ++ i ) * ( dest ++ ) = * ( source ++ ) ; if ( YY_CURRENT_BUFFER_LVALUE -> yy_buffer_status == YY_BUFFER_EOF_PENDING ) { YY_CURRENT_BUFFER_LVALUE -> yy_n_chars = ( yy_n_chars ) = 0 ; } else { <S2SV_StartBug> yy_size_t num_to_read = <S2SV_EndBug> YY_CURRENT_BUFFER_LVALUE -> yy_buf_size - number_to_move - 1 ; while ( num_to_read <= 0 ) { YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE ; int yy_c_buf_p_offset = ( int ) ( ( yy_c_buf_p ) - b -> yy_ch_buf ) ; if ( b -> yy_is_our_buffer ) { <S2SV_StartBug> yy_size_t new_size = b -> yy_buf_size * 2 ; <S2SV_EndBug> if ( new_size <= 0 ) <S2SV_StartBug> b -> yy_buf_size += b -> yy_buf_size / 8 ; <S2SV_EndBug> else b -> yy_buf_size *= 2 ; b -> yy_ch_buf = ( char * ) yyrealloc ( ( void * ) b -> yy_ch_buf , b -> yy_buf_size + 2 ) ; } else b -> yy_ch_buf = 0 ; if ( ! b -> yy_ch_buf ) YY_FATAL_ERROR ( "fatal<S2SV_blank>error<S2SV_blank>-<S2SV_blank>scanner<S2SV_blank>input<S2SV_blank>buffer<S2SV_blank>overflow" ) ; ( yy_c_buf_p ) = & b -> yy_ch_buf [ yy_c_buf_p_offset ] ; <S2SV_StartBug> num_to_read = YY_CURRENT_BUFFER_LVALUE -> yy_buf_size - <S2SV_EndBug> <S2SV_StartBug> number_to_move - 1 ; <S2SV_EndBug> } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE ; YY_INPUT ( ( & YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf [ number_to_move ] ) , ( yy_n_chars ) , num_to_read ) ; YY_CURRENT_BUFFER_LVALUE -> yy_n_chars = ( yy_n_chars ) ; } if ( ( yy_n_chars ) == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE ; yyrestart ( yyin ) ; } else { ret_val = EOB_ACT_LAST_MATCH ; YY_CURRENT_BUFFER_LVALUE -> yy_buffer_status = YY_BUFFER_EOF_PENDING ; } } else ret_val = EOB_ACT_CONTINUE_SCAN ; if ( ( yy_size_t ) ( ( yy_n_chars ) + number_to_move ) > YY_CURRENT_BUFFER_LVALUE -> yy_buf_size ) { yy_size_t new_size = ( yy_n_chars ) + number_to_move + ( ( yy_n_chars ) >> 1 ) ; YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf = ( char * ) yyrealloc ( ( void * ) YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf , new_size ) ; if ( ! YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf ) YY_FATAL_ERROR ( "out<S2SV_blank>of<S2SV_blank>dynamic<S2SV_blank>memory<S2SV_blank>in<S2SV_blank>yy_get_next_buffer()" ) ; } ( yy_n_chars ) += number_to_move ; YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf [ ( yy_n_chars ) ] = YY_END_OF_BUFFER_CHAR ; YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf [ ( yy_n_chars ) + 1 ] = YY_END_OF_BUFFER_CHAR ; ( yytext_ptr ) = & YY_CURRENT_BUFFER_LVALUE -> yy_ch_buf [ 0 ] ; return ret_val ; } | <S2SV_ModStart> { yy_size_t num_to_read ; YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE ; while ( b -> yy_buf_size <= number_to_move + 1 ) { <S2SV_ModEnd> int yy_c_buf_p_offset = <S2SV_ModStart> yy_is_our_buffer ) { <S2SV_ModEnd> b -> yy_buf_size <S2SV_ModStart> -> yy_buf_size / 4 <S2SV_ModEnd> ; b -> <S2SV_ModStart> yy_c_buf_p_offset ] ; } num_to_read = b <S2SV_ModEnd> -> yy_buf_size - <S2SV_ModStart> -> yy_buf_size - number_to_move - 1 ; <S2SV_ModEnd> if ( num_to_read |
6,438 | CWE-000 m_bool scan1_stmt_union ( Env env , Stmt_Union stmt ) { <S2SV_StartBug> m_str name = s_name ( stmt -> xid ) ; <S2SV_EndBug> <S2SV_StartBug> Decl_List l = stmt -> l ; <S2SV_EndBug> if ( name ) { Type t = type_copy ( env , & t_union ) ; t -> name = name ; t -> info = new_nspc ( name , "[union<S2SV_blank>declarator]" ) ; t -> info -> parent = env -> curr ; stmt -> value = new_value ( t , name ) ; stmt -> value -> owner_class = env -> class_def ; stmt -> value -> owner = env -> curr ; nspc_add_value ( env -> curr , stmt -> xid , stmt -> value ) ; SET_FLAG ( stmt -> value , ae_flag_checked ) ; if ( env -> class_def ) SET_FLAG ( stmt -> value , ae_flag_member ) ; env_push_class ( env , stmt -> value -> m_type ) ; } while ( l ) { Var_Decl_List list = l -> self -> d . exp_decl . list ; if ( l -> self -> exp_type != ae_exp_decl ) CHECK_BB ( err_msg ( SCAN1_ , stmt -> pos , "invalid<S2SV_blank>expression<S2SV_blank>type<S2SV_blank>\'%i\'<S2SV_blank>in<S2SV_blank>union<S2SV_blank>declaration." ) ) while ( list ) { Var_Decl var_decl = list -> self ; if ( var_decl -> array ) CHECK_BB ( scan1_stmt_union_array ( var_decl -> array ) ) list = list -> next ; } CHECK_BB ( scan1_exp_decl ( env , & l -> self -> d . exp_decl ) ) l = l -> next ; } <S2SV_StartBug> if ( name ) <S2SV_EndBug> env_pop_class ( env ) ; return 1 ; } | <S2SV_ModStart> stmt ) { Decl_List l = stmt -> l ; if ( stmt -> xid ) { <S2SV_ModStart> xid ) ; <S2SV_ModEnd> Type t = <S2SV_ModStart> } if ( stmt -> xid <S2SV_ModEnd> ) env_pop_class ( |
6,439 | CWE-000 struct sss_cmd_table * get_nss_cmds ( void ) { static struct sss_cmd_table nss_cmds [ ] = { { SSS_GET_VERSION , sss_cmd_get_version } , { SSS_NSS_GETPWNAM , nss_cmd_getpwnam } , { SSS_NSS_GETPWUID , nss_cmd_getpwuid } , { SSS_NSS_SETPWENT , nss_cmd_setpwent } , { SSS_NSS_GETPWENT , nss_cmd_getpwent } , { SSS_NSS_ENDPWENT , nss_cmd_endpwent } , { SSS_NSS_GETGRNAM , nss_cmd_getgrnam } , { SSS_NSS_GETGRGID , nss_cmd_getgrgid } , { SSS_NSS_SETGRENT , nss_cmd_setgrent } , { SSS_NSS_GETGRENT , nss_cmd_getgrent } , { SSS_NSS_ENDGRENT , nss_cmd_endgrent } , { SSS_NSS_INITGR , nss_cmd_initgroups } , { SSS_NSS_SETNETGRENT , nss_cmd_setnetgrent } , { SSS_NSS_GETNETGRENT , nss_cmd_getnetgrent } , { SSS_NSS_ENDNETGRENT , nss_cmd_endnetgrent } , { SSS_NSS_GETSERVBYNAME , nss_cmd_getservbyname } , { SSS_NSS_GETSERVBYPORT , nss_cmd_getservbyport } , { SSS_NSS_SETSERVENT , nss_cmd_setservent } , { SSS_NSS_GETSERVENT , nss_cmd_getservent } , { SSS_NSS_ENDSERVENT , nss_cmd_endservent } , { SSS_NSS_GETSIDBYNAME , nss_cmd_getsidbyname } , { SSS_NSS_GETSIDBYID , nss_cmd_getsidbyid } , { SSS_NSS_GETNAMEBYSID , nss_cmd_getnamebysid } , { SSS_NSS_GETIDBYSID , nss_cmd_getidbysid } , { SSS_NSS_GETORIGBYNAME , nss_cmd_getorigbyname } , { SSS_NSS_GETNAMEBYCERT , nss_cmd_getnamebycert } , { SSS_NSS_GETLISTBYCERT , nss_cmd_getlistbycert } , <S2SV_StartBug> { SSS_CLI_NULL , NULL } <S2SV_EndBug> } ; return nss_cmds ; } | <S2SV_ModStart> } , { SSS_NSS_GETPWNAM_EX , nss_cmd_getpwnam_ex } , { SSS_NSS_GETPWUID_EX , nss_cmd_getpwuid_ex } , { SSS_NSS_GETGRNAM_EX , nss_cmd_getgrnam_ex } , { SSS_NSS_GETGRGID_EX , nss_cmd_getgrgid_ex } , { SSS_NSS_INITGR_EX , nss_cmd_initgroups_ex } , { |
6,440 | CWE-000 bitpunch_status_t index_cache_iterator_next_twin ( struct index_cache_iterator * iter , struct track_path * item_pathp , struct browse_state * bst ) { <S2SV_StartBug> struct filter_instance_array * array ; <S2SV_EndBug> struct tracker * xtk ; bitpunch_status_t bt_ret ; <S2SV_StartBug> struct ast_node_hdl * item_type ; <S2SV_EndBug> int64_t index_end ; xtk = iter -> xtk ; if ( BLOOM_BOOK_MARK_NONE == iter -> mark ) { return BITPUNCH_NO_ITEM ; } if ( ! iter -> first ) { bt_ret = tracker_goto_next_item_internal ( xtk , bst ) ; if ( BITPUNCH_OK != bt_ret ) { return bt_ret ; } } <S2SV_StartBug> array = ( struct filter_instance_array * ) <S2SV_EndBug> xtk -> box -> filter -> ndat -> u . rexpr_filter . f_instance ; item_type = array -> item_type ; index_end = iter -> in_slice_path . u . array_slice . index_end ; while ( TRUE ) { bt_ret = tracker_goto_next_key_match_in_mark ( xtk , iter -> key , iter -> mark , bst ) ; if ( iter -> mark == iter -> from_mark ) { while ( BITPUNCH_OK == bt_ret && ( xtk -> cur . u . array . index < iter -> in_slice_path . u . array . index ) ) { bt_ret = tracker_goto_next_item_internal ( xtk , bst ) ; if ( BITPUNCH_OK == bt_ret ) { bt_ret = tracker_goto_next_key_match_in_mark ( xtk , iter -> key , iter -> mark , bst ) ; } } } if ( BITPUNCH_OK == bt_ret && - 1 != index_end && xtk -> cur . u . array . index >= index_end ) { return BITPUNCH_NO_ITEM ; } if ( BITPUNCH_NO_ITEM != bt_ret ) { break ; } iter -> mark = bloom_book_lookup_word_get_next_candidate ( xtk -> box -> u . array . cache_by_key , & iter -> bloom_cookie ) ; if ( BLOOM_BOOK_MARK_NONE == iter -> mark ) { return BITPUNCH_NO_ITEM ; } <S2SV_StartBug> bt_ret = tracker_goto_mark_internal ( xtk , item_type , iter -> mark , bst ) ; <S2SV_EndBug> if ( BITPUNCH_OK != bt_ret ) { break ; } } if ( BITPUNCH_OK == bt_ret ) { * item_pathp = xtk -> cur ; } iter -> from_mark = BLOOM_BOOK_MARK_NONE ; iter -> first = FALSE ; return bt_ret ; } | <S2SV_ModStart> ) { struct <S2SV_ModEnd> tracker * xtk <S2SV_ModStart> bitpunch_status_t bt_ret ; <S2SV_ModEnd> int64_t index_end ; <S2SV_ModStart> ; } } <S2SV_ModEnd> index_end = iter <S2SV_ModStart> ( xtk , <S2SV_ModEnd> iter -> mark |
6,441 | CWE-000 static int venus_hfi_session_clean ( void * session ) { <S2SV_StartBug> struct hal_session * sess_close ; <S2SV_EndBug> if ( ! session ) { dprintk ( VIDC_ERR , "Invalid<S2SV_blank>Params<S2SV_blank>%s" , __func__ ) ; return - EINVAL ; } sess_close = session ; device = sess_close -> device ; dprintk ( VIDC_DBG , "deleted<S2SV_blank>the<S2SV_blank>session:<S2SV_blank>0x%pK" , sess_close ) ; mutex_lock ( & ( ( struct venus_hfi_device * ) sess_close -> device ) -> session_lock ) ; list_del ( & sess_close -> list ) ; mutex_unlock ( & ( ( struct venus_hfi_device * ) sess_close -> device ) -> session_lock ) ; kfree ( sess_close ) ; return 0 ; } | <S2SV_ModStart> hal_session * sess_close ; struct venus_hfi_device * device |
6,442 | CWE-000 Board init_board ( ) { Board board = malloc ( sizeof ( struct board ) ) ; for ( int i = 0 ; i < 7 ; i ++ ) for ( int j = 0 ; j < 7 ; j ++ ) board -> tab [ i ] [ j ] = - 1 ; for ( int i = 0 ; i < 7 ; i ++ ) if ( i != 3 ) board -> tab [ i ] [ 3 ] = 0 ; for ( int i = 0 ; i < 7 ; i ++ ) if ( i != 3 ) board -> tab [ 3 ] [ i ] = 0 ; for ( int i = 0 ; i < 7 ; i ++ ) if ( i != 3 ) board -> tab [ i ] [ i ] = 0 ; for ( int i = 0 ; i < 7 ; i ++ ) if ( i != 3 ) board -> tab [ i ] [ 6 - i ] = 0 ; board -> update = 0 ; <S2SV_StartBug> board -> state = PLACE ; <S2SV_EndBug> board -> turn = FIRST ; board -> player [ FIRST ] = init_player ( "p1" ) ; board -> player [ SECOND ] = init_player ( "p2" ) ; return board ; } | <S2SV_ModStart> ; board -> last_y = - 1 ; board -> last_x = - 1 ; board -> |
6,443 | CWE-000 static int cram_byte_array_stop_decode_char ( cram_slice * slice , cram_codec * c , cram_block * in , char * out , int * out_size ) { char * cp , ch ; cram_block * b = NULL ; <S2SV_StartBug> if ( ! ( b = c -> byte_array_stop . b ) ) { <S2SV_EndBug> b = cram_get_block_by_id ( slice , c -> byte_array_stop . content_id ) ; <S2SV_StartBug> c -> byte_array_stop . b = b ; <S2SV_EndBug> } if ( ! b ) return * out_size ? - 1 : 0 ; if ( b -> idx >= b -> uncomp_size ) return - 1 ; cp = ( char * ) b -> data + b -> idx ; if ( out ) { while ( ( ch = * cp ) != ( char ) c -> byte_array_stop . stop ) { if ( cp - ( char * ) b -> data >= b -> uncomp_size ) return - 1 ; * out ++ = ch ; cp ++ ; } } else { while ( ( ch = * cp ) != ( char ) c -> byte_array_stop . stop ) { if ( cp - ( char * ) b -> data >= b -> uncomp_size ) return - 1 ; cp ++ ; } } * out_size = cp - ( char * ) ( b -> data + b -> idx ) ; b -> idx = cp - ( char * ) b -> data + 1 ; return 0 ; } | <S2SV_ModStart> = NULL ; <S2SV_ModEnd> b = cram_get_block_by_id <S2SV_ModStart> content_id ) ; <S2SV_ModEnd> if ( ! |
6,444 | CWE-000 static int pre_IP ( DECL_ARGS ) { const struct man_node * nn ; size_t len ; int savelit , ival ; switch ( n -> type ) { case ( MAN_BODY ) : <S2SV_StartBug> p -> flags |= TERMP_NOLPAD ; <S2SV_EndBug> p -> flags |= TERMP_NOSPACE ; break ; case ( MAN_HEAD ) : p -> flags |= TERMP_NOBREAK ; break ; case ( MAN_BLOCK ) : print_bvspace ( p , n ) ; default : return ( 1 ) ; } len = mt -> lmargin [ mt -> lmargincur ] ; ival = - 1 ; if ( NULL != ( nn = n -> parent -> head -> child ) ) if ( NULL != ( nn = nn -> next ) ) if ( ( ival = a2width ( p , nn -> string ) ) >= 0 ) len = ( size_t ) ival ; switch ( n -> type ) { case ( MAN_HEAD ) : if ( 0 == len ) len = term_len ( p , 1 ) ; p -> offset = mt -> offset ; p -> rmargin = mt -> offset + len ; if ( ival < 0 ) break ; mt -> lmargin [ mt -> lmargincur ] = ( size_t ) ival ; savelit = MANT_LITERAL & mt -> fl ; mt -> fl &= ~ MANT_LITERAL ; if ( n -> child ) print_man_node ( p , mt , n -> child , m ) ; if ( savelit ) mt -> fl |= MANT_LITERAL ; return ( 0 ) ; case ( MAN_BODY ) : p -> offset = mt -> offset + len ; p -> rmargin = p -> maxrmargin ; break ; default : break ; } return ( 1 ) ; } | <S2SV_ModStart> -> flags |= <S2SV_ModEnd> TERMP_NOSPACE ; break |
6,445 | CWE-000 static void cxgb_down ( struct adapter * adapter ) { <S2SV_StartBug> struct hash_mac_addr * entry , * tmp ; <S2SV_EndBug> cancel_work_sync ( & adapter -> tid_release_task ) ; cancel_work_sync ( & adapter -> db_full_task ) ; cancel_work_sync ( & adapter -> db_drop_task ) ; adapter -> tid_release_task_busy = false ; adapter -> tid_release_head = NULL ; t4_sge_stop ( adapter ) ; t4_free_sge_resources ( adapter ) ; <S2SV_StartBug> list_for_each_entry_safe ( entry , tmp , & adapter -> mac_hlist , list ) { <S2SV_EndBug> list_del ( & entry -> list ) ; kfree ( entry ) ; } adapter -> flags &= ~ FULL_INIT_DONE ; } | <S2SV_ModStart> adapter ) { <S2SV_ModEnd> cancel_work_sync ( & <S2SV_ModStart> adapter ) ; <S2SV_ModEnd> adapter -> flags |
6,446 | CWE-000 int main ( int argc , char * * argv ) { MPI_Datatype vec ; double * vecin , * vecout , ivalue ; int root , i , n , stride , errs = 0 ; int rank , size ; MPI_Aint vextent ; MTest_Init ( & argc , & argv ) ; MPI_Comm_size ( MPI_COMM_WORLD , & size ) ; MPI_Comm_rank ( MPI_COMM_WORLD , & rank ) ; n = 12 ; stride = 10 ; vecout = ( double * ) malloc ( n * stride * sizeof ( double ) ) ; vecin = ( double * ) malloc ( n * size * sizeof ( double ) ) ; MPI_Type_vector ( n , 1 , stride , MPI_DOUBLE , & vec ) ; MPI_Type_commit ( & vec ) ; MPI_Type_extent ( vec , & vextent ) ; if ( vextent != ( ( n - 1 ) * ( MPI_Aint ) stride + 1 ) * sizeof ( double ) ) { errs ++ ; printf ( "Vector<S2SV_blank>extent<S2SV_blank>is<S2SV_blank>%ld,<S2SV_blank>should<S2SV_blank>be<S2SV_blank>%ld\\n" , ( long ) vextent , ( long ) ( ( ( n - 1 ) * stride + 1 ) * sizeof ( double ) ) ) ; } for ( i = 0 ; i < n * size ; i ++ ) vecin [ i ] = ( double ) i ; for ( root = 0 ; root < size ; root ++ ) { for ( i = 0 ; i < n * stride ; i ++ ) vecout [ i ] = - 1.0 ; if ( rank == root ) { MPI_Scatter ( vecin , n , MPI_DOUBLE , vecout , 1 , vec , root , MPI_COMM_WORLD ) ; for ( i = 0 ; i < n ; i ++ ) { ivalue = n * root + i ; if ( vecout [ i * stride ] != ivalue ) { errs ++ ; printf ( "[%d]<S2SV_blank>Expected<S2SV_blank>%f<S2SV_blank>but<S2SV_blank>found<S2SV_blank>%f<S2SV_blank>for<S2SV_blank>vecout[%d]<S2SV_blank>on<S2SV_blank>root\\n" , rank , ivalue , vecout [ i * stride ] , i * stride ) ; } } } else { MPI_Scatter ( NULL , - 1 , MPI_DATATYPE_NULL , vecout , n , MPI_DOUBLE , root , MPI_COMM_WORLD ) ; for ( i = 0 ; i < n ; i ++ ) { ivalue = rank * n + i ; if ( vecout [ i ] != ivalue ) { printf ( "[%d]<S2SV_blank>Expected<S2SV_blank>%f<S2SV_blank>but<S2SV_blank>found<S2SV_blank>%f<S2SV_blank>for<S2SV_blank>vecout[%d]\\n" , rank , ivalue , vecout [ i ] , i ) ; errs ++ ; } } } } <S2SV_StartBug> MTest_Finalize ( errs ) ; <S2SV_EndBug> MPI_Type_free ( & vec ) ; MPI_Finalize ( ) ; return 0 ; } | <S2SV_ModStart> } } } free ( vecin ) ; free ( vecout ) ; |
6,447 | CWE-000 double sycamera_bsspec_dsigma ( double E0 , double p0 , double p02 , double eps0 , double k ) { double E = E0 - k , p2 = E * E - 1 , p = sqrt ( p2 ) , p3 = p2 * p , p03 = p02 * p0 , E0E = E0 * E , p0p = p0 * p , p0p2 = p0p * p0p , p0p3 = p0p2 * p0p , pf = p / ( p0 * k ) , eps = 2 * log ( E + p ) , L = 2 * log ( ( E0E + p0p - 1 ) / k ) , T1 = ( 4.0 / 3.0 ) - 2 * E0E * ( p02 + p2 ) / p0p2 + eps0 * E / p03 + eps * E0 / p3 - eps * eps0 / p0p , T2 = L * ( 8 * E0E / ( 3 * p0p ) + k * k / p0p3 * ( E0E * E0E + p0p2 ) ) , T3 = L * k / ( 2 * p0p ) * ( ( E0E + p02 ) * eps0 / p03 - <S2SV_StartBug> ( E0E + p2 ) * eps / p3 + 2 * k * E0E / p0p2 ) ; <S2SV_EndBug> printf ( "%e\\n" , pf * ( T1 + T2 + T3 ) ) ; return pf * ( T1 + T2 + T3 ) ; } | <S2SV_ModStart> E0E / p0p2 <S2SV_ModEnd> ) ; return |
6,448 | CWE-000 static int tcf_skbmod_init ( struct net * net , struct nlattr * nla , struct nlattr * est , struct tc_action * * a , int ovr , int bind ) { struct tc_action_net * tn = net_generic ( net , skbmod_net_id ) ; struct nlattr * tb [ TCA_SKBMOD_MAX + 1 ] ; struct tcf_skbmod_params * p , * p_old ; struct tc_skbmod * parm ; struct tcf_skbmod * d ; bool exists = false ; u8 * daddr = NULL ; u8 * saddr = NULL ; u16 eth_type = 0 ; u32 lflags = 0 ; int ret = 0 , err ; if ( ! nla ) return - EINVAL ; err = nla_parse_nested ( tb , TCA_SKBMOD_MAX , nla , skbmod_policy , NULL ) ; if ( err < 0 ) return err ; if ( ! tb [ TCA_SKBMOD_PARMS ] ) return - EINVAL ; if ( tb [ TCA_SKBMOD_DMAC ] ) { daddr = nla_data ( tb [ TCA_SKBMOD_DMAC ] ) ; lflags |= SKBMOD_F_DMAC ; } if ( tb [ TCA_SKBMOD_SMAC ] ) { saddr = nla_data ( tb [ TCA_SKBMOD_SMAC ] ) ; lflags |= SKBMOD_F_SMAC ; } if ( tb [ TCA_SKBMOD_ETYPE ] ) { eth_type = nla_get_u16 ( tb [ TCA_SKBMOD_ETYPE ] ) ; lflags |= SKBMOD_F_ETYPE ; } parm = nla_data ( tb [ TCA_SKBMOD_PARMS ] ) ; if ( parm -> flags & SKBMOD_F_SWAPMAC ) lflags = SKBMOD_F_SWAPMAC ; exists = tcf_idr_check ( tn , parm -> index , a , bind ) ; if ( exists && bind ) return 0 ; <S2SV_StartBug> if ( ! lflags ) <S2SV_EndBug> return - EINVAL ; <S2SV_StartBug> if ( ! exists ) { <S2SV_EndBug> ret = tcf_idr_create ( tn , parm -> index , est , a , & act_skbmod_ops , bind , true ) ; if ( ret ) return ret ; ret = ACT_P_CREATED ; } else { tcf_idr_release ( * a , bind ) ; if ( ! ovr ) return - EEXIST ; } d = to_skbmod ( * a ) ; ASSERT_RTNL ( ) ; p = kzalloc ( sizeof ( struct tcf_skbmod_params ) , GFP_KERNEL ) ; if ( unlikely ( ! p ) ) { if ( ret == ACT_P_CREATED ) tcf_idr_release ( * a , bind ) ; return - ENOMEM ; } p -> flags = lflags ; d -> tcf_action = parm -> action ; p_old = rtnl_dereference ( d -> skbmod_p ) ; if ( ovr ) spin_lock_bh ( & d -> tcf_lock ) ; if ( lflags & SKBMOD_F_DMAC ) ether_addr_copy ( p -> eth_dst , daddr ) ; if ( lflags & SKBMOD_F_SMAC ) ether_addr_copy ( p -> eth_src , saddr ) ; if ( lflags & SKBMOD_F_ETYPE ) p -> eth_type = htons ( eth_type ) ; rcu_assign_pointer ( d -> skbmod_p , p ) ; if ( ovr ) spin_unlock_bh ( & d -> tcf_lock ) ; if ( p_old ) kfree_rcu ( p_old , rcu ) ; if ( ret == ACT_P_CREATED ) tcf_idr_insert ( tn , * a ) ; return ret ; } | <S2SV_ModStart> ! lflags ) { if ( exists ) tcf_idr_release ( * a , bind ) ; <S2SV_ModStart> - EINVAL ; } |
6,449 | CWE-000 static uint16_t dpaa2_eventdev_enqueue_burst ( void * port , const struct rte_event ev [ ] , uint16_t nb_events ) { struct rte_eventdev * ev_dev = ( ( struct dpaa2_io_portal_t * ) port ) -> eventdev ; struct dpaa2_eventdev * priv = ev_dev -> data -> dev_private ; uint32_t queue_id = ev [ 0 ] . queue_id ; struct evq_info_t * evq_info = & priv -> evq_info [ queue_id ] ; uint32_t fqid ; struct qbman_swp * swp ; struct qbman_fd fd_arr [ MAX_TX_RING_SLOTS ] ; uint32_t loop , frames_to_send ; struct qbman_eq_desc eqdesc [ MAX_TX_RING_SLOTS ] ; uint16_t num_tx = 0 ; int ret ; RTE_SET_USED ( port ) ; if ( unlikely ( ! DPAA2_PER_LCORE_DPIO ) ) { ret = dpaa2_affine_qbman_swp ( ) ; if ( ret ) { <S2SV_StartBug> PMD_DRV_LOG ( ERR , PMD , "Failure<S2SV_blank>in<S2SV_blank>affining<S2SV_blank>portal\\n" ) ; <S2SV_EndBug> return 0 ; } } swp = DPAA2_PER_LCORE_PORTAL ; while ( nb_events ) { frames_to_send = ( nb_events >> 3 ) ? MAX_TX_RING_SLOTS : nb_events ; for ( loop = 0 ; loop < frames_to_send ; loop ++ ) { const struct rte_event * event = & ev [ num_tx + loop ] ; if ( event -> sched_type != RTE_SCHED_TYPE_ATOMIC ) fqid = evq_info -> dpci -> queue [ DPAA2_EVENT_DPCI_PARALLEL_QUEUE ] . fqid ; else fqid = evq_info -> dpci -> queue [ DPAA2_EVENT_DPCI_ATOMIC_QUEUE ] . fqid ; qbman_eq_desc_clear ( & eqdesc [ loop ] ) ; qbman_eq_desc_set_fq ( & eqdesc [ loop ] , fqid ) ; qbman_eq_desc_set_no_orp ( & eqdesc [ loop ] , 0 ) ; qbman_eq_desc_set_response ( & eqdesc [ loop ] , 0 , 0 ) ; if ( event -> impl_opaque ) { uint8_t dqrr_index = event -> impl_opaque - 1 ; qbman_eq_desc_set_dca ( & eqdesc [ loop ] , 1 , dqrr_index , 0 ) ; DPAA2_PER_LCORE_DPIO -> dqrr_size -- ; DPAA2_PER_LCORE_DPIO -> dqrr_held &= ~ ( 1 << dqrr_index ) ; } memset ( & fd_arr [ loop ] , 0 , sizeof ( struct qbman_fd ) ) ; struct rte_event * ev_temp = rte_malloc ( NULL , sizeof ( struct rte_event ) , 0 ) ; rte_memcpy ( ev_temp , event , sizeof ( struct rte_event ) ) ; DPAA2_SET_FD_ADDR ( ( & fd_arr [ loop ] ) , ev_temp ) ; DPAA2_SET_FD_LEN ( ( & fd_arr [ loop ] ) , sizeof ( struct rte_event ) ) ; } loop = 0 ; while ( loop < frames_to_send ) { loop += qbman_swp_enqueue_multiple_eqdesc ( swp , & eqdesc [ loop ] , & fd_arr [ loop ] , frames_to_send - loop ) ; } num_tx += frames_to_send ; nb_events -= frames_to_send ; } return num_tx ; } | <S2SV_ModStart> PMD_DRV_LOG ( ERR <S2SV_ModEnd> , "Failure<S2SV_blank>in<S2SV_blank>affining<S2SV_blank>portal\\n" ) |
6,450 | CWE-000 void list_devs ( void ) { int i ; char name [ 16 ] ; for ( i = 0 ; i < MAX_DISKS ; i ++ ) { xd_t * xd ; sprintf ( name , "(hd%d)" , i ) ; <S2SV_StartBug> xd = xd_open ( name , 1 ) ; <S2SV_EndBug> if ( xd ) { unsigned long size ; int s ; char c ; struct fb_mbr m ; size = xd_size ( xd ) ; if ( size == XD_INVALID_SIZE ) goto quit ; if ( xd_read ( xd , ( char * ) & m , 1 ) ) goto quit ; if ( size >= ( 3 << 20 ) ) { s = ( size + ( 1 << 20 ) ) >> 21 ; c = 'g' ; } else { s = ( size + ( 1 << 10 ) ) >> 11 ; c = 'm' ; } printf ( "%s:<S2SV_blank>%lu<S2SV_blank>(%d%c)\\n" , name , size , s , c ) ; quit : xd_close ( xd ) ; } } } | <S2SV_ModStart> name , 1 , 1 |
6,451 | CWE-000 static void force_ibs_eilvt_setup ( void ) { int offset ; int ret ; preempt_disable ( ) ; for ( offset = 1 ; offset < APIC_EILVT_NR_MAX ; offset ++ ) { if ( get_eilvt ( offset ) ) break ; } preempt_enable ( ) ; if ( offset == APIC_EILVT_NR_MAX ) { pr_debug ( "No<S2SV_blank>EILVT<S2SV_blank>entry<S2SV_blank>available\\n" ) ; return ; } ret = setup_ibs_ctl ( offset ) ; if ( ret ) goto out ; if ( ! ibs_eilvt_valid ( ) ) goto out ; <S2SV_StartBug> pr_info ( "IBS:<S2SV_blank>LVT<S2SV_blank>offset<S2SV_blank>%d<S2SV_blank>assigned\\n" , offset ) ; <S2SV_EndBug> return ; out : preempt_disable ( ) ; put_eilvt ( offset ) ; preempt_enable ( ) ; return ; } | <S2SV_ModStart> ; pr_info ( "LVT<S2SV_blank>offset<S2SV_blank>%d<S2SV_blank>assigned\\n" <S2SV_ModEnd> , offset ) |
6,452 | CWE-000 static void malloc_replace__intercept ( app_pc pc , routine_type_t type , alloc_routine_entry_t * e , bool check_mismatch , bool check_winapi_match ) { void * interceptor = NULL ; bool at_entry = true ; uint stack_adjust = 0 ; # ifndef WINDOWS check_winapi_match = true ; # endif if ( ! func_interceptor ( type , check_mismatch , check_winapi_match , & interceptor , & at_entry , & stack_adjust ) ) { return ; } if ( interceptor != NULL ) { void * user_data = IF_WINDOWS_ELSE ( is_rtl_routine ( type ) ? NULL : ( void * ) e , NULL ) ; <S2SV_StartBug> if ( ! drwrap_replace_native ( pc , interceptor , at_entry , stack_adjust , <S2SV_EndBug> user_data , false ) ) ASSERT ( false , "failed<S2SV_blank>to<S2SV_blank>replace<S2SV_blank>alloc<S2SV_blank>routine" ) ; } else { LOG ( 2 , "wrapping,<S2SV_blank>not<S2SV_blank>replacing,<S2SV_blank>" PFX "\\n" , pc ) ; malloc_wrap__intercept ( pc , type , e , check_mismatch , check_winapi_match ) ; } } | <S2SV_ModStart> , at_entry , IF_X64_ELSE ( 0 , stack_adjust ) <S2SV_ModEnd> , user_data , |
6,453 | CWE-000 void sfcloseout ( CSOUND * csound ) { OPARMS * O = csound -> oparms ; int nb ; alloc_globals ( csound ) ; if ( ! STA ( osfopen ) ) return ; if ( ( nb = ( O -> outbufsamps - STA ( outbufrem ) ) * sizeof ( MYFLT ) ) > 0 ) { csound -> nrecs ++ ; csound -> audtran ( csound , STA ( outbuf ) , nb ) ; } if ( STA ( pipdevout ) == 2 && ( ! STA ( isfopen ) || STA ( pipdevin ) != 2 ) ) { csound -> rtclose_callback ( csound ) ; } if ( STA ( pipdevout ) == 2 ) goto report ; if ( STA ( outfile ) != NULL ) { if ( ! STA ( pipdevout ) && O -> outformat != AE_VORBIS ) sf_command ( STA ( outfile ) , SFC_UPDATE_HEADER_NOW , NULL , 0 ) ; sf_close ( STA ( outfile ) ) ; STA ( outfile ) = NULL ; } # ifdef PIPES if ( STA ( pout ) != NULL ) { _pclose ( STA ( pout ) ) ; STA ( pout ) = NULL ; } # endif report : if ( STA ( pipdevout ) == 2 ) { csound -> Message ( csound , <S2SV_StartBug> Str ( "%d<S2SV_blank>%d<S2SV_blank>sample<S2SV_blank>blks<S2SV_blank>of<S2SV_blank>%lu-bit<S2SV_blank>floats<S2SV_blank>written<S2SV_blank>to<S2SV_blank>%s\\n" ) , <S2SV_EndBug> csound -> nrecs , O -> outbufsamps , sizeof ( MYFLT ) * 8 , STA ( sfoutname ) ) ; } else { <S2SV_StartBug> csound -> Message ( csound , Str ( "%d<S2SV_blank>%d<S2SV_blank>sample<S2SV_blank>blks<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>written<S2SV_blank>to<S2SV_blank>%s" ) , <S2SV_EndBug> O -> outbufsamps , O -> outbufsamps * O -> sfsampsize , getstrformat ( O -> outformat ) , STA ( sfoutname ) ) ; if ( O -> sfheader == 0 ) csound -> Message ( csound , Str ( "<S2SV_blank>(raw)\\n" ) ) ; else csound -> Message ( csound , "<S2SV_blank>(%s)\\n" , type2string ( O -> filetyp ) ) ; } STA ( osfopen ) = 0 ; } | <S2SV_ModStart> , Str ( "%" PRIi32 "<S2SV_blank>%d<S2SV_blank>sample<S2SV_blank>blks<S2SV_blank>of<S2SV_blank>%lu-bit<S2SV_blank>floats<S2SV_blank>written<S2SV_blank>to<S2SV_blank>%s\\n" <S2SV_ModEnd> ) , csound <S2SV_ModStart> , Str ( "%" PRIi32 "<S2SV_blank>%d<S2SV_blank>sample<S2SV_blank>blks<S2SV_blank>of<S2SV_blank>%s<S2SV_blank>written<S2SV_blank>to<S2SV_blank>%s" <S2SV_ModEnd> ) , O |
6,454 | CWE-000 static void convsmallc ( iCode * ic , eBBlock * ebp ) { iCode * icc , * icp , * ico = NULL ; assert ( ic -> op == CALL || ic -> op == PCALL ) ; for ( icc = ic -> prev ; icc && icc -> op == IPUSH ; icc = icc -> prev ) <S2SV_StartBug> ; <S2SV_EndBug> icp = icc ; ic = icp -> next ; for ( icc = ic ; icc -> op != CALL && icc -> op != PCALL ; icc = icc -> next ) { if ( icc -> next -> op != CALL && icc -> next -> op != PCALL ) icc -> prev = icc -> next ; else icc -> prev = icp ; } if ( icc != ic ) { if ( icp ) icp -> next = icc -> prev ; icc -> prev = ic ; } for ( ; icc != icp ; ico = icc , icc = icc -> prev ) { if ( icc -> op != CALL && icc -> op != PCALL ) icc -> next = ico ; } } | <S2SV_ModStart> -> prev ) ic = icc ; icp = icc <S2SV_ModEnd> ; for ( |
6,455 | CWE-000 void execute_j ( uint32_t rd , int imm ) { <S2SV_StartBug> uint32_t address ; <S2SV_EndBug> int sign ; int shift_val ; shift_val = shift_const ( 21 ) ; sign = ( imm & 0x100000 ) >> 20 ; address = ( sign ) ? ( imm | shift_val ) : imm ; <S2SV_StartBug> NEXT_STATE . PC = CURRENT_STATE . PC + address ; <S2SV_EndBug> NEXT_STATE . REGS [ rd ] = CURRENT_STATE . PC + 4 ; printf ( "[%d]<S2SV_blank>PC:%.8x\\tINSTR:%.8x\\t<S2SV_blank>JAL<S2SV_blank>X%-2d,<S2SV_blank>0x%-8x\\n" , instr_count , CURRENT_STATE . PC , instr_opcode , rd , NEXT_STATE . PC ) ; } | <S2SV_ModStart> imm ) { int <S2SV_ModEnd> address ; int <S2SV_ModStart> : imm ; printf ( "[ISS]<S2SV_blank>ADDR<S2SV_blank>is<S2SV_blank>%.8d\\n" , address ) ; <S2SV_ModStart> PC + address ; printf ( "[ISS]<S2SV_blank>CURRENT<S2SV_blank>PC:0x%.8x\\tNEXT<S2SV_blank>PC:0x%.8x\\n" , CURRENT_STATE . PC , NEXT_STATE . PC ) |
6,456 | CWE-000 static void playerctl_player_get_property ( GObject * object , guint property_id , GValue * value , GParamSpec * pspec ) { PlayerctlPlayer * self = PLAYERCTL_PLAYER ( object ) ; switch ( property_id ) { case PROP_PLAYER_NAME : g_value_set_string ( value , self -> priv -> player_name ) ; break ; case PROP_PLAYER_ID : if ( ! bus_name_is_valid ( self -> priv -> bus_name ) ) { return ; } g_value_set_string ( value , self -> priv -> bus_name + strlen ( MPRIS_PREFIX ) ) ; break ; case PROP_STATUS : if ( self -> priv -> proxy ) { g_main_context_iteration ( NULL , FALSE ) ; g_value_set_string ( value , <S2SV_StartBug> org_mpris_media_player2_player_get_playback_status ( <S2SV_EndBug> self -> priv -> proxy ) ) ; } else { g_value_set_string ( value , "" ) ; } break ; case PROP_METADATA : { GVariant * metadata = NULL ; if ( self -> priv -> proxy ) { metadata = playerctl_player_get_metadata ( self , NULL ) ; } if ( self -> priv -> metadata != NULL ) { g_variant_unref ( self -> priv -> metadata ) ; } self -> priv -> metadata = metadata ; g_value_set_variant ( value , metadata ) ; break ; } case PROP_VOLUME : if ( self -> priv -> proxy ) { g_main_context_iteration ( NULL , FALSE ) ; g_value_set_double ( value , org_mpris_media_player2_player_get_volume ( self -> priv -> proxy ) ) ; } else { g_value_set_double ( value , 0 ) ; } break ; case PROP_POSITION : { <S2SV_StartBug> g_value_set_int64 ( value , playerctl_player_calculate_position ( self ) ) ; <S2SV_EndBug> break ; } case PROP_CAN_CONTROL : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_control ( self -> priv -> proxy ) ) ; break ; case PROP_CAN_PLAY : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_play ( self -> priv -> proxy ) ) ; break ; case PROP_CAN_PAUSE : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_pause ( self -> priv -> proxy ) ) ; break ; case PROP_CAN_SEEK : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_seek ( self -> priv -> proxy ) ) ; break ; case PROP_CAN_GO_NEXT : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_go_next ( self -> priv -> proxy ) ) ; break ; case PROP_CAN_GO_PREVIOUS : if ( self -> priv -> proxy == NULL ) { g_value_set_boolean ( value , FALSE ) ; break ; } g_main_context_iteration ( NULL , FALSE ) ; g_value_set_boolean ( value , org_mpris_media_player2_player_get_can_go_previous ( self -> priv -> proxy ) ) ; break ; default : G_OBJECT_WARN_INVALID_PROPERTY_ID ( object , property_id , pspec ) ; break ; } } | <S2SV_ModStart> ( value , pctl_playback_status_to_string ( self -> priv -> cached_status <S2SV_ModEnd> ) ) ; <S2SV_ModStart> PROP_POSITION : { gint64 position = calculate_cached_position ( self -> priv -> cached_status , & self -> priv -> cached_position_monotonic , self -> priv -> cached_position ) ; <S2SV_ModStart> ( value , position <S2SV_ModEnd> ) ; break |
6,457 | CWE-000 static void Next_Kernel_Request ( ) { request_handler_func request_handlers [ NUM_KERNEL_REQUEST_TYPES ] = { Kernel_Request_None , Kernel_Request_Timer , Kernel_Request_Create , Kernel_Request_Next , Kernel_Request_GetArg , Kernel_Request_GetPid , Kernel_Request_GetNow , Kernel_Request_MsgSend , Kernel_Request_MsgRecv , Kernel_Request_MsgRply , Kernel_Request_MsgASend , <S2SV_StartBug> Kernel_Request_Terminate <S2SV_EndBug> } ; Dispatch ( ) ; for ( ; ; ) { if ( request_info ) { request_info -> request = NONE ; request_info = NULL ; } else { if ( KernelActive ) { OS_Abort ( NO_REQUEST_INFO ) ; return ; } } CurrentSp = Cp -> sp ; KernelActive = 1 ; Exit_Kernel ( ) ; if ( ! request_info ) { OS_Abort ( NO_REQUEST_INFO ) ; return ; } Cp -> sp = CurrentSp ; Cp -> state = READY ; if ( request_info -> request >= NONE && request_info -> request < NUM_KERNEL_REQUEST_TYPES ) { request_handlers [ request_info -> request ] ( ) ; } else { OS_Abort ( INVALID_REQ_INFO ) ; return ; } } } | <S2SV_ModStart> Kernel_Request_MsgASend , Kernel_Request_Terminate , Kernel_Request_Abort |
6,458 | CWE-000 static int msm_rpm_flush_requests ( bool print ) { struct rb_node * t ; int ret ; int count = 0 ; for ( t = rb_first ( & tr_root ) ; t ; t = rb_next ( t ) ) { struct slp_buf * s = rb_entry ( t , struct slp_buf , node ) ; if ( ! s -> valid ) continue ; if ( print ) msm_rpm_print_sleep_buffer ( s ) ; get_msg_id ( s -> buf ) = msm_rpm_get_next_msg_id ( ) ; if ( ! glink_enabled ) ret = msm_rpm_send_smd_buffer ( s -> buf , get_buf_len ( s -> buf ) , true ) ; else ret = msm_rpm_glink_send_buffer ( s -> buf , get_buf_len ( s -> buf ) , true ) ; WARN_ON ( ret != get_buf_len ( s -> buf ) ) ; trace_rpm_smd_send_sleep_set ( get_msg_id ( s -> buf ) , get_rsc_type ( s -> buf ) , get_rsc_id ( s -> buf ) ) ; s -> valid = false ; count ++ ; if ( count >= MAX_WAIT_ON_ACK ) { int ret = msm_rpm_read_sleep_ack ( ) ; if ( ret >= 0 ) count -- ; <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> return ret ; <S2SV_EndBug> } } return 0 ; } | <S2SV_ModStart> -- ; else { pr_err ( "Timed<S2SV_blank>out<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>RPM<S2SV_blank>ACK\\n" ) ; <S2SV_ModStart> return ret ; } |
6,459 | CWE-000 int mworker_cli_proxy_create ( ) { struct mworker_proc * child ; mworker_proxy = calloc ( 1 , sizeof ( * mworker_proxy ) ) ; if ( ! mworker_proxy ) return - 1 ; init_new_proxy ( mworker_proxy ) ; mworker_proxy -> next = proxies_list ; proxies_list = mworker_proxy ; mworker_proxy -> id = strdup ( "MASTER" ) ; mworker_proxy -> mode = PR_MODE_CLI ; mworker_proxy -> state = PR_STNEW ; mworker_proxy -> last_change = now . tv_sec ; mworker_proxy -> cap = PR_CAP_LISTEN ; mworker_proxy -> maxconn = 10 ; mworker_proxy -> timeout . client = 0 ; mworker_proxy -> conf . file = strdup ( "MASTER" ) ; mworker_proxy -> conf . line = 0 ; mworker_proxy -> accept = frontend_accept ; mworker_proxy -> lbprm . algo = BE_LB_ALGO_NONE ; mworker_proxy -> default_target = NULL ; mworker_proxy -> uuid = - 1 ; proxy_store_name ( mworker_proxy ) ; list_for_each_entry ( child , & proc_list , list ) { char * msg = NULL ; struct server * newsrv = NULL ; struct sockaddr_storage * sk ; int port1 , port2 , port ; struct protocol * proto ; char * errmsg ; newsrv = new_server ( mworker_proxy ) ; if ( ! newsrv ) return - 1 ; if ( child -> pid == - 1 ) memprintf ( & msg , "cur-%d" , child -> relative_pid ) ; else memprintf ( & msg , "old-%d" , child -> pid ) ; newsrv -> next = mworker_proxy -> srv ; mworker_proxy -> srv = newsrv ; newsrv -> conf . file = strdup ( msg ) ; newsrv -> id = strdup ( msg ) ; newsrv -> conf . line = 0 ; memprintf ( & msg , "sockpair@%d" , child -> ipc_fd [ 0 ] ) ; <S2SV_StartBug> if ( ( sk = str2sa_range ( msg , & port , & port1 , & port2 , & errmsg , NULL , NULL , 0 ) ) == 0 ) <S2SV_EndBug> <S2SV_StartBug> return - 1 ; <S2SV_EndBug> proto = protocol_by_family ( sk -> ss_family ) ; if ( ! proto || ! proto -> connect ) { return - 1 ; } newsrv -> flags |= SRV_F_MAPPORTS ; newsrv -> addr = * sk ; newsrv -> iweight = 0 ; newsrv -> uweight = 0 ; srv_lb_commit_status ( newsrv ) ; child -> srv = newsrv ; } return 0 ; } | <S2SV_ModStart> == 0 ) { free ( msg ) ; <S2SV_ModStart> return - 1 ; } free ( msg ) ; msg = NULL |
6,460 | CWE-000 static int exynos_dsi_parse_dt ( struct exynos_dsi * dsi ) { struct device * dev = dsi -> dev ; <S2SV_StartBug> struct device_node * node = dev -> of_node ; <S2SV_EndBug> struct device_node * ep ; int ret ; ret = exynos_dsi_of_read_u32 ( node , "samsung,pll-clock-frequency" , & dsi -> pll_clk_rate ) ; if ( ret < 0 ) return ret ; <S2SV_StartBug> ep = of_graph_get_endpoint_by_regs ( node , DSI_PORT_OUT , 0 ) ; <S2SV_EndBug> if ( ! ep ) { dev_err ( dev , "no<S2SV_blank>output<S2SV_blank>port<S2SV_blank>with<S2SV_blank>endpoint<S2SV_blank>specified\\n" ) ; return - EINVAL ; } <S2SV_StartBug> ret = exynos_dsi_of_read_u32 ( ep , "samsung,burst-clock-frequency" , <S2SV_EndBug> & dsi -> burst_clk_rate ) ; if ( ret < 0 ) <S2SV_StartBug> goto end ; <S2SV_EndBug> <S2SV_StartBug> ret = exynos_dsi_of_read_u32 ( ep , "samsung,esc-clock-frequency" , <S2SV_EndBug> & dsi -> esc_clk_rate ) ; if ( ret < 0 ) <S2SV_StartBug> goto end ; <S2SV_EndBug> of_node_put ( ep ) ; dsi -> bridge_node = of_graph_get_remote_node ( node , DSI_PORT_OUT , 0 ) ; if ( ! dsi -> bridge_node ) return - EINVAL ; <S2SV_StartBug> end : <S2SV_EndBug> of_node_put ( ep ) ; return ret ; } | <S2SV_ModStart> dev -> of_node <S2SV_ModEnd> ; int ret <S2SV_ModStart> return ret ; <S2SV_ModEnd> ret = exynos_dsi_of_read_u32 <S2SV_ModStart> = exynos_dsi_of_read_u32 ( node <S2SV_ModEnd> , "samsung,burst-clock-frequency" , <S2SV_ModStart> < 0 ) return ret <S2SV_ModEnd> ; ret = <S2SV_ModStart> = exynos_dsi_of_read_u32 ( node <S2SV_ModEnd> , "samsung,esc-clock-frequency" , <S2SV_ModStart> < 0 ) return ret <S2SV_ModEnd> ; dsi -> <S2SV_ModStart> - EINVAL ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
6,461 | CWE-000 int fh_set_hostname ( char * name , size_t len ) { int rc = 0 ; FILE * fd = fopen ( "/etc/hostname" , "w" ) ; if ( fd == NULL ) { rc = 1 ; } else { <S2SV_StartBug> strip_substring ( name , "\\n" ) ; <S2SV_EndBug> strcat ( name , "\\n" ) ; if ( fputs ( name , fd ) != EOF ) { rc = 1 ; } fclose ( fd ) ; } return rc ; } | <S2SV_ModStart> } else { <S2SV_ModEnd> if ( fputs |
6,462 | CWE-000 const char * bam_get_library ( bam_header_t * h , const bam1_t * b ) { const char * rg ; char * cp = h -> text ; rg = ( char * ) bam_aux_get ( b , "RG" ) ; if ( ! rg ) return NULL ; else rg ++ ; while ( * cp ) { char * ID , * LB ; char last = '\\t' ; if ( strncmp ( cp , "@RG" , 3 ) != 0 ) { while ( * cp && * cp != '\\n' ) cp ++ ; if ( * cp ) cp ++ ; continue ; } cp += 4 ; ID = LB = NULL ; while ( * cp && * cp != '\\n' ) { if ( last == '\\t' ) { if ( strncmp ( cp , "LB:" , 3 ) == 0 ) LB = cp + 3 ; else if ( strncmp ( cp , "ID:" , 3 ) == 0 ) ID = cp + 3 ; } last = * cp ++ ; <S2SV_StartBug> } <S2SV_EndBug> if ( strncmp ( rg , ID , strlen ( rg ) ) != 0 || ID [ strlen ( rg ) ] != '\\t' ) continue ; static char LB_text [ 1024 ] ; for ( cp = LB ; * cp && * cp != '\\t' && * cp != '\\n' ; cp ++ ) ; strncpy ( LB_text , LB , MIN ( cp - LB , 1023 ) ) ; LB_text [ MIN ( cp - LB , 1023 ) ] = 0 ; return LB_text ; } return NULL ; } | <S2SV_ModStart> ++ ; } if ( ! ID || ! LB ) continue ; |
6,463 | CWE-000 int GenmapParRSB ( GenmapLong * egl , GenmapLong * vl , GenmapInt * negl , GenmapLong * eglcon , GenmapLong * vlcon , GenmapInt * nve , GenmapInt neglcon , GenmapCommExternal comm ) { GenmapHandle h ; GenmapInit ( & h , comm , "fortran" ) ; GenmapLong neglcon_ = ( GenmapLong ) neglcon ; <S2SV_StartBug> GenmapGop ( h -> global , & neglcon_ , 1 , GENMAP_MPI_LONG , GENMAP_SUM ) ; <S2SV_EndBug> GenmapInt rank = GenmapId ( h -> global ) ; GenmapInt size = GenmapNp ( h -> global ) ; GenmapInt localElements = ( GenmapInt ) ( neglcon_ / size ) ; GenmapInt nrem = ( GenmapInt ) ( neglcon_ - localElements * size ) ; localElements = localElements + rank < nrem ; if ( localElements > * negl ) { printf ( "parameter<S2SV_blank>negl<S2SV_blank>is<S2SV_blank>not<S2SV_blank>large<S2SV_blank>enough<S2SV_blank>to<S2SV_blank>hold<S2SV_blank>the<S2SV_blank>resulting<S2SV_blank>partition.\\n" ) ; exit ( 1 ) ; } GenmapCreateHeader ( & h -> header ) ; h -> header -> lelt = * negl ; h -> header -> npts = ( * negl ) * 8 ; h -> header -> nv = nve [ 0 ] ; h -> header -> ndim = ( nve [ 0 ] == 8 ) ? 3 : 2 ; GenmapRead ( h , vlcon ) ; GenmapElements e = GenmapGetElements ( h ) ; for ( int i = 0 ; i < * negl ; i ++ ) { e [ i ] . globalId = eglcon [ i ] ; } double time ; # if defined ( GENMAP_MPI ) MPI_Barrier ( h -> global -> gsComm . c ) ; double start = MPI_Wtime ( ) ; # else clock_t start = clock ( ) ; # endif GenmapRSB ( h ) ; # if defined ( GENMAP_MPI ) MPI_Barrier ( h -> global -> gsComm . c ) ; double end = MPI_Wtime ( ) ; time = end - start ; # else clock_t end = clock ( ) ; time = ( double ) ( end - start ) / CLOCKS_PER_SEC ; # endif if ( rank == 0 ) printf ( "Time<S2SV_blank>taken<S2SV_blank>by<S2SV_blank>parRSB:<S2SV_blank>%lf(s)\\n" , time ) ; GenmapElements elements = GenmapGetElements ( h ) ; GenmapInt nv = h -> header -> nv ; for ( int i = 0 ; i < h -> header -> lelt ; i ++ ) { egl [ i ] = elements [ i ] . globalId ; for ( int j = 0 ; j < nv ; j ++ ) { vl [ nv * i + j ] = elements [ i ] . vertices [ j ] ; } } * negl = h -> header -> lelt ; return 0 ; } | <S2SV_ModStart> , 1 , GENMAP_LONG <S2SV_ModEnd> , GENMAP_SUM ) |
6,464 | CWE-000 void ft_strdel ( char * * as ) { <S2SV_StartBug> if ( as ) <S2SV_EndBug> { <S2SV_StartBug> ft_memdel ( ( void * ) as ) ; <S2SV_EndBug> <S2SV_StartBug> as = NULL ; <S2SV_EndBug> } } | <S2SV_ModStart> if ( as && * as <S2SV_ModStart> ( void * * <S2SV_ModStart> as ) ; * |
6,465 | CWE-000 void adc_handle_master ( struct host_adc * adc , size_t n , struct adc_response * a ) { if ( a -> adc_id > ADC_NUM ) { out_of_range_chunks ++ ; return ; } if ( a -> cmd == OP_GET ) { adc [ a -> adc_id ] . last_read = a -> val ; bisem_post ( & adc [ a -> adc_id ] . sem ) ; } else { <S2SV_StartBug> puts ( "TODO<S2SV_blank>other<S2SV_blank>case<S2SV_blank>in<S2SV_blank>adc_handle_master" ) <S2SV_EndBug> } } | <S2SV_ModStart> ( "TODO<S2SV_blank>other<S2SV_blank>case<S2SV_blank>in<S2SV_blank>adc_handle_master" ) ; |
6,466 | CWE-000 static ssize_t cg_get_max_cpus ( char * cpulist ) { char * c1 , * c2 ; char * maxcpus = cpulist ; size_t cpus = 0 ; c1 = strrchr ( maxcpus , ',' ) ; if ( c1 ) c1 ++ ; c2 = strrchr ( maxcpus , '-' ) ; if ( c2 ) c2 ++ ; if ( ! c1 && ! c2 ) c1 = maxcpus ; <S2SV_StartBug> else if ( c1 > c2 ) <S2SV_EndBug> c2 = c1 ; else if ( c1 < c2 ) c1 = c2 ; errno = 0 ; cpus = strtoul ( c1 , NULL , 0 ) ; if ( errno != 0 ) return - 1 ; return cpus ; } | <S2SV_ModStart> if ( c1 <S2SV_ModEnd> < c2 ) |
6,467 | CWE-000 static void <S2SV_StartBug> log_dest_driver_release_queue_method ( LogDestDriver * self , LogQueue * q , gpointer user_data ) <S2SV_EndBug> { GlobalConfig * cfg = log_pipe_get_config ( & self -> super . super ) ; if ( q -> persist_name && log_queue_keep_on_reload ( q ) > 0 ) { cfg_persist_config_add ( cfg , q -> persist_name , q , ( GDestroyNotify ) log_queue_unref , FALSE ) ; } else { log_queue_unref ( q ) ; } } | <S2SV_ModStart> LogQueue * q <S2SV_ModEnd> ) { GlobalConfig |
6,468 | CWE-000 void G_BounceMissile ( gentity_t * ent , trace_t * trace ) { vec3_t velocity ; float dot ; int hitTime ; hitTime = level . previousTime + ( level . time - level . previousTime ) * trace -> fraction ; BG_EvaluateTrajectoryDelta ( & ent -> s . pos , hitTime , velocity ) ; dot = DotProduct ( velocity , trace -> plane . normal ) ; <S2SV_StartBug> VectorMA ( velocity , - 2 * dot , trace -> plane . normal , ent -> s . pos . trDelta ) ; <S2SV_EndBug> if ( ent -> flags & FL_BOUNCE_SHRAPNEL ) { VectorScale ( ent -> s . pos . trDelta , 0.25f , ent -> s . pos . trDelta ) ; ent -> s . pos . trType = TR_GRAVITY ; if ( trace -> plane . normal [ 2 ] > 0.7 && ent -> s . pos . trDelta [ 2 ] < 40 ) { G_SetOrigin ( ent , trace -> endpos ) ; ent -> nextthink = level . time + 100 ; return ; } } else if ( ent -> flags & FL_BOUNCE_HALF ) { if ( ent -> s . weapon == WP_REPEATER && g_tweakWeapons . integer & WT_ROCKET_MORTAR ) VectorScale ( ent -> s . pos . trDelta , 0.4f , ent -> s . pos . trDelta ) ; else VectorScale ( ent -> s . pos . trDelta , 0.65f , ent -> s . pos . trDelta ) ; if ( trace -> plane . normal [ 2 ] > 0.2 && VectorLength ( ent -> s . pos . trDelta ) < 40 ) { G_SetOrigin ( ent , trace -> endpos ) ; return ; } } if ( ent -> s . weapon == WP_THERMAL ) { G_Sound ( ent , CHAN_BODY , G_SoundIndex ( va ( "sound/weapons/thermal/bounce%i.wav" , Q_irand ( 1 , 2 ) ) ) ) ; } else if ( ent -> s . weapon == WP_SABER ) { G_Sound ( ent , CHAN_BODY , G_SoundIndex ( va ( "sound/weapons/saber/bounce%i.wav" , Q_irand ( 1 , 3 ) ) ) ) ; } else if ( ent -> s . weapon == G2_MODEL_PART ) { } VectorAdd ( ent -> r . currentOrigin , trace -> plane . normal , ent -> r . currentOrigin ) ; VectorCopy ( ent -> r . currentOrigin , ent -> s . pos . trBase ) ; ent -> s . pos . trTime = level . time ; <S2SV_StartBug> if ( ent -> bounceCount != - 5 ) <S2SV_EndBug> { ent -> bounceCount -- ; } } | <S2SV_ModStart> trDelta ) ; if ( ent -> bounceCount != - 5 ) { ent -> bounceCount -- ; } <S2SV_ModStart> . time ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,469 | CWE-000 static int drv_gyro_bosch_bmg160_ioctl ( int cmd , unsigned long arg ) { int ret = 0 ; switch ( cmd ) { case SENSOR_IOCTL_ODR_SET : { ret = drv_gyro_bosch_bmg160_set_odr ( & bmg160_ctx , arg ) ; if ( unlikely ( ret ) ) { return - 1 ; } } break ; case SENSOR_IOCTL_RANGE_SET : { ret = drv_gyro_bosch_bmg160_set_range ( & bmg160_ctx , arg ) ; if ( unlikely ( ret ) ) { return - 1 ; } } break ; case SENSOR_IOCTL_SET_POWER : { ret = drv_gyro_bosch_bmg160_set_power_mode ( & bmg160_ctx , arg ) ; if ( unlikely ( ret ) ) { return - 1 ; } } break ; case SENSOR_IOCTL_GET_INFO : { <S2SV_StartBug> dev_sensor_info_t * info = arg ; <S2SV_EndBug> <S2SV_StartBug> * ( info -> model ) = "BMG160" ; <S2SV_EndBug> info -> range_max = 2000 ; info -> range_min = 125 ; info -> unit = udps ; } break ; default : break ; } return 0 ; } | <S2SV_ModStart> * info = ( dev_sensor_info_t * ) arg ; <S2SV_ModEnd> info -> model <S2SV_ModStart> info -> model <S2SV_ModEnd> = "BMG160" ; |
6,470 | CWE-000 u64 mlx5_query_nic_system_image_guid ( struct mlx5_core_dev * mdev ) { <S2SV_StartBug> if ( ! mdev -> sys_image_guid ) <S2SV_EndBug> <S2SV_StartBug> mlx5_query_nic_vport_system_image_guid ( mdev , & mdev -> sys_image_guid ) ; <S2SV_EndBug> return mdev -> sys_image_guid ; } | <S2SV_ModStart> mdev ) { int port_type_cap = MLX5_CAP_GEN ( mdev , port_type ) ; u64 tmp = 0 ; if ( <S2SV_ModEnd> mdev -> sys_image_guid <S2SV_ModStart> mdev -> sys_image_guid ) return mdev -> sys_image_guid ; if ( port_type_cap == MLX5_CAP_PORT_TYPE_ETH <S2SV_ModStart> mdev , & tmp ) ; else mlx5_query_hca_vport_system_image_guid ( mdev , & tmp ) ; <S2SV_ModStart> mdev -> sys_image_guid = tmp ; return tmp <S2SV_ModEnd> ; } <S2SV_null> |
6,471 | CWE-000 static int rv_print_clock_levels ( struct pp_hwmgr * hwmgr , enum pp_clock_type type , char * buf ) { struct rv_hwmgr * data = ( struct rv_hwmgr * ) ( hwmgr -> backend ) ; struct rv_voltage_dependency_table * mclk_table = data -> clock_vol_info . vdd_dep_on_fclk ; int i , now , size = 0 ; switch ( type ) { case PP_SCLK : <S2SV_StartBug> PP_ASSERT_WITH_CODE ( ! smum_send_msg_to_smc ( hwmgr -> smumgr , <S2SV_EndBug> PPSMC_MSG_GetGfxclkFrequency ) , "Attempt<S2SV_blank>to<S2SV_blank>get<S2SV_blank>current<S2SV_blank>GFXCLK<S2SV_blank>Failed!" , return - 1 ) ; <S2SV_StartBug> PP_ASSERT_WITH_CODE ( ! rv_read_arg_from_smc ( hwmgr -> smumgr , <S2SV_EndBug> & now ) , "Attempt<S2SV_blank>to<S2SV_blank>get<S2SV_blank>current<S2SV_blank>GFXCLK<S2SV_blank>Failed!" , return - 1 ) ; size += sprintf ( buf + size , "0:<S2SV_blank>%uMhz<S2SV_blank>%s\\n" , data -> gfx_min_freq_limit / 100 , ( ( data -> gfx_min_freq_limit / 100 ) == now ) ? "*" : "" ) ; size += sprintf ( buf + size , "1:<S2SV_blank>%uMhz<S2SV_blank>%s\\n" , data -> gfx_max_freq_limit / 100 , ( ( data -> gfx_max_freq_limit / 100 ) == now ) ? "*" : "" ) ; break ; case PP_MCLK : <S2SV_StartBug> PP_ASSERT_WITH_CODE ( ! smum_send_msg_to_smc ( hwmgr -> smumgr , <S2SV_EndBug> PPSMC_MSG_GetFclkFrequency ) , "Attempt<S2SV_blank>to<S2SV_blank>get<S2SV_blank>current<S2SV_blank>MEMCLK<S2SV_blank>Failed!" , return - 1 ) ; <S2SV_StartBug> PP_ASSERT_WITH_CODE ( ! rv_read_arg_from_smc ( hwmgr -> smumgr , <S2SV_EndBug> & now ) , "Attempt<S2SV_blank>to<S2SV_blank>get<S2SV_blank>current<S2SV_blank>MEMCLK<S2SV_blank>Failed!" , return - 1 ) ; for ( i = 0 ; i < mclk_table -> count ; i ++ ) size += sprintf ( buf + size , "%d:<S2SV_blank>%uMhz<S2SV_blank>%s\\n" , i , mclk_table -> entries [ i ] . clk / 100 , ( ( mclk_table -> entries [ i ] . clk / 100 ) == now ) ? "*" : "" ) ; break ; default : break ; } return size ; } | <S2SV_ModStart> smum_send_msg_to_smc ( hwmgr <S2SV_ModEnd> , PPSMC_MSG_GetGfxclkFrequency ) <S2SV_ModStart> rv_read_arg_from_smc ( hwmgr <S2SV_ModEnd> , & now <S2SV_ModStart> smum_send_msg_to_smc ( hwmgr <S2SV_ModEnd> , PPSMC_MSG_GetFclkFrequency ) <S2SV_ModStart> rv_read_arg_from_smc ( hwmgr <S2SV_ModEnd> , & now |
6,472 | CWE-000 uint next_instruction_opcode ( struct i8080 * cpu ) { if ( cpu -> pending_interrupt ) { <S2SV_StartBug> cpu -> INTE = 0 ; <S2SV_EndBug> return cpu -> interrupt_opcode ; } else { return next_byte ( cpu ) ; } } | <S2SV_ModStart> pending_interrupt ) { <S2SV_ModEnd> return cpu -> |
6,473 | CWE-000 void ls ( char * path ) { char buf [ 512 ] , * p ; <S2SV_StartBug> int fd ; <S2SV_EndBug> struct dirent de ; struct stat st ; if ( ( fd = open ( path , 0 ) ) < 0 ) { printf ( 2 , "ls:<S2SV_blank>cannot<S2SV_blank>open<S2SV_blank>%s\\n" , path ) ; return ; } <S2SV_StartBug> if ( fstat ( fd , & st ) < 0 ) { <S2SV_EndBug> printf ( 2 , "ls:<S2SV_blank>cannot<S2SV_blank>stat<S2SV_blank>%s\\n" , path ) ; close ( fd ) ; return ; } switch ( st . type ) { case T_FILE : printf ( 1 , "%s<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , fmtname ( path ) , st . type , st . ino , st . size ) ; break ; case T_DIR : if ( strlen ( path ) + 1 + DIRSIZ + 1 > sizeof buf ) { printf ( 1 , "ls:<S2SV_blank>path<S2SV_blank>too<S2SV_blank>long\\n" ) ; break ; } strcpy ( buf , path ) ; p = buf + strlen ( buf ) ; * p ++ = '/' ; while ( read ( fd , & de , sizeof ( de ) ) == sizeof ( de ) ) { if ( de . inum == 0 ) continue ; memmove ( p , de . name , DIRSIZ ) ; p [ DIRSIZ ] = 0 ; if ( stat ( buf , & st ) < 0 ) { printf ( 1 , "ls:<S2SV_blank>cannot<S2SV_blank>stat<S2SV_blank>%s\\n" , buf ) ; continue ; } printf ( 1 , "%s<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , fmtname ( buf ) , st . type , st . ino , st . size , st . premission , st . ownerid , st . groupid ) ; } break ; } close ( fd ) ; } | <S2SV_ModStart> ; int fd , flag = 0 <S2SV_ModStart> } if ( ( flag = ( <S2SV_ModStart> & st ) ) ) <S2SV_ModStart> 0 ) { if ( flag <= - 2 ) printf ( 2 , "ls:<S2SV_blank>cannot<S2SV_blank>stat<S2SV_blank>%s<S2SV_blank>:premission<S2SV_blank>deny\\n" , path ) ; else |
6,474 | CWE-000 static int cpufreq_add_dev ( struct device * dev , struct subsys_interface * sif ) { unsigned int j , cpu = dev -> id ; int ret = - ENOMEM , found = 0 ; struct cpufreq_policy * policy ; unsigned long flags ; # ifdef CONFIG_HOTPLUG_CPU struct cpufreq_governor * gov ; int sibling ; # endif if ( cpu_is_offline ( cpu ) ) return 0 ; pr_debug ( "adding<S2SV_blank>CPU<S2SV_blank>%u\\n" , cpu ) ; # ifdef CONFIG_SMP policy = cpufreq_cpu_get ( cpu ) ; if ( unlikely ( policy ) ) { cpufreq_cpu_put ( policy ) ; return 0 ; } # ifdef CONFIG_HOTPLUG_CPU for_each_online_cpu ( sibling ) { struct cpufreq_policy * cp = per_cpu ( cpufreq_cpu_data , sibling ) ; if ( cp && cpumask_test_cpu ( cpu , cp -> related_cpus ) ) return cpufreq_add_policy_cpu ( cpu , sibling , dev ) ; } # endif # endif if ( ! try_module_get ( cpufreq_driver -> owner ) ) { ret = - EINVAL ; goto module_out ; } policy = kzalloc ( sizeof ( struct cpufreq_policy ) , GFP_KERNEL ) ; if ( ! policy ) goto nomem_out ; if ( ! alloc_cpumask_var ( & policy -> cpus , GFP_KERNEL ) ) goto err_free_policy ; if ( ! zalloc_cpumask_var ( & policy -> related_cpus , GFP_KERNEL ) ) goto err_free_cpumask ; policy -> cpu = cpu ; cpumask_copy ( policy -> cpus , cpumask_of ( cpu ) ) ; per_cpu ( cpufreq_policy_cpu , cpu ) = cpu ; ret = ( lock_policy_rwsem_write ( cpu ) < 0 ) ; WARN_ON ( ret ) ; init_completion ( & policy -> kobj_unregister ) ; INIT_WORK ( & policy -> update , handle_update ) ; # ifdef CONFIG_HOTPLUG_CPU for_each_online_cpu ( sibling ) { struct cpufreq_policy * cp = per_cpu ( cpufreq_cpu_data , sibling ) ; if ( cp && cp -> governor && ( cpumask_test_cpu ( cpu , cp -> related_cpus ) ) ) { policy -> governor = cp -> governor ; found = 1 ; break ; } } # endif if ( ! found ) policy -> governor = CPUFREQ_DEFAULT_GOVERNOR ; ret = cpufreq_driver -> init ( policy ) ; if ( ret ) { pr_debug ( "initialization<S2SV_blank>failed\\n" ) ; goto err_unlock_policy ; } cpumask_and ( policy -> cpus , policy -> cpus , cpu_online_mask ) ; policy -> user_policy . min = policy -> min ; policy -> user_policy . max = policy -> max ; policy -> util = 0 ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_START , policy ) ; # ifdef CONFIG_HOTPLUG_CPU gov = __find_governor ( per_cpu ( cpufreq_policy_save , cpu ) . gov ) ; if ( gov ) { policy -> governor = gov ; pr_debug ( "Restoring<S2SV_blank>governor<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>cpu<S2SV_blank>%d\\n" , policy -> governor -> name , cpu ) ; } <S2SV_StartBug> # endif <S2SV_EndBug> ret = cpufreq_add_dev_interface ( cpu , policy , dev ) ; if ( ret ) goto err_out_unregister ; unlock_policy_rwsem_write ( cpu ) ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_CREATE_POLICY , policy ) ; kobject_uevent ( & policy -> kobj , KOBJ_ADD ) ; module_put ( cpufreq_driver -> owner ) ; pr_debug ( "initialization<S2SV_blank>complete\\n" ) ; return 0 ; err_out_unregister : spin_lock_irqsave ( & cpufreq_driver_lock , flags ) ; for_each_cpu ( j , policy -> cpus ) per_cpu ( cpufreq_cpu_data , j ) = NULL ; spin_unlock_irqrestore ( & cpufreq_driver_lock , flags ) ; kobject_put ( & policy -> kobj ) ; wait_for_completion ( & policy -> kobj_unregister ) ; err_unlock_policy : unlock_policy_rwsem_write ( cpu ) ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_REMOVE_POLICY , policy ) ; free_cpumask_var ( policy -> related_cpus ) ; err_free_cpumask : free_cpumask_var ( policy -> cpus ) ; err_free_policy : kfree ( policy ) ; nomem_out : module_put ( cpufreq_driver -> owner ) ; module_out : return ret ; } | <S2SV_ModStart> ) ; } if ( per_cpu ( cpufreq_policy_save , cpu ) . min ) { policy -> min = per_cpu ( cpufreq_policy_save , cpu ) . min ; policy -> user_policy . min = policy -> min ; } if ( per_cpu ( cpufreq_policy_save , cpu ) . max ) { policy -> max = per_cpu ( cpufreq_policy_save , cpu ) . max ; policy -> user_policy . max = policy -> max ; } pr_debug ( "Restoring<S2SV_blank>CPU%d<S2SV_blank>min<S2SV_blank>%d<S2SV_blank>and<S2SV_blank>max<S2SV_blank>%d\\n" , cpu , policy -> min , policy -> max ) ; |
6,475 | CWE-000 value_t eval_array ( Node * n , environment_t * env ) { value_t v , a = newArray ( array_value , 0 ) ; arrayNode * an = ( arrayNode * ) n ; array_t * aval = a . addr ; listNode * ln ; uint32_t l ; if ( ( l = an -> exprlist ) ) do { ln = ( listNode * ) ( env -> table + l ) ; l -= sizeof ( listNode ) / sizeof ( Node ) ; v = dispatch ( ln -> elem , env ) ; <S2SV_StartBug> incrRefCnt ( v ) ; <S2SV_EndBug> vec_push ( aval -> valuePtr , v ) ; } while ( ln -> hdr -> type == node_list ) ; vec_push ( env -> literals , a ) ; incrRefCnt ( a ) ; return a ; } | <S2SV_ModStart> env ) ; if ( v . marshaled ) v = includeDocument ( v , NULL , env ) ; |
6,476 | CWE-000 void pl_obj_layout_free ( struct pl_obj_layout * layout ) { <S2SV_StartBug> if ( layout -> ol_targets != NULL ) { <S2SV_EndBug> D_FREE ( layout -> ol_targets , layout -> ol_nr * sizeof ( * layout -> ol_targets ) ) ; } if ( layout -> ol_shards != NULL ) { D_FREE ( layout -> ol_shards , layout -> ol_nr * sizeof ( * layout -> ol_shards ) ) ; } D_FREE_PTR ( layout ) ; } | <S2SV_ModStart> layout ) { <S2SV_ModEnd> if ( layout |
6,477 | CWE-000 static int __rtc_set_alarm ( struct rtc_device * rtc , struct rtc_wkalrm * alarm ) { struct rtc_time tm ; time64_t now , scheduled ; int err ; err = rtc_valid_tm ( & alarm -> time ) ; if ( err ) return err ; <S2SV_StartBug> rtc_subtract_offset ( rtc , & alarm -> time ) ; <S2SV_EndBug> scheduled = rtc_tm_to_time64 ( & alarm -> time ) ; err = __rtc_read_time ( rtc , & tm ) ; if ( err ) return err ; now = rtc_tm_to_time64 ( & tm ) ; if ( scheduled <= now ) <S2SV_StartBug> return - ETIME ; <S2SV_EndBug> if ( ! rtc -> ops ) err = - ENODEV ; else if ( ! rtc -> ops -> set_alarm ) err = - EINVAL ; else err = rtc -> ops -> set_alarm ( rtc -> dev . parent , alarm ) ; trace_rtc_set_alarm ( rtc_tm_to_time64 ( & alarm -> time ) , err ) ; return err ; } | <S2SV_ModStart> return err ; <S2SV_ModEnd> scheduled = rtc_tm_to_time64 <S2SV_ModStart> return - ETIME ; rtc_subtract_offset ( rtc , & alarm -> time ) |
6,478 | CWE-000 int scsi_device_read_capacity ( uint8_t scsi_id , uint8_t scsi_lun , uint8_t * cdb , uint8_t * buffer , uint32_t * len ) { uint8_t lun_type = SCSIDevices [ scsi_id ] [ scsi_lun ] . LunType ; uint8_t id = 0 ; switch ( lun_type ) { case SCSI_DISK : id = scsi_hard_disks [ scsi_id ] [ scsi_lun ] ; return scsi_hd_read_capacity ( id , cdb , buffer , len ) ; case SCSI_CDROM : <S2SV_StartBug> id = scsi_hard_disks [ scsi_id ] [ scsi_lun ] ; <S2SV_EndBug> return cdrom_read_capacity ( id , cdb , buffer , len ) ; default : return 0 ; } } | <S2SV_ModStart> : id = scsi_cdrom_drives <S2SV_ModEnd> [ scsi_id ] |
6,479 | CWE-000 void obs_source_copy_filters ( obs_source_t * dst , obs_source_t * src ) <S2SV_StartBug> { <S2SV_EndBug> duplicate_filters ( dst , src , dst -> context . private ) ; } | <S2SV_ModStart> src ) { if ( obs_source_valid ( dst , "obs_source_copy_filters" ) ) |
6,480 | CWE-000 static void cmd_obj_send_parsed ( void * parsed_result , __attribute__ ( ( unused ) ) struct cmdline * cl , __attribute__ ( ( unused ) ) void * data ) { struct cmd_obj_send_result * res = parsed_result ; char ip_str [ INET6_ADDRSTRLEN ] ; struct rte_mbuf * created_pkt ; struct ether_hdr * eth_hdr ; struct arp_hdr * arp_hdr ; uint32_t bond_ip ; size_t pkt_size ; if ( res -> ip . family == AF_INET ) get_string ( res , ip_str , INET_ADDRSTRLEN ) ; else cmdline_printf ( cl , "Wrong<S2SV_blank>IP<S2SV_blank>format.<S2SV_blank>Only<S2SV_blank>IPv4<S2SV_blank>is<S2SV_blank>supported\\n" ) ; bond_ip = BOND_IP_1 | ( BOND_IP_2 << 8 ) | ( BOND_IP_3 << 16 ) | ( BOND_IP_4 << 24 ) ; created_pkt = rte_pktmbuf_alloc ( mbuf_pool ) ; <S2SV_StartBug> pkt_size = sizeof ( struct ether_hdr ) + sizeof ( struct arp_hdr ) ; <S2SV_EndBug> created_pkt -> data_len = pkt_size ; created_pkt -> pkt_len = pkt_size ; eth_hdr = rte_pktmbuf_mtod ( created_pkt , struct ether_hdr * ) ; rte_eth_macaddr_get ( BOND_PORT , & eth_hdr -> s_addr ) ; memset ( & eth_hdr -> d_addr , 0xFF , ETHER_ADDR_LEN ) ; eth_hdr -> ether_type = rte_cpu_to_be_16 ( ETHER_TYPE_ARP ) ; arp_hdr = ( struct arp_hdr * ) ( ( char * ) eth_hdr + sizeof ( struct ether_hdr ) ) ; arp_hdr -> arp_hrd = rte_cpu_to_be_16 ( ARP_HRD_ETHER ) ; arp_hdr -> arp_pro = rte_cpu_to_be_16 ( ETHER_TYPE_IPv4 ) ; arp_hdr -> arp_hln = ETHER_ADDR_LEN ; arp_hdr -> arp_pln = sizeof ( uint32_t ) ; arp_hdr -> arp_op = rte_cpu_to_be_16 ( ARP_OP_REQUEST ) ; rte_eth_macaddr_get ( BOND_PORT , & arp_hdr -> arp_data . arp_sha ) ; arp_hdr -> arp_data . arp_sip = bond_ip ; memset ( & arp_hdr -> arp_data . arp_tha , 0 , ETHER_ADDR_LEN ) ; arp_hdr -> arp_data . arp_tip = ( ( unsigned char * ) & res -> ip . addr . ipv4 ) [ 0 ] | ( ( ( unsigned char * ) & res -> ip . addr . ipv4 ) [ 1 ] << 8 ) | ( ( ( unsigned char * ) & res -> ip . addr . ipv4 ) [ 2 ] << 16 ) | ( ( ( unsigned char * ) & res -> ip . addr . ipv4 ) [ 3 ] << 24 ) ; rte_eth_tx_burst ( BOND_PORT , 0 , & created_pkt , 1 ) ; rte_delay_ms ( 100 ) ; cmdline_printf ( cl , "\\n" ) ; } | <S2SV_ModStart> mbuf_pool ) ; if ( created_pkt == NULL ) { cmdline_printf ( cl , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>mbuf\\n" ) ; return ; } |
6,481 | CWE-000 static int ov5640_set_fmt ( struct v4l2_subdev * sd , struct v4l2_subdev_pad_config * cfg , struct v4l2_subdev_format * format ) { struct ov5640_dev * sensor = to_ov5640_dev ( sd ) ; const struct ov5640_mode_info * new_mode ; struct v4l2_mbus_framefmt * mbus_fmt = & format -> format ; int ret ; if ( format -> pad != 0 ) return - EINVAL ; mutex_lock ( & sensor -> lock ) ; if ( sensor -> streaming ) { ret = - EBUSY ; goto out ; } ret = ov5640_try_fmt_internal ( sd , mbus_fmt , sensor -> current_fr , & new_mode ) ; if ( ret ) goto out ; if ( format -> which == V4L2_SUBDEV_FORMAT_TRY ) { struct v4l2_mbus_framefmt * fmt = v4l2_subdev_get_try_format ( sd , cfg , 0 ) ; * fmt = * mbus_fmt ; goto out ; } if ( new_mode != sensor -> current_mode ) { sensor -> current_mode = new_mode ; <S2SV_StartBug> sensor -> fmt = * mbus_fmt ; <S2SV_EndBug> sensor -> pending_mode_change = true ; } <S2SV_StartBug> out : <S2SV_EndBug> mutex_unlock ( & sensor -> lock ) ; return ret ; } | <S2SV_ModStart> ; sensor -> <S2SV_ModEnd> pending_mode_change = true <S2SV_ModStart> true ; } if ( mbus_fmt -> code != sensor -> fmt . code ) { sensor -> fmt = * mbus_fmt ; sensor -> pending_fmt_change = true ; } |
6,482 | CWE-000 <S2SV_StartBug> MultiplicativeExpression * read_multiplicative_expr ( ) { <S2SV_EndBug> MultiplicativeExpression * left ; MultiplicativeOperation op ; UnaryExpression * right ; <S2SV_StartBug> left = read_multiplicative_expr ( ) ; <S2SV_EndBug> if ( left == NULL ) { op = T_Identity ; right = read_unary_expr ( ) ; if ( right == NULL ) { <S2SV_StartBug> return NULL ; <S2SV_EndBug> } else { <S2SV_StartBug> return make_multiplicative_expr ( left , op , right ) ; <S2SV_EndBug> } } if ( accept ( ASTERISK ) ) { op = T_Multiply ; } else if ( accept ( SLASH ) ) { op = T_Divide ; } else { free ( left ) ; return NULL ; } right = read_unary_expr ( ) ; if ( right == NULL ) { <S2SV_StartBug> free ( left ) ; <S2SV_EndBug> return NULL ; <S2SV_StartBug> } <S2SV_EndBug> return make_multiplicative_expr ( left , op , right ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> * read_multiplicative_expr ( int calls <S2SV_ModStart> * right ; if ( calls == 0 ) { return NULL ; } <S2SV_ModEnd> right = read_unary_expr <S2SV_ModStart> NULL ) { left = read_multiplicative_expr ( calls - 1 ) ; if ( left == NULL ) { <S2SV_ModStart> } else { <S2SV_ModEnd> if ( accept <S2SV_ModStart> NULL ) { <S2SV_ModEnd> return NULL ; <S2SV_ModStart> NULL ; } else { <S2SV_ModStart> ) ; } } } else { op = T_Identity ; return make_multiplicative_expr ( NULL , op , right ) ; } } |
6,483 | CWE-000 <S2SV_StartBug> netserverinit ( const char * hostname , const char * mode ) { <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int |
6,484 | CWE-000 int memallocator_cmpf ( void * aa , void * bb ) { size_t a ; size_t b ; <S2SV_StartBug> a = ( size_t ) ( * ( void * * ) aa ) ; <S2SV_EndBug> <S2SV_StartBug> b = ( size_t ) ( * ( void * * ) bb ) ; <S2SV_EndBug> if ( a == b ) return ( 0 ) ; return ( a < b ) ? - 1 : 1 ; } | <S2SV_ModStart> size_t ) ( ( t_allocator <S2SV_ModEnd> * ) aa <S2SV_ModStart> ) aa ) -> allocator <S2SV_ModStart> size_t ) ( ( t_allocator <S2SV_ModEnd> * ) bb <S2SV_ModStart> ) bb ) -> allocator |
6,485 | CWE-000 static bool fast_classifier_find_dev_and_mac_addr ( sfe_ip_addr_t * addr , struct net_device * * dev , u8 * mac_addr , bool is_v4 ) { struct neighbour * neigh ; struct rtable * rt ; struct rt6_info * rt6 ; struct dst_entry * dst ; struct net_device * mac_dev ; if ( is_v4 ) { rt = ip_route_output ( & init_net , addr -> ip , 0 , 0 , 0 ) ; if ( unlikely ( IS_ERR ( rt ) ) ) { goto ret_fail ; } dst = ( struct dst_entry * ) rt ; <S2SV_StartBug> } else { <S2SV_EndBug> rt6 = rt6_lookup ( & init_net , ( struct in6_addr * ) addr -> ip6 , 0 , 0 , 0 ) ; if ( ! rt6 ) { goto ret_fail ; } dst = ( struct dst_entry * ) rt6 ; } rcu_read_lock ( ) ; neigh = dst_neigh_lookup ( dst , addr ) ; if ( unlikely ( ! neigh ) ) { rcu_read_unlock ( ) ; dst_release ( dst ) ; goto ret_fail ; } if ( unlikely ( ! ( neigh -> nud_state & NUD_VALID ) ) ) { rcu_read_unlock ( ) ; neigh_release ( neigh ) ; dst_release ( dst ) ; goto ret_fail ; } mac_dev = neigh -> dev ; if ( ! mac_dev ) { rcu_read_unlock ( ) ; neigh_release ( neigh ) ; dst_release ( dst ) ; goto ret_fail ; } memcpy ( mac_addr , neigh -> ha , ( size_t ) mac_dev -> addr_len ) ; dev_hold ( mac_dev ) ; * dev = mac_dev ; rcu_read_unlock ( ) ; neigh_release ( neigh ) ; dst_release ( dst ) ; return true ; ret_fail : DEBUG_TRACE ( "failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>MAC<S2SV_blank>address<S2SV_blank>for<S2SV_blank>IP:<S2SV_blank>%pIS\\n" , addr ) ; return false ; } | <S2SV_ModStart> rt ; } <S2SV_ModEnd> rcu_read_lock ( ) |
6,486 | CWE-000 <S2SV_StartBug> static void <S2SV_EndBug> wm_rxeof ( struct wm_rxqueue * rxq , u_int limit ) { struct wm_softc * sc = rxq -> rxq_sc ; struct ifnet * ifp = & sc -> sc_ethercom . ec_if ; struct wm_rxsoft * rxs ; struct mbuf * m ; int i , len ; int count = 0 ; uint32_t status , errors ; uint16_t vlantag ; <S2SV_StartBug> KASSERT ( mutex_owned ( rxq -> rxq_lock ) ) ; <S2SV_EndBug> for ( i = rxq -> rxq_ptr ; ; i = WM_NEXTRX ( i ) ) { if ( limit -- == 0 ) { <S2SV_StartBug> rxq -> rxq_ptr = i ; <S2SV_EndBug> break ; } rxs = & rxq -> rxq_soft [ i ] ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>checking<S2SV_blank>descriptor<S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , i ) ) ; wm_cdrxsync ( rxq , i , BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE ) ; status = wm_rxdesc_get_status ( rxq , i ) ; errors = wm_rxdesc_get_errors ( rxq , i ) ; len = le16toh ( wm_rxdesc_get_pktlen ( rxq , i ) ) ; vlantag = wm_rxdesc_get_vlantag ( rxq , i ) ; # ifdef WM_DEBUG uint32_t rsshash = le32toh ( wm_rxdesc_get_rsshash ( rxq , i ) ) ; uint8_t rsstype = wm_rxdesc_get_rsstype ( rxq , i ) ; # endif if ( ! wm_rxdesc_dd ( rxq , i , status ) ) { rxq -> rxq_ptr = i ; break ; } count ++ ; if ( __predict_false ( rxq -> rxq_discard ) ) { DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>discarding<S2SV_blank>contents<S2SV_blank>of<S2SV_blank>descriptor<S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , i ) ) ; wm_init_rxdesc ( rxq , i ) ; if ( wm_rxdesc_is_eop ( rxq , status ) ) { DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>resetting<S2SV_blank>rxdiscard<S2SV_blank>-><S2SV_blank>0\\n" , device_xname ( sc -> sc_dev ) ) ) ; rxq -> rxq_discard = 0 ; } continue ; } bus_dmamap_sync ( sc -> sc_dmat , rxs -> rxs_dmamap , 0 , rxs -> rxs_dmamap -> dm_mapsize , BUS_DMASYNC_POSTREAD ) ; m = rxs -> rxs_mbuf ; if ( ( len == 0 ) || ( wm_add_rxbuf ( rxq , i ) != 0 ) ) { ifp -> if_ierrors ++ ; bus_dmamap_sync ( sc -> sc_dmat , rxs -> rxs_dmamap , 0 , rxs -> rxs_dmamap -> dm_mapsize , BUS_DMASYNC_PREREAD ) ; wm_init_rxdesc ( rxq , i ) ; if ( ! wm_rxdesc_is_eop ( rxq , status ) ) rxq -> rxq_discard = 1 ; if ( rxq -> rxq_head != NULL ) m_freem ( rxq -> rxq_head ) ; WM_RXCHAIN_RESET ( rxq ) ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>Rx<S2SV_blank>buffer<S2SV_blank>allocation<S2SV_blank>failed,<S2SV_blank>" "dropping<S2SV_blank>packet%s\\n" , device_xname ( sc -> sc_dev ) , rxq -> rxq_discard ? "<S2SV_blank>(discard)" : "" ) ) ; continue ; } m -> m_len = len ; rxq -> rxq_len += len ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>buffer<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>len<S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , m -> m_data , len ) ) ; if ( ! wm_rxdesc_is_eop ( rxq , status ) ) { WM_RXCHAIN_LINK ( rxq , m ) ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>EOP,<S2SV_blank>rxlen<S2SV_blank>-><S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , rxq -> rxq_len ) ) ; continue ; } if ( ( sc -> sc_type != WM_T_I350 ) && ( sc -> sc_type != WM_T_I354 ) && ( sc -> sc_type != WM_T_I210 ) && ( sc -> sc_type != WM_T_I211 ) ) { if ( m -> m_len < ETHER_CRC_LEN ) { rxq -> rxq_tail -> m_len -= ( ETHER_CRC_LEN - m -> m_len ) ; m -> m_len = 0 ; } else m -> m_len -= ETHER_CRC_LEN ; len = rxq -> rxq_len - ETHER_CRC_LEN ; } else len = rxq -> rxq_len ; WM_RXCHAIN_LINK ( rxq , m ) ; * rxq -> rxq_tailp = NULL ; m = rxq -> rxq_head ; WM_RXCHAIN_RESET ( rxq ) ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>have<S2SV_blank>entire<S2SV_blank>packet,<S2SV_blank>len<S2SV_blank>-><S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , len ) ) ; if ( wm_rxdesc_has_errors ( rxq , errors ) ) { m_freem ( m ) ; continue ; } m_set_rcvif ( m , ifp ) ; m -> m_pkthdr . len = len ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>RSS<S2SV_blank>type=%" PRIu8 ",<S2SV_blank>RSS<S2SV_blank>hash=%" PRIu32 "\\n" , device_xname ( sc -> sc_dev ) , rsstype , rsshash ) ) ; if ( ! wm_rxdesc_input_vlantag ( rxq , status , vlantag , m ) ) continue ; wm_rxdesc_ensure_checksum ( rxq , status , errors , m ) ; rxq -> rxq_ptr = i ; rxq -> rxq_packets ++ ; rxq -> rxq_bytes += len ; mutex_exit ( rxq -> rxq_lock ) ; if_percpuq_enqueue ( sc -> sc_ipq , m ) ; mutex_enter ( rxq -> rxq_lock ) ; if ( rxq -> rxq_stopping ) break ; } if ( count != 0 ) rnd_add_uint32 ( & sc -> rnd_source , count ) ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>rxptr<S2SV_blank>-><S2SV_blank>%d\\n" , device_xname ( sc -> sc_dev ) , i ) ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static bool <S2SV_ModEnd> wm_rxeof ( struct <S2SV_ModStart> uint16_t vlantag ; bool more = false ; <S2SV_ModStart> rxq_ptr = i ; more = true ; DPRINTF ( WM_DEBUG_RX , ( "%s:<S2SV_blank>RX:<S2SV_blank>loop<S2SV_blank>limited,<S2SV_blank>descriptor<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>not<S2SV_blank>processed\\n" , device_xname ( sc -> sc_dev ) , i ) ) <S2SV_ModStart> ) ) ; return more ; |
6,487 | CWE-000 void mail_cache_reset ( void ) { mail_cache_t * message ; if ( ( message = pthread_getspecific ( mail_cache ) ) ) { st_cleanup ( message -> text ) ; message -> text = NULL ; message -> messagenum = 0 ; <S2SV_StartBug> } <S2SV_EndBug> return ; } | <S2SV_ModStart> = 0 ; mm_free ( message ) ; pthread_setspecific ( mail_cache , NULL ) ; |
6,488 | CWE-000 void enter_FFT ( ) <S2SV_StartBug> { <S2SV_EndBug> lcd_instruct ( LCD_CLEAR_DISPLAY ) ; lcd_data_string ( "Func<S2SV_blank>:<S2SV_blank>FFT" ) ; } | <S2SV_ModStart> ( ) { current_state = FFT ; |
6,489 | CWE-000 schanid_t glk_schannel_create ( glui32 rock ) { jobject jchan ; schannel_t * schan ; jchan = ( * jni_env ) -> CallObjectMethod ( GLK_M ( CREATECHAN ) ) ; if ( jni_check_exc ( ) || ! jchan ) { return NULL ; } <S2SV_StartBug> jchan = jni_new_global ( jchan ) ; <S2SV_EndBug> schan = ( schannel_t * ) gli_malloc ( sizeof ( schannel_t ) ) ; schan -> rock = rock ; schan -> jchan = jchan ; gli_schan_set_disprock ( schan ) ; schan -> prev = NULL ; schan -> next = gli_schanlist ; gli_schanlist = schan ; if ( schan -> next ) { schan -> next -> prev = schan ; } return schan ; } | <S2SV_ModStart> } jchan = jni_replace_with_global <S2SV_ModEnd> ( jchan ) |
6,490 | CWE-000 <S2SV_StartBug> int set_git_dir ( const char * path ) <S2SV_EndBug> { if ( setenv ( GIT_DIR_ENVIRONMENT , path , 1 ) ) <S2SV_StartBug> return error ( "Could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>GIT_DIR<S2SV_blank>to<S2SV_blank>\'%s\'" , path ) ; <S2SV_EndBug> repo_set_gitdir ( the_repository , path ) ; setup_git_env ( ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> set_git_dir ( const <S2SV_ModStart> 1 ) ) die ( "could<S2SV_blank>not<S2SV_blank>set<S2SV_blank>GIT_DIR<S2SV_blank>to<S2SV_blank>\'%s\'" <S2SV_ModEnd> , path ) <S2SV_ModStart> ( ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,491 | CWE-000 PHP_METHOD ( Trans , commit ) { php_alpm_transaction_object * intern = Z_TRANSO_P ( getThis ( ) ) ; int ret ; enum _alpm_errno_t pmerr ; alpm_list_t * list = NULL ; if ( zend_parse_parameters_none ( ) == FAILURE ) { RETURN_NULL ( ) } ret = alpm_trans_commit ( intern -> handle , & list ) ; if ( ret == 0 ) RETURN_NULL ( ) if ( ret != - 1 ) { zend_throw_exception ( php_alpm_transaction_exception_class_entry , "unexpected<S2SV_blank>return<S2SV_blank>value" , ret ) ; RETURN_NULL ( ) } pmerr = alpm_errno ( intern -> handle ) ; switch ( pmerr ) { case ALPM_ERR_FILE_CONFLICTS : <S2SV_StartBug> RETURN_NULL ( ) <S2SV_EndBug> break ; case ALPM_ERR_PKG_INVALID : case ALPM_ERR_PKG_INVALID_CHECKSUM : case ALPM_ERR_PKG_INVALID_SIG : case ALPM_ERR_DLT_INVALID : alpm_list_to_zval ( list , return_value ) ; break ; default : break ; } RETURN_NULL ( ) } | <S2SV_ModStart> case ALPM_ERR_FILE_CONFLICTS : alpm_fileconflicts_to_zval ( list , return_value ) ; <S2SV_ModEnd> break ; case |
6,492 | CWE-000 static void sms_compose2 ( sms_t * h , int more ) { struct ast_tm tm ; struct timeval now = h -> scts ; <S2SV_StartBug> char stm [ 9 ] ; <S2SV_EndBug> h -> omsg [ 0 ] = 0x00 ; h -> omsg [ 1 ] = 0 ; putdummydata_proto2 ( h ) ; if ( h -> smsc ) { h -> omsg [ 0 ] = 0x11 ; ast_localtime ( & now , & tm , NULL ) ; sprintf ( stm , "%02d%02d%02d%02d" , tm . tm_mon + 1 , tm . tm_mday , tm . tm_hour , tm . tm_min ) ; adddata_proto2 ( h , 0x14 , stm , 8 ) ; if ( * h -> oa == 0 ) { strcpy ( h -> oa , "00000000" ) ; } adddata_proto2 ( h , 0x15 , h -> oa , strlen ( h -> oa ) ) ; adddata_proto2 ( h , 0x17 , "\\1" , 1 ) ; } else { h -> omsg [ 0 ] = 0x10 ; adddata_proto2 ( h , 0x17 , "\\1" , 1 ) ; if ( * h -> da == 0 ) { strcpy ( h -> da , "00000000" ) ; } adddata_proto2 ( h , 0x18 , h -> da , strlen ( h -> da ) ) ; adddata_proto2 ( h , 0x1B , "\\1" , 1 ) ; adddata_proto2 ( h , 0x1C , "\\0\\0\\0" , 3 ) ; } } | <S2SV_ModStart> char stm [ 45 <S2SV_ModEnd> ] ; h |
6,493 | CWE-000 int lwip_itf_getnext ( struct mn_itf * mi ) { int rc ; int prev_idx , cur_idx ; struct netif * nif ; if ( mi -> mif_name [ 0 ] == '\\0' ) { prev_idx = - 1 ; } else { prev_idx = mi -> mif_idx ; } mi -> mif_idx = UCHAR_MAX ; rc = MN_ENOBUFS ; <S2SV_StartBug> for ( nif = netif_list ; nif ; nif = nif -> next ) { <S2SV_EndBug> cur_idx = nif -> num ; if ( cur_idx <= prev_idx || cur_idx >= mi -> mif_idx ) { continue ; } memcpy ( mi -> mif_name , nif -> name , sizeof ( nif -> name ) ) ; mi -> mif_name [ sizeof ( nif -> name ) ] = '0' + nif -> num ; mi -> mif_name [ sizeof ( nif -> name ) + 1 ] = '\\0' ; mi -> mif_idx = cur_idx ; mi -> mif_flags = lwip_if_flags ( nif -> flags ) ; rc = 0 ; } <S2SV_StartBug> return rc ; <S2SV_EndBug> } | <S2SV_ModStart> = MN_ENOBUFS ; LOCK_TCPIP_CORE ( ) ; <S2SV_ModStart> 0 ; } UNLOCK_TCPIP_CORE ( ) ; |
6,494 | CWE-000 static int fsck_loose ( const unsigned char * sha1 , const char * path , void * data ) { <S2SV_StartBug> if ( fsck_sha1 ( sha1 ) ) <S2SV_EndBug> errors_found |= ERROR_OBJECT ; return 0 ; } | <S2SV_ModStart> data ) { struct object * obj = parse_loose_object ( sha1 , path ) ; if ( ! obj ) { errors_found |= ERROR_OBJECT ; error ( "%s:<S2SV_blank>object<S2SV_blank>corrupt<S2SV_blank>or<S2SV_blank>missing:<S2SV_blank>%s" , sha1_to_hex ( sha1 ) , path ) ; return 0 ; } obj -> flags = HAS_OBJ ; if ( fsck_obj ( obj <S2SV_ModEnd> ) ) errors_found |
6,495 | CWE-000 static int _archive_read_seek_header ( struct archive * _a , size_t index ) { struct archive_read * a = ( struct archive_read * ) _a ; int ret ; archive_check_magic ( _a , ARCHIVE_READ_MAGIC , ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA | ARCHIVE_STATE_EOF , "archive_read_seek_header" ) ; if ( a -> format -> seek_header == NULL ) { archive_set_error ( & a -> archive , ARCHIVE_ERRNO_PROGRAMMER , "Internal<S2SV_blank>error:<S2SV_blank>" "No<S2SV_blank>format_seek_header<S2SV_blank>function<S2SV_blank>registered" ) ; return ( ARCHIVE_FATAL ) ; } archive_clear_error ( & a -> archive ) ; ret = ( a -> format -> seek_header ) ( a , index ) ; switch ( ret ) { case ARCHIVE_EOF : a -> archive . state = ARCHIVE_STATE_EOF ; break ; case ARCHIVE_OK : a -> archive . state = ARCHIVE_STATE_HEADER ; break ; case ARCHIVE_WARN : a -> archive . state = ARCHIVE_STATE_HEADER ; break ; case ARCHIVE_RETRY : break ; case ARCHIVE_FATAL : a -> archive . state = ARCHIVE_STATE_FATAL ; break ; } <S2SV_StartBug> a -> read_data_output_offset = 0 ; <S2SV_EndBug> a -> read_data_remaining = 0 ; a -> read_data_is_posix_read = 0 ; a -> read_data_requested = 0 ; a -> data_start_node = a -> client . cursor ; return ret ; } | <S2SV_ModStart> } a -> <S2SV_ModEnd> data_start_node = a |
6,496 | CWE-000 <S2SV_StartBug> static void wiiusb_hid_free ( void * data ) <S2SV_EndBug> { struct wiiusb_adapter * adapter = NULL ; struct wiiusb_adapter * next_adapter = NULL ; wiiusb_hid_t * hid = ( wiiusb_hid_t * ) data ; if ( ! hid ) return ; hid -> poll_thread_quit = true ; if ( hid -> poll_thread ) sthread_join ( hid -> poll_thread ) ; hid -> manual_removal = TRUE ; for ( adapter = hid -> adapters_head ; adapter ; adapter = next_adapter ) { next_adapter = adapter -> next ; wiiusb_hid_remove_adapter ( adapter ) ; } pad_connection_destroy ( hid -> connections ) ; free ( hid ) ; } | <S2SV_ModStart> void wiiusb_hid_free ( const |
6,497 | CWE-000 <S2SV_StartBug> char * * cron_cli_get_config ( ) <S2SV_EndBug> { if ( NULL != config_list ) { char * cfg = NULL ; int i = 0 ; while ( cfg = config_list [ i ++ ] ) { free ( cfg ) ; } free ( config_list ) ; } config_list = calloc ( cron_cli_record_list -> count + 1 , sizeof ( char * ) ) ; int i = 0 ; stack_for_each ( cron_cli_record_list , crontab_record_variant ) { config_list [ i ] = calloc ( 512 , sizeof ( char ) ) ; cron_cli_record_t * crontab_record = ( cron_cli_record_t * ) variant_get_ptr ( crontab_record_variant ) ; char * crontab_time = crontab_time_to_string ( crontab_record -> time ) ; snprintf ( config_list [ i ] , 511 , "job<S2SV_blank>%s<S2SV_blank>scene<S2SV_blank>%s" , crontab_time , crontab_record -> scene ) ; free ( crontab_time ) ; i ++ ; } return config_list ; } | <S2SV_ModStart> * cron_cli_get_config ( vty_t * vty |
6,498 | CWE-000 static void table_allocator_client_send_request ( struct tac_ctx * ctx ) { struct tac_address * address = ctx -> address ; struct sockaddr_un remote_addr ; int32_t retval = - 1 , sock_fd ; struct json_object * req_obj = NULL ; const char * json_str ; req_obj = table_allocator_shared_json_create_req ( address -> address_str , address -> ifname , address -> tag , address -> addr_family , ctx -> cmd ) ; if ( ! req_obj ) { if ( uv_timer_start ( & ( ctx -> request_timeout_handle ) , client_request_timeout_handle_cb , REQUEST_RETRANSMISSION_MS , 0 ) ) { TA_PRINT_SYSLOG ( ctx , LOG_CRIT , "Can\'t<S2SV_blank>start<S2SV_blank>request<S2SV_blank>timer\\n" ) ; exit ( EXIT_FAILURE ) ; } TA_PRINT_SYSLOG ( ctx , LOG_ERR , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>request<S2SV_blank>json<S2SV_blank>for<S2SV_blank>" "%s-%s-%u\\n" , address -> ifname , address -> address_str , address -> addr_family ) ; return ; } json_str = json_object_to_json_string_ext ( req_obj , JSON_C_TO_STRING_PLAIN ) ; <S2SV_StartBug> TA_PRINT_SYSLOG ( ctx , LOG_DEBUG , "JSON<S2SV_blank>request:<S2SV_blank>%s<S2SV_blank>%zd\\n" , <S2SV_EndBug> json_str , strlen ( json_str ) ) ; memset ( & remote_addr , 0 , sizeof ( remote_addr ) ) ; remote_addr . sun_family = AF_UNIX ; strncpy ( remote_addr . sun_path + 1 , ctx -> destination , strlen ( ctx -> destination ) ) ; uv_fileno ( ( const uv_handle_t * ) & ( ctx -> unix_socket_handle ) , & sock_fd ) ; retval = sendto ( sock_fd , json_str , strlen ( json_str ) , 0 , ( const struct sockaddr * ) & remote_addr , sizeof ( struct sockaddr_un ) ) ; json_object_put ( req_obj ) ; if ( retval < 0 ) { TA_PRINT_SYSLOG ( ctx , LOG_ERR , "Sending<S2SV_blank>error:<S2SV_blank>%s\\n" , uv_strerror ( retval ) ) ; } else { TA_PRINT ( ctx -> logfile , "Sent<S2SV_blank>%d<S2SV_blank>bytes\\n" , retval ) ; uv_udp_recv_start ( & ( ctx -> unix_socket_handle ) , unix_socket_alloc_cb , unix_socket_recv_cb ) ; } if ( uv_timer_start ( & ( ctx -> request_timeout_handle ) , client_request_timeout_handle_cb , REQUEST_RETRANSMISSION_MS , 0 ) ) { TA_PRINT_SYSLOG ( ctx , LOG_CRIT , "Can\'t<S2SV_blank>start<S2SV_blank>request<S2SV_blank>timer\\n" ) ; exit ( EXIT_FAILURE ) ; } } | <S2SV_ModStart> , LOG_DEBUG , "JSON<S2SV_blank>request:<S2SV_blank>%s\\n" , json_str <S2SV_ModEnd> ) ; memset |
6,499 | CWE-000 zpointer zz_thumb_writer_put_ldr_b_reg_address ( ZzThumbWriter * self , arm_reg reg , zaddr address ) { ZzArmRegInfo ri ; zz_arm_register_describe ( reg , & ri ) ; <S2SV_StartBug> if ( ( ( zaddr ) self -> pc ) % 4 ) { <S2SV_EndBug> zz_thumb_writer_put_ldr_reg_imm ( self , reg , 0x4 ) ; <S2SV_StartBug> if ( ri . meta <= ZZ_ARM_R7 ) { <S2SV_EndBug> <S2SV_StartBug> zz_thumb_writer_put_nop ( self ) ; <S2SV_EndBug> } } else { if ( ri . meta <= ZZ_ARM_R7 ) { zz_thumb_writer_put_ldr_reg_imm ( self , reg , 0x0 ) ; } else { <S2SV_StartBug> zz_thumb_writer_put_ldr_reg_imm ( self , reg , 0x4 ) ; <S2SV_EndBug> zz_thumb_writer_put_nop ( self ) ; } } zz_thumb_writer_put_b_imm ( self , 0x2 ) ; zz_thumb_writer_put_bytes ( self , ( zpointer ) & address , sizeof ( zpointer ) ) ; return self -> pc ; } | <S2SV_ModStart> ( ( ( ( <S2SV_ModStart> ) % 4 ) ) { if ( ri . meta <= ZZ_ARM_R7 <S2SV_ModStart> 0x4 ) ; <S2SV_ModEnd> zz_thumb_writer_put_nop ( self <S2SV_ModStart> zz_thumb_writer_put_nop ( self ) ; } else { zz_thumb_writer_put_ldr_reg_imm ( self , reg , 0x4 <S2SV_ModStart> , reg , 0x2 <S2SV_ModEnd> ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.