Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
6,000 | CWE-000 static int unifycr_chunk_write ( unifycr_filemeta_t * meta , int chunk_id , off_t chunk_offset , const void * buf , size_t count ) { unifycr_chunkmeta_t * chunk_meta = & ( meta -> chunk_meta [ chunk_id ] ) ; if ( chunk_meta -> location == CHUNK_LOCATION_MEMFS ) { void * chunk_buf = unifycr_compute_chunk_buf ( meta , chunk_id , chunk_offset ) ; memcpy ( chunk_buf , buf , count ) ; } else if ( chunk_meta -> location == CHUNK_LOCATION_SPILLOVER ) { off_t spill_offset = unifycr_compute_spill_offset ( meta , chunk_id , chunk_offset ) ; ssize_t rc = pwrite ( unifycr_spilloverblock , buf , count , spill_offset ) ; if ( rc < 0 ) { perror ( "pwrite<S2SV_blank>failed" ) ; } } else { DEBUG ( "unknown<S2SV_blank>chunk<S2SV_blank>type<S2SV_blank>in<S2SV_blank>read\\n" ) ; <S2SV_StartBug> return UNIFYCR_ERR_IO ; <S2SV_EndBug> } return UNIFYCR_SUCCESS ; } | <S2SV_ModStart> ) ; return UNIFYCR_ERROR_IO <S2SV_ModEnd> ; } return |
6,001 | CWE-000 <S2SV_StartBug> static void json_data_handler ( const char * json_data1 ) <S2SV_EndBug> { int is_login_website_ok ; int is_auth_login_ok ; int is_open_desktop_file_ok ; char * auth_code ; login_action_e action = UNKNOWN ; desktop_file_t desktop_file ; rdp_conn_data_t * conn_data = NULL ; login_action_type_e login_type = UNKNOWN_LOGIN_TYPE ; website_login_data_t website_data ; <S2SV_StartBug> desktop_type_e desktop_type = UNKNOWN_DESKTOP ; <S2SV_EndBug> char json_data [ 2048 ] = { 0 } ; char json_login_status [ 300 ] = { 0 } ; char del_cert_cmd [ 1024 ] = { 0 } ; char del_desktopfile_cert_cmd [ 1024 ] = { 0 } ; int i ; struct appcc_post_data appcc_data ; char * response ; char feedback_appcc_url [ 1024 ] ; if ( NULL == json_data ) return ; <S2SV_StartBug> appcc_data . uuid = key ; <S2SV_EndBug> Convert ( json_data1 , json_data , CP_UTF8 , CP_ACP ) ; action = get_action_value ( json_data ) ; memset ( feedback_appcc_url , 0 , sizeof ( feedback_appcc_url ) ) ; sprintf ( feedback_appcc_url , "%s%s" , conf_data -> appc_host , FEEDBACK_URL ) ; writelog ( WSPRO_INFO , "feedback<S2SV_blank>appcc<S2SV_blank>url<S2SV_blank>is<S2SV_blank>%s\\n" , feedback_appcc_url ) ; switch ( action ) { case SCAN : save_scan_result ( oc_json_is_scan_status_file , key ) ; break ; case LOGIN : login_type = get_login_type ( json_data ) ; switch ( login_type ) { case RDP_DESTKTOP_LOGIN_TYPE : conn_data = ( rdp_conn_data_t * ) malloc ( sizeof ( rdp_conn_data_t ) * 50 ) ; memset ( conn_data , 0 , sizeof ( rdp_conn_data_t ) * 50 ) ; if ( JSON_DATA_INVALIDE == get_login_data ( json_data , conn_data ) ) { writelog ( WSPRO_ERROR , "invalide<S2SV_blank>rdp<S2SV_blank>login<S2SV_blank>data" ) ; save_login_result ( login_status_file , key , 0 ) ; appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>login<S2SV_blank>desktop<S2SV_blank>:<S2SV_blank>invalid<S2SV_blank>json<S2SV_blank>data." ; } else { oc_do_rdp_connect ( conn_data ) ; if ( rdp_connect_flag ) { appcc_data . result = LOGIN_SUCCESS ; appcc_data . msg = "Login<S2SV_blank>desktop<S2SV_blank>success." ; } else { appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>login<S2SV_blank>desktop." ; } } response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; Sleep ( 10 * 1000 ) ; for ( i = 0 ; i < MAX_DESKTOP_COUNT ; i ++ ) { if ( conn_data [ i ] . username == NULL ) break ; memset ( del_cert_cmd , 0 , sizeof ( del_cert_cmd ) ) ; compose_del_conninfo_cmd ( & conn_data [ i ] , del_cert_cmd ) ; WinExec ( del_cert_cmd , SW_HIDE ) ; } destroy_flag = 1 ; free_rdp_conn_data ( conn_data ) ; break ; case WEBSITE_LOGIN_TYPE : if ( JSON_DATA_INVALIDE == get_website_login_data ( json_data , & website_data ) ) { writelog ( WSPRO_ERROR , "invalide<S2SV_blank>website<S2SV_blank>login<S2SV_blank>data" ) ; save_login_result ( login_status_file , key , 0 ) ; appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>login<S2SV_blank>website:<S2SV_blank>invalid<S2SV_blank>json<S2SV_blank>data." ; } else { is_login_website_ok = login_website ( & website_data ) ; save_login_result ( login_status_file , key , is_login_website_ok ) ; if ( is_login_website_ok ) { appcc_data . result = LOGIN_SUCCESS ; appcc_data . msg = "Login<S2SV_blank>website<S2SV_blank>success." ; } else { appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>login<S2SV_blank>website." ; } } response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; destroy_flag = 1 ; free_website_data ( & website_data ) ; break ; case OPEN_DESKTOP_FILE : memset ( & desktop_file , 0 , sizeof ( desktop_file ) ) ; if ( JSON_DATA_INVALIDE == get_desktop_file ( json_data , & desktop_file ) ) { writelog ( WSPRO_ERROR , "Invalide<S2SV_blank>desktop<S2SV_blank>file<S2SV_blank>data" ) ; save_login_result ( login_status_file , key , 0 ) ; appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>open<S2SV_blank>remote<S2SV_blank>app:<S2SV_blank>invalid<S2SV_blank>json<S2SV_blank>data." ; } else { is_open_desktop_file_ok = open_desktop_file ( & desktop_file ) ; save_login_result ( login_status_file , key , is_open_desktop_file_ok ) ; if ( is_open_desktop_file_ok ) { appcc_data . result = LOGIN_SUCCESS ; appcc_data . msg = "Open<S2SV_blank>remote<S2SV_blank>app<S2SV_blank>success." ; } else { appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>open<S2SV_blank>remote<S2SV_blank>app." ; } } response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; Sleep ( 10 * 1000 ) ; memset ( del_desktopfile_cert_cmd , 0 , sizeof ( del_desktopfile_cert_cmd ) ) ; compose_del_desktop_file_conn_cert_cmd ( & desktop_file , del_desktopfile_cert_cmd ) ; WinExec ( del_desktopfile_cert_cmd , SW_HIDE ) ; destroy_flag = 1 ; cleanup_desktop_file ( & desktop_file ) ; break ; case UNKNOWN_LOGIN_TYPE : sprintf ( json_login_status , "[{\\"%s\\"<S2SV_blank>:<S2SV_blank>%s}]" , key , JSON_LOGIN_UNSUPPORTED_LOGIN_TYPE ) ; write_json_data_to_file ( login_status_file , json_login_status ) ; appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Unsupported<S2SV_blank>login<S2SV_blank>type." ; response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; destroy_flag = 1 ; break ; } break ; case AUTH_LOGIN : auth_code = get_auth_login_code ( json_data ) ; writelog ( WSPRO_INFO , "the<S2SV_blank>auth_code<S2SV_blank>of<S2SV_blank>auth<S2SV_blank>login<S2SV_blank>is<S2SV_blank>%s" , auth_code ) ; if ( auth_code ) { is_auth_login_ok = auth_login_desktop ( auth_code ) ; save_login_result ( login_status_file , key , is_auth_login_ok ) ; if ( is_auth_login_ok ) { appcc_data . result = LOGIN_SUCCESS ; appcc_data . msg = "Auth<S2SV_blank>login<S2SV_blank>desktop<S2SV_blank>success." ; } else { appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Fail<S2SV_blank>auth<S2SV_blank>login<S2SV_blank>desktop." ; } free ( auth_code ) ; } response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; destroy_flag = 1 ; break ; case CANCEL : save_cancel_result ( login_status_file , key ) ; break ; case UNKNOWN : save_login_result ( login_status_file , key , 0 ) ; appcc_data . result = LOGIN_FAIL ; appcc_data . msg = "Unknown<S2SV_blank>login<S2SV_blank>action." ; response = feedback_server ( feedback_appcc_url , & appcc_data , construct_appcc_postfield ) ; appcc_response_handler ( response ) ; destroy_flag = 1 ; break ; } return ; } | <S2SV_ModStart> const char * json_data <S2SV_ModEnd> ) { int <S2SV_ModStart> desktop_type = UNKNOWN_DESKTOP <S2SV_ModEnd> ; char json_login_status <S2SV_ModStart> ) return ; setlocale ( LC_CTYPE , "chinese" ) ; <S2SV_ModStart> uuid = key <S2SV_ModEnd> ; action = |
6,002 | CWE-000 static void pr_stm ( FILE * out , T_stm stm , int d ) { if ( stm == NULL ) { <S2SV_StartBug> fprintf ( out , "NULL" , d + 1 ) ; <S2SV_EndBug> return ; } switch ( stm -> kind ) { case T_SEQ : indent ( out , d ) ; fprintf ( out , "SEQ(\\n" ) ; pr_stm ( out , stm -> u . SEQ . left , d + 1 ) ; fprintf ( out , ",\\n" ) ; pr_stm ( out , stm -> u . SEQ . right , d + 1 ) ; fprintf ( out , ")" ) ; break ; case T_LABEL : indent ( out , d ) ; fprintf ( out , "LABEL<S2SV_blank>%s" , S_name ( stm -> u . LABEL ) ) ; break ; case T_JUMP : indent ( out , d ) ; fprintf ( out , "JUMP(\\n" ) ; pr_tree_exp ( out , stm -> u . JUMP . exp , d + 1 ) ; fprintf ( out , ")" ) ; break ; case T_CJUMP : indent ( out , d ) ; fprintf ( out , "CJUMP(%s,\\n" , rel_oper [ stm -> u . CJUMP . op ] ) ; pr_tree_exp ( out , stm -> u . CJUMP . left , d + 1 ) ; fprintf ( out , ",\\n" ) ; pr_tree_exp ( out , stm -> u . CJUMP . right , d + 1 ) ; fprintf ( out , ",\\n" ) ; indent ( out , d + 1 ) ; fprintf ( out , "%s," , S_name ( stm -> u . CJUMP . true ) ) ; fprintf ( out , "%s" , S_name ( stm -> u . CJUMP . false ) ) ; fprintf ( out , ")" ) ; break ; case T_MOVE : indent ( out , d ) ; fprintf ( out , "MOVE(\\n" ) ; pr_tree_exp ( out , stm -> u . MOVE . dst , d + 1 ) ; fprintf ( out , ",\\n" ) ; pr_tree_exp ( out , stm -> u . MOVE . src , d + 1 ) ; fprintf ( out , ")" ) ; break ; case T_EXP : indent ( out , d ) ; fprintf ( out , "EXP(\\n" ) ; pr_tree_exp ( out , stm -> u . EXP , d + 1 ) ; fprintf ( out , ")" ) ; break ; } } | <S2SV_ModStart> NULL ) { indent ( out , d ) ; |
6,003 | CWE-000 uint8_t getHum ( void ) { <S2SV_StartBug> # if SIMULATOR < 1 <S2SV_EndBug> ADCSRA |= ( 1 << ADSC ) ; while ( ! ( ADCSRA & ( 1 << ADIF ) ) ) ; <S2SV_StartBug> uint8_t result = ADCH ; <S2SV_EndBug> ADCSRA |= ( 1 << ADIF ) ; <S2SV_StartBug> return ( result > ANALOG_MAX_PERCENT ) ? ANALOG_MAX_PERCENT : result ; <S2SV_EndBug> <S2SV_StartBug> # else <S2SV_EndBug> return 50 ; # endif } | <S2SV_ModStart> void ) { uint8_t result = 0 ; <S2SV_ModEnd> ADCSRA |= ( <S2SV_ModStart> ) ) ; <S2SV_ModEnd> result = ADCH <S2SV_ModStart> ADIF ) ; result = result / 2 ; <S2SV_ModStart> : result ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,004 | CWE-000 static zend_op * zend_delayed_compile_dim ( znode * result , zend_ast * ast , uint32_t type ) { zend_ast * var_ast = ast -> child [ 0 ] ; zend_ast * dim_ast = ast -> child [ 1 ] ; zend_op * opline ; znode var_node , dim_node ; zend_delayed_compile_var ( & var_node , var_ast , type ) ; zend_separate_if_call_and_write ( & var_node , var_ast , type ) ; if ( dim_ast == NULL ) { if ( type == BP_VAR_R || type == BP_VAR_IS ) { zend_error_noreturn ( E_COMPILE_ERROR , "Cannot<S2SV_blank>use<S2SV_blank>[]<S2SV_blank>for<S2SV_blank>reading" ) ; } if ( type == BP_VAR_UNSET ) { zend_error_noreturn ( E_COMPILE_ERROR , "Cannot<S2SV_blank>use<S2SV_blank>[]<S2SV_blank>for<S2SV_blank>unsetting" ) ; } dim_node . op_type = IS_UNUSED ; } else { zend_compile_expr ( & dim_node , dim_ast ) ; } opline = zend_delayed_emit_op ( result , ZEND_FETCH_DIM_R , & var_node , & dim_node ) ; zend_adjust_for_fetch_type ( opline , result , type ) ; <S2SV_StartBug> return opline ; <S2SV_EndBug> } | <S2SV_ModStart> type ) ; if ( dim_node . op_type == IS_CONST ) { zend_handle_numeric_dim ( opline , & dim_node ) ; } |
6,005 | CWE-000 ListElement listGetFirst ( List list ) { <S2SV_StartBug> assert ( list != NULL ) ; <S2SV_EndBug> list -> iterator = list -> head ; return nodeGetElement ( list -> iterator ) ; } | <S2SV_ModStart> NULL ) ; if ( nodeIsEmpty ( list -> head ) ) { list -> iterator = NULL ; return NULL ; } |
6,006 | CWE-000 int comp_updater_reset ( comp_updater_t * comp_updater , int batch_i ) { bptt_updater_t * bptt_updater ; int i , j , g ; ST_CHECK_PARAM ( comp_updater == NULL , - 1 ) ; <S2SV_StartBug> for ( g = 0 ; g < comp_updater -> comp -> num_glue_cycle ; g ++ ) { <S2SV_EndBug> bptt_updater = comp_updater -> bptt_updaters [ g ] ; for ( j = 1 ; j <= comp_updater -> comp -> glue_cycles [ g ] [ 0 ] ; j ++ ) { for ( i = 0 ; i < bptt_updater -> num_ac_bptts ; i ++ ) { if ( mat_set_row ( bptt_updater -> ac_bptts + j , i * comp_updater -> batch_size + batch_i , 0.0 ) < 0 ) { ST_WARNING ( "Failed<S2SV_blank>to<S2SV_blank>mat_set_row<S2SV_blank>ac_bptts." ) ; return - 1 ; } } for ( i = 0 ; i < bptt_updater -> num_er_bptts ; i ++ ) { if ( mat_set_row ( bptt_updater -> er_bptts + j , i * comp_updater -> batch_size + batch_i , 0.0 ) < 0 ) { ST_WARNING ( "Failed<S2SV_blank>to<S2SV_blank>mat_set_row<S2SV_blank>er_bptts." ) ; return - 1 ; } } } } for ( i = 2 ; i < comp_updater -> comp -> num_layer ; i ++ ) { if ( layer_updater_reset ( comp_updater -> layer_updaters [ i ] , batch_i ) < 0 ) { ST_WARNING ( "Failed<S2SV_blank>to<S2SV_blank>layer_updater_reset.[%s]" , comp_updater -> comp -> layers [ i ] -> name ) ; return - 1 ; } } return 0 ; } | <S2SV_ModStart> 1 ) ; if ( comp_updater -> bptt_updaters == NULL ) { return 0 ; } |
6,007 | CWE-000 static void visit_class_decl ( gvisitor_t * self , gnode_class_decl_t * node ) { DECLARE_SYMTABLE ( ) ; DEBUG_SYMTABLE ( "class:<S2SV_blank>%s" , node -> identifier ) ; <S2SV_StartBug> if ( ! symboltable_insert ( symtable , node -> identifier , ( void * ) node ) ) { <S2SV_EndBug> REPORT_ERROR ( node , "Identifier<S2SV_blank>%s<S2SV_blank>redeclared." , node -> identifier ) ; } CREATE_SYMTABLE ( SYMTABLE_TAG_CLASS ) ; gnode_array_each ( node -> decls , { visit ( val ) ; } ) ; RESTORE_SYMTABLE ( ) ; } | <S2SV_ModStart> identifier ) ; const char * identifier = node -> identifier ; char buffer [ 512 ] ; if ( ( symboltable_tag ( symtable ) == SYMTABLE_TAG_CLASS ) && node -> storage == TOK_KEY_STATIC ) { snprintf ( buffer , sizeof ( buffer ) , "$%s" , identifier ) ; identifier = ( const char * ) buffer ; } <S2SV_ModStart> ( symtable , <S2SV_ModEnd> identifier , ( |
6,008 | CWE-000 void LoadGraphic ( short resID ) { Rect bounds ; PicHandle thePicture ; thePicture = GetPicture ( resID ) ; if ( thePicture == 0L ) RedAlert ( "\\pA<S2SV_blank>Graphic<S2SV_blank>Couldn\'t<S2SV_blank>Be<S2SV_blank>Loaded" ) ; bounds = ( * thePicture ) -> picFrame ; <S2SV_StartBug> OffsetRect ( & bounds , - bounds . left , - bounds . top ) ; <S2SV_EndBug> DrawPicture ( thePicture , & bounds ) ; ReleaseResource ( ( Handle ) thePicture ) ; } | <S2SV_ModStart> -> picFrame ; # ifdef __LITTLE_ENDIAN__ bounds . top = Endian16_Swap ( bounds . top ) ; bounds . left = Endian16_Swap ( bounds . left ) ; bounds . bottom = Endian16_Swap ( bounds . bottom ) ; bounds . right = Endian16_Swap ( bounds . right ) ; # endif |
6,009 | CWE-000 void create_listening_socket ( char * char_address ) { int bind_ret = 0 ; for ( server = matches ; server != NULL ; server = server -> ai_next ) { listening_socket_fd = socket ( server -> ai_family , server -> ai_socktype , 0 ) ; if ( listening_socket_fd == - 1 ) { continue ; } bind_ret = bind ( listening_socket_fd , server -> ai_addr , server -> ai_addrlen ) ; if ( bind_ret == - 1 ) { close ( listening_socket_fd ) ; continue ; } return ; } fprintf ( stderr , "address<S2SV_blank>\'%s\'<S2SV_blank>didn\'t<S2SV_blank>parse<S2SV_blank>(v4<S2SV_blank>or<S2SV_blank>v6)\\n" , char_address ) ; <S2SV_StartBug> exit ( - 2 ) ; <S2SV_EndBug> } | <S2SV_ModStart> char_address ) ; fprintf ( stdout , "Server<S2SV_blank>exiting<S2SV_blank>cleanly" ) ; |
6,010 | CWE-000 static int array_any_nonzero ( PyArrayObject * arr ) { npy_intp counter ; PyArrayIterObject * it ; <S2SV_StartBug> npy_bool anyTRUE = NPY_FALSE ; <S2SV_EndBug> it = ( PyArrayIterObject * ) PyArray_IterNew ( ( PyObject * ) arr ) ; if ( it == NULL ) { return anyTRUE ; <S2SV_StartBug> } <S2SV_EndBug> counter = it -> size ; while ( counter -- ) { if ( PyArray_DESCR ( arr ) -> f -> nonzero ( it -> dataptr , arr ) ) { anyTRUE = NPY_TRUE ; break ; } <S2SV_StartBug> PyArray_ITER_NEXT ( it ) ; <S2SV_EndBug> } Py_DECREF ( it ) ; return anyTRUE ; } | <S2SV_ModStart> anyTRUE = NPY_FALSE ; int needs_api = 0 <S2SV_ModStart> anyTRUE ; } needs_api = NpyIter_IterationNeedsAPI ( it ) ; <S2SV_ModStart> break ; } if ( needs_api && PyErr_Occurred ( ) ) { Py_DECREF ( it ) ; return - 1 ; } |
6,011 | CWE-000 int pmix_mca_base_component_repository_add ( const char * path ) { # if PMIX_HAVE_PDL_SUPPORT char * path_to_use = NULL , * dir , * ctx ; const char sep [ ] = { PMIX_ENV_SEP , '\\0' } ; <S2SV_StartBug> if ( NULL == path ) { <S2SV_EndBug> return PMIX_SUCCESS ; } path_to_use = strdup ( path ) ; dir = strtok_r ( path_to_use , sep , & ctx ) ; do { if ( ( 0 == strcmp ( dir , "USER_DEFAULT" ) || 0 == strcmp ( dir , "USR_DEFAULT" ) ) && NULL != pmix_mca_base_user_default_path ) { dir = pmix_mca_base_user_default_path ; } else if ( 0 == strcmp ( dir , "SYS_DEFAULT" ) || 0 == strcmp ( dir , "SYSTEM_DEFAULT" ) ) { dir = pmix_mca_base_system_default_path ; } <S2SV_StartBug> if ( 0 != pmix_pdl_foreachfile ( dir , process_repository_item , NULL ) ) { <S2SV_EndBug> break ; } } while ( NULL != ( dir = strtok_r ( NULL , sep , & ctx ) ) ) ; free ( path_to_use ) ; # endif return PMIX_SUCCESS ; } | <S2SV_ModStart> '\\0' } ; int rc ; <S2SV_ModStart> pmix_mca_base_system_default_path ; } rc = <S2SV_ModEnd> pmix_pdl_foreachfile ( dir <S2SV_ModStart> , NULL ) ; if ( PMIX_ERR_SILENT == rc ) { free ( path_to_use ) ; return rc ; } else <S2SV_ModEnd> { break ; |
6,012 | CWE-000 int devinfo_init ( void ) { struct u_businfo ubus ; size_t ub_size ; int error , retries ; if ( ! devinfo_initted ) { TAILQ_INIT ( & devinfo_dev ) ; TAILQ_INIT ( & devinfo_rman ) ; TAILQ_INIT ( & devinfo_res ) ; } for ( retries = 0 ; retries < 10 ; retries ++ ) { debug ( "get<S2SV_blank>interface<S2SV_blank>version" ) ; ub_size = sizeof ( ubus ) ; if ( sysctlbyname ( "hw.bus.info" , & ubus , & ub_size , NULL , 0 ) != 0 ) { warn ( "sysctlbyname(\\"hw.bus.info\\",<S2SV_blank>...)<S2SV_blank>failed" ) ; return ( EINVAL ) ; } if ( ( ub_size != sizeof ( ubus ) ) || ( ubus . ub_version != BUS_USER_VERSION ) ) { <S2SV_StartBug> warn ( "kernel<S2SV_blank>bus<S2SV_blank>interface<S2SV_blank>version<S2SV_blank>mismatch" ) ; <S2SV_EndBug> return ( EINVAL ) ; } debug ( "generation<S2SV_blank>count<S2SV_blank>is<S2SV_blank>%d" , ubus . ub_generation ) ; if ( ubus . ub_generation == devinfo_generation ) return ( 0 ) ; devinfo_free ( ) ; devinfo_initted = 0 ; devinfo_generation = 0 ; if ( ( error = devinfo_init_devices ( ubus . ub_generation ) ) != 0 ) { devinfo_free ( ) ; if ( error == EINVAL ) continue ; break ; } if ( ( error = devinfo_init_resources ( ubus . ub_generation ) ) != 0 ) { devinfo_free ( ) ; if ( error == EINVAL ) continue ; break ; } devinfo_initted = 1 ; devinfo_generation = ubus . ub_generation ; return ( 0 ) ; } debug ( "scan<S2SV_blank>failed<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>retries" , retries ) ; errno = error ; return ( 1 ) ; } | <S2SV_ModStart> ) ) { warnx ( "kernel<S2SV_blank>bus<S2SV_blank>interface<S2SV_blank>version<S2SV_blank>mismatch:<S2SV_blank>kernel<S2SV_blank>%d<S2SV_blank>expected<S2SV_blank>%d" , ubus . ub_version , BUS_USER_VERSION <S2SV_ModEnd> ) ; return |
6,013 | CWE-000 static void drm_dp_add_port ( struct drm_dp_mst_branch * mstb , struct device * dev , struct drm_dp_link_addr_reply_port * port_msg ) { struct drm_dp_mst_port * port ; bool ret ; bool created = false ; int old_pdt = 0 ; int old_ddps = 0 ; port = drm_dp_get_port ( mstb , port_msg -> port_number ) ; if ( ! port ) { port = kzalloc ( sizeof ( * port ) , GFP_KERNEL ) ; if ( ! port ) return ; kref_init ( & port -> kref ) ; port -> parent = mstb ; port -> port_num = port_msg -> port_number ; port -> mgr = mstb -> mgr ; port -> aux . name = "DPMST" ; port -> aux . dev = dev ; created = true ; } else { old_pdt = port -> pdt ; old_ddps = port -> ddps ; } port -> pdt = port_msg -> peer_device_type ; port -> input = port_msg -> input_port ; port -> mcs = port_msg -> mcs ; port -> ddps = port_msg -> ddps ; port -> ldps = port_msg -> legacy_device_plug_status ; port -> dpcd_rev = port_msg -> dpcd_revision ; port -> num_sdp_streams = port_msg -> num_sdp_streams ; port -> num_sdp_stream_sinks = port_msg -> num_sdp_stream_sinks ; memcpy ( port -> guid , port_msg -> peer_guid , 16 ) ; if ( created ) { mutex_lock ( & mstb -> mgr -> lock ) ; kref_get ( & port -> kref ) ; list_add ( & port -> next , & mstb -> ports ) ; mutex_unlock ( & mstb -> mgr -> lock ) ; } if ( old_ddps != port -> ddps ) { if ( port -> ddps ) { drm_dp_check_port_guid ( mstb , port ) ; if ( ! port -> input ) drm_dp_send_enum_path_resources ( mstb -> mgr , mstb , port ) ; } else { port -> guid_valid = false ; port -> available_pbn = 0 ; } } if ( old_pdt != port -> pdt && ! port -> input ) { drm_dp_port_teardown_pdt ( port , old_pdt ) ; ret = drm_dp_port_setup_pdt ( port ) ; if ( ret == true ) { drm_dp_send_link_address ( mstb -> mgr , port -> mstb ) ; port -> mstb -> link_address_sent = true ; } } if ( created && ! port -> input ) { char proppath [ 255 ] ; <S2SV_StartBug> build_mst_prop_path ( port , mstb , proppath ) ; <S2SV_EndBug> port -> connector = ( * mstb -> mgr -> cbs -> add_connector ) ( mstb -> mgr , port , proppath ) ; } drm_dp_put_port ( port ) ; } | <S2SV_ModStart> mstb , proppath , sizeof ( proppath ) |
6,014 | CWE-000 char * url_to_string ( const url_t * url ) { if ( ! url ) { debugf ( DBG_WARN , "%s\\n" , "url<S2SV_blank>was<S2SV_blank>NULL" ) ; return NULL ; } <S2SV_StartBug> char * tmp = NULL ; <S2SV_EndBug> <S2SV_StartBug> buffer_t * buffer = buffer_create ( ) ; <S2SV_EndBug> const char * const * parts = ( const char * const * ) url ; const size_t difference = URL_T_PARTS_COUNT - URL_T_PARTS_EXCLUDE ; size_t i = 0 ; <S2SV_StartBug> for ( i = 0 ; i < difference ; ++ i ) <S2SV_EndBug> { <S2SV_StartBug> tmp = NULL ; <S2SV_EndBug> if ( buffer_append_str ( buffer , parts [ i ] ) == FAILURE ) { buffer_destroy ( & buffer ) ; return NULL ; } switch ( i ) { case INDEX_PROTO : tmp = POSTFIX_PROTO ; break ; case INDEX_HOST : tmp = POSTFIX_HOST ; break ; case INDEX_PATH : if ( strlen ( parts [ INDEX_QUERY ] ) ) { tmp = POSTFIX_PATH ; } break ; <S2SV_StartBug> } <S2SV_EndBug> if ( tmp && buffer_append_str ( buffer , tmp ) == FAILURE ) { buffer_destroy ( & buffer ) ; return NULL ; } } tmp = buffer_to_str ( buffer ) ; buffer_destroy ( & buffer ) ; return tmp ; } | <S2SV_ModStart> char * tmp <S2SV_ModEnd> ; buffer_t * <S2SV_ModStart> buffer_t * buffer <S2SV_ModEnd> ; const char <S2SV_ModStart> = 0 ; if ( ( buffer = buffer_create ( ) ) == NULL ) { debugf ( DBG_CRIT , "%s\\n" , "buffer<S2SV_blank>was<S2SV_blank>not<S2SV_blank>created" ) ; return NULL ; } <S2SV_ModStart> i ) { <S2SV_ModEnd> if ( buffer_append_str <S2SV_ModStart> } break ; default : tmp = NULL ; |
6,015 | CWE-000 LOCAL sysinit ( ) { static long currsp ; int i , j ; struct pentry * pptr ; struct sentry * sptr ; struct mblock * mptr ; SYSCALL pfintr ( ) ; numproc = 0 ; nextproc = NPROC - 1 ; nextsem = NSEM - 1 ; nextqueue = NPROC ; if ( maxaddr + 1 > HOLESTART ) { memlist . mnext = mptr = ( struct mblock * ) roundmb ( & end ) ; mptr -> mnext = ( struct mblock * ) HOLEEND ; mptr -> mlen = ( int ) truncew ( ( ( unsigned ) HOLESTART - ( unsigned ) & end ) ) ; mptr -> mlen -= 4 ; mptr = ( struct mblock * ) HOLEEND ; mptr -> mnext = 0 ; mptr -> mlen = ( int ) truncew ( ( unsigned ) maxaddr - HOLEEND - NULLSTK ) ; } else { memlist . mnext = mptr = ( struct mblock * ) roundmb ( & end ) ; mptr -> mnext = 0 ; mptr -> mlen = ( int ) truncew ( ( unsigned ) maxaddr - ( int ) & end - NULLSTK ) ; } for ( i = 0 ; i < NPROC ; i ++ ) proctab [ i ] . pstate = PRFREE ; # ifdef MEMMARK _mkinit ( ) ; # endif # ifdef RTCLOCK clkinit ( ) ; # endif mon_init ( ) ; # ifdef NDEVS for ( i = 0 ; i < NDEVS ; i ++ ) { init_dev ( i ) ; } # endif pptr = & proctab [ NULLPROC ] ; pd_t pdentry ; init_bsm ( ) ; init_frame ( ) ; create_global_page_tables ( ) ; <S2SV_StartBug> set_evec ( 14 , pfintr ) ; <S2SV_EndBug> <S2SV_StartBug> enable_paging ( ) ; <S2SV_EndBug> pdentry = new_page_dir ( NULLPROC ) ; if ( pdentry == SYSERR ) { return SYSERR } ; write_cr3 ( pptr -> pdbr ) ; pptr -> pstate = PRCURR ; for ( j = 0 ; j < 7 ; j ++ ) pptr -> pname [ j ] = "prnull" [ j ] ; pptr -> plimit = ( WORD ) ( maxaddr + 1 ) - NULLSTK ; pptr -> pbase = ( WORD ) maxaddr - 3 ; pptr -> pesp = pptr -> pbase - 4 ; * ( ( int * ) pptr -> pbase ) = MAGIC ; pptr -> paddr = ( WORD ) nulluser ; pptr -> pargs = 0 ; pptr -> pprio = 0 ; currpid = NULLPROC ; for ( i = 0 ; i < NSEM ; i ++ ) { ( sptr = & semaph [ i ] ) -> sstate = SFREE ; sptr -> sqtail = 1 + ( sptr -> sqhead = newqueue ( ) ) ; } rdytail = 1 + ( rdyhead = newqueue ( ) ) ; return ( OK ) ; } | <S2SV_ModStart> ( ) ; pdentry = new_page_dir ( NULLPROC ) ; if ( pdentry == SYSERR ) { return SYSERR ; } write_cr3 ( pptr -> pdbr ) ; <S2SV_ModStart> ; enable_paging ( <S2SV_ModEnd> ) ; pptr |
6,016 | CWE-000 static int create_trace_kprobe ( int argc , char * * argv ) { struct trace_kprobe * tk ; int i , ret = 0 ; bool is_return = false , is_delete = false ; char * symbol = NULL , * event = NULL , * group = NULL ; int maxactive = 0 ; char * arg ; <S2SV_StartBug> unsigned long offset = 0 ; <S2SV_EndBug> void * addr = NULL ; char buf [ MAX_EVENT_NAME_LEN ] ; if ( argv [ 0 ] [ 0 ] == 'p' ) is_return = false ; else if ( argv [ 0 ] [ 0 ] == 'r' ) is_return = true ; else if ( argv [ 0 ] [ 0 ] == '-' ) is_delete = true ; else { pr_info ( "Probe<S2SV_blank>definition<S2SV_blank>must<S2SV_blank>be<S2SV_blank>started<S2SV_blank>with<S2SV_blank>\'p\',<S2SV_blank>\'r\'<S2SV_blank>or" "<S2SV_blank>\'-\'.\\n" ) ; return - EINVAL ; } event = strchr ( & argv [ 0 ] [ 1 ] , ':' ) ; if ( event ) { event [ 0 ] = '\\0' ; event ++ ; } if ( is_return && isdigit ( argv [ 0 ] [ 1 ] ) ) { ret = kstrtouint ( & argv [ 0 ] [ 1 ] , 0 , & maxactive ) ; if ( ret ) { pr_info ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>maxactive.\\n" ) ; return ret ; } if ( maxactive > KRETPROBE_MAXACTIVE_MAX ) { pr_info ( "Maxactive<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big<S2SV_blank>(%d<S2SV_blank>><S2SV_blank>%d).\\n" , maxactive , KRETPROBE_MAXACTIVE_MAX ) ; return - E2BIG ; } } if ( event ) { if ( strchr ( event , '/' ) ) { group = event ; event = strchr ( group , '/' ) + 1 ; event [ - 1 ] = '\\0' ; if ( strlen ( group ) == 0 ) { pr_info ( "Group<S2SV_blank>name<S2SV_blank>is<S2SV_blank>not<S2SV_blank>specified\\n" ) ; return - EINVAL ; } } if ( strlen ( event ) == 0 ) { pr_info ( "Event<S2SV_blank>name<S2SV_blank>is<S2SV_blank>not<S2SV_blank>specified\\n" ) ; return - EINVAL ; } } if ( ! group ) group = KPROBE_EVENT_SYSTEM ; if ( is_delete ) { if ( ! event ) { pr_info ( "Delete<S2SV_blank>command<S2SV_blank>needs<S2SV_blank>an<S2SV_blank>event<S2SV_blank>name.\\n" ) ; return - EINVAL ; } mutex_lock ( & probe_lock ) ; tk = find_trace_kprobe ( event , group ) ; if ( ! tk ) { mutex_unlock ( & probe_lock ) ; pr_info ( "Event<S2SV_blank>%s/%s<S2SV_blank>doesn\'t<S2SV_blank>exist.\\n" , group , event ) ; return - ENOENT ; } ret = unregister_trace_kprobe ( tk ) ; if ( ret == 0 ) free_trace_kprobe ( tk ) ; mutex_unlock ( & probe_lock ) ; return ret ; } if ( argc < 2 ) { pr_info ( "Probe<S2SV_blank>point<S2SV_blank>is<S2SV_blank>not<S2SV_blank>specified.\\n" ) ; return - EINVAL ; } if ( kstrtoul ( argv [ 1 ] , 0 , ( unsigned long * ) & addr ) ) { symbol = argv [ 1 ] ; ret = traceprobe_split_symbol_offset ( symbol , & offset ) ; <S2SV_StartBug> if ( ret ) { <S2SV_EndBug> pr_info ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>either<S2SV_blank>an<S2SV_blank>address<S2SV_blank>or<S2SV_blank>a<S2SV_blank>symbol.\\n" ) ; return ret ; } if ( offset && is_return && ! kprobe_on_func_entry ( NULL , symbol , offset ) ) { pr_info ( "Given<S2SV_blank>offset<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>for<S2SV_blank>return<S2SV_blank>probe.\\n" ) ; return - EINVAL ; } } argc -= 2 ; argv += 2 ; if ( ! event ) { if ( symbol ) snprintf ( buf , MAX_EVENT_NAME_LEN , "%c_%s_%ld" , is_return ? 'r' : 'p' , symbol , offset ) ; else snprintf ( buf , MAX_EVENT_NAME_LEN , "%c_0x%p" , is_return ? 'r' : 'p' , addr ) ; sanitize_event_name ( buf ) ; event = buf ; } tk = alloc_trace_kprobe ( group , event , addr , symbol , offset , maxactive , argc , is_return ) ; if ( IS_ERR ( tk ) ) { pr_info ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>trace_probe.(%d)\\n" , ( int ) PTR_ERR ( tk ) ) ; return PTR_ERR ( tk ) ; } ret = 0 ; for ( i = 0 ; i < argc && i < MAX_TRACE_ARGS ; i ++ ) { struct probe_arg * parg = & tk -> tp . args [ i ] ; tk -> tp . nr_args ++ ; arg = strchr ( argv [ i ] , '=' ) ; if ( arg ) { * arg ++ = '\\0' ; parg -> name = kstrdup ( argv [ i ] , GFP_KERNEL ) ; } else { arg = argv [ i ] ; snprintf ( buf , MAX_EVENT_NAME_LEN , "arg%d" , i + 1 ) ; parg -> name = kstrdup ( buf , GFP_KERNEL ) ; } if ( ! parg -> name ) { pr_info ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>argument[%d]<S2SV_blank>name.\\n" , i ) ; ret = - ENOMEM ; goto error ; } if ( ! is_good_name ( parg -> name ) ) { pr_info ( "Invalid<S2SV_blank>argument[%d]<S2SV_blank>name:<S2SV_blank>%s\\n" , i , parg -> name ) ; ret = - EINVAL ; goto error ; } if ( traceprobe_conflict_field_name ( parg -> name , tk -> tp . args , i ) ) { pr_info ( "Argument[%d]<S2SV_blank>name<S2SV_blank>\'%s\'<S2SV_blank>conflicts<S2SV_blank>with<S2SV_blank>" "another<S2SV_blank>field.\\n" , i , argv [ i ] ) ; ret = - EINVAL ; goto error ; } ret = traceprobe_parse_probe_arg ( arg , & tk -> tp . size , parg , is_return , true , kprobes_fetch_type_table ) ; if ( ret ) { pr_info ( "Parse<S2SV_blank>error<S2SV_blank>at<S2SV_blank>argument[%d].<S2SV_blank>(%d)\\n" , i , ret ) ; goto error ; } } ret = register_trace_kprobe ( tk ) ; if ( ret ) goto error ; return 0 ; error : free_trace_kprobe ( tk ) ; return ret ; } | <S2SV_ModStart> * arg ; <S2SV_ModEnd> long offset = <S2SV_ModStart> if ( ret || offset < 0 || offset > UINT_MAX |
6,017 | CWE-000 bool queue_full ( queue_t * q ) { <S2SV_StartBug> return q -> indexIn + 1 == q -> indexOut ; <S2SV_EndBug> } | <S2SV_ModStart> q ) { queue_index_t temp = <S2SV_ModEnd> q -> indexIn <S2SV_ModStart> indexIn + 1 ; if ( temp >= q -> size ) { temp = 0 ; } return ( temp <S2SV_ModStart> q -> indexOut ) |
6,018 | CWE-000 struct netdev * netdev_hmap_port_get ( odp_port_t port_no , const void * obj ) { <S2SV_StartBug> size_t hash = hash_int ( odp_to_u32 ( port_no ) , hash_pointer ( obj , 0 ) ) ; <S2SV_EndBug> struct port_to_netdev_data * data ; struct netdev * ret = NULL ; ovs_mutex_lock ( & netdev_hmap_mutex ) ; <S2SV_StartBug> HMAP_FOR_EACH_WITH_HASH ( data , node , hash , & port_to_netdev ) { <S2SV_EndBug> <S2SV_StartBug> if ( data -> obj == obj && data -> dpif_port . port_no == port_no ) { <S2SV_EndBug> ret = netdev_ref ( data -> netdev ) ; <S2SV_StartBug> break ; <S2SV_EndBug> } } ovs_mutex_unlock ( & netdev_hmap_mutex ) ; return ret ; } | <S2SV_ModStart> obj ) { <S2SV_ModEnd> struct port_to_netdev_data * <S2SV_ModStart> netdev_hmap_mutex ) ; data = netdev_hmap_port_lookup ( port_no , obj ) ; <S2SV_ModEnd> if ( data <S2SV_ModStart> if ( data <S2SV_ModEnd> ) { ret <S2SV_ModStart> netdev ) ; <S2SV_ModEnd> } ovs_mutex_unlock ( |
6,019 | CWE-000 static void drawShotHandler ( void * tData ) { int_map_map ( & gData . mActiveShots , drawShot , NULL ) ; <S2SV_StartBug> setDrawingParametersToIdentity ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,020 | CWE-000 void processor_startup ( uint32_t lapic_id , physical_addr exec_base ) { lapic_send_ipi ( get_gst ( ) -> lapic_base , lapic_id , 0 , LAPIC_DELIVERY_INIT , LAPIC_DESTINATION_PHYSICAL , LAPIC_DESTINATION_TARGET ) ; lapic_sleep ( 100 ) ; lapic_send_ipi ( get_gst ( ) -> lapic_base , lapic_id , exec_base >> 12 , LAPIC_DELIVERY_SIPI , 0 , 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 0 ) ; lapic_sleep ( 1 ) ; |
6,021 | CWE-000 static int do_verify ( int argc , char * * argv ) { const id2str_t typeNames [ ] = { { SC_AC_CHV , "CHV" } , { SC_AC_AUT , "KEY" } , { SC_AC_AUT , "AUT" } , { SC_AC_PRO , "PRO" } , { SC_AC_NONE , NULL , } } ; int r , tries_left = - 1 ; u8 buf [ 64 ] ; size_t buflen = sizeof ( buf ) , i ; struct sc_pin_cmd_data data ; int prefix_len = 0 ; if ( argc < 1 || argc > 2 ) return usage ( do_verify ) ; memset ( & data , 0 , sizeof ( data ) ) ; data . cmd = SC_PIN_CMD_VERIFY ; data . pin_type = SC_AC_NONE ; for ( i = 0 ; typeNames [ i ] . str ; i ++ ) { prefix_len = strlen ( typeNames [ i ] . str ) ; if ( strncasecmp ( argv [ 0 ] , typeNames [ i ] . str , prefix_len ) == 0 ) { data . pin_type = typeNames [ i ] . id ; break ; } } if ( data . pin_type == SC_AC_NONE ) { printf ( "Invalid<S2SV_blank>type.\\n" ) ; return usage ( do_verify ) ; } if ( sscanf ( argv [ 0 ] + prefix_len , "%d" , & data . pin_reference ) != 1 ) { printf ( "Invalid<S2SV_blank>key<S2SV_blank>reference.\\n" ) ; return usage ( do_verify ) ; } if ( argc < 2 ) { if ( card -> reader -> capabilities & SC_READER_CAP_PIN_PAD ) { printf ( "Please<S2SV_blank>enter<S2SV_blank>PIN<S2SV_blank>on<S2SV_blank>the<S2SV_blank>reader\'s<S2SV_blank>pin<S2SV_blank>pad.\\n" ) ; data . pin1 . prompt = "Please<S2SV_blank>enter<S2SV_blank>PIN" ; data . flags |= SC_PIN_CMD_USE_PINPAD ; } else { char * pin = NULL ; size_t len = 0 ; printf ( "Please<S2SV_blank>enter<S2SV_blank>PIN:<S2SV_blank>" ) ; r = util_getpass ( & pin , & len , stdin ) ; if ( r < 0 ) { <S2SV_StartBug> printf ( "No<S2SV_blank>PIN<S2SV_blank>entered<S2SV_blank>-<S2SV_blank>aborting<S2SV_blank>VERIFY.\\n" ) ; <S2SV_EndBug> return - 1 ; } if ( strlcpy ( ( char * ) buf , pin , sizeof ( buf ) ) >= sizeof ( buf ) ) { free ( pin ) ; printf ( "PIN<S2SV_blank>too<S2SV_blank>long<S2SV_blank>-<S2SV_blank>aborting<S2SV_blank>VERIFY.\\n" ) ; return - 1 ; } free ( pin ) ; data . pin1 . data = buf ; data . pin1 . len = strlen ( ( char * ) buf ) ; } } else { r = parse_string_or_hexdata ( argv [ 1 ] , buf , & buflen ) ; if ( 0 != r ) { printf ( "Invalid<S2SV_blank>key<S2SV_blank>value.\\n" ) ; return usage ( do_verify ) ; } data . pin1 . data = buf ; data . pin1 . len = buflen ; } r = sc_pin_cmd ( card , & data , & tries_left ) ; if ( r ) { if ( r == SC_ERROR_PIN_CODE_INCORRECT ) { if ( tries_left >= 0 ) printf ( "Incorrect<S2SV_blank>code,<S2SV_blank>%d<S2SV_blank>tries<S2SV_blank>left.\\n" , tries_left ) ; else printf ( "Incorrect<S2SV_blank>code.\\n" ) ; } else printf ( "Unable<S2SV_blank>to<S2SV_blank>verify<S2SV_blank>PIN<S2SV_blank>code:<S2SV_blank>%s\\n" , sc_strerror ( r ) ) ; return - 1 ; } printf ( "Code<S2SV_blank>correct.\\n" ) ; return 0 ; } | <S2SV_ModStart> { printf ( "util_getpass<S2SV_blank>error.\\n" <S2SV_ModEnd> ) ; return |
6,022 | CWE-000 void xfwrite_bcount_str ( str_t * str , FILE * stream ) { size_t len = str_len ( str ) ; if ( len > 255 ) <S2SV_StartBug> die ( "string<S2SV_blank>\'%s\'<S2SV_blank>too<S2SV_blank>long<S2SV_blank>for<S2SV_blank>byte<S2SV_blank>counted<S2SV_blank>string\\n" , str_data ( str ) ) ; <S2SV_EndBug> xfwrite_byte ( len & 0xFF , stream ) ; xfwrite_str ( str , stream ) ; } | <S2SV_ModStart> ) die ( "string<S2SV_blank>\'%.40s...\'<S2SV_blank>too<S2SV_blank>long<S2SV_blank>for<S2SV_blank>byte<S2SV_blank>counted<S2SV_blank>string\\n" <S2SV_ModEnd> , str_data ( |
6,023 | CWE-000 void * peekQueue ( Queue * queue , int queue_location ) { if ( queue -> front != NULL ) { if ( queue_location == QUEUE_FRONT ) { return queue -> front -> data ; } <S2SV_StartBug> if ( queue_location == QUEUE_BACK ) <S2SV_EndBug> { return queue -> back -> data ; } <S2SV_StartBug> } <S2SV_EndBug> else { return NULL ; } } | <S2SV_ModStart> data ; } else <S2SV_ModStart> data ; } else { return NULL ; } |
6,024 | CWE-000 int uldaq_parse ( struct node * n , json_t * cfg ) { int ret ; struct uldaq * u = ( struct uldaq * ) n -> _vd ; const char * range = NULL ; size_t i ; json_t * json_signals ; json_t * json_signal ; json_error_t err ; <S2SV_StartBug> ret = json_unpack_ex ( cfg , & err , 0 , "{<S2SV_blank>s:<S2SV_blank>{<S2SV_blank>s:<S2SV_blank>o,<S2SV_blank>s:<S2SV_blank>d<S2SV_blank>}<S2SV_blank>}" , <S2SV_EndBug> "in" , "signals" , & json_signals , "sample_rate" , & u -> in . sample_rate , "range" , & range ) ; if ( ret ) jerror ( & err , "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>configuration<S2SV_blank>of<S2SV_blank>node<S2SV_blank>%s" , node_name ( n ) ) ; u -> in . queues = realloc ( u -> in . queues , sizeof ( struct AiQueueElement ) * list_length ( & n -> signals ) ) ; json_array_foreach ( json_signals , i , json_signal ) { } return ret ; } | <S2SV_ModStart> , 0 , "{<S2SV_blank>s:<S2SV_blank>{<S2SV_blank>s:<S2SV_blank>o,<S2SV_blank>s:<S2SV_blank>F<S2SV_blank>}<S2SV_blank>}" <S2SV_ModEnd> , "in" , |
6,025 | CWE-000 void phydat_dump ( phydat_t * data , uint8_t dim ) { if ( data == NULL || dim > PHYDAT_DIM ) { puts ( "Unable<S2SV_blank>to<S2SV_blank>display<S2SV_blank>data<S2SV_blank>object" ) ; return ; } printf ( "Data:" ) ; for ( uint8_t i = 0 ; i < dim ; i ++ ) { char scale_str = phydat_scale_to_str ( data -> scale ) ; printf ( "\\t[%i]<S2SV_blank>" , ( int ) i ) ; if ( scale_str ) { printf ( "%i%c" , ( int ) data -> val [ i ] , scale_str ) ; } else if ( data -> scale == 0 ) { printf ( "%i" , ( int ) data -> val [ i ] ) ; } else if ( ( data -> scale > - 5 ) && ( data -> scale < 0 ) ) { char num [ 8 ] ; <S2SV_StartBug> size_t len = fmt_s16_dfp ( num , data -> val [ i ] , data -> scale * - 1 ) ; <S2SV_EndBug> num [ len ] = '\\0' ; printf ( "%s" , num ) ; } else { printf ( "%iE%i" , ( int ) data -> val [ i ] , ( int ) data -> scale ) ; } printf ( "%s\\n" , phydat_unit_to_str ( data -> unit ) ) ; } } | <S2SV_ModStart> data -> scale <S2SV_ModEnd> ) ; num |
6,026 | CWE-000 int assemble ( compiler_t * compiler , object_t * object ) { ir_module_t * module = & object -> ir_module ; ast_t * ast = & object -> ast ; ir_pool_init ( & module -> pool ) ; module -> funcs = malloc ( sizeof ( ir_func_t ) * ast -> funcs_length ) ; module -> funcs_length = 0 ; module -> type_map . mappings = NULL ; <S2SV_StartBug> module -> common . ir_funcptr_type = NULL ; <S2SV_EndBug> object -> compilation_stage = COMPILATION_STAGE_IR_MODULE ; <S2SV_StartBug> if ( assemble_type_mappings ( compiler , object ) ) return 1 ; <S2SV_EndBug> if ( assemble_functions ( compiler , object ) ) return 1 ; if ( assemble_functions_body ( compiler , object ) ) return 1 ; return 0 ; } | <S2SV_ModStart> ; module -> globals = malloc ( sizeof ( ir_global_t ) * ast -> globals_length ) ; module -> globals_length = 0 ; module -> <S2SV_ModStart> if ( assemble_type_mappings ( compiler , object ) ) return 1 ; if ( assemble_globals |
6,027 | CWE-000 void twi_write ( twi_t * twi , uint8_t slave_address , uint8_t * write_data , uint8_t nb_bytes_to_write ) { # ifdef TWI_INT_MODE twi_i = 0 ; twi_nb_bytes_to_write = nb_bytes_to_write ; twi_write_data = write_data ; # endif twi -> MASTER . ADDR = slave_address << 1 ; <S2SV_StartBug> while ( ! ( twi -> MASTER . STATUS & TWI_MASTER_WIF_bm ) ) <S2SV_EndBug> ; twi -> MASTER . STATUS |= TWI_MASTER_WIF_bm ; for ( uint8_t i = 0 ; i < nb_bytes_to_write ; i ++ ) { twi -> MASTER . DATA = write_data [ i ] ; <S2SV_StartBug> while ( ! ( twi -> MASTER . STATUS & TWI_MASTER_WIF_bm ) ) <S2SV_EndBug> ; twi -> MASTER . STATUS |= TWI_MASTER_WIF_bm ; } twi -> MASTER . CTRLC = TWI_MASTER_CMD_STOP_gc ; } | <S2SV_ModStart> << 1 ; if ( twi_wait_wif ( twi ) ) return <S2SV_ModEnd> ; twi -> <S2SV_ModStart> i ] ; if ( twi_wait_wif ( twi ) ) return <S2SV_ModEnd> ; twi -> |
6,028 | CWE-000 int key_store ( key_t * key ) { <S2SV_StartBug> FILE * fp = NULL ; <S2SV_EndBug> if ( key -> fn ) { fp = fopen ( key -> fn , "w" ) ; if ( fp ) { PEM_write_PrivateKey ( fp , key -> key , NULL , NULL , 0 , NULL , NULL ) ; fclose ( fp ) ; return 1 ; } else { ERROR ( "Cannot<S2SV_blank>create<S2SV_blank>file<S2SV_blank>%s\\n" , key -> fn ) ; } } else { ERROR ( "Key<S2SV_blank>filename<S2SV_blank>not<S2SV_blank>specified\\n" ) ; } return 0 ; } | <S2SV_ModStart> FILE * fp <S2SV_ModEnd> ; if ( |
6,029 | CWE-000 void printCalculations ( int * respTime , int * waitTime ) { printf ( "Calculations:\\n\\n" ) ; <S2SV_StartBug> printf ( "\\t#\\tResponse<S2SV_blank>Time\\tWait<S2SV_blank>Time\\n" ) ; <S2SV_EndBug> printf ( "\\t1\\t%d\\t\\t%d\\n" , respTime [ 0 ] , waitTime [ 0 ] ) ; printf ( "\\t2\\t%d\\t\\t%d\\n" , respTime [ 1 ] , waitTime [ 1 ] ) ; printf ( "\\t3\\t%d\\t\\t%d\\n" , respTime [ 2 ] , waitTime [ 2 ] ) ; printf ( "\\t4\\t%d\\t\\t%d\\n" , respTime [ 3 ] , waitTime [ 3 ] ) ; printf ( "\\t5\\t%d\\t\\t%d\\n" , respTime [ 4 ] , waitTime [ 4 ] ) ; printf ( "-----------------------------------------\\n" ) ; int totalRespTime = ( respTime [ 0 ] + respTime [ 1 ] + respTime [ 2 ] + respTime [ 3 ] + respTime [ 4 ] ) ; int totalWaitTime = ( waitTime [ 0 ] + waitTime [ 1 ] + waitTime [ 2 ] + waitTime [ 3 ] + waitTime [ 4 ] ) ; <S2SV_StartBug> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank>Totals\\t%d\\t\\t%d\\n" , totalRespTime , totalWaitTime ) ; <S2SV_EndBug> printf ( "-----------------------------------------\\n" ) ; float avgRespTime = totalRespTime / 5.0 ; float avgWaitTime = totalWaitTime / 5.0 ; <S2SV_StartBug> printf ( "<S2SV_blank>Averages\\t%.2f\\t\\t%.2f\\n\\n" , avgRespTime , avgWaitTime ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; printf ( "\\t#\\tRESPONSE<S2SV_blank>TIME\\tWAIT<S2SV_blank>TIME\\n" <S2SV_ModEnd> ) ; printf <S2SV_ModStart> ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank>TOTALS\\t%d\\t\\t%d\\n" <S2SV_ModEnd> , totalRespTime , <S2SV_ModStart> ; printf ( "<S2SV_blank>AVERAGES\\t%.2f\\t\\t%.2f\\n\\n" <S2SV_ModEnd> , avgRespTime , |
6,030 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 4 ) { <S2SV_StartBug> fprintf ( stderr , "Usage:<S2SV_blank>./resize<S2SV_blank><multiplier><S2SV_blank><infile><S2SV_blank><outfile>\\n" ) ; <S2SV_EndBug> return 1 ; } if ( ( argv [ 1 ] < 1 ) || ( argv [ 1 ] > 101 ) ) { fprintf ( stderr , "Multiplier<S2SV_blank>must<S2SV_blank>be<S2SV_blank>between<S2SV_blank>1<S2SV_blank>and<S2SV_blank>100" ) ; return 1 ; } int multiplier = atoi ( argv [ 1 ] ) ; char * infile = argv [ 2 ] ; char * outfile = argv [ 3 ] ; <S2SV_StartBug> FILE * inptr = fopen ( infile , "r" ) ; <S2SV_EndBug> if ( inptr == NULL ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>%s.\\n" , infile ) ; <S2SV_StartBug> return 2 ; <S2SV_EndBug> } FILE * outptr = fopen ( outfile , "w" ) ; if ( outptr == NULL ) { fclose ( inptr ) ; fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>%s.\\n" , outfile ) ; <S2SV_StartBug> return 3 ; <S2SV_EndBug> } BITMAPFILEHEADER bf ; fread ( & bf , sizeof ( BITMAPFILEHEADER ) , 1 , inptr ) ; BITMAPINFOHEADER bi ; fread ( & bi , sizeof ( BITMAPINFOHEADER ) , 1 , inptr ) ; if ( bf . bfType != 0x4d42 || bf . bfOffBits != 54 || bi . biSize != 40 || bi . biBitCount != 24 || bi . biCompression != 0 ) { fclose ( outptr ) ; fclose ( inptr ) ; fprintf ( stderr , "Unsupported<S2SV_blank>file<S2SV_blank>format.\\n" ) ; <S2SV_StartBug> return 4 ; <S2SV_EndBug> } BITMAPFILEHEADER outbf ; outbf = bf ; BITMAPINFOHEADER outbi ; outbi = bi ; outbi . biHeight *= multiplier ; outbi . biWidth *= multiplier ; printf ( "%" PRId32 "\\n" , bi . biWidth ) ; printf ( "%" PRId32 "\\n" , outbi . biWidth ) ; int padding = ( 4 - ( bi . biWidth * sizeof ( RGBTRIPLE ) ) % 4 ) % 4 ; int outPadding = ( 4 - ( outbi . biWidth * sizeof ( RGBTRIPLE ) ) % 4 ) % 4 ; printf ( "%i\\n" , outPadding ) ; outbi . biSizeImage = ( ( sizeof ( RGBTRIPLE ) * outbi . biWidth ) + outPadding ) * abs ( outbi . biHeight ) ; outbf . bfSize = outbi . biSizeImage + sizeof ( BITMAPFILEHEADER ) + sizeof ( BITMAPINFOHEADER ) ; fwrite ( & outbf , sizeof ( BITMAPFILEHEADER ) , 1 , outptr ) ; fwrite ( & outbi , sizeof ( BITMAPINFOHEADER ) , 1 , outptr ) ; for ( int i = 0 , biHeight = abs ( bi . biHeight ) ; i < biHeight ; i ++ ) { for ( int j = 0 ; j < multiplier ; j ++ ) { long loopStart = ftell ( inptr ) ; for ( int k = 0 ; k < bi . biWidth ; k ++ ) { RGBTRIPLE triple ; fread ( & triple , sizeof ( RGBTRIPLE ) , 1 , inptr ) ; for ( int l = 0 ; l < multiplier ; l ++ ) { fwrite ( & triple , sizeof ( RGBTRIPLE ) , 1 , outptr ) ; } } for ( int m = 0 ; m < outPadding ; m ++ ) { fputc ( 0x00 , outptr ) ; } if ( j < multiplier - 1 ) { fseek ( inptr , loopStart , SEEK_SET ) ; } else { fseek ( inptr , padding , SEEK_CUR ) ; } } } fclose ( inptr ) ; fclose ( outptr ) ; return 0 ; } | <S2SV_ModStart> stderr , "Usage:<S2SV_blank>./resize<S2SV_blank><multiplier><S2SV_blank><infile><S2SV_blank><outfile>\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> 3 ] ; if ( ( multiplier < 1 ) || ( multiplier > 101 ) ) { fprintf ( stderr , "Multiplier<S2SV_blank>must<S2SV_blank>be<S2SV_blank>between<S2SV_blank>1<S2SV_blank>and<S2SV_blank>100" ) ; return 2 ; } <S2SV_ModStart> ) ; return 3 <S2SV_ModEnd> ; } FILE <S2SV_ModStart> ) ; return 4 <S2SV_ModEnd> ; } BITMAPFILEHEADER <S2SV_ModStart> ) ; return 5 <S2SV_ModEnd> ; } BITMAPFILEHEADER |
6,031 | CWE-000 char * getToken ( char * * p ) { while ( * * p && isspace ( * * p ) ) { ++ * p ; } char * ret = * p ; if ( ! * ret ) { return NULL ; } <S2SV_StartBug> if ( * ret == '-' ) <S2SV_EndBug> { while ( * * p && ! isspace ( * * p ) ) { ++ * p ; } ++ * p ; ret = * p ; } else { while ( * * p && ! isspace ( * * p ) ) { ++ * p ; } } if ( ! * * p ) { * * p = 0 ; ++ * p ; } return ret ; } | <S2SV_ModStart> * ret == '*' <S2SV_ModEnd> ) { while |
6,032 | CWE-000 <S2SV_StartBug> void DPAUCS_io_set_pin ( unsigned pin , bool state ) { <S2SV_EndBug> ASSERT_PIN ( pin ) ; if ( state ) { PBIT_ON ( ports , pin ) ; } else { PBIT_OFF ( ports , pin ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> , bool state , uint16_t delay <S2SV_ModStart> ) ; } while ( delay -- ) _NOP ( ) ; |
6,033 | CWE-000 static void * thread ( void * param ) { uv_timer_t * task = param ; struct data_t * settings = task -> data ; struct tm tm ; struct tm rise ; struct tm set ; struct tm midnight ; time_t t ; int risetime = 0 , settime = 0 , hournow = 0 ; if ( time_override > - 1 ) { t = time_override ; } else { t = time ( NULL ) ; if ( isntpsynced ( ) == 0 ) { t -= getntpdiff ( ) ; } } if ( localtime_l ( t , & tm , settings -> tz ) == 0 ) { int year = tm . tm_year + 1900 ; int month = tm . tm_mon + 1 ; int day = tm . tm_mday ; int hour = tm . tm_hour ; int minute = tm . tm_min ; risetime = ( int ) calculate ( year , month , day , settings -> longitude , settings -> latitude , 1 ) ; settime = ( int ) calculate ( year , month , day , settings -> longitude , settings -> latitude , 0 ) ; t = datetime2ts ( year , month , day , risetime / 100 , risetime % 100 , 0 ) ; localtime_l ( t , & rise , settings -> tz ) ; risetime = ( ( rise . tm_hour * 100 ) + rise . tm_min ) ; t = datetime2ts ( year , month , day , settime / 100 , settime % 100 , 0 ) ; localtime_l ( t , & set , settings -> tz ) ; settime = ( ( set . tm_hour * 100 ) + set . tm_min ) ; memcpy ( & midnight , & tm , sizeof ( struct tm ) ) ; midnight . tm_hour = 23 ; midnight . tm_min = 59 ; midnight . tm_sec = 59 ; unsigned long tset = mktime ( & set ) ; unsigned long trise = mktime ( & rise ) ; unsigned long tmidnight = mktime ( & midnight ) ; unsigned long tnow = mktime ( & tm ) ; if ( tset < tnow ) { tset += 86400 ; } if ( trise < tnow ) { trise += 86400 ; } if ( tmidnight < tnow ) { tmidnight += 86400 ; } unsigned long time2set = tset - tnow ; unsigned long time2rise = trise - tnow ; unsigned long time2midnight = ( tmidnight + 1 ) - tnow ; char * _sun = NULL ; hournow = ( hour * 100 ) + minute ; if ( hournow >= risetime && hournow < settime ) { _sun = "rise" ; } else { _sun = "set" ; } struct reason_code_received_t * data = MALLOC ( sizeof ( struct reason_code_received_t ) ) ; if ( data == NULL ) { OUT_OF_MEMORY } snprintf ( data -> message , 1024 , "{\\"longitude\\":%.6f,\\"latitude\\":%.6f,\\"sun\\":\\"%s\\",\\"sunrise\\":%.2f,\\"sunset\\":%.2f}" , settings -> longitude , settings -> latitude , _sun , ( rise . tm_hour + ( double ) rise . tm_min / 100 ) , ( ( set . tm_hour + ( double ) set . tm_min / 100 ) ) ) ; strncpy ( data -> origin , "receiver" , 255 ) ; data -> protocol = sunriseset -> id ; if ( strlen ( pilight_uuid ) > 0 ) { data -> uuid = pilight_uuid ; } else { data -> uuid = NULL ; } data -> repeat = 1 ; eventpool_trigger ( REASON_CODE_RECEIVED , reason_code_received_free , data ) ; <S2SV_StartBug> uv_timer_start ( settings -> timer_req , ( void ( * ) ( uv_timer_t * ) ) thread , min ( time2set , time2rise , time2midnight ) * 1000 , - 1 ) ; <S2SV_EndBug> } return ( void * ) NULL ; } | <S2SV_ModStart> data ) ; unsigned long next = 0 ; if ( ( next = min ( time2set , time2rise , time2midnight ) ) == 0 ) { if ( time2set == 0 ) { next = time2midnight ; } if ( time2rise == 0 ) { next = time2set ; } if ( time2midnight == 0 ) { next = time2rise ; } } <S2SV_ModStart> ) thread , next <S2SV_ModEnd> * 1000 , |
6,034 | CWE-000 <S2SV_StartBug> static void ena_get_stats64 ( struct net_device * netdev , <S2SV_EndBug> struct rtnl_link_stats64 * stats ) # else static struct rtnl_link_stats64 * ena_get_stats64 ( struct net_device * netdev , struct rtnl_link_stats64 * stats ) # endif { struct ena_adapter * adapter = netdev_priv ( netdev ) ; struct ena_ring * rx_ring , * tx_ring ; unsigned int start ; u64 rx_drops ; int i ; if ( ! test_bit ( ENA_FLAG_DEV_UP , & adapter -> flags ) ) <S2SV_StartBug> # if ( LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 11 , 0 ) ) <S2SV_EndBug> return ; # else return NULL ; # endif for ( i = 0 ; i < adapter -> num_queues ; i ++ ) { u64 bytes , packets ; tx_ring = & adapter -> tx_ring [ i ] ; do { start = u64_stats_fetch_begin_irq ( & tx_ring -> syncp ) ; packets = tx_ring -> tx_stats . cnt ; bytes = tx_ring -> tx_stats . bytes ; } while ( u64_stats_fetch_retry_irq ( & tx_ring -> syncp , start ) ) ; stats -> tx_packets += packets ; stats -> tx_bytes += bytes ; rx_ring = & adapter -> rx_ring [ i ] ; do { start = u64_stats_fetch_begin_irq ( & rx_ring -> syncp ) ; packets = rx_ring -> rx_stats . cnt ; bytes = rx_ring -> rx_stats . bytes ; } while ( u64_stats_fetch_retry_irq ( & rx_ring -> syncp , start ) ) ; stats -> rx_packets += packets ; stats -> rx_bytes += bytes ; } do { start = u64_stats_fetch_begin_irq ( & adapter -> syncp ) ; rx_drops = adapter -> dev_stats . rx_drops ; } while ( u64_stats_fetch_retry_irq ( & adapter -> syncp , start ) ) ; stats -> rx_dropped = rx_drops ; stats -> multicast = 0 ; stats -> collisions = 0 ; stats -> rx_length_errors = 0 ; stats -> rx_crc_errors = 0 ; stats -> rx_frame_errors = 0 ; stats -> rx_fifo_errors = 0 ; stats -> rx_missed_errors = 0 ; stats -> tx_window_errors = 0 ; stats -> rx_errors = 0 ; stats -> tx_errors = 0 ; <S2SV_StartBug> # if ( LINUX_VERSION_CODE < KERNEL_VERSION ( 4 , 11 , 0 ) ) <S2SV_EndBug> return stats ; # endif } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> static struct rtnl_link_stats64 <S2SV_ModStart> ) ) # ifdef NDO_GET_STATS_64_V2 <S2SV_ModEnd> return ; # <S2SV_ModStart> 0 ; # ifndef NDO_GET_STATS_64_V2 <S2SV_ModEnd> return stats ; |
6,035 | CWE-000 static void <S2SV_StartBug> set_endian ( char * ignore_args , int from_tty , struct cmd_list_element * c ) <S2SV_EndBug> { struct gdbarch_info info ; gdbarch_info_init ( & info ) ; if ( set_endian_string == endian_auto ) { target_byte_order_user = BFD_ENDIAN_UNKNOWN ; if ( ! gdbarch_update_p ( info ) ) internal_error ( __FILE__ , __LINE__ , _ ( "set_endian:<S2SV_blank>architecture<S2SV_blank>update<S2SV_blank>failed" ) ) ; } else if ( set_endian_string == endian_little ) { info . byte_order = BFD_ENDIAN_LITTLE ; if ( ! gdbarch_update_p ( info ) ) printf_unfiltered ( _ ( "Little<S2SV_blank>endian<S2SV_blank>target<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>GDB\\n" ) ) ; else target_byte_order_user = BFD_ENDIAN_LITTLE ; } else if ( set_endian_string == endian_big ) { info . byte_order = BFD_ENDIAN_BIG ; if ( ! gdbarch_update_p ( info ) ) printf_unfiltered ( _ ( "Big<S2SV_blank>endian<S2SV_blank>target<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>GDB\\n" ) ) ; else target_byte_order_user = BFD_ENDIAN_BIG ; } else internal_error ( __FILE__ , __LINE__ , _ ( "set_endian:<S2SV_blank>bad<S2SV_blank>value" ) ) ; show_endian ( gdb_stdout , from_tty , NULL , NULL ) ; } | <S2SV_ModStart> void set_endian ( const |
6,036 | CWE-000 bool handle_ptracee_event ( Tracee * ptracee , int event ) { <S2SV_StartBug> bool handled_by_proot_first = false ; <S2SV_EndBug> Tracee * ptracer = PTRACEE . ptracer ; bool keep_stopped ; assert ( ptracer != NULL ) ; PTRACEE . event4 . proot . value = event ; PTRACEE . event4 . proot . pending = true ; keep_stopped = true ; if ( WIFSTOPPED ( event ) ) { switch ( ( event & 0xfff00 ) >> 8 ) { case SIGTRAP | 0x80 : if ( PTRACEE . ignore_syscalls || PTRACEE . ignore_loader_syscalls ) return false ; if ( ( PTRACEE . options & PTRACE_O_TRACESYSGOOD ) == 0 ) event &= ~ ( 0x80 << 8 ) ; handled_by_proot_first = IS_IN_SYSEXIT ( ptracee ) ; break ; # define PTRACE_EVENT_VFORKDONE PTRACE_EVENT_VFORK_DONE # define CASE_FILTER_EVENT ( name ) case SIGTRAP | PTRACE_EVENT_ ## name << 8 : if ( ( PTRACEE . options & PTRACE_O_TRACE ## name ) == 0 ) return false ; PTRACEE . tracing_started = true ; handled_by_proot_first = true ; break ; CASE_FILTER_EVENT ( FORK ) ; CASE_FILTER_EVENT ( VFORK ) ; CASE_FILTER_EVENT ( VFORKDONE ) ; CASE_FILTER_EVENT ( CLONE ) ; CASE_FILTER_EVENT ( EXIT ) ; CASE_FILTER_EVENT ( EXEC ) ; assert ( 0 ) ; case SIGTRAP | PTRACE_EVENT_SECCOMP2 << 8 : case SIGTRAP | PTRACE_EVENT_SECCOMP << 8 : return false ; <S2SV_StartBug> default : <S2SV_EndBug> PTRACEE . tracing_started = true ; break ; } } else if ( WIFEXITED ( event ) || WIFSIGNALED ( event ) ) { PTRACEE . tracing_started = true ; keep_stopped = false ; } if ( ! PTRACEE . tracing_started ) return false ; if ( handled_by_proot_first ) { int signal ; signal = handle_tracee_event ( ptracee , PTRACEE . event4 . proot . value ) ; PTRACEE . event4 . proot . value = signal ; <S2SV_StartBug> assert ( signal == 0 ) ; <S2SV_EndBug> } PTRACEE . event4 . ptracer . value = event ; PTRACEE . event4 . ptracer . pending = true ; kill ( ptracer -> pid , SIGCHLD ) ; if ( ( PTRACER . wait_pid == - 1 || PTRACER . wait_pid == ptracee -> pid ) && EXPECTED_WAIT_CLONE ( PTRACER . wait_options , ptracee ) ) { bool restarted ; int status ; status = update_wait_status ( ptracer , ptracee ) ; if ( status == 0 ) chain_next_syscall ( ptracer ) ; else poke_reg ( ptracer , SYSARG_RESULT , ( word_t ) status ) ; ( void ) push_regs ( ptracer ) ; PTRACER . wait_pid = 0 ; restarted = restart_tracee ( ptracer , 0 ) ; if ( ! restarted ) keep_stopped = false ; return keep_stopped ; } return keep_stopped ; } | <S2SV_ModStart> { bool handled_by_proot_first = false ; bool handled_by_proot_first_may_suppress <S2SV_ModStart> return false ; case SIGSYS : handled_by_proot_first = true ; handled_by_proot_first_may_suppress = true ; break ; <S2SV_ModStart> = signal ; if ( handled_by_proot_first_may_suppress ) { if ( signal == 0 ) { restart_tracee ( ptracee , 0 ) ; return true ; } } else { <S2SV_ModStart> 0 ) ; } |
6,037 | CWE-000 void SLLoadSystemOrLeave ( SLBlockIO * blockDevice ) { if ( blockDevice -> media -> blockSize < 512 ) { SLPrintString ( "Block<S2SV_blank>Size<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small!\\n" ) ; SLLeave ( kSLStatusLoadError ) ; } if ( blockDevice -> media -> blockSize != 512 && blockDevice -> media -> blockSize != 4098 ) { SLPrintString ( "Bad<S2SV_blank>Block<S2SV_blank>Size!\\n" ) ; SLLeave ( kSLStatusLoadError ) ; } CAHeaderSystemImage * header = SLAllocate ( blockDevice -> media -> blockSize ) ; if ( ! header ) SLLeave ( kSLStatusLoadError ) ; <S2SV_StartBug> if ( ! SLBlockIOReadBlocks ( blockDevice , 0 , header , blockDevice -> media -> blockSize ) ) <S2SV_EndBug> SLLeave ( kSLStatusLoadError ) ; <S2SV_StartBug> SLFileLocator bootLocator = SLLocateFile ( header , blockDevice , kSLLoaderBootArchivePath ) ; <S2SV_EndBug> if ( bootLocator . present ) { SLPrintString ( "Found<S2SV_blank>\'%s\'.<S2SV_blank>Data<S2SV_blank>Offset:<S2SV_blank>%zu,<S2SV_blank>Size:<S2SV_blank>%zu\\n" , kSLLoaderBootArchivePath , bootLocator . offset , bootLocator . size ) ; CAHeaderBootX * bootX = SLLoadBootX ( bootLocator , blockDevice ) ; if ( ! bootX || ! SLValidateBootX ( bootX , bootLocator . size ) ) { SLPrintString ( "Could<S2SV_blank>not<S2SV_blank>load<S2SV_blank>BootX.car!\\n" ) ; SLBootConsoleReadKey ( true ) ; SLLeave ( kSLStatusLoadError ) ; } SLPrintString ( "Loaded<S2SV_blank>Boot-X<S2SV_blank>Archive<S2SV_blank>at<S2SV_blank>address<S2SV_blank>%p\\n" , bootX ) ; SLFileLocator kernelLoader = SLLocateKernelLoader ( bootX ) ; if ( ! kernelLoader . present ) { SLPrintString ( "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>Kernel<S2SV_blank>Loader!\\n" ) ; SLBootConsoleReadKey ( true ) ; SLLeave ( kSLStatusLoadError ) ; } SLPrintString ( "Kernel<S2SV_blank>Loader<S2SV_blank>%zu<S2SV_blank>from<S2SV_blank>start\\n" , kernelLoader . offset ) ; SLRunKernelLoader ( bootX , kernelLoader ) ; SLPrintString ( "Could<S2SV_blank>not<S2SV_blank>run<S2SV_blank>Kernel<S2SV_blank>Loader!\\n" ) ; } else { SLPrintString ( "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>\'%s\'!\\n" , kSLLoaderBootArchivePath ) ; } SLBootConsoleReadKey ( true ) ; SLLeave ( kSLStatusLoadError ) ; } | <S2SV_ModStart> if ( ! SLBlockIORead <S2SV_ModEnd> ( blockDevice , <S2SV_ModStart> blockDevice , kSLLoaderBootArchivePath ) ; SLPrintString ( "%p\\n" , bootLocator |
6,038 | CWE-000 static void keyboard_handle_enter ( void * data , struct wl_keyboard * keyboard , uint32_t serial , struct wl_surface * surface , struct wl_array * keys ) { GdkWaylandSeat * seat = data ; GdkEvent * event ; GdkWaylandDisplay * display = GDK_WAYLAND_DISPLAY ( seat -> display ) ; if ( ! surface ) return ; if ( ! GDK_IS_WINDOW ( wl_surface_get_user_data ( surface ) ) ) return ; _gdk_wayland_display_update_serial ( display , serial ) ; seat -> keyboard_focus = wl_surface_get_user_data ( surface ) ; g_object_ref ( seat -> keyboard_focus ) ; <S2SV_StartBug> seat -> nkeys = 0 ; <S2SV_EndBug> event = gdk_event_new ( GDK_FOCUS_CHANGE ) ; event -> focus_change . window = g_object_ref ( seat -> keyboard_focus ) ; event -> focus_change . send_event = FALSE ; event -> focus_change . in = TRUE ; gdk_event_set_device ( event , seat -> master_keyboard ) ; gdk_event_set_source_device ( event , seat -> keyboard ) ; gdk_event_set_seat ( event , gdk_device_get_seat ( seat -> master_pointer ) ) ; GDK_NOTE ( EVENTS , g_message ( "focus<S2SV_blank>in,<S2SV_blank>seat<S2SV_blank>%p<S2SV_blank>surface<S2SV_blank>%p" , seat , seat -> keyboard_focus ) ) ; _gdk_wayland_display_deliver_event ( seat -> display , event ) ; if ( seat -> pending_selection != GDK_NONE ) { emit_selection_owner_change ( seat -> keyboard_focus , seat -> pending_selection ) ; seat -> pending_selection = GDK_NONE ; } } | <S2SV_ModStart> ; seat -> repeat_key <S2SV_ModEnd> = 0 ; |
6,039 | CWE-000 static void coroutine_delete ( struct coroutine * co ) { struct coroutine_thread * thread = co -> thread ; unsigned long flags ; BUG_ON ( co -> magic != COROUTINE_MAGIC ) ; BUG_ON ( * ( ulong * ) ( ( ulong ) co -> stack ) != COROUTINE_STACK_BOTTOM_MAGIC ) ; BUG_ON ( * ( ulong * ) ( ( ulong ) co -> stack + COROUTINE_STACK_SIZE - sizeof ( ulong ) ) != COROUTINE_STACK_TOP_MAGIC ) ; BUG_ON ( atomic_read ( & co -> ref_count ) != 0 ) ; <S2SV_StartBug> spin_lock_irqsave ( & thread -> co_list_lock , flags ) ; <S2SV_EndBug> list_del_init ( & co -> co_list_entry ) ; spin_unlock_irqrestore ( & thread -> co_list_lock , flags ) ; kfree ( co -> stack ) ; kfree ( co ) ; } | <S2SV_ModStart> 0 ) ; trace_coroutine_delete ( co , co -> stack , thread ) ; |
6,040 | CWE-000 __attribute__ ( ( nonnull ( 1 ) , nothrow , warn_unused_result ) ) static int test3 ( darr_t * restrict darr ) { size_t snum ; int * restrict nums ; size_t sz = darr -> n ; <S2SV_StartBug> printf ( "test3<S2SV_blank>()<S2SV_blank>sz:<S2SV_blank>%d\\n" , ( int ) sz ) ; fflush ( stdout ) ; <S2SV_EndBug> if ( darr -> n == 0 ) return 0 ; <S2SV_StartBug> snum = ( size_t ) rand ( ) % darr -> n ; <S2SV_EndBug> nums = malloc ( sizeof ( int ) * snum ) ; error_check ( nums == NULL ) return - 1 ; removes_rear_darr ( darr , nums , snum ) ; free ( nums ) ; error_check ( sz - snum != darr -> n ) return - 2 ; darr_print ( darr ) ; return 0 ; } | <S2SV_ModStart> -> n ; <S2SV_ModEnd> if ( darr <S2SV_ModStart> darr -> n ; printf ( "test3<S2SV_blank>()<S2SV_blank>sz:<S2SV_blank>%d,<S2SV_blank>snum:<S2SV_blank>%d\\n" , ( int ) sz , ( int ) snum ) ; fflush ( stdout ) |
6,041 | CWE-000 <S2SV_StartBug> ImmT c_std_lib0is_hash ( ImmT ___nl__imm ) { <S2SV_EndBug> return c_rt_lib0is_hash ( ___nl__imm ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> bool <S2SV_ModEnd> c_std_lib0is_hash ( ImmT |
6,042 | CWE-000 bool check_timer ( timer_t * timerid ) { struct itimerspec spec ; <S2SV_StartBug> timer_gettime ( timerid , & spec ) ; <S2SV_EndBug> return spec . it_value . tv_sec == 0 && spec . it_value . tv_nsec == 0 ; } | <S2SV_ModStart> ; timer_gettime ( * |
6,043 | CWE-000 ISR ( INT0_vect ) { int16_t j ; uint16_t plen , i , datalen , cmdlen , offset , start , dat_p ; uint8_t * data ; struct { uint8_t id [ 2 ] ; rgb color ; } s_led ; enc28j60_writeOp ( ENC28J60_BIT_FIELD_CLR , EIE , EIE_INTIE ) ; while ( enc28j60_readReg ( EPKTCNT ) ) { plen = enc28j60_packetReceive ( ) ; if ( eth_type_is_arp_and_my_ip ( plen , myip ) && enc28j60_buffer [ ETH_ARP_OPCODE_L_P ] == ETH_ARP_OPCODE_REQ_L_V ) { make_arp_answer_from_request ( mymac , myip ) ; } else if ( eth_type_is_ip_and_my_ip ( plen , myip , broadcast ) && enc28j60_buffer [ IP_PROTO_P ] == IP_PROTO_TCP_V && enc28j60_buffer [ TCP_DST_PORT_H_P ] == 0xc0 && enc28j60_buffer [ TCP_DST_PORT_L_P ] == 0x00 ) { if ( enc28j60_buffer [ TCP_FLAGS_P ] & TCP_FLAGS_SYN_V ) { make_tcp_synack ( mymac , myip ) ; } else if ( enc28j60_buffer [ TCP_FLAGS_P ] & TCP_FLAGS_FIN_V ) { <S2SV_StartBug> make_tcp_ack_from_any ( mymac , myip ) ; <S2SV_EndBug> } else if ( enc28j60_buffer [ TCP_FLAGS_P ] & TCP_FLAGS_ACK_V ) { datalen = get_tcp_data_len ( ) ; <S2SV_StartBug> data = enc28j60_buffer + TCP_SRC_PORT_H_P + get_tcp_header_len ( ) ; <S2SV_EndBug> <S2SV_StartBug> cmdlen = data [ 2 ] | data [ 1 ] << 8 ; <S2SV_EndBug> plen = 0 ; if ( datalen > 2 && cmdlen == ( datalen - 3 ) ) { switch ( modi = data [ 0 ] ) { case 'a' : if ( ! checklen ( 3 ) ) { err ( "need<S2SV_blank>at<S2SV_blank>least<S2SV_blank>3<S2SV_blank>arguments" ) ; break ; } rgb color ; memcpy ( & color , data + 3 , 3 ) ; ws2812_locked = 0 ; LEDS_LOOP_BEGIN ws2812_set_rgb_at ( i , color ) ; LEDS_LOOP_END ; ws2812_locked = 1 ; change = 1 ; ack ( 'a' ) ; break ; case 'i' : modi = oldModi ; plen = send_reply_P ( 'i' , PSTR ( "{\\"name\\":\\"frickel\\",\\"leds\\":" MACRO_TO_STRING ( ws2812_LEDS ) ",\\"max_protolen\\":" MACRO_TO_STRING ( ENC28J60_MAX_DATALEN_M ) ",\\"note\\":\\"Send<S2SV_blank>all<S2SV_blank>the<S2SV_blank>data<S2SV_blank>in<S2SV_blank>one<S2SV_blank>fucking<S2SV_blank>packet!\\"}" ) ) ; break ; case 'n' : if ( ! checklen ( 1 ) ) { err ( "protocol<S2SV_blank>error" ) ; break ; } switch ( animation = data [ 3 ] ) { case 0x01 : if ( ! checklen ( 2 ) ) break ; if ( data [ 4 ] ) { dir = 1 ; } else { dir = 0 ; } ws2812_locked = 1 ; change = 1 ; ack ( 'n' ) ; break ; default : animation = oldAnimation ; err ( "mode<S2SV_blank>not<S2SV_blank>implemented" ) ; break ; } break ; case 'r' : if ( ! checklen ( 5 ) ) { err ( "need<S2SV_blank>at<S2SV_blank>least<S2SV_blank>5<S2SV_blank>arguments" ) ; break ; } offset = ( uint16_t ) ( data [ 3 ] >> 8 ) | data [ 4 ] ; if ( ! ( offset < ws2812_LEDS ) ) { err ( "out<S2SV_blank>of<S2SV_blank>range" ) ; } cmdlen -= 2 ; cmdlen -= cmdlen % 3 + 1 ; start = enc28j60_curPacketPointer + 6 + UDP_DATA_P + 5 ; enc28j60_dma ( start , start + cmdlen , offset * 3 + ENC28J60_HEAP_START ) ; ws2812_locked = 1 ; change = 1 ; ack ( 'r' ) ; break ; case 's' : if ( ! checklen ( 5 ) ) { err ( "need<S2SV_blank>at<S2SV_blank>least<S2SV_blank>5<S2SV_blank>arguments" ) ; break ; } cmdlen -= cmdlen % 5 ; cmdlen = cmdlen / 5 ; enc28j60_writeReg16 ( ERDPTL , enc28j60_curPacketPointer + 6 + UDP_DATA_P + 3 ) ; while ( cmdlen -- ) { enc28j60_readBuf ( 5 , ( uint8_t * ) & s_led ) ; ws2812_set_rgb_at ( s_led . id [ 0 ] << 8 | s_led . id [ 1 ] , s_led . color ) ; } ws2812_locked = 1 ; change = 1 ; ack ( 's' ) ; break ; default : modi = oldModi ; err ( "mode<S2SV_blank>not<S2SV_blank>implemented" ) ; } } else { err ( "protocol<S2SV_blank>error" ) ; } <S2SV_StartBug> make_tcp_ack_from_any ( mymac , myip ) ; <S2SV_EndBug> make_tcp_ack_with_data ( plen ) ; } } else { } enc28j60_freePacketSpace ( ) ; } enc28j60_writeOp ( ENC28J60_BIT_FIELD_SET , EIE , EIE_INTIE ) ; } | <S2SV_ModStart> TCP_FLAGS_FIN_V ) { make_tcp_ack <S2SV_ModEnd> ( mymac , <S2SV_ModStart> mymac , myip , 0 <S2SV_ModStart> ( ) ; plen = 0 ; if ( datalen > 0 ) { <S2SV_ModStart> ] << 8 <S2SV_ModEnd> ; if ( <S2SV_ModStart> ) ; } } make_tcp_ack <S2SV_ModEnd> ( mymac , <S2SV_ModStart> mymac , myip , <S2SV_ModEnd> plen ) ; |
6,044 | CWE-000 <S2SV_StartBug> u8 rtw_set_802_11_connect ( _adapter * padapter , const u8 * bssid <S2SV_EndBug> , NDIS_802_11_SSID * ssid ) { _irqL irqL ; u8 status = _SUCCESS ; u32 cur_time = 0 ; bool bssid_valid = _TRUE ; bool ssid_valid = _TRUE ; struct mlme_priv * pmlmepriv = & padapter -> mlmepriv ; _func_enter_ ; if ( ! ssid || rtw_validate_ssid ( ssid ) == _FALSE ) ssid_valid = _FALSE ; if ( ! bssid || rtw_validate_bssid ( bssid ) == _FALSE ) bssid_valid = _FALSE ; if ( ssid_valid == _FALSE && bssid_valid == _FALSE ) { DBG_871X ( FUNC_ADPT_FMT "<S2SV_blank>ssid:%p,<S2SV_blank>ssid_valid:%d,<S2SV_blank>bssid:%p,<S2SV_blank>bssid_valid:%d\\n" , FUNC_ADPT_ARG ( padapter ) , ssid , ssid_valid , bssid , bssid_valid ) ; status = _FAIL ; goto exit ; } if ( padapter -> hw_init_completed == _FALSE ) { RT_TRACE ( _module_rtl871x_ioctl_set_c_ , _drv_err_ , ( "set_ssid:<S2SV_blank>hw_init_completed==_FALSE=>exit!!!\\n" ) ) ; status = _FAIL ; goto exit ; } _enter_critical_bh ( & pmlmepriv -> lock , & irqL ) ; LOG_LEVEL ( _drv_info_ , FUNC_ADPT_FMT "<S2SV_blank><S2SV_blank>fw_state=0x%08x\\n" , FUNC_ADPT_ARG ( padapter ) , get_fwstate ( pmlmepriv ) ) ; if ( check_fwstate ( pmlmepriv , _FW_UNDER_SURVEY ) == _TRUE ) { goto handle_tkip_countermeasure ; } else if ( check_fwstate ( pmlmepriv , _FW_UNDER_LINKING ) == _TRUE ) { goto release_mlme_lock ; } handle_tkip_countermeasure : if ( rtw_handle_tkip_countermeasure ( padapter , __func__ ) == _FAIL ) { status = _FAIL ; goto release_mlme_lock ; } if ( ssid && ssid_valid ) _rtw_memcpy ( & pmlmepriv -> assoc_ssid , ssid , sizeof ( NDIS_802_11_SSID ) ) ; if ( bssid && bssid_valid ) { _rtw_memcpy ( & pmlmepriv -> assoc_bssid , bssid , ETH_ALEN ) ; pmlmepriv -> assoc_by_bssid = _TRUE ; } if ( check_fwstate ( pmlmepriv , _FW_UNDER_SURVEY ) == _TRUE ) { pmlmepriv -> to_join = _TRUE ; } else { status = rtw_do_join ( padapter ) ; } release_mlme_lock : _exit_critical_bh ( & pmlmepriv -> lock , & irqL ) ; exit : _func_exit_ ; return status ; } | <S2SV_ModStart> * padapter , <S2SV_ModEnd> u8 * bssid |
6,045 | CWE-000 static int inno_hdmi_phy_power_on ( struct display_state * state ) { struct connector_state * conn_state = & state -> conn_state ; struct inno_hdmi_phy * inno = conn_state -> phy_private ; const struct post_pll_config * cfg = post_pll_cfg_table ; const struct phy_config * phy_cfg = inno -> plat_data -> phy_cfg_table ; u32 tmdsclock = inno_hdmi_phy_get_tmdsclk ( inno , inno -> pixclock ) ; u32 chipversion = 1 ; debug ( "start<S2SV_blank>Inno<S2SV_blank>HDMI<S2SV_blank>PHY<S2SV_blank>Power<S2SV_blank>On\\n" ) ; if ( ! tmdsclock ) { printf ( "TMDS<S2SV_blank>clock<S2SV_blank>is<S2SV_blank>zero!\\n" ) ; return - EINVAL ; } if ( inno -> plat_data -> dev_type == INNO_HDMI_PHY_RK3328 && rk_get_cpu_version ( ) ) chipversion = 2 ; debug ( "tmdsclock<S2SV_blank>=<S2SV_blank>%d;<S2SV_blank>chipversion<S2SV_blank>=<S2SV_blank>%d\\n" , tmdsclock , chipversion ) ; for ( ; cfg -> tmdsclock != ~ 0UL ; cfg ++ ) if ( tmdsclock <= cfg -> tmdsclock && cfg -> version & chipversion ) break ; for ( ; phy_cfg -> tmdsclock != ~ 0UL ; phy_cfg ++ ) if ( tmdsclock <= phy_cfg -> tmdsclock ) break ; if ( cfg -> tmdsclock == ~ 0UL || phy_cfg -> tmdsclock == ~ 0UL ) return - EINVAL ; debug ( "Inno<S2SV_blank>HDMI<S2SV_blank>PHY<S2SV_blank>Power<S2SV_blank>On\\n" ) ; <S2SV_StartBug> if ( inno -> plat_data -> ops -> power_on ) { <S2SV_EndBug> return inno -> plat_data -> ops -> power_on ( inno , cfg , phy_cfg ) ; <S2SV_StartBug> } else { <S2SV_EndBug> return - EINVAL ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> -> power_on ) <S2SV_ModEnd> return inno -> <S2SV_ModStart> phy_cfg ) ; else <S2SV_ModEnd> return - EINVAL <S2SV_ModStart> EINVAL ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
6,046 | CWE-000 <S2SV_StartBug> extern void pcg64_advance ( pcg64_state * state , pcg128_t step ) { <S2SV_EndBug> <S2SV_StartBug> pcg64_advance_r ( state -> pcg_state , step ) ; <S2SV_EndBug> } | <S2SV_ModStart> * state , uint64_t * <S2SV_ModEnd> step ) { <S2SV_ModStart> step ) { pcg128_t delta ; # if __SIZEOF_INT128__ && ! defined ( PCG_FORCE_EMULATED_128BIT_MATH ) delta = ( ( ( pcg128_t ) step [ 0 ] ) << 64 ) | step [ 1 ] ; # else delta . high = step [ 0 ] ; delta . low = step [ 1 ] ; # endif <S2SV_ModStart> -> pcg_state , delta <S2SV_ModEnd> ) ; } |
6,047 | CWE-000 static void _parse_relay_upstream ( xmlDocPtr doc , xmlNodePtr node , relay_config_upstream_t * upstream ) { char * tmp ; do { if ( node == NULL ) break ; if ( xmlIsBlankNode ( node ) ) continue ; if ( xmlStrcmp ( node -> name , XMLSTR ( "server" ) ) == 0 ) { if ( upstream -> server ) xmlFree ( upstream -> server ) ; upstream -> server = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "port" ) ) == 0 ) { __read_int ( doc , node , & upstream -> port , "<port><S2SV_blank>setting<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>empty." ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "mount" ) ) == 0 ) { if ( upstream -> mount ) xmlFree ( upstream -> mount ) ; upstream -> mount = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "relay-shoutcast-metadata" ) ) == 0 ) { tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; upstream -> mp3metadata = util_str_to_bool ( tmp ) ; if ( tmp ) xmlFree ( tmp ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "username" ) ) == 0 ) { if ( upstream -> username ) xmlFree ( upstream -> username ) ; upstream -> username = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "password" ) ) == 0 ) { if ( upstream -> password ) xmlFree ( upstream -> password ) ; upstream -> password = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "bind" ) ) == 0 ) { if ( upstream -> bind ) xmlFree ( upstream -> bind ) ; upstream -> bind = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } } while ( ( node = node -> next ) ) ; <S2SV_StartBug> if ( ! upstream -> server ) <S2SV_EndBug> upstream -> server = ( char * ) xmlCharStrdup ( "127.0.0.1" ) ; if ( ! upstream -> mount ) upstream -> mount = ( char * ) xmlCharStrdup ( "/" ) ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
6,048 | CWE-000 Dummy_Read_ReturnValue_t Dummy_Read_Generate_File ( int time_in_sec ) { <S2SV_StartBug> if ( time_in_sec <= 0 ) <S2SV_EndBug> { <S2SV_StartBug> printf ( "%s:<S2SV_blank>Invalid<S2SV_blank>time<S2SV_blank>input<S2SV_blank>%d<S2SV_blank>sec<S2SV_blank>\\n" , __func__ , time_in_sec ) ; <S2SV_EndBug> return DUMMY_READ_RETURNVALUE_ERROR ; } <S2SV_StartBug> if ( time_in_sec > dummy_read_handler . dummy_queue_size_inbyte / DUMMY_READ_OUTPUT_SIZE_INBYTE_PERSECOND ) <S2SV_EndBug> { <S2SV_StartBug> printf ( "%s:<S2SV_blank>Time<S2SV_blank>required<S2SV_blank>%d<S2SV_blank>sec<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>queue<S2SV_blank>size<S2SV_blank>%d\\n" , __func__ , time_in_sec , dummy_read_handler . dummy_queue_size_inbyte / DUMMY_READ_OUTPUT_SIZE_INBYTE_PERSECOND ) ; <S2SV_EndBug> dummy_read_handler . dummy_file_flag = false ; return DUMMY_READ_RETURNVALUE_ERROR ; } <S2SV_StartBug> if ( dummy_read_handler . dummy_file_flag == false ) <S2SV_EndBug> { dummy_read_handler . dummy_file_flag = true ; <S2SV_StartBug> dummy_read_handler . dummy_file_size_inshort = time_in_sec * DUMMY_READ_OUTPUT_SIZE_INBYTE_PERSECOND / 2 ; <S2SV_EndBug> return DUMMY_READ_RETURNVALUE_OK ; } else { printf ( "%s:<S2SV_blank>Last<S2SV_blank>time<S2SV_blank>is<S2SV_blank>not<S2SV_blank>done<S2SV_blank>yet\\n" , __func__ ) ; return DUMMY_READ_RETURNVALUE_ERROR ; } } | <S2SV_ModStart> time_in_sec ) { dummy_read_handler . dummy_record_time = time_in_sec ; if ( dummy_read_handler . dummy_record_time <S2SV_ModEnd> <= 0 ) <S2SV_ModStart> , __func__ , dummy_read_handler . dummy_record_time <S2SV_ModEnd> ) ; return <S2SV_ModStart> } if ( dummy_read_handler . dummy_record_time <S2SV_ModEnd> > dummy_read_handler . <S2SV_ModStart> , __func__ , dummy_read_handler . dummy_record_time <S2SV_ModEnd> , dummy_read_handler . <S2SV_ModStart> dummy_file_flag == false && dummy_read_handler . dummy_flag == true <S2SV_ModStart> . dummy_file_size_inshort = dummy_read_handler . dummy_record_time <S2SV_ModEnd> * DUMMY_READ_OUTPUT_SIZE_INBYTE_PERSECOND / |
6,049 | CWE-000 int handle_lcd ( t_data * data ) { t_command * cmd ; cmd = ( t_command * ) data -> commands -> content ; if ( ! cmd -> args || ! cmd -> args [ 1 ] ) { <S2SV_StartBug> chdir ( data -> home ) ; <S2SV_EndBug> } else { if ( opendir ( cmd -> args [ 1 ] ) ) { chdir ( cmd -> args [ 1 ] ) ; } } return ( 1 ) ; } | <S2SV_ModStart> { chdir ( "." <S2SV_ModEnd> ) ; } |
6,050 | CWE-000 <S2SV_StartBug> uint16_t dci_rivDecode ( uint8_t bandwidthPRB , uint16_t RIV , uint8_t * outFirstPRB , uint8_t * outLastPRB ) <S2SV_EndBug> { if ( outFirstPRB == NULL || outLastPRB == NULL ) { printf ( "ERR_OCC_invalid_pointers" ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } uint8_t PRBFirst = 0 ; uint8_t PRBLength = 0 ; PRBFirst = RIV % bandwidthPRB ; PRBLength = ( - ( ( RIV - bandwidthPRB - 1 - PRBFirst ) / bandwidthPRB - bandwidthPRB - 1 ) ) ; if ( ( PRBLength - 1 ) >= ( bandwidthPRB / 2 ) ) { PRBFirst = bandwidthPRB - 1 - PRBFirst ; PRBLength = bandwidthPRB + 1 - ( RIV - ( bandwidthPRB - 1 - PRBFirst ) ) / bandwidthPRB ; } * outFirstPRB = PRBFirst ; * outLastPRB = PRBFirst + PRBLength - 1 ; return 0 ; } | <S2SV_ModStart> , uint8_t * restrict <S2SV_ModStart> , uint8_t * restrict <S2SV_ModStart> ) ; return UINT16_MAX <S2SV_ModEnd> ; } uint8_t |
6,051 | CWE-000 static void <S2SV_StartBug> delete_one_file ( const char * sound_name , const char * pattern ) <S2SV_EndBug> { GFile * file ; char * name , * filename ; <S2SV_StartBug> name = g_strdup_printf ( pattern , sound_name ) ; <S2SV_EndBug> filename = custom_theme_dir_path ( name ) ; g_free ( name ) ; file = g_file_new_for_path ( filename ) ; g_free ( filename ) ; capplet_file_delete_recursive ( file , NULL ) ; g_object_unref ( file ) ; } | <S2SV_ModStart> * sound_name , SoundType sound_type <S2SV_ModEnd> ) { GFile <S2SV_ModStart> * filename ; switch ( sound_type ) { case SOUND_TYPE_OGG : <S2SV_ModStart> = g_strdup_printf ( "%s.ogg" <S2SV_ModEnd> , sound_name ) <S2SV_ModStart> sound_name ) ; break ; case SOUND_TYPE_DISABLED : name = g_strdup_printf ( "%s.disabled" , sound_name ) ; break ; default : g_assert_not_reached ( ) ; } |
6,052 | CWE-000 static enum drm_mode_status intel_tv_mode_valid ( struct drm_connector * connector , struct drm_display_mode * mode ) { const struct tv_mode * tv_mode = intel_tv_mode_find ( connector -> state ) ; int max_dotclk = to_i915 ( connector -> dev ) -> max_dotclk_freq ; <S2SV_StartBug> if ( mode -> clock > max_dotclk ) <S2SV_EndBug> return MODE_CLOCK_HIGH ; if ( tv_mode && abs ( tv_mode -> refresh - drm_mode_vrefresh ( mode ) * 1000 ) < 1000 ) return MODE_OK ; return MODE_CLOCK_RANGE ; } | <S2SV_ModStart> ( mode -> flags & DRM_MODE_FLAG_DBLSCAN ) return MODE_NO_DBLESCAN ; if ( mode -> |
6,053 | CWE-000 void __set_device_position_on_cluster ( struct fat16_super * super , int cluster_number ) { struct fat16_boot_sector bs = super -> boot_sector ; long root_directory_region_start = ( bs . reserved_sectors + bs . number_of_fats * bs . fat_size_sectors ) * bs . sector_size ; long data_region_start = root_directory_region_start + bs . root_dir_entries * sizeof ( struct fat16_entry ) ; <S2SV_StartBug> fseek ( super -> device , data_region_start + ( cluster_number - 2 ) * bs . sectors_per_cluster * bs . sector_size , SEEK_SET ) ; <S2SV_EndBug> } | <S2SV_ModStart> fat16_entry ) ; if ( cluster_number == 0 ) { fseek ( super -> device , root_directory_region_start , SEEK_SET ) ; return ; } |
6,054 | CWE-000 void do_save_plan_txt ( GtkWidget * widget , gpointer gdata ) { GtkWidget * fdialog ; typHOE * hg ; hg = ( typHOE * ) gdata ; plan_check_consistency ( hg ) ; fdialog = gtk_file_chooser_dialog_new ( "HOE<S2SV_blank>:<S2SV_blank>Input<S2SV_blank>Text<S2SV_blank>File<S2SV_blank>to<S2SV_blank>be<S2SV_blank>Saved" , GTK_WINDOW ( hg -> w_top ) , GTK_FILE_CHOOSER_ACTION_SAVE , # ifdef USE_GTK3 "_Cancel" , GTK_RESPONSE_CANCEL , "_Save" , GTK_RESPONSE_ACCEPT , # else GTK_STOCK_CANCEL , GTK_RESPONSE_CANCEL , GTK_STOCK_SAVE , GTK_RESPONSE_ACCEPT , # endif NULL ) ; gtk_dialog_set_default_response ( GTK_DIALOG ( fdialog ) , GTK_RESPONSE_ACCEPT ) ; if ( hg -> filehead ) { if ( hg -> filename_txt ) g_free ( hg -> filename_txt ) ; <S2SV_StartBug> hg -> filename_txt = g_strconcat ( hg -> filehead , PLAN_EXTENSION , NULL ) ; <S2SV_EndBug> } if ( access ( hg -> filename_txt , F_OK ) == 0 ) { gtk_file_chooser_set_filename ( GTK_FILE_CHOOSER ( fdialog ) , to_utf8 ( hg -> filename_txt ) ) ; gtk_file_chooser_select_filename ( GTK_FILE_CHOOSER ( fdialog ) , to_utf8 ( hg -> filename_txt ) ) ; } else if ( hg -> filename_txt ) { gtk_file_chooser_set_current_folder ( GTK_FILE_CHOOSER ( fdialog ) , to_utf8 ( g_path_get_dirname ( hg -> filename_txt ) ) ) ; gtk_file_chooser_set_current_name ( GTK_FILE_CHOOSER ( fdialog ) , to_utf8 ( g_path_get_basename ( hg -> filename_txt ) ) ) ; } my_file_chooser_add_filter ( fdialog , "Plan<S2SV_blank>Text<S2SV_blank>File" , "*" PLAN_EXTENSION , NULL ) ; my_file_chooser_add_filter ( fdialog , "All<S2SV_blank>File" , "*" , NULL ) ; gtk_widget_show_all ( fdialog ) ; if ( gtk_dialog_run ( GTK_DIALOG ( fdialog ) ) == GTK_RESPONSE_ACCEPT ) { char * fname ; gchar * dest_file ; FILE * fp_test ; gboolean ret = TRUE ; fname = g_strdup ( gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER ( fdialog ) ) ) ; gtk_widget_destroy ( fdialog ) ; dest_file = to_locale ( fname ) ; dest_file = check_ext ( hg -> w_top , dest_file , PLAN_EXTENSION ) ; if ( access ( dest_file , F_OK ) == 0 ) { ret = ow_dialog ( hg , dest_file ) ; } if ( ret ) { if ( ( fp_test = fopen ( dest_file , "w" ) ) != NULL ) { fclose ( fp_test ) ; if ( hg -> filehead ) g_free ( hg -> filehead ) ; hg -> filehead = make_head ( dest_file ) ; if ( hg -> filename_txt ) g_free ( hg -> filename_txt ) ; hg -> filename_txt = g_strdup ( dest_file ) ; WritePlan ( hg ) ; } else { popup_message ( hg -> w_top , # ifdef USE_GTK3 "dialog-warning" , # else GTK_STOCK_DIALOG_WARNING , # endif POPUP_TIMEOUT , "Error:<S2SV_blank>File<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>opened." , "<S2SV_blank>" , fname , NULL ) ; } } g_free ( dest_file ) ; g_free ( fname ) ; } else { gtk_widget_destroy ( fdialog ) ; } } | <S2SV_ModStart> -> filehead , "." |
6,055 | CWE-000 int __bind ( Udp_Socket * socket , const struct sockaddr * addr , socklen_t addrlen ) { <S2SV_StartBug> return bind ( socket -> fd , addr , addrlen ) ; <S2SV_EndBug> } | <S2SV_ModStart> addrlen ) { dbg_str ( DBG_DETAIL , "run<S2SV_blank>at<S2SV_blank>here" ) ; |
6,056 | CWE-000 XenEnv * XenEnv_new ( ) { XenEnv * env = malloc ( sizeof ( XenEnv ) ) ; env -> ocount = 0 ; env -> icount = 0 ; <S2SV_StartBug> env -> table = malloc ( sizeof ( XenEnvBox ) * XenEnv_SIZE ) ; <S2SV_EndBug> return env ; } | <S2SV_ModStart> ; env -> size = XenEnv_SIZE ; env -> |
6,057 | CWE-000 void process_c2n_write ( ) { struct client * i_ptr , * kill_ptr ; int ret ; i_ptr = client_list_head ; kill_ptr = 0 ; while ( i_ptr ) { switch ( i_ptr -> state ) { case PICA_CLSTATE_CONNECTED : if ( ! i_ptr -> w_pos ) break ; if ( ! i_ptr -> btw_ssl ) i_ptr -> btw_ssl = i_ptr -> w_pos ; ret = SSL_write ( i_ptr -> ssl_comm , i_ptr -> w_buf , i_ptr -> btw_ssl ) ; PICA_debug3 ( "process_c2n_write:<S2SV_blank><S2SV_blank>ret<S2SV_blank>of<S2SV_blank>SSL_write()=%i" , ret ) ; if ( ret == i_ptr -> btw_ssl ) { i_ptr -> w_pos -= i_ptr -> btw_ssl ; i_ptr -> btw_ssl = 0 ; } if ( ! ret ) kill_ptr = i_ptr ; if ( ret < 0 ) { ret = SSL_get_error ( i_ptr -> ssl_comm , ret ) ; if ( ret != SSL_ERROR_WANT_WRITE && ret != SSL_ERROR_WANT_READ ) kill_ptr = i_ptr ; } break ; case PICA_CLSTATE_SENDINGRESP : ret = send ( i_ptr -> sck_comm , i_ptr -> w_buf , i_ptr -> w_pos , 0 ) ; if ( ! ret ) kill_ptr = i_ptr ; if ( ret == SOCKET_ERROR ) ; if ( ret < i_ptr -> w_pos ) memmove ( i_ptr -> w_buf , i_ptr -> w_buf + ret , i_ptr -> w_pos - ret ) ; i_ptr -> w_pos -= ret ; if ( ! i_ptr -> w_pos ) i_ptr -> state = PICA_CLSTATE_TLSNEGOTIATION ; break ; case PICA_CLSTATE_TLSNEGOTIATION : i_ptr -> w_pos = 0 ; ret = SSL_connect ( i_ptr -> ssl_comm ) ; PICA_debug3 ( "process_c2n_write:<S2SV_blank>SSL_connect()=%i" , ret ) ; if ( ! ret ) kill_ptr = i_ptr ; if ( ret < 0 ) { int eret ; eret = SSL_get_error ( i_ptr -> ssl_comm , ret ) ; switch ( eret ) { case SSL_ERROR_WANT_WRITE : i_ptr -> w_pos = 1 ; PICA_debug3 ( "SSL_ERROR_WANT_WRITE" ) ; break ; case SSL_ERROR_WANT_READ : PICA_debug3 ( "SSL_ERROR_WANT_READ" ) ; break ; default : PICA_debug3 ( "SSL_get_error()<S2SV_blank>=<S2SV_blank>%i" , eret ) ; kill_ptr = i_ptr ; } } if ( ret == 1 ) { X509 * client_cert ; PICA_info ( "SSL<S2SV_blank>c2n<S2SV_blank>connection<S2SV_blank>established<S2SV_blank>using<S2SV_blank>%s<S2SV_blank>cipher" , SSL_get_cipher ( i_ptr -> ssl_comm ) ) ; client_cert = SSL_get_peer_certificate ( i_ptr -> ssl_comm ) ; if ( ! client_cert ) { kill_ptr = i_ptr ; } ret = PICA_id_from_X509 ( client_cert , i_ptr -> id ) ; if ( ret == 0 ) { PICA_error ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>client<S2SV_blank>id<S2SV_blank>from<S2SV_blank>certificate" ) ; kill_ptr = i_ptr ; } # warning "see<S2SV_blank>comments<S2SV_blank>below" X509_free ( client_cert ) ; if ( client_tree_search ( i_ptr -> id ) ) { PICA_info ( "Disconnecting<S2SV_blank>client<S2SV_blank>%p<S2SV_blank>because<S2SV_blank>other<S2SV_blank>user<S2SV_blank>with<S2SV_blank>same<S2SV_blank>ID<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>already<S2SV_blank>connected" , i_ptr , i_ptr -> id ) ; <S2SV_StartBug> ret = 0 ; <S2SV_EndBug> } else { ret = client_tree_add ( i_ptr ) ; client_tree_print ( client_tree_root ) ; } if ( ! ret ) { kill_ptr = i_ptr ; } i_ptr -> state = PICA_CLSTATE_CONNECTED ; } break ; } i_ptr = i_ptr -> next ; if ( kill_ptr ) { client_list_delete ( kill_ptr ) ; kill_ptr = 0 ; } } } | <S2SV_ModStart> id ) ; memset ( i_ptr -> id , 0 , PICA_ID_SIZE ) ; |
6,058 | CWE-000 int stub_procfs_setup ( const stub_proc_pid_t * proc_pids_array , const size_t proc_pids_array_length ) { if ( mkdir ( proc_fs , S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) != 0 ) return - 1 ; char path [ 256 ] ; for ( size_t i = 0 ; i < proc_pids_array_length ; ++ i ) { memset ( path , 0 , sizeof ( path ) ) ; snprintf ( path , STATIC_ARRAY_SIZE ( path ) , "%s/%d" , proc_fs , proc_pids_array [ i ] . pid ) ; mkdir ( path , S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH ) ; strncat ( path , "/comm" , STATIC_ARRAY_SIZE ( path ) - strlen ( path ) - 1 ) ; FILE * fp = fopen ( path , "w" ) ; if ( ! fp ) return - 2 ; <S2SV_StartBug> fwrite ( proc_pids_array [ i ] . comm , sizeof ( char ) , <S2SV_EndBug> <S2SV_StartBug> strlen ( proc_pids_array [ i ] . comm ) , fp ) ; <S2SV_EndBug> <S2SV_StartBug> fclose ( fp ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> - 2 ; size_t slen = strlen <S2SV_ModEnd> ( proc_pids_array [ <S2SV_ModStart> ] . comm ) ; size_t wlen = fwrite <S2SV_ModEnd> ( proc_pids_array [ <S2SV_ModStart> ] . comm , sizeof ( char ) , slen <S2SV_ModEnd> , fp ) <S2SV_ModStart> ( fp ) ; if ( slen != wlen ) return - 3 |
6,059 | CWE-000 CuSuite * StrnTest_getSuite ( void ) { CuSuite * suite = CuSuiteNew ( ) ; <S2SV_StartBug> SUITE_ADD_TEST ( suite , Test_help_text_with_parameter ) ; <S2SV_EndBug> SUITE_ADD_TEST ( suite , Test_help_text_description_only_one_word ) ; SUITE_ADD_TEST ( suite , Test_help_text_description_change_indent ) ; SUITE_ADD_TEST ( suite , Test_help_regular_text_without_changing_indentation ) ; SUITE_ADD_TEST ( suite , Test_help_regular_text_change_indentation ) ; SUITE_ADD_TEST ( suite , Test_help_regular_text_change_indentation_go_over_limits ) ; SUITE_ADD_TEST ( suite , Test_help_regular_text_invalid_arguments ) ; SUITE_ADD_TEST ( suite , Test_snhiprintf_parse_errors ) ; return suite ; } | <S2SV_ModStart> suite , Test_help_text_with_parameter ) ; SUITE_ADD_TEST ( suite , Test_help_text_with_parameter_last_line_exact_row_length ) ; SUITE_ADD_TEST ( suite , Test_help_text_with_parameter_first_and_only_line_exact_row_length |
6,060 | CWE-000 void kernel_main ( void ) { kernel_init ( ) ; <S2SV_StartBug> scan_code_detection ( ) ; <S2SV_EndBug> while ( 1 ) ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> while ( 1 |
6,061 | CWE-000 int main ( int argc , char * * argv ) { system_is_shutting_down = false ; ready_to_work = false ; initialization_failed = false ; NSI_initialization_complete = false ; BHM_initialization_complete = false ; CommUnit_initialization_complete = false ; int return_value ; Address_map beacon_address [ MAX_NUMBER_NODES ] ; pthread_t NSI_routine_thread ; return_value = startThread ( NSI_routine_thread , NSI_routine , NULL ) ; if ( return_value != WORK_SCUCESSFULLY ) { perror ( errordesc [ E_START_THREAD ] . message ) ; cleanup_exit ( ) ; } pthread_t BHM_routine_thread ; return_value = startThread ( BHM_routine_thread , BHM_routine , NULL ) ; if ( return_value != WORK_SCUCESSFULLY ) { perror ( errordesc [ E_START_THREAD ] . message ) ; cleanup_exit ( ) ; } pthread_t CommUnit_routine_thread ; <S2SV_StartBug> return_value = startThread ( CommUnit_thread , CommUnit_routine , NULL ) ; <S2SV_EndBug> if ( return_value != WORK_SCUCESSFULLY ) { perror ( errordesc [ E_START_THREAD ] . message ) ; cleanup_exit ( ) ; } while ( 1 ) { sleep ( A_LONG_TIME ) ; } cleanup_exit ( ) ; } | <S2SV_ModStart> = startThread ( CommUnit_routine_thread <S2SV_ModEnd> , CommUnit_routine , |
6,062 | CWE-000 static int vmw_cmd_dx_view_define ( struct vmw_private * dev_priv , struct vmw_sw_context * sw_context , SVGA3dCmdHeader * header ) { struct vmw_resource_val_node * ctx_node = sw_context -> dx_ctx_node ; struct vmw_resource_val_node * srf_node ; struct vmw_resource * res ; enum vmw_view_type view_type ; int ret ; struct { SVGA3dCmdHeader header ; uint32 defined_id ; uint32 sid ; } * cmd ; if ( unlikely ( ctx_node == NULL ) ) { DRM_ERROR ( "DX<S2SV_blank>Context<S2SV_blank>not<S2SV_blank>set.\\n" ) ; return - EINVAL ; } view_type = vmw_view_cmd_to_type ( header -> id ) ; <S2SV_StartBug> cmd = container_of ( header , typeof ( * cmd ) , header ) ; <S2SV_EndBug> ret = vmw_cmd_res_check ( dev_priv , sw_context , vmw_res_surface , user_surface_converter , & cmd -> sid , & srf_node ) ; if ( unlikely ( ret != 0 ) ) return ret ; res = vmw_context_cotable ( ctx_node -> res , vmw_view_cotables [ view_type ] ) ; ret = vmw_cotable_notify ( res , cmd -> defined_id ) ; vmw_resource_unreference ( & res ) ; if ( unlikely ( ret != 0 ) ) return ret ; return vmw_view_add ( sw_context -> man , ctx_node -> res , srf_node -> res , view_type , cmd -> defined_id , header , header -> size + sizeof ( * header ) , & sw_context -> staged_cmd_res ) ; } | <S2SV_ModStart> id ) ; if ( view_type == vmw_view_max ) return - EINVAL ; |
6,063 | CWE-000 int main ( ) { pthread_t loop_th1 , loop_th2 ; as_setsighandler ( SIGSEGV , & handle_segv ) ; pthread_create ( & loop_th1 , NULL , & loop , NULL ) ; pthread_create ( & loop_th2 , NULL , & loop , NULL ) ; <S2SV_StartBug> as_pmtstacktrace ( AS_STDERR , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> char * unmapped = ( char * ) NULL ; <S2SV_EndBug> * unmapped = '\\0' ; pthread_join ( loop_th1 , NULL ) ; pthread_join ( loop_th2 , NULL ) ; return 0 ; } | <S2SV_ModStart> NULL ) ; put_separator ( ',' ) ; <S2SV_ModStart> NULL ) ; put_separator ( '\\'' ) ; as_fputs ( "\\n" , AS_STDERR ) ; volatile char * volatile unmapped = <S2SV_ModEnd> NULL ; * |
6,064 | CWE-000 void SetFunctionArgType ( Oid funcOid , int argIndex , Oid newArgType ) { Relation pg_proc_rel ; HeapTuple tup ; <S2SV_StartBug> Form_pg_proc procForm ; <S2SV_EndBug> pg_proc_rel = heap_open ( ProcedureRelationId , RowExclusiveLock ) ; tup = SearchSysCacheCopy1 ( PROCOID , ObjectIdGetDatum ( funcOid ) ) ; if ( ! HeapTupleIsValid ( tup ) ) elog ( ERROR , "cache<S2SV_blank>lookup<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>function<S2SV_blank>%u" , funcOid ) ; procForm = ( Form_pg_proc ) GETSTRUCT ( tup ) ; if ( argIndex < 0 || argIndex >= procForm -> pronargs || procForm -> proargtypes . values [ argIndex ] != OPAQUEOID ) elog ( ERROR , "function<S2SV_blank>%u<S2SV_blank>doesn\'t<S2SV_blank>take<S2SV_blank>OPAQUE" , funcOid ) ; procForm -> proargtypes . values [ argIndex ] = newArgType ; CatalogTupleUpdate ( pg_proc_rel , & tup -> t_self , tup ) ; heap_close ( pg_proc_rel , RowExclusiveLock ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; Form_pg_proc procForm ; ObjectAddress func_address ; ObjectAddress type_address <S2SV_ModStart> RowExclusiveLock ) ; ObjectAddressSet ( type_address , TypeRelationId , newArgType ) ; ObjectAddressSet ( func_address , ProcedureRelationId , funcOid ) ; recordDependencyOn ( & func_address , & type_address , DEPENDENCY_NORMAL ) ; |
6,065 | CWE-000 int main ( void ) { halInit ( ) ; chSysInit ( ) ; palClearPad ( IOPORT2 , PORTB_LED1 ) ; sdStart ( & SD1 , NULL ) ; chThdCreateStatic ( waThread1 , sizeof ( waThread1 ) , NORMALPRIO , Thread1 , NULL ) ; <S2SV_StartBug> test_execute ( ( BaseSequentialStream * ) & SD1 , & rt_test_suite ) ; <S2SV_EndBug> test_execute ( ( BaseSequentialStream * ) & SD1 , & oslib_test_suite ) ; while ( TRUE ) { chThdSleepMilliseconds ( 1000 ) ; } } | <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> while ( TRUE |
6,066 | CWE-000 int check_horizontal ( char board [ ] [ BOARD_SIZE ] ) { int i , j , winner = 0 ; for ( i = 0 ; i < BOARD_SIZE ; i ++ ) { for ( j = 0 ; j < BOARD_SIZE ; j ++ ) { <S2SV_StartBug> if ( board [ i ] [ 0 ] == board [ i ] [ 1 ] && board [ i ] [ 1 ] == board [ i ] [ 2 ] ) { <S2SV_EndBug> <S2SV_StartBug> if ( board [ i ] [ 0 ] == '-' && board [ i ] [ 1 ] == '-' && board [ i ] [ 2 ] == '-' ) { <S2SV_EndBug> continue ; } else { <S2SV_StartBug> if ( board [ i ] [ j ] == X_PIECE ) { <S2SV_EndBug> winner = PLAYER_1 ; } else { winner = PLAYER_2 ; } <S2SV_StartBug> } <S2SV_EndBug> } } } return winner ; } | <S2SV_ModStart> ( board [ j <S2SV_ModEnd> ] [ 0 <S2SV_ModStart> == board [ j <S2SV_ModEnd> ] [ 1 <S2SV_ModStart> && board [ j <S2SV_ModEnd> ] [ 1 <S2SV_ModStart> == board [ j <S2SV_ModEnd> ] [ 2 <S2SV_ModStart> ( board [ j <S2SV_ModEnd> ] [ 0 <S2SV_ModStart> && board [ j <S2SV_ModEnd> ] [ 1 <S2SV_ModStart> && board [ j <S2SV_ModEnd> ] [ 2 <S2SV_ModStart> ( board [ j ] [ 2 <S2SV_ModEnd> ] == X_PIECE <S2SV_ModStart> PLAYER_2 ; } break ; } } } if ( winner ) { break ; <S2SV_ModEnd> } } return |
6,067 | CWE-000 bool parse_actual_args ( TokenStream * input , AstNode * args ) { assert ( KIND ( args , eAstNode_node_list ) ) ; bool success = true ; AstNode * expr = 0 ; if ( success = parse_expr ( input , & expr ) ) { if ( expr ) { <S2SV_StartBug> AstNode * actual_arg = new_ast_node ( input -> arena , eAstNode_actual_arg , <S2SV_EndBug> clone_source_loc ( input -> arena , & input -> src_loc ) ) ; <S2SV_StartBug> actual_arg -> actual_arg . expr = expr ; <S2SV_EndBug> <S2SV_StartBug> append_list_elem ( & args -> node_list , actual_arg , eList_ast_node ) ; <S2SV_EndBug> success = parse_rest_of_actual_args ( input , args ) ; } } return success ; } | <S2SV_ModStart> { AstNode * call_arg <S2SV_ModEnd> = new_ast_node ( <S2SV_ModStart> -> arena , eAstNode_call_arg <S2SV_ModEnd> , clone_source_loc ( <S2SV_ModStart> ) ) ; call_arg -> call_arg <S2SV_ModEnd> . expr = <S2SV_ModStart> -> node_list , call_arg <S2SV_ModEnd> , eList_ast_node ) |
6,068 | CWE-000 char * relative ( const char * from , const char * to ) { int i = 0 , last_sep = 0 ; while ( from [ i ] != '\\0' && to [ i ] != '\\0' && from [ i ] == to [ i ] ) { if ( from [ i ] == SEP ) { last_sep = i ; } i ++ ; } int dots = count_levels ( & from [ last_sep + 1 ] ) ; <S2SV_StartBug> char * rel = malloc ( dots == 0 ? 2 : ( dots * 3 ) + strlen ( & to [ last_sep ] ) ) ; <S2SV_EndBug> rel [ 0 ] = 0 ; if ( dots == 0 ) { <S2SV_StartBug> strcat ( rel , "./" ) ; <S2SV_EndBug> } while ( dots -- ) { strcat ( rel , "../" ) ; } strcat ( rel , & to [ last_sep + 1 ] ) ; printf ( "rel<S2SV_blank>=<S2SV_blank>\'%s\'\\n" , rel ) ; return rel ; } | <S2SV_ModStart> = malloc ( ( <S2SV_ModStart> * 3 ) ) <S2SV_ModStart> last_sep ] ) + 1 <S2SV_ModStart> 0 ) { strcpy <S2SV_ModEnd> ( rel , |
6,069 | CWE-000 ConfOptions * init_options ( ConfOptions * options ) { if ( ! options ) options = g_new0 ( ConfOptions , 1 ) ; options -> collections . rectangular_selection = FALSE ; options -> color_profile . enabled = TRUE ; options -> color_profile . input_type = 0 ; options -> color_profile . screen_file = NULL ; options -> color_profile . use_image = TRUE ; options -> color_profile . use_x11_screen_profile = TRUE ; options -> color_profile . render_intent = 0 ; options -> dnd_icon_size = 48 ; options -> duplicates_similarity_threshold = 99 ; options -> rot_invariant_sim = TRUE ; options -> file_filter . disable = FALSE ; options -> file_filter . show_dot_directory = FALSE ; options -> file_filter . show_hidden_files = FALSE ; options -> file_filter . show_parent_directory = TRUE ; options -> file_filter . disable_file_extension_checks = FALSE ; options -> save_window_positions = TRUE ; options -> use_saved_window_positions_for_new_windows = FALSE ; options -> tools_restore_state = TRUE ; options -> file_ops . confirm_delete = TRUE ; options -> file_ops . enable_delete_key = TRUE ; options -> file_ops . enable_in_place_rename = TRUE ; options -> file_ops . safe_delete_enable = FALSE ; options -> file_ops . safe_delete_folder_maxsize = 128 ; options -> file_ops . safe_delete_path = NULL ; options -> file_sort . ascending = TRUE ; options -> file_sort . case_sensitive = FALSE ; options -> file_sort . method = SORT_NAME ; options -> file_sort . natural = FALSE ; options -> fullscreen . above = FALSE ; options -> fullscreen . clean_flip = FALSE ; options -> fullscreen . disable_saver = TRUE ; options -> fullscreen . screen = - 1 ; memset ( & options -> image . border_color , 0 , sizeof ( options -> image . border_color ) ) ; memset ( & options -> image . alpha_color_1 , 0 , sizeof ( options -> image . alpha_color_1 ) ) ; memset ( & options -> image . alpha_color_2 , 0 , sizeof ( options -> image . alpha_color_2 ) ) ; options -> image . alpha_color_1 . red = 0x009999 ; options -> image . alpha_color_1 . green = 0x009999 ; options -> image . alpha_color_1 . blue = 0x009999 ; options -> image . alpha_color_2 . red = 0x006666 ; options -> image . alpha_color_2 . green = 0x006666 ; options -> image . alpha_color_2 . blue = 0x006666 ; options -> image . enable_read_ahead = TRUE ; options -> image . exif_rotate_enable = TRUE ; options -> image . exif_proof_rotate_enable = TRUE ; options -> image . fit_window_to_image = FALSE ; options -> image . limit_autofit_size = FALSE ; options -> image . limit_window_size = TRUE ; options -> image . max_autofit_size = 100 ; <S2SV_StartBug> options -> image . max_window_size = 90 ; <S2SV_EndBug> options -> image . scroll_reset_method = SCROLL_RESET_NOCHANGE ; options -> image . tile_cache_max = 10 ; options -> image . image_cache_max = 128 ; options -> image . use_custom_border_color = FALSE ; options -> image . use_custom_border_color_in_fullscreen = TRUE ; options -> image . zoom_2pass = TRUE ; options -> image . zoom_increment = 5 ; options -> image . zoom_mode = ZOOM_RESET_NONE ; options -> image . zoom_quality = GDK_INTERP_BILINEAR ; options -> image . zoom_to_fit_allow_expand = FALSE ; options -> image_overlay . template_string = NULL ; options -> image_overlay . x = 10 ; options -> image_overlay . y = - 10 ; options -> image_overlay . font = NULL ; options -> image_overlay . text_red = 0 ; options -> image_overlay . text_green = 0 ; options -> image_overlay . text_blue = 0 ; options -> image_overlay . text_alpha = 255 ; options -> image_overlay . background_red = 240 ; options -> image_overlay . background_green = 240 ; options -> image_overlay . background_blue = 240 ; options -> image_overlay . background_alpha = 210 ; options -> lazy_image_sync = FALSE ; options -> mousewheel_scrolls = FALSE ; options -> image_lm_click_nav = TRUE ; options -> open_recent_list_maxsize = 10 ; options -> place_dialogs_under_mouse = FALSE ; options -> progressive_key_scrolling = TRUE ; options -> keyboard_scroll_step = 1 ; options -> metadata . enable_metadata_dirs = FALSE ; options -> metadata . save_in_image_file = FALSE ; options -> metadata . save_legacy_IPTC = FALSE ; options -> metadata . warn_on_write_problems = TRUE ; options -> metadata . save_legacy_format = FALSE ; options -> metadata . sync_grouped_files = TRUE ; options -> metadata . confirm_write = TRUE ; options -> metadata . confirm_after_timeout = FALSE ; options -> metadata . confirm_timeout = 10 ; options -> metadata . confirm_on_image_change = FALSE ; options -> metadata . confirm_on_dir_change = TRUE ; options -> metadata . keywords_case_sensitive = FALSE ; options -> metadata . write_orientation = TRUE ; options -> metadata . sidecar_extended_name = FALSE ; options -> show_icon_names = TRUE ; options -> slideshow . delay = 50 ; options -> slideshow . random = FALSE ; options -> slideshow . repeat = FALSE ; options -> thumbnails . cache_into_dirs = FALSE ; options -> thumbnails . enable_caching = TRUE ; options -> thumbnails . max_height = DEFAULT_THUMB_HEIGHT ; options -> thumbnails . max_width = DEFAULT_THUMB_WIDTH ; options -> thumbnails . quality = GDK_INTERP_TILES ; options -> thumbnails . spec_standard = TRUE ; options -> thumbnails . use_xvpics = TRUE ; options -> thumbnails . use_exif = FALSE ; options -> tree_descend_subdirs = FALSE ; options -> view_dir_list_single_click_enter = TRUE ; options -> update_on_time_change = TRUE ; options -> stereo . fixed_w = 1920 ; options -> stereo . fixed_h = 1080 ; options -> stereo . fixed_x1 = 0 ; options -> stereo . fixed_y1 = 0 ; options -> stereo . fixed_x2 = 0 ; options -> stereo . fixed_y2 = 1125 ; return options ; } | <S2SV_ModStart> -> image . max_enlargement_size = 900 ; options -> image . |
6,070 | CWE-000 static void DeleteStyleGroup ( Dict * dict ) { <S2SV_StartBug> Dict_Release ( dict ) ; <S2SV_EndBug> <S2SV_StartBug> free ( dict -> privdata ) ; <S2SV_EndBug> dict -> privdata = NULL ; } | <S2SV_ModStart> dict ) { DictType * dtype ; dtype = dict -> privdata ; <S2SV_ModStart> ; free ( dtype ) <S2SV_ModEnd> ; } <S2SV_null> |
6,071 | CWE-000 static int fts5ApiPhraseFirstColumn ( Fts5Context * pCtx , int iPhrase , Fts5PhraseIter * pIter , int * piCol ) { int rc = SQLITE_OK ; Fts5Cursor * pCsr = ( Fts5Cursor * ) pCtx ; Fts5Config * pConfig = ( ( Fts5Table * ) ( pCsr -> base . pVtab ) ) -> pConfig ; if ( pConfig -> eDetail == FTS5_DETAIL_COLUMNS ) { <S2SV_StartBug> int n ; <S2SV_EndBug> <S2SV_StartBug> rc = sqlite3Fts5ExprPhraseCollist ( pCsr -> pExpr , iPhrase , & pIter -> a , & n ) ; <S2SV_EndBug> if ( rc == SQLITE_OK ) { pIter -> b = & pIter -> a [ n ] ; * piCol = 0 ; fts5ApiPhraseNextColumn ( pCtx , pIter , piCol ) ; } } else { int n ; rc = fts5CsrPoslist ( pCsr , iPhrase , & pIter -> a , & n ) ; if ( rc == SQLITE_OK ) { pIter -> b = & pIter -> a [ n ] ; if ( n <= 0 ) { * piCol = - 1 ; } else if ( pIter -> a [ 0 ] == 0x01 ) { pIter -> a += 1 + fts5GetVarint32 ( & pIter -> a [ 1 ] , * piCol ) ; } else { * piCol = 0 ; } } } return rc ; } | <S2SV_ModStart> FTS5_DETAIL_COLUMNS ) { Fts5Sorter * pSorter = pCsr -> pSorter ; int n ; if ( pSorter ) { int i1 = ( iPhrase == 0 ? 0 : pSorter -> aIdx [ iPhrase - 1 ] ) ; n = pSorter -> aIdx [ iPhrase ] - i1 ; pIter -> a = & pSorter -> aPoslist [ i1 ] ; } else { <S2SV_ModEnd> rc = sqlite3Fts5ExprPhraseCollist <S2SV_ModStart> n ) ; } |
6,072 | CWE-000 int32_t SystemNative_Pipe ( int32_t pipeFds [ 2 ] , int32_t flags ) { switch ( flags ) { case 0 : break ; case PAL_O_CLOEXEC : <S2SV_StartBug> flags = O_CLOEXEC ; <S2SV_EndBug> break ; default : assert_msg ( false , "Unknown<S2SV_blank>pipe<S2SV_blank>flag" , ( int ) flags ) ; errno = EINVAL ; return - 1 ; } int32_t result ; # if HAVE_PIPE2 while ( ( result = pipe2 ( pipeFds , flags ) ) < 0 && errno == EINTR ) ; # else while ( ( result = pipe ( pipeFds ) ) < 0 && errno == EINTR ) ; <S2SV_StartBug> if ( ( flags & O_CLOEXEC ) != 0 && result == 0 ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> while ( ( result = fcntl ( pipeFds [ 0 ] , F_SETFD , FD_CLOEXEC ) ) < 0 && errno == EINTR ) ; if ( result == 0 ) { while ( ( result = fcntl ( pipeFds [ 1 ] , F_SETFD , FD_CLOEXEC ) ) < 0 && errno == EINTR ) ; } if ( result != 0 ) { int tmpErrno = errno ; close ( pipeFds [ 0 ] ) ; close ( pipeFds [ 1 ] ) ; errno = tmpErrno ; } } # endif return result ; } | <S2SV_ModStart> case PAL_O_CLOEXEC : # if HAVE_O_CLOEXEC <S2SV_ModStart> = O_CLOEXEC ; # endif <S2SV_ModStart> EINTR ) ; # if HAVE_O_CLOEXEC <S2SV_ModStart> == 0 ) # else if ( ( flags & PAL_O_CLOEXEC ) != 0 && result == 0 ) # endif |
6,073 | CWE-000 Result update_audio ( audio_s * audio ) <S2SV_StartBug> { <S2SV_EndBug> long size = audio -> wave_buf [ audio -> buf_pos ] . nsamples * 4 - audio -> data_read ; char size_info [ 50 ] = { 0 } ; sprintf ( size_info , "Audio<S2SV_blank>Size:<S2SV_blank>%ld\\n" , size ) ; DEBUG ( size_info ) ; if ( audio -> wave_buf [ audio -> buf_pos ] . status == NDSP_WBUF_DONE ) { size_t read = ov_read ( & audio -> vf , ( char * ) audio -> wave_buf [ audio -> buf_pos ] . data_vaddr + audio -> data_read , size , NULL ) ; if ( read <= 0 ) { ov_clear ( & audio -> vf ) ; if ( read == 0 ) { ov_open ( fmemopen ( audio -> filebuf , audio -> filesize , "rb" ) , & audio -> vf , NULL , 0 ) ; } else { char error [ 100 ] = { 0 } ; sprintf ( error , "Vorbis<S2SV_blank>play<S2SV_blank>error:<S2SV_blank>%d\\n" , read ) ; DEBUG ( error ) ; ndspChnReset ( 0 ) ; return MAKERESULT ( RL_FATAL , RS_INVALIDARG , RM_APPLICATION , RD_NO_DATA ) ; } } else { audio -> data_read += read ; if ( read == size ) { audio -> data_read = 0 ; ndspChnWaveBufAdd ( 0 , & audio -> wave_buf [ audio -> buf_pos ] ) ; audio -> buf_pos = 1 - audio -> buf_pos ; } } } return MAKERESULT ( RL_SUCCESS , RS_SUCCESS , RM_APPLICATION , RD_SUCCESS ) ; } | <S2SV_ModStart> audio ) { svcCreateEvent ( & audio -> finished , RESET_STICKY ) ; |
6,074 | CWE-000 void http_worker_flush ( http_client_t * client ) { http_buffer_t * buffer = http_res_compose ( client -> res ) ; uv_write_t * write = malloc ( sizeof ( uv_write_t ) ) ; uv_buf_t wbuf = uv_buf_init ( malloc ( buffer -> position ) , buffer -> position ) ; memcpy ( wbuf . base , buffer -> data , wbuf . len ) ; write -> handle = client -> socket ; <S2SV_StartBug> http_write_token_s token = { <S2SV_EndBug> <S2SV_StartBug> . uv_buffer = & wbuf , <S2SV_EndBug> . http_buffer = buffer } ; <S2SV_StartBug> write -> data = & token ; <S2SV_EndBug> uv_write ( write , client -> socket , & wbuf , 1 , & http_worker_close_on_write ) ; } | <S2SV_ModStart> socket ; http_write_token_s * token = malloc ( sizeof ( http_write_token_s ) ) ; token -> http_buffer = buffer ; token -> <S2SV_ModEnd> uv_buffer = & <S2SV_ModStart> = & wbuf <S2SV_ModEnd> ; write -> <S2SV_ModStart> -> data = <S2SV_ModEnd> token ; uv_write |
6,075 | CWE-000 void mintg__gles_error ( ) { GLenum error = glGetError ( ) ; if ( error != GL_NO_ERROR ) { <S2SV_StartBug> mint_error ( error | 0x03020000 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> { mint_error ( ( uint32_t ) error | 0x03020000u <S2SV_ModEnd> ) ; } |
6,076 | CWE-000 static int find_sys_call_table ( char * kern_ver ) { char buf [ MAX_LEN ] ; int i = 0 ; char * filename ; char * p ; struct file * f = NULL ; mm_segment_t oldfs ; oldfs = get_fs ( ) ; set_fs ( KERNEL_DS ) ; # ifdef BOOT_PATH filename = kmalloc ( strlen ( kern_ver ) + strlen ( BOOT_PATH ) + 1 , GFP_KERNEL ) ; if ( filename == NULL ) { return - 1 ; } memset ( filename , 0 , strlen ( BOOT_PATH ) + strlen ( kern_ver ) + 1 ) ; strncpy ( filename , BOOT_PATH , strlen ( BOOT_PATH ) ) ; strncat ( filename , kern_ver , strlen ( kern_ver ) ) ; # else filename = KALLSYMS ; # endif <S2SV_StartBug> printk ( KERN_ALERT "\\nPath<S2SV_blank>%s\\n" , filename ) ; <S2SV_EndBug> f = filp_open ( filename , O_RDONLY , 0 ) ; if ( IS_ERR ( f ) || ( f == NULL ) ) { return - 1 ; } memset ( buf , 0x0 , MAX_LEN ) ; p = buf ; while ( vfs_read ( f , p + i , 1 , & f -> f_pos ) == 1 ) { if ( p [ i ] == '\\n' || i == 255 ) { i = 0 ; if ( ( strstr ( p , "sys_call_table" ) ) != NULL ) { char * sys_string ; sys_string = kmalloc ( MAX_LEN , GFP_KERNEL ) ; if ( sys_string == NULL ) { filp_close ( f , 0 ) ; set_fs ( oldfs ) ; kfree ( filename ) ; return - 1 ; } memset ( sys_string , 0 , MAX_LEN ) ; strncpy ( sys_string , strsep ( & p , "<S2SV_blank>" ) , MAX_LEN ) ; syscall_table = ( void * ) simple_strtoll ( sys_string , NULL , 16 ) ; kfree ( sys_string ) ; break ; } memset ( buf , 0x0 , MAX_LEN ) ; continue ; } i ++ ; } filp_close ( f , 0 ) ; set_fs ( oldfs ) ; # ifdef BOOT_PATH kfree ( filename ) ; # endif return 0 ; } | <S2SV_ModStart> ; # endif dbg_info ( <S2SV_ModEnd> "\\nPath<S2SV_blank>%s\\n" , filename |
6,077 | CWE-000 SEXP next_desc_k_partitions ( SEXP _n , SEXP _k , SEXP _d , SEXP state , SEXP _type ) { int n = as_uint ( _n ) ; int k = as_uint ( _k ) ; double dd ; int d = Rf_asInteger ( _d ) ; if ( d == - 1 ) { dd = npartitions_k ( n , k ) ; } else { dd = as_uint ( _d ) ; } char type ; if ( _type == R_NilValue ) { type = 'r' ; } else { type = CHAR ( Rf_asChar ( _type ) ) [ 0 ] ; if ( type != 'r' && type != 'c' && type != 'l' ) type = 'r' ; } if ( type == 'l' ) { if ( dd > INT_MAX ) Rf_error ( "too<S2SV_blank>many<S2SV_blank>results" ) ; } else { if ( dd * k > INT_MAX ) Rf_error ( "too<S2SV_blank>many<S2SV_blank>results" ) ; } d = round ( dd ) ; size_t i , j ; SEXP as ; unsigned int * ap ; <S2SV_StartBug> int status = 0 ; <S2SV_EndBug> if ( state == R_NilValue ) { as = R_UnboundValue ; } else { as = Rf_findVarInFrame ( state , Rf_install ( "a" ) ) ; } if ( as == R_UnboundValue ) { if ( state == R_NilValue ) { ap = ( unsigned int * ) R_alloc ( n , sizeof ( int ) ) ; } else { as = PROTECT ( Rf_allocVector ( INTSXP , n ) ) ; Rf_defineVar ( Rf_install ( "a" ) , as , state ) ; UNPROTECT ( 1 ) ; ap = ( unsigned int * ) INTEGER ( as ) ; } for ( i = 1 ; i < k ; i ++ ) ap [ i ] = 1 ; ap [ 0 ] = n - k + 1 ; } else { ap = ( unsigned int * ) INTEGER ( as ) ; status = 1 ; } SEXP rdim ; SEXP result , resulti ; int * resultp ; <S2SV_StartBug> int nprotect = 0 ; <S2SV_EndBug> if ( type == 'r' ) { result = PROTECT ( Rf_allocVector ( INTSXP , k * d ) ) ; nprotect ++ ; resultp = INTEGER ( result ) ; for ( j = 0 ; j < d ; j ++ ) { if ( status ) { if ( ! next_desc_k_partition ( ap , n , k ) ) { status = 0 ; break ; } } else { status = 1 ; } for ( i = 0 ; i < k ; i ++ ) { resultp [ j + i * d ] = ap [ i ] ; } } if ( status == 0 ) { result = PROTECT ( resize_row ( result , k , d , j ) ) ; nprotect ++ ; } PROTECT ( rdim = Rf_allocVector ( INTSXP , 2 ) ) ; INTEGER ( rdim ) [ 0 ] = j ; INTEGER ( rdim ) [ 1 ] = k ; Rf_setAttrib ( result , R_DimSymbol , rdim ) ; UNPROTECT ( 1 ) ; } else if ( type == 'c' ) { result = PROTECT ( Rf_allocVector ( INTSXP , k * d ) ) ; nprotect ++ ; resultp = INTEGER ( result ) ; for ( j = 0 ; j < d ; j ++ ) { if ( status ) { if ( ! next_desc_k_partition ( ap , n , k ) ) { status = 0 ; break ; } } else { status = 1 ; } for ( i = 0 ; i < k ; i ++ ) { resultp [ j * k + i ] = ap [ i ] ; } } if ( status == 0 ) { result = PROTECT ( resize_col ( result , k , d , j ) ) ; nprotect ++ ; } PROTECT ( rdim = Rf_allocVector ( INTSXP , 2 ) ) ; INTEGER ( rdim ) [ 0 ] = k ; INTEGER ( rdim ) [ 1 ] = j ; Rf_setAttrib ( result , R_DimSymbol , rdim ) ; UNPROTECT ( 1 ) ; } else if ( type == 'l' ) { result = PROTECT ( Rf_allocVector ( VECSXP , d ) ) ; nprotect ++ ; for ( j = 0 ; j < d ; j ++ ) { if ( status ) { if ( ! next_desc_k_partition ( ap , n , k ) ) { status = 0 ; break ; } } else { status = 1 ; } resulti = Rf_allocVector ( INTSXP , k ) ; SET_VECTOR_ELT ( result , j , resulti ) ; resultp = INTEGER ( resulti ) ; for ( i = 0 ; i < k ; i ++ ) { resultp [ i ] = ap [ i ] ; } } if ( status == 0 ) { result = PROTECT ( resize_list ( result , d , j ) ) ; nprotect ++ ; } } UNPROTECT ( nprotect ) ; return result ; } | <S2SV_ModStart> ap ; int nprotect = 0 ; int <S2SV_ModStart> * resultp ; <S2SV_ModEnd> if ( type |
6,078 | CWE-000 static gboolean check_gateway_entry ( const char * str ) { gs_free char * str_clone = NULL ; char * str_iter ; const char * tok ; gboolean success = FALSE ; if ( ! str || ! str [ 0 ] ) return FALSE ; str_clone = g_strdup ( str ) ; str_iter = str_clone ; while ( ( tok = strsep ( & str_iter , "<S2SV_blank>\\t," ) ) ) { <S2SV_StartBug> if ( tok [ 0 ] <S2SV_EndBug> && ( nmovpn_remote_parse ( tok , NULL , NULL , NULL , NULL , <S2SV_StartBug> NULL ) != - 1 ) ) <S2SV_EndBug> return FALSE ; success = TRUE ; } return success ; } | <S2SV_ModStart> { if ( ! <S2SV_ModStart> [ 0 ] ) continue ; if <S2SV_ModEnd> ( nmovpn_remote_parse ( <S2SV_ModStart> - 1 ) <S2SV_ModEnd> return FALSE ; |
6,079 | CWE-000 INLINE void Block_recycleMarkedLineOld ( BlockHeader * blockHeader , LineHeader * lineHeader , int lineIndex ) { Line_Unmark ( lineHeader ) ; if ( Line_ContainsObject ( lineHeader ) ) { Object * object = Line_GetFirstObject ( lineHeader ) ; word_t * lineEnd = Block_GetLineAddress ( blockHeader , lineIndex ) + WORDS_IN_LINE ; while ( object != NULL && ( word_t * ) object < lineEnd ) { ObjectHeader * objectHeader = & object -> header ; if ( Object_IsMarked ( objectHeader ) ) { Object_SetFree ( objectHeader ) ; <S2SV_StartBug> } else { <S2SV_EndBug> Object_Mark ( object ) ; } object = Object_NextObject ( object ) ; } } } | <S2SV_ModStart> ; } else if ( Object_IsAllocated ( objectHeader ) ) |
6,080 | CWE-000 static PyObject * BenzinaDatasetCore_getlength ( BenzinaDatasetCore * self , void * closure ) { size_t length ; <S2SV_StartBug> if ( benzinaDatasetGetLength ( self -> dset , & length ) != 0 ) { <S2SV_EndBug> PyErr_SetString ( PyExc_RuntimeError , "Could<S2SV_blank>not<S2SV_blank>obtain<S2SV_blank>length<S2SV_blank>of<S2SV_blank>dataset<S2SV_blank>for<S2SV_blank>unknown<S2SV_blank>reasons." ) ; return NULL ; } return PyLong_FromSize_t ( length ) ; } | <S2SV_ModStart> ( self -> dataset <S2SV_ModEnd> , & length |
6,081 | CWE-000 void stagetext_numeric_predraw ( StageText * txt , int t , float a ) { char buf [ 32 ] ; SDL_FreeSurface ( txt -> rendered_text ) ; snprintf ( buf , sizeof ( buf ) , "%i" , ( int ) ( ( intptr_t ) txt -> custom . data1 * pow ( a , 5 ) ) ) ; <S2SV_StartBug> txt -> rendered_text = fontrender_render ( & resources . fontren , buf , ( TTF_Font * ) txt -> custom . data2 ) ; <S2SV_EndBug> } | <S2SV_ModStart> , buf , * ( TTF_Font * <S2SV_ModEnd> * ) txt |
6,082 | CWE-000 static void gus_realizefn ( DeviceState * dev , Error * * errp ) { ISADevice * d = ISA_DEVICE ( dev ) ; GUSState * s = GUS ( dev ) ; IsaDmaClass * k ; struct audsettings as ; <S2SV_StartBug> AUD_register_card ( "gus" , & s -> card ) ; <S2SV_EndBug> as . freq = s -> freq ; as . nchannels = 2 ; as . fmt = AUD_FMT_S16 ; as . endianness = GUS_ENDIANNESS ; s -> voice = AUD_open_out ( & s -> card , NULL , "gus" , s , GUS_callback , & as ) ; if ( ! s -> voice ) { AUD_remove_card ( & s -> card ) ; error_setg ( errp , "No<S2SV_blank>voice" ) ; return ; } s -> shift = 2 ; s -> samples = AUD_get_buffer_size_out ( s -> voice ) >> s -> shift ; s -> mixbuf = g_malloc0 ( s -> samples << s -> shift ) ; isa_register_portio_list ( d , & s -> portio_list1 , s -> port , gus_portio_list1 , s , "gus" ) ; isa_register_portio_list ( d , & s -> portio_list2 , ( s -> port + 0x100 ) & 0xf00 , gus_portio_list2 , s , "gus" ) ; <S2SV_StartBug> s -> isa_dma = isa_get_dma ( isa_bus_from_device ( d ) , s -> emu . gusdma ) ; <S2SV_EndBug> k = ISADMA_GET_CLASS ( s -> isa_dma ) ; k -> register_channel ( s -> isa_dma , s -> emu . gusdma , GUS_read_DMA , s ) ; s -> emu . himemaddr = s -> himem ; s -> emu . gusdatapos = s -> emu . himemaddr + 1024 * 1024 + 32 ; s -> emu . opaque = s ; isa_init_irq ( d , & s -> pic , s -> emu . gusirq ) ; AUD_set_active_out ( s -> voice , 1 ) ; } | <S2SV_ModStart> audsettings as ; s -> isa_dma = isa_get_dma ( isa_bus_from_device ( d ) , s -> emu . gusdma ) ; if ( ! s -> isa_dma ) { error_setg ( errp , "ISA<S2SV_blank>controller<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>DMA" ) ; return ; } <S2SV_ModStart> "gus" ) ; <S2SV_ModEnd> k = ISADMA_GET_CLASS |
6,083 | CWE-000 static void rndis_response_complete ( struct usb_ep * ep , struct usb_request * req ) { <S2SV_StartBug> struct f_rndis * rndis = __rndis ; <S2SV_EndBug> struct usb_composite_dev * cdev ; int status = req -> status ; struct usb_ep * notify_ep ; spin_lock ( & _rndis_lock ) ; if ( ! rndis || ! rndis -> notify || ! rndis -> notify -> driver_data ) { spin_unlock ( & _rndis_lock ) ; return ; } if ( ! rndis -> port . func . config || ! rndis -> port . func . config -> cdev ) { spin_unlock ( & _rndis_lock ) ; return ; } cdev = rndis -> port . func . config -> cdev ; switch ( status ) { case - ECONNRESET : case - ESHUTDOWN : atomic_set ( & rndis -> notify_count , 0 ) ; goto out ; default : DBG ( cdev , "RNDIS<S2SV_blank>%s<S2SV_blank>response<S2SV_blank>error<S2SV_blank>%d,<S2SV_blank>%d/%d\\n" , ep -> name , status , req -> actual , req -> length ) ; case 0 : if ( ep != rndis -> notify ) goto out ; if ( atomic_dec_and_test ( & rndis -> notify_count ) ) goto out ; notify_ep = rndis -> notify ; spin_unlock ( & _rndis_lock ) ; status = usb_ep_queue ( notify_ep , req , GFP_ATOMIC ) ; if ( status ) { spin_lock ( & _rndis_lock ) ; if ( ! __rndis ) goto out ; atomic_dec ( & __rndis -> notify_count ) ; DBG ( cdev , "notify/1<S2SV_blank>--><S2SV_blank>%d\\n" , status ) ; spin_unlock ( & _rndis_lock ) ; } } return ; out : spin_unlock ( & _rndis_lock ) ; } | <S2SV_ModStart> f_rndis * rndis ; struct usb_composite_dev * cdev ; int status = req -> status ; struct usb_ep * notify_ep ; spin_lock ( & _rndis_lock ) ; rndis = __rndis <S2SV_ModEnd> ; if ( |
6,084 | CWE-000 <S2SV_StartBug> static int real_php_log_buffer ( zval * msg_buffer , char * opt TSRMLS_DC ) <S2SV_EndBug> { php_stream * stream = NULL ; HashTable * ht ; # if PHP_VERSION_ID >= 70000 zend_ulong num_key ; zend_string * str_key ; zval * entry ; # else zval * * log ; # endif <S2SV_StartBug> stream = seaslog_stream_open_wrapper ( opt TSRMLS_CC ) ; <S2SV_EndBug> if ( ! stream ) { return FAILURE ; } # if PHP_VERSION_ID >= 70000 ht = HASH_OF ( msg_buffer ) ; ZEND_HASH_FOREACH_KEY_VAL ( ht , num_key , str_key , entry ) { zend_string * s = zval_get_string ( entry ) ; php_stream_write ( stream , ZSTR_VAL ( s ) , ZSTR_LEN ( s ) ) ; zend_string_release ( s ) ; } ZEND_HASH_FOREACH_END ( ) ; # else ht = HASH_OF ( msg_buffer ) ; zend_hash_internal_pointer_reset ( ht ) ; while ( zend_hash_get_current_data ( ht , ( void * * ) & log ) == SUCCESS ) { convert_to_string_ex ( log ) ; php_stream_write ( stream , Z_STRVAL_PP ( log ) , Z_STRLEN_PP ( log ) ) ; zend_hash_move_forward ( ht ) ; } # endif <S2SV_StartBug> php_stream_close ( stream ) ; <S2SV_EndBug> php_stream_free ( stream , PHP_STREAM_FREE_RELEASE_STREAM ) ; return SUCCESS ; } | <S2SV_ModStart> char * opt , int opt_len <S2SV_ModStart> endif stream = process_stream ( opt , opt_len <S2SV_ModEnd> TSRMLS_CC ) ; <S2SV_ModStart> } # endif <S2SV_ModEnd> return SUCCESS ; |
6,085 | CWE-000 static int cna_handle_snapvault_data ( const char * hostname , cfg_snapvault_t * cfg_snapvault , na_elem_t * data , cdtime_t interval ) { <S2SV_StartBug> na_elem_iter_t status_iter ; <S2SV_EndBug> status = na_elem_child ( data , "status-list" ) ; if ( ! status ) { ERROR ( "netapp<S2SV_blank>plugin:<S2SV_blank>SnapVault<S2SV_blank>status<S2SV_blank>record<S2SV_blank>missing<S2SV_blank>status-list" ) ; return ( 0 ) ; } <S2SV_StartBug> status_iter = na_child_iterator ( status ) ; <S2SV_EndBug> for ( na_elem_t * status = na_iterator_next ( & status_iter ) ; status != NULL ; status = na_iterator_next ( & status_iter ) ) { const char * dest_sys , * dest_path , * src_sys , * src_path ; char plugin_instance [ DATA_MAX_NAME_LEN ] ; uint64_t value ; dest_sys = na_child_get_string ( status , "destination-system" ) ; dest_path = na_child_get_string ( status , "destination-path" ) ; src_sys = na_child_get_string ( status , "source-system" ) ; src_path = na_child_get_string ( status , "source-path" ) ; if ( ( ! dest_sys ) || ( ! dest_path ) || ( ! src_sys ) || ( ! src_path ) ) continue ; value = na_child_get_uint64 ( status , "lag-time" , UINT64_MAX ) ; if ( value == UINT64_MAX ) continue ; ssnprintf ( plugin_instance , sizeof ( plugin_instance ) , "snapvault-%s" , dest_path ) ; submit_double ( hostname , plugin_instance , "delay" , NULL , ( double ) value , 0 , interval ) ; value = na_child_get_uint64 ( status , "last-transfer-duration" , UINT64_MAX ) ; if ( value != UINT64_MAX ) submit_double ( hostname , plugin_instance , "duration" , "last_transfer" , ( double ) value , 0 , interval ) ; value = na_child_get_uint64 ( status , "transfer-progress" , UINT64_MAX ) ; if ( value == UINT64_MAX ) value = na_child_get_uint64 ( status , "last-transfer-size" , UINT64_MAX ) ; if ( value != UINT64_MAX ) { value *= 1024 ; submit_derive ( hostname , plugin_instance , "if_rx_octets" , "transferred" , value , 0 , interval ) ; } } return ( 0 ) ; } | <S2SV_ModStart> interval ) { na_elem_t * status_list = na_elem_child ( data , "status-list" ) ; if ( status_list == NULL ) { ERROR ( "netapp<S2SV_blank>plugin:<S2SV_blank>SnapVault<S2SV_blank>status<S2SV_blank>record<S2SV_blank>missing<S2SV_blank>status-list" ) ; return ( 0 ) ; } na_elem_iter_t status_iter <S2SV_ModEnd> = na_child_iterator ( <S2SV_ModStart> = na_child_iterator ( status_list <S2SV_ModEnd> ) ; for |
6,086 | CWE-000 void sleep_my_pretty ( void ) { cli ( ) ; disable_io ( ) ; init_pcint ( ) ; set_sleep_mode ( SLEEP_MODE_PWR_DOWN ) ; sleep_enable ( ) ; <S2SV_StartBug> sleep_bod_disable ( ) ; <S2SV_EndBug> sei ( ) ; sleep_cpu ( ) ; disable_pcint ( ) ; sleep_disable ( ) ; init_io ( ) ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> sei ( ) |
6,087 | CWE-000 void connect_and_talk ( ) { int s , number ; struct sockaddr_in server ; struct hostent * host ; host = gethostbyname ( "localhost" ) ; if ( host == NULL ) { perror ( "Client:<S2SV_blank>cannot<S2SV_blank>get<S2SV_blank>host<S2SV_blank>description" ) ; exit ( 1 ) ; } char str [ 1000 ] ; printf ( "start\\n" ) ; s = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( s < 0 ) { perror ( "Client:<S2SV_blank>cannot<S2SV_blank>open<S2SV_blank>socket" ) ; exit ( 1 ) ; } bzero ( & server , sizeof ( server ) ) ; bcopy ( host -> h_addr , & ( server . sin_addr ) , host -> h_length ) ; server . sin_family = host -> h_addrtype ; server . sin_port = htons ( MY_PORT ) ; if ( connect ( s , ( struct sockaddr * ) & server , sizeof ( server ) ) ) { perror ( "Client:<S2SV_blank>cannot<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>server" ) ; exit ( 1 ) ; } while ( 1 ) { <S2SV_StartBug> fgets ( str , sizeof ( str ) , stdin ) ; <S2SV_EndBug> do_crypt ( str ) ; char * strptr = base64encode ( ( void * ) str , strlen ( str ) ) ; strncpy ( str , strptr , sizeof ( str ) - 1 ) ; write ( s , & str , sizeof ( str ) ) ; if ( str [ 0 ] == 'e' ) { <S2SV_StartBug> break ; <S2SV_EndBug> } } printf ( "TY\\n" ) ; close ( s ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ) , stdin <S2SV_ModEnd> ) ; if <S2SV_ModStart> 'e' ) { <S2SV_ModEnd> printf ( "TY\\n" <S2SV_ModStart> s ) ; return ; } do_crypt ( str ) ; char * strptr = base64encode ( ( void * ) str , strlen ( str ) ) ; strncpy ( str , strptr , sizeof ( str ) - 1 ) ; write ( s , & str , sizeof ( str ) ) ; sleep ( 2 ) ; } |
6,088 | CWE-000 static int check_extent_data_backref ( struct btrfs_fs_info * fs_info , u64 root_id , u64 objectid , u64 offset , u64 bytenr , u64 len , u32 count ) { struct btrfs_root * root ; struct btrfs_root * extent_root = fs_info -> extent_root ; struct btrfs_key key ; struct btrfs_path path ; struct extent_buffer * leaf ; struct btrfs_file_extent_item * fi ; u32 found_count = 0 ; int slot ; int ret = 0 ; if ( ! len ) { key . objectid = bytenr ; key . type = BTRFS_EXTENT_ITEM_KEY ; key . offset = ( u64 ) - 1 ; btrfs_init_path ( & path ) ; ret = btrfs_search_slot ( NULL , extent_root , & key , & path , 0 , 0 ) ; if ( ret < 0 ) goto out ; ret = btrfs_previous_extent_item ( extent_root , & path , bytenr ) ; if ( ret ) goto out ; btrfs_item_key_to_cpu ( path . nodes [ 0 ] , & key , path . slots [ 0 ] ) ; if ( key . objectid != bytenr || key . type != BTRFS_EXTENT_ITEM_KEY ) goto out ; len = key . offset ; btrfs_release_path ( & path ) ; } key . objectid = root_id ; key . type = BTRFS_ROOT_ITEM_KEY ; key . offset = ( u64 ) - 1 ; btrfs_init_path ( & path ) ; root = btrfs_read_fs_root ( fs_info , & key ) ; if ( IS_ERR ( root ) ) goto out ; key . objectid = objectid ; key . type = BTRFS_EXTENT_DATA_KEY ; key . offset = offset & ( 1ULL << 63 ) ? 0 : offset ; ret = btrfs_search_slot ( NULL , root , & key , & path , 0 , 0 ) ; if ( ret < 0 ) goto out ; while ( 1 ) { leaf = path . nodes [ 0 ] ; slot = path . slots [ 0 ] ; if ( slot >= btrfs_header_nritems ( leaf ) || btrfs_header_owner ( leaf ) != root_id ) goto next ; <S2SV_StartBug> btrfs_item_key_to_cpu ( leaf , & key , slot ) ; <S2SV_EndBug> if ( key . objectid != objectid || key . type != BTRFS_EXTENT_DATA_KEY ) break ; fi = btrfs_item_ptr ( leaf , slot , struct btrfs_file_extent_item ) ; if ( btrfs_file_extent_disk_bytenr ( leaf , fi ) == bytenr && btrfs_file_extent_disk_num_bytes ( leaf , fi ) == len && ( u64 ) ( key . offset - btrfs_file_extent_offset ( leaf , fi ) ) == offset && btrfs_header_owner ( leaf ) == root_id ) found_count ++ ; next : ret = btrfs_next_item ( root , & path ) ; if ( ret ) break ; } out : btrfs_release_path ( & path ) ; if ( found_count != count ) { error ( "extent[%llu,<S2SV_blank>%llu]<S2SV_blank>referencer<S2SV_blank>count<S2SV_blank>mismatch<S2SV_blank>(root:<S2SV_blank>%llu,<S2SV_blank>owner:<S2SV_blank>%llu,<S2SV_blank>offset:<S2SV_blank>%llu)<S2SV_blank>wanted:<S2SV_blank>%u,<S2SV_blank>have:<S2SV_blank>%u" , bytenr , len , root_id , objectid , offset , count , found_count ) ; return REFERENCER_MISSING ; } return 0 ; } | <S2SV_ModStart> goto next ; if ( btrfs_header_flag ( leaf , BTRFS_HEADER_FLAG_RELOC ) ) { slot = btrfs_header_nritems ( leaf ) ; goto next ; } |
6,089 | CWE-000 void atualizaNivel ( struct Node * root ) { <S2SV_StartBug> if ( root -> parent == NULL ) <S2SV_EndBug> root -> Nivel = 1 ; else root -> Nivel = root -> parent -> Nivel + 1 ; <S2SV_StartBug> if ( root -> left != NULL ) <S2SV_EndBug> atualizaNivel ( root -> left ) ; <S2SV_StartBug> if ( root -> right != NULL ) <S2SV_EndBug> atualizaNivel ( root -> right ) ; } | <S2SV_ModStart> { if ( ! <S2SV_ModStart> root -> parent <S2SV_ModEnd> ) root -> <S2SV_ModStart> root -> left <S2SV_ModEnd> ) atualizaNivel ( <S2SV_ModStart> root -> right <S2SV_ModEnd> ) atualizaNivel ( |
6,090 | CWE-000 char * get_string_at_index ( const char * src , int start , int len ) { char * res = malloc ( len + 1 ) ; memcpy ( res , src + start , len ) ; <S2SV_StartBug> res [ len + 1 ] = '\\0' ; <S2SV_EndBug> return res ; } | <S2SV_ModStart> res [ len <S2SV_ModEnd> ] = '\\0' |
6,091 | CWE-000 void server_log ( const String const msg ) { const mode_t mode_d = 0770 , mode_f = 0660 ; const time_t cur_time = time ( NULL ) ; String log_dir = ( String ) calloc ( PATH_MAX + NT_LEN , sizeof ( char ) ) , f_time = ( String ) malloc ( ( FTIME_MLEN + NT_LEN ) * sizeof ( char ) ) ; char ff_time_path [ FF_TIME_PATH_MLEN + NT_LEN ] ; const struct tm * const t_data = localtime ( & cur_time ) ; if ( ! log_dir || ! f_time ) { fprintf ( stderr , RED "Memory<S2SV_blank>Error:<S2SV_blank>%s\\n" RESET , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } strftime ( f_time , FTIME_MLEN , "%a<S2SV_blank>%b<S2SV_blank>%d<S2SV_blank>%T<S2SV_blank>%Y" , t_data ) ; strftime ( ff_time_path , 10 , "logs/%Y" , t_data ) ; mkdir ( ff_time_path , mode_d ) ; strftime ( ff_time_path , 14 , "logs/%Y/%b" , t_data ) ; mkdir ( ff_time_path , mode_d ) ; strftime ( ff_time_path , 17 , "logs/%Y/%b/%U" , t_data ) ; mkdir ( ff_time_path , mode_d ) ; strftime ( ff_time_path , 20 , "%Y/%b/%U/%a.log" , t_data ) ; snprintf ( log_dir , PATH_MAX , "%s%s" , _log_root , ff_time_path ) ; const int fd = open ( log_dir , O_CREAT | O_WRONLY | O_APPEND , mode_f ) ; if ( fd == - 1 ) { if ( verbose_flag ) <S2SV_StartBug> fprintf ( stderr , YELLOW "File<S2SV_blank>Error:<S2SV_blank>%s\\n" RESET , strerror ( errno ) ) ; <S2SV_EndBug> } else dprintf ( fd , "[%s]:<S2SV_blank>%s\\n" , f_time , msg ) ; <S2SV_StartBug> close ( fd ) ; <S2SV_EndBug> free ( f_time ) ; f_time = NULL ; free ( log_dir ) ; log_dir = NULL ; } | <S2SV_ModStart> ( verbose_flag ) printf ( YELLOW "Logging<S2SV_blank>File<S2SV_blank>Error:<S2SV_blank>%s\\n" <S2SV_ModEnd> RESET , strerror <S2SV_ModStart> msg ) ; if ( <S2SV_ModStart> ( fd ) == - 1 ) { if ( verbose_flag ) printf ( YELLOW "Loggind<S2SV_blank>File<S2SV_blank>Descriptor<S2SV_blank>Error:<S2SV_blank>%s\\n" RESET , strerror ( errno ) ) ; } <S2SV_ModEnd> free ( f_time |
6,092 | CWE-000 static void handle_pingresp ( struct mqtt_connection * conn ) { DBG ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>RINGRESP\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>RINGRESP\\n" ) ; printf ( "MQTT<S2SV_blank>-<S2SV_blank>Got<S2SV_blank>RINGRESP---" ) ; TD ; ctimer_restart ( & conn -> keep_alive_timer ) ; TD ; |
6,093 | CWE-000 static int process_head_main ( struct archive_read * a , struct rar5 * rar , struct archive_entry * entry , size_t block_flags ) { ( void ) entry ; int ret ; <S2SV_StartBug> size_t extra_data_size , <S2SV_EndBug> extra_field_size , extra_field_id , archive_flags ; if ( block_flags & HFL_EXTRA_DATA ) { if ( ! read_var_sized ( a , & extra_data_size , NULL ) ) return ARCHIVE_EOF ; } else { extra_data_size = 0 ; } if ( ! read_var_sized ( a , & archive_flags , NULL ) ) { return ARCHIVE_EOF ; } enum MAIN_FLAGS { VOLUME = 0x0001 , VOLUME_NUMBER = 0x0002 , SOLID = 0x0004 , PROTECT = 0x0008 , LOCK = 0x0010 , } ; rar -> main . volume = ( archive_flags & VOLUME ) > 0 ; rar -> main . solid = ( archive_flags & SOLID ) > 0 ; if ( archive_flags & VOLUME_NUMBER ) { <S2SV_StartBug> size_t v ; <S2SV_EndBug> if ( ! read_var_sized ( a , & v , NULL ) ) { return ARCHIVE_EOF ; } rar -> main . vol_no = ( int ) v ; } else { rar -> main . vol_no = 0 ; } if ( rar -> vol . expected_vol_no > 0 && rar -> main . vol_no != rar -> vol . expected_vol_no ) { return ARCHIVE_EOF ; } if ( extra_data_size == 0 ) { return ARCHIVE_OK ; } if ( ! read_var_sized ( a , & extra_field_size , NULL ) ) { return ARCHIVE_EOF ; } if ( ! read_var_sized ( a , & extra_field_id , NULL ) ) { return ARCHIVE_EOF ; } if ( extra_field_size == 0 ) { archive_set_error ( & a -> archive , ARCHIVE_ERRNO_FILE_FORMAT , "Invalid<S2SV_blank>extra<S2SV_blank>field<S2SV_blank>size" ) ; return ARCHIVE_FATAL ; } enum MAIN_EXTRA { LOCATOR = 0x01 , } ; switch ( extra_field_id ) { case LOCATOR : ret = process_main_locator_extra_block ( a , rar ) ; if ( ret != ARCHIVE_OK ) { return ret ; } break ; default : archive_set_error ( & a -> archive , ARCHIVE_ERRNO_FILE_FORMAT , "Unsupported<S2SV_blank>extra<S2SV_blank>type<S2SV_blank>(0x%02x)" , ( int ) extra_field_id ) ; return ARCHIVE_FATAL ; } return ARCHIVE_OK ; } | <S2SV_ModStart> ; size_t extra_data_size = 0 ; size_t extra_field_size = 0 ; size_t extra_field_id = 0 ; size_t archive_flags = 0 <S2SV_ModEnd> ; if ( <S2SV_ModStart> { size_t v = 0 |
6,094 | CWE-000 static void RecycleBuffer ( ChannelState * statePtr , ChannelBuffer * bufPtr , int mustDiscard ) { <S2SV_StartBug> if ( mustDiscard ) { <S2SV_EndBug> ReleaseChannelBuffer ( bufPtr ) ; return ; } if ( ( bufPtr -> bufLength - BUFFER_PADDING ) < statePtr -> bufSize ) { ReleaseChannelBuffer ( bufPtr ) ; return ; } if ( statePtr -> flags & TCL_READABLE ) { if ( statePtr -> inQueueHead == NULL ) { statePtr -> inQueueHead = bufPtr ; statePtr -> inQueueTail = bufPtr ; goto keepBuffer ; } if ( statePtr -> saveInBufPtr == NULL ) { statePtr -> saveInBufPtr = bufPtr ; goto keepBuffer ; } } if ( statePtr -> flags & TCL_WRITABLE ) { if ( statePtr -> curOutPtr == NULL ) { statePtr -> curOutPtr = bufPtr ; goto keepBuffer ; } } ReleaseChannelBuffer ( bufPtr ) ; return ; keepBuffer : bufPtr -> nextRemoved = BUFFER_PADDING ; bufPtr -> nextAdded = BUFFER_PADDING ; bufPtr -> nextPtr = NULL ; } | <S2SV_ModStart> { if ( 1 || |
6,095 | CWE-000 static void handle_get_req ( int client , int speedtest , const char * file ) { int ret = - 1 ; int fd = - 1 ; ull totallen = 0 ; ull contentlen = 0 ; char buf [ RXTX_BUF_LEN ] = { 0 } ; <S2SV_StartBug> unsigned int sendlen = 0 ; <S2SV_EndBug> fd_set wrset ; fd_set tmpset ; struct timeval tval ; struct timeval timeout ; if ( speedtest ) { contentlen = 0x7fffffff ; } else { if ( access ( file , F_OK | R_OK ) < 0 ) { perror ( "access" ) ; goto NOT_FOUND ; } if ( ( ret = get_file_size ( file , & contentlen ) ) == SERV_ERR ) { goto INTERNAL_ERR ; } else if ( ret == CLIENT_ERR ) { goto BAD_REQ ; } if ( ( fd = open ( file , O_RDONLY ) ) < 0 ) { perror ( "open" ) ; goto INTERNAL_ERR ; } } sprintf ( buf , "HTTP/1.1<S2SV_blank>200<S2SV_blank>OK\\r\\nContent-Length:<S2SV_blank>%llu\\r\\n\\r\\n" , contentlen ) ; send ( client , buf , strlen ( buf ) , 0 ) ; FD_ZERO ( & tmpset ) ; FD_SET ( client , & tmpset ) ; tval . tv_sec = SOCKET_TIMEOUT ; tval . tv_usec = 0 ; sendlen = RXTX_BUF_LEN ; memset ( buf , 0 , RXTX_BUF_LEN ) ; while ( 1 ) { wrset = tmpset ; timeout = tval ; ret = select ( client + 1 , NULL , & wrset , NULL , & timeout ) ; if ( ret > 0 ) { if ( FD_ISSET ( client , & wrset ) ) { if ( ! speedtest ) { sendlen = read ( fd , buf , RXTX_BUF_LEN ) ; if ( ! sendlen ) { break ; } else if ( sendlen < 0 ) { perror ( "read" ) ; break ; } } else { if ( totallen + sendlen > contentlen ) { sendlen = contentlen - totallen ; } } if ( send_bytes ( client , buf , sendlen ) == 0 ) { totallen += sendlen ; if ( totallen >= contentlen ) { break ; } } else { break ; } } } else if ( ret == - 1 && errno == EINTR ) { printf ( "select<S2SV_blank>interrupted,<S2SV_blank>try<S2SV_blank>again!\\n" ) ; } else if ( ret == 0 ) { printf ( "select<S2SV_blank>timeout!\\n" ) ; break ; } else { perror ( "select" ) ; break ; } } if ( ! speedtest ) { close ( fd ) ; } printf ( "Total<S2SV_blank>sent<S2SV_blank>bytes<S2SV_blank>[%llu].\\n" , totallen ) ; return ; BAD_REQ : bad_request ( client ) ; return ; NOT_FOUND : not_found ( client ) ; return ; INTERNAL_ERR : internal_err ( client ) ; return ; } | <S2SV_ModStart> 0 } ; <S2SV_ModEnd> int sendlen = |
6,096 | CWE-000 static void uvd_v5_0_mc_resume ( struct amdgpu_device * adev ) { uint64_t offset ; uint32_t size ; WREG32 ( mmUVD_LMI_VCPU_CACHE_64BIT_BAR_LOW , lower_32_bits ( adev -> uvd . gpu_addr ) ) ; WREG32 ( mmUVD_LMI_VCPU_CACHE_64BIT_BAR_HIGH , upper_32_bits ( adev -> uvd . gpu_addr ) ) ; offset = AMDGPU_UVD_FIRMWARE_OFFSET ; <S2SV_StartBug> size = AMDGPU_GPU_PAGE_ALIGN ( adev -> uvd . fw -> size + 4 ) ; <S2SV_EndBug> WREG32 ( mmUVD_VCPU_CACHE_OFFSET0 , offset >> 3 ) ; WREG32 ( mmUVD_VCPU_CACHE_SIZE0 , size ) ; offset += size ; size = AMDGPU_UVD_HEAP_SIZE ; WREG32 ( mmUVD_VCPU_CACHE_OFFSET1 , offset >> 3 ) ; WREG32 ( mmUVD_VCPU_CACHE_SIZE1 , size ) ; offset += size ; size = AMDGPU_UVD_STACK_SIZE + ( AMDGPU_UVD_SESSION_SIZE * adev -> uvd . max_handles ) ; WREG32 ( mmUVD_VCPU_CACHE_OFFSET2 , offset >> 3 ) ; WREG32 ( mmUVD_VCPU_CACHE_SIZE2 , size ) ; WREG32 ( mmUVD_UDEC_ADDR_CONFIG , adev -> gfx . config . gb_addr_config ) ; WREG32 ( mmUVD_UDEC_DB_ADDR_CONFIG , adev -> gfx . config . gb_addr_config ) ; WREG32 ( mmUVD_UDEC_DBW_ADDR_CONFIG , adev -> gfx . config . gb_addr_config ) ; } | <S2SV_ModStart> ; size = AMDGPU_UVD_FIRMWARE_SIZE ( adev <S2SV_ModEnd> ) ; WREG32 |
6,097 | CWE-000 static struct string * read_token ( struct input * i ) { struct string * s ; skipws ( i ) ; int ch = getch ( i ) ; if ( ch == EOF ) return NULL ; if ( i -> type == IN_FILE ) { s = make_str ( ) ; } else { s = make_str_ref ( i -> str + ( i -> offset - 1 ) ) ; } <S2SV_StartBug> str_append ( s , ( char ) ch ) ; <S2SV_EndBug> if ( ch == \'"\' ) { int isescape = 0 ; for ( ; ; ) { ch = getch ( i ) ; if ( ch == EOF ) { fputs ( "Unterminated<S2SV_blank>string\\n" , stderr ) ; return NULL ; } if ( ! isprint ( ch ) ) { fprintf ( stderr , "Invalid<S2SV_blank>byte<S2SV_blank>\\\\x%02X<S2SV_blank>in<S2SV_blank>string\\n" , ch ) ; return NULL ; } <S2SV_StartBug> str_append ( s , ( char ) ch ) ; <S2SV_EndBug> switch ( ch ) { default : isescape = 0 ; break ; case '\\\\' : isescape = ! isescape ; break ; case \'"\' : if ( isescape ) isescape = 0 ; else return s ; break ; } } } else if ( ! isdelim ( ch ) ) { while ( ( ch = getch ( i ) ) != EOF && ! isspace ( ch ) && ! isdelim ( ch ) ) { <S2SV_StartBug> str_append ( s , ( char ) ch ) ; <S2SV_EndBug> } ungetch ( i , ch ) ; } return s ; } | <S2SV_ModStart> ) ; } s = <S2SV_ModStart> NULL ; } s = <S2SV_ModStart> ) ) { s = |
6,098 | CWE-000 static unsigned int armada_37xx_irq_startup ( struct irq_data * d ) { <S2SV_StartBug> struct gpio_chip * chip = irq_data_get_irq_chip_data ( d ) ; <S2SV_EndBug> d -> mask = BIT ( d -> hwirq % GPIO_PER_REG ) ; armada_37xx_irq_unmask ( d ) ; return 0 ; } | <S2SV_ModStart> d ) { <S2SV_ModEnd> d -> mask |
6,099 | CWE-000 static rtsp_message * msg_init ( void ) { rtsp_message * msg = malloc ( sizeof ( rtsp_message ) ) ; <S2SV_StartBug> memset ( msg , 0 , sizeof ( rtsp_message ) ) ; <S2SV_EndBug> msg -> referenceCount = 1 ; <S2SV_StartBug> return msg ; <S2SV_EndBug> } | <S2SV_ModStart> ) ) ; if ( msg ) { <S2SV_ModStart> = 1 ; } else { die ( "can<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>an<S2SV_blank>rtsp_message." ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.