Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,300 | CWE-000 static void compress ( main_node_t * * cas_address , main_node_t * old_main_node , int lev , thread_args_t * thread_args ) { main_node_t * new_main_node = NULL ; int32_t delete_map = 0 ; MALLOC ( new_main_node , main_node_t ) ; new_main_node -> type = CNODE ; new_main_node -> node . cnode = old_main_node -> node . cnode ; int i = 0 ; for ( i = 0 ; i < MAX_BRANCHES ; i ++ ) { if ( new_main_node -> node . cnode . array [ i ] != NULL ) { branch_t * curr_branch = new_main_node -> node . cnode . array [ i ] ; PLACE_TMP_HP ( thread_args , curr_branch ) ; if ( old_main_node -> node . cnode . marked ) { goto CLEANUP ; } if ( curr_branch -> type == INODE && curr_branch -> node . inode . main -> type == TNODE ) { branch_t * new_branch = resurrect ( & ( curr_branch -> node . inode ) ) ; if ( new_branch == NULL ) { FAIL ( "Failed<S2SV_blank>to<S2SV_blank>resurrect" ) ; } new_main_node -> node . cnode . array [ i ] = new_branch ; delete_map |= 1 << i ; } } } branch_t * old_branch = NULL ; new_main_node = to_contracted ( new_main_node , lev , & old_branch ) ; if ( ! CAS ( cas_address , old_main_node , new_main_node ) ) { goto CLEANUP ; } if ( old_branch != NULL ) { old_main_node -> node . cnode . marked = 1 ; } for ( i = 0 ; i < MAX_BRANCHES ; i ++ ) { if ( delete_map & ( 1 << i ) ) { branch_t * branch = old_main_node -> node . cnode . array [ i ] ; branch -> node . inode . marked = 1 ; } } FENCE ; for ( i = 0 ; i < MAX_BRANCHES ; i ++ ) { if ( delete_map & ( 1 << i ) ) { branch_t * branch = old_main_node -> node . cnode . array [ i ] ; add_to_free_list ( thread_args , branch ) ; <S2SV_StartBug> } <S2SV_EndBug> } add_to_free_list ( thread_args , old_main_node ) ; if ( old_branch != NULL ) { add_to_free_list ( thread_args , old_branch ) ; } return ; CLEANUP : main_node_free ( new_main_node ) ; } | <S2SV_ModStart> branch ) ; add_to_free_list ( thread_args , branch -> node . inode . main ) ; |
4,301 | CWE-000 void wlan_hdd_two_connections_scenario ( hdd_context_t * hdd_ctx , uint8_t first_chnl , enum cds_chain_mode first_chain_mask ) { uint8_t vdevid = 0 , tx_stream = 2 , rx_stream = 2 ; uint8_t type = WMI_VDEV_TYPE_STA , channel_id = first_chnl , mac_id = 1 ; uint8_t pcl [ QDF_MAX_NUM_CHAN ] = { 0 } , weight_list [ QDF_MAX_NUM_CHAN ] = { 0 } ; uint32_t pcl_len = 0 ; enum cds_chain_mode chain_mask = first_chain_mask ; enum cds_con_mode sub_type , next_sub_type , dummy_type ; <S2SV_StartBug> enum cds_conc_priority_mode system_pref = <S2SV_EndBug> hdd_ctx -> config -> conc_system_pref ; enum cds_pcl_type pcl_type ; enum cds_one_connection_mode second_index ; char reason [ 20 ] = { 0 } ; bool status = false ; QDF_STATUS ret ; struct cds_sme_cbacks sme_cbacks ; <S2SV_StartBug> for ( sub_type = CDS_STA_MODE ; <S2SV_EndBug> sub_type < CDS_MAX_NUM_OF_MODE ; sub_type ++ ) { type = wlan_hdd_valid_type_of_persona ( sub_type ) ; sme_cbacks . sme_get_valid_channels = sme_get_cfg_valid_channels ; sme_cbacks . sme_get_nss_for_vdev = sme_get_vdev_type_nss ; ret = cds_init_policy_mgr ( & sme_cbacks ) ; if ( ! QDF_IS_STATUS_SUCCESS ( ret ) ) { hdd_err ( "Policy<S2SV_blank>manager<S2SV_blank>initialization<S2SV_blank>failed" ) ; return ; } wlan_hdd_map_subtypes_hdd_wma ( & dummy_type , & sub_type ) ; cds_incr_connection_count_utfw ( vdevid , tx_stream , rx_stream , chain_mask , type , dummy_type , channel_id , mac_id ) ; if ( cds_get_connection_count ( ) != 1 ) { hdd_err ( "Test<S2SV_blank>failed<S2SV_blank>-<S2SV_blank>No.<S2SV_blank>of<S2SV_blank>connection<S2SV_blank>is<S2SV_blank>not<S2SV_blank>1" ) ; return ; } next_sub_type = CDS_STA_MODE ; while ( next_sub_type < CDS_MAX_NUM_OF_MODE ) { second_index = cds_get_second_connection_pcl_table_index ( ) ; if ( CDS_MAX_ONE_CONNECTION_MODE == second_index ) { hdd_err ( "couldn\'t<S2SV_blank>find<S2SV_blank>index<S2SV_blank>for<S2SV_blank>2nd<S2SV_blank>connection<S2SV_blank>pcl<S2SV_blank>table" ) ; next_sub_type ++ ; continue ; } qdf_mem_zero ( pcl , sizeof ( pcl ) ) ; pcl_len = 0 ; pcl_type = get_pcl_from_second_conn_table ( second_index , next_sub_type , system_pref , wma_is_hw_dbs_capable ( ) ) ; cds_get_pcl ( next_sub_type , pcl , & pcl_len , weight_list , QDF_ARRAY_SIZE ( weight_list ) ) ; status = wlan_hdd_validate_pcl ( hdd_ctx , pcl_type , pcl , pcl_len , channel_id , 0 , reason , sizeof ( reason ) ) ; if ( ( pcl_type == CDS_MAX_PCL_TYPE ) && ( pcl [ 0 ] == 0 ) ) { next_sub_type ++ ; continue ; } fill_report ( hdd_ctx , "2<S2SV_blank>connections" , sub_type , next_sub_type , CDS_MAX_NUM_OF_MODE , first_chnl , 0 , 0 , status , pcl_type , reason , pcl ) ; next_sub_type ++ ; } } } | <S2SV_ModStart> enum cds_conc_priority_mode system_pref <S2SV_ModEnd> ; enum cds_pcl_type <S2SV_ModStart> cds_sme_cbacks sme_cbacks ; system_pref = cds_get_cur_conc_system_pref ( ) ; |
4,302 | CWE-000 static void dp8393x_update_wt_regs ( dp8393xState * s ) { int64_t elapsed ; uint32_t val ; if ( s -> regs [ SONIC_CR ] & SONIC_CR_STP ) { timer_del ( s -> watchdog ) ; return ; } elapsed = s -> wt_last_update - qemu_clock_get_ns ( QEMU_CLOCK_VIRTUAL ) ; <S2SV_StartBug> val = s -> regs [ SONIC_WT1 ] << 16 | s -> regs [ SONIC_WT0 ] ; <S2SV_EndBug> val -= elapsed / 5000000 ; s -> regs [ SONIC_WT1 ] = ( val >> 16 ) & 0xffff ; s -> regs [ SONIC_WT0 ] = ( val >> 0 ) & 0xffff ; dp8393x_set_next_tick ( s ) ; } | <S2SV_ModStart> ; val = dp8393x_wt ( s ) <S2SV_ModEnd> ; val -= |
4,303 | CWE-000 static void il2c_setup_interface_vptrs ( IL2C_RUNTIME_TYPE type , void * pReference ) { il2c_assert ( type != NULL ) ; il2c_assert ( pReference != NULL ) ; IL2C_IMPLEMENTED_INTERFACE * pInterface = <S2SV_StartBug> ( IL2C_IMPLEMENTED_INTERFACE * ) ( ( ( const uintptr_t * ) ( type + 1 ) ) + type -> markTarget ) ; <S2SV_EndBug> uintptr_t index ; for ( index = 0 ; index < type -> interfaceCount ; index ++ , pInterface ++ ) { il2c_assert ( ( pInterface -> type -> flags & IL2C_TYPE_INTERFACE ) == IL2C_TYPE_INTERFACE ) ; uintptr_t offset = * ( const uintptr_t * ) ( pInterface -> vptr0 ) ; * ( ( const void * * ) ( ( ( uint8_t * ) pReference ) + offset ) ) = pInterface -> vptr0 ; } } | <S2SV_ModStart> ( ( ( IL2C_MARK_TARGET <S2SV_ModEnd> * ) ( |
4,304 | CWE-000 static int __async_op_dequeue ( WT_CONNECTION_IMPL * conn , WT_SESSION_IMPL * session , WT_ASYNC_OP_IMPL * * op ) { WT_ASYNC * async ; uint64_t cur_tail , last_consume , my_consume , my_slot , prev_slot ; uint64_t sleep_usec ; uint32_t tries ; <S2SV_StartBug> async = conn -> async ; <S2SV_EndBug> * op = NULL ; retry : tries = 0 ; sleep_usec = 100 ; WT_ORDERED_READ ( last_consume , async -> alloc_tail ) ; while ( last_consume == async -> head && async -> flush_state != WT_ASYNC_FLUSHING ) { WT_STAT_CONN_INCR ( session , async_nowork ) ; if ( ++ tries < MAX_ASYNC_YIELD ) __wt_yield ( ) ; else { __wt_sleep ( 0 , sleep_usec ) ; sleep_usec = WT_MIN ( sleep_usec * 2 , MAX_ASYNC_SLEEP_USECS ) ; } if ( ! F_ISSET ( session , WT_SESSION_SERVER_ASYNC ) ) return ( 0 ) ; if ( ! F_ISSET ( conn , WT_CONN_SERVER_ASYNC ) ) return ( 0 ) ; WT_ORDERED_READ ( last_consume , async -> alloc_tail ) ; } if ( async -> flush_state == WT_ASYNC_FLUSHING ) return ( 0 ) ; my_consume = last_consume + 1 ; if ( ! __wt_atomic_cas64 ( & async -> alloc_tail , last_consume , my_consume ) ) goto retry ; my_slot = my_consume % async -> async_qsize ; prev_slot = last_consume % async -> async_qsize ; * op = async -> async_queue [ my_slot ] ; async -> async_queue [ my_slot ] = NULL ; WT_ASSERT ( session , async -> cur_queue > 0 ) ; WT_ASSERT ( session , * op != NULL ) ; WT_ASSERT ( session , ( * op ) -> state == WT_ASYNCOP_ENQUEUED ) ; ( void ) __wt_atomic_sub32 ( & async -> cur_queue , 1 ) ; ( * op ) -> state = WT_ASYNCOP_WORKING ; if ( * op == & async -> flush_op ) WT_PUBLISH ( async -> flush_state , WT_ASYNC_FLUSHING ) ; WT_ORDERED_READ ( cur_tail , async -> tail_slot ) ; while ( cur_tail != prev_slot ) { __wt_yield ( ) ; WT_ORDERED_READ ( cur_tail , async -> tail_slot ) ; } WT_PUBLISH ( async -> tail_slot , my_slot ) ; return ( 0 ) ; } | <S2SV_ModStart> uint32_t tries ; * op = NULL ; <S2SV_ModStart> conn -> async <S2SV_ModEnd> ; retry : |
4,305 | CWE-000 static PyObject * pyPostUriFromService ( PyObject * self , PyObject * args ) { const char * uri ; <S2SV_StartBug> const char * content ; <S2SV_EndBug> redfishService * cService = ( ( pyRedfishService * ) self ) -> cService ; json_t * cJson ; const char * retStr ; <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "ss" , & uri , & content ) ) <S2SV_EndBug> { return NULL ; } <S2SV_StartBug> cJson = postUriFromService ( cService , uri , content ) ; <S2SV_EndBug> retStr = json_dumps ( cJson , 0 ) ; return Py_BuildValue ( "s" , retStr ) ; } | <S2SV_ModStart> char * content ; int contentLength ; char * contentType = NULL <S2SV_ModStart> ( args , "ss#|S" <S2SV_ModEnd> , & uri <S2SV_ModStart> , & content , & contentLength , & contentType <S2SV_ModStart> uri , content , contentLength , contentType |
4,306 | CWE-000 static void kgsl_cmdbatch_sync_fence_func ( void * priv ) { <S2SV_StartBug> struct kgsl_cmdbatch_sync_event * event = priv ; <S2SV_EndBug> trace_syncpoint_fence_expire ( event -> cmdbatch , event -> handle ? event -> handle -> name : "unknown" ) ; <S2SV_StartBug> kgsl_cmdbatch_sync_expire ( event -> device , event ) ; <S2SV_EndBug> kgsl_cmdbatch_put ( event -> cmdbatch ) ; } | <S2SV_ModStart> priv ) { unsigned long flags ; <S2SV_ModStart> event = priv ; kgsl_cmdbatch_sync_expire ( event -> device , event ) <S2SV_ModStart> "unknown" ) ; spin_lock_irqsave ( & event -> handle_lock , flags ) ; event -> handle = NULL ; spin_unlock_irqrestore ( & event -> handle_lock , flags <S2SV_ModEnd> ) ; kgsl_cmdbatch_put |
4,307 | CWE-000 VM * VM_new ( ) { VM * vm = ( VM * ) malloc ( sizeof ( VM ) ) ; vm -> alive = true ; vm -> classloader = Classloader_new ( ) ; vm -> classpath = "./" ; <S2SV_StartBug> return vm ; <S2SV_EndBug> } | <S2SV_ModStart> = "./" ; vm -> ThreadNum = 0 ; vm -> Threads = NULL ; |
4,308 | CWE-000 ngx_int_t ngx_http_modsecurity_body_filter ( ngx_http_request_t * r , ngx_chain_t * in ) { <S2SV_StartBug> int buffer_fully_loadead = 0 ; <S2SV_EndBug> ngx_chain_t * chain = in ; ngx_http_modsecurity_ctx_t * ctx = NULL ; # if defined ( MODSECURITY_SANITY_CHECKS ) && ( MODSECURITY_SANITY_CHECKS ) ngx_http_modsecurity_conf_t * loc_cf = NULL ; ngx_list_part_t * part = & r -> headers_out . headers . part ; ngx_table_elt_t * data = part -> elts ; ngx_uint_t i = 0 ; # endif if ( in == NULL ) { return ngx_http_next_body_filter ( r , in ) ; } ctx = ngx_http_get_module_ctx ( r , ngx_http_modsecurity_module ) ; dd ( "body<S2SV_blank>filter,<S2SV_blank>recovering<S2SV_blank>ctx:<S2SV_blank>%p" , ctx ) ; if ( ctx == NULL ) { return ngx_http_next_body_filter ( r , in ) ; } # if defined ( MODSECURITY_SANITY_CHECKS ) && ( MODSECURITY_SANITY_CHECKS ) loc_cf = ngx_http_get_module_loc_conf ( r , ngx_http_modsecurity_module ) ; if ( loc_cf != NULL && loc_cf -> sanity_checks_enabled != NGX_CONF_UNSET ) { # if 0 dd ( "dumping<S2SV_blank>stored<S2SV_blank>ctx<S2SV_blank>headers" ) ; for ( i = 0 ; i < ctx -> sanity_headers_out -> nelts ; i ++ ) { ngx_http_modsecurity_header_t * vals = ctx -> sanity_headers_out -> elts ; ngx_str_t * s2 = & vals [ i ] . name , * s3 = & vals [ i ] . value ; dd ( "<S2SV_blank>dump[%d]:<S2SV_blank>name<S2SV_blank>=<S2SV_blank>\'%.*s\',<S2SV_blank>value<S2SV_blank>=<S2SV_blank>\'%.*s\'" , ( int ) i , ( int ) s2 -> len , ( char * ) s2 -> data , ( int ) s3 -> len , ( char * ) s3 -> data ) ; } # endif int worth_to_fail = 0 ; for ( i = 0 ; ; i ++ ) { int found = 0 ; ngx_uint_t j = 0 ; ngx_table_elt_t * s1 ; ngx_http_modsecurity_header_t * vals ; if ( i >= part -> nelts ) { if ( part -> next == NULL ) { break ; } part = part -> next ; data = part -> elts ; i = 0 ; } vals = ctx -> sanity_headers_out -> elts ; s1 = & data [ i ] ; while ( j < ctx -> sanity_headers_out -> nelts ) { ngx_str_t * s2 = & vals [ j ] . name ; ngx_str_t * s3 = & vals [ j ] . value ; if ( s1 -> key . len == s2 -> len && ngx_strncmp ( s1 -> key . data , s2 -> data , s1 -> key . len ) == 0 ) { if ( s1 -> value . len == s3 -> len && ngx_strncmp ( s1 -> value . data , s3 -> data , s1 -> value . len ) == 0 ) { found = 1 ; break ; } } j ++ ; } if ( ! found ) { dd ( "header:<S2SV_blank>`%.*s\'<S2SV_blank>with<S2SV_blank>value:<S2SV_blank>`%.*s\'<S2SV_blank>was<S2SV_blank>not<S2SV_blank>inspected<S2SV_blank>by<S2SV_blank>ModSecurity" , ( int ) s1 -> key . len , ( const char * ) s1 -> key . data , ( int ) s1 -> value . len , ( const char * ) s1 -> value . data ) ; worth_to_fail ++ ; } } if ( worth_to_fail ) { dd ( "%d<S2SV_blank>header(s)<S2SV_blank>were<S2SV_blank>not<S2SV_blank>inspected<S2SV_blank>by<S2SV_blank>ModSecurity,<S2SV_blank>so<S2SV_blank>exiting" , worth_to_fail ) ; return ngx_http_filter_finalize_request ( r , & ngx_http_modsecurity_module , NGX_HTTP_INTERNAL_SERVER_ERROR ) ; } } # endif <S2SV_StartBug> for ( ; chain != NULL ; chain = chain -> next ) <S2SV_EndBug> { <S2SV_StartBug> if ( chain -> buf -> last_buf ) { <S2SV_EndBug> buffer_fully_loadead = 1 ; } } if ( buffer_fully_loadead == 1 ) { int ret ; <S2SV_StartBug> ngx_pool_t * old_pool ; <S2SV_EndBug> for ( chain = in ; chain != NULL ; chain = chain -> next ) { u_char * data = chain -> buf -> pos ; msc_append_response_body ( ctx -> modsec_transaction , data , chain -> buf -> last - data ) ; ret = ngx_http_modsecurity_process_intervention ( ctx -> modsec_transaction , r ) ; if ( ret > 0 ) { return ngx_http_filter_finalize_request ( r , & ngx_http_modsecurity_module , ret ) ; } <S2SV_StartBug> } <S2SV_EndBug> old_pool = ngx_http_modsecurity_pcre_malloc_init ( r -> pool ) ; msc_process_response_body ( ctx -> modsec_transaction ) ; ngx_http_modsecurity_pcre_malloc_done ( old_pool ) ; ret = ngx_http_modsecurity_process_intervention ( ctx -> modsec_transaction , r ) ; if ( ret > 0 ) { return ret ; } else if ( ret < 0 ) { return ngx_http_filter_finalize_request ( r , & ngx_http_modsecurity_module , NGX_HTTP_INTERNAL_SERVER_ERROR ) ; } } <S2SV_StartBug> else <S2SV_EndBug> { dd ( "buffer<S2SV_blank>was<S2SV_blank>not<S2SV_blank>fully<S2SV_blank>loaded!<S2SV_blank>ctx:<S2SV_blank>%p" , ctx ) ; } return ngx_http_next_body_filter ( r , in ) ; } | <S2SV_ModStart> in ) { <S2SV_ModEnd> ngx_chain_t * chain <S2SV_ModStart> } # endif int is_request_processed = 0 ; <S2SV_ModStart> next ) { u_char * data = <S2SV_ModEnd> chain -> buf <S2SV_ModStart> -> buf -> pos ; <S2SV_ModEnd> int ret ; <S2SV_ModStart> int ret ; <S2SV_ModEnd> msc_append_response_body ( ctx <S2SV_ModStart> ) ; } is_request_processed = chain -> buf -> last_buf ; if ( is_request_processed ) { ngx_pool_t * old_pool ; <S2SV_ModEnd> old_pool = ngx_http_modsecurity_pcre_malloc_init <S2SV_ModStart> ; } } } if ( ! is_request_processed ) <S2SV_ModEnd> { dd ( |
4,309 | CWE-000 struct sock * inet_diag_find_one_icsk ( struct inet_hashinfo * hashinfo , struct inet_diag_req_v2 * req ) { struct inet_diag_sockid * id = & req -> id ; struct sock * sk ; switch ( req -> sdiag_family ) { case AF_INET : sk = inet_lookup ( & init_net , hashinfo , id -> idiag_dst [ 0 ] , id -> idiag_dport , id -> idiag_src [ 0 ] , id -> idiag_sport , id -> idiag_if ) ; break ; # if IS_ENABLED ( CONFIG_IPV6 ) case AF_INET6 : <S2SV_StartBug> sk = inet6_lookup ( & init_net , hashinfo , <S2SV_EndBug> ( struct in6_addr * ) id -> idiag_dst , id -> idiag_dport , ( struct in6_addr * ) id -> idiag_src , id -> idiag_sport , id -> idiag_if ) ; break ; # endif default : return ERR_PTR ( - EINVAL ) ; } if ( IS_ERR_OR_NULL ( sk ) ) return ERR_PTR ( - ENOENT ) ; if ( sock_diag_check_cookie ( sk , id -> idiag_cookie ) ) { sk -> sk_state == TCP_TIME_WAIT ? inet_twsk_put ( ( struct inet_timewait_sock * ) sk ) : sock_put ( sk ) ; return ERR_PTR ( - ENOENT ) ; } return sk ; } | <S2SV_ModStart> case AF_INET6 : if ( ipv6_addr_v4mapped ( ( struct in6_addr * ) id -> idiag_dst ) && ipv6_addr_v4mapped ( ( struct in6_addr * ) id -> idiag_src ) ) sk = inet_lookup ( & init_net , hashinfo , id -> idiag_dst [ 3 ] , id -> idiag_dport , id -> idiag_src [ 3 ] , id -> idiag_sport , id -> idiag_if ) ; else |
4,310 | CWE-000 <S2SV_StartBug> void resetVisited ( void ) { <S2SV_EndBug> int row ; int col ; for ( row = 0 ; row < numRows ; row ++ ) { for ( col = 0 ; col < numCols ; col ++ ) { theBoard [ row ] [ col ] . visited = FALSE ; } } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
4,311 | CWE-000 int file_attr_to_st_mode ( wchar_t * path , DWORD attributes ) { int mode = S_IREAD ; <S2SV_StartBug> if ( ( attributes & FILE_ATTRIBUTE_DIRECTORY != 0 ) || is_root_or_empty ( path ) ) <S2SV_EndBug> mode |= S_IFDIR | _S_IEXEC ; else { mode |= S_IFREG ; if ( has_executable_extension ( path ) ) mode |= _S_IEXEC ; } if ( ! ( attributes & FILE_ATTRIBUTE_READONLY ) ) mode |= S_IWRITE ; mode |= ( mode & 0700 ) >> 3 ; mode |= ( mode & 0700 ) >> 6 ; return mode ; } | <S2SV_ModStart> attributes & FILE_ATTRIBUTE_DIRECTORY ) != 0 <S2SV_ModEnd> || is_root_or_empty ( |
4,312 | CWE-000 void setup ( void * _lz_base ) { void * dev_table ; void * * second_stack ; u32 * tb_dev_map ; u64 pfn , end_pfn ; u32 dev ; lz_base = _lz_base ; lz_header = ( lz_header_t * ) ( ( u8 * ) lz_base + sizeof ( sl_header_t ) ) ; zero_page = ( u8 * ) ( u64 ) lz_header -> zero_page_addr ; dev_table = ( u8 * ) lz_base + LZ_DEV_TABLE_OFFSET ; pfn = PAGE_PFN ( zero_page ) ; end_pfn = PAGE_PFN ( PAGE_DOWN ( ( u8 * ) lz_base + 0x10000 ) ) ; for ( ; pfn ++ ; pfn <= end_pfn ) dev_protect_page ( pfn , ( u8 * ) dev_table ) ; dev = dev_locate ( ) ; dev_load_map ( dev , ( u32 ) ( ( u64 ) dev_table ) ) ; dev_flush_cache ( dev ) ; tb_dev_map = ( u32 * ) ( ( u8 * ) zero_page + BP_TB_DEV_MAP ) ; * tb_dev_map = ( u32 ) ( ( u64 ) dev_table ) ; <S2SV_StartBug> second_stack = lz_base ; <S2SV_EndBug> load_stack ( * second_stack ) ; setup2 ( ) ; die ( ) ; } | <S2SV_ModStart> second_stack = lz_base - LZ_SECOND_STAGE_STACK_OFFSET |
4,313 | CWE-000 int main_set_core_defaults ( void ) { float fConfigParamsVersion ; int bSaveConfig = 0 , bUpgrade = 0 ; if ( ConfigGetParameter ( g_CoreConfig , "Version" , M64TYPE_FLOAT , & fConfigParamsVersion , sizeof ( float ) ) != M64ERR_SUCCESS ) { DebugMessage ( M64MSG_WARNING , "No<S2SV_blank>version<S2SV_blank>number<S2SV_blank>in<S2SV_blank>\'Core\'<S2SV_blank>config<S2SV_blank>section.<S2SV_blank>Setting<S2SV_blank>defaults." ) ; ConfigDeleteSection ( "Core" ) ; ConfigOpenSection ( "Core" , & g_CoreConfig ) ; bSaveConfig = 1 ; } else if ( ( ( int ) fConfigParamsVersion ) != ( ( int ) CONFIG_PARAM_VERSION ) ) { DebugMessage ( M64MSG_WARNING , "Incompatible<S2SV_blank>version<S2SV_blank>%.2f<S2SV_blank>in<S2SV_blank>\'Core\'<S2SV_blank>config<S2SV_blank>section:<S2SV_blank>current<S2SV_blank>is<S2SV_blank>%.2f.<S2SV_blank>Setting<S2SV_blank>defaults." , fConfigParamsVersion , ( float ) CONFIG_PARAM_VERSION ) ; ConfigDeleteSection ( "Core" ) ; ConfigOpenSection ( "Core" , & g_CoreConfig ) ; bSaveConfig = 1 ; } else if ( ( CONFIG_PARAM_VERSION - fConfigParamsVersion ) >= 0.0001f ) { float fVersion = ( float ) CONFIG_PARAM_VERSION ; ConfigSetParameter ( g_CoreConfig , "Version" , M64TYPE_FLOAT , & fVersion ) ; DebugMessage ( M64MSG_INFO , "Updating<S2SV_blank>parameter<S2SV_blank>set<S2SV_blank>version<S2SV_blank>in<S2SV_blank>\'Core\'<S2SV_blank>config<S2SV_blank>section<S2SV_blank>to<S2SV_blank>%.2f" , fVersion ) ; bUpgrade = 1 ; bSaveConfig = 1 ; } ConfigSetDefaultFloat ( g_CoreConfig , "Version" , ( float ) CONFIG_PARAM_VERSION , "Mupen64Plus<S2SV_blank>Core<S2SV_blank>config<S2SV_blank>parameter<S2SV_blank>set<S2SV_blank>version<S2SV_blank>number.<S2SV_blank><S2SV_blank>Please<S2SV_blank>don\'t<S2SV_blank>change<S2SV_blank>this<S2SV_blank>version<S2SV_blank>number." ) ; ConfigSetDefaultBool ( g_CoreConfig , "OnScreenDisplay" , 1 , "Draw<S2SV_blank>on-screen<S2SV_blank>display<S2SV_blank>if<S2SV_blank>True,<S2SV_blank>otherwise<S2SV_blank>don\'t<S2SV_blank>draw<S2SV_blank>OSD" ) ; # if defined ( DYNAREC ) ConfigSetDefaultInt ( g_CoreConfig , "R4300Emulator" , 2 , "Use<S2SV_blank>Pure<S2SV_blank>Interpreter<S2SV_blank>if<S2SV_blank>0,<S2SV_blank>Cached<S2SV_blank>Interpreter<S2SV_blank>if<S2SV_blank>1,<S2SV_blank>or<S2SV_blank>Dynamic<S2SV_blank>Recompiler<S2SV_blank>if<S2SV_blank>2<S2SV_blank>or<S2SV_blank>more" ) ; # else ConfigSetDefaultInt ( g_CoreConfig , "R4300Emulator" , 1 , "Use<S2SV_blank>Pure<S2SV_blank>Interpreter<S2SV_blank>if<S2SV_blank>0,<S2SV_blank>Cached<S2SV_blank>Interpreter<S2SV_blank>if<S2SV_blank>1,<S2SV_blank>or<S2SV_blank>Dynamic<S2SV_blank>Recompiler<S2SV_blank>if<S2SV_blank>2<S2SV_blank>or<S2SV_blank>more" ) ; # endif ConfigSetDefaultBool ( g_CoreConfig , "NoCompiledJump" , 0 , "Disable<S2SV_blank>compiled<S2SV_blank>jump<S2SV_blank>commands<S2SV_blank>in<S2SV_blank>dynamic<S2SV_blank>recompiler<S2SV_blank>(should<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>False)<S2SV_blank>" ) ; ConfigSetDefaultBool ( g_CoreConfig , "DisableExtraMem" , 0 , "Disable<S2SV_blank>4MB<S2SV_blank>expansion<S2SV_blank>RAM<S2SV_blank>pack.<S2SV_blank>May<S2SV_blank>be<S2SV_blank>necessary<S2SV_blank>for<S2SV_blank>some<S2SV_blank>games" ) ; ConfigSetDefaultBool ( g_CoreConfig , "AutoStateSlotIncrement" , 0 , "Increment<S2SV_blank>the<S2SV_blank>save<S2SV_blank>state<S2SV_blank>slot<S2SV_blank>after<S2SV_blank>each<S2SV_blank>save<S2SV_blank>operation" ) ; ConfigSetDefaultBool ( g_CoreConfig , "EnableDebugger" , 0 , "Activate<S2SV_blank>the<S2SV_blank>R4300<S2SV_blank>debugger<S2SV_blank>when<S2SV_blank>ROM<S2SV_blank>execution<S2SV_blank>begins,<S2SV_blank>if<S2SV_blank>core<S2SV_blank>was<S2SV_blank>built<S2SV_blank>with<S2SV_blank>Debugger<S2SV_blank>support" ) ; ConfigSetDefaultInt ( g_CoreConfig , "CurrentStateSlot" , 0 , "Save<S2SV_blank>state<S2SV_blank>slot<S2SV_blank>(0-9)<S2SV_blank>to<S2SV_blank>use<S2SV_blank>when<S2SV_blank>saving/loading<S2SV_blank>the<S2SV_blank>emulator<S2SV_blank>state" ) ; ConfigSetDefaultString ( g_CoreConfig , "ScreenshotPath" , "" , "Path<S2SV_blank>to<S2SV_blank>directory<S2SV_blank>where<S2SV_blank>screenshots<S2SV_blank>are<S2SV_blank>saved.<S2SV_blank>If<S2SV_blank>this<S2SV_blank>is<S2SV_blank>blank,<S2SV_blank>the<S2SV_blank>default<S2SV_blank>value<S2SV_blank>of<S2SV_blank>${UserDataPath}/screenshot<S2SV_blank>will<S2SV_blank>be<S2SV_blank>used" ) ; ConfigSetDefaultString ( g_CoreConfig , "SaveStatePath" , "" , "Path<S2SV_blank>to<S2SV_blank>directory<S2SV_blank>where<S2SV_blank>emulator<S2SV_blank>save<S2SV_blank>states<S2SV_blank>(snapshots)<S2SV_blank>are<S2SV_blank>saved.<S2SV_blank>If<S2SV_blank>this<S2SV_blank>is<S2SV_blank>blank,<S2SV_blank>the<S2SV_blank>default<S2SV_blank>value<S2SV_blank>of<S2SV_blank>${UserDataPath}/save<S2SV_blank>will<S2SV_blank>be<S2SV_blank>used" ) ; ConfigSetDefaultString ( g_CoreConfig , "SaveSRAMPath" , "" , "Path<S2SV_blank>to<S2SV_blank>directory<S2SV_blank>where<S2SV_blank>SRAM/EEPROM<S2SV_blank>data<S2SV_blank>(in-game<S2SV_blank>saves)<S2SV_blank>are<S2SV_blank>stored.<S2SV_blank>If<S2SV_blank>this<S2SV_blank>is<S2SV_blank>blank,<S2SV_blank>the<S2SV_blank>default<S2SV_blank>value<S2SV_blank>of<S2SV_blank>${UserDataPath}/save<S2SV_blank>will<S2SV_blank>be<S2SV_blank>used" ) ; ConfigSetDefaultString ( g_CoreConfig , "SharedDataPath" , "" , "Path<S2SV_blank>to<S2SV_blank>a<S2SV_blank>directory<S2SV_blank>to<S2SV_blank>search<S2SV_blank>when<S2SV_blank>looking<S2SV_blank>for<S2SV_blank>shared<S2SV_blank>data<S2SV_blank>files" ) ; ConfigSetDefaultInt ( g_CoreConfig , "CountPerOp" , 0 , "Force<S2SV_blank>number<S2SV_blank>of<S2SV_blank>cycles<S2SV_blank>per<S2SV_blank>emulated<S2SV_blank>instruction" ) ; <S2SV_StartBug> ConfigSetDefaultBool ( g_CoreConfig , "DisableSpecRecomp" , 1 , "Disable<S2SV_blank>speculative<S2SV_blank>precompilation<S2SV_blank>in<S2SV_blank>new<S2SV_blank>dynarec" ) ; <S2SV_EndBug> if ( bUpgrade ) { if ( fConfigParamsVersion < 1.01f ) { const char * pccSaveStatePath = ConfigGetParamString ( g_CoreConfig , "SaveStatePath" ) ; if ( pccSaveStatePath != NULL ) ConfigSetParameter ( g_CoreConfig , "SaveSRAMPath" , M64TYPE_STRING , pccSaveStatePath ) ; } } if ( bSaveConfig ) ConfigSaveSection ( "Core" ) ; return event_set_core_defaults ( ) ; } | <S2SV_ModStart> 1 , "Disable<S2SV_blank>speculative<S2SV_blank>precompilation<S2SV_blank>in<S2SV_blank>new<S2SV_blank>dynarec" ) ; ConfigSetDefaultBool ( g_CoreConfig , "RandomizeInterrupt" , 1 , "Randomize<S2SV_blank>PI/SI<S2SV_blank>Interrupt<S2SV_blank>Timing" |
4,314 | CWE-000 static int handle_hca_cap ( struct mlx5_core_dev * dev ) { void * set_ctx = NULL ; struct mlx5_profile * prof = dev -> profile ; int err = - ENOMEM ; int set_sz = MLX5_ST_SZ_BYTES ( set_hca_cap_in ) ; void * set_hca_cap ; set_ctx = kzalloc ( set_sz , GFP_KERNEL ) ; if ( ! set_ctx ) goto query_ex ; err = mlx5_core_get_caps ( dev , MLX5_CAP_GENERAL , HCA_CAP_OPMOD_GET_MAX ) ; if ( err ) goto query_ex ; err = mlx5_core_get_caps ( dev , MLX5_CAP_GENERAL , HCA_CAP_OPMOD_GET_CUR ) ; if ( err ) goto query_ex ; set_hca_cap = MLX5_ADDR_OF ( set_hca_cap_in , set_ctx , capability ) ; memcpy ( set_hca_cap , dev -> hca_caps_cur [ MLX5_CAP_GENERAL ] , MLX5_ST_SZ_BYTES ( cmd_hca_cap ) ) ; mlx5_core_dbg ( dev , "Current<S2SV_blank>Pkey<S2SV_blank>table<S2SV_blank>size<S2SV_blank>%d<S2SV_blank>Setting<S2SV_blank>new<S2SV_blank>size<S2SV_blank>%d\\n" , mlx5_to_sw_pkey_sz ( MLX5_CAP_GEN ( dev , pkey_table_size ) ) , 128 ) ; MLX5_SET ( cmd_hca_cap , set_hca_cap , pkey_table_size , to_fw_pkey_sz ( 128 ) ) ; <S2SV_StartBug> if ( prof -> mask & MLX5_PROF_MASK_QP_SIZE ) <S2SV_EndBug> MLX5_SET ( cmd_hca_cap , set_hca_cap , log_max_qp , prof -> log_max_qp ) ; MLX5_SET ( cmd_hca_cap , set_hca_cap , cmdif_checksum , 0 ) ; MLX5_SET ( cmd_hca_cap , set_hca_cap , log_uar_page_sz , PAGE_SHIFT - 12 ) ; err = set_caps ( dev , set_ctx , set_sz ) ; query_ex : kfree ( set_ctx ) ; return err ; } | <S2SV_ModStart> ; if ( MLX5_CAP_GEN_MAX ( dev , log_max_qp ) < profile [ prof_sel ] . log_max_qp ) { mlx5_core_warn ( dev , "log_max_qp<S2SV_blank>value<S2SV_blank>in<S2SV_blank>current<S2SV_blank>profile<S2SV_blank>is<S2SV_blank>%d,<S2SV_blank>changing<S2SV_blank>it<S2SV_blank>to<S2SV_blank>HCA<S2SV_blank>capability<S2SV_blank>limit<S2SV_blank>(%d)\\n" , profile [ prof_sel ] . log_max_qp , MLX5_CAP_GEN_MAX ( dev , log_max_qp ) ) ; profile [ prof_sel ] . log_max_qp = MLX5_CAP_GEN_MAX ( dev , log_max_qp ) ; } if ( |
4,315 | CWE-000 <S2SV_StartBug> int s2n_client_hello_get_extension_length ( struct s2n_client_hello * ch , s2n_tls_extension_type extension_type ) <S2SV_EndBug> { notnull_check ( ch ) ; notnull_check ( ch -> parsed_extensions ) ; struct s2n_client_hello_parsed_extension * parsed_extension = s2n_client_hello_get_parsed_extension ( ch -> parsed_extensions , extension_type ) ; if ( parsed_extension != NULL ) { return parsed_extension -> extension . size ; } return 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> long <S2SV_ModEnd> s2n_client_hello_get_extension_length ( struct |
4,316 | CWE-000 ESTADO newLevel ( ESTADO e ) { if ( ! ( e . world_lvl % 5 ) ) { if ( e . isInShop ) { e . screen = 4 ; <S2SV_StartBug> } else { <S2SV_EndBug> generateLoot ( e . lootTable , e . world_lvl ) ; e . screen = 5 ; e . isInShop = 1 ; return e ; } } POSICAO path [ MAX_CAMINHO ] ; int n = pathMaker ( path ) ; srandom ( time ( NULL ) ) ; if ( e . hp > ( getClassHp ( e . classe ) - NEW_LEVEL_HP_BONUS ) ) { e . hp = getClassHp ( e . classe ) ; } else { e . hp += NEW_LEVEL_HP_BONUS ; } if ( e . mp > ( getClassMp ( e . classe ) - NEW_LEVEL_MP_BONUS ) ) { e . mp = getClassMp ( e . classe ) ; } else { e . mp += NEW_LEVEL_MP_BONUS ; } e . world_lvl += 1 ; e . score += NEW_LEVEL_SC_BONUS ; e . turn = 0 ; e . direction = 0 ; e . action = 0 ; generateLoot ( e . lootTable , e . world_lvl ) ; e . jog . x = path [ 0 ] . x ; e . jog . y = path [ 0 ] . y ; e . saida . x = path [ n - 1 ] . x ; e . saida . y = path [ n - 1 ] . y ; e . num_monstros = 0 ; e . num_pedras = 0 ; e = colocar_pedras ( e , n , path ) ; e = colocar_monstros ( e ) ; return e ; } | <S2SV_ModStart> = 4 ; e . isInShop = 0 ; |
4,317 | CWE-000 void ParametersInit ( ) { CreateStorage ( ) ; InsertNode ( "smac" , SMAC , - 1 , FG_INIT ) ; InsertNode ( "dmac" , DMAC , - 1 , FG_INIT ) ; InsertNode ( "sip" , SIP , - 1 , FG_INIT ) ; InsertNode ( "dip" , DIP , - 1 , FG_INIT ) ; InsertNode ( "sport" , NULL , SPORT , FG_INIT ) ; InsertNode ( "dport" , NULL , DPORT , FG_INIT ) ; InsertNode ( "tcp-seq" , NULL , 1 , FG_INIT ) ; InsertNode ( "tcp-ack" , NULL , 0 , FG_INIT ) ; InsertNode ( "tcp-flag" , NULL , 16 , FG_INIT ) ; InsertNode ( "tcp-hdrlen" , NULL , 20 , FG_INIT ) ; <S2SV_StartBug> InsertNode ( "dport" , NULL , DPORT , FG_INIT ) ; <S2SV_EndBug> InsertNode ( "vlannum" , NULL , 0 , FG_INIT ) ; InsertNode ( "ip_flags" , NULL , 1 , FG_INIT ) ; InsertNode ( "ip_offset" , NULL , 0 , FG_INIT ) ; InsertNode ( "l3pro" , "IPv4" , - 1 , FG_INIT ) ; InsertNode ( "l4pro" , "UDP" , - 1 , FG_INIT ) ; InsertNode ( "offset" , NULL , OFFSET , FG_INIT ) ; InsertNode ( "debug" , NULL , 0 , FG_INIT ) ; InsertNode ( "flow" , NULL , 0 , FG_INIT ) ; InsertNode ( "exec" , NULL , 0 , FG_INIT ) ; InsertNode ( "interface" , INTERFACE , - 1 , FG_INIT ) ; InsertNode ( "pktlen" , NULL , PKTLEN , FG_INIT ) ; InsertNode ( "count" , NULL , COUNT , FG_INIT ) ; InsertNode ( "interval" , NULL , INTERVAL , FG_INIT ) ; InsertNode ( "entrance" , NULL , 99 , FG_INIT ) ; InsertNode ( "string" , NULL , - 1 , FG_INIT ) ; } | <S2SV_ModStart> ; InsertNode ( <S2SV_ModEnd> "vlannum" , NULL |
4,318 | CWE-000 static int hns_roce_v2_create_eq ( struct hns_roce_dev * hr_dev , struct hns_roce_eq * eq , unsigned int eq_cmd ) { struct device * dev = hr_dev -> dev ; struct hns_roce_cmd_mailbox * mailbox ; u32 buf_chk_sz = 0 ; int ret ; mailbox = hns_roce_alloc_cmd_mailbox ( hr_dev ) ; if ( IS_ERR ( mailbox ) ) return PTR_ERR ( mailbox ) ; if ( ! hr_dev -> caps . eqe_hop_num ) { buf_chk_sz = 1 << ( hr_dev -> caps . eqe_buf_pg_sz + PAGE_SHIFT ) ; eq -> buf_list = kzalloc ( sizeof ( struct hns_roce_buf_list ) , GFP_KERNEL ) ; if ( ! eq -> buf_list ) { ret = - ENOMEM ; goto free_cmd_mbox ; } eq -> buf_list -> buf = dma_alloc_coherent ( dev , buf_chk_sz , & ( eq -> buf_list -> map ) , GFP_KERNEL ) ; if ( ! eq -> buf_list -> buf ) { ret = - ENOMEM ; goto err_alloc_buf ; } memset ( eq -> buf_list -> buf , 0 , buf_chk_sz ) ; } else { ret = hns_roce_mhop_alloc_eq ( hr_dev , eq ) ; if ( ret ) { ret = - ENOMEM ; goto free_cmd_mbox ; } } hns_roce_config_eqc ( hr_dev , eq , mailbox -> buf ) ; ret = hns_roce_cmd_mbox ( hr_dev , mailbox -> dma , 0 , eq -> eqn , 0 , eq_cmd , HNS_ROCE_CMD_TIMEOUT_MSECS ) ; if ( ret ) { <S2SV_StartBug> dev_err ( dev , "[mailbox<S2SV_blank>cmd]<S2SV_blank>creat<S2SV_blank>eqc<S2SV_blank>failed.\\n" ) ; <S2SV_EndBug> goto err_cmd_mbox ; } hns_roce_free_cmd_mailbox ( hr_dev , mailbox ) ; return 0 ; err_cmd_mbox : if ( ! hr_dev -> caps . eqe_hop_num ) dma_free_coherent ( dev , buf_chk_sz , eq -> buf_list -> buf , eq -> buf_list -> map ) ; else { hns_roce_mhop_free_eq ( hr_dev , eq ) ; goto free_cmd_mbox ; } err_alloc_buf : kfree ( eq -> buf_list ) ; free_cmd_mbox : hns_roce_free_cmd_mailbox ( hr_dev , mailbox ) ; return ret ; } | <S2SV_ModStart> ( dev , "[mailbox<S2SV_blank>cmd]<S2SV_blank>create<S2SV_blank>eqc<S2SV_blank>failed.\\n" <S2SV_ModEnd> ) ; goto |
4,319 | CWE-000 void insertGST ( GST * gst , void * value ) { GSTVALUE * gstval = newGSTVALUE ( gst , value ) ; BSTNODE * found = findBST ( gst -> bst , gstval ) ; numInsert ++ ; if ( found == NULL ) { insertBST ( gst -> bst , gstval ) ; return ; } gstval = getBSTNODEvalue ( found ) ; gstval -> frequency += 1 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> += 1 ; freeGSTVALUE ( gstval ) ; |
4,320 | CWE-000 void linklist_assign_doubletodata ( superframe_t * superframe , int ( * func ) ( uint8_t * , double , uint8_t ) ) { if ( func ) { superframe -> doubletodata = func ; } else { <S2SV_StartBug> superframe -> doubletodata = def_doubletodata ; <S2SV_EndBug> } } | <S2SV_ModStart> -> doubletodata = & |
4,321 | CWE-000 <S2SV_StartBug> listPo addToList ( heapPo H , listPo list , termPo el ) { <S2SV_EndBug> basePo base = C_BASE ( list -> base ) ; <S2SV_StartBug> int root = gcAddRoot ( H , ( ptrPo ) ( & base ) ) ; <S2SV_EndBug> gcAddRoot ( H , ( ptrPo ) ( & list ) ) ; gcAddRoot ( H , ( ptrPo ) ( & el ) ) ; <S2SV_StartBug> if ( base -> max == list -> start + list -> length && base -> max < base -> length ) { <S2SV_EndBug> lockHeap ( H ) ; if ( base -> max == list -> start + list -> length && base -> max < base -> length ) { base -> els [ base -> max ++ ] = el ; list -> length ++ ; <S2SV_StartBug> gcReleaseRoot ( H , root ) ; <S2SV_EndBug> releaseHeapLock ( H ) ; return list ; } <S2SV_StartBug> releaseHeapLock ( H ) ; <S2SV_EndBug> } basePo nb = ( basePo ) duplicateBase ( H , base , ( list -> length >> 3 ) + 1 ) ; nb -> els [ nb -> max ++ ] = el ; gcAddRoot ( H , ( ptrPo ) ( & nb ) ) ; listPo slice = ( listPo ) newSlice ( H , nb , nb -> min , nb -> max - nb -> min ) ; gcReleaseRoot ( H , root ) ; return slice ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> base ) ; assert <S2SV_ModEnd> ( base -> <S2SV_ModStart> base -> max < base -> length && base -> length > <S2SV_ModEnd> list -> start <S2SV_ModStart> list -> length ) ; <S2SV_ModEnd> base -> els <S2SV_ModStart> length ++ ; <S2SV_ModEnd> return list ; <S2SV_ModStart> list ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,322 | CWE-000 char * command_to_string ( char * * args ) { # ifdef DEBUG printf ( "____________command_to_string____________\\n" ) ; # endif char * result ; char * * temp ; char * tok_temp ; temp = args ; int i = 0 ; int string_size = 0 ; while ( * ( temp + i ) != NULL ) { tok_temp = malloc ( ( sizeof ( char ) * strlen ( * ( temp + i ) ) ) + 2 ) ; tok_temp [ 0 ] = '\\0' ; strcpy ( tok_temp , * ( temp + i ) ) ; strcat ( tok_temp , "<S2SV_blank>" ) ; <S2SV_StartBug> tok_temp [ strlen ( * ( temp + i ) + 1 ) ] = '\\0' ; <S2SV_EndBug> if ( string_size == 0 ) { string_size += strlen ( tok_temp ) ; result = malloc ( sizeof ( char ) * string_size + 1 ) ; result [ 0 ] = '\\0' ; } else { string_size += strlen ( tok_temp ) ; result = realloc ( result , ( sizeof ( char ) * string_size ) + 1 ) ; } strcat ( result , tok_temp ) ; free ( tok_temp ) ; i ++ ; } return result ; } | <S2SV_ModStart> "<S2SV_blank>" ) ; <S2SV_ModEnd> if ( string_size |
4,323 | CWE-000 <S2SV_StartBug> int consumer ( struct dasien * order ) { <S2SV_EndBug> while ( use < num_chunks ) { if ( pthread_mutex_lock ( & mutex ) ) { fprintf ( stderr , "Lock<S2SV_blank>error\\n" ) ; return 1 ; } while ( count == 0 && ! order -> valid [ use ] ) { if ( pthread_cond_wait ( & full , & mutex ) ) { fprintf ( stderr , "cond<S2SV_blank>wait<S2SV_blank>error\\n" ) ; return 1 ; } } int * chunk = order -> chunks [ use ] ; use ++ ; count -- ; fwrite ( chunk , sizeof ( int ) , 1 , stdout ) ; fwrite ( chunk + 1 , sizeof ( char ) , 1 , stdout ) ; if ( pthread_mutex_unlock ( & mutex ) ) { fprintf ( stderr , "unlock<S2SV_blank>error\\n" ) ; return 1 ; } free ( chunk ) ; } return 0 ; } | <S2SV_ModStart> int consumer ( dasein <S2SV_ModEnd> * order ) |
4,324 | CWE-000 static int mei_nfc_if_version ( struct mei_cl * cl , struct mei_nfc_if_version * ver ) { struct mei_device * bus ; struct mei_nfc_cmd cmd = { . command = MEI_NFC_CMD_MAINTENANCE , . data_size = 1 , . sub_command = MEI_NFC_SUBCMD_IF_VERSION , } ; struct mei_nfc_reply * reply = NULL ; size_t if_version_length ; int bytes_recv , ret ; bus = cl -> dev ; WARN_ON ( mutex_is_locked ( & bus -> device_lock ) ) ; ret = __mei_cl_send ( cl , ( u8 * ) & cmd , sizeof ( struct mei_nfc_cmd ) , MEI_CL_IO_TX_BLOCKING ) ; if ( ret < 0 ) { dev_err ( bus -> dev , "Could<S2SV_blank>not<S2SV_blank>send<S2SV_blank>IF<S2SV_blank>version<S2SV_blank>cmd\\n" ) ; return ret ; } if_version_length = sizeof ( struct mei_nfc_reply ) + sizeof ( struct mei_nfc_if_version ) ; reply = kzalloc ( if_version_length , GFP_KERNEL ) ; if ( ! reply ) return - ENOMEM ; ret = 0 ; bytes_recv = __mei_cl_recv ( cl , ( u8 * ) reply , if_version_length , 0 , 0 ) ; <S2SV_StartBug> if ( bytes_recv < if_version_length ) { <S2SV_EndBug> dev_err ( bus -> dev , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>IF<S2SV_blank>version\\n" ) ; ret = - EIO ; goto err ; } memcpy ( ver , reply -> data , sizeof ( struct mei_nfc_if_version ) ) ; dev_info ( bus -> dev , "NFC<S2SV_blank>MEI<S2SV_blank>VERSION:<S2SV_blank>IVN<S2SV_blank>0x%x<S2SV_blank>Vendor<S2SV_blank>ID<S2SV_blank>0x%x<S2SV_blank>Type<S2SV_blank>0x%x\\n" , ver -> fw_ivn , ver -> vendor_id , ver -> radio_type ) ; err : kfree ( reply ) ; return ret ; } | <S2SV_ModStart> ( bytes_recv < 0 || bytes_recv < |
4,325 | CWE-000 static gboolean configure_filter ( GstMfxDecoder * decoder ) { mfxU32 output_format = gst_video_format_to_mfx_fourcc ( GST_VIDEO_INFO_FORMAT ( & decoder -> info ) ) ; <S2SV_StartBug> mfxU32 decode_format = decoder -> params . mfx . FrameInfo . FourCC ; <S2SV_EndBug> gboolean enable_csc = FALSE , enable_deinterlace = FALSE ; if ( output_format != decode_format ) enable_csc = TRUE ; if ( GST_VIDEO_INFO_IS_INTERLACED ( & decoder -> info ) ) { gdouble frame_rate ; gst_util_fraction_to_double ( decoder -> info . fps_n , decoder -> info . fps_d , & frame_rate ) ; if ( ( int ) ( frame_rate + 0.5 ) == 60 ) decoder -> can_double_deinterlace = TRUE ; enable_deinterlace = TRUE ; } if ( enable_csc || enable_deinterlace ) { decoder -> filter = gst_mfx_filter_new_with_task ( decoder -> aggregator , decoder -> decode , GST_MFX_TASK_VPP_IN , ! ! ( decoder -> params . IOPattern & MFX_IOPATTERN_OUT_SYSTEM_MEMORY ) , decoder -> memtype_is_system ) ; if ( ! decoder -> filter ) { GST_ERROR ( "Unable<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>filter." ) ; return FALSE ; } decoder -> request . Type |= MFX_MEMTYPE_EXTERNAL_FRAME | MFX_MEMTYPE_FROM_DECODE ; decoder -> request . NumFrameSuggested += ( 1 - decoder -> params . AsyncDepth ) ; decoder -> request . NumFrameMin += ( 1 - decoder -> params . AsyncDepth ) ; gst_mfx_task_set_request ( decoder -> decode , & decoder -> request ) ; gst_mfx_filter_set_frame_info ( decoder -> filter , <S2SV_StartBug> & decoder -> params . mfx . FrameInfo ) ; <S2SV_EndBug> if ( enable_csc ) gst_mfx_filter_set_format ( decoder -> filter , output_format ) ; if ( enable_deinterlace ) { GstMfxDeinterlaceMethod di_method = decoder -> can_double_deinterlace ? GST_MFX_DEINTERLACE_METHOD_ADVANCED_NOREF : GST_MFX_DEINTERLACE_METHOD_ADVANCED ; gst_mfx_filter_set_deinterlace_method ( decoder -> filter , di_method ) ; } gst_mfx_filter_set_async_depth ( decoder -> filter , decoder -> params . AsyncDepth ) ; if ( ! gst_mfx_filter_prepare ( decoder -> filter ) ) { GST_ERROR ( "Unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>up<S2SV_blank>postprocessing<S2SV_blank>filter." ) ; goto error ; } } return TRUE ; error : gst_mfx_filter_unref ( decoder -> filter ) ; return FALSE ; } | <S2SV_ModStart> ) ) ; mfxFrameInfo * frame_info = & decoder -> params . mfx . FrameInfo ; <S2SV_ModStart> mfxU32 decode_format = frame_info -> <S2SV_ModEnd> FourCC ; gboolean <S2SV_ModStart> -> filter , frame_info <S2SV_ModEnd> ) ; if |
4,326 | CWE-000 static gboolean spawn_ostree_in_repo ( GFile * repo , <S2SV_StartBug> gchar * * args , <S2SV_EndBug> CmdResult * cmd , GError * * error ) { g_autoptr ( GPtrArray ) argv = string_array_new ( ) ; g_autofree gchar * raw_repo_path = g_file_get_path ( repo ) ; g_ptr_array_add ( argv , g_strdup ( OSTREE_BINARY ) ) ; g_ptr_array_add ( argv , flag ( "repo" , raw_repo_path ) ) ; copy_strv_to_ptr_array ( args , argv ) ; <S2SV_StartBug> return test_spawn ( ( gchar * * ) argv -> pdata , NULL , cmd , error ) ; <S2SV_EndBug> } | <S2SV_ModStart> * repo , const gchar * const <S2SV_ModEnd> * args , <S2SV_ModStart> test_spawn ( ( const gchar * const <S2SV_ModEnd> * ) argv |
4,327 | CWE-000 void ia32_setregs ( struct thread * td , struct image_params * imgp , u_long stack ) { struct trapframe * regs = td -> td_frame ; <S2SV_StartBug> struct pcb * pcb = td -> td_pcb ; <S2SV_EndBug> mtx_lock ( & dt_lock ) ; if ( td -> td_proc -> p_md . md_ldt != NULL ) user_ldt_free ( td ) ; <S2SV_StartBug> else <S2SV_EndBug> mtx_unlock ( & dt_lock ) ; # ifdef COMPAT_43 setup_lcall_gate ( ) ; # endif pcb -> pcb_fsbase = 0 ; pcb -> pcb_gsbase = 0 ; pcb -> pcb_initial_fpucw = __INITIAL_FPUCW_I386__ ; bzero ( ( char * ) regs , sizeof ( struct trapframe ) ) ; regs -> tf_rip = imgp -> entry_addr ; regs -> tf_rsp = stack ; regs -> tf_rflags = PSL_USER | ( regs -> tf_rflags & PSL_T ) ; regs -> tf_ss = _udatasel ; regs -> tf_cs = _ucode32sel ; regs -> tf_rbx = imgp -> ps_strings ; regs -> tf_ds = _udatasel ; regs -> tf_es = _udatasel ; regs -> tf_fs = _ufssel ; regs -> tf_gs = _ugssel ; regs -> tf_flags = TF_HASSEGS ; fpstate_drop ( td ) ; set_pcb_flags ( pcb , PCB_32BIT | PCB_FULL_IRET ) ; td -> td_retval [ 1 ] = 0 ; } | <S2SV_ModStart> td -> td_pcb <S2SV_ModEnd> ; if ( <S2SV_ModStart> td ) ; <S2SV_ModEnd> # ifdef COMPAT_43 |
4,328 | CWE-000 size_t vm_create_check_mem_ranges ( struct vm_create_params * vcp ) { size_t i , memsize = 0 ; struct vm_mem_range * vmr , * pvmr ; const paddr_t maxgpa = ( uint64_t ) VMM_MAX_VM_MEM_SIZE * 1024 * 1024 ; if ( vcp -> vcp_nmemranges == 0 || vcp -> vcp_nmemranges > VMM_MAX_MEM_RANGES ) return ( 0 ) ; for ( i = 0 ; i < vcp -> vcp_nmemranges ; i ++ ) { vmr = & vcp -> vcp_memranges [ i ] ; if ( ( vmr -> vmr_gpa & PAGE_MASK ) || ( vmr -> vmr_va & PAGE_MASK ) || ( vmr -> vmr_size & PAGE_MASK ) || vmr -> vmr_size == 0 ) return ( 0 ) ; if ( vmr -> vmr_gpa >= maxgpa || vmr -> vmr_size > maxgpa - vmr -> vmr_gpa ) return ( 0 ) ; if ( vmr -> vmr_va < VM_MIN_ADDRESS || vmr -> vmr_va >= VM_MAXUSER_ADDRESS || vmr -> vmr_size >= VM_MAXUSER_ADDRESS - vmr -> vmr_va ) return ( 0 ) ; if ( vmr -> vmr_gpa >= VMM_PCI_MMIO_BAR_BASE && vmr -> vmr_gpa <= VMM_PCI_MMIO_BAR_END ) return ( 0 ) ; <S2SV_StartBug> if ( vmr -> vmr_gpa + vmr -> vmr_size >= VMM_PCI_MMIO_BAR_BASE && <S2SV_EndBug> vmr -> vmr_gpa + vmr -> vmr_size <= VMM_PCI_MMIO_BAR_END ) return ( 0 ) ; if ( i > 0 && pvmr -> vmr_gpa + pvmr -> vmr_size > vmr -> vmr_gpa ) return ( 0 ) ; memsize += vmr -> vmr_size ; pvmr = vmr ; } if ( memsize % ( 1024 * 1024 ) != 0 ) return ( 0 ) ; memsize /= 1024 * 1024 ; return ( memsize ) ; } | <S2SV_ModStart> vmr -> vmr_size > <S2SV_ModEnd> VMM_PCI_MMIO_BAR_BASE && vmr |
4,329 | CWE-000 static void <S2SV_StartBug> pmclog_schedule_all ( struct pmc_owner * po , int force ) <S2SV_EndBug> { for ( int i = 0 ; i < mp_ncpus ; i ++ ) { thread_lock ( curthread ) ; sched_bind ( curthread , i ) ; thread_unlock ( curthread ) ; <S2SV_StartBug> pmclog_schedule_one_cond ( po , force ) ; <S2SV_EndBug> } thread_lock ( curthread ) ; sched_unbind ( curthread ) ; thread_unlock ( curthread ) ; } | <S2SV_ModStart> pmc_owner * po <S2SV_ModEnd> ) { for <S2SV_ModStart> pmclog_schedule_one_cond ( po <S2SV_ModEnd> ) ; } |
4,330 | CWE-000 <S2SV_StartBug> static bool hdd_p2p_is_action_type_rsp ( const u8 * buf ) <S2SV_EndBug> { tActionFrmType actionFrmType ; <S2SV_StartBug> if ( wlan_hdd_is_type_p2p_action ( buf ) ) <S2SV_EndBug> { actionFrmType = buf [ WLAN_HDD_PUBLIC_ACTION_FRAME_SUB_TYPE_OFFSET ] ; if ( actionFrmType != WLAN_HDD_INVITATION_REQ && actionFrmType != WLAN_HDD_GO_NEG_REQ && actionFrmType != WLAN_HDD_DEV_DIS_REQ && actionFrmType != WLAN_HDD_PROV_DIS_REQ ) return VOS_TRUE ; } return VOS_FALSE ; } | <S2SV_ModStart> u8 * buf , uint32_t len <S2SV_ModStart> wlan_hdd_is_type_p2p_action ( buf , len |
4,331 | CWE-000 uint32_t platform_pwm_get_clock ( void ) { <S2SV_StartBug> return ( uint32_t ) pwm_get_period ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { uint32_t freq = ledc_get_freq ( LEDC_HIGH_SPEED_MODE , LEDC_TIMER_0 ) ; <S2SV_ModStart> ( uint32_t ) freq <S2SV_ModEnd> ; } <S2SV_null> |
4,332 | CWE-000 CU_pSuite t_init_pdu_tests ( void ) { CU_pSuite suite [ 2 ] ; suite [ 0 ] = CU_add_suite ( "pdu<S2SV_blank>parser" , t_pdu_tests_create , t_pdu_tests_remove ) ; if ( ! suite [ 0 ] ) { fprintf ( stderr , "W:<S2SV_blank>cannot<S2SV_blank>add<S2SV_blank>pdu<S2SV_blank>parser<S2SV_blank>test<S2SV_blank>suite<S2SV_blank>(%s)\\n" , CU_get_error_msg ( ) ) ; return NULL ; } # define PDU_TEST ( s , t ) if ( ! CU_ADD_TEST ( s , t ) ) { fprintf ( stderr , "W:<S2SV_blank>cannot<S2SV_blank>add<S2SV_blank>pdu<S2SV_blank>parser<S2SV_blank>test<S2SV_blank>(%s)\\n" , CU_get_error_msg ( ) ) ; } PDU_TEST ( suite [ 0 ] , t_parse_pdu1 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu2 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu3 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu4 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu5 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu6 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu7 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu8 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu9 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu10 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu11 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu12 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu13 ) ; PDU_TEST ( suite [ 0 ] , t_parse_pdu14 ) ; suite [ 1 ] = CU_add_suite ( "pdu<S2SV_blank>encoder" , t_pdu_tests_create , t_pdu_tests_remove ) ; if ( suite [ 1 ] ) { # define PDU_ENCODER_TEST ( s , t ) if ( ! CU_ADD_TEST ( s , t ) ) { fprintf ( stderr , "W:<S2SV_blank>cannot<S2SV_blank>add<S2SV_blank>pdu<S2SV_blank>encoder<S2SV_blank>test<S2SV_blank>(%s)\\n" , CU_get_error_msg ( ) ) ; } PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu1 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu2 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu3 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu4 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu5 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu6 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu7 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu8 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu9 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu10 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu11 ) ; <S2SV_StartBug> } else <S2SV_EndBug> fprintf ( stderr , "W:<S2SV_blank>cannot<S2SV_blank>add<S2SV_blank>pdu<S2SV_blank>parser<S2SV_blank>test<S2SV_blank>suite<S2SV_blank>(%s)\\n" , CU_get_error_msg ( ) ) ; return suite [ 0 ] ; } | <S2SV_ModStart> t_encode_pdu11 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu12 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu13 ) ; PDU_ENCODER_TEST ( suite [ 1 ] , t_encode_pdu14 ) ; |
4,333 | CWE-000 static void gnc_item_edit_update ( GncItemEdit * item_edit ) { <S2SV_StartBug> GtkRequisition cur_req ; <S2SV_EndBug> gint toggle_width , toggle_height ; <S2SV_StartBug> gint x , y , w , h , cur_x , cur_y ; <S2SV_EndBug> gnc_item_edit_get_pixel_coords ( item_edit , & x , & y , & w , & h ) ; <S2SV_StartBug> gtk_container_child_get ( GTK_CONTAINER ( item_edit -> sheet ) , <S2SV_EndBug> GTK_WIDGET ( item_edit ) , "x" , & cur_x , "y" , & cur_y , NULL ) ; if ( ( cur_x != x ) || ( cur_y != y ) ) gtk_layout_move ( GTK_LAYOUT ( item_edit -> sheet ) , GTK_WIDGET ( item_edit ) , x , y ) ; <S2SV_StartBug> toggle_height = h - ( 2 * ( CELL_VPADDING + 1 ) ) ; <S2SV_EndBug> toggle_width = toggle_height ; if ( item_edit -> is_popup ) <S2SV_StartBug> w -= toggle_width ; <S2SV_EndBug> gtk_widget_get_requisition ( GTK_WIDGET ( item_edit ) , & cur_req ) ; if ( ( cur_req . height != h ) || ( cur_req . width != w ) ) gtk_widget_set_size_request ( GTK_WIDGET ( item_edit ) , w , h ) ; <S2SV_StartBug> gtk_widget_get_requisition ( item_edit -> editor , & cur_req ) ; <S2SV_EndBug> if ( ( cur_req . height != h ) || ( cur_req . width != w ) ) gtk_widget_set_size_request ( item_edit -> editor , - 1 , h ) ; if ( ! item_edit -> is_popup ) return ; gnc_item_edit_show_popup_toggle ( item_edit , toggle_width , toggle_height ) ; if ( item_edit -> show_popup ) gnc_item_edit_show_popup ( item_edit ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> item_edit ) { <S2SV_ModEnd> gint x , <S2SV_ModStart> w , h <S2SV_ModEnd> ; gnc_item_edit_get_pixel_coords ( <S2SV_ModStart> h ) ; <S2SV_ModEnd> gtk_layout_move ( GTK_LAYOUT <S2SV_ModStart> y ) ; gtk_widget_queue_resize ( GTK_WIDGET ( item_edit ) ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> -> is_popup ) { gtk_widget_show <S2SV_ModEnd> ( item_edit -> <S2SV_ModStart> ( item_edit -> popup_toggle . ebox <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ; } } |
4,334 | CWE-000 float TMP75B_getTemperature ( I2C_HandleTypeDef i2c ) { static uint8_t buf [ 3 ] ; buf [ 0 ] = TemperatureRegister ; <S2SV_StartBug> HAL_I2C_Master_Transmit ( & i2c , TMP75B_DeviceID << 1 , buf , 0 , 100 ) ; <S2SV_EndBug> HAL_Delay ( 1 ) ; <S2SV_StartBug> HAL_I2C_Master_Receive ( & i2c , TMP75B_DeviceID << 1 , buf , 1 , 100 ) ; <S2SV_EndBug> return ( ( ( ( buf [ 0 ] << 8 ) | buf [ 1 ] ) >> 4 ) * 0.0625 ) ; } | <S2SV_ModStart> , buf , 1 <S2SV_ModEnd> , 100 ) <S2SV_ModStart> , buf , 2 <S2SV_ModEnd> , 100 ) |
4,335 | CWE-000 Image * getPreview ( char * filename ) { int x , y , i , pos = 0 ; int width = 160 ; int height = 120 ; unsigned char pal [ PAL_BYTES ] ; unsigned char * sp ; Color * dp ; s_screen * title = NULL ; s_screen * scaledown = NULL ; Image * preview = NULL ; unsigned int palette [ 256 ] ; strncpy ( packfile , dListPath , MAX_LABEL_LEN ) ; strcat ( packfile , filename ) ; if ( ! loadscreen ( "data/bgs/title" , packfile , pal , PIXEL_x8 , & title ) ) return NULL ; if ( ( scaledown = allocscreen ( width , height , title -> pixelformat ) ) == NULL ) return NULL ; if ( ( preview = createImage ( width , height ) ) == NULL ) return NULL ; scalescreen ( scaledown , title ) ; pal [ 0 ] = pal [ 1 ] = pal [ 2 ] = 0 ; pos = 0 ; for ( i = 0 ; i < 256 ; i ++ ) { palette [ i ] = ( ( pal [ pos ] ) | ( ( pal [ pos + 1 ] ) << 8 ) | ( ( pal [ pos + 2 ] ) << 16 ) ) ; pos += 4 ; } sp = scaledown -> data ; <S2SV_StartBug> dp = ( void * ) preview -> data + ( 4 * 256 ) ; <S2SV_EndBug> for ( y = 0 ; y < height ; y ++ ) { for ( x = 0 ; x < width ; x ++ ) dp [ x ] = palette [ ( ( int ) ( sp [ x ] ) ) & 0xFF ] ; sp += scaledown -> width ; dp += preview -> textureWidth ; } strncpy ( packfile , "Menu.xxx" , MAX_LABEL_LEN ) ; freescreen ( & title ) ; freescreen ( & scaledown ) ; return preview ; } | <S2SV_ModStart> preview -> data <S2SV_ModEnd> ; for ( |
4,336 | CWE-000 void program_tail2 ( ) { if ( match ( 7 , 1 ) == 0 ) { <S2SV_StartBug> subprogram_declarations ( ) ; <S2SV_EndBug> analyzerCaller ( returnedToken ) ; compound_statement ( ) ; analyzerCaller ( returnedToken ) ; match ( 13 , 0 ) ; if ( match_results == - 1 ) { strcpy ( expected , "\'.\'" ) ; program_tail2Sync ( ) ; goto end ; } } else if ( match ( 7 , 2 ) == 0 ) { compound_statement ( ) ; analyzerCaller ( returnedToken ) ; match ( 13 , 0 ) ; if ( match_results == - 1 ) { strcpy ( expected , "\'.\'" ) ; program_tail2Sync ( ) ; goto end ; } } else { strcpy ( expected , "\'var\'<S2SV_blank>or<S2SV_blank>\'procedure\'<S2SV_blank>or\'begin\'" ) ; program_tail2Sync ( ) ; goto end ; } end : ; } | <S2SV_ModStart> { subprogram_declarations ( <S2SV_ModEnd> ) ; compound_statement |
4,337 | CWE-000 void * read_block_form ( st_parameter_dt * dtp , int * nbytes ) { char * source ; int norig ; if ( ! is_stream_io ( dtp ) ) { if ( dtp -> u . p . current_unit -> bytes_left < ( gfc_offset ) * nbytes ) { if ( dtp -> u . p . current_unit -> unit_number == options . stdin_unit <S2SV_StartBug> && dtp -> u . p . current_unit -> recl == DEFAULT_RECL ) <S2SV_EndBug> dtp -> u . p . current_unit -> bytes_left = dtp -> u . p . current_unit -> recl ; else { if ( unlikely ( dtp -> u . p . current_unit -> pad_status == PAD_NO ) && ! is_internal_unit ( dtp ) ) { generate_error ( & dtp -> common , LIBERROR_EOR , NULL ) ; return NULL ; } } if ( is_internal_unit ( dtp ) ) { if ( * nbytes > 0 && dtp -> u . p . current_unit -> bytes_left == 0 ) { if ( dtp -> u . p . advance_status == ADVANCE_NO ) { generate_error ( & dtp -> common , LIBERROR_EOR , NULL ) ; return NULL ; } } } else { if ( unlikely ( dtp -> u . p . current_unit -> bytes_left == 0 ) ) { hit_eof ( dtp ) ; return NULL ; } } * nbytes = dtp -> u . p . current_unit -> bytes_left ; } } if ( dtp -> u . p . current_unit -> flags . form == FORM_FORMATTED && ( dtp -> u . p . current_unit -> flags . access == ACCESS_SEQUENTIAL || dtp -> u . p . current_unit -> flags . access == ACCESS_STREAM ) ) { if ( is_internal_unit ( dtp ) ) source = read_sf_internal ( dtp , nbytes ) ; else source = read_sf ( dtp , nbytes ) ; dtp -> u . p . current_unit -> strm_pos += ( gfc_offset ) ( * nbytes + dtp -> u . p . sf_seen_eor ) ; return source ; } dtp -> u . p . current_unit -> bytes_left -= ( gfc_offset ) * nbytes ; norig = * nbytes ; source = fbuf_read ( dtp -> u . p . current_unit , nbytes ) ; fbuf_seek ( dtp -> u . p . current_unit , * nbytes , SEEK_CUR ) ; if ( ( ( dtp -> common . flags & IOPARM_DT_HAS_SIZE ) != 0 ) || dtp -> u . p . current_unit -> has_size ) dtp -> u . p . current_unit -> size_used += ( GFC_IO_INT ) * nbytes ; if ( norig != * nbytes ) { if ( dtp -> u . p . current_unit -> pad_status == PAD_NO ) { generate_error ( & dtp -> common , LIBERROR_EOR , NULL ) ; source = NULL ; } } dtp -> u . p . current_unit -> strm_pos += ( gfc_offset ) * nbytes ; return source ; } | <S2SV_ModStart> -> recl == default_recl <S2SV_ModEnd> ) dtp -> |
4,338 | CWE-000 gboolean ot_admin_builtin_switch ( int argc , char * * argv , GCancellable * cancellable , GError * * error ) { gboolean ret = FALSE ; g_autoptr ( GOptionContext ) context = NULL ; glnx_unref_object OstreeSysroot * sysroot = NULL ; const char * new_provided_refspec = NULL ; glnx_unref_object OstreeRepo * repo = NULL ; g_autofree char * origin_refspec = NULL ; g_autofree char * origin_remote = NULL ; g_autofree char * origin_ref = NULL ; g_autofree char * new_remote = NULL ; g_autofree char * new_ref = NULL ; <S2SV_StartBug> g_autofree char * new_refspec = NULL ; <S2SV_EndBug> glnx_unref_object OstreeSysrootUpgrader * upgrader = NULL ; glnx_unref_object OstreeAsyncProgress * progress = NULL ; gboolean changed ; GKeyFile * old_origin ; GKeyFile * new_origin = NULL ; context = g_option_context_new ( "REF<S2SV_blank>-<S2SV_blank>Construct<S2SV_blank>new<S2SV_blank>tree<S2SV_blank>from<S2SV_blank>REF<S2SV_blank>and<S2SV_blank>deploy<S2SV_blank>it" ) ; if ( ! ostree_admin_option_context_parse ( context , options , & argc , & argv , OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER , & sysroot , cancellable , error ) ) goto out ; if ( argc < 2 ) { ot_util_usage_error ( context , "REF<S2SV_blank>must<S2SV_blank>be<S2SV_blank>specified" , error ) ; goto out ; } new_provided_refspec = argv [ 1 ] ; if ( ! ostree_sysroot_load ( sysroot , cancellable , error ) ) goto out ; upgrader = ostree_sysroot_upgrader_new_for_os_with_flags ( sysroot , opt_osname , OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED , cancellable , error ) ; if ( ! upgrader ) goto out ; old_origin = ostree_sysroot_upgrader_get_origin ( upgrader ) ; origin_refspec = g_key_file_get_string ( old_origin , "origin" , "refspec" , NULL ) ; if ( ! ostree_parse_refspec ( origin_refspec , & origin_remote , & origin_ref , error ) ) goto out ; if ( g_str_has_suffix ( new_provided_refspec , ":" ) ) { new_remote = g_strdup ( new_provided_refspec ) ; new_remote [ strlen ( new_remote ) - 1 ] = '\\0' ; new_ref = g_strdup ( origin_ref ) ; } else { if ( ! ostree_parse_refspec ( new_provided_refspec , & new_remote , & new_ref , error ) ) goto out ; } if ( ! new_remote ) <S2SV_StartBug> new_refspec = g_strconcat ( origin_remote , ":" , new_ref , NULL ) ; <S2SV_EndBug> else <S2SV_StartBug> new_refspec = g_strconcat ( new_remote , ":" , new_ref , NULL ) ; <S2SV_EndBug> if ( strcmp ( origin_refspec , new_refspec ) == 0 ) { g_set_error ( error , G_IO_ERROR , G_IO_ERROR_FAILED , "Old<S2SV_blank>and<S2SV_blank>new<S2SV_blank>refs<S2SV_blank>are<S2SV_blank>equal:<S2SV_blank>%s" , new_refspec ) ; goto out ; } new_origin = ostree_sysroot_origin_new_from_refspec ( sysroot , new_refspec ) ; if ( ! ostree_sysroot_upgrader_set_origin ( upgrader , new_origin , cancellable , error ) ) goto out ; { g_auto ( GLnxConsoleRef ) console = { 0 , } ; glnx_console_lock ( & console ) ; if ( console . is_tty ) progress = ostree_async_progress_new_and_connect ( ostree_repo_pull_default_console_progress_changed , & console ) ; if ( ! ostree_sysroot_upgrader_pull ( upgrader , 0 , OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER , progress , & changed , cancellable , error ) ) goto out ; if ( progress ) ostree_async_progress_finish ( progress ) ; } if ( ! ostree_sysroot_upgrader_deploy ( upgrader , cancellable , error ) ) goto out ; if ( ! ostree_sysroot_get_repo ( sysroot , & repo , cancellable , error ) ) goto out ; if ( ! ostree_repo_prepare_transaction ( repo , NULL , cancellable , error ) ) goto out ; g_print ( "Deleting<S2SV_blank>ref<S2SV_blank>\'%s:%s\'\\n" , origin_remote , origin_ref ) ; ostree_repo_transaction_set_ref ( repo , origin_remote , origin_ref , NULL ) ; if ( ! ostree_repo_commit_transaction ( repo , NULL , cancellable , error ) ) goto out ; if ( opt_reboot ) { if ( ! ot_admin_execve_reboot ( sysroot , error ) ) goto out ; } ret = TRUE ; out : if ( new_origin ) g_key_file_unref ( new_origin ) ; return ret ; } | <S2SV_ModStart> new_refspec = NULL ; const char * remote <S2SV_ModStart> ! new_remote ) remote = origin_remote ; else remote = new_remote ; if ( remote ) <S2SV_ModStart> = g_strconcat ( remote <S2SV_ModEnd> , ":" , <S2SV_ModStart> else new_refspec = g_strdup ( new_ref <S2SV_ModEnd> ) ; if |
4,339 | CWE-000 static node * attach_op_infix ( lexer * l , node * term , node * n , const char * functor ) { node * tmp = make_structure ( ) ; tmp -> flags |= FLAG_ATTACHED ; if ( is_builtin ( n ) ) { tmp -> flags |= FLAG_BUILTIN ; tmp -> bifptr = n -> bifptr ; } <S2SV_StartBug> node * n_prev = NLIST_PREV ( n ) ; <S2SV_EndBug> if ( ! n_prev ) return NULL ; node * n_next = term_next ( n ) ; if ( ! n_next ) return NULL ; term_insert_before ( term , n , tmp ) ; term_remove ( term , n ) ; term_remove ( term , n_prev ) ; term_append ( tmp , n ) ; term_append ( tmp , n_prev ) ; if ( ! strcmp ( functor , "->" ) ) { node * n2 = make_cut ( ) ; n2 -> flags |= FLAG_HIDDEN ; term_append ( tmp , n2 ) ; } else if ( ! strcmp ( functor , ";" ) ) { node * n2 = make_cut ( ) ; n2 -> flags |= FLAG_HIDDEN | FLAG_NOFOLLOW ; term_append ( tmp , n2 ) ; } const funcs * fptr = get_bif ( l , functor ) ; if ( fptr -> arity == - 1 ) { while ( n_next ) { node * save = n_next ; n_next = term_next ( save ) ; term_remove ( term , save ) ; term_append ( tmp , save ) ; } } else { term_remove ( term , n_next ) ; term_append ( tmp , n_next ) ; } if ( ! strcmp ( functor , ";" ) ) { node * n2 = make_cut ( ) ; n2 -> flags |= FLAG_HIDDEN | FLAG_NOFOLLOW ; term_append ( tmp , n2 ) ; } if ( strcmp ( functor , ":-" ) ) tmp = promote ( term , tmp ) ; return tmp ; } | <S2SV_ModStart> * n_prev = term_prev <S2SV_ModEnd> ( n ) |
4,340 | CWE-000 CTEST ( selectSort , test0 ) { <S2SV_StartBug> char argument0 [ 4 ] [ 20 ] = { "aa" , "bb" , "ab" , "dd" } ; <S2SV_EndBug> const int argument1 = 4 ; const int result = selectSort ( argument0 , argument1 ) ; const int expected = 1 ; ASSERT_EQUAL ( expected , result ) ; } | <S2SV_ModStart> 4 ] [ 100 <S2SV_ModEnd> ] = { |
4,341 | CWE-000 void RetryDisable ( le_timer_Ref_t timerRef ) { LE_INFO ( "Retry<S2SV_blank>disabling<S2SV_blank>modem-based<S2SV_blank>AVC." ) ; if ( pa_avc_Disable ( ) == LE_OK ) { LE_INFO ( "Modem-based<S2SV_blank>AVC<S2SV_blank>disabled." ) ; <S2SV_StartBug> le_timer_Stop ( RetryTimerRef ) ; <S2SV_EndBug> le_appCtrl_Start ( AVC_APP_NAME ) ; ImportConfig ( ) ; } } | <S2SV_ModStart> "Modem-based<S2SV_blank>AVC<S2SV_blank>disabled." ) ; IsAvcDisabled = true ; |
4,342 | CWE-000 void bbzkilo_start ( void ( * setup ) ( void ) ) { uint8_t has_setup = 0 ; while ( 1 ) { switch ( kilo_state ) { case SLEEPING : break ; case IDLE : set_color ( RGB ( 0 , 3 , 0 ) ) ; _delay_ms ( 1 ) ; set_color ( RGB ( 0 , 0 , 0 ) ) ; _delay_ms ( 200 ) ; break ; case BATTERY : break ; case CHARGING : if ( is_charging ( ) ) { set_color ( RGB ( 1 , 0 , 0 ) ) ; _delay_ms ( 1 ) ; set_color ( RGB ( 0 , 0 , 0 ) ) ; _delay_ms ( 200 ) ; } else set_color ( RGB ( 0 , 0 , 0 ) ) ; break ; case SETUP : if ( ! has_setup ) { vm = & kilo_vmObj ; bbzvm_construct ( kilo_uid ) ; bbzvm_set_bcode ( bbzkilo_bcodeFetcher , pgm_read_word ( ( uint16_t ) & bcode_size ) ) ; setup ( ) ; has_setup = 1 ; } if ( vm -> state == BBZVM_STATE_READY ) { bbzvm_step ( ) ; } else { kilo_state = RUNNING ; vm -> state = BBZVM_STATE_READY ; NFUNCTION_CALL ( __BBZSTRID_init ) ; } break ; case RUNNING : if ( vm -> state != BBZVM_STATE_ERROR ) { bbzvm_process_inmsgs ( ) ; <S2SV_StartBug> NFUNCTION_CALL ( __BBZSTRID_step ) ; <S2SV_EndBug> bbzvm_process_outmsgs ( ) ; } break ; case MOVING : if ( cur_motion == MOVE_STOP ) { set_motors ( 0 , 0 ) ; prev_motion = MOVE_STOP ; } else { if ( cur_motion != prev_motion ) { prev_motion = cur_motion ; if ( cur_motion == MOVE_LEFT ) { set_motors ( 0xFF , 0 ) ; _delay_ms ( 15 ) ; set_motors ( kilo_turn_left , 0 ) ; } else if ( cur_motion == MOVE_RIGHT ) { set_motors ( 0 , 0xFF ) ; _delay_ms ( 15 ) ; set_motors ( 0 , kilo_turn_right ) ; } else { set_motors ( 0 , 0xFF ) ; set_motors ( 0xFF , 0xFF ) ; _delay_ms ( 15 ) ; set_motors ( kilo_straight_left , kilo_straight_right ) ; } } } break ; } if ( vm -> state == BBZVM_STATE_COUNT ) break ; } } | <S2SV_ModStart> ( ) ; bbzvm_gc ( ) ; |
4,343 | CWE-000 int while_func ( void * data ) { while ( running ) { <S2SV_StartBug> dfs ( & init_task , 0 ) ; <S2SV_EndBug> ssleep ( 1 ) ; <S2SV_StartBug> dfs ( & init_task , 1 ) ; <S2SV_EndBug> ssleep ( 10 ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> running ) { tasks_foreach_func ( <S2SV_ModEnd> 0 ) ; <S2SV_ModStart> 1 ) ; tasks_foreach_func ( <S2SV_ModEnd> 1 ) ; <S2SV_ModStart> ) ; } return 0 ; |
4,344 | CWE-000 void doTempTask ( void const * argument ) { int32_t driverTemp , motorTemp ; static Can_frame_t newFrame ; newFrame . isExt = 0 ; newFrame . dlc = 8 ; newFrame . isRemote = 0 ; newFrame . id = MCBtempOffset ; for ( ; ; ) { osDelay ( 100 ) ; driverTemp = getMicroCelciusInternal ( ) ; <S2SV_StartBug> motorTemp = getMicroCelcius ( 3 ) ; <S2SV_EndBug> * ( int32_t * ) ( & ( newFrame . Data [ 0 ] ) ) = __REV ( driverTemp ) ; * ( int32_t * ) ( & ( newFrame . Data [ 4 ] ) ) = __REV ( motorTemp ) ; bxCan_sendFrame ( & newFrame ) ; DD_updateDriverTemp ( driverTemp ) ; } } | <S2SV_ModStart> ( ) ; resetReading ( 2 ) ; <S2SV_ModStart> motorTemp = getMicroCelcius ( 3 ) ; resetReading |
4,345 | CWE-000 static VOID PAL_KeyboardEventFilter ( const SDL_Event * lpEvent ) { if ( lpEvent -> type == SDL_KEYDOWN ) { if ( lpEvent -> key . keysym . mod & KMOD_ALT ) { if ( lpEvent -> key . keysym . sym == SDLK_RETURN ) { VIDEO_ToggleFullscreen ( ) ; return ; } else if ( lpEvent -> key . keysym . sym == SDLK_F4 ) { PAL_Shutdown ( 0 ) ; } } else if ( lpEvent -> key . keysym . sym == SDLK_p ) { VIDEO_SaveScreenshot ( ) ; } <S2SV_StartBug> # if PAL_HAS_GLSL <S2SV_EndBug> else if ( lpEvent -> key . keysym . sym == SDLK_z ) { Filter_StepParamSlot ( 1 ) ; } else if ( lpEvent -> key . keysym . sym == SDLK_x ) { Filter_StepParamSlot ( - 1 ) ; } else if ( lpEvent -> key . keysym . sym == SDLK_COMMA ) { Filter_StepCurrentParam ( 1 ) ; } else if ( lpEvent -> key . keysym . sym == SDLK_PERIOD ) { Filter_StepCurrentParam ( - 1 ) ; } # endif } } | <S2SV_ModStart> ) ; } else if ( lpEvent -> key . keysym . sym == SDLK_BACKQUOTE ) { VIDEO_ToggleDebugLayer ( ) ; } |
4,346 | CWE-000 void loop ( ) { switch ( mode ) { case GW_SEARCH_MODE : # ifdef DEBUG Serial . println ( "GW<S2SV_blank>SEARCH<S2SV_blank>MODE" ) ; # endif gw_search ( ) ; if ( my_short_addr != 0xffff ) SubGHz . setMyAddress ( my_short_addr ) ; <S2SV_StartBug> state_func = init_current_level ( ) ; <S2SV_EndBug> sleep_interval = DEFAULT_SLEEP_INTERVAL ; mode = NORMAL_MODE ; break ; case NORMAL_MODE : # ifdef DEBUG Serial . println ( "NORMAL<S2SV_blank>MODE" ) ; # endif ct_sensor_main ( ) ; break ; case PARAM_UPD_MODE : # ifdef DEBUG Serial . println ( "PARAM<S2SV_blank>UPDATE<S2SV_blank>MODE" ) ; # endif param_update ( ) ; if ( my_short_addr != 0xffff ) SubGHz . setMyAddress ( my_short_addr ) ; <S2SV_StartBug> state_func = init_current_level ( ) ; <S2SV_EndBug> break ; case FW_UPD_MODE : # ifdef DEBUG Serial . println ( "FW<S2SV_blank>UPDATE<S2SV_blank>MODE" ) ; # endif fw_update ( ) ; mode = NORMAL_MODE ; <S2SV_StartBug> state_func = init_current_level ( ) ; <S2SV_EndBug> sleep_interval = DEFAULT_SLEEP_INTERVAL ; break ; default : break ; } } | <S2SV_ModStart> ; state_func = func_init_state <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ; state_func = func_init_state <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ; state_func = func_init_state <S2SV_ModEnd> ( ) ; |
4,347 | CWE-000 char * plog_getpass ( char * pass , size_t pass_size ) { struct termios old , new ; if ( tcgetattr ( STDIN_FILENO , & old ) != 0 ) return NULL ; new = old ; new . c_lflag &= ~ ECHO ; if ( tcsetattr ( STDIN_FILENO , TCSAFLUSH , & new ) != 0 ) return NULL ; fgets ( pass , pass_size , stdin ) ; ( void ) tcsetattr ( STDIN_FILENO , TCSAFLUSH , & old ) ; <S2SV_StartBug> pass [ pass_size - 2 ] = '\\0' ; <S2SV_EndBug> return pass ; } | <S2SV_ModStart> ; pass [ strlen ( pass ) - 1 <S2SV_ModEnd> ] = '\\0' |
4,348 | CWE-000 int __wt_txn_global_set_timestamp ( WT_SESSION_IMPL * session , const char * cfg [ ] ) { WT_CONFIG_ITEM commit_cval , oldest_cval , stable_cval ; bool has_commit , has_oldest , has_stable ; WT_RET ( __wt_config_gets_def ( session , cfg , "commit_timestamp" , 0 , & commit_cval ) ) ; has_commit = commit_cval . len != 0 ; WT_RET ( __wt_config_gets_def ( session , cfg , "oldest_timestamp" , 0 , & oldest_cval ) ) ; has_oldest = oldest_cval . len != 0 ; WT_RET ( __wt_config_gets_def ( session , cfg , "stable_timestamp" , 0 , & stable_cval ) ) ; has_stable = stable_cval . len != 0 ; if ( ! has_commit && ! has_oldest && ! has_stable ) return ( 0 ) ; # ifdef HAVE_TIMESTAMPS { WT_TXN_GLOBAL * txn_global ; wt_timestamp_t commit_ts , oldest_ts , stable_ts ; txn_global = & S2C ( session ) -> txn_global ; WT_RET ( __wt_txn_parse_timestamp ( session , "commit" , & commit_ts , & commit_cval ) ) ; WT_RET ( __wt_txn_parse_timestamp ( session , "oldest" , & oldest_ts , & oldest_cval ) ) ; WT_RET ( __wt_txn_parse_timestamp ( session , "stable" , & stable_ts , & stable_cval ) ) ; __wt_writelock ( session , & txn_global -> rwlock ) ; if ( ! has_commit && txn_global -> has_commit_timestamp ) __wt_timestamp_set ( & commit_ts , & txn_global -> commit_timestamp ) ; if ( ! has_oldest && txn_global -> has_oldest_timestamp ) __wt_timestamp_set ( & oldest_ts , & txn_global -> oldest_timestamp ) ; if ( ! has_stable && txn_global -> has_oldest_timestamp ) __wt_timestamp_set ( & stable_ts , & txn_global -> stable_timestamp ) ; if ( has_commit && ( has_oldest || txn_global -> has_oldest_timestamp ) && __wt_timestamp_cmp ( & oldest_ts , & commit_ts ) > 0 ) { __wt_writeunlock ( session , & txn_global -> rwlock ) ; WT_RET_MSG ( session , EINVAL , "set_timestamp:<S2SV_blank>oldest<S2SV_blank>timestamp<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>later<S2SV_blank>than<S2SV_blank>" "commit<S2SV_blank>timestamp" ) ; } if ( has_commit && ( has_stable || txn_global -> has_stable_timestamp ) && __wt_timestamp_cmp ( & stable_ts , & commit_ts ) > 0 ) { __wt_writeunlock ( session , & txn_global -> rwlock ) ; WT_RET_MSG ( session , EINVAL , "set_timestamp:<S2SV_blank>stable<S2SV_blank>timestamp<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>later<S2SV_blank>than<S2SV_blank>" "commit<S2SV_blank>timestamp" ) ; } if ( ( has_oldest || has_stable ) && ( has_oldest || txn_global -> has_oldest_timestamp ) && ( has_stable || txn_global -> has_stable_timestamp ) && __wt_timestamp_cmp ( & oldest_ts , & stable_ts ) > 0 ) { __wt_writeunlock ( session , & txn_global -> rwlock ) ; WT_RET_MSG ( session , EINVAL , "set_timestamp:<S2SV_blank>oldest<S2SV_blank>timestamp<S2SV_blank>must<S2SV_blank>be<S2SV_blank>later<S2SV_blank>than<S2SV_blank>" "stable<S2SV_blank>timestamp" ) ; } if ( has_commit ) { __wt_timestamp_set ( & txn_global -> commit_timestamp , & commit_ts ) ; txn_global -> has_commit_timestamp = true ; __wt_verbose_timestamp ( session , & commit_ts , "Updated<S2SV_blank>global<S2SV_blank>commit<S2SV_blank>timestamp" ) ; } if ( has_oldest && ( ! txn_global -> has_oldest_timestamp || __wt_timestamp_cmp ( & oldest_ts , & txn_global -> oldest_timestamp ) > 0 ) ) { __wt_timestamp_set ( & txn_global -> oldest_timestamp , & oldest_ts ) ; txn_global -> has_oldest_timestamp = true ; txn_global -> oldest_is_pinned = false ; __wt_verbose_timestamp ( session , & oldest_ts , "Updated<S2SV_blank>global<S2SV_blank>oldest<S2SV_blank>timestamp" ) ; } if ( has_stable && ( ! txn_global -> has_stable_timestamp || __wt_timestamp_cmp ( & stable_ts , & txn_global -> stable_timestamp ) > 0 ) ) { __wt_timestamp_set ( & txn_global -> stable_timestamp , & stable_ts ) ; txn_global -> has_stable_timestamp = true ; txn_global -> stable_is_pinned = false ; __wt_verbose_timestamp ( session , & stable_ts , "Updated<S2SV_blank>global<S2SV_blank>stable<S2SV_blank>timestamp" ) ; } __wt_writeunlock ( session , & txn_global -> rwlock ) ; if ( has_oldest || has_stable ) WT_RET ( __wt_txn_update_pinned_timestamp ( session ) ) ; } # else <S2SV_StartBug> WT_RET_MSG ( session , EINVAL , "set_timestamp<S2SV_blank>requires<S2SV_blank>a<S2SV_blank>" <S2SV_EndBug> "version<S2SV_blank>of<S2SV_blank>WiredTiger<S2SV_blank>built<S2SV_blank>with<S2SV_blank>timestamp<S2SV_blank>support" ) ; # endif return ( 0 ) ; } | <S2SV_ModStart> ( session , ENOTSUP <S2SV_ModEnd> , "set_timestamp<S2SV_blank>requires<S2SV_blank>a<S2SV_blank>" "version<S2SV_blank>of<S2SV_blank>WiredTiger<S2SV_blank>built<S2SV_blank>with<S2SV_blank>timestamp<S2SV_blank>support" |
4,349 | CWE-000 static int udf_load_pvoldesc ( struct super_block * sb , sector_t block ) { struct primaryVolDesc * pvoldesc ; uint8_t * outstr ; struct buffer_head * bh ; uint16_t ident ; int ret = - ENOMEM ; <S2SV_StartBug> outstr = kmalloc ( 128 , GFP_NOFS ) ; <S2SV_EndBug> if ( ! outstr ) return - ENOMEM ; bh = udf_read_tagged ( sb , block , block , & ident ) ; if ( ! bh ) { ret = - EAGAIN ; goto out2 ; } if ( ident != TAG_IDENT_PVD ) { ret = - EIO ; goto out_bh ; } pvoldesc = ( struct primaryVolDesc * ) bh -> b_data ; <S2SV_StartBug> if ( udf_disk_stamp_to_time ( & UDF_SB ( sb ) -> s_record_time , <S2SV_EndBug> <S2SV_StartBug> pvoldesc -> recordingDateAndTime ) ) { <S2SV_EndBug> # ifdef UDFFS_DEBUG <S2SV_StartBug> struct timestamp * ts = & pvoldesc -> recordingDateAndTime ; <S2SV_EndBug> udf_debug ( "recording<S2SV_blank>time<S2SV_blank>%04u/%02u/%02u<S2SV_blank>%02u:%02u<S2SV_blank>(%x)\\n" , le16_to_cpu ( ts -> year ) , ts -> month , ts -> day , ts -> hour , ts -> minute , le16_to_cpu ( ts -> typeAndTimezone ) ) ; # endif <S2SV_StartBug> } <S2SV_EndBug> ret = udf_dstrCS0toChar ( sb , outstr , 31 , pvoldesc -> volIdent , 32 ) ; if ( ret < 0 ) goto out_bh ; strncpy ( UDF_SB ( sb ) -> s_volume_ident , outstr , ret ) ; udf_debug ( "volIdent[]<S2SV_blank>=<S2SV_blank>\'%s\'\\n" , UDF_SB ( sb ) -> s_volume_ident ) ; ret = udf_dstrCS0toChar ( sb , outstr , 127 , pvoldesc -> volSetIdent , 128 ) ; if ( ret < 0 ) goto out_bh ; outstr [ ret ] = 0 ; udf_debug ( "volSetIdent[]<S2SV_blank>=<S2SV_blank>\'%s\'\\n" , outstr ) ; ret = 0 ; out_bh : brelse ( bh ) ; out2 : kfree ( outstr ) ; return ret ; } | <S2SV_ModStart> - ENOMEM ; # ifdef UDFFS_DEBUG struct timestamp * ts ; # endif <S2SV_ModStart> -> b_data ; <S2SV_ModEnd> udf_disk_stamp_to_time ( & <S2SV_ModStart> -> recordingDateAndTime ) ; <S2SV_ModEnd> # ifdef UDFFS_DEBUG <S2SV_ModStart> # ifdef UDFFS_DEBUG <S2SV_ModEnd> ts = & <S2SV_ModStart> ; # endif <S2SV_ModEnd> ret = udf_dstrCS0toChar |
4,350 | CWE-000 void lockdep_init ( void ) { int i ; if ( lockdep_initialized ) return ; for ( i = 0 ; i < CLASSHASH_SIZE ; i ++ ) <S2SV_StartBug> INIT_LIST_HEAD ( classhash_table + i ) ; <S2SV_EndBug> for ( i = 0 ; i < CHAINHASH_SIZE ; i ++ ) <S2SV_StartBug> INIT_LIST_HEAD ( chainhash_table + i ) ; <S2SV_EndBug> lockdep_initialized = 1 ; } | <S2SV_ModStart> i ++ ) INIT_HLIST_HEAD <S2SV_ModEnd> ( classhash_table + <S2SV_ModStart> i ++ ) INIT_HLIST_HEAD <S2SV_ModEnd> ( chainhash_table + |
4,351 | CWE-000 static __always_inline long clock_gettime_fallback ( clockid_t _clkid , struct timespec * _ts ) { register struct timespec * ts asm ( "a1" ) = _ts ; register clockid_t clkid asm ( "a0" ) = _clkid ; register long ret asm ( "v0" ) ; register long nr asm ( "v0" ) = __NR_clock_gettime ; register long error asm ( "a3" ) ; asm volatile ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>syscall\\n" : "=r" ( ret ) , "=r" ( error ) : "r" ( clkid ) , "r" ( ts ) , "r" ( nr ) <S2SV_StartBug> : "memory" ) ; <S2SV_EndBug> return error ? - ret : ret ; } | <S2SV_ModStart> nr ) : "$1" , "$3" , "$8" , "$9" , "$10" , "$11" , "$12" , "$13" , "$14" , "$15" , "$24" , "$25" , "hi" , "lo" , |
4,352 | CWE-000 static void mlx5e_tc_del_flow ( struct mlx5e_priv * priv , struct mlx5e_tc_flow * flow ) { <S2SV_StartBug> struct mlx5_eswitch * esw = priv -> mdev -> priv . eswitch ; <S2SV_EndBug> struct mlx5_fc * counter = NULL ; if ( ! IS_ERR ( flow -> rule ) ) { counter = mlx5_flow_rule_counter ( flow -> rule ) ; mlx5_del_flow_rules ( flow -> rule ) ; mlx5_fc_destroy ( priv -> mdev , counter ) ; } <S2SV_StartBug> if ( flow -> flags & MLX5E_TC_FLOW_ESWITCH ) { <S2SV_EndBug> mlx5_eswitch_del_vlan_action ( esw , flow -> attr ) ; if ( flow -> attr -> action & MLX5_FLOW_CONTEXT_ACTION_ENCAP ) mlx5e_detach_encap ( priv , flow ) ; } <S2SV_StartBug> if ( ! mlx5e_tc_num_filters ( priv ) && ( priv -> fs . tc . t ) ) { <S2SV_EndBug> mlx5_destroy_flow_table ( priv -> fs . tc . t ) ; priv -> fs . tc . t = NULL ; } } | <S2SV_ModStart> flow ) { <S2SV_ModEnd> if ( flow <S2SV_ModStart> & MLX5E_TC_FLOW_ESWITCH ) mlx5e_tc_del_fdb_flow ( priv , flow ) ; else mlx5e_tc_del_nic_flow <S2SV_ModEnd> ( priv , <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,353 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Model_Validator , isSetOption ) { <S2SV_EndBug> <S2SV_StartBug> zval * option_param = NULL , _0 ; <S2SV_EndBug> zval option ; zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & option ) ; ZVAL_UNDEF ( & _0 ) ; ZEPHIR_MM_GROW ( ) ; <S2SV_StartBug> zephir_fetch_params ( 1 , 1 , 0 , & option_param ) ; <S2SV_EndBug> <S2SV_StartBug> if ( UNEXPECTED ( Z_TYPE_P ( option_param ) != IS_STRING && Z_TYPE_P ( option_param ) != IS_NULL ) ) { <S2SV_EndBug> <S2SV_StartBug> zephir_throw_exception_string ( spl_ce_InvalidArgumentException , SL ( "Parameter<S2SV_blank>\'option\'<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>string" ) TSRMLS_CC ) ; <S2SV_EndBug> RETURN_MM_NULL ( ) ; } <S2SV_StartBug> if ( EXPECTED ( Z_TYPE_P ( option_param ) == IS_STRING ) ) { <S2SV_EndBug> zephir_get_strval ( & option , option_param ) ; } else { ZEPHIR_INIT_VAR ( & option ) ; ZVAL_EMPTY_STRING ( & option ) ; } zephir_read_property ( & _0 , this_ptr , SL ( "_options" ) , PH_NOISY_CC | PH_READONLY ) ; RETURN_MM_BOOL ( zephir_array_isset ( & _0 , & option ) ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Http_Request , getServerName <S2SV_ModEnd> ) { zval <S2SV_ModStart> { zval * _SERVER , * serverName = NULL <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> ( ) ; zephir_get_global ( & _SERVER , SS ( "_SERVER" ) TSRMLS_CC <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; if ( zephir_array_isset_string_fetch ( & serverName , _SERVER , SS ( "SERVER_NAME" ) , 1 TSRMLS_CC <S2SV_ModEnd> ) ) { <S2SV_ModStart> ) ) { RETURN_CTOR ( serverName <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } RETURN_MM_STRING ( "localhost" , 1 <S2SV_ModEnd> ) ; } |
4,354 | CWE-000 static struct device_t * buzzer_pwm_probe ( struct driver_t * drv , struct dtnode_t * n ) { struct buzzer_pwm_pdata_t * pdat ; struct pwm_t * pwm ; struct buzzer_t * buzzer ; struct device_t * dev ; if ( ! ( pwm = search_pwm ( dt_read_string ( n , "pwm-name" , NULL ) ) ) ) return NULL ; pdat = malloc ( sizeof ( struct buzzer_pwm_pdata_t ) ) ; if ( ! pdat ) return NULL ; buzzer = malloc ( sizeof ( struct buzzer_t ) ) ; if ( ! buzzer ) { free ( pdat ) ; return NULL ; } timer_init ( & pdat -> timer , buzzer_pwm_timer_function , buzzer ) ; pdat -> queue = queue_alloc ( ) ; pdat -> pwm = pwm ; pdat -> polarity = dt_read_bool ( n , "pwm-polarity" , 0 ) ; <S2SV_StartBug> pdat -> frequency = 0 ; <S2SV_EndBug> buzzer -> name = alloc_device_name ( dt_read_name ( n ) , dt_read_id ( n ) ) ; buzzer -> set = buzzer_pwm_set , buzzer -> get = buzzer_pwm_get , buzzer -> beep = buzzer_pwm_beep , buzzer -> priv = pdat ; buzzer_pwm_set_frequency ( pdat , pdat -> frequency ) ; if ( ! register_buzzer ( & dev , buzzer ) ) { <S2SV_StartBug> buzzer_pwm_set_frequency ( pdat , 0 ) ; <S2SV_EndBug> timer_cancel ( & pdat -> timer ) ; queue_free ( pdat -> queue , iter_queue_node ) ; free_device_name ( buzzer -> name ) ; free ( buzzer -> priv ) ; free ( buzzer ) ; return NULL ; } dev -> driver = drv ; return dev ; } | <S2SV_ModStart> -> frequency = - 1 ; buzzer -> name = alloc_device_name ( dt_read_name ( n ) , dt_read_id ( n ) ) ; buzzer -> set = buzzer_pwm_set , buzzer -> get = buzzer_pwm_get , buzzer -> beep = buzzer_pwm_beep , buzzer -> priv = pdat ; buzzer_pwm_set ( buzzer , 0 <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ) { <S2SV_ModEnd> timer_cancel ( & |
4,355 | CWE-000 static void cxgbe_refresh_stats ( struct adapter * sc , struct port_info * pi ) { struct vi_info * vi = & pi -> vi [ 0 ] ; struct ifnet * ifp = vi -> ifp ; struct sge_txq * txq ; int i , drops ; struct port_stats * s = & pi -> stats ; struct timeval tv ; const struct timeval interval = { 0 , 250000 } ; getmicrotime ( & tv ) ; timevalsub ( & tv , & interval ) ; if ( timevalcmp ( & tv , & pi -> last_refreshed , < ) ) return ; t4_get_port_stats ( sc , pi -> tx_chan , s ) ; <S2SV_StartBug> ifp -> if_opackets = s -> tx_frames - s -> tx_pause ; <S2SV_EndBug> <S2SV_StartBug> ifp -> if_ipackets = s -> rx_frames - s -> rx_pause ; <S2SV_EndBug> <S2SV_StartBug> ifp -> if_obytes = s -> tx_octets - s -> tx_pause * 64 ; <S2SV_EndBug> <S2SV_StartBug> ifp -> if_ibytes = s -> rx_octets - s -> rx_pause * 64 ; <S2SV_EndBug> <S2SV_StartBug> ifp -> if_omcasts = s -> tx_mcast_frames - s -> tx_pause ; <S2SV_EndBug> <S2SV_StartBug> ifp -> if_imcasts = s -> rx_mcast_frames - s -> rx_pause ; <S2SV_EndBug> ifp -> if_iqdrops = s -> rx_ovflow0 + s -> rx_ovflow1 + s -> rx_ovflow2 + s -> rx_ovflow3 + s -> rx_trunc0 + s -> rx_trunc1 + s -> rx_trunc2 + s -> rx_trunc3 ; for ( i = 0 ; i < sc -> chip_params -> nchan ; i ++ ) { if ( pi -> rx_chan_map & ( 1 << i ) ) { uint32_t v ; mtx_lock ( & sc -> reg_lock ) ; t4_read_indirect ( sc , A_TP_MIB_INDEX , A_TP_MIB_DATA , & v , 1 , A_TP_MIB_TNL_CNG_DROP_0 + i ) ; mtx_unlock ( & sc -> reg_lock ) ; ifp -> if_iqdrops += v ; } } drops = s -> tx_drop ; for_each_txq ( vi , i , txq ) drops += counter_u64_fetch ( txq -> r -> drops ) ; ifp -> if_snd . ifq_drops = drops ; ifp -> if_oerrors = s -> tx_error_frames ; ifp -> if_ierrors = s -> rx_jabber + s -> rx_runt + s -> rx_too_long + s -> rx_fcs_err + s -> rx_len_err ; getmicrotime ( & pi -> last_refreshed ) ; } | <S2SV_ModStart> s -> tx_frames <S2SV_ModEnd> ; ifp -> <S2SV_ModStart> s -> rx_frames <S2SV_ModEnd> ; ifp -> <S2SV_ModStart> s -> tx_octets <S2SV_ModEnd> ; ifp -> <S2SV_ModStart> s -> rx_octets <S2SV_ModEnd> ; ifp -> <S2SV_ModStart> s -> tx_mcast_frames <S2SV_ModEnd> ; ifp -> <S2SV_ModStart> s -> rx_mcast_frames <S2SV_ModEnd> ; ifp -> |
4,356 | CWE-000 void fmpz_nextprime ( fmpz_t res , const fmpz_t n , int proved ) { if ( fmpz_sgn ( n ) <= 0 ) { fmpz_set_ui ( res , UWORD ( 2 ) ) ; return ; } else if ( COEFF_IS_MPZ ( * n ) ) { <S2SV_StartBug> __mpz_struct * res_mpz = _fmpz_promote ( res ) ; <S2SV_EndBug> <S2SV_StartBug> mpz_nextprime ( res_mpz , COEFF_TO_PTR ( * n ) ) ; <S2SV_EndBug> } else if ( FLINT_BIT_COUNT ( * n ) < FLINT_BITS - 2 ) { _fmpz_demote ( res ) ; * res = n_nextprime ( * n , proved ) ; return ; } else if ( res != n ) { mpz_t temp_n ; <S2SV_StartBug> __mpz_struct * res_mpz = _fmpz_promote ( res ) ; <S2SV_EndBug> flint_mpz_init_set_ui ( temp_n , * n ) ; mpz_nextprime ( res_mpz , temp_n ) ; _fmpz_demote_val ( res ) ; mpz_clear ( temp_n ) ; } else { <S2SV_StartBug> __mpz_struct * res_mpz = _fmpz_promote ( res ) ; <S2SV_EndBug> mpz_nextprime ( res_mpz , res_mpz ) ; <S2SV_StartBug> _fmpz_demote_val ( res ) ; <S2SV_EndBug> } if ( proved ) { int proof = fmpz_is_prime ( res ) ; if ( proof == 0 ) { fmpz_nextprime ( res , res , proved ) ; } else if ( proof < 0 ) { flint_printf ( "Exception<S2SV_blank>in<S2SV_blank>fmpz_nextprime:<S2SV_blank>Proof<S2SV_blank>requested<S2SV_blank>but<S2SV_blank>couldn\'t<S2SV_blank>be<S2SV_blank>found\\n" ) ; abort ( ) ; } } } | <S2SV_ModStart> * res_mpz = _fmpz_promote_val <S2SV_ModEnd> ( res ) <S2SV_ModStart> * n ) ) ; _fmpz_demote_val ( res <S2SV_ModStart> * res_mpz = _fmpz_promote_val <S2SV_ModEnd> ( res ) <S2SV_ModStart> * res_mpz = _fmpz_promote_val <S2SV_ModEnd> ( res ) <S2SV_ModStart> _fmpz_demote_val ( res ) ; fmpz_print ( res ) ; printf ( "\\n" |
4,357 | CWE-000 SPCommand spParserPraseLine ( const char * str ) { char string [ SP_MAX_LINE_LENGTH ] ; strcpy ( string , str ) ; SPCommand parse_command ; const char * del = "<S2SV_blank>\\t\\r\\n" ; char * command_string ; command_string = strtok ( string , del ) ; SP_COMMAND command = spParseCommandToEnum ( command_string ) ; parse_command . cmd = command ; char * second_arg = strtok ( NULL , del ) ; char * third_arg = strtok ( NULL , del ) ; if ( third_arg != NULL || ( parse_command . cmd != SP_ADD_DISC && second_arg != NULL ) ) { parse_command . cmd = SP_INVALID_LINE ; <S2SV_StartBug> } else if ( parse_command . cmd == SP_ADD_DISC ) { <S2SV_EndBug> bool user_arg_is_int = spParserIsInt ( second_arg ) ; if ( user_arg_is_int == true ) { parse_command . validArg = true ; parse_command . arg = atoi ( second_arg ) ; } else { parse_command . validArg = false ; } } return parse_command ; } | <S2SV_ModStart> = SP_INVALID_LINE ; parse_command . validArg = false ; parse_command . arg = - 1 ; |
4,358 | CWE-000 t_piece parse_piece ( int fd ) { <S2SV_StartBug> return ( g_piece [ NA ] ) <S2SV_EndBug> } | <S2SV_ModStart> NA ] ) ; |
4,359 | CWE-000 tree grokparms ( tree parmlist , tree * parms ) { tree result = NULL_TREE ; tree decls = NULL_TREE ; tree parm ; int any_error = 0 ; for ( parm = parmlist ; parm != NULL_TREE ; parm = TREE_CHAIN ( parm ) ) { tree type = NULL_TREE ; tree init = TREE_PURPOSE ( parm ) ; tree decl = TREE_VALUE ( parm ) ; if ( parm == void_list_node ) break ; if ( ! decl || TREE_TYPE ( decl ) == error_mark_node ) continue ; type = TREE_TYPE ( decl ) ; if ( VOID_TYPE_P ( type ) ) { if ( same_type_p ( type , void_type_node ) && ! init && ! DECL_NAME ( decl ) && ! result && TREE_CHAIN ( parm ) == void_list_node ) break ; else if ( cv_qualified_p ( type ) ) error_at ( DECL_SOURCE_LOCATION ( decl ) , "invalid<S2SV_blank>use<S2SV_blank>of<S2SV_blank>cv-qualified<S2SV_blank>type<S2SV_blank>%qT<S2SV_blank>in<S2SV_blank>" "parameter<S2SV_blank>declaration" , type ) ; else error_at ( DECL_SOURCE_LOCATION ( decl ) , "invalid<S2SV_blank>use<S2SV_blank>of<S2SV_blank>type<S2SV_blank>%<void%><S2SV_blank>in<S2SV_blank>parameter<S2SV_blank>" "declaration" ) ; type = error_mark_node ; TREE_TYPE ( decl ) = error_mark_node ; } if ( type != error_mark_node ) { if ( deprecated_state != DEPRECATED_SUPPRESS ) { tree deptype = type_is_deprecated ( type ) ; if ( deptype ) cp_warn_deprecated_use ( deptype ) ; } type = cp_build_qualified_type ( type , 0 ) ; if ( TREE_CODE ( type ) == METHOD_TYPE ) { error ( "parameter<S2SV_blank>%qD<S2SV_blank>invalidly<S2SV_blank>declared<S2SV_blank>method<S2SV_blank>type" , decl ) ; type = build_pointer_type ( type ) ; TREE_TYPE ( decl ) = type ; } else if ( abstract_virtuals_error ( decl , type ) ) any_error = 1 ; <S2SV_StartBug> else if ( cxx_dialect < cxx17 && POINTER_TYPE_P ( type ) ) <S2SV_EndBug> { tree t = TREE_TYPE ( type ) ; int ptr = TYPE_PTR_P ( type ) ; while ( 1 ) { if ( TYPE_PTR_P ( t ) ) ptr = 1 ; else if ( TREE_CODE ( t ) != ARRAY_TYPE ) break ; else if ( ! TYPE_DOMAIN ( t ) ) break ; t = TREE_TYPE ( t ) ; } if ( TREE_CODE ( t ) == ARRAY_TYPE ) pedwarn ( DECL_SOURCE_LOCATION ( decl ) , OPT_Wpedantic , ptr ? G_ ( "parameter<S2SV_blank>%qD<S2SV_blank>includes<S2SV_blank>pointer<S2SV_blank>to<S2SV_blank>array<S2SV_blank>of<S2SV_blank>" "unknown<S2SV_blank>bound<S2SV_blank>%qT" ) : G_ ( "parameter<S2SV_blank>%qD<S2SV_blank>includes<S2SV_blank>reference<S2SV_blank>to<S2SV_blank>array<S2SV_blank>of<S2SV_blank>" "unknown<S2SV_blank>bound<S2SV_blank>%qT" ) , decl , t ) ; } if ( any_error ) init = NULL_TREE ; else if ( init && ! processing_template_decl ) init = check_default_argument ( decl , init , tf_warning_or_error ) ; } DECL_CHAIN ( decl ) = decls ; decls = decl ; result = tree_cons ( init , type , result ) ; } decls = nreverse ( decls ) ; result = nreverse ( result ) ; if ( parm ) result = chainon ( result , void_list_node ) ; * parms = decls ; return result ; } | <S2SV_ModStart> < cxx17 && INDIRECT_TYPE_P <S2SV_ModEnd> ( type ) |
4,360 | CWE-000 void nft_reject_ipv6_eval ( const struct nft_expr * expr , struct nft_data data [ NFT_REG_MAX + 1 ] , const struct nft_pktinfo * pkt ) { struct nft_reject * priv = nft_expr_priv ( expr ) ; struct net * net = dev_net ( ( pkt -> in != NULL ) ? pkt -> in : pkt -> out ) ; switch ( priv -> type ) { case NFT_REJECT_ICMP_UNREACH : nf_send_unreach6 ( net , pkt -> skb , priv -> icmp_code , pkt -> ops -> hooknum ) ; break ; case NFT_REJECT_TCP_RST : nf_send_reset6 ( net , pkt -> skb , pkt -> ops -> hooknum ) ; break ; <S2SV_StartBug> } <S2SV_EndBug> data [ NFT_REG_VERDICT ] . verdict = NF_DROP ; } | <S2SV_ModStart> ; break ; default : break ; |
4,361 | CWE-000 int main ( ) { queue = malloc ( 100 * sizeof ( process ) ) ; struct timeval start ; struct timeval end ; long int timedif ; int timedummy1 = gettimeofday ( & start , NULL ) ; const int INST_SIZE = 256 ; int has_exit = 0 ; char token [ INST_SIZE ] ; char * * bucket ; char temp [ INST_SIZE ] ; while ( has_exit == 0 ) { prompt ( ) ; int numI = 0 ; do { scanf ( "%s" , token ) ; readEnv ( token , INST_SIZE ) ; int i ; int start ; start = 0 ; for ( i = 0 ; i < strlen ( token ) ; i ++ ) { if ( token [ i ] == '|' || token [ i ] == '>' || token [ i ] == '<' || token [ i ] == '&' ) { if ( i - start > 0 ) { memcpy ( temp , token + start , i - start ) ; temp [ i - start ] = '\\0' ; bucket = addToken ( bucket , temp , numI ) ; numI ++ ; } char specialChar [ 2 ] ; specialChar [ 0 ] = token [ i ] ; specialChar [ 1 ] = '\\0' ; bucket = addToken ( bucket , specialChar , numI ) ; numI ++ ; start = i + 1 ; } } if ( start < strlen ( token ) ) { memcpy ( temp , token + start , strlen ( token ) - start ) ; temp [ i - start ] = '\\0' ; bucket = addToken ( bucket , temp , numI ) ; numI ++ ; } } while ( '\\n' != getchar ( ) ) ; has_exit = executeTokens ( bucket , numI ) ; <S2SV_StartBug> } <S2SV_EndBug> int timedummy2 = gettimeofday ( & end , NULL ) ; timedif = end . tv_sec - start . tv_sec ; freeq ( ) ; <S2SV_StartBug> free ( bucket ) ; <S2SV_EndBug> printf ( "Exiting...\\n\\t<S2SV_blank>Session<S2SV_blank>Time:<S2SV_blank><S2SV_blank>%lds\\n" , timedif ) ; return 0 ; } | <S2SV_ModStart> numI ) ; emptyBucket ( bucket , numI ) ; <S2SV_ModStart> ( ) ; <S2SV_ModEnd> printf ( "Exiting...\\n\\t<S2SV_blank>Session<S2SV_blank>Time:<S2SV_blank><S2SV_blank>%lds\\n" |
4,362 | CWE-000 void AlluxioDisconnectDir ( alluxioHandler * handler ) { <S2SV_StartBug> AlluxioFileSync ( handler ) ; <S2SV_EndBug> ListCell * lc = NULL ; foreach ( lc , handler -> blocksinfo ) { pfree ( ( ( alluxioBlock * ) lfirst ( lc ) ) -> name ) ; pfree ( ( alluxioBlock * ) lfirst ( lc ) ) ; } list_free ( handler -> blocksinfo ) ; handler -> url = NULL ; } | <S2SV_ModStart> handler ) { AlluxioSync <S2SV_ModEnd> ( handler ) |
4,363 | CWE-000 void CONDITION ( ) <S2SV_StartBug> { <S2SV_EndBug> int temp = 0 ; if ( TOKEN == oddsym ) { GETTOKEN ( ) ; EXPRESSION ( ) ; curReg -- ; sprintf ( PrintmaStack [ pc ] , "17<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>0\\n" , curReg , curReg ) ; pc ++ ; } else { EXPRESSION ( ) ; if ( TOKEN != eqlsym && TOKEN != neqsym && TOKEN != lessym && TOKEN != leqsym && TOKEN != gtrsym && TOKEN != geqsym ) ERROR ( 20 ) ; temp = TOKEN ; GETTOKEN ( ) ; EXPRESSION ( ) ; curReg -- ; temp = temp + 10 ; sprintf ( PrintmaStack [ pc ] , "%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , temp , ( curReg - 1 ) , ( curReg - 1 ) , curReg ) ; pc ++ ; temp = 0 ; } } | <S2SV_ModStart> ( ) { printf ( "o%do" , TOKEN ) ; |
4,364 | CWE-000 long long ubifs_get_free_space_nolock ( struct ubifs_info * c ) { int rsvd_idx_lebs , lebs ; long long available , outstanding , free ; <S2SV_StartBug> ubifs_assert ( c -> bi . min_idx_lebs == ubifs_calc_min_idx_lebs ( c ) ) ; <S2SV_EndBug> outstanding = c -> bi . data_growth + c -> bi . dd_growth ; available = ubifs_calc_available ( c , c -> bi . min_idx_lebs ) ; if ( c -> bi . min_idx_lebs > c -> lst . idx_lebs ) rsvd_idx_lebs = c -> bi . min_idx_lebs - c -> lst . idx_lebs ; else rsvd_idx_lebs = 0 ; lebs = c -> lst . empty_lebs + c -> freeable_cnt + c -> idx_gc_cnt - c -> lst . taken_empty_lebs ; lebs -= rsvd_idx_lebs ; available += lebs * ( c -> dark_wm - c -> leb_overhead ) ; if ( available > outstanding ) free = ubifs_reported_space ( c , available - outstanding ) ; else free = 0 ; return free ; } | <S2SV_ModStart> ; ubifs_assert ( c , |
4,365 | CWE-000 static SLresult IEngine_QueryNumSupportedExtensions ( SLEngineItf self , SLuint32 * pNumExtensions ) { SL_ENTER_INTERFACE if ( NULL == pNumExtensions ) { result = SL_RESULT_PARAMETER_INVALID ; } else { <S2SV_StartBug> # ifdef ANDROID <S2SV_EndBug> # else <S2SV_StartBug> * pNumExtensions = 0 ; <S2SV_EndBug> # endif result = SL_RESULT_SUCCESS ; } SL_LEAVE_INTERFACE } | <S2SV_ModStart> } else { <S2SV_ModEnd> * pNumExtensions = <S2SV_ModStart> * pNumExtensions = sizeof ( extensionNames ) / sizeof ( extensionNames [ 0 ] ) ; <S2SV_ModEnd> result = SL_RESULT_SUCCESS |
4,366 | CWE-000 int menu_main ( menu_t * menu ) { SDL_Event event ; int dirty ; redraw ( menu ) ; quit_menu = 0 ; while ( menu -> quit == 0 ) { dirty = 0 ; while ( SDL_PollEvent ( & event ) ) { switch ( event . type ) { case SDL_QUIT : SDL_Quit ( ) ; exit ( 0 ) ; break ; case SDL_KEYDOWN : switch ( event . key . keysym . sym ) { case SDLK_UP : if ( menu -> selected_entry > 0 ) { -- menu -> selected_entry ; dirty = 1 ; } break ; case SDLK_DOWN : if ( menu -> selected_entry < menu -> n_entries - 1 ) { ++ menu -> selected_entry ; dirty = 1 ; } break ; case SDLK_LEFT : if ( menu -> entries [ menu -> selected_entry ] -> is_shiftable ) { if ( menu -> entries [ menu -> selected_entry ] -> selected_entry > 0 ) { -- menu -> entries [ menu -> selected_entry ] -> selected_entry ; dirty = 1 ; } } break ; case SDLK_RIGHT : if ( menu -> entries [ menu -> selected_entry ] -> is_shiftable ) { if ( menu -> entries [ menu -> selected_entry ] -> selected_entry < menu -> entries [ menu -> selected_entry ] -> n_entries - 1 ) { ++ menu -> entries [ menu -> selected_entry ] -> selected_entry ; dirty = 1 ; } } break ; case SDLK_RETURN : case SDLK_LCTRL : if ( ( menu -> entries [ menu -> selected_entry ] -> callback != NULL ) && ( ! menu -> entries [ menu -> selected_entry ] -> is_shiftable ) ) { menu -> entries [ menu -> selected_entry ] -> callback ( menu ) ; redraw ( menu ) ; } break ; case SDLK_LALT : if ( menu -> back_callback != NULL ) { menu -> back_callback ( menu ) ; } break ; default : break ; } default : break ; } } if ( dirty ) { redraw ( menu ) ; } SDL_Delay ( 10 ) ; } quit_menu = 0 ; clear_surface ( screen , 0 ) ; SDL_Flip ( screen ) ; <S2SV_StartBug> return menu -> selected_entry ; <S2SV_EndBug> } | <S2SV_ModStart> screen ) ; clear_surface ( screen , 0 ) ; SDL_Flip ( screen ) ; |
4,367 | CWE-000 int main ( int argc , char * * argv ) { int fd ; t_list * list ; t_tetrim * aa ; char * content ; char * * tab ; int x ; int y ; int i ; int j ; x = 0 ; if ( ! ( tab = ( char * * ) malloc ( sizeof ( * * tab ) * 200 ) ) ) return ( 0 ) ; while ( x < 10 ) { j = 0 ; if ( ! ( tab [ x ] = ( char * ) malloc ( sizeof ( char ) * 200 ) ) ) return ( 0 ) ; while ( j < 10 ) { tab [ x ] [ j ] = '.' ; j ++ ; } x ++ ; } fd = open ( argv [ 1 ] , O_RDONLY ) ; if ( fd > - 1 ) { content = get_file_content ( fd ) ; if ( check_content ( content ) ) { list = split_by_jumpline ( content ) ; i = 0 ; while ( list ) { <S2SV_StartBug> y = chek ( ( t_tetrim * ) ( list -> content ) , tab , 10 ) ; <S2SV_EndBug> list = list -> next ; } free ( content ) ; close ( fd ) ; } else printf ( "error\\n" ) ; } } | <S2SV_ModStart> list ) { aa = <S2SV_ModEnd> ( t_tetrim * <S2SV_ModStart> -> content ) ; while ( aa -> content [ i ] ) { printf ( "%s\\n" , aa -> content [ i ] ) ; i ++ ; } printf ( "\\n" ) ; i = 0 <S2SV_ModEnd> ; list = |
4,368 | CWE-000 const struct operator_s * sense_recon_create ( const struct sense_conf * conf , const long dims [ DIMS ] , const struct linop_s * sense_op , const long pat_dims [ DIMS ] , const complex float * pattern , italgo_fun2_t italgo , iter_conf * iconf , const complex float * init , unsigned int num_funs , const struct operator_p_s * thresh_op [ num_funs ] , const struct linop_s * thresh_funs [ num_funs ] , const long ksp_dims [ DIMS ] , const struct operator_s * precond_op ) { struct lsqr_conf lsqr_conf = { conf -> cclambda , conf -> gpu } ; const struct operator_s * op = NULL ; long img_dims [ DIMS ] ; md_select_dims ( DIMS , ~ COIL_FLAG , img_dims , dims ) ; if ( conf -> rvc ) { struct linop_s * rvc = linop_realval_create ( DIMS , img_dims ) ; struct linop_s * tmp_op = linop_chain ( rvc , sense_op ) ; linop_free ( rvc ) ; linop_free ( sense_op ) ; sense_op = tmp_op ; } if ( 1 < conf -> rwiter ) { struct linop_s * sampling = linop_sampling_create ( dims , pat_dims , pattern ) ; struct linop_s * tmp_op = linop_chain ( sense_op , sampling ) ; linop_free ( sampling ) ; linop_free ( sense_op ) ; sense_op = tmp_op ; unsigned int flags = 0 ; for ( unsigned int i = 0 ; i < DIMS ; i ++ ) if ( pat_dims [ i ] > 1 ) flags = MD_SET ( flags , i ) ; const struct lad_conf lad_conf = { conf -> rwiter , conf -> gamma , flags , & lsqr_conf } ; op = lad2_create ( & lad_conf , italgo , iconf , ( const float * ) init , sense_op , num_funs , thresh_op , thresh_funs ) ; } else if ( NULL == pattern ) { op = lsqr2_create ( & lsqr_conf , italgo , iconf , ( const float * ) init , sense_op , precond_op , num_funs , thresh_op , thresh_funs ) ; } else { complex float * weights = md_alloc ( DIMS , pat_dims , CFL_SIZE ) ; # if 0 # else long dimsR [ DIMS + 1 ] ; real_from_complex_dims ( DIMS , dimsR , pat_dims ) ; md_sqrt ( DIMS + 1 , dimsR , ( float * ) weights , ( const float * ) pattern ) ; # endif <S2SV_StartBug> struct linop_s * weights_op = linop_cdiag_create ( DIMS , ksp_dims , FFT_FLAGS , weights ) ; <S2SV_EndBug> op = wlsqr2_create ( & lsqr_conf , italgo , iconf , ( const float * ) init , sense_op , weights_op , precond_op , num_funs , thresh_op , thresh_funs ) ; } return op ; } | <S2SV_ModStart> , ksp_dims , ~ COIL_FLAG <S2SV_ModEnd> , weights ) |
4,369 | CWE-000 __visible __notrace_funcgraph struct task_struct * __switch_to ( struct task_struct * prev_p , struct task_struct * next_p ) { struct thread_struct * prev = & prev_p -> thread ; struct thread_struct * next = & next_p -> thread ; int cpu = smp_processor_id ( ) ; struct tss_struct * tss = & per_cpu ( init_tss , cpu ) ; unsigned fsindex , gsindex ; fpu_switch_t fpu ; fpu = switch_fpu_prepare ( prev_p , next_p , cpu ) ; load_sp0 ( tss , next ) ; <S2SV_StartBug> savesegment ( es , prev -> es ) ; <S2SV_EndBug> if ( unlikely ( next -> es | prev -> es ) ) loadsegment ( es , next -> es ) ; savesegment ( ds , prev -> ds ) ; if ( unlikely ( next -> ds | prev -> ds ) ) <S2SV_StartBug> loadsegment ( ds , next -> ds ) ; <S2SV_EndBug> savesegment ( fs , fsindex ) ; savesegment ( gs , gsindex ) ; load_TLS ( next , cpu ) ; arch_end_context_switch ( next_p ) ; if ( unlikely ( fsindex | next -> fsindex | prev -> fs ) ) { loadsegment ( fs , next -> fsindex ) ; if ( fsindex ) prev -> fs = 0 ; } if ( next -> fs ) wrmsrl ( MSR_FS_BASE , next -> fs ) ; prev -> fsindex = fsindex ; if ( unlikely ( gsindex | next -> gsindex | prev -> gs ) ) { load_gs_index ( next -> gsindex ) ; if ( gsindex ) prev -> gs = 0 ; } if ( next -> gs ) wrmsrl ( MSR_KERNEL_GS_BASE , next -> gs ) ; prev -> gsindex = gsindex ; switch_fpu_finish ( next_p , fpu ) ; prev -> usersp = this_cpu_read ( old_rsp ) ; this_cpu_write ( old_rsp , next -> usersp ) ; this_cpu_write ( current_task , next_p ) ; task_thread_info ( prev_p ) -> saved_preempt_count = this_cpu_read ( __preempt_count ) ; this_cpu_write ( __preempt_count , task_thread_info ( next_p ) -> saved_preempt_count ) ; this_cpu_write ( kernel_stack , ( unsigned long ) task_stack_page ( next_p ) + THREAD_SIZE - KERNEL_STACK_OFFSET ) ; if ( unlikely ( task_thread_info ( next_p ) -> flags & _TIF_WORK_CTXSW_NEXT || task_thread_info ( prev_p ) -> flags & _TIF_WORK_CTXSW_PREV ) ) __switch_to_xtra ( prev_p , next_p , tss ) ; return prev_p ; } | <S2SV_ModStart> ; savesegment ( fs , fsindex ) ; savesegment ( gs , gsindex ) ; load_TLS ( next , cpu ) ; arch_end_context_switch ( next_p ) ; savesegment ( <S2SV_ModStart> next -> ds <S2SV_ModEnd> ) ; if |
4,370 | CWE-000 void AdamBotIntermission ( bot_state_t * bs ) { bs -> flags &= ~ BFL_IDEALVIEWSET ; <S2SV_StartBug> if ( ! BotIntermission ( bs ) ) <S2SV_EndBug> { BotUpdateInventory ( bs ) ; BotCheckSnapshot ( bs ) ; BotCheckAir ( bs ) ; } } | <S2SV_ModStart> bs ) ) { BotSetTeleportTime ( bs ) ; <S2SV_ModEnd> BotUpdateInventory ( bs |
4,371 | CWE-000 void write_line ( char lcd_data [ ] ) { <S2SV_StartBug> write_inst ( CURSOR_RETURN ) ; <S2SV_EndBug> for ( int i = 0 ; lcd_data [ i ] != '\\0' ; i ++ ) { <S2SV_StartBug> write_char ( lcd_data [ i ] ) ; <S2SV_EndBug> } } | <S2SV_ModStart> write_inst ( CURSOR_RETURN , BIT4 <S2SV_ModStart> [ i ] , BIT4 |
4,372 | CWE-000 <S2SV_StartBug> static void init_create_message_contents ( CONTROL_MESSAGE_CREATE_MSG * create_msg ) <S2SV_EndBug> { create_msg -> uris_count = 0 ; create_msg -> uris = NULL ; create_msg -> args_size = 0 ; create_msg -> args = NULL ; } | <S2SV_ModStart> void init_create_message_contents ( CONTROL_MESSAGE_MODULE_CREATE <S2SV_ModEnd> * create_msg ) |
4,373 | CWE-000 bool thread_has_highest_priority ( ) <S2SV_StartBug> { <S2SV_EndBug> if ( list_empty ( & ready_list ) ) { return true ; } else { return thread_current ( ) -> priority >= list_entry ( list_back ( & ready_list ) , struct thread , elem ) -> priority ; } } | <S2SV_ModStart> ( ) { if ( thread_mlfqs ) return thread_mlfqs_highest_priority ( ) ; |
4,374 | CWE-000 void write_nat_bits ( struct f2fs_sb_info * sbi , struct f2fs_super_block * sb , struct f2fs_checkpoint * cp , int set ) { struct f2fs_nm_info * nm_i = NM_I ( sbi ) ; u_int32_t nat_blocks = get_sb ( segment_count_nat ) << ( get_sb ( log_blocks_per_seg ) - 1 ) ; u_int32_t nat_bits_bytes = nat_blocks >> 3 ; u_int32_t nat_bits_blocks = F2FS_BYTES_TO_BLK ( ( nat_bits_bytes << 1 ) + 8 + F2FS_BLKSIZE - 1 ) ; unsigned char * nat_bits , * full_nat_bits , * empty_nat_bits ; struct f2fs_nat_block * nat_block ; u_int32_t i , j ; block_t blkaddr ; int ret ; nat_bits = calloc ( F2FS_BLKSIZE , nat_bits_blocks ) ; ASSERT ( nat_bits ) ; nat_block = malloc ( F2FS_BLKSIZE ) ; ASSERT ( nat_block ) ; full_nat_bits = nat_bits + 8 ; empty_nat_bits = full_nat_bits + nat_bits_bytes ; memset ( full_nat_bits , 0 , nat_bits_bytes ) ; memset ( empty_nat_bits , 0 , nat_bits_bytes ) ; for ( i = 0 ; i < nat_blocks ; i ++ ) { int seg_off = i >> get_sb ( log_blocks_per_seg ) ; int valid = 0 ; blkaddr = ( pgoff_t ) ( get_sb ( nat_blkaddr ) + ( seg_off << get_sb ( log_blocks_per_seg ) << 1 ) + ( i & ( ( 1 << get_sb ( log_blocks_per_seg ) ) - 1 ) ) ) ; <S2SV_StartBug> if ( f2fs_test_bit ( i , nm_i -> nat_bitmap ) ) <S2SV_EndBug> blkaddr += ( 1 << get_sb ( log_blocks_per_seg ) ) ; ret = dev_read_block ( nat_block , blkaddr ) ; ASSERT ( ret >= 0 ) ; for ( j = 0 ; j < NAT_ENTRY_PER_BLOCK ; j ++ ) { if ( ( i == 0 && j == 0 ) || nat_block -> entries [ j ] . block_addr != NULL_ADDR ) valid ++ ; } if ( valid == 0 ) test_and_set_bit_le ( i , empty_nat_bits ) ; else if ( valid == NAT_ENTRY_PER_BLOCK ) test_and_set_bit_le ( i , full_nat_bits ) ; } * ( __le64 * ) nat_bits = get_cp_crc ( cp ) ; free ( nat_block ) ; blkaddr = get_sb ( segment0_blkaddr ) + ( set << get_sb ( log_blocks_per_seg ) ) - nat_bits_blocks ; DBG ( 1 , "\\tWriting<S2SV_blank>NAT<S2SV_blank>bits<S2SV_blank>pages,<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>0x%08x\\n" , blkaddr ) ; for ( i = 0 ; i < nat_bits_blocks ; i ++ ) { if ( dev_write_block ( nat_bits + i * F2FS_BLKSIZE , blkaddr + i ) ) ASSERT_MSG ( "\\tError:<S2SV_blank>write<S2SV_blank>NAT<S2SV_blank>bits<S2SV_blank>to<S2SV_blank>disk!!!\\n" ) ; } MSG ( 0 , "Info:<S2SV_blank>Write<S2SV_blank>valid<S2SV_blank>nat_bits<S2SV_blank>in<S2SV_blank>checkpoint\\n" ) ; free ( nat_bits ) ; } | <S2SV_ModStart> ; if ( i < nm_i -> nat_blocks && |
4,375 | CWE-000 static int hdmi_codec_probe ( struct platform_device * pdev ) { struct hdmi_codec_pdata * hcd = pdev -> dev . platform_data ; struct device * dev = & pdev -> dev ; struct hdmi_codec_priv * hcp ; struct hdmi_device * hd ; struct list_head * pos ; int dai_count , i = 0 ; int ret ; dev_dbg ( dev , "%s()\\n" , __func__ ) ; if ( ! hcd ) { dev_err ( dev , "%s:<S2SV_blank>No<S2SV_blank>plalform<S2SV_blank>data\\n" , __func__ ) ; return - EINVAL ; } dai_count = hcd -> i2s + hcd -> spdif ; if ( dai_count < 1 || ! hcd -> ops || ! hcd -> ops -> hw_params || ! hcd -> ops -> audio_shutdown ) { dev_err ( dev , "%s:<S2SV_blank>Invalid<S2SV_blank>parameters\\n" , __func__ ) ; return - EINVAL ; } hcp = devm_kzalloc ( dev , sizeof ( * hcp ) , GFP_KERNEL ) ; if ( ! hcp ) return - ENOMEM ; hd = NULL ; mutex_lock ( & hdmi_mutex ) ; list_for_each ( pos , & hdmi_device_list ) { struct hdmi_device * tmp = pos_to_hdmi_device ( pos ) ; if ( tmp -> dev == dev -> parent ) { hd = tmp ; break ; } } if ( ! hd ) { hd = devm_kzalloc ( dev , sizeof ( * hd ) , GFP_KERNEL ) ; if ( ! hd ) { mutex_unlock ( & hdmi_mutex ) ; return - ENOMEM ; } hd -> dev = dev -> parent ; list_add_tail ( & hd -> list , & hdmi_device_list ) ; } mutex_unlock ( & hdmi_mutex ) ; if ( hd -> cnt >= ARRAY_SIZE ( hdmi_dai_name ) ) { dev_err ( dev , "too<S2SV_blank>many<S2SV_blank>hdmi<S2SV_blank>codec<S2SV_blank>are<S2SV_blank>deteced\\n" ) ; return - EINVAL ; } hcp -> hcd = * hcd ; mutex_init ( & hcp -> current_stream_lock ) ; <S2SV_StartBug> hcp -> daidrv = devm_kzalloc ( dev , dai_count * sizeof ( * hcp -> daidrv ) , <S2SV_EndBug> GFP_KERNEL ) ; if ( ! hcp -> daidrv ) return - ENOMEM ; if ( hcd -> i2s ) { hcp -> daidrv [ i ] = hdmi_i2s_dai ; hcp -> daidrv [ i ] . playback . channels_max = hcd -> max_i2s_channels ; hcp -> daidrv [ i ] . name = hdmi_dai_name [ hd -> cnt ++ ] ; i ++ ; } if ( hcd -> spdif ) { hcp -> daidrv [ i ] = hdmi_spdif_dai ; hcp -> daidrv [ i ] . name = hdmi_dai_name [ hd -> cnt ++ ] ; } <S2SV_StartBug> ret = snd_soc_register_codec ( dev , & hdmi_codec , hcp -> daidrv , <S2SV_EndBug> dai_count ) ; if ( ret ) { dev_err ( dev , "%s:<S2SV_blank>snd_soc_register_codec()<S2SV_blank>failed<S2SV_blank>(%d)\\n" , __func__ , ret ) ; return ret ; } <S2SV_StartBug> dev_set_drvdata ( dev , hcp ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> current_stream_lock ) ; mutex_init ( & hcp -> eld_lock ) ; <S2SV_ModStart> ] ; } dev_set_drvdata ( dev , hcp ) ; <S2SV_ModStart> ret ; } hcp -> dev = dev <S2SV_ModEnd> ; return 0 |
4,376 | CWE-000 int main ( ) { srand ( time ( NULL ) ) ; total_cells = length * height ; struct Cell grid [ total_cells ] ; init_grid ( grid , total_cells , cells_to_start_cars ) ; for ( int i = 0 ; i < total_cells ; i ++ ) { <S2SV_StartBug> if ( i < 9 ) { <S2SV_EndBug> printf ( "[0%i]" , i ) ; } else { printf ( "[%i]" , i ) ; } if ( ( ( i + 1 ) % length ) == 0 ) { printf ( "\\n" ) ; } } print_grid ( grid ) ; printf ( "\\n\\n\\n" ) ; while ( 1 ) { char str [ 20 ] ; printf ( "\\nPush<S2SV_blank>Enter<S2SV_blank>to<S2SV_blank>cycle<S2SV_blank>(ctrl+c<S2SV_blank>to<S2SV_blank>quit)" ) ; gets ( str ) ; do_cycle ( grid ) ; print_grid ( grid ) ; printf ( "\\n===========end===========\\n" ) ; } return 0 ; } | <S2SV_ModStart> i < 9 ) { printf ( "[00%i]" , i ) ; } else if ( i < 100 |
4,377 | CWE-000 bool isValidMoveRook ( ChessGame * game , Move move ) { <S2SV_StartBug> Vector2 diff = vecDiff ( move . from , move . to ) ; <S2SV_EndBug> if ( diff . x != 0 && diff . y != 0 ) return false ; return checkClearPath ( game , move ) ; } | <S2SV_ModStart> ( move . to <S2SV_ModEnd> , move . <S2SV_ModStart> , move . from <S2SV_ModEnd> ) ; if |
4,378 | CWE-000 int MPI_Win_lock ( int lock_type , int target_rank , int assert , MPI_Win win ) { CSP_win_t * ug_win ; CSP_win_target_t * target ; int mpi_errno = MPI_SUCCESS ; int user_rank ; CSP_DBG_PRINT_FCNAME ( ) ; CSP_fetch_ug_win_from_cache ( win , ug_win ) ; if ( ug_win == NULL ) { return PMPI_Win_lock ( lock_type , target_rank , assert , win ) ; } if ( target_rank == MPI_PROC_NULL ) goto fn_exit ; <S2SV_StartBug> CSP_assert ( ( ug_win -> info_args . epochs_used & CSP_EPOCH_LOCK ) ) ; <S2SV_EndBug> target = & ( ug_win -> targets [ target_rank ] ) ; PMPI_Comm_rank ( ug_win -> user_comm , & user_rank ) ; # ifdef CSP_ENABLE_EPOCH_STAT_CHECK if ( ug_win -> epoch_stat == CSP_WIN_EPOCH_LOCK_ALL ) { CSP_ERR_PRINT ( "Wrong<S2SV_blank>synchronization<S2SV_blank>call!<S2SV_blank>" "Previous<S2SV_blank>LOCK_ALL<S2SV_blank>epoch<S2SV_blank>is<S2SV_blank>still<S2SV_blank>open<S2SV_blank>in<S2SV_blank>%s\\n" , __FUNCTION__ ) ; mpi_errno = - 1 ; goto fn_fail ; } if ( ug_win -> epoch_stat == CSP_WIN_EPOCH_PER_TARGET && target -> epoch_stat != CSP_TARGET_NO_EPOCH ) { CSP_ERR_PRINT ( "Wrong<S2SV_blank>synchronization<S2SV_blank>call!<S2SV_blank>" "Previous<S2SV_blank>%s<S2SV_blank>epoch<S2SV_blank>on<S2SV_blank>target<S2SV_blank>%d<S2SV_blank>is<S2SV_blank>still<S2SV_blank>open<S2SV_blank>in<S2SV_blank>%s\\n" , target -> epoch_stat == CSP_TARGET_EPOCH_LOCK ? "LOCK" : "PSCW" , target_rank , __FUNCTION__ ) ; mpi_errno = - 1 ; goto fn_fail ; } CSP_assert ( user_rank != target_rank || ug_win -> is_self_locked == 0 ) ; # endif target -> remote_lock_assert = assert ; CSP_DBG_PRINT ( "<S2SV_blank>lock(%d),<S2SV_blank>MPI_MODE_NOCHECK<S2SV_blank>%d(assert<S2SV_blank>%d)\\n" , target_rank , ( assert & MPI_MODE_NOCHECK ) != 0 , assert ) ; # ifdef CSP_ENABLE_SYNC_ALL_OPT CSP_DBG_PRINT ( "<S2SV_blank>lock_all(ug_win<S2SV_blank>0x%x),<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>target<S2SV_blank>rank<S2SV_blank>%d\\n" , target -> ug_win , target_rank ) ; mpi_errno = PMPI_Win_lock_all ( assert , target -> ug_win ) ; if ( mpi_errno != MPI_SUCCESS ) goto fn_fail ; if ( user_rank == target_rank ) ug_win -> is_self_locked = 1 ; # else mpi_errno = CSP_win_target_lock ( lock_type , assert , target_rank , ug_win ) ; if ( mpi_errno != MPI_SUCCESS ) goto fn_fail ; # endif # if defined ( CSP_ENABLE_RUNTIME_LOAD_OPT ) int j ; for ( j = 0 ; j < target -> num_segs ; j ++ ) { target -> segs [ j ] . main_lock_stat = CSP_MAIN_LOCK_RESET ; CSP_reset_target_opload ( target_rank , ug_win ) ; } # endif target -> epoch_stat = CSP_TARGET_EPOCH_LOCK ; ug_win -> epoch_stat = CSP_WIN_EPOCH_PER_TARGET ; ug_win -> lock_counter ++ ; fn_exit : return mpi_errno ; fn_fail : goto fn_exit ; } | <S2SV_ModStart> CSP_EPOCH_LOCK ) ) ; if ( ug_win -> epoch_stat == CSP_WIN_EPOCH_FENCE ) ug_win -> is_self_locked = 0 |
4,379 | CWE-000 static void disas_bitfield ( DisasContext * s , uint32_t insn ) { unsigned int sf , n , opc , ri , si , rn , rd , bitsize , pos , len ; TCGv_i64 tcg_rd , tcg_tmp ; sf = extract32 ( insn , 31 , 1 ) ; opc = extract32 ( insn , 29 , 2 ) ; n = extract32 ( insn , 22 , 1 ) ; ri = extract32 ( insn , 16 , 6 ) ; si = extract32 ( insn , 10 , 6 ) ; rn = extract32 ( insn , 5 , 5 ) ; rd = extract32 ( insn , 0 , 5 ) ; bitsize = sf ? 64 : 32 ; if ( sf != n || ri >= bitsize || si >= bitsize || opc > 2 ) { unallocated_encoding ( s ) ; return ; } tcg_rd = cpu_reg ( s , rd ) ; tcg_tmp = read_cpu_reg ( s , rn , 1 ) ; <S2SV_StartBug> if ( si <= ri ) { <S2SV_EndBug> len = ( si - ri ) + 1 ; if ( opc == 0 ) { tcg_gen_sextract_i64 ( tcg_rd , tcg_tmp , ri , len ) ; goto done ; } else if ( opc == 2 ) { tcg_gen_extract_i64 ( tcg_rd , tcg_tmp , ri , len ) ; return ; } tcg_gen_extract_i64 ( tcg_tmp , tcg_tmp , ri , len ) ; pos = 0 ; } else { len = si + 1 ; pos = ( bitsize - ri ) & ( bitsize - 1 ) ; } if ( opc == 0 && len < ri ) { tcg_gen_sextract_i64 ( tcg_tmp , tcg_tmp , 0 , len ) ; len = ri ; } if ( opc == 1 ) { tcg_gen_deposit_i64 ( tcg_rd , tcg_rd , tcg_tmp , pos , len ) ; } else { tcg_gen_deposit_z_i64 ( tcg_rd , tcg_tmp , pos , len ) ; return ; } done : if ( ! sf ) { tcg_gen_ext32u_i64 ( tcg_rd , tcg_rd ) ; } } | <S2SV_ModStart> if ( si >= <S2SV_ModEnd> ri ) { |
4,380 | CWE-000 <S2SV_StartBug> int cms_init_optimal_alt ( CountMinSketch * cms , float error_rate , float certainty , cms_hash_function hash_function ) { <S2SV_EndBug> <S2SV_StartBug> int width , depth ; <S2SV_EndBug> width = ceil ( 2 / error_rate ) ; <S2SV_StartBug> depth = ceil ( log ( 1 / ( 1 - certainty ) ) / LOG_TWO ) ; <S2SV_EndBug> <S2SV_StartBug> return cms_init_alt ( cms , width , depth , hash_function ) ; <S2SV_EndBug> } | <S2SV_ModStart> * cms , double error_rate , double confidence <S2SV_ModEnd> , cms_hash_function hash_function <S2SV_ModStart> ) { int <S2SV_ModEnd> width = ceil <S2SV_ModStart> error_rate ) ; int <S2SV_ModStart> = ceil ( ( - 1 * <S2SV_ModStart> log ( 1 - confidence <S2SV_ModEnd> ) ) / <S2SV_ModStart> ) ; return __setup_cms <S2SV_ModEnd> ( cms , <S2SV_ModStart> , depth , error_rate , confidence , |
4,381 | CWE-000 void save_aliases ( ) { FILE * source = fopen ( ".aliases" , "w+" ) ; int i , j ; <S2SV_StartBug> for ( i = history_index ; i < MAX_HISTORY_SIZE ; i ++ ) { <S2SV_EndBug> if ( alias_array [ i ] . alias != NULL ) { fprintf ( source , "%d<S2SV_blank>%s<S2SV_blank>%s\\n" , alias_array [ i ] . command_id , alias_array [ i ] . alias , alias_array [ i ] . cmd ) ; } } <S2SV_StartBug> for ( j = 0 ; j < history_index ; j ++ ) { <S2SV_EndBug> if ( alias_array [ j ] . alias != NULL ) { fprintf ( source , "%d<S2SV_blank>%s<S2SV_blank>%s\\n" , alias_array [ j ] . command_id , alias_array [ j ] . alias , alias_array [ j ] . cmd ) ; } } fclose ( source ) ; } | <S2SV_ModStart> ( i = 0 <S2SV_ModEnd> ; i < <S2SV_ModStart> ; } } <S2SV_ModEnd> fclose ( source |
4,382 | CWE-000 void loadWalls ( Slider * slider , FILE * level ) { uint i , valRead ; <S2SV_StartBug> fscanf ( level , "%d" , & slider -> nbWalls ) ; <S2SV_EndBug> if ( slider -> nbWalls != 0 ) { slider -> walls = malloc ( slider -> nbWalls * sizeof ( Wall ) ) ; for ( i = 0 ; i < slider -> nbWalls ; i ++ ) { valRead = fscanf ( level , "%d<S2SV_blank>%d<S2SV_blank>%d\\n" , & slider -> walls [ i ] . position . x , & slider -> walls [ i ] . position . y , & slider -> walls [ i ] . direction ) ; if ( valRead == 3 ) { slider -> walls [ i ] . direction /= 3 ; } else { free ( slider ) ; free ( slider -> walls ) ; printf ( "Le<S2SV_blank>mur<S2SV_blank>n\'est<S2SV_blank>pas<S2SV_blank>valide<S2SV_blank>sur<S2SV_blank>la<S2SV_blank>ligne<S2SV_blank>des<S2SV_blank>murs<S2SV_blank>num<S2SV_blank>:<S2SV_blank>%d<S2SV_blank>\\n" , i + 1 ) ; exit ( ERROR_CREATING_WALLS ) ; } } } } | <S2SV_ModStart> ( level , "%d\\n" <S2SV_ModEnd> , & slider |
4,383 | CWE-000 MSG_HEADER * * utox_load_chatlog ( char hex [ TOX_PUBLIC_KEY_SIZE * 2 ] , size_t * size , uint32_t count , uint32_t skip ) { size_t records_count = utox_count_chatlog ( hex ) ; if ( skip >= records_count ) { if ( skip > 0 ) { LOG_ERR ( "Chatlog" , "Error,<S2SV_blank>skipped<S2SV_blank>all<S2SV_blank>records" ) ; } else { LOG_INFO ( "Chatlog" , "No<S2SV_blank>log<S2SV_blank>exists." ) ; } return NULL ; } FILE * file = chatlog_get_file ( hex , false ) ; if ( ! file ) { LOG_TRACE ( "Chatlog" , "Log<S2SV_blank>read:\\tUnable<S2SV_blank>to<S2SV_blank>access<S2SV_blank>file<S2SV_blank>provided." ) ; return NULL ; } if ( count > ( records_count - skip ) ) { count = records_count - skip ; } MSG_HEADER * * data = calloc ( count + 1 , sizeof ( MSG_HEADER ) ) ; MSG_HEADER * * start = data ; if ( ! data ) { LOG_ERR ( "Chatlog" , "Log<S2SV_blank>read:\\tCouldn\'t<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>log<S2SV_blank>entries." ) ; fclose ( file ) ; return NULL ; } size_t start_at = records_count - count - skip ; size_t actual_count = 0 ; size_t file_offset = 0 ; LOG_FILE_MSG_HEADER header ; while ( fread ( & header , sizeof ( header ) , 1 , file ) == 1 ) { if ( start_at ) { fseeko ( file , header . author_length , SEEK_CUR ) ; fseeko ( file , header . msg_length , SEEK_CUR ) ; fseeko ( file , 1 , SEEK_CUR ) ; start_at -- ; file_offset = ftello ( file ) ; continue ; } if ( count ) { fseeko ( file , header . author_length , SEEK_CUR ) ; if ( header . msg_length > 1 << 16 ) { LOG_ERR ( "Chatlog" , "Can\'t<S2SV_blank>malloc<S2SV_blank>that<S2SV_blank>much,<S2SV_blank>you\'ll<S2SV_blank>probably<S2SV_blank>have<S2SV_blank>to<S2SV_blank>move<S2SV_blank>or<S2SV_blank>delete<S2SV_blank>your" "<S2SV_blank>history<S2SV_blank>for<S2SV_blank>this<S2SV_blank>peer.\\n\\t\\tFriend<S2SV_blank>number<S2SV_blank>%.*s,<S2SV_blank>count<S2SV_blank>%u," "<S2SV_blank>actual_count<S2SV_blank>%lu,<S2SV_blank>start<S2SV_blank>at<S2SV_blank>%lu,<S2SV_blank>error<S2SV_blank>size<S2SV_blank>%lu.\\n" , TOX_PUBLIC_KEY_SIZE * 2 , hex , count , actual_count , start_at , header . msg_length ) ; if ( size ) { * size = 0 ; } fclose ( file ) ; return start ; } MSG_HEADER * msg = calloc ( 1 , sizeof ( MSG_HEADER ) ) ; if ( ! msg ) { LOG_ERR ( "Chatlog" , "Unable<S2SV_blank>to<S2SV_blank>malloc...<S2SV_blank>sorry!" ) ; fclose ( file ) ; return NULL ; } msg -> our_msg = header . author ; msg -> receipt_time = header . receipt ; msg -> time = header . time ; msg -> msg_type = header . msg_type ; msg -> disk_offset = file_offset ; msg -> via . txt . length = header . msg_length ; msg -> via . txt . msg = calloc ( 1 , msg -> via . txt . length ) ; if ( ! msg -> via . txt . msg ) { LOG_ERR ( "Chatlog" , "Unable<S2SV_blank>to<S2SV_blank>malloc<S2SV_blank>for<S2SV_blank>via.txt.msg...<S2SV_blank>sorry!" ) ; <S2SV_StartBug> free ( msg ) ; <S2SV_EndBug> fclose ( file ) ; return NULL ; } msg -> via . txt . author_length = header . author_length ; if ( fread ( msg -> via . txt . msg , msg -> via . txt . length , 1 , file ) != 1 ) { LOG_ERR ( "Chatlog" , "Log<S2SV_blank>read:\\tError<S2SV_blank>reading<S2SV_blank>record<S2SV_blank>%u<S2SV_blank>of<S2SV_blank>length<S2SV_blank>%u<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>%lu:<S2SV_blank>stopping." , count , msg -> via . txt . length , msg -> disk_offset ) ; free ( msg -> via . txt . msg ) ; free ( msg ) ; break ; } msg -> via . txt . length = utf8_validate ( ( uint8_t * ) msg -> via . txt . msg , msg -> via . txt . length ) ; * data ++ = msg ; -- count ; ++ actual_count ; fseeko ( file , 1 , SEEK_CUR ) ; file_offset = ftello ( file ) ; } } fclose ( file ) ; if ( size ) { * size = actual_count ; } return start ; } | <S2SV_ModStart> ; free ( start ) ; free ( |
4,384 | CWE-000 <S2SV_StartBug> int ft_dtoa ( double n , int p , char * frac ) <S2SV_EndBug> { long double holder ; int i ; long double tens ; <S2SV_StartBug> int lastdig ; <S2SV_EndBug> tens = 1 ; i = 0 ; while ( i < p ) { holder = n * tens ; frac [ i ] = ( long ) ( ( holder - ( ( long long ) holder ) ) * 10 ) + 48 ; tens *= 10 ; i ++ ; } holder = n * tens ; lastdig = ( long ) ( ( holder - ( ( long ) holder ) ) * 10 ) ; return ( lastdig ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> char <S2SV_ModEnd> ft_dtoa ( double <S2SV_ModStart> double tens ; char <S2SV_ModEnd> lastdig ; tens |
4,385 | CWE-000 EXT_RETURN tls_construct_ctos_key_share ( SSL * s , WPACKET * pkt , unsigned int context , X509 * x , size_t chainidx ) { # ifndef OPENSSL_NO_TLS1_3 size_t i , num_groups = 0 ; const uint16_t * pgroups = NULL ; uint16_t curve_id = 0 ; if ( ! WPACKET_put_bytes_u16 ( pkt , TLSEXT_TYPE_key_share ) || ! WPACKET_start_sub_packet_u16 ( pkt ) || ! WPACKET_start_sub_packet_u16 ( pkt ) ) { SSLfatal ( s , SSL_AD_INTERNAL_ERROR , SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE , ERR_R_INTERNAL_ERROR ) ; return EXT_RETURN_FAIL ; } tls1_get_supported_groups ( s , & pgroups , & num_groups ) ; if ( s -> s3 -> group_id != 0 ) { curve_id = s -> s3 -> group_id ; } else { for ( i = 0 ; i < num_groups ; i ++ ) { if ( ! tls_curve_allowed ( s , pgroups [ i ] , SSL_SECOP_CURVE_SUPPORTED ) ) continue ; curve_id = pgroups [ i ] ; break ; } } if ( curve_id == 0 ) { SSLfatal ( s , SSL_AD_INTERNAL_ERROR , SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE , SSL_R_NO_SUITABLE_KEY_SHARE ) ; return EXT_RETURN_FAIL ; } if ( ! add_key_share ( s , pkt , curve_id ) ) { return EXT_RETURN_FAIL ; } if ( ! WPACKET_close ( pkt ) || ! WPACKET_close ( pkt ) ) { SSLfatal ( s , SSL_AD_INTERNAL_ERROR , SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE , ERR_R_INTERNAL_ERROR ) ; return EXT_RETURN_FAIL ; } <S2SV_StartBug> # endif <S2SV_EndBug> return EXT_RETURN_SENT ; } | <S2SV_ModStart> EXT_RETURN_FAIL ; } return EXT_RETURN_SENT ; # else return EXT_RETURN_NOT_SENT ; # endif <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,386 | CWE-000 static char * fetch_char ( t_printf * pf ) { char * s ; if ( pf -> fspec . length == 3 ) { if ( pf -> fspec . spec == 'c' ) return ( set_wide ( va_arg ( pf -> ap , wchar_t ) ) ) ; else if ( pf -> fspec . spec == 's' ) return ( set_wstr ( va_arg ( pf -> ap , wchar_t * ) ) ) ; } else if ( pf -> fspec . spec == 'c' || pf -> fspec . spec == 'C' ) { s = ft_strnew ( 1 ) ; s [ 0 ] = va_arg ( pf -> ap , int ) ; <S2SV_StartBug> return ( s ) ; <S2SV_EndBug> } else if ( pf -> fspec . spec == 's' || pf -> fspec . spec == 'S' ) return ( ft_strdup ( ( va_arg ( pf -> ap , char * ) ) ) ) ; return ( NULL ) ; } | <S2SV_ModStart> int ) ; if ( s [ 0 ] == 0 ) ++ pf -> len ; |
4,387 | CWE-000 int main ( int argc , char const * argv [ ] ) { <S2SV_StartBug> char * str1 = "12040593581025012501259998" ; <S2SV_EndBug> <S2SV_StartBug> char * str2 = "1101298375120985710298752100" ; <S2SV_EndBug> void * intal1 ; void * intal2 ; void * sum ; void * diff ; void * product ; void * quotient ; void * exp ; intal1 = intal_create ( str1 ) ; intal2 = intal_create ( str2 ) ; printf ( "First<S2SV_blank>intal:<S2SV_blank>%s\\n" , intal2str ( intal1 ) ) ; printf ( "Second<S2SV_blank>intal:<S2SV_blank>%s\\n" , intal2str ( intal2 ) ) ; intal1 = intal_increment ( intal1 ) ; intal2 = intal_decrement ( intal2 ) ; printf ( "Two<S2SV_blank>intals<S2SV_blank>after<S2SV_blank>increment<S2SV_blank>and<S2SV_blank>decrement:\\n" ) ; printf ( "%s\\n" , intal2str ( intal1 ) ) ; printf ( "%s\\n" , intal2str ( intal2 ) ) ; sum = intal_add ( intal1 , intal2 ) ; printf ( "Sum:<S2SV_blank>%s\\n" , intal2str ( sum ) ) ; diff = intal_diff ( intal1 , intal2 ) ; printf ( "Diff:<S2SV_blank>%s\\n" , intal2str ( diff ) ) ; } | <S2SV_ModStart> * str1 = "6233" <S2SV_ModEnd> ; char * <S2SV_ModStart> * str2 = "6231" <S2SV_ModEnd> ; void * |
4,388 | CWE-000 static struct aa_label * __label_update ( struct aa_label * label ) { struct aa_label * new , * tmp ; struct aa_labelset * ls ; struct aa_profile * p ; struct label_it i ; unsigned long flags ; int invcount = 0 ; AA_BUG ( ! label ) ; AA_BUG ( ! mutex_is_locked ( & labels_ns ( label ) -> lock ) ) ; new = aa_label_alloc ( label -> size , label -> proxy , GFP_KERNEL ) ; if ( ! new ) return NULL ; ls = labels_set ( label ) ; write_lock_irqsave ( & ls -> lock , flags ) ; label_for_each ( i , label , p ) { new -> vec [ i . i ] = aa_get_newest_profile ( p ) ; <S2SV_StartBug> if ( & new -> vec [ i . i ] -> label . proxy != & p -> label . proxy ) <S2SV_EndBug> invcount ++ ; } if ( invcount ) { new -> size -= aa_vec_unique ( & new -> vec [ 0 ] , new -> size , VEC_FLAG_TERMINATE ) ; if ( labels_set ( label ) != labels_set ( new ) ) { write_unlock_irqrestore ( & ls -> lock , flags ) ; tmp = aa_label_insert ( labels_set ( new ) , new ) ; write_lock_irqsave ( & ls -> lock , flags ) ; goto remove ; } } else AA_BUG ( labels_ns ( label ) != labels_ns ( new ) ) ; tmp = __label_insert ( labels_set ( label ) , new , true ) ; remove : __label_remove ( label , tmp ) ; write_unlock_irqrestore ( & ls -> lock , flags ) ; aa_put_label ( new ) ; return tmp ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> new -> vec <S2SV_ModStart> . proxy != <S2SV_ModEnd> p -> label |
4,389 | CWE-000 void aplRxCustomCallBack ( ) { unsigned short len , i ; unsigned char * ptr ; unsigned char isBoardcast = FALSE ; printf ( "aplRxCustomCallBack():<S2SV_blank>recv<S2SV_blank>a<S2SV_blank>packet,<S2SV_blank>type=" ) ; switch ( aplGetRxMsgType ( ) ) { case FRAME_TYPE_LONG_BROADCAST : isBoardcast = TRUE ; printf ( "broadcast:<S2SV_blank>\\r\\n" ) ; break ; case FRAME_TYPE_LONG_MSG : printf ( "msg:<S2SV_blank>\\r\\n" ) ; break ; default : printf ( "unsupported<S2SV_blank>msg,<S2SV_blank>ignore<S2SV_blank>it\\r\\n" ) ; return ; } ptr = aplGetRxMsgData ( ) ; len = aplGetRxMsgLen ( ) ; if ( ( aplGetRxMsgType ( ) == FRAME_TYPE_LONG_BROADCAST ) && * ( ptr ) == 0xff && * ( ptr + 1 ) == 0xff ) { fprintf ( stderr , "ZZIFrecv<S2SV_blank>a<S2SV_blank>broadcast:<S2SV_blank>%s@\\r\\n" , ptr + 2 ) ; return ; } # if 1 # define DISPLAY_ON_SERIAL <S2SV_StartBug> # ifndef DISPLAY_ON_SERIAL <S2SV_EndBug> for ( i = 0 ; i < len ; ++ i ) printf ( "%c" , * ( ptr + i ) ) ; puts ( "" ) ; # endif show_msg_to_PC ( aplGetRxMsgSrcAddr ( ) , ptr , len , isBoardcast ) ; # else ptr += 24 ; while ( * ptr != 0 ) printf ( "%c" , * ( ptr ++ ) ) ; printf ( "\\r\\n" ) ; # endif } | <S2SV_ModStart> define DISPLAY_ON_SERIAL # ifdef <S2SV_ModEnd> DISPLAY_ON_SERIAL for ( |
4,390 | CWE-000 static int hclge_vport_setup ( struct hclge_vport * vport , u16 num_tqps ) { struct hnae3_handle * nic = & vport -> nic ; struct hclge_dev * hdev = vport -> back ; int ret ; nic -> pdev = hdev -> pdev ; nic -> ae_algo = & ae_algo ; nic -> numa_node_mask = hdev -> numa_node_mask ; if ( hdev -> ae_dev -> dev_type == HNAE3_DEV_KNIC ) { <S2SV_StartBug> ret = hclge_knic_setup ( vport , num_tqps ) ; <S2SV_EndBug> if ( ret ) { dev_err ( & hdev -> pdev -> dev , "knic<S2SV_blank>setup<S2SV_blank>failed<S2SV_blank>%d\\n" , ret ) ; return ret ; } } else { hclge_unic_setup ( vport , num_tqps ) ; } return 0 ; } | <S2SV_ModStart> vport , num_tqps , hdev -> num_desc |
4,391 | CWE-000 static int is_qp0 ( struct mlx4_ib_dev * dev , struct mlx4_ib_qp * qp ) { int proxy_qp0 = 0 ; int real_qp0 = 0 ; int i ; real_qp0 = ( ( mlx4_is_master ( dev -> dev ) || ! mlx4_is_mfunc ( dev -> dev ) ) && qp -> mqp . qpn >= dev -> dev -> phys_caps . base_sqpn && qp -> mqp . qpn <= dev -> dev -> phys_caps . base_sqpn + 1 ) ; if ( real_qp0 ) return 1 ; if ( mlx4_is_mfunc ( dev -> dev ) ) { for ( i = 0 ; i < dev -> dev -> caps . num_ports ; i ++ ) { <S2SV_StartBug> if ( qp -> mqp . qpn == dev -> dev -> caps . qp0_proxy [ i ] ) { <S2SV_EndBug> proxy_qp0 = 1 ; break ; } } } return proxy_qp0 ; } | <S2SV_ModStart> -> caps . qp_info <S2SV_ModEnd> [ i ] <S2SV_ModStart> [ i ] . qp0_proxy |
4,392 | CWE-000 static void dump_emmc_selected ( dumpType_t dumpType ) { int res = 0 ; u32 timer = 0 ; gfx_clear_grey ( & gfx_ctxt , 0x1B ) ; gfx_con_setpos ( & gfx_con , 0 , 0 ) ; if ( ! sd_mount ( ) ) goto out ; gfx_puts ( & gfx_con , "Checking<S2SV_blank>for<S2SV_blank>available<S2SV_blank>free<S2SV_blank>space...\\n\\n" ) ; f_getfree ( "" , & sd_fs . free_clst , NULL ) ; sdmmc_storage_t storage ; sdmmc_t sdmmc ; if ( ! sdmmc_storage_init_mmc ( & storage , & sdmmc , SDMMC_4 , SDMMC_BUS_WIDTH_8 , 4 ) ) { EPRINTF ( "Failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>eMMC." ) ; goto out ; } int i = 0 ; char sdPath [ 64 ] ; memcpy ( sdPath , "Backup/" , 7 ) ; <S2SV_StartBug> timer = get_tmr ( ) ; <S2SV_EndBug> f_mkdir ( "Backup" ) ; f_mkdir ( "Backup/Partitions" ) ; f_mkdir ( "Backup/Restore" ) ; if ( dumpType & DUMP_BOOT ) { static const u32 BOOT_PART_SIZE = 0x400000 ; emmc_part_t bootPart ; memset ( & bootPart , 0 , sizeof ( bootPart ) ) ; bootPart . lba_start = 0 ; bootPart . lba_end = ( BOOT_PART_SIZE / NX_EMMC_BLOCKSIZE ) - 1 ; for ( i = 0 ; i < 2 ; i ++ ) { memcpy ( bootPart . name , "BOOT" , 4 ) ; bootPart . name [ 4 ] = ( u8 ) ( '0' + i ) ; bootPart . name [ 5 ] = 0 ; gfx_printf ( & gfx_con , "%k%02d:<S2SV_blank>%s<S2SV_blank>(%07X-%07X)%k\\n" , 0xFF00DDFF , i , bootPart . name , bootPart . lba_start , bootPart . lba_end , 0xFFCCCCCC ) ; sdmmc_storage_set_mmc_partition ( & storage , i + 1 ) ; strcpy ( sdPath + 7 , bootPart . name ) ; res = dump_emmc_part ( sdPath , & storage , & bootPart ) ; } } if ( ( dumpType & DUMP_SYSTEM ) || ( dumpType & DUMP_USER ) || ( dumpType & DUMP_RAW ) ) { sdmmc_storage_set_mmc_partition ( & storage , 0 ) ; if ( ( dumpType & DUMP_SYSTEM ) || ( dumpType & DUMP_USER ) ) { LIST_INIT ( gpt ) ; nx_emmc_gpt_parse ( & gpt , & storage ) ; LIST_FOREACH_ENTRY ( emmc_part_t , part , & gpt , link ) { if ( ( dumpType & DUMP_USER ) == 0 && ! strcmp ( part -> name , "USER" ) ) continue ; if ( ( dumpType & DUMP_SYSTEM ) == 0 && strcmp ( part -> name , "USER" ) ) continue ; gfx_printf ( & gfx_con , "%k%02d:<S2SV_blank>%s<S2SV_blank>(%07X-%07X)%k\\n" , 0xFF00DDFF , i ++ , part -> name , part -> lba_start , part -> lba_end , 0xFFCCCCCC ) ; memcpy ( sdPath , "Backup/Partitions/" , 18 ) ; strcpy ( sdPath + 18 , part -> name ) ; res = dump_emmc_part ( sdPath , & storage , part ) ; if ( ! res ) break ; } nx_emmc_gpt_free ( & gpt ) ; } if ( dumpType & DUMP_RAW ) { const u32 RAW_AREA_NUM_SECTORS = storage . sec_cnt ; emmc_part_t rawPart ; memset ( & rawPart , 0 , sizeof ( rawPart ) ) ; rawPart . lba_start = 0 ; rawPart . lba_end = RAW_AREA_NUM_SECTORS - 1 ; strcpy ( rawPart . name , "rawnand.bin" ) ; { gfx_printf ( & gfx_con , "%k%02d:<S2SV_blank>%s<S2SV_blank>(%07X-%07X)%k\\n" , 0xFF00DDFF , i ++ , rawPart . name , rawPart . lba_start , rawPart . lba_end , 0xFFCCCCCC ) ; strcpy ( sdPath + 7 , rawPart . name ) ; res = dump_emmc_part ( sdPath , & storage , & rawPart ) ; } } } gfx_putc ( & gfx_con , '\\n' ) ; <S2SV_StartBug> gfx_printf ( & gfx_con , "Time<S2SV_blank>taken:<S2SV_blank>%d<S2SV_blank>seconds.\\n" , ( get_tmr ( ) - timer ) / 1000000 ) ; <S2SV_EndBug> sdmmc_storage_end ( & storage ) ; if ( res && 0 ) gfx_printf ( & gfx_con , "\\n%kFinished<S2SV_blank>and<S2SV_blank>verified!%k\\nPress<S2SV_blank>any<S2SV_blank>key...\\n" , 0xFF96FF00 , 0xFFCCCCCC ) ; else if ( res ) gfx_printf ( & gfx_con , "\\nFinished!<S2SV_blank>Press<S2SV_blank>any<S2SV_blank>key...\\n" ) ; out : ; sd_unmount ( ) ; btn_wait ( ) ; } | <S2SV_ModStart> 7 ) ; f_mkdir ( "Backup" ) ; f_mkdir ( "Backup/Partitions" ) ; f_mkdir ( "Backup/Restore" ) ; timer = get_tmr_s ( <S2SV_ModEnd> ) ; if <S2SV_ModStart> , "Time<S2SV_blank>taken:<S2SV_blank>%d<S2SV_blank>seconds.\\n" , get_tmr_s <S2SV_ModEnd> ( ) - <S2SV_ModStart> - timer ) <S2SV_ModEnd> ; sdmmc_storage_end ( |
4,393 | CWE-000 static ssize_t f2fs_direct_IO ( struct kiocb * iocb , struct iov_iter * iter ) { struct address_space * mapping = iocb -> ki_filp -> f_mapping ; struct inode * inode = mapping -> host ; <S2SV_StartBug> size_t count = iov_iter_count ( iter ) ; <S2SV_EndBug> loff_t offset = iocb -> ki_pos ; int rw = iov_iter_rw ( iter ) ; int err ; <S2SV_StartBug> err = check_direct_IO ( inode , iter , offset ) ; <S2SV_EndBug> if ( err ) return err ; if ( __force_buffered_io ( inode , rw ) ) return 0 ; trace_f2fs_direct_IO_enter ( inode , offset , count , rw ) ; <S2SV_StartBug> down_read ( & F2FS_I ( inode ) -> dio_rwsem [ rw ] ) ; <S2SV_EndBug> err = blockdev_direct_IO ( iocb , inode , iter , get_data_block_dio ) ; up_read ( & F2FS_I ( inode ) -> dio_rwsem [ rw ] ) ; if ( rw == WRITE ) { <S2SV_StartBug> if ( err > 0 ) { <S2SV_EndBug> f2fs_update_iostat ( F2FS_I_SB ( inode ) , APP_DIRECT_IO , err ) ; set_inode_flag ( inode , FI_UPDATE_WRITE ) ; } else if ( err < 0 ) { f2fs_write_failed ( mapping , offset + count ) ; } } trace_f2fs_direct_IO_exit ( inode , offset , count , rw , err ) ; return err ; } | <S2SV_ModStart> -> host ; struct f2fs_sb_info * sbi = F2FS_I_SB ( inode ) ; <S2SV_ModStart> int err ; enum rw_hint hint = iocb -> ki_hint ; int whint_mode = sbi -> whint_mode ; <S2SV_ModStart> rw ) ; if ( rw == WRITE && whint_mode == WHINT_MODE_OFF ) iocb -> ki_hint = WRITE_LIFE_NOT_SET ; <S2SV_ModStart> { if ( whint_mode == WHINT_MODE_OFF ) iocb -> ki_hint = hint ; if ( |
4,394 | CWE-000 test_f test_leading_zeros ( void ) { <S2SV_StartBug> int a = 0x0000F234 ; <S2SV_EndBug> # ifdef __ARCH_64__ <S2SV_StartBug> long b = 0x00000000F2345678 ; <S2SV_EndBug> # elif defined ( __ARCH_32__ ) <S2SV_StartBug> long b = 0x00000F234 ; <S2SV_EndBug> # endif <S2SV_StartBug> long long c = 0x0000000000F23456 ; <S2SV_EndBug> T_EXPECT ( leading_0_int ( a ) , 4 * 4 ) ; # ifdef __ARCH_64__ T_EXPECT ( leading_0_long ( b ) , 8 * 4 ) ; # elif defined ( __ARCH_32__ ) T_EXPECT ( leading_0_long ( b ) , 5 * 4 ) ; # endif T_EXPECT ( leading_0_longlong ( c ) , 10 * 4 ) ; a = 0xF0000000 ; # ifdef __ARCH_64__ b = 0xF000000000000000 ; # elif defined ( __ARCH_32__ ) b = 0xF0000000 ; # endif c = 0xF000000000000000 ; T_EXPECT ( leading_0_int ( a ) , 0 ) ; T_EXPECT ( leading_0_long ( b ) , 0 ) ; T_EXPECT ( leading_0_longlong ( c ) , 0 ) ; a = 0 ; b = 0 ; c = 0 ; T_EXPECT ( leading_0_int ( a ) , sizeof ( typeof ( a ) ) << 3 ) ; T_EXPECT ( leading_0_long ( b ) , sizeof ( typeof ( b ) ) << 3 ) ; T_EXPECT ( leading_0_longlong ( c ) , sizeof ( typeof ( c ) ) << 3 ) ; } | <S2SV_ModStart> void ) { unsigned <S2SV_ModStart> # ifdef __ARCH_64__ unsigned <S2SV_ModStart> ( __ARCH_32__ ) unsigned <S2SV_ModStart> ; # endif unsigned |
4,395 | CWE-000 static void ble_evt_dispatch ( ble_evt_t * p_ble_evt ) { ble_conn_state_on_ble_evt ( p_ble_evt ) ; pm_on_ble_evt ( p_ble_evt ) ; ble_conn_params_on_ble_evt ( p_ble_evt ) ; on_ble_evt ( p_ble_evt ) ; if ( ! m_ble_power_down ) { ble_advertising_on_ble_evt ( p_ble_evt ) ; } ble_iccs_on_ble_evt ( p_ble_evt ) ; <S2SV_StartBug> ic_ez_ltc_on_ble_evt ( p_ble_evt ) ; <S2SV_EndBug> ble_dfu_on_ble_evt ( & m_dfus , p_ble_evt ) ; } | <S2SV_ModStart> p_ble_evt ) ; <S2SV_ModEnd> ble_dfu_on_ble_evt ( & |
4,396 | CWE-000 static const char * duration_to_str ( const uint64_t * duration ) { uint64_t dur_conv = * duration ; switch ( output_params . duration_conv ) { case OUTPUT_DURATION_CONV_NONE : snprintf ( global_str , sizeof ( global_str ) , "%" PRIu64 , * duration ) ; break ; case OUTPUT_DURATION_CONV_STR : { size_t msec ; size_t sec ; size_t min ; msec = dur_conv % 1000 ; dur_conv /= 1000 ; sec = dur_conv % 60 ; dur_conv /= 60 ; min = dur_conv % 60 ; dur_conv /= 60 ; snprintf ( global_str , sizeof ( global_str ) , "%2.2" PRIu64 ":%2.2zu:%2.2zu.%3.3zu" , dur_conv , min , sec , msec ) ; break ; } <S2SV_StartBug> default : <S2SV_EndBug> assert ( ! "unknown<S2SV_blank>duration<S2SV_blank>conversion" ) ; } return global_str ; } | <S2SV_ModStart> break ; } case OUTPUT_DURATION_CONV_UNSET : assert ( ! "illegal<S2SV_blank>duration<S2SV_blank>conversion" ) ; |
4,397 | CWE-000 static int _win32_error_unmap ( slurp_t * slurp , const char * filename , const char * function ) { DWORD err = GetLastError ( ) ; LPTSTR errmsg ; FormatMessage ( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS , NULL , <S2SV_StartBug> err , MAKELANGID ( LANG_NEUTRAL , SUBLANG_DEFAULT ) , errmsg , 0 , NULL ) ; <S2SV_EndBug> log_appendf ( 4 , "%s:<S2SV_blank>%s:<S2SV_blank>error<S2SV_blank>%lu:" , filename , function , err ) ; log_appendf ( 4 , "<S2SV_blank><S2SV_blank>%s" , errmsg ) ; LocalFree ( errmsg ) ; _win32_unmap ( slurp ) ; return 0 ; } | <S2SV_ModStart> SUBLANG_DEFAULT ) , ( LPTSTR ) ( & errmsg ) <S2SV_ModEnd> , 0 , |
4,398 | CWE-000 static inline void reset_page_flags ( page_index_t page ) { page_table [ page ] . scan_start_offset_ = 0 ; page_table [ page ] . allocated = page_table [ page ] . write_protected = page_table [ page ] . write_protected_cleared <S2SV_StartBug> = page_table [ page ] . dont_move = page_table [ page ] . has_pins <S2SV_EndBug> = page_table [ page ] . large_object = 0 ; } | <S2SV_ModStart> page ] . filler <S2SV_ModEnd> = page_table [ |
4,399 | CWE-000 static void CommitTransaction ( void ) { TransactionState s = CurrentTransactionState ; TransactionId latestXid ; ShowTransactionState ( "CommitTransaction" ) ; if ( s -> state != TRANS_INPROGRESS ) elog ( WARNING , "CommitTransaction<S2SV_blank>while<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>state" , TransStateAsString ( s -> state ) ) ; Assert ( s -> parent == NULL ) ; for ( ; ; ) { AfterTriggerFireDeferred ( ) ; if ( ! PreCommit_Portals ( false ) ) break ; } CallXactCallbacks ( XACT_EVENT_PRE_COMMIT ) ; AfterTriggerEndXact ( true ) ; PreCommit_on_commit_actions ( ) ; AtEOXact_LargeObject ( true ) ; PreCommit_CheckForSerializationFailure ( ) ; PreCommit_Notify ( ) ; HOLD_INTERRUPTS ( ) ; AtEOXact_RelationMap ( true ) ; s -> state = TRANS_COMMIT ; latestXid = RecordTransactionCommit ( ) ; TRACE_POSTGRESQL_TRANSACTION_COMMIT ( MyProc -> lxid ) ; ProcArrayEndTransaction ( MyProc , latestXid ) ; CallXactCallbacks ( XACT_EVENT_COMMIT ) ; ResourceOwnerRelease ( TopTransactionResourceOwner , RESOURCE_RELEASE_BEFORE_LOCKS , true , true ) ; AtEOXact_Buffers ( true ) ; AtEOXact_RelationCache ( true ) ; AtEOXact_Inval ( true ) ; AtEOXact_MultiXact ( ) ; ResourceOwnerRelease ( TopTransactionResourceOwner , RESOURCE_RELEASE_LOCKS , true , true ) ; ResourceOwnerRelease ( TopTransactionResourceOwner , RESOURCE_RELEASE_AFTER_LOCKS , true , true ) ; smgrDoPendingDeletes ( true ) ; <S2SV_StartBug> AtEOXact_CatCache ( true ) ; <S2SV_EndBug> AtCommit_Notify ( ) ; AtEOXact_GUC ( true , 1 ) ; AtEOXact_SPI ( true ) ; AtEOXact_on_commit_actions ( true ) ; AtEOXact_Namespace ( true ) ; AtEOXact_SMgr ( ) ; AtEOXact_Files ( ) ; AtEOXact_ComboCid ( ) ; AtEOXact_HashTables ( true ) ; AtEOXact_PgStat ( true ) ; AtEOXact_Snapshot ( true ) ; pgstat_report_xact_timestamp ( 0 ) ; CurrentResourceOwner = NULL ; ResourceOwnerDelete ( TopTransactionResourceOwner ) ; s -> curTransactionOwner = NULL ; CurTransactionResourceOwner = NULL ; TopTransactionResourceOwner = NULL ; AtCommit_Memory ( ) ; s -> transactionId = InvalidTransactionId ; s -> subTransactionId = InvalidSubTransactionId ; s -> nestingLevel = 0 ; s -> gucNestLevel = 0 ; s -> childXids = NULL ; s -> nChildXids = 0 ; s -> maxChildXids = 0 ; s -> state = TRANS_DEFAULT ; RESUME_INTERRUPTS ( ) ; } | <S2SV_ModStart> true ) ; <S2SV_ModEnd> AtCommit_Notify ( ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.