Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,400 | CWE-000 static MmEntry * init_mm_entry ( struct lazy_pages_info * lpi ) { struct cr_img * img ; MmEntry * mm ; int ret ; img = open_image ( CR_FD_MM , O_RSTR , lpi -> pid ) ; if ( ! img ) return NULL ; ret = pb_read_one_eof ( img , & mm , PB_MM ) ; close_image ( img ) ; if ( ret == - 1 ) return NULL ; <S2SV_StartBug> pr_debug ( "Found<S2SV_blank>%zd<S2SV_blank>VMAs<S2SV_blank>in<S2SV_blank>image\\n" , mm -> n_vmas ) ; <S2SV_EndBug> return mm ; } | <S2SV_ModStart> return NULL ; lp_debug ( lpi , <S2SV_ModEnd> "Found<S2SV_blank>%zd<S2SV_blank>VMAs<S2SV_blank>in<S2SV_blank>image\\n" , mm |
1,401 | CWE-000 void test_AvrOperatorTable_given_cpse_r16_r17 ( void ) { <S2SV_StartBug> uint8_t pc ; <S2SV_EndBug> uint8_t codeMemory [ ] = { 0x01 , 0x13 , 0x0f , 0x01 , } ; uint8_t * progCounter = codeMemory ; flash = codeMemory ; r [ 16 ] = 0x12 ; r [ 17 ] = 0x12 ; <S2SV_StartBug> pc = simulateOneInstruction ( progCounter ) ; <S2SV_EndBug> <S2SV_StartBug> TEST_ASSERT_EQUAL ( 4 , pc ) ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { int relAddr <S2SV_ModEnd> ; uint8_t codeMemory <S2SV_ModStart> = 0x12 ; relAddr <S2SV_ModEnd> = simulateOneInstruction ( <S2SV_ModStart> ( 4 , relAddr <S2SV_ModEnd> ) ; } |
1,402 | CWE-000 void popAdj ( Adj * * inicio , int id ) { if ( * inicio == NULL ) { return ; } Adj * cursor = * inicio ; Adj * cursorProx = cursor -> prox ; if ( cursor -> id == id ) { * inicio = ( * inicio ) -> prox ; free ( cursor ) ; return ; } while ( cursorProx != NULL ) { if ( cursorProx -> id == id ) { cursor -> prox = cursorProx -> prox ; free ( cursorProx ) ; return ; } cursor = cursorProx ; cursorProx = cursorProx -> prox ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> prox ; } printf ( "\\nATENCAO:POPADJ<S2SV_blank>CHAMADO<S2SV_blank>MAS<S2SV_blank>ELEM<S2SV_blank>NAO<S2SV_blank>ENCONTRADO\\n" ) ; |
1,403 | CWE-000 <S2SV_StartBug> settings_ctx_t * health_context_get_settings_ctx ( health_ctx_t * health_ctx ) <S2SV_EndBug> { return health_ctx -> settings_ctx ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> pk_settings_ctx_t <S2SV_ModEnd> * health_context_get_settings_ctx ( |
1,404 | CWE-000 void intel_dp_start_link_train ( struct intel_dp * intel_dp ) { struct intel_connector * intel_connector = intel_dp -> attached_connector ; if ( ! intel_dp_link_training_clock_recovery ( intel_dp ) ) goto failure_handling ; if ( ! intel_dp_link_training_channel_equalization ( intel_dp ) ) goto failure_handling ; DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>Link<S2SV_blank>Training<S2SV_blank>Passed<S2SV_blank>at<S2SV_blank>Link<S2SV_blank>Rate<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>Lane<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%d" , intel_connector -> base . base . id , intel_connector -> base . name , intel_dp -> link_rate , intel_dp -> lane_count ) ; return ; failure_handling : <S2SV_StartBug> if ( ! intel_dp_is_edp ( intel_dp ) ) { <S2SV_EndBug> DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>Link<S2SV_blank>Training<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>link<S2SV_blank>rate<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>lane<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%d" , intel_connector -> base . base . id , intel_connector -> base . name , intel_dp -> link_rate , intel_dp -> lane_count ) ; if ( ! intel_dp_get_link_train_fallback_values ( intel_dp , intel_dp -> link_rate , intel_dp -> lane_count ) ) schedule_work ( & intel_connector -> modeset_retry_work ) ; <S2SV_StartBug> } else { <S2SV_EndBug> DRM_ERROR ( "[CONNECTOR:%d:%s]<S2SV_blank>Link<S2SV_blank>Training<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>link<S2SV_blank>rate<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>lane<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%d" , intel_connector -> base . base . id , intel_connector -> base . name , intel_dp -> link_rate , intel_dp -> lane_count ) ; } return ; } | <S2SV_ModStart> ; failure_handling : <S2SV_ModEnd> DRM_DEBUG_KMS ( "[CONNECTOR:%d:%s]<S2SV_blank>Link<S2SV_blank>Training<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>link<S2SV_blank>rate<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>lane<S2SV_blank>count<S2SV_blank>=<S2SV_blank>%d" <S2SV_ModStart> modeset_retry_work ) ; <S2SV_ModEnd> return ; } |
1,405 | CWE-000 SDL_Surface * TTF_RenderUNICODE_Shaded ( TTF_Font * font , const Uint16 * text , SDL_Color fg , SDL_Color bg ) { int xstart ; int width ; int height ; SDL_Surface * textbuf ; SDL_Palette * palette ; int index ; int rdiff ; int gdiff ; int bdiff ; const Uint16 * ch ; Uint8 * src ; Uint8 * dst ; Uint8 * dst_check ; int swapped ; int row , col ; FT_Bitmap * current ; c_glyph * glyph ; FT_Error error ; FT_Long use_kerning ; FT_UInt prev_index = 0 ; <S2SV_StartBug> if ( ( TTF_SizeUNICODE ( font , text , & width , & height ) < 0 ) || ! width ) { <S2SV_EndBug> TTF_SetError ( "Text<S2SV_blank>has<S2SV_blank>zero<S2SV_blank>width" ) ; return NULL ; } textbuf = SDL_AllocSurface ( SDL_SWSURFACE , width , height , 8 , 0 , 0 , 0 , 0 ) ; if ( textbuf == NULL ) { return NULL ; } dst_check = ( Uint8 * ) textbuf -> pixels + textbuf -> pitch * textbuf -> h ; palette = textbuf -> format -> palette ; rdiff = fg . r - bg . r ; gdiff = fg . g - bg . g ; bdiff = fg . b - bg . b ; for ( index = 0 ; index < NUM_GRAYS ; ++ index ) { palette -> colors [ index ] . r = bg . r + ( index * rdiff ) / ( NUM_GRAYS - 1 ) ; palette -> colors [ index ] . g = bg . g + ( index * gdiff ) / ( NUM_GRAYS - 1 ) ; palette -> colors [ index ] . b = bg . b + ( index * bdiff ) / ( NUM_GRAYS - 1 ) ; } <S2SV_StartBug> use_kerning = FT_HAS_KERNING ( font -> face ) && font -> kerning ; <S2SV_EndBug> xstart = 0 ; swapped = TTF_byteswapped ; for ( ch = text ; * ch ; ++ ch ) { Uint16 c = * ch ; if ( c == UNICODE_BOM_NATIVE ) { swapped = 0 ; if ( text == ch ) { ++ text ; } continue ; } if ( c == UNICODE_BOM_SWAPPED ) { swapped = 1 ; if ( text == ch ) { ++ text ; } continue ; } if ( swapped ) { c = SDL_Swap16 ( c ) ; } error = Find_Glyph ( font , c , CACHED_METRICS | CACHED_PIXMAP ) ; if ( error ) { TTF_SetFTError ( "Couldn\'t<S2SV_blank>find<S2SV_blank>glyph" , error ) ; SDL_FreeSurface ( textbuf ) ; return NULL ; } glyph = font -> current ; width = glyph -> pixmap . width ; if ( font -> outline <= 0 && width > glyph -> maxx - glyph -> minx ) { width = glyph -> maxx - glyph -> minx ; } if ( use_kerning && prev_index && glyph -> index ) { FT_Vector delta ; FT_Get_Kerning ( font -> face , prev_index , glyph -> index , ft_kerning_default , & delta ) ; xstart += delta . x >> 6 ; } current = & glyph -> pixmap ; for ( row = 0 ; row < current -> rows ; ++ row ) { <S2SV_StartBug> if ( ( xstart + glyph -> minx ) < 0 ) { <S2SV_EndBug> xstart -= ( xstart + glyph -> minx ) ; } if ( ( row + glyph -> yoffset ) < 0 ) { continue ; } if ( ( row + glyph -> yoffset ) >= textbuf -> h ) { continue ; } dst = ( Uint8 * ) textbuf -> pixels + ( row + glyph -> yoffset ) * textbuf -> pitch + xstart + glyph -> minx ; src = current -> buffer + row * current -> pitch ; for ( col = width ; col > 0 && dst < dst_check ; -- col ) { * dst ++ |= * src ++ ; } } xstart += glyph -> advance ; if ( TTF_HANDLE_STYLE_BOLD ( font ) ) { xstart += font -> glyph_overhang ; } prev_index = glyph -> index ; } if ( TTF_HANDLE_STYLE_UNDERLINE ( font ) ) { row = TTF_underline_top_row ( font ) ; TTF_drawLine_Shaded ( font , textbuf , row ) ; } if ( TTF_HANDLE_STYLE_STRIKETHROUGH ( font ) ) { row = TTF_strikethrough_top_row ( font ) ; TTF_drawLine_Shaded ( font , textbuf , row ) ; } return textbuf ; } | <S2SV_ModStart> if ( ( TTF_SizeUNICODE_Internal <S2SV_ModEnd> ( font , <S2SV_ModStart> , & height , & xstart <S2SV_ModStart> font -> kerning <S2SV_ModEnd> ; swapped = <S2SV_ModStart> if ( ( <S2SV_ModEnd> row + glyph |
1,406 | CWE-000 wrp_wasm_mdle_t * wrp_instantiate_mdle ( wrp_vm_t * vm , wrp_buf_t * buf ) { if ( vm -> mdle != NULL ) { return NULL ; } wrp_wasm_meta_t meta = { 0 } ; vm -> err = WRP_ERR_UNKNOWN ; if ( ( vm -> err = wrp_scan_mdle ( buf , & meta ) ) != WRP_SUCCESS ) { return NULL ; } <S2SV_StartBug> if ( ( vm -> err = wrp_check_meta ( & meta ) != WRP_SUCCESS ) ) { <S2SV_EndBug> return NULL ; } size_t mdle_sz = wrp_mdle_sz ( & meta ) ; wrp_wasm_mdle_t * mdle = vm -> alloc_fn ( mdle_sz , 64 ) ; if ( mdle == NULL ) { vm -> err = WRP_ERR_MEMORY_ALLOCATION_FAILED ; return mdle ; } wrp_mdle_init ( & meta , mdle ) ; if ( ( vm -> err = wrp_load_mdle ( vm , buf , mdle ) ) != WRP_SUCCESS ) { wrp_destroy_mdle ( vm , mdle ) ; vm -> mdle = NULL ; return NULL ; } if ( ( vm -> err = wrp_type_check_mdle ( vm , mdle ) ) != WRP_SUCCESS ) { wrp_destroy_mdle ( vm , mdle ) ; vm -> mdle = NULL ; return NULL ; } return mdle ; } | <S2SV_ModStart> & meta ) ) != WRP_SUCCESS <S2SV_ModEnd> ) { return |
1,407 | CWE-000 int main ( int ac , char * * av ) { int rval = 0 ; QSexactStart ( ) ; if ( ac > 1 ) { printf ( "Usage:<S2SV_blank>%s\\n" , * av ) ; rval = EXIT_FAILURE ; goto CLEANUP ; } QSexact_set_precision ( 128 ) ; static test_func * test_functions [ ] = { test_new_column , test_new_column_without_name , test_new_column_with_duplicate_name , test_delete_row , test_delete_invalid_row , test_delete_row_in_empty_problem , test_delete_column , test_delete_invalid_column , test_delete_column_in_empty_problem , test_row_count , test_col_count , <S2SV_StartBug> test_solution_is_optimal , <S2SV_EndBug> test_solution_objective , test_solution_get_variables , test_solution_get_dual_values , test_write_problem_to_file } ; int count = sizeof ( test_functions ) / sizeof ( test_functions [ 0 ] ) ; printf ( "1..%i\\n" , count ) ; int i ; for ( i = 0 ; i < count ; i ++ ) { int test_id = i + 1 ; test_functions [ i ] ( test_id ) ; } CLEANUP : QSexactClear ( ) ; return rval ; } | <S2SV_ModStart> , test_col_count , test_solve_no_constraints , |
1,408 | CWE-000 void td_fn_rctrl_each ( qk_tap_dance_state_t * state , void * user_data ) { if ( ! td_fn_rctrl_data . started ) { td_fn_rctrl_data . fn_on = IS_LAYER_ON ( L_FN ) ; td_fn_rctrl_data . started = true ; } <S2SV_StartBug> if ( state -> count & 1 ) { <S2SV_EndBug> layer_on ( L_FN ) ; } <S2SV_StartBug> if ( state -> count & 2 ) { <S2SV_EndBug> <S2SV_StartBug> if ( ! ( state -> count & 1 ) && ! td_fn_rctrl_data . fn_on ) { <S2SV_EndBug> layer_off ( L_FN ) ; } register_code ( KC_RCTL ) ; } } | <S2SV_ModStart> state -> count == 1 || state -> count == 3 <S2SV_ModEnd> ) { layer_on <S2SV_ModStart> ) ; } else <S2SV_ModStart> state -> count == <S2SV_ModEnd> 2 ) { <S2SV_ModStart> { if ( <S2SV_ModEnd> ! td_fn_rctrl_data . |
1,409 | CWE-000 char * XMLOpenDocument ( const char * rootTag , const char * xslStyle ) { const char * doctype = "<?xml<S2SV_blank>version=\\"1.0\\"<S2SV_blank>encoding=\\"ISO-8859-1\\"?>\\n" ; const char * styleStart = "<?xml-stylesheet<S2SV_blank>type=\\"text/xsl\\"<S2SV_blank>href=\\"" ; const char * styleEnd = "\\"?>\\n" ; const int sizeStyleStart = SDL_strlen ( styleStart ) ; const int sizeStyleEnd = SDL_strlen ( styleEnd ) ; const int sizeStyleSheetName = SDL_strlen ( xslStyle ) ; const int tempSize = sizeStyleStart + sizeStyleEnd + sizeStyleSheetName + 1 ; char * style = SDL_malloc ( tempSize ) ; memset ( style , 0 , tempSize ) ; <S2SV_StartBug> snprintf ( style , tempSize , "%s%s%s" , styleStart , xslStyle , styleEnd ) ; <S2SV_EndBug> memset ( buffer , 0 , bufferSize ) ; <S2SV_StartBug> snprintf ( buffer , bufferSize , "<%s>" , rootTag ) ; <S2SV_EndBug> AddOpenTag ( rootTag ) ; root = rootTag ; const int doctypeSize = SDL_strlen ( doctype ) ; const int styleSize = SDL_strlen ( style ) ; const int tagSize = SDL_strlen ( buffer ) ; const int size = doctypeSize + styleSize + tagSize + 1 ; char * retBuf = SDL_malloc ( size ) ; strcat ( retBuf , doctype ) ; strcat ( retBuf , style ) ; strcat ( retBuf , buffer ) ; SDL_free ( style ) ; return retBuf ; } | <S2SV_ModStart> tempSize ) ; SDL_snprintf <S2SV_ModEnd> ( style , <S2SV_ModStart> bufferSize ) ; SDL_snprintf <S2SV_ModEnd> ( buffer , |
1,410 | CWE-000 static void destroy_pager ( GtkWidget * widget , PagerData * pager ) <S2SV_StartBug> { <S2SV_EndBug> g_object_unref ( pager -> settings ) ; if ( pager -> properties_dialog ) gtk_widget_destroy ( pager -> properties_dialog ) ; g_free ( pager ) ; } | <S2SV_ModStart> pager ) { g_signal_handlers_disconnect_by_data ( pager -> settings , pager ) ; |
1,411 | CWE-000 void disable_border ( void ) { border_enabled . v = 0 ; modificado_border . v = 1 ; recalcular_get_total_ancho_rainbow ( ) ; recalcular_get_total_alto_rainbow ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; init_cache_putpixel ( ) ; |
1,412 | CWE-000 static void __run_hrtimer ( struct hrtimer * timer , ktime_t * now ) { struct hrtimer_clock_base * base = timer -> base ; struct hrtimer_cpu_base * cpu_base = base -> cpu_base ; enum hrtimer_restart ( * fn ) ( struct hrtimer * ) ; int restart ; WARN_ON ( ! irqs_disabled ( ) ) ; debug_deactivate ( timer ) ; __remove_hrtimer ( timer , base , HRTIMER_STATE_CALLBACK , 0 ) ; timer_stats_account_hrtimer ( timer ) ; fn = timer -> function ; raw_spin_unlock ( & cpu_base -> lock ) ; trace_hrtimer_expire_entry ( timer , now ) ; exynos_ss_hrtimer ( timer , & now -> tv64 , fn , ESS_FLAG_IN ) ; restart = fn ( timer ) ; exynos_ss_hrtimer ( timer , & now -> tv64 , fn , ESS_FLAG_OUT ) ; trace_hrtimer_expire_exit ( timer ) ; raw_spin_lock ( & cpu_base -> lock ) ; <S2SV_StartBug> if ( restart != HRTIMER_NORESTART ) { <S2SV_EndBug> <S2SV_StartBug> BUG_ON ( timer -> state != HRTIMER_STATE_CALLBACK ) ; <S2SV_EndBug> enqueue_hrtimer ( timer , base ) ; <S2SV_StartBug> } <S2SV_EndBug> WARN_ON_ONCE ( ! ( timer -> state & HRTIMER_STATE_CALLBACK ) ) ; timer -> state &= ~ HRTIMER_STATE_CALLBACK ; } | <S2SV_ModStart> restart != HRTIMER_NORESTART && ! <S2SV_ModEnd> ( timer -> <S2SV_ModStart> timer -> state & HRTIMER_STATE_ENQUEUED ) ) <S2SV_ModEnd> enqueue_hrtimer ( timer <S2SV_ModStart> base ) ; <S2SV_ModEnd> WARN_ON_ONCE ( ! |
1,413 | CWE-000 static char * netlink_get_info ( int ifindex , uint8_t nl_cmd , const char * header ) { struct nl_sock * sock ; struct nl_msg * msg ; struct nl_cb * cb ; int family ; struct print_opts opts = { . read_opt = 0 , . nl_cmd = nl_cmd , . remaining_header = NULL , . static_header = header , } ; sock = nl_socket_alloc ( ) ; if ( ! sock ) return NULL ; genl_connect ( sock ) ; family = genl_ctrl_resolve ( sock , BATADV_NL_NAME ) ; if ( family < 0 ) <S2SV_StartBug> return NULL ; <S2SV_EndBug> msg = nlmsg_alloc ( ) ; if ( ! msg ) { nl_socket_free ( sock ) ; return NULL ; } genlmsg_put ( msg , NL_AUTO_PID , NL_AUTO_SEQ , family , 0 , 0 , BATADV_CMD_GET_MESH_INFO , 1 ) ; nla_put_u32 ( msg , BATADV_ATTR_MESH_IFINDEX , ifindex ) ; nl_send_auto_complete ( sock , msg ) ; nlmsg_free ( msg ) ; cb = nl_cb_alloc ( NL_CB_DEFAULT ) ; if ( ! cb ) goto err_free_sock ; nl_cb_set ( cb , NL_CB_VALID , NL_CB_CUSTOM , info_callback , & opts ) ; nl_cb_err ( cb , NL_CB_CUSTOM , print_error , NULL ) ; nl_recvmsgs ( sock , cb ) ; err_free_sock : nl_socket_free ( sock ) ; return opts . remaining_header ; } | <S2SV_ModStart> < 0 ) { nl_socket_free ( sock ) ; return NULL ; } <S2SV_ModEnd> msg = nlmsg_alloc |
1,414 | CWE-000 void binomialfr_seqbial_sample ( unsigned long obs_p1 , unsigned long obs_p2 , unsigned long exp_ner1 , unsigned long exp_ner2 , double * lnfact , double * lnprior , struct MCMCsample * next , double random1 , unsigned long pmc ) { double pval0 ; unsigned long i , j ; double sumtot ; sumtot = 0. ; for ( i = 0 ; i < pmc + 1 ; i ++ ) { j = minint ( ( unsigned long int ) i , ( int ) pmc - ( unsigned long int ) i ) ; sumtot += exp ( lnbinomialfr ( obs_p1 - exp_ner1 + exp_ner2 , obs_p2 - exp_ner2 + exp_ner1 , ( double ) i / pmc , lnfact ) + lnprior [ j ] ) ; } <S2SV_StartBug> pval0 = 0. ; <S2SV_EndBug> for ( i = 0 ; i < pmc ; i ++ ) { j = minint ( ( unsigned long int ) i , ( unsigned long int ) pmc - ( int ) i ) ; pval0 += exp ( lnbinomialfr ( obs_p1 - exp_ner1 + exp_ner2 , obs_p2 - exp_ner2 + exp_ner1 , ( double ) i / pmc , lnfact ) + lnprior [ j ] ) / sumtot ; if ( pval0 >= random1 ) break ; } next -> frp1 = i ; if ( ( ( ( obs_p1 - exp_ner1 + exp_ner2 ) > 0 ) + ( ( obs_p2 - exp_ner2 + exp_ner1 ) > 0 ) ) == 2 && ( i == 0 || i == pmc ) ) { printf ( "\\nError:<S2SV_blank>binomial<S2SV_blank>assigns<S2SV_blank>an<S2SV_blank>impossible<S2SV_blank>value.\\n" ) ; exit ( 1 ) ; } if ( i > pmc ) { printf ( "\\nError:<S2SV_blank>binomial<S2SV_blank>assigns<S2SV_blank>an<S2SV_blank>impossible<S2SV_blank>value.\\n" ) ; exit ( 1 ) ; } return ; } | <S2SV_ModStart> ) ; } if ( sumtot == 0.0 ) { next -> frp1 = ( obs_p1 - exp_ner1 + exp_ner2 ) / ( obs_p1 + obs_p2 ) ; return ; } |
1,415 | CWE-000 void p1move ( ) { int k , x = 1 ; <S2SV_StartBug> printf ( "\\nWhere<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>play<S2SV_blank>P1:" ) ; <S2SV_EndBug> scanf ( "%d" , & k ) ; if ( k > 0 && k < 10 ) for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 3 ; j ++ ) { if ( x ++ == k ) { if ( checkexist ( a [ i ] [ j ] ) ) a [ i ] [ j ] = 1 ; else { printf ( "THAT<S2SV_blank>POSITION<S2SV_blank>IS<S2SV_blank>ALREAY<S2SV_blank>PLAYED" ) ; p1move ( ) ; } } } else { printf ( "INVALID<S2SV_blank>INPUT!" ) ; p1move ( ) ; } } | <S2SV_ModStart> ; printf ( "\\nWHERE<S2SV_blank>YOU<S2SV_blank>WANT<S2SV_blank>TO<S2SV_blank>PLAY<S2SV_blank>P1:" <S2SV_ModEnd> ) ; scanf |
1,416 | CWE-000 bool page_list_copy_page_table ( page_list_t * l , page_list_t * p ) { l -> page_table = kmalloc ( sizeof ( page_table_t ) ) ; if ( ! l -> page_table ) { kfree ( l ) ; return false ; } l -> page_table -> pages = page_get_aligned_four_kb ( ) ; if ( ! l -> page_table -> pages ) { kfree ( l -> page_table ) ; kfree ( l ) ; return false ; } for ( uint32_t z = 0 ; z < NUM_PAGE_TABLE_ENTRIES ; z ++ ) { if ( page_list_read_bitmap ( p -> page_table -> cow , z ) ) { <S2SV_StartBug> p -> page_table -> pages [ z ] = vm_create_page_table_entry ( p -> page_table -> pages [ z ] & ~ ( FOUR_KB_SIZE - 1 ) , <S2SV_EndBug> <S2SV_StartBug> p -> permissions & ~ MEMORY_WRITE ) ; <S2SV_EndBug> } l -> page_table -> pages [ z ] = p -> page_table -> pages [ z ] ; } memset ( l -> page_table -> owners , 0 , NUM_PAGE_TABLE_ENTRIES / 8 ) ; memcpy ( l -> page_table -> cow , p -> page_table -> cow , NUM_PAGE_TABLE_ENTRIES / 8 ) ; return true ; } | <S2SV_ModStart> ) ) { uint32_t mask = <S2SV_ModEnd> ( FOUR_KB_SIZE - <S2SV_ModStart> - 1 ) ; if ( p -> mmapped ) { p -> page_table -> pages [ z ] = vm_create_page_table_entry ( p -> page_table -> pages [ z ] & ~ mask , ( p -> page_table -> pages [ z ] & mask ) & ~ MEMORY_WRITE ) ; } else { p -> page_table -> pages [ z ] = vm_create_page_table_entry ( p -> page_table -> pages [ z ] & ~ mask <S2SV_ModStart> MEMORY_WRITE ) ; } |
1,417 | CWE-000 __attribute__ ( ( nothrow , warn_unused_result ) ) int main ( void ) { darr_t darr ; time_t t ; int nums [ 10 ] ; size_t ntest = 100 ; size_t testi ; t = time ( NULL ) ; srand ( ( unsigned int ) t ) ; error_check ( init_test ( & darr ) != 0 ) return - 1 ; get_nums ( nums , ARRSZ ( nums ) ) ; for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { <S2SV_StartBug> error_check ( insert_front_darr ( & darr , ( size_t ) 0 , nums + testi ) != 0 ) <S2SV_EndBug> return - 1 ; error_check ( trim_cap_darr ( & darr , testi + 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { remove_front_darr ( & darr , ( size_t ) 0 , nums + testi ) ; error_check ( trim_cap_darr ( & darr , ARRSZ ( nums ) - testi - 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; printf ( "nums[%d]:<S2SV_blank>%d\\n" , ( int ) testi , nums [ testi ] ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { error_check ( insert_front_darr ( & darr , ( size_t ) 0 , nums + testi ) != 0 ) return - 1 ; error_check ( trim_cap_darr ( & darr , testi + 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { remove_front_darr ( & darr , ( size_t ) 0 , nums + testi ) ; error_check ( trim_cap_darr ( & darr , ARRSZ ( nums ) - testi - 1 ) != 0 ) return - 1 ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { <S2SV_StartBug> error_check ( insert_front_darr ( & darr , darr . n - 1 , nums + testi ) != 0 ) <S2SV_EndBug> return - 1 ; error_check ( trim_cap_darr ( & darr , testi + 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { remove_front_darr ( & darr , darr . n - 1 , nums + testi ) ; error_check ( trim_cap_darr ( & darr , ARRSZ ( nums ) - testi - 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; printf ( "nums[%d]:<S2SV_blank>%d\\n" , ( int ) testi , nums [ testi ] ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { <S2SV_StartBug> error_check ( insert_front_darr ( & darr , darr . n - 1 , nums + testi ) != 0 ) <S2SV_EndBug> return - 1 ; error_check ( trim_cap_darr ( & darr , testi + 1 ) != 0 ) return - 1 ; darr_print ( & darr ) ; } for ( testi = 0 ; testi != ARRSZ ( nums ) ; testi ++ ) { remove_front_darr ( & darr , darr . n - 1 , nums + testi ) ; error_check ( trim_cap_darr ( & darr , ARRSZ ( nums ) - testi - 1 ) != 0 ) return - 1 ; } free_test ( & darr ) ; puts ( "success" ) ; fflush ( stdout ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> & darr , <S2SV_ModEnd> darr . n <S2SV_ModStart> darr . n <S2SV_ModEnd> , nums + <S2SV_ModStart> darr . n <S2SV_ModEnd> , nums + |
1,418 | CWE-000 int check_extra ( t_file * current , char * * total , int * first ) { int i ; i = 0 ; if ( ! ( ( current -> extra ) [ i ] ) ) { <S2SV_StartBug> ( * total ) [ i ] = '\\0' ; <S2SV_EndBug> return ( 0 ) ; } while ( ( current -> extra ) [ i ] ) { if ( ( current -> extra ) [ i ] == '\\n' ) { ( * total ) [ i ] = '\\0' ; i ++ ; current -> extra = ft_copystr ( current -> extra + i ) ; return ( 1 ) ; } ( * total ) [ i ] = ( current -> extra ) [ i ] ; i ++ ; } ( * total ) [ i ] = '\\0' ; * first = 2 ; return ( 0 ) ; } | <S2SV_ModStart> ] = '\\0' ; if ( current -> ret == 0 ) return ( 1 ) |
1,419 | CWE-000 static pci_ers_result_t e1000_io_error_detected ( struct pci_dev * pdev , pci_channel_state_t state ) { struct net_device * netdev = pci_get_drvdata ( pdev ) ; struct e1000_adapter * adapter = netdev_priv ( netdev ) ; netif_device_detach ( netdev ) ; if ( state == pci_channel_io_perm_failure ) return PCI_ERS_RESULT_DISCONNECT ; if ( netif_running ( netdev ) ) e1000_down ( adapter ) ; <S2SV_StartBug> pci_disable_device ( pdev ) ; <S2SV_EndBug> return PCI_ERS_RESULT_NEED_RESET ; } | <S2SV_ModStart> adapter ) ; if ( ! test_and_set_bit ( __E1000_DISABLED , & adapter -> flags ) ) |
1,420 | CWE-000 <S2SV_StartBug> void unpad_tree_uchar ( unsigned char * L , unsigned char * R , unsigned short * C , unsigned char * t , unsigned int i , node root ) <S2SV_EndBug> { if ( root -> t == 0 ) { unsigned char l , r ; l = L [ i ] ; if ( l != 0 ) { node lroot = new_node2 ( C [ l ] , t [ l ] ) ; root -> left = lroot ; unpad_tree_uchar ( L , R , C , t , l , lroot ) ; } r = R [ i ] ; if ( r != 0 ) { node rroot = new_node2 ( C [ r ] , t [ r ] ) ; root -> right = rroot ; unpad_tree_uchar ( L , R , C , t , r , rroot ) ; } } } | <S2SV_ModStart> R , unsigned int <S2SV_ModEnd> * C , |
1,421 | CWE-000 uint32_t performShift ( uint8_t shiftType , uint32_t contentToShiftOn , uint32_t amountToShiftBy , bool * isCarrySet ) { uint32_t operand2 ; <S2SV_StartBug> if ( ( shiftType & lsl ) == lsl ) { <S2SV_EndBug> * isCarrySet = ( ( ( ( contentToShiftOn << ( amountToShiftBy - 1 ) ) & 0x80000000 ) >> 31 ) & 0x1 ) == 0x1 ; operand2 = contentToShiftOn << amountToShiftBy ; <S2SV_StartBug> } else if ( ( shiftType & lsr ) == lsr ) { <S2SV_EndBug> * isCarrySet = ( ( contentToShiftOn >> ( amountToShiftBy - 1 ) ) & 0x1 ) == 0x1 ; operand2 = contentToShiftOn >> amountToShiftBy ; <S2SV_StartBug> } else if ( ( shiftType & asr ) == asr ) { <S2SV_EndBug> * isCarrySet = ( ( contentToShiftOn >> ( amountToShiftBy - 1 ) ) & 0x1 ) == 0x1 ; operand2 = ( signed ) contentToShiftOn << amountToShiftBy ; } else { * isCarrySet = ( ( contentToShiftOn >> ( amountToShiftBy - 1 ) ) & 0x1 ) == 0x1 ; operand2 = rotr32 ( contentToShiftOn , amountToShiftBy ) ; } return operand2 ; } | <S2SV_ModStart> ; if ( shiftType <S2SV_ModEnd> == lsl ) <S2SV_ModStart> else if ( shiftType <S2SV_ModEnd> == lsr ) <S2SV_ModStart> else if ( shiftType <S2SV_ModEnd> == asr ) |
1,422 | CWE-000 int BN_hex2bn ( BIGNUM * * bn , const char * a ) { BIGNUM * ret = NULL ; BN_ULONG l = 0 ; int neg = 0 , h , m , i , j , k , c ; int num ; if ( ( a == NULL ) || ( * a == '\\0' ) ) return ( 0 ) ; if ( * a == '-' ) { neg = 1 ; a ++ ; } <S2SV_StartBug> for ( i = 0 ; isxdigit ( ( unsigned char ) a [ i ] ) ; i ++ ) ; <S2SV_EndBug> num = i + neg ; if ( bn == NULL ) return ( num ) ; if ( * bn == NULL ) { if ( ( ret = BN_new ( ) ) == NULL ) return ( 0 ) ; } else { ret = * bn ; BN_zero ( ret ) ; } if ( bn_expand ( ret , i * 4 ) == NULL ) goto err ; j = i ; m = 0 ; h = 0 ; while ( j > 0 ) { m = ( ( BN_BYTES * 2 ) <= j ) ? ( BN_BYTES * 2 ) : j ; l = 0 ; for ( ; ; ) { c = a [ j - m ] ; if ( ( c >= '0' ) && ( c <= '9' ) ) k = c - '0' ; else if ( ( c >= 'a' ) && ( c <= 'f' ) ) k = c - 'a' + 10 ; else if ( ( c >= 'A' ) && ( c <= 'F' ) ) k = c - 'A' + 10 ; else k = 0 ; l = ( l << 4 ) | k ; if ( -- m <= 0 ) { ret -> d [ h ++ ] = l ; break ; } } j -= ( BN_BYTES * 2 ) ; } ret -> top = h ; bn_correct_top ( ret ) ; ret -> neg = neg ; * bn = ret ; bn_check_top ( ret ) ; return ( num ) ; err : if ( * bn == NULL ) BN_free ( ret ) ; return ( 0 ) ; } | <S2SV_ModStart> = 0 ; i <= ( INT_MAX / 4 ) && <S2SV_ModStart> i ++ ) continue ; if ( i > INT_MAX / 4 ) goto err |
1,423 | CWE-000 static cairo_status_t _cairo_amigaos_font_face_scaled_font_create ( void * abstract_face , const cairo_matrix_t * font_matrix , const cairo_matrix_t * ctm , const cairo_font_options_t * options , cairo_scaled_font_t * * font_out ) { cairo_amigaos_font_face_t * face = abstract_face ; cairo_status_t status ; cairo_matrix_t scale ; double xscale , yscale ; struct OutlineFont * outline_font ; struct EGlyphEngine * engine ; cairo_amigaos_scaled_font_t * font ; debugf ( "_cairo_amigaos_font_face_scaled_font_create(%p,<S2SV_blank>%p,<S2SV_blank>%p,<S2SV_blank>%p,<S2SV_blank>%p)\\n" , abstract_face , font_matrix , ctm , options , font_out ) ; cairo_matrix_multiply ( & scale , font_matrix , ctm ) ; status = _cairo_matrix_compute_basis_scale_factors ( & scale , & xscale , & yscale , 1 ) ; if ( status != CAIRO_STATUS_SUCCESS ) return status ; outline_font = IDiskfont -> OpenOutlineFont ( face -> filename , NULL , OFF_OPEN ) ; if ( outline_font == NULL ) return _cairo_error ( CAIRO_STATUS_NO_MEMORY ) ; engine = & outline_font -> olf_EEngine ; font = malloc ( sizeof ( cairo_amigaos_scaled_font_t ) ) ; font -> outline_font = outline_font ; font -> xscale = xscale ; font -> yscale = yscale ; IDiskfont -> ESetInfo ( engine , OT_PointHeight , FLOAT_TO_FIXED ( font -> yscale ) , TAG_END ) ; if ( IDiskfont -> ESetInfo ( engine , OT_GlyphCode_32 , 'A' , TAG_END ) == OTERR_UnknownTag ) { font -> ucs2_only = TRUE ; } else { font -> ucs2_only = FALSE ; } font -> xspace = FIXED_TO_FLOAT ( IUtility -> GetTagData ( OT_SpaceWidth , 0 , outline_font -> olf_OTagList ) ) * font -> xscale ; switch ( options -> antialias ) { case CAIRO_ANTIALIAS_DEFAULT : case CAIRO_ANTIALIAS_NONE : font -> antialias = FALSE ; break ; case CAIRO_ANTIALIAS_GRAY : case CAIRO_ANTIALIAS_SUBPIXEL : case CAIRO_ANTIALIAS_FAST : case CAIRO_ANTIALIAS_GOOD : case CAIRO_ANTIALIAS_BEST : font -> antialias = TRUE ; break ; } status = _cairo_scaled_font_init ( & font -> base , & face -> base , font_matrix , ctm , options , & cairo_amigaos_scaled_font_backend ) ; if ( status ) { IDiskfont -> CloseOutlineFont ( outline_font , NULL ) ; free ( font ) ; return status ; } <S2SV_StartBug> return CAIRO_STATUS_SUCCESS ; <S2SV_EndBug> } | <S2SV_ModStart> status ; } * font_out = & font -> base ; |
1,424 | CWE-000 <S2SV_StartBug> static int send_eof_pty_channel_object ( SPC_Channel_Ptr channel ) { <S2SV_EndBug> Wire * wire = channel -> wires [ STDIN ] ; char output_char ; int fd , ret ; static int send_eof_pty_channel_object ( SPC_Channel_Ptr channel ) { Wire * wire = channel -> wires [ STDIN ] ; char output_char ; int fd , ret ; if ( wire == NULL ) return ( TRUE ) ; if ( ( wire -> slave_termio . c_lflag & ~ ICANON ) == 0 ) return ( FALSE ) ; output_char = wire -> slave_termio . c_cc [ VEOF ] ; fd = channel -> file_descs [ STDIN ] ; ret = write ( fd , & output_char , 1 ) ; ret = write ( fd , & output_char , 1 ) ; return ( TRUE ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> static int send_eof_pty_channel_object |
1,425 | CWE-000 int mt76x02_set_rts_threshold ( struct ieee80211_hw * hw , u32 val ) { struct mt76x02_dev * dev = hw -> priv ; if ( val != ~ 0 && val > 0xffff ) return - EINVAL ; <S2SV_StartBug> mutex_lock ( & dev -> mutex ) ; <S2SV_EndBug> mt76x02_mac_set_tx_protection ( dev , val ) ; <S2SV_StartBug> mutex_unlock ( & dev -> mutex ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> & dev -> mt76 . <S2SV_ModStart> & dev -> mt76 . |
1,426 | CWE-000 void mrmailbox_unref ( mrmailbox_t * mailbox ) { if ( mailbox == NULL || mailbox -> m_magic != MR_MAILBOX_MAGIC ) { return ; } mrpgp_exit ( mailbox ) ; <S2SV_StartBug> mrjob_exit_thread ( mailbox ) ; <S2SV_EndBug> if ( mrmailbox_is_open ( mailbox ) ) { mrmailbox_close ( mailbox ) ; } mrimap_unref ( mailbox -> m_imap ) ; mrsmtp_unref ( mailbox -> m_smtp ) ; mrsqlite3_unref ( mailbox -> m_sql ) ; pthread_mutex_destroy ( & mailbox -> m_wake_lock_critical ) ; pthread_mutex_destroy ( & mailbox -> m_log_ringbuf_critical ) ; for ( int i = 0 ; i < MR_LOG_RINGBUF_SIZE ; i ++ ) { free ( mailbox -> m_log_ringbuf [ i ] ) ; } free ( mailbox -> m_os_name ) ; mailbox -> m_magic = 0 ; free ( mailbox ) ; if ( s_localize_mb_obj == mailbox ) { s_localize_mb_obj = NULL ; } } | <S2SV_ModStart> mailbox ) ; mrjob_stop_thread ( mailbox ) ; mrjob_exit <S2SV_ModEnd> ( mailbox ) |
1,427 | CWE-000 bool add_cell ( Cell * * handle , int r , int c ) { <S2SV_StartBug> Cell * head = * handle ; <S2SV_EndBug> while ( head ) { if ( head -> r == r && head -> c == c ) { return false ; } head = head -> next ; } * handle = malloc ( sizeof ( Cell ) ) ; <S2SV_StartBug> ( * handle ) -> next = NULL ; <S2SV_EndBug> ( * handle ) -> r = r ; ( * handle ) -> c = c ; return true ; } | <S2SV_ModStart> Cell * head = * handle ; Cell * front <S2SV_ModStart> -> next = front <S2SV_ModEnd> ; ( * |
1,428 | CWE-000 void intel_irq_init ( struct drm_i915_private * dev_priv ) { struct drm_device * dev = & dev_priv -> drm ; intel_hpd_init_work ( dev_priv ) ; INIT_WORK ( & dev_priv -> rps . work , gen6_pm_rps_work ) ; INIT_WORK ( & dev_priv -> l3_parity . error_work , ivybridge_parity_work ) ; if ( HAS_GUC_SCHED ( dev_priv ) ) dev_priv -> pm_guc_events = GEN9_GUC_TO_HOST_INT_EVENT ; if ( IS_VALLEYVIEW ( dev_priv ) ) dev_priv -> pm_rps_events = GEN6_PM_RP_UP_EI_EXPIRED ; else dev_priv -> pm_rps_events = GEN6_PM_RPS_EVENTS ; dev_priv -> rps . pm_intrmsk_mbz = 0 ; if ( INTEL_INFO ( dev_priv ) -> gen <= 7 ) dev_priv -> rps . pm_intrmsk_mbz |= GEN6_PM_RP_UP_EI_EXPIRED ; if ( INTEL_INFO ( dev_priv ) -> gen >= 8 ) dev_priv -> rps . pm_intrmsk_mbz |= GEN8_PMINTR_DISABLE_REDIRECT_TO_GUC ; if ( IS_GEN2 ( dev_priv ) ) { dev -> max_vblank_count = 0 ; } else if ( IS_G4X ( dev_priv ) || INTEL_INFO ( dev_priv ) -> gen >= 5 ) { dev -> max_vblank_count = 0xffffffff ; dev -> driver -> get_vblank_counter = g4x_get_vblank_counter ; } else { dev -> driver -> get_vblank_counter = i915_get_vblank_counter ; dev -> max_vblank_count = 0xffffff ; } if ( ! IS_GEN2 ( dev_priv ) ) dev -> vblank_disable_immediate = true ; dev_priv -> display_irqs_enabled = true ; if ( IS_VALLEYVIEW ( dev_priv ) || IS_CHERRYVIEW ( dev_priv ) ) dev_priv -> display_irqs_enabled = false ; dev_priv -> hotplug . hpd_storm_threshold = HPD_STORM_DEFAULT_THRESHOLD ; <S2SV_StartBug> dev -> driver -> get_vblank_timestamp = i915_get_vblank_timestamp ; <S2SV_EndBug> dev -> driver -> get_scanout_position = i915_get_crtc_scanoutpos ; if ( IS_CHERRYVIEW ( dev_priv ) ) { dev -> driver -> irq_handler = cherryview_irq_handler ; dev -> driver -> irq_preinstall = cherryview_irq_preinstall ; dev -> driver -> irq_postinstall = cherryview_irq_postinstall ; dev -> driver -> irq_uninstall = cherryview_irq_uninstall ; dev -> driver -> enable_vblank = i965_enable_vblank ; dev -> driver -> disable_vblank = i965_disable_vblank ; dev_priv -> display . hpd_irq_setup = i915_hpd_irq_setup ; } else if ( IS_VALLEYVIEW ( dev_priv ) ) { dev -> driver -> irq_handler = valleyview_irq_handler ; dev -> driver -> irq_preinstall = valleyview_irq_preinstall ; dev -> driver -> irq_postinstall = valleyview_irq_postinstall ; dev -> driver -> irq_uninstall = valleyview_irq_uninstall ; dev -> driver -> enable_vblank = i965_enable_vblank ; dev -> driver -> disable_vblank = i965_disable_vblank ; dev_priv -> display . hpd_irq_setup = i915_hpd_irq_setup ; } else if ( INTEL_INFO ( dev_priv ) -> gen >= 8 ) { dev -> driver -> irq_handler = gen8_irq_handler ; dev -> driver -> irq_preinstall = gen8_irq_reset ; dev -> driver -> irq_postinstall = gen8_irq_postinstall ; dev -> driver -> irq_uninstall = gen8_irq_uninstall ; dev -> driver -> enable_vblank = gen8_enable_vblank ; dev -> driver -> disable_vblank = gen8_disable_vblank ; if ( IS_GEN9_LP ( dev_priv ) ) dev_priv -> display . hpd_irq_setup = bxt_hpd_irq_setup ; else if ( HAS_PCH_SPT ( dev_priv ) || HAS_PCH_KBP ( dev_priv ) ) dev_priv -> display . hpd_irq_setup = spt_hpd_irq_setup ; else dev_priv -> display . hpd_irq_setup = ilk_hpd_irq_setup ; } else if ( HAS_PCH_SPLIT ( dev_priv ) ) { dev -> driver -> irq_handler = ironlake_irq_handler ; dev -> driver -> irq_preinstall = ironlake_irq_reset ; dev -> driver -> irq_postinstall = ironlake_irq_postinstall ; dev -> driver -> irq_uninstall = ironlake_irq_uninstall ; dev -> driver -> enable_vblank = ironlake_enable_vblank ; dev -> driver -> disable_vblank = ironlake_disable_vblank ; dev_priv -> display . hpd_irq_setup = ilk_hpd_irq_setup ; } else { if ( IS_GEN2 ( dev_priv ) ) { dev -> driver -> irq_preinstall = i8xx_irq_preinstall ; dev -> driver -> irq_postinstall = i8xx_irq_postinstall ; dev -> driver -> irq_handler = i8xx_irq_handler ; dev -> driver -> irq_uninstall = i8xx_irq_uninstall ; dev -> driver -> enable_vblank = i8xx_enable_vblank ; dev -> driver -> disable_vblank = i8xx_disable_vblank ; } else if ( IS_GEN3 ( dev_priv ) ) { dev -> driver -> irq_preinstall = i915_irq_preinstall ; dev -> driver -> irq_postinstall = i915_irq_postinstall ; dev -> driver -> irq_uninstall = i915_irq_uninstall ; dev -> driver -> irq_handler = i915_irq_handler ; dev -> driver -> enable_vblank = i8xx_enable_vblank ; dev -> driver -> disable_vblank = i8xx_disable_vblank ; } else { dev -> driver -> irq_preinstall = i965_irq_preinstall ; dev -> driver -> irq_postinstall = i965_irq_postinstall ; dev -> driver -> irq_uninstall = i965_irq_uninstall ; dev -> driver -> irq_handler = i965_irq_handler ; dev -> driver -> enable_vblank = i965_enable_vblank ; dev -> driver -> disable_vblank = i965_disable_vblank ; } if ( I915_HAS_HOTPLUG ( dev_priv ) ) dev_priv -> display . hpd_irq_setup = i915_hpd_irq_setup ; } } | <S2SV_ModStart> -> get_vblank_timestamp = drm_calc_vbltimestamp_from_scanoutpos <S2SV_ModEnd> ; dev -> |
1,429 | CWE-000 static void virtex_init ( MachineState * machine ) { ram_addr_t ram_size = machine -> ram_size ; const char * kernel_filename = machine -> kernel_filename ; const char * kernel_cmdline = machine -> kernel_cmdline ; hwaddr initrd_base = 0 ; int initrd_size = 0 ; MemoryRegion * address_space_mem = get_system_memory ( ) ; DeviceState * dev ; PowerPCCPU * cpu ; CPUPPCState * env ; hwaddr ram_base = 0 ; DriveInfo * dinfo ; MemoryRegion * phys_ram = g_new ( MemoryRegion , 1 ) ; qemu_irq irq [ 32 ] , * cpu_irq ; int kernel_size ; int i ; # ifdef TARGET_PPCEMB if ( ! qtest_enabled ( ) ) { warn_report ( "qemu-system-ppcemb<S2SV_blank>is<S2SV_blank>deprecated,<S2SV_blank>" "please<S2SV_blank>use<S2SV_blank>qemu-system-ppc<S2SV_blank>instead." ) ; } # endif cpu = ppc440_init_xilinx ( & ram_size , 1 , machine -> cpu_type , 400000000 ) ; env = & cpu -> env ; if ( env -> mmu_model != POWERPC_MMU_BOOKE ) { <S2SV_StartBug> fprintf ( stderr , "MMU<S2SV_blank>model<S2SV_blank>%i<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>this<S2SV_blank>machine.\\n" , <S2SV_EndBug> env -> mmu_model ) ; exit ( 1 ) ; } qemu_register_reset ( main_cpu_reset , cpu ) ; memory_region_allocate_system_memory ( phys_ram , NULL , "ram" , ram_size ) ; memory_region_add_subregion ( address_space_mem , ram_base , phys_ram ) ; dinfo = drive_get ( IF_PFLASH , 0 , 0 ) ; pflash_cfi01_register ( PFLASH_BASEADDR , NULL , "virtex.flash" , FLASH_SIZE , dinfo ? blk_by_legacy_dinfo ( dinfo ) : NULL , ( 64 * 1024 ) , FLASH_SIZE >> 16 , 1 , 0x89 , 0x18 , 0x0000 , 0x0 , 1 ) ; cpu_irq = ( qemu_irq * ) & env -> irq_inputs [ PPC40x_INPUT_INT ] ; dev = qdev_create ( NULL , "xlnx.xps-intc" ) ; qdev_prop_set_uint32 ( dev , "kind-of-intr" , 0 ) ; qdev_init_nofail ( dev ) ; sysbus_mmio_map ( SYS_BUS_DEVICE ( dev ) , 0 , INTC_BASEADDR ) ; sysbus_connect_irq ( SYS_BUS_DEVICE ( dev ) , 0 , cpu_irq [ 0 ] ) ; for ( i = 0 ; i < 32 ; i ++ ) { irq [ i ] = qdev_get_gpio_in ( dev , i ) ; } serial_mm_init ( address_space_mem , UART16550_BASEADDR , 2 , irq [ UART16550_IRQ ] , 115200 , serial_hds [ 0 ] , DEVICE_LITTLE_ENDIAN ) ; dev = qdev_create ( NULL , "xlnx.xps-timer" ) ; qdev_prop_set_uint32 ( dev , "one-timer-only" , 0 ) ; qdev_prop_set_uint32 ( dev , "clock-frequency" , 62 * 1000000 ) ; qdev_init_nofail ( dev ) ; sysbus_mmio_map ( SYS_BUS_DEVICE ( dev ) , 0 , TIMER_BASEADDR ) ; sysbus_connect_irq ( SYS_BUS_DEVICE ( dev ) , 0 , irq [ TIMER_IRQ ] ) ; if ( kernel_filename ) { uint64_t entry , low , high ; hwaddr boot_offset ; kernel_size = load_elf ( kernel_filename , NULL , NULL , & entry , & low , & high , 1 , PPC_ELF_MACHINE , 0 , 0 ) ; boot_info . bootstrap_pc = entry & 0x00ffffff ; if ( kernel_size < 0 ) { boot_offset = 0x1200000 ; kernel_size = load_image_targphys ( kernel_filename , boot_offset , ram_size ) ; boot_info . bootstrap_pc = boot_offset ; high = boot_info . bootstrap_pc + kernel_size + 8192 ; } boot_info . ima_size = kernel_size ; if ( machine -> initrd_filename ) { initrd_base = high = ROUND_UP ( high , 4 ) ; initrd_size = load_image_targphys ( machine -> initrd_filename , high , ram_size - high ) ; if ( initrd_size < 0 ) { error_report ( "couldn\'t<S2SV_blank>load<S2SV_blank>ram<S2SV_blank>disk<S2SV_blank>\'%s\'" , machine -> initrd_filename ) ; exit ( 1 ) ; } high = ROUND_UP ( high + initrd_size , 4 ) ; } boot_info . fdt = high + ( 8192 * 2 ) ; boot_info . fdt &= ~ 8191 ; xilinx_load_device_tree ( boot_info . fdt , ram_size , initrd_base , initrd_size , kernel_cmdline ) ; } env -> load_info = & boot_info ; } | <S2SV_ModStart> POWERPC_MMU_BOOKE ) { error_report ( "MMU<S2SV_blank>model<S2SV_blank>%i<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>this<S2SV_blank>machine" <S2SV_ModEnd> , env -> |
1,430 | CWE-000 static int _epoll_signal_add ( struct AMCEpoll * base , struct AMCEpollEvent * amcEvent ) { int callStat = 0 ; struct epoll_event epollEvent ; struct EpSigPipe * sigPipe = ( struct EpSigPipe * ) ( amcEvent -> inter_data ) ; epollEvent . events = _signal_epoll_code_from_amc_code ( amcEvent -> events ) ; epollEvent . data . ptr = amcEvent ; callStat = epoll_ctl ( base -> epoll_fd , EPOLL_CTL_ADD , sigPipe -> fd [ PIPE_READ ] , & epollEvent ) ; if ( 0 == callStat ) { return 0 ; } else { int err = errno ; ERROR ( "Failed<S2SV_blank>in<S2SV_blank>epoll_add():<S2SV_blank>%s" , strerror ( err ) ) ; <S2SV_StartBug> _RETURN_ERR ( err ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ) ) ; return ep_err <S2SV_ModEnd> ( err ) |
1,431 | CWE-000 static int spi_uevent ( struct device * dev , struct kobj_uevent_env * env ) { const struct spi_device * spi = to_spi_device ( dev ) ; <S2SV_StartBug> int rc ; <S2SV_EndBug> rc = acpi_device_uevent_modalias ( dev , env ) ; if ( rc != - ENODEV ) return rc ; add_uevent_var ( env , "MODALIAS=%s%s" , SPI_MODULE_PREFIX , spi -> modalias ) ; return 0 ; } | <S2SV_ModStart> ) ; int rc ; rc = of_device_uevent_modalias ( dev , env ) ; if ( rc != - ENODEV ) return |
1,432 | CWE-000 static void keyboard_callback ( registers_t regs ) { u8 scancode = port_byte_in ( 0x60 ) ; if ( scancode > SC_MAX ) return ; if ( scancode == BACKSPACE ) { <S2SV_StartBug> backspace ( key_buffer ) ; <S2SV_EndBug> kprint_backspace ( ) ; <S2SV_StartBug> } else if ( scancode == ENTER ) { <S2SV_EndBug> kprint ( "\\n" ) ; <S2SV_StartBug> user_input ( key_buffer ) ; <S2SV_EndBug> key_buffer [ 0 ] = '\\0' ; } else if ( scancode == LSHIFT || scancode == RSHIFT ) { if ( shift == 0 ) { shift = 1 ; } else { shift = 0 ; } } else { <S2SV_StartBug> if ( shift == 0 ) { <S2SV_EndBug> char letter = sc_ascii [ ( int ) scancode ] ; char str [ 2 ] = { letter , '\\0' } ; append ( key_buffer , letter ) ; kprint ( str ) ; } else { char letter = sc_ascii_uppercase [ ( int ) scancode ] ; char str [ 2 ] = { letter , '\\0' } ; append ( key_buffer , letter ) ; kprint ( str ) ; } } UNUSED ( regs ) ; } | <S2SV_ModStart> BACKSPACE ) { if ( uinlen > 0 ) { <S2SV_ModStart> ( ) ; uinlen -= 1 ; } <S2SV_ModStart> ( key_buffer ) ; uinlen = 0 <S2SV_ModStart> } else { uinlen += 1 ; |
1,433 | CWE-000 void IDSetSwitch ( const ISwitchVectorProperty * svp , const char * fmt , ... ) { int i ; pthread_mutex_lock ( & stdout_mutex ) ; xmlv1 ( ) ; locale_char_t * orig = indi_locale_C_numeric_push ( ) ; printf ( "<setSwitchVector\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>device=\'%s\'\\n" , svp -> device ) ; printf ( "<S2SV_blank><S2SV_blank>name=\'%s\'\\n" , svp -> name ) ; printf ( "<S2SV_blank><S2SV_blank>state=\'%s\'\\n" , pstateStr ( svp -> s ) ) ; printf ( "<S2SV_blank><S2SV_blank>timeout=\'%g\'\\n" , svp -> timeout ) ; printf ( "<S2SV_blank><S2SV_blank>timestamp=\'%s\'\\n" , timestamp ( ) ) ; if ( fmt ) { va_list ap ; va_start ( ap , fmt ) ; char message [ MAXINDIMESSAGE ] ; printf ( "<S2SV_blank><S2SV_blank>message=\'" ) ; vsnprintf ( message , MAXINDIMESSAGE , fmt , ap ) ; <S2SV_StartBug> char * escapedMessage = escapeXML ( message , MAXINDIMESSAGE ) ; <S2SV_EndBug> printf ( "%s\'\\n" , escapedMessage ) ; free ( escapedMessage ) ; va_end ( ap ) ; } printf ( ">\\n" ) ; for ( i = 0 ; i < svp -> nsp ; i ++ ) { ISwitch * sp = & svp -> sp [ i ] ; printf ( "<S2SV_blank><S2SV_blank><oneSwitch<S2SV_blank>name=\'%s\'>\\n" , sp -> name ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , sstateStr ( sp -> s ) ) ; printf ( "<S2SV_blank><S2SV_blank></oneSwitch>\\n" ) ; } printf ( "</setSwitchVector>\\n" ) ; indi_locale_C_numeric_pop ( orig ) ; fflush ( stdout ) ; pthread_mutex_unlock ( & stdout_mutex ) ; } | <S2SV_ModStart> ap ) ; printf ( "%s\'\\n" , entityXML ( message ) <S2SV_ModEnd> ) ; va_end |
1,434 | CWE-000 static void * raid5_takeover_raid1 ( struct mddev * mddev ) { int chunksect ; void * ret ; if ( mddev -> raid_disks != 2 || mddev -> degraded > 1 ) return ERR_PTR ( - EINVAL ) ; chunksect = 64 * 2 ; while ( chunksect && ( mddev -> array_sectors & ( chunksect - 1 ) ) ) chunksect >>= 1 ; if ( ( chunksect << 9 ) < STRIPE_SIZE ) return ERR_PTR ( - EINVAL ) ; mddev -> new_level = 5 ; mddev -> new_layout = ALGORITHM_LEFT_SYMMETRIC ; mddev -> new_chunk_sectors = chunksect ; ret = setup_conf ( mddev ) ; <S2SV_StartBug> if ( ! IS_ERR_VALUE ( ret ) ) <S2SV_EndBug> mddev_clear_unsupported_flags ( mddev , UNSUPPORTED_MDDEV_FLAGS ) ; return ret ; } | <S2SV_ModStart> if ( ! IS_ERR <S2SV_ModEnd> ( ret ) |
1,435 | CWE-000 enum pm_ret_status pm_ipi_send_sync ( const struct pm_proc * proc , uint32_t payload [ PAYLOAD_ARG_CNT ] , unsigned int * value , size_t count ) { enum pm_ret_status ret ; bakery_lock_get ( & pm_secure_lock ) ; <S2SV_StartBug> ret = pm_ipi_send_common ( proc , payload ) ; <S2SV_EndBug> if ( ret != PM_RET_SUCCESS ) goto unlock ; ret = pm_ipi_buff_read ( proc , value , count ) ; unlock : bakery_lock_release ( & pm_secure_lock ) ; return ret ; } | <S2SV_ModStart> proc , payload , IPI_BLOCKING |
1,436 | CWE-000 static int get_vht_mcs ( __u32 capa , const __u8 * mcs ) { __u16 tmp ; int i ; int latest = - 1 ; tmp = mcs [ 4 ] | ( mcs [ 5 ] << 8 ) ; for ( i = 1 ; i <= 8 ; i ++ ) { switch ( ( tmp >> ( ( i - 1 ) * 2 ) ) & 3 ) { case 0 : <S2SV_StartBug> latest = ( ( i - 1 ) * 9 ) + 7 ; <S2SV_EndBug> break ; case 1 : <S2SV_StartBug> latest = ( ( i - 1 ) * 9 ) + 8 ; <S2SV_EndBug> break ; case 2 : <S2SV_StartBug> latest = ( ( i - 1 ) * 9 ) + 9 ; <S2SV_EndBug> break ; case 3 : break ; } } <S2SV_StartBug> fprintf ( stderr , "vht<S2SV_blank>mcs<S2SV_blank>%d\\n" , latest ) ; <S2SV_EndBug> return latest ; } | <S2SV_ModStart> 1 ) * 10 <S2SV_ModEnd> ) + 7 <S2SV_ModStart> 1 ) * 10 <S2SV_ModEnd> ) + 8 <S2SV_ModStart> 1 ) * 10 <S2SV_ModEnd> ) + 9 <S2SV_ModStart> ; } } <S2SV_ModEnd> return latest ; |
1,437 | CWE-000 static gchar * default_render_value ( const GValue * value , GdaSqlRenderingContext * context , GError * * error ) { if ( value && ! gda_value_is_null ( value ) ) { GdaDataHandler * dh ; if ( context -> provider ) dh = gda_server_provider_get_data_handler_g_type ( context -> provider , context -> cnc , G_VALUE_TYPE ( value ) ) ; else dh = gda_data_handler_get_default ( G_VALUE_TYPE ( value ) ) ; if ( ! dh ) { if ( G_VALUE_TYPE ( value ) == GDA_TYPE_DEFAULT ) return g_strdup ( "DEFAULT" ) ; else { g_set_error ( error , GDA_SQL_ERROR , GDA_SQL_STRUCTURE_CONTENTS_ERROR , _ ( "No<S2SV_blank>data<S2SV_blank>handler<S2SV_blank>for<S2SV_blank>type<S2SV_blank>\'%s\'" ) , g_type_name ( G_VALUE_TYPE ( value ) ) ) ; return NULL ; } } if ( context -> flags & GDA_STATEMENT_SQL_TIMEZONE_TO_GMT ) { if ( G_VALUE_TYPE ( value ) == GDA_TYPE_TIME ) { GdaTime * nts ; nts = ( GdaTime * ) gda_value_get_time ( value ) ; if ( nts && ( nts -> timezone != GDA_TIMEZONE_INVALID ) ) { nts = gda_time_copy ( nts ) ; gda_time_change_timezone ( nts , 0 ) ; nts -> timezone = GDA_TIMEZONE_INVALID ; GValue v = { 0 } ; g_value_init ( & v , GDA_TYPE_TIME ) ; gda_value_set_time ( & v , nts ) ; gda_time_free ( nts ) ; gchar * tmp ; tmp = gda_data_handler_get_sql_from_value ( dh , & v ) ; g_value_reset ( & v ) ; return tmp ; } } else if ( G_VALUE_TYPE ( value ) == GDA_TYPE_TIMESTAMP ) { GdaTimestamp * nts ; nts = ( GdaTimestamp * ) gda_value_get_timestamp ( value ) ; <S2SV_StartBug> if ( nts && ( nts -> timezone != GDA_TIMEZONE_INVALID ) ) { <S2SV_EndBug> nts = gda_timestamp_copy ( nts ) ; gda_timestamp_change_timezone ( nts , 0 ) ; <S2SV_StartBug> nts -> timezone = GDA_TIMEZONE_INVALID ; <S2SV_EndBug> GValue v = { 0 } ; g_value_init ( & v , GDA_TYPE_TIMESTAMP ) ; gda_value_set_timestamp ( & v , nts ) ; gda_timestamp_free ( nts ) ; gchar * tmp ; tmp = gda_data_handler_get_sql_from_value ( dh , & v ) ; g_value_reset ( & v ) ; return tmp ; } } } return gda_data_handler_get_sql_from_value ( dh , value ) ; } else return g_strdup ( "NULL" ) ; } | <S2SV_ModStart> nts && ( gda_timestamp_get_timezone ( nts ) <S2SV_ModEnd> != GDA_TIMEZONE_INVALID ) <S2SV_ModStart> 0 ) ; gda_timestamp_set_timezone ( nts , GDA_TIMEZONE_INVALID ) <S2SV_ModEnd> ; GValue v |
1,438 | CWE-000 <S2SV_StartBug> int sendWindow ( int sockfd , int base , int w , gbnhdr * * packetarray , struct sockaddr * client , socklen_t socklen ) { <S2SV_EndBug> if ( signal ( SIGALRM , sig_alrm ) == SIG_ERR ) return ( - 1 ) ; int i = 0 ; int n = 0 ; alarm ( TIMEOUT ) ; fprintf ( stdout , "Alarm<S2SV_blank>set\\n" ) ; for ( i = base ; i < base + w ; i ++ ) { <S2SV_StartBug> n = sendto ( sockfd , packetarray [ i ] , sizeof ( gbnhdr ) , 0 , client , socklen ) ; <S2SV_EndBug> <S2SV_StartBug> fprintf ( stdout , "Sending<S2SV_blank>packet<S2SV_blank>%u<S2SV_blank>content<S2SV_blank>%c\\n" , packetarray [ i ] -> seqnum , packetarray [ i ] -> data ) ; <S2SV_EndBug> } return i ; } | <S2SV_ModStart> , socklen_t socklen , int total <S2SV_ModStart> ++ ) { if ( packetarray [ i ] == NULL ) break ; <S2SV_ModStart> ( stdout , "Sending<S2SV_blank>packet<S2SV_blank>%u<S2SV_blank>content<S2SV_blank>%u\\n" <S2SV_ModEnd> , packetarray [ |
1,439 | CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> return FI_ENODATA ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return ft_exit_code ( FI_ENODATA ) <S2SV_ModEnd> ; } <S2SV_null> |
1,440 | CWE-000 static int fg_get_prop_capacity ( struct fg_chip * chip , int * val ) { int rc , msoc ; if ( is_debug_batt_id ( chip ) ) { * val = DEBUG_BATT_SOC ; return 0 ; } if ( chip -> fg_restarting ) { * val = chip -> last_soc ; return 0 ; } if ( chip -> battery_missing ) { * val = BATT_MISS_SOC ; return 0 ; } if ( is_batt_empty ( chip ) ) { * val = EMPTY_SOC ; return 0 ; } if ( chip -> charge_full ) { * val = FULL_CAPACITY ; return 0 ; } rc = fg_get_msoc ( chip , & msoc ) ; if ( rc < 0 ) return rc ; <S2SV_StartBug> if ( chip -> delta_soc > 0 ) <S2SV_EndBug> * val = chip -> maint_soc ; else * val = msoc ; return 0 ; } | <S2SV_ModStart> ( chip -> dt . linearize_soc && chip -> |
1,441 | CWE-000 static void nvmet_start_ctrl ( struct nvmet_ctrl * ctrl ) { lockdep_assert_held ( & ctrl -> lock ) ; if ( nvmet_cc_iosqes ( ctrl -> cc ) != NVME_NVM_IOSQES || nvmet_cc_iocqes ( ctrl -> cc ) != NVME_NVM_IOCQES || nvmet_cc_mps ( ctrl -> cc ) != 0 || nvmet_cc_ams ( ctrl -> cc ) != 0 || nvmet_cc_css ( ctrl -> cc ) != 0 ) { ctrl -> csts = NVME_CSTS_CFS ; return ; } ctrl -> csts = NVME_CSTS_RDY ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = NVME_CSTS_RDY ; mod_delayed_work ( system_wq , & ctrl -> ka_work , ctrl -> kato * HZ ) ; |
1,442 | CWE-000 static struct wlr_primary_selection_offer * source_send_offer ( struct wlr_primary_selection_source * source , struct wlr_seat_client * target ) { <S2SV_StartBug> if ( wl_list_empty ( & target -> data_devices ) ) { <S2SV_EndBug> return NULL ; } struct wlr_primary_selection_offer * offer = calloc ( 1 , sizeof ( struct wlr_primary_selection_offer ) ) ; if ( offer == NULL ) { return NULL ; } uint32_t version = wl_resource_get_version ( <S2SV_StartBug> wl_resource_from_link ( target -> data_devices . next ) ) ; <S2SV_EndBug> offer -> resource = wl_resource_create ( target -> client , <S2SV_StartBug> & wl_data_offer_interface , version , 0 ) ; <S2SV_EndBug> if ( offer -> resource == NULL ) { free ( offer ) ; return NULL ; } wl_resource_set_implementation ( offer -> resource , & offer_impl , offer , offer_resource_handle_destroy ) ; offer -> source_destroy . notify = offer_handle_source_destroy ; wl_signal_add ( & source -> events . destroy , & offer -> source_destroy ) ; struct wl_resource * target_resource ; <S2SV_StartBug> wl_resource_for_each ( target_resource , & target -> data_devices ) { <S2SV_EndBug> wl_data_device_send_data_offer ( target_resource , offer -> resource ) ; } char * * p ; wl_array_for_each ( p , & source -> mime_types ) { <S2SV_StartBug> wl_data_offer_send_offer ( offer -> resource , * p ) ; <S2SV_EndBug> } offer -> source = source ; source -> offer = offer ; <S2SV_StartBug> source -> accepted = false ; <S2SV_EndBug> return offer ; } | <S2SV_ModStart> & target -> primary_selection_devices <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( target -> primary_selection_devices <S2SV_ModEnd> . next ) <S2SV_ModStart> client , & gtk_primary_selection_offer_interface <S2SV_ModEnd> , version , <S2SV_ModStart> & target -> primary_selection_devices ) { gtk_primary_selection_device_send_data_offer <S2SV_ModEnd> ( target_resource , <S2SV_ModStart> mime_types ) { gtk_primary_selection_offer_send_offer <S2SV_ModEnd> ( offer -> <S2SV_ModStart> = offer ; <S2SV_ModEnd> return offer ; |
1,443 | CWE-000 static int parse_tc_fdb_actions ( struct mlx5e_priv * priv , struct tcf_exts * exts , struct mlx5e_tc_flow * flow ) { struct mlx5_esw_flow_attr * attr = flow -> attr ; struct ip_tunnel_info * info = NULL ; const struct tc_action * a ; LIST_HEAD ( actions ) ; bool encap = false ; int err ; if ( tc_no_actions ( exts ) ) return - EINVAL ; memset ( attr , 0 , sizeof ( * attr ) ) ; attr -> in_rep = priv -> ppriv ; tcf_exts_to_list ( exts , & actions ) ; list_for_each_entry ( a , & actions , list ) { if ( is_tcf_gact_shot ( a ) ) { attr -> action |= MLX5_FLOW_CONTEXT_ACTION_DROP | MLX5_FLOW_CONTEXT_ACTION_COUNT ; continue ; } if ( is_tcf_mirred_egress_redirect ( a ) ) { int ifindex = tcf_mirred_ifindex ( a ) ; struct net_device * out_dev ; struct mlx5e_priv * out_priv ; out_dev = __dev_get_by_index ( dev_net ( priv -> netdev ) , ifindex ) ; if ( switchdev_port_same_parent_id ( priv -> netdev , out_dev ) ) { attr -> action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST | MLX5_FLOW_CONTEXT_ACTION_COUNT ; out_priv = netdev_priv ( out_dev ) ; attr -> out_rep = out_priv -> ppriv ; } else if ( encap ) { err = mlx5e_attach_encap ( priv , info , out_dev , attr ) ; if ( err ) return err ; list_add ( & flow -> encap , & attr -> encap -> flows ) ; attr -> action |= MLX5_FLOW_CONTEXT_ACTION_ENCAP | MLX5_FLOW_CONTEXT_ACTION_FWD_DEST | MLX5_FLOW_CONTEXT_ACTION_COUNT ; out_priv = netdev_priv ( attr -> encap -> out_dev ) ; attr -> out_rep = out_priv -> ppriv ; } else { pr_err ( "devices<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>on<S2SV_blank>same<S2SV_blank>switch<S2SV_blank>HW,<S2SV_blank>can\'t<S2SV_blank>offload<S2SV_blank>forwarding\\n" , priv -> netdev -> name , out_dev -> name ) ; return - EINVAL ; } continue ; } if ( is_tcf_tunnel_set ( a ) ) { info = tcf_tunnel_info ( a ) ; if ( info ) encap = true ; else return - EOPNOTSUPP ; continue ; } if ( is_tcf_vlan ( a ) ) { <S2SV_StartBug> if ( tcf_vlan_action ( a ) == VLAN_F_POP ) { <S2SV_EndBug> attr -> action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_POP ; <S2SV_StartBug> } else if ( tcf_vlan_action ( a ) == VLAN_F_PUSH ) { <S2SV_EndBug> if ( tcf_vlan_push_proto ( a ) != htons ( ETH_P_8021Q ) ) return - EOPNOTSUPP ; attr -> action |= MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH ; attr -> vlan = tcf_vlan_push_vid ( a ) ; <S2SV_StartBug> } <S2SV_EndBug> continue ; } if ( is_tcf_tunnel_release ( a ) ) { attr -> action |= MLX5_FLOW_CONTEXT_ACTION_DECAP ; continue ; } return - EINVAL ; } return 0 ; } | <S2SV_ModStart> a ) == TCA_VLAN_ACT_POP <S2SV_ModEnd> ) { attr <S2SV_ModStart> a ) == TCA_VLAN_ACT_PUSH <S2SV_ModEnd> ) { if <S2SV_ModStart> ) ; } else { return - EOPNOTSUPP ; } |
1,444 | CWE-000 int my_pthread_create ( my_pthread_t * thread , my_pthread_attr_t * attr , void * ( * function ) ( void * ) , void * arg ) { if ( scd == NULL ) { initialize ( ) ; } pause_timer ( scd -> timer ) ; ucontext_t * newCxt = ( ucontext_t * ) myallocate ( sizeof ( ucontext_t ) , __FILE__ , __LINE__ , LIBRARYREQ ) ; if ( newCxt == NULL ) { unpause_timer ( scd -> timer ) ; return 1 ; } getcontext ( newCxt ) ; newCxt -> uc_stack . ss_sp = ( char * ) myallocate ( STACK_SIZE , __FILE__ , __LINE__ , LIBRARYREQ ) ; if ( newCxt -> uc_stack . ss_sp == NULL ) { unpause_timer ( scd -> timer ) ; return 1 ; } newCxt -> uc_stack . ss_size = STACK_SIZE ; newCxt -> uc_link = scd -> termHandler ; makecontext ( newCxt , ( void ( * ) ( void ) ) function , 1 , arg ) ; <S2SV_StartBug> newthread = thread ; <S2SV_EndBug> newthread -> id = scd -> threadNum ; scd -> threadNum ++ ; newthread -> isDead = 0 ; newthread -> exitArg = NULL ; newthread -> pageNum = 0 ; newthread -> next = NULL ; addThread ( newthread ) ; <S2SV_StartBug> node * newNode = createNode ( newCxt , thread ) ; <S2SV_EndBug> enQ ( scd -> runQ [ 0 ] , newNode ) ; unpause_timer ( scd -> timer ) ; return 0 ; } | <S2SV_ModStart> arg ) ; my_pthread_t * newthread ; <S2SV_ModStart> newthread ) ; printThreads ( ) ; |
1,445 | CWE-000 address_t synaptogenesis_dynamics_initialise ( address_t sdram_sp_address ) { log_debug ( "SR<S2SV_blank>init." ) ; log_debug ( "Registering<S2SV_blank>DMA<S2SV_blank>callback" ) ; simulation_dma_transfer_done_callback_on ( DMA_TAG_READ_SYNAPTIC_ROW_FOR_REWIRING , synaptic_row_restructure ) ; log_debug ( "Callback<S2SV_blank>registered" ) ; int32_t * sp_word = ( int32_t * ) sdram_sp_address ; rewiring_data . fast = * sp_word ++ ; rewiring_data . p_rew = * sp_word ++ ; rewiring_data . weight = * sp_word ++ ; rewiring_data . delay = * sp_word ++ ; rewiring_data . s_max = * sp_word ++ ; rewiring_data . app_no_atoms = * sp_word ++ ; rewiring_data . low_atom = * sp_word ++ ; rewiring_data . high_atom = * sp_word ++ ; rewiring_data . machine_no_atoms = * sp_word ++ ; rewiring_data . grid_x = * sp_word ++ ; rewiring_data . grid_y = * sp_word ++ ; rewiring_data . p_elim_dep = * sp_word ++ ; rewiring_data . p_elim_pot = * sp_word ++ ; rewiring_data . shared_seed [ 0 ] = * sp_word ++ ; rewiring_data . shared_seed [ 1 ] = * sp_word ++ ; rewiring_data . shared_seed [ 2 ] = * sp_word ++ ; rewiring_data . shared_seed [ 3 ] = * sp_word ++ ; rewiring_data . local_seed [ 0 ] = * sp_word ++ ; rewiring_data . local_seed [ 1 ] = * sp_word ++ ; rewiring_data . local_seed [ 2 ] = * sp_word ++ ; rewiring_data . local_seed [ 3 ] = * sp_word ++ ; <S2SV_StartBug> log_info ( "p_rew<S2SV_blank>%d<S2SV_blank>fast<S2SV_blank>%d<S2SV_blank>weight<S2SV_blank>%d<S2SV_blank>delay<S2SV_blank>%d<S2SV_blank>s_max<S2SV_blank>%d<S2SV_blank>app_no_atoms<S2SV_blank>%d<S2SV_blank>lo<S2SV_blank>%d<S2SV_blank>hi<S2SV_blank>%d<S2SV_blank>machine_no_atoms<S2SV_blank>%d<S2SV_blank>x<S2SV_blank>%d<S2SV_blank>y<S2SV_blank>%d<S2SV_blank>p_elim_dep<S2SV_blank>%d<S2SV_blank>p_elim_pot<S2SV_blank>%d" , <S2SV_EndBug> rewiring_data . p_rew , rewiring_data . fast , rewiring_data . weight , rewiring_data . delay , rewiring_data . s_max , rewiring_data . app_no_atoms , rewiring_data . low_atom , rewiring_data . high_atom , rewiring_data . machine_no_atoms , rewiring_data . grid_x , rewiring_data . grid_y , rewiring_data . p_elim_dep , rewiring_data . p_elim_pot ) ; rewiring_data . pre_pop_info_table . no_pre_pops = * sp_word ++ ; if ( rewiring_data . pre_pop_info_table . no_pre_pops == 0 ) return NULL ; rewiring_data . pre_pop_info_table . subpop_info = ( subpopulation_info_t * ) sark_alloc ( rewiring_data . pre_pop_info_table . no_pre_pops , sizeof ( subpopulation_info_t ) ) ; uint32_t index ; uint16_t * half_word ; for ( index = 0 ; index < rewiring_data . pre_pop_info_table . no_pre_pops ; index ++ ) { half_word = ( uint16_t * ) sp_word ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . no_pre_vertices = * half_word ++ ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . sp_control = * half_word ++ ; sp_word = ( int32_t * ) half_word ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . total_no_atoms = * sp_word ++ ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . key_atom_info = ( int32_t * ) sark_alloc ( KEY_INFO_CONSTANTS * rewiring_data . pre_pop_info_table . subpop_info [ index ] . no_pre_vertices , sizeof ( int32_t ) ) ; int32_t subpop_index ; for ( subpop_index = 0 ; subpop_index < KEY_INFO_CONSTANTS * rewiring_data . pre_pop_info_table . subpop_info [ index ] . no_pre_vertices ; subpop_index ++ ) { rewiring_data . pre_pop_info_table . subpop_info [ index ] . key_atom_info [ subpop_index ++ ] = * sp_word ++ ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . key_atom_info [ subpop_index ++ ] = * sp_word ++ ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . key_atom_info [ subpop_index ++ ] = * sp_word ++ ; rewiring_data . pre_pop_info_table . subpop_info [ index ] . key_atom_info [ subpop_index ] = * sp_word ++ ; } } rewiring_data . size_ff_prob = * sp_word ++ ; rewiring_data . ff_probabilities = ( uint16_t * ) sark_alloc ( rewiring_data . size_ff_prob , sizeof ( uint16_t ) ) ; log_debug ( "size<S2SV_blank>ff<S2SV_blank>lut<S2SV_blank>%d" , rewiring_data . size_ff_prob ) ; half_word = ( uint16_t * ) sp_word ; for ( index = 0 ; index < rewiring_data . size_ff_prob ; index ++ ) { rewiring_data . ff_probabilities [ index ] = * half_word ++ ; log_debug ( "ff_probabilities<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>index<S2SV_blank>%d" , rewiring_data . ff_probabilities [ index ] , index ) ; } sp_word = ( int32_t * ) half_word ; rewiring_data . size_lat_prob = * sp_word ++ ; log_debug ( "size<S2SV_blank>lat<S2SV_blank>lut<S2SV_blank>%d" , rewiring_data . size_lat_prob ) ; rewiring_data . lat_probabilities = ( uint16_t * ) sark_alloc ( rewiring_data . size_lat_prob , sizeof ( uint16_t ) ) ; half_word = ( uint16_t * ) sp_word ; for ( index = 0 ; index < rewiring_data . size_lat_prob ; index ++ ) { rewiring_data . lat_probabilities [ index ] = * half_word ++ ; log_debug ( "lat_probabilities<S2SV_blank>%d<S2SV_blank>for<S2SV_blank>index<S2SV_blank>%d" , rewiring_data . lat_probabilities [ index ] , index ) ; } assert ( ( ( int ) half_word ) % 4 == 4 ) ; sp_word = ( int32_t * ) half_word ; rewiring_data . post_to_pre_table = sp_word ; int total_no_of_elements = rewiring_data . s_max * rewiring_data . machine_no_atoms ; sp_word = & rewiring_data . post_to_pre_table [ total_no_of_elements + 1 ] ; validate_mars_kiss64_seed ( rewiring_data . shared_seed ) ; validate_mars_kiss64_seed ( rewiring_data . local_seed ) ; rewiring_dma_buffer . row = ( uint32_t * ) sark_alloc ( 10 * rewiring_data . s_max , sizeof ( uint32_t ) ) ; if ( rewiring_dma_buffer . row == NULL ) { log_error ( "Fail<S2SV_blank>init<S2SV_blank>DMA<S2SV_blank>buffers" ) ; rt_error ( RTE_SWERR ) ; } # if STDP_ENABLED == 1 search_for_neuron = & find_plastic_neuron_with_id ; remove_neuron = & remove_plastic_neuron_at_offset ; add_neuron = & add_plastic_neuron_with_id ; number_of_connections_in_row = & synapse_row_num_plastic_controls ; # else search_for_neuron = & find_static_neuron_with_id ; remove_neuron = & remove_static_neuron_at_offset ; add_neuron = & add_static_neuron_with_id ; number_of_connections_in_row = & synapse_row_num_fixed_synapses ; # endif log_info ( "SR<S2SV_blank>init<S2SV_blank>complete." ) ; return ( address_t ) sp_word ; } | <S2SV_ModStart> sp_word ++ ; log_debug <S2SV_ModEnd> ( "p_rew<S2SV_blank>%d<S2SV_blank>fast<S2SV_blank>%d<S2SV_blank>weight<S2SV_blank>%d<S2SV_blank>delay<S2SV_blank>%d<S2SV_blank>s_max<S2SV_blank>%d<S2SV_blank>app_no_atoms<S2SV_blank>%d<S2SV_blank>lo<S2SV_blank>%d<S2SV_blank>hi<S2SV_blank>%d<S2SV_blank>machine_no_atoms<S2SV_blank>%d<S2SV_blank>x<S2SV_blank>%d<S2SV_blank>y<S2SV_blank>%d<S2SV_blank>p_elim_dep<S2SV_blank>%d<S2SV_blank>p_elim_pot<S2SV_blank>%d" , |
1,446 | CWE-000 void etMSCLogger_asyncOut ( const char * sourceName , const char * messageName , const char * targetName ) { if ( etMSCLogger_fileHandle != NULL ) { etLogger_fprintf ( etMSCLogger_fileHandle , "%s<S2SV_blank>>--<S2SV_blank>%s<S2SV_blank>%s\\n" , sourceName , targetName , messageName ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> messageName ) ; fflush ( etMSCLogger_fileHandle ) ; |
1,447 | CWE-000 t_list * read_tetrominoes ( char * filename ) { char * line ; int read_result ; t_read_context context ; context . tet_count = 0 ; context . head = NULL ; <S2SV_StartBug> context . fd = open ( filename , O_RDONLY ) ; <S2SV_EndBug> while ( 1 ) { read_tetromino ( & context ) ; context . tet_count ++ ; if ( ( read_result = get_next_line ( context . fd , & line ) ) ) { if ( string_length ( line ) != 0 ) error ( & context , line ) ; free ( line ) ; } else break ; if ( context . tet_count > 26 ) error ( & context , NULL ) ; } close ( context . fd ) ; return ( context . head ) ; } | <S2SV_ModStart> = NULL ; if ( ( <S2SV_ModStart> filename , O_RDONLY ) ) < 0 ) error ( & context , NULL |
1,448 | CWE-000 SQLITE_PRIVATE void sqlite3OsFileControlHint ( sqlite3_file * id , int op , void * pArg ) { <S2SV_StartBug> ( void ) id -> pMethods -> xFileControl ( id , op , pArg ) ; <S2SV_EndBug> } | <S2SV_ModStart> pArg ) { if ( id -> pMethods ) |
1,449 | CWE-000 static int dump_tablespaces_for_databases ( char * * databases ) { DYNAMIC_STRING where ; int r ; int i ; init_dynamic_string_checked ( & where , "<S2SV_blank>AND<S2SV_blank>TABLESPACE_NAME<S2SV_blank>IN<S2SV_blank>(" "SELECT<S2SV_blank>DISTINCT<S2SV_blank>TABLESPACE_NAME<S2SV_blank>FROM" "<S2SV_blank>INFORMATION_SCHEMA.PARTITIONS" "<S2SV_blank>WHERE" "<S2SV_blank>TABLE_SCHEMA<S2SV_blank>IN<S2SV_blank>(" , 256 , 1024 ) ; for ( i = 0 ; databases [ i ] != NULL ; i ++ ) { char db_name_buff [ NAME_LEN * 2 + 3 ] ; mysql_real_escape_string ( mysql , db_name_buff , <S2SV_StartBug> databases [ i ] , strlen ( databases [ i ] ) ) ; <S2SV_EndBug> dynstr_append_checked ( & where , "\'" ) ; dynstr_append_checked ( & where , db_name_buff ) ; dynstr_append_checked ( & where , "\'," ) ; } dynstr_trunc ( & where , 1 ) ; dynstr_append_checked ( & where , "))" ) ; DBUG_PRINT ( "info" , ( "Dump<S2SV_blank>TS<S2SV_blank>for<S2SV_blank>DBs<S2SV_blank>where:<S2SV_blank>%s" , where . str ) ) ; r = dump_tablespaces ( where . str ) ; dynstr_free ( & where ) ; return r ; } | <S2SV_ModStart> i ] , ( ulong ) |
1,450 | CWE-000 static sock_gres_t * _build_sock_gres_by_type ( gres_job_state_t * job_gres_ptr , gres_node_state_t * node_gres_ptr , bool use_total_gres , bitstr_t * core_bitmap , uint16_t sockets , uint16_t cores_per_sock , uint32_t job_id , char * node_name ) { int i ; <S2SV_StartBug> sock_gres_t * sock_gres = xmalloc ( sizeof ( sock_gres_t ) ) ; <S2SV_EndBug> uint64_t avail_gres , min_gres = 1 ; bool match = false ; if ( core_bitmap && ( bit_set_count ( core_bitmap ) == 0 ) ) return NULL ; if ( job_gres_ptr -> gres_per_node ) min_gres = job_gres_ptr -> gres_per_node ; if ( job_gres_ptr -> gres_per_socket ) min_gres = MAX ( min_gres , job_gres_ptr -> gres_per_socket ) ; if ( job_gres_ptr -> gres_per_task ) min_gres = MAX ( min_gres , job_gres_ptr -> gres_per_task ) ; sock_gres = xmalloc ( sizeof ( sock_gres_t ) ) ; for ( i = 0 ; i < node_gres_ptr -> type_cnt ; i ++ ) { if ( job_gres_ptr -> type_name && ( job_gres_ptr -> type_id != node_gres_ptr -> type_id [ i ] ) ) continue ; if ( ! use_total_gres && ( node_gres_ptr -> type_cnt_alloc [ i ] >= node_gres_ptr -> type_cnt_avail [ i ] ) ) { continue ; } else if ( ! use_total_gres ) { avail_gres = node_gres_ptr -> type_cnt_avail [ i ] - node_gres_ptr -> type_cnt_alloc [ i ] ; } else { avail_gres = node_gres_ptr -> type_cnt_avail [ i ] ; } if ( avail_gres < min_gres ) continue ; sock_gres -> total_cnt += avail_gres ; match = true ; } if ( match ) { sock_gres -> type_id = job_gres_ptr -> type_id ; sock_gres -> type_name = xstrdup ( job_gres_ptr -> type_name ) ; } else xfree ( sock_gres ) ; return sock_gres ; } | <S2SV_ModStart> sock_gres_t * sock_gres <S2SV_ModEnd> ; uint64_t avail_gres |
1,451 | CWE-000 void control ( uint8_t * msg , int msg_len , Connection * conn_ptr ) { int i , payload_length , cr_byte , channel_id , lookup_table_id ; Connection conn = * conn_ptr ; uint8_t reply [ 1024 ] , payload [ 1024 ] , crc ; char * tmp ; cr_byte = msg [ 2 ] ; memset ( reply , 0 , 1024 ) ; memset ( payload , 0 , 1024 ) ; if ( cr_byte == 0x81 ) { uint8_t * vts_id ; payload_length = msg [ 3 ] - 1 ; channel_id = msg [ 4 ] ; if ( payload_length > 1 ) { for ( i = 5 ; i < ( 5 + payload_length ) ; i ++ ) { payload [ i - 5 ] = msg [ i ] ; } vts_id = ( uint8_t * ) malloc ( payload_length * sizeof ( uint8_t ) ) ; vts_id = payload ; conn . vts_id = vts_id ; } if ( vts_entry_id ( vts_id ) < 0 ) { conn . vts_entry_id = add_new_device ( vts_id ) ; * conn_ptr = conn ; } else { conn . vts_entry_id = vts_entry_id ( vts_id ) ; conn . vts_id = vts_id ; * conn_ptr = conn ; } lookup_table_id = conn . vts_entry_id ; } else if ( cr_byte == 0x88 ) { payload_length = msg [ 3 ] - 1 ; uint8_t * reply_string = ( uint8_t * ) malloc ( payload_length * sizeof ( uint8_t ) ) ; int j , command_value = msg [ 4 ] ; for ( j = 6 ; j < payload_length + 6 ; j ++ ) { reply_string [ j - 6 ] = msg [ j ] ; } <S2SV_StartBug> int ret_val = insert ( reply_string , command_value , lookup_table_id ) ; <S2SV_EndBug> if ( ret_val >= 0 ) { send ( conn . socket_fd , "entry<S2SV_blank>success" , 13 , 0 ) ; } else { send ( conn . socket_fd , "entry<S2SV_blank>failed" , 12 , 0 ) ; } } if ( cr_byte != 0x88 ) { tmp = lookup ( lookup_table_id , cr_byte ) ; strcpy ( reply , tmp ) ; puts ( reply ) ; send ( conn . socket_fd , reply , strlen ( reply ) , 0 ) ; } } | <S2SV_ModStart> ] ; } reply_string [ j - 6 ] = '\\0' ; |
1,452 | CWE-000 const char * article_get ( article_root * root , const char * uri ) { const char * ptr = uri ; if ( '0' <= * ptr && * ptr <= '9' ) { <S2SV_StartBug> uint year , month , day ; <S2SV_EndBug> uint32_t time0 , time1 ; <S2SV_StartBug> if ( to_uint ( & ptr , & year ) < 0 || ! ( ptr ++ ) || <S2SV_EndBug> <S2SV_StartBug> to_uint ( & ptr , & month ) < 0 || ! ( ptr ++ ) || <S2SV_EndBug> to_uint ( & ptr , & day ) < 0 ) return NULL ; <S2SV_StartBug> if ( year == 0 ) { <S2SV_EndBug> time0 = 0 ; time1 = 0xFFffFFff ; } else if ( month == 0 ) { time0 = format_date ( year , 0 , 0 , 0 , 0 ) ; time1 = format_date ( year , 11 , 31 , 23 , 59 ) ; } else if ( day == 0 ) { time0 = format_date ( year , month , 0 , 0 , 0 ) ; time1 = format_date ( year , month , 31 , 23 , 59 ) ; } else { time0 = format_date ( year , month , day , 0 , 0 ) ; time1 = format_date ( year , month , day , 23 , 59 ) ; } return article_get_between_times ( root , time0 , time1 ) ; } else if ( * ptr == 0 ) { return article_get_between_times ( root , 0 , 0xFFffFFff ) ; } else { char dburi [ DB_FILE_LEN ] ; memset ( dburi , 0 , sizeof ( dburi ) ) ; strncpy ( dburi , uri , sizeof ( dburi ) ) ; const char * entry = database_get ( & root -> db , DB_URI_FIELD , dburi ) ; if ( entry == NULL ) return NULL ; char file [ 512 ] , * ptr = file ; size_t l = strlen ( root -> dir ) ; memcpy ( ptr , root -> dir , l ) ; ptr += l ; if ( database_get_field ( & root -> db , ptr , entry , DB_FILE_FIELD ) < 0 ) return NULL ; ptr [ strlen ( ptr ) ] = 0 ; int fd = open ( file , O_RDONLY ) ; if ( fd < 0 ) return NULL ; struct stat statbuf ; if ( fstat ( fd , & statbuf ) < 0 ) { close ( fd ) ; return NULL ; } char * buf = malloc ( statbuf . st_size + 1 ) ; if ( read ( fd , buf , statbuf . st_size ) != statbuf . st_size ) { close ( fd ) ; free ( buf ) ; return NULL ; } close ( fd ) ; buf [ statbuf . st_size ] = 0 ; const char * prev_entry = database_get_offset ( & root -> db , DB_URI_FIELD , dburi , - 1 ) ; const char * next_entry = database_get_offset ( & root -> db , DB_URI_FIELD , dburi , 1 ) ; uint32_t date ; char title [ DB_TITLE_LEN ] , author [ DB_AUTHOR_LEN ] , datestr [ 64 ] , prev [ DB_URI_LEN ] , next [ DB_URI_LEN ] ; if ( database_get_field ( & root -> db , ( char * ) & date , entry , DB_DATE_FIELD ) < 0 || database_get_field ( & root -> db , title , entry , DB_TITLE_FIELD ) < 0 || database_get_field ( & root -> db , author , entry , DB_AUTHOR_FIELD ) < 0 || <S2SV_StartBug> date_to_str ( datestr , date ) < 0 || <S2SV_EndBug> ( prev_entry != NULL && database_get_field ( & root -> db , prev , prev_entry , DB_URI_FIELD ) ) || ( next_entry != NULL && database_get_field ( & root -> db , next , next_entry , DB_URI_FIELD ) ) ) ; dictionary dict ; dict_create ( & dict ) ; dict_set ( & dict , "BODY" , buf ) ; dict_set ( & dict , "TITLE" , title ) ; dict_set ( & dict , "AUTHOR" , author ) ; dict_set ( & dict , "DATE" , datestr ) ; if ( prev_entry != NULL ) dict_set ( & dict , "PREVIOUS" , prev ) ; if ( next_entry != NULL ) dict_set ( & dict , "NEXT" , next ) ; char * body = template_parse ( & temp , & dict ) ; dict_free ( & dict ) ; free ( buf ) ; return body ; } return NULL ; } | <S2SV_ModStart> { uint year = 0 , month = 0 , day = 0 <S2SV_ModEnd> ; uint32_t time0 <S2SV_ModStart> ) < 0 ) return NULL ; if ( * ptr != 0 && ptr ++ && <S2SV_ModEnd> to_uint ( & <S2SV_ModStart> ) < 0 ) return NULL ; if ( * ptr != 0 && ptr ++ && <S2SV_ModEnd> to_uint ( & <S2SV_ModStart> return NULL ; <S2SV_ModEnd> if ( month <S2SV_ModStart> ( datestr , htonl ( date ) <S2SV_ModEnd> ) < 0 |
1,453 | CWE-000 int passwordgood ( char * cpw ) { char * crypted ; assert ( me != NULL ) ; crypted = crypt ( cpw , cpw ) ; if ( crypted == NULL ) return 0 ; <S2SV_StartBug> if ( ! strncmp ( crypted , me -> password , DGL_PASSWDLEN ) ) <S2SV_EndBug> <S2SV_StartBug> return 1 ; <S2SV_EndBug> if ( ! strncmp ( cpw , me -> password , DGL_PASSWDLEN ) ) return 1 ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> return 0 ; # ifdef USE_SQLITE3 <S2SV_ModStart> return 1 ; # else <S2SV_ModStart> return 1 ; # endif |
1,454 | CWE-000 <S2SV_StartBug> int kyk_deseri_new_ptl_message ( ptl_message * * new_ptl_msg , const uint8_t * buf , size_t buf_len ) <S2SV_EndBug> { const uint8_t * bufp = NULL ; ptl_payload * pld = NULL ; ptl_message * msg = NULL ; check ( buf , "Failed<S2SV_blank>to<S2SV_blank>kyk_deseri_new_ptl_message:<S2SV_blank>buf<S2SV_blank>is<S2SV_blank>NULL" ) ; msg = calloc ( 1 , sizeof ( * msg ) ) ; check ( msg , "Failed<S2SV_blank>to<S2SV_blank>kyk_deseri_new_ptl_message" ) ; bufp = buf ; beej_unpack ( bufp , "<L" , & msg -> magic ) ; bufp += sizeof ( msg -> magic ) ; memcpy ( msg -> cmd , bufp , sizeof ( msg -> cmd ) ) ; bufp += sizeof ( msg -> cmd ) ; beej_unpack ( bufp , "<L" , & msg -> pld_len ) ; bufp += sizeof ( msg -> pld_len ) ; memcpy ( msg -> checksum , bufp , sizeof ( msg -> checksum ) ) ; bufp += sizeof ( msg -> checksum ) ; msg -> pld = calloc ( 1 , sizeof ( * msg -> pld ) ) ; check ( msg -> pld , "Failed<S2SV_blank>to<S2SV_blank>kyk_deseri_new_ptl_message:<S2SV_blank>calloc<S2SV_blank>failed" ) ; pld = msg -> pld ; pld -> len = msg -> pld_len ; pld -> data = calloc ( pld -> len , sizeof ( * pld -> data ) ) ; check ( pld -> data , "Failed<S2SV_blank>to<S2SV_blank>kyk_deseri_new_ptl_message:<S2SV_blank>calloc<S2SV_blank>failed" ) ; memcpy ( pld -> data , bufp , pld -> len ) ; bufp += pld -> len ; <S2SV_StartBug> if ( buf_len > 0 ) { <S2SV_EndBug> <S2SV_StartBug> check ( buf_len == ( size_t ) ( bufp - buf ) , "Failed<S2SV_blank>to<S2SV_blank>kyk_deseri_new_ptl_message" ) ; <S2SV_EndBug> } * new_ptl_msg = msg ; return 0 ; error : if ( msg ) kyk_free_ptl_msg ( msg ) ; return - 1 ; } | <S2SV_ModStart> buf , size_t checklen <S2SV_ModEnd> ) { const <S2SV_ModStart> ; if ( checklen <S2SV_ModEnd> > 0 ) <S2SV_ModStart> { check ( checklen <S2SV_ModEnd> == ( size_t |
1,455 | CWE-000 static int cmd_resume_execution ( int argc , char * * argv ) { # ifdef ENABLE_DEBUGGER <S2SV_StartBug> cons_puts ( "ERROR:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>control<S2SV_blank>execution<S2SV_blank>from<S2SV_blank>the<S2SV_blank>cmd<S2SV_blank>prompt<S2SV_blank>in<S2SV_blank>gdb<S2SV_blank>" <S2SV_EndBug> "builds\\n" ) ; return 1 ; <S2SV_StartBug> # else <S2SV_EndBug> enum dc_state dc_state = dc_get_state ( ) ; if ( dc_state == DC_STATE_SUSPEND ) { dc_state_transition ( DC_STATE_RUNNING , DC_STATE_SUSPEND ) ; return 0 ; } cons_puts ( "ERROR:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>resume<S2SV_blank>execution<S2SV_blank>because<S2SV_blank>WashingtonDC<S2SV_blank>is<S2SV_blank>not<S2SV_blank>" "suspended\\n" ) ; return 1 ; <S2SV_StartBug> # endif <S2SV_EndBug> } | <S2SV_ModStart> # ifdef ENABLE_DEBUGGER if ( config_get_dbg_enable ( ) ) { cons_puts ( "ERROR:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>control<S2SV_blank>execution<S2SV_blank>from<S2SV_blank>the<S2SV_blank>cmd<S2SV_blank>prompt<S2SV_blank>when<S2SV_blank>" "gdb<S2SV_blank>is<S2SV_blank>enabled.\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> return 1 ; } # endif <S2SV_ModEnd> enum dc_state dc_state <S2SV_ModStart> return 1 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,456 | CWE-000 int load_bpf_file ( char * path ) { int fd , i ; Elf * elf ; GElf_Ehdr ehdr ; GElf_Shdr shdr , shdr_prog ; Elf_Data * data , * data_prog , * symbols = NULL ; char * shname , * shname_prog ; <S2SV_StartBug> if ( elf_version ( EV_CURRENT ) == EV_NONE ) <S2SV_EndBug> return 1 ; fd = open ( path , O_RDONLY , 0 ) ; if ( fd < 0 ) return 1 ; elf = elf_begin ( fd , ELF_C_READ , NULL ) ; if ( ! elf ) return 1 ; if ( gelf_getehdr ( elf , & ehdr ) != & ehdr ) return 1 ; i = system ( "echo<S2SV_blank>\\"\\"<S2SV_blank>><S2SV_blank>/sys/kernel/debug/tracing/kprobe_events" ) ; for ( i = 1 ; i < ehdr . e_shnum ; i ++ ) { if ( get_sec ( elf , i , & ehdr , & shname , & shdr , & data ) ) continue ; if ( 0 ) printf ( "section<S2SV_blank>%d:%s<S2SV_blank>data<S2SV_blank>%p<S2SV_blank>size<S2SV_blank>%zd<S2SV_blank>link<S2SV_blank>%d<S2SV_blank>flags<S2SV_blank>%d\\n" , i , shname , data -> d_buf , data -> d_size , shdr . sh_link , ( int ) shdr . sh_flags ) ; if ( strcmp ( shname , "license" ) == 0 ) { processed_sec [ i ] = true ; memcpy ( license , data -> d_buf , data -> d_size ) ; } else if ( strcmp ( shname , "version" ) == 0 ) { processed_sec [ i ] = true ; if ( data -> d_size != sizeof ( int ) ) { printf ( "invalid<S2SV_blank>size<S2SV_blank>of<S2SV_blank>version<S2SV_blank>section<S2SV_blank>%zd\\n" , data -> d_size ) ; return 1 ; } memcpy ( & kern_version , data -> d_buf , sizeof ( int ) ) ; } else if ( strcmp ( shname , "maps" ) == 0 ) { processed_sec [ i ] = true ; if ( load_maps ( data -> d_buf , data -> d_size ) ) return 1 ; } else if ( shdr . sh_type == SHT_SYMTAB ) { symbols = data ; } } <S2SV_StartBug> for ( i = 1 ; i < ehdr . e_shnum ; i ++ ) { <S2SV_EndBug> if ( get_sec ( elf , i , & ehdr , & shname , & shdr , & data ) ) continue ; if ( shdr . sh_type == SHT_REL ) { struct bpf_insn * insns ; if ( get_sec ( elf , shdr . sh_info , & ehdr , & shname_prog , & shdr_prog , & data_prog ) ) continue ; if ( shdr_prog . sh_type != SHT_PROGBITS || ! ( shdr_prog . sh_flags & SHF_EXECINSTR ) ) continue ; insns = ( struct bpf_insn * ) data_prog -> d_buf ; processed_sec [ shdr . sh_info ] = true ; processed_sec [ i ] = true ; if ( parse_relo_and_apply ( data , symbols , & shdr , insns ) ) continue ; if ( memcmp ( shname_prog , "kprobe/" , 7 ) == 0 || memcmp ( shname_prog , "kretprobe/" , 10 ) == 0 || memcmp ( shname_prog , "tracepoint/" , 11 ) == 0 || memcmp ( shname_prog , "xdp" , 3 ) == 0 || memcmp ( shname_prog , "perf_event" , 10 ) == 0 || memcmp ( shname_prog , "socket" , 6 ) == 0 || memcmp ( shname_prog , "cgroup/" , 7 ) == 0 ) load_and_attach ( shname_prog , insns , data_prog -> d_size ) ; } } for ( i = 1 ; i < ehdr . e_shnum ; i ++ ) { if ( processed_sec [ i ] ) continue ; if ( get_sec ( elf , i , & ehdr , & shname , & shdr , & data ) ) continue ; if ( memcmp ( shname , "kprobe/" , 7 ) == 0 || memcmp ( shname , "kretprobe/" , 10 ) == 0 || memcmp ( shname , "tracepoint/" , 11 ) == 0 || memcmp ( shname , "xdp" , 3 ) == 0 || memcmp ( shname , "perf_event" , 10 ) == 0 || memcmp ( shname , "socket" , 6 ) == 0 || memcmp ( shname , "cgroup/" , 7 ) == 0 ) load_and_attach ( shname , data -> d_buf , data -> d_size ) ; } close ( fd ) ; return 0 ; } | <S2SV_ModStart> * shname_prog ; kern_version = 0 ; memset ( license , 0 , sizeof ( license ) ) ; memset ( processed_sec , 0 , sizeof ( processed_sec ) ) ; <S2SV_ModStart> ++ ) { if ( processed_sec [ i ] ) continue ; |
1,457 | CWE-000 void vm_aff ( t_process * process , t_vm * env ) { static char * * perm = NULL ; t_param param ; char peb ; peb = env -> memory [ process -> pc + 1 ] ; if ( ! perm ) perm = get_aff_perm ( ) ; param . mod = 0 ; <S2SV_StartBug> if ( ! check_peb ( peb , perm , 1 ) ) <S2SV_EndBug> { <S2SV_StartBug> get_param ( & param , process , env ) ; <S2SV_EndBug> if ( ( env -> verbose & SHOW_MOVE ) ) show_pc_mov ( process -> pc , process -> pc + param . len , param . len , env ) ; if ( ! check_reg ( peb , 1 , & param ) ) ft_putchar ( ( unsigned char ) process -> reg [ param . one - 1 ] ) ; } <S2SV_StartBug> process -> pc += param_len ( peb , 1 , 1 ) + 2 ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; param . len = param_len ( peb , 1 , 1 ) + 2 ; <S2SV_ModStart> param , process <S2SV_ModEnd> , env ) <S2SV_ModStart> ) ; } if ( ( env -> verbose & SHOW_MOVE ) ) show_pc_mov ( process -> pc , process -> pc + param . len , param . len , env ) ; <S2SV_ModStart> -> pc += param . len <S2SV_ModEnd> ; } <S2SV_null> |
1,458 | CWE-000 static conversion_stat_t gru_variant_try_double ( const char * str , long double * out ) { char * end ; errno = 0 ; * out = strtold ( str , & end ) ; if ( errno == ERANGE ) { logger_t logger = gru_logger_get ( ) ; <S2SV_StartBug> logger ( WARNING , "Cannot<S2SV_blank>convert<S2SV_blank>the<S2SV_blank>value<S2SV_blank>%s<S2SV_blank>because<S2SV_blank>it\'s<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range" , str ) ; <S2SV_EndBug> return VAR_ERROR | VAR_OUT_OF_RANGE ; } if ( end == str || * end != '\\0' ) { return VAR_ERROR | VAR_NOT_CONVERSIBLE ; } return VAR_SUCCESS ; } | <S2SV_ModStart> ; logger ( GRU_WARNING <S2SV_ModEnd> , "Cannot<S2SV_blank>convert<S2SV_blank>the<S2SV_blank>value<S2SV_blank>%s<S2SV_blank>because<S2SV_blank>it\'s<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range" , |
1,459 | CWE-000 int32_t NaClSysOpen ( struct NaClAppThread * natp , char * pathname , int flags , int mode ) { struct NaClApp * nap = natp -> nap ; uint32_t retval = - NACL_ABI_EINVAL ; char path [ NACL_CONFIG_PATH_MAX ] ; nacl_host_stat_t stbuf ; int allowed_flags ; const char glibc_prefix [ ] = "/lib/glibc/" ; const char tls_prefix [ ] = "/lib/glibc/tls/" ; const size_t tls_start_idx = strlen ( glibc_prefix ) ; const size_t tls_end_idx = strlen ( tls_prefix ) ; int fd_retval ; NaClLog ( 2 , "NaClSysOpen(0x%08" NACL_PRIxPTR ",<S2SV_blank>" "0x%08" NACL_PRIxPTR ",<S2SV_blank>0x%x,<S2SV_blank>0x%x)\\n" , ( uintptr_t ) natp , ( uintptr_t ) pathname , flags , mode ) ; retval = CopyPathFromUser ( nap , path , sizeof path , ( uintptr_t ) pathname ) ; if ( ! memcmp ( path , tls_prefix , sizeof tls_prefix - 1 ) ) { memmove ( path + tls_start_idx , path + tls_end_idx , strlen ( path ) + tls_end_idx + 1 ) ; } if ( retval ) { goto cleanup ; } allowed_flags = ( NACL_ABI_O_ACCMODE | NACL_ABI_O_CREAT | NACL_ABI_O_TRUNC | NACL_ABI_O_APPEND ) ; if ( flags & ~ allowed_flags ) { NaClLog ( 1 , "Invalid<S2SV_blank>open<S2SV_blank>flags<S2SV_blank>0%o,<S2SV_blank>ignoring<S2SV_blank>extraneous<S2SV_blank>bits\\n" , flags ) ; flags &= allowed_flags ; } if ( mode & ~ 0600 ) { NaClLog ( 1 , "IGNORING<S2SV_blank>Invalid<S2SV_blank>access<S2SV_blank>mode<S2SV_blank>bits<S2SV_blank>0%o\\n" , mode ) ; mode &= 0600 ; } retval = NaClOpenAclCheck ( nap , path , flags , mode ) ; if ( retval ) { NaClLog ( 2 , "Open<S2SV_blank>ACL<S2SV_blank>check<S2SV_blank>rejected<S2SV_blank>\\"%s\\".\\n" , path ) ; goto cleanup ; } retval = NaClHostDescStat ( path , & stbuf ) ; if ( ! retval && S_IFDIR == ( S_IFDIR & stbuf . st_mode ) ) { struct NaClHostDir * hd ; hd = malloc ( sizeof * hd ) ; if ( ! hd ) { retval = - NACL_ABI_ENOMEM ; goto cleanup ; } retval = NaClHostDirOpen ( hd , path ) ; NaClLog ( 1 , "NaClHostDirOpen(0x%08" NACL_PRIxPTR ",<S2SV_blank>%s)<S2SV_blank>returned<S2SV_blank>%d\\n" , ( uintptr_t ) hd , path , retval ) ; if ( ! retval ) { retval = NaClSetAvail ( nap , ( ( struct NaClDesc * ) NaClDescDirDescMake ( hd ) ) ) ; NaClLog ( 1 , "Entered<S2SV_blank>directory<S2SV_blank>into<S2SV_blank>open<S2SV_blank>file<S2SV_blank>table<S2SV_blank>at<S2SV_blank>%d\\n" , retval ) ; } } else { struct NaClHostDesc * hd ; hd = malloc ( sizeof * hd ) ; if ( ! hd ) { retval = - NACL_ABI_ENOMEM ; goto cleanup ; } retval = NaClHostDescOpen ( hd , path , flags , mode ) ; NaClLog ( 1 , "NaClHostDescOpen(0x%08" NACL_PRIxPTR ",<S2SV_blank>%s,<S2SV_blank>0%o,<S2SV_blank>0%o)<S2SV_blank>returned<S2SV_blank>%d\\n" , ( uintptr_t ) hd , path , flags , mode , retval ) ; if ( ! retval ) { retval = NaClSetAvail ( nap , ( ( struct NaClDesc * ) NaClDescIoDescMake ( hd ) ) ) ; NaClLog ( 1 , "Entered<S2SV_blank>into<S2SV_blank>open<S2SV_blank>file<S2SV_blank>table<S2SV_blank>at<S2SV_blank>%d\\n" , retval ) ; } } cleanup : fd_cage_table [ nap -> cage_id ] [ nap -> fd ] = retval ; <S2SV_StartBug> fd_retval = nap -> fd ; <S2SV_EndBug> nap -> fd ++ ; if ( fd_retval > CACHED_LIB_NUM_MAX ) { strncpy ( nap -> lib_table [ fd_retval ] . path , path , strlen ( path ) + 1 ) ; nap -> num_lib ++ ; } NaClLog ( 1 , "[***<S2SV_blank>Debug<S2SV_blank>***][Open]<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>filepath<S2SV_blank>=<S2SV_blank>%s<S2SV_blank>\\n" , fd_retval , path ) ; return fd_retval ; } | <S2SV_ModStart> ; fd_retval = <S2SV_ModEnd> nap -> fd |
1,460 | CWE-000 void p9_pgpe_pstate_wof_ctrl ( uint32_t action ) { uint32_t activeCores , activeQuads , c ; if ( action == PGPE_ACTION_WOF_ON ) { if ( ( G_pgpe_header_data -> g_pgpe_qm_flags & PGPE_FLAG_ENABLE_VRATIO ) || ( G_pgpe_header_data -> g_pgpe_qm_flags & PGPE_FLAG_VRATIO_MODIFIER ) ) { <S2SV_StartBug> p9_pgpe_pstate_send_ctrl_stop_updt ( CTRL_STOP_UPDT_ENABLE_CORE ) ; <S2SV_EndBug> activeCores = G_sgpe_control_updt . fields . active_cores << 8 ; <S2SV_StartBug> G_pgpe_pstate_record . activeCoreUpdtAction = ACTIVE_CORE_UPDATE_ACTION_PROCESS_AND_ACK ; <S2SV_EndBug> } else { activeCores = G_pgpe_pstate_record . activeDB ; } activeQuads = G_pgpe_pstate_record . activeQuads ; G_pgpe_pstate_record . wofStatus = WOF_ENABLED ; G_pgpe_pstate_record . activeCores = activeCores ; G_pgpe_pstate_record . pQuadState0 -> fields . active_cores = G_pgpe_pstate_record . activeCores >> 16 ; G_pgpe_pstate_record . pQuadState1 -> fields . active_cores = ( G_pgpe_pstate_record . activeCores & 0xFF00 ) ; G_pgpe_pstate_record . pReqActQuads -> fields . requested_active_quads = activeQuads ; G_pgpe_pstate_record . numActiveCores = 0 ; for ( c = 0 ; c < MAX_CORES ; c ++ ) { if ( G_pgpe_pstate_record . activeCores & CORE_MASK ( c ) ) { G_pgpe_pstate_record . numActiveCores += 1 ; } } PK_TRACE_DBG ( "WCT:<S2SV_blank>numActiveCores=0x%x" , G_pgpe_pstate_record . numActiveCores ) ; PK_TRACE_DBG ( "WCT:<S2SV_blank>activeCores=0x%x" , G_pgpe_pstate_record . activeCores ) ; p9_pgpe_pstate_calc_wof ( ) ; PK_TRACE_DBG ( "WCT:<S2SV_blank>WOF<S2SV_blank>Enabled" ) ; } else if ( action == PGPE_ACTION_WOF_OFF ) { if ( ( G_pgpe_header_data -> g_pgpe_qm_flags & PGPE_FLAG_ENABLE_VRATIO ) || ( G_pgpe_header_data -> g_pgpe_qm_flags & PGPE_FLAG_VRATIO_MODIFIER ) ) { G_pgpe_pstate_record . activeCoreUpdtAction = ACTIVE_CORE_UPDATE_ACTION_ACK_ONLY ; } G_pgpe_pstate_record . wofStatus = WOF_DISABLED ; PK_TRACE_DBG ( "WCT:<S2SV_blank>WOF<S2SV_blank>Disabled" ) ; } } | <S2SV_ModStart> ) ) { if ( G_pgpe_pstate_record . activeCoreUpdtAction == ACTIVE_CORE_UPDATE_ACTION_ERROR ) { <S2SV_ModStart> << 8 ; } else { activeCores = G_pgpe_pstate_record . activeCores ; } |
1,461 | CWE-000 static int disp_resp_workers_not_matched ( network_mysqld_con * con , int * disp_flag ) { int result = 1 ; if ( con -> dist_tran_failed && con -> dist_tran ) { if ( con -> num_pending_servers ) { g_debug ( "%s:<S2SV_blank>not<S2SV_blank>recv<S2SV_blank>all<S2SV_blank>resp:%d" , G_STRLOC , con -> state ) ; * disp_flag = DISP_STOP ; result = 0 ; } else { g_debug ( "%s:<S2SV_blank>check<S2SV_blank>dist<S2SV_blank>tran<S2SV_blank>query<S2SV_blank>status:%d,<S2SV_blank>dist<S2SV_blank>tran<S2SV_blank>state:%d,<S2SV_blank>attr<S2SV_blank>state:%d" , G_STRLOC , con -> state , con -> dist_tran_state , con -> attr_adj_state ) ; if ( con -> xa_query_status_error_and_abort ) { g_debug ( "%s:<S2SV_blank>dist<S2SV_blank>tran<S2SV_blank>query<S2SV_blank>status<S2SV_blank>error:%d" , G_STRLOC , con -> state ) ; } else { if ( con -> is_attr_adjust ) { g_critical ( "%s:<S2SV_blank>attr<S2SV_blank>adj<S2SV_blank>met<S2SV_blank>problems<S2SV_blank>here<S2SV_blank>for<S2SV_blank>con:%p" , G_STRLOC , con ) ; con -> server_to_be_closed = 1 ; <S2SV_StartBug> } else { <S2SV_EndBug> if ( con -> dist_tran_state < NEXT_ST_XA_CANDIDATE_OVER ) { <S2SV_StartBug> g_debug ( "%s:<S2SV_blank>build<S2SV_blank>xa<S2SV_blank>stmt<S2SV_blank>for<S2SV_blank>failure,<S2SV_blank>state:%d" , G_STRLOC , con -> state ) ; <S2SV_EndBug> build_xa_statements ( con ) ; if ( con -> dist_tran_state != NEXT_ST_XA_OVER ) { * disp_flag = DISP_CONTINUE ; return 0 ; } } } con -> state = ST_SEND_QUERY_RESULT ; g_message ( "%s:<S2SV_blank>send<S2SV_blank>dist<S2SV_blank>trans<S2SV_blank>error<S2SV_blank>to<S2SV_blank>client,<S2SV_blank>dist<S2SV_blank>state:%d" , G_STRLOC , con -> dist_tran_state ) ; if ( con -> dist_tran_state != NEXT_ST_XA_OVER ) { g_message ( "%s:<S2SV_blank>dist<S2SV_blank>state<S2SV_blank>not<S2SV_blank>NEXT_ST_XA_OVER<S2SV_blank>for<S2SV_blank>con:%p" , G_STRLOC , con ) ; } g_debug ( "%s:<S2SV_blank>set<S2SV_blank>dist_tran_state<S2SV_blank>NEXT_ST_XA_OVER<S2SV_blank>for<S2SV_blank>con:%p" , G_STRLOC , con ) ; con -> dist_tran_state = NEXT_ST_XA_OVER ; con -> dist_tran = 0 ; con -> dist_tran_failed = 0 ; process_service_unavailable ( con ) ; remove_mul_server_recv_packets ( con ) ; network_queue_clear ( con -> client -> send_queue ) ; * disp_flag = DISP_CONTINUE ; result = 0 ; } } } else { if ( con -> num_pending_servers ) { if ( con -> candidate_tcp_streamed ) { if ( con -> num_read_pending != 0 ) { g_debug ( "%s:<S2SV_blank>we<S2SV_blank>will<S2SV_blank>stop<S2SV_blank>for<S2SV_blank>a<S2SV_blank>while:%p" , G_STRLOC , con ) ; * disp_flag = DISP_STOP ; result = 0 ; } } else { g_debug ( "%s:<S2SV_blank>we<S2SV_blank>will<S2SV_blank>stop<S2SV_blank>for<S2SV_blank>a<S2SV_blank>while:%p" , G_STRLOC , con ) ; * disp_flag = DISP_STOP ; result = 0 ; } } } return result ; } | <S2SV_ModStart> ; } else if ( con -> is_timeout ) { g_critical ( "%s:<S2SV_blank>server<S2SV_blank>timeout<S2SV_blank>for<S2SV_blank>con:%p" , G_STRLOC , con ) ; con -> server_to_be_closed = 1 ; } else <S2SV_ModStart> { g_debug ( "%s:<S2SV_blank>build<S2SV_blank>xa<S2SV_blank>stmt<S2SV_blank>for<S2SV_blank>failure,<S2SV_blank>dist<S2SV_blank>state:%d" , G_STRLOC , con -> dist_tran_state <S2SV_ModEnd> ) ; build_xa_statements |
1,462 | CWE-000 int main ( int ac , char * * av ) { int fd , num_read , i ; unsigned char * buff ; Elf64_Ehdr head ; if ( ac != 2 ) dprintf ( STDERR_FILENO , "Usage:<S2SV_blank>elf_header<S2SV_blank>elf_file\\n" ) , exit ( 98 ) ; fd = open ( av [ 1 ] , O_RDONLY ) ; if ( fd == - 1 ) dprintf ( STDERR_FILENO , "Error:<S2SV_blank>Can\'t<S2SV_blank>read<S2SV_blank>from<S2SV_blank>file<S2SV_blank>%s\\n" , av [ 1 ] ) , exit ( 98 ) ; num_read = read ( fd , & head , sizeof ( Elf64_Ehdr ) ) ; if ( num_read == - 1 ) dprintf ( STDERR_FILENO , "Error:<S2SV_blank>Can\'t<S2SV_blank>read<S2SV_blank>from<S2SV_blank>file<S2SV_blank>%s\\n" , av [ 1 ] ) , exit ( 98 ) ; buff = head . e_ident ; if ( buff [ 0 ] == 0x7f && buff [ 1 ] == 'E' && buff [ 2 ] == 'L' && buff [ 3 ] == 'F' ) { printf ( "ELF<S2SV_blank>Header:\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>Magic:<S2SV_blank><S2SV_blank><S2SV_blank>" ) ; <S2SV_StartBug> for ( i = 0 ; i < 15 ; i ++ ) <S2SV_EndBug> printf ( "%02x<S2SV_blank>" , buff [ i ] ) ; printf ( "\\n" ) ; printf ( "<S2SV_blank><S2SV_blank>Class:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; print_class ( head . e_ident [ 4 ] ) ; printf ( "<S2SV_blank><S2SV_blank>Data:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; print_data ( head . e_ident [ 5 ] ) ; printf ( "<S2SV_blank><S2SV_blank>Version:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; print_version ( head . e_ident [ 6 ] ) ; printf ( "<S2SV_blank><S2SV_blank>OS/ABI:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; print_obsabi ( head . e_ident [ 7 ] ) ; printf ( "<S2SV_blank><S2SV_blank>ABI<S2SV_blank>Version:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%u\\n" , head . e_ident [ 8 ] ) ; printf ( "<S2SV_blank><S2SV_blank>Type:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>" ) ; print_type ( head . e_type ) ; printf ( "<S2SV_blank><S2SV_blank>Entry<S2SV_blank>point<S2SV_blank>address:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>0x" ) ; printf ( "%x\\n" , ( unsigned int ) head . e_entry ) ; } else dprintf ( STDERR_FILENO , "Error:<S2SV_blank>Not<S2SV_blank>an<S2SV_blank>ELF<S2SV_blank>file<S2SV_blank>%s\\n" , av [ 1 ] ) , exit ( 98 ) ; if ( close ( fd ) == - 1 ) dprintf ( STDERR_FILENO , "Error:<S2SV_blank>Cannot<S2SV_blank>close<S2SV_blank>file<S2SV_blank>%s\\n" , av [ 1 ] ) , exit ( 98 ) ; return ( 0 ) ; } | <S2SV_ModStart> ; i < 16 <S2SV_ModEnd> ; i ++ |
1,463 | CWE-000 void task_dcom_wait_for_master ( task_t * i_self ) { int l_rc = 0 ; pbax_id_t l_pbaxid ; uint32_t l_num_read = 0 ; static bool L_first_doorbell_rcvd = FALSE ; static bool L_queue_enabled = FALSE ; static uint32_t L_pobid_retries_left = POBID_RETRIES ; static uint16_t L_no_master_doorbell_cnt = 0 ; static bool L_log_first_fail = FALSE ; DCOM_DBG ( "0.<S2SV_blank>Wait<S2SV_blank>for<S2SV_blank>Master\\n" ) ; do { if ( ! L_queue_enabled ) { pbax_queue_enable ( & G_pbax_read_queue [ 0 ] ) ; L_queue_enabled = TRUE ; } l_num_read = ( CURRENT_TICK ) ? dcom_rx_slv_inbox_doorbell ( ) : 0 ; G_dcomSlvInboxCounter . totalTicks ++ ; if ( l_num_read < sizeof ( G_dcom_slv_inbox_doorbell_rx ) ) { if ( L_first_doorbell_rcvd ) { L_no_master_doorbell_cnt ++ ; if ( L_no_master_doorbell_cnt >= APSS_DATA_FAIL_PMAX_RAIL ) { TRAC_INFO ( "task_dcom_wait_for_master:<S2SV_blank>experiencing<S2SV_blank>data<S2SV_blank>collection<S2SV_blank>problems!<S2SV_blank>fail_count=%i" , L_no_master_doorbell_cnt ) ; G_apss_lower_pmax_rail = TRUE ; if ( ! L_log_first_fail ) { L_log_first_fail = TRUE ; TRAC_ERR ( "Detected<S2SV_blank>a<S2SV_blank>problem<S2SV_blank>with<S2SV_blank>slave<S2SV_blank>data<S2SV_blank>collection:<S2SV_blank>soft<S2SV_blank>time-out[%d].<S2SV_blank>Lowering<S2SV_blank>Pmax_rail!" , APSS_DATA_FAIL_PMAX_RAIL ) ; errlHndl_t l_errl = createErrl ( DCOM_MID_TASK_WAIT_FOR_MASTER , APSS_SLV_SHORT_TIMEOUT , OCC_NO_EXTENDED_RC , ERRL_SEV_INFORMATIONAL , NULL , DEFAULT_TRACE_SIZE , APSS_DATA_FAIL_PMAX_RAIL , 0 ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_COMPONENT_ID , ERRL_COMPONENT_ID_FIRMWARE , ERRL_CALLOUT_PRIORITY_MED ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_HUID , G_sysConfigData . proc_huid , ERRL_CALLOUT_PRIORITY_LOW ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_HUID , G_sysConfigData . apss_huid , ERRL_CALLOUT_PRIORITY_LOW ) ; setErrlActions ( l_errl , ERRL_ACTIONS_MANUFACTURING_ERROR ) ; commitErrl ( & l_errl ) ; } } if ( L_no_master_doorbell_cnt == APSS_DATA_FAIL_MAX ) { TRAC_ERR ( "Detected<S2SV_blank>a<S2SV_blank>problem<S2SV_blank>with<S2SV_blank>slave<S2SV_blank>data<S2SV_blank>collection:<S2SV_blank>hard<S2SV_blank>time-out[%d].<S2SV_blank>Requesting<S2SV_blank>a<S2SV_blank>reset!" , APSS_DATA_FAIL_MAX ) ; errlHndl_t l_errl = createErrl ( DCOM_MID_TASK_WAIT_FOR_MASTER , APSS_SLV_LONG_TIMEOUT , OCC_NO_EXTENDED_RC , ERRL_SEV_INFORMATIONAL , NULL , DEFAULT_TRACE_SIZE , APSS_DATA_FAIL_MAX , 0 ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_COMPONENT_ID , ERRL_COMPONENT_ID_FIRMWARE , ERRL_CALLOUT_PRIORITY_MED ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_HUID , G_sysConfigData . proc_huid , ERRL_CALLOUT_PRIORITY_LOW ) ; addCalloutToErrl ( l_errl , ERRL_CALLOUT_TYPE_HUID , G_sysConfigData . apss_huid , ERRL_CALLOUT_PRIORITY_LOW ) ; REQUEST_RESET ( l_errl ) ; } } break ; } if ( ! L_first_doorbell_rcvd ) { l_pbaxid = G_dcom_slv_inbox_doorbell_rx . pob_id ; if ( l_pbaxid . node_id >= MAX_NUM_NODES ) { if ( L_pobid_retries_left ) { L_pobid_retries_left -- ; break ; } errlHndl_t l_errl = createErrl ( DCOM_MID_WAIT_FOR_MASTER , INTERNAL_FAILURE , OCC_NO_EXTENDED_RC , ERRL_SEV_UNRECOVERABLE , NULL , DEFAULT_TRACE_SIZE , 0 , 0 ) ; REQUEST_RESET ( l_errl ) ; break ; } l_rc = pbax_target_create ( & G_pbax_unicast_target , PBAX_UNICAST , <S2SV_StartBug> PBAX_GROUP , <S2SV_EndBug> 1 , l_pbaxid . node_id , l_pbaxid . chip_id , 0 ) ; if ( l_rc ) { TRAC_ERR ( "pbax_target_create<S2SV_blank>failed<S2SV_blank>creating<S2SV_blank>pbax<S2SV_blank>target<S2SV_blank>to<S2SV_blank>master<S2SV_blank>OCC.<S2SV_blank>rc=%d,<S2SV_blank>node=%d,<S2SV_blank>chip=%d" , l_rc , l_pbaxid . node_id , l_pbaxid . chip_id ) ; errlHndl_t l_errl = createErrl ( DCOM_MID_WAIT_FOR_MASTER , SSX_GENERIC_FAILURE , OCC_NO_EXTENDED_RC , ERRL_SEV_UNRECOVERABLE , NULL , DEFAULT_TRACE_SIZE , l_rc , 0 ) ; REQUEST_RESET ( l_errl ) ; break ; } TRAC_IMP ( "Slave<S2SV_blank>OCC[%d]<S2SV_blank>Received<S2SV_blank>first<S2SV_blank>doorbell<S2SV_blank>from<S2SV_blank>Master<S2SV_blank>OCC[%d]" , ( int ) G_pbax_id . chip_id , G_dcom_slv_inbox_doorbell_rx . pob_id . chip_id ) ; G_dcomSlvInboxCounter . totalTicks = 0 ; G_dcomSlvInboxCounter . totalSuccessful = 0 ; G_dcomSlvInboxCounter . currentFailCount = 0 ; L_first_doorbell_rcvd = TRUE ; } else { TRAC_INFO ( "[%d]<S2SV_blank>Restablished<S2SV_blank>contact<S2SV_blank>via<S2SV_blank>doorbell<S2SV_blank>from<S2SV_blank>Master" , ( int ) G_pbax_id . chip_id ) ; G_apss_lower_pmax_rail = FALSE ; L_no_master_doorbell_cnt = 0 ; } G_dcomTime . slave . doorbellNumWaitRx ++ ; rtl_clr_run_mask_deferred ( RTL_FLAG_MSTR_READY ) ; rtl_stop_task ( TASK_ID_DCOM_WAIT_4_MSTR ) ; } while ( 0 ) ; } | <S2SV_ModStart> , PBAX_UNICAST , PBAX_SYSTEM <S2SV_ModEnd> , 1 , |
1,464 | CWE-000 static int s3c_pm_ops_suspend ( struct device * dev ) { <S2SV_StartBug> struct platform_device * pdev = to_platform_device ( dev ) ; <S2SV_EndBug> <S2SV_StartBug> struct mtd_info * mtd = platform_get_drvdata ( pdev ) ; <S2SV_EndBug> struct onenand_chip * this = mtd -> priv ; this -> wait ( mtd , FL_PM_SUSPENDED ) ; return 0 ; } | <S2SV_ModStart> ) { struct <S2SV_ModEnd> mtd_info * mtd <S2SV_ModStart> * mtd = dev_get_drvdata ( dev <S2SV_ModEnd> ) ; struct |
1,465 | CWE-000 <S2SV_StartBug> VOID <S2SV_EndBug> phydm_Init_cck_setting ( IN PDM_ODM_T pDM_Odm ) { u4Byte value_824 , value_82c ; pDM_Odm -> bCckHighPower = ( BOOLEAN ) ODM_GetBBReg ( pDM_Odm , ODM_REG ( CCK_RPT_FORMAT , pDM_Odm ) , ODM_BIT ( CCK_RPT_FORMAT , pDM_Odm ) ) ; # if ( RTL8192E_SUPPORT == 1 ) if ( pDM_Odm -> SupportICType & ( ODM_RTL8192E ) ) { # if ( DM_ODM_SUPPORT_TYPE == ODM_WIN ) phydm_config_cck_rx_antenna_init ( pDM_Odm ) ; phydm_config_cck_rx_path ( pDM_Odm , PHYDM_A , CCA_PATHDIV_DISABLE ) ; # endif value_824 = ODM_GetBBReg ( pDM_Odm , 0x824 , BIT9 ) ; value_82c = ODM_GetBBReg ( pDM_Odm , 0x82c , BIT9 ) ; if ( value_824 != value_82c ) { ODM_SetBBReg ( pDM_Odm , 0x82c , BIT9 , value_824 ) ; } ODM_SetBBReg ( pDM_Odm , 0xa80 , BIT7 , value_824 ) ; pDM_Odm -> cck_agc_report_type = ( BOOLEAN ) value_824 ; ODM_RT_TRACE ( pDM_Odm , ODM_COMP_INIT , ODM_DBG_LOUD , ( "cck_agc_report_type<S2SV_blank>=<S2SV_blank>((<S2SV_blank>%d<S2SV_blank>)),<S2SV_blank>ExtLNAGain<S2SV_blank>=<S2SV_blank>((<S2SV_blank>%d<S2SV_blank>))\\n" , pDM_Odm -> cck_agc_report_type , pDM_Odm -> ExtLNAGain ) ) ; } # endif # if ( ( RTL8703B_SUPPORT == 1 ) || ( RTL8723D_SUPPORT == 1 ) ) if ( pDM_Odm -> SupportICType & ( ODM_RTL8703B | ODM_RTL8723D ) ) { pDM_Odm -> cck_agc_report_type = ODM_GetBBReg ( pDM_Odm , 0x950 , BIT11 ) ? 1 : 0 ; if ( pDM_Odm -> cck_agc_report_type != 1 ) { DbgPrint ( "[Warning]<S2SV_blank>8703B/8723D<S2SV_blank>CCK<S2SV_blank>should<S2SV_blank>be<S2SV_blank>4bit<S2SV_blank>LNA,<S2SV_blank>ie.<S2SV_blank>0x950[11]<S2SV_blank>=<S2SV_blank>1\\n" ) ; } } # endif # if ( ( RTL8723D_SUPPORT == 1 ) || ( RTL8822B_SUPPORT == 1 ) || ( RTL8197F_SUPPORT == 1 ) ) if ( pDM_Odm -> SupportICType & ( ODM_RTL8723D | ODM_RTL8822B | ODM_RTL8197F ) ) { pDM_Odm -> cck_new_agc = ODM_GetBBReg ( pDM_Odm , 0xa9c , BIT17 ) ? TRUE : FALSE ; } else # endif pDM_Odm -> cck_new_agc = FALSE ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
1,466 | CWE-000 static void _cb_popup ( void * data , Evas_Object * _obj EINA_UNUSED , void * event ) { Term * term = data ; const char * src = event ; if ( ! src ) src = termio_link_get ( term -> termio ) ; if ( ! src ) return ; _popmedia ( term , src ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> src ) ; if ( ! event ) free ( ( void * ) src ) ; |
1,467 | CWE-000 void generatekey_explicitlySetWrongDigest_ShouldFail ( void * * state ) { rnp_test_state_t * rstate = * state ; rnp_t rnp ; rnp_cfg_t ops = { 0 } ; static const char test_ecdsa_384 [ ] = "19\\n2\\n" ; <S2SV_StartBug> rnp_assert_true ( rstate , rnp_cfg_setint ( & ops , CFG_EXPERT , 1 ) ) ; <S2SV_EndBug> rnp_assert_true ( rstate , rnp_cfg_set ( & ops , CFG_HASH , "WRONG_DIGEST_ALGORITHM" ) ) ; rnp_assert_false ( rstate , ask_expert_details ( & rnp , & ops , test_ecdsa_384 , sizeof ( test_ecdsa_384 ) ) ) ; rnp_cfg_free ( & ops ) ; } | <S2SV_ModStart> ( rstate , rnp_cfg_setbool <S2SV_ModEnd> ( & ops <S2SV_ModStart> , CFG_EXPERT , true <S2SV_ModEnd> ) ) ; |
1,468 | CWE-000 LIS_INT main ( int argc , char * argv [ ] ) { LIS_Comm comm ; LIS_SCALAR * a , * x , * b , * u , * w ; LIS_INT m , n , nn ; LIS_INT i , j , ii , jj , nnz ; double time , time0 ; LIS_REAL resid_r , resid_b ; LIS_DEBUG_FUNC_IN ; lis_initialize ( & argc , & argv ) ; comm = LIS_COMM_WORLD ; if ( argc < 3 ) { lis_printf ( comm , "Usage:<S2SV_blank>%s<S2SV_blank>m<S2SV_blank>n\\n" , argv [ 0 ] ) ; CHKERR ( 1 ) ; } m = atoi ( argv [ 1 ] ) ; n = atoi ( argv [ 2 ] ) ; if ( m <= 0 || n <= 0 ) { lis_printf ( comm , "m=%D<S2SV_blank><=0<S2SV_blank>or<S2SV_blank>n=%D<S2SV_blank><=0\\n" , m , n ) ; CHKERR ( 1 ) ; } lis_printf ( comm , "\\n" ) ; nn = m * n ; a = ( LIS_SCALAR * ) malloc ( nn * nn * sizeof ( LIS_SCALAR ) ) ; b = ( LIS_SCALAR * ) malloc ( nn * sizeof ( LIS_SCALAR ) ) ; x = ( LIS_SCALAR * ) malloc ( nn * sizeof ( LIS_SCALAR ) ) ; u = ( LIS_SCALAR * ) malloc ( nn * sizeof ( LIS_SCALAR ) ) ; w = ( LIS_SCALAR * ) malloc ( nn * nn * sizeof ( LIS_SCALAR ) ) ; lis_array_set_all ( nn * nn , ( LIS_SCALAR ) 0.0 , a ) ; nnz = 0 ; for ( ii = 0 ; ii < nn ; ii ++ ) { i = ii / m ; j = ii - i * m ; if ( i > 0 ) { jj = ii - m ; a [ ii + jj * nn ] = - 1.0 ; nnz ++ ; } if ( i < n - 1 ) { jj = ii + m ; a [ ii + jj * nn ] = - 1.0 ; nnz ++ ; } if ( j > 0 ) { jj = ii - 1 ; a [ ii + jj * nn ] = - 1.0 ; nnz ++ ; } if ( j < m - 1 ) { jj = ii + 1 ; a [ ii + jj * nn ] = - 1.0 ; nnz ++ ; } jj = ii ; a [ ii + jj * nn ] = 4.0 ; nnz ++ ; } lis_printf ( comm , "matrix<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%D<S2SV_blank>x<S2SV_blank>%D<S2SV_blank>(%D<S2SV_blank>nonzero<S2SV_blank>entries)\\n\\n" , nn , nn , nnz ) ; lis_array_set_all ( nn , ( LIS_SCALAR ) 1.0 , u ) ; lis_array_matvec ( nn , a , u , b , LIS_INS_VALUE ) ; time0 = lis_wtime ( ) ; lis_array_solve ( nn , a , b , x , w ) ; time = lis_wtime ( ) - time0 ; lis_array_xpay ( nn , x , ( LIS_SCALAR ) - 1.0 , u ) ; lis_array_nrm2 ( nn , u , & resid_r ) ; lis_array_nrm2 ( nn , b , & resid_b ) ; lis_printf ( comm , "Direct:<S2SV_blank>elapsed<S2SV_blank>time<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%e<S2SV_blank>sec.\\n" , time ) ; lis_printf ( comm , "Direct:<S2SV_blank><S2SV_blank><S2SV_blank>linear<S2SV_blank>solver<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%e<S2SV_blank>sec.\\n" , time ) ; <S2SV_StartBug> lis_printf ( comm , "Direct:<S2SV_blank>relative<S2SV_blank>residual<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>=<S2SV_blank>%e\\n\\n" , ( double ) resid_r / resid_b ) ; <S2SV_EndBug> free ( a ) ; free ( b ) ; free ( x ) ; free ( u ) ; free ( w ) ; lis_finalize ( ) ; LIS_DEBUG_FUNC_OUT ; return 0 ; } | <S2SV_ModStart> ( double ) ( <S2SV_ModStart> / resid_b ) ) |
1,469 | CWE-000 dictionary * _Nonnull allocateDictionary ( void ) { dictionary * d = ( dictionary * ) malloc ( sizeof ( dictionary ) ) ; <S2SV_StartBug> * d = ( dictionary ) { . next = NULL , . previous = NULL } ; <S2SV_EndBug> bzero ( d -> key , MAX_KEY_VALUE_STRING ) ; bzero ( d -> value , MAX_KEY_VALUE_STRING ) ; <S2SV_StartBug> return d ; <S2SV_EndBug> } | <S2SV_ModStart> ) { . has_tag = false , . <S2SV_ModStart> MAX_KEY_VALUE_STRING ) ; bzero ( d -> tag , 1 ) ; |
1,470 | CWE-000 void msg_cleanup_function ( void * arg ) { <S2SV_StartBug> debug ( 1 , "msg_cleanup_function<S2SV_blank>called." ) ; <S2SV_EndBug> msg_free ( ( rtsp_message * ) arg ) ; } | <S2SV_ModStart> arg ) { <S2SV_ModEnd> msg_free ( ( |
1,471 | CWE-000 static ssize_t mipi2lvds_auto_brightness_show ( struct device * dev , struct device_attribute * attr , char * buf ) { int rc ; <S2SV_StartBug> rc = snprintf ( ( char * ) buf , sizeof ( buf ) , "%d\\n" , <S2SV_EndBug> msd . dstat . auto_brightness ) ; pr_info ( "%s<S2SV_blank>:[MIPI2LVDS]<S2SV_blank>auto_brightness<S2SV_blank>:<S2SV_blank>%d\\n" , __func__ , msd . dstat . auto_brightness ) ; return rc ; } | <S2SV_ModStart> ) buf , ( int ) |
1,472 | CWE-000 int arch_prepare_optimized_kprobe ( struct optimized_kprobe * op , struct kprobe * __unused ) { u8 * buf ; int ret ; long rel ; if ( ! can_optimize ( ( unsigned long ) op -> kp . addr ) ) return - EILSEQ ; op -> optinsn . insn = get_optinsn_slot ( ) ; if ( ! op -> optinsn . insn ) return - ENOMEM ; rel = ( long ) op -> optinsn . insn - ( long ) op -> kp . addr + RELATIVEJUMP_SIZE ; if ( abs ( rel ) > 0x7fffffff ) { __arch_remove_optimized_kprobe ( op , 0 ) ; return - ERANGE ; } buf = ( u8 * ) op -> optinsn . insn ; <S2SV_StartBug> ret = copy_optimized_instructions ( buf + TMPL_END_IDX , op -> kp . addr ) ; <S2SV_EndBug> if ( ret < 0 ) { __arch_remove_optimized_kprobe ( op , 0 ) ; return ret ; } op -> optinsn . size = ret ; memcpy ( buf , & optprobe_template_entry , TMPL_END_IDX ) ; synthesize_set_arg1 ( buf + TMPL_MOVE_IDX , ( unsigned long ) op ) ; synthesize_relcall ( buf + TMPL_CALL_IDX , optimized_callback ) ; synthesize_reljump ( buf + TMPL_END_IDX + op -> optinsn . size , ( u8 * ) op -> kp . addr + op -> optinsn . size ) ; <S2SV_StartBug> flush_icache_range ( ( unsigned long ) buf , <S2SV_EndBug> ( unsigned long ) buf + TMPL_END_IDX + op -> optinsn . size + RELATIVEJUMP_SIZE ) ; return 0 ; } | <S2SV_ModStart> . insn ; set_memory_rw ( ( unsigned long ) buf & PAGE_MASK , 1 ) ; <S2SV_ModStart> size ) ; set_memory_ro ( ( unsigned long ) buf & PAGE_MASK , 1 ) ; |
1,473 | CWE-000 int main ( int argc , char * * argv ) { int r ; int server_socket ; int client_socket ; int client_address_size ; struct sockaddr_in client_address ; char buffer [ BUF_SIZE ] ; char filePath [ FILE_NAME_SIZE ] ; if ( argc != 4 ) { fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank><launcher_ip><S2SV_blank><start_ip><S2SV_blank><end_ip>\\n" , argv [ 0 ] ) ; exit ( 1 ) ; } if ( check_ip_arg ( argv [ 2 ] , argv [ 3 ] ) == - 1 ) { fprintf ( stderr , "IP<S2SV_blank>Argument<S2SV_blank>Error\\n" ) ; exit ( 1 ) ; } server_socket = port_bind ( argv [ 1 ] ) ; if ( server_socket == - 1 ) { exit ( 1 ) ; } while ( 1 ) { client_address_size = sizeof ( client_address ) ; client_socket = accept ( server_socket , ( struct sockaddr * ) & client_address , & client_address_size ) ; if ( client_socket == - 1 ) { fprintf ( stderr , "accept()<S2SV_blank>error\\n" ) ; continue ; } if ( check_range ( argv [ 2 ] , argv [ 3 ] , inet_ntoa ( client_address . sin_addr ) ) == - 1 ) { fprintf ( stderr , "range<S2SV_blank>error\\n" ) ; close ( client_socket ) ; continue ; } printf ( "DEBUG]<S2SV_blank>Hello<S2SV_blank>%s\\n" , inet_ntoa ( client_address . sin_addr ) ) ; <S2SV_StartBug> while ( 1 ) { <S2SV_EndBug> memset ( buffer , 0 , BUF_SIZE ) ; memset ( filePath , 0 , FILE_NAME_SIZE ) ; r = read ( client_socket , buffer , BUF_SIZE ) ; if ( r <= 0 ) { break ; } if ( jsonParse ( filePath , buffer ) == 0 ) { printf ( "DEBUG]<S2SV_blank>Client:<S2SV_blank>%s\\n" , filePath ) ; } <S2SV_StartBug> } <S2SV_EndBug> close ( client_socket ) ; } close ( server_socket ) ; return 0 ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> memset ( buffer <S2SV_ModStart> ) ; } <S2SV_ModEnd> close ( client_socket |
1,474 | CWE-000 static char * int_handler ( char c , va_list * args , int * f , int * wpl ) { size_t t ; char * o ; char * temp ; intmax_t n ; n = s_con ( c , args , ( t_lmod ) wpl [ 2 ] ) ; <S2SV_StartBug> wpl [ 0 ] = ( ( n < 0 || f [ 2 ] == 2 ) && f [ 1 ] == 1 ) ? wpl [ 0 ] - 1 : wpl [ 0 ] ; <S2SV_EndBug> wpl [ 1 ] = ( f [ 1 ] == 1 && wpl [ 1 ] < wpl [ 0 ] ) ? wpl [ 0 ] : wpl [ 1 ] ; o = ft_itoa_base ( n , 10 , wpl [ 1 ] ) ; if ( ( f [ 2 ] == 1 || f [ 2 ] == 2 ) && ft_strchr ( o , '-' ) == NULL ) { temp = ( f [ 2 ] == 1 ) ? ft_strjoin ( "<S2SV_blank>" , o ) : ft_strjoin ( "+" , o ) ; free ( o ) ; o = ft_strdup ( temp ) ; free ( temp ) ; } t = ( wpl [ 0 ] >= 0 ) ? wpl [ 0 ] : 0 ; o = ( f [ 1 ] == 0 ) ? ft_strfill ( o , "<S2SV_blank>" , t , 0 ) : o ; o = ( f [ 1 ] == 2 ) ? ft_strfill ( o , "<S2SV_blank>" , t , 1 ) : o ; return ( o ) ; } | <S2SV_ModStart> [ 2 ] > 0 <S2SV_ModEnd> ) && f |
1,475 | CWE-000 int census_add ( struct census * c , int item , double weight ) { int err , pos , i , rehash ; rehash = 0 ; if ( isnan ( weight ) ) { <S2SV_StartBug> err = ERROR_INVAL ; <S2SV_EndBug> logmsg ( err , "invalid<S2SV_blank>weight<S2SV_blank>for<S2SV_blank>census<S2SV_blank>item<S2SV_blank>%d<S2SV_blank>(NaN)" , item ) ; goto error ; } if ( census_find ( c , item , & i ) ) { c -> weights [ i ] += weight ; err = 0 ; goto out ; } pos = i ; i = c -> nitem ; if ( c -> nitem == c -> nitem_max ) { if ( ( err = census_grow ( c , 1 ) ) ) { goto error ; } } if ( c -> nitem == c -> table . capacity ) { if ( ( err = corpus_table_reinit ( & c -> table , c -> nitem + 1 ) ) ) { goto error ; } rehash = 1 ; } c -> weights [ i ] = weight ; c -> items [ i ] = item ; c -> nitem ++ ; if ( rehash ) { census_rehash ( c ) ; } else { c -> table . items [ pos ] = i ; } err = 0 ; goto out ; error : <S2SV_StartBug> logmsg ( err , "failed<S2SV_blank>adding<S2SV_blank>item<S2SV_blank>to<S2SV_blank>census" ) ; <S2SV_EndBug> if ( rehash ) { census_rehash ( c ) ; } out : return err ; } | <S2SV_ModStart> { err = CORPUS_ERROR_INVAL ; corpus_log <S2SV_ModEnd> ( err , <S2SV_ModStart> ; error : corpus_log <S2SV_ModEnd> ( err , |
1,476 | CWE-000 fpga_result sysfs_read_u32 ( const char * path , uint32_t * u ) { int fd ; int res ; char buf [ SYSFS_PATH_MAX ] ; int b ; <S2SV_StartBug> fd = open ( path , O_RDONLY ) ; <S2SV_EndBug> if ( fd < 0 ) { FPGA_MSG ( "open(%s)<S2SV_blank>failed" , path ) ; return FPGA_NOT_FOUND ; } if ( ( off_t ) - 1 == lseek ( fd , 0 , SEEK_SET ) ) { FPGA_MSG ( "seek<S2SV_blank>failed" ) ; goto out_close ; } b = 0 ; do { res = read ( fd , buf + b , sizeof ( buf ) - b ) ; if ( res <= 0 ) { FPGA_MSG ( "Read<S2SV_blank>from<S2SV_blank>%s<S2SV_blank>failed" , path ) ; goto out_close ; } b += res ; if ( ( ( unsigned ) b > sizeof ( buf ) ) || ( b <= 0 ) ) { FPGA_MSG ( "Unexpected<S2SV_blank>size<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>%s" , path ) ; goto out_close ; } } while ( buf [ b - 1 ] != '\\n' && buf [ b - 1 ] != '\\0' && ( unsigned ) b < sizeof ( buf ) ) ; buf [ b - 1 ] = 0 ; * u = strtoul ( buf , NULL , 0 ) ; close ( fd ) ; return FPGA_OK ; out_close : close ( fd ) ; return FPGA_NOT_FOUND ; } | <S2SV_ModStart> int b ; if ( path == NULL ) { FPGA_ERR ( "Invalid<S2SV_blank>input<S2SV_blank>path" ) ; return FPGA_INVALID_PARAM ; } |
1,477 | CWE-000 static void set_restore ( char * argv0 ) { char buffer [ 1024 ] ; char * ptr , * name = NULL ; char cmd = '<S2SV_blank>' ; int line = 0 , first_pass , i , bindings = 0 ; struct settype * settype = NULL ; struct ip_set_req_setnames * header ; ip_set_id_t index ; FILE * in ; int res ; in = create_tempfile ( ) ; load_set_list ( IPSET_TOKEN_ALL , & index , IP_SET_OP_LIST_SIZE , CMD_RESTORE ) ; restore_size = sizeof ( struct ip_set_req_setnames ) + sizeof ( struct ip_set_restore ) ; DP ( "restore_size:<S2SV_blank>%u" , restore_size ) ; while ( fgets ( buffer , sizeof ( buffer ) , in ) ) { line ++ ; if ( buffer [ 0 ] == '\\n' ) continue ; else if ( buffer [ 0 ] == '#' ) continue ; else if ( strcmp ( buffer , "COMMIT\\n" ) == 0 ) { restore = 1 ; break ; } ptr = strtok ( buffer , "<S2SV_blank>\\t\\n" ) ; DP ( "ptr:<S2SV_blank>%s" , ptr ) ; if ( ptr == NULL || ptr [ 0 ] != '-' || ! ( ptr [ 1 ] == 'N' || ptr [ 1 ] == 'A' || ptr [ 1 ] == 'B' ) || ptr [ 2 ] != '\\0' ) { exit_error ( PARAMETER_PROBLEM , "Line<S2SV_blank>%u<S2SV_blank>does<S2SV_blank>not<S2SV_blank>start<S2SV_blank>as<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>restore<S2SV_blank>command\\n" , line ) ; } cmd = ptr [ 1 ] ; ptr = strtok ( NULL , "<S2SV_blank>\\t\\n" ) ; DP ( "setname:<S2SV_blank>%s" , ptr ) ; if ( ptr == NULL ) exit_error ( PARAMETER_PROBLEM , "Missing<S2SV_blank>set<S2SV_blank>name<S2SV_blank>in<S2SV_blank>line<S2SV_blank>%u\\n" , line ) ; DP ( "cmd<S2SV_blank>%c" , cmd ) ; switch ( cmd ) { case 'N' : { name = check_set_name ( ptr ) ; ptr = strtok ( NULL , "<S2SV_blank>\\t\\n" ) ; if ( ptr == NULL ) exit_error ( PARAMETER_PROBLEM , "Missing<S2SV_blank>settype<S2SV_blank>in<S2SV_blank>line<S2SV_blank>%u\\n" , line ) ; if ( bindings ) exit_error ( PARAMETER_PROBLEM , "Invalid<S2SV_blank>line<S2SV_blank>%u:<S2SV_blank>create<S2SV_blank>must<S2SV_blank>precede<S2SV_blank>bindings\\n" , line ) ; settype = check_set_typename ( ptr ) ; restore_size += sizeof ( struct ip_set_restore ) + settype -> create_size ; DP ( "restore_size<S2SV_blank>(N):<S2SV_blank>%u" , restore_size ) ; break ; } case 'A' : { if ( name == NULL || strncmp ( name , ptr , sizeof ( name ) ) != 0 ) exit_error ( PARAMETER_PROBLEM , "Add<S2SV_blank>IP<S2SV_blank>to<S2SV_blank>set<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>line<S2SV_blank>%u<S2SV_blank>without<S2SV_blank>" "preceding<S2SV_blank>corresponding<S2SV_blank>create<S2SV_blank>set<S2SV_blank>line\\n" , ptr , line ) ; if ( bindings ) exit_error ( PARAMETER_PROBLEM , "Invalid<S2SV_blank>line<S2SV_blank>%u:<S2SV_blank>adding<S2SV_blank>entries<S2SV_blank>must<S2SV_blank>precede<S2SV_blank>bindings\\n" , line ) ; restore_size += settype -> adt_size ; DP ( "restore_size<S2SV_blank>(A):<S2SV_blank>%u" , restore_size ) ; break ; } case 'B' : { bindings = 1 ; restore_size += sizeof ( struct ip_set_hash_save ) ; DP ( "restore_size<S2SV_blank>(B):<S2SV_blank>%u" , restore_size ) ; break ; } default : { exit_error ( PARAMETER_PROBLEM , "Unrecognized<S2SV_blank>restore<S2SV_blank>command<S2SV_blank>in<S2SV_blank>line<S2SV_blank>%u\\n" , line ) ; } } } if ( ! restore ) exit_error ( PARAMETER_PROBLEM , "Missing<S2SV_blank>COMMIT<S2SV_blank>line\\n" ) ; DP ( "restore_size:<S2SV_blank>%u" , restore_size ) ; restore_data = ipset_malloc ( restore_size ) ; header = ( struct ip_set_req_setnames * ) restore_data ; header -> op = IP_SET_OP_RESTORE ; header -> size = restore_size ; restore_offset = sizeof ( struct ip_set_req_setnames ) ; fseek ( in , 0L , SEEK_SET ) ; first_pass = line ; line = 0 ; <S2SV_StartBug> newargv [ newargc ++ ] = strdup ( argv0 ) ; <S2SV_EndBug> while ( fgets ( buffer , sizeof ( buffer ) , in ) ) { line ++ ; if ( buffer [ 0 ] == '\\n' ) continue ; else if ( buffer [ 0 ] == '#' ) continue ; else if ( strcmp ( buffer , "COMMIT\\n" ) == 0 ) goto do_restore ; DP ( "restoring:<S2SV_blank>%s" , buffer ) ; build_argv ( line , buffer ) ; for ( i = 0 ; i < newargc ; i ++ ) DP ( "argv[%u]:<S2SV_blank>%s" , i , newargv [ i ] ) ; parse_commandline ( newargc , newargv ) ; } exit_error ( PARAMETER_PROBLEM , "Broken<S2SV_blank>restore<S2SV_blank>file\\n" ) ; do_restore : if ( bindings == 0 && restore_size == ( restore_offset + sizeof ( struct ip_set_restore ) ) ) { struct ip_set_restore * marker = ( struct ip_set_restore * ) ( restore_data + restore_offset ) ; DP ( "restore<S2SV_blank>marker" ) ; marker -> index = IP_SET_INVALID_ID ; marker -> header_size = marker -> members_size = 0 ; restore_offset += sizeof ( struct ip_set_restore ) ; } if ( restore_size != restore_offset ) exit_error ( PARAMETER_PROBLEM , "Giving<S2SV_blank>up,<S2SV_blank>restore<S2SV_blank>file<S2SV_blank>is<S2SV_blank>screwed<S2SV_blank>up!" ) ; res = kernel_getfrom_handleerrno ( CMD_RESTORE , restore_data , & restore_size ) ; if ( res != 0 ) { if ( restore_size != sizeof ( struct ip_set_req_setnames ) ) exit_error ( PARAMETER_PROBLEM , "Communication<S2SV_blank>with<S2SV_blank>kernel<S2SV_blank>failed<S2SV_blank>(%u<S2SV_blank>%u)!" , restore_size , sizeof ( struct ip_set_req_setnames ) ) ; header = ( struct ip_set_req_setnames * ) restore_data ; if ( header -> size != 0 ) exit_error ( PARAMETER_PROBLEM , "Committing<S2SV_blank>restoring<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>line<S2SV_blank>%u!" , header -> size ) ; } } | <S2SV_ModStart> ++ ] = ipset_strdup <S2SV_ModEnd> ( argv0 ) |
1,478 | CWE-000 bool pm_get_wakeup_count ( unsigned int * count , bool block ) { unsigned int cnt , inpr ; <S2SV_StartBug> if ( block ) { <S2SV_EndBug> <S2SV_StartBug> DEFINE_WAIT ( wait ) ; <S2SV_EndBug> for ( ; ; ) { prepare_to_wait ( & wakeup_count_wait_queue , & wait , TASK_INTERRUPTIBLE ) ; split_counters ( & cnt , & inpr ) ; if ( inpr == 0 || signal_pending ( current ) ) break ; print_active_wakeup_sources ( ) ; schedule ( ) ; } finish_wait ( & wakeup_count_wait_queue , & wait ) ; } split_counters ( & cnt , & inpr ) ; * count = cnt ; return ! inpr ; } | <S2SV_ModStart> , inpr ; unsigned long flags ; <S2SV_ModStart> DEFINE_WAIT ( wait ) ; spin_lock_irqsave ( & events_lock , flags ) ; last_read_time = ktime_get ( ) ; spin_unlock_irqrestore ( & events_lock , flags |
1,479 | CWE-000 NPY_NO_EXPORT PyObject * PyArray_Resize ( PyArrayObject * self , PyArray_Dims * newshape , int refcheck , NPY_ORDER order ) { npy_intp oldnbytes , newnbytes ; npy_intp oldsize , newsize ; int new_nd = newshape -> len , k , n , elsize ; int refcnt ; npy_intp * new_dimensions = newshape -> ptr ; npy_intp new_strides [ NPY_MAXDIMS ] ; npy_intp * dimptr ; char * new_data ; if ( ! PyArray_ISONESEGMENT ( self ) ) { PyErr_SetString ( PyExc_ValueError , "resize<S2SV_blank>only<S2SV_blank>works<S2SV_blank>on<S2SV_blank>single-segment<S2SV_blank>arrays" ) ; return NULL ; } oldsize = PyArray_SIZE ( self ) ; newsize = 1 ; for ( k = 0 ; k < new_nd ; k ++ ) { if ( new_dimensions [ k ] == 0 ) { newsize = 0 ; break ; } if ( new_dimensions [ k ] < 0 ) { PyErr_SetString ( PyExc_ValueError , "negative<S2SV_blank>dimensions<S2SV_blank>not<S2SV_blank>allowed" ) ; return NULL ; } if ( npy_mul_with_overflow_intp ( & newsize , newsize , new_dimensions [ k ] ) ) { return PyErr_NoMemory ( ) ; } } elsize = PyArray_DESCR ( self ) -> elsize ; oldnbytes = oldsize * elsize ; if ( npy_mul_with_overflow_intp ( & newnbytes , newsize , elsize ) ) { return PyErr_NoMemory ( ) ; } if ( oldnbytes != newnbytes ) { if ( ! ( PyArray_FLAGS ( self ) & NPY_ARRAY_OWNDATA ) ) { PyErr_SetString ( PyExc_ValueError , "cannot<S2SV_blank>resize<S2SV_blank>this<S2SV_blank>array:<S2SV_blank>it<S2SV_blank>does<S2SV_blank>not<S2SV_blank>own<S2SV_blank>its<S2SV_blank>data" ) ; return NULL ; } if ( refcheck ) { # ifdef PYPY_VERSION PyErr_SetString ( PyExc_ValueError , "cannot<S2SV_blank>resize<S2SV_blank>an<S2SV_blank>array<S2SV_blank>with<S2SV_blank>refcheck=True<S2SV_blank>on<S2SV_blank>PyPy.\\n" <S2SV_StartBug> "Use<S2SV_blank>the<S2SV_blank>resize<S2SV_blank>function<S2SV_blank>or<S2SV_blank>refcheck=False" ) ; <S2SV_EndBug> return NULL ; # else refcnt = PyArray_REFCOUNT ( self ) ; # endif } else { refcnt = 1 ; } if ( ( refcnt > 2 ) || ( PyArray_BASE ( self ) != NULL ) || ( ( ( PyArrayObject_fields * ) self ) -> weakreflist != NULL ) ) { PyErr_SetString ( PyExc_ValueError , "cannot<S2SV_blank>resize<S2SV_blank>an<S2SV_blank>array<S2SV_blank>that<S2SV_blank>" "references<S2SV_blank>or<S2SV_blank>is<S2SV_blank>referenced\\n" <S2SV_StartBug> "by<S2SV_blank>another<S2SV_blank>array<S2SV_blank>in<S2SV_blank>this<S2SV_blank>way.<S2SV_blank><S2SV_blank>Use<S2SV_blank>the<S2SV_blank>resize<S2SV_blank>function" ) ; <S2SV_EndBug> return NULL ; } new_data = PyDataMem_RENEW ( PyArray_DATA ( self ) , newnbytes == 0 ? elsize : newnbytes ) ; if ( new_data == NULL ) { PyErr_SetString ( PyExc_MemoryError , "cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>array" ) ; return NULL ; } ( ( PyArrayObject_fields * ) self ) -> data = new_data ; } if ( newnbytes > oldnbytes && PyArray_ISWRITEABLE ( self ) ) { if ( PyDataType_FLAGCHK ( PyArray_DESCR ( self ) , NPY_ITEM_REFCOUNT ) ) { PyObject * zero = PyInt_FromLong ( 0 ) ; char * optr ; optr = PyArray_BYTES ( self ) + oldnbytes ; n = newsize - oldsize ; for ( k = 0 ; k < n ; k ++ ) { _putzero ( ( char * ) optr , zero , PyArray_DESCR ( self ) ) ; optr += elsize ; } Py_DECREF ( zero ) ; } else { memset ( PyArray_BYTES ( self ) + oldnbytes , 0 , newnbytes - oldnbytes ) ; } } if ( new_nd > 0 ) { if ( PyArray_NDIM ( self ) != new_nd ) { ( ( PyArrayObject_fields * ) self ) -> nd = new_nd ; dimptr = PyDimMem_RENEW ( PyArray_DIMS ( self ) , 3 * new_nd ) ; if ( dimptr == NULL ) { PyErr_SetString ( PyExc_MemoryError , "cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>array" ) ; return NULL ; } ( ( PyArrayObject_fields * ) self ) -> dimensions = dimptr ; ( ( PyArrayObject_fields * ) self ) -> strides = dimptr + new_nd ; } _array_fill_strides ( new_strides , new_dimensions , new_nd , PyArray_DESCR ( self ) -> elsize , PyArray_FLAGS ( self ) , & ( ( ( PyArrayObject_fields * ) self ) -> flags ) ) ; memmove ( PyArray_DIMS ( self ) , new_dimensions , new_nd * sizeof ( npy_intp ) ) ; memmove ( PyArray_STRIDES ( self ) , new_strides , new_nd * sizeof ( npy_intp ) ) ; } else { PyDimMem_FREE ( ( ( PyArrayObject_fields * ) self ) -> dimensions ) ; ( ( PyArrayObject_fields * ) self ) -> nd = 0 ; ( ( PyArrayObject_fields * ) self ) -> dimensions = NULL ; ( ( PyArrayObject_fields * ) self ) -> strides = NULL ; } Py_RETURN_NONE ; } | <S2SV_ModStart> PyExc_ValueError , "cannot<S2SV_blank>resize<S2SV_blank>an<S2SV_blank>array<S2SV_blank>with<S2SV_blank>refcheck=True<S2SV_blank>on<S2SV_blank>PyPy.\\n" "Use<S2SV_blank>the<S2SV_blank>reshape<S2SV_blank>function<S2SV_blank>or<S2SV_blank>refcheck=False" <S2SV_ModEnd> ) ; return <S2SV_ModStart> , "cannot<S2SV_blank>resize<S2SV_blank>an<S2SV_blank>array<S2SV_blank>that<S2SV_blank>" "references<S2SV_blank>or<S2SV_blank>is<S2SV_blank>referenced\\n" "by<S2SV_blank>another<S2SV_blank>array<S2SV_blank>in<S2SV_blank>this<S2SV_blank>way.<S2SV_blank><S2SV_blank>Use<S2SV_blank>the<S2SV_blank>reshape<S2SV_blank>function<S2SV_blank>or<S2SV_blank>refcheck=False" <S2SV_ModEnd> ) ; return |
1,480 | CWE-000 struct Code_Node * get_new_node_from_code_node_array ( struct Code_Node_Array * code_node_array ) { <S2SV_StartBug> if ( code_node_array -> capacity == code_node_array -> length ) { <S2SV_EndBug> code_node_array -> capacity *= 2 ; <S2SV_StartBug> realloc ( code_node_array -> first , code_node_array -> capacity ) ; <S2SV_EndBug> } code_node_array -> length += 1 ; code_node_array -> last ++ ; return code_node_array -> last ; } | <S2SV_ModStart> ( code_node_array -> length <S2SV_ModEnd> == code_node_array -> <S2SV_ModStart> == code_node_array -> capacity <S2SV_ModEnd> ) { code_node_array <S2SV_ModStart> *= 2 ; code_node_array -> first = |
1,481 | CWE-000 static struct hash_entry * hash_table_u64_search ( struct hash_table_u64 * ht , uint64_t key ) { if ( sizeof ( void * ) == 8 ) { <S2SV_StartBug> return _mesa_hash_table_search ( ht -> table , ( void * ) key ) ; <S2SV_EndBug> } else { struct hash_key_u64 _key = { . value = key } ; return _mesa_hash_table_search ( ht -> table , & _key ) ; } } | <S2SV_ModStart> void * ) ( uintptr_t ) |
1,482 | CWE-000 static int bthread_check_if_zombie ( bthread_t bthread , void * * retval ) { volatile __bthread_scheduler_private * scheduler = bthread_get_scheduler ( ) ; __bthread_private * thread = tqueue_get_data ( scheduler -> current_item ) ; if ( thread -> state == __BTHREAD_ZOMBIE ) { <S2SV_StartBug> printf ( "Zombie\\n" ) ; <S2SV_EndBug> if ( retval != NULL ) { thread -> retval = * retval ; free ( thread -> stack ) ; <S2SV_StartBug> tqueue_pop ( & scheduler -> current_item ) ; <S2SV_EndBug> } return 1 ; } else { return 0 ; } } | <S2SV_ModStart> { printf ( "Thread<S2SV_blank>is<S2SV_blank>a<S2SV_blank>zombie<S2SV_blank>and<S2SV_blank>should<S2SV_blank>be<S2SV_blank>reaped\\n" <S2SV_ModEnd> ) ; if <S2SV_ModStart> stack ) ; TQueue q = scheduler -> current_item ; q = scheduler -> current_item ; <S2SV_ModStart> tqueue_pop ( & q <S2SV_ModEnd> ) ; } |
1,483 | CWE-000 static void Cg_DrawRespawn ( const player_state_t * ps ) { r_pixel_t x , y ; if ( ps -> stats [ STAT_HEALTH ] > 0 || ( ps -> stats [ STAT_SPECTATOR ] && ! ps -> stats [ STAT_CHASE ] ) ) { return ; } const char * string ; <S2SV_StartBug> if ( ps -> stats [ STAT_RESPAWN ] ) { <S2SV_EndBug> <S2SV_StartBug> string = va ( "Respawn<S2SV_blank>in<S2SV_blank>^3%0.1f" , ( ps -> stats [ STAT_RESPAWN ] - cgi . client -> time ) / 1000.0 ) ; <S2SV_EndBug> } else { string = va ( "^2Ready<S2SV_blank>to<S2SV_blank>respawn" ) ; } cgi . BindFont ( "small" , NULL , NULL ) ; x = cgi . view -> viewport . x + ( ( cgi . view -> viewport . w - cgi . StringWidth ( string ) ) / 2 ) ; y = cgi . view -> viewport . y + ( cgi . view -> viewport . h * 0.7 ) ; cgi . DrawString ( x , y , string , CON_COLOR_DEFAULT ) ; cgi . BindFont ( NULL , NULL , NULL ) ; } | <S2SV_ModStart> * string ; printf ( "%d\\n" , ps -> stats [ STAT_RESPAWN ] ) ; <S2SV_ModStart> ( "Respawn<S2SV_blank>in<S2SV_blank>^3%0.1f" , MILLIS_TO_SECONDS <S2SV_ModStart> [ STAT_RESPAWN ] ) <S2SV_ModEnd> ) ; } |
1,484 | CWE-000 static bool qdf2400_erratum_44_present ( struct acpi_table_header * h ) { if ( memcmp ( h -> oem_id , "QCOM<S2SV_blank><S2SV_blank>" , ACPI_OEM_ID_SIZE ) ) return false ; if ( ! memcmp ( h -> oem_table_id , "QDF2432<S2SV_blank>" , ACPI_OEM_TABLE_ID_SIZE ) ) return true ; if ( ! memcmp ( h -> oem_table_id , "QDF2400<S2SV_blank>" , ACPI_OEM_TABLE_ID_SIZE ) && <S2SV_StartBug> h -> oem_revision == 0 ) <S2SV_EndBug> return true ; return false ; } | <S2SV_ModStart> -> oem_revision == 1 <S2SV_ModEnd> ) return true |
1,485 | CWE-000 static int logi_dj_recv_query_paired_devices ( struct dj_receiver_dev * djrcv_dev ) { struct dj_report * dj_report ; <S2SV_StartBug> int retval ; <S2SV_EndBug> dj_report = kzalloc ( sizeof ( struct dj_report ) , GFP_KERNEL ) ; if ( ! dj_report ) return - ENOMEM ; dj_report -> report_id = REPORT_ID_DJ_SHORT ; dj_report -> device_index = 0xFF ; dj_report -> report_type = REPORT_TYPE_CMD_GET_PAIRED_DEVICES ; retval = logi_dj_recv_send_report ( djrcv_dev , dj_report ) ; kfree ( dj_report ) ; return retval ; } | <S2SV_ModStart> ; int retval ; if ( djrcv_dev -> querying_devices ) return 0 |
1,486 | CWE-000 duk_ret_t hash_is_set ( duk_context * _ctx ) { const char * key = duk_require_string ( _ctx , 0 ) ; const char * hashkey = duk_to_string ( _ctx , 1 ) ; RedisModuleString * RMS_Key = RedisModule_CreateString ( RM_ctx , key , strlen ( key ) ) ; int exists ; void * key_h = RedisModule_OpenKey ( RM_ctx , RMS_Key , REDISMODULE_READ ) ; <S2SV_StartBug> int ret = RedisModule_HashGet ( key_h , REDISMODULE_HASH_CFIELDS | REDISMODULE_HASH_EXISTS , hashkey , & exists , NULL ) ; <S2SV_EndBug> RedisModule_CloseKey ( key_h ) ; <S2SV_StartBug> duk_pop ( _ctx ) ; <S2SV_EndBug> size_t len ; duk_push_boolean ( _ctx , exists ) ; return 1 ; } | <S2SV_ModStart> REDISMODULE_READ ) ; if ( key_h == NULL ) { exists = 0 ; } else { <S2SV_ModEnd> RedisModule_HashGet ( key_h <S2SV_ModStart> key_h ) ; } <S2SV_ModStart> ( _ctx ) <S2SV_ModEnd> ; duk_push_boolean ( |
1,487 | CWE-000 o2_message_ptr o2_finish_service_message ( o2_time time , const char * service , const char * address ) { int addr_len = ( int ) strlen ( address ) ; int service_len = ( service ? ( int ) strlen ( service ) : 0 ) ; int addr_size = ( service_len + addr_len + 4 ) & ~ 3 ; int types_len = msg_types . length ; int types_size = ( types_len + 4 ) & ~ 3 ; int msg_size = sizeof ( o2_time ) + addr_size + types_size + msg_data . length ; o2_message_ptr msg = o2_alloc_size_message ( msg_size ) ; if ( ! msg ) return NULL ; msg -> next = NULL ; <S2SV_StartBug> msg -> allocated = msg_size ; <S2SV_EndBug> msg -> length = msg_size ; msg -> data . timestamp = time ; char * dst = msg -> data . address ; int32_t * last_32 = ( int32_t * ) ( dst + addr_size - 4 ) ; * last_32 = 0 ; if ( service_len ) { memcpy ( dst , service , service_len ) ; dst += service_len ; } memcpy ( dst , address , addr_len ) ; dst = ( char * ) ( last_32 + 1 ) ; last_32 = ( int32_t * ) ( dst + types_size - 4 ) ; * last_32 = 0 ; memcpy ( dst , msg_types . array , types_len ) ; dst += types_size ; memcpy ( dst , msg_data . array , msg_data . length ) ; return msg ; } | <S2SV_ModStart> ; msg -> <S2SV_ModEnd> length = msg_size |
1,488 | CWE-000 static void init_player ( t_global * g , char * line ) { int coord [ 2 ] ; if ( ! line ) error ( "Error<S2SV_blank>:<S2SV_blank>empty<S2SV_blank>map." ) ; if ( count_word ( line , '<S2SV_blank>' ) != 2 ) error ( "Error<S2SV_blank>:<S2SV_blank>starting<S2SV_blank>position<S2SV_blank>not<S2SV_blank>found<S2SV_blank>or<S2SV_blank>in<S2SV_blank>a<S2SV_blank>wall." ) ; coord [ 0 ] = ft_atoi ( line ) ; coord [ 1 ] = ft_atoi ( ft_strchr ( line , '<S2SV_blank>' ) ) ; g -> player . pos_x = coord [ 0 ] + 0.5 ; g -> player . pos_y = coord [ 1 ] + 0.5 ; g -> player . dir_x = 1 ; g -> player . dir_y = 0 ; g -> player . plane_x = 0 ; g -> player . plane_y = 0.66 ; g -> player . rot = 0.021 ; <S2SV_StartBug> g -> player . speed = 0.05 ; <S2SV_EndBug> } | <S2SV_ModStart> . speed = 0.04 <S2SV_ModEnd> ; } <S2SV_null> |
1,489 | CWE-000 SQLITE_PRIVATE CollSeq * sqlite3ExprCollSeq ( Parse * pParse , Expr * pExpr ) { sqlite3 * db = pParse -> db ; CollSeq * pColl = 0 ; Expr * p = pExpr ; while ( p ) { int op = p -> op ; if ( p -> flags & EP_Generic ) break ; <S2SV_StartBug> if ( op == TK_CAST || op == TK_UPLUS ) { <S2SV_EndBug> p = p -> pLeft ; continue ; } if ( op == TK_COLLATE || ( op == TK_REGISTER && p -> op2 == TK_COLLATE ) ) { pColl = sqlite3GetCollSeq ( pParse , ENC ( db ) , 0 , p -> u . zToken ) ; break ; } if ( ( op == TK_AGG_COLUMN || op == TK_COLUMN || op == TK_REGISTER || op == TK_TRIGGER ) && p -> pTab != 0 ) { int j = p -> iColumn ; if ( j >= 0 ) { const char * zColl = p -> pTab -> aCol [ j ] . zColl ; pColl = sqlite3FindCollSeq ( db , ENC ( db ) , zColl , 0 ) ; } break ; } <S2SV_StartBug> if ( p -> flags & EP_Collate ) { <S2SV_EndBug> if ( p -> pLeft && ( p -> pLeft -> flags & EP_Collate ) != 0 ) { p = p -> pLeft ; } else { Expr * pNext = p -> pRight ; assert ( p -> x . pList == 0 || p -> pRight == 0 ) ; if ( p -> x . pList != 0 && ALWAYS ( ! ExprHasProperty ( p , EP_xIsSelect ) ) ) { int i ; for ( i = 0 ; ALWAYS ( i < p -> x . pList -> nExpr ) ; i ++ ) { if ( ExprHasProperty ( p -> x . pList -> a [ i ] . pExpr , EP_Collate ) ) { pNext = p -> x . pList -> a [ i ] . pExpr ; break ; } } } p = pNext ; } } else { break ; } } if ( sqlite3CheckCollSeq ( pParse , pColl ) ) { pColl = 0 ; } return pColl ; } | <S2SV_ModStart> ) break ; <S2SV_ModEnd> if ( ( <S2SV_ModStart> } if ( op == TK_CAST || op == TK_UPLUS ) { p = p -> pLeft ; continue ; } if ( op == TK_COLLATE || ( op == TK_REGISTER && p -> op2 == TK_COLLATE ) ) { pColl = sqlite3GetCollSeq ( pParse , ENC ( db ) , 0 , p -> u . zToken ) ; break ; } if ( |
1,490 | CWE-000 Status dll_remove_node_tail ( DoublyLinkedList * dll , DoublyLinkedNode * * node ) { if ( dll == NULL ) return DS_ERR_NULL_POINTER ; if ( dll_is_empty ( dll ) ) return DS_ERR_INVALID_OPERATION ; ( * node ) = dll -> tail ; dll -> tail = dll -> tail -> prev ; if ( dll -> tail == NULL ) <S2SV_StartBug> dll -> head == NULL ; <S2SV_EndBug> else dll -> tail -> next = NULL ; ( * node ) -> next = NULL ; ( * node ) -> prev = NULL ; ( dll -> length ) -- ; if ( dll_is_empty ( dll ) ) { dll -> head = NULL ; dll -> tail = NULL ; } return DS_OK ; } | <S2SV_ModStart> dll -> head = <S2SV_ModEnd> NULL ; else |
1,491 | CWE-000 static void perf_hashmap ( unsigned int method , unsigned int rounds ) { struct hashmap map ; char buf [ 16 ] ; struct test_entry * * entries ; unsigned int * hashes ; unsigned int i , j ; <S2SV_StartBug> entries = malloc ( TEST_SIZE * sizeof ( struct test_entry * ) ) ; <S2SV_EndBug> hashes = malloc ( TEST_SIZE * sizeof ( int ) ) ; for ( i = 0 ; i < TEST_SIZE ; i ++ ) { snprintf ( buf , sizeof ( buf ) , "%i" , i ) ; entries [ i ] = alloc_test_entry ( 0 , buf , strlen ( buf ) , "" , 0 ) ; hashes [ i ] = hash ( method , i , entries [ i ] -> key ) ; } if ( method & TEST_ADD ) { for ( j = 0 ; j < rounds ; j ++ ) { hashmap_init ( & map , test_entry_cmp , NULL , 0 ) ; for ( i = 0 ; i < TEST_SIZE ; i ++ ) { hashmap_entry_init ( entries [ i ] , hashes [ i ] ) ; hashmap_add ( & map , entries [ i ] ) ; } hashmap_free ( & map , 0 ) ; } } else { hashmap_init ( & map , test_entry_cmp , NULL , 0 ) ; j = ( method & TEST_SPARSE ) ? TEST_SIZE / 10 : TEST_SIZE ; for ( i = 0 ; i < j ; i ++ ) { hashmap_entry_init ( entries [ i ] , hashes [ i ] ) ; hashmap_add ( & map , entries [ i ] ) ; } for ( j = 0 ; j < rounds ; j ++ ) { for ( i = 0 ; i < TEST_SIZE ; i ++ ) { hashmap_get_from_hash ( & map , hashes [ i ] , entries [ i ] -> key ) ; } } hashmap_free ( & map , 0 ) ; } } | <S2SV_ModStart> , j ; ALLOC_ARRAY ( entries , TEST_SIZE ) ; ALLOC_ARRAY ( hashes , TEST_SIZE <S2SV_ModEnd> ) ; for |
1,492 | CWE-000 static inline int venus_hfi_power_on ( struct venus_hfi_device * device ) { int rc = 0 ; if ( ! device ) { dprintk ( VIDC_ERR , "Invalid<S2SV_blank>params:<S2SV_blank>%p\\n" , device ) ; return - EINVAL ; } if ( device -> res -> ocmem_size ) rc = venus_hfi_scale_buses ( device , DDR_MEM | OCMEM_MEM ) ; else rc = venus_hfi_scale_buses ( device , DDR_MEM ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>scale<S2SV_blank>buses" ) ; goto err_scale_buses ; } rc = regulator_enable ( device -> gdsc ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>GDSC<S2SV_blank>%d" , rc ) ; goto err_enable_gdsc ; } if ( device -> clk_state == DISABLED_UNPREPARED ) rc = venus_hfi_prepare_enable_clks ( device ) ; else if ( device -> clk_state == DISABLED_PREPARED ) rc = venus_hfi_clk_enable ( device ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>clocks" ) ; goto err_enable_clk ; } rc = venus_hfi_iommu_attach ( device ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>attach<S2SV_blank>iommu<S2SV_blank>after<S2SV_blank>power<S2SV_blank>on" ) ; goto err_iommu_attach ; } rc = venus_hfi_tzbsp_set_video_state ( TZBSP_VIDEO_STATE_RESUME ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>resume<S2SV_blank>video<S2SV_blank>core<S2SV_blank>%d\\n" , rc ) ; goto err_set_video_state ; } venus_hfi_set_registers ( device ) ; venus_hfi_write_register ( device , VIDC_UC_REGION_ADDR , ( u32 ) device -> iface_q_table . align_device_addr , 0 ) ; venus_hfi_write_register ( device , VIDC_UC_REGION_SIZE , SHARED_QSIZE , 0 ) ; venus_hfi_write_register ( device , VIDC_CPU_CS_SCIACMDARG2 , ( u32 ) device -> iface_q_table . align_device_addr , device -> iface_q_table . align_virtual_addr ) ; if ( ! IS_ERR_OR_NULL ( device -> sfr . align_device_addr ) ) venus_hfi_write_register ( device , VIDC_SFR_ADDR , ( u32 ) device -> sfr . align_device_addr , 0 ) ; if ( ! IS_ERR_OR_NULL ( device -> qdss . align_device_addr ) ) venus_hfi_write_register ( device , VIDC_MMAP_ADDR , ( u32 ) device -> qdss . align_device_addr , 0 ) ; rc = venus_hfi_reset_core ( device ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>reset<S2SV_blank>venus<S2SV_blank>core" ) ; goto err_reset_core ; } <S2SV_StartBug> WARN_ON ( ! mutex_is_locked ( & device -> write_lock ) ) ; <S2SV_EndBug> rc = __alloc_set_ocmem ( device , false ) ; if ( rc ) { dprintk ( VIDC_ERR , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>OCMEM" ) ; goto err_alloc_ocmem ; } device -> power_enabled = true ; ++ device -> pwr_cnt ; dprintk ( VIDC_INFO , "resuming<S2SV_blank>from<S2SV_blank>power<S2SV_blank>collapse\\n" ) ; return rc ; err_alloc_ocmem : err_reset_core : venus_hfi_tzbsp_set_video_state ( TZBSP_VIDEO_STATE_SUSPEND ) ; err_set_video_state : venus_hfi_iommu_detach ( device ) ; err_iommu_attach : venus_hfi_clk_disable ( device ) ; err_enable_clk : regulator_disable ( device -> gdsc ) ; err_enable_gdsc : if ( device -> res -> ocmem_size ) venus_hfi_unvote_buses ( device , DDR_MEM | OCMEM_MEM ) ; else venus_hfi_unvote_buses ( device , DDR_MEM ) ; err_scale_buses : return rc ; } | <S2SV_ModStart> -> write_lock ) && ( msm_vidc_debug & VIDC_INFO ) |
1,493 | CWE-000 void * map_file ( char * filename , size_t * memSize_ptr ) { void * retVal = NULL ; int fileDesc = 0 ; struct stat fileStat ; int errNum = 0 ; if ( filename && * filename && memSize_ptr ) { <S2SV_StartBug> fileDes = open ( filename , O_RDONLY ) ; <S2SV_EndBug> if ( 0 > fileDesc ) <S2SV_StartBug> { <S2SV_EndBug> HARKLE_ERROR ( ELFleroad , map_file , Unable to open filename ) ; <S2SV_StartBug> } <S2SV_EndBug> else { if ( fstat ( fileDesc , & fileStat ) ) { HARKLE_ERROR ( ELFleroad , map_file , Unable to fstat filename ) ; } else { if ( 0 >= fileStat . st_size ) { HARKLE_ERROR ( ELFleroad , map_file , Invalid file size ) ; } else { * memSize_ptr = fileStat . st_size ; retVal = mmap ( NULL , fileStat . st_size , PROT_READ , MAP_SHARED , fileDesc , 0 ) ; if ( ! retVal || MAP_FAILED == retVal ) { errNum = errno ; retVal = NULL ; HARKLE_ERROR ( ELFleroad , map_file , mmap failed ) ; HARKLE_ERRNO ( ELFleroad , mmap , errNum ) ; } } } } } return retVal ; } | <S2SV_ModStart> memSize_ptr ) { fileDesc <S2SV_ModEnd> = open ( <S2SV_ModStart> fileDesc ) { errNum = errno ; <S2SV_ModStart> filename ) ; HARKLE_ERRNO ( ELFleroad , open , errNum ) ; |
1,494 | CWE-000 bool circBufPop ( volatile CircBuf * cb , uint8_t * value ) { assert ( cb != NULL ) ; assert ( value != NULL ) ; if ( cb -> head == cb -> tail ) return false ; * value = cb -> buffer [ cb -> head ] ; <S2SV_StartBug> if ( cb -> head == 255 ) <S2SV_EndBug> cb -> head = 0 ; else cb -> head ++ ; return true ; } | <S2SV_ModStart> head ] ; cb -> head = circBufIndexNext <S2SV_ModEnd> ( cb -> <S2SV_ModStart> cb -> head ) <S2SV_ModEnd> ; return true |
1,495 | CWE-000 int parse_argv ( int * argc_ptr , char * argv [ ] , FILE * input ) { char ch ; <S2SV_StartBug> if ( argv [ 1 ] [ 0 ] != '-' || * argc_ptr < 3 ) { <S2SV_EndBug> fprintf ( stderr , "ERROR<S2SV_blank>Usage:<S2SV_blank>%s<S2SV_blank>-f<S2SV_blank><logfile><S2SV_blank><substrings>\\n" , argv [ 0 ] ) ; return 1 ; } while ( ( ch = getopt ( * argc_ptr , argv , "f:" ) ) != EOF ) { switch ( ch ) { case 'f' : if ( ! input ) { fprintf ( stderr , "Can\'t<S2SV_blank>open<S2SV_blank>%s.<S2SV_blank>No<S2SV_blank>such<S2SV_blank>file\\n" , optarg ) ; return 1 ; } break ; default : fprintf ( stderr , "Unknown<S2SV_blank>argument!\\n" ) ; return 1 ; } } * argc_ptr -= optind ; return 0 ; } | <S2SV_ModStart> ; if ( * argc_ptr < 3 || <S2SV_ModStart> ] != '-' <S2SV_ModEnd> ) { fprintf |
1,496 | CWE-000 int main ( int argc , char * * argv ) { check_argc ( "Usage:<S2SV_blank>ext2_cp<S2SV_blank><image<S2SV_blank>file<S2SV_blank>name><S2SV_blank><absolute<S2SV_blank>path<S2SV_blank>on<S2SV_blank>ext2<S2SV_blank>disk>\\n" , argc , 3 ) ; read_disk ( argv [ 1 ] ) ; check_path_format ( argv [ 2 ] ) ; char * target_pathname = NULL ; char * target_filename = NULL ; split_last_part_of_path ( argv [ 2 ] , & target_pathname , & target_filename ) ; struct ext2_inode * tpath_inode = get_inode_by_path ( root_inode , target_pathname ) ; struct ext2_inode * find_result = find_file ( tpath_inode , target_filename ) ; if ( find_result == NULL ) { free ( target_pathname ) ; if ( target_filename != NULL ) { free ( target_filename ) ; } fprintf ( stderr , "File<S2SV_blank>not<S2SV_blank>exist\\n" ) ; exit ( ENOENT ) ; } else { if ( find_result -> i_mode & EXT2_S_IFDIR ) { free ( target_filename ) ; free ( target_pathname ) ; fprintf ( stderr , "Target<S2SV_blank>is<S2SV_blank>a<S2SV_blank>directory\\n" ) ; exit ( EISDIR ) ; } } unsigned long target_inode_num = INODE_TO_NUM ( find_result ) ; find_result -> i_links_count -- ; if ( find_result -> i_links_count == 0 ) { for ( unsigned int i = 0 ; i < IBLOCKS ( find_result ) ; i ++ ) { int target_block_num = get_block_from_inode ( find_result , i ) ; set_bit ( 'b' , target_block_num , 0 ) ; } set_bit ( 'i' , target_inode_num , 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> directory_block_iterator ( tpath_inode , remove_dir_entry , 1 , & target_inode_num ) ; free ( target_filename ) ; free ( target_pathname ) ; return 0 ; } | <S2SV_ModStart> 0 ) ; memset ( find_result , 0 , sb -> s_inode_size ) ; |
1,497 | CWE-000 static int rk_gmac_probe ( struct platform_device * pdev ) { struct plat_stmmacenet_data * plat_dat ; struct stmmac_resources stmmac_res ; const struct rk_gmac_ops * data ; int ret ; data = of_device_get_match_data ( & pdev -> dev ) ; if ( ! data ) { dev_err ( & pdev -> dev , "no<S2SV_blank>of<S2SV_blank>match<S2SV_blank>data<S2SV_blank>provided\\n" ) ; return - EINVAL ; } ret = stmmac_get_platform_resources ( pdev , & stmmac_res ) ; if ( ret ) return ret ; plat_dat = stmmac_probe_config_dt ( pdev , & stmmac_res . mac ) ; if ( IS_ERR ( plat_dat ) ) return PTR_ERR ( plat_dat ) ; plat_dat -> has_gmac = true ; plat_dat -> init = rk_gmac_init ; plat_dat -> exit = rk_gmac_exit ; plat_dat -> fix_mac_speed = rk_fix_speed ; plat_dat -> suspend = rk_gmac_suspend ; plat_dat -> resume = rk_gmac_resume ; plat_dat -> bsp_priv = rk_gmac_setup ( pdev , data ) ; if ( IS_ERR ( plat_dat -> bsp_priv ) ) <S2SV_StartBug> return PTR_ERR ( plat_dat -> bsp_priv ) ; <S2SV_EndBug> <S2SV_StartBug> ret = rk_gmac_init ( pdev , plat_dat -> bsp_priv ) ; <S2SV_EndBug> if ( ret ) <S2SV_StartBug> return ret ; <S2SV_EndBug> ret = stmmac_dvr_probe ( & pdev -> dev , plat_dat , & stmmac_res ) ; if ( ret ) goto err_gmac_exit ; return 0 ; err_gmac_exit : rk_gmac_exit ( pdev , plat_dat -> bsp_priv ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> bsp_priv ) ) { ret = <S2SV_ModEnd> PTR_ERR ( plat_dat <S2SV_ModStart> bsp_priv ) ; goto err_remove_config_dt ; } <S2SV_ModStart> ( ret ) goto err_remove_config_dt <S2SV_ModEnd> ; ret = <S2SV_ModStart> bsp_priv ) ; err_remove_config_dt : stmmac_remove_config_dt ( pdev , plat_dat ) ; |
1,498 | CWE-000 void UpdateBatteryStatus ( void ) { if ( BatteryStatus & PiUPSBatteryGood ) { <S2SV_StartBug> if ( voltage_bat < 6000 ) <S2SV_EndBug> { BatteryStatus &= ~ ( ( uint8_t ) PiUPSBatteryGood ) ; BatteryStatus |= ( ( uint8_t ) PiUPSBatteryLow ) ; LEDRedOn ( ) ; } } else { <S2SV_StartBug> if ( voltage_bat > 6500 ) <S2SV_EndBug> { BatteryStatus |= ( ( uint8_t ) PiUPSBatteryGood ) ; BatteryStatus &= ~ ( ( uint8_t ) PiUPSBatteryLow ) ; LEDRedOff ( ) ; } } } | <S2SV_ModStart> ( voltage_bat < read_eeprom_word ( EEPROM_VBATT_LOWDIS ) <S2SV_ModEnd> ) { BatteryStatus <S2SV_ModStart> ( voltage_bat > read_eeprom_word ( EEPROM_VBATT_LOWEN ) <S2SV_ModEnd> ) { BatteryStatus |
1,499 | CWE-000 USER_OBJECT_ S_atk_component_iface_get_extents ( USER_OBJECT_ s_object_class , USER_OBJECT_ s_object , USER_OBJECT_ s_coord_type ) { USER_OBJECT_ _result = NULL_USER_OBJECT ; AtkComponentIface * object_class = ( ( AtkComponentIface * ) getPtrValue ( s_object_class ) ) ; AtkComponent * object = ATK_COMPONENT ( getPtrValue ( s_object ) ) ; AtkCoordType coord_type = ( ( AtkCoordType ) asCEnum ( s_coord_type , ATK_TYPE_COORD_TYPE ) ) ; gint x ; gint y ; gint width ; gint height ; object_class -> get_extents ( object , & x , & y , & width , & height , coord_type ) ; <S2SV_StartBug> _result = retByVal ( _result , "x" , asRInteger ( x ) , "y" , asRInteger ( y ) , "width" , asRInteger ( width ) , "height" , asRInteger ( height ) , NULL ) ; <S2SV_EndBug> ; ; ; ; return ( _result ) ; } | <S2SV_ModStart> = retByVal ( PROTECT ( _result ) <S2SV_ModEnd> , "x" , <S2SV_ModStart> , "x" , PROTECT ( <S2SV_ModStart> ( x ) ) <S2SV_ModStart> , "y" , PROTECT ( <S2SV_ModStart> ( y ) ) <S2SV_ModStart> , "width" , PROTECT ( <S2SV_ModStart> ( width ) ) <S2SV_ModStart> , "height" , PROTECT ( <S2SV_ModStart> ( height ) ) , NULL ) ; UNPROTECT ( 5 <S2SV_ModEnd> ) ; ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.