Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
7,100 |
CWE-000 OCStackResult OCRegisterPersistentStorageHandler ( OCPersistentStorage * persistentStorageHandler ) { OIC_LOG ( INFO , TAG , "RegisterPersistentStorageHandler<S2SV_blank>!!" ) ; <S2SV_StartBug> if ( ! persistentStorageHandler ) <S2SV_EndBug> { OIC_LOG ( ERROR , TAG , "The<S2SV_blank>persistent<S2SV_blank>storage<S2SV_blank>handler<S2SV_blank>is<S2SV_blank>invalid" ) ; return OC_STACK_INVALID_PARAM ; } else { if ( ! persistentStorageHandler -> open || ! persistentStorageHandler -> close || ! persistentStorageHandler -> read || ! persistentStorageHandler -> unlink || ! persistentStorageHandler -> write ) { OIC_LOG ( ERROR , TAG , "The<S2SV_blank>persistent<S2SV_blank>storage<S2SV_blank>handler<S2SV_blank>is<S2SV_blank>invalid" ) ; return OC_STACK_INVALID_PARAM ; } } g_PersistentStorageHandler = persistentStorageHandler ; return OC_STACK_OK ; }
|
<S2SV_ModStart> ; if ( persistentStorageHandler ) <S2SV_ModEnd> { if (
|
7,101 |
CWE-000 static int patch_stac92hd73xx ( struct hda_codec * codec ) { struct sigmatel_spec * spec ; int err ; int num_dacs ; err = alloc_stac_spec ( codec ) ; if ( err < 0 ) return err ; spec = codec -> spec ; spec -> linear_tone_beep = 0 ; spec -> gen . mixer_nid = 0x1d ; spec -> have_spdif_mux = 1 ; num_dacs = snd_hda_get_num_conns ( codec , 0x0a ) - 1 ; if ( num_dacs < 3 || num_dacs > 5 ) { printk ( KERN_WARNING "hda_codec:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>determine<S2SV_blank>" "number<S2SV_blank>of<S2SV_blank>channels<S2SV_blank>defaulting<S2SV_blank>to<S2SV_blank>DAC<S2SV_blank>count\\n" ) ; num_dacs = 5 ; } switch ( num_dacs ) { case 0x3 : spec -> aloopback_ctl = & stac92hd73xx_6ch_loopback ; break ; case 0x4 : spec -> aloopback_ctl = & stac92hd73xx_8ch_loopback ; break ; case 0x5 : spec -> aloopback_ctl = & stac92hd73xx_10ch_loopback ; break ; } spec -> aloopback_mask = 0x01 ; spec -> aloopback_shift = 8 ; spec -> digbeep_nid = 0x1c ; spec -> eapd_mask = spec -> gpio_mask = spec -> gpio_dir = 0x1 ; spec -> gpio_data = 0x01 ; spec -> eapd_switch = 1 ; spec -> num_pwrs = ARRAY_SIZE ( stac92hd73xx_pwr_nids ) ; spec -> pwr_nids = stac92hd73xx_pwr_nids ; spec -> gen . own_eapd_ctl = 1 ; spec -> gen . power_down_unused = 1 ; codec -> patch_ops = stac_patch_ops ; snd_hda_pick_fixup ( codec , stac92hd73xx_models , stac92hd73xx_fixup_tbl , stac92hd73xx_fixups ) ; snd_hda_apply_fixup ( codec , HDA_FIXUP_ACT_PRE_PROBE ) ; if ( ! spec -> volknob_init ) snd_hda_add_verbs ( codec , stac92hd73xx_core_init ) ; err = stac_parse_auto_config ( codec ) ; if ( err < 0 ) { stac_free ( codec ) ; return err ; } <S2SV_StartBug> codec -> proc_widget_hook = stac92hd7x_proc_hook ; <S2SV_EndBug> snd_hda_apply_fixup ( codec , HDA_FIXUP_ACT_PROBE ) ; return 0 ; }
|
<S2SV_ModStart> err ; } if ( spec -> eapd_switch && ! has_builtin_speaker ( codec ) ) spec -> eapd_switch = 0 ;
|
7,102 |
CWE-000 int MCFileGetPathFromBundle ( const char * bundlename , const char * filename , char * buffer ) { char basename [ 256 ] = { 0 } ; char extension [ 64 ] = { 0 } ; <S2SV_StartBug> MCString_extensionFromFilename ( filename , basename , extension ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "MCFileGetPath<S2SV_blank>-<S2SV_blank>filename/basename/extension<S2SV_blank>-><S2SV_blank>%s/%s/%s\\n" , filename , basename , extension ) ; <S2SV_EndBug> # ifdef __ANDROID__ if ( assetManager_ != null ) { const char * subpath ; if ( strcmp ( extension , "fsh" ) == 0 ) { subpath = "shaders" ; } else if ( strcmp ( extension , "vsh" ) == 0 ) { subpath = "shaders" ; } else if ( strcmp ( extension , "obj" ) == 0 || strcmp ( extension , "mtl" ) == 0 ) { subpath = "raw" ; } else if ( strcmp ( extension , "png" ) == 0 ) { subpath = "textures" ; } else if ( strcmp ( extension , "jpg" ) == 0 ) { subpath = "textures" ; } else if ( strcmp ( extension , "tga" ) == 0 ) { subpath = "textures" ; } else { subpath = "raw" ; error_log ( "can<S2SV_blank>not<S2SV_blank>detect<S2SV_blank>use<S2SV_blank>raw<S2SV_blank>folder\\n" ) ; } AAssetDir * rootdir = AAssetManager_openDir ( assetManager_ , subpath ) ; if ( rootdir ) { const char * name ; char fullpath [ PATH_MAX ] = { 0 } ; while ( ( name = AAssetDir_getNextFileName ( rootdir ) ) != NULL ) { if ( strcmp ( filename , name ) == 0 ) { sprintf ( fullpath , "%s/%s" , subpath , name ) ; strcpy ( buffer , fullpath ) ; } } } else { error_log ( "can<S2SV_blank>not<S2SV_blank>find<S2SV_blank>rootdir\\n" ) ; return - 1 ; } } return 0 ; # else static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER ; pthread_mutex_lock ( & lock ) ; CFBundleRef bundle = NULL ; if ( bundlename ) { CFStringRef bid = CFStringCreateWithCString ( kCFAllocatorDefault , bundlename , kCFStringEncodingUTF8 ) ; bundle = CFBundleGetBundleWithIdentifier ( bid ) ; CFRelease ( bid ) ; } else { bundle = CFBundleGetMainBundle ( ) ; } if ( ! bundle ) { error_log ( "BEAssetManager<S2SV_blank>can<S2SV_blank>not<S2SV_blank>find<S2SV_blank>bundle<S2SV_blank>(%s)\\n" , bundlename ) ; return - 1 ; } CFStringRef fname = CFStringCreateWithCString ( kCFAllocatorDefault , basename , kCFStringEncodingUTF8 ) ; CFStringRef fext = CFStringCreateWithCString ( kCFAllocatorDefault , extension , kCFStringEncodingUTF8 ) ; CFURLRef url = CFBundleCopyResourceURL ( bundle , fname , fext , NULL ) ; if ( url ) { CFStringRef path = CFURLCopyPath ( url ) ; CFStringGetCString ( path , buffer , PATH_MAX , kCFStringEncodingUTF8 ) ; if ( path ) CFRelease ( path ) ; if ( url ) CFRelease ( url ) ; if ( fname ) CFRelease ( fname ) ; if ( fext ) CFRelease ( fext ) ; pthread_mutex_unlock ( & lock ) ; return 0 ; } else { error_log ( "BEAssetManager<S2SV_blank>can<S2SV_blank>not<S2SV_blank>find<S2SV_blank>path<S2SV_blank>of<S2SV_blank>(%s).(%s)\\n" , basename , extension ) ; if ( fname ) CFRelease ( fname ) ; if ( fext ) CFRelease ( fext ) ; pthread_mutex_unlock ( & lock ) ; return - 1 ; } # endif }
|
<S2SV_ModStart> 0 } ; if ( <S2SV_ModStart> , extension ) > 0 ) { <S2SV_ModEnd> printf ( "MCFileGetPath<S2SV_blank>-<S2SV_blank>filename/basename/extension<S2SV_blank>-><S2SV_blank>%s/%s/%s\\n" <S2SV_ModStart> extension ) ; } else { printf ( "MCFileGetPath<S2SV_blank>-<S2SV_blank>filename/basename/no<S2SV_blank>extension<S2SV_blank>-><S2SV_blank>%s/%s\\n" , filename , basename ) ; }
|
7,103 |
CWE-000 int dbgPrintf ( uint8_t level , const char * format , ... ) { <S2SV_StartBug> ( void ) level ; <S2SV_EndBug> va_list arg ; int done ; va_start ( arg , format ) ; done = chprintf ( ( BaseSequentialStream * ) SERIAL_CFG_DEBUG_DRIVER , format , arg ) ; va_end ( arg ) ; return done ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ) level ; # if ENABLE_EXTERNAL_I2C == FALSE <S2SV_ModStart> return done ; # else ( void ) format ; return 0 ; # endif
|
7,104 |
CWE-000 void _UG_TextboxUpdate ( UG_WINDOW * wnd , UG_OBJECT * obj ) { UG_TEXTBOX * txb ; UG_AREA a ; UG_TEXT txt ; txb = ( UG_TEXTBOX * ) ( obj -> data ) ; if ( obj -> state & OBJ_STATE_UPDATE ) { if ( obj -> state & OBJ_STATE_VISIBLE ) { if ( obj -> state & OBJ_STATE_REDRAW ) { UG_WindowGetArea ( wnd , & a ) ; obj -> a_abs . xs = obj -> a_rel . xs + a . xs ; obj -> a_abs . ys = obj -> a_rel . ys + a . ys ; obj -> a_abs . xe = obj -> a_rel . xe + a . xs ; obj -> a_abs . ye = obj -> a_rel . ye + a . ys ; if ( obj -> a_abs . ye >= wnd -> ye ) return ; if ( obj -> a_abs . xe >= wnd -> xe ) return ; # ifdef USE_PRERENDER_EVENT _UG_SendObjectPrerenderEvent ( wnd , obj ) ; # endif txt . bc = txb -> bc ; txt . fc = txb -> fc ; UG_FillFrame ( obj -> a_abs . xs , obj -> a_abs . ys , obj -> a_abs . xe , obj -> a_abs . ye , txt . bc ) ; txt . a . xs = obj -> a_abs . xs ; txt . a . ys = obj -> a_abs . ys ; txt . a . xe = obj -> a_abs . xe ; txt . a . ye = obj -> a_abs . ye ; txt . align = txb -> align ; txt . font = txb -> font ; txt . h_space = txb -> h_space ; txt . v_space = txb -> v_space ; txt . str = txb -> str ; _UG_PutText ( & txt ) ; obj -> state &= ~ OBJ_STATE_REDRAW ; # ifdef USE_POSTRENDER_EVENT _UG_SendObjectPostrenderEvent ( wnd , obj ) ; # endif } } else { <S2SV_StartBug> UG_FillFrame ( obj -> a_abs . xs , obj -> a_abs . ys , obj -> a_abs . xe , obj -> a_abs . ye , wnd -> bc ) ; <S2SV_EndBug> } obj -> state &= ~ OBJ_STATE_UPDATE ; } }
|
<S2SV_ModStart> } else { UG_WindowGetArea ( wnd , & a ) ; obj -> a_abs . xs = obj -> a_rel . xs + a . xs ; obj -> a_abs . ys = obj -> a_rel . ys + a . ys ; obj -> a_abs . xe = obj -> a_rel . xe + a . xs ; obj -> a_abs . ye = obj -> a_rel . ye + a . ys ;
|
7,105 |
CWE-000 int ft_conv_s ( t_form * form ) { wchar_t * wstr ; char * s ; if ( form -> conv == 's' && ! form -> mod ) { form -> arg = ft_strdup ( va_arg ( form -> ap , char * ) ) ; check_alloc ( ( void * ) form -> arg ) ; } <S2SV_StartBug> else if ( form -> conv == 's' && ( ( form -> mod ) [ 0 ] == 'l' || form -> conv == 'S' ) ) <S2SV_EndBug> { form -> arg = ft_strnew ( 0 ) ; wstr = va_arg ( form -> ap , wchar_t * ) ; while ( * wstr ) { check_alloc ( ( void * ) form -> arg ) ; ft_wchar_to_str ( * wstr , & s ) ; form -> arg = free_swap ( form -> arg , ft_strjoin ( form -> arg , s ) ) ; wstr ++ ; free ( s ) ; } } return ( ( form -> arg ) ? 1 : 0 ) ; }
|
<S2SV_ModStart> else if ( ( <S2SV_ModStart> == 's' && <S2SV_ModEnd> ( form -> <S2SV_ModStart> ] == 'l' ) <S2SV_ModStart> conv == 'S' <S2SV_ModEnd> ) { form
|
7,106 |
CWE-000 static boolean_t dbuf_undirty ( dmu_buf_impl_t * db , dmu_tx_t * tx ) { dnode_t * dn ; uint64_t txg = tx -> tx_txg ; dbuf_dirty_record_t * dr , * * drp ; ASSERT ( txg != 0 ) ; <S2SV_StartBug> ASSERT ( db -> db_blkid != DMU_BONUS_BLKID ) ; <S2SV_EndBug> ASSERT0 ( db -> db_level ) ; ASSERT ( MUTEX_HELD ( & db -> db_mtx ) ) ; for ( drp = & db -> db_last_dirty ; ( dr = * drp ) != NULL ; drp = & dr -> dr_next ) if ( dr -> dr_txg <= txg ) break ; if ( dr == NULL || dr -> dr_txg < txg ) return ( B_FALSE ) ; ASSERT ( dr -> dr_txg == txg ) ; ASSERT ( dr -> dr_dbuf == db ) ; DB_DNODE_ENTER ( db ) ; dn = DB_DNODE ( db ) ; dprintf_dbuf ( db , "size=%llx\\n" , ( u_longlong_t ) db -> db . db_size ) ; <S2SV_StartBug> ASSERT ( db -> db . db_size != 0 ) ; <S2SV_EndBug> * drp = dr -> dr_next ; if ( dr -> dr_parent ) { mutex_enter ( & dr -> dr_parent -> dt . di . dr_mtx ) ; list_remove ( & dr -> dr_parent -> dt . di . dr_children , dr ) ; mutex_exit ( & dr -> dr_parent -> dt . di . dr_mtx ) ; } else if ( db -> db_blkid == DMU_SPILL_BLKID || db -> db_level + 1 == dn -> dn_nlevels ) { ASSERT ( db -> db_blkptr == NULL || db -> db_parent == dn -> dn_dbuf ) ; mutex_enter ( & dn -> dn_mtx ) ; list_remove ( & dn -> dn_dirty_records [ txg & TXG_MASK ] , dr ) ; mutex_exit ( & dn -> dn_mtx ) ; } DB_DNODE_EXIT ( db ) ; if ( db -> db_state != DB_NOFILL ) { dbuf_unoverride ( dr ) ; ASSERT ( db -> db_buf != NULL ) ; ASSERT ( dr -> dt . dl . dr_data != NULL ) ; if ( dr -> dt . dl . dr_data != db -> db_buf ) VERIFY ( arc_buf_remove_ref ( dr -> dt . dl . dr_data , db ) ) ; } <S2SV_StartBug> if ( db -> db_level != 0 ) { <S2SV_EndBug> mutex_destroy ( & dr -> dt . di . dr_mtx ) ; list_destroy ( & dr -> dt . di . dr_children ) ; } kmem_free ( dr , sizeof ( dbuf_dirty_record_t ) ) ; ASSERT ( db -> db_dirtycnt > 0 ) ; db -> db_dirtycnt -= 1 ; if ( refcount_remove ( & db -> db_holds , ( void * ) ( uintptr_t ) txg ) == 0 ) { arc_buf_t * buf = db -> db_buf ; ASSERT ( db -> db_state == DB_NOFILL || arc_released ( buf ) ) ; dbuf_clear_data ( db ) ; VERIFY ( arc_buf_remove_ref ( buf , db ) ) ; dbuf_evict ( db ) ; return ( B_TRUE ) ; } return ( B_FALSE ) ; }
|
<S2SV_ModStart> ( db -> db_objset == dmu_objset_pool ( db -> db_objset ) -> dp_meta_objset || txg != spa_syncing_txg ( dmu_objset_spa ( db -> db_objset ) ) ) ; ASSERT ( db -> <S2SV_ModStart> db_size != 0 ) ; dsl_pool_undirty_space ( dmu_objset_pool ( dn -> dn_objset ) , dr -> dr_accounted , txg <S2SV_ModStart> ) ; } <S2SV_ModEnd> kmem_free ( dr
|
7,107 |
CWE-000 <S2SV_StartBug> size_t append_size ( size_t request_sizes [ ] , size_t len , size_t size ) { <S2SV_EndBug> for ( size_t i = 0 ; i < len ; ++ i ) { if ( request_sizes [ i ] == VACANT_SLOT_VAL ) { request_sizes [ i ] = size ; return i ; } } return len ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static
|
7,108 |
CWE-000 static int davinci_gpio_probe ( struct platform_device * pdev ) { int i , base ; <S2SV_StartBug> unsigned ngpio ; <S2SV_EndBug> struct davinci_gpio_controller * chips ; struct davinci_gpio_platform_data * pdata ; struct davinci_gpio_regs __iomem * regs ; struct device * dev = & pdev -> dev ; struct resource * res ; pdata = davinci_gpio_get_pdata ( pdev ) ; if ( ! pdata ) { dev_err ( dev , "No<S2SV_blank>platform<S2SV_blank>data<S2SV_blank>found\\n" ) ; return - EINVAL ; } dev -> platform_data = pdata ; ngpio = pdata -> ngpio ; if ( ngpio == 0 ) { dev_err ( dev , "How<S2SV_blank>many<S2SV_blank>GPIOs?\\n" ) ; return - EINVAL ; } if ( WARN_ON ( ARCH_NR_GPIOS < ngpio ) ) ngpio = ARCH_NR_GPIOS ; <S2SV_StartBug> chips = devm_kzalloc ( dev , <S2SV_EndBug> <S2SV_StartBug> ngpio * sizeof ( struct davinci_gpio_controller ) , <S2SV_EndBug> GFP_KERNEL ) ; if ( ! chips ) return - ENOMEM ; res = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; gpio_base = devm_ioremap_resource ( dev , res ) ; if ( IS_ERR ( gpio_base ) ) return PTR_ERR ( gpio_base ) ; for ( i = 0 , base = 0 ; base < ngpio ; i ++ , base += 32 ) { chips [ i ] . chip . label = "DaVinci" ; chips [ i ] . chip . direction_input = davinci_direction_in ; chips [ i ] . chip . get = davinci_gpio_get ; chips [ i ] . chip . direction_output = davinci_direction_out ; chips [ i ] . chip . set = davinci_gpio_set ; chips [ i ] . chip . base = base ; chips [ i ] . chip . ngpio = ngpio - base ; if ( chips [ i ] . chip . ngpio > 32 ) chips [ i ] . chip . ngpio = 32 ; # ifdef CONFIG_OF_GPIO chips [ i ] . chip . of_gpio_n_cells = 2 ; chips [ i ] . chip . of_xlate = davinci_gpio_of_xlate ; chips [ i ] . chip . parent = dev ; chips [ i ] . chip . of_node = dev -> of_node ; # endif spin_lock_init ( & chips [ i ] . lock ) ; regs = gpio2regs ( base ) ; chips [ i ] . regs = regs ; chips [ i ] . set_data = & regs -> set_data ; chips [ i ] . clr_data = & regs -> clr_data ; chips [ i ] . in_data = & regs -> in_data ; gpiochip_add_data ( & chips [ i ] . chip , & chips [ i ] ) ; } platform_set_drvdata ( pdev , chips ) ; davinci_gpio_irq_setup ( pdev ) ; return 0 ; }
|
<S2SV_ModStart> ; unsigned ngpio , nbank <S2SV_ModStart> = ARCH_NR_GPIOS ; nbank = DIV_ROUND_UP ( ngpio , 32 ) ; <S2SV_ModStart> ( dev , nbank <S2SV_ModEnd> * sizeof (
|
7,109 |
CWE-000 void oj_write_leaf_to_file ( Leaf leaf , const char * path , Options copts ) { char buf [ 4096 ] ; struct _Out out ; size_t size ; FILE * f ; out . buf = buf ; out . end = buf + sizeof ( buf ) - BUFFER_EXTRA ; out . allocated = 0 ; <S2SV_StartBug> oj_dump_leaf_to_json ( leaf , copts , & out ) ; <S2SV_EndBug> out . omit_nil = copts -> dump_opts . omit_nil ; <S2SV_StartBug> size = out . cur - out . buf ; <S2SV_EndBug> if ( 0 == ( f = fopen ( path , "w" ) ) ) { rb_raise ( rb_eIOError , "%s\\n" , strerror ( errno ) ) ; } if ( size != fwrite ( out . buf , 1 , size , f ) ) { int err = ferror ( f ) ; rb_raise ( rb_eIOError , "Write<S2SV_blank>failed.<S2SV_blank>[%d:%s]\\n" , err , strerror ( err ) ) ; } if ( out . allocated ) { xfree ( out . buf ) ; } fclose ( f ) ; }
|
<S2SV_ModStart> = 0 ; <S2SV_ModEnd> out . omit_nil <S2SV_ModStart> . omit_nil ; oj_dump_leaf_to_json ( leaf , copts , & out ) ;
|
7,110 |
CWE-000 int websocket_client ( void * arg ) { int i ; int r = WEBSOCKET_SUCCESS ; char * * argv = arg ; char * addr = NULL ; char * port = NULL ; char * path = NULL ; int tls = atoi ( argv [ 3 ] ) ; int size = atoi ( argv [ 4 ] ) ; int send_cnt = atoi ( argv [ 5 ] ) ; websocket_frame_t * tx_frame = NULL ; websocket_t * websocket_cli = NULL ; char * test_message = NULL ; static websocket_cb_t cb = { recv_cb , send_cb , genmask_cb , NULL , NULL , NULL , print_on_msg_cb } ; mbedtls_ssl_config conf ; mbedtls_x509_crt cert ; mbedtls_pk_context pkey ; mbedtls_entropy_context entropy ; mbedtls_ctr_drbg_context ctr_drbg ; mbedtls_ssl_cache_context cache ; if ( size < 16 ) { printf ( "wrong<S2SV_blank>size\\n<S2SV_blank>%s\\n" , WEBSOCKET_USAGE ) ; return - 1 ; } if ( send_cnt < 1 ) { printf ( "wrong<S2SV_blank>send<S2SV_blank>count\\n<S2SV_blank>%s\\n" , WEBSOCKET_USAGE ) ; return - 1 ; } addr = malloc ( strlen ( argv [ 0 ] ) + 1 ) ; if ( addr == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } port = malloc ( strlen ( argv [ 1 ] ) + 1 ) ; if ( port == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } path = malloc ( strlen ( argv [ 2 ] ) + 1 ) ; if ( path == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } memset ( addr , 0 , strlen ( argv [ 0 ] ) + 1 ) ; memset ( port , 0 , strlen ( argv [ 1 ] ) + 1 ) ; memset ( path , 0 , strlen ( argv [ 2 ] ) + 1 ) ; strncpy ( addr , argv [ 0 ] , strlen ( argv [ 0 ] ) ) ; strncpy ( port , argv [ 1 ] , strlen ( argv [ 1 ] ) ) ; strncpy ( path , argv [ 2 ] , strlen ( argv [ 2 ] ) ) ; received_cnt = 0 ; websocket_cli = malloc ( sizeof ( websocket_t ) ) ; if ( websocket_cli == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } memset ( websocket_cli , 0 , sizeof ( websocket_t ) ) ; websocket_cli -> fd = - 1 ; websocket_cli -> cb = & cb ; websocket_cli -> tls_enabled = tls ; if ( tls ) { # ifdef MBEDTLS_DEBUG_C mbedtls_debug_set_threshold ( MBEDTLS_DEBUG_LEVEL ) ; # endif if ( ( r = websocket_tls_init ( 1 , websocket_cli , & conf , & cert , & pkey , & entropy , & ctr_drbg , & cache ) ) != WEBSOCKET_SUCCESS ) { printf ( "fail<S2SV_blank>to<S2SV_blank>init<S2SV_blank>TLS,<S2SV_blank>error:<S2SV_blank>%d\\n" , r ) ; goto WEB_CLI_EXIT ; } websocket_cli -> tls_ssl = malloc ( sizeof ( mbedtls_ssl_context ) ) ; if ( websocket_cli -> tls_ssl == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } mbedtls_net_init ( & ( websocket_cli -> tls_net ) ) ; mbedtls_ssl_init ( websocket_cli -> tls_ssl ) ; } printf ( "start<S2SV_blank>opening<S2SV_blank>websocket<S2SV_blank>client<S2SV_blank>to<S2SV_blank>addr:<S2SV_blank>%s,<S2SV_blank>port:<S2SV_blank>%s,<S2SV_blank>Security:<S2SV_blank>%s\\n" , addr , port , tls ? "enabled" : "disabled" ) ; r = websocket_client_open ( websocket_cli , addr , port , path ) ; if ( r != WEBSOCKET_SUCCESS ) { printf ( "websocket_client_open<S2SV_blank>returned<S2SV_blank>error:<S2SV_blank>%d\\n" , r ) ; goto WEB_CLI_EXIT ; } test_message = malloc ( size ) ; if ( test_message == NULL ) { goto WEB_CLI_EXIT ; } memset ( test_message , '.' , size ) ; <S2SV_StartBug> sprintf ( test_message , "[%d]<S2SV_blank>hello<S2SV_blank>websocket" , size ) ; <S2SV_EndBug> test_message [ size - 1 ] = '\\0' ; tx_frame = malloc ( sizeof ( websocket_frame_t ) ) ; if ( tx_frame == NULL ) { printf ( "fail<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory\\n" ) ; goto WEB_CLI_EXIT ; } memset ( tx_frame , 0 , sizeof ( websocket_frame_t ) ) ; tx_frame -> opcode = WEBSOCKET_TEXT_FRAME ; tx_frame -> msg = ( const uint8_t * ) test_message ; tx_frame -> msg_length = size ; for ( i = 1 ; i <= send_cnt ; i ++ ) { r = websocket_queue_msg ( websocket_cli , tx_frame ) ; if ( r != WEBSOCKET_SUCCESS ) { printf ( "websocket_queue_msg<S2SV_blank>returned<S2SV_blank>error<S2SV_blank>:<S2SV_blank>%d\\n" , r ) ; goto WEB_CLI_EXIT ; } while ( received_cnt != i ) { if ( websocket_cli -> state == WEBSOCKET_STOP ) { goto WEB_CLI_EXIT ; } usleep ( 100000 ) ; } } while ( websocket_cli -> state == WEBSOCKET_RUNNING ) { if ( received_cnt == send_cnt ) { printf ( "all<S2SV_blank>message<S2SV_blank>was<S2SV_blank>received<S2SV_blank>well\\n" ) ; break ; } usleep ( 100000 ) ; } ; WEB_CLI_EXIT : r = websocket_queue_close ( websocket_cli , NULL ) ; if ( r != WEBSOCKET_SUCCESS ) { printf ( "websocket_close<S2SV_blank>returned<S2SV_blank>error<S2SV_blank>:<S2SV_blank>%d\\n" , r ) ; } printf ( "websocket<S2SV_blank>client<S2SV_blank>%s<S2SV_blank>[%d]\\n" , ( r ? "error" : "finished" ) , r ) ; if ( tx_frame ) { free ( tx_frame ) ; } if ( tls ) { websocket_tls_release ( 1 , & conf , & cert , & pkey , & entropy , & ctr_drbg , & cache ) ; if ( websocket_cli -> tls_ssl ) { mbedtls_ssl_free ( websocket_cli -> tls_ssl ) ; free ( websocket_cli -> tls_ssl ) ; } } if ( websocket_cli ) { free ( websocket_cli ) ; } if ( addr ) { free ( addr ) ; } if ( port ) { free ( port ) ; } if ( path ) { free ( path ) ; } if ( test_message ) { free ( test_message ) ; } return r ; }
|
<S2SV_ModStart> ( test_message , "[%d]<S2SV_blank>websocket" <S2SV_ModEnd> , size )
|
7,111 |
CWE-000 void unserialize_response ( char * buffer , t_game * g ) { char * * response ; char * * buff ; char * * buff2 ; <S2SV_StartBug> response = my_str_to_wordtab ( buffer , '<S2SV_blank>' ) ; <S2SV_EndBug> <S2SV_StartBug> buff = my_str_to_wordtab ( response [ 0 ] , ':' ) ; <S2SV_EndBug> g -> info -> status = atoi ( buff [ 0 ] ) ; g -> info -> max_player = atoi ( buff [ 1 ] ) ; g -> info -> winner = atoi ( buff [ 2 ] ) ; g -> info -> throw_bomb = atoi ( buff [ 3 ] ) ; g -> info -> player_move = atoi ( buff [ 4 ] ) ; <S2SV_StartBug> buff = my_str_to_wordtab ( response [ 1 ] , ';' ) ; <S2SV_EndBug> for ( int i = 0 ; i < MAX_PLAYER ; i ++ ) { if ( ( buff2 = my_str_to_wordtab ( buff [ i ] , ':' ) ) ) { if ( g -> player [ i ] != NULL ) { g -> player [ i ] -> x = atoi ( buff2 [ 0 ] ) ; g -> player [ i ] -> y = atoi ( buff2 [ 1 ] ) ; g -> player [ i ] -> dir = atoi ( buff2 [ 2 ] ) ; g -> player [ i ] -> ammo = atoi ( buff2 [ 3 ] ) ; g -> player [ i ] -> reload = atoi ( buff2 [ 4 ] ) ; g -> player [ i ] -> frags = atoi ( buff2 [ 5 ] ) ; g -> player [ i ] -> connected = atoi ( buff2 [ 6 ] ) ; g -> player [ i ] -> life = atoi ( buff2 [ 7 ] ) ; g -> player [ i ] -> speed = atoi ( buff2 [ 8 ] ) ; } } } <S2SV_StartBug> buff = my_str_to_wordtab ( response [ 2 ] , ';' ) ; <S2SV_EndBug> for ( int i = 0 ; i < MAP_SIZE ; ++ i ) { <S2SV_StartBug> buff2 = my_str_to_wordtab ( buff [ i ] , ':' ) ; <S2SV_EndBug> for ( int j = 0 ; j < MAP_SIZE ; ++ j ) { g -> map [ i ] [ j ] . data = buff2 [ j ] ; } } }
|
<S2SV_ModStart> * buff2 ; if ( ! ( <S2SV_ModStart> , '<S2SV_blank>' ) ) ) return ; if ( ! ( <S2SV_ModEnd> buff = my_str_to_wordtab <S2SV_ModStart> , ':' ) ) ) return <S2SV_ModStart> ] ) ; if ( ! ( <S2SV_ModStart> , ';' ) ) ) return <S2SV_ModStart> } } } if ( ! ( <S2SV_ModStart> , ';' ) ) ) return <S2SV_ModStart> i ) { if ( ! ( <S2SV_ModStart> , ':' ) ) ) return
|
7,112 |
CWE-000 void detectEdgeCanny ( unsigned char * image8 , unsigned char * tempBuf , int * width , int * height ) { <S2SV_StartBug> gaussBlur5x5 ( image8 , tempBuf , width , height ) ; <S2SV_EndBug> int * Gx = sobelHoriz ( image8 , width , height ) ; int * Gy = sobelVert ( image8 , width , height ) ; * width = * width - 2 ; * height = * height - 2 ; int * direction = edgeDirection ( Gx , Gy , * width , * height ) ; int * magnitude = edgeMagnitude ( Gx , Gy , * width , * height ) ; nonMaxSuppress ( image8 , magnitude , direction , * width , * height ) ; <S2SV_StartBug> doubleThreshold ( image8 , direction , width , height ) ; <S2SV_EndBug> free ( Gx ) ; free ( Gy ) ; free ( direction ) ; free ( magnitude ) ; }
|
<S2SV_ModStart> height ) { unsigned char avg = averagePixel ( image8 , * width , * height ) ; avg = 2 * avg / 4 ; printf ( "%d\\n" , avg ) ; LOW_THRESH = 84 * avg / 64 ; HIGH_THRESH = 42 * avg / 64 ; <S2SV_ModStart> ( image8 , <S2SV_ModEnd> width , height
|
7,113 |
CWE-000 void dwc2_hcd_qh_free ( struct dwc2_hsotg * hsotg , struct dwc2_qh * qh ) <S2SV_StartBug> { <S2SV_EndBug> if ( hsotg -> core_params -> dma_desc_enable > 0 ) dwc2_hcd_qh_free_ddma ( hsotg , qh ) ; else if ( qh -> dw_align_buf ) dma_free_coherent ( hsotg -> dev , qh -> dw_align_buf_size , qh -> dw_align_buf , qh -> dw_align_buf_dma ) ; kfree ( qh ) ; }
|
<S2SV_ModStart> qh ) { del_timer_sync ( & qh -> wait_timer ) ;
|
7,114 |
CWE-000 static int ft_bw_atomic ( void ) { int ret , i ; enum fi_datatype datatype ; size_t count ; if ( listen_sock < 0 ) { for ( datatype = 0 ; datatype <= FI_LONG_DOUBLE_COMPLEX ; datatype ++ ) { ft_atom_ctrl . datatype = datatype ; ret = check_atomic_attr ( & count ) ; ft_atom_ctrl . count = ft_tx_ctrl . rma_msg_size / ft_atom_ctrl . datatype_size ; if ( ret == - FI_ENOSYS || ret == - FI_EOPNOTSUPP || ft_atom_ctrl . count > count || ft_atom_ctrl . count == 0 ) { ret = 0 ; continue ; } if ( ret ) return ret ; for ( i = 0 ; i < ft_ctrl . xfer_iter ; i ++ ) { ret = ft_send_rma ( ) ; <S2SV_StartBug> } <S2SV_EndBug> } ret = ft_send_msg ( ) ; if ( ret ) return ret ; } else { ret = ft_recv_msg ( ) ; if ( ret ) return ret ; } return 0 ; }
|
<S2SV_ModStart> ( ) ; if ( ret ) return ret ;
|
7,115 |
CWE-000 void segment_add_datasum ( struct segment * seg , char * block , uint32_t size ) { uint32_t i ; for ( i = 0 ; i < size ; i += DFL_LFSBLOCK ) { <S2SV_StartBug> memcpy ( seg , & block [ i ] , sizeof ( int32_t ) ) ; <S2SV_EndBug> <S2SV_StartBug> seg -> cur_data_for_cksum ++ ; <S2SV_EndBug> } }
|
<S2SV_ModStart> DFL_LFSBLOCK ) { assert ( seg -> cksum_idx < MAX_BLOCKS_PER_SEG <S2SV_ModEnd> ) ; seg <S2SV_ModStart> ; seg -> data_for_cksum [ seg -> cksum_idx ++ ] = block [ i ] <S2SV_ModEnd> ; } }
|
7,116 |
CWE-000 void manualControl ( struct message_info tmessage ) { static uint8_t receivedTestData [ 5 ] ; newDataFlag = 0 ; uint16_t straightDirection ; convertData ( tmessage , receivedTestData ) ; straightDirection = ( receivedTestData [ 0 ] << 8 ) + ( receivedTestData [ 1 ] ) ; if ( tmessage . command == MANUAL_STRAIGHT ) { moveRobot ( straightDirection , receivedTestData [ 2 ] ) ; } else if ( tmessage . command == MANUAL_STOP ) { <S2SV_StartBug> robotState = IDLE ; <S2SV_EndBug> } else if ( tmessage . command == CW ) { signed char speed = - 1 * receivedTestData [ 0 ] ; rotateRobot ( speed ) ; } else if ( tmessage . command == CCW ) { rotateRobot ( receivedTestData [ 0 ] ) ; } }
|
<S2SV_ModStart> MANUAL_STOP ) { mainRobotState <S2SV_ModEnd> = IDLE ;
|
7,117 |
CWE-000 static int dw_i2c_plat_remove ( struct platform_device * pdev ) { struct dw_i2c_dev * dev = platform_get_drvdata ( pdev ) ; <S2SV_StartBug> pm_runtime_get_sync ( & pdev -> dev ) ; <S2SV_EndBug> i2c_del_adapter ( & dev -> adapter ) ; i2c_dw_disable ( dev ) ; pm_runtime_dont_use_autosuspend ( & pdev -> dev ) ; <S2SV_StartBug> pm_runtime_put_sync ( & pdev -> dev ) ; <S2SV_EndBug> if ( ! dev -> pm_runtime_disabled ) pm_runtime_disable ( & pdev -> dev ) ; return 0 ; }
|
<S2SV_ModStart> pdev ) ; pm_runtime_get <S2SV_ModEnd> ( & pdev <S2SV_ModStart> dev ) ; pm_runtime_put <S2SV_ModEnd> ( & pdev
|
7,118 |
CWE-000 int smb_vfs_unlink ( char * name ) { struct path parent ; struct dentry * dir , * dentry ; char * last ; int err = - ENOENT ; last = strrchr ( name , '/' ) ; if ( last && last [ 1 ] != '\\0' ) { * last = '\\0' ; last ++ ; } else { cifssrv_debug ( "can\'t<S2SV_blank>get<S2SV_blank>last<S2SV_blank>component<S2SV_blank>in<S2SV_blank>path<S2SV_blank>%s\\n" , name ) ; return - ENOENT ; } err = kern_path ( name , LOOKUP_FOLLOW | LOOKUP_DIRECTORY , & parent ) ; if ( err ) { cifssrv_debug ( "can\'t<S2SV_blank>get<S2SV_blank>%s,<S2SV_blank>err<S2SV_blank>%d\\n" , name , err ) ; return err ; } dir = parent . dentry ; if ( ! dir -> d_inode ) goto out ; <S2SV_StartBug> # if LINUX_VERSION_CODE > KERNEL_VERSION ( 4 , 1 , 10 ) <S2SV_EndBug> inode_lock_nested ( dir -> d_inode , I_MUTEX_PARENT ) ; # else mutex_lock_nested ( & dir -> d_inode -> i_mutex , I_MUTEX_PARENT ) ; # endif dentry = lookup_one_len ( last , dir , strlen ( last ) ) ; if ( IS_ERR ( dentry ) ) { err = PTR_ERR ( dentry ) ; cifssrv_debug ( "%s:<S2SV_blank>lookup<S2SV_blank>failed,<S2SV_blank>err<S2SV_blank>%d\\n" , last , err ) ; goto out_err ; } if ( ! dentry -> d_inode || ! dentry -> d_inode -> i_nlink ) { dput ( dentry ) ; err = - ENOENT ; goto out_err ; } if ( S_ISDIR ( dentry -> d_inode -> i_mode ) ) { err = vfs_rmdir ( dir -> d_inode , dentry ) ; if ( err && err != - ENOTEMPTY ) cifssrv_debug ( "%s:<S2SV_blank>rmdir<S2SV_blank>failed,<S2SV_blank>err<S2SV_blank>%d\\n" , name , err ) ; } else { # if LINUX_VERSION_CODE > KERNEL_VERSION ( 3 , 10 , 30 ) err = vfs_unlink ( dir -> d_inode , dentry , NULL ) ; # else err = vfs_unlink ( dir -> d_inode , dentry ) ; # endif if ( err ) cifssrv_debug ( "%s:<S2SV_blank>unlink<S2SV_blank>failed,<S2SV_blank>err<S2SV_blank>%d\\n" , name , err ) ; } dput ( dentry ) ; out_err : <S2SV_StartBug> # if LINUX_VERSION_CODE > KERNEL_VERSION ( 4 , 1 , 10 ) <S2SV_EndBug> inode_unlock ( dir -> d_inode ) ; # else mutex_unlock ( & dir -> d_inode -> i_mutex ) ; # endif out : path_put ( & parent ) ; return err ; }
|
<S2SV_ModStart> # if LINUX_VERSION_CODE >= <S2SV_ModEnd> KERNEL_VERSION ( 4 <S2SV_ModStart> ( 4 , 2 , 0 <S2SV_ModEnd> ) inode_lock_nested ( <S2SV_ModStart> # if LINUX_VERSION_CODE >= <S2SV_ModEnd> KERNEL_VERSION ( 4 <S2SV_ModStart> ( 4 , 2 , 0 <S2SV_ModEnd> ) inode_unlock (
|
7,119 |
CWE-000 static int configure_cmd ( void * arg ) { int n , i = 0 ; unsigned int checksum = 0 ; update_data_t * ud = arg ; stepgen_t * stepgen = ud -> stepgen ; tx_buf [ i ++ ] = SWAP_BYTES ( CMD_CFG ) ; tx_buf [ i ++ ] = SWAP_BYTES ( base_freq ) ; <S2SV_StartBug> tx_buf [ i ++ ] = SWAP_BYTES ( num_axes ) ; <S2SV_EndBug> <S2SV_StartBug> tx_buf [ i ++ ] = SWAP_BYTES ( num_pwm ) ; <S2SV_EndBug> <S2SV_StartBug> for ( n = 0 ; n < num_axes ; n ++ ) { <S2SV_EndBug> tx_buf [ i ++ ] = SWAP_BYTES ( ( unsigned int ) stepgen_array [ n ] . axis ) ; tx_buf [ i ++ ] = SWAP_BYTES ( stepgen_array [ n ] . step_len_ticks ) ; tx_buf [ i ++ ] = SWAP_BYTES ( stepgen_array [ n ] . step_space_ticks ) ; tx_buf [ i ++ ] = SWAP_BYTES ( stepgen_array [ n ] . dir_setup_ticks ) ; tx_buf [ i ++ ] = SWAP_BYTES ( stepgen_array [ n ] . dir_hold_ticks ) ; } <S2SV_StartBug> for ( n = 0 ; n < num_pwm ; n ++ ) { <S2SV_EndBug> tx_buf [ i ++ ] = SWAP_BYTES ( pwmgen_array [ n ] . pwm_frequency ) ; } for ( n = 0 ; n < i ; n ++ ) checksum ^= tx_buf [ n ] ; tx_buf [ i ++ ] = checksum ; if ( ! spi_xmit ( ++ i ) ) { rtapi_print_msg ( RTAPI_MSG_ERR , "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>configuration<S2SV_blank>update<S2SV_blank>to<S2SV_blank>controller.\\n" , module_name ) ; return 0 ; } return 1 ; }
|
<S2SV_ModStart> = SWAP_BYTES ( ud -> <S2SV_ModStart> = SWAP_BYTES ( ud -> <S2SV_ModStart> ; n < ud -> <S2SV_ModStart> ; n < ud ->
|
7,120 |
CWE-000 static int _wait_for_all_windows ( nrt_tableinfo_t * tableinfo ) { int err , i , rc = SLURM_SUCCESS ; int retry = 15 ; nrt_window_id_t window_id = 0 ; if ( ! my_lpar_id_set && ! my_network_id_set ) _get_my_id ( ) ; for ( i = 0 ; i < tableinfo -> table_length ; i ++ ) { if ( tableinfo -> adapter_type == NRT_IB ) { nrt_ib_task_info_t * ib_tbl_ptr ; ib_tbl_ptr = ( nrt_ib_task_info_t * ) tableinfo -> table ; ib_tbl_ptr += i ; if ( ib_tbl_ptr -> node_number != my_network_id ) continue ; window_id = ib_tbl_ptr -> win_id ; } else if ( tableinfo -> adapter_type == NRT_HFI ) { nrt_hfi_task_info_t * hfi_tbl_ptr ; hfi_tbl_ptr = ( nrt_hfi_task_info_t * ) tableinfo -> table ; hfi_tbl_ptr += i ; <S2SV_StartBug> if ( hfi_tbl_ptr -> lpar_id != my_lpar_id ) <S2SV_EndBug> continue ; window_id = hfi_tbl_ptr -> win_id ; } # if NRT_VERSION < 1300 else if ( ( tableinfo -> adapter_type == NRT_HPCE ) || ( tableinfo -> adapter_type == NRT_KMUX ) ) { nrt_hpce_task_info_t * hpce_tbl_ptr ; hpce_tbl_ptr = ( nrt_hpce_task_info_t * ) tableinfo -> table ; hpce_tbl_ptr += i ; if ( hpce_tbl_ptr -> node_number != my_network_id ) continue ; window_id = hpce_tbl_ptr -> win_id ; } # endif else { error ( "_wait_for_all_windows:<S2SV_blank>Missing<S2SV_blank>support<S2SV_blank>for<S2SV_blank>" "adapter_type<S2SV_blank>%s" , _adapter_type_str ( tableinfo -> adapter_type ) ) ; } err = _wait_for_window_unloaded ( tableinfo -> adapter_name , tableinfo -> adapter_type , window_id , retry ) ; if ( err != SLURM_SUCCESS ) { error ( "Window<S2SV_blank>%hu<S2SV_blank>adapter<S2SV_blank>%s<S2SV_blank>did<S2SV_blank>not<S2SV_blank>" "become<S2SV_blank>free<S2SV_blank>within<S2SV_blank>%d<S2SV_blank>seconds" , window_id , tableinfo -> adapter_name , retry ) ; rc = err ; } } return rc ; }
|
<S2SV_ModStart> ; if ( ( <S2SV_ModStart> lpar_id != my_lpar_id ) || ( hfi_tbl_ptr -> lid != my_lid )
|
7,121 |
CWE-000 <S2SV_StartBug> SMILE_EXTERNAL_FUNCTION ( RadToDeg ) <S2SV_EndBug> { <S2SV_StartBug> return SmileUnboxedReal32_From ( Real32_Mul ( argv [ 0 ] . unboxed . r32 , _radToDegConstant ) ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> SMILE_EXTERNAL_FUNCTION ( DegToRad <S2SV_ModEnd> ) { return <S2SV_ModStart> . r32 , _degToRadConstant <S2SV_ModEnd> ) ) ;
|
7,122 |
CWE-000 static void __cpufreq_interactive_timer ( unsigned long data , bool is_notif ) { s64 now ; unsigned int delta_time ; u64 cputime_speedadj ; int cpu_load ; int pol_load = 0 ; struct cpufreq_interactive_policyinfo * ppol = per_cpu ( polinfo , data ) ; struct cpufreq_interactive_tunables * tunables = ppol -> policy -> governor_data ; struct cpufreq_interactive_cpuinfo * pcpu ; <S2SV_StartBug> unsigned int new_freq ; <S2SV_EndBug> unsigned int loadadjfreq = 0 , tmploadadjfreq ; unsigned int index ; unsigned long flags ; unsigned long max_cpu ; int i , fcpu ; struct cpufreq_govinfo govinfo ; if ( ! down_read_trylock ( & ppol -> enable_sem ) ) return ; if ( ! ppol -> governor_enabled ) goto exit ; fcpu = cpumask_first ( ppol -> policy -> related_cpus ) ; now = ktime_to_us ( ktime_get ( ) ) ; spin_lock_irqsave ( & ppol -> load_lock , flags ) ; ppol -> last_evaluated_jiffy = get_jiffies_64 ( ) ; max_cpu = cpumask_first ( ppol -> policy -> cpus ) ; for_each_cpu ( i , ppol -> policy -> cpus ) { pcpu = & per_cpu ( cpuinfo , i ) ; if ( tunables -> use_sched_load ) { cputime_speedadj = ( u64 ) ppol -> cpu_busy_times [ i - fcpu ] * ppol -> policy -> cpuinfo . max_freq ; do_div ( cputime_speedadj , tunables -> timer_rate ) ; } else { now = update_load ( i ) ; delta_time = ( unsigned int ) ( now - pcpu -> cputime_speedadj_timestamp ) ; if ( WARN_ON_ONCE ( ! delta_time ) ) continue ; cputime_speedadj = pcpu -> cputime_speedadj ; do_div ( cputime_speedadj , delta_time ) ; } tmploadadjfreq = ( unsigned int ) cputime_speedadj * 100 ; pcpu -> loadadjfreq = tmploadadjfreq ; trace_cpufreq_interactive_cpuload ( i , tmploadadjfreq / ppol -> policy -> cur ) ; if ( tmploadadjfreq > loadadjfreq ) { loadadjfreq = tmploadadjfreq ; max_cpu = i ; } } spin_unlock_irqrestore ( & ppol -> load_lock , flags ) ; for_each_cpu ( i , ppol -> policy -> cpus ) { pcpu = & per_cpu ( cpuinfo , i ) ; govinfo . cpu = i ; govinfo . load = pcpu -> loadadjfreq / ppol -> policy -> max ; govinfo . sampling_rate_us = tunables -> timer_rate ; atomic_notifier_call_chain ( & cpufreq_govinfo_notifier_list , CPUFREQ_LOAD_CHANGE , & govinfo ) ; } spin_lock_irqsave ( & ppol -> target_freq_lock , flags ) ; cpu_load = loadadjfreq / ppol -> target_freq ; tunables -> boosted = tunables -> boost_val || now < tunables -> boostpulse_endtime ; if ( tunables -> ignore_hispeed_on_notif && is_notif ) { new_freq = choose_freq ( ppol , loadadjfreq ) ; } else if ( cpu_load >= tunables -> go_hispeed_load || tunables -> boosted ) { if ( ppol -> target_freq < tunables -> hispeed_freq ) { new_freq = tunables -> hispeed_freq ; } else { new_freq = choose_freq ( ppol , loadadjfreq ) ; if ( new_freq < tunables -> hispeed_freq ) new_freq = tunables -> hispeed_freq ; else new_freq = max ( new_freq , tunables -> hispeed_freq ) ; } } if ( ( ! tunables -> ignore_hispeed_on_notif || ! is_notif ) && ppol -> target_freq >= tunables -> hispeed_freq && new_freq > ppol -> target_freq && now - ppol -> hispeed_validate_time < freq_to_above_hispeed_delay ( tunables , ppol -> target_freq ) ) { trace_cpufreq_interactive_notyet ( max_cpu , pol_load , ppol -> target_freq , ppol -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; goto rearm ; } ppol -> hispeed_validate_time = now ; if ( cpufreq_frequency_table_target ( ppol -> policy , ppol -> freq_table , new_freq , CPUFREQ_RELATION_L , & index ) ) { spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; goto rearm ; } new_freq = ppol -> freq_table [ index ] . frequency ; if ( ( ! tunables -> fast_ramp_down || ! is_notif ) && new_freq < ppol -> target_freq && now - ppol -> max_freq_hyst_start_time < tunables -> max_freq_hysteresis ) { trace_cpufreq_interactive_notyet ( max_cpu , cpu_load , ppol -> target_freq , ppol -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; goto rearm ; } if ( ( ! tunables -> fast_ramp_down || ! is_notif ) && new_freq < ppol -> floor_freq ) { if ( now - ppol -> floor_validate_time < tunables -> min_sample_time ) { trace_cpufreq_interactive_notyet ( max_cpu , pol_load , ppol -> target_freq , ppol -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; goto rearm ; } } if ( ! tunables -> boosted || new_freq > tunables -> hispeed_freq ) { ppol -> floor_freq = new_freq ; ppol -> floor_validate_time = now ; } if ( new_freq == ppol -> policy -> max ) ppol -> max_freq_hyst_start_time = now ; if ( ppol -> target_freq == new_freq && ppol -> target_freq <= ppol -> policy -> cur ) { trace_cpufreq_interactive_already ( max_cpu , pol_load , ppol -> target_freq , ppol -> policy -> cur , new_freq ) ; spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; goto rearm ; } trace_cpufreq_interactive_target ( max_cpu , pol_load , ppol -> target_freq , ppol -> policy -> cur , new_freq ) ; ppol -> target_freq = new_freq ; spin_unlock_irqrestore ( & ppol -> target_freq_lock , flags ) ; spin_lock_irqsave ( & speedchange_cpumask_lock , flags ) ; cpumask_set_cpu ( max_cpu , & speedchange_cpumask ) ; spin_unlock_irqrestore ( & speedchange_cpumask_lock , flags ) ; wake_up_process_no_notif ( speedchange_task ) ; rearm : if ( ! timer_pending ( & ppol -> policy_timer ) ) cpufreq_interactive_timer_resched ( data , false ) ; exit : up_read ( & ppol -> enable_sem ) ; return ; }
|
<S2SV_ModStart> unsigned int new_freq = 0
|
7,123 |
CWE-000 int tfb_set_window ( u32 x , u32 y , u32 w , u32 h ) { if ( x + w > __fb_screen_w ) <S2SV_StartBug> return TFB_INVALID_WINDOW ; <S2SV_EndBug> if ( y + h > __fb_screen_h ) <S2SV_StartBug> return TFB_INVALID_WINDOW ; <S2SV_EndBug> __fb_off_x = __fbi . xoffset + x ; __fb_off_y = __fbi . yoffset + y ; __fb_win_w = w ; __fb_win_h = h ; __fb_win_end_x = __fb_off_x + __fb_win_w ; __fb_win_end_y = __fb_off_y + __fb_win_h ; return TFB_SUCCESS ; }
|
<S2SV_ModStart> __fb_screen_w ) return TFB_ERR_INVALID_WINDOW <S2SV_ModEnd> ; if ( <S2SV_ModStart> __fb_screen_h ) return TFB_ERR_INVALID_WINDOW <S2SV_ModEnd> ; __fb_off_x =
|
7,124 |
CWE-000 void <S2SV_StartBug> BlockInfo_Set_tttn ( BlockInfo * bi , int8 ttt , int8 n , int8 overWriteSize ) <S2SV_EndBug> { bi -> LogicCode = Here ; if ( ! GetState ( _Context_ , C_SYNTAX ) ) bi -> LogicCodeWord = Compiler_WordList ( 1 ) ; bi -> Ttt = ttt ; <S2SV_StartBug> bi -> NegFlag = n ; <S2SV_EndBug> bi -> OverWriteSize = overWriteSize ; }
|
<S2SV_ModStart> ttt , int8 negFlag <S2SV_ModEnd> , int8 overWriteSize <S2SV_ModStart> -> NegFlag = negFlag <S2SV_ModEnd> ; bi ->
|
7,125 |
CWE-000 void placeInSuperObject ( Data * super_object , Data * objects , int num_objs , int * index ) { int j = 0 ; int idx = * index ; Data * sub_objects = malloc ( ( num_objs - idx + 1 ) * sizeof ( Data ) ) ; <S2SV_StartBug> while ( super_object -> this_tree_address == objects [ idx ] . parent_tree_address ) <S2SV_EndBug> { sub_objects [ j ] = objects [ idx ] ; idx ++ ; if ( sub_objects [ j ] . type == STRUCT || sub_objects [ j ] . type == REF ) { placeInSuperObject ( & sub_objects [ j ] , objects , num_objs , & idx ) ; } j ++ ; } sub_objects [ j ] . type = UNDEF ; super_object -> sub_objects = sub_objects ; * index = idx ; }
|
<S2SV_ModStart> ( super_object -> this_obj_address <S2SV_ModEnd> == objects [ <S2SV_ModStart> idx ] . parent_obj_address <S2SV_ModEnd> ) { sub_objects
|
7,126 |
CWE-000 size_t hw_malloc_all ( void * * p , size_t align ) { <S2SV_StartBug> void * memory_align_bgn ; <S2SV_EndBug> int left ; if ( align ) { <S2SV_StartBug> memory_align_bgn = CUPKEE_ADDR_ALIGN ( memory_bgn , align ) ; <S2SV_EndBug> } else { <S2SV_StartBug> memory_align_bgn = memory_bgn ; <S2SV_EndBug> } <S2SV_StartBug> left = memory_end - memory_align_bgn ; <S2SV_EndBug> memory_bgn = memory_align_bgn + left ; if ( p ) { <S2SV_StartBug> * p = memory_align_bgn ; <S2SV_EndBug> } return left ; }
|
<S2SV_ModStart> { void * memory_align <S2SV_ModEnd> ; int left <S2SV_ModStart> align ) { memory_align <S2SV_ModEnd> = CUPKEE_ADDR_ALIGN ( <S2SV_ModStart> = CUPKEE_ADDR_ALIGN ( hw_memory_bgn <S2SV_ModEnd> , align ) <S2SV_ModStart> } else { memory_align = hw_memory_bgn <S2SV_ModEnd> ; } left <S2SV_ModStart> } left = hw_memory_end - memory_align ; hw_memory_bgn = memory_align <S2SV_ModEnd> + left ; <S2SV_ModStart> * p = memory_align <S2SV_ModEnd> ; } return
|
7,127 |
CWE-000 void process_messages ( int sock , int buf_id ) { size_t received = recv ( sock , bufs [ buf_id ] . curr_buf , bufs [ buf_id ] . curr_size , 0 ) ; cw_log ( "recv()<S2SV_blank>returned:<S2SV_blank>%d\\n" , ( int ) received ) ; if ( received == 0 ) { cw_log ( "Connection<S2SV_blank>closed<S2SV_blank>by<S2SV_blank>remote<S2SV_blank>end\\n" ) ; close ( sock ) ; free ( bufs [ buf_id ] . buf ) ; bufs [ buf_id ] . buf = NULL ; return ; } else if ( received == - 1 && ( errno == EAGAIN || errno == EWOULDBLOCK ) ) { cw_log ( "Got<S2SV_blank>EAGAIN<S2SV_blank>or<S2SV_blank>EWOULDBLOCK,<S2SV_blank>ignoring...\\n" ) ; return ; } else if ( received == - 1 ) { perror ( "Unexpected<S2SV_blank>error!" ) ; exit ( - 1 ) ; } bufs [ buf_id ] . curr_buf += received ; bufs [ buf_id ] . curr_size -= received ; unsigned char * buf = bufs [ buf_id ] . buf ; unsigned long msg_size = bufs [ buf_id ] . curr_buf - buf ; do { if ( msg_size < 8 ) { cw_log ( "Got<S2SV_blank>incomplete<S2SV_blank>header,<S2SV_blank>need<S2SV_blank>to<S2SV_blank>recv()<S2SV_blank>more...\\n" ) ; break ; } message_t * m = ( message_t * ) buf ; cw_log ( "Received<S2SV_blank>%lu<S2SV_blank>bytes,<S2SV_blank>req_id=%u,<S2SV_blank>req_size=%u,<S2SV_blank>num=%d\\n" , msg_size , m -> req_id , m -> req_size , m -> num ) ; if ( msg_size < m -> req_size ) { cw_log ( "Got<S2SV_blank>header<S2SV_blank>but<S2SV_blank>incomplete<S2SV_blank>message,<S2SV_blank>need<S2SV_blank>to<S2SV_blank>recv()<S2SV_blank>more...\\n" ) ; break ; } if ( m -> num >= 1 ) { if ( m -> cmds [ 0 ] . cmd == COMPUTE ) { compute_for ( m -> cmds [ 0 ] . u . comp_time_us ) ; } } <S2SV_StartBug> cw_log ( "Sending<S2SV_blank>back<S2SV_blank>%lu\\n" , m -> req_id ) ; <S2SV_EndBug> safe_send ( sock , buf , sizeof ( message_t ) ) ; buf += m -> req_size ; msg_size = bufs [ buf_id ] . curr_buf - buf ; if ( msg_size > 0 ) cw_log ( "Repeating<S2SV_blank>loop<S2SV_blank>with<S2SV_blank>msg_size=%lu\\n" , msg_size ) ; } while ( msg_size > 0 ) ; if ( buf == bufs [ buf_id ] . curr_buf ) { bufs [ buf_id ] . curr_buf = bufs [ buf_id ] . buf ; bufs [ buf_id ] . curr_size = bufs [ buf_id ] . buf_size ; } else { memmove ( bufs [ buf_id ] . buf , buf , bufs [ buf_id ] . curr_buf - buf ) ; bufs [ buf_id ] . curr_buf = bufs [ buf_id ] . buf ; bufs [ buf_id ] . curr_size = bufs [ buf_id ] . buf_size - ( bufs [ buf_id ] . curr_buf - bufs [ buf_id ] . buf ) ; } }
|
<S2SV_ModStart> } cw_log ( "Sending<S2SV_blank>back<S2SV_blank>%u\\n" <S2SV_ModEnd> , m ->
|
7,128 |
CWE-000 void FORM ( free_all_wiz_map_ , wiz_string_and_user_type ) ( FORM ( wiz_map_ , wiz_string_and_user_type ) * _map ) { <S2SV_StartBug> remove_all_wiz_string_and_user_type ( _map -> root , 1 ) ; <S2SV_EndBug> _map -> count = 0 ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> _map ) { if ( _map -> root != NULL ) { <S2SV_ModStart> = 0 ; _map -> root = NULL ; }
|
7,129 |
CWE-000 int findProductId ( GString * certContent , GString * result ) { int ret_val = 1 ; BIO * bio = BIO_new_mem_buf ( certContent -> str , ( int ) certContent -> len ) ; if ( bio == NULL ) { debug ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>buffer<S2SV_blank>for<S2SV_blank>content<S2SV_blank>of<S2SV_blank>certificate:<S2SV_blank>%s" , ERR_error_string ( ERR_get_error ( ) , NULL ) ) ; return - 1 ; } X509 * x509 = PEM_read_bio_X509 ( bio , NULL , NULL , NULL ) ; <S2SV_StartBug> if ( x509 == NULL ) { <S2SV_EndBug> debug ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>content<S2SV_blank>of<S2SV_blank>certificate<S2SV_blank>from<S2SV_blank>buffer<S2SV_blank>to<S2SV_blank>X509<S2SV_blank>structure:<S2SV_blank>%s" , ERR_error_string ( ERR_get_error ( ) , NULL ) ) ; return - 1 ; } <S2SV_StartBug> BIO_free ( bio ) ; <S2SV_EndBug> bio = NULL ; int exts = X509_get_ext_count ( x509 ) ; gboolean redhat_oid_found = FALSE ; for ( int i = 0 ; i < exts ; i ++ ) { char oid [ MAX_BUFF ] ; X509_EXTENSION * ext = X509_get_ext ( x509 , i ) ; if ( ext == NULL ) { debug ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>extension<S2SV_blank>of<S2SV_blank>X509<S2SV_blank>structure:<S2SV_blank>%s" , ERR_error_string ( ERR_get_error ( ) , NULL ) ) ; ret_val = - 1 ; break ; } OBJ_obj2txt ( oid , MAX_BUFF , X509_EXTENSION_get_object ( ext ) , 1 ) ; if ( strncmp ( REDHAT_PRODUCT_OID , oid , strlen ( REDHAT_PRODUCT_OID ) ) == 0 ) { redhat_oid_found = TRUE ; gchar * * components = g_strsplit ( oid , "." , - 1 ) ; int comp_id = 0 ; while ( components [ comp_id ] != NULL ) { comp_id ++ ; } debug ( "Number<S2SV_blank>of<S2SV_blank>OID<S2SV_blank>components:<S2SV_blank>%d" , comp_id ) ; if ( comp_id > 9 ) { debug ( "ID<S2SV_blank>of<S2SV_blank>product<S2SV_blank>certificate:<S2SV_blank>%s" , components [ 9 ] ) ; g_string_assign ( result , components [ 9 ] ) ; } else { error ( "Product<S2SV_blank>certificate<S2SV_blank>does<S2SV_blank>not<S2SV_blank>contain<S2SV_blank>required<S2SV_blank>ID" ) ; ret_val = - 1 ; } g_strfreev ( components ) ; break ; } } if ( redhat_oid_found == FALSE ) { warn ( "RedHat<S2SV_blank>Product<S2SV_blank>OID:<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found" , REDHAT_PRODUCT_OID ) ; ret_val = - 1 ; } X509_free ( x509 ) ; return ret_val ; }
|
<S2SV_ModStart> NULL ) ; BIO_free ( bio ) ; bio = NULL ; <S2SV_ModStart> 1 ; } <S2SV_ModEnd> int exts =
|
7,130 |
CWE-000 static void MenuIndicatorElementSize ( void * clientData , void * elementRecord , Tk_Window tkwin , int * widthPtr , int * heightPtr , Ttk_Padding * paddingPtr ) { <S2SV_StartBug> MenuIndicatorElement * mi = elementRecord ; <S2SV_EndBug> Tk_GetPixelsFromObj ( NULL , tkwin , mi -> widthObj , widthPtr ) ; Tk_GetPixelsFromObj ( NULL , tkwin , mi -> heightObj , heightPtr ) ; <S2SV_StartBug> Ttk_GetPaddingFromObj ( NULL , tkwin , mi -> marginObj , paddingPtr ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> mi = elementRecord ; Ttk_Padding margins <S2SV_ModStart> -> marginObj , & margins ) ; * widthPtr += Ttk_PaddingWidth ( margins ) ; * heightPtr += Ttk_PaddingHeight ( margins <S2SV_ModEnd> ) ; }
|
7,131 |
CWE-000 static void x86_cpu_register_feature_bit_props ( X86CPU * cpu , FeatureWord w , int bitnr ) { FeatureWordInfo * fi = & feature_word_info [ w ] ; const char * name = fi -> feat_names [ bitnr ] ; if ( ! name ) { return ; } assert ( ! strchr ( name , '_' ) ) ; assert ( ! strchr ( name , '|' ) ) ; <S2SV_StartBug> x86_cpu_register_bit_prop ( cpu , name , & cpu -> env . features [ w ] , bitnr ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> , name , w <S2SV_ModEnd> , bitnr )
|
7,132 |
CWE-000 GLogWriterOutput g_log_writer_journald ( GLogLevelFlags log_level , const GLogField * fields , gsize n_fields , gpointer user_data ) <S2SV_StartBug> { <S2SV_EndBug> const char equals = '=' ; const char newline = '\\n' ; gsize i , k ; struct iovec * iov , * v ; char * buf ; gint retval ; g_return_val_if_fail ( fields != NULL , G_LOG_WRITER_UNHANDLED ) ; g_return_val_if_fail ( n_fields > 0 , G_LOG_WRITER_UNHANDLED ) ; iov = g_alloca ( sizeof ( struct iovec ) * 5 * n_fields ) ; buf = g_alloca ( 32 * n_fields ) ; k = 0 ; v = iov ; for ( i = 0 ; i < n_fields ; i ++ ) { guint64 length ; gboolean binary ; if ( fields [ i ] . length < 0 ) { length = strlen ( fields [ i ] . value ) ; binary = strchr ( fields [ i ] . value , '\\n' ) != NULL ; } else { length = fields [ i ] . length ; binary = TRUE ; } if ( binary ) { guint64 nstr ; v [ 0 ] . iov_base = ( gpointer ) fields [ i ] . key ; v [ 0 ] . iov_len = strlen ( fields [ i ] . key ) ; v [ 1 ] . iov_base = ( gpointer ) & newline ; v [ 1 ] . iov_len = 1 ; nstr = GUINT64_TO_LE ( length ) ; memcpy ( & buf [ k ] , & nstr , sizeof ( nstr ) ) ; v [ 2 ] . iov_base = & buf [ k ] ; v [ 2 ] . iov_len = sizeof ( nstr ) ; v += 3 ; k += sizeof ( nstr ) ; } else { v [ 0 ] . iov_base = ( gpointer ) fields [ i ] . key ; v [ 0 ] . iov_len = strlen ( fields [ i ] . key ) ; v [ 1 ] . iov_base = ( gpointer ) & equals ; v [ 1 ] . iov_len = 1 ; v += 2 ; } v [ 0 ] . iov_base = ( gpointer ) fields [ i ] . value ; v [ 0 ] . iov_len = length ; v [ 1 ] . iov_base = ( gpointer ) & newline ; v [ 1 ] . iov_len = 1 ; v += 2 ; } retval = journal_sendv ( iov , v - iov ) ; return retval == 0 ? G_LOG_WRITER_HANDLED : G_LOG_WRITER_UNHANDLED ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> user_data ) { # ifdef __linux__ <S2SV_ModStart> : G_LOG_WRITER_UNHANDLED ; # else return G_LOG_WRITER_UNHANDLED ; # endif
|
7,133 |
CWE-000 void test_verify16_dpo ( void ) { int ret , dpofua , usage_data_dpo ; struct scsi_task * ms_task = NULL ; struct scsi_mode_sense * ms ; struct scsi_task * rso_task = NULL ; struct scsi_report_supported_op_codes_one_command * rsoc ; unsigned char * buf = alloca ( block_size ) ; logging ( LOG_VERBOSE , LOG_BLANK_LINE ) ; logging ( LOG_VERBOSE , "Test<S2SV_blank>VERIFY16<S2SV_blank>DPO<S2SV_blank>flag" ) ; CHECK_FOR_SBC ; ret = read10 ( sd , NULL , 0 , block_size , block_size , 0 , 0 , 0 , 0 , 0 , buf , EXPECT_STATUS_GOOD ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; logging ( LOG_VERBOSE , "Read<S2SV_blank>the<S2SV_blank>DPOFUA<S2SV_blank>flag<S2SV_blank>from<S2SV_blank>mode<S2SV_blank>sense<S2SV_blank>data" ) ; ret = modesense6 ( sd , & ms_task , 0 , SCSI_MODESENSE_PC_CURRENT , SCSI_MODEPAGE_RETURN_ALL_PAGES , 0 , 255 , EXPECT_STATUS_GOOD ) ; CU_ASSERT_EQUAL ( ret , 0 ) ; logging ( LOG_VERBOSE , "[SUCCESS]<S2SV_blank>Mode<S2SV_blank>sense<S2SV_blank>returned<S2SV_blank>status<S2SV_blank>GOOD" ) ; ms = scsi_datain_unmarshall ( ms_task ) ; dpofua = ms && ( ms -> device_specific_parameter & 0x10 ) ; scsi_free_scsi_task ( ms_task ) ; if ( dpofua ) { logging ( LOG_VERBOSE , "DPOFUA<S2SV_blank>flag<S2SV_blank>is<S2SV_blank>set.<S2SV_blank>Device<S2SV_blank>should<S2SV_blank>allow<S2SV_blank>" "DPO/FUA<S2SV_blank>flags<S2SV_blank>in<S2SV_blank>CDBs" ) ; } else { logging ( LOG_VERBOSE , "DPOFUA<S2SV_blank>flag<S2SV_blank>is<S2SV_blank>clear.<S2SV_blank>Device<S2SV_blank>should<S2SV_blank>fail<S2SV_blank>" "CDBs<S2SV_blank>with<S2SV_blank>DPO/FUA<S2SV_blank>set" ) ; } logging ( LOG_VERBOSE , "Test<S2SV_blank>VERIFY16<S2SV_blank>with<S2SV_blank>DPO==1" ) ; if ( dpofua ) { ret = verify16 ( sd , 0 , block_size , block_size , 0 , 1 , 0 , buf , EXPECT_STATUS_GOOD ) ; if ( ret == - 2 ) { logging ( LOG_NORMAL , "[SKIPPED]<S2SV_blank>VERIFY16<S2SV_blank>is<S2SV_blank>not<S2SV_blank>implemented." ) ; CU_PASS ( "VERIFY16<S2SV_blank>is<S2SV_blank>not<S2SV_blank>implemented." ) ; return ; } CU_ASSERT_EQUAL ( ret , 0 ) ; } else { ret = verify16 ( sd , 0 , block_size , block_size , 0 , 1 , 0 , buf , EXPECT_INVALID_FIELD_IN_CDB ) ; if ( ret == - 2 ) { logging ( LOG_NORMAL , "[SKIPPED]<S2SV_blank>VERIFY16<S2SV_blank>is<S2SV_blank>not<S2SV_blank>implemented." ) ; CU_PASS ( "VERIFY16<S2SV_blank>is<S2SV_blank>not<S2SV_blank>implemented." ) ; return ; } CU_ASSERT_EQUAL ( ret , 0 ) ; } logging ( LOG_VERBOSE , "Try<S2SV_blank>fetching<S2SV_blank>REPORT_SUPPORTED_OPCODES<S2SV_blank>" "for<S2SV_blank>VERIFY16" ) ; ret = report_supported_opcodes ( sd , & rso_task , 0 , SCSI_REPORT_SUPPORTING_OPCODE , SCSI_OPCODE_VERIFY16 , 0 , 65535 , EXPECT_STATUS_GOOD ) ; if ( ret == - 2 ) { logging ( LOG_NORMAL , "REPORT_SUPPORTED_OPCODES<S2SV_blank>not<S2SV_blank>implemented.<S2SV_blank>" "Skipping<S2SV_blank>this<S2SV_blank>part<S2SV_blank>of<S2SV_blank>the<S2SV_blank>test" ) ; <S2SV_StartBug> return ; <S2SV_EndBug> } logging ( LOG_VERBOSE , "Unmarshall<S2SV_blank>the<S2SV_blank>DATA-IN<S2SV_blank>buffer" ) ; rsoc = scsi_datain_unmarshall ( rso_task ) ; CU_ASSERT_NOT_EQUAL ( rsoc , NULL ) ; usage_data_dpo = rsoc ? rsoc -> cdb_usage_data [ 1 ] & 0x10 : - 1 ; if ( dpofua ) { logging ( LOG_VERBOSE , "DPOFUA<S2SV_blank>is<S2SV_blank>set.<S2SV_blank>Verify<S2SV_blank>the<S2SV_blank>DPO<S2SV_blank>flag<S2SV_blank>" "is<S2SV_blank>set<S2SV_blank>in<S2SV_blank>the<S2SV_blank>CDB_USAGE_DATA" ) ; CU_ASSERT_EQUAL ( usage_data_dpo , 0x10 ) ; } else { logging ( LOG_VERBOSE , "DPOFUA<S2SV_blank>is<S2SV_blank>clear.<S2SV_blank>Verify<S2SV_blank>the<S2SV_blank>DPO<S2SV_blank>" "flag<S2SV_blank>is<S2SV_blank>clear<S2SV_blank>in<S2SV_blank>the<S2SV_blank>CDB_USAGE_DATA" ) ; CU_ASSERT_EQUAL ( usage_data_dpo , 0x00 ) ; } <S2SV_StartBug> scsi_free_scsi_task ( rso_task ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> "Skipping<S2SV_blank>this<S2SV_blank>part<S2SV_blank>of<S2SV_blank>the<S2SV_blank>test" ) ; goto out <S2SV_ModEnd> ; } logging <S2SV_ModStart> ) ; } out :
|
7,134 |
CWE-000 static void mdm_signal_handler_init ( MdmSignalHandler * handler ) { GIOChannel * ioc ; <S2SV_StartBug> handler -> priv = MDM_SIGNAL_HANDLER_GET_PRIVATE ( handler ) ; <S2SV_EndBug> handler -> priv -> next_id = 1 ; <S2SV_StartBug> handler -> priv -> lookup = g_hash_table_new ( NULL , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> handler -> priv -> id_lookup = g_hash_table_new ( NULL , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> handler -> priv -> action_lookup = g_hash_table_new ( NULL , NULL ) ; <S2SV_EndBug> if ( pipe ( signal_pipes ) == - 1 ) { g_error ( "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>pipe()<S2SV_blank>for<S2SV_blank>signal<S2SV_blank>handling" ) ; } ioc = g_io_channel_unix_new ( signal_pipes [ 0 ] ) ; g_io_channel_set_flags ( ioc , G_IO_FLAG_NONBLOCK , NULL ) ; g_io_add_watch_full ( ioc , G_PRIORITY_HIGH , G_IO_IN , ( GIOFunc ) signal_io_watch , handler , NULL ) ; g_io_channel_set_close_on_unref ( ioc , TRUE ) ; g_io_channel_unref ( ioc ) ; }
|
<S2SV_ModStart> ; handler -> <S2SV_ModEnd> next_id = 1 <S2SV_ModStart> 1 ; handler <S2SV_ModEnd> -> lookup = <S2SV_ModStart> ; handler -> <S2SV_ModEnd> id_lookup = g_hash_table_new <S2SV_ModStart> ) ; handler <S2SV_ModEnd> -> action_lookup =
|
7,135 |
CWE-000 int format_arrow_key ( char * buf , Terminal * term , int xkey , bool ctrl ) { char * p = buf ; if ( term -> vt52_mode ) <S2SV_StartBug> p += sprintf ( ( char * ) p , "\\x1B%c" , xkey ) ; <S2SV_EndBug> else { bool app_flg = ( term -> app_cursor_keys && ! term -> no_applic_c ) ; # if 0 if ( ! term -> app_keypad_keys ) app_flg = 0 ; # endif if ( ctrl ) app_flg = ! app_flg ; if ( app_flg ) <S2SV_StartBug> p += sprintf ( ( char * ) p , "\\x1BO%c" , xkey ) ; <S2SV_EndBug> else <S2SV_StartBug> p += sprintf ( ( char * ) p , "\\x1B[%c" , xkey ) ; <S2SV_EndBug> } return p - buf ; }
|
<S2SV_ModStart> += sprintf ( <S2SV_ModEnd> p , "\\x1B%c" <S2SV_ModStart> += sprintf ( <S2SV_ModEnd> p , "\\x1BO%c" <S2SV_ModStart> += sprintf ( <S2SV_ModEnd> p , "\\x1B[%c"
|
7,136 |
CWE-000 <S2SV_StartBug> static const char * nic_broadcast_mode_str ( nic_unicast_mode_t mode ) <S2SV_EndBug> { switch ( mode ) { case NIC_BROADCAST_UNKNOWN : return "unknown" ; case NIC_BROADCAST_BLOCKED : return "blocked" ; case NIC_BROADCAST_ACCEPTED : return "accepted" ; default : assert ( false ) ; return NULL ; } }
|
<S2SV_ModStart> * nic_broadcast_mode_str ( nic_broadcast_mode_t <S2SV_ModEnd> mode ) {
|
7,137 |
CWE-000 int irc_shutdown_client ( struct_irc_info * irc_info , struct_cli_info * cli_info ) { struct_cli_info * * ret ; <S2SV_StartBug> irc_info -> full_fd_list = irc_remove_fd_list ( irc_info , cli_info -> sockfd ) ; <S2SV_EndBug> irc_info -> cli_list = serv_remove_client ( cli_info -> name , irc_info -> cli_list , irc_info -> num_clients , cli_info -> sockfd ) ; <S2SV_StartBug> -- ( irc_info -> num_clients ) ; <S2SV_EndBug> serv_free_client ( irc_info -> rooms , cli_info ) ; <S2SV_StartBug> shutdown ( cli_info -> sockfd , SHUT_RDWR ) ; <S2SV_EndBug> return SUCCESS ; }
|
<S2SV_ModStart> * ret ; shutdown ( cli_info -> sockfd , SHUT_RDWR ) ; <S2SV_ModStart> -> sockfd ) ; errno = 0 <S2SV_ModStart> sockfd ) ; if ( errno == EINVAL ) { errno = 0 ; return FAILURE ; } <S2SV_ModStart> cli_info ) ; <S2SV_ModEnd> return SUCCESS ;
|
7,138 |
CWE-000 static int ans_init_ports ( unsigned short nb_ports , struct ans_user_config * user_conf , struct ans_lcore_queue * lcore_conf ) { int ret ; uint8_t portid ; uint16_t queueid ; unsigned lcore_id ; uint8_t nb_rx_queue = 0 ; uint8_t max_rx_queue = 0 ; uint8_t queue , socketid ; uint32_t n_tx_queue , nb_lcores , nb_mbuf ; struct ether_addr eth_addr ; struct rte_eth_dev_info dev_info ; struct rte_eth_txconf * txconf ; struct rte_eth_rxconf * rxconf ; nb_lcores = rte_lcore_count ( ) ; n_tx_queue = nb_lcores ; if ( n_tx_queue > MAX_TX_QUEUE_PER_PORT ) n_tx_queue = MAX_TX_QUEUE_PER_PORT ; printf ( "\\nStart<S2SV_blank>to<S2SV_blank>Init<S2SV_blank>port<S2SV_blank>\\n" ) ; for ( portid = 0 ; portid < nb_ports ; portid ++ ) { if ( ( user_conf -> port_mask & ( 1 << portid ) ) == 0 ) { printf ( "\\nSkipping<S2SV_blank>disabled<S2SV_blank>port<S2SV_blank>%d\\n" , portid ) ; continue ; } printf ( "\\t<S2SV_blank>port<S2SV_blank>%d:<S2SV_blank><S2SV_blank>\\n" , portid ) ; rte_eth_dev_info_get ( portid , & dev_info ) ; printf ( "\\t<S2SV_blank>port<S2SV_blank>name<S2SV_blank>%s:<S2SV_blank><S2SV_blank>\\n" , dev_info . driver_name ) ; printf ( "\\t<S2SV_blank>max_rx_queues<S2SV_blank>%d:<S2SV_blank>max_tx_queues:%d<S2SV_blank>\\n" , dev_info . max_rx_queues , dev_info . max_tx_queues ) ; printf ( "\\t<S2SV_blank>rx_offload_capa<S2SV_blank>0x%x:<S2SV_blank>tx_offload_capa:0x%x<S2SV_blank>\\n" , dev_info . rx_offload_capa , dev_info . tx_offload_capa ) ; nb_rx_queue = ans_get_port_rx_queues_nb ( portid , user_conf ) ; if ( max_rx_queue < nb_rx_queue ) max_rx_queue = nb_rx_queue ; printf ( "\\t<S2SV_blank>Creating<S2SV_blank>queues:<S2SV_blank>rx<S2SV_blank>queue<S2SV_blank>number=%d<S2SV_blank>tx<S2SV_blank>queue<S2SV_blank>number=%u...<S2SV_blank>\\n" , nb_rx_queue , ( unsigned ) n_tx_queue ) ; ret = rte_eth_dev_configure ( portid , nb_rx_queue , ( uint16_t ) n_tx_queue , & ans_port_conf ) ; if ( ret < 0 ) rte_exit ( EXIT_FAILURE , "Cannot<S2SV_blank>configure<S2SV_blank>device:<S2SV_blank>err=%d,<S2SV_blank>port=%d\\n" , ret , portid ) ; rte_eth_macaddr_get ( portid , & eth_addr ) ; printf ( "\\t<S2SV_blank>MAC<S2SV_blank>Address:%02X:%02X:%02X:%02X:%02X:%02X<S2SV_blank>\\n" , eth_addr . addr_bytes [ 0 ] , eth_addr . addr_bytes [ 1 ] , eth_addr . addr_bytes [ 2 ] , eth_addr . addr_bytes [ 3 ] , eth_addr . addr_bytes [ 4 ] , eth_addr . addr_bytes [ 5 ] ) ; queueid = 0 ; for ( lcore_id = 0 ; lcore_id < RTE_MAX_LCORE ; lcore_id ++ ) { if ( rte_lcore_is_enabled ( lcore_id ) == 0 ) continue ; if ( user_conf -> numa_on ) socketid = ( uint8_t ) rte_lcore_to_socket_id ( lcore_id ) ; else socketid = 0 ; rte_eth_dev_info_get ( portid , & dev_info ) ; txconf = & dev_info . default_txconf ; if ( ans_port_conf . rxmode . jumbo_frame ) txconf -> txq_flags = 0 ; printf ( "\\t<S2SV_blank>Deault--<S2SV_blank>tx<S2SV_blank>pthresh:%d,<S2SV_blank>tx<S2SV_blank>hthresh:%d,<S2SV_blank>tx<S2SV_blank>wthresh:%d,<S2SV_blank>txq_flags:0x%x<S2SV_blank>\\n" , txconf -> tx_thresh . pthresh , txconf -> tx_thresh . hthresh , txconf -> tx_thresh . wthresh , txconf -> txq_flags ) ; <S2SV_StartBug> txconf -> txq_flags = ans_tx_conf . txq_flags ; <S2SV_EndBug> printf ( "\\t<S2SV_blank>lcore<S2SV_blank>id:%u,<S2SV_blank>tx<S2SV_blank>queue<S2SV_blank>id:%d,<S2SV_blank>socket<S2SV_blank>id:%d<S2SV_blank>\\n" , lcore_id , queueid , socketid ) ; printf ( "\\t<S2SV_blank>Conf--<S2SV_blank>tx<S2SV_blank>pthresh:%d,<S2SV_blank>tx<S2SV_blank>hthresh:%d,<S2SV_blank>tx<S2SV_blank>wthresh:%d,<S2SV_blank>txq_flags:0x%x<S2SV_blank>\\n" , txconf -> tx_thresh . pthresh , txconf -> tx_thresh . hthresh , txconf -> tx_thresh . wthresh , txconf -> txq_flags ) ; ret = rte_eth_tx_queue_setup ( portid , queueid , ANS_TX_DESC_DEFAULT , socketid , txconf ) ; if ( ret < 0 ) rte_exit ( EXIT_FAILURE , "rte_eth_tx_queue_setup:<S2SV_blank>err=%d,<S2SV_blank>" "port=%d\\n" , ret , portid ) ; lcore_conf [ lcore_id ] . tx_queue_id [ portid ] = queueid ; queueid ++ ; } printf ( "\\n" ) ; } nb_mbuf = RTE_MAX ( ( nb_ports * nb_rx_queue * ANS_RX_DESC_DEFAULT + nb_ports * nb_lcores * MAX_PKT_BURST + nb_ports * n_tx_queue * ANS_TX_DESC_DEFAULT + nb_lcores * MEMPOOL_CACHE_SIZE ) , MAX_MBUF_NB ) ; ret = ans_init_mbuf_pool ( nb_mbuf , user_conf ) ; if ( ret < 0 ) rte_exit ( EXIT_FAILURE , "init_mem<S2SV_blank>failed\\n" ) ; for ( lcore_id = 0 ; lcore_id < RTE_MAX_LCORE ; lcore_id ++ ) { if ( rte_lcore_is_enabled ( lcore_id ) == 0 ) continue ; printf ( "\\nInitializing<S2SV_blank>rx<S2SV_blank>queues<S2SV_blank>on<S2SV_blank>lcore<S2SV_blank>%u<S2SV_blank>...<S2SV_blank>\\n" , lcore_id ) ; for ( queue = 0 ; queue < lcore_conf [ lcore_id ] . n_rx_queue ; ++ queue ) { portid = lcore_conf [ lcore_id ] . rx_queue_list [ queue ] . port_id ; queueid = lcore_conf [ lcore_id ] . rx_queue_list [ queue ] . queue_id ; if ( user_conf -> numa_on ) socketid = ( uint8_t ) rte_lcore_to_socket_id ( lcore_id ) ; else socketid = 0 ; rte_eth_dev_info_get ( portid , & dev_info ) ; rxconf = & dev_info . default_rxconf ; printf ( "Default--<S2SV_blank>rx<S2SV_blank>pthresh:%d,<S2SV_blank>rx<S2SV_blank>hthresh:%d,<S2SV_blank>rx<S2SV_blank>wthresh:%d<S2SV_blank>\\n" , rxconf -> rx_thresh . pthresh , rxconf -> rx_thresh . hthresh , rxconf -> rx_thresh . wthresh ) ; printf ( "port<S2SV_blank>id:%d,<S2SV_blank>rx<S2SV_blank>queue<S2SV_blank>id:<S2SV_blank>%d,<S2SV_blank>socket<S2SV_blank>id:%d<S2SV_blank>\\n" , portid , queueid , socketid ) ; printf ( "Conf--<S2SV_blank>rx<S2SV_blank>pthresh:%d,<S2SV_blank>rx<S2SV_blank>hthresh:%d,<S2SV_blank>rx<S2SV_blank>wthresh:%d<S2SV_blank>\\n" , ans_rx_conf . rx_thresh . pthresh , ans_rx_conf . rx_thresh . hthresh , ans_rx_conf . rx_thresh . wthresh ) ; ret = rte_eth_rx_queue_setup ( portid , queueid , ANS_RX_DESC_DEFAULT , socketid , NULL , ans_pktmbuf_pool [ socketid ] ) ; if ( ret < 0 ) rte_exit ( EXIT_FAILURE , "rte_eth_rx_queue_setup:<S2SV_blank>err=%d," "port=%d\\n" , ret , portid ) ; } } return 0 ; }
|
<S2SV_ModStart> -> txq_flags = 0 <S2SV_ModEnd> ; printf (
|
7,139 |
CWE-000 static int psp_hw_fini ( void * handle ) { struct amdgpu_device * adev = ( struct amdgpu_device * ) handle ; struct psp_context * psp = & adev -> psp ; if ( adev -> firmware . load_type != AMDGPU_FW_LOAD_PSP ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> psp_ring_destroy ( psp , PSP_RING_TYPE__KM ) ; amdgpu_bo_free_kernel ( & psp -> tmr_bo , & psp -> tmr_mc_addr , & psp -> tmr_buf ) ; amdgpu_bo_free_kernel ( & psp -> fw_pri_bo , & psp -> fw_pri_mc_addr , & psp -> fw_pri_buf ) ; amdgpu_bo_free_kernel ( & psp -> fence_buf_bo , & psp -> fence_buf_mc_addr , & psp -> fence_buf ) ; amdgpu_bo_free_kernel ( & psp -> asd_shared_bo , & psp -> asd_shared_mc_addr , & psp -> asd_shared_buf ) ; amdgpu_bo_free_kernel ( & psp -> cmd_buf_bo , & psp -> cmd_buf_mc_addr , ( void * * ) & psp -> cmd_buf_mem ) ; kfree ( psp -> cmd ) ; psp -> cmd = NULL ; return 0 ; }
|
<S2SV_ModStart> ) return 0 ; amdgpu_ucode_fini_bo ( adev )
|
7,140 |
CWE-000 void CthAwaken ( CthThread th ) { if ( B ( th ) -> awakenfn == 0 ) CthNoStrategy ( ) ; # if CMK_TRACE_ENABLED # if ! CMK_TRACE_IN_CHARM if ( CpvAccess ( traceOn ) ) traceAwaken ( th ) ; # endif # endif <S2SV_StartBug> # if CMK_OMP <S2SV_EndBug> if ( B ( th ) -> scheduled > 0 ) { CmiAbort ( "this<S2SV_blank>thread<S2SV_blank>is<S2SV_blank>already<S2SV_blank>scheduled\\n" ) ; } # endif # if CMK_OMP CmiMemoryAtomicIncrement ( B ( th ) -> scheduled , memory_order_release ) ; # else B ( th ) -> scheduled ++ ; <S2SV_StartBug> # endif <S2SV_EndBug> B ( th ) -> awakenfn ( B ( th ) -> token , CQS_QUEUEING_FIFO , 0 , 0 ) ; }
|
<S2SV_ModStart> endif # endif <S2SV_ModEnd> B ( th <S2SV_ModStart> scheduled ++ ; <S2SV_ModEnd> B ( th
|
7,141 |
CWE-000 CU_Test ( ddsc_qos , copy_with_partition , . init = qos_init , . fini = qos_fini ) { dds_return_t result ; dds_qos_t * qos ; struct pol_partition p = { 0 , NULL } ; qos = dds_create_qos ( ) ; CU_ASSERT_PTR_NOT_NULL_FATAL ( qos ) ; dds_qset_partition ( g_qos , g_pol_partition . n , ( const char * * ) g_pol_partition . ps ) ; result = dds_copy_qos ( qos , g_qos ) ; CU_ASSERT_EQUAL_FATAL ( result , DDS_RETCODE_OK ) ; dds_qget_partition ( qos , & p . n , & p . ps ) ; CU_ASSERT_EQUAL_FATAL ( p . n , g_pol_partition . n ) ; for ( uint32_t cnt = 0 ; cnt < p . n ; cnt ++ ) { CU_ASSERT_STRING_EQUAL_FATAL ( p . ps [ cnt ] , g_pol_partition . ps [ cnt ] ) ; } <S2SV_StartBug> dds_delete_qos ( qos ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ) ; } for ( uint32_t cnt = 0 ; cnt < p . n ; cnt ++ ) { dds_free ( p . ps [ cnt ] ) ; } dds_free ( p . ps ) ;
|
7,142 |
CWE-000 gpointer mono_create_jump_trampoline ( MonoDomain * domain , MonoMethod * method , gboolean add_sync_wrapper , MonoError * error ) { MonoJitInfo * ji ; gpointer code ; guint32 code_size = 0 ; error_init ( error ) ; if ( mono_use_interpreter ) { <S2SV_StartBug> gpointer ret = mini_get_interp_callbacks ( ) -> create_method_pointer ( method , error ) ; <S2SV_EndBug> if ( ! mono_error_ok ( error ) ) return NULL ; return ret ; } code = mono_jit_find_compiled_method_with_jit_info ( domain , method , & ji ) ; if ( code && ! ji -> has_generic_jit_info && ! ( method -> iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED ) ) return code ; if ( mono_llvm_only ) { code = mono_jit_compile_method ( method , error ) ; if ( ! mono_error_ok ( error ) ) return NULL ; return code ; } mono_domain_lock ( domain ) ; code = g_hash_table_lookup ( domain_jit_info ( domain ) -> jump_trampoline_hash , method ) ; mono_domain_unlock ( domain ) ; if ( code ) return code ; code = mono_create_specific_trampoline ( method , MONO_TRAMPOLINE_JUMP , mono_domain_get ( ) , & code_size ) ; g_assert ( code_size ) ; ji = ( MonoJitInfo * ) mono_domain_alloc0 ( domain , MONO_SIZEOF_JIT_INFO ) ; ji -> code_start = code ; ji -> code_size = code_size ; ji -> d . method = method ; mono_jit_info_table_add ( domain , ji ) ; mono_domain_lock ( domain ) ; g_hash_table_insert ( domain_jit_info ( domain ) -> jump_trampoline_hash , method , ji -> code_start ) ; mono_domain_unlock ( domain ) ; return ji -> code_start ; }
|
<S2SV_ModStart> create_method_pointer ( method , FALSE
|
7,143 |
CWE-000 static void bcm63xx_spi_setup_transfer ( struct spi_device * spi , struct spi_transfer * t ) { struct bcm63xx_spi * bs = spi_master_get_devdata ( spi -> master ) ; u8 clk_cfg , reg ; <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < SPI_CLK_MASK ; i ++ ) { if ( t -> speed_hz >= bcm63xx_spi_freq_table [ i ] [ 0 ] ) { clk_cfg = bcm63xx_spi_freq_table [ i ] [ 1 ] ; break ; } } <S2SV_StartBug> if ( i == SPI_CLK_MASK ) <S2SV_EndBug> clk_cfg = SPI_CLK_0_391MHZ ; reg = bcm_spi_readb ( bs , SPI_CLK_CFG ) ; reg &= ~ SPI_CLK_MASK ; reg |= clk_cfg ; bcm_spi_writeb ( bs , reg , SPI_CLK_CFG ) ; dev_dbg ( & spi -> dev , "Setting<S2SV_blank>clock<S2SV_blank>register<S2SV_blank>to<S2SV_blank>%02x<S2SV_blank>(hz<S2SV_blank>%d)\\n" , clk_cfg , t -> speed_hz ) ; }
|
<S2SV_ModStart> ; int i ; clk_cfg = SPI_CLK_0_391MHZ <S2SV_ModStart> ; } } <S2SV_ModEnd> reg = bcm_spi_readb
|
7,144 |
CWE-000 VOS_STATUS WLAN_BAPReadLinkSupervisionTimeout ( ptBtampHandle btampHandle , tBtampTLVHCI_Read_Link_Supervision_Timeout_Cmd * pBapHCIReadLinkSupervisionTimeout , tpBtampHCI_Event pBapHCIEvent ) { ptBtampContext btampContext = ( ptBtampContext ) btampHandle ; v_U8_t phyLinkHandle ; VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_INFO_HIGH , <S2SV_StartBug> "%s:<S2SV_blank>btampHandle<S2SV_blank>value:<S2SV_blank>%p" , __func__ , btampHandle ) ; <S2SV_EndBug> if ( ( NULL == btampHandle ) || ( NULL == pBapHCIReadLinkSupervisionTimeout ) || ( NULL == pBapHCIEvent ) ) { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_INFO_HIGH , "Invalid<S2SV_blank>input<S2SV_blank>parameters<S2SV_blank>in<S2SV_blank>%s" , __func__ ) ; return VOS_STATUS_E_FAULT ; } phyLinkHandle = ( v_U8_t ) pBapHCIReadLinkSupervisionTimeout -> log_link_handle ; if ( phyLinkHandle != btampContext -> phy_link_handle ) { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_INFO_HIGH , "Invalid<S2SV_blank>Physical<S2SV_blank>link<S2SV_blank>handle<S2SV_blank>in<S2SV_blank>%s" , __func__ ) ; pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . link_supervision_timeout = 0x00 ; pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . log_link_handle = pBapHCIReadLinkSupervisionTimeout -> log_link_handle ; pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . status = WLANBAP_ERROR_INVALID_HCI_CMND_PARAM ; } else { pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . link_supervision_timeout = btampContext -> bapLinkSupervisionTimerInterval ; pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . log_link_handle = pBapHCIReadLinkSupervisionTimeout -> log_link_handle ; pBapHCIEvent -> u . btampCommandCompleteEvent . cc_event . Read_Link_Supervision_TO . status = WLANBAP_STATUS_SUCCESS ; } pBapHCIEvent -> bapHCIEventCode = BTAMP_TLV_HCI_COMMAND_COMPLETE_EVENT ; pBapHCIEvent -> u . btampCommandCompleteEvent . present = TRUE ; pBapHCIEvent -> u . btampCommandCompleteEvent . num_hci_command_packets = 1 ; pBapHCIEvent -> u . btampCommandCompleteEvent . command_opcode = BTAMP_TLV_HCI_READ_LINK_SUPERVISION_TIMEOUT_CMD ; return VOS_STATUS_SUCCESS ; }
|
<S2SV_ModStart> , VOS_TRACE_LEVEL_INFO_HIGH , "%s:<S2SV_blank>btampHandle<S2SV_blank>value:<S2SV_blank>%pK" <S2SV_ModEnd> , __func__ ,
|
7,145 |
CWE-000 int16_t str_intmax ( char * dst , intmax_t n , uint8_t base , const char * digits ) { int16_t i ; int16_t x ; if ( base > 36 ) return ( 0 ) ; i = len_intmax ( n , base ) ; x = 0 ; if ( n < 0 && base == 10 ) dst [ x ] = '-' ; x = ( n < 0 && base == 10 ) ? 1 + i : i ; dst [ x -- ] = 0 ; <S2SV_StartBug> while ( n ) <S2SV_EndBug> { dst [ x -- ] = digits [ ( n < 0 ) ? - ( n % base ) : ( n % base ) ] ; n /= base ; } return ( ( uint8_t ) ( i + 1 ) ) ; }
|
<S2SV_ModStart> = 0 ; if ( n == 0 ) { dst [ 0 ] = '0' ; return 2 ; }
|
7,146 |
CWE-000 static void cif_isp11_v4l2_vm_close ( struct vm_area_struct * vma ) <S2SV_StartBug> { <S2SV_EndBug> struct cif_isp11_metadata_s * metadata = ( struct cif_isp11_metadata_s * ) vma -> vm_private_data ; <S2SV_StartBug> metadata -> vmas -- ; <S2SV_EndBug> return ; }
|
<S2SV_ModStart> vma ) { unsigned long flags = 0 ; <S2SV_ModStart> -> vm_private_data ; spin_lock_irqsave ( & metadata -> spinlock , flags ) ; <S2SV_ModStart> -> vmas -- ; spin_unlock_irqrestore ( & metadata -> spinlock , flags )
|
7,147 |
CWE-000 static EGLBoolean terminateDisplay ( EGLDisplay dpy , EGLBoolean skipDestroy ) { WlEglDisplay * display = ( WlEglDisplay * ) dpy ; WlEglPlatformData * data = display -> data ; EGLBoolean fullTerminate = EGL_FALSE ; EGLBoolean res = EGL_TRUE ; <S2SV_StartBug> if ( display -> useRefCount ) { <S2SV_EndBug> display -> refCount -= 1 ; if ( display -> refCount > 0 ) { return EGL_TRUE ; } } <S2SV_StartBug> wlEglDestroyAllSurfaces ( display ) ; <S2SV_EndBug> if ( skipDestroy != EGL_TRUE || display -> ownNativeDpy ) { if ( display -> wlRegistry ) { wl_registry_destroy ( display -> wlRegistry ) ; } if ( display -> wlStreamDpy ) { wl_eglstream_display_destroy ( display -> wlStreamDpy ) ; } } if ( display -> ownNativeDpy ) { wl_display_disconnect ( display -> nativeDpy ) ; } if ( display -> devDpy != NULL ) { display -> devDpy -> refCount -- ; if ( display -> devDpy -> refCount == 0 ) { fullTerminate = EGL_TRUE ; dpy = display -> devDpy -> eglDisplay ; wl_list_remove ( & display -> devDpy -> link ) ; free ( display -> devDpy ) ; } <S2SV_StartBug> } <S2SV_EndBug> if ( display -> link . prev && display -> link . next ) { wl_list_remove ( & display -> link ) ; } free ( display ) ; if ( fullTerminate ) { wlExternalApiUnlock ( ) ; res = data -> egl . terminate ( dpy ) ; wlExternalApiLock ( ) ; } return res ; }
|
<S2SV_ModStart> ; if ( ! wlEglIsWlEglDisplay ( display ) ) { return EGL_TRUE ; } if ( <S2SV_ModStart> ; } } wl_list_remove ( & display -> link ) ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> } free (
|
7,148 |
CWE-000 static struct amdgpu_encoder * dm_dp_create_fake_mst_encoder ( struct amdgpu_dm_connector * connector ) { struct drm_device * dev = connector -> base . dev ; struct amdgpu_device * adev = dev -> dev_private ; struct amdgpu_encoder * amdgpu_encoder ; <S2SV_StartBug> struct drm_encoder * encoder ; <S2SV_EndBug> const struct drm_connector_helper_funcs * connector_funcs = connector -> base . helper_private ; struct drm_encoder * enc_master = connector_funcs -> best_encoder ( & connector -> base ) ; DRM_DEBUG_KMS ( "enc<S2SV_blank>master<S2SV_blank>is<S2SV_blank>%p\\n" , enc_master ) ; amdgpu_encoder = kzalloc ( sizeof ( * amdgpu_encoder ) , GFP_KERNEL ) ; if ( ! amdgpu_encoder ) return NULL ; encoder = & amdgpu_encoder -> base ; encoder -> possible_crtcs = amdgpu_dm_get_encoder_crtc_mask ( adev ) ; drm_encoder_init ( dev , & amdgpu_encoder -> base , & amdgpu_dm_encoder_funcs , DRM_MODE_ENCODER_DPMST , NULL ) ; drm_encoder_helper_add ( encoder , & amdgpu_dm_encoder_helper_funcs ) ; return amdgpu_encoder ; }
|
<S2SV_ModStart> drm_encoder * encoder <S2SV_ModEnd> ; amdgpu_encoder =
|
7,149 |
CWE-000 void convertTDPStoFlatBytes_int ( TightDataPointStorageI * tdps , unsigned char * * bytes , size_t * size ) { size_t i , k = 0 ; unsigned char dsLengthBytes [ 8 ] ; if ( exe_params -> SZ_SIZE_TYPE == 4 ) intToBytes_bigEndian ( dsLengthBytes , tdps -> dataSeriesLength ) ; else longToBytes_bigEndian ( dsLengthBytes , tdps -> dataSeriesLength ) ; unsigned char sameByte = tdps -> allSameData == 1 ? ( unsigned char ) 1 : ( unsigned char ) 0 ; sameByte = sameByte | ( confparams_cpr -> szMode << 1 ) ; if ( tdps -> isLossless ) sameByte = ( unsigned char ) ( sameByte | 0x10 ) ; int dataTypeSizeCode = convertDataTypeSize ( tdps -> dataTypeSize ) ; sameByte = ( unsigned char ) ( sameByte | dataTypeSizeCode ) ; if ( exe_params -> SZ_SIZE_TYPE == 8 ) sameByte = ( unsigned char ) ( sameByte | 0x40 ) ; if ( tdps -> allSameData == 1 ) { size_t totalByteLength = 3 + 1 + MetaDataByteLength + exe_params -> SZ_SIZE_TYPE + tdps -> exactDataBytes_size ; * bytes = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * totalByteLength ) ; for ( i = 0 ; i < 3 ; i ++ ) ( * bytes ) [ k ++ ] = versionNumber [ i ] ; ( * bytes ) [ k ++ ] = sameByte ; convertSZParamsToBytes ( confparams_cpr , & ( ( * bytes ) [ k ] ) ) ; k = k + MetaDataByteLength ; for ( i = 0 ; i < exe_params -> SZ_SIZE_TYPE ; i ++ ) ( * bytes ) [ k ++ ] = dsLengthBytes [ i ] ; for ( i = 0 ; i < tdps -> exactDataBytes_size ; i ++ ) ( * bytes ) [ k ++ ] = tdps -> exactDataBytes [ i ] ; * size = totalByteLength ; } else { if ( confparams_cpr -> errorBoundMode >= PW_REL ) { printf ( "Error:<S2SV_blank>errorBoundMode<S2SV_blank>>=<S2SV_blank>PW_REL!!<S2SV_blank>can\'t<S2SV_blank>be...\\n" ) ; exit ( 0 ) ; } size_t totalByteLength = 3 + 1 + MetaDataByteLength + 1 + exe_params -> SZ_SIZE_TYPE + 4 + 4 + 8 + 8 + exe_params -> SZ_SIZE_TYPE + exe_params -> SZ_SIZE_TYPE + exe_params -> SZ_SIZE_TYPE + tdps -> typeArray_size + tdps -> exactDataBytes_size ; * bytes = ( unsigned char * ) malloc ( sizeof ( unsigned char ) * totalByteLength ) ; <S2SV_StartBug> convertTDPStoBytes_int ( tdps , * bytes , dsLengthBytes , sameByte ) ; <S2SV_EndBug> * size = totalByteLength ; } }
|
<S2SV_ModStart> * bytes , <S2SV_ModEnd> sameByte ) ;
|
7,150 |
CWE-000 void expression ( symset fsys ) { void BSE ( fsys ) ; if ( sym == SYM_IDENTIFIER ) { int i , sym1 ; mask * mk ; if ( ! ( i = position ( id ) ) ) { error ( 11 ) ; } else if ( table [ i ] . kind != ID_VARIABLE ) { error ( 12 ) ; i = 0 ; } getsym ( ) ; sym1 = sym ; mk = ( mask * ) & table [ i ] ; <S2SV_StartBug> if ( i ) <S2SV_EndBug> { gen ( LOD , level - mk -> level , mk -> address ) ; } BSE ( fsys ) ; if ( i && sym1 == SYM_BECOMES ) { gen ( STO , level - mk -> level , mk -> address ) ; gen ( LOD , level - mk -> level , mk -> address ) ; } } else { numfunc ( fsys ) ; } }
|
<S2SV_ModStart> if ( i && sym1 != SYM_BECOMES
|
7,151 |
CWE-000 int qed_sp_eth_vport_start ( struct qed_hwfn * p_hwfn , struct qed_sp_vport_start_params * p_params ) { struct vport_start_ramrod_data * p_ramrod = NULL ; struct qed_spq_entry * p_ent = NULL ; struct qed_sp_init_data init_data ; u8 abs_vport_id = 0 ; int rc = - EINVAL ; u16 rx_mode = 0 ; rc = qed_fw_vport ( p_hwfn , p_params -> vport_id , & abs_vport_id ) ; if ( rc ) return rc ; memset ( & init_data , 0 , sizeof ( init_data ) ) ; init_data . cid = qed_spq_get_cid ( p_hwfn ) ; init_data . opaque_fid = p_params -> opaque_fid ; init_data . comp_mode = QED_SPQ_MODE_EBLOCK ; rc = qed_sp_init_request ( p_hwfn , & p_ent , ETH_RAMROD_VPORT_START , PROTOCOLID_ETH , & init_data ) ; if ( rc ) return rc ; p_ramrod = & p_ent -> ramrod . vport_start ; p_ramrod -> vport_id = abs_vport_id ; p_ramrod -> mtu = cpu_to_le16 ( p_params -> mtu ) ; <S2SV_StartBug> p_ramrod -> inner_vlan_removal_en = p_params -> remove_inner_vlan ; <S2SV_EndBug> p_ramrod -> drop_ttl0_en = p_params -> drop_ttl0 ; p_ramrod -> untagged = p_params -> only_untagged ; SET_FIELD ( rx_mode , ETH_VPORT_RX_MODE_UCAST_DROP_ALL , 1 ) ; SET_FIELD ( rx_mode , ETH_VPORT_RX_MODE_MCAST_DROP_ALL , 1 ) ; p_ramrod -> rx_mode . state = cpu_to_le16 ( rx_mode ) ; memset ( & p_ramrod -> tpa_param , 0 , sizeof ( struct eth_vport_tpa_param ) ) ; p_ramrod -> tpa_param . max_buff_num = p_params -> max_buffers_per_cqe ; switch ( p_params -> tpa_mode ) { case QED_TPA_MODE_GRO : p_ramrod -> tpa_param . tpa_max_aggs_num = ETH_TPA_MAX_AGGS_NUM ; p_ramrod -> tpa_param . tpa_max_size = ( u16 ) - 1 ; p_ramrod -> tpa_param . tpa_min_size_to_cont = p_params -> mtu / 2 ; p_ramrod -> tpa_param . tpa_min_size_to_start = p_params -> mtu / 2 ; p_ramrod -> tpa_param . tpa_ipv4_en_flg = 1 ; p_ramrod -> tpa_param . tpa_ipv6_en_flg = 1 ; p_ramrod -> tpa_param . tpa_pkt_split_flg = 1 ; p_ramrod -> tpa_param . tpa_gro_consistent_flg = 1 ; break ; default : break ; } p_ramrod -> tx_switching_en = p_params -> tx_switching ; p_ramrod -> ctl_frame_mac_check_en = ! ! p_params -> check_mac ; p_ramrod -> ctl_frame_ethtype_check_en = ! ! p_params -> check_ethtype ; p_ramrod -> sw_fid = qed_concrete_to_sw_fid ( p_hwfn -> cdev , p_params -> concrete_fid ) ; return qed_spq_post ( p_hwfn , p_ent , NULL ) ; }
|
<S2SV_ModStart> ; p_ramrod -> handle_ptp_pkts = p_params -> handle_ptp_pkts ; p_ramrod ->
|
7,152 |
CWE-000 DEFUN ( vrf_vni_mapping , vrf_vni_mapping_cmd , "vni<S2SV_blank>" CMD_VNI_RANGE , "VNI<S2SV_blank>corresponding<S2SV_blank>to<S2SV_blank>tenant<S2SV_blank>VRF\\n" "VNI-ID\\n" ) { int ret = 0 ; ZEBRA_DECLVAR_CONTEXT ( vrf , zvrf ) ; vni_t vni = strtoul ( argv [ 1 ] -> arg , NULL , 10 ) ; char err [ ERR_STR_SZ ] ; assert ( vrf ) ; assert ( zvrf ) ; <S2SV_StartBug> ret = zebra_vxlan_process_vrf_vni_cmd ( zvrf , vni , err , ERR_STR_SZ , 1 ) ; <S2SV_EndBug> if ( ret != 0 ) { vty_out ( vty , "%s\\n" , err ) ; return CMD_WARNING ; } return CMD_SUCCESS ; }
|
<S2SV_ModStart> zvrf ) ; vrf_set_user_cfged ( vrf ) ;
|
7,153 |
CWE-000 MRECURSION ( TC_INST_NUM , _TC_INTERRUPT_HANDLER , TC_INST_MAX_ID ) # endif void _tc_interrupt_handler ( uint8_t instance ) { volatile uint8_t * const COUNT_REGISTER = COUNT_REGISTER_ADD ; volatile uint32_t * const PORT_CLEAR_REGISTER = PORT_CLEAR_REGISTER_ADD ; volatile uint8_t * const STATUS_REGISTER = STATUS_REGISTER_ADD ; volatile uint8_t * const COMPARE_REGISTER = COMPARE_REGISTER_ADD ; volatile uint32_t * const PORT_SET = PORT_SET_REGISTER_ADD ; uint8_t interrupt_and_callback_status_mask ; uint8_t i = 0 ; static bool int_enable = false ; static bool led_disable_flag = false ; uint32_t B2_RGB = 0x08000000 ; uint32_t G2_RGB = 0x00000200 ; static uint8_t compare_value = 0 ; static uint8_t compare_value_last = 0 ; static uint8_t compare_value_current = 0 ; static bool first_time = true ; static volatile uint8_t compare_array [ NO_OF_LEDS ] ; static volatile uint8_t compare_array_ID ; static volatile uint8_t pin_array [ NO_OF_LEDS ] ; static volatile uint8_t pin_array_ID ; struct tc_module * module = ( struct tc_module * ) _tc_instances [ instance ] ; interrupt_and_callback_status_mask = module -> hw -> COUNT8 . INTFLAG . reg & module -> register_callback_mask & module -> enable_callback_mask ; if ( interrupt_and_callback_status_mask & TC_INTFLAG_MC ( 1 ) ) { if ( first_time == false ) { if ( compare_array_ID != N_valid_compares ) { * PORT_SET = ( 1UL << pin_array [ pin_array_ID ++ ] ) ; compare_array_ID = compare_array_ID + 1 ; } if ( compare_array_ID < N_valid_compares ) { compare_value_last = compare_array [ compare_array_ID - 1 ] ; compare_value_current = compare_array [ compare_array_ID ] ; while ( ( compare_value_last == compare_value_current ) && ( compare_array_ID <= N_valid_compares - 1 ) ) { * PORT_SET = ( 1UL << pin_array [ pin_array_ID ++ ] ) ; compare_value_last = compare_array [ compare_array_ID ] ; compare_value_current = compare_array [ ++ compare_array_ID ] ; } if ( compare_value_current != 255 ) { while ( ( * STATUS_REGISTER && MASK_SYNC ) == true ) ; * COMPARE_REGISTER = compare_value_current ; * COUNT_REGISTER = compare_value_last ; } else { while ( ( * STATUS_REGISTER && MASK_SYNC ) == true ) ; * COUNT_REGISTER = compare_value_last ; } } } else { first_time = false ; } module -> hw -> COUNT8 . INTFLAG . reg = TC_INTFLAG_MC ( 1 ) ; } if ( interrupt_and_callback_status_mask & TC_INTFLAG_OVF ) { serial_timeout_count ++ ; if ( serial_timeout_count > MAX_SERIAL_TIMEOUT ) { serial_timeout = true ; serial_timeout_count = 0 ; } * PORT_CLEAR_REGISTER = CLEAR_ORB_LEDS ; if ( update_compare_array == true ) { if ( int_enable == true ) { int_enable = false ; <S2SV_StartBug> if ( led_disable_flag == true ) <S2SV_EndBug> { tc_enable_callback ( module , TC_CALLBACK_CC_CHANNEL0 ) ; tc_clear_status ( module , 0x00000011 ) ; <S2SV_StartBug> led_disable_flag = false ; <S2SV_EndBug> } tc_enable_callback ( module , TC_CALLBACK_CC_CHANNEL0 ) ; } N_valid_compares = 0 ; for ( i = 0 ; i < NO_OF_LEDS ; i ++ ) { if ( temp_compare_array [ i ] != 255 ) { N_valid_compares ++ ; } compare_array [ i ] = temp_compare_array [ i ] ; <S2SV_StartBug> pin_array [ i ] = temp_pin_array [ i ] ; <S2SV_EndBug> } update_compare_array = false ; } compare_array_ID = 0 ; pin_array_ID = 0 ; compare_value = compare_array [ 0 ] ; if ( compare_value != 255 ) { <S2SV_StartBug> led_disable_flag = true ; <S2SV_EndBug> while ( ( * STATUS_REGISTER && MASK_SYNC ) == true ) ; * COMPARE_REGISTER = compare_value ; } else { int_enable = true ; tc_disable_callback ( module , TC_CALLBACK_CC_CHANNEL0 ) ; } while ( ( * STATUS_REGISTER && MASK_SYNC ) == true ) ; * COUNT_REGISTER = 0 ; module -> hw -> COUNT8 . INTFLAG . reg = TC_INTFLAG_OVF ; } }
|
<S2SV_ModStart> = false ; <S2SV_ModEnd> tc_enable_callback ( module <S2SV_ModStart> 0x00000011 ) ; } if ( lock_temp_array == false ) { <S2SV_ModEnd> N_valid_compares = 0 <S2SV_ModStart> i ] ; } <S2SV_ModStart> 255 ) { <S2SV_ModEnd> while ( (
|
7,154 |
CWE-000 static int ad7768_probe ( struct spi_device * spi ) { struct ad7768_state * st ; struct iio_dev * indio_dev ; struct iio_buffer * buffer ; int ret ; indio_dev = devm_iio_device_alloc ( & spi -> dev , sizeof ( * st ) ) ; if ( ! indio_dev ) return - ENOMEM ; st = iio_priv ( indio_dev ) ; st -> vref = devm_regulator_get ( & spi -> dev , "vref" ) ; if ( IS_ERR ( st -> vref ) ) return PTR_ERR ( st -> vref ) ; st -> mclk = devm_clk_get ( & spi -> dev , "mclk" ) ; if ( IS_ERR ( st -> mclk ) ) return PTR_ERR ( st -> mclk ) ; spi_set_drvdata ( spi , indio_dev ) ; st -> spi = spi ; mutex_init ( & st -> lock ) ; indio_dev -> dev . parent = & spi -> dev ; indio_dev -> name = spi_get_device_id ( spi ) -> name ; indio_dev -> modes = INDIO_DIRECT_MODE | INDIO_BUFFER_HARDWARE ; indio_dev -> channels = ad7768_channels ; indio_dev -> num_channels = ARRAY_SIZE ( ad7768_channels ) ; indio_dev -> info = & ad7768_info ; buffer = iio_dmaengine_buffer_alloc ( indio_dev -> dev . parent , "rx" , & dma_buffer_ops , indio_dev ) ; if ( IS_ERR ( buffer ) ) return PTR_ERR ( buffer ) ; iio_device_attach_buffer ( indio_dev , buffer ) ; ret = regulator_enable ( st -> vref ) ; if ( ret ) return ret ; ret = clk_prepare_enable ( st -> mclk ) ; if ( ret < 0 ) goto error_disable_reg ; ret = ad7768_samp_freq_config ( st , AD7768_MAX_SAMP_FREQ ) ; if ( ret < 0 ) goto error_disable_clk ; ret = devm_iio_device_register ( & spi -> dev , indio_dev ) ; if ( ret < 0 ) goto error_disable_clk ; return 0 ; error_disable_clk : clk_disable_unprepare ( st -> mclk ) ; error_disable_reg : regulator_disable ( st -> vref ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> }
|
<S2SV_ModStart> vref ) ; iio_dmaengine_buffer_free ( indio_dev -> buffer ) ;
|
7,155 |
CWE-000 int pthread_join ( pthread_t thread , void * * retval ) { esp_pthread_t * pthread = ( esp_pthread_t * ) thread ; <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> ESP_LOGV ( TAG , "%s<S2SV_blank>%p" , __FUNCTION__ , pthread ) ; if ( xSemaphoreTake ( s_threads_mux , portMAX_DELAY ) != pdTRUE ) { assert ( false && "Failed<S2SV_blank>to<S2SV_blank>lock<S2SV_blank>threads<S2SV_blank>list!" ) ; } TaskHandle_t handle = pthread_find_handle ( thread ) ; if ( ! handle ) { ret = ESRCH ; } else if ( pthread -> join_task ) { ret = EINVAL ; } else if ( handle == xTaskGetCurrentTaskHandle ( ) ) { ret = EDEADLK ; } else { esp_pthread_t * cur_pthread = pthread_find ( xTaskGetCurrentTaskHandle ( ) ) ; if ( cur_pthread && cur_pthread -> join_task == handle ) { ret = EDEADLK ; } else { if ( pthread -> state == PTHREAD_TASK_STATE_RUN ) { pthread -> join_task = xTaskGetCurrentTaskHandle ( ) ; <S2SV_StartBug> } else { <S2SV_EndBug> pthread_delete ( pthread ) ; } } } xSemaphoreGive ( s_threads_mux ) ; <S2SV_StartBug> if ( ret == 0 && pthread -> join_task ) { <S2SV_EndBug> xTaskNotifyWait ( 0 , 0 , NULL , portMAX_DELAY ) ; if ( xSemaphoreTake ( s_threads_mux , portMAX_DELAY ) != pdTRUE ) { assert ( false && "Failed<S2SV_blank>to<S2SV_blank>lock<S2SV_blank>threads<S2SV_blank>list!" ) ; } pthread_delete ( pthread ) ; xSemaphoreGive ( s_threads_mux ) ; } if ( retval ) { * retval = 0 ; } ESP_LOGV ( TAG , "%s<S2SV_blank>%p<S2SV_blank>EXIT<S2SV_blank>%d" , __FUNCTION__ , pthread , ret ) ; return ret ; }
|
<S2SV_ModStart> ret = 0 ; bool wait = false <S2SV_ModStart> ( ) ; wait = true ; <S2SV_ModStart> == 0 && wait <S2SV_ModEnd> ) { xTaskNotifyWait
|
7,156 |
CWE-000 static gboolean save_image ( GFile * file , gint32 image_ID , gint32 drawable_ID , GError * * error ) { GOutputStream * output ; GimpPatternHeader ph ; GeglBuffer * buffer ; const Babl * file_format ; guchar * buf ; gint width ; gint height ; gint line_size ; gint line ; switch ( gimp_drawable_type ( drawable_ID ) ) { case GIMP_GRAY_IMAGE : file_format = babl_format ( "Y\'<S2SV_blank>u8" ) ; break ; case GIMP_GRAYA_IMAGE : file_format = babl_format ( "Y\'A<S2SV_blank>u8" ) ; break ; case GIMP_RGB_IMAGE : case GIMP_INDEXED_IMAGE : file_format = babl_format ( "R\'G\'B\'<S2SV_blank>u8" ) ; break ; case GIMP_RGBA_IMAGE : case GIMP_INDEXEDA_IMAGE : file_format = babl_format ( "R\'G\'B\'A<S2SV_blank>u8" ) ; break ; default : g_message ( "Unsupported<S2SV_blank>image<S2SV_blank>type:<S2SV_blank>%d\\n" "GIMP<S2SV_blank>Patterns<S2SV_blank>must<S2SV_blank>be<S2SV_blank>GRAY<S2SV_blank>or<S2SV_blank>RGB" , gimp_drawable_type ( drawable_ID ) ) ; return FALSE ; } gimp_progress_init_printf ( _ ( "Exporting<S2SV_blank>\'%s\'" ) , g_file_get_parse_name ( file ) ) ; output = G_OUTPUT_STREAM ( g_file_replace ( file , NULL , FALSE , G_FILE_CREATE_NONE , NULL , error ) ) ; if ( ! output ) return FALSE ; buffer = gimp_drawable_get_buffer ( drawable_ID ) ; width = gegl_buffer_get_width ( buffer ) ; height = gegl_buffer_get_height ( buffer ) ; ph . header_size = g_htonl ( sizeof ( GimpPatternHeader ) + strlen ( description ) + 1 ) ; ph . version = g_htonl ( 1 ) ; ph . width = g_htonl ( width ) ; ph . height = g_htonl ( height ) ; ph . bytes = g_htonl ( babl_format_get_bytes_per_pixel ( file_format ) ) ; ph . magic_number = g_htonl ( GIMP_PATTERN_MAGIC ) ; if ( ! g_output_stream_write_all ( output , & ph , sizeof ( GimpPatternHeader ) , NULL , NULL , error ) ) { <S2SV_StartBug> g_object_unref ( output ) ; <S2SV_EndBug> return FALSE ; } if ( ! g_output_stream_write_all ( output , description , strlen ( description ) + 1 , NULL , NULL , error ) ) <S2SV_StartBug> { <S2SV_EndBug> g_object_unref ( output ) ; return FALSE ; } line_size = width * babl_format_get_bytes_per_pixel ( file_format ) ; buf = g_alloca ( line_size ) ; for ( line = 0 ; line < height ; line ++ ) { gegl_buffer_get ( buffer , GEGL_RECTANGLE ( 0 , line , width , 1 ) , 1.0 , file_format , buf , GEGL_AUTO_ROWSTRIDE , GEGL_ABYSS_NONE ) ; if ( ! g_output_stream_write_all ( output , buf , line_size , NULL , NULL , error ) ) { <S2SV_StartBug> g_object_unref ( buffer ) ; <S2SV_EndBug> g_object_unref ( output ) ; return FALSE ; } gimp_progress_update ( ( gdouble ) line / ( gdouble ) height ) ; } g_object_unref ( buffer ) ; g_object_unref ( output ) ; gimp_progress_update ( 1.0 ) ; return TRUE ; }
|
<S2SV_ModStart> ) ) { GCancellable * cancellable = g_cancellable_new ( ) ; g_cancellable_cancel ( cancellable ) ; g_output_stream_close ( output , cancellable , NULL ) ; g_object_unref ( cancellable ) ; <S2SV_ModStart> ) ) { GCancellable * cancellable = g_cancellable_new ( ) ; g_cancellable_cancel ( cancellable ) ; g_output_stream_close ( output , cancellable , NULL ) ; g_object_unref ( cancellable ) ; <S2SV_ModStart> ) ) { GCancellable * cancellable = g_cancellable_new ( ) ; g_cancellable_cancel ( cancellable ) ; g_output_stream_close ( output , cancellable , NULL ) ; g_object_unref ( cancellable ) ;
|
7,157 |
CWE-000 static char * expandvar ( t_sds * word , size_t from ) { char var [ PATH_MAX ] ; char * val ; size_t len ; if ( ( len = getvar ( word -> buf + from , var ) ) ) { ft_sdsnrem ( word , from - 1 , len + 1 , NULL ) ; if ( ( val = sh_varget ( var , g_env ) ) ) ft_sdsmput ( word , from - 1 , val , len = ft_strlen ( val ) ) ; <S2SV_StartBug> else if ( ft_isdigit ( * var ) || ( len == 1 && ft_strchr ( "@*#?-$!" , * var ) ) ) <S2SV_EndBug> len = expandspecial ( word , var , from ) ; else len = 0 ; return ( word -> buf + from - 1 + len ) ; } return ( word -> buf + from ) ; }
|
<S2SV_ModStart> && ft_strchr ( "#?$!" <S2SV_ModEnd> , * var
|
7,158 |
CWE-000 static UCS_CLASS_INIT_FUNC ( uct_mm_iface_t , uct_md_h md , uct_worker_h worker , const uct_iface_params_t * params , const uct_iface_config_t * tl_config ) { uct_mm_iface_config_t * mm_config = ucs_derived_of ( tl_config , uct_mm_iface_config_t ) ; uct_mm_fifo_element_t * fifo_elem_p ; ucs_status_t status ; unsigned i ; UCS_CLASS_CALL_SUPER_INIT ( uct_base_iface_t , & uct_mm_iface_ops , md , worker , params , tl_config UCS_STATS_ARG ( params -> stats_root ) UCS_STATS_ARG ( UCT_MM_TL_NAME ) ) ; ucs_trace_func ( "Creating<S2SV_blank>an<S2SV_blank>MM<S2SV_blank>iface=%p<S2SV_blank>worker=%p" , self , worker ) ; if ( ( mm_config -> fifo_size <= 1 ) || ucs_is_pow2 ( mm_config -> fifo_size ) != 1 ) { ucs_error ( "The<S2SV_blank>MM<S2SV_blank>FIFO<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>power<S2SV_blank>of<S2SV_blank>two<S2SV_blank>and<S2SV_blank>bigger<S2SV_blank>than<S2SV_blank>1." ) ; status = UCS_ERR_INVALID_PARAM ; goto err ; } if ( ( mm_config -> release_fifo_factor < 0 ) || ( mm_config -> release_fifo_factor >= 1 ) ) { ucs_error ( "The<S2SV_blank>MM<S2SV_blank>release<S2SV_blank>FIFO<S2SV_blank>factor<S2SV_blank>must<S2SV_blank>be:<S2SV_blank>(0<S2SV_blank>=<<S2SV_blank>factor<S2SV_blank><<S2SV_blank>1)." ) ; status = UCS_ERR_INVALID_PARAM ; goto err ; } if ( mm_config -> super . max_short <= sizeof ( uct_mm_fifo_element_t ) ) { ucs_error ( "The<S2SV_blank>UCT_MM_MAX_SHORT<S2SV_blank>parameter<S2SV_blank>must<S2SV_blank>be<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>FIFO<S2SV_blank>" <S2SV_StartBug> "element<S2SV_blank>header<S2SV_blank>size.<S2SV_blank>(<S2SV_blank>>=<S2SV_blank>%ld<S2SV_blank>bytes)." , <S2SV_EndBug> sizeof ( uct_mm_fifo_element_t ) ) ; status = UCS_ERR_INVALID_PARAM ; goto err ; } self -> config . fifo_size = mm_config -> fifo_size ; self -> config . fifo_elem_size = mm_config -> super . max_short ; self -> config . seg_size = mm_config -> super . max_bcopy ; self -> fifo_release_factor_mask = UCS_MASK ( ucs_ilog2 ( ucs_max ( ( int ) ( mm_config -> fifo_size * mm_config -> release_fifo_factor ) , 1 ) ) ) ; self -> fifo_mask = mm_config -> fifo_size - 1 ; self -> fifo_shift = ucs_count_zero_bits ( mm_config -> fifo_size ) ; self -> rx_headroom = params -> rx_headroom ; self -> release_desc . cb = uct_mm_iface_release_desc ; status = uct_mm_allocate_fifo_mem ( self , mm_config , md ) ; if ( status != UCS_OK ) { goto err ; } self -> recv_fifo_ctl -> head = 0 ; self -> recv_fifo_ctl -> tail = 0 ; self -> read_index = 0 ; status = uct_mm_iface_create_signal_fd ( self ) ; if ( status != UCS_OK ) { goto err_free_fifo ; } status = uct_iface_mpool_init ( & self -> super , & self -> recv_desc_mp , sizeof ( uct_mm_recv_desc_t ) + params -> rx_headroom + self -> config . seg_size , sizeof ( uct_mm_recv_desc_t ) , UCS_SYS_CACHE_LINE_SIZE , & mm_config -> mp , 256 , uct_mm_iface_recv_desc_init , "mm_recv_desc" ) ; if ( status != UCS_OK ) { ucs_error ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>a<S2SV_blank>receive<S2SV_blank>descriptor<S2SV_blank>memory<S2SV_blank>pool<S2SV_blank>for<S2SV_blank>the<S2SV_blank>MM<S2SV_blank>transport" ) ; goto err_close_signal_fd ; } self -> last_recv_desc = ucs_mpool_get ( & self -> recv_desc_mp ) ; VALGRIND_MAKE_MEM_DEFINED ( self -> last_recv_desc , sizeof ( * ( self -> last_recv_desc ) ) ) ; if ( self -> last_recv_desc == NULL ) { ucs_error ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>the<S2SV_blank>first<S2SV_blank>receive<S2SV_blank>descriptor" ) ; status = UCS_ERR_NO_RESOURCE ; goto destroy_recv_mpool ; } for ( i = 0 ; i < mm_config -> fifo_size ; i ++ ) { fifo_elem_p = UCT_MM_IFACE_GET_FIFO_ELEM ( self , self -> recv_fifo_elements , i ) ; fifo_elem_p -> flags = UCT_MM_FIFO_ELEM_FLAG_OWNER ; status = uct_mm_assign_desc_to_fifo_elem ( self , fifo_elem_p , 1 ) ; if ( status != UCS_OK ) { ucs_error ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>a<S2SV_blank>descriptor<S2SV_blank>for<S2SV_blank>MM" ) ; goto destroy_descs ; } } uct_mm_iface_init_dummy_fifo_ctl ( self ) ; ucs_arbiter_init ( & self -> arbiter ) ; ucs_async_set_event_handler ( ( worker -> async != NULL ) ? worker -> async -> mode : UCS_ASYNC_MODE_THREAD , self -> signal_fd , POLLIN , uct_mm_iface_singal_handler , self , worker -> async ) ; ucs_debug ( "Created<S2SV_blank>an<S2SV_blank>MM<S2SV_blank>iface.<S2SV_blank>FIFO<S2SV_blank>mm<S2SV_blank>id:<S2SV_blank>%zu" , self -> fifo_mm_id ) ; return UCS_OK ; destroy_descs : uct_mm_iface_free_rx_descs ( self , i ) ; ucs_mpool_put ( self -> last_recv_desc ) ; destroy_recv_mpool : ucs_mpool_cleanup ( & self -> recv_desc_mp , 1 ) ; err_close_signal_fd : close ( self -> signal_fd ) ; err_free_fifo : uct_mm_md_mapper_ops ( md ) -> free ( self -> shared_mem , self -> fifo_mm_id , UCT_MM_GET_FIFO_SIZE ( self ) , self -> path ) ; err : return status ; }
|
<S2SV_ModStart> ucs_error ( "The<S2SV_blank>UCT_MM_MAX_SHORT<S2SV_blank>parameter<S2SV_blank>must<S2SV_blank>be<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>FIFO<S2SV_blank>" "element<S2SV_blank>header<S2SV_blank>size.<S2SV_blank>(<S2SV_blank>><S2SV_blank>%ld<S2SV_blank>bytes)." <S2SV_ModEnd> , sizeof (
|
7,159 |
CWE-000 static void handle_rtnetlink ( _unused void * addr , void * data , size_t len , _unused struct interface * iface , _unused void * dest ) { bool dump_neigh = false ; struct in6_addr last_solicited = IN6ADDR_ANY_INIT ; for ( struct nlmsghdr * nh = data ; NLMSG_OK ( nh , len ) ; nh = NLMSG_NEXT ( nh , len ) ) { struct ndmsg * ndm = NLMSG_DATA ( nh ) ; struct rtmsg * rtm = NLMSG_DATA ( nh ) ; bool is_addr = ( nh -> nlmsg_type == RTM_NEWADDR || nh -> nlmsg_type == RTM_DELADDR ) ; bool is_route = ( nh -> nlmsg_type == RTM_NEWROUTE || nh -> nlmsg_type == RTM_DELROUTE ) ; bool is_neigh = ( nh -> nlmsg_type == RTM_NEWNEIGH || nh -> nlmsg_type == RTM_DELNEIGH ) ; if ( ( ! is_addr && ! is_route && ! is_neigh ) || NLMSG_PAYLOAD ( nh , 0 ) < sizeof ( * ndm ) || ndm -> ndm_family != AF_INET6 ) continue ; <S2SV_StartBug> if ( is_route && rtm -> rtm_dst_len == 0 ) <S2SV_EndBug> raise ( SIGUSR1 ) ; <S2SV_StartBug> else if ( is_route ) <S2SV_EndBug> continue ; size_t rta_offset = ( is_addr ) ? sizeof ( struct ifaddrmsg ) : sizeof ( * ndm ) ; uint16_t atype = ( is_addr ) ? IFA_ADDRESS : NDA_DST ; ssize_t alen = NLMSG_PAYLOAD ( nh , rta_offset ) ; struct in6_addr * addr = NULL ; for ( struct rtattr * rta = ( void * ) ( ( ( uint8_t * ) ndm ) + rta_offset ) ; RTA_OK ( rta , alen ) ; rta = RTA_NEXT ( rta , alen ) ) { if ( rta -> rta_type == atype && RTA_PAYLOAD ( rta ) >= sizeof ( * addr ) ) { addr = RTA_DATA ( rta ) ; } } struct interface * iface = odhcpd_get_interface_by_index ( ndm -> ndm_ifindex ) ; if ( ! iface ) continue ; if ( ! addr || IN6_IS_ADDR_LINKLOCAL ( addr ) || IN6_IS_ADDR_MULTICAST ( addr ) ) continue ; bool add ; if ( is_addr ) add = ( nh -> nlmsg_type == RTM_NEWADDR ) ; else add = ( nh -> nlmsg_type == RTM_NEWNEIGH && ( ndm -> ndm_state & ( NUD_REACHABLE | NUD_STALE | NUD_DELAY | NUD_PROBE | NUD_PERMANENT | NUD_NOARP ) ) ) ; if ( iface -> ndp == RELAYD_RELAY ) { struct { struct nlmsghdr nh ; struct ndmsg ndm ; struct nlattr nla_dst ; struct in6_addr dst ; } req = { { sizeof ( req ) , RTM_DELNEIGH , NLM_F_REQUEST , ++ rtnl_seqid , 0 } , { . ndm_family = AF_INET6 , . ndm_flags = NTF_PROXY } , { sizeof ( struct nlattr ) + sizeof ( struct in6_addr ) , NDA_DST } , * addr } ; if ( ndm -> ndm_flags & NTF_PROXY ) { if ( nh -> nlmsg_type == RTM_NEWNEIGH ) { req . ndm . ndm_ifindex = iface -> ifindex ; send ( rtnl_event . uloop . fd , & req , sizeof ( req ) , MSG_DONTWAIT ) ; setup_route ( addr , iface , false ) ; dump_neigh = true ; } } else if ( add ) { struct interface * c ; list_for_each_entry ( c , & interfaces , head ) { if ( iface == c ) continue ; if ( c -> ndp == RELAYD_RELAY ) { req . nh . nlmsg_type = RTM_NEWNEIGH ; req . nh . nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE ; req . ndm . ndm_ifindex = c -> ifindex ; send ( rtnl_event . uloop . fd , & req , sizeof ( req ) , MSG_DONTWAIT ) ; } else { req . nh . nlmsg_type = RTM_DELNEIGH ; req . nh . nlmsg_flags &= ~ ( NLM_F_CREATE | NLM_F_REPLACE ) ; req . ndm . ndm_ifindex = c -> ifindex ; send ( rtnl_event . uloop . fd , & req , sizeof ( req ) , MSG_DONTWAIT ) ; } } setup_route ( addr , iface , true ) ; } else { if ( nh -> nlmsg_type == RTM_NEWNEIGH ) { if ( ! IN6_ARE_ADDR_EQUAL ( & last_solicited , addr ) ) { last_solicited = * addr ; struct interface * c ; list_for_each_entry ( c , & interfaces , head ) if ( iface -> ndp == RELAYD_RELAY && iface != c && ! c -> external == false ) ping6 ( addr , c ) ; } } else { struct interface * c ; list_for_each_entry ( c , & interfaces , head ) { if ( c -> ndp == RELAYD_RELAY && iface != c ) { req . ndm . ndm_ifindex = c -> ifindex ; send ( rtnl_event . uloop . fd , & req , sizeof ( req ) , MSG_DONTWAIT ) ; } } setup_route ( addr , iface , false ) ; dump_neigh = true ; } } } if ( is_addr ) { check_updates ( iface ) ; if ( iface -> dhcpv6 == RELAYD_SERVER ) iface -> ia_reconf = true ; if ( iface -> ndp == RELAYD_RELAY && iface -> master ) { nh -> nlmsg_flags = NLM_F_REQUEST ; if ( nh -> nlmsg_type == RTM_NEWADDR ) nh -> nlmsg_flags |= NLM_F_CREATE | NLM_F_REPLACE ; struct interface * c ; list_for_each_entry ( c , & interfaces , head ) { if ( c -> ndp == RELAYD_RELAY && ! c -> master ) { ndm -> ndm_ifindex = c -> ifindex ; send ( rtnl_event . uloop . fd , nh , nh -> nlmsg_len , MSG_DONTWAIT ) ; } } } } } if ( dump_neigh ) dump_neigh_table ( false ) ; }
|
<S2SV_ModStart> if ( is_route ) { if ( <S2SV_ModEnd> rtm -> rtm_dst_len <S2SV_ModStart> SIGUSR1 ) ; continue ; } <S2SV_ModEnd> size_t rta_offset =
|
7,160 |
CWE-000 void sp_dump_macro ( struct sp_macro_def * macro , struct sp_preprocessor * pp ) { printf ( "#define<S2SV_blank>%s" , sp_get_macro_name ( macro , pp ) ) ; if ( macro -> is_function ) { printf ( "(" ) ; <S2SV_StartBug> struct sp_pp_token * t = sp_rewind_pp_token_list ( & macro -> params ) ; <S2SV_EndBug> <S2SV_StartBug> while ( sp_read_pp_token_from_list ( & macro -> params , & t ) ) { <S2SV_EndBug> if ( pp_tok_is_identifier ( t ) && strcmp ( sp_get_pp_token_string ( pp , t ) , "__VA_ARGS__" ) == 0 ) printf ( "..." ) ; else { printf ( "%s" , sp_dump_pp_token ( pp , t ) ) ; <S2SV_StartBug> if ( sp_peek_pp_token_from_list ( & macro -> params ) ) <S2SV_EndBug> printf ( ",<S2SV_blank>" ) ; else if ( macro -> is_named_variadic ) printf ( "..." ) ; } } printf ( ")<S2SV_blank>" ) ; } else { printf ( "<S2SV_blank>" ) ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> struct sp_pp_token * t = sp_rewind_pp_token_list ( & macro -> body ) ; <S2SV_EndBug> <S2SV_StartBug> while ( sp_read_pp_token_from_list ( & macro -> body , & t ) ) <S2SV_EndBug> printf ( "%s" , sp_dump_pp_token ( pp , t ) ) ; printf ( "\\n" ) ; }
|
<S2SV_ModStart> ) ; struct sp_pp_token_list_walker w ; struct <S2SV_ModStart> sp_rewind_pp_token_list ( & w , & <S2SV_ModStart> sp_read_pp_token_from_list ( & w <S2SV_ModEnd> , & t <S2SV_ModStart> sp_peek_pp_token_from_list ( & w <S2SV_ModEnd> ) ) printf <S2SV_ModStart> ) ; } struct sp_pp_token_list_walker w ; <S2SV_ModStart> sp_rewind_pp_token_list ( & w , & <S2SV_ModStart> sp_read_pp_token_from_list ( & w <S2SV_ModEnd> , & t
|
7,161 |
CWE-000 void * bed_read ( const char * fn ) { reghash_t * h = kh_init ( reg ) ; gzFile fp ; kstream_t * ks = NULL ; int dret ; unsigned int line = 0 ; kstring_t str = { 0 , 0 , NULL } ; if ( NULL == h ) return NULL ; fp = strcmp ( fn , "-" ) ? gzopen ( fn , "r" ) : gzdopen ( fileno ( stdin ) , "r" ) ; if ( fp == 0 ) return 0 ; ks = ks_init ( fp ) ; if ( NULL == ks ) goto fail ; while ( ks_getuntil ( ks , KS_SEP_LINE , & str , & dret ) > 0 ) { char * ref = str . s , * ref_end ; unsigned int beg = 0 , end = 0 ; int num = 0 ; khint_t k ; bed_reglist_t * p ; line ++ ; while ( * ref && isspace ( * ref ) ) ref ++ ; if ( '\\0' == * ref ) continue ; if ( '#' == * ref ) continue ; ref_end = ref ; while ( * ref_end && ! isspace ( * ref_end ) ) ref_end ++ ; if ( '\\0' != * ref_end ) { * ref_end = '\\0' ; num = sscanf ( ref_end + 1 , "%u<S2SV_blank>%u" , & beg , & end ) ; } if ( 1 == num ) { end = beg -- ; } if ( num < 1 || end < beg ) { if ( 0 == strcmp ( ref , "browser" ) ) continue ; if ( 0 == strcmp ( ref , "track" ) ) continue ; fprintf ( stderr , "[bed_read]<S2SV_blank>Parse<S2SV_blank>error<S2SV_blank>reading<S2SV_blank>%s<S2SV_blank>at<S2SV_blank>line<S2SV_blank>%u\\n" , fn , line ) ; goto fail_no_msg ; } k = kh_get ( reg , h , ref ) ; if ( k == kh_end ( h ) ) { int ret ; char * s = strdup ( ref ) ; if ( NULL == s ) goto fail ; k = kh_put ( reg , h , s , & ret ) ; if ( - 1 == ret ) { free ( s ) ; goto fail ; } memset ( & kh_val ( h , k ) , 0 , sizeof ( bed_reglist_t ) ) ; } p = & kh_val ( h , k ) ; <S2SV_StartBug> if ( p -> n == p -> a_space ) { <S2SV_EndBug> <S2SV_StartBug> p -> a_space = p -> a_space ? p -> a_space << 1 : 4 ; <S2SV_EndBug> <S2SV_StartBug> p -> a = realloc ( p -> a , p -> a_space * sizeof ( uint64_t ) ) ; <S2SV_EndBug> if ( NULL == p -> a ) goto fail ; } p -> a [ p -> n ++ ] = ( uint64_t ) beg << 32 | end ; } ks_destroy ( ks ) ; gzclose ( fp ) ; free ( str . s ) ; bed_index ( h ) ; bed_unify ( h ) ; return h ; fail : fprintf ( stderr , "[bed_read]<S2SV_blank>Error<S2SV_blank>reading<S2SV_blank>%s<S2SV_blank>:<S2SV_blank>%s\\n" , fn , strerror ( errno ) ) ; fail_no_msg : if ( ks ) ks_destroy ( ks ) ; if ( fp ) gzclose ( fp ) ; free ( str . s ) ; bed_destroy ( h ) ; return NULL ; }
|
<S2SV_ModStart> == p -> m ) { p -> m = p -> m <S2SV_ModEnd> ? p -> <S2SV_ModStart> ? p -> m <S2SV_ModEnd> << 1 : <S2SV_ModStart> , p -> m <S2SV_ModEnd> * sizeof (
|
7,162 |
CWE-000 static int _dpdk_vdev_promisc_mode_set ( uint16_t port_id , int enable ) { <S2SV_StartBug> struct rte_eth_dev_info dev_info = { 0 } ; <S2SV_EndBug> struct ifreq ifr ; int ret ; int sockfd ; rte_eth_dev_info_get ( port_id , & dev_info ) ; if_indextoname ( dev_info . if_index , ifr . ifr_name ) ; sockfd = socket ( AF_INET , SOCK_DGRAM , 0 ) ; ret = ioctl ( sockfd , SIOCGIFFLAGS , & ifr ) ; if ( ret < 0 ) { close ( sockfd ) ; ODP_DBG ( "ioctl<S2SV_blank>SIOCGIFFLAGS<S2SV_blank>error\\n" ) ; return - 1 ; } if ( enable ) ifr . ifr_flags |= IFF_PROMISC ; else ifr . ifr_flags &= ~ ( IFF_PROMISC ) ; ret = ioctl ( sockfd , SIOCSIFFLAGS , & ifr ) ; if ( ret < 0 ) { close ( sockfd ) ; ODP_DBG ( "ioctl<S2SV_blank>SIOCSIFFLAGS<S2SV_blank>error\\n" ) ; return - 1 ; } ret = ioctl ( sockfd , SIOCGIFMTU , & ifr ) ; if ( ret < 0 ) { close ( sockfd ) ; ODP_DBG ( "ioctl<S2SV_blank>SIOCGIFMTU<S2SV_blank>error\\n" ) ; return - 1 ; } ODP_DBG ( "vdev<S2SV_blank>promisc<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%d\\n" , enable ) ; close ( sockfd ) ; return 0 ; }
|
<S2SV_ModStart> struct rte_eth_dev_info dev_info <S2SV_ModEnd> ; struct ifreq
|
7,163 |
CWE-000 const char * pie_cfg_get ( const char * key ) { if ( pie_cfg . cfg_map == NULL ) { return NULL ; } <S2SV_StartBug> return hmap_get ( pie_cfg . cfg_map , DB_PATH ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> . cfg_map , key <S2SV_ModEnd> ) ; }
|
7,164 |
CWE-000 static void pbkdf2_sha512 ( const char * passphrase , const char * salt , unsigned int count , char * derived_key ) { size_t passphrase_size = strlen ( passphrase ) ; unsigned char buf [ SHA512_LENGTH + MAX_PASSPHRASE_SIZE ] = { 0 } ; unsigned char tempbuf [ SHA512_LENGTH ] = { 0 } ; char final [ SHA512_LENGTH ] = { 0 } ; unsigned char saltbuf [ SALT_BYTES + MAX_PASSPHRASE_SIZE ] = { 0 } ; int actual_buf_len = SHA512_LENGTH + passphrase_size ; int actual_saltbuf_len = SALT_BYTES + passphrase_size ; unsigned int x , y ; unsigned int * final_u32 = ( unsigned int * ) final ; unsigned int * temp_u32 = ( unsigned int * ) tempbuf ; memcpy ( saltbuf , salt , SALT_BYTES ) ; memcpy ( & saltbuf [ SALT_BYTES ] , passphrase , passphrase_size ) ; memcpy ( & buf [ SHA512_LENGTH ] , passphrase , passphrase_size ) ; for ( x = 0 ; x < count ; ++ x ) { if ( x == 0 ) { start_sha512 ( saltbuf , actual_saltbuf_len , tempbuf ) ; } else { <S2SV_StartBug> memcpy ( buf , tempbuf , SHA256_LENGTH ) ; <S2SV_EndBug> start_sha512 ( buf , actual_buf_len , tempbuf ) ; } for ( y = 0 ; y < ( sizeof ( final ) / sizeof ( * final_u32 ) ) ; ++ y ) final_u32 [ y ] = final_u32 [ y ] ^ temp_u32 [ y ] ; } memcpy ( derived_key , final , SYM_KEY_BYTES ) ; }
|
<S2SV_ModStart> , tempbuf , SHA512_LENGTH <S2SV_ModEnd> ) ; start_sha512
|
7,165 |
CWE-000 void analyzeCameraFrame ( vehicle_t * c , imfeatures_t * imft ) { int i , j ; int minim = HRES * VRES ; int bwStreet [ minim ] ; int bwTL [ minim ] ; int tmp ; for ( i = 0 ; i < VRES ; ++ i ) { for ( j = 0 ; j < HRES ; ++ j ) { tmp = c -> cam . image [ i ] [ j ] ; bwStreet [ i * HRES + j ] = ( tmp != STREET_COL ) ? BLACK : WHITE ; bwTL [ i * HRES + j ] = ( tmp == TL_COL ) ? WHITE : BLACK ; } } <S2SV_StartBug> RosenfeldPfaltz ( bwTL , & imft -> TLcenter ) ; <S2SV_EndBug> fastHarrisRobertCornerDetection ( bwStreet , & imft -> streetCorner ) ; <S2SV_StartBug> display ( bwTL , 400 , 620 ) ; <S2SV_EndBug> for ( i = 0 ; i < imft -> TLcenter . N ; i ++ ) { if ( imft -> TLcenter . y [ i + 1 ] > ( HRES / 2 ) ) { if ( imft -> TLcenter . x [ i + 1 ] < minim ) { minim = imft -> TLcenter . x [ i + 1 ] ; imft -> TLminDistance = minim ; imft -> TLstatus = c -> cam . image [ imft -> TLcenter . x [ i + 1 ] ] [ imft -> TLcenter . y [ i + 1 ] ] ; } } } }
|
<S2SV_ModStart> ; } } RobertsEdgeDetectorH ( bwTL <S2SV_ModEnd> ) ; fastHarrisRobertCornerDetection <S2SV_ModStart> streetCorner ) ; <S2SV_ModEnd> for ( i
|
7,166 |
CWE-000 static void do_clear_cpu_cap ( struct cpuinfo_x86 * c , unsigned int feature ) { <S2SV_StartBug> bool changed ; <S2SV_EndBug> <S2SV_StartBug> DECLARE_BITMAP ( disable , NCAPINTS * sizeof ( u32 ) * 8 ) ; <S2SV_EndBug> <S2SV_StartBug> const struct cpuid_dep * d ; <S2SV_EndBug> clear_feature ( c , feature ) ; memset ( disable , 0 , sizeof ( disable ) ) ; __set_bit ( feature , disable ) ; do { changed = false ; for ( d = cpuid_deps ; d -> feature ; d ++ ) { if ( ! test_bit ( d -> depends , disable ) ) continue ; if ( __test_and_set_bit ( d -> feature , disable ) ) continue ; changed = true ; clear_feature ( c , d -> feature ) ; } } while ( changed ) ; }
|
<S2SV_ModStart> feature ) { <S2SV_ModEnd> DECLARE_BITMAP ( disable <S2SV_ModStart> ( disable , MAX_FEATURE_BITS <S2SV_ModEnd> ) ; const <S2SV_ModStart> cpuid_dep * d ; bool changed ; if ( WARN_ON ( feature >= MAX_FEATURE_BITS ) ) return
|
7,167 |
CWE-000 static GstPadProbeReturn ghost_pad_event_probe ( GstPad * pad , GstPadProbeInfo * info , DecodebinOutputStream * output ) { GstPadProbeReturn ret = GST_PAD_PROBE_OK ; GstDecodebin3 * dbin = output -> dbin ; GstEvent * event = GST_PAD_PROBE_INFO_EVENT ( info ) ; GST_DEBUG_OBJECT ( pad , "Got<S2SV_blank>event<S2SV_blank>%p<S2SV_blank>%s" , event , GST_EVENT_TYPE_NAME ( event ) ) ; switch ( GST_EVENT_TYPE ( event ) ) { case GST_EVENT_SELECT_STREAMS : { GstPad * peer ; GList * streams = NULL ; guint32 seqnum = gst_event_get_seqnum ( event ) ; SELECTION_LOCK ( dbin ) ; if ( seqnum == dbin -> select_streams_seqnum ) { SELECTION_UNLOCK ( dbin ) ; GST_DEBUG_OBJECT ( pad , "Already<S2SV_blank>handled/handling<S2SV_blank>that<S2SV_blank>SELECT_STREAMS<S2SV_blank>event" ) ; break ; } dbin -> select_streams_seqnum = seqnum ; if ( dbin -> pending_select_streams != NULL ) { GST_LOG_OBJECT ( dbin , "Replacing<S2SV_blank>pending<S2SV_blank>select<S2SV_blank>streams" ) ; g_list_free ( dbin -> pending_select_streams ) ; dbin -> pending_select_streams = NULL ; } gst_event_parse_select_streams ( event , & streams ) ; dbin -> pending_select_streams = g_list_copy ( streams ) ; SELECTION_UNLOCK ( dbin ) ; if ( ( peer = gst_pad_get_peer ( pad ) ) ) { gst_pad_send_event ( peer , event ) ; gst_object_unref ( peer ) ; } else { gst_event_unref ( event ) ; } <S2SV_StartBug> if ( streams ) <S2SV_EndBug> <S2SV_StartBug> handle_stream_switch ( dbin , streams , seqnum ) ; <S2SV_EndBug> ret = GST_PAD_PROBE_HANDLED ; } break ; default : break ; } return ret ; }
|
<S2SV_ModStart> ( streams ) { <S2SV_ModStart> seqnum ) ; g_list_free_full ( streams , g_free ) ; }
|
7,168 |
CWE-000 static void print_available_algos ( ) { <S2SV_StartBug> for ( int i = 0 ; i < kinmon_algos_count ; i ++ ) printf ( "%s<S2SV_blank>" , ( ( JSSAlgo * ) ( kinmon_algos + i ) ) -> name ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> JSSAlgo * ) * ( & <S2SV_ModEnd> kinmon_algos + i
|
7,169 |
CWE-000 int call ( int no ) { <S2SV_StartBug> int ret = - 1 ; <S2SV_EndBug> __asm__ __volatile__ ( "mov<S2SV_blank>0x8(%ebp),<S2SV_blank>%eax\\n\\t" "int<S2SV_blank>$0x80\\n\\t" "mov<S2SV_blank>%eax,<S2SV_blank>-0x4(%ebp)" ) ; return ret ; }
|
<S2SV_ModStart> no ) { volatile
|
7,170 |
CWE-000 void in_received_handler ( DictionaryIterator * received , void * context ) { SettingsHandler * handler = ( SettingsHandler * ) context ; Settings * settings = handler -> settings ; Tuple * show_local_t = dict_find ( received , MESSAGE_KEY_ShowLocalTime ) ; if ( show_local_t ) { settings -> show_local_time = show_local_t -> value -> int16 ; } Tuple * allways_local_t = dict_find ( received , MESSAGE_KEY_ForceShowLocalTime ) ; if ( allways_local_t ) { settings -> allways_show_local_time = show_local_t -> value -> int16 ; } Tuple * show_dow_t = dict_find ( received , MESSAGE_KEY_ShowDOW ) ; if ( show_dow_t ) { settings -> show_dow = show_dow_t -> value -> uint16 ; } Tuple * show_date_t = dict_find ( received , MESSAGE_KEY_ShowDate ) ; if ( show_date_t ) { settings -> show_date = show_date_t -> value -> int16 ; } Tuple * custom_color_bubles_t = dict_find ( received , MESSAGE_KEY_CustomColorBubbles ) ; if ( custom_color_bubles_t ) { if ( custom_color_bubles_t -> value -> int16 ) { Tuple * back_color_t = dict_find ( received , MESSAGE_KEY_BackgroundColor ) ; if ( back_color_t ) { settings -> BackgroundColor = GColorFromHEX ( back_color_t -> value -> int32 ) ; } Tuple * front_color_t = dict_find ( received , MESSAGE_KEY_ForegroundColor ) ; if ( front_color_t ) { settings -> ForegroundColor = GColorFromHEX ( front_color_t -> value -> int32 ) ; } Tuple * text_color_t = dict_find ( received , MESSAGE_KEY_TextColor ) ; if ( text_color_t ) { settings -> TextColor = GColorFromHEX ( text_color_t -> value -> int32 ) ; } } else { init_colors_bubble ( settings ) ; } } Tuple * custom_color_map_t = dict_find ( received , MESSAGE_KEY_CustomColorsMap ) ; if ( custom_color_map_t ) { if ( custom_color_map_t -> value -> int16 ) { Tuple * high_color_t = dict_find ( received , MESSAGE_KEY_HighlightMapColor ) ; if ( high_color_t ) { <S2SV_StartBug> settings -> BackgroundColor = GColorFromHEX ( high_color_t -> value -> int32 ) ; <S2SV_EndBug> } Tuple * low_color_t = dict_find ( received , MESSAGE_KEY_GrayMapColor ) ; if ( low_color_t ) { settings -> ShadowColor = GColorFromHEX ( low_color_t -> value -> int32 ) ; } } else { init_colors_map ( settings ) ; } } { { Tuple * city_t ; Tuple * offset_t ; Tuple * x_t ; Tuple * y_t ; city_t = dict_find ( received , MESSAGE_KEY_Place1 ) ; offset_t = dict_find ( received , MESSAGE_KEY_ZoneOffset1 ) ; x_t = dict_find ( received , MESSAGE_KEY_P1X ) ; y_t = dict_find ( received , MESSAGE_KEY_P1Y ) ; update_place ( & settings -> place1 , city_t , offset_t , x_t , y_t ) ; city_t = dict_find ( received , MESSAGE_KEY_Place2 ) ; offset_t = dict_find ( received , MESSAGE_KEY_ZoneOffset2 ) ; x_t = dict_find ( received , MESSAGE_KEY_P2X ) ; y_t = dict_find ( received , MESSAGE_KEY_P2Y ) ; update_place ( & settings -> place2 , city_t , offset_t , x_t , y_t ) ; reorder_places_if_needed ( & settings -> place1 , & settings -> place2 ) ; } <S2SV_StartBug> prv_save_settings ( settings ) ; <S2SV_EndBug> handler -> callback ( ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> { settings -> HighlightColor <S2SV_ModEnd> = GColorFromHEX ( <S2SV_ModStart> ) ; } } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
|
7,171 |
CWE-000 static int mdss_fb_unblank_sub ( struct msm_fb_data_type * mfd ) { int ret = 0 ; int cur_power_state ; if ( ! mfd ) return - EINVAL ; if ( mfd -> disp_thread == NULL ) { ret = mdss_fb_start_disp_thread ( mfd ) ; if ( IS_ERR_VALUE ( ret ) ) return ret ; } cur_power_state = mfd -> panel_power_state ; if ( ! mdss_panel_is_power_on_interactive ( cur_power_state ) && mfd -> mdp . on_fnc ) { ret = mfd -> mdp . on_fnc ( mfd ) ; if ( ret == 0 ) { mfd -> panel_power_state = MDSS_PANEL_POWER_ON ; mfd -> panel_info -> panel_dead = false ; } else if ( mfd -> disp_thread ) { mdss_fb_stop_disp_thread ( mfd ) ; goto error ; } mutex_lock ( & mfd -> update . lock ) ; mfd -> update . type = NOTIFY_TYPE_UPDATE ; mfd -> update . is_suspend = 0 ; mutex_unlock ( & mfd -> update . lock ) ; if ( mfd -> idle_time ) schedule_delayed_work ( & mfd -> idle_notify_work , msecs_to_jiffies ( mfd -> idle_time ) ) ; } if ( mdss_panel_is_power_off ( cur_power_state ) ) { mutex_lock ( & mfd -> bl_lock ) ; if ( ! mfd -> bl_updated ) { mfd -> bl_updated = 1 ; <S2SV_StartBug> mdss_fb_set_backlight ( mfd , mfd -> unset_bl_level ) ; <S2SV_EndBug> } mutex_unlock ( & mfd -> bl_lock ) ; } error : return ret ; }
|
<S2SV_ModStart> = 1 ; if ( ! IS_CALIB_MODE_BL ( mfd ) ) <S2SV_ModStart> mfd -> unset_bl_level ) ; else mdss_fb_set_backlight ( mfd , mfd -> calib_mode_bl
|
7,172 |
CWE-000 HTAB * hash_create ( const char * tabname , long nelem , HASHCTL * info , int flags ) { HTAB * hashp ; HASHHDR * hctl ; if ( flags & HASH_SHARED_MEM ) { CurrentDynaHashCxt = TopMemoryContext ; } else { if ( flags & HASH_CONTEXT ) CurrentDynaHashCxt = info -> hcxt ; else CurrentDynaHashCxt = TopMemoryContext ; CurrentDynaHashCxt = AllocSetContextCreate ( CurrentDynaHashCxt , tabname , ALLOCSET_DEFAULT_MINSIZE , ALLOCSET_DEFAULT_INITSIZE , ALLOCSET_DEFAULT_MAXSIZE ) ; } hashp = ( HTAB * ) DynaHashAlloc ( sizeof ( HTAB ) + strlen ( tabname ) + 1 ) ; MemSet ( hashp , 0 , sizeof ( HTAB ) ) ; hashp -> tabname = ( char * ) ( hashp + 1 ) ; strcpy ( hashp -> tabname , tabname ) ; if ( flags & HASH_FUNCTION ) hashp -> hash = info -> hash ; else hashp -> hash = string_hash ; if ( flags & HASH_COMPARE ) hashp -> match = info -> match ; else if ( hashp -> hash == string_hash ) hashp -> match = ( HashCompareFunc ) string_compare ; else hashp -> match = memcmp ; if ( flags & HASH_KEYCOPY ) hashp -> keycopy = info -> keycopy ; else if ( hashp -> hash == string_hash ) hashp -> keycopy = ( HashCopyFunc ) strlcpy ; else hashp -> keycopy = memcpy ; if ( flags & HASH_ALLOC ) hashp -> alloc = info -> alloc ; else hashp -> alloc = DynaHashAlloc ; if ( flags & HASH_SHARED_MEM ) { hashp -> hctl = info -> hctl ; hashp -> dir = ( HASHSEGMENT * ) ( ( ( char * ) info -> hctl ) + sizeof ( HASHHDR ) ) ; hashp -> hcxt = NULL ; hashp -> isshared = true ; if ( flags & HASH_ATTACH ) { hctl = hashp -> hctl ; hashp -> keysize = hctl -> keysize ; hashp -> ssize = hctl -> ssize ; hashp -> sshift = hctl -> sshift ; return hashp ; } } else { hashp -> hctl = NULL ; hashp -> dir = NULL ; hashp -> hcxt = CurrentDynaHashCxt ; hashp -> isshared = false ; } if ( ! hashp -> hctl ) { hashp -> hctl = ( HASHHDR * ) hashp -> alloc ( sizeof ( HASHHDR ) ) ; if ( ! hashp -> hctl ) ereport ( ERROR , ( errcode ( ERRCODE_OUT_OF_MEMORY ) , errmsg ( "out<S2SV_blank>of<S2SV_blank>memory" ) ) ) ; } hashp -> frozen = false ; hdefault ( hashp ) ; hctl = hashp -> hctl ; if ( flags & HASH_PARTITION ) { Assert ( flags & HASH_SHARED_MEM ) ; <S2SV_StartBug> Assert ( info -> num_partitions == ( 1L << my_log2 ( info -> num_partitions ) ) ) ; <S2SV_EndBug> hctl -> num_partitions = info -> num_partitions ; } if ( flags & HASH_SEGMENT ) { hctl -> ssize = info -> ssize ; hctl -> sshift = my_log2 ( info -> ssize ) ; Assert ( hctl -> ssize == ( 1L << hctl -> sshift ) ) ; } if ( flags & HASH_FFACTOR ) hctl -> ffactor = info -> ffactor ; if ( flags & HASH_DIRSIZE ) { hctl -> max_dsize = info -> max_dsize ; hctl -> dsize = info -> dsize ; } if ( flags & HASH_ELEM ) { Assert ( info -> entrysize >= info -> keysize ) ; hctl -> keysize = info -> keysize ; hctl -> entrysize = info -> entrysize ; } hashp -> keysize = hctl -> keysize ; hashp -> ssize = hctl -> ssize ; hashp -> sshift = hctl -> sshift ; if ( ! init_htab ( hashp , nelem ) ) elog ( ERROR , "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>hash<S2SV_blank>table<S2SV_blank>\\"%s\\"" , hashp -> tabname ) ; if ( ( flags & HASH_SHARED_MEM ) || nelem < hctl -> nelem_alloc ) { if ( ! element_alloc ( hashp , ( int ) nelem ) ) ereport ( ERROR , ( errcode ( ERRCODE_OUT_OF_MEMORY ) , errmsg ( "out<S2SV_blank>of<S2SV_blank>memory" ) ) ) ; } if ( flags & HASH_FIXED_SIZE ) hashp -> isfixed = true ; return hashp ; }
|
<S2SV_ModStart> -> num_partitions == next_pow2_int ( info -> num_partitions ) ) ; hctl -> num_partitions = info -> num_partitions ; } if ( flags & HASH_SEGMENT ) { hctl -> ssize = info -> ssize ; hctl -> sshift = my_log2 ( info -> ssize ) ; Assert ( hctl -> ssize == <S2SV_ModStart> ( 1L << <S2SV_ModEnd> hctl -> sshift
|
7,173 |
CWE-000 int thread_join ( int tid ) { if ( POLICY == FIFO ) { ucontext_t * mainContext = malloc ( sizeof ( ucontext_t ) ) ; <S2SV_StartBug> swapcontext ( mainContext , ( ( TCB * ) ( FIFOList -> tail -> TCB ) ) -> ucontext ) ; <S2SV_EndBug> } }
|
<S2SV_ModStart> ) ) ; getcontext ( mainContext ) ;
|
7,174 |
CWE-000 void initializeFilter ( ) { <S2SV_StartBug> arm_fir_init_q31 ( & fir , NUM_TAPS , & firCoefficients [ 0 ] , & firState [ 0 ] , BUFFER_SIZE ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ( ) { arm_biquad_cascade_df1_init_q31 ( & biquad , NUM_STAGES , & biquadCoefficients <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> ] , & biquadState <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> 0 ] , 0 <S2SV_ModEnd> ) ; }
|
7,175 |
CWE-000 void serial_process_input ( ) { if ( validate_rx_buffer ( ) != 0 ) { goto cleanup ; } switch ( rx_buffer [ PKT_TYPE ] ) { case PACKET_TYPE_START_HEARTBEAT : SF1_SET_BIT ( SF1_HB_ENABLE ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_STOP_HEARTBEAT : SF1_CLEAR_BIT ( SF1_HB_ENABLE ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_PING : serial_send_reply ( PACKET_TYPE_PONG ) ; break ; case PACKET_TYPE_REQUEST_STATUS : serial_send_status ( ) ; break ; case PACKET_TYPE_MANUAL : SF1_CLEAR_BIT ( SF1_AUTOMATED ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_AUTOMATIC : SF1_SET_BIT ( SF1_AUTOMATED ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_SYS_VERSION : serial_send_reply ( FLOWMASTER_VERSION ) ; break ; case PACKET_TYPE_ROTATE : SF1_SET_BIT ( SF1_ROTATE ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_NO_ROTATE : SF1_CLEAR_BIT ( SF1_ROTATE ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_BOOTLOADER : serial_call_bootloader ( ) ; break ; case PACKET_TYPE_SET_FAN : speed_set_fan ( rx_buffer [ 2 ] , rx_buffer [ 3 ] ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; case PACKET_TYPE_SET_PUMP : speed_set_pump ( rx_buffer [ 2 ] , rx_buffer [ 3 ] ) ; serial_send_reply ( PACKET_TYPE_ACK ) ; break ; <S2SV_StartBug> case PACKET_TYPE_GET_ADC : <S2SV_EndBug> serial_send_adc_value ( ) ; break ; default : serial_send_reply ( PACKET_TYPE_NAK ) ; break ; } cleanup : SF1_CLEAR_BIT ( SF1_RX_WAITING ) ; ENABLE_RX_INT ( ) ; RAISE_CTS ( ) ; }
|
<S2SV_ModStart> ; break ; <S2SV_ModEnd> default : serial_send_reply
|
7,176 |
CWE-000 <S2SV_StartBug> UTEST ( utf8lwr , latin_upper ) { <S2SV_EndBug> size_t sz ; void * str ; <S2SV_StartBug> sz = utf8size ( uppersStr ) ; <S2SV_EndBug> str = malloc ( sz ) ; <S2SV_StartBug> memcpy ( str , uppersStr , sz ) ; <S2SV_EndBug> utf8lwr ( str ) ; ASSERT_EQ ( 0 , utf8cmp ( str , lowersStr ) ) ; free ( str ) ; }
|
<S2SV_ModStart> ( utf8lwr , latin_lower <S2SV_ModEnd> ) { size_t <S2SV_ModStart> = utf8size ( lowersStr <S2SV_ModEnd> ) ; str <S2SV_ModStart> ( str , lowersStr <S2SV_ModEnd> , sz )
|
7,177 |
CWE-000 static void mono_domain_fire_assembly_load ( MonoAssembly * assembly , gpointer user_data ) <S2SV_StartBug> { <S2SV_EndBug> static MonoClassField * assembly_load_field ; static MonoMethod * assembly_load_method ; MonoError error ; MonoDomain * domain = mono_domain_get ( ) ; MonoClass * klass ; gpointer load_value ; void * params [ 1 ] ; if ( ! domain -> domain ) <S2SV_StartBug> return ; <S2SV_EndBug> # ifdef ASSEMBLY_LOAD_DEBUG fprintf ( stderr , "Loading<S2SV_blank>%s<S2SV_blank>into<S2SV_blank>domain<S2SV_blank>%s\\n" , assembly -> aname . name , domain -> friendly_name ) ; # endif klass = domain -> domain -> mbr . obj . vtable -> klass ; mono_domain_assemblies_lock ( domain ) ; add_assemblies_to_domain ( domain , assembly , NULL ) ; mono_domain_assemblies_unlock ( domain ) ; if ( assembly_load_field == NULL ) { assembly_load_field = mono_class_get_field_from_name ( klass , "AssemblyLoad" ) ; g_assert ( assembly_load_field ) ; } mono_field_get_value ( ( MonoObject * ) domain -> domain , assembly_load_field , & load_value ) ; if ( load_value == NULL ) { <S2SV_StartBug> return ; <S2SV_EndBug> } MonoReflectionAssemblyHandle ref_assembly = mono_assembly_get_object_handle ( domain , assembly , & error ) ; mono_error_assert_ok ( & error ) ; if ( assembly_load_method == NULL ) { assembly_load_method = mono_class_get_method_from_name ( klass , "DoAssemblyLoad" , - 1 ) ; g_assert ( assembly_load_method ) ; } * params = MONO_HANDLE_RAW ( ref_assembly ) ; mono_runtime_invoke_checked ( assembly_load_method , domain -> domain , params , & error ) ; mono_error_cleanup ( & error ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> user_data ) { HANDLE_FUNCTION_ENTER ( ) ; <S2SV_ModStart> -> domain ) goto leave <S2SV_ModEnd> ; # ifdef <S2SV_ModStart> NULL ) { goto leave <S2SV_ModEnd> ; } MonoReflectionAssemblyHandle <S2SV_ModStart> error ) ; leave : HANDLE_FUNCTION_RETURN ( ) ;
|
7,178 |
CWE-000 static gboolean gs_plugin_refine_item_metadata ( GsFlatpak * self , GsApp * app , GCancellable * cancellable , GError * * error ) { const gchar * str ; gsize len = 0 ; g_autofree gchar * contents = NULL ; g_autofree gchar * installation_path_str = NULL ; g_autofree gchar * install_path = NULL ; g_autoptr ( AsProfileTask ) ptask = NULL ; g_autoptr ( GBytes ) data = NULL ; g_autoptr ( GFile ) installation_path = NULL ; ptask = as_profile_start ( gs_plugin_get_profile ( self -> plugin ) , "flatpak::refine-metadata{%s}" , gs_app_get_id ( app ) ) ; g_assert ( ptask != NULL ) ; if ( gs_app_get_kind ( app ) == AS_APP_KIND_SOURCE ) return TRUE ; if ( gs_app_get_flatpak_kind ( app ) != FLATPAK_REF_KIND_APP ) return TRUE ; if ( gs_app_has_kudo ( app , GS_APP_KUDO_SANDBOXED ) ) return TRUE ; installation_path = flatpak_installation_get_path ( self -> installation ) ; installation_path_str = g_file_get_path ( installation_path ) ; install_path = g_build_filename ( installation_path_str , gs_app_get_flatpak_kind_as_str ( app ) , gs_app_get_flatpak_name ( app ) , gs_app_get_flatpak_arch ( app ) , gs_app_get_flatpak_branch ( app ) , "active" , "metadata" , NULL ) ; if ( g_file_test ( install_path , G_FILE_TEST_EXISTS ) ) { if ( ! g_file_get_contents ( install_path , & contents , & len , error ) ) return FALSE ; str = contents ; } else { data = gs_flatpak_fetch_remote_metadata ( self , app , cancellable , error ) ; <S2SV_StartBug> str = g_bytes_get_data ( data , & len ) ; <S2SV_EndBug> } if ( ! gs_flatpak_set_app_metadata ( self , app , str , len , error ) ) return FALSE ; return TRUE ; }
|
<S2SV_ModStart> error ) ; if ( data == NULL ) return FALSE ;
|
7,179 |
CWE-000 static int test_ss_tolower ( const char * a , const char * b ) { srt_string * sa = ss_dup_c ( a ) ; <S2SV_StartBug> int res = ! sa ? 1 : ( srt_stringolower ( & sa ) ? 0 : 2 ) | <S2SV_EndBug> ( ! strcmp ( ss_to_c ( sa ) , b ) ? 0 : 4 ) ; ss_free ( & sa ) ; return res ; }
|
<S2SV_ModStart> 1 : ( ss_tolower <S2SV_ModEnd> ( & sa
|
7,180 |
CWE-000 void atcmd_start ( void ) { at_serial_para_t para ; at_cmd_init ( ) ; at_serial ( & para ) ; serial_init ( SERIAL_UART_ID , para . baudrate , UART_DATA_BITS_8 , UART_PARITY_NONE , UART_STOP_BITS_1 , para . hwfc ) ; serial_start ( ) ; if ( OS_ThreadCreate ( & g_atcmd_thread , <S2SV_StartBug> "" , <S2SV_EndBug> atcmd_task , NULL , OS_THREAD_PRIO_CONSOLE , ATCMD_THREAD_STACK_SIZE ) != OS_OK ) { ATCMD_ERR ( "create<S2SV_blank>serial<S2SV_blank>task<S2SV_blank>failed\\n" ) ; return ; } }
|
<S2SV_ModStart> & g_atcmd_thread , "atcmd" <S2SV_ModEnd> , atcmd_task ,
|
7,181 |
CWE-000 static void coda_buf_queue ( struct vb2_buffer * vb ) { struct vb2_v4l2_buffer * vbuf = to_vb2_v4l2_buffer ( vb ) ; struct coda_ctx * ctx = vb2_get_drv_priv ( vb -> vb2_queue ) ; struct vb2_queue * vq = vb -> vb2_queue ; struct coda_q_data * q_data ; q_data = get_q_data ( ctx , vb -> vb2_queue -> type ) ; if ( ctx -> bitstream . size && vq -> type == V4L2_BUF_TYPE_VIDEO_OUTPUT ) { if ( vb2_get_plane_payload ( vb , 0 ) == 0 ) coda_bit_stream_end_flag ( ctx ) ; <S2SV_StartBug> mutex_lock ( & ctx -> bitstream_mutex ) ; <S2SV_EndBug> v4l2_m2m_buf_queue ( ctx -> fh . m2m_ctx , vbuf ) ; if ( vb2_is_streaming ( vb -> vb2_queue ) ) coda_fill_bitstream ( ctx , NULL ) ; mutex_unlock ( & ctx -> bitstream_mutex ) ; } else { if ( ctx -> inst_type == CODA_INST_ENCODER && vq -> type == V4L2_BUF_TYPE_VIDEO_OUTPUT ) vbuf -> sequence = ctx -> qsequence ++ ; v4l2_m2m_buf_queue ( ctx -> fh . m2m_ctx , vbuf ) ; } }
|
<S2SV_ModStart> ctx ) ; if ( q_data -> fourcc == V4L2_PIX_FMT_H264 ) { if ( ! ctx -> params . h264_profile_idc ) coda_sps_parse_profile ( ctx , vb ) ; }
|
7,182 |
CWE-000 <S2SV_StartBug> static void ft_print_owner_and_group ( struct stat status , int usr_indent , int grg_indent ) <S2SV_EndBug> { struct passwd * user_id ; <S2SV_StartBug> struct group * group_id ; <S2SV_EndBug> user_id = getpwuid ( status . st_uid ) ; group_id = getgrgid ( status . st_gid ) ; ft_printf ( "%-*s" , usr_indent , user_id -> pw_name ) ; ft_printf ( "<S2SV_blank><S2SV_blank>%-*s" , grg_indent , group_id -> gr_name ) ; }
|
<S2SV_ModStart> , int grg_indent , int link_width <S2SV_ModStart> group * group_id ; ft_printf ( "<S2SV_blank>%*u<S2SV_blank>" , link_width + 1 , status . st_nlink )
|
7,183 |
CWE-000 void timer_ten_ms_init ( ) { cli ( ) ; TCCR0A = 0x02 ; TCCR0B = 0x05 ; OCR0A = 0xC2 ; TIMSK0 |= 0x02 ; sei ( ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ( ) ; twenty_ms_counter = 0 ;
|
7,184 |
CWE-000 void subtilis_fpa_gen_callr ( subtilis_ir_section_t * s , size_t start , void * user_data , subtilis_error_t * err ) { subtilis_arm_reg_t dest ; subtilis_arm_reg_t op1 ; subtilis_arm_section_t * arm_s = user_data ; subtilis_ir_call_t * call = & s -> ops [ start ] -> op . call ; subtilis_arm_gen_call ( s , start , user_data , err ) ; if ( err -> type != SUBTILIS_ERROR_OK ) return ; <S2SV_StartBug> dest . num = call -> reg ; <S2SV_EndBug> dest . type = SUBTILIS_ARM_REG_FLOATING ; op1 . num = 0 ; op1 . type = SUBTILIS_ARM_REG_FIXED ; subtilis_fpa_add_mov ( arm_s , SUBTILIS_ARM_CCODE_AL , SUBTILIS_FPA_ROUNDING_NEAREST , dest , op1 , err ) ; }
|
<S2SV_ModStart> return ; dest = subtilis_arm_ir_to_freg ( <S2SV_ModEnd> call -> reg <S2SV_ModStart> call -> reg ) <S2SV_ModEnd> ; op1 .
|
7,185 |
CWE-000 static int esp_apptrace_safe_halt_targets ( struct esp_apptrace_cmd_ctx * ctx , struct esp108_apptrace_target_state * targets ) { int res = ERROR_OK ; memset ( targets , 0 , ctx -> cores_num * sizeof ( struct esp108_apptrace_target_state ) ) ; LOG_DEBUG ( "Halt<S2SV_blank>all<S2SV_blank>targets!" ) ; if ( ctx -> esp32_target ) { <S2SV_StartBug> res = target_halt ( ctx -> esp32_target ) ; <S2SV_EndBug> if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>halt<S2SV_blank>target<S2SV_blank>(%d)!" , res ) ; return res ; } res = target_wait_state ( ctx -> esp32_target , TARGET_HALTED , ESP_APPTRACE_TGT_STATE_TMO ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>halt<S2SV_blank>target<S2SV_blank>%s<S2SV_blank>/<S2SV_blank>%d<S2SV_blank>(%d)!" , target_name ( ctx -> esp32_target ) , ctx -> esp32_target -> state , res ) ; return res ; } <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> for ( int k = 0 ; k < ctx -> cores_num ; k ++ ) { <S2SV_EndBug> targets [ k ] . running = 1 ; res = target_halt ( ctx -> cpus [ k ] ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>halt<S2SV_blank>target%d<S2SV_blank>(%d)!" , k , res ) ; return res ; } res = target_wait_state ( ctx -> cpus [ k ] , TARGET_HALTED , ESP_APPTRACE_TGT_STATE_TMO ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>halt<S2SV_blank>target<S2SV_blank>%s<S2SV_blank>/<S2SV_blank>%d<S2SV_blank>(%d)!" , target_name ( ctx -> cpus [ k ] ) , ctx -> cpus [ k ] -> state , res ) ; return res ; } } } LOG_DEBUG ( "Read<S2SV_blank>current<S2SV_blank>block<S2SV_blank>statuses" ) ; for ( int k = 0 ; k < ctx -> cores_num ; k ++ ) { uint32_t stat ; res = esp108_apptrace_read_status ( ctx -> cpus [ k ] , & stat ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>trace<S2SV_blank>status<S2SV_blank>(%d)!" , res ) ; return res ; } if ( stat ) { res = esp108_activate_swdbg ( ctx -> cpus [ k ] , 1 ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>activate<S2SV_blank>SW<S2SV_blank>debug<S2SV_blank>(%d)!" , res ) ; return res ; } uint32_t bp_addr = stat ; res = breakpoint_add ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , bp_addr , 1 , BKPT_HARD ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>breakpoint<S2SV_blank>(%d)!" , res ) ; return res ; } while ( stat ) { res = target_resume ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , 1 , 0 , 1 , 0 ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>resume<S2SV_blank>target<S2SV_blank>(%d)!" , res ) ; breakpoint_remove ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , bp_addr ) ; return res ; } enum target_debug_reason debug_reason = DBG_REASON_UNDEFINED ; while ( debug_reason != DBG_REASON_BREAKPOINT ) { res = target_wait_state ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , TARGET_HALTED , ESP_APPTRACE_TGT_STATE_TMO ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>halt<S2SV_blank>on<S2SV_blank>bp<S2SV_blank>target<S2SV_blank>(%d)!" , res ) ; breakpoint_remove ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , bp_addr ) ; return res ; } debug_reason = ctx -> esp32_target ? ctx -> esp32_target -> debug_reason : ctx -> cpus [ k ] -> debug_reason ; } res = esp108_apptrace_read_status ( ctx -> cpus [ k ] , & stat ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>trace<S2SV_blank>status<S2SV_blank>(%d)!" , res ) ; breakpoint_remove ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , bp_addr ) ; return res ; } } breakpoint_remove ( ctx -> esp32_target ? ctx -> esp32_target : ctx -> cpus [ k ] , bp_addr ) ; res = esp108_activate_swdbg ( ctx -> cpus [ k ] , 0 ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>de-activate<S2SV_blank>SW<S2SV_blank>debug<S2SV_blank>(%d)!" , res ) ; return res ; } } res = esp108_apptrace_read_data_len ( ctx -> cpus [ k ] , & targets [ k ] . block_id , & targets [ k ] . data_len ) ; if ( res != ERROR_OK ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>trace<S2SV_blank>status<S2SV_blank>(%d)!" , res ) ; return res ; } } return ERROR_OK ; }
|
<S2SV_ModStart> esp32_target ) { if ( ctx -> esp32_target -> state != TARGET_HALTED ) { <S2SV_ModStart> ; } } } <S2SV_ModStart> ++ ) { if ( ctx -> cpus [ k ] -> state == TARGET_HALTED ) { targets [ k ] . running = 0 ; continue ; }
|
7,186 |
CWE-000 void SV_Init ( quakeparms_t * parms ) { if ( isDedicated ) { COM_InitArgv ( parms -> argc , parms -> argv ) ; host_parms = * parms ; Cvar_Init ( ) ; Memory_Init ( ) ; Sys_Init ( ) ; COM_ParsePlusSets ( false ) ; Cbuf_Init ( ) ; Cmd_Init ( ) ; # ifndef SERVERONLY R_SetRenderer ( NULL ) ; # endif NET_Init ( ) ; COM_Init ( ) ; <S2SV_StartBug> # ifdef Q2BSPS <S2SV_EndBug> CM_Init ( ) ; # endif # ifdef TERRAIN Terr_Init ( ) ; # endif Mod_Init ( true ) ; Mod_Init ( false ) ; PF_Common_RegisterCvars ( ) ; } else { # if defined ( SERVERONLY ) || ! ( defined ( CSQC_DAT ) || defined ( MENU_DAT ) ) PF_Common_RegisterCvars ( ) ; # endif } PR_Init ( ) ; SV_InitNet ( ) ; SV_InitLocal ( ) ; # ifdef WEBSERVER IWebInit ( ) ; # endif # ifdef SERVER_DEMO_PLAYBACK SV_Demo_Init ( ) ; # endif # ifdef SVRANKING Rank_RegisterCommands ( ) ; # endif # ifndef SERVERONLY if ( isDedicated ) # endif { int manarg ; PM_Init ( ) ; # ifdef PLUGINS Plug_Initialise ( true ) ; # endif Cvar_ParseWatches ( ) ; host_initialized = true ; manarg = COM_CheckParm ( "-manifest" ) ; if ( manarg && manarg < com_argc - 1 && com_argv [ manarg + 1 ] ) { char * man = FS_MallocFile ( com_argv [ manarg + 1 ] , FS_SYSTEM , NULL ) ; FS_ChangeGame ( FS_Manifest_Parse ( NULL , man ) , true , true ) ; BZ_Free ( man ) ; } else FS_ChangeGame ( NULL , true , true ) ; Cmd_StuffCmds ( ) ; Cbuf_Execute ( ) ; Con_TPrintf ( "Exe:<S2SV_blank>%s<S2SV_blank>%s\\n" , __DATE__ , __TIME__ ) ; Con_Printf ( "%s\\n" , version_string ( ) ) ; Con_TPrintf ( "========<S2SV_blank>%s<S2SV_blank>Initialized<S2SV_blank>========\\n" , * fs_gamename . string ? fs_gamename . string : "Nothing" ) ; # ifdef SUBSERVERS if ( SSV_IsSubServer ( ) ) { NET_InitServer ( ) ; return ; } # endif IPLog_Merge_File ( "iplog.txt" ) ; IPLog_Merge_File ( "iplog.dat" ) ; if ( sv . state == ss_dead && Cmd_AliasExist ( "startmap_dm" , RESTRICT_LOCAL ) ) { Cbuf_AddText ( "startmap_dm" , RESTRICT_LOCAL ) ; Cbuf_Execute ( ) ; } if ( sv . state == ss_dead && Cmd_AliasExist ( "startmap_sp" , RESTRICT_LOCAL ) ) { Cbuf_AddText ( "startmap_sp" , RESTRICT_LOCAL ) ; Cbuf_Execute ( ) ; } if ( sv . state == ss_dead && COM_FCheckExists ( "maps/start.bsp" ) ) Cmd_ExecuteString ( "map<S2SV_blank>start" , RESTRICT_LOCAL ) ; # ifdef HEXEN2 if ( sv . state == ss_dead && COM_FCheckExists ( "maps/demo1.bsp" ) ) Cmd_ExecuteString ( "map<S2SV_blank>demo1" , RESTRICT_LOCAL ) ; # endif # ifdef Q2SERVER if ( sv . state == ss_dead && COM_FCheckExists ( "maps/base1.bsp" ) ) Cmd_ExecuteString ( "map<S2SV_blank>base1" , RESTRICT_LOCAL ) ; # endif # ifdef Q3SERVER if ( sv . state == ss_dead && COM_FCheckExists ( "maps/q3dm1.bsp" ) ) Cmd_ExecuteString ( "map<S2SV_blank>q3dm1" , RESTRICT_LOCAL ) ; # endif # ifdef HLSERVER if ( sv . state == ss_dead && COM_FCheckExists ( "maps/c0a0.bsp" ) ) Cmd_ExecuteString ( "map<S2SV_blank>c0a0" , RESTRICT_LOCAL ) ; # endif if ( sv . state == ss_dead ) { Cmd_ExecuteString ( "path" , RESTRICT_LOCAL ) ; SV_Error ( "Couldn\'t<S2SV_blank>load<S2SV_blank>a<S2SV_blank>map.<S2SV_blank>You<S2SV_blank>may<S2SV_blank>need<S2SV_blank>to<S2SV_blank>use<S2SV_blank>the<S2SV_blank>-basedir<S2SV_blank>argument." ) ; } } }
|
<S2SV_ModStart> ) ; # if defined ( Q2BSPS ) || defined ( Q3BSPS ) <S2SV_ModEnd> CM_Init ( )
|
7,187 |
CWE-000 void add_dir_entry_to_block ( struct ext2_inode * dir_inode , unsigned int inode , unsigned char file_type , char * name ) { int req_space = PAD ( 8 + ( int ) strlen ( name ) ) ; <S2SV_StartBug> long parsed_args [ 5 ] = { req_space , inode , 0 , file_type , ( intptr_t ) name } ; <S2SV_EndBug> int res = directory_block_iterator ( dir_inode , add_dir_entry , 5 , parsed_args ) ; if ( res == 0 ) { if ( IBLOCKS ( dir_inode ) >= MAX12 ) { fprintf ( stderr , "Not<S2SV_blank>enough<S2SV_blank>block<S2SV_blank>space<S2SV_blank>in<S2SV_blank>directory<S2SV_blank>entry." ) ; exit ( 1 ) ; } unsigned int nblock_num = find_free_block ( ) ; struct block * nblock = ( struct block * ) BLOCK ( nblock_num ) ; struct ext2_dir_entry_2 * dir = ( struct ext2_dir_entry_2 * ) nblock ; set_dir_entry ( dir , inode , EXT2_BLOCK_SIZE , file_type , name ) ; add_block_to_inode ( dir_inode , nblock_num ) ; } }
|
<S2SV_ModStart> req_space , inode <S2SV_ModEnd> , file_type ,
|
7,188 |
CWE-000 static YfsStatus yfs_dir_buildEntry ( const ydir * dir , yentry * entry ) { if ( YFS_NO_ENTRY ( dir ) ) { return YFS_STATUS_NO_FILE ; } size_t path_len = strlen ( dir -> path ) + strlen ( YFS_FILE_NAME ( dir ) ) + 1 + YFS_PATH_EXTRA ; if ( path_len >= YFS_PATH_MAX ) { return YFS_STATUS_NAME_TOO_LONG ; } if ( strlen ( YFS_FILE_NAME ( dir ) ) >= YFS_FILENAME_MAX ) { return YFS_STATUS_NAME_TOO_LONG ; } ychar_t path_buf [ path_len ] ; yfs_path_concat ( path_buf , dir -> path , YFS_FILE_NAME ( dir ) ) ; if ( yerror ( ystat ( path_buf , & ( entry -> s ) ) == - 1 ) ) { return YFS_STATUS_IO_ERR ; } <S2SV_StartBug> entry -> extIdx = yfs_path_extIdx ( entry -> name ) ; <S2SV_EndBug> strcpy ( entry -> name , YFS_FILE_NAME ( dir ) ) ; entry -> is_dir = YFS_ISDIR ( dir , entry ) ? true : false ; entry -> is_file = YFS_ISREG ( dir , entry ) ? true : false ; return YFS_STATUS_SUCCESS ; }
|
<S2SV_ModStart> YFS_STATUS_IO_ERR ; } strcpy ( entry -> name , YFS_FILE_NAME ( dir ) ) ; <S2SV_ModStart> entry -> name <S2SV_ModEnd> ) ; entry
|
7,189 |
CWE-000 static grub_err_t tftp_open ( struct grub_file * file , const char * filename ) { struct tftphdr * tftph ; char * rrq ; int i ; int rrqlen ; int hdrlen ; grub_uint8_t open_data [ 1500 ] ; struct grub_net_buff nb ; tftp_data_t data ; grub_err_t err ; grub_uint8_t * nbd ; grub_net_network_level_address_t addr ; data = grub_zalloc ( sizeof ( * data ) ) ; if ( ! data ) return grub_errno ; nb . head = open_data ; nb . end = open_data + sizeof ( open_data ) ; grub_netbuff_clear ( & nb ) ; grub_netbuff_reserve ( & nb , 1500 ) ; err = grub_netbuff_push ( & nb , sizeof ( * tftph ) ) ; if ( err ) { grub_free ( data ) ; return err ; } tftph = ( struct tftphdr * ) nb . data ; rrq = ( char * ) tftph -> u . rrq ; rrqlen = 0 ; tftph -> opcode = grub_cpu_to_be16_compile_time ( TFTP_RRQ ) ; <S2SV_StartBug> grub_strcpy ( rrq , filename ) ; <S2SV_EndBug> <S2SV_StartBug> rrqlen += grub_strlen ( filename ) + 1 ; <S2SV_EndBug> rrq += grub_strlen ( filename ) + 1 ; grub_strcpy ( rrq , "octet" ) ; rrqlen += grub_strlen ( "octet" ) + 1 ; rrq += grub_strlen ( "octet" ) + 1 ; grub_strcpy ( rrq , "blksize" ) ; rrqlen += grub_strlen ( "blksize" ) + 1 ; rrq += grub_strlen ( "blksize" ) + 1 ; grub_strcpy ( rrq , "1024" ) ; rrqlen += grub_strlen ( "1024" ) + 1 ; rrq += grub_strlen ( "1024" ) + 1 ; grub_strcpy ( rrq , "tsize" ) ; rrqlen += grub_strlen ( "tsize" ) + 1 ; rrq += grub_strlen ( "tsize" ) + 1 ; grub_strcpy ( rrq , "0" ) ; rrqlen += grub_strlen ( "0" ) + 1 ; rrq += grub_strlen ( "0" ) + 1 ; hdrlen = sizeof ( tftph -> opcode ) + rrqlen ; err = grub_netbuff_unput ( & nb , nb . tail - ( nb . data + hdrlen ) ) ; if ( err ) { grub_free ( data ) ; return err ; } file -> not_easily_seekable = 1 ; file -> data = data ; data -> pq = grub_priority_queue_new ( sizeof ( struct grub_net_buff * ) , cmp ) ; if ( ! data -> pq ) { grub_free ( data ) ; return grub_errno ; } err = grub_net_resolve_address ( file -> device -> net -> server , & addr ) ; if ( err ) { destroy_pq ( data ) ; grub_free ( data ) ; return err ; } data -> sock = grub_net_udp_open ( addr , TFTP_SERVER_PORT , tftp_receive , file ) ; if ( ! data -> sock ) { destroy_pq ( data ) ; grub_free ( data ) ; return grub_errno ; } nbd = nb . data ; for ( i = 0 ; i < GRUB_NET_TRIES ; i ++ ) { nb . data = nbd ; err = grub_net_send_udp_packet ( data -> sock , & nb ) ; if ( err ) { grub_net_udp_close ( data -> sock ) ; destroy_pq ( data ) ; grub_free ( data ) ; return err ; } grub_net_poll_cards ( GRUB_NET_INTERVAL + ( i * GRUB_NET_INTERVAL_ADDITION ) , & data -> have_oack ) ; if ( data -> have_oack ) break ; } if ( ! data -> have_oack ) grub_error ( GRUB_ERR_TIMEOUT , N_ ( "time<S2SV_blank>out<S2SV_blank>opening<S2SV_blank>`%s\'" ) , filename ) ; else grub_error_load ( & data -> save_err ) ; if ( grub_errno ) { grub_net_udp_close ( data -> sock ) ; destroy_pq ( data ) ; grub_free ( data ) ; return grub_errno ; } file -> size = data -> file_size ; return GRUB_ERR_NONE ; }
|
<S2SV_ModStart> TFTP_RRQ ) ; grub_normalize_filename <S2SV_ModEnd> ( rrq , <S2SV_ModStart> += grub_strlen ( rrq ) + 1 ; rrq += grub_strlen ( rrq <S2SV_ModEnd> ) + 1
|
7,190 |
CWE-000 int iscsi_target_rx_thread ( void * arg ) { int ret , rc ; u8 buffer [ ISCSI_HDR_LEN ] , opcode ; u32 checksum = 0 , digest = 0 ; struct iscsi_conn * conn = arg ; struct kvec iov ; allow_signal ( SIGINT ) ; rc = wait_for_completion_interruptible ( & conn -> rx_login_comp ) ; <S2SV_StartBug> if ( rc < 0 ) <S2SV_EndBug> return 0 ; if ( conn -> conn_transport -> transport_type == ISCSI_INFINIBAND ) { struct completion comp ; init_completion ( & comp ) ; rc = wait_for_completion_interruptible ( & comp ) ; if ( rc < 0 ) goto transport_err ; goto transport_err ; } while ( ! kthread_should_stop ( ) ) { iscsit_thread_check_cpumask ( conn , current , 0 ) ; memset ( buffer , 0 , ISCSI_HDR_LEN ) ; memset ( & iov , 0 , sizeof ( struct kvec ) ) ; iov . iov_base = buffer ; iov . iov_len = ISCSI_HDR_LEN ; ret = rx_data ( conn , & iov , 1 , ISCSI_HDR_LEN ) ; if ( ret != ISCSI_HDR_LEN ) { iscsit_rx_thread_wait_for_tcp ( conn ) ; goto transport_err ; } if ( conn -> conn_ops -> HeaderDigest ) { iov . iov_base = & digest ; iov . iov_len = ISCSI_CRC_LEN ; ret = rx_data ( conn , & iov , 1 , ISCSI_CRC_LEN ) ; if ( ret != ISCSI_CRC_LEN ) { iscsit_rx_thread_wait_for_tcp ( conn ) ; goto transport_err ; } iscsit_do_crypto_hash_buf ( & conn -> conn_rx_hash , buffer , ISCSI_HDR_LEN , 0 , NULL , ( u8 * ) & checksum ) ; if ( digest != checksum ) { pr_err ( "HeaderDigest<S2SV_blank>CRC32C<S2SV_blank>failed," "<S2SV_blank>received<S2SV_blank>0x%08x,<S2SV_blank>computed<S2SV_blank>0x%08x\\n" , digest , checksum ) ; memset ( buffer , 0xff , ISCSI_HDR_LEN ) ; atomic_long_inc ( & conn -> sess -> conn_digest_errors ) ; } else { pr_debug ( "Got<S2SV_blank>HeaderDigest<S2SV_blank>CRC32C" "<S2SV_blank>0x%08x\\n" , checksum ) ; } } if ( conn -> conn_state == TARG_CONN_STATE_IN_LOGOUT ) goto transport_err ; opcode = buffer [ 0 ] & ISCSI_OPCODE_MASK ; if ( conn -> sess -> sess_ops -> SessionType && ( ( ! ( opcode & ISCSI_OP_TEXT ) ) || ( ! ( opcode & ISCSI_OP_LOGOUT ) ) ) ) { pr_err ( "Received<S2SV_blank>illegal<S2SV_blank>iSCSI<S2SV_blank>Opcode:<S2SV_blank>0x%02x" "<S2SV_blank>while<S2SV_blank>in<S2SV_blank>Discovery<S2SV_blank>Session,<S2SV_blank>rejecting.\\n" , opcode ) ; iscsit_add_reject ( conn , ISCSI_REASON_PROTOCOL_ERROR , buffer ) ; goto transport_err ; } ret = iscsi_target_rx_opcode ( conn , buffer ) ; if ( ret < 0 ) goto transport_err ; } transport_err : if ( ! signal_pending ( current ) ) atomic_set ( & conn -> transport_failed , 1 ) ; iscsit_take_action_for_connection_exit ( conn ) ; return 0 ; }
|
<S2SV_ModStart> rc < 0 || iscsi_target_check_conn_state ( conn )
|
7,191 |
CWE-000 void ShadowMap_Render ( ShadowMap * sm , PassFrameParams * cameraPFP , Vector * lightPos ) { PassDrawParams * cameraPDP = cameraPFP -> dp ; PassFrameParams smPFP ; PassDrawParams smPDP ; smPFP . dp = & smPDP ; Vector lpos ; Vector ldir ; Vector lcenter = { 120 , 120 , 0 } ; Matrix m_wv = IDENT_MATRIX ; Matrix m_vp = IDENT_MATRIX ; Matrix m_wp = IDENT_MATRIX ; Matrix m_wv_inv ; Matrix m_vp_inv ; Matrix m_wp_inv ; <S2SV_StartBug> mPerspective ( 60 , 1 , sm -> clipPlanes . x , sm -> clipPlanes . y , & m_vp ) ; <S2SV_EndBug> double time = cameraPDP -> timeSeconds + cameraPDP -> timeFractional ; <S2SV_StartBug> float zoom = ( fabs ( sin ( fmod ( time , 6.28 ) ) ) * 20 ) + 10 ; <S2SV_EndBug> <S2SV_StartBug> float lrot = - 3.14 / 3 ; <S2SV_EndBug> zoom = - 150 ; mTrans3f ( 0 , - 1 , zoom , & m_wv ) ; <S2SV_StartBug> mRot3f ( 1 , 0 , 0 , F_PI / 3 , & m_wv ) ; <S2SV_EndBug> mRot3f ( 0 , 1 , 0 , lrot , & m_wv ) ; mTrans3f ( - lcenter . x , 0 , - lcenter . y , & m_wv ) ; mRot3f ( 1 , 0 , 0 , F_PI_2 , & m_wv ) ; mScale3f ( 1 , 1 , - 1 , & m_wv ) ; mFastMul ( & m_wv , & m_vp , & m_wp ) ; sm -> mWorldLight = m_wp ; mInverse ( & m_wv , & m_wv_inv ) ; mInverse ( & m_vp , & m_vp_inv ) ; mInverse ( & m_wp , & m_wp_inv ) ; smPDP . mWorldView = & m_wv ; smPDP . mViewProj = & m_vp ; smPDP . mWorldProj = & m_wp ; smPDP . mViewWorld = & m_wv_inv ; smPDP . mProjView = & m_vp_inv ; smPDP . mProjWorld = & m_wp_inv ; smPDP . eyeVec = ldir ; smPDP . eyePos = lpos ; smPDP . targetSize = sm -> size ; smPDP . timeSeconds = cameraPDP -> timeSeconds ; smPDP . timeFractional = cameraPDP -> timeFractional ; glViewport ( 0 , 0 , sm -> size . x , sm -> size . y ) ; RenderPipeline_renderAll ( sm -> rpipe , & smPFP ) ; }
|
<S2SV_ModStart> Matrix m_wp_inv ; mOrtho ( - 100 , 100 , 100 , - 100 <S2SV_ModEnd> , sm -> <S2SV_ModStart> ) ) * - 100 ) - 150 <S2SV_ModEnd> ; float lrot <S2SV_ModStart> - 3.14 / 2 <S2SV_ModEnd> ; zoom = <S2SV_ModStart> , F_PI / 6 <S2SV_ModEnd> , & m_wv
|
7,192 |
CWE-000 void trace_printf ( int hdr , const char * fmt , ... ) { if ( ! get_tracing_enabled ( ) ) return ; <S2SV_StartBug> int old_tracing_enabled = set_tracing_enabled ( 0 ) ; <S2SV_EndBug> real_getpid = RETRACE_GET_REAL ( getpid ) ; char str [ 1024 ] ; if ( hdr == 1 ) { rtr_getpid_t getpid_ = RETRACE_GET_REAL ( getpid ) ; fprintf ( stderr , "(%d)<S2SV_blank>" , getpid_ ( ) ) ; } va_list arglist ; va_start ( arglist , fmt ) ; <S2SV_StartBug> vsnprintf ( str , sizeof ( str ) , fmt , arglist ) ; <S2SV_EndBug> va_end ( arglist ) ; fputs ( str , stderr ) ; set_tracing_enabled ( old_tracing_enabled ) ; }
|
<S2SV_ModStart> set_tracing_enabled ( 0 <S2SV_ModEnd> ) ; char <S2SV_ModStart> fmt ) ; rtr_vsnprintf_t vsnprintf_ = RETRACE_GET_REAL ( vsnprintf ) ; vsnprintf_ <S2SV_ModEnd> ( str ,
|
7,193 |
CWE-000 void grabber_xinput_loop ( Grabber * self , Configuration * conf ) { XEvent ev ; grabber_xinput_open_devices ( self ) ; grabbing_xinput_grab_start ( self ) ; while ( ! self -> shut_down ) { XNextEvent ( self -> dpy , & ev ) ; if ( ev . xcookie . type == GenericEvent && ev . xcookie . extension == self -> opcode && XGetEventData ( self -> dpy , & ev . xcookie ) ) { XIDeviceEvent * data = NULL ; switch ( ev . xcookie . evtype ) { case XI_Motion : data = ( XIDeviceEvent * ) ev . xcookie . data ; grabbing_update_movement ( self , data -> root_x , data -> root_y ) ; break ; case XI_ButtonPress : data = ( XIDeviceEvent * ) ev . xcookie . data ; grabbing_start_movement ( self , data -> root_x , data -> root_y ) ; break ; case XI_ButtonRelease : data = ( XIDeviceEvent * ) ev . xcookie . data ; <S2SV_StartBug> char * device_name = "" ; <S2SV_EndBug> int ndevices ; XIDeviceInfo * device ; XIDeviceInfo * devices ; <S2SV_StartBug> devices = XIQueryDevice ( self -> dpy , data -> deviceid , & ndevices ) ; <S2SV_EndBug> if ( ndevices == 1 ) { device = & devices [ 0 ] ; device_name = strdup ( device -> name ) ; } grabbing_xinput_grab_stop ( self ) ; grabbing_end_movement ( self , data -> root_x , data -> root_y , device_name , conf ) ; grabbing_xinput_grab_start ( self ) ; break ; } } XFreeEventData ( self -> dpy , & ev . xcookie ) ; } }
|
<S2SV_ModStart> * device_name = get_device_name_from_event ( self , data ) ; grabbing_xinput_grab_stop ( self ) ; grabbing_end_movement ( self , data -> root_x , data -> root_y , device_name , conf ) ; grabbing_xinput_grab_start ( self ) ; break ; } } XFreeEventData <S2SV_ModEnd> ( self -> <S2SV_ModStart> -> dpy , & <S2SV_ModEnd> ev . xcookie
|
7,194 |
CWE-000 static struct kvsroot * getroot ( kvs_ctx_t * ctx , const char * namespace , flux_msg_handler_t * mh , const flux_msg_t * msg , <S2SV_StartBug> flux_msg_handler_f cb , <S2SV_EndBug> bool * stall ) { <S2SV_StartBug> struct kvsroot * root ; <S2SV_EndBug> blobref_t rootref ; int rootseq , flags ; ( * stall ) = false ; if ( ! ( root = kvsroot_mgr_lookup_root_safe ( ctx -> krm , namespace ) ) ) { if ( ctx -> rank == 0 ) { errno = ENOTSUP ; return NULL ; } else { <S2SV_StartBug> if ( getroot_request_send ( ctx , namespace , mh , msg , cb , <S2SV_EndBug> & rootseq , rootref , & flags ) < 0 ) { flux_log_error ( ctx -> h , "getroot_request_send" ) ; return NULL ; } ( * stall ) = true ; return NULL ; } } if ( check_user ( ctx , root , msg ) < 0 ) return NULL ; return root ; }
|
<S2SV_ModStart> * msg , void * arg , <S2SV_ModStart> kvsroot * root <S2SV_ModEnd> ; ( * <S2SV_ModStart> , msg , arg , cb <S2SV_ModEnd> ) < 0
|
7,195 |
CWE-000 static int mcopy_atomic_pte ( struct mm_struct * dst_mm , pmd_t * dst_pmd , struct vm_area_struct * dst_vma , unsigned long dst_addr , unsigned long src_addr , struct page * * pagep , bool wp_copy ) { struct mem_cgroup * memcg ; pte_t _dst_pte , * dst_pte ; spinlock_t * ptl ; void * page_kaddr ; int ret ; struct page * page ; if ( ! * pagep ) { ret = - ENOMEM ; page = alloc_page_vma ( GFP_HIGHUSER_MOVABLE , dst_vma , dst_addr ) ; if ( ! page ) goto out ; page_kaddr = kmap_atomic ( page ) ; ret = copy_from_user ( page_kaddr , ( const void __user * ) src_addr , PAGE_SIZE ) ; kunmap_atomic ( page_kaddr ) ; if ( unlikely ( ret ) ) { ret = - EFAULT ; * pagep = page ; goto out ; } } else { page = * pagep ; * pagep = NULL ; } __SetPageUptodate ( page ) ; ret = - ENOMEM ; if ( mem_cgroup_try_charge ( page , dst_mm , GFP_KERNEL , & memcg , false ) ) goto out_release ; _dst_pte = pte_mkdirty ( mk_pte ( page , dst_vma -> vm_page_prot ) ) ; <S2SV_StartBug> if ( dst_vma -> vm_flags & VM_WRITE && ! wp_copy ) <S2SV_EndBug> <S2SV_StartBug> _dst_pte = pte_mkwrite ( _dst_pte ) ; <S2SV_EndBug> ret = - EEXIST ; dst_pte = pte_offset_map_lock ( dst_mm , dst_pmd , dst_addr , & ptl ) ; if ( ! pte_none ( * dst_pte ) ) goto out_release_uncharge_unlock ; inc_mm_counter ( dst_mm , MM_ANONPAGES ) ; page_add_new_anon_rmap ( page , dst_vma , dst_addr , false ) ; mem_cgroup_commit_charge ( page , memcg , false , false ) ; lru_cache_add_active_or_unevictable ( page , dst_vma ) ; set_pte_at ( dst_mm , dst_addr , dst_pte , _dst_pte ) ; update_mmu_cache ( dst_vma , dst_addr , dst_pte ) ; pte_unmap_unlock ( dst_pte , ptl ) ; ret = 0 ; out : return ret ; out_release_uncharge_unlock : pte_unmap_unlock ( dst_pte , ptl ) ; mem_cgroup_cancel_charge ( page , memcg , false ) ; out_release : put_page ( page ) ; goto out ; }
|
<S2SV_ModStart> ; if ( <S2SV_ModEnd> wp_copy ) _dst_pte <S2SV_ModStart> ) _dst_pte = pte_wrprotect <S2SV_ModEnd> ( _dst_pte )
|
7,196 |
CWE-000 int32 udp_recvt ( uid32 slot , char * buff , int32 len , uint32 timeout ) { intmask mask ; struct udpentry * udptr ; umsg32 msg ; struct netpacket * pkt ; int32 i ; int32 msglen ; char * udataptr ; mask = disable ( ) ; if ( ( slot < 0 ) || ( slot >= UDP_SLOTS ) ) { restore ( mask ) ; return SYSERR ; } udptr = & udptab [ slot ] ; if ( udptr -> udstate != UDP_USED ) { restore ( mask ) ; return SYSERR ; } if ( udptr -> udcount == 0 ) { udptr -> udstate = UDP_RECV ; udptr -> udpid = currpid ; resume ( create ( timer , 8192 , getprio ( getpid ( ) ) , "timer" , 1 , timeout ) ) ; <S2SV_StartBug> receive ( ) ; <S2SV_EndBug> msg = recvclr ( ) ; udptr -> udstate = UDP_USED ; if ( msg == TIMEOUT ) { restore ( mask ) ; return TIMEOUT ; } else if ( msg != OK ) { restore ( mask ) ; return SYSERR ; } } pkt = udptr -> udqueue [ udptr -> udhead ++ ] ; if ( udptr -> udhead >= UDP_QSIZ ) { udptr -> udhead = 0 ; } udptr -> udcount -- ; msglen = pkt -> net_udplen - UDP_HDR_LEN ; udataptr = ( char * ) pkt -> net_udpdata ; if ( len < msglen ) { msglen = len ; } for ( i = 0 ; i < msglen ; i ++ ) { * buff ++ = * udataptr ++ ; } freebuf ( ( char * ) pkt ) ; restore ( mask ) ; return msglen ; }
|
<S2SV_ModStart> ) ) ; msg = receive <S2SV_ModEnd> ( ) ;
|
7,197 |
CWE-000 int main ( int argc , char * * argv ) { PROGRAM_NAME = argv [ 0 ] ; <S2SV_StartBug> sh ( ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; sh ( argc
|
7,198 |
CWE-000 static void parserInit ( XML_Parser parser , const XML_Char * encodingName ) { processor = prologInitProcessor ; XmlPrologStateInit ( & prologState ) ; if ( encodingName != NULL ) { protocolEncodingName = copyString ( encodingName , & ( parser -> m_mem ) ) ; } curBase = NULL ; XmlInitEncoding ( & initEncoding , & encoding , 0 ) ; parser -> m_userData = NULL ; parser -> m_handlerArg = NULL ; parser -> m_startElementHandler = NULL ; parser -> m_endElementHandler = NULL ; parser -> m_characterDataHandler = NULL ; processingInstructionHandler = NULL ; parser -> m_commentHandler = NULL ; startCdataSectionHandler = NULL ; parser -> m_endCdataSectionHandler = NULL ; parser -> m_defaultHandler = NULL ; parser -> m_startDoctypeDeclHandler = NULL ; parser -> m_endDoctypeDeclHandler = NULL ; unparsedEntityDeclHandler = NULL ; parser -> m_notationDeclHandler = NULL ; startNamespaceDeclHandler = NULL ; <S2SV_StartBug> endNamespaceDeclHandler = NULL ; <S2SV_EndBug> notStandaloneHandler = NULL ; externalEntityRefHandler = NULL ; externalEntityRefHandlerArg = parser ; skippedEntityHandler = NULL ; elementDeclHandler = NULL ; attlistDeclHandler = NULL ; entityDeclHandler = NULL ; xmlDeclHandler = NULL ; bufferPtr = buffer ; bufferEnd = buffer ; parseEndByteIndex = 0 ; parseEndPtr = NULL ; declElementType = NULL ; declAttributeId = NULL ; declEntity = NULL ; doctypeName = NULL ; doctypeSysid = NULL ; doctypePubid = NULL ; declAttributeType = NULL ; declNotationName = NULL ; declNotationPublicId = NULL ; declAttributeIsCdata = XML_FALSE ; declAttributeIsId = XML_FALSE ; memset ( & position , 0 , sizeof ( POSITION ) ) ; errorCode = XML_ERROR_NONE ; eventPtr = NULL ; eventEndPtr = NULL ; positionPtr = NULL ; openInternalEntities = NULL ; defaultExpandInternalEntities = XML_TRUE ; tagLevel = 0 ; tagStack = NULL ; inheritedBindings = NULL ; nSpecifiedAtts = 0 ; unknownEncodingMem = NULL ; unknownEncodingRelease = NULL ; unknownEncodingData = NULL ; parentParser = NULL ; ps_parsing = XML_INITIALIZED ; # ifdef XML_DTD isParamEntity = XML_FALSE ; useForeignDTD = XML_FALSE ; paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER ; # endif hash_secret_salt = 0 ; }
|
<S2SV_ModStart> = NULL ; parser -> m_endNamespaceDeclHandler <S2SV_ModEnd> = NULL ;
|
7,199 |
CWE-000 static int relocate_file ( elf_file_t ef ) { <S2SV_StartBug> int e ; <S2SV_EndBug> <S2SV_StartBug> e = relocate_file1 ( ef , elf_reloc ) ; <S2SV_EndBug> # if defined ( __i386__ ) || defined ( __amd64__ ) if ( e == 0 ) <S2SV_StartBug> e = relocate_file1 ( ef , elf_reloc_ifunc ) ; <S2SV_EndBug> # endif return ( e ) ; }
|
<S2SV_ModStart> ) { int error ; error <S2SV_ModEnd> = relocate_file1 ( <S2SV_ModStart> ( ef , elf_lookup , elf_reloc , false ) ; if ( error <S2SV_ModEnd> == 0 ) <S2SV_ModStart> == 0 ) error <S2SV_ModEnd> = relocate_file1 ( <S2SV_ModStart> ( ef , elf_lookup , elf_reloc , true ) ; return ( error <S2SV_ModEnd> ) ; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.