Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
3,800 | CWE-000 <S2SV_StartBug> static void ui_draw_vision ( UIState * s ) { <S2SV_EndBug> const UIScene * scene = & s -> scene ; int ui_viz_rx = scene -> ui_viz_rx ; int ui_viz_rw = scene -> ui_viz_rw ; int ui_viz_ro = scene -> ui_viz_ro ; glClearColor ( 0.0 , 0.0 , 0.0 , 0.0 ) ; glClear ( GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT ) ; glEnable ( GL_SCISSOR_TEST ) ; glViewport ( ui_viz_rx + ui_viz_ro , s -> fb_h - ( box_y + box_h ) , viz_w , box_h ) ; glScissor ( ui_viz_rx , s -> fb_h - ( box_y + box_h ) , ui_viz_rw , box_h ) ; draw_frame ( s ) ; glViewport ( 0 , 0 , s -> fb_w , s -> fb_h ) ; glDisable ( GL_SCISSOR_TEST ) ; glEnable ( GL_BLEND ) ; glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ; glClear ( GL_STENCIL_BUFFER_BIT ) ; nvgBeginFrame ( s -> vg , s -> fb_w , s -> fb_h , 1.0f ) ; nvgSave ( s -> vg ) ; const int inner_height = viz_w * 9 / 16 ; nvgScissor ( s -> vg , ui_viz_rx , box_y , ui_viz_rw , box_h ) ; nvgTranslate ( s -> vg , ui_viz_rx + ui_viz_ro , box_y + ( box_h - inner_height ) / 2.0 ) ; nvgScale ( s -> vg , ( float ) viz_w / s -> fb_w , ( float ) inner_height / s -> fb_h ) ; if ( ! scene -> frontview && ! scene -> fullview ) { ui_draw_world ( s ) ; } nvgRestore ( s -> vg ) ; ui_draw_vision_header ( s ) ; if ( s -> scene . alert_size != ALERTSIZE_NONE ) { ui_draw_vision_alert ( s , s -> scene . alert_size , s -> status , s -> scene . alert_text1 , s -> scene . alert_text2 ) ; } else if ( scene -> cal_status == CALIBRATION_UNCALIBRATED ) { ui_draw_calibration_status ( s ) ; } else { ui_draw_vision_footer ( s ) ; } nvgEndFrame ( s -> vg ) ; glDisable ( GL_BLEND ) ; } | <S2SV_ModStart> s ) { if ( ! s -> b . shouldDrawFrame ) { s -> b . shouldDrawFrame = true ; } s -> b . shouldDrawFrame = false ; |
3,801 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc < 2 ) return 1 ; parseInput ( argc , argv ) ; if ( mode == 1 ) printf ( "Running<S2SV_blank>sproxy<S2SV_blank>on<S2SV_blank>port<S2SV_blank>%d\\n" , serverPort ) ; cpOpenNetwork ( ) ; if ( mode == 1 ) printf ( "connecting:<S2SV_blank>client\\n" ) ; struct PortableSocket * clientAcceptor = getClientAcceptor ( serverPort ) ; struct PortableSocket * clientProxy = getClient ( clientAcceptor ) ; if ( mode == 1 ) printf ( "connecting:<S2SV_blank>telnet\\n" ) ; struct PortableSocket * telnetSocket = getTelnet ( ) ; fd_set readfds ; int socketN [ ] = { clientProxy -> socket , telnetSocket -> socket } ; int n = getN ( socketN , 2 ) ; struct message messageStruct ; char message [ size ] ; memset ( message , 0 , size ) ; struct timeval tv ; tv . tv_sec = 3 ; while ( cpCheckError ( telnetSocket ) == 0 ) { reset ( & readfds , telnetSocket -> socket , clientProxy -> socket ) ; if ( mode == 1 ) printf ( "Waiting<S2SV_blank>for<S2SV_blank>message<S2SV_blank>\\n" ) ; <S2SV_StartBug> selectValue = select ( n , & readfds , NULL , NULL , NULL ) ; <S2SV_EndBug> if ( FD_ISSET ( telnetSocket -> socket , & readfds ) ) { forward ( telnetSocket , clientProxy , message , "telnet" ) ; } if ( FD_ISSET ( clientProxy -> socket , & readfds ) ) { getMessage ( & messageStruct , clientProxy ) ; if ( messageStruct . type == MESSAGE ) { sendMessage ( telnetSocket , messageStruct . message ) ; <S2SV_StartBug> } else if ( messageStruct . type == HEARTBEAT ) { } <S2SV_EndBug> } } cpClose ( clientAcceptor ) ; cpClose ( clientProxy ) ; cpClose ( telnetSocket ) ; cpCloseNetwork ( ) ; if ( mode == 1 ) printf ( "all<S2SV_blank>sockets<S2SV_blank>closed\\n" ) ; return 0 ; } | <S2SV_ModStart> , NULL , & tv <S2SV_ModEnd> ) ; if <S2SV_ModStart> == HEARTBEAT ) { <S2SV_ModEnd> } } } |
3,802 | CWE-000 static void test_geoip_load_2nd_file ( void * arg ) { ( void ) arg ; <S2SV_StartBug> const char FNAME [ ] = SRCDIR "/src/config/geoip" ; <S2SV_EndBug> <S2SV_StartBug> tt_int_op ( 0 , OP_EQ , geoip_load_file ( AF_INET , FNAME ) ) ; <S2SV_EndBug> const char FNAME2 [ ] = SRCDIR "/src/test/geoip_dummy" ; <S2SV_StartBug> tt_int_op ( 0 , OP_EQ , geoip_load_file ( AF_INET , FNAME2 ) ) ; <S2SV_EndBug> int country = geoip_get_country_by_ipv4 ( 0x08080808 ) ; tt_int_op ( country , OP_EQ , 0 ) ; <S2SV_StartBug> done : ; <S2SV_EndBug> } | <S2SV_ModStart> ) arg ; char * fname_geoip = tor_strdup ( get_fname ( "geoip_data" ) ) ; char * fname_empty = tor_strdup ( get_fname ( "geoip_empty" ) ) ; tt_int_op ( 0 , OP_EQ , write_str_to_file ( fname_geoip , GEOIP_CONTENT , 0 ) ) ; tt_int_op ( 0 , OP_EQ , write_str_to_file ( fname_empty , "\\n" , 0 ) ) <S2SV_ModEnd> ; tt_int_op ( <S2SV_ModStart> ( AF_INET , fname_geoip ) ) <S2SV_ModEnd> ; tt_int_op ( <S2SV_ModStart> ( AF_INET , fname_empty <S2SV_ModEnd> ) ) ; <S2SV_ModStart> ; done : tor_free ( fname_geoip ) ; tor_free ( fname_empty ) |
3,803 | CWE-000 static bool rnd_transmit ( struct team * team , struct sk_buff * skb ) { struct team_port * port ; int port_index ; port_index = random_N ( team -> en_port_count ) ; <S2SV_StartBug> port = team_get_port_by_index_rcu ( team , port_index ) ; <S2SV_EndBug> port = team_get_first_port_txable_rcu ( team , port ) ; if ( unlikely ( ! port ) ) goto drop ; if ( team_dev_queue_xmit ( team , port , skb ) ) return false ; return true ; drop : dev_kfree_skb_any ( skb ) ; return false ; } | <S2SV_ModStart> , port_index ) ; if ( unlikely ( ! port ) ) goto drop |
3,804 | CWE-000 BOOL System_mktime ( CLVALUE * * stack_ptr , CLVALUE * lvar , sVMInfo * info ) { CLVALUE * time = lvar ; sCLObject * object_data = CLOBJECT ( time -> mObjectValue ) ; struct tm tm ; tm . tm_sec = object_data -> mFields [ 0 ] . mIntValue ; tm . tm_min = object_data -> mFields [ 1 ] . mIntValue ; tm . tm_hour = object_data -> mFields [ 2 ] . mIntValue ; tm . tm_mday = object_data -> mFields [ 3 ] . mIntValue ; tm . tm_mon = object_data -> mFields [ 4 ] . mIntValue ; tm . tm_year = object_data -> mFields [ 5 ] . mIntValue ; tm . tm_wday = object_data -> mFields [ 6 ] . mIntValue ; tm . tm_yday = object_data -> mFields [ 7 ] . mIntValue ; tm . tm_isdst = object_data -> mFields [ 8 ] . mBoolValue ; time_t result = mktime ( & tm ) ; if ( result == - 1 ) { <S2SV_StartBug> entry_exception_object_with_class_name ( * stack_ptr , info , "Exception" , "mktime(3)<S2SV_blank>is<S2SV_blank>faield" ) ; <S2SV_EndBug> return FALSE ; } ( * stack_ptr ) -> mULongValue = result ; ( * stack_ptr ) ++ ; return TRUE ; } | <S2SV_ModStart> { entry_exception_object_with_class_name ( stack_ptr , info -> current_stack , info -> current_var_num <S2SV_ModEnd> , info , |
3,805 | CWE-000 static qboolean UI_BotName_HandleKey ( int flags , float * special , int key ) { int select = UI_SelectForKey ( key ) ; if ( select != 0 ) { int game = trap_Cvar_VariableValue ( "g_gametype" ) ; int value = uiInfo . botIndex ; value += select ; if ( game > GT_TOURNAMENT ) { <S2SV_StartBug> if ( value >= uiInfo . characterCount + 2 ) { <S2SV_EndBug> value = 0 ; } else if ( value < 0 ) { <S2SV_StartBug> value = uiInfo . characterCount + 2 - 1 ; <S2SV_EndBug> } } else { <S2SV_StartBug> if ( value >= UI_GetNumBots ( ) + 2 ) { <S2SV_EndBug> value = 0 ; } else if ( value < 0 ) { <S2SV_StartBug> value = UI_GetNumBots ( ) + 2 - 1 ; <S2SV_EndBug> } } uiInfo . botIndex = value ; return qtrue ; } return qfalse ; } | <S2SV_ModStart> uiInfo . characterCount <S2SV_ModEnd> ) { value <S2SV_ModStart> uiInfo . characterCount <S2SV_ModEnd> - 1 ; <S2SV_ModStart> UI_GetNumBots ( ) <S2SV_ModEnd> ) { value <S2SV_ModStart> UI_GetNumBots ( ) <S2SV_ModEnd> - 1 ; |
3,806 | CWE-000 static void hns3_del_tunnel_port ( struct net_device * netdev , u16 port , enum hns3_udp_tnl_type type ) { struct hns3_nic_priv * priv = netdev_priv ( netdev ) ; struct hns3_udp_tunnel * udp_tnl = & priv -> udp_tnl [ type ] ; struct hnae3_handle * h = priv -> ae_handle ; if ( ! udp_tnl -> used || udp_tnl -> dst_port != port ) { netdev_warn ( netdev , "Invalid<S2SV_blank>UDP<S2SV_blank>tunnel<S2SV_blank>port<S2SV_blank>%d\\n" , port ) ; return ; } udp_tnl -> used -- ; if ( udp_tnl -> used ) return ; udp_tnl -> dst_port = 0 ; if ( h -> ae_algo -> ops -> del_tunnel_udp ) <S2SV_StartBug> h -> ae_algo -> ops -> add_tunnel_udp ( h , port ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> ops -> del_tunnel_udp <S2SV_ModEnd> ( h , |
3,807 | CWE-000 void gd_gl_area_scanout_texture ( DisplayChangeListener * dcl , uint32_t backing_id , bool backing_y_0_top , uint32_t backing_width , uint32_t backing_height , uint32_t x , uint32_t y , uint32_t w , uint32_t h ) { VirtualConsole * vc = container_of ( dcl , VirtualConsole , gfx . dcl ) ; vc -> gfx . x = x ; vc -> gfx . y = y ; vc -> gfx . w = w ; vc -> gfx . h = h ; vc -> gfx . y0_top = backing_y_0_top ; gtk_gl_area_make_current ( GTK_GL_AREA ( vc -> gfx . drawing_area ) ) ; <S2SV_StartBug> if ( vc -> gfx . guest_fb . framebuffer == 0 || <S2SV_EndBug> vc -> gfx . w == 0 || vc -> gfx . h == 0 ) { gtk_gl_area_set_scanout_mode ( vc , false ) ; return ; } gtk_gl_area_set_scanout_mode ( vc , true ) ; egl_fb_setup_for_tex ( & vc -> gfx . guest_fb , backing_width , backing_height , backing_id , false ) ; } | <S2SV_ModStart> ; if ( backing_id <S2SV_ModEnd> == 0 || |
3,808 | CWE-000 bool gl_nir_link_uniforms ( struct gl_context * ctx , struct gl_shader_program * prog ) { ralloc_free ( prog -> data -> UniformStorage ) ; prog -> data -> UniformStorage = NULL ; prog -> data -> NumUniformStorage = 0 ; struct nir_link_uniforms_state state = { 0 , } ; for ( unsigned shader_type = 0 ; shader_type < MESA_SHADER_STAGES ; shader_type ++ ) { struct gl_linked_shader * sh = prog -> _LinkedShaders [ shader_type ] ; if ( ! sh ) continue ; nir_shader * nir = sh -> Program -> nir ; assert ( nir ) ; state . num_shader_samplers = 0 ; state . num_shader_images = 0 ; state . num_shader_uniform_components = 0 ; state . shader_samplers_used = 0 ; state . shader_shadow_samplers = 0 ; nir_foreach_variable ( var , & nir -> uniforms ) { struct gl_uniform_storage * uniform = NULL ; uniform = find_previous_uniform_storage ( prog , var -> data . location ) ; if ( uniform ) { uniform -> active_shader_mask |= 1 << shader_type ; var -> data . location = uniform - prog -> data -> UniformStorage ; continue ; } int location = var -> data . location ; var -> data . location = prog -> data -> NumUniformStorage ; state . current_var = var ; const struct glsl_type * type = var -> type ; if ( nir_variable_is_in_block ( var ) && glsl_type_is_array ( type ) ) { type = glsl_without_array ( type ) ; } struct type_tree_entry * type_tree = build_type_tree_for_type ( type ) ; state . current_type = type_tree ; int res = nir_link_uniform ( ctx , prog , sh -> Program , shader_type , type , <S2SV_StartBug> location , & state ) ; <S2SV_EndBug> free_type_tree ( type_tree ) ; if ( res == - 1 ) return false ; } sh -> Program -> SamplersUsed = state . shader_samplers_used ; sh -> shadow_samplers = state . shader_shadow_samplers ; sh -> Program -> info . num_textures = state . num_shader_samplers ; sh -> Program -> info . num_images = state . num_shader_images ; sh -> num_uniform_components = state . num_shader_uniform_components ; sh -> num_combined_uniform_components = sh -> num_uniform_components ; } prog -> data -> NumHiddenUniforms = state . num_hidden_uniforms ; prog -> NumUniformRemapTable = state . max_uniform_location ; prog -> data -> NumUniformDataSlots = state . num_values ; nir_setup_uniform_remap_tables ( ctx , prog ) ; gl_nir_set_uniform_initializers ( ctx , prog ) ; return true ; } | <S2SV_ModStart> , type , NULL , 0 , |
3,809 | CWE-000 seq_t * seq_alloc ( const char * name , size_t len ) { seq_t * seq = malloc ( sizeof ( seq_t ) ) ; if ( name != NULL ) { <S2SV_StartBug> seq -> name = malloc ( strlen ( name ) * sizeof ( char ) ) ; <S2SV_EndBug> strcpy ( seq -> name , name ) ; } else seq -> name = NULL ; seq -> seq = calloc ( len , sizeof ( char ) + 1 ) ; seq -> enc = NULL ; seq -> len = len ; return seq ; } | <S2SV_ModStart> name ) * ( <S2SV_ModStart> sizeof ( char ) + 1 |
3,810 | CWE-000 <S2SV_StartBug> char * * datetime_cli_get_config ( ) <S2SV_EndBug> { if ( NULL != config_list ) { char * cfg = NULL ; int i = 0 ; while ( cfg = config_list [ i ++ ] ) { free ( cfg ) ; } free ( config_list ) ; } config_list = calloc ( 3 , sizeof ( char * ) ) ; config_list [ 0 ] = calloc ( strlen ( datetime_time_format ) + strlen ( "time-format<S2SV_blank>" ) + 1 , sizeof ( char ) ) ; strcat ( config_list [ 0 ] , "time-format<S2SV_blank>" ) ; strcat ( config_list [ 0 ] , datetime_time_format ) ; config_list [ 1 ] = calloc ( strlen ( datetime_date_format ) + strlen ( "date-format<S2SV_blank>" ) + 1 , sizeof ( char ) ) ; strcat ( config_list [ 1 ] , "date-format<S2SV_blank>" ) ; strcat ( config_list [ 1 ] , datetime_date_format ) ; return config_list ; } | <S2SV_ModStart> * datetime_cli_get_config ( vty_t * vty |
3,811 | CWE-000 void _hash_squeezebucket ( Relation rel , Bucket bucket , BlockNumber bucket_blkno , Buffer bucket_buf , BufferAccessStrategy bstrategy ) { BlockNumber wblkno ; BlockNumber rblkno ; Buffer wbuf ; Buffer rbuf ; Page wpage ; Page rpage ; HashPageOpaque wopaque ; HashPageOpaque ropaque ; wblkno = bucket_blkno ; wbuf = bucket_buf ; wpage = BufferGetPage ( wbuf ) ; wopaque = ( HashPageOpaque ) PageGetSpecialPointer ( wpage ) ; if ( ! BlockNumberIsValid ( wopaque -> hasho_nextblkno ) ) { LockBuffer ( wbuf , BUFFER_LOCK_UNLOCK ) ; return ; } rbuf = InvalidBuffer ; ropaque = wopaque ; do { rblkno = ropaque -> hasho_nextblkno ; if ( rbuf != InvalidBuffer ) _hash_relbuf ( rel , rbuf ) ; rbuf = _hash_getbuf_with_strategy ( rel , rblkno , HASH_WRITE , LH_OVERFLOW_PAGE , bstrategy ) ; rpage = BufferGetPage ( rbuf ) ; ropaque = ( HashPageOpaque ) PageGetSpecialPointer ( rpage ) ; Assert ( ropaque -> hasho_bucket == bucket ) ; } while ( BlockNumberIsValid ( ropaque -> hasho_nextblkno ) ) ; for ( ; ; ) { OffsetNumber roffnum ; OffsetNumber maxroffnum ; OffsetNumber deletable [ MaxOffsetNumber ] ; IndexTuple itups [ MaxIndexTuplesPerPage ] ; Size tups_size [ MaxIndexTuplesPerPage ] ; OffsetNumber itup_offsets [ MaxIndexTuplesPerPage ] ; uint16 ndeletable = 0 ; uint16 nitups = 0 ; Size all_tups_size = 0 ; int i ; bool retain_pin = false ; readpage : maxroffnum = PageGetMaxOffsetNumber ( rpage ) ; for ( roffnum = FirstOffsetNumber ; roffnum <= maxroffnum ; roffnum = OffsetNumberNext ( roffnum ) ) { IndexTuple itup ; Size itemsz ; if ( ItemIdIsDead ( PageGetItemId ( rpage , roffnum ) ) ) continue ; itup = ( IndexTuple ) PageGetItem ( rpage , PageGetItemId ( rpage , roffnum ) ) ; itemsz = IndexTupleDSize ( * itup ) ; itemsz = MAXALIGN ( itemsz ) ; while ( PageGetFreeSpaceForMultipleTuples ( wpage , nitups + 1 ) < ( all_tups_size + itemsz ) ) { Buffer next_wbuf = InvalidBuffer ; bool tups_moved = false ; Assert ( ! PageIsEmpty ( wpage ) ) ; if ( wblkno == bucket_blkno ) retain_pin = true ; wblkno = wopaque -> hasho_nextblkno ; Assert ( BlockNumberIsValid ( wblkno ) ) ; if ( wblkno != rblkno ) next_wbuf = _hash_getbuf_with_strategy ( rel , wblkno , HASH_WRITE , LH_OVERFLOW_PAGE , bstrategy ) ; if ( nitups > 0 ) { Assert ( nitups == ndeletable ) ; if ( RelationNeedsWAL ( rel ) ) XLogEnsureRecordSpace ( 0 , 3 + nitups ) ; START_CRIT_SECTION ( ) ; _hash_pgaddmultitup ( rel , wbuf , itups , itup_offsets , nitups ) ; MarkBufferDirty ( wbuf ) ; <S2SV_StartBug> PageIndexMultiDelete ( rpage , deletable , ndeletable ) ; <S2SV_EndBug> MarkBufferDirty ( rbuf ) ; if ( RelationNeedsWAL ( rel ) ) { XLogRecPtr recptr ; xl_hash_move_page_contents xlrec ; xlrec . ntups = nitups ; xlrec . is_prim_bucket_same_wrt = ( wbuf == bucket_buf ) ? true : false ; XLogBeginInsert ( ) ; XLogRegisterData ( ( char * ) & xlrec , SizeOfHashMovePageContents ) ; if ( ! xlrec . is_prim_bucket_same_wrt ) XLogRegisterBuffer ( 0 , bucket_buf , REGBUF_STANDARD | REGBUF_NO_IMAGE ) ; XLogRegisterBuffer ( 1 , wbuf , REGBUF_STANDARD ) ; XLogRegisterBufData ( 1 , ( char * ) itup_offsets , nitups * sizeof ( OffsetNumber ) ) ; for ( i = 0 ; i < nitups ; i ++ ) XLogRegisterBufData ( 1 , ( char * ) itups [ i ] , tups_size [ i ] ) ; XLogRegisterBuffer ( 2 , rbuf , REGBUF_STANDARD ) ; XLogRegisterBufData ( 2 , ( char * ) deletable , ndeletable * sizeof ( OffsetNumber ) ) ; recptr = XLogInsert ( RM_HASH_ID , XLOG_HASH_MOVE_PAGE_CONTENTS ) ; PageSetLSN ( BufferGetPage ( wbuf ) , recptr ) ; PageSetLSN ( BufferGetPage ( rbuf ) , recptr ) ; } END_CRIT_SECTION ( ) ; tups_moved = true ; } if ( retain_pin ) LockBuffer ( wbuf , BUFFER_LOCK_UNLOCK ) ; else _hash_relbuf ( rel , wbuf ) ; if ( rblkno == wblkno ) { _hash_relbuf ( rel , rbuf ) ; return ; } wbuf = next_wbuf ; wpage = BufferGetPage ( wbuf ) ; wopaque = ( HashPageOpaque ) PageGetSpecialPointer ( wpage ) ; Assert ( wopaque -> hasho_bucket == bucket ) ; retain_pin = false ; for ( i = 0 ; i < nitups ; i ++ ) pfree ( itups [ i ] ) ; nitups = 0 ; all_tups_size = 0 ; ndeletable = 0 ; if ( tups_moved ) goto readpage ; } deletable [ ndeletable ++ ] = roffnum ; itups [ nitups ] = CopyIndexTuple ( itup ) ; tups_size [ nitups ++ ] = itemsz ; all_tups_size += itemsz ; } rblkno = ropaque -> hasho_prevblkno ; Assert ( BlockNumberIsValid ( rblkno ) ) ; _hash_freeovflpage ( rel , bucket_buf , rbuf , wbuf , itups , itup_offsets , tups_size , nitups , bstrategy ) ; for ( i = 0 ; i < nitups ; i ++ ) pfree ( itups [ i ] ) ; if ( rblkno == wblkno ) { if ( wblkno == bucket_blkno ) LockBuffer ( wbuf , BUFFER_LOCK_UNLOCK ) ; else _hash_relbuf ( rel , wbuf ) ; return ; } rbuf = _hash_getbuf_with_strategy ( rel , rblkno , HASH_WRITE , LH_OVERFLOW_PAGE , bstrategy ) ; rpage = BufferGetPage ( rbuf ) ; ropaque = ( HashPageOpaque ) PageGetSpecialPointer ( rpage ) ; Assert ( ropaque -> hasho_bucket == bucket ) ; } } | <S2SV_ModStart> deletable , ndeletable , false |
3,812 | CWE-000 void fillNotesBuffer ( unsigned int samples_count , unsigned int channels , unsigned int data_frame_size , struct note * note_buffer , unsigned int h , struct oscillator * * o , size_t data_length , void * prev_data , void * data ) { struct oscillator * oscs = * o ; double pvl = 0 , pvr = 0 , pl , pr , l , r ; unsigned int i , j , frame_data_index = 8 ; unsigned int li = 0 , ri = 1 ; unsigned int index = 0 , note_osc_index = 0 , osc_count = 0 ; double volume_l , volume_r , blue , alpha , palpha ; double inv_full_brightness = 1.0 / 255.0 ; unsigned int note_i = 0 ; unsigned int monophonic [ 1 ] ; memcpy ( & monophonic , & ( ( char * ) data ) [ 4 ] , sizeof ( monophonic ) ) ; if ( data_frame_size == sizeof ( float ) ) { inv_full_brightness = 1. ; frame_data_index = 2 ; data_length /= data_frame_size ; } if ( ( * monophonic ) == 1 ) { li = 3 ; ri = 3 ; } for ( j = 0 ; j < channels ; j += 1 ) { note_osc_index = index ; index += 1 ; osc_count = 0 ; unsigned int y = h - 1 ; for ( i = 0 ; i < data_length ; i += 4 ) { if ( data_frame_size == sizeof ( float ) ) { float * pdata = ( float * ) prev_data ; float * cdata = ( float * ) data ; pl = pdata [ frame_data_index + li ] ; pr = pdata [ frame_data_index + ri ] ; l = cdata [ frame_data_index + li ] ; r = cdata [ frame_data_index + ri ] ; blue = cdata [ frame_data_index + 2 ] ; palpha = pdata [ frame_data_index + 3 ] ; alpha = cdata [ frame_data_index + 3 ] ; } else { unsigned char * pdata = ( unsigned char * ) prev_data ; unsigned char * cdata = ( unsigned char * ) data ; pl = pdata [ frame_data_index + li ] ; pr = pdata [ frame_data_index + ri ] ; l = cdata [ frame_data_index + li ] ; r = cdata [ frame_data_index + ri ] ; blue = cdata [ frame_data_index + 2 ] * inv_full_brightness ; palpha = pdata [ frame_data_index + 3 ] * inv_full_brightness ; alpha = cdata [ frame_data_index + 3 ] * inv_full_brightness ; } frame_data_index += 4 ; struct note * _note = & note_buffer [ index ] ; _note -> osc_index = y ; _note -> noise_multiplier = blue ; _note -> alpha = alpha ; _note -> previous_a = palpha ; _note -> diff_a = abs ( alpha - palpha ) ; <S2SV_StartBug> _note -> smp_index = ( double ) samples_count * blue ; <S2SV_EndBug> if ( l > 0 ) { volume_l = l * inv_full_brightness ; pvl = pl * inv_full_brightness ; _note -> previous_volume_l = pvl ; _note -> volume_l = volume_l ; _note -> diff_volume_l = volume_l - pvl ; } else { if ( pl > 0 ) { pvl = pl * inv_full_brightness ; _note -> previous_volume_l = pvl ; _note -> diff_volume_l = - pvl ; _note -> volume_l = 0 ; } else { _note -> previous_volume_l = 0 ; _note -> diff_volume_l = 0 ; _note -> volume_l = 0 ; if ( r == 0 && pr == 0 ) { y -= 1 ; continue ; } } } if ( r > 0 ) { volume_r = r * inv_full_brightness ; pvr = pr * inv_full_brightness ; _note -> previous_volume_r = pvr ; _note -> volume_r = volume_r ; _note -> diff_volume_r = volume_r - pvr ; } else { if ( pr > 0 ) { pvr = pr * inv_full_brightness ; _note -> previous_volume_r = pvr ; _note -> diff_volume_r = - pvr ; _note -> volume_r = 0 ; } else { _note -> previous_volume_r = 0 ; _note -> diff_volume_r = 0 ; _note -> volume_r = 0 ; if ( l == 0 && pl == 0 ) { y -= 1 ; continue ; } } } index += 1 ; osc_count += 1 ; y -= 1 ; } note_buffer [ note_osc_index ] . osc_index = osc_count ; # ifdef DEBUG if ( ( * monophonic ) == 1 ) { printf ( "Channel<S2SV_blank>l/r<S2SV_blank>(mono)<S2SV_blank>%u<S2SV_blank>:<S2SV_blank>%i<S2SV_blank>oscillators<S2SV_blank>\\n" , ( j + 1 ) , osc_count ) ; } else { printf ( "Channel<S2SV_blank>l/r<S2SV_blank>(stereo)<S2SV_blank>%u<S2SV_blank>:<S2SV_blank>%i<S2SV_blank>oscillators<S2SV_blank>\\n" , ( j + 1 ) , osc_count ) ; } # endif } } | <S2SV_ModStart> -> smp_index = round ( <S2SV_ModStart> samples_count * blue ) |
3,813 | CWE-000 int main ( int argc , char * * argv ) { printf ( "-----------------------------------------------------------------\\n" ) ; printf ( "Student<S2SV_blank>name:<S2SV_blank>Ashish<S2SV_blank>John\\n" ) ; printf ( "Student<S2SV_blank>number:<S2SV_blank>s3624455\\n" ) ; printf ( "Advanced<S2SV_blank>Programming<S2SV_blank>Techniques,<S2SV_blank>Assignment<S2SV_blank>Two,<S2SV_blank>Semester<S2SV_blank>1,<S2SV_blank>2017\\n" ) ; printf ( "-----------------------------------------------------------------<S2SV_blank>\\n" ) ; do { printf ( "Enter<S2SV_blank>your<S2SV_blank>command<S2SV_blank>:<S2SV_blank>" ) ; <S2SV_StartBug> scanf ( "%[^\\n]" , msg ) ; <S2SV_EndBug> while ( msg [ msg_index ] != '\\0' ) { if ( msg [ msg_index ] != '<S2SV_blank>' ) { array_of_string [ string_num ] [ word_size ] = msg [ msg_index ] ; word_size ++ ; } else { array_of_string [ string_num ] [ word_size ] = '\\0' ; string_num ++ ; word_size = 0 ; } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> if ( strcmp ( array_of_string [ 0 ] , COMMAND_LOAD ) ) { <S2SV_EndBug> printf ( "><S2SV_blank>Opening<S2SV_blank>the<S2SV_blank>file<S2SV_blank>%s\\n" , array_of_string [ 1 ] ) ; printf ( "%s\\n" , array_of_string [ 1 ] ) ; a = commandLoad ( array_of_string [ 1 ] ) ; } } while ( array_of_string [ 0 ] != NULL && strcmp ( array_of_string [ 0 ] , COMMAND_QUIT ) ) ; printf ( "><S2SV_blank>Goodbye.<S2SV_blank>\\n\\n" ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ; scanf ( "%[^\\n]<S2SV_blank>" , msg ) ; string_num = 0 ; word_size = 0 ; msg_index = 0 <S2SV_ModEnd> ; while ( <S2SV_ModStart> 0 ; } msg_index ++ ; <S2SV_ModStart> , COMMAND_LOAD ) == 0 |
3,814 | CWE-000 static void FsAddMountsToGlobResult ( Tcl_Obj * resultPtr , Tcl_Obj * pathPtr , const char * pattern , Tcl_GlobTypeData * types ) { int mLength , gLength , i ; int dir = ( types == NULL || ( types -> type & TCL_GLOB_TYPE_DIR ) ) ; Tcl_Obj * mounts = FsListMounts ( pathPtr , pattern ) ; if ( mounts == NULL ) { return ; } if ( Tcl_ListObjLength ( NULL , mounts , & mLength ) != TCL_OK || mLength == 0 ) { goto endOfMounts ; } if ( Tcl_ListObjLength ( NULL , resultPtr , & gLength ) != TCL_OK ) { goto endOfMounts ; } for ( i = 0 ; i < mLength ; i ++ ) { Tcl_Obj * mElt ; int j ; int found = 0 ; Tcl_ListObjIndex ( NULL , mounts , i , & mElt ) ; for ( j = 0 ; j < gLength ; j ++ ) { Tcl_Obj * gElt ; Tcl_ListObjIndex ( NULL , resultPtr , j , & gElt ) ; if ( Tcl_FSEqualPaths ( mElt , gElt ) ) { found = 1 ; if ( ! dir ) { Tcl_ListObjReplace ( NULL , resultPtr , j , 1 , 0 , NULL ) ; gLength -- ; } break ; } } if ( ! found && dir ) { <S2SV_StartBug> int len , mlen ; <S2SV_EndBug> <S2SV_StartBug> const char * path ; <S2SV_EndBug> const char * mount ; <S2SV_StartBug> Tcl_Obj * norm ; <S2SV_EndBug> mount = Tcl_GetStringFromObj ( mElt , & mlen ) ; <S2SV_StartBug> norm = Tcl_FSGetNormalizedPath ( NULL , pathPtr ) ; <S2SV_EndBug> if ( norm != NULL ) { path = Tcl_GetStringFromObj ( norm , & len ) ; if ( path [ len - 1 ] == '/' ) { len -- ; } <S2SV_StartBug> mElt = TclNewFSPathObj ( pathPtr , mount + len + 1 , mlen - len ) ; <S2SV_EndBug> Tcl_ListObjAppendElement ( NULL , resultPtr , mElt ) ; } } } endOfMounts : Tcl_DecrRefCount ( mounts ) ; } | <S2SV_ModStart> dir ) { Tcl_Obj * norm ; <S2SV_ModStart> , mlen ; norm = Tcl_FSGetNormalizedPath ( NULL , pathPtr ) ; if ( norm != NULL ) { <S2SV_ModStart> char * path , <S2SV_ModEnd> * mount ; <S2SV_ModStart> * mount ; <S2SV_ModEnd> mount = Tcl_GetStringFromObj <S2SV_ModStart> mlen ) ; <S2SV_ModEnd> path = Tcl_GetStringFromObj <S2SV_ModStart> -- ; } len ++ ; <S2SV_ModStart> mount + len <S2SV_ModEnd> , mlen - |
3,815 | CWE-000 void hash_map_get ( hash_map_t * map , char * key , char * value ) { pthread_rwlock_rdlock ( & map -> rwlock ) ; int index = get_hash ( key ) % map -> arr_size ; int cnt = 0 ; while ( map -> entries [ index ] . deleted || ( map -> entries [ index ] . key != NULL && strcmp ( map -> entries [ index ] . key , key ) ) != 0 && cnt ++ < map -> arr_size ) { index = ( index + 1 ) % map -> arr_size ; } if ( map -> entries [ index ] . key != NULL && strcmp ( map -> entries [ index ] . key , key ) == 0 ) { strcpy ( value , map -> entries [ index ] . value ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } <S2SV_StartBug> strcpy ( value , "nil" ) ; <S2SV_EndBug> pthread_rwlock_unlock ( & map -> rwlock ) ; } | <S2SV_ModStart> value ) ; } else { <S2SV_ModEnd> strcpy ( value <S2SV_ModStart> "nil" ) ; } |
3,816 | CWE-000 static void gs_feature_tile_class_init ( GsFeatureTileClass * klass ) { GtkWidgetClass * widget_class = GTK_WIDGET_CLASS ( klass ) ; GsAppTileClass * app_tile_class = GS_APP_TILE_CLASS ( klass ) ; widget_class -> destroy = gs_feature_tile_destroy ; app_tile_class -> set_app = gs_feature_tile_set_app ; app_tile_class -> get_app = gs_feature_tile_get_app ; gtk_widget_class_set_template_from_resource ( widget_class , "/org/gnome/Software/gs-feature-tile.ui" ) ; <S2SV_StartBug> gtk_widget_class_bind_template_child ( widget_class , GsFeatureTile , image ) ; <S2SV_EndBug> gtk_widget_class_bind_template_child ( widget_class , GsFeatureTile , stack ) ; gtk_widget_class_bind_template_child ( widget_class , GsFeatureTile , title ) ; gtk_widget_class_bind_template_child ( widget_class , GsFeatureTile , subtitle ) ; } | <S2SV_ModStart> , GsFeatureTile , <S2SV_ModEnd> stack ) ; |
3,817 | CWE-000 static const MPU_REGION * vmpu_fault_find_container_region ( uint32_t fault_addr , const MPU_CONTAINER * container ) { uint32_t count ; const MPU_REGION * region ; count = container -> count ; region = container -> region ; while ( count -- > 0 ) { <S2SV_StartBug> if ( ( fault_addr >= region -> base ) && ( fault_addr < region -> end ) ) { <S2SV_EndBug> return region ; } else { region ++ ; } } return NULL ; } | <S2SV_ModStart> ( fault_addr < ( <S2SV_ModStart> region -> end + ARC_FEATURE_MPU_ALIGNMENT ) |
3,818 | CWE-000 void perf_regions_init ( ) { int i , j , region_id ; int istart_count ; count_init ( ) ; num_perf_counters = count_get_num ( ) ; perf_counter_names = count_get_event_names ( ) ; if ( regions != NULL ) { fprintf ( stderr , "perf_regions_init<S2SV_blank>called<S2SV_blank>twice?" ) ; exit ( - 1 ) ; } regions = malloc ( sizeof ( struct PerfRegion ) * ( PERF_REGIONS_MAX + 3 ) ) ; perf_region_name_init ( ) ; perf_regions_reset ( ) ; for ( i = 0 ; i < 100 ; i ++ ) { perf_region_start ( PERF_REGIONS_OVERHEAD_TIMINGS , PERF_FLAG_TIMINGS ) ; perf_region_stop ( PERF_REGIONS_OVERHEAD_TIMINGS ) ; } for ( i = 0 ; i < 100 ; i ++ ) { perf_region_start ( PERF_REGIONS_OVERHEAD_COUNTERS , PERF_FLAG_COUNTERS ) ; perf_region_stop ( PERF_REGIONS_OVERHEAD_COUNTERS ) ; } for ( i = 0 ; i < 100 ; i ++ ) { perf_region_start ( PERF_REGIONS_OVERHEAD_TIMINGS_COUNTERS , PERF_FLAG_TIMINGS | PERF_FLAG_COUNTERS ) ; perf_region_stop ( PERF_REGIONS_OVERHEAD_TIMINGS_COUNTERS ) ; } for ( region_id = PERF_REGIONS_OVERHEAD_TIMINGS_COUNTERS ; region_id <= PERF_REGIONS_OVERHEAD_TIMINGS ; region_id ++ ) { struct PerfRegion * r = & regions [ region_id ] ; <S2SV_StartBug> r -> wallclock_time /= ( double ) ( r -> region_enter_counter_normalize_denom ) ; <S2SV_EndBug> <S2SV_StartBug> # if PERF_COUNTERS_ACTIVE <S2SV_EndBug> for ( j = 0 ; j < num_perf_counters ; j ++ ) r -> counter_values [ j ] /= ( double ) ( r -> region_enter_counter_normalize_denom ) ; # endif r -> region_enter_counter_normalize_denom = 1.0 ; } # if PERF_TIMINGS_ACTIVE <S2SV_StartBug> gettimeofday ( & tm_ini , NULL ) ; <S2SV_EndBug> # endif <S2SV_StartBug> time ( & init_time ) ; <S2SV_EndBug> num_nested_performance_regions = 0 ; } | <S2SV_ModStart> region_id ] ; # if PERF_TIMINGS_ACTIVE <S2SV_ModStart> ) ; # endif # <S2SV_ModStart> gettimeofday ( & wallclock_init_time <S2SV_ModEnd> , NULL ) <S2SV_ModStart> time ( & wallclock_pretty_init_time <S2SV_ModEnd> ) ; num_nested_performance_regions |
3,819 | CWE-000 gchar * g_log_writer_format_fields ( GLogLevelFlags log_level , const GLogField * fields , gsize n_fields , gboolean use_color ) { gsize i ; const gchar * message = NULL ; const gchar * log_domain = NULL ; gchar level_prefix [ STRING_BUFFER_SIZE ] ; GString * gstring ; gint64 now ; time_t now_secs ; struct tm * now_tm ; gchar time_buf [ 128 ] ; for ( i = 0 ; ( message == NULL || log_domain == NULL ) && i < n_fields ; i ++ ) { const GLogField * field = & fields [ i ] ; if ( g_strcmp0 ( field -> key , "MESSAGE" ) == 0 ) message = field -> value ; else if ( g_strcmp0 ( field -> key , "GLIB_DOMAIN" ) == 0 ) log_domain = field -> value ; } mklevel_prefix ( level_prefix , log_level , use_color ) ; gstring = g_string_new ( NULL ) ; if ( log_level & ALERT_LEVELS ) g_string_append ( gstring , "\\n" ) ; if ( ! log_domain ) g_string_append ( gstring , "**<S2SV_blank>" ) ; if ( ( g_log_msg_prefix & ( log_level & G_LOG_LEVEL_MASK ) ) == ( log_level & G_LOG_LEVEL_MASK ) ) { const gchar * prg_name = g_get_prgname ( ) ; gulong pid = getpid ( ) ; if ( prg_name == NULL ) g_string_append_printf ( gstring , "(process:%lu):<S2SV_blank>" , pid ) ; else g_string_append_printf ( gstring , "(%s:%lu):<S2SV_blank>" , prg_name , pid ) ; } if ( log_domain != NULL ) { g_string_append ( gstring , log_domain ) ; g_string_append_c ( gstring , '-' ) ; } g_string_append ( gstring , level_prefix ) ; g_string_append ( gstring , ":<S2SV_blank>" ) ; now = g_get_real_time ( ) ; <S2SV_StartBug> now_secs = ( time_t ) now / 1000000 ; <S2SV_EndBug> now_tm = localtime ( & now_secs ) ; strftime ( time_buf , sizeof ( time_buf ) , "%H:%M:%S" , now_tm ) ; g_string_append_printf ( gstring , "%s%s.%03d%s:<S2SV_blank>" , use_color ? "\\033[34m" : "" , time_buf , ( gint ) ( ( now / 1000 ) % 1000 ) , color_reset ( use_color ) ) ; if ( message == NULL ) { g_string_append ( gstring , "(NULL)<S2SV_blank>message" ) ; } else { GString * msg ; const gchar * charset ; msg = g_string_new ( message ) ; escape_string ( msg ) ; if ( g_get_charset ( & charset ) ) { g_string_append ( gstring , msg -> str ) ; } else { gchar * lstring = strdup_convert ( msg -> str , charset ) ; g_string_append ( gstring , lstring ) ; g_free ( lstring ) ; } g_string_free ( msg , TRUE ) ; } return g_string_free ( gstring , FALSE ) ; } | <S2SV_ModStart> ( time_t ) ( <S2SV_ModStart> now / 1000000 ) |
3,820 | CWE-000 char * perform_flag_funcs ( int * flags , char * temp , char spec ) { int i ; char * ( * f ) ( char * ) ; for ( i = 0 ; i < 3 ; i ++ ) { if ( flags [ i ] ) { f = get_flag_func ( i , spec ) ; flags [ i ] = 0 ; if ( f ) temp = f ( temp ) ; <S2SV_StartBug> } <S2SV_EndBug> } return ( temp ) ; } | <S2SV_ModStart> temp ) ; if ( ! temp ) return ( NULL ) ; |
3,821 | CWE-000 static void ipa_get_ext_groups_done ( struct tevent_req * subreq ) { struct tevent_req * req = tevent_req_callback_data ( subreq , struct tevent_req ) ; struct get_ad_membership_state * state = tevent_req_data ( req , struct get_ad_membership_state ) ; int ret ; hash_table_t * ext_group_hash ; ret = sdap_search_bases_recv ( subreq , state , & state -> reply_count , & state -> reply ) ; talloc_zfree ( subreq ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_OP_FAILURE , "ipa_get_ext_groups<S2SV_blank>request<S2SV_blank>failed.\\n" ) ; tevent_req_error ( req , ret ) ; return ; } DEBUG ( SSSDBG_TRACE_FUNC , "[%zu]<S2SV_blank>external<S2SV_blank>groups<S2SV_blank>found.\\n" , state -> reply_count ) ; <S2SV_StartBug> ret = process_ext_groups ( state -> server_mode -> ext_groups , <S2SV_EndBug> state -> reply_count , state -> reply , & ext_group_hash ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_OP_FAILURE , "process_ext_groups<S2SV_blank>failed.\\n" ) ; goto fail ; } <S2SV_StartBug> state -> server_mode -> ext_groups -> ext_groups = ext_group_hash ; <S2SV_EndBug> state -> server_mode -> ext_groups -> next_update = time ( NULL ) + 10 ; ret = ipa_add_ext_groups_step ( req ) ; if ( ret == EOK ) { tevent_req_done ( req ) ; return ; } else if ( ret == EAGAIN ) { return ; } else { DEBUG ( SSSDBG_OP_FAILURE , "ipa_add_ext_groups_step<S2SV_blank>failed.\\n" ) ; goto fail ; } fail : tevent_req_error ( req , ret ) ; return ; } | <S2SV_ModStart> process_ext_groups ( state <S2SV_ModEnd> , state -> <S2SV_ModStart> fail ; } talloc_free ( state -> server_mode -> ext_groups -> ext_groups ) ; state -> server_mode -> ext_groups -> ext_groups = talloc_steal ( state -> server_mode -> ext_groups , ext_group_hash ) <S2SV_ModEnd> ; state -> |
3,822 | CWE-000 void init ( void ) { uint32_t ret_pid = fork ( ) ; if ( ret_pid ) { <S2SV_StartBug> while ( 1 ) ; <S2SV_EndBug> } else { my_shell ( ) ; } <S2SV_StartBug> while ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ret_pid ) { int status ; int child_pid ; <S2SV_ModStart> ( 1 ) { child_pid = wait ( & status ) ; printf ( "i<S2SV_blank>am<S2SV_blank>init,<S2SV_blank>my<S2SV_blank>pid<S2SV_blank>is<S2SV_blank>1.<S2SV_blank>i<S2SV_blank>recive<S2SV_blank>a<S2SV_blank>child<S2SV_blank>%d,<S2SV_blank>status<S2SV_blank>is<S2SV_blank>%d" , child_pid , status ) ; } <S2SV_ModEnd> } else { <S2SV_ModStart> ) ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,823 | CWE-000 script static void UpdateMagicUI ( struct player * p , upgrade_t * upgr ) { gui_state_t * g = & UData . gst ; Lith_GUI_Begin ( g , 320 , 240 ) ; Lith_GUI_UpdateState ( g , p ) ; PrintSprite ( s ":UI:MagicSelectBack" , 0 , 1 , 0 , 1 ) ; bool any = false ; for ( int i = 0 ; i < countof ( minf ) ; i ++ ) { struct magic_info const * m = & minf [ i ] ; if ( m -> st != - 1 && ! world . cbiupgr [ m -> st ] ) continue ; char gfx [ 18 ] ; sprintf ( gfx , ":UI:%s" , m -> name ) ; char hot [ 18 ] ; sprintf ( hot , ":UI:%sSel" , m -> name ) ; gui_button_preset_t pre = { . gfx = gfx , . hot = hot , . snd = "player/cbi/buttonpress" , . cdef = "d" , . cact = "r" , . chot = "k" , . cdis = "m" , . font = "cbifont" , . external = true , . w = 64 , . h = 64 } ; <S2SV_StartBug> char name [ 24 ] ; sprintf ( name , LANG "INFO_SHORT_%s" , m -> name ) ; <S2SV_EndBug> if ( Lith_GUI_Button_FId ( g , i + 1 , name , m -> x , m -> y , . preset = & pre ) ) GiveMagic ( m ) ; } Lith_GUI_End ( g , gui_curs_outline ) ; } | <S2SV_ModStart> 24 ] ; LanguageCV <S2SV_ModEnd> ( name , |
3,824 | CWE-000 static bool alnum_rec ( bool producer , struct alnum_chunk_t * ch ) { if ( producer && ch -> pos == 4 ) { <S2SV_StartBug> printf ( "yield(%.8s,%d)\\n" , ch -> key , ch -> pos ) ; <S2SV_EndBug> return producer_yield ( ch , sizeof ( struct alnum_chunk_t ) ) ; } if ( ! producer && ch -> pos == NWZ_KEY_SIZE ) return check_key ( ch -> key , alnum_validate_sig ) ; int p = ch -> pos ++ ; <S2SV_StartBug> for ( int i = '0' ; i <= '9' ; i += 2 ) <S2SV_EndBug> { ch -> key [ p ] = i ; if ( alnum_rec ( producer , ch ) ) return true ; } <S2SV_StartBug> for ( int i = 'a' ; i <= 'z' ; i += 2 ) <S2SV_EndBug> { ch -> key [ p ] = i ; if ( alnum_rec ( producer , ch ) ) return true ; } ch -> pos -- ; return false ; } | <S2SV_ModStart> 4 ) { <S2SV_ModEnd> return producer_yield ( <S2SV_ModStart> pos ++ ; int step = ( p % 2 ) ? 2 : 1 ; <S2SV_ModStart> ; i += step <S2SV_ModEnd> ) { ch <S2SV_ModStart> ; i += step <S2SV_ModEnd> ) { ch |
3,825 | CWE-000 <S2SV_StartBug> inline void PCTxSendByte ( u8 data ) <S2SV_EndBug> { # if COMMS_LOGA == COMMS_LOG_PCTX COMMS_LOGA_WRITE ( data ) ; # endif # if COMMS_LOGB == COMMS_LOG_PCTX COMMS_LOGB_WRITE ( data ) ; # endif DISABLE_USART_INTERRUPTS ( ) ; USART3 -> SR = ~ USART_SR_TC ; USART3 -> DR = ( u16 ) data ; USART3 -> CR1 |= USART_CR1_TCIE ; REENABLE_USART_INTERRUPTS ( ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
3,826 | CWE-000 int main ( ) { int * res ; res = NULL ; int test = 255 ; printf ( "%d\\n" , test >> 1 ) ; <S2SV_StartBug> printf ( "%d\\n" , 63 / 8 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( "%d\\n" , 14 <S2SV_ModEnd> / 8 ) |
3,827 | CWE-000 static void bnxt_tx_timeout ( struct net_device * dev ) { struct bnxt * bp = netdev_priv ( dev ) ; netdev_err ( bp -> dev , "TX<S2SV_blank>timeout<S2SV_blank>detected,<S2SV_blank>starting<S2SV_blank>reset<S2SV_blank>task!\\n" ) ; set_bit ( BNXT_RESET_TASK_SP_EVENT , & bp -> sp_event ) ; <S2SV_StartBug> schedule_work ( & bp -> sp_task ) ; <S2SV_EndBug> } | <S2SV_ModStart> sp_event ) ; bnxt_queue_sp_work ( bp <S2SV_ModEnd> ) ; } |
3,828 | CWE-000 DPS_Status DPS_ResolveAddress ( DPS_Node * node , const char * host , const char * service , DPS_OnResolveAddressComplete cb , void * data ) { DPS_Status ret ; ResolverInfo * resolver ; DPS_DBGTRACE ( ) ; if ( ! node -> loop ) { DPS_ERRPRINT ( "Cannot<S2SV_blank>resolve<S2SV_blank>address<S2SV_blank>-<S2SV_blank>node<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>started\\n" ) ; return DPS_ERR_INVALID ; } if ( ! service || ! cb ) { return DPS_ERR_NULL ; } if ( ! host ) { host = "localhost" ; } resolver = calloc ( 1 , sizeof ( ResolverInfo ) ) ; if ( ! resolver ) { return DPS_ERR_RESOURCES ; } strncpy_s ( resolver -> host , sizeof ( resolver -> host ) , host , sizeof ( resolver -> host ) - 1 ) ; strncpy_s ( resolver -> service , sizeof ( resolver -> service ) , service , sizeof ( resolver -> service ) - 1 ) ; resolver -> node = node ; resolver -> cb = cb ; resolver -> data = data ; DPS_LockNode ( node ) ; if ( uv_async_send ( & node -> resolverAsync ) ) { <S2SV_StartBug> ret = DPS_ERR_FAILURE ; <S2SV_EndBug> } else { resolver -> next = node -> resolverList ; node -> resolverList = resolver ; ret = DPS_OK ; } DPS_UnlockNode ( node ) ; return ret ; } | <S2SV_ModStart> ) ) { free ( resolver ) ; |
3,829 | CWE-000 void SubsystemADC ( ) { if ( ( tempRxMsg . Data [ 1 ] & 0x01 ) == 1 ) { ADCMsg . DLC = 2 ; <S2SV_StartBug> ADCMsg . StdId = 32 ; <S2SV_EndBug> ADCMsg . Data [ 0 ] = AD_VAL & 0xFF ; ADCMsg . Data [ 1 ] = ( AD_VAL >> 8 ) & 0xFF ; CanRouter250k . putMsg ( ADCMsg ) ; CanRouter250k . runTransmitter ( ) ; } } | <S2SV_ModStart> . StdId = CAN_DEMAND_VOL_BACK <S2SV_ModEnd> ; ADCMsg . |
3,830 | CWE-000 static bool find_broken_link ( void * * * parent_ret , void * * child_ret ) { void * next_table [ NUM_TIMER_OBJECTS ] = { } ; void * prev_table [ NUM_TIMER_OBJECTS ] = { } ; * parent_ret = NULL ; * child_ret = NULL ; u32 i = 0 ; for ( void * parent = ( void * ) KTIMER_BASE ; parent < ( void * ) KTIMER_END ; parent += KTIMER_OBJECT_SIZE , i ++ ) { <S2SV_StartBug> void * child = * ( void * * ) parent ; <S2SV_EndBug> if ( TOBJ_ADDR_TO_IDX ( parent ) != i ) { printf ( "[!]<S2SV_blank>Got<S2SV_blank>TOBJ_ADDR_TO_IDX(parent)<S2SV_blank>!=<S2SV_blank>i:<S2SV_blank>0x%lx<S2SV_blank>!=<S2SV_blank>0x%lx\\n" , TOBJ_ADDR_TO_IDX ( parent ) , i ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( IS_VTABLE ( child ) ) { next_table [ TOBJ_ADDR_TO_IDX ( parent ) ] = ( void * ) 1 ; <S2SV_StartBug> prev_table [ TOBJ_ADDR_TO_IDX ( child ) ] = ( void * ) 1 ; <S2SV_EndBug> } else { next_table [ TOBJ_ADDR_TO_IDX ( parent ) ] = child ; prev_table [ TOBJ_ADDR_TO_IDX ( child ) ] = parent ; } } if ( i != NUM_TIMER_OBJECTS ) { printf ( "[!]<S2SV_blank>Unexpected<S2SV_blank>number<S2SV_blank>of<S2SV_blank>iterations<S2SV_blank>over<S2SV_blank>timer<S2SV_blank>object<S2SV_blank>list.\\n" ) ; printf ( "[!]<S2SV_blank>Got<S2SV_blank>%lu,<S2SV_blank>expected<S2SV_blank>%u.\\n" , i , NUM_TIMER_OBJECTS ) ; return false ; } void * head_parent = ( void * ) KTIMER_POOL_HEAD ; void * head_child = ( void * ) kreadint_real ( head_parent ) ; if ( head_child ) { prev_table [ TOBJ_ADDR_TO_IDX ( head_child ) ] = head_parent ; } if ( next_table [ NUM_TIMER_OBJECTS - 1 ] != NULL ) { printf ( "[!]<S2SV_blank>Warning!<S2SV_blank>Bad<S2SV_blank>invariant:<S2SV_blank>last<S2SV_blank>node<S2SV_blank>does<S2SV_blank>not<S2SV_blank>point<S2SV_blank>to<S2SV_blank>NULL\\n" ) ; printf ( "[!]<S2SV_blank>The<S2SV_blank>exploit<S2SV_blank>cannot<S2SV_blank>cleanup<S2SV_blank>sufficiently.\\n" ) ; printf ( "[!]<S2SV_blank>Please<S2SV_blank>reboot<S2SV_blank>your<S2SV_blank>3DS<S2SV_blank>and<S2SV_blank>try<S2SV_blank>again.\\n" ) ; return false ; } for ( i = 0 ; i < NUM_TIMER_OBJECTS ; i ++ ) { if ( i != NUM_TIMER_OBJECTS - 1 && next_table [ i ] == NULL ) { if ( * parent_ret != NULL ) { printf ( "[!]<S2SV_blank>Warning:<S2SV_blank>unexpectedly<S2SV_blank>found<S2SV_blank>more<S2SV_blank>than<S2SV_blank>one<S2SV_blank>NULL<S2SV_blank>next.\\n" ) ; } * parent_ret = ( void * * ) TOBJ_IDX_TO_ADDR ( i ) ; } if ( prev_table [ i ] == NULL ) { if ( * child_ret != NULL ) { printf ( "[!]<S2SV_blank>Warning:<S2SV_blank>unexpectedly<S2SV_blank>found<S2SV_blank>more<S2SV_blank>than<S2SV_blank>one<S2SV_blank>NULL<S2SV_blank>prev.\\n" ) ; } * child_ret = ( void * ) TOBJ_IDX_TO_ADDR ( i ) ; } } if ( * parent_ret == NULL ) { printf ( "[-]<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>parent<S2SV_blank>for<S2SV_blank>broken<S2SV_blank>link<S2SV_blank>search.\\n" ) ; return false ; } for ( i = 0 ; i < NUM_TIMER_OBJECTS ; i ++ ) { } if ( * child_ret == NULL ) { printf ( "[-]<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>child<S2SV_blank>for<S2SV_blank>broken<S2SV_blank>link<S2SV_blank>search.\\n" ) ; return false ; } return true ; } | <S2SV_ModStart> * child = ( void * ) kreadint ( parent ) ; printf ( "parent:<S2SV_blank>%p,<S2SV_blank>child:<S2SV_blank>%p,<S2SV_blank>TOBJ_ADDR_TO_IDX(parent)<S2SV_blank>=<S2SV_blank>0x%lx,<S2SV_blank>TOBJ_ADDR_TO_IDX(child)<S2SV_blank>=<S2SV_blank>0x%lx\\n" , parent , child , TOBJ_ADDR_TO_IDX ( parent ) , TOBJ_ADDR_TO_IDX ( child ) ) <S2SV_ModEnd> ; if ( <S2SV_ModStart> i ) ; wait_for_user ( ) ; } printf ( "obj_addr_to_idx:<S2SV_blank>parent<S2SV_blank>-><S2SV_blank>%ld,<S2SV_blank>child<S2SV_blank>-><S2SV_blank>%ld\\n" , TOBJ_ADDR_TO_IDX ( parent ) , TOBJ_ADDR_TO_IDX ( child ) ) ; <S2SV_ModEnd> if ( IS_VTABLE <S2SV_ModStart> [ TOBJ_ADDR_TO_IDX ( parent <S2SV_ModEnd> ) ] = |
3,831 | CWE-000 static struct vr_flow_entry * vr_find_free_entry ( struct vrouter * router , struct vr_flow * key , uint8_t type , bool need_hold , unsigned int * fe_index ) { <S2SV_StartBug> unsigned int i , index , hash ; <S2SV_EndBug> <S2SV_StartBug> struct vr_flow_entry * tmp_fe , * fe = NULL ; <S2SV_EndBug> * fe_index = 0 ; hash = vr_hash ( key , key -> key_len , 0 ) ; index = ( hash % vr_flow_entries ) & ~ ( VR_FLOW_ENTRIES_PER_BUCKET - 1 ) ; for ( i = 0 ; i < VR_FLOW_ENTRIES_PER_BUCKET ; i ++ ) { tmp_fe = vr_flow_table_entry_get ( router , index ) ; if ( tmp_fe && ! ( tmp_fe -> fe_flags & VR_FLOW_FLAG_ACTIVE ) ) { if ( vr_set_flow_active ( tmp_fe ) ) { vr_init_flow_entry ( tmp_fe ) ; fe = tmp_fe ; break ; } } index ++ ; } if ( ! fe ) { index = hash % vr_oflow_entries ; for ( i = 0 ; i < vr_oflow_entries ; i ++ ) { tmp_fe = vr_oflow_table_entry_get ( router , index ) ; if ( tmp_fe && ! ( tmp_fe -> fe_flags & VR_FLOW_FLAG_ACTIVE ) ) { if ( vr_set_flow_active ( tmp_fe ) ) { vr_init_flow_entry ( tmp_fe ) ; fe = tmp_fe ; break ; } } index = ( index + 1 ) % vr_oflow_entries ; } if ( fe ) <S2SV_StartBug> * fe_index += vr_flow_entries ; <S2SV_EndBug> } if ( fe ) { <S2SV_StartBug> * fe_index += index ; <S2SV_EndBug> if ( need_hold ) { fe -> fe_hold_list = vr_zalloc ( sizeof ( struct vr_flow_queue ) ) ; if ( ! fe -> fe_hold_list ) { <S2SV_StartBug> vr_reset_flow_entry ( router , fe , * fe_index ) ; <S2SV_EndBug> fe = NULL ; } else { <S2SV_StartBug> fe -> fe_hold_list -> vfq_index = * fe_index ; <S2SV_EndBug> } } if ( fe ) { fe -> fe_type = type ; fe -> fe_key . key_len = key -> key_len ; memcpy ( & fe -> fe_key , key , key -> key_len ) ; <S2SV_StartBug> } <S2SV_EndBug> } return fe ; } | <S2SV_ModStart> index , hash , free_index = 0 <S2SV_ModStart> fe = NULL <S2SV_ModEnd> ; hash = <S2SV_ModStart> ( fe ) free_index <S2SV_ModEnd> += vr_flow_entries ; <S2SV_ModStart> fe ) { free_index <S2SV_ModEnd> += index ; <S2SV_ModStart> , fe , free_index <S2SV_ModEnd> ) ; fe <S2SV_ModStart> -> vfq_index = free_index <S2SV_ModEnd> ; } } <S2SV_ModStart> key_len ) ; * fe_index = free_index ; |
3,832 | CWE-000 static long __get_user_pages ( struct task_struct * tsk , struct mm_struct * mm , unsigned long start , unsigned long nr_pages , unsigned int gup_flags , struct page * * pages , struct vm_area_struct * * vmas , int * nonblocking ) { long ret = 0 , i = 0 ; struct vm_area_struct * vma = NULL ; struct follow_page_context ctx = { NULL } ; if ( ! nr_pages ) return 0 ; VM_BUG_ON ( ! ! pages != ! ! ( gup_flags & FOLL_GET ) ) ; if ( ! ( gup_flags & FOLL_FORCE ) ) gup_flags |= FOLL_NUMA ; do { struct page * page ; unsigned int foll_flags = gup_flags ; unsigned int page_increm ; if ( ! vma || start >= vma -> vm_end ) { vma = find_extend_vma ( mm , start ) ; if ( ! vma && in_gate_area ( mm , start ) ) { <S2SV_StartBug> int ret ; <S2SV_EndBug> ret = get_gate_page ( mm , start & PAGE_MASK , gup_flags , & vma , pages ? & pages [ i ] : NULL ) ; if ( ret ) <S2SV_StartBug> return i ? : ret ; <S2SV_EndBug> ctx . page_mask = 0 ; goto next_page ; } if ( ! vma || check_vma_flags ( vma , gup_flags ) ) { ret = - EFAULT ; goto out ; } if ( is_vm_hugetlb_page ( vma ) ) { i = follow_hugetlb_page ( mm , vma , pages , vmas , & start , & nr_pages , i , gup_flags , nonblocking ) ; continue ; } } retry : if ( unlikely ( fatal_signal_pending ( current ) ) ) { ret = - ERESTARTSYS ; goto out ; } cond_resched ( ) ; page = follow_page_mask ( vma , start , foll_flags , & ctx ) ; if ( ! page ) { ret = faultin_page ( tsk , vma , start , & foll_flags , nonblocking ) ; switch ( ret ) { case 0 : goto retry ; case - EBUSY : ret = 0 ; case - EFAULT : case - ENOMEM : case - EHWPOISON : goto out ; case - ENOENT : goto next_page ; } BUG ( ) ; } else if ( PTR_ERR ( page ) == - EEXIST ) { goto next_page ; } else if ( IS_ERR ( page ) ) { ret = PTR_ERR ( page ) ; goto out ; } if ( pages ) { pages [ i ] = page ; flush_anon_page ( vma , page , start ) ; flush_dcache_page ( page ) ; ctx . page_mask = 0 ; } next_page : if ( vmas ) { vmas [ i ] = vma ; ctx . page_mask = 0 ; } page_increm = 1 + ( ~ ( start >> PAGE_SHIFT ) & ctx . page_mask ) ; if ( page_increm > nr_pages ) page_increm = nr_pages ; i += page_increm ; start += page_increm * PAGE_SIZE ; nr_pages -= page_increm ; } while ( nr_pages ) ; out : if ( ctx . pgmap ) put_dev_pagemap ( ctx . pgmap ) ; return i ? i : ret ; } | <S2SV_ModStart> ) ) { <S2SV_ModEnd> ret = get_gate_page <S2SV_ModStart> ( ret ) goto out <S2SV_ModEnd> ; ctx . |
3,833 | CWE-000 static str dumpPointsLineString ( BAT * idBAT , BAT * geomBAT , const GEOSGeometry * geosGeometry , const char * path ) { int pointsNum = 0 ; str err ; int i = 0 ; int check = 0 ; unsigned int lvl = 0 ; wkb * geomWKB = geos2wkb ( geosGeometry ) ; err = wkbNumPoints ( & pointsNum , & geomWKB , & check ) ; GDKfree ( geomWKB ) ; if ( err != MAL_SUCCEED ) return err ; for ( i = 0 ; i < pointsNum && err == MAL_SUCCEED ; i ++ ) { GEOSGeometry * pointGeometry = GEOSGeomGetPointN ( geosGeometry , i ) ; if ( pointGeometry == NULL ) <S2SV_StartBug> throw ( MAL , "geom.DumpPoints" , "SQLSTATE<S2SV_blank>38000<S2SV_blank>!" "Geos<S2SV_blank>operation<S2SV_blank>GEOSGeomGetPointN<S2SV_blank>failed" ) ; <S2SV_EndBug> err = dumpPointsPoint ( idBAT , geomBAT , pointGeometry , & lvl , path ) ; GEOSGeom_destroy ( pointGeometry ) ; } return err ; } | <S2SV_ModStart> , "geom.DumpPoints" , SQLSTATE ( 38000 ) <S2SV_ModEnd> "Geos<S2SV_blank>operation<S2SV_blank>GEOSGeomGetPointN<S2SV_blank>failed" ) ; |
3,834 | CWE-000 int base64_decode_chars ( const char * code_in , const int length_in , char * plaintext_out ) { <S2SV_StartBug> base64_decodestate _state ; <S2SV_EndBug> base64_init_decodestate ( & _state ) ; <S2SV_StartBug> int len = base64_decode_block ( code_in , length_in , plaintext_out , & _state ) ; <S2SV_EndBug> if ( len > 0 ) { plaintext_out [ len ] = 0 ; } return len ; } | <S2SV_ModStart> plaintext_out ) { return base64_decode_chars_signed ( ( int8_t * ) <S2SV_ModEnd> code_in , length_in <S2SV_ModStart> , length_in , ( int8_t * ) plaintext_out ) <S2SV_ModEnd> ; } <S2SV_null> |
3,835 | CWE-000 int spiffs_mount ( const char * path , u32_t phys_addr , u32_t phys_size , u32_t phys_erase_block , u32_t log_block_size , u32_t log_page_size , s32_t ( * spi_rd ) ( struct spiffs_t * , u32_t , u32_t , u8_t * ) , s32_t ( * spi_wr ) ( struct spiffs_t * , u32_t , u32_t , u8_t * ) , s32_t ( * spi_er ) ( struct spiffs_t * , u32_t , u32_t ) ) { spiffs * fs ; spiffs_config c ; u8_t * wbuf ; u8_t * fds ; u8_t * cache ; int ret = - 1 ; # define LOS_SPIFFS_FD_SIZE ( sizeof ( spiffs_fd ) * 8 ) # define LOS_SPIFFS_CACHE_SIZE ( ( ( log_page_size + 32 ) * 4 ) + 40 ) fs = ( spiffs * ) malloc ( sizeof ( spiffs ) ) ; wbuf = ( u8_t * ) malloc ( log_page_size * 2 ) ; fds = ( u8_t * ) malloc ( LOS_SPIFFS_FD_SIZE ) ; cache = ( u8_t * ) malloc ( LOS_SPIFFS_CACHE_SIZE ) ; if ( ( fs == NULL ) || ( wbuf == NULL ) || ( fds == NULL ) || ( cache == NULL ) ) { PRINT_ERR ( "fail<S2SV_blank>to<S2SV_blank>malloc<S2SV_blank>memory<S2SV_blank>in<S2SV_blank>SPIFFS,<S2SV_blank><malloc.c><S2SV_blank>is<S2SV_blank>needed," "make<S2SV_blank>sure<S2SV_blank>it<S2SV_blank>is<S2SV_blank>added\\n" ) ; goto err_free ; } memset ( fs , 0 , sizeof ( spiffs ) ) ; c . hal_read_f = spi_rd ; c . hal_write_f = spi_wr ; c . hal_erase_f = spi_er ; c . log_block_size = log_block_size ; c . log_page_size = log_page_size ; c . phys_addr = phys_addr ; c . phys_erase_block = phys_erase_block ; c . phys_size = phys_size ; c . fh_ix_offset = TEST_SPIFFS_FILEHDL_OFFSET ; ret = SPIFFS_mount ( fs , & c , wbuf , fds , LOS_SPIFFS_FD_SIZE , cache , LOS_SPIFFS_CACHE_SIZE , NULL ) ; if ( ret == SPIFFS_ERR_NOT_A_FS ) { PRINT_INFO ( "formating<S2SV_blank>fs...\\n" ) ; SPIFFS_format ( fs ) ; ret = SPIFFS_mount ( fs , & c , wbuf , fds , LOS_SPIFFS_FD_SIZE , cache , LOS_SPIFFS_CACHE_SIZE , NULL ) ; } if ( ret != SPIFFS_OK ) { PRINT_ERR ( "format<S2SV_blank>fail!\\n" ) ; goto err_unmount ; } ret = los_fs_mount ( "spiffs" , path , fs ) ; if ( ret == LOS_OK ) { PRINT_INFO ( "spiffs<S2SV_blank>mount<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>done!\\n" , path ) ; return LOS_OK ; } PRINT_ERR ( "failed<S2SV_blank>to<S2SV_blank>mount!\\n" ) ; err_unmount : SPIFFS_unmount ( fs ) ; err_free : <S2SV_StartBug> if ( fs == NULL ) <S2SV_EndBug> free ( fs ) ; <S2SV_StartBug> if ( wbuf == NULL ) <S2SV_EndBug> free ( wbuf ) ; <S2SV_StartBug> if ( fds == NULL ) <S2SV_EndBug> free ( fds ) ; <S2SV_StartBug> if ( cache == NULL ) <S2SV_EndBug> free ( cache ) ; return ret ; } | <S2SV_ModStart> if ( fs != <S2SV_ModEnd> NULL ) free <S2SV_ModStart> if ( wbuf != <S2SV_ModEnd> NULL ) free <S2SV_ModStart> if ( fds != <S2SV_ModEnd> NULL ) free <S2SV_ModStart> if ( cache != <S2SV_ModEnd> NULL ) free |
3,836 | CWE-000 int ConfigEnergy ( int m , int mr , int ng , int * kg ) { CONFIG_GROUP * g ; CONFIG * cfg ; int k , i ; if ( m == 0 ) { if ( ng == 0 ) { ng = GetNumGroups ( ) ; for ( k = 0 ; k < ng ; k ++ ) { OptimizeRadial ( 1 , & k , NULL ) ; if ( mr > 0 ) RefineRadial ( mr , 0 ) ; g = GetGroup ( k ) ; for ( i = 0 ; i < g -> n_cfgs ; i ++ ) { cfg = ( CONFIG * ) ArrayGet ( & ( g -> cfg_list ) , i ) ; cfg -> energy = AverageEnergyConfig ( cfg ) ; } ReinitRadial ( 1 ) ; ClearOrbitalTable ( 0 ) ; } } else { OptimizeRadial ( ng , kg , NULL ) ; if ( mr ) RefineRadial ( mr , 0 ) ; for ( k = 0 ; k < ng ; k ++ ) { g = GetGroup ( kg [ k ] ) ; for ( i = 0 ; i < g -> n_cfgs ; i ++ ) { cfg = ( CONFIG * ) ArrayGet ( & ( g -> cfg_list ) , i ) ; if ( cfg -> energy == 0 ) { cfg -> energy = AverageEnergyConfig ( cfg ) ; } } } ReinitRadial ( 1 ) ; ClearOrbitalTable ( 0 ) ; } } else { ng = GetNumGroups ( ) ; for ( k = 0 ; k < ng ; k ++ ) { g = GetGroup ( k ) ; for ( i = 0 ; i < g -> n_cfgs ; i ++ ) { cfg = ( CONFIG * ) ArrayGet ( & ( g -> cfg_list ) , i ) ; if ( cfg -> energy != 0 ) { <S2SV_StartBug> cfg -> delta = cfg -> energy - AverageEnergyConfig ( cfg ) ; <S2SV_EndBug> } } } } return 0 ; } | <S2SV_ModStart> 0 ) { double e = AverageEnergyConfig ( cfg ) ; <S2SV_ModStart> -> energy - e <S2SV_ModEnd> ; } } |
3,837 | CWE-000 <S2SV_StartBug> SDL_bool cmd_terminate ( pid_t pid ) { <S2SV_EndBug> return kill ( pid , SIGTERM ) != - 1 ; } | <S2SV_ModStart> pid ) { if ( pid <= 0 ) { LOGC ( "Requested<S2SV_blank>to<S2SV_blank>kill<S2SV_blank>%d,<S2SV_blank>this<S2SV_blank>is<S2SV_blank>an<S2SV_blank>error.<S2SV_blank>Please<S2SV_blank>report<S2SV_blank>the<S2SV_blank>bug.\\n" , ( int ) pid ) ; abort ( ) ; } |
3,838 | CWE-000 int pqos_l2ca_get ( const unsigned l2id , const unsigned max_num_ca , unsigned * num_ca , struct pqos_l2ca * ca ) { int ret ; if ( num_ca == NULL || ca == NULL || max_num_ca == 0 ) return PQOS_RETVAL_PARAM ; _pqos_api_lock ( ) ; ret = _pqos_check_init ( 1 ) ; if ( ret != PQOS_RETVAL_OK ) { _pqos_api_unlock ( ) ; return ret ; } if ( m_interface == PQOS_INTER_MSR ) ret = hw_l2ca_get ( l2id , max_num_ca , num_ca , ca ) ; <S2SV_StartBug> else <S2SV_EndBug> # ifndef __FreeBSD__ ret = os_l2ca_get ( l2id , max_num_ca , num_ca , ca ) ; # else LOG_INFO ( "OS<S2SV_blank>interface<S2SV_blank>not<S2SV_blank>supported!\\n" ) ; ret = PQOS_RETVAL_RESOURCE ; # endif <S2SV_StartBug> _pqos_api_unlock ( ) ; <S2SV_EndBug> return ret ; } | <S2SV_ModStart> ) ; else { <S2SV_ModStart> ; # endif } |
3,839 | CWE-000 <S2SV_StartBug> void stopButton ( void ) { <S2SV_EndBug> int stopped = 0 ; while ( elev_get_stop_signal ( ) ) { elev_set_motor_direction ( DIRN_STOP ) ; elev_set_stop_lamp ( 1 ) ; clearAll ( ) ; stopped = 1 ; } <S2SV_StartBug> if ( ( currentFloor != - 1 ) && ( stopped ) ) { <S2SV_EndBug> openDoor ( ) ; status = IDLE ; } else if ( stopped ) { status = IDLE ; } elev_set_stop_lamp ( 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> stopButton ( void <S2SV_ModStart> if ( ( elev_get_floor_sensor_signal ( ) <S2SV_ModEnd> != - 1 <S2SV_ModStart> 0 ) ; return stopped ; |
3,840 | CWE-000 double SECTION __ieee754_pow ( double x , double y ) { double z , a , aa , error , t , a1 , a2 , y1 , y2 ; mynumber u , v ; int k ; int4 qx , qy ; v . x = y ; u . x = x ; if ( v . i [ LOW_HALF ] == 0 ) { qx = u . i [ HIGH_HALF ] & 0x7fffffff ; <S2SV_StartBug> if ( ( ( qx == 0x7ff00000 ) && ( u . i [ LOW_HALF ] != 0 ) ) || ( qx > 0x7ff00000 ) ) <S2SV_EndBug> return x ; if ( y == 1.0 ) return x ; if ( y == 2.0 ) return x * x ; if ( y == - 1.0 ) return 1.0 / x ; if ( y == 0 ) return 1.0 ; } if ( ( ( u . i [ HIGH_HALF ] > 0 && u . i [ HIGH_HALF ] < 0x7ff00000 ) || ( u . i [ HIGH_HALF ] == 0 && u . i [ LOW_HALF ] != 0 ) ) && ( v . i [ HIGH_HALF ] & 0x7fffffff ) < 0x4ff00000 ) { double retval ; { SET_RESTORE_ROUND ( FE_TONEAREST ) ; if ( fabs ( y ) < 0x1p-64 ) y = y < 0 ? - 0x1p-64 : 0x1p-64 ; z = log1 ( x , & aa , & error ) ; t = y * CN ; y1 = t - ( t - y ) ; y2 = y - y1 ; t = z * CN ; a1 = t - ( t - z ) ; a2 = ( z - a1 ) + aa ; a = y1 * a1 ; aa = y2 * a1 + y * a2 ; a1 = a + aa ; a2 = ( a - a1 ) + aa ; error = error * fabs ( y ) ; t = __exp1 ( a1 , a2 , 1.9e16 * error ) ; retval = ( t > 0 ) ? t : power1 ( x , y ) ; } if ( isinf ( retval ) ) retval = huge * huge ; else if ( retval == 0 ) retval = tiny * tiny ; else math_check_force_underflow_nonneg ( retval ) ; return retval ; } if ( x == 0 ) { if ( ( ( v . i [ HIGH_HALF ] & 0x7fffffff ) == 0x7ff00000 && v . i [ LOW_HALF ] != 0 ) || ( v . i [ HIGH_HALF ] & 0x7fffffff ) > 0x7ff00000 ) return y ; if ( fabs ( y ) > 1.0e20 ) return ( y > 0 ) ? 0 : 1.0 / 0.0 ; k = checkint ( y ) ; if ( k == - 1 ) return y < 0 ? 1.0 / x : x ; else return y < 0 ? 1.0 / 0.0 : 0.0 ; } qx = u . i [ HIGH_HALF ] & 0x7fffffff ; qy = v . i [ HIGH_HALF ] & 0x7fffffff ; if ( qx >= 0x7ff00000 && ( qx > 0x7ff00000 || u . i [ LOW_HALF ] != 0 ) ) return x ; if ( qy >= 0x7ff00000 && ( qy > 0x7ff00000 || v . i [ LOW_HALF ] != 0 ) ) return x == 1.0 ? 1.0 : y ; if ( u . i [ HIGH_HALF ] < 0 ) { k = checkint ( y ) ; if ( k == 0 ) { if ( qy == 0x7ff00000 ) { if ( x == - 1.0 ) return 1.0 ; else if ( x > - 1.0 ) return v . i [ HIGH_HALF ] < 0 ? INF . x : 0.0 ; else return v . i [ HIGH_HALF ] < 0 ? 0.0 : INF . x ; } else if ( qx == 0x7ff00000 ) return y < 0 ? 0.0 : INF . x ; return ( x - x ) / ( x - x ) ; } else if ( qx == 0x7ff00000 ) { if ( k < 0 ) return y < 0 ? nZERO . x : nINF . x ; else return y < 0 ? 0.0 : INF . x ; } if ( k == 1 ) return __ieee754_pow ( - x , y ) ; else { double retval ; { SET_RESTORE_ROUND ( FE_TONEAREST ) ; retval = - __ieee754_pow ( - x , y ) ; } if ( isinf ( retval ) ) retval = - huge * huge ; else if ( retval == 0 ) retval = - tiny * tiny ; return retval ; } } if ( qx == 0x7ff00000 ) return y > 0 ? x : 0 ; if ( qy > 0x45f00000 && qy < 0x7ff00000 ) { if ( x == 1.0 ) return 1.0 ; if ( y > 0 ) return ( x > 1.0 ) ? huge * huge : tiny * tiny ; if ( y < 0 ) return ( x < 1.0 ) ? huge * huge : tiny * tiny ; } if ( x == 1.0 ) return 1.0 ; if ( y > 0 ) return ( x > 1.0 ) ? INF . x : 0 ; if ( y < 0 ) return ( x < 1.0 ) ? INF . x : 0 ; return 0 ; } | <S2SV_ModStart> ( ( ( ( <S2SV_ModStart> > 0x7ff00000 ) ) && y != 0 |
3,841 | CWE-000 void main ( ) { int s ; printf ( "ENTER<S2SV_blank>THE<S2SV_blank>SIZE<S2SV_blank>OF<S2SV_blank>MATRICES:<S2SV_blank>" ) ; scanf ( "%d" , & s ) ; int i = 0 , j = 0 ; int * * arr ; int * * arr2 = ( int * * ) malloc ( s * sizeof ( int * ) ) ; int * * arr1 = ( int * * ) malloc ( s * sizeof ( int * ) ) ; for ( i = 0 ; i < s ; i ++ ) { arr1 [ i ] = ( int * ) malloc ( s * sizeof ( int ) ) ; arr2 [ i ] = ( int * ) malloc ( s * sizeof ( int ) ) ; } printf ( "ENTER<S2SV_blank>MATRIX-1\\n" ) ; for ( i = 0 ; i < s ; i ++ ) { for ( j = 0 ; j < s ; j ++ ) { scanf ( "%d" , & arr1 [ i ] [ j ] ) ; } } printf ( "ENTER<S2SV_blank>MATRIX-2\\n" ) ; for ( i = 0 ; i < s ; i ++ ) { for ( j = 0 ; j < s ; j ++ ) { scanf ( "%d" , & arr2 [ i ] [ j ] ) ; } } arr = smmr ( arr1 , arr2 , s ) ; printf ( "-----MATRIX-1-------\\n" ) ; for ( i = 0 ; i < s ; i ++ ) { for ( j = 0 ; j < s ; j ++ ) { printf ( "%d\\t" , arr1 [ i ] [ j ] ) ; } printf ( "\\n" ) ; } printf ( "-----MATRIX-2--------\\n" ) ; for ( i = 0 ; i < s ; i ++ ) { for ( j = 0 ; j < s ; j ++ ) { printf ( "%d\\t" , arr2 [ i ] [ j ] ) ; } printf ( "\\n" ) ; } printf ( "----------MATRIX-1<S2SV_blank>X<S2SV_blank>MATRIX-2-------\\n" ) ; for ( i = 0 ; i < s ; i ++ ) { for ( j = 0 ; j < s ; j ++ ) { printf ( "%d\\t" , arr [ i ] [ j ] ) ; } printf ( "\\n" ) ; } free ( arr ) ; free ( arr1 ) ; free ( arr2 ) ; <S2SV_StartBug> getch ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> arr2 ) ; getchar <S2SV_ModEnd> ( ) ; |
3,842 | CWE-000 static int artnet_listener ( char * host , char * port ) { int fd = - 1 , status , yes = 1 , flags ; struct addrinfo hints = { . ai_family = AF_UNSPEC , . ai_socktype = SOCK_DGRAM , . ai_flags = AI_PASSIVE } ; struct addrinfo * info ; struct addrinfo * addr_it ; if ( artnet_fds >= MAX_FDS ) { fprintf ( stderr , "ArtNet<S2SV_blank>backend<S2SV_blank>descriptor<S2SV_blank>limit<S2SV_blank>reached\\n" ) ; return - 1 ; } status = getaddrinfo ( host , port , & hints , & info ) ; if ( status ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>socket<S2SV_blank>info<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s:<S2SV_blank>%s\\n" , host , port , gai_strerror ( status ) ) ; return - 1 ; } for ( addr_it = info ; addr_it != NULL ; addr_it = addr_it -> ai_next ) { fd = socket ( addr_it -> ai_family , addr_it -> ai_socktype , addr_it -> ai_protocol ) ; if ( fd < 0 ) { continue ; } yes = 1 ; if ( setsockopt ( fd , SOL_SOCKET , SO_REUSEADDR , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>SO_REUSEADDR<S2SV_blank>on<S2SV_blank>socket\\n" ) ; } yes = 1 ; if ( setsockopt ( fd , SOL_SOCKET , SO_BROADCAST , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>SO_BROADCAST<S2SV_blank>on<S2SV_blank>socket\\n" ) ; } yes = 0 ; if ( setsockopt ( fd , IPPROTO_IP , IP_MULTICAST_LOOP , ( void * ) & yes , sizeof ( yes ) ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>unset<S2SV_blank>IP_MULTICAST_LOOP<S2SV_blank>option:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } status = bind ( fd , addr_it -> ai_addr , addr_it -> ai_addrlen ) ; if ( status < 0 ) { close ( fd ) ; continue ; } break ; } freeaddrinfo ( info ) ; if ( ! addr_it ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>listening<S2SV_blank>socket<S2SV_blank>for<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s\\n" , host , port ) ; return - 1 ; } flags = fcntl ( fd , F_GETFL , 0 ) ; if ( fcntl ( fd , F_SETFL , flags | O_NONBLOCK ) < 0 ) { fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>ArtNet<S2SV_blank>descriptor<S2SV_blank>nonblocking\\n" ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } artnet_fd = realloc ( artnet_fd , ( artnet_fds + 1 ) * sizeof ( artnet_descriptor ) ) ; if ( ! artnet_fd ) { close ( fd ) ; fprintf ( stderr , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; return - 1 ; } fprintf ( stderr , "ArtNet<S2SV_blank>backend<S2SV_blank>interface<S2SV_blank>%zu<S2SV_blank>bound<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>port<S2SV_blank>%s\\n" , artnet_fds , host , port ) ; artnet_fd [ artnet_fds ] . fd = fd ; artnet_fd [ artnet_fds ] . output_instances = 0 ; artnet_fd [ artnet_fds ] . output_instance = NULL ; artnet_fd [ artnet_fds ] . last_frame = NULL ; artnet_fds ++ ; return 0 ; } | <S2SV_ModStart> "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>ArtNet<S2SV_blank>descriptor<S2SV_blank>nonblocking\\n" ) ; close ( fd ) ; |
3,843 | CWE-000 static bool wcd_is_special_headset ( struct wcd_mbhc * mbhc ) { struct snd_soc_codec * codec = mbhc -> codec ; int delay = 0 , rc ; bool ret = false ; u16 hs_comp_res ; bool is_spl_hs = false ; if ( mbhc -> mbhc_cb -> mbhc_micbias_control && ! mbhc -> mbhc_cb -> mbhc_micb_ctrl_thr_mic ) { pr_debug ( "%s:<S2SV_blank>callback<S2SV_blank>fn<S2SV_blank>micb_ctrl_thr_mic<S2SV_blank>not<S2SV_blank>defined\\n" , __func__ ) ; return false ; } else if ( mbhc -> mbhc_cb -> mbhc_micb_ctrl_thr_mic ) { rc = mbhc -> mbhc_cb -> mbhc_micb_ctrl_thr_mic ( codec , MIC_BIAS_2 , true ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>Micbias<S2SV_blank>control<S2SV_blank>for<S2SV_blank>thr<S2SV_blank>mic<S2SV_blank>failed,<S2SV_blank>rc:<S2SV_blank>%d\\n" , __func__ , rc ) ; return false ; } } wcd_enable_curr_micbias ( mbhc , WCD_MBHC_EN_MB ) ; pr_debug ( "%s:<S2SV_blank>special<S2SV_blank>headset,<S2SV_blank>start<S2SV_blank>register<S2SV_blank>writes\\n" , __func__ ) ; WCD_MBHC_REG_READ ( WCD_MBHC_HS_COMP_RESULT , hs_comp_res ) ; <S2SV_StartBug> while ( hs_comp_res ) { <S2SV_EndBug> if ( mbhc -> hs_detect_work_stop ) { pr_debug ( "%s:<S2SV_blank>stop<S2SV_blank>requested:<S2SV_blank>%d\\n" , __func__ , mbhc -> hs_detect_work_stop ) ; break ; } delay = delay + 50 ; if ( mbhc -> mbhc_cb -> mbhc_common_micb_ctrl ) { mbhc -> mbhc_cb -> mbhc_common_micb_ctrl ( codec , MBHC_COMMON_MICB_PRECHARGE , true ) ; mbhc -> mbhc_cb -> mbhc_common_micb_ctrl ( codec , MBHC_COMMON_MICB_SET_VAL , true ) ; } msleep ( 50 ) ; if ( mbhc -> mbhc_cb -> set_auto_zeroing ) mbhc -> mbhc_cb -> set_auto_zeroing ( codec , true ) ; msleep ( 50 ) ; WCD_MBHC_REG_READ ( WCD_MBHC_HS_COMP_RESULT , hs_comp_res ) ; if ( ! ( hs_comp_res ) ) { pr_debug ( "%s:<S2SV_blank>Special<S2SV_blank>headset<S2SV_blank>detected<S2SV_blank>in<S2SV_blank>%d<S2SV_blank>msecs\\n" , __func__ , ( delay * 2 ) ) ; is_spl_hs = true ; } if ( delay == SPECIAL_HS_DETECT_TIME_MS ) { pr_debug ( "%s:<S2SV_blank>Spl<S2SV_blank>headset<S2SV_blank>didnt<S2SV_blank>get<S2SV_blank>detect<S2SV_blank>in<S2SV_blank>4<S2SV_blank>sec\\n" , __func__ ) ; break ; } } if ( is_spl_hs ) { pr_debug ( "%s:<S2SV_blank>Headset<S2SV_blank>with<S2SV_blank>threshold<S2SV_blank>found\\n" , __func__ ) ; mbhc -> micbias_enable = true ; ret = true ; } if ( mbhc -> mbhc_cb -> mbhc_common_micb_ctrl ) mbhc -> mbhc_cb -> mbhc_common_micb_ctrl ( codec , MBHC_COMMON_MICB_PRECHARGE , false ) ; if ( mbhc -> mbhc_cb -> set_micbias_value ) mbhc -> mbhc_cb -> set_micbias_value ( codec ) ; if ( mbhc -> mbhc_cb -> set_auto_zeroing ) mbhc -> mbhc_cb -> set_auto_zeroing ( codec , false ) ; if ( mbhc -> mbhc_cb -> mbhc_micb_ctrl_thr_mic && ! mbhc -> micbias_enable ) mbhc -> mbhc_cb -> mbhc_micb_ctrl_thr_mic ( codec , MIC_BIAS_2 , false ) ; pr_debug ( "%s:<S2SV_blank>leave,<S2SV_blank>micb_enable:<S2SV_blank>%d\\n" , __func__ , mbhc -> micbias_enable ) ; return ret ; } | <S2SV_ModStart> ; while ( ! is_spl_hs <S2SV_ModEnd> ) { if |
3,844 | CWE-000 int knet_link_get_status ( knet_handle_t knet_h , knet_node_id_t host_id , uint8_t link_id , struct knet_link_status * status , size_t struct_size ) { int savederrno = 0 , err = 0 ; struct knet_host * host ; struct knet_link * link ; if ( ! knet_h ) { errno = EINVAL ; return - 1 ; } if ( link_id >= KNET_MAX_LINK ) { errno = EINVAL ; return - 1 ; } if ( ! status ) { errno = EINVAL ; return - 1 ; } <S2SV_StartBug> savederrno = pthread_rwlock_wrlock ( & knet_h -> global_rwlock ) ; <S2SV_EndBug> if ( savederrno ) { log_err ( knet_h , KNET_SUB_LINK , "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>read<S2SV_blank>lock:<S2SV_blank>%s" , strerror ( savederrno ) ) ; errno = savederrno ; return - 1 ; } host = knet_h -> host_index [ host_id ] ; if ( ! host ) { err = - 1 ; savederrno = EINVAL ; log_err ( knet_h , KNET_SUB_LINK , "Unable<S2SV_blank>to<S2SV_blank>find<S2SV_blank>host<S2SV_blank>%u:<S2SV_blank>%s" , host_id , strerror ( savederrno ) ) ; goto exit_unlock ; } link = & host -> link [ link_id ] ; if ( ! link -> configured ) { err = - 1 ; savederrno = EINVAL ; log_err ( knet_h , KNET_SUB_LINK , "host<S2SV_blank>%u<S2SV_blank>link<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>not<S2SV_blank>configured:<S2SV_blank>%s" , host_id , link_id , strerror ( savederrno ) ) ; goto exit_unlock ; } memmove ( status , & link -> status , struct_size ) ; status -> stats . rx_total_packets = status -> stats . rx_data_packets + status -> stats . rx_ping_packets + status -> stats . rx_pong_packets + status -> stats . rx_pmtu_packets ; status -> stats . tx_total_packets = status -> stats . tx_data_packets + status -> stats . tx_ping_packets + status -> stats . tx_pong_packets + status -> stats . tx_pmtu_packets ; status -> stats . rx_total_bytes = status -> stats . rx_data_bytes + status -> stats . rx_ping_bytes + status -> stats . rx_pong_bytes + status -> stats . rx_pmtu_bytes ; status -> stats . tx_total_bytes = status -> stats . tx_data_bytes + status -> stats . tx_ping_bytes + status -> stats . tx_pong_bytes + status -> stats . tx_pmtu_bytes ; status -> stats . tx_total_errors = status -> stats . tx_data_errors + status -> stats . tx_ping_errors + status -> stats . tx_pong_errors + status -> stats . tx_pmtu_errors ; status -> stats . tx_total_retries = status -> stats . tx_data_retries + status -> stats . tx_ping_retries + status -> stats . tx_pong_retries + status -> stats . tx_pmtu_retries ; status -> size = sizeof ( struct knet_link_status ) ; exit_unlock : pthread_rwlock_unlock ( & knet_h -> global_rwlock ) ; errno = savederrno ; return err ; } | <S2SV_ModStart> } savederrno = get_global_wrlock ( knet_h <S2SV_ModEnd> ) ; if |
3,845 | CWE-000 <S2SV_StartBug> static inline int zephir_maybe_separate_zval ( zval * z ) <S2SV_EndBug> { <S2SV_StartBug> if ( ! Z_REFCOUNTED_P ( z ) || ( Z_REFCOUNT_P ( z ) > 1 && ! Z_ISREF_P ( z ) ) ) { <S2SV_EndBug> if ( ! ( Z_COPYABLE_P ( z ) && ! Z_REFCOUNTED_P ( z ) ) ) { Z_DELREF_P ( z ) ; <S2SV_StartBug> } <S2SV_EndBug> zval_copy_ctor_func ( z ) ; return 1 ; } return 0 ; } | <S2SV_ModStart> zephir_maybe_separate_zval ( zval * <S2SV_ModStart> { if ( Z_REFCOUNT_PP <S2SV_ModEnd> ( z ) <S2SV_ModStart> 1 && ! Z_ISREF_PP <S2SV_ModEnd> ( z ) <S2SV_ModStart> z ) ) { zval * new_zv ; ALLOC_ZVAL ( new_zv ) ; INIT_PZVAL_COPY ( new_zv , * <S2SV_ModEnd> z ) ; <S2SV_ModStart> z ) ; * z = new_zv ; zval_copy_ctor ( new_zv <S2SV_ModEnd> ) ; return |
3,846 | CWE-000 void parse_args ( int argc , char * * argv ) { server -> config_file = malloc ( 256 * sizeof ( char ) ) ; memset ( server -> config_file , 0 , 256 ) ; strncpy ( server -> config_file , "bproxy.json" , 11 ) ; int opt ; while ( ( opt = getopt ( argc , argv , "c:h" ) ) != - 1 ) { switch ( opt ) { case 'c' : if ( 1 != sscanf ( optarg , "%s" , server -> config_file ) ) { usage ( ) ; } break ; case 'h' : usage ( ) ; break ; default : usage ( ) ; } } if ( ! strcmp ( server -> config_file , "" ) ) { usage ( ) ; } else { char * json = read_file ( server -> config_file ) ; parse_config ( json , server -> config ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> config ) ; free ( json ) ; |
3,847 | CWE-000 static noinline int check_item_in_log ( struct btrfs_trans_handle * trans , struct btrfs_root * root , struct btrfs_root * log , struct btrfs_path * path , struct btrfs_path * log_path , struct inode * dir , struct btrfs_key * dir_key ) { struct btrfs_fs_info * fs_info = root -> fs_info ; int ret ; struct extent_buffer * eb ; int slot ; u32 item_size ; struct btrfs_dir_item * di ; struct btrfs_dir_item * log_di ; int name_len ; unsigned long ptr ; unsigned long ptr_end ; char * name ; struct inode * inode ; struct btrfs_key location ; again : eb = path -> nodes [ 0 ] ; slot = path -> slots [ 0 ] ; item_size = btrfs_item_size_nr ( eb , slot ) ; ptr = btrfs_item_ptr_offset ( eb , slot ) ; ptr_end = ptr + item_size ; while ( ptr < ptr_end ) { di = ( struct btrfs_dir_item * ) ptr ; <S2SV_StartBug> if ( verify_dir_item ( fs_info , eb , di ) ) { <S2SV_EndBug> ret = - EIO ; goto out ; } name_len = btrfs_dir_name_len ( eb , di ) ; name = kmalloc ( name_len , GFP_NOFS ) ; if ( ! name ) { ret = - ENOMEM ; goto out ; } read_extent_buffer ( eb , name , ( unsigned long ) ( di + 1 ) , name_len ) ; log_di = NULL ; if ( log && dir_key -> type == BTRFS_DIR_ITEM_KEY ) { log_di = btrfs_lookup_dir_item ( trans , log , log_path , dir_key -> objectid , name , name_len , 0 ) ; } else if ( log && dir_key -> type == BTRFS_DIR_INDEX_KEY ) { log_di = btrfs_lookup_dir_index_item ( trans , log , log_path , dir_key -> objectid , dir_key -> offset , name , name_len , 0 ) ; } if ( ! log_di || ( IS_ERR ( log_di ) && PTR_ERR ( log_di ) == - ENOENT ) ) { btrfs_dir_item_key_to_cpu ( eb , di , & location ) ; btrfs_release_path ( path ) ; btrfs_release_path ( log_path ) ; inode = read_one_inode ( root , location . objectid ) ; if ( ! inode ) { kfree ( name ) ; return - EIO ; } ret = link_to_fixup_dir ( trans , root , path , location . objectid ) ; if ( ret ) { kfree ( name ) ; iput ( inode ) ; goto out ; } inc_nlink ( inode ) ; ret = btrfs_unlink_inode ( trans , root , BTRFS_I ( dir ) , BTRFS_I ( inode ) , name , name_len ) ; if ( ! ret ) ret = btrfs_run_delayed_items ( trans , fs_info ) ; kfree ( name ) ; iput ( inode ) ; if ( ret ) goto out ; ret = btrfs_search_slot ( NULL , root , dir_key , path , 0 , 0 ) ; if ( ret == 0 ) goto again ; ret = 0 ; goto out ; } else if ( IS_ERR ( log_di ) ) { kfree ( name ) ; return PTR_ERR ( log_di ) ; } btrfs_release_path ( log_path ) ; kfree ( name ) ; ptr = ( unsigned long ) ( di + 1 ) ; ptr += name_len ; } ret = 0 ; out : btrfs_release_path ( path ) ; btrfs_release_path ( log_path ) ; return ret ; } | <S2SV_ModStart> , eb , slot , |
3,848 | CWE-000 static int tcf_simp_init ( struct net * net , struct nlattr * nla , struct nlattr * est , struct tc_action * * a , int ovr , int bind , struct netlink_ext_ack * extack ) { struct tc_action_net * tn = net_generic ( net , simp_net_id ) ; struct nlattr * tb [ TCA_DEF_MAX + 1 ] ; struct tc_defact * parm ; struct tcf_defact * d ; bool exists = false ; int ret = 0 , err ; <S2SV_StartBug> char * defdata ; <S2SV_EndBug> if ( nla == NULL ) return - EINVAL ; err = nla_parse_nested ( tb , TCA_DEF_MAX , nla , simple_policy , NULL ) ; if ( err < 0 ) return err ; if ( tb [ TCA_DEF_PARMS ] == NULL ) return - EINVAL ; parm = nla_data ( tb [ TCA_DEF_PARMS ] ) ; exists = tcf_idr_check ( tn , parm -> index , a , bind ) ; if ( exists && bind ) return 0 ; if ( tb [ TCA_DEF_DATA ] == NULL ) { if ( exists ) tcf_idr_release ( * a , bind ) ; return - EINVAL ; } <S2SV_StartBug> defdata = nla_data ( tb [ TCA_DEF_DATA ] ) ; <S2SV_EndBug> if ( ! exists ) { ret = tcf_idr_create ( tn , parm -> index , est , a , & act_simp_ops , bind , false ) ; if ( ret ) return ret ; d = to_defact ( * a ) ; <S2SV_StartBug> ret = alloc_defdata ( d , defdata ) ; <S2SV_EndBug> if ( ret < 0 ) { tcf_idr_release ( * a , bind ) ; return ret ; } d -> tcf_action = parm -> action ; ret = ACT_P_CREATED ; } else { d = to_defact ( * a ) ; tcf_idr_release ( * a , bind ) ; if ( ! ovr ) return - EEXIST ; <S2SV_StartBug> reset_policy ( d , defdata , parm ) ; <S2SV_EndBug> } if ( ret == ACT_P_CREATED ) tcf_idr_insert ( tn , * a ) ; return ret ; } | <S2SV_ModStart> , err ; <S2SV_ModEnd> if ( nla <S2SV_ModStart> EINVAL ; } <S2SV_ModEnd> if ( ! <S2SV_ModStart> ( d , tb [ TCA_DEF_DATA ] <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( d , tb [ TCA_DEF_DATA ] <S2SV_ModEnd> , parm ) |
3,849 | CWE-000 void jacobi_openmp_2D ( int Nx , int Ny , int maxit , double threshold , double * U , double * F , double * Unew ) { if ( ! U || ! F || ! Unew ) { fprintf ( stderr , "Pointer<S2SV_blank>is<S2SV_blank>NULL.\\n" ) ; return ; } int i , j ; int I , J ; I = Ny ; J = Nx ; double hi = 2.0 / ( I - 1.0 ) ; double hj = 2.0 / ( J - 1.0 ) ; double stepi = hi * hi ; double stepj = hj * hj ; bool use_tol = false ; int iter = 0 ; double norm_diff = 10.0 ; if ( strcmp ( "on" , getenv ( "USE_TOLERANCE" ) ) == 0 ) { use_tol = true ; } for ( iter = 0 ; iter < maxit ; iter ++ ) { norm_diff = 0.0 ; # pragma omp parallel for private ( i , j ) reduction ( + : norm_diff ) schedule ( runtime ) for ( i = 1 ; i < I - 1 ; i ++ ) { for ( j = 1 ; j < J - 1 ; j ++ ) { double ui = U [ IND_2D ( i - 1 , j , I , J ) ] + U [ IND_2D ( i + 1 , j , I , J ) ] + 0.5 * stepi * F [ IND_2D ( i , j , I , J ) ] ; double uj = U [ IND_2D ( i , j - 1 , I , J ) ] + U [ IND_2D ( i , j + 1 , I , J ) ] + 0.5 * stepj * F [ IND_2D ( i , j , I , J ) ] ; Unew [ IND_2D ( i , j , I , J ) ] = 0.25 * ( ui + uj ) ; double uij = U [ IND_2D ( i , j , I , J ) ] ; double unewij = Unew [ IND_2D ( i , j , I , J ) ] ; norm_diff += ( uij - unewij ) * ( uij - unewij ) ; } } swap_array ( & U , & Unew ) ; norm_diff = sqrt ( norm_diff ) ; if ( use_tol && ( norm_diff < threshold ) ) break ; } <S2SV_StartBug> MFLOP += 1e-6 * ( ( 4.0 + 2.0 * 4.0 ) + ( 1.0 * 6.0 + 14.0 * Nx * Ny * Nz ) * iter ) ; <S2SV_EndBug> if ( strcmp ( "matrix" , getenv ( "OUTPUT_INFO" ) ) == 0 ) { if ( norm_diff < threshold && use_tol ) fprintf ( stdout , "Exited<S2SV_blank>because<S2SV_blank>norm<S2SV_blank><<S2SV_blank>threshold\\n" ) ; else fprintf ( stdout , "Exited<S2SV_blank>because<S2SV_blank>iter<S2SV_blank>=<S2SV_blank>maxit\\n" ) ; } } | <S2SV_ModStart> Nx * Ny <S2SV_ModEnd> ) * iter |
3,850 | CWE-000 void twi0Init ( void ) <S2SV_StartBug> { <S2SV_EndBug> REG_PMC_PCER0 |= ( 1 << ID_TWI0 ) ; REG_PIOA_PDR |= PIO_PDR_P3 | PIO_PDR_P4 ; twi0Reset ; REG_TWI0_CWGR |= TWI_CWGR_CKDIV ( 2 ) | TWI_CWGR_CLDIV ( 63 ) | TWI_CWGR_CHDIV ( 28 ) ; twi0MasterMode ; } | <S2SV_ModStart> void ) { TWIMUX_RESET_PORT -> PIO_OER |= TWIMUX_RESET_PIN ; TWIMUX_RESET_PORT -> PIO_PUER |= TWIMUX_RESET_PIN ; twiMuxSet ; |
3,851 | CWE-000 void recovery_from_aoflog ( ) <S2SV_StartBug> { <S2SV_EndBug> char logfile [ 4096 ] = { '\\0' } ; <S2SV_StartBug> sprintf ( logfile , "%s/aoq.log" , Serv -> work_dir_path ) ; <S2SV_EndBug> const int LEN = 1024 * 1025 + 100 ; char line [ LEN ] = { '\\0' } ; <S2SV_StartBug> FILE * fp_logfile = fopen ( logfile , "r" ) ; <S2SV_EndBug> if ( fp_logfile != NULL ) { while ( ! feof ( fp_logfile ) ) { if ( fgets ( line , LEN , fp_logfile ) != NULL ) { execute_command_line ( line ) ; } } <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> ( ) { serverlog ( "Recover<S2SV_blank>data<S2SV_blank>from<S2SV_blank>aof<S2SV_blank>log." ) ; <S2SV_ModStart> ( logfile , "%s/%s" <S2SV_ModEnd> , Serv -> <S2SV_ModStart> Serv -> work_dir_path , AOQ_LOG_FILE_NAME <S2SV_ModStart> ( logfile , "rb" <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; } } fclose ( fp_logfile ) ; } serverlog ( "Recover<S2SV_blank>data<S2SV_blank>complate." ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
3,852 | CWE-000 static void vk_tex_destroy ( const struct ra * ra , struct ra_tex * tex ) { if ( ! tex ) return ; struct vk_ctx * vk = ra_vk_get ( ra ) ; struct ra_tex_vk * tex_vk = tex -> priv ; struct ra_vk * p = ra -> priv ; ra_buf_pool_uninit ( ra , & tex_vk -> pbo_write ) ; ra_buf_pool_uninit ( ra , & tex_vk -> pbo_read ) ; vk_signal_destroy ( vk , & tex_vk -> sig ) ; vkDestroyFramebuffer ( vk -> dev , tex_vk -> framebuffer , VK_ALLOC ) ; <S2SV_StartBug> vkDestroyRenderPass ( vk -> dev , tex_vk -> dummyPass , VK_ALLOC ) ; <S2SV_EndBug> vkDestroySampler ( vk -> dev , tex_vk -> sampler , VK_ALLOC ) ; vkDestroyImageView ( vk -> dev , tex_vk -> view , VK_ALLOC ) ; if ( ! tex_vk -> external_img ) { vkDestroyImage ( vk -> dev , tex_vk -> img , VK_ALLOC ) ; vk_free_memslice ( p -> alloc , tex_vk -> mem ) ; } talloc_free ( tex ) ; } | <S2SV_ModStart> VK_ALLOC ) ; <S2SV_ModEnd> vkDestroySampler ( vk |
3,853 | CWE-000 struct __gitpack_index * __gitpack_get_sortedindexes ( unsigned char * val , struct __gitpack * pack , size_t packsize ) { struct __gitpack_index * ret = ( struct __gitpack_index * ) malloc ( sizeof ( * ret ) * pack -> count ) ; <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> for ( i = 0 ; i < pack -> count ; i ++ ) { struct __gitpack_index index = { i , __GITPACK_NTH_OFF ( val , pack -> count , i ) , 0 , NULL } ; ret [ i ] = index ; ret [ i ] . sign = __sign_dup ( __GITPACK_NTH_SIGN ( val , i ) ) ; } __gitpack_quicksort_indexes ( val , pack , ret , 0 , pack -> count - 1 ) ; ret [ pack -> count - 1 ] . len = packsize - 20 - ret [ pack -> count - 1 ] . off ; for ( i = 0 ; i < pack -> count - 1 ; i ++ ) { ret [ i ] . len = ret [ i + 1 ] . off - ret [ i ] . off ; } return ret ; } | <S2SV_ModStart> count ) ; if ( ret == NULL ) { DBG_LOG ( DBG_ERROR , "__gitpack_get_sortedindexes:<S2SV_blank>have<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>free<S2SV_blank>memory" ) ; return NULL ; } |
3,854 | CWE-000 static int find_dev_dax ( struct ndctl_ctx * ndctl_ctx , struct daxio_device * dev ) { struct ndctl_bus * bus ; struct ndctl_region * region ; struct ndctl_dax * dax ; struct daxctl_region * dax_region ; ndctl_bus_foreach ( ndctl_ctx , bus ) { ndctl_region_foreach ( bus , region ) { ndctl_dax_foreach ( region , dax ) { dax_region = ndctl_dax_get_daxctl_region ( dax ) ; if ( match_dev_dax ( dev , dax_region ) ) { <S2SV_StartBug> dev -> dax = dax ; <S2SV_EndBug> dev -> align = ndctl_dax_get_align ( dax ) ; dev -> region = region ; return 1 ; } } } } struct daxctl_ctx * daxctl_ctx ; if ( daxctl_new ( & daxctl_ctx ) ) return 0 ; int ret = 0 ; daxctl_region_foreach ( daxctl_ctx , dax_region ) { if ( match_dev_dax ( dev , dax_region ) ) { <S2SV_StartBug> dev -> dax = dax ; <S2SV_EndBug> dev -> align = ndctl_dax_get_align ( dax ) ; dev -> region = region ; ret = 1 ; goto end ; } } end : daxctl_unref ( daxctl_ctx ) ; return ret ; } | <S2SV_ModStart> { dev -> is_devdax = 1 <S2SV_ModEnd> ; dev -> <S2SV_ModStart> { dev -> is_devdax = 1 <S2SV_ModEnd> ; dev -> |
3,855 | CWE-000 <S2SV_StartBug> static ui effof01 ( ui n , ui shift ) { <S2SV_EndBug> n >>= shift ; ui a , b ; a = n & 0x44 ; b = n & 0x22 ; n -= a + b ; n += ( a >> 1 ) + ( b << 1 ) ; return n << shift ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static inline |
3,856 | CWE-000 spScaleTimeline * spScaleTimeline_create ( int framesCount ) { <S2SV_StartBug> return _spBaseTimeline_create ( framesCount , SP_TIMELINE_SCALE , TRANSLATE_ENTRIES , _spScaleTimeline_apply ) ; <S2SV_EndBug> } | <S2SV_ModStart> TRANSLATE_ENTRIES , _spScaleTimeline_apply , _spScaleTimeline_getPropertyId |
3,857 | CWE-000 static int set_config ( struct usb_composite_dev * cdev , const struct usb_ctrlrequest * ctrl , unsigned number ) { struct usb_gadget * gadget = cdev -> gadget ; struct usb_configuration * c = NULL ; int result = - EINVAL ; unsigned power = gadget_is_otg ( gadget ) ? 8 : 100 ; int tmp ; if ( cdev -> config && ( cdev -> config -> bConfigurationValue == number ) ) { DBG ( cdev , "already<S2SV_blank>in<S2SV_blank>the<S2SV_blank>same<S2SV_blank>config<S2SV_blank>with<S2SV_blank>value<S2SV_blank>%d\\n" , number ) ; return 0 ; } if ( number ) { list_for_each_entry ( c , & cdev -> configs , list ) { # ifdef CONFIG_USB_ANDROID_SAMSUNG_COMPOSITE if ( c -> bConfigurationValue == number || check_config ( number ) ) { # else if ( c -> bConfigurationValue == number ) { # endif if ( cdev -> config ) reset_config ( cdev ) ; result = 0 ; break ; } } if ( result < 0 ) goto done ; } else { if ( cdev -> config ) reset_config ( cdev ) ; result = 0 ; } INFO ( cdev , "%s<S2SV_blank>config<S2SV_blank>#%d:<S2SV_blank>%s\\n" , usb_speed_string ( gadget -> speed ) , number , c ? c -> label : "unconfigured" ) ; if ( ! c ) goto done ; cdev -> config = c ; for ( tmp = 0 ; tmp < MAX_CONFIG_INTERFACES ; tmp ++ ) { struct usb_function * f = c -> interface [ tmp ] ; struct usb_descriptor_header * * descriptors ; if ( ! f ) break ; switch ( gadget -> speed ) { case USB_SPEED_SUPER : { struct power_supply * psy = power_supply_get_by_name ( PSY_CHG_NAME ) ; union power_supply_propval value ; int main_type = POWER_SUPPLY_TYPE_USB_DCP ; if ( ! f -> ss_descriptors ) { pr_err ( "%s():<S2SV_blank>No<S2SV_blank>SS<S2SV_blank>desc<S2SV_blank>for<S2SV_blank>function:%s\\n" , __func__ , f -> name ) ; return - EINVAL ; } descriptors = f -> ss_descriptors ; if ( ! psy ) { pr_err ( "%s:<S2SV_blank>fail<S2SV_blank>to<S2SV_blank>get<S2SV_blank>%s<S2SV_blank>psy\\n" , __func__ , PSY_CHG_NAME ) ; break ; } value . intval = main_type ; psy -> set_property ( psy , POWER_SUPPLY_PROP_ONLINE , & value ) ; break ; } case USB_SPEED_HIGH : descriptors = f -> hs_descriptors ; break ; default : <S2SV_StartBug> descriptors = f -> descriptors ; <S2SV_EndBug> } for ( ; * descriptors ; ++ descriptors ) { struct usb_endpoint_descriptor * ep ; int addr ; if ( ( * descriptors ) -> bDescriptorType != USB_DT_ENDPOINT ) continue ; ep = ( struct usb_endpoint_descriptor * ) * descriptors ; addr = ( ( ep -> bEndpointAddress & 0x80 ) >> 3 ) | ( ep -> bEndpointAddress & 0x0f ) ; set_bit ( addr , f -> endpoints ) ; } result = f -> set_alt ( f , tmp , 0 ) ; if ( result < 0 ) { DBG ( cdev , "interface<S2SV_blank>%d<S2SV_blank>(%s/%p)<S2SV_blank>alt<S2SV_blank>0<S2SV_blank>--><S2SV_blank>%d\\n" , tmp , f -> name , f , result ) ; reset_config ( cdev ) ; goto done ; } if ( result == USB_GADGET_DELAYED_STATUS ) { DBG ( cdev , "%s:<S2SV_blank>interface<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>requested<S2SV_blank>delayed<S2SV_blank>status\\n" , __func__ , tmp , f -> name ) ; cdev -> delayed_status ++ ; DBG ( cdev , "delayed_status<S2SV_blank>count<S2SV_blank>%d\\n" , cdev -> delayed_status ) ; } } power = c -> bMaxPower ? ( cdev -> vbus_draw_units * c -> bMaxPower ) : CONFIG_USB_GADGET_VBUS_DRAW ; done : usb_gadget_vbus_draw ( gadget , power ) ; if ( result >= 0 && cdev -> delayed_status ) result = USB_GADGET_DELAYED_STATUS ; return result ; } | <S2SV_ModStart> = f -> fs_descriptors <S2SV_ModEnd> ; } for |
3,858 | CWE-000 static gpointer ostree_fetcher_session_thread ( gpointer data ) { ThreadClosure * closure = data ; g_autoptr ( GMainContext ) mainctx = g_main_context_ref ( closure -> main_context ) ; gint max_conns ; g_main_context_push_thread_default ( mainctx ) ; closure -> session = soup_session_async_new_with_options ( SOUP_SESSION_USER_AGENT , "ostree<S2SV_blank>" , SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE , TRUE , SOUP_SESSION_USE_THREAD_CONTEXT , TRUE , SOUP_SESSION_ADD_FEATURE_BY_TYPE , SOUP_TYPE_REQUESTER , SOUP_SESSION_TIMEOUT , 60 , SOUP_SESSION_IDLE_TIMEOUT , 60 , NULL ) ; <S2SV_StartBug> g_object_get ( closure -> session , "max-conns-per-host" , & max_conns , NULL ) ; <S2SV_EndBug> if ( max_conns < 8 ) { max_conns = 8 ; g_object_set ( closure -> session , "max-conns-per-host" , max_conns , NULL ) ; } closure -> max_outstanding = 3 * max_conns ; while ( g_atomic_int_get ( & closure -> running ) ) g_main_context_iteration ( closure -> main_context , TRUE ) ; g_clear_pointer ( & closure -> outstanding , g_hash_table_unref ) ; while ( ! g_queue_is_empty ( & closure -> pending_queue ) ) g_object_unref ( g_queue_pop_head ( & closure -> pending_queue ) ) ; g_clear_pointer ( & closure -> session , g_object_unref ) ; thread_closure_unref ( closure ) ; g_main_context_pop_thread_default ( mainctx ) ; return NULL ; } | <S2SV_ModStart> NULL ) ; if ( closure -> transfer_gzip ) soup_session_add_feature_by_type ( closure -> session , SOUP_TYPE_CONTENT_DECODER ) ; |
3,859 | CWE-000 static _PyInitError cmdline_init_env_warnoptions ( _PyMain * pymain , _PyCoreConfig * config , _PyCmdline * cmdline ) { <S2SV_StartBug> if ( config -> ignore_environment ) { <S2SV_EndBug> return _Py_INIT_OK ( ) ; } wchar_t * env ; int res = config_get_env_var_dup ( config , & env , L"PYTHONWARNINGS" , "PYTHONWARNINGS" ) ; if ( res < 0 ) { return DECODE_LOCALE_ERR ( "PYTHONWARNINGS" , res ) ; } if ( env == NULL ) { return _Py_INIT_OK ( ) ; } wchar_t * warning , * context = NULL ; for ( warning = WCSTOK ( env , L"," , & context ) ; warning != NULL ; warning = WCSTOK ( NULL , L"," , & context ) ) { _PyInitError err = _Py_wstrlist_append ( & cmdline -> nenv_warnoption , & cmdline -> env_warnoptions , warning ) ; if ( _Py_INIT_FAILED ( err ) ) { PyMem_RawFree ( env ) ; return err ; } } PyMem_RawFree ( env ) ; return _Py_INIT_OK ( ) ; } | <S2SV_ModStart> cmdline ) { assert ( ! <S2SV_ModEnd> config -> ignore_environment <S2SV_ModStart> -> ignore_environment ) ; <S2SV_ModEnd> wchar_t * env |
3,860 | CWE-000 Test ( insert_tests , insertTest ) { listS * starter = init ( ) ; <S2SV_StartBug> int ins_val = 4 ; <S2SV_EndBug> int test_i = insert ( starter , ins_val ) ; cr_expect ( test_i == 0 , "Funkcja<S2SV_blank>insert<S2SV_blank>nie<S2SV_blank>działa<S2SV_blank>prawidłowo" ) ; cr_expect ( starter -> head -> dane == ins_val , "Funkcja<S2SV_blank>insert<S2SV_blank>nie<S2SV_blank>przypisuje<S2SV_blank>odpowiedniej<S2SV_blank>wartości<S2SV_blank>dla<S2SV_blank>pierwszego<S2SV_blank>nodea" ) ; insert ( starter , 3 * ins_val ) ; cr_expect ( starter -> head -> next -> dane == ( 3 * ins_val ) , "Funkcja<S2SV_blank>insert<S2SV_blank>nie<S2SV_blank>przypisuje<S2SV_blank>odpowiedniej<S2SV_blank>wartości<S2SV_blank>dla<S2SV_blank>drugiego<S2SV_blank>nodea<S2SV_blank>nodea" ) ; clear ( starter ) ; } | <S2SV_ModStart> ( ) ; const |
3,861 | CWE-000 char * * parseBuffer ( char * buffer ) { <S2SV_StartBug> char * * tokens = tokenize ( buffer , "<S2SV_blank>" ) ; <S2SV_EndBug> return ( tokens ) ; } | <S2SV_ModStart> ) { char delim [ ] = "<S2SV_blank>" ; char <S2SV_ModStart> ( buffer , delim <S2SV_ModEnd> ) ; return |
3,862 | CWE-000 static int __hpf ( struct proc * p , uintptr_t va , int prot , bool file_ok ) { struct vm_region * vmr ; struct page * a_page ; unsigned int f_idx ; int ret = 0 ; bool first = TRUE ; va = ROUNDDOWN ( va , PGSIZE ) ; refault : spin_lock ( & p -> vmr_lock ) ; vmr = find_vmr ( p , va ) ; if ( ! vmr ) { printd ( "fault:<S2SV_blank>%p<S2SV_blank>not<S2SV_blank>mapped\\n" , va ) ; ret = - EFAULT ; goto out ; } if ( ! ( vmr -> vm_prot & prot ) ) { ret = - EPERM ; goto out ; } if ( ! vmr -> vm_file ) { if ( upage_alloc ( p , & a_page , TRUE ) ) { ret = - ENOMEM ; goto out ; } } else { if ( ! file_ok ) { ret = - EACCES ; goto out ; } if ( ! check_file_perms ( vmr , vmr -> vm_file , prot ) ) printk ( "[kernel]<S2SV_blank>possible<S2SV_blank>issue<S2SV_blank>with<S2SV_blank>VMR<S2SV_blank>prots<S2SV_blank>on<S2SV_blank>file<S2SV_blank>%s!\\n" , file_name ( vmr -> vm_file ) ) ; assert ( ! PGOFF ( va - vmr -> vm_base + vmr -> vm_foff ) ) ; f_idx = ( va - vmr -> vm_base + vmr -> vm_foff ) >> PGSHIFT ; if ( f_idx + 1 > nr_pages ( vmr -> vm_file -> f_dentry -> d_inode -> i_size ) ) { ret = - ESPIPE ; goto out ; } ret = pm_load_page_nowait ( vmr -> vm_file -> f_mapping , f_idx , & a_page ) ; if ( ret ) { if ( ret != - EAGAIN ) goto out ; kref_get ( & vmr -> vm_file -> f_kref , 1 ) ; spin_unlock ( & p -> vmr_lock ) ; ret = __hpf_load_page ( p , vmr -> vm_file -> f_mapping , f_idx , & a_page , first ) ; first = FALSE ; kref_put ( & vmr -> vm_file -> f_kref ) ; if ( ret ) return ret ; goto refault ; } if ( ( vmr -> vm_flags & MAP_PRIVATE ) ) { ret = __copy_and_swap_pmpg ( p , & a_page ) ; if ( ret ) goto out_put_pg ; } if ( vmr -> vm_prot & PROT_EXEC ) icache_flush_page ( ( void * ) va , page2kva ( a_page ) ) ; } int pte_prot = ( vmr -> vm_prot & PROT_WRITE ) ? PTE_USER_RW : ( vmr -> vm_prot & ( PROT_READ | PROT_EXEC ) ) ? PTE_USER_RO : 0 ; <S2SV_StartBug> ret = map_page_at_addr ( p , a_page , va , pte_prot , page_is_pagemap ( a_page ) ) ; <S2SV_EndBug> out_put_pg : if ( page_is_pagemap ( a_page ) ) pm_put_page ( a_page ) ; out : spin_unlock ( & p -> vmr_lock ) ; return ret ; } | <S2SV_ModStart> va , pte_prot <S2SV_ModEnd> ) ; out_put_pg |
3,863 | CWE-000 void * backgroundRemoval ( void * input ) { dataLayerThread_t * thread = ( dataLayerThread_t * ) input ; node_t * sentinel = thread -> sentinel ; while ( thread -> finished == 0 ) { usleep ( thread -> sleep_time ) ; node_t * previous = sentinel ; node_t * current = sentinel -> next ; while ( current -> next != NULL ) { <S2SV_StartBug> if ( current -> fresh ) { <S2SV_EndBug> current -> fresh = 0 ; if ( current -> markedToDelete ) { dispatchSignal ( current -> val , current , REMOVAL ) ; } else { dispatchSignal ( current -> val , current , INSERTION ) ; } } else if ( current -> markedToDelete && current -> references == 0 ) { int valid = 0 ; <S2SV_StartBug> pthread_mutex_lock ( & previous -> lock ) ; <S2SV_EndBug> <S2SV_StartBug> pthread_mutex_lock ( & current -> lock ) ; <S2SV_EndBug> if ( ( valid = validateLink ( previous , current ) ) != 0 ) { previous -> next = current -> next ; } pthread_mutex_unlock ( & previous -> lock ) ; pthread_mutex_unlock ( & current -> lock ) ; if ( valid ) { current = current -> next ; continue ; } } previous = current ; current = current -> next ; } } return NULL ; } | <S2SV_ModStart> NULL ) { fprintf ( stderr , "Value:<S2SV_blank>%d<S2SV_blank>Fresh:<S2SV_blank>%d<S2SV_blank>References<S2SV_blank>%d<S2SV_blank>markedToDelete<S2SV_blank>%d\\n" , current -> val , current -> fresh , current -> references , current -> markedToDelete ) ; <S2SV_ModStart> = 0 ; fprintf ( stderr , "Trying<S2SV_blank>to<S2SV_blank>get<S2SV_blank>previous\\n" ) ; <S2SV_ModStart> lock ) ; fprintf ( stderr , "Trying<S2SV_blank>to<S2SV_blank>get<S2SV_blank>Current\\n" ) ; <S2SV_ModStart> current -> lock ) ; fprintf ( stderr , "I<S2SV_blank>have<S2SV_blank>both\\n" |
3,864 | CWE-000 static void fifo_reset ( struct fifo * fifo ) { <S2SV_StartBug> fifo -> rindex = 0 ; <S2SV_EndBug> <S2SV_StartBug> fifo -> windex = 0 ; <S2SV_EndBug> <S2SV_StartBug> fifo -> num = 0 ; <S2SV_EndBug> } | <S2SV_ModStart> -> rindex = 0U <S2SV_ModEnd> ; fifo -> <S2SV_ModStart> -> windex = 0U <S2SV_ModEnd> ; fifo -> <S2SV_ModStart> -> num = 0U <S2SV_ModEnd> ; } <S2SV_null> |
3,865 | CWE-000 void init_blocks ( ) { <S2SV_StartBug> void * req = sbrk ( MAX_SIZE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( req == ( void * ) - 1 ) { <S2SV_EndBug> write ( 2 , "init<S2SV_blank>fail\\n" , 10 ) ; return ; } <S2SV_StartBug> write ( 2 , "init\\n" , 5 ) ; <S2SV_EndBug> list_t * block = sbrk ( 0 ) ; start = block ; block -> size = N ; block -> free = 1 ; block -> pred = NULL ; block -> succ = NULL ; free_list [ N - 1 ] = block ; } | <S2SV_ModStart> ( ) { list_t * block <S2SV_ModEnd> = sbrk ( <S2SV_ModStart> ; if ( block <S2SV_ModEnd> == ( void <S2SV_ModStart> return ; } <S2SV_ModEnd> start = block |
3,866 | CWE-000 void fty_metric_snmp_server_actor_main_loop ( fty_metric_snmp_server_t * self , zsock_t * pipe ) { if ( ! self || ! pipe ) return ; fty_metric_snmp_server_update_poller ( self , pipe ) ; zsock_signal ( pipe , 0 ) ; while ( ! zsys_interrupted ) { zsock_t * which = ( zsock_t * ) zpoller_wait ( self -> poller , - 1 ) ; if ( which == pipe ) { zmsg_t * msg = zmsg_recv ( pipe ) ; if ( msg ) { char * cmd = zmsg_popstr ( msg ) ; zsys_debug ( "pipe<S2SV_blank>command<S2SV_blank>%s" , cmd ) ; if ( cmd ) { if ( streq ( cmd , "$TERM" ) ) { zstr_free ( & cmd ) ; zmsg_destroy ( & msg ) ; break ; } else if ( streq ( cmd , "BIND" ) ) { char * endpoint = zmsg_popstr ( msg ) ; char * myname = zmsg_popstr ( msg ) ; assert ( endpoint && myname ) ; mlm_client_connect ( self -> mlm , endpoint , 5000 , myname ) ; zstr_free ( & endpoint ) ; zstr_free ( & myname ) ; } else if ( streq ( cmd , "PRODUCER" ) ) { char * stream = zmsg_popstr ( msg ) ; assert ( stream ) ; mlm_client_set_producer ( self -> mlm , stream ) ; zstr_free ( & stream ) ; } else if ( streq ( cmd , "CONSUMER" ) ) { char * stream = zmsg_popstr ( msg ) ; char * pattern = zmsg_popstr ( msg ) ; assert ( stream && pattern ) ; mlm_client_set_consumer ( self -> mlm , stream , pattern ) ; zstr_free ( & stream ) ; zstr_free ( & pattern ) ; } else if ( streq ( cmd , "LOADRULES" ) ) { char * path = zmsg_popstr ( msg ) ; assert ( path ) ; fty_metric_snmp_server_load_rules ( self , path ) ; zstr_free ( & path ) ; } else if ( streq ( cmd , "RULE" ) ) { char * json = zmsg_popstr ( msg ) ; assert ( json ) ; fty_metric_snmp_server_add_rule ( self , json ) ; zstr_free ( & json ) ; } else if ( streq ( cmd , "WAKEUP" ) ) { zsys_debug ( "WAKEUP" ) ; zactor_t * a = ( zactor_t * ) zhash_first ( self -> host_actors ) ; while ( a ) { zstr_send ( a , "WAKEUP" ) ; a = ( zactor_t * ) zhash_next ( self -> host_actors ) ; } } zstr_free ( & cmd ) ; } zmsg_destroy ( & msg ) ; } } else if ( which == mlm_client_msgpipe ( self -> mlm ) ) { <S2SV_StartBug> zsys_debug ( "got<S2SV_blank>malamute<S2SV_blank>message" ) ; <S2SV_EndBug> <S2SV_StartBug> zmsg_t * msg = zmsg_recv ( which ) ; <S2SV_EndBug> if ( msg && is_fty_proto ( msg ) ) { fty_proto_t * ftymsg = fty_proto_decode ( & msg ) ; if ( fty_proto_id ( ftymsg ) == FTY_PROTO_ASSET ) { if ( streq ( fty_proto_operation ( ftymsg ) , "update" ) || streq ( fty_proto_operation ( ftymsg ) , "create" ) ) { zactor_t * act = fty_metric_snmp_server_asset_update ( self , ftymsg ) ; if ( act ) { fty_metric_snmp_server_update_poller ( self , pipe ) ; } } if ( streq ( fty_proto_operation ( ftymsg ) , "delete" ) ) { fty_metric_snmp_server_asset_delete ( self , ftymsg ) ; fty_metric_snmp_server_update_poller ( self , pipe ) ; } } fty_proto_destroy ( & ftymsg ) ; } zmsg_destroy ( & msg ) ; } else if ( which != NULL ) { zsys_debug ( "got<S2SV_blank>host<S2SV_blank>actor<S2SV_blank>message" ) ; zmsg_t * msg = zmsg_recv ( which ) ; char * cmd = zmsg_popstr ( msg ) ; if ( cmd && streq ( cmd , "METRIC" ) ) { char * element = zmsg_popstr ( msg ) ; char * type = zmsg_popstr ( msg ) ; char * value = zmsg_popstr ( msg ) ; char * units = zmsg_popstr ( msg ) ; if ( type && element && value && units ) { char * topic ; asprintf ( & topic , "%s@%s" , type , element ) ; zmsg_t * metric = fty_proto_encode_metric ( NULL , type , element , value , units , 60 ) ; mlm_client_send ( self -> mlm , topic , & metric ) ; zmsg_destroy ( & metric ) ; zstr_free ( & topic ) ; } zstr_free ( & type ) ; zstr_free ( & element ) ; zstr_free ( & value ) ; zstr_free ( & units ) ; } zstr_free ( & cmd ) ; zmsg_destroy ( & msg ) ; } } } | <S2SV_ModStart> ) ) { <S2SV_ModEnd> zmsg_t * msg <S2SV_ModStart> * msg = mlm_client_recv ( self -> mlm <S2SV_ModEnd> ) ; if |
3,867 | CWE-000 int ip6_find_1stfragopt ( struct sk_buff * skb , u8 * * nexthdr ) { <S2SV_StartBug> u16 offset = sizeof ( struct ipv6hdr ) ; <S2SV_EndBug> struct ipv6_opt_hdr * exthdr = ( struct ipv6_opt_hdr * ) ( ipv6_hdr ( skb ) + 1 ) ; unsigned int packet_len = skb -> tail - skb -> network_header ; int found_rhdr = 0 ; * nexthdr = & ipv6_hdr ( skb ) -> nexthdr ; <S2SV_StartBug> while ( offset + 1 <= packet_len ) { <S2SV_EndBug> <S2SV_StartBug> switch ( * * nexthdr ) { <S2SV_EndBug> case NEXTHDR_HOP : break ; case NEXTHDR_ROUTING : found_rhdr = 1 ; break ; case NEXTHDR_DEST : # if IS_ENABLED ( CONFIG_IPV6_MIP6 ) if ( ipv6_find_tlv ( skb , offset , IPV6_TLV_HAO ) >= 0 ) break ; # endif if ( found_rhdr ) return offset ; break ; default : return offset ; } <S2SV_StartBug> offset += ipv6_optlen ( exthdr ) ; <S2SV_EndBug> * nexthdr = & exthdr -> nexthdr ; <S2SV_StartBug> exthdr = ( struct ipv6_opt_hdr * ) ( skb_network_header ( skb ) + <S2SV_EndBug> offset ) ; } return offset ; } | <S2SV_ModStart> ( struct ipv6hdr <S2SV_ModEnd> ) ; unsigned <S2SV_ModStart> while ( offset <S2SV_ModEnd> <= packet_len ) <S2SV_ModStart> packet_len ) { struct ipv6_opt_hdr * exthdr ; <S2SV_ModStart> offset ; } if ( offset + sizeof ( struct ipv6_opt_hdr ) > packet_len ) return - EINVAL ; exthdr = ( struct ipv6_opt_hdr * ) ( skb_network_header ( skb ) + offset ) ; <S2SV_ModStart> -> nexthdr ; } return - EINVAL <S2SV_ModEnd> ; } <S2SV_null> |
3,868 | CWE-000 int connection_push_data_packet ( connection * connection , char packet_type , char * packet , short packet_length , char * data , short data_length ) { char * send_data = ( connection -> send_data + connection -> send_data_count ) ; short header_length = sizeof ( packet_header ) ; short packet_and_data_length = packet_length + data_length ; int remaining_bytes = ( connection -> send_data_capacity - connection -> send_data_count ) ; int full_length = header_length + packet_and_data_length ; if ( full_length < remaining_bytes ) { <S2SV_StartBug> packet_header * header = ( packet_header * ) ( send_data + connection -> send_data_count ) ; <S2SV_EndBug> header -> packet_type = packet_type ; header -> packet_size = packet_and_data_length ; send_data += sizeof ( packet_header ) ; if ( packet_length > 0 ) { memcpy ( send_data , packet , packet_length ) ; } send_data += packet_length ; if ( data_length > 0 ) { memcpy ( send_data , data , data_length ) ; } connection -> send_data_count += header_length ; connection -> send_data_count += packet_length ; connection -> send_data_count += data_length ; return 1 ; } return 0 ; } | <S2SV_ModStart> packet_header * ) send_data <S2SV_ModEnd> ; header -> |
3,869 | CWE-000 void GB_init ( GB_gameboy_t * gb ) { memset ( gb , 0 , sizeof ( * gb ) ) ; gb -> ram = malloc ( gb -> ram_size = 0x2000 ) ; gb -> vram = malloc ( gb -> vram_size = 0x2000 ) ; gb -> input_callback = default_input_callback ; gb -> async_input_callback = default_async_input_callback ; gb -> cartridge_type = & GB_cart_defs [ 0 ] ; <S2SV_StartBug> GB_reset ( gb ) ; <S2SV_EndBug> } | <S2SV_ModStart> 0 ] ; gb -> audio_quality = 4 ; |
3,870 | CWE-000 static void vx900_dram_map_row_col_bank ( dimm_info * dimms ) { u8 reg8 , rcb_val , col_bits , max_row_bits ; size_t i ; max_row_bits = rcb_val = reg8 = 0 ; for ( i = 0 ; i < VX900_MAX_DIMM_SLOTS ; i ++ ) { if ( dimms -> dimm [ i ] . dram_type == SPD_MEMORY_TYPE_UNDEFINED ) continue ; col_bits = dimms -> dimm [ i ] . col_bits ; if ( ( col_bits < 10 ) || ( col_bits > 11 ) ) { <S2SV_StartBug> printram ( "DIMM<S2SV_blank>%ld<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>column<S2SV_blank>address<S2SV_blank>bits.\\n" , <S2SV_EndBug> i , col_bits ) ; die ( "Unsupported<S2SV_blank>DIMM.<S2SV_blank>Try<S2SV_blank>booting<S2SV_blank>without<S2SV_blank>this<S2SV_blank>DIMM" ) ; } rcb_val = col_bits - 5 ; reg8 |= ( rcb_val << ( ( i * 3 ) + 2 ) ) ; max_row_bits = MAX ( max_row_bits , dimms -> dimm [ i ] . row_bits ) ; } printram ( "RCBA<S2SV_blank>map<S2SV_blank>(rx50)<S2SV_blank><-<S2SV_blank>%.2x\\n" , reg8 ) ; pci_write_config8 ( MCU , 0x50 , reg8 ) ; printram ( "Houston,<S2SV_blank>we<S2SV_blank>have<S2SV_blank>%d<S2SV_blank>row<S2SV_blank>address<S2SV_blank>bits\\n" , max_row_bits ) ; vx900_dram_map_pins ( 13 , 14 , 15 , 17 , 16 ) ; } | <S2SV_ModStart> { printram ( "DIMM<S2SV_blank>%zd<S2SV_blank>has<S2SV_blank>%d<S2SV_blank>column<S2SV_blank>address<S2SV_blank>bits.\\n" <S2SV_ModEnd> , i , |
3,871 | CWE-000 static gboolean _gst_param_array_validate ( GParamSpec * pspec , GValue * value ) { <S2SV_StartBug> GstParamSpecArray * aspec = GST_PARAM_SPEC_ARRAY_LIST ( pspec ) ; <S2SV_EndBug> if ( aspec -> element_spec ) { GParamSpec * element_spec = aspec -> element_spec ; guint i ; for ( i = 0 ; i < gst_value_array_get_size ( value ) ; i ++ ) { GValue * element = ( GValue * ) gst_value_array_get_value ( value , i ) ; if ( ! g_value_type_compatible ( G_VALUE_TYPE ( element ) , G_PARAM_SPEC_VALUE_TYPE ( element_spec ) ) ) { if ( G_VALUE_TYPE ( element ) != 0 ) g_value_unset ( element ) ; g_value_init ( element , G_PARAM_SPEC_VALUE_TYPE ( element_spec ) ) ; g_param_value_set_default ( element_spec , element ) ; <S2SV_StartBug> return FALSE ; <S2SV_EndBug> } <S2SV_StartBug> if ( ! g_param_value_validate ( element_spec , element ) ) <S2SV_EndBug> <S2SV_StartBug> return FALSE ; <S2SV_EndBug> } } <S2SV_StartBug> return TRUE ; <S2SV_EndBug> } | <S2SV_ModStart> ( pspec ) ; gboolean ret = FALSE <S2SV_ModStart> element ) ; ret = TRUE <S2SV_ModEnd> ; } if <S2SV_ModStart> } if ( <S2SV_ModEnd> g_param_value_validate ( element_spec <S2SV_ModStart> element ) ) ret = TRUE <S2SV_ModEnd> ; } } <S2SV_ModStart> } } return ret <S2SV_ModEnd> ; } <S2SV_null> |
3,872 | CWE-000 void cm_free_leaks_info ( cm_leak_info * * leak_array , size_t size ) { size_t i ; if ( ! leak_array || size == 0 ) return ; <S2SV_StartBug> for ( i = 0 ; i < size ; i ++ ) { <S2SV_EndBug> free ( leak_array [ i ] ) ; } free ( leak_array ) ; * leak_array = NULL ; } | <S2SV_ModStart> < size ; ++ i <S2SV_ModEnd> ) { free |
3,873 | CWE-000 static inline void tcg_out_st ( TCGContext * s , TCGType type , TCGReg arg , TCGReg arg1 , intptr_t arg2 ) { int opi , opx ; <S2SV_StartBug> assert ( TCG_TARGET_REG_BITS == 64 || type == TCG_TYPE_I32 ) ; <S2SV_EndBug> if ( type == TCG_TYPE_I32 ) { opi = STW , opx = STWX ; } else { opi = STD , opx = STDX ; } tcg_out_mem_long ( s , opi , opx , arg , arg1 , arg2 ) ; } | <S2SV_ModStart> , opx ; tcg_debug_assert <S2SV_ModEnd> ( TCG_TARGET_REG_BITS == |
3,874 | CWE-000 static void tls_handle ( int rc , int fd ) { struct tls_resource * resource ; mbedtls_ssl_context * ssl ; const char * query ; uint32_t flags ; int ret ; resource = tls_find_resource ( fd ) ; if ( resource == NULL ) { close ( fd ) ; net_remove_handler ( fd , & tls_handle ) ; return ; } ssl = & resource -> ssl ; query = & resource -> query [ 0 ] ; if ( rc < 0 ) { if ( errno != EINPROGRESS ) { <S2SV_StartBug> log_warn ( "TLS:<S2SV_blank>Socket<S2SV_blank>error<S2SV_blank>for<S2SV_blank>\'%s\':<S2SV_blank>%s" , query , strerror ( errno ) ) ; <S2SV_EndBug> auth_end ( resource , AUTH_ERROR ) ; } else { } return ; } do ret = mbedtls_ssl_handshake ( ssl ) ; while ( ret == MBEDTLS_ERR_SSL_WANT_WRITE ) ; if ( ret == MBEDTLS_ERR_SSL_WANT_READ ) { return ; } if ( ret ) { # ifdef DEBUG <S2SV_StartBug> log_debug ( "TLS:<S2SV_blank>mbedtls_ssl_handshake<S2SV_blank>returned<S2SV_blank>-0x%x:<S2SV_blank>%s" , - ret , query ) ; <S2SV_EndBug> if ( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED ) { <S2SV_StartBug> log_debug ( "TLS:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>verify<S2SV_blank>the<S2SV_blank>server\'s<S2SV_blank>certificate:<S2SV_blank>%s" , query ) ; <S2SV_EndBug> } # endif auth_end ( resource , AUTH_FAILED ) ; } else { <S2SV_StartBug> log_debug ( "TLS:<S2SV_blank>Protocol<S2SV_blank>[%s],<S2SV_blank>Ciphersuite<S2SV_blank>[%s]<S2SV_blank>and<S2SV_blank>fragment<S2SV_blank>length<S2SV_blank>%u:<S2SV_blank>%s" , <S2SV_EndBug> mbedtls_ssl_get_version ( ssl ) , mbedtls_ssl_get_ciphersuite ( ssl ) , ( unsigned int ) mbedtls_ssl_get_max_frag_len ( ssl ) , query ) ; flags = mbedtls_ssl_get_verify_result ( ssl ) ; # ifdef DEBUG char buf [ MBEDTLS_SSL_MAX_CONTENT_LEN + 1 ] ; if ( flags != 0 ) { mbedtls_x509_crt_verify_info ( buf , sizeof ( buf ) , "" , flags ) ; <S2SV_StartBug> log_debug ( "TLS:<S2SV_blank>Peer<S2SV_blank>verification<S2SV_blank>failed:<S2SV_blank>%s" , buf ) ; <S2SV_EndBug> } if ( mbedtls_ssl_get_peer_cert ( ssl ) != NULL ) { mbedtls_x509_crt_info ( ( char * ) buf , sizeof ( buf ) - 1 , "" , mbedtls_ssl_get_peer_cert ( ssl ) ) ; <S2SV_StartBug> log_debug ( "TLS:<S2SV_blank>Peer<S2SV_blank>certificate<S2SV_blank>information:<S2SV_blank>%s" , buf ) ; <S2SV_EndBug> } # endif auth_end ( resource , flags == 0 ? AUTH_OK : AUTH_FAILED ) ; } } | <S2SV_ModStart> { log_warn ( "TLS-Client:<S2SV_blank>Socket<S2SV_blank>error<S2SV_blank>for<S2SV_blank>\'%s\':<S2SV_blank>%s" <S2SV_ModEnd> , query , <S2SV_ModStart> DEBUG log_debug ( "TLS-Client:<S2SV_blank>mbedtls_ssl_handshake<S2SV_blank>returned<S2SV_blank>-0x%x:<S2SV_blank>%s" <S2SV_ModEnd> , - ret <S2SV_ModStart> { log_debug ( "TLS-Client:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>verify<S2SV_blank>the<S2SV_blank>servers<S2SV_blank>certificate:<S2SV_blank>%s" <S2SV_ModEnd> , query ) <S2SV_ModStart> { log_debug ( "TLS-Client:<S2SV_blank>Protocol<S2SV_blank>[%s],<S2SV_blank>Ciphersuite<S2SV_blank>[%s]<S2SV_blank>and<S2SV_blank>fragment<S2SV_blank>length<S2SV_blank>%u:<S2SV_blank>%s" <S2SV_ModEnd> , mbedtls_ssl_get_version ( <S2SV_ModStart> ; log_debug ( "TLS-Client:<S2SV_blank>Peer<S2SV_blank>verification<S2SV_blank>failed:<S2SV_blank>%s" <S2SV_ModEnd> , buf ) <S2SV_ModStart> ; log_debug ( "TLS-Client:<S2SV_blank>Peer<S2SV_blank>certificate<S2SV_blank>information:<S2SV_blank>%s" <S2SV_ModEnd> , buf ) |
3,875 | CWE-000 void btc_blufi_call_handler ( btc_msg_t * msg ) { btc_blufi_args_t * arg = ( btc_blufi_args_t * ) msg -> arg ; switch ( msg -> act ) { case BTC_BLUFI_ACT_INIT : btc_blufi_profile_init ( ) ; break ; case BTC_BLUFI_ACT_DEINIT : break ; case BTC_BLUFI_ACT_SEND_CFG_STATE : if ( arg -> cfg_state . state == ESP_BLUFI_CONFIG_OK ) { btc_blufi_config_success ( ) ; } else { btc_blufi_config_failed ( ) ; } break ; default : <S2SV_StartBug> LOG_ERROR ( "%s<S2SV_blank>UNKNOWN<S2SV_blank>%d\\n" , msg -> act ) ; <S2SV_EndBug> break ; } } | <S2SV_ModStart> ( "%s<S2SV_blank>UNKNOWN<S2SV_blank>%d\\n" , __func__ , |
3,876 | CWE-000 struct buffer_head * sb_getblk ( struct super_block * sb , sector_t block ) { struct buffer_head * bh = calloc ( 1 , sizeof ( struct buffer_head ) ) ; if ( ! bh ) { fprintf ( stderr , "***<S2SV_blank>fatal<S2SV_blank>error:<S2SV_blank>cannot<S2SV_blank>allocate<S2SV_blank>buffer\\n" ) ; abort ( ) ; } bh -> b_flags . dynamic = 1 ; <S2SV_StartBug> bh -> b_size = PAGE_SIZE ; <S2SV_EndBug> bh -> b_blocknr = block ; return bh ; } | <S2SV_ModStart> -> b_size = sb -> s_blocksize <S2SV_ModEnd> ; bh -> |
3,877 | CWE-000 static BrainData new_data ( BrainString repository_path , BrainString tokenizer , const BrainUint input_length , const BrainUint output_length , const DataParser parser , const BrainBool is_labedelled , const BrainDataFormat format , const BrainUint number_of_preprocessing , const DataPreprocessing * preprocessings ) { BrainData _data = NULL ; if ( repository_path ) { BrainUint i = 0 ; BRAIN_NEW ( _data , Data , 1 ) ; _data -> _input_length = input_length ; _data -> _output_length = output_length ; _data -> _labels_length = 0 ; _data -> _is_labelled = is_labedelled ; _data -> _format = format ; <S2SV_StartBug> switch ( parser ) <S2SV_EndBug> { case Parser_CSV : { const BrainUint number_of_fields = _data -> _is_labelled ? _data -> _input_length : _data -> _input_length + _data -> _output_length ; BrainCsvReader reader = new_csv_reader ( repository_path , tokenizer , number_of_fields , _data -> _format , _data -> _is_labelled ) ; csv_reader_load ( reader , csv_line_callback , _data ) ; delete_csv_reader ( reader ) ; } break ; default : break ; } for ( i = 0 ; i < number_of_preprocessing ; ++ i ) { switch ( preprocessings [ i ] ) { case Preprocessing_GaussianNormalization : { BRAIN_NEW ( _data -> _means , BrainReal , _data -> _input_length ) ; BRAIN_NEW ( _data -> _sigmas , BrainReal , _data -> _input_length ) ; FindGaussianModel ( _data -> _training . _input , _data -> _means , _data -> _sigmas , _data -> _training . _children , _data -> _input_length ) ; ApplyGaussianModel ( _data -> _training . _input , _data -> _means , _data -> _sigmas , _data -> _training . _children , _data -> _input_length ) ; ApplyGaussianModel ( _data -> _evaluating . _input , _data -> _means , _data -> _sigmas , _data -> _evaluating . _children , _data -> _input_length ) ; } break ; default : break ; } } } return _data ; } | <S2SV_ModStart> = format ; printf ( "Format:<S2SV_blank>%d" , format ) ; |
3,878 | CWE-000 static gboolean ide_python_indenter_is_trigger ( IdeIndenter * indenter , GdkEventKey * event ) { switch ( event -> keyval ) { <S2SV_StartBug> case GDK_KEY_e : <S2SV_EndBug> case GDK_KEY_f : case GDK_KEY_KP_Enter : case GDK_KEY_Return : return TRUE ; default : return FALSE ; } } | <S2SV_ModStart> ) { case GDK_KEY_colon : case GDK_KEY_space <S2SV_ModEnd> : case GDK_KEY_KP_Enter |
3,879 | CWE-000 t_vector vector_rot_x ( t_vector v , float angle ) { t_vector vector ; vector . x = v . x ; <S2SV_StartBug> vector . y = v . y * cos ( angle ) - v . z * sin ( angle ) ; <S2SV_EndBug> <S2SV_StartBug> vector . z = v . y * sin ( angle ) + v . z * cos ( angle ) ; <S2SV_EndBug> return ( vector ) ; } | <S2SV_ModStart> . y * cosf <S2SV_ModEnd> ( angle ) <S2SV_ModStart> . z * sinf <S2SV_ModEnd> ( angle ) <S2SV_ModStart> . y * sinf <S2SV_ModEnd> ( angle ) <S2SV_ModStart> . z * cosf <S2SV_ModEnd> ( angle ) |
3,880 | CWE-000 static bool filter_query_done_send ( void * hookdata , void * cbdata , isc_result_t * resp ) { query_ctx_t * qctx = ( query_ctx_t * ) hookdata ; <S2SV_StartBug> filter_aaaa_t * qfa = ( filter_aaaa_t * ) & qctx -> hookdata [ filter_aaaa ] ; <S2SV_EndBug> isc_result_t result ; UNUSED ( cbdata ) ; <S2SV_StartBug> if ( * qfa == OK ) { <S2SV_EndBug> * resp = ISC_R_UNSET ; return ( false ) ; } result = dns_message_firstname ( qctx -> client -> message , DNS_SECTION_ADDITIONAL ) ; while ( result == ISC_R_SUCCESS ) { dns_name_t * name = NULL ; dns_rdataset_t * aaaa = NULL , * aaaa_sig = NULL ; dns_rdataset_t * a = NULL ; dns_message_currentname ( qctx -> client -> message , DNS_SECTION_ADDITIONAL , & name ) ; result = dns_message_nextname ( qctx -> client -> message , DNS_SECTION_ADDITIONAL ) ; dns_message_findtype ( name , dns_rdatatype_a , 0 , & a ) ; if ( a == NULL ) { continue ; } dns_message_findtype ( name , dns_rdatatype_aaaa , 0 , & aaaa ) ; if ( aaaa == NULL ) { continue ; } dns_message_findtype ( name , dns_rdatatype_rrsig , dns_rdatatype_aaaa , & aaaa_sig ) ; if ( aaaa_sig == NULL || ! WANTDNSSEC ( qctx -> client ) || <S2SV_StartBug> * qfa == BREAK_DNSSEC ) <S2SV_EndBug> { aaaa -> attributes |= DNS_RDATASETATTR_RENDERED ; if ( aaaa_sig != NULL ) { aaaa_sig -> attributes |= DNS_RDATASETATTR_RENDERED ; } } } * resp = ISC_R_UNSET ; return ( false ) ; } | <S2SV_ModStart> ) hookdata ; <S2SV_ModEnd> isc_result_t result ; <S2SV_ModStart> if ( * * QFA <S2SV_ModEnd> == OK ) <S2SV_ModStart> ) || * * QFA <S2SV_ModEnd> == BREAK_DNSSEC ) |
3,881 | CWE-000 void parseWhile ( FILE * f , char * token , struct whileStatement * state ) { parseToken ( f , token ) ; <S2SV_StartBug> struct expression * * exp = ( struct expression * * ) malloc ( sizeof ( struct expression ) ) ; <S2SV_EndBug> <S2SV_StartBug> parseExpression ( f , exp , token , ')' ) ; <S2SV_EndBug> parseToken ( f , token ) ; parseToken ( f , token ) ; state -> cond = * exp ; state -> commands = NULL ; int i = 0 ; struct command * * comms = ( struct command * * ) malloc ( sizeof ( struct command * * ) ) ; while ( token [ 0 ] != '}' ) { parseCommand ( f , token , comms + i ) ; if ( i > 0 ) comms [ i - 1 ] -> next = comms [ i ] ; i ++ ; } if ( comms != NULL ) state -> commands = comms [ 0 ] ; } | <S2SV_ModStart> token ) ; parseToken ( f , token ) ; printf ( "%s\\n" , token ) ; <S2SV_ModStart> token , ')' ) ; printf ( "here\\n" ) ; printExpression ( * exp |
3,882 | CWE-000 int istgt_queue_init ( ISTGT_QUEUE_Ptr head ) { if ( head == NULL ) <S2SV_StartBug> return - 1 ; <S2SV_EndBug> head -> prev = head ; head -> next = head ; head -> elem = NULL ; head -> num = 0 ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> NULL ) return ( - 1 ) <S2SV_ModEnd> ; head -> <S2SV_ModStart> 0 ; return ( 0 ) <S2SV_ModEnd> ; } <S2SV_null> |
3,883 | CWE-000 int register_table ( int argc , int view_index , const char * * q , const char * * sqlite_names , int port_number ) { char sqlite_query [ 200 ] ; <S2SV_StartBug> int re , i = 0 , output ; <S2SV_EndBug> sqlite3_module * mod ; # ifdef PICO_QL_DEBUG for ( i = 0 ; i < argc ; i ++ ) { printf ( "\\nquery<S2SV_blank>to<S2SV_blank>be<S2SV_blank>executed:<S2SV_blank>%s.\\n" , q [ i ] ) ; } # endif <S2SV_StartBug> mod = ( sqlite3_module * ) sqlite3_malloc ( sizeof ( sqlite3_module ) ) ; <S2SV_EndBug> fill_module ( mod ) ; <S2SV_StartBug> output = sqlite3_create_module ( db , "PicoQL" , mod , NULL ) ; <S2SV_EndBug> if ( output == 1 ) printf ( "Error<S2SV_blank>while<S2SV_blank>registering<S2SV_blank>module\\n" ) ; # ifdef PICO_QL_DEBUG else if ( output == 0 ) printf ( "Module<S2SV_blank>registered<S2SV_blank>successfully\\n" ) ; # endif for ( i = 0 ; i < argc ; i ++ ) { char sqlite_type [ 10 ] ; if ( i < view_index ) strcpy ( sqlite_type , "table" ) ; else strcpy ( sqlite_type , "view" ) ; sprintf ( sqlite_query , "SELECT<S2SV_blank>*<S2SV_blank>FROM<S2SV_blank>sqlite_master<S2SV_blank>WHERE<S2SV_blank>type=\'%s\'<S2SV_blank>AND<S2SV_blank>name=\'%s\';" , sqlite_type , sqlite_names [ i ] ) ; if ( pico_ql_exec_query ( ( const char * ) sqlite_query , NULL , pico_ql_step_mute ) != SQLITE_ROW ) { re = pico_ql_exec_query ( ( const char * ) q [ i ] , NULL , pico_ql_step_mute ) ; # ifdef PICO_QL_DEBUG printf ( "Query<S2SV_blank>%s<S2SV_blank>returned:<S2SV_blank>%i\\n" , q [ i ] , re ) ; # endif if ( ( re = sqlite3_extended_errcode ( db ) ) != SQLITE_DONE && re != SQLITE_OK ) { printf ( "Extended<S2SV_blank>error<S2SV_blank>code:<S2SV_blank>%i.\\n" , sqlite3_extended_errcode ( db ) ) ; printf ( "Extended<S2SV_blank>error<S2SV_blank>message:\\n%s.\\n" , sqlite3_errmsg ( db ) ) ; return re ; } } } start_serving ( ) ; # ifndef PICO_QL_TEST if ( port_number == - 1 ) return re ; # ifdef PICO_QL_SWILL else { printf ( "Please<S2SV_blank>visit<S2SV_blank>http://localhost:%i<S2SV_blank>to<S2SV_blank>be<S2SV_blank>served\\n" , port_number ) ; init_pico_ql_swill ( port_number ) ; } # endif # else re = exec_tests ( ) ; # endif <S2SV_StartBug> sqlite3_free ( mod ) ; <S2SV_EndBug> return re ; } | <S2SV_ModStart> 0 , output <S2SV_ModEnd> ; # ifdef <S2SV_ModStart> } # endif <S2SV_ModEnd> output = sqlite3_create_module <S2SV_ModStart> , "PicoQL" , & pico_ql_mod <S2SV_ModEnd> , NULL ) <S2SV_ModStart> ; # endif <S2SV_ModEnd> return re ; |
3,884 | CWE-000 <S2SV_StartBug> int lamb_amqp_setting ( lamb_amqp_t * amqp , const char * exchange , const char * key ) { <S2SV_EndBug> amqp -> exchange = exchange ; amqp -> key = key ; return 0 ; } | <S2SV_ModStart> * amqp , <S2SV_ModEnd> char * exchange <S2SV_ModStart> * exchange , <S2SV_ModEnd> char * key |
3,885 | CWE-000 int main ( int argc , char * * argv ) { mpc_parser_t * Number = mpc_new ( "number" ) ; mpc_parser_t * Symbol = mpc_new ( "symbol" ) ; mpc_parser_t * Sexpr = mpc_new ( "sexpr" ) ; mpc_parser_t * Expr = mpc_new ( "expr" ) ; mpc_parser_t * Lispy = mpc_new ( "lispy" ) ; mpca_lang ( MPCA_LANG_DEFAULT , <S2SV_StartBug> "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><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>\\\n<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>number<S2SV_blank>:<S2SV_blank>/-?[0-9]+(\\\\.[0-9]+)?/<S2SV_blank>;<S2SV_blank>\\\n<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>symbol<S2SV_blank>:<S2SV_blank>\'+\'<S2SV_blank>|<S2SV_blank>\'-\'<S2SV_blank>|<S2SV_blank>\'*\'<S2SV_blank>|<S2SV_blank>\'/\'<S2SV_blank>;<S2SV_blank>\\\n<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>sexpr<S2SV_blank>:<S2SV_blank>\'(\'<S2SV_blank><expr>*<S2SV_blank>\')\'<S2SV_blank>;<S2SV_blank>\\\n<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>expr<S2SV_blank>:<S2SV_blank><number><S2SV_blank>|<S2SV_blank><symbol><S2SV_blank>|<S2SV_blank><sexpr><S2SV_blank>;<S2SV_blank>\\\n<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>lispy<S2SV_blank>:<S2SV_blank>/^/<S2SV_blank><expr>*<S2SV_blank>/$/<S2SV_blank>;<S2SV_blank>\\\n<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_EndBug> Number , Symbol , Sexpr , Expr , Lispy ) ; puts ( "myLisp<S2SV_blank>Version<S2SV_blank>0.0.0.1" ) ; puts ( "Press<S2SV_blank>Ctrl+C<S2SV_blank>to<S2SV_blank>Exit\\n" ) ; while ( 1 ) { char * input = readline ( "myLisp><S2SV_blank>" ) ; add_history ( input ) ; mpc_result_t r ; if ( mpc_parse ( "<stdin>" , input , Lispy , & r ) ) { <S2SV_StartBug> lval result = eval ( r . output ) ; <S2SV_EndBug> <S2SV_StartBug> lval_println ( result ) ; <S2SV_EndBug> printf ( "Number<S2SV_blank>of<S2SV_blank>leaves:<S2SV_blank>%ld\\n" , count_leaves ( r . output ) ) ; mpc_ast_delete ( r . output ) ; } else { mpc_err_print ( r . error ) ; mpc_err_delete ( r . error ) ; } free ( input ) ; } mpc_cleanup ( 5 , Number , Symbol , Sexpr , Expr , Lispy ) ; return 0 ; } | <S2SV_ModStart> ( MPCA_LANG_DEFAULT , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><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>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>number<S2SV_blank>:<S2SV_blank>/-?[0-9]+(\\\\.[0-9]+)?/<S2SV_blank>;<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>symbol<S2SV_blank>:<S2SV_blank>\'+\'<S2SV_blank>|<S2SV_blank>\'-\'<S2SV_blank>|<S2SV_blank>\'*\'<S2SV_blank>|<S2SV_blank>\'/\'<S2SV_blank>;<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>sexpr<S2SV_blank>:<S2SV_blank>\'(\'<S2SV_blank><expr>*<S2SV_blank>\')\'<S2SV_blank>;<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>expr<S2SV_blank>:<S2SV_blank><number><S2SV_blank>|<S2SV_blank><symbol><S2SV_blank>|<S2SV_blank><sexpr><S2SV_blank>;<S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>lispy<S2SV_blank>:<S2SV_blank>/^/<S2SV_blank><expr>*<S2SV_blank>/$/<S2SV_blank>;<S2SV_blank>\\\n<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_ModEnd> , Number , <S2SV_ModStart> ) { lval * result = lval_read <S2SV_ModEnd> ( r . <S2SV_ModStart> ) ; lval_println ( result ) ; lval_del |
3,886 | CWE-000 static ssize_t rsendv ( int socket , const struct iovec * iov , int iovcnt , int flags ) { struct rsocket * rs ; const struct iovec * cur_iov ; size_t left , len , offset = 0 ; uint32_t xfer_size , olen = RS_OLAP_START_SIZE ; int i , ret = 0 ; rs = idm_at ( & idm , socket ) ; <S2SV_StartBug> if ( rs -> state & rs_opening ) { <S2SV_EndBug> ret = rs_do_connect ( rs ) ; if ( ret ) { if ( errno == EINPROGRESS ) errno = EAGAIN ; return ret ; } } cur_iov = iov ; len = iov [ 0 ] . iov_len ; for ( i = 1 ; i < iovcnt ; i ++ ) len += iov [ i ] . iov_len ; left = len ; fastlock_acquire ( & rs -> slock ) ; if ( rs -> iomap_pending ) { ret = rs_send_iomaps ( rs , flags ) ; if ( ret ) goto out ; } for ( ; left ; left -= xfer_size ) { if ( ! rs_can_send ( rs ) ) { ret = rs_get_comp ( rs , rs_nonblocking ( rs , flags ) , rs_conn_can_send ) ; if ( ret ) break ; if ( ! ( rs -> state & rs_writable ) ) { ret = ERR ( ECONNRESET ) ; break ; } } if ( olen < left ) { xfer_size = olen ; if ( olen < RS_MAX_TRANSFER ) olen <<= 1 ; } else { xfer_size = left ; } if ( xfer_size > rs -> sbuf_bytes_avail ) xfer_size = rs -> sbuf_bytes_avail ; if ( xfer_size > rs -> target_sgl [ rs -> target_sge ] . length ) xfer_size = rs -> target_sgl [ rs -> target_sge ] . length ; if ( xfer_size <= rs_sbuf_left ( rs ) ) { rs_copy_iov ( ( void * ) ( uintptr_t ) rs -> ssgl [ 0 ] . addr , & cur_iov , & offset , xfer_size ) ; rs -> ssgl [ 0 ] . length = xfer_size ; ret = rs_write_data ( rs , rs -> ssgl , 1 , xfer_size , xfer_size <= rs -> sq_inline ? IBV_SEND_INLINE : 0 ) ; if ( xfer_size < rs_sbuf_left ( rs ) ) rs -> ssgl [ 0 ] . addr += xfer_size ; else rs -> ssgl [ 0 ] . addr = ( uintptr_t ) rs -> sbuf ; } else { rs -> ssgl [ 0 ] . length = rs_sbuf_left ( rs ) ; rs_copy_iov ( ( void * ) ( uintptr_t ) rs -> ssgl [ 0 ] . addr , & cur_iov , & offset , rs -> ssgl [ 0 ] . length ) ; rs -> ssgl [ 1 ] . length = xfer_size - rs -> ssgl [ 0 ] . length ; rs_copy_iov ( rs -> sbuf , & cur_iov , & offset , rs -> ssgl [ 1 ] . length ) ; ret = rs_write_data ( rs , rs -> ssgl , 2 , xfer_size , xfer_size <= rs -> sq_inline ? IBV_SEND_INLINE : 0 ) ; rs -> ssgl [ 0 ] . addr = ( uintptr_t ) rs -> sbuf + rs -> ssgl [ 1 ] . length ; } if ( ret ) break ; } out : fastlock_release ( & rs -> slock ) ; return ( ret && left == len ) ? ret : len - left ; } | <S2SV_ModStart> ; if ( ! rs ) return ERR ( EBADF ) ; if ( |
3,887 | CWE-000 inline static protocol_s * protocol_try_lock ( intptr_t fd , enum facil_protocol_lock_e type ) { if ( spn_trylock ( & fd_data ( fd ) . lock ) ) goto would_block ; protocol_s * pr = fd_data ( fd ) . protocol ; if ( ! pr ) { spn_unlock ( & fd_data ( fd ) . lock ) ; errno = EBADF ; return NULL ; } <S2SV_StartBug> if ( spn_trylock ( & prt_meta ( pr ) . locks [ type ] ) ) <S2SV_EndBug> <S2SV_StartBug> goto would_block ; <S2SV_EndBug> spn_unlock ( & fd_data ( fd ) . lock ) ; return pr ; would_block : errno = EWOULDBLOCK ; return NULL ; } | <S2SV_ModStart> ] ) ) { spn_unlock ( & fd_data ( fd ) . lock ) ; <S2SV_ModStart> goto would_block ; } |
3,888 | CWE-000 <S2SV_StartBug> PHP_METHOD ( Collection , toCollection ) <S2SV_EndBug> { zval * dest ; ZEND_PARSE_PARAMETERS_START ( 1 , 1 ) Z_PARAM_OBJECT_OF_CLASS ( dest , collections_collection_ce ) ZEND_PARSE_PARAMETERS_END ( ) ; zend_array * current = COLLECTION_FETCH_CURRENT ( ) ; <S2SV_StartBug> zend_array * dest_arr = COLLECTION_FETCH ( dest ) ; <S2SV_EndBug> SEPARATE_COLLECTION ( dest_arr , dest ) ; ZEND_HASH_FOREACH_BUCKET ( current , Bucket * bucket ) if ( bucket -> key ) zend_hash_add ( dest_arr , bucket -> key , & bucket -> val ) ; else zend_hash_next_index_insert ( dest_arr , & bucket -> val ) ; ZEND_HASH_FOREACH_END ( ) ; RETVAL_ZVAL ( dest , 1 , 0 ) ; } | <S2SV_ModStart> ( Collection , toArray ) { zend_array * retval <S2SV_ModEnd> = COLLECTION_FETCH_CURRENT ( <S2SV_ModStart> ( ) ; GC_ADDREF ( retval ) ; RETVAL_ARR ( retval <S2SV_ModEnd> ) ; } |
3,889 | CWE-000 bool friendRequest ( CourseManager course_manager , Student student_in , int id ) { if ( course_manager == NULL ) { return false ; } if ( student_in == NULL ) { setError ( course_manager , MTM_NOT_LOGGED_IN ) ; return false ; } Student student = getStudent ( course_manager , id ) ; if ( student == NULL ) { setError ( course_manager , MTM_STUDENT_DOES_NOT_EXIST ) ; return false ; } <S2SV_StartBug> else if ( setIsIn ( student_in -> friends , student ) ) { <S2SV_EndBug> setError ( course_manager , MTM_ALREADY_FRIEND ) ; return false ; } else if ( setIsIn ( student_in -> sent_requests , student ) ) { setError ( course_manager , MTM_ALREADY_REQUESTED ) ; return false ; } else { SetResult result = setAdd ( student_in -> sent_requests , student ) ; if ( result == SET_OUT_OF_MEMORY ) { setError ( course_manager , MTM_OUT_OF_MEMORY ) ; return false ; } else { return true ; } } } | <S2SV_ModStart> , student ) || compareStudents ( student_in , student ) == 0 |
3,890 | CWE-000 static Bool TegraEXAPixmapIsOffscreen ( PixmapPtr pPix ) { TegraPixmapPtr priv = exaGetPixmapDriverPrivate ( pPix ) ; <S2SV_StartBug> return priv && ( priv -> type == TEGRA_EXA_PIXMAP_TYPE_BO || <S2SV_EndBug> priv -> type == TEGRA_EXA_PIXMAP_TYPE_POOL ) ; } | <S2SV_ModStart> return priv && priv -> accel <S2SV_ModEnd> ; } <S2SV_null> |
3,891 | CWE-000 static void unregister_characteristic ( void * data ) { struct characteristic * chrc = data ; struct bt_gatt_client * gatt = chrc -> service -> client -> gatt ; DBG ( "Removing<S2SV_blank>GATT<S2SV_blank>characteristic:<S2SV_blank>%s" , chrc -> path ) ; if ( chrc -> read_op ) bt_gatt_client_cancel ( gatt , chrc -> read_op -> id ) ; if ( chrc -> write_op ) bt_gatt_client_cancel ( gatt , chrc -> write_op -> id ) ; <S2SV_StartBug> queue_remove_all ( chrc -> notify_clients , NULL , NULL , remove_client ) ; <S2SV_EndBug> queue_remove_all ( chrc -> descs , NULL , NULL , unregister_descriptor ) ; g_dbus_unregister_interface ( btd_get_dbus_connection ( ) , chrc -> path , GATT_CHARACTERISTIC_IFACE ) ; } | <S2SV_ModStart> ( chrc -> <S2SV_ModEnd> descs , NULL |
3,892 | CWE-000 void c_term_clear ( t_comp * c ) { int i ; int lcmd ; ft_putstr ( tgetstr ( "do" , NULL ) ) ; ft_putstr ( tgetstr ( "cd" , NULL ) ) ; ft_putstr ( tgetstr ( "up" , NULL ) ) ; i = 0 ; lcmd = 0 ; <S2SV_StartBug> c -> rcmd ? lcmd += c_virtual_position ( c ) + c -> prompt + 1 : 0 ; <S2SV_EndBug> while ( i < lcmd ) { ft_putstr ( tgetstr ( "nd" , NULL ) ) ; i ++ ; } } | <S2SV_ModStart> = 0 ; lcmd = ( <S2SV_ModStart> c -> rcmd ) ? ft_nb_last_line ( data_singleton ( ) -> line . input , data_singleton ( ) -> line . pos ) <S2SV_ModEnd> : 0 ; |
3,893 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( getpid ( ) == 1 ) { open_tty ( ) ; int args ; while ( ( args = getopt ( argc , argv , "s" ) ) != - 1 ) { switch ( args ) { case 's' : <S2SV_StartBug> return single ( "Booting<S2SV_blank>into<S2SV_blank>single<S2SV_blank>user<S2SV_blank>mode...\\n" ) ; <S2SV_EndBug> } } bootrc ( ) ; } if ( getuid ( ) != 0 ) { printf ( COLOR_BOLD COLOR_RED "*<S2SV_blank>" COLOR_LIGHT_RED "%s" COLOR_RESET "\\n" , strerror ( EPERM ) ) ; return 1 ; } if ( argc == 1 ) return usage ( ) ; switch ( * argv [ 1 ] ) { case '0' : return kill ( 1 , SIGUSR2 ) ; case '6' : return kill ( 1 , SIGINT ) ; default : return usage ( ) ; } } | <S2SV_ModStart> return single ( "Booting<S2SV_blank>into<S2SV_blank>single<S2SV_blank>user<S2SV_blank>mode..." <S2SV_ModEnd> ) ; } |
3,894 | CWE-000 void run ( void ) { int xfd ; fd_set fds ; struct timeval timeout ; bool discard , init_thumb , load_thumb , to_set ; XEvent ev , nextev ; while ( true ) { to_set = check_timeouts ( & timeout ) ; init_thumb = mode == MODE_THUMB && tns . initnext < filecnt ; load_thumb = mode == MODE_THUMB && tns . loadnext < tns . end ; if ( ( init_thumb || load_thumb || to_set || info . fd != - 1 ) && XPending ( win . env . dpy ) == 0 ) { if ( load_thumb ) { set_timeout ( redraw , TO_REDRAW_THUMBS , false ) ; if ( ! tns_load ( & tns , tns . loadnext , false , false ) ) { remove_file ( tns . loadnext , false ) ; tns . dirty = true ; } if ( tns . loadnext >= tns . end ) redraw ( ) ; } else if ( init_thumb ) { set_timeout ( redraw , TO_REDRAW_THUMBS , false ) ; if ( ! tns_load ( & tns , tns . initnext , false , true ) ) remove_file ( tns . initnext , false ) ; } else { xfd = ConnectionNumber ( win . env . dpy ) ; FD_ZERO ( & fds ) ; FD_SET ( xfd , & fds ) ; if ( info . fd != - 1 ) { FD_SET ( info . fd , & fds ) ; xfd = MAX ( xfd , info . fd ) ; } select ( xfd + 1 , & fds , 0 , 0 , to_set ? & timeout : NULL ) ; if ( info . fd != - 1 && FD_ISSET ( info . fd , & fds ) ) read_info ( ) ; } continue ; } do { XNextEvent ( win . env . dpy , & ev ) ; discard = false ; if ( XEventsQueued ( win . env . dpy , QueuedAlready ) > 0 ) { XPeekEvent ( win . env . dpy , & nextev ) ; switch ( ev . type ) { case ConfigureNotify : discard = ev . type == nextev . type ; break ; case KeyPress : discard = ( nextev . type == KeyPress || nextev . type == KeyRelease ) && ev . xkey . keycode == nextev . xkey . keycode ; break ; } } } while ( discard ) ; switch ( ev . type ) { case ButtonPress : on_buttonpress ( & ev . xbutton ) ; break ; case ClientMessage : if ( ( Atom ) ev . xclient . data . l [ 0 ] == atoms [ ATOM_WM_DELETE_WINDOW ] ) <S2SV_StartBug> return ; <S2SV_EndBug> break ; case ConfigureNotify : if ( win_configure ( & win , & ev . xconfigure ) ) { if ( mode == MODE_IMAGE ) { img . dirty = true ; img . checkpan = true ; } else { tns . dirty = true ; } if ( ! resized || win . fullscreen ) { redraw ( ) ; set_timeout ( clear_resize , TO_REDRAW_RESIZE , false ) ; resized = true ; } else { set_timeout ( redraw , TO_REDRAW_RESIZE , false ) ; } } break ; case KeyPress : on_keypress ( & ev . xkey ) ; break ; case MotionNotify : if ( mode == MODE_IMAGE ) { win_set_cursor ( & win , CURSOR_ARROW ) ; set_timeout ( reset_cursor , TO_CURSOR_HIDE , true ) ; } break ; } } } | <S2SV_ModStart> ATOM_WM_DELETE_WINDOW ] ) cmds [ g_quit ] . func ( 0 ) <S2SV_ModEnd> ; break ; |
3,895 | CWE-000 static int linux_console_probe ( struct device_d * dev ) { struct console_device * cdev ; struct linux_console_data * data = dev -> platform_data ; cdev = xzalloc ( sizeof ( struct console_device ) ) ; cdev -> dev = dev ; if ( data -> stdinfd >= 0 ) { cdev -> tstc = linux_console_tstc ; cdev -> getc = linux_console_getc ; } if ( data -> stdoutfd >= 0 ) cdev -> putc = linux_console_putc ; console_register ( cdev ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> cdev ) ; pr_info ( "%s:<S2SV_blank>registered<S2SV_blank>as<S2SV_blank>%s%d\\n" , dev -> name , cdev -> class_dev . name , cdev -> class_dev . id ) ; |
3,896 | CWE-000 void load_inputmap_table ( ) { parsetree_program_t * s = NULL ; const char * fullpath = assetfs_fullpath ( INPUTMAP_FILE ) ; logfile_message ( "inputmap:<S2SV_blank>loading<S2SV_blank>the<S2SV_blank>input<S2SV_blank>mappings..." ) ; <S2SV_StartBug> s = nanoparser_construct_tree ( fullpath ) ; <S2SV_EndBug> nanoparser_traverse_program ( s , traverse ) ; s = nanoparser_deconstruct_tree ( s ) ; } | <S2SV_ModStart> "inputmap:<S2SV_blank>loading<S2SV_blank>the<S2SV_blank>input<S2SV_blank>mappings..." ) ; hashtable_inputmapnode_t_add ( mappings , NULL_INPUTMAP , inputmapnode_create ( NULL_INPUTMAP ) ) ; |
3,897 | CWE-000 static int pixlet_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) { PixletContext * ctx = avctx -> priv_data ; int i , w , h , width , height , ret , version ; AVFrame * p = data ; ThreadFrame frame = { . f = data } ; uint32_t pktsize ; bytestream2_init ( & ctx -> gb , avpkt -> data , avpkt -> size ) ; pktsize = bytestream2_get_be32 ( & ctx -> gb ) ; if ( pktsize <= 44 || pktsize - 4 > bytestream2_get_bytes_left ( & ctx -> gb ) ) { av_log ( avctx , AV_LOG_ERROR , "Invalid<S2SV_blank>packet<S2SV_blank>size<S2SV_blank>%" PRIu32 "\\n" , pktsize ) ; return AVERROR_INVALIDDATA ; } version = bytestream2_get_le32 ( & ctx -> gb ) ; if ( version != 1 ) avpriv_request_sample ( avctx , "Version<S2SV_blank>%d" , version ) ; bytestream2_skip ( & ctx -> gb , 4 ) ; if ( bytestream2_get_be32 ( & ctx -> gb ) != 1 ) return AVERROR_INVALIDDATA ; bytestream2_skip ( & ctx -> gb , 4 ) ; width = bytestream2_get_be32 ( & ctx -> gb ) ; height = bytestream2_get_be32 ( & ctx -> gb ) ; <S2SV_StartBug> w = FFALIGN ( width , 1 << ( NB_LEVELS + 1 ) ) ; <S2SV_EndBug> h = FFALIGN ( height , 1 << ( NB_LEVELS + 1 ) ) ; ctx -> levels = bytestream2_get_be32 ( & ctx -> gb ) ; if ( ctx -> levels != NB_LEVELS ) return AVERROR_INVALIDDATA ; ctx -> depth = bytestream2_get_be32 ( & ctx -> gb ) ; if ( ctx -> depth < 8 || ctx -> depth > 15 ) { avpriv_request_sample ( avctx , "Depth<S2SV_blank>%d" , ctx -> depth ) ; return AVERROR_INVALIDDATA ; } ret = ff_set_dimensions ( avctx , w , h ) ; if ( ret < 0 ) return ret ; avctx -> width = width ; avctx -> height = height ; if ( ctx -> w != w || ctx -> h != h ) { free_buffers ( avctx ) ; ctx -> w = w ; ctx -> h = h ; ret = init_decoder ( avctx ) ; if ( ret < 0 ) { free_buffers ( avctx ) ; ctx -> w = 0 ; ctx -> h = 0 ; return ret ; } } bytestream2_skip ( & ctx -> gb , 8 ) ; p -> pict_type = AV_PICTURE_TYPE_I ; p -> key_frame = 1 ; p -> color_range = AVCOL_RANGE_JPEG ; ret = ff_thread_get_buffer ( avctx , & frame , 0 ) ; if ( ret < 0 ) return ret ; for ( i = 0 ; i < 3 ; i ++ ) { ret = decode_plane ( avctx , i , avpkt , frame . f ) ; if ( ret < 0 ) return ret ; if ( avctx -> flags & AV_CODEC_FLAG_GRAY ) break ; } postprocess_luma ( frame . f , ctx -> w , ctx -> h , ctx -> depth ) ; postprocess_chroma ( frame . f , ctx -> w >> 1 , ctx -> h >> 1 , ctx -> depth ) ; * got_frame = 1 ; return pktsize ; } | <S2SV_ModStart> gb ) ; if ( width > INT_MAX - ( 1U << ( NB_LEVELS + 1 ) ) || height > INT_MAX - ( 1U << ( NB_LEVELS + 1 ) ) ) return AVERROR_INVALIDDATA ; |
3,898 | CWE-000 static void endTiming ( struct timeval * tvStart , struct runstats * stats ) { long sec , usec ; unsigned long runtime ; struct timeval tvEnd ; gettimeofday ( & tvEnd , NULL ) ; if ( tvStart -> tv_usec > tvEnd . tv_usec ) { tvEnd . tv_sec -- ; tvEnd . tv_usec += 1000000 ; } sec = tvEnd . tv_sec - tvStart -> tv_sec ; usec = tvEnd . tv_usec - tvStart -> tv_usec ; runtime = sec * 1000 + ( usec / 1000 ) ; stats -> totalRuntime += runtime ; if ( runtime < stats -> minRuntime ) stats -> minRuntime = runtime ; if ( runtime > stats -> maxRuntime ) stats -> maxRuntime = runtime ; if ( ! bSilent || bStatsRecords ) { if ( bCSVoutput ) { <S2SV_StartBug> printf ( "%ld.%3.3ld\\n" , runtime / 1000 , runtime % 1000 ) ; <S2SV_EndBug> } else { <S2SV_StartBug> printf ( "runtime:<S2SV_blank>%ld.%3.3ld\\n" , runtime / 1000 , runtime % 1000 ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> { printf ( "%lu.%3.3ld\\n" <S2SV_ModEnd> , runtime / <S2SV_ModStart> { printf ( "runtime:<S2SV_blank>%lu.%3.3ld\\n" <S2SV_ModEnd> , runtime / |
3,899 | CWE-000 static void aica_channel_reg_write ( struct aica * aica , uint32_t addr , uint32_t data , uint32_t data_mask ) { int n = addr >> 7 ; addr &= 0x7f ; struct aica_channel * ch = & aica -> channels [ n ] ; <S2SV_StartBug> WRITE_DATA ( ( uint8_t * ) ch -> data + addr ) ; <S2SV_EndBug> switch ( addr ) { case 0x0 : case 0x1 : case 0x4 : <S2SV_StartBug> aica_channel_update_key_state ( aica , ch ) ; <S2SV_EndBug> break ; } } | <S2SV_ModStart> n ] ; LOG_AICA ( "aica_channel_reg_write<S2SV_blank>[%d]<S2SV_blank>0x%x<S2SV_blank>:<S2SV_blank>0x%x" , ch -> id , addr , data ) ; <S2SV_ModStart> case 0x4 : case 0x5 : |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.