Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,100 | CWE-000 static int rmw_output ( int new_out , int mask ) { <S2SV_StartBug> gpio_out = gpio_out & ! mask ; <S2SV_EndBug> <S2SV_StartBug> gpio_out = gpio_out & new_out ; <S2SV_EndBug> <S2SV_StartBug> printf ( "%04x\\n" , gpio_out ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> mask ) { printf ( "GPIO_OUT:<S2SV_blank>%04x\\n" , gpio_out ) ; printf ( "NEW:<S2SV_blank>%04x\\n" , new_out ) ; printf ( "MASK:<S2SV_blank>%04x\\n" , mask ) <S2SV_ModEnd> ; gpio_out = <S2SV_ModStart> = gpio_out & ~ mask ; printf ( "OUT1:<S2SV_blank>%04x\\n" , gpio_out ) ; gpio_out = gpio_out | <S2SV_ModStart> ; printf ( "OUT2:<S2SV_blank>%04x\\n" <S2SV_ModEnd> , gpio_out ) |
4,101 | CWE-000 void tgl_do_phone_call ( struct tgl_state * TLS , const char * user , const char * hash , void ( * callback ) ( struct tgl_state * TLS , void * callback_extra , int success ) , void * callback_extra ) { vlogprintf ( E_DEBUG , "calling<S2SV_blank>user\\n" ) ; clear_packet ( ) ; <S2SV_StartBug> tgl_do_insert_header ( ) ; <S2SV_EndBug> out_int ( CODE_auth_send_call ) ; out_string ( user ) ; out_string ( hash ) ; tglq_send_query ( TLS , TLS -> DC_working , packet_ptr - packet_buffer , packet_buffer , & phone_call_methods , 0 , callback , callback_extra ) ; } | <S2SV_ModStart> ; tgl_do_insert_header ( TLS |
4,102 | CWE-000 static int ccache_builder_connectdb ( void ) { int i , j , ev ; uint32 generation ; char dbname [ NAMEDATALEN ] ; bool startup_log = false ; for ( ; ; ) { ResetLatch ( MyLatch ) ; if ( ccache_builder_got_sigterm ) elog ( ERROR , "terminating<S2SV_blank>ccache-builder%d" , ccache_builder -> builder_id ) ; SpinLockAcquire ( & ccache_state -> lock ) ; for ( i = 0 ; i < ccache_state -> num_databases ; i ++ ) { if ( ! ccache_state -> databases [ i ] . invalid_database ) break ; } if ( i < ccache_state -> num_databases ) { j = ( ccache_state -> rr_count ++ % ccache_state -> num_databases ) ; if ( ccache_state -> databases [ j ] . invalid_database ) { SpinLockRelease ( & ccache_state -> lock ) ; continue ; } generation = pg_atomic_read_u32 ( & ccache_state -> generation ) ; ccache_builder_generation = generation ; ccache_database = & ccache_state -> databases [ j ] ; strncpy ( dbname , ccache_database -> dbname , NAMEDATALEN ) ; SpinLockRelease ( & ccache_state -> lock ) ; break ; } else { SpinLockRelease ( & ccache_state -> lock ) ; if ( ! startup_log ) { elog ( LOG , "ccache-builder%d:<S2SV_blank>not<S2SV_blank>assigned<S2SV_blank>to<S2SV_blank>a<S2SV_blank>particular<S2SV_blank>database" , ccache_builder -> builder_id ) ; startup_log = true ; } ev = WaitLatch ( MyLatch , WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH , <S2SV_StartBug> 60000L ) ; <S2SV_EndBug> if ( ev & WL_POSTMASTER_DEATH ) elog ( FATAL , "Unexpected<S2SV_blank>postmaster<S2SV_blank>dead" ) ; } } PG_ENSURE_ERROR_CLEANUP ( ccache_builder_fail_on_connectdb , 0L ) ; { BackgroundWorkerInitializeConnection ( dbname , NULL ) ; } PG_END_ENSURE_ERROR_CLEANUP ( ccache_builder_fail_on_connectdb , 0L ) ; elog ( LOG , "ccache-builder%d<S2SV_blank>(gen=%u)<S2SV_blank>now<S2SV_blank>ready<S2SV_blank>on<S2SV_blank>database<S2SV_blank>\\"%s\\"" , ccache_builder -> builder_id , generation , dbname ) ; SpinLockAcquire ( & ccache_state -> lock ) ; ccache_builder -> database_oid = MyDatabaseId ; ccache_builder -> state = CCBUILDER_STATE__PRELOAD ; SpinLockRelease ( & ccache_state -> lock ) ; return CCBUILDER_STATE__PRELOAD ; } | <S2SV_ModStart> WL_POSTMASTER_DEATH , 60000L # if PG_VERSION_NUM >= 100000 , PG_WAIT_EXTENSION # endif |
4,103 | CWE-000 static int hash_accept_nokey ( struct socket * sock , struct socket * newsock , <S2SV_StartBug> int flags ) <S2SV_EndBug> { int err ; err = hash_check_key ( sock ) ; if ( err ) return err ; <S2SV_StartBug> return hash_accept ( sock , newsock , flags ) ; <S2SV_EndBug> } | <S2SV_ModStart> , int flags , bool kern <S2SV_ModStart> newsock , flags , kern |
4,104 | CWE-000 int entry ( uint32 magic , void * boot_header , void * boot_info ) { printf_vga_clear ( ) ; <S2SV_StartBug> printf_vga_tk ( "Hello,<S2SV_blank>The<S2SV_blank>World<S2SV_blank>of<S2SV_blank>OS.\\n" ) ; <S2SV_EndBug> multiboot_env_detect ( magic , boot_header , boot_info ) ; descriptor_table_gdt_initialize ( ) ; descriptor_table_idt_initialize ( ) ; irq_0_timer_initialize ( 1000 ) ; page_initialize ( ) ; kernel_heap_initialize ( ) ; test_main ( ) ; printf_vga_tk ( "Reach<S2SV_blank>end<S2SV_blank>of<S2SV_blank>entry,<S2SV_blank>will<S2SV_blank>idle.\\n" ) ; return 0x0 ; } | <S2SV_ModStart> ; printf_vga_tk ( "Hello<S2SV_blank>World<S2SV_blank>of<S2SV_blank>OS<S2SV_blank>Development.\\n" <S2SV_ModEnd> ) ; multiboot_env_detect |
4,105 | CWE-000 static int lzw_process_code ( deark * c , lctx * d , struct gif_image_data * gi , struct lzwdeccontext * lz , unsigned int code ) { <S2SV_StartBug> if ( code == lz -> eoi_code ) { <S2SV_EndBug> lz -> eoi_flag = 1 ; return 1 ; } if ( code == lz -> clear_code ) { lzw_clear ( lz ) ; return 1 ; } lz -> ncodes_since_clear ++ ; if ( lz -> ncodes_since_clear == 1 ) { lzw_emit_code ( c , d , gi , lz , code ) ; lz -> oldcode = code ; return 1 ; } if ( code < lz -> ct_used ) { lzw_emit_code ( c , d , gi , lz , code ) ; <S2SV_StartBug> lzw_add_to_dict ( lz , lz -> oldcode , lz -> ct [ code ] . firstchar ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> else { if ( lz -> oldcode >= lz -> ct_used ) { de_err ( c , "GIF<S2SV_blank>decoding<S2SV_blank>error\\n" ) ; return 0 ; } <S2SV_StartBug> if ( lzw_add_to_dict ( lz , lz -> oldcode , lz -> ct [ lz -> oldcode ] . firstchar ) ) { <S2SV_EndBug> lzw_emit_code ( c , d , gi , lz , lz -> last_code_added ) ; } } lz -> oldcode = code ; return 1 ; } | <S2SV_ModStart> code ) { int ret ; <S2SV_ModStart> code ) ; ret = lzw_add_to_dict ( c , <S2SV_ModEnd> lz , lz <S2SV_ModStart> firstchar ) ; if ( ret == 0 ) return 0 ; <S2SV_ModStart> 0 ; } ret = lzw_add_to_dict ( c , <S2SV_ModEnd> lz , lz <S2SV_ModStart> . firstchar ) ; if ( ret == 0 ) return 0 ; if ( ret == 1 |
4,106 | CWE-000 <S2SV_StartBug> static int render_samples_32bit ( double * raw , void * rendered , int count ) { <S2SV_EndBug> float * out_samples ; <S2SV_StartBug> int i ; <S2SV_EndBug> out_samples = ( float * ) rendered ; for ( i = 0 ; i < count ; i ++ ) * ( out_samples + i ) = ( float ) * ( raw + i ) ; return 0 ; } | <S2SV_ModStart> * rendered , unsigned <S2SV_ModStart> * out_samples ; unsigned |
4,107 | CWE-000 gboolean ostree_pull ( GFile * repo , const gchar * remote_name , const gchar * ref , CmdResult * cmd , GError * * error ) { <S2SV_StartBug> gchar * args [ ] = <S2SV_EndBug> { "pull" , <S2SV_StartBug> ( gchar * ) remote_name , <S2SV_EndBug> ( gchar * ) ref , NULL } ; return spawn_ostree_in_repo ( repo , args , cmd , error ) ; } | <S2SV_ModStart> error ) { const <S2SV_ModStart> { "pull" , remote_name , <S2SV_ModEnd> ref , NULL |
4,108 | CWE-000 static void CreateNormalArray ( int * grad , int * face , int * normal , int * nfaces , int maxfaces , int Nc ) { int n , nf ; for ( n = 0 ; n < Nc ; n ++ ) { for ( nf = 0 ; nf < nfaces [ n ] ; nf ++ ) { <S2SV_StartBug> if ( n == grad [ 2 * face [ maxfaces * n + nf ] ] ) <S2SV_EndBug> normal [ n * maxfaces + nf ] = - 1 ; else normal [ n * maxfaces + nf ] = 1 ; } } } | <S2SV_ModStart> ++ ) { assert ( face [ maxfaces * n + nf ] >= 0 ) ; |
4,109 | CWE-000 label_t * firstPass ( char * assemblyFile , label_t * labels ) { char assemblyLine [ MAX_LENGTH ] ; char * assemblyToken ; int locationCounter = 0 ; int tokenLength = 0 ; int containsEndCommand = FALSE ; FILE * fptr ; if ( ( fptr = fopen ( assemblyFile , "r" ) ) == NULL ) { printf ( "Error!<S2SV_blank>opening<S2SV_blank>file" ) ; exit ( 1 ) ; } while ( fgets ( assemblyLine , MAX_LENGTH , fptr ) ) { assemblyToken = strtok ( assemblyLine , "<S2SV_blank>,\\t" ) ; <S2SV_StartBug> if ( ( strcmp ( assemblyToken , "\\n" ) == 0 ) || ( strcmp ( assemblyToken , ".word" ) == 0 ) ) <S2SV_EndBug> <S2SV_StartBug> continue ; <S2SV_EndBug> else if ( assemblyToken == NULL ) break ; else if ( assemblyToken [ 0 ] != '#' ) { tokenLength = strlen ( assemblyToken ) ; if ( ( assemblyToken [ tokenLength - 1 ] == ':' ) || ( assemblyToken [ tokenLength - 2 ] == ':' ) ) { labels = addLable ( labels , assemblyToken , tokenLength , locationCounter ) ; if ( isLabelLineEmpty ( assemblyToken ) ) continue ; } else if ( strcmp ( assemblyToken , "halt" ) == 0 ) { containsEndCommand = TRUE ; } locationCounter ++ ; } } fclose ( fptr ) ; if ( ! containsEndCommand ) { printf ( "ERROR:<S2SV_blank>halt<S2SV_blank>command<S2SV_blank>is<S2SV_blank>missing<S2SV_blank>from<S2SV_blank>code." ) ; exit ( 1 ) ; } return labels ; } | <S2SV_ModStart> ; if ( assemblyToken == NULL ) break ; else if ( <S2SV_ModStart> ) ) continue <S2SV_ModEnd> ; else if |
4,110 | CWE-000 void vars ( node_t * root , token_t * * tklist ) { const char * FUNC = "vars" ; token_t * tmp = ( token_t * ) malloc ( sizeof ( token_t ) ) ; int lvl = level ; if ( strcmp ( tk -> id , "varTK" ) == 0 ) { <S2SV_StartBug> insert ( root , tk , ++ level ) ; <S2SV_EndBug> tk = ( token_t * ) pop ( ( void * * ) tklist ) ; } else return ; if ( strcmp ( tk -> id , "idTK" ) == 0 ) { insert ( root , tk , level ) ; tk = ( token_t * ) pop ( ( void * * ) tklist ) ; } else { printerror ( FUNC ) ; return ; } if ( strcmp ( tk -> id , "=TK" ) == 0 ) { insert ( root , tk , level ) ; tk = ( token_t * ) pop ( ( void * * ) tklist ) ; } else if ( strcmp ( tk -> id , ".TK" ) == 0 ) { insert ( root , tk , level ) ; tk = ( token_t * ) pop ( ( void * * ) tklist ) ; return ; } else { printerror ( FUNC ) ; return ; } lvl = level ; if ( strcmp ( tk -> id , "(TK" ) == 0 || strcmp ( tk -> id , "idTK" ) == 0 || strcmp ( tk -> id , "intTK" ) == 0 || strcmp ( tk -> id , "%TK" ) == 0 ) { tmp = customtoken ( "<>" , "<expr>" , 0 ) ; lvl = level ; root = insert ( root , tmp , level ++ ) ; expr ( root -> children [ root -> num_children - 1 ] , tklist ) ; level = lvl ; } else { printerror ( FUNC ) ; return ; } level = lvl ; if ( strcmp ( tk -> id , ".TK" ) == 0 || strcmp ( tk -> id , ":TK" ) == 0 ) { tmp = customtoken ( "<>" , "<mvars>" , 0 ) ; lvl = level ; root = insert ( root , tmp , level ++ ) ; mvars ( root -> children [ root -> num_children - 1 ] , tklist ) ; level = lvl ; } return ; } | <S2SV_ModStart> , tk , <S2SV_ModEnd> level ) ; |
4,111 | CWE-000 unsigned my_strlen ( const char * p ) { <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> while ( p [ i ++ ] != '\\0' ) ; return i ; } | <S2SV_ModStart> p ) { unsigned <S2SV_ModEnd> i = 0 |
4,112 | CWE-000 static void day_initialise ( struct day * this , int numSteps , char * description , int steps [ ] ) { this -> numSteps = numSteps ; this -> steps = malloc ( sizeof ( struct day ) * numSteps ) ; this -> description = description ; for ( int i = 0 ; i < numSteps ; i ++ ) { this -> steps [ i ] = ( struct step ) { . duration = steps [ i ] , . isWalk = i % 2 == 1 } ; } this -> dayIndex = dayIndex ; <S2SV_StartBug> this -> title = malloc ( SIZE_OF_WEEK_STRING ) ; <S2SV_EndBug> <S2SV_StartBug> this -> subtitle = malloc ( SIZE_OF_DAY_STRING ) ; <S2SV_EndBug> <S2SV_StartBug> snprintf ( this -> title , SIZE_OF_WEEK_STRING , "Week<S2SV_blank>%d" , ( dayIndex / NUM_OF_DAYS_PER_WEEK ) + 1 ) ; <S2SV_EndBug> <S2SV_StartBug> snprintf ( this -> subtitle , SIZE_OF_DAY_STRING , "Day<S2SV_blank>%d" , ( dayIndex % NUM_OF_DAYS_PER_WEEK ) + 1 ) ; <S2SV_EndBug> dayIndex ++ ; } | <S2SV_ModStart> = malloc ( strlen ( _ ( "Week<S2SV_blank>%d" ) ) <S2SV_ModEnd> ) ; this <S2SV_ModStart> = malloc ( strlen ( _ ( "Day<S2SV_blank>%d" ) ) <S2SV_ModEnd> ) ; snprintf <S2SV_ModStart> , SIZE_OF_WEEK_STRING , _ ( "Week<S2SV_blank>%d" ) <S2SV_ModEnd> , ( dayIndex <S2SV_ModStart> , SIZE_OF_DAY_STRING , _ ( "Day<S2SV_blank>%d" ) <S2SV_ModEnd> , ( dayIndex |
4,113 | CWE-000 celix_status_t pubsub_udpmcAdmin_matchPublisher ( void * handle , long svcRequesterBndId , const celix_filter_t * svcFilter , double * outScore , long * outSerializerSvcId ) { pubsub_udpmc_admin_t * psa = handle ; <S2SV_StartBug> LOG_DEBUG ( "[PSA_UDPMC]<S2SV_blank>pubsub_udpmcAdmin_matchPublisher" ) ; <S2SV_EndBug> celix_status_t status = CELIX_SUCCESS ; double score = pubsub_utils_matchPublisher ( psa -> ctx , svcRequesterBndId , svcFilter -> filterStr , PUBSUB_UDPMC_ADMIN_TYPE , psa -> qosSampleScore , psa -> qosControlScore , psa -> defaultScore , outSerializerSvcId ) ; * outScore = score ; return status ; } | <S2SV_ModStart> = handle ; L_DEBUG <S2SV_ModEnd> ( "[PSA_UDPMC]<S2SV_blank>pubsub_udpmcAdmin_matchPublisher" ) |
4,114 | CWE-000 void section_add ( t_section sections [ N_SECTION ] , struct segment_command_64 * seg ) { char type ; <S2SV_StartBug> uint32_t i ; <S2SV_EndBug> uint32_t j ; <S2SV_StartBug> struct section_64 * sec ; <S2SV_EndBug> i = 0 ; j = sections [ 0 ] . type ? 0 : 1 ; j += sections [ 1 ] . type ? 1 : 0 ; sec = ( void * ) ( seg + 1 ) ; <S2SV_StartBug> while ( i < seg -> nsects && j < N_SECTION ) <S2SV_EndBug> { if ( ( type = get_section_type ( sec -> sectname ) ) ) { sections [ j ++ ] = ( t_section ) { . index = i + 1 , . type = type } ; } sec += 1 ; ++ i ; } } | <S2SV_ModStart> char type ; struct section_64 * sec <S2SV_ModEnd> ; uint32_t j <S2SV_ModStart> uint32_t j ; uint32_t k ; static uint32_t <S2SV_ModEnd> i = 0 <S2SV_ModStart> 1 ) ; k = - 1 ; while ( ++ k <S2SV_ModEnd> < seg -> |
4,115 | CWE-000 int main ( void ) <S2SV_StartBug> { <S2SV_EndBug> fsr_init ( fsr_buffer ) ; multiplexer_init ( ) ; adc_init ( adc_evt_handler , adc_buffer ) ; while ( true ) { <S2SV_StartBug> state_machine ( ) ; <S2SV_EndBug> } } | <S2SV_ModStart> void ) { log_init ( ) ; <S2SV_ModStart> true ) { if ( adc_done_flag ) { state_machine ( & adc_done_flag ) ; } __WFE ( ) ; __SEV ( ) ; __WFE <S2SV_ModEnd> ( ) ; |
4,116 | CWE-000 void sys_alsa_close_midi ( ) { alsa_nmidiin = alsa_nmidiout = 0 ; if ( midi_handle ) { snd_seq_close ( midi_handle ) ; <S2SV_StartBug> if ( midiev ) <S2SV_EndBug> { snd_midi_event_free ( midiev ) ; <S2SV_StartBug> } <S2SV_EndBug> } } | <S2SV_ModStart> midi_handle ) ; midi_handle = NULL ; <S2SV_ModStart> midiev ) ; midiev = NULL ; |
4,117 | CWE-000 static void thread_ctor ( int rank , int nthreads , void * data , void * info ) { thread_queue_t * thr = ( thread_queue_t * ) data ; Pthread_mutex_init ( & thr -> L , NULL ) ; thr -> deque = malloc ( sizeof ( struct Task * ) * INIT_STACK ) ; thr -> T = thr -> H = thr -> E = thr -> deque ; thr -> deque_size = INIT_STACK ; thr -> rank = rank ; thr -> global = ( struct GlobalInfo * ) info ; if ( rank == 0 ) { thr -> global -> threads = thr ; } { int avail = thr -> global -> initial -> avail ; int mine = avail / nthreads + ( rank < ( avail % nthreads ) ) ; int start = ( avail / nthreads ) * rank + MIN ( avail % nthreads , rank ) ; progress ( "%d:<S2SV_blank>Initial<S2SV_blank>start<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>mine<S2SV_blank>=<S2SV_blank>%d\\n" , thr -> rank , start , mine ) ; for ( int i = 0 ; i < mine ; i ++ ) { <S2SV_StartBug> push ( thr , thr -> global -> initial -> task [ i + start ] ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> ++ ) { task_t * task = <S2SV_ModEnd> thr -> global <S2SV_ModStart> + start ] ; enable_task ( thr , task |
4,118 | CWE-000 static void fastrpc_mmap_free ( struct fastrpc_mmap * map ) { struct fastrpc_apps * me = & gfa ; <S2SV_StartBug> struct fastrpc_file * fl ; <S2SV_EndBug> int vmid ; if ( ! map ) return ; fl = map -> fl ; if ( map -> flags == ADSP_MMAP_HEAP_ADDR ) { spin_lock ( & me -> hlock ) ; map -> refs -- ; if ( ! map -> refs ) hlist_del_init ( & map -> hn ) ; spin_unlock ( & me -> hlock ) ; } else { spin_lock ( & fl -> hlock ) ; map -> refs -- ; if ( ! map -> refs ) hlist_del_init ( & map -> hn ) ; spin_unlock ( & fl -> hlock ) ; } if ( map -> refs > 0 ) return ; if ( map -> flags == ADSP_MMAP_HEAP_ADDR ) { DEFINE_DMA_ATTRS ( attrs ) ; if ( me -> dev == NULL ) { pr_err ( "failed<S2SV_blank>to<S2SV_blank>free<S2SV_blank>remote<S2SV_blank>heap<S2SV_blank>allocation\\n" ) ; return ; } if ( map -> phys ) { dma_set_attr ( DMA_ATTR_SKIP_ZEROING , & attrs ) ; dma_set_attr ( DMA_ATTR_NO_KERNEL_MAPPING , & attrs ) ; dma_free_attrs ( me -> dev , map -> size , & ( map -> va ) , map -> phys , & attrs ) ; } } else { int destVM [ 1 ] = { VMID_HLOS } ; int destVMperm [ 1 ] = { PERM_READ | PERM_WRITE | PERM_EXEC } ; if ( ! IS_ERR_OR_NULL ( map -> handle ) ) ion_free ( fl -> apps -> client , map -> handle ) ; if ( fl -> sctx -> smmu . enabled ) { if ( map -> size || map -> phys ) msm_dma_unmap_sg ( fl -> sctx -> dev , map -> table -> sgl , map -> table -> nents , DMA_BIDIRECTIONAL , map -> buf ) ; } vmid = fl -> apps -> channel [ fl -> cid ] . vmid ; if ( vmid && map -> phys ) { int srcVM [ 2 ] = { VMID_HLOS , vmid } ; hyp_assign_phys ( map -> phys , buf_page_size ( map -> size ) , srcVM , 2 , destVM , destVMperm , 1 ) ; } if ( ! IS_ERR_OR_NULL ( map -> table ) ) dma_buf_unmap_attachment ( map -> attach , map -> table , DMA_BIDIRECTIONAL ) ; if ( ! IS_ERR_OR_NULL ( map -> attach ) ) dma_buf_detach ( map -> buf , map -> attach ) ; if ( ! IS_ERR_OR_NULL ( map -> buf ) ) dma_buf_put ( map -> buf ) ; } kfree ( map ) ; } | <S2SV_ModStart> fastrpc_file * fl = NULL |
4,119 | CWE-000 int update_mapping_column_table ( const char * schema_name , const char * table_name , const char * column_name , const char * remark , bool operation ) { char sql [ QBUFFLEN ] ; int i = 0 ; int ret = 0 ; SPI_connect ( ) ; if ( operation ) snprintf ( sql , QBUFFLEN - 1 , INSERT_COLUMN_MAP_TABLE , remark , schema_name , table_name , column_name ) ; else <S2SV_StartBug> snprintf ( sql , QBUFFLEN - 1 , DELETE_MAP_TABLE , schema_name , table_name ) ; <S2SV_EndBug> ret = SPI_exec ( sql , 1 ) ; if ( ret != SPI_OK_DELETE && ret != SPI_OK_INSERT ) { for ( i = 0 ; i < 10 ; i ++ ) ret = ESPI ; } if ( SPI_processed < 1 ) { ret = ENEXIST ; } SPI_finish ( ) ; return ret ; } | <S2SV_ModStart> - 1 , DELETE_COLUMN_MAP_TABLE <S2SV_ModEnd> , schema_name , <S2SV_ModStart> schema_name , table_name , column_name |
4,120 | CWE-000 void test_api_conversation ( void ) { OTR4_INIT ; otrv4_keypair_t alice_keypair [ 1 ] , bob_keypair [ 1 ] ; uint8_t alice_sym [ ED448_PRIVATE_BYTES ] = { 1 } ; otrv4_keypair_generate ( alice_keypair , alice_sym ) ; uint8_t bob_sym [ ED448_PRIVATE_BYTES ] = { 2 } ; otrv4_keypair_generate ( bob_keypair , bob_sym ) ; otrv4_policy_t policy = { . allows = OTRV4_ALLOW_V3 | OTRV4_ALLOW_V4 } ; otrv4_t * alice = otrv4_new ( alice_keypair , policy ) ; <S2SV_StartBug> otrv4_t * bob = otrv4_new ( bob_keypair , policy ) ; <S2SV_EndBug> do_ake_fixture ( alice , bob ) ; int message_id ; otrv4_response_t * response_to_bob = NULL ; otrv4_response_t * response_to_alice = NULL ; string_t to_send = NULL ; for ( message_id = 2 ; message_id < 5 ; message_id ++ ) { otrv4_assert ( otrv4_send_message ( & to_send , "hi" , NULL , alice ) ) ; otrv4_assert ( to_send ) ; otrv4_assert_cmpmem ( "?OTR:AAQD" , to_send , 9 ) ; <S2SV_StartBug> g_assert_cmpint ( alice -> keys -> i , == , 0 ) ; <S2SV_EndBug> g_assert_cmpint ( alice -> keys -> j , == , message_id ) ; response_to_alice = otrv4_response_new ( ) ; otrv4_assert ( otrv4_receive_message <S2SV_StartBug> ( response_to_alice , to_send , bob ) ) ; <S2SV_EndBug> free ( to_send ) ; to_send = NULL ; otrv4_assert_cmpmem ( "hi" , response_to_alice -> to_display , 3 ) ; g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , message_id - 1 ) ; otrv4_assert ( response_to_alice -> to_send == NULL ) ; otrv4_response_free ( response_to_alice ) ; response_to_alice = NULL ; g_assert_cmpint ( bob -> keys -> i , == , 0 ) ; g_assert_cmpint ( bob -> keys -> j , == , 0 ) ; } for ( message_id = 1 ; message_id < 4 ; message_id ++ ) { otrv4_assert ( otrv4_send_message ( & to_send , "hello" , NULL , bob ) ) ; otrv4_assert ( to_send ) ; otrv4_assert_cmpmem ( "?OTR:AAQD" , to_send , 9 ) ; g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , 0 ) ; g_assert_cmpint ( bob -> keys -> i , == , 1 ) ; g_assert_cmpint ( bob -> keys -> j , == , message_id ) ; response_to_bob = otrv4_response_new ( ) ; otrv4_assert ( otrv4_receive_message ( response_to_bob , ( string_t ) to_send , alice ) ) ; g_assert_cmpint ( list_len ( alice -> keys -> old_mac_keys ) , == , message_id ) ; free ( to_send ) ; to_send = NULL ; otrv4_assert_cmpmem ( "hello" , response_to_bob -> to_display , 6 ) ; otrv4_assert ( response_to_bob -> to_send == NULL ) ; otrv4_response_free ( response_to_bob ) ; response_to_bob = NULL ; g_assert_cmpint ( alice -> keys -> i , == , 1 ) ; g_assert_cmpint ( alice -> keys -> j , == , 0 ) ; } tlv_t * tlvs = otrv4_padding_tlv_new ( 10 ) ; otrv4_assert ( tlvs ) ; otrv4_assert ( otrv4_send_message ( & to_send , "hi" , tlvs , bob ) ) ; otrv4_assert ( to_send ) ; otrv4_assert_cmpmem ( "?OTR:AAQD" , to_send , 9 ) ; <S2SV_StartBug> otrv4_tlv_free ( tlvs ) ; <S2SV_EndBug> response_to_bob = otrv4_response_new ( ) ; otrv4_assert ( otrv4_receive_message <S2SV_StartBug> ( response_to_bob , ( string_t ) to_send , alice ) ) ; <S2SV_EndBug> free ( to_send ) ; to_send = NULL ; otrv4_assert ( response_to_bob -> tlvs ) ; g_assert_cmpint ( response_to_bob -> tlvs -> type , == , OTRV4_TLV_PADDING ) ; g_assert_cmpint ( response_to_bob -> tlvs -> len , == , 10 ) ; otrv4_response_free ( response_to_bob ) ; response_to_bob = NULL ; otrv4_free ( alice ) ; otrv4_free ( bob ) ; otrv4_keypair_destroy ( alice_keypair ) ; otrv4_keypair_destroy ( bob_keypair ) ; OTR4_FREE ; } | <S2SV_ModStart> policy ) ; otrv4_assert ( ! alice -> keys -> old_mac_keys ) ; <S2SV_ModStart> bob_keypair , policy ) ; otrv4_assert ( ! bob -> keys -> old_mac_keys <S2SV_ModStart> 9 ) ; otrv4_assert ( ! alice -> keys -> old_mac_keys ) ; <S2SV_ModStart> , bob ) ) ; otrv4_assert ( bob -> keys -> old_mac_keys <S2SV_ModStart> 9 ) ; g_assert_cmpint ( list_len ( bob -> keys -> old_mac_keys ) , == , 0 ) ; <S2SV_ModStart> , alice ) ) ; g_assert_cmpint ( list_len ( alice -> keys -> old_mac_keys ) , == , 4 |
4,121 | CWE-000 JSObject ForkObjectConstructor ( JSContext ctx , JSObject constructor , size_t argc , const JSValue argv [ ] , JSValue * exception ) { JSObject self = JSObjectMake ( ctx , JSForkClass , NULL ) ; JSObject scope = JSValueToObject ( ctx , argv [ 0 ] , NULL ) ; JSObject func = JSValueToObject ( ctx , argv [ 1 ] , NULL ) ; JSValue args [ argc - 2 ] ; for ( int i = 2 ; i < argc ; i ++ ) args [ i - 2 ] = argv [ i ] ; int c = fork ( ) ; if ( c == 0 ) { <S2SV_StartBug> JSValue exn ; <S2SV_EndBug> JSObjectCallAsFunction ( ctx , func , scope , argc - 2 , args , & exn ) ; if ( exn ) JSReportException ( ctx , "fork" , exn ) ; exit ( ( exn != 0 ) ? 1 : 0 ) ; } else { JSObjectSetUtf8Property ( ctx , self , "pid" , JSValueFromNumber ( ctx , c ) , kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly ) ; } return self ; } | <S2SV_ModStart> { JSValue exn = 0 |
4,122 | CWE-000 json_object * getCleanConfig ( char * filename ) { FILE * fd ; char buffer [ 102400 ] = { 0 } ; char * pline = NULL ; ssize_t read ; fd = fopen ( filename , "r" ) ; if ( ! fd ) { printf ( "ERROR:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>file<S2SV_blank>%s\\n" , filename ) ; return NULL ; } while ( ( read = getline ( & pline , & read , fd ) ) != - 1 ) { if ( isCommentLine ( pline ) ) { continue ; } else { strcat ( buffer , pline ) ; strcat ( buffer , "\\n" ) ; } } free ( pline ) ; fclose ( fd ) ; json_object * json = NULL ; json = json_tokener_parse ( buffer ) ; if ( json ) { } else { <S2SV_StartBug> printf ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>response\\n" ) ; <S2SV_EndBug> } return json ; } | <S2SV_ModStart> { printf ( "Failed<S2SV_blank>to<S2SV_blank>parse<S2SV_blank>config\\n" ) ; return NULL <S2SV_ModEnd> ; } return |
4,123 | CWE-000 int malzmq_ctx_send_message ( void * self , mal_endpoint_t * mal_endpoint , mal_message_t * mal_message ) { malzmq_ctx_t * malzmq_ctx = ( malzmq_ctx_t * ) self ; mal_interactiontype_t interaction = mal_message_get_interaction_type ( mal_message ) ; mal_uoctet_t stage = mal_message_get_interaction_stage ( mal_message ) ; if ( ( interaction == MAL_INTERACTIONTYPE_PUBSUB ) && malzmq_header_is_internal_broker ( malzmq_ctx -> malzmq_header ) ) { if ( stage == MAL_IP_STAGE_PUBSUB_PUBLISH_REGISTER ) { return trap_publish_register ( mal_endpoint , mal_message , MAL_IP_STAGE_PUBSUB_PUBLISH_REGISTER_ACK ) ; } else if ( stage == MAL_IP_STAGE_PUBSUB_PUBLISH_DEREGISTER ) { return trap_publish_register ( mal_endpoint , mal_message , MAL_IP_STAGE_PUBSUB_PUBLISH_DEREGISTER_ACK ) ; } } mal_uri_t * uri_to = mal_message_get_uri_to ( mal_message ) ; mal_uri_t * ptp_uri = get_remote_ptp_zmtp_uri ( malzmq_ctx , uri_to ) ; mal_uri_t * mcast_uri = NULL ; if ( ( interaction == MAL_INTERACTIONTYPE_PUBSUB ) && ( stage == MAL_IP_STAGE_PUBSUB_PUBLISH ) ) { mcast_uri = get_remote_mcast_zmtp_uri ( malzmq_ctx , uri_to ) ; } clog_debug ( malzmq_logger , "malzmq_ctx_send_message:<S2SV_blank>socket_uri=%s,<S2SV_blank>%s\\n" , ptp_uri , mcast_uri ) ; if ( clog_is_loggable ( malzmq_logger , CLOG_INFO_LEVEL ) ) { clog_info ( malzmq_logger , "malzmq_ctx_send_message()\\n" ) ; mal_message_print ( mal_message ) ; clog_info ( malzmq_logger , "\\n" ) ; } int rc = 0 ; malzmq_endpoint_data_t * endpoint_data = ( malzmq_endpoint_data_t * ) mal_endpoint_get_endpoint_data ( mal_endpoint ) ; void * socket = NULL ; if ( mcast_uri != NULL ) { socket = zhash_lookup ( endpoint_data -> remote_socket_table , mcast_uri ) ; } else { socket = zhash_lookup ( endpoint_data -> remote_socket_table , ptp_uri ) ; } if ( socket == NULL ) { mal_uri_t * socket_uri = NULL ; if ( mcast_uri == NULL ) { socket_uri = ptp_uri ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>open<S2SV_blank>a<S2SV_blank>new<S2SV_blank>PTP<S2SV_blank>socket\\n" ) ; socket = zsocket_new ( malzmq_ctx -> zmq_ctx , ZMQ_DEALER ) ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>%s\\n" , socket_uri ) ; zmq_connect ( socket , socket_uri ) ; } else { socket_uri = mcast_uri ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>open<S2SV_blank>a<S2SV_blank>new<S2SV_blank>PUBSUB<S2SV_blank>socket\\n" ) ; socket = zsocket_new ( malzmq_ctx -> zmq_ctx , ZMQ_PUB ) ; int val = 0 ; rc = zmq_setsockopt ( socket , ZMQ_LINGER , & val , sizeof ( val ) ) ; assert ( rc == 0 ) ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>%s\\n" , socket_uri ) ; zmq_connect ( socket , socket_uri ) ; zclock_sleep ( 500 ) ; } clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>update<S2SV_blank>table\\n" ) ; zhash_update ( endpoint_data -> remote_socket_table , socket_uri , socket ) ; } clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>mal_message_add_encoding_length_malbinary\\n" ) ; malbinary_cursor_t cursor ; malbinary_cursor_reset ( & cursor ) ; rc = malzmq_add_message_encoding_length ( malzmq_ctx -> malzmq_header , mal_message , malzmq_ctx -> encoder , & cursor ) ; if ( rc < 0 ) return rc ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>encoding_length=%d\\n" , malbinary_cursor_get_length ( & cursor ) ) ; malbinary_cursor_init ( & cursor , ( char * ) malloc ( malbinary_cursor_get_length ( & cursor ) ) , malbinary_cursor_get_length ( & cursor ) , 0 ) ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>mal_message_encode_malbinary\\n" ) ; rc = malzmq_encode_message ( malzmq_ctx -> malzmq_header , mal_message , malzmq_ctx -> encoder , & cursor ) ; if ( rc < 0 ) return rc ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>message<S2SV_blank>is<S2SV_blank>encoded:<S2SV_blank>%d<S2SV_blank>bytes\\n" , malbinary_cursor_get_offset ( & cursor ) ) ; zframe_t * frame = zframe_new ( cursor . body_ptr , malbinary_cursor_get_length ( & cursor ) ) ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>send<S2SV_blank>zmq<S2SV_blank>message\\n" ) ; if ( mcast_uri == NULL ) { rc = zframe_send ( & frame , socket , 0 ) ; <S2SV_StartBug> } else { <S2SV_EndBug> rc = zstr_sendm ( socket , SUB_NAME ) ; <S2SV_StartBug> clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>send<S2SV_blank>the<S2SV_blank>SUB_NAME,<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , rc ) ; <S2SV_EndBug> rc = zframe_send ( & frame , socket , 0 ) ; clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>zframe_send<S2SV_blank>the<S2SV_blank>message,<S2SV_blank><S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , rc ) ; assert ( rc == 0 ) ; } clog_debug ( malzmq_logger , "malzmq_ctx:<S2SV_blank>message<S2SV_blank>sent.\\n" ) ; return rc ; } | <S2SV_ModStart> 0 ) ; assert ( rc == 0 ) ; <S2SV_ModStart> ( malzmq_logger , "malzmq_ctx:<S2SV_blank>send<S2SV_blank>the<S2SV_blank>SUB_NAME<S2SV_blank>\\"%s\\",<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , SUB_NAME <S2SV_ModEnd> , rc ) |
4,124 | CWE-000 void updateCamera ( ) { loadIdentity ( compMat4 ) ; <S2SV_StartBug> if ( Player -> pos . x > WIDTH / 2 ) { <S2SV_EndBug> camera . x = ( Player -> pos . x - WIDTH / 2 ) ; translateMat ( compMat4 , ( Vec2D ) { - camera . x , 0.0 } ) ; } <S2SV_StartBug> if ( Player -> pos . y > HEIGHT / 2 ) { <S2SV_EndBug> camera . y = ( Player -> pos . y - HEIGHT / 2 ) ; translateMat ( compMat4 , ( Vec2D ) { 0.0 , - camera . y } ) ; } loadViewMatrix ( compMat4 ) ; } | <S2SV_ModStart> pos . x >= <S2SV_ModEnd> WIDTH / 2 <S2SV_ModStart> pos . y >= <S2SV_ModEnd> HEIGHT / 2 |
4,125 | CWE-000 int ft_vprintf ( const char * restrict str , va_list ap ) { int i ; char * tmp ; intmax_t n ; t_unicode * s ; int c ; t_args a ; int printed ; static int old_return = 0 ; int new_return ; i = 0 ; if ( str == NULL ) { return ( - 1 ) ; } tmp = ft_strchr ( str , '%' ) ; if ( tmp == NULL ) { ft_putstr ( str ) ; return ( old_return == - 1 ? - 1 : ( int ) ft_strlen ( str ) ) ; } i = tmp - str ; write ( 1 , str , i ) ; a = ft_printf_readarg ( str + i ) ; ft_printf_synonyms ( & a ) ; if ( a . type == 's' ) ft_printf_execarg_s ( & a , ap ) ; else if ( a . type == 'p' ) { a . hash = 1 ; ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 16 ) ; } else if ( a . type == 'b' ) ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 2 ) ; else if ( a . type == 'r' ) ft_printf_execarg_r ( & a , ap ) ; else if ( a . type == 'd' || a . type == 'i' ) { n = ft_printf_getarg_nbr_signed ( ap , a ) ; ft_printf_putnbr_signed ( n , & a , 10 , n < 0 ) ; } else if ( a . type == 'o' ) ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 8 ) ; else if ( a . type == 'u' ) ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 10 ) ; else if ( a . type == 'x' ) ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 16 ) ; else if ( a . type == 'X' ) ft_printf_putnbr_unsigned ( ft_printf_getarg_nbr_unsigned ( ap , a ) , & a , 16 ) ; else if ( a . type == '%' ) { c = '%' ; a . width = - 1 ; a . precision = - 1 ; a . zero = - 1 ; s = ft_wstrdup ( ( unsigned char * ) ( & c ) , 1 ) ; if ( ! s ) return ( - 1 ) ; ft_printf_wputstr ( s , & a , ft_putstr_ascii ) ; free ( s ) ; } else if ( a . type == 'c' ) ft_printf_execarg_c ( & a , ap ) ; else <S2SV_StartBug> { <S2SV_EndBug> if ( a . type != '\\0' ) { c = a . type ; if ( a . lenght != SIZE_L ) s = ft_wstrdup ( ( unsigned char * ) ( & c ) , 1 ) ; else { s = ( int * ) ft_memalloc ( sizeof ( int ) * 2 ) ; * s = c ; } if ( ! s ) return ( - 1 ) ; ft_printf_wputstr ( s , & a , ft_putstr_ascii ) ; free ( s ) ; } else return ( 0 ) ; } printed = i + a . tmp ; i += a . nbr ; if ( a . err == 1 ) old_return = - 1 ; new_return = ft_vprintf ( str + i , ap ) + printed ; if ( old_return == - 1 && PERSIST_RETURN ) return - 1 ; old_return = new_return ; return new_return ; } | <S2SV_ModStart> ) ; else ft_printf_execarg_undefineds ( & a ) ; <S2SV_ModEnd> printed = i |
4,126 | CWE-000 void webNewSection ( char * format , ... ) { va_list args ; va_start ( args , format ) ; webNewSectionHeaderStart ( TRUE ) ; vprintf ( format , args ) ; <S2SV_StartBug> webNewSectionHeaderEnd ( ) ; <S2SV_EndBug> va_end ( args ) ; } | <S2SV_ModStart> ; webNewSectionHeaderEnd ( TRUE |
4,127 | CWE-000 void bbzoutmsg_queue_first ( bbzmsg_payload_t * buf ) { bbzmsg_t * msg = ( bbzmsg_t * ) bbzringbuf_at ( & vm -> outmsgs . queue , 0 ) ; bbzringbuf_clear ( buf ) ; bbzmsg_serialize_u8 ( buf , msg -> type ) ; bbzmsg_serialize_u16 ( buf , msg -> base . rid ) ; switch ( msg -> type ) { case BBZMSG_BROADCAST : # ifndef BBZ_DISABLE_NEIGHBORS if ( bbztype_istable ( msg -> bc . value ) ) return ; bbzmsg_serialize_u16 ( buf , msg -> bc . topic ) ; bbzmsg_serialize_obj ( buf , & msg -> bc . value ) ; break ; # else return ; # endif case BBZMSG_VSTIG_PUT : case BBZMSG_VSTIG_QUERY : # ifndef BBZ_DISABLE_VSTIGS if ( bbztype_istable ( msg -> vs . data ) ) return ; bbzmsg_serialize_u16 ( buf , msg -> vs . key ) ; bbzmsg_serialize_obj ( buf , & msg -> vs . data ) ; bbzmsg_serialize_u8 ( buf , msg -> vs . lamport ) ; break ; # else return ; # endif case BBZMSG_SWARM : <S2SV_StartBug> # ifndef BBZ_DISABLE_SWARMS <S2SV_EndBug> bbzmsg_serialize_u16 ( buf , msg -> sw . lamport ) ; bbzmsg_serialize_u8 ( buf , msg -> sw . swarms ) ; break ; # else return ; # endif default : break ; } } | <S2SV_ModStart> BBZMSG_SWARM : # if ! defined ( BBZ_DISABLE_SWARMS ) && ! defined ( BBZ_DISABLE_SWARMLIST_BROADCASTS ) <S2SV_ModEnd> bbzmsg_serialize_u16 ( buf |
4,128 | CWE-000 NTSTATUS ndisprotOpenDevice ( _In_reads_bytes_ ( DeviceNameLength ) IN PUCHAR pDeviceName , IN ULONG DeviceNameLength , IN PFILE_OBJECT pFileObject , OUT PNDISPROT_OPEN_CONTEXT * ppOpenContext ) { PNDISPROT_OPEN_CONTEXT pOpenContext ; NTSTATUS NtStatus ; ULONG PacketFilter ; NDIS_STATUS NdisStatus ; ULONG BytesProcessed ; PNDISPROT_OPEN_CONTEXT pCurrentOpenContext = NULL ; pOpenContext = NULL ; do { <S2SV_StartBug> pOpenContext = ndisprotLookupDevice ( <S2SV_EndBug> pDeviceName , DeviceNameLength ) ; if ( pOpenContext == NULL ) { DEBUGP ( DL_WARN , ( "ndisprotOpenDevice:<S2SV_blank>couldn\'t<S2SV_blank>find<S2SV_blank>device\\n" ) ) ; NtStatus = STATUS_OBJECT_NAME_NOT_FOUND ; break ; } NPROT_ACQUIRE_LOCK ( & pOpenContext -> Lock , FALSE ) ; if ( ! NPROT_TEST_FLAGS ( pOpenContext -> Flags , NPROTO_OPEN_FLAGS , NPROTO_OPEN_IDLE ) ) { NPROT_ASSERT ( pOpenContext -> pFileObject != NULL ) ; DEBUGP ( DL_WARN , ( "ndisprotOpenDevice:<S2SV_blank>Open<S2SV_blank>%p/%x<S2SV_blank>already<S2SV_blank>associated" "<S2SV_blank>with<S2SV_blank>another<S2SV_blank>FileObject<S2SV_blank>%p\\n" , pOpenContext , pOpenContext -> Flags , pOpenContext -> pFileObject ) ) ; NPROT_RELEASE_LOCK ( & pOpenContext -> Lock , FALSE ) ; NPROT_DEREF_OPEN ( pOpenContext ) ; NtStatus = STATUS_DEVICE_BUSY ; break ; } if ( ( pCurrentOpenContext = InterlockedCompareExchangePointer ( & ( pFileObject -> FsContext ) , pOpenContext , NULL ) ) != NULL ) { DEBUGP ( DL_WARN , ( "ndisprotOpenDevice:<S2SV_blank>FileObject<S2SV_blank>%p<S2SV_blank>already<S2SV_blank>associated" "<S2SV_blank>with<S2SV_blank>another<S2SV_blank>Open<S2SV_blank>%p/%x\\n" , pFileObject , pCurrentOpenContext , pCurrentOpenContext -> Flags ) ) ; NPROT_RELEASE_LOCK ( & pOpenContext -> Lock , FALSE ) ; NPROT_DEREF_OPEN ( pOpenContext ) ; NtStatus = STATUS_INVALID_DEVICE_REQUEST ; break ; } pOpenContext -> pFileObject = pFileObject ; NPROT_SET_FLAGS ( pOpenContext -> Flags , NPROTO_OPEN_FLAGS , NPROTO_OPEN_ACTIVE ) ; NPROT_RELEASE_LOCK ( & pOpenContext -> Lock , FALSE ) ; PacketFilter = NPROTO_PACKET_FILTER ; NdisStatus = ndisprotValidateOpenAndDoRequest ( pOpenContext , NdisRequestSetInformation , OID_GEN_CURRENT_PACKET_FILTER , & PacketFilter , sizeof ( PacketFilter ) , & BytesProcessed , TRUE ) ; if ( NdisStatus != NDIS_STATUS_SUCCESS ) { DEBUGP ( DL_WARN , ( "openDevice:<S2SV_blank>Open<S2SV_blank>%p:<S2SV_blank>set<S2SV_blank>packet<S2SV_blank>filter<S2SV_blank>(%x)<S2SV_blank>failed:<S2SV_blank>%x\\n" , pOpenContext , PacketFilter , NdisStatus ) ) ; NPROT_ACQUIRE_LOCK ( & pOpenContext -> Lock , FALSE ) ; pCurrentOpenContext = InterlockedCompareExchangePointer ( & ( pFileObject -> FsContext ) , NULL , pOpenContext ) ; NPROT_ASSERT ( pCurrentOpenContext == pOpenContext ) ; NPROT_SET_FLAGS ( pOpenContext -> Flags , NPROTO_OPEN_FLAGS , NPROTO_OPEN_IDLE ) ; pOpenContext -> pFileObject = NULL ; NPROT_RELEASE_LOCK ( & pOpenContext -> Lock , FALSE ) ; NPROT_DEREF_OPEN ( pOpenContext ) ; NDIS_STATUS_TO_NT_STATUS ( NdisStatus , & NtStatus ) ; break ; } * ppOpenContext = pOpenContext ; NtStatus = STATUS_SUCCESS ; } while ( FALSE ) ; return ( NtStatus ) ; } | <S2SV_ModStart> ; do { UNREFERENCED_PARAMETER ( DeviceNameLength ) ; UNREFERENCED_PARAMETER ( pDeviceName ) ; pOpenContext = ndisprotLookupSingleDevice ( <S2SV_ModEnd> ) ; if |
4,129 | CWE-000 static int bootstrap ( lua_State * L , struct rosieL_string * rosie_home ) { const char * bootscript = "/src/core/bootstrap.lua" ; LOG ( "About<S2SV_blank>to<S2SV_blank>bootstrap\\n" ) ; char * name = malloc ( rosie_home -> len + strlen ( bootscript ) + 1 ) ; memcpy ( name , rosie_home -> ptr , rosie_home -> len ) ; memcpy ( name + ( rosie_home -> len ) , bootscript , strlen ( bootscript ) + 1 ) ; int status = luaL_loadfile ( L , name ) ; <S2SV_StartBug> if ( status != LUA_OK ) return status ; <S2SV_EndBug> status = lua_pcall ( L , 0 , LUA_MULTRET , 0 ) ; return status ; } | <S2SV_ModStart> name ) ; free ( name ) ; |
4,130 | CWE-000 vfs_path_node_t vfs_construct_path ( const char * path ) { assert ( path ) ; vfs_path_node_t first = NULL ; vfs_path_node_t last = NULL ; if ( * path == '/' ) { first = calloc ( 1 , sizeof ( * first ) ) ; first -> is_root = 1 ; last = first ; path ++ ; } uint8_t component_count = 0 ; uint32_t path_len = ( uint32_t ) strlen ( path ) ; uint32_t start = 0 ; for ( uint32_t i = 0 ; i <= path_len ; ++ i ) { if ( path [ i ] == '/' || i == path_len ) { uint32_t length = i - start ; char * component = calloc ( length , sizeof ( * component ) ) ; memcpy ( component , path + start , length ) ; vfs_path_node_t node = NULL ; if ( component_count == 0 && first ) { node = first ; } else { node = calloc ( 1 , sizeof ( * node ) ) ; <S2SV_StartBug> last -> next = node ; <S2SV_EndBug> <S2SV_StartBug> last = node ; <S2SV_EndBug> } node -> name = component ; start = i + 1 ; component_count ++ ; } } return first ; } | <S2SV_ModStart> ) ) ; if ( last ) { <S2SV_ModStart> = node ; } last = node ; if ( ! first ) { first = node ; } <S2SV_ModEnd> } node -> |
4,131 | CWE-000 <S2SV_StartBug> static int check_day ( const int year , const int month , const int day ) <S2SV_EndBug> { if ( day <= daytab [ leap ( year ) ] [ month ] && day > 0 ) return 0 ; return - 1 ; } | <S2SV_ModStart> check_day ( const int_fast16_t <S2SV_ModEnd> year , const <S2SV_ModStart> year , const uint_fast8_t <S2SV_ModEnd> month , const <S2SV_ModStart> month , const uint_fast16_t <S2SV_ModEnd> day ) { |
4,132 | CWE-000 static void wlan_hdd_pld_uevent ( struct device * dev , struct pld_uevent_data * uevent ) { enum cds_driver_state driver_state ; ENTER ( ) ; mutex_lock ( & hdd_init_deinit_lock ) ; hdd_info ( "pld<S2SV_blank>event<S2SV_blank>%d" , uevent -> uevent ) ; driver_state = cds_get_driver_state ( ) ; if ( driver_state == CDS_DRIVER_STATE_UNINITIALIZED || cds_is_driver_loading ( ) ) { wlan_hdd_set_the_pld_uevent ( uevent ) ; goto uevent_not_allowed ; } wlan_hdd_set_the_pld_uevent ( uevent ) ; switch ( uevent -> uevent ) { case PLD_RECOVERY : <S2SV_StartBug> hdd_pld_ipa_uc_shutdown_pipes ( ) ; <S2SV_EndBug> wlan_hdd_purge_notifier ( ) ; break ; case PLD_FW_DOWN : hdd_cleanup_on_fw_down ( ) ; break ; case PLD_FW_READY : break ; } uevent_not_allowed : mutex_unlock ( & hdd_init_deinit_lock ) ; EXIT ( ) ; return ; } | <S2SV_ModStart> case PLD_RECOVERY : cds_set_target_ready ( false ) ; |
4,133 | CWE-000 void tr_torrentRemoveResume ( tr_torrent const * tor ) { <S2SV_StartBug> char * filename = getResumeFilename ( tor ) ; <S2SV_EndBug> tr_sys_path_remove ( filename , NULL ) ; tr_free ( filename ) ; } | <S2SV_ModStart> char * filename ; filename <S2SV_ModStart> getResumeFilename ( tor , TR_METAINFO_BASENAME_HASH ) ; tr_sys_path_remove ( filename , NULL ) ; tr_free ( filename ) ; filename = getResumeFilename ( tor , TR_METAINFO_BASENAME_NAME_AND_PARTIAL_HASH |
4,134 | CWE-000 void chapter_c_destroy ( chapter_c_t * * chapter_c ) { <S2SV_StartBug> if ( ! chapter_c ) return ; <S2SV_EndBug> if ( ( * chapter_c ) -> controller_log ) { FREENULL ( "chapter_c:controller_log" , ( void * * ) ( & ( ( * chapter_c ) -> controller_log ) ) ) ; } FREENULL ( "chapter_c" , ( void * * ) & ( * chapter_c ) ) ; } | <S2SV_ModStart> if ( ! chapter_c ) return ; if ( ! * |
4,135 | CWE-000 void tcp_init ( void ) { const char * tcbhash_tuneable ; int hashsize ; tcbhash_tuneable = "net.inet.tcp.tcbhashsize" ; # ifdef TCP_HHOOK if ( hhook_head_register ( HHOOK_TYPE_TCP , HHOOK_TCP_EST_IN , & V_tcp_hhh [ HHOOK_TCP_EST_IN ] , HHOOK_NOWAIT | HHOOK_HEADISINVNET ) != 0 ) printf ( "%s:<S2SV_blank>WARNING:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>helper<S2SV_blank>hook\\n" , __func__ ) ; if ( hhook_head_register ( HHOOK_TYPE_TCP , HHOOK_TCP_EST_OUT , & V_tcp_hhh [ HHOOK_TCP_EST_OUT ] , HHOOK_NOWAIT | HHOOK_HEADISINVNET ) != 0 ) printf ( "%s:<S2SV_blank>WARNING:<S2SV_blank>unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>helper<S2SV_blank>hook\\n" , __func__ ) ; # endif hashsize = TCBHASHSIZE ; TUNABLE_INT_FETCH ( tcbhash_tuneable , & hashsize ) ; if ( hashsize == 0 ) { hashsize = maketcp_hashsize ( maxsockets / 4 ) ; if ( hashsize < 512 ) hashsize = 512 ; if ( bootverbose && IS_DEFAULT_VNET ( curvnet ) ) printf ( "%s:<S2SV_blank>%s<S2SV_blank>auto<S2SV_blank>tuned<S2SV_blank>to<S2SV_blank>%d\\n" , __func__ , tcbhash_tuneable , hashsize ) ; } if ( ! powerof2 ( hashsize ) ) { int oldhashsize = hashsize ; hashsize = maketcp_hashsize ( hashsize ) ; if ( hashsize < 16 ) hashsize = 16 ; printf ( "%s:<S2SV_blank>WARNING:<S2SV_blank>TCB<S2SV_blank>hash<S2SV_blank>size<S2SV_blank>not<S2SV_blank>a<S2SV_blank>power<S2SV_blank>of<S2SV_blank>2,<S2SV_blank>" "clipped<S2SV_blank>from<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d.\\n" , __func__ , oldhashsize , hashsize ) ; } in_pcbinfo_init ( & V_tcbinfo , "tcp" , & V_tcb , hashsize , hashsize , "tcp_inpcb" , tcp_inpcb_init , NULL , 0 , IPI_HASHFIELDS_4TUPLE ) ; V_tcpcb_zone = uma_zcreate ( "tcpcb" , sizeof ( struct tcpcb_mem ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , 0 ) ; uma_zone_set_max ( V_tcpcb_zone , maxsockets ) ; uma_zone_set_warning ( V_tcpcb_zone , "kern.ipc.maxsockets<S2SV_blank>limit<S2SV_blank>reached" ) ; tcp_tw_init ( ) ; syncache_init ( ) ; tcp_hc_init ( ) ; TUNABLE_INT_FETCH ( "net.inet.tcp.sack.enable" , & V_tcp_do_sack ) ; V_sack_hole_zone = uma_zcreate ( "sackhole" , sizeof ( struct sackhole ) , NULL , NULL , NULL , NULL , UMA_ALIGN_PTR , 0 ) ; <S2SV_StartBug> if ( ! IS_DEFAULT_VNET ( curvnet ) ) <S2SV_EndBug> return ; tcp_reass_global_init ( ) ; tcp_delacktime = TCPTV_DELACK ; tcp_keepinit = TCPTV_KEEP_INIT ; tcp_keepidle = TCPTV_KEEP_IDLE ; tcp_keepintvl = TCPTV_KEEPINTVL ; tcp_maxpersistidle = TCPTV_KEEP_IDLE ; tcp_msl = TCPTV_MSL ; tcp_rexmit_min = TCPTV_MIN ; if ( tcp_rexmit_min < 1 ) tcp_rexmit_min = 1 ; tcp_persmin = TCPTV_PERSMIN ; tcp_persmax = TCPTV_PERSMAX ; tcp_rexmit_slop = TCPTV_CPU_VAR ; tcp_finwait2_timeout = TCPTV_FINWAIT2_TIMEOUT ; tcp_tcbhashsize = hashsize ; init_tcp_functions ( ) ; register_tcp_functions ( & tcp_def_funcblk , M_WAITOK ) ; if ( tcp_soreceive_stream ) { # ifdef INET tcp_usrreqs . pru_soreceive = soreceive_stream ; # endif # ifdef INET6 tcp6_usrreqs . pru_soreceive = soreceive_stream ; # endif } # ifdef INET6 # define TCP_MINPROTOHDR ( sizeof ( struct ip6_hdr ) + sizeof ( struct tcphdr ) ) # else # define TCP_MINPROTOHDR ( sizeof ( struct tcpiphdr ) ) # endif if ( max_protohdr < TCP_MINPROTOHDR ) max_protohdr = TCP_MINPROTOHDR ; if ( max_linkhdr + TCP_MINPROTOHDR > MHLEN ) panic ( "tcp_init" ) ; # undef TCP_MINPROTOHDR ISN_LOCK_INIT ( ) ; EVENTHANDLER_REGISTER ( shutdown_pre_sync , tcp_fini , NULL , SHUTDOWN_PRI_DEFAULT ) ; EVENTHANDLER_REGISTER ( maxsockets_change , tcp_zone_change , NULL , EVENTHANDLER_PRI_ANY ) ; # ifdef TCPPCAP tcp_pcap_init ( ) ; # endif <S2SV_StartBug> # ifdef TCP_RFC7413 <S2SV_EndBug> tcp_fastopen_init ( ) ; # endif } | <S2SV_ModStart> 0 ) ; # ifdef TCP_RFC7413 tcp_fastopen_init ( ) ; # endif <S2SV_ModStart> ; # endif <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,136 | CWE-000 void displayDebug ( CPU_s * cpu , ALU_s * alu , int memStart , unsigned short mem [ ] ) { int i ; for ( i = 0 ; i < NUM_REG ; i ++ ) { mvwprintw ( debug , GREET_LEN + i , 0 , "R%d:x%04X\\t\\tx%04X:x%04X" , i , <S2SV_StartBug> cpu -> regFile [ i ] , memStart + i , mem [ memStart + i ] ) ; <S2SV_EndBug> } for ( ; i < 11 ; i ++ ) { <S2SV_StartBug> mvwprintw ( debug , GREET_LEN + i , 0 , "\\t\\t\\tx%04X:x%04X" , memStart + i , <S2SV_EndBug> mem [ memStart + i ] ) ; } <S2SV_StartBug> mvwprintw ( debug , GREET_LEN + i , 0 , "PC:x%04X<S2SV_blank><S2SV_blank>IR:x%04X\\tx%04X:x%04X" , cpu -> pc , <S2SV_EndBug> <S2SV_StartBug> cpu -> ir , memStart + i , mem [ memStart + i ] ) ; <S2SV_EndBug> i ++ ; mvwprintw ( debug , GREET_LEN + i , 0 , "A:<S2SV_blank>x%04X<S2SV_blank><S2SV_blank>B:<S2SV_blank>x%04X\\tx%04X:x%04X" , alu -> a , <S2SV_StartBug> alu -> b , memStart + i , mem [ memStart + i ] ) ; <S2SV_EndBug> i ++ ; mvwprintw ( debug , GREET_LEN + i , 0 , "MAR:x%04X<S2SV_blank>MDR:x%04X\\tx%04X:x%04X" , <S2SV_StartBug> cpu -> mar , cpu -> mdr , memStart + i , mem [ memStart + i ] ) ; <S2SV_EndBug> i ++ ; mvwprintw ( debug , GREET_LEN + i , 0 , "CC:<S2SV_blank>N:%X<S2SV_blank>Z:%X<S2SV_blank>P:%X\\t\\tx%04X:x%04X" , <S2SV_StartBug> cpu -> n , cpu -> z , cpu -> p , memStart + i , mem [ memStart + i ] ) ; <S2SV_EndBug> i ++ ; <S2SV_StartBug> mvwprintw ( debug , GREET_LEN + i , 0 , "\\t\\t\\tx%04X:x%04X" , memStart + i , <S2SV_EndBug> mem [ memStart + i ] ) ; wrefresh ( debug ) ; } | <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> cpu -> pc + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> cpu -> mar + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 <S2SV_ModStart> memStart + i + 0x3000 |
4,137 | CWE-000 BOOL CheckButtonPressed ( void ) { static char buttonPressed = FALSE ; static unsigned long buttonPressCounter = 0 ; static char toprint [ ] ; char string [ 20 ] = "Button:" ; <S2SV_StartBug> char press = 0X50 ; <S2SV_EndBug> char notPress = 0x4F ; if ( PORTBbits . RB0 == 0 ) { sprintf ( toprint , "%s" , string ) ; oledPutString ( toprint , 3 , 0 ) ; oledWriteChar1x ( press , 3 + 0xB0 , 45 ) ; if ( buttonPressCounter ++ > 10 ) { buttonPressCounter = 0 ; buttonPressed = TRUE ; } } else { sprintf ( toprint , "%s" , string ) ; oledPutString ( toprint , 3 , 0 ) ; oledWriteChar1x ( notPress , 3 + 0xB0 , 45 ) ; if ( buttonPressed == TRUE ) { if ( buttonPressCounter == 0 ) { buttonPressed = FALSE ; return TRUE ; } else { buttonPressCounter -- ; } } } return FALSE ; } | <S2SV_ModStart> char press = 0x50 <S2SV_ModEnd> ; char notPress |
4,138 | CWE-000 void lcd_relative_write ( struct t_lcd * lcd , const char * string ) { int rw , ya , xa ; size_t len ; if ( ! lcd ) return ; <S2SV_StartBug> rw = lcd -> expander_chip -> callback_get_expansion_pin ( <S2SV_EndBug> lcd -> expander_chip -> instance , 0x01 ) ; pinMode ( rw , OUTPUT ) ; digitalWrite ( rw , LOW ) ; len = strlen ( string ) ; ya = ( ( len + lcd -> cursor -> x ) / lcd -> columns ) ; xa = ( ( len + lcd -> cursor -> x ) % lcd -> columns ) ; if ( ( lcd -> cursor -> y < 0 ) || ( lcd -> cursor -> y > lcd -> rows ) ) return ; if ( ( ( ya + lcd -> cursor -> y ) < 0 ) || ( ( lcd -> cursor -> y + ya ) > lcd -> rows ) ) return ; if ( ( ( lcd -> cursor -> y + ya ) >= lcd -> rows ) && ( int ) ( lcd -> cursor -> x + len ) > lcd -> columns ) return ; lcdPosition ( lcd -> handle , lcd -> cursor -> x , lcd -> cursor -> y ) ; lcd -> cursor -> y += ya ; lcd -> cursor -> x = xa ; lcdPuts ( lcd -> handle , string ) ; } | <S2SV_ModStart> -> expander_chip -> get_expansion_pin ( <S2SV_ModEnd> lcd -> expander_chip |
4,139 | CWE-000 gentity_t * G_Spawn ( void ) { int i , force ; gentity_t * e ; e = NULL ; i = 0 ; for ( force = 0 ; force < 2 ; force ++ ) { e = & g_entities [ MAX_CLIENTS ] ; for ( i = MAX_CLIENTS ; i < level . num_entities ; i ++ , e ++ ) { if ( e -> inuse ) { continue ; } if ( ! force && e -> freetime > level . startTime + 2000 && level . time - e -> freetime < 1000 ) { continue ; } G_InitGentity ( e ) ; return e ; } <S2SV_StartBug> if ( i != MAX_GENTITIES ) { <S2SV_EndBug> break ; } } <S2SV_StartBug> if ( i == ENTITYNUM_MAX_NORMAL ) { <S2SV_EndBug> for ( i = 0 ; i < MAX_GENTITIES ; i ++ ) { G_Printf ( "%4i:<S2SV_blank>%s\\n" , i , g_entities [ i ] . classname ) ; } G_Error ( "G_Spawn:<S2SV_blank>no<S2SV_blank>free<S2SV_blank>entities" ) ; } level . num_entities ++ ; trap_LocateGameData ( level . gentities , level . num_entities , sizeof ( gentity_t ) , & level . clients [ 0 ] . ps , sizeof ( level . clients [ 0 ] ) ) ; G_InitGentity ( e ) ; return e ; } | <S2SV_ModStart> } if ( level . num_entities < ENTITYNUM_MAX_NORMAL <S2SV_ModEnd> ) { break <S2SV_ModStart> } if ( level . num_entities <S2SV_ModEnd> == ENTITYNUM_MAX_NORMAL ) |
4,140 | CWE-000 void CORD__next ( register CORD_pos p ) { register size_t cur_pos = p [ 0 ] . cur_pos + 1 ; <S2SV_StartBug> register struct CORD_pe * current_pe = & ( ( p ) [ 0 ] . path [ ( p ) [ 0 ] . path_len ] ) ; <S2SV_EndBug> register CORD leaf = current_pe -> pe_cord ; p [ 0 ] . cur_pos = cur_pos ; if ( ! CORD_IS_STRING ( leaf ) ) { register struct Function * f = & ( ( ( CordRep * ) leaf ) -> function ) ; register size_t start_pos = current_pe -> pe_start_pos ; register size_t end_pos = start_pos + f -> len ; if ( cur_pos < end_pos ) { register size_t i ; register size_t limit = cur_pos + FUNCTION_BUF_SZ ; register CORD_fn fn = f -> fn ; register void * client_data = f -> client_data ; if ( limit > end_pos ) { limit = end_pos ; } for ( i = cur_pos ; i < limit ; i ++ ) { p [ 0 ] . function_buf [ i - cur_pos ] = ( * fn ) ( i - start_pos , client_data ) ; } p [ 0 ] . cur_start = cur_pos ; p [ 0 ] . cur_leaf = p [ 0 ] . function_buf ; p [ 0 ] . cur_end = limit ; return ; } } { while ( p [ 0 ] . path_len > 0 && current_pe [ 0 ] . pe_start_pos != current_pe [ - 1 ] . pe_start_pos ) { p [ 0 ] . path_len -- ; current_pe -- ; } if ( p [ 0 ] . path_len == 0 ) { p [ 0 ] . path_len = CORD_POS_INVALID ; return ; } } p [ 0 ] . path_len -- ; CORD__extend_path ( p ) ; } | <S2SV_ModStart> CORD_pe * current_pe ; register CORD leaf ; if ( ! CORD_pos_valid ( p ) ) ABORT ( "CORD_next:<S2SV_blank>invalid<S2SV_blank>argument" ) ; current_pe = & p <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> . path [ p [ 0 ] . path_len ] ; <S2SV_ModEnd> leaf = current_pe |
4,141 | CWE-000 void emulate_JNC ( _cpu_info * cpu ) { uint16_t addr = 0 ; if ( ! cpu -> flags . c ) { addr = read_byte_at_pc ( cpu ) ; addr |= read_byte_at_pc ( cpu ) << 8 ; cpu -> pc = addr ; } else { <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> } else { cpu -> pc += 2 ; |
4,142 | CWE-000 void CL_UnqueOutputPacket ( qbool sendall ) { <S2SV_StartBug> int i ; <S2SV_EndBug> double time = Sys_DoubleTime ( ) ; <S2SV_StartBug> for ( i = 0 ; i < CL_MAX_DELAYED_PACKETS ; i ++ ) <S2SV_EndBug> { <S2SV_StartBug> if ( ! cl_delayed_packets_send [ i ] . time ) <S2SV_EndBug> continue ; if ( cl_delayed_packets_send [ i ] . time > time && ! sendall ) <S2SV_StartBug> continue ; <S2SV_EndBug> <S2SV_StartBug> NET_SendPacketEx ( NS_CLIENT , cl_delayed_packets_send [ i ] . length , <S2SV_EndBug> cl_delayed_packets_send [ i ] . data , cl_delayed_packets_send [ i ] . addr , false ) ; <S2SV_StartBug> cl_delayed_packets_send [ i ] . time = 0 ; <S2SV_EndBug> } } | <S2SV_ModStart> sendall ) { <S2SV_ModEnd> double time = <S2SV_ModStart> ( ) ; cl_delayed_packet_t * packet = NULL ; while ( ( packet = NET_PacketQueuePeek ( & delay_queue_send ) ) <S2SV_ModEnd> ) { if <S2SV_ModStart> { if ( packet -> <S2SV_ModEnd> time > time <S2SV_ModStart> ! sendall ) break <S2SV_ModEnd> ; NET_SendPacketEx ( <S2SV_ModStart> ( NS_CLIENT , packet -> length , packet -> data , packet -> <S2SV_ModEnd> addr , false <S2SV_ModStart> false ) ; NET_PacketQueueSkip ( & delay_queue_send ) <S2SV_ModEnd> ; } } |
4,143 | CWE-000 int t_reply_matching ( struct sip_msg * p_msg , int * p_branch ) { struct cell * p_cell ; <S2SV_StartBug> int hash_index = 0 ; <S2SV_EndBug> <S2SV_StartBug> int entry_label = 0 ; <S2SV_EndBug> <S2SV_StartBug> int branch_id = 0 ; <S2SV_EndBug> char * hashi , * branchi , * p , * n ; int hashl , branchl ; int scan_space ; struct cseq_body * cseq ; char * loopi ; int loopl ; char * syni ; int synl ; loopi = 0 ; loopl = 0 ; syni = 0 ; synl = 0 ; if ( ! ( p_msg -> via1 && p_msg -> via1 -> branch && p_msg -> via1 -> branch -> value . s ) ) goto nomatch2 ; if ( p_msg -> via1 -> branch -> value . len <= MCOOKIE_LEN ) goto nomatch2 ; if ( memcmp ( p_msg -> via1 -> branch -> value . s , MCOOKIE , MCOOKIE_LEN ) != 0 ) goto nomatch2 ; p = p_msg -> via1 -> branch -> value . s + MCOOKIE_LEN ; scan_space = p_msg -> via1 -> branch -> value . len - MCOOKIE_LEN ; n = eat_token2_end ( p , p + scan_space , BRANCH_SEPARATOR ) ; hashl = n - p ; scan_space -= hashl ; if ( ! hashl || scan_space < 2 || * n != BRANCH_SEPARATOR ) goto nomatch2 ; hashi = p ; p = n + 1 ; scan_space -- ; if ( ! syn_branch ) { n = eat_token2_end ( p , p + scan_space , BRANCH_SEPARATOR ) ; loopl = n - p ; scan_space -= loopl ; if ( n == p || scan_space < 2 || * n != BRANCH_SEPARATOR ) goto nomatch2 ; loopi = p ; p = n + 1 ; scan_space -- ; } else { n = eat_token2_end ( p , p + scan_space , BRANCH_SEPARATOR ) ; synl = n - p ; scan_space -= synl ; if ( ! synl || scan_space < 2 || * n != BRANCH_SEPARATOR ) goto nomatch2 ; syni = p ; p = n + 1 ; scan_space -- ; } n = eat_token_end ( p , p + scan_space ) ; branchl = n - p ; if ( ! branchl ) goto nomatch2 ; branchi = p ; <S2SV_StartBug> if ( ( hash_index = reverse_hex2int ( hashi , hashl ) ) < 0 <S2SV_EndBug> || hash_index >= TM_TABLE_ENTRIES <S2SV_StartBug> || ( branch_id = reverse_hex2int ( branchi , branchl ) ) < 0 <S2SV_EndBug> || branch_id >= MAX_BRANCHES <S2SV_StartBug> || ( syn_branch ? ( entry_label = reverse_hex2int ( syni , synl ) ) < 0 <S2SV_EndBug> : loopl != MD5_LEN ) ) { <S2SV_StartBug> LM_DBG ( "poor<S2SV_blank>reply<S2SV_blank>labels<S2SV_blank>%d<S2SV_blank>label<S2SV_blank>%d<S2SV_blank>branch<S2SV_blank>%d\\n" , <S2SV_EndBug> hash_index , entry_label , branch_id ) ; goto nomatch2 ; } <S2SV_StartBug> LM_DBG ( "hash<S2SV_blank>%d<S2SV_blank>label<S2SV_blank>%d<S2SV_blank>branch<S2SV_blank>%d\\n" , hash_index , entry_label , branch_id ) ; <S2SV_EndBug> cseq = get_cseq ( p_msg ) ; LOCK_HASH ( hash_index ) ; for ( p_cell = get_tm_table ( ) -> entrys [ hash_index ] . first_cell ; p_cell ; p_cell = p_cell -> next_cell ) { if ( syn_branch ) { if ( p_cell -> label != entry_label ) continue ; } else { if ( memcmp ( p_cell -> md5 , loopi , MD5_LEN ) != 0 ) continue ; } if ( branch_id >= p_cell -> nr_of_outgoings ) continue ; if ( ! ( ( cseq -> method_id == METHOD_CANCEL && is_invite ( p_cell ) && p_cell -> uac [ branch_id ] . local_cancel . buffer . len ) || ( ( cseq -> method_id != METHOD_OTHER && p_cell -> uas . request ) ? ( cseq -> method_id == REQ_LINE ( p_cell -> uas . request ) . method_value ) : ( EQ_STRS ( cseq -> method , p_cell -> method ) ) ) ) ) continue ; set_t ( p_cell ) ; * p_branch = branch_id ; REF_UNSAFE ( T ) ; UNLOCK_HASH ( hash_index ) ; LM_DBG ( "reply<S2SV_blank>matched<S2SV_blank>(T=%p)!\\n" , T ) ; if ( is_invite ( p_cell ) && p_msg -> REPLY_STATUS >= 200 && p_msg -> REPLY_STATUS < 300 && ( ( ! is_local ( p_cell ) && has_tran_tmcbs ( p_cell , TMCB_RESPONSE_OUT | TMCB_RESPONSE_PRE_OUT ) ) || ( is_local ( p_cell ) && has_tran_tmcbs ( p_cell , TMCB_LOCAL_COMPLETED ) ) ) ) { if ( parse_headers ( p_msg , HDR_TO_F , 0 ) == - 1 ) { LM_ERR ( "to<S2SV_blank>parsing<S2SV_blank>failed\\n" ) ; } } if ( ! is_local ( p_cell ) && ! ( cseq -> method_id == METHOD_CANCEL && is_invite ( p_cell ) ) ) { run_trans_callbacks ( TMCB_RESPONSE_IN , T , T -> uas . request , p_msg , p_msg -> REPLY_STATUS ) ; } if ( has_tran_tmcbs ( T , TMCB_MSG_MATCHED_IN ) ) run_trans_callbacks ( TMCB_MSG_MATCHED_IN , T , 0 , p_msg , p_msg -> REPLY_STATUS ) ; return 1 ; } UNLOCK_HASH ( hash_index ) ; LM_DBG ( "no<S2SV_blank>matching<S2SV_blank>transaction<S2SV_blank>exists\\n" ) ; nomatch2 : LM_DBG ( "failure<S2SV_blank>to<S2SV_blank>match<S2SV_blank>a<S2SV_blank>transaction\\n" ) ; * p_branch = - 1 ; set_t ( 0 ) ; return - 1 ; } | <S2SV_ModStart> * p_cell ; unsigned <S2SV_ModStart> = 0 ; unsigned <S2SV_ModStart> = 0 ; unsigned <S2SV_ModStart> ; if ( reverse_hex2int ( hashi , hashl , & hash_index <S2SV_ModEnd> ) < 0 <S2SV_ModStart> >= TM_TABLE_ENTRIES || reverse_hex2int ( branchi , branchl , & branch_id <S2SV_ModEnd> ) < 0 <S2SV_ModStart> ( syn_branch ? reverse_hex2int ( syni , synl , & entry_label <S2SV_ModEnd> ) < 0 <S2SV_ModStart> { LM_DBG ( "poor<S2SV_blank>reply<S2SV_blank>labels<S2SV_blank>%u<S2SV_blank>label<S2SV_blank>%u<S2SV_blank>branch<S2SV_blank>%u\\n" <S2SV_ModEnd> , hash_index , <S2SV_ModStart> } LM_DBG ( "hash<S2SV_blank>%u<S2SV_blank>label<S2SV_blank>%d<S2SV_blank>branch<S2SV_blank>%u\\n" <S2SV_ModEnd> , hash_index , |
4,144 | CWE-000 <S2SV_StartBug> int rdataset_dematerialize ( const knot_rdataset_t * rds , void * restrict data ) <S2SV_EndBug> { assert ( data ) ; if ( ! data ) { return kr_error ( EINVAL ) ; } uint16_t rr_count = rds ? rds -> rr_count : 0 ; memcpy ( data , & rr_count , sizeof ( rr_count ) ) ; data += sizeof ( rr_count ) ; knot_rdata_t * rd = rds ? rds -> data : NULL ; for ( int i = 0 ; i < rr_count ; ++ i , rd = kr_rdataset_next ( rd ) ) { uint16_t len = knot_rdata_rdlen ( rd ) ; memcpy ( data , & len , sizeof ( len ) ) ; data += sizeof ( len ) ; memcpy ( data , knot_rdata_data ( rd ) , len ) ; data += len ; } return kr_ok ( ) ; } | <S2SV_ModStart> * rds , uint8_t <S2SV_ModEnd> * restrict data |
4,145 | CWE-000 int getline ( ) { int c , i = 0 ; <S2SV_StartBug> for ( i , i < LINE_LEN - 1 && ( ( c = getchar ( ) ) != '\\n' && c != EOF ) , i ++ ) <S2SV_EndBug> { expression [ i ] = c ; } if ( c == '\\n' ) { expression [ i ] = '\\n' ; i ++ ; } expression [ i ] = '\\0' ; return i ; } | <S2SV_ModStart> for ( i ; <S2SV_ModEnd> i < LINE_LEN <S2SV_ModStart> != EOF ) ; <S2SV_ModEnd> i ++ ) |
4,146 | CWE-000 static void smbchg_chg_led_blink_set ( struct smbchg_chip * chip , unsigned long blinking ) { u8 reg ; int rc ; <S2SV_StartBug> if ( blinking == 0 ) { <S2SV_EndBug> reg = CHG_LED_OFF << CHG_LED_SHIFT ; <S2SV_StartBug> power_supply_set_hi_power_state ( chip -> bms_psy , 0 ) ; <S2SV_EndBug> } else { <S2SV_StartBug> power_supply_set_hi_power_state ( chip -> bms_psy , 1 ) ; <S2SV_EndBug> if ( blinking == 1 ) reg = LED_BLINKING_PATTERN2 << CHG_LED_SHIFT ; else if ( blinking == 2 ) reg = LED_BLINKING_PATTERN1 << CHG_LED_SHIFT ; else reg = LED_BLINKING_PATTERN2 << CHG_LED_SHIFT ; } rc = smbchg_sec_masked_write ( chip , chip -> bat_if_base + CMD_CHG_LED_REG , LED_BLINKING_CFG_MASK , reg ) ; if ( rc ) dev_err ( chip -> dev , "Couldn\'t<S2SV_blank>write<S2SV_blank>CHG_LED<S2SV_blank>rc=%d\\n" , rc ) ; } | <S2SV_ModStart> ; if ( chip -> bms_psy ) { if ( blinking == 0 ) power_supply_set_hi_power_state ( chip -> bms_psy , 0 ) ; else power_supply_set_hi_power_state ( chip -> bms_psy , 1 ) ; } if ( <S2SV_ModStart> << CHG_LED_SHIFT ; <S2SV_ModEnd> } else { <S2SV_ModStart> } else { <S2SV_ModEnd> if ( blinking |
4,147 | CWE-000 int main ( int argc , char * * argv ) { int verbose = 0 ; int flag ; while ( ( flag = getopt ( argc , argv , "v" ) ) != - 1 ) { switch ( flag ) { case 'v' : verbose = 1 ; break ; default : break ; } } regs = init_registers ( ) ; ptrs = init_pointers ( ) ; flags = init_flags ( ) ; <S2SV_StartBug> cartridge = load_cartridge ( argv [ optind ] ) ; <S2SV_EndBug> memory = init_memory ( ) ; <S2SV_StartBug> while ( 1 ) <S2SV_EndBug> { <S2SV_StartBug> cpu_execution ( ) ; <S2SV_EndBug> } free ( regs ) ; free ( ptrs ) ; free ( flags ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ; cartridge = load_test_cartridge ( <S2SV_ModEnd> ) ; memory <S2SV_ModStart> ; while ( opcode != 0x76 <S2SV_ModEnd> ) { cpu_execution <S2SV_ModStart> ) { cpu_execution ( ) ; printf ( "opcode:<S2SV_blank>%x\\n" , opcode ) ; dump_registers |
4,148 | CWE-000 int EdgeCmdCget ( Edge * edgePtr , Tcl_Interp * interp , int objc , Tcl_Obj * const objv [ ] ) { int optIdx ; <S2SV_StartBug> char * opts [ ] = { "-name" , "-from" , "-to" , "-weight" , NULL } ; <S2SV_EndBug> enum OptsIx { NameIx , FromIx , ToIx , <S2SV_StartBug> WeightIx <S2SV_EndBug> } ; if ( objc != 1 ) { Tcl_WrongNumArgs ( interp , 1 , objv , "option<S2SV_blank>arg" ) ; return TCL_ERROR ; } if ( Tcl_GetIndexFromObj ( interp , objv [ 0 ] , opts , "option" , 0 , & optIdx ) != TCL_OK ) { return TCL_ERROR ; } switch ( optIdx ) { case NameIx : { Tcl_SetObjResult ( interp , Tcl_NewStringObj ( edgePtr -> name , - 1 ) ) ; return TCL_OK ; } case FromIx : { Tcl_SetObjResult ( interp , Tcl_NewStringObj ( edgePtr -> fromNode -> cmdName , - 1 ) ) ; return TCL_OK ; } case ToIx : { Tcl_SetObjResult ( interp , Tcl_NewStringObj ( edgePtr -> toNode -> cmdName , - 1 ) ) ; return TCL_OK ; } case WeightIx : { Tcl_SetObjResult ( interp , Tcl_NewDoubleObj ( edgePtr -> weight ) ) ; return TCL_OK ; } <S2SV_StartBug> default : { <S2SV_EndBug> break ; } } return TCL_OK ; } | <S2SV_ModStart> , "-weight" , "-undirected" , <S2SV_ModStart> ToIx , WeightIx , UndirectedIx <S2SV_ModStart> TCL_OK ; } case UndirectedIx : { Tcl_SetObjResult ( interp , Tcl_NewBooleanObj ( edgePtr -> undirected ) ) ; return TCL_OK ; } |
4,149 | CWE-000 int dsa_port_vlan_del ( struct dsa_port * dp , const struct switchdev_obj_port_vlan * vlan ) { struct dsa_notifier_vlan_info info = { . sw_index = dp -> ds -> index , . port = dp -> index , . vlan = vlan , } ; <S2SV_StartBug> return dsa_port_notify ( dp , DSA_NOTIFIER_VLAN_DEL , & info ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> , } ; if ( br_vlan_enabled ( dp -> bridge_dev ) ) <S2SV_ModStart> info ) ; return 0 ; |
4,150 | CWE-000 uint32_t gp_add_krb5_creds ( uint32_t * min , struct gp_call_ctx * gpcall , enum gp_aqcuire_cred_type acquire_type , gss_cred_id_t in_cred , gssx_name * desired_name , gss_cred_usage_t cred_usage , uint32_t initiator_time_req , uint32_t acceptor_time_req , gss_cred_id_t * output_cred_handle , gss_OID_set * actual_mechs , uint32_t * initiator_time_rec , uint32_t * acceptor_time_rec ) { uint32_t ret_maj = 0 ; uint32_t ret_min = 0 ; uint32_t discard ; gss_name_t req_name = GSS_C_NO_NAME ; gss_OID_set_desc desired_mechs = { 1 , & gp_mech_krb5 } ; gss_key_value_set_desc cred_store = { 0 } ; gss_cred_id_t impersonator_cred = GSS_C_NO_CREDENTIAL ; gss_cred_id_t user_cred = GSS_C_NO_CREDENTIAL ; gss_ctx_id_t initiator_context = GSS_C_NO_CONTEXT ; gss_ctx_id_t acceptor_context = GSS_C_NO_CONTEXT ; gss_name_t target_name = GSS_C_NO_NAME ; gss_buffer_desc init_token = GSS_C_EMPTY_BUFFER ; gss_buffer_desc accept_token = GSS_C_EMPTY_BUFFER ; gss_cred_id_t input_cred ; if ( ! min || ! output_cred_handle ) { return GSS_S_CALL_INACCESSIBLE_WRITE ; } * min = 0 ; * output_cred_handle = GSS_C_NO_CREDENTIAL ; if ( actual_mechs ) { * actual_mechs = GSS_C_NO_OID_SET ; } if ( in_cred != GSS_C_NO_CREDENTIAL && acquire_type != ACQ_IMPNAME ) { ret_maj = gp_check_cred ( & ret_min , in_cred , desired_name , cred_usage ) ; if ( ret_maj == GSS_S_COMPLETE ) { return GSS_S_COMPLETE ; <S2SV_StartBug> } else if ( ret_maj != GSS_S_CREDENTIALS_EXPIRED && <S2SV_EndBug> ret_maj != GSS_S_NO_CRED ) { * min = ret_min ; return GSS_S_CRED_UNAVAIL ; } } if ( acquire_type == ACQ_NORMAL ) { ret_min = gp_get_cred_environment ( gpcall , desired_name , & req_name , & cred_usage , & cred_store ) ; <S2SV_StartBug> } else if ( desired_name ) { <S2SV_EndBug> ret_maj = gp_conv_gssx_to_name ( & ret_min , desired_name , & req_name ) ; } if ( ret_maj ) { <S2SV_StartBug> goto done ; <S2SV_EndBug> } else if ( ret_min ) { ret_maj = GSS_S_CRED_UNAVAIL ; goto done ; } if ( ! try_impersonate ( gpcall -> service , cred_usage , acquire_type ) ) { ret_maj = gss_acquire_cred_from ( & ret_min , req_name , GSS_C_INDEFINITE , & desired_mechs , cred_usage , & cred_store , output_cred_handle , actual_mechs , NULL ) ; if ( ret_maj ) { goto done ; } } else { switch ( acquire_type ) { case ACQ_NORMAL : ret_maj = gss_acquire_cred_from ( & ret_min , GSS_C_NO_NAME , GSS_C_INDEFINITE , & desired_mechs , GSS_C_BOTH , & cred_store , & impersonator_cred , NULL , NULL ) ; if ( ret_maj ) { goto done ; } input_cred = impersonator_cred ; break ; case ACQ_IMPNAME : input_cred = in_cred ; break ; default : ret_maj = GSS_S_FAILURE ; ret_min = EFAULT ; goto done ; } ret_maj = gss_inquire_cred ( & ret_min , input_cred , & target_name , NULL , NULL , NULL ) ; if ( ret_maj ) { goto done ; } ret_maj = gss_acquire_cred_impersonate_name ( & ret_min , input_cred , req_name , GSS_C_INDEFINITE , & desired_mechs , GSS_C_INITIATE , & user_cred , actual_mechs , NULL ) ; if ( ret_maj ) { goto done ; } if ( acquire_type == ACQ_IMPNAME ) { * output_cred_handle = user_cred ; user_cred = GSS_C_NO_CREDENTIAL ; goto done ; } ret_maj = gss_init_sec_context ( & ret_min , user_cred , & initiator_context , target_name , & gp_mech_krb5 , GSS_C_REPLAY_FLAG | GSS_C_SEQUENCE_FLAG , GSS_C_INDEFINITE , GSS_C_NO_CHANNEL_BINDINGS , GSS_C_NO_BUFFER , NULL , & init_token , NULL , NULL ) ; if ( ret_maj ) { goto done ; } ret_maj = gss_accept_sec_context ( & ret_min , & acceptor_context , input_cred , & init_token , GSS_C_NO_CHANNEL_BINDINGS , NULL , NULL , & accept_token , NULL , NULL , output_cred_handle ) ; if ( ret_maj ) { goto done ; } } if ( initiator_time_rec || acceptor_time_rec ) { ret_maj = gss_inquire_cred_by_mech ( & ret_min , * output_cred_handle , & gp_mech_krb5 , NULL , initiator_time_rec , acceptor_time_rec , NULL ) ; if ( ret_maj ) { goto done ; } } done : if ( ret_maj ) { gp_log_status ( & gp_mech_krb5 , ret_maj , ret_min ) ; if ( * output_cred_handle ) { gss_release_cred ( & discard , output_cred_handle ) ; } if ( actual_mechs && * actual_mechs ) { gss_release_oid_set ( & discard , actual_mechs ) ; } } free_cred_store_elements ( & cred_store ) ; gss_release_cred ( & discard , & impersonator_cred ) ; gss_release_cred ( & discard , & user_cred ) ; gss_release_name ( & discard , & target_name ) ; gss_delete_sec_context ( & discard , & initiator_context , NULL ) ; gss_release_buffer ( & discard , & init_token ) ; gss_release_buffer ( & discard , & accept_token ) ; gss_release_name ( & discard , & req_name ) ; * min = ret_min ; return ret_maj ; } | <S2SV_ModStart> if ( ret_maj == GSS_S_CREDENTIALS_EXPIRED || ret_maj == GSS_S_NO_CRED ) { ret_maj = 0 ; ret_min = 0 ; } else <S2SV_ModEnd> { * min <S2SV_ModStart> cred_store ) ; if ( ret_min ) { ret_maj = GSS_S_CRED_UNAVAIL ; } <S2SV_ModStart> ret_maj ) { <S2SV_ModEnd> goto done ; |
4,151 | CWE-000 int get_avdp ( uint8_t * dev , struct udf_disc * disc , int * sectorsize , size_t devsize , avdp_type_e type , int force_sectorsize , struct filesystemStats * stats ) { int64_t position = 0 ; tag desc_tag ; int ssize = 512 ; int it = 0 ; int status = 0 ; for ( int it = 0 ; it < 5 ; it ++ , ssize *= 2 ) { if ( force_sectorsize ) { ssize = * sectorsize ; it = INT_MAX - 1 ; } dbg ( "Trying<S2SV_blank>sectorsize<S2SV_blank>%d\\n" , ssize ) ; status = 0 ; if ( type == 0 ) { position = ssize * 256 ; } else if ( type == 1 ) { position = devsize - ssize ; } else if ( type == 2 ) { position = devsize - ssize - 256 * ssize ; } else { position = ssize * 512 ; type = 0 ; } dbg ( "DevSize:<S2SV_blank>%zu\\n" , devsize ) ; dbg ( "Current<S2SV_blank>position:<S2SV_blank>%lx\\n" , position ) ; if ( disc -> udf_anchor [ type ] == NULL ) { disc -> udf_anchor [ type ] = malloc ( sizeof ( struct anchorVolDescPtr ) ) ; } desc_tag = * ( tag * ) ( dev + position ) ; if ( ! checksum ( desc_tag ) ) { status |= E_CHECKSUM ; continue ; } if ( le16_to_cpu ( desc_tag . tagIdent ) != TAG_IDENT_AVDP ) { status |= E_WRONGDESC ; continue ; } dbg ( "Tag<S2SV_blank>Serial<S2SV_blank>Num:<S2SV_blank>%d\\n" , desc_tag . tagSerialNum ) ; if ( stats -> AVDPSerialNum == 0xFFFF ) { stats -> AVDPSerialNum = desc_tag . tagSerialNum ; } else if ( stats -> AVDPSerialNum != desc_tag . tagSerialNum ) { stats -> AVDPSerialNum = 0 ; } memcpy ( disc -> udf_anchor [ type ] , dev + position , sizeof ( struct anchorVolDescPtr ) ) ; if ( crc ( disc -> udf_anchor [ type ] , sizeof ( struct anchorVolDescPtr ) ) ) { status |= E_CRC ; continue ; } if ( check_position ( desc_tag , position / ssize ) ) { status |= E_POSITION ; continue ; } dbg ( "AVDP[%d]:<S2SV_blank>Main<S2SV_blank>Ext<S2SV_blank>Len:<S2SV_blank>%d,<S2SV_blank>Reserve<S2SV_blank>Ext<S2SV_blank>Len:<S2SV_blank>%d\\n" , type , disc -> udf_anchor [ type ] -> mainVolDescSeqExt . extLength , disc -> udf_anchor [ type ] -> reserveVolDescSeqExt . extLength ) ; <S2SV_StartBug> if ( disc -> udf_anchor [ type ] -> mainVolDescSeqExt . extLength < 16 * ssize || disc -> udf_anchor [ type ] -> reserveVolDescSeqExt . extLength < 16 * ssize ) { <S2SV_EndBug> status |= E_EXTLEN ; } msg ( "AVDP[%d]<S2SV_blank>successfully<S2SV_blank>loaded.\\n" , type ) ; * sectorsize = ssize ; if ( status & E_CHECKSUM ) { err ( "Checksum<S2SV_blank>failure<S2SV_blank>at<S2SV_blank>AVDP[%d]\\n" , type ) ; } if ( status & E_WRONGDESC ) { err ( "AVDP<S2SV_blank>not<S2SV_blank>found<S2SV_blank>at<S2SV_blank>0x%lx\\n" , position ) ; } if ( status & E_CRC ) { err ( "CRC<S2SV_blank>error<S2SV_blank>at<S2SV_blank>AVDP[%d]\\n" , type ) ; } if ( status & E_POSITION ) { err ( "Position<S2SV_blank>mismatch<S2SV_blank>at<S2SV_blank>AVDP[%d]\\n" , type ) ; } if ( status & E_EXTLEN ) { err ( "Main<S2SV_blank>or<S2SV_blank>Reserve<S2SV_blank>Extent<S2SV_blank>Length<S2SV_blank>at<S2SV_blank>AVDP[%d]<S2SV_blank>is<S2SV_blank>less<S2SV_blank>than<S2SV_blank>16<S2SV_blank>sectors\\n" , type ) ; } return status ; } return status ; } | <S2SV_ModStart> extLength ) ; dbg ( "AVDP[%d]:<S2SV_blank>Main<S2SV_blank>Ext<S2SV_blank>Pos:<S2SV_blank>0x%08x,<S2SV_blank>Reserve<S2SV_blank>Ext<S2SV_blank>Pos:<S2SV_blank>0x%08x\\n" , type , disc -> udf_anchor [ type ] -> mainVolDescSeqExt . extLocation , disc -> udf_anchor [ type ] -> reserveVolDescSeqExt . extLocation ) ; |
4,152 | CWE-000 void initialize ( struct pqueue * pq ) { pq -> f = - 1 ; pq -> r = - 1 ; <S2SV_StartBug> pq -> k = 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ; pq -> count <S2SV_ModEnd> = 0 ; |
4,153 | CWE-000 static void session_set_state ( SESSION_INSTANCE * session_instance , SESSION_STATE session_state ) { <S2SV_StartBug> uint64_t i ; <S2SV_EndBug> session_instance -> previous_session_state = session_instance -> session_state ; session_instance -> session_state = session_state ; for ( i = 0 ; i < session_instance -> link_endpoint_count ; i ++ ) { if ( session_instance -> link_endpoints [ i ] -> on_session_state_changed != NULL ) { <S2SV_StartBug> session_instance -> link_endpoints [ i ] -> on_session_state_changed ( session_instance -> link_endpoints [ i ] -> callback_context , session_state , session_instance -> previous_session_state ) ; <S2SV_EndBug> } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> session_state ) { uint32_t <S2SV_ModEnd> i ; session_instance <S2SV_ModStart> NULL ) { if ( session_instance -> link_endpoints [ i ] -> link_endpoint_state != LINK_ENDPOINT_STATE_DETACHING ) { <S2SV_ModStart> } } } } |
4,154 | CWE-000 HAL_StatusTypeDef ENC28J60_setup ( ENC28J60 * enc28j60 ) { enc28j60 -> bank = ERXTX_BANK ; enc28j60 -> receivedPackets = 0 ; enc28j60 -> sentPackets = 0 ; periodicTimer_setup ( & enc28j60 -> watchDogTimer , 30 * 1000 ) ; <S2SV_StartBug> _ENC28J60_reset ( enc28j60 ) ; <S2SV_EndBug> ENC28J60_DEBUG_OUT ( "ENC28J60<S2SV_blank>rev.<S2SV_blank>B%d\\n" , _ENC28J60_readRev ( enc28j60 ) ) ; return HAL_OK ; } | <S2SV_ModStart> 1000 ) ; while ( <S2SV_ModStart> _ENC28J60_reset ( enc28j60 ) != 0 |
4,155 | CWE-000 void initInterruptFromEncoderSensor ( ) { ConfigIntQEI ( QEI_INT_PRI_6 & QEI_INT_ENABLE ) ; POSCNT = 0 ; <S2SV_StartBug> MAXCNT = 0x7FFF ; <S2SV_EndBug> OpenQEI ( QEI_IDLE_CON & QEI_INT_CLK & QEI_INDEX_RESET_DISABLE & QEI_CLK_PRESCALE_1 & QEI_GATED_ACC_DISABLE & QEI_INPUTS_NOSWAP & QEI_MODE_x4_MATCH & QEI_DIR_SEL_CNTRL , POS_CNT_ERR_INT_DISABLE & QEI_QE_CLK_DIVIDE_1_4 & QEI_QE_OUT_ENABLE & MATCH_INDEX_PHASEA_HIGH & MATCH_INDEX_PHASEB_HIGH ) ; <S2SV_StartBug> QEICONbits . UPDN = 1 ; <S2SV_EndBug> } | <S2SV_ModStart> ; MAXCNT = 0xFFFF <S2SV_ModEnd> ; OpenQEI ( <S2SV_ModStart> MATCH_INDEX_PHASEB_HIGH ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,156 | CWE-000 void raspberrypi_photoupload_run ( void * messageLoop ) { IoTKitHoLContext iotKitHoLContext ; IOTHUB_CLIENT_HANDLE iotHubClientHandle ; iotKitHoLContext . messageLoop = messageLoop ; time_t now ; struct tm * local ; char * photoFileName ; const unsigned char * photoContent ; long contentLength ; if ( platform_init ( ) != 0 ) { printf ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>the<S2SV_blank>platform.\\r\\n" ) ; } else { ( void ) printf ( "Starting<S2SV_blank>the<S2SV_blank>IoTHub<S2SV_blank>client<S2SV_blank>sample<S2SV_blank>upload<S2SV_blank>to<S2SV_blank>blob...\\r\\n" ) ; if ( ( iotHubClientHandle = IoTHubClient_CreateFromConnectionString ( connectionString , HTTP_Protocol ) ) == NULL ) { ( void ) printf ( "ERROR:<S2SV_blank>iotHubClientHandle<S2SV_blank>is<S2SV_blank>NULL!\\r\\n" ) ; } else { iotKitHoLContext . iotHubClientHandle = iotHubClientHandle ; printf ( "Connected<S2SV_blank>to<S2SV_blank>IoT<S2SV_blank>Hub\\r\\n" ) ; while ( true ) { photoContent = take_photo ( & contentLength ) ; if ( photoContent != NULL ) { now = time ( NULL ) ; local = localtime ( & now ) ; photoFileName = ( char * ) malloc ( strlen ( deviceId ) + 32 ) ; sprintf ( photoFileName , "%s_%04d_%02d_%02d_%02d_%02d_%02d_Pro.jpg" , deviceId , local -> tm_year + 1900 , local -> tm_mon + 1 , local -> tm_mday , local -> tm_hour , local -> tm_min , local -> tm_sec ) ; printf ( "Try<S2SV_blank>to<S2SV_blank>upload<S2SV_blank>as<S2SV_blank>%s<S2SV_blank>size<S2SV_blank>is<S2SV_blank>%d\\r\\n" , photoFileName , contentLength ) ; <S2SV_StartBug> if ( IoTHubClient_UploadToBlobAsync ( iotHubClientHandle , photoFileName , photoContent , contentLength , UploadCallback , iotKitHolContext ) != IOTHUB_CLIENT_OK ) <S2SV_EndBug> { printf ( "Failed<S2SV_blank>to<S2SV_blank>upload<S2SV_blank>picture\\r\\n" ) ; } else { printf ( "Uploaded<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>bytes.\\r\\n" , photoFileName , contentLength ) ; } free ( ( void * ) photoFileName ) ; free ( ( void * ) photoContent ) ; } else { printf ( "Failed<S2SV_blank>to<S2SV_blank>take<S2SV_blank>a<S2SV_blank>picture\\r\\n" ) ; } sleep ( duration ) ; } IoTHubClient_Destroy ( iotHubClientHandle ) ; } platform_deinit ( ) ; } } | <S2SV_ModStart> , UploadCallback , & iotKitHoLContext <S2SV_ModEnd> ) != IOTHUB_CLIENT_OK |
4,157 | CWE-000 void parse ( logic_signal_packet * in , frame_struct * out ) { uint32_t count_1 = 0 ; uint32_t count_0 = 0 ; uint32_t check = 0 ; uint32_t result [ 4 ] = { 0 } ; int i = target_buffer_len ; int count = 159 ; int payload_len = - 1 ; while ( i >= 0 ) { uint8_t cur_bit = ( in -> bits [ count / 32 ] & ( 0x01 << ( count % 32 ) ) ) ? 0x01 : 0x00 ; if ( cur_bit != 0 ) { count_1 ++ ; count_0 = 0 ; } else { count_0 ++ ; count_1 = 0 ; } <S2SV_StartBug> if ( count_1 == 5 || count_0 == 5 ) { <S2SV_EndBug> if ( payload_len > 0 ) { if ( ( target_buffer_len - i - 8 * payload_len ) < 34 ) count -- ; } else count -- ; count_1 = 0 ; count_0 = 0 ; } { result [ i / 32 ] |= cur_bit << i % 32 ; i -- ; if ( target_buffer_len - i == 19 ) { payload_len = ( result [ 3 ] >> 13 ) & 0xf ; if ( payload_len > 8 ) payload_len = 8 ; } } if ( target_buffer_len - i == 8 * payload_len + 19 + 25 ) break ; count -- ; } out -> SOF = ( result [ 3 ] >> 31 ) & 0x1 ; out -> ID_A = 0 ; for ( int i = 30 ; i >= 20 ; i -- ) out -> ID_A = out -> ID_A + ( ( ( result [ 3 ] >> i ) & 0x1 ) << ( i - 20 ) ) ; out -> RTR = ( result [ 3 ] >> 19 ) & 0x1 ; out -> IDE = ( result [ 3 ] >> 18 ) & 0x1 ; out -> r0 = ( result [ 3 ] >> 17 ) & 0x1 ; out -> DLC = ( result [ 3 ] >> 13 ) & 0xf ; for ( int j = 1 ; j < out -> DLC + 1 ; j ++ ) { uint32_t data_base = target_buffer_len - 19 - 8 * j ; uint32_t _tmp = 0 ; if ( data_base % 32 > 24 ) { _tmp = result [ data_base / 32 ] >> ( data_base % 32 + 1 ) ; _tmp |= result [ data_base / 32 + 1 ] << ( 31 - data_base % 32 ) ; _tmp &= 0xff ; } else { _tmp = result [ data_base / 32 ] >> ( data_base % 32 + 1 ) ; _tmp &= 0xff ; } } switch ( out -> DLC ) { case 0 : out -> data [ 0 ] = '\\0' ; for ( int i = 24 ; i >= 10 ; i -- ) out -> CRC = out -> CRC + ( ( ( result [ 2 ] >> i ) & 0x1 ) << ( i - 10 ) ) ; out -> CRC_del = ( result [ 2 ] >> 9 ) & 0x1 ; out -> ACK = ( result [ 3 ] >> 8 ) & 0x1 ; out -> ACK_del = ( result [ 2 ] >> 7 ) & 0x1 ; for ( int i = 6 ; i >= 0 ; i -- ) out -> end_of_frame = out -> end_of_frame + ( ( ( result [ 2 ] >> i ) & 0x1 ) << i ) ; break ; case 1 : { <S2SV_StartBug> out -> data [ 0 ] = '\\0' ; <S2SV_EndBug> for ( int i = 12 ; i >= 5 ; i -- ) { out -> data [ 0 ] = out -> data [ 0 ] | ( ( ( result [ 3 ] >> i ) & 0x1 ) << ( i - 5 ) ) ; } out -> data [ 1 ] = '\\0' ; <S2SV_StartBug> for ( int i = 4 ; i >= 0 ; i -- ) <S2SV_EndBug> <S2SV_StartBug> out -> CRC = out -> CRC + ( ( result [ 3 ] >> i ) & 0x1 ) << ( i + 10 ) ; <S2SV_EndBug> <S2SV_StartBug> for ( int i = 31 ; i >= 22 ; i -- ) <S2SV_EndBug> <S2SV_StartBug> out -> CRC = out -> CRC + ( ( result [ 2 ] >> i ) & 0x1 ) << ( i - 22 ) ; <S2SV_EndBug> out -> CRC_del = ( result [ 2 ] >> 21 ) & 0x1 ; out -> ACK = ( result [ 2 ] >> 20 ) & 0x1 ; out -> ACK_del = ( result [ 2 ] >> 19 ) & 0x1 ; for ( int i = 18 ; i >= 12 ; i -- ) <S2SV_StartBug> out -> end_of_frame = out -> end_of_frame + ( ( ( result [ 2 ] >> i ) & 0x1 ) << ( i - 12 ) ) ; <S2SV_EndBug> break ; } } } | <S2SV_ModStart> } if ( <S2SV_ModEnd> count_0 == 5 <S2SV_ModStart> { out -> CRC = 0 ; out -> <S2SV_ModStart> i -- ) { <S2SV_ModStart> + ( ( ( <S2SV_ModStart> + 10 ) ) ; } <S2SV_ModEnd> for ( int <S2SV_ModStart> i -- ) { <S2SV_ModStart> + ( ( ( <S2SV_ModStart> - 22 ) ) ; } <S2SV_ModEnd> out -> CRC_del <S2SV_ModStart> ( ( ( ( <S2SV_ModStart> 12 ) ) ) |
4,158 | CWE-000 static void clearpad_funcarea_down ( struct clearpad_t * this , struct clearpad_pointer_t * pointer ) { int touch_major , touch_minor ; struct clearpad_button_data_t * button ; struct clearpad_pointer_data_t * pointer_data ; struct clearpad_point_t * cur = & pointer -> cur ; struct input_dev * idev = this -> input ; bool valid ; switch ( pointer -> funcarea -> func ) { case SYN_FUNCAREA_INSENSIBLE : LOG_EVENT ( this , "insensible\\n" ) ; pointer -> down = false ; break ; case SYN_FUNCAREA_POINTER : clearpad_funcarea_crop ( & pointer -> funcarea -> original , cur ) ; pointer_data = ( struct clearpad_pointer_data_t * ) pointer -> funcarea -> data ; if ( pointer_data ) { cur -> x -= pointer_data -> offset_x ; cur -> y -= pointer_data -> offset_y ; } if ( cur -> tool == SYN_TOOL_PEN ) { cur -> tool = MT_TOOL_PEN ; } else { if ( cur -> tool == SYN_TOOL_GLOVE ) { if ( cur -> z > 0 ) cur -> z += SYN_MAX_Z_VALUE + 1 ; else cur -> z = 0 ; } else { if ( cur -> z > SYN_MAX_Z_VALUE ) cur -> z = SYN_MAX_Z_VALUE ; } cur -> tool = MT_TOOL_FINGER ; } valid = idev -> users > 0 ; LOG_EVENT ( this , "%s[%d]:<S2SV_blank>(x,y)=(%d,%d)<S2SV_blank>w=(%d,%d)<S2SV_blank>z=%d<S2SV_blank>t=%d\\n" , valid ? "pt" : "unused<S2SV_blank>pt" , cur -> id , cur -> x , cur -> y , cur -> wx , cur -> wy , cur -> z , cur -> tool ) ; if ( ! valid ) break ; touch_major = max ( cur -> wx , cur -> wy ) + 1 ; touch_minor = min ( cur -> wx , cur -> wy ) + 1 ; <S2SV_StartBug> input_report_abs ( idev , ABS_MT_TRACKING_ID , cur -> id ) ; <S2SV_EndBug> <S2SV_StartBug> input_report_abs ( idev , ABS_MT_TOOL_TYPE , cur -> tool ) ; <S2SV_EndBug> input_report_abs ( idev , ABS_MT_POSITION_X , cur -> x ) ; input_report_abs ( idev , ABS_MT_POSITION_Y , cur -> y ) ; if ( this -> touch_pressure_enabled ) input_report_abs ( idev , ABS_MT_PRESSURE , cur -> z ) ; if ( this -> touch_size_enabled ) { input_report_abs ( idev , ABS_MT_TOUCH_MAJOR , touch_major ) ; input_report_abs ( idev , ABS_MT_TOUCH_MINOR , touch_minor ) ; } if ( this -> touch_orientation_enabled ) input_report_abs ( idev , ABS_MT_ORIENTATION , <S2SV_StartBug> ( cur -> wx > cur -> wy ) ) ; <S2SV_EndBug> input_mt_sync ( idev ) ; break ; case SYN_FUNCAREA_BUTTON : LOG_EVENT ( this , "button\\n" ) ; button = ( struct clearpad_button_data_t * ) pointer -> funcarea -> data ; if ( button ) button -> down = true ; break ; default : break ; } } | <S2SV_ModStart> + 1 ; input_mt_slot ( idev <S2SV_ModEnd> , cur -> <S2SV_ModStart> id ) ; input_mt_report_slot_state ( idev <S2SV_ModEnd> , cur -> <S2SV_ModStart> cur -> tool , true <S2SV_ModStart> -> wy ) <S2SV_ModEnd> ) ; break |
4,159 | CWE-000 void printPicture ( BaseSequentialStream * chp , int argc , char * argv [ ] ) { <S2SV_StartBug> ( void ) chp ; <S2SV_EndBug> ( void ) argc ; ( void ) argv ; ssdv_conf_t conf = { . res = RES_VGA , . quality = 4 , . ram_buffer = usb_buffer , . ram_size = sizeof ( usb_buffer ) , } ; bool camera_found = takePicture ( & conf , false ) ; if ( camera_found ) { bool start_detected = false ; for ( uint32_t i = 0 ; i < conf . size_sampled ; i ++ ) { if ( ! start_detected && conf . ram_buffer [ i ] == 0xFF && conf . ram_buffer [ i + 1 ] == 0xE0 ) { start_detected = true ; TRACE_USB ( "DATA<S2SV_blank>><S2SV_blank>image/jpeg,%d" , conf . size_sampled - i + 1 ) ; <S2SV_StartBug> streamPut ( & SDU1 , 0xFF ) ; <S2SV_EndBug> <S2SV_StartBug> streamPut ( & SDU1 , 0xD8 ) ; <S2SV_EndBug> } if ( start_detected ) <S2SV_StartBug> streamPut ( & SDU1 , conf . ram_buffer [ i ] ) ; <S2SV_EndBug> } } else { <S2SV_StartBug> for ( uint32_t i = 0 ; i < sizeof ( noCameraFound ) ; i ++ ) <S2SV_EndBug> streamPut ( & SDU1 , noCameraFound [ i ] ) ; } } | <S2SV_ModStart> ( void ) <S2SV_ModEnd> argc ; ( <S2SV_ModStart> ; streamPut ( chp <S2SV_ModEnd> , 0xFF ) <S2SV_ModStart> ; streamPut ( chp <S2SV_ModEnd> , 0xD8 ) <S2SV_ModStart> ) streamPut ( chp , conf . ram_buffer [ i ] ) ; } if ( ! start_detected ) { TRACE_USB ( "DATA<S2SV_blank>><S2SV_blank>image,jpeg,0" ) ; TRACE_USB ( "DATA<S2SV_blank>><S2SV_blank>error,no<S2SV_blank>SOI<S2SV_blank>flag<S2SV_blank>found" <S2SV_ModEnd> ) ; } <S2SV_ModStart> } else { TRACE_USB ( "DATA<S2SV_blank>><S2SV_blank>image,jpeg,0" ) ; TRACE_USB ( "DATA<S2SV_blank>><S2SV_blank>error,no<S2SV_blank>camera<S2SV_blank>found" <S2SV_ModEnd> ) ; } |
4,160 | CWE-000 int xhci_intr1 ( struct xhci_softc * const sc ) { uint32_t usbsts ; uint32_t iman ; XHCIHIST_FUNC ( ) ; XHCIHIST_CALLED ( ) ; usbsts = xhci_op_read_4 ( sc , XHCI_USBSTS ) ; DPRINTFN ( 16 , "USBSTS<S2SV_blank>%08jx" , usbsts , 0 , 0 , 0 ) ; <S2SV_StartBug> # if 0 <S2SV_EndBug> <S2SV_StartBug> if ( ( usbsts & ( XHCI_STS_EINT | XHCI_STS_PCD ) ) == 0 ) { <S2SV_EndBug> return 0 ; } # endif xhci_op_write_4 ( sc , XHCI_USBSTS , <S2SV_StartBug> usbsts & ( 2 | XHCI_STS_EINT | XHCI_STS_PCD ) ) ; <S2SV_EndBug> usbsts = xhci_op_read_4 ( sc , XHCI_USBSTS ) ; <S2SV_StartBug> DPRINTFN ( 16 , "USBSTS<S2SV_blank>%08jx" , usbsts , 0 , 0 , 0 ) ; <S2SV_EndBug> iman = xhci_rt_read_4 ( sc , XHCI_IMAN ( 0 ) ) ; DPRINTFN ( 16 , "IMAN0<S2SV_blank>%08jx" , iman , 0 , 0 , 0 ) ; iman |= XHCI_IMAN_INTR_PEND ; xhci_rt_write_4 ( sc , XHCI_IMAN ( 0 ) , iman ) ; <S2SV_StartBug> iman = xhci_rt_read_4 ( sc , XHCI_IMAN ( 0 ) ) ; <S2SV_EndBug> DPRINTFN ( 16 , "IMAN0<S2SV_blank>%08jx" , iman , 0 , 0 , 0 ) ; usbsts = xhci_op_read_4 ( sc , XHCI_USBSTS ) ; <S2SV_StartBug> DPRINTFN ( 16 , "USBSTS<S2SV_blank>%08jx" , usbsts , 0 , 0 , 0 ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> 0 ) ; if <S2SV_ModEnd> ( ( usbsts <S2SV_ModStart> usbsts & ( XHCI_STS_HSE <S2SV_ModEnd> | XHCI_STS_EINT | <S2SV_ModStart> XHCI_STS_EINT | XHCI_STS_PCD | XHCI_STS_HCE ) ) == 0 ) { DPRINTFN ( 16 , "ignored<S2SV_blank>intr<S2SV_blank>not<S2SV_blank>for<S2SV_blank>%s" , device_xname ( sc -> sc_dev ) , 0 , 0 , 0 ) ; return 0 ; } xhci_op_write_4 ( sc , XHCI_USBSTS , usbsts & XHCI_STS_RSVDP0 ) ; # ifdef XHCI_DEBUG <S2SV_ModEnd> usbsts = xhci_op_read_4 <S2SV_ModStart> 0 ) ; # endif <S2SV_ModStart> iman ) ; # ifdef XHCI_DEBUG <S2SV_ModStart> 0 ) ; # endif |
4,161 | CWE-000 int ft_precision ( t_datas * datas , char * strflag , t_flags * flags , size_t * i ) { int result ; int len ; if ( strflag [ 0 ] != '.' ) return ( 0 ) ; <S2SV_StartBug> flags -> zero = 0 ; <S2SV_EndBug> if ( strflag [ 1 ] == '*' ) return ( ft_arg_precision ( datas , strflag + 2 , flags , i ) ) ; else if ( strflag [ 1 ] >= '1' && strflag [ 1 ] <= '9' ) { result = ft_atoi ( strflag + 1 ) ; len = ft_ilen ( result , 10 ) ; if ( strflag [ len + 1 ] == '$' ) return ( - 1 ) ; flags -> precision = result ; <S2SV_StartBug> * i += len + 1 ; <S2SV_EndBug> return ( 1 ) ; } else flags -> precision = 0 ; return ( 1 ) ; } | <S2SV_ModStart> zero = 0 ; * i += 1 <S2SV_ModStart> i += len <S2SV_ModEnd> ; return ( |
4,162 | CWE-000 void task_par_matprod_outer ( helpers_op_t op , helpers_var_ptr sz , helpers_var_ptr sx , helpers_var_ptr sy ) { double * MATPROD_RESTRICT x = REAL ( sx ) ; double * MATPROD_RESTRICT y = REAL ( sy ) ; double * MATPROD_RESTRICT z = REAL ( sz ) ; helpers_size_t n = LENGTH ( sx ) ; if ( n <= 1 ) { if ( n == 1 ) { task_par_matprod_scalar_vec ( op , sz , sx , sy ) ; } return ; } helpers_size_t m = LENGTH ( sy ) ; if ( m <= 1 ) { if ( m == 1 ) { task_par_matprod_scalar_vec ( op , sz , sy , sx ) ; } return ; } SETUP_SPLIT ( 4 * s > m ) if ( s > 1 ) { helpers_size_t d , d1 , a , a1 ; d = w == 0 ? 0 : ( helpers_size_t ) ( ( double ) m * w / s ) & ~ 3 ; d1 = w == s - 1 ? m : ( helpers_size_t ) ( ( double ) m * ( w + 1 ) / s ) & ~ 3 ; a = d ; a1 = d1 ; while ( d < d1 ) { helpers_size_t od = d ; helpers_size_t na = d1 - d <= 4 ? a1 : d + 4 ; <S2SV_StartBug> HELPERS_WAIT_IN2 ( a , na - 1 , a1 ) ; <S2SV_EndBug> d = a ; if ( d < m ) d &= ~ 3 ; if ( d > d1 ) d = d1 ; matprod_outer ( x , y + od , z + od * n , n , d - od EXTRA ( z , z + od * n , w ) ) ; } if ( w != 0 ) WAIT_FOR_EARLIER_TASKS ( sz ) ; } else { helpers_size_t d = 0 ; helpers_size_t a = 0 ; while ( d < m ) { helpers_size_t od = d ; helpers_size_t na = m - d <= 4 ? m : d + 4 ; HELPERS_WAIT_IN2 ( a , na - 1 , m ) ; d = a ; if ( d < m ) d &= ~ 3 ; matprod_outer ( x , y + od , z + od * n , n , d - od EXTRA ( z , z + od * n , 0 ) ) ; } } } | <S2SV_ModStart> - 1 , m ) ; if ( a > a1 ) a = a1 <S2SV_ModEnd> ; d = |
4,163 | CWE-000 size_t mov_write_stsz ( const struct mov_t * mov ) { size_t size , i ; const struct mov_track_t * track = mov -> track ; const struct mov_stbl_t * stbl = & mov -> track -> stbl ; for ( i = 1 ; i < track -> sample_count ; i ++ ) { if ( track -> samples [ i ] . bytes != track -> samples [ i - 1 ] . bytes ) break ; } size = 12 + 8 + ( i < track -> sample_count ? 4 * track -> sample_count : 0 ) ; file_writer_wb32 ( mov -> fp , size ) ; file_writer_write ( mov -> fp , "stsz" , 4 ) ; file_writer_wb32 ( mov -> fp , 0 ) ; if ( i < track -> sample_count ) { file_writer_wb32 ( mov -> fp , 0 ) ; <S2SV_StartBug> file_writer_wb32 ( mov -> fp , stbl -> stsc_count ) ; <S2SV_EndBug> for ( i = 0 ; i < track -> sample_count ; i ++ ) file_writer_wb32 ( mov -> fp , track -> samples [ i ] . bytes ) ; } else { file_writer_wb32 ( mov -> fp , track -> sample_count < 1 ? 0 : track -> samples [ 0 ] . bytes ) ; file_writer_wb32 ( mov -> fp , track -> sample_count ) ; } return size ; } | <S2SV_ModStart> -> fp , track -> sample_count <S2SV_ModEnd> ) ; for |
4,164 | CWE-000 bool is_uint8 ( const char * val ) { char * end = NULL ; <S2SV_StartBug> long int v = strtol ( val , & end , 0 ) ; <S2SV_EndBug> if ( end == NULL || * end != '\\0' ) return false ; if ( v < 0 || v > UINT8_MAX ) return false ; <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> = NULL ; int pre_err = errno ; errno = 0 ; <S2SV_ModStart> int v = strtoul <S2SV_ModEnd> ( val , <S2SV_ModStart> return false ; if ( errno == ERANGE ) { errno = pre_err ; return false ; } |
4,165 | CWE-000 static bool dentry_connected ( struct dentry * dentry ) { dget ( dentry ) ; while ( dentry -> d_flags & DCACHE_DISCONNECTED ) { struct dentry * parent = dget_parent ( dentry ) ; dput ( dentry ) ; <S2SV_StartBug> if ( IS_ROOT ( dentry ) ) { <S2SV_EndBug> dput ( parent ) ; return false ; } dentry = parent ; } dput ( dentry ) ; return true ; } | <S2SV_ModStart> ; if ( dentry == parent <S2SV_ModEnd> ) { dput |
4,166 | CWE-000 static int suspend_bw_hwmon ( struct bw_hwmon * hw ) { struct bwmon * m = to_bwmon ( hw ) ; <S2SV_StartBug> disable_irq ( m -> irq ) ; <S2SV_EndBug> mon_disable ( m ) ; <S2SV_StartBug> mon_irq_disable ( m ) ; <S2SV_EndBug> mon_irq_clear ( m ) ; return 0 ; } | <S2SV_ModStart> hw ) ; mon_irq_disable <S2SV_ModEnd> ( m ) <S2SV_ModStart> m ) ; free_irq ( m -> irq , m ) ; mon_disable <S2SV_ModEnd> ( m ) |
4,167 | CWE-000 void SetStoredBaud ( unsigned long baud ) { <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < 4 ; i ++ ) { EEPROM_Write ( i , ( baud & ( ( ( unsigned long ) 0xFF ) << i * 8 ) ) >> i * 8 ) ; Delay_ms ( 20 ) ; } } | <S2SV_ModStart> { int i = 0 |
4,168 | CWE-000 static int32 stat ( FileSystemNode * node , struct stat * buf ) { char targetPath [ 128 ] ; FileSystemNode * n = node ; <S2SV_StartBug> int charIndex = 127 ; <S2SV_EndBug> targetPath [ charIndex ] = '\\0' ; while ( NULL == n -> mountSource ) { int length = strlen ( n -> name ) ; charIndex -= length ; if ( charIndex < 2 ) { return NULL ; } strcpyNonNull ( targetPath + charIndex , n -> name ) ; charIndex -= 1 ; targetPath [ charIndex ] = '/' ; n = n -> parent ; } char number [ 8 ] ; sprintf ( number , "%d" , n -> privateNodeData ) ; targetPath [ charIndex ] = ':' ; int length = strlen ( number ) ; charIndex -= length ; if ( charIndex < 0 ) { return NULL ; } strcpyNonNull ( targetPath + charIndex , number ) ; char * target = targetPath + charIndex ; FILINFO fileInfo ; memset ( ( uint8 * ) & fileInfo , 0 , sizeof ( FILINFO ) ) ; FRESULT fr = f_stat ( target , & fileInfo ) ; if ( FR_OK == fr ) { if ( ( fileInfo . fattrib & AM_DIR ) == AM_DIR ) { node -> nodeType = FT_Directory ; } else { node -> nodeType = FT_File ; } node -> length = fileInfo . fsize ; return 1 ; } return - 1 ; } | <S2SV_ModStart> int charIndex = 126 ; memset ( targetPath , 0 , 128 ) <S2SV_ModEnd> ; while ( |
4,169 | CWE-000 static void rtp_session_process_bye ( RTPSession * sess , GstRTCPPacket * packet , RTPPacketInfo * pinfo ) { guint count , i ; gchar * reason ; gboolean reconsider = FALSE ; reason = gst_rtcp_packet_bye_get_reason ( packet ) ; GST_DEBUG ( "got<S2SV_blank>BYE<S2SV_blank>packet<S2SV_blank>(reason:<S2SV_blank>%s)" , GST_STR_NULL ( reason ) ) ; count = gst_rtcp_packet_bye_get_ssrc_count ( packet ) ; for ( i = 0 ; i < count ; i ++ ) { guint32 ssrc ; RTPSource * source ; <S2SV_StartBug> gboolean created , prevactive , prevsender ; <S2SV_EndBug> guint pmembers , members ; ssrc = gst_rtcp_packet_bye_get_nth_ssrc ( packet , i ) ; GST_DEBUG ( "SSRC:<S2SV_blank>%08x" , ssrc ) ; <S2SV_StartBug> source = obtain_source ( sess , ssrc , & created , pinfo , FALSE ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! source ) <S2SV_EndBug> return ; if ( source -> internal ) { <S2SV_StartBug> g_object_unref ( source ) ; <S2SV_EndBug> continue ; } source -> bye_time = pinfo -> current_time ; prevactive = RTP_SOURCE_IS_ACTIVE ( source ) ; prevsender = RTP_SOURCE_IS_SENDER ( source ) ; rtp_source_mark_bye ( source , reason ) ; pmembers = sess -> stats . active_sources ; source_update_active ( sess , source , prevactive ) ; source_update_sender ( sess , source , prevsender ) ; members = sess -> stats . active_sources ; if ( ! sess -> scheduled_bye && members < pmembers ) { if ( sess -> next_rtcp_check_time != GST_CLOCK_TIME_NONE && pinfo -> current_time < sess -> next_rtcp_check_time ) { GstClockTime time_remaining ; if ( sess -> last_rtcp_send_time == GST_CLOCK_TIME_NONE || ! ( sess -> rtp_profile == GST_RTP_PROFILE_AVPF || sess -> rtp_profile == GST_RTP_PROFILE_SAVPF ) || sess -> next_rtcp_check_time - sess -> last_rtcp_send_time == sess -> last_rtcp_interval ) { time_remaining = sess -> next_rtcp_check_time - pinfo -> current_time ; sess -> next_rtcp_check_time = gst_util_uint64_scale ( time_remaining , members , pmembers ) ; sess -> next_rtcp_check_time += pinfo -> current_time ; } sess -> last_rtcp_interval = gst_util_uint64_scale ( sess -> last_rtcp_interval , members , pmembers ) ; GST_DEBUG ( "reverse<S2SV_blank>reconsideration<S2SV_blank>%" GST_TIME_FORMAT , GST_TIME_ARGS ( sess -> next_rtcp_check_time ) ) ; reconsider = TRUE ; } } <S2SV_StartBug> if ( created ) <S2SV_EndBug> on_new_ssrc ( sess , source ) ; <S2SV_StartBug> on_bye_ssrc ( sess , source ) ; <S2SV_EndBug> g_object_unref ( source ) ; } if ( reconsider ) { RTP_SESSION_UNLOCK ( sess ) ; if ( sess -> callbacks . reconsider ) sess -> callbacks . reconsider ( sess , sess -> reconsider_user_data ) ; RTP_SESSION_LOCK ( sess ) ; } g_free ( reason ) ; } | <S2SV_ModStart> source ; gboolean <S2SV_ModEnd> prevactive , prevsender <S2SV_ModStart> ; source = find_source <S2SV_ModEnd> ( sess , <S2SV_ModStart> sess , ssrc <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( ! source || <S2SV_ModEnd> source -> internal <S2SV_ModStart> internal ) { GST_DEBUG ( "Ignoring<S2SV_blank>suspicious<S2SV_blank>BYE<S2SV_blank>packet<S2SV_blank>(reason:<S2SV_blank>%s)" , ! source ? "can\'t<S2SV_blank>find<S2SV_blank>source" : "has<S2SV_blank>internal<S2SV_blank>source<S2SV_blank>SSRC" ) ; break <S2SV_ModEnd> ; } source <S2SV_ModStart> ; } } <S2SV_ModEnd> on_bye_ssrc ( sess <S2SV_ModStart> ( sess , <S2SV_ModEnd> source ) ; |
4,170 | CWE-000 static void atoi_tab ( char * * tab , t_map * map ) { int i ; int n ; n = 0 ; i = 0 ; while ( tab [ n ] ) <S2SV_StartBug> ++ n ; <S2SV_EndBug> while ( tab [ i ] ) { map -> data [ map -> sizey * n + i ] = ft_atoi ( tab [ i ] ) ; ++ i ; } ft_set_sizex ( map , i ) ; } | <S2SV_ModStart> n ] ) { if ( tab [ n ] [ 0 ] > '9' || tab [ n ] [ 0 ] > '0' ) exit ( 1 ) ; <S2SV_ModStart> ++ n ; } |
4,171 | CWE-000 expublic int accept_connection ( void ) { int ret = EXSUCCEED ; tp_conversation_control_t * conv ; char fn [ ] = "accept_connection" ; long revent ; int q_opened = EXFALSE ; char their_qstr [ NDRX_MAX_Q_SIZE + 1 ] ; ATMI_TLS_ENTRY ; conv = & G_atmi_tls -> G_accepted_connection ; conv -> flags = G_atmi_tls -> G_last_call . flags ; conv -> cd = G_atmi_tls -> G_last_call . cd - MAX_CONNECTIONS ; conv -> status = CONV_IN_CONVERSATION ; conv -> msgseqout = NDRX_CONF_MSGSEQ_START ; conv -> msgseqin = NDRX_CONF_MSGSEQ_START ; conv -> callseq = G_atmi_tls -> G_last_call . callseq ; snprintf ( conv -> my_listen_q_str , sizeof ( conv -> my_listen_q_str ) , NDRX_CONV_SRV_Q , G_atmi_tls -> G_atmi_conf . q_prefix , G_atmi_tls -> G_last_call . my_id , G_atmi_tls -> G_last_call . cd - MAX_CONNECTIONS , G_atmi_tls -> G_atmi_conf . my_id ) ; if ( ( mqd_t ) EXFAIL == ( conv -> my_listen_q = open_conv_q ( conv -> my_listen_q_str , & conv -> my_q_attr ) ) ) { NDRX_LOG ( log_error , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>listen<S2SV_blank>queue" , __func__ ) ; ret = EXFAIL ; goto out ; } q_opened = EXTRUE ; NDRX_STRCPY_SAFE ( conv -> reply_q_str , G_atmi_tls -> G_last_call . reply_to ) ; if ( 0 != G_atmi_tls -> G_last_call . callstack [ 0 ] ) { br_dump_nodestack ( G_atmi_tls -> G_last_call . callstack , "Incoming<S2SV_blank>conversation<S2SV_blank>from<S2SV_blank>bridge," "using<S2SV_blank>first<S2SV_blank>node<S2SV_blank>from<S2SV_blank>node<S2SV_blank>stack" ) ; # ifndef EX_USE_POLL snprintf ( their_qstr , sizeof ( their_qstr ) , NDRX_SVC_QBRDIGE , G_atmi_tls -> G_atmi_conf . q_prefix , ( int ) G_atmi_tls -> G_last_call . callstack [ 0 ] ) ; # else { int is_bridge ; char tmpsvc [ MAXTIDENT + 1 ] ; sprintf ( tmpsvc , NDRX_SVC_BRIDGE , ( int ) G_atmi_tls -> G_last_call . callstack [ 0 ] ) ; <S2SV_StartBug> if ( EXSUCCEED != ndrx_shm_get_svc ( tmpsvc , their_qstr , & is_bridge ) ) <S2SV_EndBug> { NDRX_LOG ( log_error , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>bridge<S2SV_blank>svc:<S2SV_blank>[%s]" , tmpsvc ) ; EXFAIL_OUT ( ret ) ; } } # endif } else { NDRX_STRCPY_SAFE ( their_qstr , conv -> reply_q_str ) ; } NDRX_LOG ( log_debug , "Connecting<S2SV_blank>to:<S2SV_blank>[%s]" , their_qstr ) ; if ( ( mqd_t ) EXFAIL == ( conv -> reply_q = open_reply_q ( their_qstr , & conv -> reply_q_attr ) ) ) { NDRX_LOG ( log_error , "%s:<S2SV_blank>Cannot<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>reply<S2SV_blank>queue<S2SV_blank>[%s]<S2SV_blank>-<S2SV_blank>" "cannot<S2SV_blank>accept<S2SV_blank>connection!" , __func__ , their_qstr ) ; ret = EXFAIL ; goto out ; } NDRX_LOG ( log_debug , "About<S2SV_blank>to<S2SV_blank>send<S2SV_blank>handshake<S2SV_blank>back<S2SV_blank>to<S2SV_blank>client..." ) ; if ( EXSUCCEED != ndrx_tpsend ( G_atmi_tls -> G_last_call . cd , NULL , 0 , 0 , & revent , ATMI_COMMAND_CONNRPLY ) ) { NDRX_LOG ( log_error , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>reply<S2SV_blank>for<S2SV_blank>acceptance!" ) ; ret = EXFAIL ; } out : if ( EXSUCCEED != ret && q_opened ) { if ( EXFAIL == ndrx_mq_close ( conv -> my_listen_q ) ) { NDRX_LOG ( log_warn , "Failed<S2SV_blank>to<S2SV_blank>close<S2SV_blank>%s:%s" , conv -> my_listen_q_str , strerror ( errno ) ) ; } } if ( EXSUCCEED == ret ) { conv -> handshaked = EXTRUE ; } NDRX_LOG ( log_debug , "%s:<S2SV_blank>returns<S2SV_blank>%d" , __func__ , ret ) ; return ret ; } | <S2SV_ModStart> , & is_bridge , NULL |
4,172 | CWE-000 int Door_isOpen ( ) { <S2SV_StartBug> return open ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return opened_once <S2SV_ModEnd> ; } <S2SV_null> |
4,173 | CWE-000 static int file_free ( BIO * a ) { if ( a == NULL ) return ( 0 ) ; if ( a -> shutdown ) { if ( ( a -> init ) && ( a -> ptr != NULL ) ) { <S2SV_StartBug> if ( a -> flags & BIO_FLAGS_UPLINK ) <S2SV_EndBug> UP_fclose ( a -> ptr ) ; else fclose ( a -> ptr ) ; a -> ptr = NULL ; a -> flags = BIO_FLAGS_UPLINK ; } a -> init = 0 ; } return ( 1 ) ; } | <S2SV_ModStart> { if ( BIO_UPLINK_SET ( a ) <S2SV_ModEnd> ) UP_fclose ( |
4,174 | CWE-000 int nghttp2_session_want_write ( nghttp2_session * session ) { if ( session -> goaway_flags & NGHTTP2_GOAWAY_TERM_SENT ) { return 0 ; } <S2SV_StartBug> if ( session -> aob . item == NULL && <S2SV_EndBug> <S2SV_StartBug> nghttp2_outbound_queue_top ( & session -> ob_urgent ) == NULL && <S2SV_EndBug> <S2SV_StartBug> nghttp2_outbound_queue_top ( & session -> ob_reg ) == NULL && <S2SV_EndBug> <S2SV_StartBug> ( nghttp2_pq_empty ( & session -> root . obq ) || <S2SV_EndBug> <S2SV_StartBug> session -> remote_window_size == 0 ) && <S2SV_EndBug> <S2SV_StartBug> ( nghttp2_outbound_queue_top ( & session -> ob_syn ) == NULL || <S2SV_EndBug> <S2SV_StartBug> session_is_outgoing_concurrent_streams_max ( session ) ) ) { <S2SV_EndBug> return 0 ; } return ( session -> goaway_flags & ( NGHTTP2_GOAWAY_SENT | NGHTTP2_GOAWAY_RECV ) ) == 0 ; } | <S2SV_ModStart> 0 ; } return <S2SV_ModEnd> session -> aob <S2SV_ModStart> aob . item || <S2SV_ModEnd> nghttp2_outbound_queue_top ( & <S2SV_ModStart> -> ob_urgent ) || <S2SV_ModEnd> nghttp2_outbound_queue_top ( & <S2SV_ModStart> -> ob_reg ) || ( ! <S2SV_ModEnd> nghttp2_pq_empty ( & <S2SV_ModStart> . obq ) && <S2SV_ModEnd> session -> remote_window_size <S2SV_ModStart> session -> remote_window_size > 0 ) || <S2SV_ModEnd> ( nghttp2_outbound_queue_top ( <S2SV_ModStart> -> ob_syn ) && ! <S2SV_ModEnd> session_is_outgoing_concurrent_streams_max ( session <S2SV_ModStart> session ) ) <S2SV_ModEnd> ; } <S2SV_null> |
4,175 | CWE-000 int msm_isp_request_axi_stream ( struct vfe_device * vfe_dev , void * arg ) { <S2SV_StartBug> int rc = 0 , i ; <S2SV_EndBug> uint32_t io_format = 0 ; struct msm_vfe_axi_stream_request_cmd * stream_cfg_cmd = arg ; struct msm_vfe_axi_stream * stream_info ; if ( stream_cfg_cmd -> stream_src >= VFE_AXI_SRC_MAX ) { pr_err ( "%s:%d<S2SV_blank>invalid<S2SV_blank>stream_src<S2SV_blank>%d\\n" , __func__ , __LINE__ , stream_cfg_cmd -> stream_src ) ; return - EINVAL ; } stream_info = msm_isp_get_stream_common_data ( vfe_dev , stream_cfg_cmd -> stream_src ) ; rc = msm_isp_axi_create_stream ( vfe_dev , & vfe_dev -> axi_data , stream_cfg_cmd , stream_info ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>create<S2SV_blank>stream<S2SV_blank>failed\\n" , __func__ ) ; return rc ; } rc = msm_isp_validate_axi_request ( vfe_dev , stream_info , stream_cfg_cmd ) ; if ( rc ) { msm_isp_axi_destroy_stream ( vfe_dev , stream_info ) ; pr_err ( "%s:<S2SV_blank>Request<S2SV_blank>validation<S2SV_blank>failed\\n" , __func__ ) ; return rc ; } stream_info -> rdi_input_type = stream_cfg_cmd -> rdi_input_type ; vfe_dev -> reg_update_requested &= ~ ( BIT ( SRC_TO_INTF ( stream_info -> stream_src ) ) ) ; msm_isp_axi_reserve_wm ( vfe_dev , stream_info ) ; if ( stream_info -> stream_src < RDI_INTF_0 ) { io_format = vfe_dev -> axi_data . src_info [ VFE_PIX_0 ] . input_format ; if ( stream_info -> stream_src == CAMIF_RAW || stream_info -> stream_src == IDEAL_RAW ) { if ( stream_info -> stream_src == CAMIF_RAW && io_format != stream_info -> output_format ) pr_debug ( "%s:<S2SV_blank>Overriding<S2SV_blank>input<S2SV_blank>format\\n" , __func__ ) ; io_format = stream_info -> output_format ; } rc = vfe_dev -> hw_info -> vfe_ops . axi_ops . cfg_io_format ( vfe_dev , stream_info -> stream_src , io_format ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>cfg<S2SV_blank>io<S2SV_blank>format<S2SV_blank>failed\\n" , __func__ ) ; goto done ; } } if ( ! stream_info -> controllable_output ) { if ( stream_info -> num_isp > 1 ) { if ( stream_cfg_cmd -> init_frame_drop != stream_info -> init_frame_drop ) { pr_err ( "%s:<S2SV_blank>stream<S2SV_blank>%d<S2SV_blank>init<S2SV_blank>drop<S2SV_blank>mismatch<S2SV_blank>%d/%d\\n" , __func__ , stream_info -> stream_id , stream_info -> init_frame_drop , stream_cfg_cmd -> init_frame_drop ) ; rc = - EINVAL ; } if ( stream_cfg_cmd -> frame_skip_pattern != stream_info -> frame_skip_pattern ) { pr_err ( "%s:<S2SV_blank>stream<S2SV_blank>%d<S2SV_blank>skip<S2SV_blank>pattern<S2SV_blank>mismatch<S2SV_blank>%d/%d\\n" , __func__ , stream_info -> stream_id , stream_info -> frame_skip_pattern , stream_cfg_cmd -> frame_skip_pattern ) ; rc = - EINVAL ; } if ( stream_info -> stream_type == CONTINUOUS_STREAM && stream_cfg_cmd -> burst_count > 0 ) { pr_err ( "%s:<S2SV_blank>stream<S2SV_blank>%d<S2SV_blank>stream<S2SV_blank>type<S2SV_blank>mismatch\\n" , __func__ , stream_info -> stream_id ) ; rc = - EINVAL ; } if ( stream_info -> stream_type == BURST_STREAM && stream_info -> num_burst_capture != stream_cfg_cmd -> burst_count ) { pr_err ( "%s:<S2SV_blank>stream<S2SV_blank>%d<S2SV_blank>stream<S2SV_blank>burst<S2SV_blank>count<S2SV_blank>mismatch<S2SV_blank>%d/%d\\n" , __func__ , stream_info -> stream_id , stream_info -> num_burst_capture , stream_cfg_cmd -> burst_count ) ; rc = - EINVAL ; } } else { rc = msm_isp_calculate_framedrop ( vfe_dev , stream_cfg_cmd ) ; } if ( rc ) goto done ; } else { stream_info -> stream_type = BURST_STREAM ; stream_info -> num_burst_capture = 0 ; stream_info -> frame_skip_pattern = NO_SKIP ; stream_info -> init_frame_drop = stream_cfg_cmd -> init_frame_drop ; stream_info -> current_framedrop_period = MSM_VFE_STREAM_STOP_PERIOD ; } if ( stream_cfg_cmd -> vt_enable && ! vfe_dev -> vt_enable ) { vfe_dev -> vt_enable = stream_cfg_cmd -> vt_enable ; msm_isp_start_avtimer ( ) ; } if ( stream_info -> num_planes > 1 ) msm_isp_axi_reserve_comp_mask ( vfe_dev , stream_info ) ; for ( i = 0 ; i < stream_info -> num_planes ; i ++ ) { vfe_dev -> hw_info -> vfe_ops . axi_ops . cfg_wm_reg ( vfe_dev , stream_info , i ) ; vfe_dev -> hw_info -> vfe_ops . axi_ops . cfg_wm_xbar_reg ( vfe_dev , stream_info , i ) ; } if ( stream_info -> state == INACTIVE ) { msm_isp_cfg_stream_scratch ( stream_info , VFE_PING_FLAG ) ; msm_isp_cfg_stream_scratch ( stream_info , VFE_PONG_FLAG ) ; } done : if ( rc ) { msm_isp_axi_free_wm ( vfe_dev , stream_info ) ; msm_isp_axi_destroy_stream ( vfe_dev , stream_info ) ; } return rc ; } | <S2SV_ModStart> 0 , i = 0 |
4,176 | CWE-000 void main ( word32 o1 , word32 dwArg44 , word32 dwArg48 ) { <S2SV_StartBug> fn00014EA4_entry : <S2SV_EndBug> word32 o0_21 = Mem0 [ o1 + 0x00 : word32 ] strrchr ( ) word32 o2_231 = o0_21 + 0x01 branch o0_21 != 0x00 l00014EA4_ds_t goto l00014EA4_ds_f l00014EA4 : l00014EA4_ds_f : Mem229 [ 164176 : word32 ] = o0_21 o2_231 = Mem229 [ Mem229 [ fp + 0x0048 : word32 ] + 0x00 : word32 ] goto l00014EE8 l00014EA4_ds_t : Mem233 [ 164176 : word32 ] = o0_21 goto l00014EE8 l00014EDC : l00014EE8 : Mem33 [ 164176 : word32 ] = o2_231 setlocale ( ) word32 i6_36 = getpwd ( ) branch true l00014EE8_ds_t l00014EE8_ds_f : Mem42 [ 0x0002B270 : word32 ] = 0x05 xstrerror ( Mem42 [ 0x0002B760 : word32 ] ) notice ( 0x00017810 , o1 , dwArg4C , dwArg50 , dwArg54 , dwArg58 ) exit ( ) l00014EE8_ds_t : Mem57 [ 0x0002B270 : word32 ] = 0x05 string_list_cons ( 0x05 , 0x00 ) Mem61 [ 178020 : word32 ] = 0x05 word32 o0_76 = Mem61 [ i6_36 + 0x0044 : word32 ] word32 l6_81 word32 l7_82 word32 i6_83 word32 l0_84 = getopt_long ( o0_76 , Mem61 [ i6_36 + 0x0048 : word32 ] , 0x00017838 , 163672 , i6_36 + ~ 0x13 , out l6_81 , out l7_82 , out i6_83 ) branch o0_76 != ~ 0x00 l00015074_ds_t goto l00015074_ds_f l00014F14 : l00014F48 : l00014F94 : l00014F94_ds_f : o0_213 = ( l0_84 + 0x0C ) [ Mem61 [ i6_83 + - 0x0014 : word32 ] * 0x10 ] + ~ 0x4D goto l00014FB0 l00014F94_ds_t : o0_213 = o0_76 + ~ 0x4D goto l00014FB0 l00014F9C : l00014FB0 : branch o0_213 >= u 0x2A l00014FB0_ds_t l00014FB0_ds_f : return l00014FB0_ds_t : usage ( ) l00014FBC : l0001506C : l00015074 : l00015074_ds_f : munge_compile_params ( Mem61 [ i6_83 + - 0x0018 : word32 ] , 163672 ) word32 o1_93 = Mem61 [ i6_83 + 0x0044 : word32 ] - Mem61 [ l7_82 + 0x0068 : word32 ] Mem95 [ l6_81 + 844 : word32 ] = o1_93 word32 o0_96 = o1_93 + 0x01 << 0x02 xmalloc ( o0_96 ) Mem98 [ 0x00028160 : word32 ] = o0_96 word32 o1_99 = Mem98 [ l7_82 + 0x0068 : word32 ] Mem100 [ l6_81 + 844 : word32 ] = 0x00 branch o1_99 - Mem100 [ i6_83 + 0x0044 : word32 ] >= 0x00 l0001509C_ds_t goto l000150EC l00015074_ds_t : word32 o0_213 branch o0_76 != 0x00 l00014F94_ds_t goto l00014F94_ds_f l0001509C : l000150E0 : l000150E0_ds_f : branch ( int32 ) Mem100 [ - 0x02 : int8 ] != 0x2E l00015120_ds_t goto l00015120_ds_f l000150EC : abspath ( 0x00 , Mem100 [ i6_83 + 0x0048 : word32 ] [ Mem100 [ l7_82 + 0x0068 : word32 ] * 0x04 ] ) strlen ( ) branch ( int32 ) Mem100 [ - 0x01 : int8 ] != 99 l000150E0_ds_t goto l000150E0_ds_f l00015120 : l00015120_ds_f : word32 o0_196 = Mem100 [ l6_81 + 844 : word32 ] Mem100 [ 0x00028160 : word32 ] [ o0_196 * 0x04 ] = 0x00 Mem202 [ l6_81 + 844 : word32 ] = o0_196 + 0x01 goto l00015180 l00015130 : l00015150 : shortpath ( 0x00 , 0x00 ) notice ( 96336 , o1 , dwArg4C , dwArg50 , dwArg54 , dwArg58 ) Mem189 [ 163616 : word32 ] = Mem100 [ 163616 : word32 ] + 0x01 l00015180 : word32 o0_168 = Mem100 [ l7_82 + 0x0068 : word32 ] branch o0_168 + 0x01 - Mem100 [ i6_83 + 0x0044 : word32 ] < 0x00 l00015180_ds_t l00015180_ds_f : Mem174 [ l7_82 + 0x0068 : word32 ] = o0_168 + 0x01 goto l0001519C l00015180_ds_t : Mem176 [ l7_82 + 0x0068 : word32 ] = o0_168 + 0x01 goto l000150EC l00015198 : l0001519C : branch Mem100 [ 163616 : word32 ] == 0x00 l0001519C_ds_t l0001519C_ds_f : usage ( ) l0001519C_ds_t : branch Mem100 [ 0x00027F28 : word32 ] == 0x00 l000151B4_ds_t goto l000151B4_ds_f l000151AC : l000151B4 : l000151B4_ds_f : fprintf ( ) l000151B4_ds_t : do_processing ( 0x00028000 ) exit ( ) l000151C4 : l000151E4 : l00015200 : l00015204 : <S2SV_StartBug> fn00014EA4_exit : <S2SV_EndBug> } | <S2SV_ModStart> dwArg48 ) { main_entry <S2SV_ModEnd> : word32 o0_21 <S2SV_ModStart> : l00015204 : main_exit <S2SV_ModEnd> : } <S2SV_null> |
4,177 | CWE-000 static struct dentry * __d_instantiate_unique ( struct dentry * entry , struct inode * inode ) { struct dentry * alias ; int len = entry -> d_name . len ; const char * name = entry -> d_name . name ; unsigned int hash = entry -> d_name . hash ; if ( ! inode ) { __d_instantiate ( entry , NULL ) ; return NULL ; } list_for_each_entry ( alias , & inode -> i_dentry , d_u . d_alias ) { <S2SV_StartBug> struct qstr * qstr = & alias -> d_name ; <S2SV_EndBug> if ( qstr -> hash != hash ) continue ; if ( alias -> d_parent != entry -> d_parent ) continue ; <S2SV_StartBug> if ( dentry_cmp ( qstr -> name , qstr -> len , name , len ) ) <S2SV_EndBug> continue ; __dget ( alias ) ; return alias ; } __d_instantiate ( entry , inode ) ; return NULL ; } | <S2SV_ModStart> d_alias ) { if ( <S2SV_ModEnd> alias -> d_name <S2SV_ModStart> alias -> d_name . <S2SV_ModEnd> hash != hash <S2SV_ModStart> ( dentry_cmp ( alias <S2SV_ModEnd> , name , |
4,178 | CWE-000 static void vmspace_drop_notoken ( struct vmspace * vm ) { <S2SV_StartBug> if ( refcount_release ( & vm -> vm_holdcnt ) ) { <S2SV_EndBug> <S2SV_StartBug> if ( vm -> vm_refcnt == ( u_int ) - 1 ) { <S2SV_EndBug> vmspace_terminate ( vm , 1 ) ; } } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { if ( atomic_fetchadd_int <S2SV_ModEnd> ( & vm <S2SV_ModStart> vm -> vm_holdcnt , - 1 ) == 1 <S2SV_ModEnd> ) { if <S2SV_ModStart> vm -> vm_refcnt & VM_REF_DELETED ) <S2SV_ModEnd> vmspace_terminate ( vm <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,179 | CWE-000 static int push_shim ( struct sk_buff * skb , struct sw_flow_key * key , const struct ovs_action_push_shim * push_shim ) { struct iphdr * ip_header ; uint16_t push_hdr_len = push_shim -> shim_len ; if ( push_hdr_len % 4 != 0 ) { push_hdr_len = push_hdr_len + ( 4 - ( push_hdr_len % 4 ) ) ; } pr_info ( "BF_DEBUG:<S2SV_blank>push_shim<S2SV_blank>called,<S2SV_blank>mac_len<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>ihl<S2SV_blank>(bytes)<S2SV_blank>=<S2SV_blank>%d\\n" , skb -> mac_len , ip_hdr ( skb ) -> ihl * 4 ) ; if ( skb_cow_head ( skb , push_hdr_len ) < 0 ) return - ENOMEM ; skb_push ( skb , push_hdr_len ) ; memmove ( skb_mac_header ( skb ) - push_hdr_len , skb_mac_header ( skb ) , skb -> mac_len + ( ip_hdr ( skb ) -> ihl * 4 ) ) ; skb_reset_mac_header ( skb ) ; skb_set_network_header ( skb , skb -> mac_len ) ; memcpy ( skb_network_header ( skb ) + 20 , push_shim -> shim , push_hdr_len ) ; ip_header = ip_hdr ( skb ) ; <S2SV_StartBug> ip_header -> tot_len = ip_header -> tot_len + push_hdr_len ; <S2SV_EndBug> ip_header -> ihl = ip_header -> ihl + ( ( push_hdr_len / 4 ) & 0x0F ) ; skb_set_transport_header ( skb , skb -> mac_len + ( ip_hdr ( skb ) -> ihl * 4 ) ) ; ip_header -> check = 0 ; ip_send_check ( ip_header ) ; pr_info ( "BF_DEBUG:<S2SV_blank>push_shim<S2SV_blank>completed<S2SV_blank>successfully\\n" ) ; return 0 ; } | <S2SV_ModStart> -> tot_len = htons ( ntohs ( <S2SV_ModStart> ip_header -> tot_len ) + push_hdr_len ) <S2SV_ModEnd> ; ip_header -> |
4,180 | CWE-000 void mg_state_machine ( void ) { static State_t stateTop = TOP_STATE_INIT ; static bool firstPass = true ; switch ( stateTop ) { case TOP_STATE_INIT : { char myString [ ] = "Light<S2SV_blank>Sensor<S2SV_blank>Node" ; HAL_UART_Transmit ( & huart1 , ( uint8_t * ) myString , strlen ( myString ) , 500 ) ; <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> stateTop = AWAKE ; == == == = stateTop = TOP_STATE_AWAKE ; <S2SV_StartBug> >> >> >> > ADC - Interrupts - FlagStruct <S2SV_EndBug> break ; } case TOP_STATE_AWAKE : { if ( firstPass ) { adcExtFlags . flagStartConv = true ; firstPass = false ; } mg_adc_StateMachine ( ) ; if ( adcExtFlags . flagConvDone ) { adcExtFlags . flagConvDone = false ; firstPass = true ; stateTop = TOP_STATE_ASLEEP ; } break ; } case TOP_STATE_ASLEEP : { static uint32_t lastTick ; if ( firstPass ) { lastTick = HAL_GetTick ( ) ; firstPass = false ; } if ( ( HAL_GetTick ( ) - lastTick ) > SLEEP_PERIOD_MS ) { firstPass = true ; stateTop = TOP_STATE_AWAKE ; } break ; } case TOP_STATE_ERROR : { } case TOP_STATE_NUM_STATES : { } default : { char myString [ ] = "Error:<S2SV_blank>Top<S2SV_blank>state<S2SV_blank>machine" ; HAL_UART_Transmit ( & huart1 , ( uint8_t * ) myString , strlen ( myString ) , 500 ) ; while ( 1 ) ; } } } | <S2SV_ModStart> 500 ) ; <S2SV_ModEnd> stateTop = TOP_STATE_AWAKE <S2SV_ModStart> = TOP_STATE_AWAKE ; <S2SV_ModEnd> break ; } |
4,181 | CWE-000 static error_t args_parse_entry ( int key , char arg [ ] , struct argp_state * state ) { struct args_container * args = state -> input ; switch ( key ) { case 'd' : <S2SV_StartBug> if ( ! arg ) <S2SV_EndBug> <S2SV_StartBug> args -> dir = state -> argv [ state -> next ] ; <S2SV_EndBug> <S2SV_StartBug> else <S2SV_EndBug> args -> dir = arg ; break ; case 'q' : <S2SV_StartBug> if ( ! arg ) <S2SV_EndBug> <S2SV_StartBug> args -> query = state -> argv [ state -> next ] ; <S2SV_EndBug> else args -> query = arg ; break ; case 'Q' : args -> isquiet = true ; break ; case - 1 : args -> isgui = true ; break ; case ARGP_KEY_ARG : if ( state -> arg_num >= 2 ) argp_usage ( state ) ; break ; case ARGP_KEY_END : break ; default : return ARGP_ERR_UNKNOWN ; } return 0 ; } | <S2SV_ModStart> case 'd' : <S2SV_ModEnd> args -> dir <S2SV_ModStart> -> dir = arg ? arg : <S2SV_ModStart> next ] ; <S2SV_ModEnd> break ; case <S2SV_ModStart> case 'q' : <S2SV_ModEnd> args -> query <S2SV_ModStart> -> query = arg ? arg : <S2SV_ModStart> -> next ] <S2SV_ModEnd> ; break ; |
4,182 | CWE-000 void clearScreen ( void ) { # ifdef CASIO_PRIZM <S2SV_StartBug> memset ( ( void * ) 0xA8000000 , 0 , 384 * 216 * 2 ) ; <S2SV_EndBug> # endif # ifdef PC if ( SDL_MUSTLOCK ( screen ) ) SDL_LockSurface ( screen ) ; memset ( screen -> pixels , 0 , screen -> w * screen -> h * 2 ) ; if ( SDL_MUSTLOCK ( screen ) ) SDL_UnlockSurface ( screen ) ; # endif } | <S2SV_ModStart> void * ) VRAM_ADDR <S2SV_ModEnd> , 0 , |
4,183 | CWE-000 static int psmx2_av_lookup ( struct fid_av * av , fi_addr_t fi_addr , void * addr , size_t * addrlen ) { struct psmx2_fid_av * av_priv ; struct psmx2_epaddr_context * context ; struct psmx2_ep_name name ; <S2SV_StartBug> int idx , sep_id ; <S2SV_EndBug> if ( ! addr || ! addrlen ) return - FI_EINVAL ; av_priv = container_of ( av , struct psmx2_fid_av , av ) ; memset ( & name , 0 , sizeof ( name ) ) ; if ( PSMX2_SEP_ADDR_TEST ( fi_addr ) ) { idx = PSMX2_SEP_ADDR_IDX ( fi_addr ) ; <S2SV_StartBug> sep_id = PSMX2_SEP_ADDR_CTXT ( fi_addr , av_priv -> rx_ctx_bits ) ; <S2SV_EndBug> if ( idx >= av_priv -> last ) return - FI_EINVAL ; name . type = PSMX2_EP_SCALABLE ; name . epid = av_priv -> epids [ idx ] ; <S2SV_StartBug> name . sep_id = sep_id ; <S2SV_EndBug> } else if ( av_priv -> type == FI_AV_TABLE ) { idx = ( int ) ( int64_t ) fi_addr ; if ( idx >= av_priv -> last ) return - FI_EINVAL ; name . type = PSMX2_EP_REGULAR ; name . epid = av_priv -> epids [ idx ] ; } else { context = psm2_epaddr_getctxt ( PSMX2_ADDR_TO_EP ( fi_addr ) ) ; name . type = PSMX2_EP_REGULAR ; name . epid = context -> epid ; } if ( av_priv -> addr_format == FI_ADDR_STR ) { ofi_straddr ( addr , addrlen , FI_ADDR_PSMX2 , & name ) ; } else { memcpy ( addr , & name , MIN ( * addrlen , sizeof ( name ) ) ) ; * addrlen = sizeof ( name ) ; } return 0 ; } | <S2SV_ModStart> ; int idx <S2SV_ModEnd> ; if ( <S2SV_ModStart> fi_addr ) ; <S2SV_ModEnd> if ( idx <S2SV_ModStart> . sep_id = av_priv -> peers [ idx ] . |
4,184 | CWE-000 void ip_send_unicast_reply ( struct sock * sk , struct sk_buff * skb , const struct ip_options * sopt , __be32 daddr , __be32 saddr , const struct ip_reply_arg * arg , unsigned int len ) { struct ip_options_data replyopts ; struct ipcm_cookie ipc ; struct flowi4 fl4 ; struct rtable * rt = skb_rtable ( skb ) ; struct net * net = sock_net ( sk ) ; struct sk_buff * nskb ; int err ; int oif ; if ( __ip_options_echo ( & replyopts . opt . opt , skb , sopt ) ) return ; ipc . addr = daddr ; ipc . opt = NULL ; ipc . tx_flags = 0 ; ipc . ttl = 0 ; ipc . tos = - 1 ; if ( replyopts . opt . opt . optlen ) { ipc . opt = & replyopts . opt ; if ( replyopts . opt . opt . srr ) daddr = replyopts . opt . opt . faddr ; } oif = arg -> bound_dev_if ; if ( ! oif && netif_index_is_l3_master ( net , skb -> skb_iif ) ) oif = skb -> skb_iif ; flowi4_init_output ( & fl4 , oif , IP4_REPLY_MARK ( net , skb -> mark ) , RT_TOS ( arg -> tos ) , RT_SCOPE_UNIVERSE , ip_hdr ( skb ) -> protocol , ip_reply_arg_flowi_flags ( arg ) , daddr , saddr , <S2SV_StartBug> tcp_hdr ( skb ) -> source , tcp_hdr ( skb ) -> dest ) ; <S2SV_EndBug> security_skb_classify_flow ( skb , flowi4_to_flowi ( & fl4 ) ) ; rt = ip_route_output_key ( net , & fl4 ) ; if ( IS_ERR ( rt ) ) return ; inet_sk ( sk ) -> tos = arg -> tos ; sk -> sk_priority = skb -> priority ; sk -> sk_protocol = ip_hdr ( skb ) -> protocol ; sk -> sk_bound_dev_if = arg -> bound_dev_if ; sk -> sk_sndbuf = sysctl_wmem_default ; err = ip_append_data ( sk , & fl4 , ip_reply_glue_bits , arg -> iov -> iov_base , len , 0 , & ipc , & rt , MSG_DONTWAIT ) ; if ( unlikely ( err ) ) { ip_flush_pending_frames ( sk ) ; goto out ; } nskb = skb_peek ( & sk -> sk_write_queue ) ; if ( nskb ) { if ( arg -> csumoffset >= 0 ) * ( ( __sum16 * ) skb_transport_header ( nskb ) + arg -> csumoffset ) = csum_fold ( csum_add ( nskb -> csum , arg -> csum ) ) ; nskb -> ip_summed = CHECKSUM_NONE ; ip_push_pending_frames ( sk , & fl4 ) ; } out : ip_rt_put ( rt ) ; } | <S2SV_ModStart> ) -> dest , arg -> uid |
4,185 | CWE-000 static void on_name_lost ( GDBusConnection * connection , const char * name , gpointer data ) { <S2SV_StartBug> GsmManager * manager = ( GsmManager * ) data ; <S2SV_EndBug> if ( connection == NULL ) { g_warning ( "Lost<S2SV_blank>name<S2SV_blank>on<S2SV_blank>bus:<S2SV_blank>%s" , name ) ; gsm_fail_whale_dialog_we_failed ( TRUE , TRUE , NULL ) ; } else { g_debug ( "Calling<S2SV_blank>name<S2SV_blank>lost<S2SV_blank>callback<S2SV_blank>function" ) ; gsm_manager_set_phase ( manager , GSM_MANAGER_PHASE_EXIT ) ; gsm_quit ( ) ; } } | <S2SV_ModStart> data ) { <S2SV_ModEnd> if ( connection |
4,186 | CWE-000 int au_change_serial_owner ( MOP * object , MOP new_owner ) { DB_OTMPL * obt_p = NULL ; DB_VALUE value ; int au_save , error ; assert ( object != NULL ) ; if ( ! au_is_dba_group_member ( Au_user ) ) { er_set ( ER_WARNING_SEVERITY , ARG_FILE_LINE , ER_AU_DBA_ONLY , 1 , "change_serial_owner" ) ; return ER_AU_DBA_ONLY ; } AU_DISABLE ( au_save ) ; obt_p = dbt_edit_object ( * object ) ; if ( obt_p == NULL ) { goto exit_on_error ; } db_make_object ( & value , new_owner ) ; error = dbt_put_internal ( obt_p , "owner" , & value ) ; pr_clear_value ( & value ) ; if ( error != NO_ERROR ) { goto exit_on_error ; } * object = dbt_finish_object ( obt_p ) ; if ( * object == NULL ) { goto exit_on_error ; } AU_ENABLE ( au_save ) ; return NO_ERROR ; exit_on_error : <S2SV_StartBug> AU_ENABLE ( au_save ) ; <S2SV_EndBug> assert ( er_errid ( ) != NO_ERROR ) ; return er_errid ( ) ; } | <S2SV_ModStart> ; exit_on_error : if ( obt_p != NULL ) { dbt_abort_object ( obt_p ) ; } |
4,187 | CWE-000 static void payload3 ( ) { uint64_t timer_expire_val = 100000 ; uint32_t index = val_pe_get_index_mpid ( val_pe_get_mpid ( ) ) ; val_set_status ( index , RESULT_FAIL ( g_sbsa_level , TEST_NUM3 , 01 ) ) ; <S2SV_StartBug> intid = val_timer_get_info ( TIMER_INFO_PHY_EL2_INTID ) ; <S2SV_EndBug> val_gic_install_isr ( intid , isr3 ) ; wakeup_set_failsafe ( ) ; val_timer_set_phy_el2 ( timer_expire_val ) ; val_power_enter_semantic ( SBSA_POWER_SEM_B ) ; wakeup_clear_failsafe ( ) ; return ; } | <S2SV_ModStart> val_timer_get_info ( TIMER_INFO_PHY_EL2_INTID , 0 |
4,188 | CWE-000 void component_master_del ( struct device * dev , const struct component_master_ops * ops ) { <S2SV_StartBug> struct master * master ; <S2SV_EndBug> int i ; mutex_lock ( & component_mutex ) ; master = __master_find ( dev , ops ) ; if ( master ) { <S2SV_StartBug> struct component_match * match = master -> match ; <S2SV_EndBug> take_down_master ( master ) ; <S2SV_StartBug> list_del ( & master -> node ) ; <S2SV_EndBug> if ( match ) { for ( i = 0 ; i < match -> num ; i ++ ) { struct component * c = match -> compare [ i ] . component ; if ( c ) c -> master = NULL ; } } kfree ( master ) ; } mutex_unlock ( & component_mutex ) ; } | <S2SV_ModStart> master * master <S2SV_ModEnd> ; mutex_lock ( <S2SV_ModStart> master ) { <S2SV_ModEnd> take_down_master ( master <S2SV_ModStart> master ) ; free_master <S2SV_ModEnd> ( master ) |
4,189 | CWE-000 void I2C_write ( uint8_t address , uint8_t * data , uint16_t size ) <S2SV_StartBug> { <S2SV_EndBug> I2C_TxDMAComplete = 0 ; if ( HAL_I2C_Master_Transmit_DMA ( & hi2c1 , address << 1 , data , size ) != HAL_OK ) Error_Handler ( ) ; while ( ! I2C_TxDMAComplete ) ; } | <S2SV_ModStart> size ) { SCB_CleanDCache_by_Addr ( data , size ) ; |
4,190 | CWE-000 <S2SV_StartBug> static void parse_host_arg ( struct hostinfo * hi , char * extra_args , int buflen ) <S2SV_EndBug> { char * val ; int vallen ; char * end = extra_args + buflen ; if ( extra_args < end && * extra_args ) { hi -> saw_extended_args = 1 ; if ( strncasecmp ( "host=" , extra_args , 5 ) == 0 ) { val = extra_args + 5 ; vallen = strlen ( val ) + 1 ; if ( * val ) { char * host ; char * port ; parse_host_and_port ( val , & host , & port ) ; if ( port ) sanitize_client ( & hi -> tcp_port , port ) ; canonicalize_client ( & hi -> hostname , host ) ; hi -> hostname_lookup_done = 0 ; } extra_args = val + vallen ; } if ( extra_args < end && * extra_args ) die ( "Invalid<S2SV_blank>request" ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static char * <S2SV_ModEnd> parse_host_arg ( struct <S2SV_ModStart> ) ; } return extra_args ; |
4,191 | CWE-000 void spawn ( ) { <S2SV_StartBug> for ( int i = 0 ; i < 4 ; i ++ ) { <S2SV_EndBug> for ( int j = 0 ; j < 4 ; j ++ ) { if ( tetronimos [ cur_piece . type ] [ cur_piece . rotation ] & tet_location ( i , j ) ) { map . tile [ cur_piece . y + j ] [ cur_piece . x + i ] = 2 ; } } } next_tet ( ) ; cur_piece . type = tets_queue [ cur_block_num ++ ] ; for ( int i = 0 ; i < 4 ; i ++ ) { for ( int j = 0 ; j < 4 ; j ++ ) { if ( tetronimos [ cur_piece . type ] [ cur_piece . rotation ] & tet_location ( i , j ) ) { map . tile [ cur_piece . y + j ] [ cur_piece . x + i ] = 1 ; } } } } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> next_tet ( ) |
4,192 | CWE-000 int kgsl_sharedmem_alloc_coherent ( struct kgsl_memdesc * memdesc , size_t size ) { int result = 0 ; size = ALIGN ( size , PAGE_SIZE ) ; if ( size == 0 ) return - EINVAL ; memdesc -> size = size ; memdesc -> ops = & kgsl_coherent_ops ; memdesc -> hostptr = dma_alloc_coherent ( NULL , size , & memdesc -> physaddr , GFP_KERNEL ) ; if ( memdesc -> hostptr == NULL ) { <S2SV_StartBug> KGSL_CORE_ERR ( "dma_alloc_coherent(%d)<S2SV_blank>failed\\n" , size ) ; <S2SV_EndBug> result = - ENOMEM ; goto err ; } result = memdesc_sg_phys ( memdesc , memdesc -> physaddr , size ) ; if ( result ) goto err ; KGSL_STATS_ADD ( size , & kgsl_driver . stats . coherent , & kgsl_driver . stats . coherent_max ) ; err : if ( result ) kgsl_sharedmem_free ( memdesc ) ; return result ; } | <S2SV_ModStart> NULL ) { <S2SV_ModEnd> result = - |
4,193 | CWE-000 static int InstallGolden ( int newestIndex , int currentIndex ) { int goldenIndex = newestIndex + 1 ; char path [ PATH_MAX ] ; CreateSystemPathName ( goldenIndex , path , sizeof ( path ) ) ; RecursiveDelete ( path ) ; if ( currentIndex > - 1 ) { char pathBuffer [ PATH_MAX ] ; CreateSystemPathName ( currentIndex , pathBuffer , sizeof ( pathBuffer ) ) ; fs_TryLazyUmount ( CurrentSystemDir ) ; Rename ( CurrentSystemDir , pathBuffer ) ; } MakeUnpackDirFromGolden ( goldenIndex ) ; ImportOldConfigTrees ( newestIndex , - 1 ) ; InstallGoldenApps ( newestIndex ) ; Rename ( SystemsUnpackDir , CurrentSystemDir ) ; DeleteAllButCurrent ( ) ; RequestLdSoConfig ( ) ; <S2SV_StartBug> MarkGoldenInstallComplete ( ) ; <S2SV_EndBug> return goldenIndex ; } | <S2SV_ModStart> ( ) ; sync ( ) ; |
4,194 | CWE-000 static int x_file_glob ( int flags __unused , const char * str , int slen , char * * * wordsp ) { char * toglob ; char * * words ; int nwords , i , idx , escaping ; XPtrV w ; struct source * s , * sold ; if ( slen < 0 ) return 0 ; toglob = add_glob ( str , slen ) ; escaping = 0 ; for ( i = 0 , idx = 0 ; toglob [ i ] ; i ++ ) { if ( toglob [ i ] == '\\\\' && ! escaping ) { escaping = 1 ; continue ; } if ( escaping && toglob [ i ] == '[' ) toglob [ idx ++ ] = QCHAR ; toglob [ idx ] = toglob [ i ] ; idx ++ ; if ( escaping ) escaping = 0 ; } toglob [ idx ] = '\\0' ; sold = source ; s = pushs ( SWSTR , ATEMP ) ; s -> start = s -> str = toglob ; source = s ; if ( yylex ( ONEWORD | LQCHAR ) != LWORD ) { source = sold ; <S2SV_StartBug> internal_errorf ( 0 , "fileglob:<S2SV_blank>substitute<S2SV_blank>error" ) ; <S2SV_EndBug> return 0 ; } source = sold ; XPinit ( w , 32 ) ; expand ( yylval . cp , & w , DOGLOB | DOTILDE | DOMARKDIRS ) ; XPput ( w , NULL ) ; words = ( char * * ) XPclose ( w ) ; for ( nwords = 0 ; words [ nwords ] ; nwords ++ ) ; if ( nwords == 1 ) { struct stat statb ; if ( ( strcmp ( words [ 0 ] , toglob ) == 0 && stat ( words [ 0 ] , & statb ) < 0 ) || words [ 0 ] [ 0 ] == '\\0' ) { x_free_words ( nwords , words ) ; nwords = 0 ; } } afree ( toglob , ATEMP ) ; * wordsp = nwords ? words : NULL ; return nwords ; } | <S2SV_ModStart> = sold ; internal_warningf ( <S2SV_ModEnd> "fileglob:<S2SV_blank>substitute<S2SV_blank>error" ) ; |
4,195 | CWE-000 int main ( ) { printf ( "Hello,<S2SV_blank>OCR<S2SV_blank>Project!\\n" ) ; SDL_Surface * image_surface ; SDL_Surface * screen_surface ; init_sdl ( ) ; image_surface = load_image ( "Images_test/rafale.bmp" ) ; screen_surface = display_image ( image_surface ) ; wait_for_keypressed ( ) ; printf ( "to_grayscale\\n" ) ; to_grayscale ( image_surface ) ; update_surface ( screen_surface , image_surface ) ; wait_for_keypressed ( ) ; printf ( "B&W\\n" ) ; BlackAndWhite ( image_surface ) ; update_surface ( screen_surface , image_surface ) ; wait_for_keypressed ( ) ; printf ( "RSLA<S2SV_blank>:<S2SV_blank>horizontal\\n" ) ; <S2SV_StartBug> SDL_Surface * image_mask1 ; <S2SV_EndBug> <S2SV_StartBug> image_mask1 = Process ( image_surface , 10 , 1 ) ; <S2SV_EndBug> update_surface ( screen_surface , image_mask1 ) ; wait_for_keypressed ( ) ; printf ( "RSLA<S2SV_blank>:<S2SV_blank>vertical\\n" ) ; <S2SV_StartBug> SDL_Surface * image_mask2 ; <S2SV_EndBug> <S2SV_StartBug> image_mask2 = Process ( image_surface , 15 , 0 ) ; <S2SV_EndBug> update_surface ( screen_surface , image_mask2 ) ; wait_for_keypressed ( ) ; <S2SV_StartBug> printf ( "RSLA<S2SV_blank>:<S2SV_blank>merge\\n" ) ; <S2SV_EndBug> <S2SV_StartBug> SDL_Surface * image_mask3 ; <S2SV_EndBug> image_mask3 = NULL ; image_mask3 = Merge ( image_mask1 , image_mask2 , image_mask3 ) ; update_surface ( screen_surface , image_mask3 ) ; wait_for_keypressed ( ) ; <S2SV_StartBug> printf ( "End\\n" ) ; <S2SV_EndBug> SDL_FreeSurface ( image_surface ) ; SDL_FreeSurface ( screen_surface ) ; return 0 ; } | <S2SV_ModStart> SDL_Surface * image_mask1 = NULL <S2SV_ModStart> ( image_surface , image_mask1 , <S2SV_ModStart> SDL_Surface * image_mask2 = NULL <S2SV_ModStart> ( image_surface , image_mask2 , <S2SV_ModStart> ( ) ; SDL_Surface * image_mask3 = NULL ; image_mask3 = Merge ( image_mask1 , image_mask2 , image_mask3 ) ; update_surface ( screen_surface , image_mask3 ) ; <S2SV_ModStart> "RSLA<S2SV_blank>:<S2SV_blank>merge\\n" ) ; <S2SV_ModEnd> wait_for_keypressed ( ) <S2SV_ModStart> printf ( "End\\n" ) ; SDL_FreeSurface ( image_mask1 ) ; SDL_FreeSurface ( image_mask2 ) ; SDL_FreeSurface ( image_mask3 |
4,196 | CWE-000 ion_err_t iinq_rewrite_open_source ( char * name , ion_iinq_rewrite_source_t * source ) { ion_err_t error ; <S2SV_StartBug> strcpy ( source -> name , name ) ; <S2SV_EndBug> if ( source -> name == NULL ) { return err_out_of_memory ; } <S2SV_StartBug> source -> dictionary . handler = malloc ( sizeof ( ion_dictionary_handler_t ) ) ; <S2SV_EndBug> <S2SV_StartBug> if ( NULL == source -> dictionary . handler ) { <S2SV_EndBug> free ( source -> name ) ; return err_out_of_memory ; } <S2SV_StartBug> error = iinq_open_source ( name , & ( source -> dictionary ) , source -> dictionary . handler ) ; <S2SV_EndBug> if ( err_ok != error ) { <S2SV_StartBug> free ( source -> dictionary . handler ) ; <S2SV_EndBug> free ( source -> name ) ; return error ; } ion_predicate_t predicate ; error = dictionary_build_predicate ( & predicate , predicate_all_records ) ; if ( err_ok != error ) { <S2SV_StartBug> free ( source -> dictionary . handler ) ; <S2SV_EndBug> free ( source -> name ) ; return error ; } <S2SV_StartBug> error = dictionary_find ( & ( source -> dictionary ) , & predicate , & source -> cursor ) ; <S2SV_EndBug> if ( err_ok != error ) { <S2SV_StartBug> free ( source -> dictionary . handler ) ; <S2SV_EndBug> free ( source -> name ) ; } return error ; } | <S2SV_ModStart> ion_err_t error ; source -> dictionary = malloc ( sizeof ( ion_dictionary_t ) ) ; <S2SV_ModStart> source -> dictionary -> <S2SV_ModEnd> handler = malloc <S2SV_ModStart> source -> dictionary -> <S2SV_ModEnd> handler ) { <S2SV_ModStart> ( name , source -> dictionary , source -> dictionary -> <S2SV_ModEnd> handler ) ; <S2SV_ModStart> source -> dictionary -> <S2SV_ModEnd> handler ) ; <S2SV_ModStart> source -> dictionary -> <S2SV_ModEnd> handler ) ; <S2SV_ModStart> = dictionary_find ( source -> dictionary <S2SV_ModEnd> , & predicate <S2SV_ModStart> source -> dictionary -> <S2SV_ModEnd> handler ) ; |
4,197 | CWE-000 void tbblue_reset_common ( void ) { <S2SV_StartBug> tbblue_registers [ 20 ] = TBBLUE_DEFAULT_TRANSPARENT ; <S2SV_EndBug> tbblue_registers [ 21 ] = 0 ; tbblue_registers [ 22 ] = 0 ; tbblue_registers [ 23 ] = 0 ; tbblue_registers [ 24 ] = 191 ; tbblue_registers [ 25 ] = 191 ; tbblue_registers [ 26 ] = 191 ; tbblue_registers [ 28 ] = 0 ; <S2SV_StartBug> clip_window_layer2 [ 0 ] = 0 ; <S2SV_EndBug> clip_window_layer2 [ 1 ] = 255 ; clip_window_layer2 [ 2 ] = 0 ; clip_window_layer2 [ 3 ] = 191 ; clip_window_sprites [ 0 ] = 0 ; clip_window_sprites [ 1 ] = 255 ; clip_window_sprites [ 2 ] = 0 ; clip_window_sprites [ 3 ] = 191 ; clip_window_ula [ 0 ] = 0 ; clip_window_ula [ 1 ] = 255 ; clip_window_ula [ 2 ] = 0 ; clip_window_ula [ 3 ] = 191 ; <S2SV_StartBug> clip_window_layer2_index = clip_window_sprites_index = clip_window_ula_index = 0 ; <S2SV_EndBug> tbblue_registers [ 30 ] = 0 ; tbblue_registers [ 31 ] = 0 ; tbblue_registers [ 34 ] = 0 ; tbblue_registers [ 35 ] = 0 ; tbblue_registers [ 50 ] = 0 ; tbblue_registers [ 51 ] = 0 ; tbblue_registers [ 66 ] = 15 ; tbblue_set_mmu_128k_default ( ) ; tbblue_was_in_p2a_ram_in_rom . v = 0 ; } | <S2SV_ModStart> { tbblue_registers [ 18 ] = 8 ; tbblue_registers [ 19 ] = 11 ; tbblue_registers [ <S2SV_ModStart> = 0 ; tbblue_registers [ 30 ] = 0 ; tbblue_registers [ 31 ] = 0 ; tbblue_registers [ 34 ] = 0 ; tbblue_registers [ 35 ] = 0 ; tbblue_registers [ 50 ] = 0 ; tbblue_registers [ 51 ] = 0 ; tbblue_registers [ 66 ] = 15 ; tbblue_registers [ 67 ] = 0 ; tbblue_registers [ 74 ] = 0 ; tbblue_registers [ 97 ] = 0 ; <S2SV_ModStart> clip_window_ula_index = 0 <S2SV_ModEnd> ; tbblue_set_mmu_128k_default ( |
4,198 | CWE-000 extern int client_init ( int argc , char * const argv [ ] ) { int pos ; mtrace ( ) ; if ( ( pos = mpt_init ( & no , argc , argv ) ) < 0 ) { <S2SV_StartBug> fputs ( "client<S2SV_blank>init<S2SV_blank>failed\\n" , stderr ) ; <S2SV_EndBug> return - 1 ; } if ( pos < argc ) { cfg = argv + pos ; return argc - pos ; } return 0 ; } | <S2SV_ModStart> 0 ) { mpt_log ( 0 , __func__ , MPT_LOG ( Error ) , "%s" , "client<S2SV_blank>init<S2SV_blank>failed" <S2SV_ModEnd> ) ; return |
4,199 | CWE-000 node_t node_init ( unsigned int node_id ) { node_t node = xbt_new ( s_node_t , 1 ) ; node -> id = node_id ; node -> table = routing_table_init ( node_id ) ; <S2SV_StartBug> snprintf ( node -> mailbox , MAILBOX_NAME_SIZE - 1 , "%d" , node_id ) ; <S2SV_EndBug> node -> find_node_failed = 0 ; node -> find_node_success = 0 ; node -> task_received = NULL ; node -> receive_comm = NULL ; return node ; } | <S2SV_ModStart> - 1 , "%u" <S2SV_ModEnd> , node_id ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.