Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,000 | CWE-000 DEFUN ( show_bgp_afi_vpn_rd_route , show_bgp_afi_vpn_rd_route_cmd , "show<S2SV_blank>bgp<S2SV_blank>" BGP_AFI_CMD_STR "<S2SV_blank>vpn<S2SV_blank>rd<S2SV_blank>ASN:NN_OR_IP-ADDRESS:NN<S2SV_blank><A.B.C.D/M|X:X::X:X/M><S2SV_blank>[json]" , SHOW_STR BGP_STR BGP_AFI_HELP_STR "Address<S2SV_blank>Family<S2SV_blank>modifier\\n" "Display<S2SV_blank>information<S2SV_blank>for<S2SV_blank>a<S2SV_blank>route<S2SV_blank>distinguisher\\n" "Route<S2SV_blank>Distinguisher\\n" "Network<S2SV_blank>in<S2SV_blank>the<S2SV_blank>BGP<S2SV_blank>routing<S2SV_blank>table<S2SV_blank>to<S2SV_blank>display\\n" "Network<S2SV_blank>in<S2SV_blank>the<S2SV_blank>BGP<S2SV_blank>routing<S2SV_blank>table<S2SV_blank>to<S2SV_blank>display\\n" JSON_STR ) { int ret ; struct prefix_rd prd ; afi_t afi = AFI_MAX ; int idx = 0 ; <S2SV_StartBug> argv_find_and_parse_afi ( argv , argc , & idx , & afi ) ; <S2SV_EndBug> ret = str2prefix_rd ( argv [ 5 ] -> arg , & prd ) ; if ( ! ret ) { vty_out ( vty , "%%<S2SV_blank>Malformed<S2SV_blank>Route<S2SV_blank>Distinguisher\\n" ) ; return CMD_WARNING ; } return bgp_show_route ( vty , NULL , argv [ 6 ] -> arg , afi , SAFI_MPLS_VPN , & prd , 0 , BGP_PATH_ALL , use_json ( argc , argv ) ) ; } | <S2SV_ModStart> = 0 ; ( void ) |
4,001 | CWE-000 void view_destroy ( struct roots_view * view ) { wl_signal_emit ( & view -> events . destroy , view ) ; <S2SV_StartBug> wl_list_remove ( & view -> link ) ; <S2SV_EndBug> free ( view ) ; } | <S2SV_ModStart> view ) ; <S2SV_ModEnd> free ( view |
4,002 | CWE-000 static PHP_METHOD ( Phalcon_Tag , monthField ) { zend_long ZEPHIR_LAST_CALL_STATUS ; zephir_fcall_cache_entry * _0 = NULL ; <S2SV_StartBug> zval * parameters , parameters_sub , _1 ; <S2SV_EndBug> zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & parameters_sub ) ; ZVAL_UNDEF ( & _1 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & parameters ) ; <S2SV_StartBug> ZEPHIR_INIT_VAR ( & _1 ) ; <S2SV_EndBug> <S2SV_StartBug> ZVAL_STRING ( & _1 , "month" ) ; <S2SV_EndBug> <S2SV_StartBug> ZEPHIR_RETURN_CALL_SELF ( "_inputfield" , & _0 , 412 , & _1 , parameters ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; RETURN_MM ( ) ; } | <S2SV_ModStart> * parameters , * _1 <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> ; ZEPHIR_INIT_VAR ( <S2SV_ModEnd> _1 ) ; <S2SV_ModStart> ; ZVAL_STRING ( <S2SV_ModEnd> _1 , "month" <S2SV_ModStart> _1 , "month" , ZEPHIR_TEMP_PARAM_COPY <S2SV_ModStart> & _0 , 445 , <S2SV_ModEnd> _1 , parameters <S2SV_ModStart> _1 , parameters ) ; zephir_check_temp_parameter ( _1 |
4,003 | CWE-000 void pre_syscall_default_setup ( ) { printc ( "pre_syscall_default_setup\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> "pre_syscall_default_setup\\n" ) ; struct cos_defcompinfo * defci = cos_defcompinfo_curr_get ( ) ; struct cos_compinfo * ci = cos_compinfo_get ( defci ) ; cos_defcompinfo_init ( ) ; cos_meminfo_init ( & ( ci -> mi ) , BOOT_MEM_KM_BASE , COS_MEM_KERN_PA_SZ , BOOT_CAPTBL_SELF_UNTYPED_PT ) ; |
4,004 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 1 ) { exit ( 1 ) ; } int run = 1 ; int sid = 1 ; pos = 0 ; char * cmd = ( char * ) malloc ( 128 * sizeof ( char ) ) ; char * * args ; char error_message [ 30 ] = "An<S2SV_blank>error<S2SV_blank>has<S2SV_blank>occurred\\n" ; char c , h ; while ( run ) { printf ( "mysh<S2SV_blank>(%d)><S2SV_blank>" , sid ) ; int cpos = 0 ; int toolong = 0 ; fgets ( cmd , 128 , stdin ) ; <S2SV_StartBug> while ( ( c = cmd [ cpos ] ) != '\\n' && c != EOF && ( ! toolong ) ) <S2SV_EndBug> { <S2SV_StartBug> if ( cpos >= 128 ) <S2SV_EndBug> { while ( ( h = getchar ( ) ) != '\\n' && c != EOF ) { } <S2SV_StartBug> write ( STDERR_FILENO , error_message , strlen ( error_message ) ) ; <S2SV_EndBug> toolong = 1 ; break ; } cpos ++ ; } if ( toolong ) { sid ++ ; continue ; } if ( strcmp ( cmd , "\\n" ) == 0 ) { continue ; } args = parse ( cmd ) ; checkjob ( ) ; run = launch ( args ) ; if ( run == 2 ) { write ( STDERR_FILENO , error_message , strlen ( error_message ) ) ; sid ++ ; } else if ( run == 4 ) { run = 0 ; killjobs ( ) ; exit ( 0 ) ; } else if ( run ) { sid ++ ; } } free ( args ) ; free ( cmd ) ; return 0 ; } | <S2SV_ModStart> while ( ( ( <S2SV_ModStart> ) != '\\n' ) && ( <S2SV_ModEnd> c != EOF <S2SV_ModStart> c != EOF ) <S2SV_ModStart> if ( cpos > 128 ) { write ( STDERR_FILENO , error_message , strlen ( error_message ) ) ; toolong = 1 ; break ; } cpos ++ ; } if ( toolong <S2SV_ModEnd> ) { while <S2SV_ModStart> ) { } <S2SV_ModEnd> sid ++ ; |
4,005 | CWE-000 utility ( MCString , const char * , baseFromPath , const char * path , char ( * buff ) [ ] ) { <S2SV_StartBug> char reversebuff [ PATH_MAX ] ; <S2SV_EndBug> size_t count = MCString_reverse ( path , & reversebuff ) ; char * head = & reversebuff [ count - 1 ] ; char * tail = & reversebuff [ 0 ] ; while ( * tail != '/' && * head != NUL ) { tail ++ ; } int i = 0 ; while ( head != tail ) { ( * buff ) [ i ++ ] = * head ; head -- ; } ( * buff ) [ i ] = NUL ; return & ( * buff ) [ 0 ] ; } | <S2SV_ModStart> [ PATH_MAX ] = { } |
4,006 | CWE-000 static irqreturn_t zynqmp_dma_irq_handler ( int irq , void * data ) { struct zynqmp_dma_chan * chan = ( struct zynqmp_dma_chan * ) data ; u32 isr , imr , status ; irqreturn_t ret = IRQ_NONE ; isr = readl ( chan -> regs + ZYNQMP_DMA_ISR ) ; imr = readl ( chan -> regs + ZYNQMP_DMA_IMR ) ; status = isr & ~ imr ; writel ( isr , chan -> regs + ZYNQMP_DMA_ISR ) ; if ( status & ZYNQMP_DMA_INT_DONE ) { tasklet_schedule ( & chan -> tasklet ) ; ret = IRQ_HANDLED ; } if ( status & ZYNQMP_DMA_DONE ) chan -> idle = true ; if ( status & ZYNQMP_DMA_INT_ERR ) { chan -> err = true ; tasklet_schedule ( & chan -> tasklet ) ; dev_err ( chan -> dev , "Channel<S2SV_blank>%p<S2SV_blank>has<S2SV_blank>errors\\n" , chan ) ; ret = IRQ_HANDLED ; } if ( status & ZYNQMP_DMA_INT_OVRFL ) { zynqmp_dma_handle_ovfl_int ( chan , status ) ; <S2SV_StartBug> dev_info ( chan -> dev , "Channel<S2SV_blank>%p<S2SV_blank>overflow<S2SV_blank>interrupt\\n" , chan ) ; <S2SV_EndBug> ret = IRQ_HANDLED ; } return ret ; } | <S2SV_ModStart> status ) ; dev_dbg <S2SV_ModEnd> ( chan -> |
4,007 | CWE-000 static void l2tp_tunnel_destruct ( struct sock * sk ) { struct l2tp_tunnel * tunnel = l2tp_tunnel ( sk ) ; struct l2tp_net * pn ; if ( tunnel == NULL ) goto end ; l2tp_info ( tunnel , L2TP_MSG_CONTROL , "%s:<S2SV_blank>closing...\\n" , tunnel -> name ) ; switch ( tunnel -> encap ) { case L2TP_ENCAPTYPE_UDP : ( udp_sk ( sk ) ) -> encap_type = 0 ; ( udp_sk ( sk ) ) -> encap_rcv = NULL ; ( udp_sk ( sk ) ) -> encap_destroy = NULL ; break ; case L2TP_ENCAPTYPE_IP : break ; } sk -> sk_destruct = tunnel -> old_sk_destruct ; sk -> sk_user_data = NULL ; <S2SV_StartBug> tunnel -> sock = NULL ; <S2SV_EndBug> pn = l2tp_pernet ( tunnel -> l2tp_net ) ; spin_lock_bh ( & pn -> l2tp_tunnel_list_lock ) ; list_del_rcu ( & tunnel -> list ) ; spin_unlock_bh ( & pn -> l2tp_tunnel_list_lock ) ; atomic_dec ( & l2tp_tunnel_count ) ; l2tp_tunnel_closeall ( tunnel ) ; l2tp_tunnel_dec_refcount ( tunnel ) ; if ( sk -> sk_destruct ) ( * sk -> sk_destruct ) ( sk ) ; end : return ; } | <S2SV_ModStart> = NULL ; pn = l2tp_pernet ( tunnel -> l2tp_net ) ; spin_lock_bh ( & pn -> l2tp_tunnel_list_lock ) ; list_del_rcu ( & tunnel -> list ) ; spin_unlock_bh ( & pn -> l2tp_tunnel_list_lock ) ; atomic_dec ( & l2tp_tunnel_count ) ; l2tp_tunnel_closeall ( tunnel ) ; <S2SV_ModStart> sock = NULL <S2SV_ModEnd> ; l2tp_tunnel_dec_refcount ( |
4,008 | CWE-000 kii_bool_t onboard_with_vendor_thing_id ( kii_thing_if_t * kii_thing_if , const char * vendor_thing_id , const char * password , const char * thing_type , const char * firmware_version , const char * layout_position , const char * thing_properties , kii_thing_if_error_t * error ) { if ( kii_thing_if -> state == KII_THING_IF_STATE_STARTED ) { if ( error != NULL ) { <S2SV_StartBug> error -> reason = KII_THING_IF_ERROR_REASON_ALREADY_STARTED ; <S2SV_EndBug> } return KII_FALSE ; } if ( prv_onboard_with_vendor_thing_id ( & kii_thing_if -> command_handler , vendor_thing_id , password , thing_type , thing_properties , firmware_version , layout_position , error ) == KII_FALSE ) { return KII_FALSE ; } if ( prv_set_author ( & ( kii_thing_if -> state_updater . kii_core . author ) , kii_thing_if -> command_handler . kii_core . author . author_id , kii_thing_if -> command_handler . kii_core . author . access_token ) == KII_FALSE ) { return KII_FALSE ; } kii_thing_if -> state = KII_THING_IF_STATE_ONBOARDED ; return KII_TRUE ; } | <S2SV_ModStart> { error -> code = KII_THING_IF_ERROR_INVALID_STATE <S2SV_ModEnd> ; } return |
4,009 | CWE-000 void readInputData ( int dimensions , int imageWidth ) { <S2SV_StartBug> int filed = open ( "data" , O_RDWR ) ; <S2SV_EndBug> char * buf = malloc ( READ_BUFFER ) ; if ( ! filed ) { printf ( "Openfile<S2SV_blank>error\\n" ) ; exit ( - 1 ) ; } int nbytes ; while ( 1 ) { <S2SV_StartBug> nbytes = read ( filed , buf , READ_BUFFER ) ; <S2SV_EndBug> if ( nbytes > 0 ) { pthread_mutex_lock ( & lock ) ; <S2SV_StartBug> int intensity = 1000 / cbrt ( nbytes ) ; <S2SV_EndBug> <S2SV_StartBug> linearVisualisation ( buf , imageData , nbytes , imageWidth , intensity , dimensions ) ; <S2SV_EndBug> pthread_mutex_unlock ( & lock ) ; <S2SV_StartBug> } <S2SV_EndBug> usleep ( 100 * 1000 ) ; } } | <S2SV_ModStart> imageWidth ) { <S2SV_ModEnd> while ( 1 <S2SV_ModStart> 1 ) { File f = fileRead ( "data" ) ; <S2SV_ModEnd> pthread_mutex_lock ( & <S2SV_ModStart> / cbrt ( f . size <S2SV_ModEnd> ) ; linearVisualisation <S2SV_ModStart> ; linearVisualisation ( f . data <S2SV_ModEnd> , imageData , <S2SV_ModStart> , imageData , f . size <S2SV_ModEnd> , imageWidth , <S2SV_ModStart> lock ) ; if ( f . size > 0 ) free ( f . data ) ; textFileWrite ( "data" , "" ) ; <S2SV_ModEnd> usleep ( 100 |
4,010 | CWE-000 t_path * save_path ( t_room * r , int * i ) { t_path * path ; int p ; p = 1 ; path = NULL ; <S2SV_StartBug> if ( ! r -> tube || ! verif_no_path ( r ) ) <S2SV_EndBug> { ( * i ) ++ ; <S2SV_StartBug> return ( path ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> save_path_ ( & r , & path , p ) ; return ( path ) ; } | <S2SV_ModStart> = NULL ; ft_printf ( "1" ) ; <S2SV_ModStart> ) ++ ; ft_printf ( "3" ) ; <S2SV_ModStart> ) ; } ft_printf ( "2" ) ; |
4,011 | CWE-000 static void * io_read_thread ( void * data ) { struct io_stream * s = ( struct io_stream * ) data ; logit ( "IO<S2SV_blank>read<S2SV_blank>thread<S2SV_blank>created" ) ; while ( ! s -> stop_read_thread ) { char read_buf [ 8096 ] ; int read_buf_fill = 0 ; int read_buf_pos = 0 ; LOCK ( s -> io_mtx ) ; debug ( "Reading..." ) ; LOCK ( s -> buf_mtx ) ; s -> after_seek = 0 ; UNLOCK ( s -> buf_mtx ) ; read_buf_fill = io_internal_read ( s , 0 , read_buf , sizeof ( read_buf ) ) ; UNLOCK ( s -> io_mtx ) ; <S2SV_StartBug> debug ( "Read<S2SV_blank>%d<S2SV_blank>bytes" , read_buf_fill ) ; <S2SV_EndBug> LOCK ( s -> buf_mtx ) ; if ( s -> stop_read_thread ) { UNLOCK ( s -> buf_mtx ) ; break ; } if ( read_buf_fill < 0 ) { s -> errno_val = errno ; s -> read_error = 1 ; logit ( "Exiting<S2SV_blank>due<S2SV_blank>to<S2SV_blank>read<S2SV_blank>error." ) ; pthread_cond_broadcast ( & s -> buf_fill_cond ) ; UNLOCK ( s -> buf_mtx ) ; break ; } if ( read_buf_fill == 0 ) { s -> eof = 1 ; debug ( "EOF,<S2SV_blank>waiting" ) ; pthread_cond_broadcast ( & s -> buf_fill_cond ) ; pthread_cond_wait ( & s -> buf_free_cond , & s -> buf_mtx ) ; debug ( "Got<S2SV_blank>signal" ) ; UNLOCK ( s -> buf_mtx ) ; continue ; } s -> eof = 0 ; while ( read_buf_pos < read_buf_fill && ! s -> after_seek ) { size_t put ; debug ( "Buffer<S2SV_blank>fill:<S2SV_blank>%zu" , fifo_buf_get_fill ( s -> buf ) ) ; put = fifo_buf_put ( s -> buf , read_buf + read_buf_pos , read_buf_fill - read_buf_pos ) ; if ( s -> stop_read_thread ) break ; if ( put > 0 ) { debug ( "Put<S2SV_blank>%zu<S2SV_blank>bytes<S2SV_blank>into<S2SV_blank>the<S2SV_blank>buffer" , put ) ; if ( s -> buf_fill_callback ) { UNLOCK ( s -> buf_mtx ) ; s -> buf_fill_callback ( s , fifo_buf_get_fill ( s -> buf ) , fifo_buf_get_size ( s -> buf ) , s -> buf_fill_callback_data ) ; LOCK ( s -> buf_mtx ) ; } pthread_cond_broadcast ( & s -> buf_fill_cond ) ; read_buf_pos += put ; continue ; } debug ( "The<S2SV_blank>buffer<S2SV_blank>is<S2SV_blank>full,<S2SV_blank>waiting." ) ; pthread_cond_wait ( & s -> buf_free_cond , & s -> buf_mtx ) ; debug ( "Some<S2SV_blank>space<S2SV_blank>in<S2SV_blank>the<S2SV_blank>buffer<S2SV_blank>was<S2SV_blank>freed" ) ; } UNLOCK ( s -> buf_mtx ) ; } if ( s -> stop_read_thread ) logit ( "Stop<S2SV_blank>request" ) ; logit ( "Exiting<S2SV_blank>IO<S2SV_blank>read<S2SV_blank>thread" ) ; return NULL ; } | <S2SV_ModStart> io_mtx ) ; if ( read_buf_fill > 0 ) |
4,012 | CWE-000 <S2SV_StartBug> static void run8xS ( void ) { <S2SV_EndBug> DEBUG_FUNC_ENTER ( run8xS ) ; if ( ( g_settings . debugRs232 >= 2 ) || ( g_state . rfm12modeis ) ) { char c = rs232_getchar ( ) ; if ( c == 0 ) { c = rfm12_getchar ( ) ; } if ( c == 'w' ) { menu_keypress ( 3 ) ; } if ( c == 'a' ) { menu_keypress ( 1 ) ; } if ( c == 's' ) { menu_keypress ( 2 ) ; } if ( c == 'd' ) { menu_keypress ( 4 ) ; } if ( c == 'l' ) { increaseRfmTimeout ( ) ; logger_print ( 0 ) ; } if ( c == 'L' ) { increaseRfmTimeout ( ) ; logger_print ( 1 ) ; } if ( c == 'm' ) { rfm12_showstats ( ) ; } if ( c == 'h' ) { const char * buffer = PSTR ( "Hello<S2SV_blank>world\\n\\r" ) ; rfm12_sendP ( buffer , strlen_P ( buffer ) ) ; } if ( c > 0 ) { g_state . displayNoOffCd = 60 ; } } if ( dcf77_is_enabled ( ) ) { if ( dcf77_update ( ) ) { dcf77_disable ( ) ; g_state . dcf77ResyncCd = 60 * 60 * 6 ; menu_keypress ( 100 ) ; } if ( g_state . dcf77ResyncTrytimeCd ) { g_state . dcf77ResyncTrytimeCd -- ; } else { dcf77_disable ( ) ; g_state . dcf77ResyncCd = 60 * 60 * 1 ; } } uint8_t irKey = 0 ; if ( dcf77_is_idle ( ) ) { if ( ( ( g_state . dcf77Synced ) && ( ( g_state . dcf77ResyncTrytimeCd > ( 8 * 60 * 60 ) ) || ( g_state . timehcache > 3 ) || ( g_state . timehcache < 2 ) ) ) || ( g_state . time < ( 10 * 60 ) ) || ( dcf77_is_enabled ( ) == 0 ) || ( g_state . soundEnabledCd ) ) { irKey = irKeysRead ( ) ; } } uint8_t rc5key = rc5keyget ( ) ; if ( rc5key ) { irKey = rc5key ; } if ( irKey ) { rc5keypress ( ) ; rfm12keypress ( ) ; g_state . displayNoOffCd = 60 ; if ( irKey != g_state . irKeyLast ) { if ( g_state . soundEnabledCd ) { g_state . soundEnabledCd = 0 ; } else { menu_keypress ( irKey ) ; } g_state . irKeyCd = 6 ; } else { if ( g_state . irKeyCd == 0 ) { menu_keypress ( irKey ) ; g_state . irKeyCd = 4 ; } } } g_state . irKeyLast = irKey ; if ( g_state . irKeyCd ) { g_state . irKeyCd -- ; } <S2SV_StartBug> DEBUG_FUNC_LEAVE ( run8xS ) ; <S2SV_EndBug> } | <S2SV_ModStart> void run8xS ( uint8_t delayed <S2SV_ModEnd> ) { DEBUG_FUNC_ENTER <S2SV_ModStart> -- ; } if ( ! delayed ) { logger_print_iter ( ) ; } |
4,013 | CWE-000 static void buslogic_mca_write ( int port , uint8_t val , void * priv ) { x54x_t * dev = ( x54x_t * ) priv ; buslogic_data_t * bl = ( buslogic_data_t * ) dev -> ven_data ; HALocalRAM * HALR = & bl -> LocalRAM ; if ( port < 0x0102 ) return ; dev -> pos_regs [ port & 7 ] = val ; <S2SV_StartBug> x54x_io_remove ( dev , dev -> Base ) ; <S2SV_EndBug> if ( dev -> pos_regs [ 3 ] ) { dev -> Base = dev -> pos_regs [ 3 ] << 8 ; dev -> Base |= ( ( dev -> pos_regs [ 2 ] & 0x10 ) ? 4 : 0 ) ; } else { dev -> Base = 0x0000 ; } dev -> Irq = ( ( dev -> pos_regs [ 2 ] >> 1 ) & 0x07 ) + 8 ; dev -> DmaChannel = dev -> pos_regs [ 5 ] & 0x0f ; if ( dev -> pos_regs [ 0 ] & 0xe0 ) switch ( dev -> pos_regs [ 0 ] & 0xe0 ) { case 0xe0 : bl -> bios_addr = 0xDC000 ; break ; case 0x00 : bl -> bios_addr = 0 ; break ; case 0xc0 : bl -> bios_addr = 0xD8000 ; break ; case 0xa0 : bl -> bios_addr = 0xD4000 ; break ; case 0x80 : bl -> bios_addr = 0xD0000 ; break ; case 0x60 : bl -> bios_addr = 0xCC000 ; break ; case 0x40 : bl -> bios_addr = 0xC8000 ; break ; case 0x20 : bl -> bios_addr = 0xC4000 ; break ; } else { bl -> bios_addr = 0x000000 ; } dev -> HostID = ( dev -> pos_regs [ 4 ] >> 5 ) & 0x07 ; HALR -> structured . autoSCSIData . uSCSIConfiguration &= ~ 2 ; HALR -> structured . autoSCSIData . uSCSIConfiguration |= ( dev -> pos_regs [ 4 ] & 2 ) ; HALR -> structured . autoSCSIData . u16SynchronousPermittedMask = ( dev -> pos_regs [ 4 ] & 0x10 ) ? 0xffff : 0x0000 ; HALR -> structured . autoSCSIData . uBIOSConfiguration &= ~ 4 ; HALR -> structured . autoSCSIData . uBIOSConfiguration |= ( dev -> pos_regs [ 4 ] & 8 ) ? 4 : 0 ; mem_mapping_disable ( & dev -> bios . mapping ) ; if ( dev -> pos_regs [ 2 ] & 0x01 ) { <S2SV_StartBug> x54x_io_set ( dev , dev -> Base ) ; <S2SV_EndBug> x54x_reset_ctrl ( dev , CTRL_HRST ) ; if ( bl -> has_bios && ( bl -> bios_addr != 0x000000 ) ) { mem_mapping_enable ( & bl -> bios . mapping ) ; mem_mapping_set_addr ( & bl -> bios . mapping , bl -> bios_addr , ROM_SIZE ) ; } } } | <S2SV_ModStart> dev -> Base , 4 <S2SV_ModStart> dev -> Base , 4 |
4,014 | CWE-000 static int android_create_device ( struct android_dev * dev ) { struct device_attribute * * attrs = android_usb_attributes ; struct device_attribute * attr ; int err ; <S2SV_StartBug> int hid_enabled ; <S2SV_EndBug> dev -> dev = device_create ( android_class , NULL , MKDEV ( 0 , 0 ) , NULL , "android0" ) ; if ( IS_ERR ( dev -> dev ) ) return PTR_ERR ( dev -> dev ) ; dev_set_drvdata ( dev -> dev , dev ) ; while ( ( attr = * attrs ++ ) ) { err = device_create_file ( dev -> dev , attr ) ; if ( err ) { device_destroy ( android_class , dev -> dev -> devt ) ; return err ; } } return 0 ; } | <S2SV_ModStart> err ; int __attribute__ ( ( unused ) ) |
4,015 | CWE-000 void hash_table_insert ( BasicHashTable * ht , char * key , char * value ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> value ) { unsigned int hash_index = hash ( key , ht -> capacity ) ; if ( ht -> storage [ hash_index ] != NULL ) { printf ( "WARNING:<S2SV_blank>Index<S2SV_blank>will<S2SV_blank>be<S2SV_blank>overwritten!\\n" ) ; destroy_pair ( ht -> storage [ hash_index ] ) ; } ht -> storage [ hash_index ] = create_pair ( key , value ) ; |
4,016 | CWE-000 VOS_STATUS wlan_hdd_get_rssi ( hdd_adapter_t * pAdapter , v_S7_t * rssi_value ) { struct statsContext context ; hdd_context_t * pHddCtx ; hdd_station_ctx_t * pHddStaCtx ; eHalStatus hstatus ; long lrc ; if ( NULL == pAdapter ) { hddLog ( VOS_TRACE_LEVEL_WARN , "%s:<S2SV_blank>Invalid<S2SV_blank>context,<S2SV_blank>pAdapter" , __func__ ) ; return VOS_STATUS_E_FAULT ; } if ( ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> isLogpInProgress ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , "%s:LOGP<S2SV_blank>in<S2SV_blank>Progress.<S2SV_blank>Ignore!!!" , __func__ ) ; * rssi_value = pAdapter -> rssi ; return VOS_STATUS_SUCCESS ; } pHddCtx = WLAN_HDD_GET_CTX ( pAdapter ) ; pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR ( pAdapter ) ; if ( eConnectionState_Associated != pHddStaCtx -> conn_info . connState ) { <S2SV_StartBug> VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_INFO , "%s:Not<S2SV_blank>associated!" , __func__ ) ; <S2SV_EndBug> * rssi_value = 0 ; return VOS_STATUS_SUCCESS ; } if ( VOS_TRUE == pHddStaCtx -> hdd_ReassocScenario ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_INFO , "%s:<S2SV_blank>Roaming<S2SV_blank>in<S2SV_blank>progress,<S2SV_blank>hence<S2SV_blank>return<S2SV_blank>last<S2SV_blank>cached<S2SV_blank>RSSI" , __func__ ) ; * rssi_value = pAdapter -> rssi ; return VOS_STATUS_SUCCESS ; } init_completion ( & context . completion ) ; context . pAdapter = pAdapter ; context . magic = RSSI_CONTEXT_MAGIC ; hstatus = sme_GetRssi ( pHddCtx -> hHal , hdd_GetRssiCB , pHddStaCtx -> conn_info . staId [ 0 ] , pHddStaCtx -> conn_info . bssId , & context , pHddCtx -> pvosContext ) ; if ( eHAL_STATUS_SUCCESS != hstatus ) { hddLog ( VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>retrieve<S2SV_blank>RSSI" , __func__ ) ; } else { lrc = wait_for_completion_interruptible_timeout ( & context . completion , msecs_to_jiffies ( WLAN_WAIT_TIME_STATS ) ) ; if ( lrc <= 0 ) { hddLog ( VOS_TRACE_LEVEL_ERROR , "%s:<S2SV_blank>SME<S2SV_blank>%s<S2SV_blank>while<S2SV_blank>retrieving<S2SV_blank>RSSI" , __func__ , ( 0 == lrc ) ? "timeout" : "interrupt" ) ; } } spin_lock ( & hdd_context_lock ) ; context . magic = 0 ; spin_unlock ( & hdd_context_lock ) ; * rssi_value = pAdapter -> rssi ; return VOS_STATUS_SUCCESS ; } | <S2SV_ModStart> , VOS_TRACE_LEVEL_INFO , "%s:Not<S2SV_blank>associated,<S2SV_blank>rssi<S2SV_blank>on<S2SV_blank>Disconnect<S2SV_blank>:<S2SV_blank>%d" , __func__ , pAdapter -> rssi_on_disconnect ) ; * rssi_value = pAdapter -> rssi_on_disconnect <S2SV_ModEnd> ; return VOS_STATUS_SUCCESS |
4,017 | CWE-000 static int event_dispatch_poll_handler ( struct event_pool * event_pool , struct pollfd * ufds , int i ) { event_handler_t handler = NULL ; void * data = NULL ; int idx = - 1 ; int ret = 0 ; handler = NULL ; data = NULL ; pthread_mutex_lock ( & event_pool -> mutex ) ; { idx = __event_getindex ( event_pool , ufds [ i ] . fd , i ) ; if ( idx == - 1 ) { gf_msg ( "poll" , GF_LOG_ERROR , 0 , LG_MSG_INDEX_NOT_FOUND , "index<S2SV_blank>not<S2SV_blank>found<S2SV_blank>for<S2SV_blank>" "fd=%d<S2SV_blank>(idx_hint=%d)" , ufds [ i ] . fd , i ) ; goto unlock ; } handler = event_pool -> reg [ idx ] . handler ; data = event_pool -> reg [ idx ] . data ; } unlock : pthread_mutex_unlock ( & event_pool -> mutex ) ; if ( handler ) <S2SV_StartBug> ret = handler ( ufds [ i ] . fd , idx , data , <S2SV_EndBug> ( ufds [ i ] . revents & ( POLLIN | POLLPRI ) ) , ( ufds [ i ] . revents & ( POLLOUT ) ) , ( ufds [ i ] . revents & ( POLLERR | POLLHUP | POLLNVAL ) ) ) ; return ret ; } | <S2SV_ModStart> fd , idx , 0 |
4,018 | CWE-000 static void _outQuery ( StringInfo str , const Query * node ) { WRITE_NODE_TYPE ( "QUERY" ) ; WRITE_ENUM_FIELD ( commandType , CmdType ) ; WRITE_ENUM_FIELD ( querySource , QuerySource ) ; WRITE_BOOL_FIELD ( canSetTag ) ; if ( node -> utilityStmt ) { switch ( nodeTag ( node -> utilityStmt ) ) { case T_CreateStmt : case T_CreateLabelStmt : case T_CreatePropertyIndexStmt : case T_IndexStmt : case T_NotifyStmt : case T_DeclareCursorStmt : WRITE_NODE_FIELD ( utilityStmt ) ; break ; default : appendStringInfoString ( str , "<S2SV_blank>:utilityStmt<S2SV_blank>?" ) ; break ; } } else appendStringInfoString ( str , "<S2SV_blank>:utilityStmt<S2SV_blank><>" ) ; WRITE_INT_FIELD ( resultRelation ) ; WRITE_BOOL_FIELD ( hasAggs ) ; WRITE_BOOL_FIELD ( hasWindowFuncs ) ; WRITE_BOOL_FIELD ( hasSubLinks ) ; WRITE_BOOL_FIELD ( hasDistinctOn ) ; WRITE_BOOL_FIELD ( hasRecursive ) ; WRITE_BOOL_FIELD ( hasModifyingCTE ) ; WRITE_BOOL_FIELD ( hasForUpdate ) ; WRITE_BOOL_FIELD ( hasRowSecurity ) ; WRITE_NODE_FIELD ( cteList ) ; WRITE_NODE_FIELD ( rtable ) ; WRITE_NODE_FIELD ( jointree ) ; WRITE_NODE_FIELD ( targetList ) ; WRITE_NODE_FIELD ( onConflict ) ; WRITE_NODE_FIELD ( returningList ) ; WRITE_NODE_FIELD ( groupClause ) ; WRITE_NODE_FIELD ( groupingSets ) ; WRITE_NODE_FIELD ( havingQual ) ; WRITE_NODE_FIELD ( windowClause ) ; WRITE_NODE_FIELD ( distinctClause ) ; WRITE_NODE_FIELD ( sortClause ) ; WRITE_NODE_FIELD ( limitOffset ) ; WRITE_NODE_FIELD ( limitCount ) ; WRITE_NODE_FIELD ( rowMarks ) ; WRITE_NODE_FIELD ( setOperations ) ; WRITE_NODE_FIELD ( constraintDeps ) ; WRITE_ENUM_FIELD ( graph . writeOp , GraphWriteOp ) ; WRITE_BOOL_FIELD ( graph . last ) ; WRITE_BOOL_FIELD ( graph . detach ) ; <S2SV_StartBug> WRITE_NODE_FIELD ( graph . resultRel ) ; <S2SV_EndBug> WRITE_NODE_FIELD ( graph . pattern ) ; WRITE_NODE_FIELD ( graph . exprs ) ; WRITE_NODE_FIELD ( graph . sets ) ; } | <S2SV_ModStart> ( graph . pattern ) ; WRITE_NODE_FIELD ( graph . targets <S2SV_ModEnd> ) ; WRITE_NODE_FIELD |
4,019 | CWE-000 int td_io_prep ( struct thread_data * td , struct io_u * io_u ) { dprint_io_u ( io_u , "prep" ) ; fio_ro_check ( td , io_u ) ; lock_file ( td , io_u -> file , io_u -> ddir ) ; if ( td -> io_ops -> prep ) { int ret = td -> io_ops -> prep ( td , io_u ) ; <S2SV_StartBug> dprint ( FD_IO , "->prep(%p)=%d\\n" , io_u , ret ) ; <S2SV_EndBug> if ( ret ) unlock_file ( td , io_u -> file ) ; return ret ; } return 0 ; } | <S2SV_ModStart> ( FD_IO , "prep:<S2SV_blank>io_u<S2SV_blank>%p:<S2SV_blank>ret=%d\\n" <S2SV_ModEnd> , io_u , |
4,020 | CWE-000 static int dev_pread ( int fd , void * buf , size_t nbytes , off_t offset ) { int r ; _TimerLap ( & tv_start ) ; <S2SV_StartBug> # ifdef SIMULATION <S2SV_EndBug> r = simu_smr_read ( fd , buf , nbytes , offset ) ; # else r = pread ( fd , buf , nbytes , offset ) ; <S2SV_StartBug> # endif <S2SV_EndBug> _TimerLap ( & tv_stop ) ; if ( r < 0 ) { printf ( "[ERROR]<S2SV_blank>read():-------read<S2SV_blank>from<S2SV_blank>device:<S2SV_blank>fd=%d,<S2SV_blank>errorcode=%d,<S2SV_blank>offset=%lu\\n" , fd , r , offset ) ; exit ( - 1 ) ; } return r ; } | <S2SV_ModStart> tv_start ) ; <S2SV_ModEnd> r = pread <S2SV_ModStart> offset ) ; <S2SV_ModEnd> _TimerLap ( & |
4,021 | CWE-000 _Float128 __ieee754_hypotl ( _Float128 x , _Float128 y ) { _Float128 a , b , t1 , t2 , y1 , y2 , w ; int64_t j , k , ha , hb ; GET_LDOUBLE_MSW64 ( ha , x ) ; ha &= 0x7fffffffffffffffLL ; GET_LDOUBLE_MSW64 ( hb , y ) ; hb &= 0x7fffffffffffffffLL ; if ( hb > ha ) { a = y ; b = x ; j = ha ; ha = hb ; hb = j ; } else { a = x ; b = y ; } SET_LDOUBLE_MSW64 ( a , ha ) ; SET_LDOUBLE_MSW64 ( b , hb ) ; if ( ( ha - hb ) > 0x78000000000000LL ) { return a + b ; } k = 0 ; if ( ha > 0x5f3f000000000000LL ) { if ( ha >= 0x7fff000000000000LL ) { u_int64_t low ; <S2SV_StartBug> w = a + b ; <S2SV_EndBug> GET_LDOUBLE_LSW64 ( low , a ) ; if ( ( ( ha & 0xffffffffffffLL ) | low ) == 0 ) w = a ; GET_LDOUBLE_LSW64 ( low , b ) ; if ( ( ( hb ^ 0x7fff000000000000LL ) | low ) == 0 ) w = b ; return w ; } ha -= 0x2580000000000000LL ; hb -= 0x2580000000000000LL ; k += 9600 ; SET_LDOUBLE_MSW64 ( a , ha ) ; SET_LDOUBLE_MSW64 ( b , hb ) ; } if ( hb < 0x20bf000000000000LL ) { if ( hb <= 0x0000ffffffffffffLL ) { u_int64_t low ; GET_LDOUBLE_LSW64 ( low , b ) ; if ( ( hb | low ) == 0 ) return a ; t1 = 0 ; SET_LDOUBLE_MSW64 ( t1 , 0x7ffd000000000000LL ) ; b *= t1 ; a *= t1 ; k -= 16382 ; GET_LDOUBLE_MSW64 ( ha , a ) ; GET_LDOUBLE_MSW64 ( hb , b ) ; if ( hb > ha ) { t1 = a ; a = b ; b = t1 ; j = ha ; ha = hb ; hb = j ; } } else { ha += 0x2580000000000000LL ; hb += 0x2580000000000000LL ; k -= 9600 ; SET_LDOUBLE_MSW64 ( a , ha ) ; SET_LDOUBLE_MSW64 ( b , hb ) ; } } w = a - b ; if ( w > b ) { t1 = 0 ; SET_LDOUBLE_MSW64 ( t1 , ha ) ; t2 = a - t1 ; w = __ieee754_sqrtl ( t1 * t1 - ( b * ( - b ) - t2 * ( a + t1 ) ) ) ; } else { a = a + a ; y1 = 0 ; SET_LDOUBLE_MSW64 ( y1 , hb ) ; y2 = b - y1 ; t1 = 0 ; SET_LDOUBLE_MSW64 ( t1 , ha + 0x0001000000000000LL ) ; t2 = a - t1 ; w = __ieee754_sqrtl ( t1 * y1 - ( w * ( - w ) - ( t1 * y2 + t2 * b ) ) ) ; } if ( k != 0 ) { u_int64_t high ; t1 = 1 ; GET_LDOUBLE_MSW64 ( high , t1 ) ; SET_LDOUBLE_MSW64 ( t1 , high + ( k << 48 ) ) ; w *= t1 ; math_check_force_underflow_nonneg ( w ) ; return w ; } else return w ; } | <S2SV_ModStart> a + b ; if ( issignaling ( a ) || issignaling ( b ) ) return w |
4,022 | CWE-000 void setvareq ( char * s , int flags ) { struct var * vp , * * vpp ; int nlen ; if ( aflag && ! ( flags & VNOEXPORT ) ) flags |= VEXPORT ; vp = find_var ( s , & vpp , & nlen ) ; if ( vp != NULL ) { if ( vp -> flags & VREADONLY ) { if ( ( flags & ( VTEXTFIXED | VSTACK ) ) == 0 ) ckfree ( s ) ; if ( flags & VNOERROR ) return ; error ( "%.*s:<S2SV_blank>is<S2SV_blank>read<S2SV_blank>only" , vp -> name_len , vp -> text ) ; } if ( flags & VNOSET ) { if ( ( flags & ( VTEXTFIXED | VSTACK ) ) == 0 ) ckfree ( s ) ; return ; } INTOFF ; if ( vp -> func && ! ( vp -> flags & VFUNCREF ) && ! ( flags & VNOFUNC ) ) ( * vp -> func ) ( s + vp -> name_len + 1 ) ; if ( ( vp -> flags & ( VTEXTFIXED | VSTACK ) ) == 0 ) <S2SV_StartBug> ckfree ( vp -> text ) ; <S2SV_EndBug> vp -> flags &= ~ ( VTEXTFIXED | VSTACK | VUNSET ) ; if ( flags & VNOEXPORT ) vp -> flags &= ~ VEXPORT ; if ( vp -> flags & VNOEXPORT ) flags &= ~ VEXPORT ; vp -> flags |= flags & ~ VNOFUNC ; vp -> text = s ; if ( vp == & vmpath || ( vp == & vmail && ! mpathset ( ) ) ) chkmail ( 1 ) ; INTON ; return ; } if ( flags & VNOSET ) { if ( ( flags & ( VTEXTFIXED | VSTACK ) ) == 0 ) ckfree ( s ) ; return ; } vp = ckmalloc ( sizeof ( * vp ) ) ; vp -> flags = flags & ~ ( VNOFUNC | VFUNCREF ) ; vp -> text = s ; vp -> name_len = nlen ; vp -> next = * vpp ; vp -> func = NULL ; * vpp = vp ; } | <S2SV_ModStart> -> text ) ; if ( vp -> rfunc && ( vp -> flags & ( VFUNCREF | VSPECIAL ) ) == VFUNCREF ) vp -> rfunc = NULL |
4,023 | CWE-000 void initPID ( ) { TA0CTL = 0 | ( TASSEL_2 | ID_3 ) ; TA0CTL |= MC_1 ; TA0CTL |= TAIE ; TA0CCR0 = 12500 ; <S2SV_StartBug> __enable_interrupt ( ) ; <S2SV_EndBug> } | <S2SV_ModStart> = 12500 ; initOptoCoupleur ( ) ; |
4,024 | CWE-000 double dvmh_omp_interval_productive_time ( dvmh_omp_interval_t * i ) { <S2SV_StartBug> return i -> used_time <S2SV_EndBug> - i -> sync_barrier_time - i -> idle_critical_time - i -> sync_flush_time ; } | <S2SV_ModStart> ) { return dvmh_omp_interval_used_time ( i ) - dvmh_omp_interval_sync_barrier_time ( i ) - dvmh_omp_interval_idle_critical_time ( i ) - dvmh_omp_interval_sync_flush_time ( i ) <S2SV_ModEnd> ; } <S2SV_null> |
4,025 | CWE-000 int32_t linenr ( CSOUND * csound , LINENR * p ) { IGN ( csound ) ; uint32_t offset = p -> h . insdshead -> ksmps_offset ; uint32_t early = p -> h . insdshead -> ksmps_no_end ; uint32_t flag = 0 , n , nsmps = CS_KSMPS ; <S2SV_StartBug> MYFLT * rs , * sg , val ; <S2SV_EndBug> int32_t asgsg = IS_ASIG_ARG ( p -> sig ) ; val = p -> val ; rs = p -> rslt ; sg = p -> sig ; if ( UNLIKELY ( offset ) ) memset ( rs , '\\0' , offset * sizeof ( MYFLT ) ) ; if ( UNLIKELY ( early ) ) { nsmps -= early ; memset ( & rs [ nsmps ] , '\\0' , early * sizeof ( MYFLT ) ) ; } for ( n = offset ; n < nsmps ; n ++ ) { if ( p -> cnt1 > 0L ) { flag = 1 ; val = p -> lin1 ; p -> lin1 += p -> inc1 ; p -> cnt1 -- ; } if ( p -> h . insdshead -> relesing ) { flag = 1 ; <S2SV_StartBug> val = p -> val2 ; <S2SV_EndBug> p -> val2 *= p -> mlt2 ; } if ( flag ) { if ( asgsg ) rs [ n ] = sg [ n ] * val ; else rs [ n ] = * sg * val ; } else { if ( asgsg ) rs [ n ] = sg [ n ] ; else rs [ n ] = * sg ; } } p -> val = val ; <S2SV_StartBug> p -> val2 = val ; <S2SV_EndBug> return OK ; } | <S2SV_ModStart> sg , val , val2 = p -> val2 <S2SV_ModStart> ; val = val2 ; <S2SV_ModEnd> val2 *= p <S2SV_ModStart> -> val2 = val2 <S2SV_ModEnd> ; return OK |
4,026 | CWE-000 <S2SV_StartBug> void gl4es_glDeleteRenderbuffers ( GLsizei n , GLuint * renderbuffers ) { <S2SV_EndBug> if ( glstate -> gl_batch ) flush ( ) ; LOAD_GLES_OES ( glDeleteRenderbuffers ) ; khint_t k ; if ( depthstencil ) for ( int i = 0 ; i < n ; i ++ ) { khint_t k ; gldepthstencil_t * dsr ; for ( int i = 0 ; i < n ; i ++ ) { GLuint t = renderbuffers [ i ] ; k = kh_get ( dsr , depthstencil , t ) ; if ( k != kh_end ( depthstencil ) ) { dsr = kh_value ( depthstencil , k ) ; gles_glDeleteRenderbuffers ( 1 , & dsr -> stencil ) ; kh_del ( dsr , depthstencil , k ) ; free ( dsr ) ; } } } errorGL ( ) ; gles_glDeleteRenderbuffers ( n , renderbuffers ) ; } | <S2SV_ModStart> renderbuffers ) { DBG ( printf ( "glDeleteRenderbuffer(%d,<S2SV_blank>%p)\\n" , n , renderbuffers ) ; ) |
4,027 | CWE-000 bool iptvx_config_init ( ) { bool result = false ; if ( iptvx_config_file_exists ( ) == true ) { config_init ( & cfg ) ; char * configFile = iptvx_get_config_filename ( ) ; if ( ! config_read_file ( & cfg , configFile ) ) { fprintf ( stderr , "Bad<S2SV_blank>configuration<S2SV_blank>file.\\n" "%s:%d<S2SV_blank>-<S2SV_blank>%s\\n" , config_error_file ( & cfg ) , config_error_line ( & cfg ) , config_error_text ( & cfg ) ) ; config_destroy ( & cfg ) ; } else { if ( iptvx_config_has_channels ( ) ) { char * data_dir = iptvx_config_get_data_dir ( ) ; GString * gs_data_dir = g_string_new ( data_dir ) ; if ( gs_data_dir -> len > 0 ) { result = true ; } else { printf ( "Data<S2SV_blank>directory<S2SV_blank>not<S2SV_blank>present<S2SV_blank>" "or<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>created.\\n" ) ; } <S2SV_StartBug> } else { <S2SV_EndBug> printf ( "No<S2SV_blank>channels<S2SV_blank>configured,<S2SV_blank>check<S2SV_blank>your<S2SV_blank>config.\\n" ) ; } } } return result ; } | <S2SV_ModStart> ) ; } g_string_free ( gs_data_dir , true ) ; |
4,028 | CWE-000 int main ( ) { int status ; <S2SV_StartBug> pthread_t thread_id [ THREADS_NUM ] ; <S2SV_EndBug> int thread_assign [ THREADS_NUM ] ; data . _counter = 0 ; for ( int i = 0 ; i < THREADS_NUM ; ++ i ) { thread_assign [ i ] = i ; status = pthread_create ( & thread_id [ i ] , NULL , assign_thread , & thread_assign [ i ] ) ; if ( status != 0 ) { fputs ( "error<S2SV_blank>creating<S2SV_blank>threads<S2SV_blank>in<S2SV_blank>main()" , stderr ) ; exit ( EXIT_FAILURE ) ; } } for ( int j = 0 ; j < THREADS_NUM / 2 ; ++ j ) { status = pthread_join ( thread_id [ j ] , NULL ) ; if ( status != 0 ) { fputs ( "Error<S2SV_blank>joining<S2SV_blank>threads<S2SV_blank>in<S2SV_blank>main()" , stderr ) ; exit ( EXIT_FAILURE ) ; } } data . _counter = STOP_VALUE ; pthread_cond_signal ( & cv ) ; for ( int k = THREADS_NUM / 2 ; k < THREADS_NUM ; ++ k ) { status = pthread_join ( thread_id [ k ] , NULL ) ; if ( status != 0 ) { fputs ( "Error<S2SV_blank>joining<S2SV_blank>threads<S2SV_blank>in<S2SV_blank>main()" , stderr ) ; exit ( EXIT_FAILURE ) ; } } pthread_mutex_destroy ( & mtx ) ; pthread_cond_destroy ( & cv ) ; exit ( EXIT_SUCCESS ) ; } | <S2SV_ModStart> [ THREADS_NUM ] ; srand ( ( unsigned ) time ( NULL ) ) |
4,029 | CWE-000 int main ( int argc , char * * argv ) { struct sockaddr_in servaddr ; if ( argc != 2 ) { fprintf ( stderr , "usage:<S2SV_blank>tcpcli<S2SV_blank><IPaddress>\\n" ) ; exit ( - 1 ) ; } <S2SV_StartBug> int sockfd = socket ( AF_INET , SOCK_STREAM , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> if ( sockfd < 0 ) { <S2SV_EndBug> perror ( "socket" ) ; exit ( - 1 ) ; } memset ( & servaddr , 0 , sizeof ( servaddr ) ) ; servaddr . sin_family = AF_INET ; servaddr . sin_port = htons ( LISTEN_PORT ) ; int ret = inet_pton ( AF_INET , argv [ 1 ] , & servaddr . sin_addr ) ; if ( ret == 0 ) { fprintf ( stderr , "inet_pton:<S2SV_blank>not<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>network<S2SV_blank>address.\\n" ) ; exit ( - 1 ) ; } else if ( ret == - 1 ) { perror ( "inet_pton" ) ; exit ( - 1 ) ; } <S2SV_StartBug> if ( connect ( sockfd , ( struct sockaddr * ) & servaddr , sizeof ( servaddr ) ) < 0 ) { <S2SV_EndBug> perror ( "connect" ) ; exit ( - 1 ) ; } <S2SV_StartBug> str_cli ( stdin , sockfd ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> } int sockfd [ 5 ] ; for ( int i = 0 ; i < 5 ; ++ i ) { sockfd [ i ] <S2SV_ModStart> if ( sockfd [ i ] <S2SV_ModStart> connect ( sockfd [ i ] <S2SV_ModStart> ) ; } } <S2SV_ModStart> stdin , sockfd [ 0 ] |
4,030 | CWE-000 static void hci_acl_create_connection_cancel ( struct hci_conn * conn ) { struct hci_cp_create_conn_cancel cp ; <S2SV_StartBug> BT_DBG ( "hcon<S2SV_blank>%pK" , conn ) ; <S2SV_EndBug> if ( conn -> hdev -> hci_ver < BLUETOOTH_VER_1_2 ) return ; bacpy ( & cp . bdaddr , & conn -> dst ) ; hci_send_cmd ( conn -> hdev , HCI_OP_CREATE_CONN_CANCEL , sizeof ( cp ) , & cp ) ; } | <S2SV_ModStart> ; BT_DBG ( "hcon<S2SV_blank>%p" <S2SV_ModEnd> , conn ) |
4,031 | CWE-000 void oom_kill_process ( struct task_struct * p , gfp_t gfp_mask , int order , unsigned int points , unsigned long totalpages , struct mem_cgroup * memcg , nodemask_t * nodemask , const char * message ) { struct task_struct * victim = p ; struct task_struct * child ; struct task_struct * t = p ; struct mm_struct * mm ; unsigned int victim_points = 0 ; static DEFINE_RATELIMIT_STATE ( oom_rs , DEFAULT_RATELIMIT_INTERVAL , DEFAULT_RATELIMIT_BURST ) ; if ( p -> flags & PF_EXITING ) { <S2SV_StartBug> set_tsk_thread_flag ( p , TIF_MEMDIE ) ; <S2SV_EndBug> put_task_struct ( p ) ; return ; } if ( __ratelimit ( & oom_rs ) ) dump_header ( p , gfp_mask , order , memcg , nodemask ) ; task_lock ( p ) ; pr_err ( "%s:<S2SV_blank>Kill<S2SV_blank>process<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>score<S2SV_blank>%d<S2SV_blank>or<S2SV_blank>sacrifice<S2SV_blank>child\\n" , message , task_pid_nr ( p ) , p -> comm , points ) ; task_unlock ( p ) ; read_lock ( & tasklist_lock ) ; do { list_for_each_entry ( child , & t -> children , sibling ) { unsigned int child_points ; enum oom_scan_t scan_result ; if ( child -> mm == p -> mm ) continue ; scan_result = oom_scan_process_thread ( child , totalpages , nodemask , false ) ; if ( scan_result == OOM_SCAN_CONTINUE || scan_result == OOM_SCAN_ABORT ) continue ; child_points = oom_badness ( child , memcg , nodemask , totalpages ) ; if ( child_points > victim_points ) { put_task_struct ( victim ) ; victim = child ; victim_points = child_points ; get_task_struct ( victim ) ; } } } while_each_thread ( p , t ) ; read_unlock ( & tasklist_lock ) ; rcu_read_lock ( ) ; p = find_lock_task_mm ( victim ) ; if ( ! p ) { rcu_read_unlock ( ) ; put_task_struct ( victim ) ; return ; } else if ( victim != p ) { get_task_struct ( p ) ; put_task_struct ( victim ) ; victim = p ; } mm = victim -> mm ; pr_err ( "Killed<S2SV_blank>process<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>total-vm:%lukB,<S2SV_blank>anon-rss:%lukB,<S2SV_blank>file-rss:%lukB\\n" , task_pid_nr ( victim ) , victim -> comm , K ( victim -> mm -> total_vm ) , K ( get_mm_counter ( victim -> mm , MM_ANONPAGES ) ) , K ( get_mm_counter ( victim -> mm , MM_FILEPAGES ) ) ) ; task_unlock ( victim ) ; for_each_process ( p ) if ( p -> mm == mm && ! same_thread_group ( p , victim ) && ! ( p -> flags & PF_KTHREAD ) ) { if ( p -> signal -> oom_score_adj == OOM_SCORE_ADJ_MIN ) continue ; task_lock ( p ) ; pr_err ( "Kill<S2SV_blank>process<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>sharing<S2SV_blank>same<S2SV_blank>memory\\n" , task_pid_nr ( p ) , p -> comm ) ; task_unlock ( p ) ; do_send_sig_info ( SIGKILL , SEND_SIG_FORCED , p , true ) ; } rcu_read_unlock ( ) ; set_tsk_thread_flag ( victim , TIF_MEMDIE ) ; <S2SV_StartBug> do_send_sig_info ( SIGKILL , SEND_SIG_FORCED , victim , true ) ; <S2SV_EndBug> put_task_struct ( victim ) ; } | <S2SV_ModStart> , TIF_MEMDIE ) ; last_victim = jiffies <S2SV_ModStart> TIF_MEMDIE ) ; last_victim = jiffies ; |
4,032 | CWE-000 void GameAssignRunwaytoAircraft ( TYPE_PLAYER * ptrPlayer , TYPE_FLIGHT_DATA * ptrFlightData ) { uint16_t assignedRwy = GameRwy [ ptrPlayer -> SelectedRunway ] ; uint8_t aircraftIndex = ptrPlayer -> FlightDataSelectedAircraft ; uint16_t rwyExit ; uint32_t i ; uint16_t targets [ AIRCRAFT_MAX_TARGETS ] = { 0 } ; uint8_t rwyTiles [ GAME_MAX_RWY_LENGTH ] = { 0 } ; dprintf ( "aircraftIndex<S2SV_blank>=<S2SV_blank>%d\\n" , aircraftIndex ) ; if ( ptrFlightData -> State [ aircraftIndex ] == STATE_APPROACH ) { ptrFlightData -> State [ aircraftIndex ] = STATE_FINAL ; GameScore += SCORE_REWARD_FINAL ; GameGetSelectedRunwayArray ( assignedRwy ) ; for ( i = 0 ; i < GAME_MAX_RWY_LENGTH ; i ++ ) { rwyTiles [ i ] = GameLevelBuffer [ GameRwyArray [ i ] ] ; } i = SystemIndexOf_U8 ( ( uint8_t ) TILE_RWY_EXIT , rwyTiles , 0 , GAME_MAX_RWY_LENGTH ) ; if ( i == - 1 ) { dprintf ( "ERROR:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>TILE_RWY_EXIT<S2SV_blank>for<S2SV_blank>runway<S2SV_blank>header<S2SV_blank>%d.\\n" , assignedRwy ) ; return ; } i = SystemIndexOf_U8 ( ( uint8_t ) TILE_RWY_EXIT , rwyTiles , i + 1 , GAME_MAX_RWY_LENGTH ) ; if ( i == - 1 ) { dprintf ( "ERROR:<S2SV_blank>Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>second<S2SV_blank>TILE_RWY_EXIT<S2SV_blank>for<S2SV_blank>runway<S2SV_blank>header<S2SV_blank>%d.\\n" , assignedRwy ) ; return ; } rwyExit = GameRwyArray [ i ] ; targets [ 0 ] = assignedRwy ; targets [ 1 ] = rwyExit ; if ( AircraftAddNew ( ptrFlightData , aircraftIndex , targets ) == false ) { dprintf ( "Exceeded<S2SV_blank>maximum<S2SV_blank>aircraft<S2SV_blank>number!\\n" ) ; return ; } } else if ( ptrFlightData -> State [ aircraftIndex ] == STATE_HOLDING_RWY ) { TYPE_RWY_ENTRY_DATA rwyEntryData ; uint8_t i ; GameGetRunwayEntryTile ( aircraftIndex , & rwyEntryData ) ; targets [ 0 ] = rwyEntryData . rwyEntryTile ; targets [ 1 ] = targets [ 0 ] + rwyEntryData . rwyStep ; dprintf ( "Added<S2SV_blank>the<S2SV_blank>following<S2SV_blank>targets<S2SV_blank>=<S2SV_blank>" ) ; for ( i = 0 ; i < ( sizeof ( targets ) / sizeof ( targets [ 0 ] ) ) ; i ++ ) { dprintf ( "%d<S2SV_blank>" , targets [ i ] ) ; } dprintf ( "\\n" ) ; AircraftAddTargets ( AircraftFromFlightDataIndex ( aircraftIndex ) , targets ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> targets ) ; ptrFlightData -> State [ aircraftIndex ] = STATE_ENTERING_RWY ; |
4,033 | CWE-000 static cairo_region_t * gimp_canvas_text_cursor_get_extents ( GimpCanvasItem * item ) { GimpCanvasTextCursorPrivate * private = GET_PRIVATE ( item ) ; cairo_rectangle_int_t rectangle ; gdouble x , y ; gdouble w , h ; gimp_canvas_text_cursor_transform ( item , & x , & y , & w , & h ) ; if ( private -> overwrite ) { rectangle . x = floor ( x - 1.5 ) ; rectangle . y = floor ( y - 1.5 ) ; rectangle . width = ceil ( w + 3.0 ) ; rectangle . height = ceil ( h + 3.0 ) ; } else { <S2SV_StartBug> rectangle . x = floor ( x - 4.5 ) ; <S2SV_EndBug> rectangle . y = floor ( y - 1.5 ) ; rectangle . width = ceil ( 9.0 ) ; <S2SV_StartBug> rectangle . height = ceil ( h + 3.0 ) ; <S2SV_EndBug> } return cairo_region_create_rectangle ( & rectangle ) ; } | <S2SV_ModStart> } else { switch ( private -> direction ) { case GIMP_TEXT_DIRECTION_LTR : case GIMP_TEXT_DIRECTION_RTL : <S2SV_ModStart> 3.0 ) ; break ; case GIMP_TEXT_DIRECTION_TTB_RTL : case GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT : case GIMP_TEXT_DIRECTION_TTB_LTR : case GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT : rectangle . x = floor ( x - 1.5 ) ; rectangle . y = floor ( y - 4.5 ) ; rectangle . width = ceil ( w + 3.0 ) ; rectangle . height = ceil ( 9.0 ) ; break ; } |
4,034 | CWE-000 int Sprimme ( REAL * evals , SCALAR * evecs , REAL * resNorms , primme_params * primme ) { int ret ; int * perm ; double machEps ; primme_wTimer ( 1 ) ; machEps = MACHINE_EPSILON ; <S2SV_StartBug> primme_set_defaults ( primme ) ; <S2SV_EndBug> if ( evals == NULL && evecs == NULL && resNorms == NULL ) return allocate_workspace ( primme , FALSE ) ; if ( primme -> iseed [ 0 ] < 0 || primme -> iseed [ 0 ] > 4095 ) primme -> iseed [ 0 ] = primme -> procID % 4096 ; if ( primme -> iseed [ 1 ] < 0 || primme -> iseed [ 1 ] > 4095 ) primme -> iseed [ 1 ] = ( int ) ( primme -> procID / 4096 + 1 ) % 4096 ; if ( primme -> iseed [ 2 ] < 0 || primme -> iseed [ 2 ] > 4095 ) primme -> iseed [ 2 ] = ( int ) ( ( primme -> procID / 4096 ) / 4096 + 2 ) % 4096 ; if ( primme -> iseed [ 3 ] < 0 || primme -> iseed [ 3 ] > 4095 ) primme -> iseed [ 3 ] = ( 2 * ( int ) ( ( ( primme -> procID / 4096 ) / 4096 ) / 4096 ) + 1 ) % 4096 ; if ( ! primme -> convTestFun ) { primme -> convTestFun = convTestFunAbsolute ; if ( primme -> eps == 0.0 ) { primme -> eps = machEps * 1e4 ; } } if ( ! primme -> monitorFun ) { primme -> monitorFun = default_monitor ; } CHKERRNOABORT ( ret = check_input ( evals , evecs , resNorms , primme ) , ret ) ; CHKERRNOABORT ( allocate_workspace ( primme , TRUE ) , ALLOCATE_WORKSPACE_FAILURE ) ; CHKERRNOABORT ( MALLOC_PRIMME ( primme -> numEvals , & perm ) , MALLOC_FAILURE ) ; CHKERRNOABORT ( main_iter_Sprimme ( evals , perm , evecs , primme -> ldevecs , resNorms , machEps , primme -> intWork , primme -> realWork , primme ) , MAIN_ITER_FAILURE ) ; assert ( primme -> realWorkSize >= sizeof ( SCALAR ) * primme -> nLocal && primme -> intWorkSize >= ( int ) sizeof ( int ) * primme -> initSize ) ; permute_vecs_Sprimme ( & evecs [ primme -> numOrthoConst * primme -> ldevecs ] , primme -> nLocal , primme -> initSize , primme -> ldevecs , perm , ( SCALAR * ) primme -> realWork , ( int * ) primme -> intWork ) ; free ( perm ) ; primme -> stats . elapsedTime = primme_wTimer ( 0 ) ; return ( 0 ) ; } | <S2SV_ModStart> primme ) ; if ( primme -> orth == primme_orth_default ) { # ifdef USE_FLOAT if ( primme -> target == primme_largest || primme -> target == primme_smallest ) { primme -> orth = primme_orth_explicit_I ; } else # endif primme -> orth = primme_orth_implicit_I ; } |
4,035 | CWE-000 SYSCALL_DEFINE2 ( setns , int , fd , int , nstype ) { struct task_struct * tsk = current ; struct nsproxy * new_nsproxy ; struct file * file ; struct ns_common * ns ; int err ; file = proc_ns_fget ( fd ) ; if ( IS_ERR ( file ) ) return PTR_ERR ( file ) ; err = - EINVAL ; ns = get_proc_ns ( file_inode ( file ) ) ; if ( nstype && ( ns -> ops -> type != nstype ) ) goto out ; new_nsproxy = create_new_namespaces ( 0 , tsk , current_user_ns ( ) , tsk -> fs ) ; if ( IS_ERR ( new_nsproxy ) ) { err = PTR_ERR ( new_nsproxy ) ; goto out ; } err = ns -> ops -> install ( new_nsproxy , ns ) ; if ( err ) { free_nsproxy ( new_nsproxy ) ; goto out ; } switch_task_namespaces ( tsk , new_nsproxy ) ; <S2SV_StartBug> out : <S2SV_EndBug> fput ( file ) ; return err ; } | <S2SV_ModStart> new_nsproxy ) ; perf_event_namespaces ( tsk ) ; |
4,036 | CWE-000 RTT_TEST_END RTT_TEST_START ( skal_net_unix_stream_should_close_server ) { <S2SV_StartBug> RTT_EXPECT ( SkalNetSocketDestroy ( gNet , gServerSockid ) ) ; <S2SV_EndBug> gServerSockid = - 1 ; } | <S2SV_ModStart> skal_net_unix_stream_should_close_server ) { <S2SV_ModEnd> SkalNetSocketDestroy ( gNet <S2SV_ModStart> gNet , gServerSockid <S2SV_ModEnd> ) ; gServerSockid |
4,037 | CWE-000 HIDDEN float <S2SV_StartBug> __math_divzerof ( unsigned long sign ) <S2SV_EndBug> { float y = 0 ; return with_errnof ( ( sign ? - 1 : 1 ) / y , ERANGE ) ; } | <S2SV_ModStart> float __math_divzerof ( uint32_t <S2SV_ModEnd> sign ) { |
4,038 | CWE-000 int hcsr04_file_open ( struct inode * inode , struct file * filp ) { struct hcsr04_data * pdata ; pdata = container_of ( inode -> i_cdev , struct hcsr04_data , cdev ) ; <S2SV_StartBug> filp -> private_data = pdata ; <S2SV_EndBug> if ( IS_ERR_VALUE ( request_irq ( pdata -> irq , hcsr04_echo_interrupt , IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "proximity" , pdata ) ) ) { goto err_file_open ; } INIT_DELAYED_WORK ( & pdata -> begin_dwork , hcsr04_sample_work ) ; schedule_delayed_work ( & pdata -> begin_dwork , 0 ) ; <S2SV_StartBug> pdata -> reading = 1 ; <S2SV_EndBug> <S2SV_StartBug> dev_dbg ( & pdata -> pdev -> dev , "file<S2SV_blank>open<S2SV_blank>succeeded:<S2SV_blank>scheduled<S2SV_blank>immediate<S2SV_blank>sensor<S2SV_blank>polling\\n" ) ; <S2SV_EndBug> return 0 ; err_file_open : dev_err ( & pdata -> pdev -> dev , "can\'t<S2SV_blank>request<S2SV_blank>echo<S2SV_blank>irq<S2SV_blank>for<S2SV_blank>rising/falling<S2SV_blank>detection\\n" ) ; <S2SV_StartBug> pdata -> reading = 0 ; <S2SV_EndBug> dev_err ( & pdata -> pdev -> dev , "file<S2SV_blank>open<S2SV_blank>error\\n" ) ; return - ENODEV ; } | <S2SV_ModStart> = pdata ; if ( pdata -> count == 0 ) { <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> dev_dbg ( & <S2SV_ModStart> , "file<S2SV_blank>open<S2SV_blank>succeeded:<S2SV_blank>scheduled<S2SV_blank>immediate<S2SV_blank>sensor<S2SV_blank>polling\\n" ) ; } pdata -> count ++ <S2SV_ModStart> ; pdata -> count <S2SV_ModEnd> = 0 ; |
4,039 | CWE-000 int add_node ( Node_Dir * nd , Node * node ) { if ( ( nd -> cur_nodes ) < ( nd -> max_nodes ) ) { <S2SV_StartBug> nd -> cur_nodes ++ ; <S2SV_EndBug> <S2SV_StartBug> nd -> ( n_array [ cur_nodes ] ) = node ; <S2SV_EndBug> return 1 ; } return 0 ; } | <S2SV_ModStart> ) ) { int n = ( <S2SV_ModStart> nd -> cur_nodes ) + 1 <S2SV_ModEnd> ; nd -> <S2SV_ModStart> ; nd -> n_array [ n ] = node ; nd -> cur_nodes = n <S2SV_ModEnd> ; return 1 |
4,040 | CWE-000 asmlinkage void decompress_kernel ( void * rmode , memptr heap , unsigned char * input_data , unsigned long input_len , unsigned char * output ) { real_mode = rmode ; if ( cmdline_find_option_bool ( "quiet" ) ) quiet = 1 ; if ( cmdline_find_option_bool ( "debug" ) ) debug = 1 ; if ( real_mode -> screen_info . orig_video_mode == 7 ) { vidmem = ( char * ) 0xb0000 ; vidport = 0x3b4 ; } else { vidmem = ( char * ) 0xb8000 ; vidport = 0x3d4 ; } lines = real_mode -> screen_info . orig_video_lines ; cols = real_mode -> screen_info . orig_video_cols ; console_init ( ) ; if ( debug ) putstr ( "early<S2SV_blank>console<S2SV_blank>in<S2SV_blank>decompress_kernel\\n" ) ; free_mem_ptr = heap ; free_mem_end_ptr = heap + BOOT_HEAP_SIZE ; if ( ( unsigned long ) output & ( MIN_KERNEL_ALIGN - 1 ) ) error ( "Destination<S2SV_blank>address<S2SV_blank>inappropriately<S2SV_blank>aligned" ) ; # ifdef CONFIG_X86_64 if ( heap > 0x3fffffffffffUL ) error ( "Destination<S2SV_blank>address<S2SV_blank>too<S2SV_blank>large" ) ; # else if ( heap > ( ( - __PAGE_OFFSET - ( 128 << 20 ) - 1 ) & 0x7fffffff ) ) error ( "Destination<S2SV_blank>address<S2SV_blank>too<S2SV_blank>large" ) ; # endif # ifndef CONFIG_RELOCATABLE if ( ( unsigned long ) output != LOAD_PHYSICAL_ADDR ) error ( "Wrong<S2SV_blank>destination<S2SV_blank>address" ) ; # endif if ( ! quiet ) putstr ( "\\nDecompressing<S2SV_blank>Linux...<S2SV_blank>" ) ; <S2SV_StartBug> decompress ( input_data , input_len , NULL , NULL , output , NULL , error ) ; <S2SV_EndBug> parse_elf ( output ) ; if ( ! quiet ) putstr ( "done.\\nBooting<S2SV_blank>the<S2SV_blank>kernel.\\n" ) ; return ; } | <S2SV_ModStart> "\\nDecompressing<S2SV_blank>Linux...<S2SV_blank>" ) ; __decompress <S2SV_ModEnd> ( input_data , <S2SV_ModStart> , output , output_len , |
4,041 | CWE-000 static int sti_compositor_bind ( struct device * dev , struct device * master , void * data ) { struct sti_compositor * compo = dev_get_drvdata ( dev ) ; struct drm_device * drm_dev = data ; unsigned int i , mixer_id = 0 , vid_id = 0 , crtc_id = 0 ; struct sti_private * dev_priv = drm_dev -> dev_private ; struct drm_plane * cursor = NULL ; struct drm_plane * primary = NULL ; struct sti_compositor_subdev_descriptor * desc = compo -> data . subdev_desc ; unsigned int array_size = compo -> data . nb_subdev ; dev_priv -> compo = compo ; for ( i = 0 ; i < array_size ; i ++ ) { switch ( desc [ i ] . type ) { case STI_VID_SUBDEV : compo -> vid [ vid_id ++ ] = sti_vid_create ( compo -> dev , drm_dev , desc [ i ] . id , compo -> regs + desc [ i ] . offset ) ; break ; case STI_MIXER_MAIN_SUBDEV : case STI_MIXER_AUX_SUBDEV : compo -> mixer [ mixer_id ++ ] = sti_mixer_create ( compo -> dev , drm_dev , desc [ i ] . id , compo -> regs + desc [ i ] . offset ) ; break ; case STI_GPD_SUBDEV : case STI_CURSOR_SUBDEV : break ; default : DRM_ERROR ( "Unknow<S2SV_blank>subdev<S2SV_blank>compoment<S2SV_blank>type\\n" ) ; return 1 ; } } for ( i = 0 ; i < array_size ; i ++ ) { enum drm_plane_type plane_type = DRM_PLANE_TYPE_OVERLAY ; if ( crtc_id < mixer_id ) plane_type = DRM_PLANE_TYPE_PRIMARY ; switch ( desc [ i ] . type ) { case STI_MIXER_MAIN_SUBDEV : case STI_MIXER_AUX_SUBDEV : case STI_VID_SUBDEV : break ; case STI_CURSOR_SUBDEV : cursor = sti_cursor_create ( drm_dev , compo -> dev , desc [ i ] . id , compo -> regs + desc [ i ] . offset , 1 ) ; if ( ! cursor ) { DRM_ERROR ( "Can\'t<S2SV_blank>create<S2SV_blank>CURSOR<S2SV_blank>plane\\n" ) ; break ; } break ; case STI_GPD_SUBDEV : primary = sti_gdp_create ( drm_dev , compo -> dev , desc [ i ] . id , compo -> regs + desc [ i ] . offset , ( 1 << mixer_id ) - 1 , plane_type ) ; if ( ! primary ) { DRM_ERROR ( "Can\'t<S2SV_blank>create<S2SV_blank>GDP<S2SV_blank>plane\\n" ) ; break ; } break ; default : <S2SV_StartBug> DRM_ERROR ( "Unknown<S2SV_blank>subdev<S2SV_blank>compoment<S2SV_blank>type\\n" ) ; <S2SV_EndBug> return 1 ; } if ( crtc_id < mixer_id && primary ) { sti_crtc_init ( drm_dev , compo -> mixer [ crtc_id ] , primary , cursor ) ; crtc_id ++ ; cursor = NULL ; primary = NULL ; } } drm_vblank_init ( drm_dev , crtc_id ) ; drm_dev -> irq_enabled = 1 ; return 0 ; } | <S2SV_ModStart> : DRM_ERROR ( "Unknown<S2SV_blank>subdev<S2SV_blank>component<S2SV_blank>type\\n" <S2SV_ModEnd> ) ; return |
4,042 | CWE-000 static int str_is_inline ( const str * self ) { <S2SV_StartBug> return ( ( ( const str_alloc * ) self ) -> _cap & 1 ) == 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ( ( const char <S2SV_ModEnd> * ) self <S2SV_ModStart> ) self ) [ sizeof ( str ) - 1 ] <S2SV_ModEnd> & 1 ) |
4,043 | CWE-000 void msm_camera_io_memcpy ( void __iomem * dest_addr , void __iomem * src_addr , u32 len ) { <S2SV_StartBug> CDBG ( "%s:<S2SV_blank>%p<S2SV_blank>%p<S2SV_blank>%d\\n" , __func__ , dest_addr , src_addr , len ) ; <S2SV_EndBug> msm_camera_io_memcpy_toio ( dest_addr , src_addr , len / 4 ) ; msm_camera_io_dump ( dest_addr , len ) ; } | <S2SV_ModStart> { CDBG ( "%s:<S2SV_blank>%pK<S2SV_blank>%pK<S2SV_blank>%d\\n" <S2SV_ModEnd> , __func__ , |
4,044 | CWE-000 static int ext4_fs_init_inode_table ( struct ext4_block_group_ref * bg_ref ) { struct ext4_sblock * sb = & bg_ref -> fs -> sb ; struct ext4_bgroup * bg = bg_ref -> block_group ; <S2SV_StartBug> uint32_t inode_size = ext4_get32 ( sb , inode_size ) ; <S2SV_EndBug> uint32_t block_size = ext4_sb_get_block_size ( sb ) ; uint32_t inodes_per_block = block_size / inode_size ; uint32_t inodes_in_group = ext4_inodes_in_group_cnt ( sb , bg_ref -> index ) ; uint32_t table_blocks = inodes_in_group / inodes_per_block ; ext4_fsblk_t fblock ; if ( inodes_in_group % inodes_per_block ) table_blocks ++ ; ext4_fsblk_t first_block = ext4_bg_get_inode_table_first_block ( bg , sb ) ; ext4_fsblk_t last_block = first_block + table_blocks - 1 ; for ( fblock = first_block ; fblock <= last_block ; ++ fblock ) { struct ext4_block b ; int rc = ext4_trans_block_get_noread ( bg_ref -> fs -> bdev , & b , fblock ) ; if ( rc != EOK ) return rc ; memset ( b . data , 0 , block_size ) ; ext4_trans_set_block_dirty ( b . buf ) ; ext4_block_set ( bg_ref -> fs -> bdev , & b ) ; if ( rc != EOK ) return rc ; } return EOK ; } | <S2SV_ModStart> uint32_t inode_size = ext4_get16 <S2SV_ModEnd> ( sb , |
4,045 | CWE-000 void mtk_list_destroy ( mtk_list_t * list ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> list ) { mtk_list_elem_t * elem , * t ; elem = list -> first ; while ( elem != NULL ) { t = elem ; elem = elem -> next ; mtk_list_elem_destroy ( list , t ) ; } free ( list ) ; |
4,046 | CWE-000 int main ( ) { clear ( ) ; cli ( ) ; initializeKernelHeap ( ) ; setUpSystemCalls ( ) ; terminalInitializeC ( ) ; loadIDT ( ) ; mouse_init ( ) ; enablePIC ( ) ; printMsg ( 0 , 0 , "Arquitectura<S2SV_blank>de<S2SV_blank>computadoras" , 0x0F ) ; ncPrint ( "H" ) ; printMsg ( 1 , 0 , "La<S2SV_blank>hora<S2SV_blank>local<S2SV_blank>es:" , 0x0F ) ; <S2SV_StartBug> mapModulesLogical ( ( void * ) 0xC00000 ) ; <S2SV_EndBug> updateCR3 ( ) ; ncPrint ( "checkpoint<S2SV_blank>1" ) ; resetBuffer ( ) ; ncPrint ( "checkpoint<S2SV_blank>2" ) ; createHeap ( ) ; ncPrint ( "checkpoint<S2SV_blank>3" ) ; initializeMutexes ( ) ; ncPrint ( "checkpoint<S2SV_blank>4" ) ; initializeSemaphores ( ) ; ncPrint ( "checkpoint<S2SV_blank>5" ) ; createProcess ( init , "init" ) ; <S2SV_StartBug> createProcess ( processA , "process<S2SV_blank>A" ) ; <S2SV_EndBug> createProcess ( processB , "process<S2SV_blank>B" ) ; createProcess ( currentAddress , "SHELL" ) ; createProcess ( mainPC , "PRODCONS" ) ; ncPrint ( "checkpoint<S2SV_blank>6" ) ; finishStartup ( ) ; while ( 1 ) ; } | <S2SV_ModStart> void * ) shellAddress <S2SV_ModEnd> ) ; updateCR3 <S2SV_ModStart> ; createProcess ( shellAddress , "SHELL" <S2SV_ModEnd> ) ; ncPrint |
4,047 | CWE-000 void usage ( char * * argv ) { <S2SV_StartBug> fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[-i<S2SV_blank>/dev/i2c-X]<S2SV_blank>[-d]<S2SV_blank>{<S2SV_blank>-up<S2SV_blank>|<S2SV_blank>-dn<S2SV_blank>|<S2SV_blank>-t<S2SV_blank>freq-in-10khz<S2SV_blank>|<S2SV_blank>-r<S2SV_blank>srate<S2SV_blank>|<S2SV_blank>-ts<S2SV_blank>|<S2SV_blank>-s<S2SV_blank>}\\n" ) ; <S2SV_EndBug> fprintf ( stderr , "<S2SV_blank>e.g.:<S2SV_blank>%s<S2SV_blank>-i<S2SV_blank>/dev/i2c-2<S2SV_blank>-up<S2SV_blank>-t<S2SV_blank>9380<S2SV_blank>for<S2SV_blank>93800khz\\n" , argv [ 0 ] ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank>or:<S2SV_blank>%s<S2SV_blank>-dn<S2SV_blank>to<S2SV_blank>power<S2SV_blank>off\\n" , argv [ 0 ] ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[-i<S2SV_blank>/dev/i2c-X]<S2SV_blank>[-d]<S2SV_blank>{<S2SV_blank>-up<S2SV_blank>|<S2SV_blank>-t<S2SV_blank>freq-in-10khz<S2SV_blank>|<S2SV_blank>-r<S2SV_blank>srate<S2SV_blank>|<S2SV_blank>-ts<S2SV_blank>|<S2SV_blank>-s<S2SV_blank>|<S2SV_blank>-rds<S2SV_blank>|<S2SV_blank>-dn<S2SV_blank>}\\n" , argv [ 0 ] <S2SV_ModEnd> ) ; fprintf <S2SV_ModStart> ] ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-i<S2SV_blank>choose<S2SV_blank>i2c<S2SV_blank>device\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-d<S2SV_blank>debug\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-up<S2SV_blank>power<S2SV_blank>on<S2SV_blank>and<S2SV_blank>chip<S2SV_blank>revision\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-dn<S2SV_blank>power<S2SV_blank>off\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-t<S2SV_blank>tune<S2SV_blank>to<S2SV_blank>given<S2SV_blank>frequency\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-r<S2SV_blank>specify<S2SV_blank>sample<S2SV_blank>rate\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-ts<S2SV_blank>report<S2SV_blank>tune<S2SV_blank>status\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-s<S2SV_blank>report<S2SV_blank>signal<S2SV_blank>status\\n" ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>-rds<S2SV_blank>report<S2SV_blank>RDS<S2SV_blank>status\\n" ) ; |
4,048 | CWE-000 static int refresh ( int fbfd , struct mxcfb_rect region , bool is_flashing ) { struct mxcfb_update_data update = { . temp = TEMP_USE_AMBIENT , . update_marker = ( uint32_t ) getpid ( ) , . update_mode = is_flashing ? UPDATE_MODE_FULL : UPDATE_MODE_PARTIAL , . update_region = region , . waveform_mode = is_flashing ? WAVEFORM_MODE_GC16 : WAVEFORM_MODE_AUTO , . flags = 0U , } ; if ( update . update_marker == 0U ) { update . update_marker = ( 70U + 66U + 73U + 78U + 75U ) ; } if ( ioctl ( fbfd , MXCFB_SEND_UPDATE , & update ) < 0 ) { char buf [ 256 ] ; char * errstr = strerror_r ( errno , buf , sizeof ( buf ) ) ; fprintf ( stderr , "[FBInk]<S2SV_blank>MXCFB_SEND_UPDATE:<S2SV_blank>%s\\n" , errstr ) ; return EXIT_FAILURE ; } if ( is_flashing ) { # ifdef FBINK_FOR_KINDLE struct mxcfb_update_marker_data update_marker = { . update_marker = update . update_marker , . collision_test = 0 , } ; bool failed = false ; if ( ioctl ( fbfd , MXCFB_WAIT_FOR_UPDATE_COMPLETE , & update_marker ) < 0 ) { char buf [ 256 ] ; char * errstr = strerror_r ( errno , buf , sizeof ( buf ) ) ; fprintf ( stderr , "[FBInk]<S2SV_blank>MXCFB_WAIT_FOR_UPDATE_COMPLETE:<S2SV_blank>%s\\n" , errstr ) ; failed = true ; if ( ioctl ( fbfd , MXCFB_WAIT_FOR_UPDATE_COMPLETE_PEARL , & update . update_marker ) < 0 ) { errstr = strerror_r ( errno , buf , sizeof ( buf ) ) ; <S2SV_StartBug> fprintf ( stderr , "[FBInk]<S2SV_blank>MXCFB_WAIT_FOR_UPDATE_COMPLETE:<S2SV_blank>%s\\n" , errstr ) ; <S2SV_EndBug> failed = true ; } else { failed = false ; } } if ( failed ) { return EXIT_FAILURE ; } # else if ( ioctl ( fbfd , MXCFB_WAIT_FOR_UPDATE_COMPLETE , & update . update_marker ) < 0 ) { { char buf [ 256 ] ; char * errstr = strerror_r ( errno , buf , sizeof ( buf ) ) ; fprintf ( stderr , "[FBInk]<S2SV_blank>MXCFB_WAIT_FOR_UPDATE_COMPLETE:<S2SV_blank>%s\\n" , errstr ) ; return EXIT_FAILURE ; } } # endif } return EXIT_SUCCESS ; } | <S2SV_ModStart> ( stderr , "[FBInk]<S2SV_blank>MXCFB_WAIT_FOR_UPDATE_COMPLETE_PEARL:<S2SV_blank>%s\\n" <S2SV_ModEnd> , errstr ) |
4,049 | CWE-000 void ff_h264_flush_change ( H264Context * h ) { int i , j ; h -> next_outputed_poc = INT_MIN ; <S2SV_StartBug> h -> prev_interlaced_frame = 1 ; <S2SV_EndBug> idr ( h ) ; h -> poc . prev_frame_num = - 1 ; if ( h -> cur_pic_ptr ) { h -> cur_pic_ptr -> reference = 0 ; for ( j = i = 0 ; h -> delayed_pic [ i ] ; i ++ ) if ( h -> delayed_pic [ i ] != h -> cur_pic_ptr ) h -> delayed_pic [ j ++ ] = h -> delayed_pic [ i ] ; h -> delayed_pic [ j ] = NULL ; } ff_h264_unref_picture ( h , & h -> last_pic_for_ec ) ; h -> first_field = 0 ; ff_h264_sei_uninit ( & h -> sei ) ; h -> recovery_frame = - 1 ; h -> frame_recovered = 0 ; h -> current_slice = 0 ; h -> mmco_reset = 1 ; } | <S2SV_ModStart> prev_interlaced_frame = 1 ; h -> got_first_iframe = 0 |
4,050 | CWE-000 void <S2SV_StartBug> platform_free_rwe ( const void * addr , uint64_t len ) <S2SV_EndBug> { bfignored ( len ) ; <S2SV_StartBug> free ( ( void * ) addr ) ; <S2SV_EndBug> } | <S2SV_ModStart> void platform_free_rwe ( <S2SV_ModEnd> void * addr <S2SV_ModStart> ; free ( <S2SV_ModEnd> addr ) ; |
4,051 | CWE-000 CK_RV sks_ck_token_mechanism_ids ( CK_SLOT_ID slot , CK_MECHANISM_TYPE_PTR mechanisms , CK_ULONG_PTR count ) { uint32_t ctrl [ 1 ] = { slot } ; <S2SV_StartBug> uint32_t outsize = * count * sizeof ( uint32_t ) ; <S2SV_EndBug> void * outbuf ; CK_RV rv ; outbuf = malloc ( outsize ) ; if ( ! outbuf ) return CKR_HOST_MEMORY ; rv = ck_invoke_ta ( NULL , SKS_CMD_CK_MECHANISM_IDS , & ctrl , sizeof ( ctrl ) , NULL , 0 , outbuf , & outsize ) ; if ( rv == CKR_OK || rv == CKR_BUFFER_TOO_SMALL ) * count = outsize / sizeof ( uint32_t ) ; if ( rv ) goto bail ; if ( sks2ck_mechanism_type_list ( mechanisms , outbuf , * count ) ) { LOG_ERROR ( "unexpected<S2SV_blank>bad<S2SV_blank>mechanism_type<S2SV_blank>list\\n" ) ; rv = CKR_DEVICE_ERROR ; } bail : free ( outbuf ) ; return rv ; } | <S2SV_ModStart> slot } ; size_t <S2SV_ModEnd> outsize = * |
4,052 | CWE-000 void SecondTaskEventDispatch ( MQTT_Event_t * pEvent ) { switch ( pEvent -> id ) { <S2SV_StartBug> case MQTT_EVENT_CONNECTED : <S2SV_EndBug> Trace ( 1 , "MQTT<S2SV_blank>connected,<S2SV_blank>now<S2SV_blank>subscribe<S2SV_blank>topic:%s" , SUBSCRIBE_TOPIC ) ; MQTT_Error_t err ; MQTT_SetInPubCallback ( pEvent -> client , OnMqttReceived , OnMqttReceiedData , NULL ) ; err = MQTT_Subscribe ( pEvent -> client , SUBSCRIBE_TOPIC , 2 , OnMqttSubscribed , ( void * ) SUBSCRIBE_TOPIC ) ; if ( err != MQTT_ERROR_NONE ) Trace ( 1 , "MQTT<S2SV_blank>subscribe<S2SV_blank>error,<S2SV_blank>error<S2SV_blank>code:%d" , err ) ; StartTimerPublish ( PUBLISH_INTERVAL , pEvent -> client ) ; break ; <S2SV_StartBug> default : <S2SV_EndBug> break ; } } | <S2SV_ModStart> case MQTT_EVENT_CONNECTED : mqttStatus = MQTT_STATUS_CONNECTED ; <S2SV_ModStart> ; break ; case MQTT_EVENT_DISCONNECTED : mqttStatus = MQTT_STATUS_DISCONNECTED ; break ; |
4,053 | CWE-000 int Push_PointQueue ( PointQueue * queue , int x , int y ) { <S2SV_StartBug> return Enqueue_PointQueue ( queue , int x , int y ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( queue , x , <S2SV_ModEnd> y ) ; |
4,054 | CWE-000 PROCESS_THREAD ( StopBlinkingProcess , ev , data ) { static struct etimer et_stop_blinking ; PROCESS_BEGIN ( ) ; etimer_set ( & et_stop_blinking , 16 * CLOCK_SECOND ) ; PROCESS_WAIT_EVENT_UNTIL ( etimer_expired ( & et_stop_blinking ) ) ; process_exit ( & BlinkingProcess ) ; <S2SV_StartBug> leds_set ( led_status ) ; <S2SV_EndBug> PROCESS_END ( ) ; } | <S2SV_ModStart> BlinkingProcess ) ; <S2SV_ModEnd> PROCESS_END ( ) |
4,055 | CWE-000 static mrb_value mrb_exec_do_exec ( mrb_state * mrb , mrb_value self ) { mrb_value * mrb_argv ; mrb_int len ; char * * result ; mrb_get_args ( mrb , "*" , & mrb_argv , & len ) ; result = ( char * * ) mrb_malloc ( mrb , sizeof ( char * ) * ( len + 1 ) ) ; if ( mrb_value_to_strv ( mrb , mrb_argv , len , result ) < 0 ) { <S2SV_StartBug> mrb_sys_fail ( mrb , "[BUG]<S2SV_blank>mrb_value_to_strv<S2SV_blank>failed" ) ; <S2SV_EndBug> } <S2SV_StartBug> execv ( result [ 0 ] , result ) ; <S2SV_EndBug> mrb_exec_sys_fail ( mrb , errno , "execv<S2SV_blank>failed" ) ; return mrb_nil_value ( ) ; } | <S2SV_ModStart> 0 ) { mrb_free ( mrb , result ) ; <S2SV_ModStart> [ 0 ] , result ) ; mrb_free ( mrb |
4,056 | CWE-000 static void sha1_process ( SHA1_CTX * ctx , const uint32_t block [ 16 ] ) { unsigned i , j ; uint32_t ubc_dv_mask [ DVMASKSIZE ] = { 0xFFFFFFFF } ; uint32_t ihvtmp [ 5 ] ; # ifdef SHA1DC_HAVE_SIMD if ( ctx -> ubc_check == 0 && ctx -> simd > 0 ) { <S2SV_StartBug> sha1_process_simd ( ctx , block ) ; <S2SV_EndBug> return ; } # endif ctx -> ihv1 [ 0 ] = ctx -> ihv [ 0 ] ; ctx -> ihv1 [ 1 ] = ctx -> ihv [ 1 ] ; ctx -> ihv1 [ 2 ] = ctx -> ihv [ 2 ] ; ctx -> ihv1 [ 3 ] = ctx -> ihv [ 3 ] ; ctx -> ihv1 [ 4 ] = ctx -> ihv [ 4 ] ; sha1_compression_states ( ctx -> ihv , block , ctx -> m1 , ctx -> states ) ; if ( ctx -> detect_coll ) { if ( ctx -> ubc_check ) { ubc_check ( ctx -> m1 , ubc_dv_mask ) ; } if ( ubc_dv_mask [ 0 ] != 0 ) { for ( i = 0 ; sha1_dvs [ i ] . dvType != 0 ; ++ i ) { if ( ubc_dv_mask [ 0 ] & ( ( uint32_t ) ( 1 ) << sha1_dvs [ i ] . maskb ) ) { for ( j = 0 ; j < 80 ; ++ j ) ctx -> m2 [ j ] = ctx -> m1 [ j ] ^ sha1_dvs [ i ] . dm [ j ] ; sha1_recompression_step ( sha1_dvs [ i ] . testt , ctx -> ihv2 , ihvtmp , ctx -> m2 , ctx -> states [ sha1_dvs [ i ] . testt ] ) ; if ( ( 0 == ( ( ihvtmp [ 0 ] ^ ctx -> ihv [ 0 ] ) | ( ihvtmp [ 1 ] ^ ctx -> ihv [ 1 ] ) | ( ihvtmp [ 2 ] ^ ctx -> ihv [ 2 ] ) | ( ihvtmp [ 3 ] ^ ctx -> ihv [ 3 ] ) | ( ihvtmp [ 4 ] ^ ctx -> ihv [ 4 ] ) ) ) || ( ctx -> reduced_round_coll && 0 == ( ( ctx -> ihv1 [ 0 ] ^ ctx -> ihv2 [ 0 ] ) | ( ctx -> ihv1 [ 1 ] ^ ctx -> ihv2 [ 1 ] ) | ( ctx -> ihv1 [ 2 ] ^ ctx -> ihv2 [ 2 ] ) | ( ctx -> ihv1 [ 3 ] ^ ctx -> ihv2 [ 3 ] ) | ( ctx -> ihv1 [ 4 ] ^ ctx -> ihv2 [ 4 ] ) ) ) ) { ctx -> found_collision = 1 ; if ( ctx -> callback != NULL ) { ctx -> callback ( ctx -> total - 64 , ctx -> ihv1 , ctx -> ihv2 , ctx -> m1 , ctx -> m2 , ctx -> callback_data ) ; } if ( ctx -> safe_hash ) { sha1_compression_W ( ctx -> ihv , ctx -> m1 ) ; sha1_compression_W ( ctx -> ihv , ctx -> m1 ) ; } break ; } } } } } } | <S2SV_ModStart> 0 ) { fprintf ( stderr , "calling<S2SV_blank>simd<S2SV_blank>code" ) ; |
4,057 | CWE-000 int du_decap ( struct du * du ) { pdu_type_t type ; ssize_t pci_len ; du -> pci . h = du -> skb -> data ; type = pci_type ( & du -> pci ) ; if ( unlikely ( ! pdu_type_is_ok ( type ) ) ) { LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>decap<S2SV_blank>DU.<S2SV_blank>Type<S2SV_blank>is<S2SV_blank>not<S2SV_blank>ok" ) ; return - 1 ; } pci_len = pci_calculate_size ( du -> cfg , type ) ; if ( pci_len <= 0 ) { LOG_ERR ( "Could<S2SV_blank>not<S2SV_blank>decap<S2SV_blank>DU.<S2SV_blank>PCI<S2SV_blank>len<S2SV_blank>is<S2SV_blank><<S2SV_blank>0" ) ; return - 1 ; } <S2SV_StartBug> LOG_INFO ( "PDU<S2SV_blank>length<S2SV_blank>%u,<S2SV_blank>PCI<S2SV_blank>PDU<S2SV_blank>length<S2SV_blank>%zd" , <S2SV_EndBug> du -> skb -> len , pci_length ( & du -> pci ) ) ; if ( du -> skb -> len > pci_length ( & du -> pci ) ) { du_tail_shrink ( du , du -> skb -> len - pci_length ( & du -> pci ) ) ; } <S2SV_StartBug> LOG_INFO ( "PDU<S2SV_blank>length<S2SV_blank>%u,<S2SV_blank>PCI<S2SV_blank>PDU<S2SV_blank>length<S2SV_blank>%zd" , <S2SV_EndBug> du -> skb -> len , pci_length ( & du -> pci ) ) ; skb_pull ( du -> skb , pci_len ) ; du -> pci . len = pci_len ; <S2SV_StartBug> LOG_INFO ( "Payload<S2SV_blank>length<S2SV_blank>%u" , du -> skb -> len ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> 1 ; } <S2SV_ModEnd> if ( du <S2SV_ModStart> ) ; } <S2SV_ModEnd> skb_pull ( du <S2SV_ModStart> = pci_len ; <S2SV_ModEnd> return 0 ; |
4,058 | CWE-000 static void btif_dm_auth_cmpl_evt ( tBTA_DM_AUTH_CMPL * p_auth_cmpl ) { bt_bdaddr_t bd_addr ; bt_status_t status = BT_STATUS_FAIL ; bt_bond_state_t state = BT_BOND_STATE_NONE ; BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>bond<S2SV_blank>state=%d" , __func__ , pairing_cb . state ) ; bdcpy ( bd_addr . address , p_auth_cmpl -> bd_addr ) ; if ( ( p_auth_cmpl -> success == TRUE ) && ( p_auth_cmpl -> key_present ) ) { if ( ( p_auth_cmpl -> key_type < HCI_LKEY_TYPE_DEBUG_COMB ) || ( p_auth_cmpl -> key_type == HCI_LKEY_TYPE_AUTH_COMB ) || ( p_auth_cmpl -> key_type == HCI_LKEY_TYPE_CHANGED_COMB ) || ( p_auth_cmpl -> key_type == HCI_LKEY_TYPE_AUTH_COMB_P_256 ) || pairing_cb . bond_type == BOND_TYPE_PERSISTENT ) { bt_status_t ret ; BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>Storing<S2SV_blank>link<S2SV_blank>key.<S2SV_blank>key_type=0x%x,<S2SV_blank>bond_type=%d" , __FUNCTION__ , p_auth_cmpl -> key_type , pairing_cb . bond_type ) ; ret = btif_storage_add_bonded_device ( & bd_addr , p_auth_cmpl -> key , p_auth_cmpl -> key_type , pairing_cb . pin_code_len ) ; ASSERTC ( ret == BT_STATUS_SUCCESS , "storing<S2SV_blank>link<S2SV_blank>key<S2SV_blank>failed" , ret ) ; } else { BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>Temporary<S2SV_blank>key.<S2SV_blank>Not<S2SV_blank>storing.<S2SV_blank>key_type=0x%x,<S2SV_blank>bond_type=%d" , __FUNCTION__ , p_auth_cmpl -> key_type , pairing_cb . bond_type ) ; if ( pairing_cb . bond_type == BOND_TYPE_TEMPORARY ) { BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>sending<S2SV_blank>BT_BOND_STATE_NONE<S2SV_blank>for<S2SV_blank>Temp<S2SV_blank>pairing" , __FUNCTION__ ) ; btif_storage_remove_bonded_device ( & bd_addr ) ; bond_state_changed ( BT_STATUS_SUCCESS , & bd_addr , BT_BOND_STATE_NONE ) ; return ; } } } if ( p_auth_cmpl -> success ) { if ( ( bdcmp ( p_auth_cmpl -> bd_addr , pairing_cb . bd_addr ) != 0 ) && ( ! pairing_cb . ble . is_penc_key_rcvd ) ) { char address [ 32 ] ; bt_bdaddr_t bt_bdaddr ; memcpy ( bt_bdaddr . address , p_auth_cmpl -> bd_addr , sizeof ( bt_bdaddr . address ) ) ; bdaddr_to_string ( & bt_bdaddr , address , sizeof ( address ) ) ; LOG_INFO ( LOG_TAG , "%s<S2SV_blank>skipping<S2SV_blank>SDP<S2SV_blank>since<S2SV_blank>we<S2SV_blank>did<S2SV_blank>not<S2SV_blank>initiate<S2SV_blank>pairing<S2SV_blank>to<S2SV_blank>%s." , __func__ , address ) ; return ; } # if BLE_INCLUDED == TRUE btif_storage_set_remote_addr_type ( & bd_addr , p_auth_cmpl -> addr_type ) ; # endif btif_update_remote_properties ( p_auth_cmpl -> bd_addr , p_auth_cmpl -> bd_name , NULL , p_auth_cmpl -> dev_type ) ; pairing_cb . timeout_retries = 0 ; if ( interop_skip_sdp ( & bd_addr ) && check_cod_hid ( & bd_addr ) ) { bond_state_changed ( BT_STATUS_SUCCESS , & bd_addr , BT_BOND_STATE_BONDED ) ; BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>HID<S2SV_blank>Connection<S2SV_blank>from<S2SV_blank>" "blacklisted<S2SV_blank>device,<S2SV_blank>skipping<S2SV_blank>sdp" , __FUNCTION__ ) ; bt_property_t prop ; bt_uuid_t uuid ; char uuid_str [ 128 ] = UUID_HUMAN_INTERFACE_DEVICE ; string_to_uuid ( uuid_str , & uuid ) ; prop . type = BT_PROPERTY_UUIDS ; prop . val = uuid . uu ; prop . len = MAX_UUID_SIZE ; status = btif_storage_set_remote_device_property ( & bd_addr , & prop ) ; HAL_CBACK ( bt_hal_cbacks , remote_device_properties_cb , BT_STATUS_SUCCESS , & bd_addr , 1 , & prop ) ; } else { status = BT_STATUS_SUCCESS ; state = BT_BOND_STATE_BONDED ; # if BLE_INCLUDED == TRUE BOOLEAN is_crosskey = FALSE ; if ( pairing_cb . state == BT_BOND_STATE_BONDING && ( bdcmp ( p_auth_cmpl -> bd_addr , pairing_cb . bd_addr ) != 0 ) ) { BTIF_TRACE_DEBUG ( "%s:<S2SV_blank>bonding<S2SV_blank>initiated<S2SV_blank>due<S2SV_blank>to<S2SV_blank>cross<S2SV_blank>key,<S2SV_blank>adding<S2SV_blank>static<S2SV_blank>address" , __func__ ) ; bdcpy ( pairing_cb . static_bdaddr . address , p_auth_cmpl -> bd_addr ) ; is_crosskey = TRUE ; } if ( ! is_crosskey || ! ( stack_config_get_interface ( ) -> get_pts_crosskey_sdp_disable ( ) ) ) { # endif btif_dm_cancel_discovery ( ) ; pairing_cb . sdp_attempts = 1 ; btif_dm_get_remote_services ( & bd_addr ) ; # if BLE_INCLUDED == TRUE } # endif } } else { switch ( p_auth_cmpl -> fail_reason ) { case HCI_ERR_PAGE_TIMEOUT : <S2SV_StartBug> if ( interop_match_addr ( INTEROP_AUTO_RETRY_PAIRING , ( bt_bdaddr_t * ) & bd_addr ) <S2SV_EndBug> <S2SV_StartBug> && pairing_cb . timeout_retries ) <S2SV_EndBug> { BTIF_TRACE_WARNING ( "%s()<S2SV_blank>-<S2SV_blank>Pairing<S2SV_blank>timeout;<S2SV_blank>retrying<S2SV_blank>(%d)<S2SV_blank>..." , __FUNCTION__ , pairing_cb . timeout_retries ) ; -- pairing_cb . timeout_retries ; btif_dm_cb_create_bond ( & bd_addr , BTA_TRANSPORT_UNKNOWN ) ; return ; } case HCI_ERR_CONNECTION_TOUT : status = BT_STATUS_RMT_DEV_DOWN ; break ; case HCI_ERR_PAIRING_NOT_ALLOWED : btif_storage_remove_bonded_device ( & bd_addr ) ; status = BT_STATUS_AUTH_REJECTED ; break ; case HCI_ERR_LMP_RESPONSE_TIMEOUT : status = BT_STATUS_AUTH_FAILURE ; break ; case HCI_ERR_AUTH_FAILURE : case HCI_ERR_KEY_MISSING : btif_storage_remove_bonded_device ( & bd_addr ) ; case HCI_ERR_HOST_REJECT_SECURITY : case HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE : case HCI_ERR_UNIT_KEY_USED : case HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED : case HCI_ERR_INSUFFCIENT_SECURITY : case HCI_ERR_PEER_USER : case HCI_ERR_UNSPECIFIED : BTIF_TRACE_DEBUG ( "<S2SV_blank>%s()<S2SV_blank>Authentication<S2SV_blank>fail<S2SV_blank>reason<S2SV_blank>%d" , __FUNCTION__ , p_auth_cmpl -> fail_reason ) ; if ( pairing_cb . autopair_attempts == 1 ) { BTIF_TRACE_WARNING ( "%s()<S2SV_blank>auto<S2SV_blank>pair<S2SV_blank>failed.<S2SV_blank>Reinitiate<S2SV_blank>Bond" , __FUNCTION__ ) ; btif_dm_cb_create_bond ( & bd_addr , BTA_TRANSPORT_UNKNOWN ) ; return ; } else { status = BT_STATUS_AUTH_FAILURE ; } break ; default : status = BT_STATUS_FAIL ; } if ( p_auth_cmpl -> fail_reason == HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE || p_auth_cmpl -> fail_reason == HCI_ERR_UNIT_KEY_USED || p_auth_cmpl -> fail_reason == HCI_ERR_INSUFFCIENT_SECURITY || p_auth_cmpl -> fail_reason == HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED || p_auth_cmpl -> fail_reason == HCI_ERR_HOST_REJECT_SECURITY || p_auth_cmpl -> fail_reason == HCI_ERR_UNSPECIFIED ) GENERATE_VND_LOGS ( ) ; if ( check_cod ( & bd_addr , COD_HID_POINTING ) ) { BTIF_TRACE_DEBUG ( "%s():<S2SV_blank>removing<S2SV_blank>hid<S2SV_blank>pointing<S2SV_blank>device<S2SV_blank>from<S2SV_blank>nvram" , __FUNCTION__ ) ; btif_storage_remove_bonded_device ( & bd_addr ) ; } bond_state_changed ( status , & bd_addr , state ) ; } } | <S2SV_ModStart> : if ( ( pairing_cb . timeout_retries == NUM_TIMEOUT_RETRIES ) || ( <S2SV_ModStart> . timeout_retries ) ) |
4,059 | CWE-000 entry * append ( char lastName [ ] , entry * e ) { <S2SV_StartBug> e = ( entry * ) malloc ( sizeof ( entry ) ) ; <S2SV_EndBug> strcpy ( e -> lastName , lastName ) ; e -> pNext = NULL ; return e ; } | <S2SV_ModStart> ) { e -> pNext <S2SV_ModStart> entry ) ) ; e = e -> pNext |
4,060 | CWE-000 int main ( int argc , char * argv [ ] ) { int ret ; ABT_xstream xstream ; <S2SV_StartBug> ATS_init ( argc , argv ) ; <S2SV_EndBug> ret = ABT_xstream_self ( & xstream ) ; ATS_ERROR ( ret , "ABT_xstream_self" ) ; ABT_pool pool ; ret = ABT_xstream_get_main_pools ( xstream , 1 , & pool ) ; ATS_ERROR ( ret , "ABT_xstream_get_main_pools" ) ; ret = ABT_thread_create ( pool , fn1 , NULL , ABT_THREAD_ATTR_NULL , & th1 ) ; ATS_ERROR ( ret , "ABT_thread_create" ) ; ret = ABT_thread_create ( pool , fn2 , NULL , ABT_THREAD_ATTR_NULL , & th2 ) ; ATS_ERROR ( ret , "ABT_thread_create" ) ; ret = ABT_thread_create ( pool , fn3 , NULL , ABT_THREAD_ATTR_NULL , & th3 ) ; ATS_ERROR ( ret , "ABT_thread_create" ) ; ret = ABT_eventual_create ( EVENTUAL_SIZE , & myeventual ) ; ATS_ERROR ( ret , "ABT_eventual_create" ) ; ATS_printf ( 1 , "START\\n" ) ; void * data ; ATS_printf ( 1 , "Thread<S2SV_blank>main<S2SV_blank>iteration<S2SV_blank>%d<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>eventual\\n" , 0 ) ; ABT_eventual_wait ( myeventual , & data ) ; ATS_printf ( 1 , "Thread<S2SV_blank>main<S2SV_blank>continue<S2SV_blank>iteration<S2SV_blank>%d<S2SV_blank>returning<S2SV_blank>from<S2SV_blank>" "eventual\\n" , 0 ) ; ret = ABT_thread_free ( & th1 ) ; ATS_ERROR ( ret , "ABT_thread_free" ) ; ret = ABT_thread_free ( & th2 ) ; ATS_ERROR ( ret , "ABT_thread_free" ) ; ret = ABT_thread_free ( & th3 ) ; ATS_ERROR ( ret , "ABT_thread_free" ) ; ATS_printf ( 1 , "END\\n" ) ; ret = ATS_finalize ( 0 ) ; return ret ; } | <S2SV_ModStart> ABT_xstream xstream ; ATS_read_args ( argc , argv ) ; <S2SV_ModStart> argc , argv , 1 |
4,061 | CWE-000 void cb ( __attribute__ ( ( unused ) ) pa_context * pulseaudio_context , const pa_server_info * i , void * userdata ) { struct audio_data * audio = ( struct audio_data * ) userdata ; audio -> source = malloc ( sizeof ( char ) * 1024 ) ; strcpy ( audio -> source , i -> default_sink_name ) ; audio -> source = strcat ( audio -> source , ".monitor" ) ; <S2SV_StartBug> pa_mainloop_quit ( m_pulseaudio_mainloop , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ".monitor" ) ; pa_context_disconnect ( pulseaudio_context ) ; pa_context_unref ( pulseaudio_context ) ; <S2SV_ModStart> 0 ) ; pa_mainloop_free ( m_pulseaudio_mainloop ) ; |
4,062 | CWE-000 static GatherMerge * _readGatherMerge ( void ) { READ_LOCALS ( GatherMerge ) ; ReadCommonPlan ( & local_node -> plan ) ; <S2SV_StartBug> READ_INT_FIELD ( num_workers ) ; <S2SV_EndBug> READ_INT_FIELD ( numCols ) ; READ_ATTRNUMBER_ARRAY ( sortColIdx , local_node -> numCols ) ; READ_OID_ARRAY ( sortOperators , local_node -> numCols ) ; READ_OID_ARRAY ( collations , local_node -> numCols ) ; READ_BOOL_ARRAY ( nullsFirst , local_node -> numCols ) ; READ_DONE ( ) ; } | <S2SV_ModStart> READ_INT_FIELD ( num_workers ) ; READ_INT_FIELD ( rescan_param |
4,063 | CWE-000 int kgsl_add_fence_event ( struct kgsl_device * device , u32 context_id , u32 timestamp , void __user * data , int len , struct kgsl_device_private * owner ) { struct kgsl_timestamp_event_fence priv ; struct kgsl_context * context ; struct sync_pt * pt ; struct sync_fence * fence = NULL ; int ret = - EINVAL ; unsigned int cur ; priv . fence_fd = - 1 ; if ( len != sizeof ( priv ) ) return - EINVAL ; kgsl_mutex_lock ( & device -> mutex , & device -> mutex_owner ) ; context = kgsl_context_get_owner ( owner , context_id ) ; if ( context == NULL ) goto unlock ; pt = kgsl_sync_pt_create ( context -> timeline , timestamp ) ; if ( pt == NULL ) { KGSL_DRV_ERR ( device , "kgsl_sync_pt_create<S2SV_blank>failed\\n" ) ; ret = - ENOMEM ; goto unlock ; } fence = sync_fence_create ( "kgsl-fence" , pt ) ; if ( fence == NULL ) { kgsl_sync_pt_destroy ( pt ) ; KGSL_DRV_ERR ( device , "sync_fence_create<S2SV_blank>failed\\n" ) ; ret = - ENOMEM ; goto unlock ; } priv . fence_fd = get_unused_fd_flags ( 0 ) ; if ( priv . fence_fd < 0 ) { KGSL_DRV_ERR ( device , "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>a<S2SV_blank>file<S2SV_blank>descriptor:<S2SV_blank>%d\\n" , priv . fence_fd ) ; ret = priv . fence_fd ; goto unlock ; } <S2SV_StartBug> sync_fence_install ( fence , priv . fence_fd ) ; <S2SV_EndBug> cur = kgsl_readtimestamp ( device , context , KGSL_TIMESTAMP_RETIRED ) ; if ( timestamp_cmp ( cur , timestamp ) >= 0 ) kgsl_sync_timeline_signal ( context -> timeline , cur ) ; else { ret = _add_fence_event ( device , context , timestamp ) ; if ( ret ) goto unlock ; } kgsl_context_put ( context ) ; kgsl_mutex_unlock ( & device -> mutex , & device -> mutex_owner ) ; if ( copy_to_user ( data , & priv , sizeof ( priv ) ) ) { ret = - EFAULT ; goto out ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> unlock : kgsl_mutex_unlock ( & device -> mutex , & device -> mutex_owner ) ; out : if ( priv . fence_fd >= 0 ) put_unused_fd ( priv . fence_fd ) ; if ( fence ) sync_fence_put ( fence ) ; kgsl_context_put ( context ) ; return ret ; } | <S2SV_ModStart> unlock ; } <S2SV_ModEnd> cur = kgsl_readtimestamp <S2SV_ModStart> out ; } sync_fence_install ( fence , priv . fence_fd ) ; |
4,064 | CWE-000 static void cpu_common_initfn ( Object * obj ) { CPUState * cpu = CPU ( obj ) ; CPUClass * cc = CPU_GET_CLASS ( obj ) ; cpu -> cpu_index = UNASSIGNED_CPU_INDEX ; cpu -> gdb_num_regs = cpu -> gdb_num_g_regs = cc -> gdb_num_core_regs ; cpu -> nr_cores = 1 ; cpu -> nr_threads = 1 ; qemu_mutex_init ( & cpu -> lock ) ; qemu_cond_init ( & cpu -> work_cond ) ; <S2SV_StartBug> QTAILQ_INIT ( & cpu -> breakpoints ) ; <S2SV_EndBug> QTAILQ_INIT ( & cpu -> watchpoints ) ; cpu_exec_initfn ( cpu ) ; } | <S2SV_ModStart> work_cond ) ; qemu_cond_init ( & cpu -> exclusive_req_cond ) ; |
4,065 | CWE-000 StatusCode insertInstruction ( char * instruction , char * operands , int isSecondIteration ) { StatusCode code ; opType sourceType = Immediate ; opType destType = Immediate ; Symbol * op1 ; Symbol * op2 ; int sumL = 0 ; int i ; int bothRegisters = 0 ; int count = 0 ; int numberOfOperands ; int keepBin ; char firstOp [ LINE_LENGTH ] ; char secondOp [ LINE_LENGTH ] ; char line [ LINE_LENGTH ] ; char * token ; strcpy ( line , operands ) ; keepBin = searchOp ( instruction ) ; if ( keepBin <= FIRST_INSTRUCTION_GROUP_INDEX ) { numberOfOperands = 2 ; token = strtok ( line , "," ) ; <S2SV_StartBug> strcpy ( firstOp , token ) ; <S2SV_EndBug> if ( ( code = trimOperand ( firstOp ) ) < 0 ) return code ; while ( token != NULL ) { if ( count <= 1 ) strcpy ( secondOp , token ) ; token = strtok ( NULL , "," ) ; count ++ ; } if ( count > numberOfOperands ) return wrong_number_of_operands ; if ( ( code = trimOperand ( secondOp ) ) < 0 ) <S2SV_StartBug> return code ; <S2SV_EndBug> printf ( "%s\\t%s\\n" , firstOp , secondOp ) ; if ( ( code = checkType ( firstOp , & sourceType ) ) < 0 ) return code ; if ( ( code = checkType ( secondOp , & destType ) ) < 0 ) return code ; } else if ( keepBin > FIRST_INSTRUCTION_GROUP_INDEX && keepBin <= SECOND_INSTRUCTION_GROUP_INDEX ) { numberOfOperands = 1 ; if ( sscanf ( line , "%s<S2SV_blank>%s" , firstOp , secondOp ) != numberOfOperands ) return wrong_number_of_operands ; if ( ( code = checkType ( firstOp , & destType ) ) < 0 ) return code ; } else { numberOfOperands = 0 ; if ( ! isWhitespace ( line ) ) return wrong_number_of_operands ; } if ( ! isValidSourceDest ( keepBin , sourceType , destType ) ) return invalid_source_dest_operands ; if ( ( code = instSumRow ( sourceType , destType , numberOfOperands , & sumL ) ) < 0 ) return code ; if ( isSecondIteration == 0 ) { instructionsArray [ IC ] = keepBin ; instructionsArray [ IC ] = ( instructionsArray [ IC ] << 2 ) + sourceType ; instructionsArray [ IC ] = ( instructionsArray [ IC ] << 2 ) + destType ; instructionsArray [ IC ] = instructionsArray [ IC ] << 2 ; IC += sumL ; } else { if ( numberOfOperands > 0 ) { if ( numberOfOperands == 1 ) { if ( destType == Struct || destType == Direct ) { if ( destType == Direct ) { if ( ( op1 = doesExist ( firstOp ) ) == NULL ) return symbol_doesnt_exist ; } else { if ( ( op1 = doesStructExist ( firstOp ) ) == NULL ) return symbol_doesnt_exist ; } } } else { if ( sourceType == Struct || sourceType == Direct ) { if ( sourceType == Direct ) { if ( ( op1 = doesExist ( firstOp ) ) == NULL ) return symbol_doesnt_exist ; } else { if ( ( op1 = doesStructExist ( firstOp ) ) == NULL ) return symbol_doesnt_exist ; } } if ( destType == Struct || destType == Direct ) { if ( destType == Direct ) { if ( ( op2 = doesExist ( secondOp ) ) == NULL ) return symbol_doesnt_exist ; } else { if ( ( op2 = doesStructExist ( secondOp ) ) == NULL ) return symbol_doesnt_exist ; } } } } bothRegisters = ( numberOfOperands == 2 && sourceType == Register && destType == Register ) ; i = 1 ; if ( numberOfOperands == 1 ) { switch ( destType ) { case Immediate : insertImmediate ( firstOp , i + IC ) ; break ; case Direct : insertDirect ( op1 , i + IC ) ; break ; case Struct : insertDirect ( op1 , i + IC ) ; i ++ ; insertStructField ( firstOp , i + IC ) ; break ; case Register : insertRegisters ( firstOp , NULL , i + IC ) ; break ; } } else { switch ( sourceType ) { case Immediate : insertImmediate ( firstOp , i + IC ) ; break ; case Direct : insertDirect ( op1 , i + IC ) ; break ; case Struct : insertDirect ( op1 , i + IC ) ; i ++ ; insertStructField ( firstOp , i + IC ) ; break ; case Register : insertRegisters ( firstOp , bothRegisters ? secondOp : NULL , i + IC ) ; break ; } i ++ ; switch ( destType ) { case Immediate : insertImmediate ( secondOp , i + IC ) ; break ; case Direct : insertDirect ( op2 , i + IC ) ; break ; case Struct : insertDirect ( op2 , i + IC ) ; i ++ ; insertStructField ( secondOp , i + IC ) ; break ; case Register : if ( ! bothRegisters ) insertRegisters ( NULL , secondOp , i + IC ) ; break ; } } IC += sumL ; } return success ; } | <S2SV_ModStart> "," ) ; if ( token == NULL ) return wrong_number_of_operands ; <S2SV_ModStart> ) return code <S2SV_ModEnd> ; if ( |
4,066 | CWE-000 void SCR_UpdateScreen ( void ) { <S2SV_StartBug> static float oldscr_viewsize ; <S2SV_EndBug> vrect_t vrect ; if ( block_drawing ) return ; vid . numpages = ( int ) ( 2 + gl_triplebuffer . value ) ; scr_copytop = 0 ; scr_copyeverything = 0 ; if ( scr_disabled_for_loading ) { if ( realtime - scr_disabled_time > 60 ) { scr_disabled_for_loading = false ; Con_Printf ( "load<S2SV_blank>failed.\\n" ) ; } else return ; } if ( ! scr_initialized || ! con_initialized ) return ; GL_BeginRendering ( & glx , & gly , & glwidth , & glheight ) ; <S2SV_StartBug> if ( oldfov != scr_fov . value ) <S2SV_EndBug> { <S2SV_StartBug> oldfov = scr_fov . value ; <S2SV_EndBug> vid . recalc_refdef = true ; } <S2SV_StartBug> if ( oldscreensize != scr_viewsize . value ) <S2SV_EndBug> { <S2SV_StartBug> oldscreensize = scr_viewsize . value ; <S2SV_EndBug> vid . recalc_refdef = true ; } if ( oldsbaralpha != scr_sbaralpha . value ) { oldsbaralpha = scr_sbaralpha . value ; vid . recalc_refdef = true ; } if ( vid . recalc_refdef ) SCR_CalcRefdef ( ) ; SCR_SetUpToDrawConsole ( ) ; V_RenderView ( ) ; GL_Set2D ( ) ; SCR_TileClear ( ) ; if ( scr_drawdialog ) { Sbar_Draw ( ) ; Draw_FadeScreen ( ) ; SCR_DrawNotifyString ( ) ; scr_copyeverything = true ; } else if ( scr_drawloading ) { SCR_DrawLoading ( ) ; Sbar_Draw ( ) ; } else if ( cl . intermission == 1 && key_dest == key_game ) { Sbar_IntermissionOverlay ( ) ; } else if ( cl . intermission == 2 && key_dest == key_game ) { Sbar_FinaleOverlay ( ) ; SCR_CheckDrawCenterString ( ) ; } else { if ( crosshair . value ) Draw_Character ( scr_vrect . x + scr_vrect . width / 2 , scr_vrect . y + scr_vrect . height / 2 , '+' ) ; SCR_DrawRam ( ) ; SCR_DrawNet ( ) ; SCR_DrawTurtle ( ) ; SCR_DrawPause ( ) ; SCR_CheckDrawCenterString ( ) ; Sbar_Draw ( ) ; SCR_DrawConsole ( ) ; M_Draw ( ) ; } V_UpdatePalette ( ) ; GL_EndRendering ( ) ; } | <S2SV_ModStart> void ) { <S2SV_ModEnd> vrect_t vrect ; <S2SV_ModStart> ( oldfov != fov <S2SV_ModEnd> . value ) <S2SV_ModStart> { oldfov = fov <S2SV_ModEnd> . value ; <S2SV_ModStart> ( oldscreensize != viewsize <S2SV_ModEnd> . value ) <S2SV_ModStart> { oldscreensize = viewsize <S2SV_ModEnd> . value ; |
4,067 | CWE-000 int read_solutions ( FILE * cfp , double * p , clus_source_t * carr , int N , int M ) { int Nc = 8 * N - 1 ; int c , buff_len , ci , ck , cn ; double jtmp ; char * buf ; buff_len = 128 ; if ( ( buf = ( char * ) malloc ( sizeof ( char ) * ( size_t ) ( buff_len ) ) ) == NULL ) { fprintf ( stderr , "%s:<S2SV_blank>%d:<S2SV_blank>No<S2SV_blank>free<S2SV_blank>memory\\n" , __FILE__ , __LINE__ ) ; exit ( 1 ) ; } # ifdef DEBUG printf ( "Nc=%d\\n" , Nc ) ; # endif c = skip_lines ( cfp ) ; while ( Nc >= 0 && c >= 0 ) { memset ( buf , 0 , buff_len ) ; c = read_next_string ( & buf , & buff_len , cfp ) ; if ( c != 1 ) { sscanf ( buf , "%d" , & cn ) ; <S2SV_StartBug> if ( cn < 0 || cn > Nc ) cn = 0 ; <S2SV_EndBug> } # ifdef DEBUG printf ( "%d<S2SV_blank>" , cn ) ; # endif for ( ci = M - 1 ; ci >= 0 ; ci -- ) { for ( ck = 0 ; ck < carr [ ci ] . nchunk ; ck ++ ) { if ( strlen ( buf ) > 0 ) { memset ( buf , 0 , buff_len ) ; c = read_next_string ( & buf , & buff_len , cfp ) ; sscanf ( buf , "%lf" , & jtmp ) ; p [ carr [ ci ] . p [ ck ] + cn ] = jtmp ; # ifdef DEBUG printf ( "%e<S2SV_blank>" , jtmp ) ; # endif } } } # ifdef DEBUG printf ( "\\n" ) ; # endif c = skip_lines ( cfp ) ; Nc -- ; } if ( Nc >= 0 ) { fprintf ( stderr , "Warning:<S2SV_blank>solution<S2SV_blank>file<S2SV_blank>EOF<S2SV_blank>reached,<S2SV_blank>check<S2SV_blank>your<S2SV_blank>solution<S2SV_blank>file\\n" ) ; exit ( 1 ) ; } free ( buf ) ; return 0 ; } | <S2SV_ModStart> || cn > 8 * N - 1 <S2SV_ModEnd> ) cn = |
4,068 | CWE-000 static void vpn_pro1000_new ( struct pci_device * pci_device , bool option_tty , char * option_net , bool option_virtio ) { int i ; struct data2 * d2 ; struct data * d ; void * tmp ; struct pci_bar_info bar_info ; struct nicfunc * virtio_net_func ; if ( ( pci_device -> config_space . base_address [ 0 ] & PCI_CONFIG_BASE_ADDRESS_SPACEMASK ) != PCI_CONFIG_BASE_ADDRESS_MEMSPACE ) { printf ( "vpn_pro1000:<S2SV_blank>region<S2SV_blank>0<S2SV_blank>is<S2SV_blank>not<S2SV_blank>memory<S2SV_blank>space\\n" ) ; return ; } if ( ( pci_device -> base_address_mask [ 0 ] & PCI_CONFIG_BASE_ADDRESS_MEMMASK ) & 0xFFFF ) { printf ( "vpn_pro1000:<S2SV_blank>region<S2SV_blank>0<S2SV_blank>is<S2SV_blank>too<S2SV_blank>small\\n" ) ; return ; } printf ( "PRO/1000<S2SV_blank>found.\\n" ) ; # ifdef VTD_TRANS if ( iommu_detected ) { add_remap ( pci_device -> address . bus_no , pci_device -> address . device_no , pci_device -> address . func_no , vmm_start_inf ( ) >> 12 , ( vmm_term_inf ( ) - vmm_start_inf ( ) ) >> 12 , PERM_DMA_RW ) ; } # endif d2 = alloc ( sizeof * d2 ) ; memset ( d2 , 0 , sizeof * d2 ) ; d2 -> nethandle = net_new_nic ( option_net , option_tty ) ; alloc_pages ( & tmp , NULL , ( BUFSIZE + PAGESIZE - 1 ) / PAGESIZE ) ; memset ( tmp , 0 , ( BUFSIZE + PAGESIZE - 1 ) / PAGESIZE * PAGESIZE ) ; d2 -> buf = tmp ; d2 -> buf_premap = net_premap_recvbuf ( d2 -> nethandle , tmp , BUFSIZE ) ; spinlock_init ( & d2 -> lock ) ; d = alloc ( sizeof * d * 6 ) ; for ( i = 0 ; i < 6 ; i ++ ) { d [ i ] . d = d2 ; d [ i ] . e = 0 ; pci_get_bar_info ( pci_device , i , & bar_info ) ; reghook ( & d [ i ] , i , & bar_info ) ; } d -> disable = false ; d2 -> d1 = d ; <S2SV_StartBug> get_macaddr ( d2 , d2 -> macaddr ) ; <S2SV_EndBug> pci_device -> host = d ; pci_device -> driver -> options . use_base_address_mask_emulation = 1 ; d2 -> pci_device = pci_device ; d2 -> virtio_net = NULL ; if ( option_virtio ) { d2 -> virtio_net = virtio_net_init ( & virtio_net_func , d2 -> macaddr , pro1000_intr_clear , pro1000_intr_set , pro1000_intr_disable , pro1000_intr_enable , d2 ) ; } if ( d2 -> virtio_net ) { d2 -> virtio_net_msi = pci_msi_init ( pci_device , pro1000_msi , d2 ) ; if ( d2 -> virtio_net_msi ) virtio_net_set_msix ( d2 -> virtio_net , 0x5 , pro1000_msix_disable , pro1000_msix_enable , d2 ) ; pci_device -> driver -> options . use_base_address_mask_emulation = 0 ; net_init ( d2 -> nethandle , d2 , & phys_func , d2 -> virtio_net , virtio_net_func ) ; d2 -> seize = true ; } else { d2 -> seize = net_init ( d2 -> nethandle , d2 , & phys_func , NULL , NULL ) ; } if ( d2 -> seize ) { seize_pro1000 ( d2 ) ; net_start ( d2 -> nethandle ) ; } LIST1_PUSH ( d2list , d2 ) ; return ; } | <S2SV_ModStart> = d ; pro1000_enable_dma_and_memory ( pci_device ) ; |
4,069 | CWE-000 static void mlxsw_sp_router_neigh_ent_ipv6_process ( struct mlxsw_sp * mlxsw_sp , char * rauhtd_pl , int rec_index ) { <S2SV_StartBug> struct net_device * dev ; <S2SV_EndBug> struct neighbour * n ; struct in6_addr dip ; u16 rif ; mlxsw_reg_rauhtd_ent_ipv6_unpack ( rauhtd_pl , rec_index , & rif , ( char * ) & dip ) ; if ( ! mlxsw_sp -> router -> rifs [ rif ] ) { dev_err_ratelimited ( mlxsw_sp -> bus_info -> dev , "Incorrect<S2SV_blank>RIF<S2SV_blank>in<S2SV_blank>neighbour<S2SV_blank>entry\\n" ) ; return ; } dev = mlxsw_sp -> router -> rifs [ rif ] -> dev ; n = neigh_lookup ( & nd_tbl , & dip , dev ) ; if ( ! n ) { netdev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>matching<S2SV_blank>neighbour<S2SV_blank>for<S2SV_blank>IP=%pI6c\\n" , & dip ) ; return ; } netdev_dbg ( dev , "Updating<S2SV_blank>neighbour<S2SV_blank>with<S2SV_blank>IP=%pI6c\\n" , & dip ) ; neigh_event_send ( n , NULL ) ; neigh_release ( n ) ; } | <S2SV_ModStart> rec_index ) { <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,070 | CWE-000 static int ParseSizeString ( const char * size , double * res ) { # define MAX_SUBSTRINGS 30 int pcre_exec_ret ; int r ; int ov [ MAX_SUBSTRINGS ] ; int retval = 0 ; char str [ 128 ] ; char str2 [ 128 ] ; * res = 0 ; <S2SV_StartBug> pcre_exec_ret = pcre_exec ( parse_regex , parse_regex_study , size , strlen ( size ) , 0 , 0 , <S2SV_EndBug> ov , MAX_SUBSTRINGS ) ; if ( ! ( pcre_exec_ret == 2 || pcre_exec_ret == 3 ) ) { SCLogError ( SC_ERR_PCRE_MATCH , "invalid<S2SV_blank>size<S2SV_blank>argument<S2SV_blank>-<S2SV_blank>%s.<S2SV_blank>Valid<S2SV_blank>size<S2SV_blank>" "argument<S2SV_blank>should<S2SV_blank>be<S2SV_blank>in<S2SV_blank>the<S2SV_blank>format<S2SV_blank>-<S2SV_blank>\\n" "xxx<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>it<S2SV_blank>is<S2SV_blank>just<S2SV_blank>bytes\\n" "xxxkb<S2SV_blank>or<S2SV_blank>xxxKb<S2SV_blank>or<S2SV_blank>xxxKB<S2SV_blank>or<S2SV_blank>xxxkB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>kilobytes\\n" "xxxmb<S2SV_blank>or<S2SV_blank>xxxMb<S2SV_blank>or<S2SV_blank>xxxMB<S2SV_blank>or<S2SV_blank>xxxmB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>megabytes\\n" "xxxgb<S2SV_blank>or<S2SV_blank>xxxGb<S2SV_blank>or<S2SV_blank>xxxGB<S2SV_blank>or<S2SV_blank>xxxgB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>gigabytes.\\n" , size ) ; retval = - 2 ; goto end ; } r = pcre_copy_substring ( ( char * ) size , ov , MAX_SUBSTRINGS , 1 , str , sizeof ( str ) ) ; if ( r < 0 ) { SCLogError ( SC_ERR_PCRE_GET_SUBSTRING , "pcre_copy_substring<S2SV_blank>failed" ) ; retval = - 2 ; goto end ; } char * endptr , * str_ptr = str ; errno = 0 ; * res = strtod ( str_ptr , & endptr ) ; if ( errno == ERANGE ) { SCLogError ( SC_ERR_NUMERIC_VALUE_ERANGE , "Numeric<S2SV_blank>value<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range" ) ; retval = - 1 ; goto end ; } else if ( endptr == str_ptr ) { SCLogError ( SC_ERR_INVALID_NUMERIC_VALUE , "Invalid<S2SV_blank>numeric<S2SV_blank>value" ) ; retval = - 1 ; goto end ; } if ( pcre_exec_ret == 3 ) { r = pcre_copy_substring ( ( char * ) size , ov , MAX_SUBSTRINGS , 2 , str2 , sizeof ( str2 ) ) ; if ( r < 0 ) { SCLogError ( SC_ERR_PCRE_GET_SUBSTRING , "pcre_copy_substring<S2SV_blank>failed" ) ; retval = - 2 ; goto end ; } if ( strcasecmp ( str2 , "kb" ) == 0 ) { * res *= 1024 ; } else if ( strcasecmp ( str2 , "mb" ) == 0 ) { * res *= 1024 * 1024 ; } else if ( strcasecmp ( str2 , "gb" ) == 0 ) { * res *= 1024 * 1024 * 1024 ; } else { retval = - 1 ; goto end ; } } retval = 0 ; end : return retval ; } | <S2SV_ModStart> = 0 ; if ( size == NULL ) { SCLogError ( SC_ERR_INVALID_ARGUMENTS , "invalid<S2SV_blank>size<S2SV_blank>argument<S2SV_blank>-<S2SV_blank>NULL.<S2SV_blank>Valid<S2SV_blank>size<S2SV_blank>" "argument<S2SV_blank>should<S2SV_blank>be<S2SV_blank>in<S2SV_blank>the<S2SV_blank>format<S2SV_blank>-<S2SV_blank>\\n" "xxx<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>it<S2SV_blank>is<S2SV_blank>just<S2SV_blank>bytes\\n" "xxxkb<S2SV_blank>or<S2SV_blank>xxxKb<S2SV_blank>or<S2SV_blank>xxxKB<S2SV_blank>or<S2SV_blank>xxxkB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>kilobytes\\n" "xxxmb<S2SV_blank>or<S2SV_blank>xxxMb<S2SV_blank>or<S2SV_blank>xxxMB<S2SV_blank>or<S2SV_blank>xxxmB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>megabytes\\n" "xxxgb<S2SV_blank>or<S2SV_blank>xxxGb<S2SV_blank>or<S2SV_blank>xxxGB<S2SV_blank>or<S2SV_blank>xxxgB<S2SV_blank><-<S2SV_blank>indicates<S2SV_blank>gigabytes.\\n" ) ; retval = - 2 ; goto end ; } |
4,071 | CWE-000 int ixv_msix_que ( void * arg ) { struct ix_queue * que = arg ; struct adapter * adapter = que -> adapter ; <S2SV_StartBug> struct ifnet * ifp = adapter -> ifp ; <S2SV_EndBug> struct tx_ring * txr = que -> txr ; struct rx_ring * rxr = que -> rxr ; bool more ; u32 newitr = 0 ; ixv_disable_queue ( adapter , que -> msix ) ; ++ que -> irqs . ev_count ; # ifdef __NetBSD__ more = true ; # else more = ixgbe_rxeof ( que ) ; # endif IXGBE_TX_LOCK ( txr ) ; ixgbe_txeof ( txr ) ; # ifdef IXGBE_LEGACY_TX if ( ! IFQ_IS_EMPTY ( & adapter -> ifp -> if_snd ) ) ixgbe_start_locked ( txr , ifp ) ; <S2SV_StartBug> # else <S2SV_EndBug> if ( pcq_peek ( txr -> txr_interq ) != NULL ) ixgbe_mq_start_locked ( ifp , txr ) ; # endif IXGBE_TX_UNLOCK ( txr ) ; if ( adapter -> enable_aim == false ) goto no_calc ; if ( que -> eitr_setting ) IXGBE_WRITE_REG ( & adapter -> hw , IXGBE_VTEITR ( que -> msix ) , que -> eitr_setting ) ; que -> eitr_setting = 0 ; if ( ( txr -> bytes == 0 ) && ( rxr -> bytes == 0 ) ) goto no_calc ; if ( ( txr -> bytes ) && ( txr -> packets ) ) newitr = txr -> bytes / txr -> packets ; if ( ( rxr -> bytes ) && ( rxr -> packets ) ) newitr = max ( newitr , ( rxr -> bytes / rxr -> packets ) ) ; newitr += 24 ; newitr = min ( newitr , 3000 ) ; if ( ( newitr > 300 ) && ( newitr < 1200 ) ) newitr = ( newitr / 3 ) ; else newitr = ( newitr / 2 ) ; newitr |= newitr << 16 ; que -> eitr_setting = newitr ; txr -> bytes = 0 ; txr -> packets = 0 ; rxr -> bytes = 0 ; rxr -> packets = 0 ; no_calc : if ( more ) softint_schedule ( que -> que_si ) ; else ixv_enable_queue ( adapter , que -> msix ) ; return 1 ; } | <S2SV_ModStart> -> adapter ; # ifdef IXGBE_LEGACY_TX <S2SV_ModStart> -> ifp ; # endif <S2SV_ModStart> ) ; # <S2SV_ModEnd> endif IXGBE_TX_UNLOCK ( |
4,072 | CWE-000 static int ueld_umount ( char * info ) { int fd ; char * src , * target , * type ; src = info ; target = strchr ( src , '<S2SV_blank>' ) ; * target ++ = 0 ; type = strchr ( target , '<S2SV_blank>' ) ; * type ++ = 0 ; <S2SV_StartBug> printf ( "Trying<S2SV_blank>to<S2SV_blank>unmount<S2SV_blank>%s\\n" , target ) ; <S2SV_EndBug> if ( ( fd = open ( target , O_RDONLY ) ) >= 0 ) { syncfs ( fd ) ; close ( fd ) ; } if ( strcmp ( target , "/" ) != 0 ) { if ( umount ( target ) < 0 ) { <S2SV_StartBug> printf ( "Unmounting<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>(%s),<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>remount<S2SV_blank>it<S2SV_blank>to<S2SV_blank>read-only.\\n" , target , strerror ( errno ) ) ; <S2SV_EndBug> } else { return 0 ; } } if ( mount ( src , target , type , MS_MGC_VAL | MS_RDONLY | MS_REMOUNT , NULL ) < 0 ) { <S2SV_StartBug> perror ( "mount" ) ; <S2SV_EndBug> return - 1 ; } return 0 ; } | <S2SV_ModStart> = 0 ; ueld_print <S2SV_ModEnd> ( "Trying<S2SV_blank>to<S2SV_blank>unmount<S2SV_blank>%s\\n" , <S2SV_ModStart> 0 ) { ueld_print <S2SV_ModEnd> ( "Unmounting<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>(%s),<S2SV_blank>trying<S2SV_blank>to<S2SV_blank>remount<S2SV_blank>it<S2SV_blank>to<S2SV_blank>read-only.\\n" , <S2SV_ModStart> 0 ) { ueld_print ( "Error:<S2SV_blank>Re-mount<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>(%s),<S2SV_blank>system<S2SV_blank>will<S2SV_blank>not<S2SV_blank>poweroff<S2SV_blank>or<S2SV_blank>poweroff<S2SV_blank>unsafely." , target , strerror ( errno ) <S2SV_ModEnd> ) ; return |
4,073 | CWE-000 static OSStatus GetFontFamilyName ( FMFontFamily fontFamily , char * name , int numBytes ) { OSStatus err ; Str255 nativeName ; CFStringRef cfString ; TextEncoding encoding ; ScriptCode nameencoding ; nativeName [ 0 ] = 0 ; name [ 0 ] = 0 ; err = ChkErr ( FMGetFontFamilyName , fontFamily , nativeName ) ; if ( err != noErr ) { return err ; } encoding = kTextEncodingMacRoman ; ChkErr ( FMGetFontFamilyTextEncoding , fontFamily , & encoding ) ; nameencoding = encoding ; ChkErr ( RevertTextEncodingToScriptInfo , encoding , & nameencoding , NULL , NULL ) ; cfString = CFStringCreateWithPascalStringNoCopy ( NULL , nativeName , nameencoding , kCFAllocatorNull ) ; <S2SV_StartBug> CFStringGetCString ( <S2SV_EndBug> cfString , name , numBytes , kCFStringEncodingUTF8 ) ; CFRelease ( cfString ) ; return noErr ; } | <S2SV_ModStart> kCFAllocatorNull ) ; if ( cfString == NULL ) { TkMacOSXDbgMsg ( "CFStringCreate:<S2SV_blank>" "\'%.*s\'<S2SV_blank>could<S2SV_blank>not<S2SV_blank>be<S2SV_blank>decoded<S2SV_blank>with<S2SV_blank>encoding<S2SV_blank>%d" , nativeName [ 0 ] , nativeName + 1 , ( int ) nameencoding ) ; return kTextMalformedInputErr ; } |
4,074 | CWE-000 int cellular_op_iccid ( struct cellular * modem , char * buf , size_t len ) { at_set_timeout ( modem -> at , AT_TIMEOUT_LONG ) ; const char * response = at_command ( modem -> at , "AT+CCID" ) ; if ( response == NULL ) { return - 2 ; } if ( strlen ( response ) == CELLULAR_ICCID_LENGTH && len > CELLULAR_ICCID_LENGTH ) { strncpy ( buf , response , len ) ; <S2SV_StartBug> } else { <S2SV_EndBug> return - 1 ; } return 0 ; } | <S2SV_ModStart> ; } else if ( ! strncmp ( response , "+CCID:" , strlen ( "+CCID:" ) ) ) { sscanf ( response , "+CCID:<S2SV_blank>%[0-9]" , buf ) ; } else |
4,075 | CWE-000 void matrix_mult ( matrix a , matrix b , matrix buf ) { <S2SV_StartBug> vector curr_line ; <S2SV_EndBug> matrix bT ; matrix_transpose ( b , bT ) ; for ( int k = 0 ; k < N ; k ++ ) { for ( int i = 0 ; i < N ; i ++ ) { vector_assign ( curr_line , a [ k ] ) ; vector_mult ( curr_line , bT [ i ] ) ; float reduce = vector_reduce ( curr_line ) ; matrix_setxy ( buf , k , i , reduce ) ; } } } | <S2SV_ModStart> buf ) { <S2SV_ModEnd> matrix_transpose ( b |
4,076 | CWE-000 static gboolean delete_signatures ( OstreeRepo * repo , const char * commit_checksum , const char * const * key_ids , guint n_key_ids , guint * out_n_deleted , GCancellable * cancellable , GError * * error ) { GVariantDict metadata_dict ; g_autoptr ( OstreeGpgVerifyResult ) result = NULL ; g_autoptr ( GVariant ) old_metadata = NULL ; g_autoptr ( GVariant ) new_metadata = NULL ; g_autoptr ( GVariant ) signature_data = NULL ; GVariantIter iter ; GVariant * child ; GQueue signatures = G_QUEUE_INIT ; GQueue trash = G_QUEUE_INIT ; guint n_deleted = 0 ; guint ii ; gboolean ret = FALSE ; GError * local_error = NULL ; if ( ! ostree_repo_read_commit_detached_metadata ( repo , commit_checksum , & old_metadata , cancellable , error ) ) goto out ; g_variant_dict_init ( & metadata_dict , old_metadata ) ; signature_data = g_variant_dict_lookup_value ( & metadata_dict , _OSTREE_METADATA_GPGSIGS_NAME , G_VARIANT_TYPE ( "aay" ) ) ; if ( signature_data == NULL ) { g_variant_dict_clear ( & metadata_dict ) ; goto shortcut ; } result = ostree_repo_verify_commit_ext ( repo , commit_checksum , NULL , NULL , cancellable , & local_error ) ; if ( result == NULL ) { g_variant_dict_clear ( & metadata_dict ) ; goto out ; } g_variant_iter_init ( & iter , signature_data ) ; while ( ( child = g_variant_iter_next_value ( & iter ) ) != NULL ) { g_queue_push_tail ( & signatures , child ) ; } g_assert_cmpuint ( ostree_gpg_verify_result_count_all ( result ) , == , signatures . length ) ; for ( ii = 0 ; ii < n_key_ids ; ii ++ ) { guint index ; if ( ostree_gpg_verify_result_lookup ( result , key_ids [ ii ] , & index ) ) { GList * link = g_queue_peek_nth_link ( & signatures , index ) ; if ( g_queue_find ( & trash , link ) == NULL ) <S2SV_StartBug> g_queue_push_tail ( & trash , link ) ; <S2SV_EndBug> } } n_deleted = trash . length ; while ( ! g_queue_is_empty ( & trash ) ) { GList * link = g_queue_pop_head ( & trash ) ; g_variant_unref ( link -> data ) ; g_queue_delete_link ( & signatures , link ) ; } if ( g_queue_is_empty ( & signatures ) ) { g_variant_dict_remove ( & metadata_dict , _OSTREE_METADATA_GPGSIGS_NAME ) ; } else { GVariantBuilder signature_builder ; g_variant_builder_init ( & signature_builder , G_VARIANT_TYPE ( "aay" ) ) ; while ( ! g_queue_is_empty ( & signatures ) ) { GVariant * child = g_queue_pop_head ( & signatures ) ; g_variant_builder_add_value ( & signature_builder , child ) ; g_variant_unref ( child ) ; } g_variant_dict_insert_value ( & metadata_dict , _OSTREE_METADATA_GPGSIGS_NAME , g_variant_builder_end ( & signature_builder ) ) ; } new_metadata = g_variant_dict_end ( & metadata_dict ) ; if ( ! ostree_repo_write_commit_detached_metadata ( repo , commit_checksum , new_metadata , cancellable , error ) ) goto out ; shortcut : if ( out_n_deleted != NULL ) * out_n_deleted = n_deleted ; ret = TRUE ; out : return ret ; } | <S2SV_ModStart> == NULL ) { g_autoptr ( GBytes ) sig_bytes = NULL ; <S2SV_ModStart> link ) ; sig_bytes = g_variant_get_data_as_bytes ( link -> data ) ; if ( ! ostree_repo_delete_compat_signature ( repo , commit_checksum , sig_bytes , cancellable , error ) ) goto out ; } |
4,077 | CWE-000 void rsp_recv_done ( struct context * ctx , struct conn * conn , struct msg * msg , struct msg * nmsg ) { struct msg * pmsg ; ASSERT ( ! conn -> client && ! conn -> proxy ) ; ASSERT ( msg != NULL && conn -> rmsg == msg ) ; ASSERT ( ! msg -> request ) ; ASSERT ( msg -> owner == conn ) ; ASSERT ( nmsg == NULL || ! nmsg -> request ) ; pmsg = TAILQ_FIRST ( & conn -> omsg_q ) ; <S2SV_StartBug> stats_server_record_latency ( ctx , conn -> owner , nc_msec_now ( ) - pmsg -> forward_start_ts ) ; <S2SV_EndBug> conn -> rmsg = nmsg ; if ( rsp_filter ( ctx , conn , msg ) ) { return ; } rsp_forward ( ctx , conn , msg ) ; } | <S2SV_ModStart> omsg_q ) ; if ( pmsg ) { <S2SV_ModStart> forward_start_ts ) ; } |
4,078 | CWE-000 bool logicIsKingThreatened ( ChessGame * game , PLAYER_COLOR color ) { <S2SV_StartBug> ChessPiece * king = ( color == WHITE ? game -> whiteKing : game -> blackKing ) ; <S2SV_EndBug> <S2SV_StartBug> return logicCheckThreatened ( game , king -> position , color ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> color ) { for ( int i = 0 ; i < 8 ; i ++ ) { for ( int j = 0 ; j < 8 ; j ++ ) { Position pos = newPos ( i , j ) ; ChessPiece * piece = gameGetPieceAt ( game , pos ) ; if ( piece != NULL && piece -> type == KING ) <S2SV_ModEnd> return logicCheckThreatened ( <S2SV_ModStart> ( game , pos <S2SV_ModEnd> , color ) <S2SV_ModStart> ) ; } } return false ; } |
4,079 | CWE-000 int stopExp ( ) { if ( is_root ( ) && isModuleLoaded ( ) ) { char command [ 100 ] ; flush_buffer ( command , 100 ) ; <S2SV_StartBug> sprintf ( command , "%c" , STOP_EXP ) ; <S2SV_EndBug> return send_to_timekeeper ( command ) ; } return - 1 ; } | <S2SV_ModStart> ( command , "%c," <S2SV_ModEnd> , STOP_EXP ) |
4,080 | CWE-000 int_f h5oget_info_c ( hid_t_f * object_id , H5O_info_t_f * object_info ) { int_f ret_value = 0 ; H5O_info_t Oinfo ; <S2SV_StartBug> if ( H5Oget_info ( ( hid_t ) * object_id , & Oinfo ) < 0 ) <S2SV_EndBug> HGOTO_DONE ( FAIL ) ; ret_value = fill_h5o_info_t_f ( Oinfo , object_info ) ; done : return ret_value ; } | <S2SV_ModStart> ; if ( H5Oget_info2 <S2SV_ModEnd> ( ( hid_t <S2SV_ModStart> , & Oinfo , ( unsigned ) 15 |
4,081 | CWE-000 ret_t widget_to_local ( widget_t * widget , point_t * p ) { widget_t * iter = widget ; return_value_if_fail ( widget != NULL && p != NULL , RET_BAD_PARAMS ) ; while ( iter != NULL ) { <S2SV_StartBug> p -> x -= iter -> x ; <S2SV_EndBug> p -> y -= iter -> y ; iter = iter -> parent ; } return RET_OK ; } | <S2SV_ModStart> NULL ) { if ( iter -> vt -> scrollable ) { p -> x += widget_get_prop_int ( iter , WIDGET_PROP_XOFFSET , 0 ) ; p -> y += widget_get_prop_int ( iter , WIDGET_PROP_YOFFSET , 0 ) ; } |
4,082 | CWE-000 static int __qce_init_clk ( struct qce_device * pce_dev ) { int rc = 0 ; pce_dev -> ce_core_src_clk = clk_get ( pce_dev -> pdev , "core_clk_src" ) ; if ( ! IS_ERR ( pce_dev -> ce_core_src_clk ) ) { rc = clk_set_rate ( pce_dev -> ce_core_src_clk , pce_dev -> ce_opp_freq_hz ) ; if ( rc ) { pr_err ( "Unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the<S2SV_blank>core<S2SV_blank>src<S2SV_blank>clk<S2SV_blank>@%uMhz.\\n" , pce_dev -> ce_opp_freq_hz / CE_CLK_DIV ) ; goto exit_put_core_src_clk ; } } else { if ( pce_dev -> support_only_core_src_clk ) { rc = PTR_ERR ( pce_dev -> ce_core_src_clk ) ; pce_dev -> ce_core_src_clk = NULL ; pr_err ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>CE<S2SV_blank>core<S2SV_blank>src<S2SV_blank>clk\\n" ) ; return rc ; } else { pr_warn ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>CE<S2SV_blank>core<S2SV_blank>src<S2SV_blank>clk,<S2SV_blank>set<S2SV_blank>to<S2SV_blank>NULL\\n" ) ; pce_dev -> ce_core_src_clk = NULL ; } } if ( pce_dev -> support_only_core_src_clk ) { pce_dev -> ce_core_clk = NULL ; pce_dev -> ce_clk = NULL ; pce_dev -> ce_bus_clk = NULL ; } else { pce_dev -> ce_core_clk = clk_get ( pce_dev -> pdev , "core_clk" ) ; if ( IS_ERR ( pce_dev -> ce_core_clk ) ) { rc = PTR_ERR ( pce_dev -> ce_core_clk ) ; pr_err ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>CE<S2SV_blank>core<S2SV_blank>clk\\n" ) ; goto exit_put_core_src_clk ; } pce_dev -> ce_clk = clk_get ( pce_dev -> pdev , "iface_clk" ) ; if ( IS_ERR ( pce_dev -> ce_clk ) ) { rc = PTR_ERR ( pce_dev -> ce_clk ) ; pr_err ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>CE<S2SV_blank>interface<S2SV_blank>clk\\n" ) ; goto exit_put_core_clk ; } pce_dev -> ce_bus_clk = clk_get ( pce_dev -> pdev , "bus_clk" ) ; if ( IS_ERR ( pce_dev -> ce_bus_clk ) ) { rc = PTR_ERR ( pce_dev -> ce_bus_clk ) ; pr_err ( "Unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>CE<S2SV_blank>BUS<S2SV_blank>interface<S2SV_blank>clk\\n" ) ; goto exit_put_iface_clk ; } } return rc ; exit_put_iface_clk : <S2SV_StartBug> clk_put ( pce_dev -> ce_clk ) ; <S2SV_EndBug> exit_put_core_clk : if ( pce_dev -> ce_core_clk ) clk_put ( pce_dev -> ce_core_clk ) ; exit_put_core_src_clk : <S2SV_StartBug> clk_put ( pce_dev -> ce_core_src_clk ) ; <S2SV_EndBug> pr_err ( "Unable<S2SV_blank>to<S2SV_blank>init<S2SV_blank>CE<S2SV_blank>clks,<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , rc ) ; return rc ; } | <S2SV_ModStart> ; exit_put_iface_clk : if ( pce_dev -> ce_clk ) <S2SV_ModStart> ; exit_put_core_src_clk : if ( pce_dev -> ce_core_src_clk ) |
4,083 | CWE-000 static const char * unique_tracking_name ( const char * name , struct object_id * oid ) { struct tracking_name_data cb_data = { NULL , NULL , NULL , 1 } ; <S2SV_StartBug> char src_ref [ PATH_MAX ] ; <S2SV_EndBug> <S2SV_StartBug> snprintf ( src_ref , PATH_MAX , "refs/heads/%s" , name ) ; <S2SV_EndBug> cb_data . src_ref = src_ref ; cb_data . dst_oid = oid ; <S2SV_StartBug> for_each_remote ( check_tracking_name , & cb_data ) ; <S2SV_EndBug> if ( cb_data . unique ) return cb_data . dst_ref ; free ( cb_data . dst_ref ) ; return NULL ; } | <S2SV_ModStart> 1 } ; cb_data . src_ref = xstrfmt ( <S2SV_ModEnd> "refs/heads/%s" , name <S2SV_ModStart> , name ) <S2SV_ModEnd> ; cb_data . <S2SV_ModStart> , & cb_data ) ; free ( cb_data . src_ref |
4,084 | CWE-000 int checkUse ( int ldes ) { struct lockent * lptr = & locktab [ ldes ] ; int j = 0 ; <S2SV_StartBug> for ( j = 0 ; j < NPROC ; j ++ ) { <S2SV_EndBug> if ( lptr -> procArray [ j ] == 1 ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> = 0 ; while ( <S2SV_ModEnd> j < NPROC <S2SV_ModStart> j < NPROC <S2SV_ModEnd> ) { if <S2SV_ModStart> ) { return 0 ; } j ++ ; } return <S2SV_ModStart> 1 ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,085 | CWE-000 static VALUE parser_append_data ( VALUE self , VALUE source , int is_placeholder ) { struct parser_t * parser = NULL ; char * string = NULL ; <S2SV_StartBug> long unsigned int length = 0 , cursor = 0 ; <S2SV_EndBug> if ( NIL_P ( source ) ) return Qnil ; Check_Type ( source , T_STRING ) ; Parser_Get_Struct ( self , parser ) ; string = StringValueCStr ( source ) ; length = strlen ( string ) ; <S2SV_StartBug> cursor = parser -> doc . length ; <S2SV_EndBug> if ( parser -> doc . data == NULL ) { parser -> doc . enc_index = rb_enc_get_index ( source ) ; } else if ( parser -> doc . enc_index != rb_enc_get_index ( source ) ) { rb_raise ( rb_eArgError , "cannot<S2SV_blank>append<S2SV_blank>%s<S2SV_blank>string<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>document" , rb_enc_name ( rb_enc_get ( source ) ) , rb_enc_name ( rb_enc_from_index ( parser -> doc . enc_index ) ) ) ; } if ( ! parser_document_append ( parser , string , length ) ) { return Qnil ; } if ( is_placeholder ) { parser_adjust_line_number ( parser , cursor , length ) ; } else { parser -> tk . scan . cursor = cursor ; parser -> tk . scan . string = parser -> doc . data ; parser -> tk . scan . length = parser -> doc . length ; <S2SV_StartBug> tokenizer_scan_all ( & parser -> tk ) ; <S2SV_EndBug> } return Qtrue ; } | <S2SV_ModStart> cursor = 0 , mb_cursor = 0 <S2SV_ModStart> doc . length ; mb_cursor = parser -> doc . mb_length <S2SV_ModStart> . length ; parser -> tk . scan . enc_index = parser -> doc . enc_index ; parser -> tk . scan . mb_cursor = mb_cursor ; |
4,086 | CWE-000 static void inc_lineno ( void ) { if ( ++ lineno == 0 ) { lineno -- ; <S2SV_StartBug> fatal_error ( "Source<S2SV_blank>file<S2SV_blank>longer<S2SV_blank>than<S2SV_blank>" # UINT16_MAX "<S2SV_blank>lines" ) ; <S2SV_EndBug> } } | <S2SV_ModStart> fatal_error ( "Source<S2SV_blank>file<S2SV_blank>longer<S2SV_blank>than<S2SV_blank>" xstr ( UINT16_MAX ) <S2SV_ModEnd> "<S2SV_blank>lines" ) ; |
4,087 | CWE-000 void intSeconds ( void ) { secInt = true ; count_sec ++ ; g_wButtonPressedCounter1 ++ ; g_wButtonPressedCounter2 ++ ; <S2SV_StartBug> byPressCount ++ ; <S2SV_EndBug> } | <S2SV_ModStart> g_wButtonPressedCounter2 ++ ; g_wButtonPressedCounter3 ++ ; |
4,088 | CWE-000 int dvb_open_device ( adapter * ad ) { char buf [ 100 ] ; LOG ( "trying<S2SV_blank>to<S2SV_blank>open<S2SV_blank>[%d]<S2SV_blank>adapter<S2SV_blank>%d<S2SV_blank>and<S2SV_blank>frontend<S2SV_blank>%d" , ad -> id , ad -> pa , ad -> fn ) ; sprintf ( buf , DEV_FRONTEND , ad -> pa , ad -> fn ) ; ad -> fe = open ( buf , O_RDWR | O_NONBLOCK ) ; if ( ! opts . use_demux_device ) sprintf ( buf , DEV_DVR , ad -> pa , ad -> fn ) ; else sprintf ( buf , DEV_DEMUX , ad -> pa , ad -> fn ) ; ad -> dvr = open ( buf , opts . use_demux_device ? O_RDWR | O_NONBLOCK : O_RDONLY | O_NONBLOCK ) ; if ( ad -> fe < 0 || ad -> dvr < 0 ) { sprintf ( buf , DEV_FRONTEND , ad -> pa , ad -> fn ) ; LOG ( "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>RW<S2SV_blank>mode<S2SV_blank>(fe:<S2SV_blank>%d,<S2SV_blank>dvr:<S2SV_blank>%d)<S2SV_blank>error<S2SV_blank>%d:<S2SV_blank>%s" , buf , ad -> fe , ad -> dvr , errno , strerror ( errno ) ) ; if ( ad -> fe >= 0 ) close ( ad -> fe ) ; if ( ad -> dvr >= 0 ) close ( ad -> dvr ) ; ad -> fe = ad -> dvr = - 1 ; return 1 ; } ad -> type = ADAPTER_DVB ; ad -> dmx = - 1 ; LOG ( "opened<S2SV_blank>DVB<S2SV_blank>adapter<S2SV_blank>%d<S2SV_blank>fe:%d<S2SV_blank>dvr:%d" , ad -> id , ad -> fe , ad -> dvr ) ; if ( ioctl ( ad -> dvr , DMX_SET_BUFFER_SIZE , opts . dvr_buffer ) < 0 ) LOG ( "couldn\'t<S2SV_blank>set<S2SV_blank>DVR<S2SV_blank>buffer<S2SV_blank>size<S2SV_blank>error<S2SV_blank>%d:<S2SV_blank>%s" , errno , strerror ( errno ) ) else LOG ( "DVR<S2SV_blank>buffer<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>bytes" , opts . dvr_buffer ) ; if ( ad -> dmx_source >= 0 ) { sprintf ( buf , DEV_DEMUX , ad -> pa , ad -> fn ) ; ad -> dmx = open ( buf , O_RDWR | O_NONBLOCK ) ; if ( ad -> dmx <= 0 ) LOG ( "DMX_SET_SOURCE:<S2SV_blank>Failed<S2SV_blank>opening<S2SV_blank>%s" , buf ) else if ( ioctl ( ad -> dmx , DMX_SET_SOURCE , & ad -> dmx_source ) ) { LOG ( "DMX_SET_SOURCE<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>adapter<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>%d:<S2SV_blank>%s" , ad -> id , errno , strerror ( errno ) ) ; } else LOG ( "Set<S2SV_blank>DMX_SET_SOURCE<S2SV_blank>for<S2SV_blank>adapter<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>%d" , ad -> id , ad -> dmx_source ) ; <S2SV_StartBug> close ( ad -> dmx ) ; <S2SV_EndBug> ad -> dmx = - 1 ; } return 0 ; } | <S2SV_ModStart> dmx_source ) ; if ( ad -> dmx >= 0 ) |
4,089 | CWE-000 static int peak_usb_create_dev ( struct peak_usb_adapter * peak_usb_adapter , struct usb_interface * intf , int ctrl_idx ) { struct usb_device * usb_dev = interface_to_usbdev ( intf ) ; int sizeof_candev = peak_usb_adapter -> sizeof_dev_private ; struct peak_usb_device * dev ; struct net_device * netdev ; int i , err ; u16 tmp16 ; if ( sizeof_candev < sizeof ( struct peak_usb_device ) ) sizeof_candev = sizeof ( struct peak_usb_device ) ; netdev = alloc_candev ( sizeof_candev , PCAN_USB_MAX_TX_URBS ) ; if ( ! netdev ) { dev_err ( & intf -> dev , "%s:<S2SV_blank>couldn\'t<S2SV_blank>alloc<S2SV_blank>candev\\n" , PCAN_USB_DRIVER_NAME ) ; return - ENOMEM ; } dev = netdev_priv ( netdev ) ; dev -> cmd_buf = kmalloc ( PCAN_USB_MAX_CMD_LEN , GFP_KERNEL ) ; if ( ! dev -> cmd_buf ) { err = - ENOMEM ; <S2SV_StartBug> goto lbl_set_intf_data ; <S2SV_EndBug> } dev -> udev = usb_dev ; dev -> netdev = netdev ; dev -> adapter = peak_usb_adapter ; dev -> ctrl_idx = ctrl_idx ; dev -> state = PCAN_USB_STATE_CONNECTED ; dev -> ep_msg_in = peak_usb_adapter -> ep_msg_in ; dev -> ep_msg_out = peak_usb_adapter -> ep_msg_out [ ctrl_idx ] ; dev -> can . clock = peak_usb_adapter -> clock ; dev -> can . bittiming_const = & peak_usb_adapter -> bittiming_const ; dev -> can . do_set_bittiming = peak_usb_set_bittiming ; dev -> can . do_set_mode = peak_usb_set_mode ; dev -> can . ctrlmode_supported = CAN_CTRLMODE_3_SAMPLES | CAN_CTRLMODE_LISTENONLY ; netdev -> netdev_ops = & peak_usb_netdev_ops ; netdev -> flags |= IFF_ECHO ; init_usb_anchor ( & dev -> rx_submitted ) ; init_usb_anchor ( & dev -> tx_submitted ) ; atomic_set ( & dev -> active_tx_urbs , 0 ) ; for ( i = 0 ; i < PCAN_USB_MAX_TX_URBS ; i ++ ) dev -> tx_contexts [ i ] . echo_index = PCAN_USB_MAX_TX_URBS ; dev -> prev_siblings = usb_get_intfdata ( intf ) ; usb_set_intfdata ( intf , dev ) ; SET_NETDEV_DEV ( netdev , & intf -> dev ) ; err = register_candev ( netdev ) ; if ( err ) { dev_err ( & intf -> dev , "couldn\'t<S2SV_blank>register<S2SV_blank>CAN<S2SV_blank>device:<S2SV_blank>%d\\n" , err ) ; <S2SV_StartBug> goto lbl_free_cmd_buf ; <S2SV_EndBug> } if ( dev -> prev_siblings ) ( dev -> prev_siblings ) -> next_siblings = dev ; tmp16 = le16_to_cpu ( usb_dev -> descriptor . bcdDevice ) ; dev -> device_rev = tmp16 >> 8 ; if ( dev -> adapter -> dev_init ) { err = dev -> adapter -> dev_init ( dev ) ; if ( err ) <S2SV_StartBug> goto lbl_free_cmd_buf ; <S2SV_EndBug> } if ( dev -> adapter -> dev_set_bus ) { err = dev -> adapter -> dev_set_bus ( dev , 0 ) ; if ( err ) <S2SV_StartBug> goto lbl_free_cmd_buf ; <S2SV_EndBug> } if ( dev -> adapter -> dev_get_device_id ) dev -> adapter -> dev_get_device_id ( dev , & dev -> device_number ) ; netdev_info ( netdev , "attached<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>channel<S2SV_blank>%u<S2SV_blank>(device<S2SV_blank>%u)\\n" , peak_usb_adapter -> name , ctrl_idx , dev -> device_number ) ; return 0 ; <S2SV_StartBug> lbl_free_cmd_buf : <S2SV_EndBug> kfree ( dev -> cmd_buf ) ; <S2SV_StartBug> lbl_set_intf_data : <S2SV_EndBug> usb_set_intfdata ( intf , dev -> prev_siblings ) ; free_candev ( netdev ) ; return err ; } | <S2SV_ModStart> ENOMEM ; goto lbl_free_candev <S2SV_ModEnd> ; } dev <S2SV_ModStart> ) ; goto lbl_restore_intf_data <S2SV_ModEnd> ; } if <S2SV_ModStart> err ) goto lbl_unregister_candev <S2SV_ModEnd> ; } if <S2SV_ModStart> err ) goto lbl_unregister_candev <S2SV_ModEnd> ; } if <S2SV_ModStart> return 0 ; lbl_unregister_candev : unregister_candev ( netdev ) ; lbl_restore_intf_data : usb_set_intfdata ( intf , dev -> prev_siblings ) ; <S2SV_ModEnd> kfree ( dev <S2SV_ModStart> cmd_buf ) ; lbl_free_candev : <S2SV_ModEnd> free_candev ( netdev |
4,090 | CWE-000 int write_intensity_to_file ( Mu_hist * hist , double * intensity ) { FILE * write_file_intens = NULL ; if ( ( write_file_intens = fopen ( OUTPUT_FILE_INTENS , "w" ) ) == NULL ) { printf ( "Cannot<S2SV_blank>access<S2SV_blank>file<S2SV_blank>\'%s\'.\\n" , OUTPUT_FILE_INTENS ) ; exit ( - 1 ) ; } fprintf ( write_file_intens , "theta\\tcounts\\tintensity\\n" ) ; for ( int i = 0 ; i < mu_bins ; i ++ ) <S2SV_StartBug> fprintf ( write_file_intens , "%f\\t%d\\t%f\\n" , hist -> theta [ i ] , <S2SV_EndBug> hist -> bins [ i ] , intensity [ i ] ) ; if ( fclose ( write_file_intens ) != 0 ) { printf ( "Cannot<S2SV_blank>close<S2SV_blank>file<S2SV_blank>\'%s\'.\\n" , OUTPUT_FILE_INTENS ) ; exit ( - 1 ) ; } return 0 ; } | <S2SV_ModStart> ( write_file_intens , "%f\\t%f\\t%f\\n" <S2SV_ModEnd> , hist -> |
4,091 | CWE-000 double power_law_f ( double gamma , struct parameters * params ) { static double norm = 0. ; static double previous_power_law_p = 0. ; static double previous_gamma_min = 0. ; static double previous_gamma_max = 0. ; static double previous_gamma_cutoff = 0. ; if ( norm == 0. || previous_power_law_p != params -> power_law_p || previous_gamma_min != params -> gamma_min || previous_gamma_max != params -> gamma_max || previous_gamma_cutoff != params -> gamma_cutoff ) { norm = 1. / normalize_f ( & power_law_to_be_normalized , params ) ; previous_power_law_p = params -> power_law_p ; previous_gamma_min = params -> gamma_min ; previous_gamma_max = params -> gamma_max ; previous_gamma_cutoff = params -> gamma_cutoff ; } <S2SV_StartBug> if ( gamma < params -> gamma_min || gamma > params -> gamma_max ) <S2SV_EndBug> return 0 ; double beta = sqrt ( 1. - 1. / ( gamma * gamma ) ) ; double prefactor = params -> electron_density * ( params -> power_law_p - 1. ) / ( pow ( params -> gamma_min , 1. - params -> power_law_p ) - pow ( params -> gamma_max , 1. - params -> power_law_p ) ) ; double body = pow ( gamma , - params -> power_law_p ) * exp ( - gamma / params -> gamma_cutoff ) ; double ans = norm * prefactor * body * 1. / ( pow ( params -> mass_electron , 3. ) * pow ( params -> speed_light , 3. ) * gamma * gamma * beta ) ; return ans ; } | <S2SV_ModStart> gamma_cutoff ; } <S2SV_ModEnd> double beta = |
4,092 | CWE-000 struct wlr_primary_selection_device_manager * wlr_primary_selection_device_manager_create ( struct wl_display * display ) { struct wlr_primary_selection_device_manager * manager = calloc ( 1 , sizeof ( struct wlr_primary_selection_device_manager ) ) ; if ( manager == NULL ) { return NULL ; } manager -> global = wl_global_create ( display , <S2SV_StartBug> & gtk_primary_selection_device_manager_interface , 1 , manager , <S2SV_EndBug> primary_selection_device_manager_bind ) ; if ( manager -> global == NULL ) { free ( manager ) ; return NULL ; } wl_signal_init ( & manager -> events . destroy ) ; manager -> display_destroy . notify = handle_display_destroy ; wl_display_add_destroy_listener ( display , & manager -> display_destroy ) ; return manager ; } | <S2SV_ModStart> & gtk_primary_selection_device_manager_interface , DEVICE_MANAGER_VERSION <S2SV_ModEnd> , manager , |
4,093 | CWE-000 Entry * newEntry ( char * text , int sz ) { Entry * p ; require ( text != NULL , "new:<S2SV_blank>NULL<S2SV_blank>terminal" ) ; <S2SV_StartBug> p = ( Entry * ) calloc ( 1 , sz ) ) ; <S2SV_EndBug> if ( p == NULL ) { fatal_internal ( "newEntry:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>terminals\\n" ) ; exit ( PCCTS_EXIT_FAILURE ) ; } p -> str = strdup ( text ) ; return ( p ) ; } | <S2SV_ModStart> 1 , sz <S2SV_ModEnd> ) ; if |
4,094 | CWE-000 static void i2s_stop ( ) { esp_intr_disable ( s_state -> i2s_intr_handle ) ; <S2SV_StartBug> esp_intr_disable ( s_state -> vsync_intr_handle ) ; <S2SV_EndBug> i2s_conf_reset ( ) ; I2S0 . conf . rx_start = 0 ; size_t val = SIZE_MAX ; BaseType_t higher_priority_task_woken ; xQueueSendFromISR ( s_state -> data_ready , & val , & higher_priority_task_woken ) ; } | <S2SV_ModStart> i2s_intr_handle ) ; vsync_intr_disable ( <S2SV_ModEnd> ) ; i2s_conf_reset |
4,095 | CWE-000 void menu_cmd_spitest_handler ( uint8_t arg_len , char * * args ) { if ( arg_len != 1 ) { <S2SV_StartBug> serial_0_put_string_P ( menu_help_loops ) ; <S2SV_EndBug> return ; } uint8_t id ; uint8_t rdid_cmd [ 4 ] = { 0b10101011 , 0 , 0 , 0 } ; uint8_t input [ 1 ] ; spi_start_half_duplex ( & id , EEPROM_CS_NUM , rdid_cmd , 4 , input , 1 ) ; while ( ! spi_transaction_done ( id ) ) { spi_service ( ) ; } serial_0_put_string ( "RDID<S2SV_blank>finished.<S2SV_blank>SIG:<S2SV_blank>0x" ) ; char str [ 10 ] ; ultoa ( input [ 0 ] , str , 16 ) ; serial_0_put_string ( str ) ; serial_0_put_byte ( '\\n' ) ; spi_clear_transaction ( id ) ; uint8_t wren_cmd [ 1 ] = { 0b00000110 } ; spi_start_half_duplex ( & id , EEPROM_CS_NUM , wren_cmd , 1 , NULL , 0 ) ; while ( ! spi_transaction_done ( id ) ) { spi_service ( ) ; } serial_0_put_string ( "WREN<S2SV_blank>finished.\\n" ) ; <S2SV_StartBug> uint8_t write_cmd [ 3 ] = { 0b00000110 , 0 , 0 , 0 , 0xff } ; <S2SV_EndBug> <S2SV_StartBug> spi_start_half_duplex ( & id , EEPROM_CS_NUM , wren_cmd , 1 , NULL , 0 ) ; <S2SV_EndBug> while ( ! spi_transaction_done ( id ) ) { spi_service ( ) ; } serial_0_put_string ( "WRITE<S2SV_blank>finished.\\n" ) ; } | <S2SV_ModStart> { serial_0_put_string_P ( menu_help_spitest <S2SV_ModEnd> ) ; return <S2SV_ModStart> uint8_t write_cmd [ 5 <S2SV_ModEnd> ] = { <S2SV_ModStart> , EEPROM_CS_NUM , write_cmd <S2SV_ModEnd> , 1 , |
4,096 | CWE-000 GstMfxEncoderStatus gst_mfx_encoder_prepare ( GstMfxEncoder * encoder ) { GstMfxEncoderPrivate * const priv = GST_MFX_ENCODER_GET_PRIVATE ( encoder ) ; mfxStatus sts = MFX_ERR_NONE ; mfxFrameAllocRequest * request ; mfxVideoParam * params ; mfxFrameAllocRequest enc_request = { 0 } ; mfxU32 encoder_format , input_format = gst_video_format_to_mfx_fourcc ( GST_VIDEO_INFO_FORMAT ( & priv -> info ) ) ; if ( GST_VIDEO_INFO_FORMAT ( & priv -> info ) == GST_VIDEO_FORMAT_P010_10LE ) gst_mfx_encoder_set_profile ( encoder , MFX_PROFILE_HEVC_MAIN10 ) ; gst_mfx_encoder_set_encoding_params ( encoder ) ; encoder_format = priv -> params . mfx . FrameInfo . FourCC ; if ( ! priv -> input_memtype_is_system ) { if ( configure_encoder_sharing ( encoder ) ) input_format = priv -> frame_info . FourCC ; else return GST_MFX_ENCODER_STATUS_ERROR_ALLOCATION_FAILED ; } else { init_encoder_task ( encoder ) ; } if ( ! priv -> encode ) return GST_MFX_ENCODER_STATUS_ERROR_ALLOCATION_FAILED ; if ( encoder_format == input_format && priv -> input_memtype_is_system ) priv -> encoder_memtype_is_system = TRUE ; <S2SV_StartBug> gst_mfx_encoder_set_frame_info ( encoder ) ; <S2SV_EndBug> if ( priv -> plugin_uids ) if ( ! gst_mfx_encoder_load_plugin ( encoder ) ) <S2SV_StartBug> return GST_MFX_ENCODER_STATUS_ERROR_OPERATION_FAILED ; <S2SV_EndBug> sts = MFXVideoENCODE_Query ( priv -> session , & priv -> params , & priv -> params ) ; if ( MFX_WRN_PARTIAL_ACCELERATION == sts ) { GST_WARNING ( "Partial<S2SV_blank>acceleration<S2SV_blank>%d" , sts ) ; priv -> encoder_memtype_is_system = TRUE ; } else if ( MFX_WRN_INCOMPATIBLE_VIDEO_PARAM == sts ) { GST_WARNING ( "Incompatible<S2SV_blank>video<S2SV_blank>params<S2SV_blank>detected<S2SV_blank>%d" , sts ) ; } sts = MFXVideoENCODE_QueryIOSurf ( priv -> session , & priv -> params , & enc_request ) ; if ( sts < 0 ) { GST_ERROR ( "Unable<S2SV_blank>to<S2SV_blank>query<S2SV_blank>encode<S2SV_blank>allocation<S2SV_blank>request<S2SV_blank>%d" , sts ) ; return GST_MFX_ENCODER_STATUS_ERROR_ALLOCATION_FAILED ; } if ( priv -> shared ) { params = gst_mfx_task_get_video_params ( priv -> encode ) ; request = gst_mfx_task_get_request ( priv -> encode ) ; params -> AsyncDepth = priv -> params . AsyncDepth ; if ( gst_mfx_task_has_type ( priv -> encode , GST_MFX_TASK_VPP_OUT ) ) { mfxFrameAllocRequest vpp_request [ 2 ] ; MFXVideoVPP_QueryIOSurf ( priv -> session , params , vpp_request ) ; * request = vpp_request [ 1 ] ; } else if ( gst_mfx_task_has_type ( priv -> encode , GST_MFX_TASK_DECODER ) ) { MFXVideoDECODE_QueryIOSurf ( priv -> session , params , request ) ; } request -> NumFrameSuggested += ( enc_request . NumFrameSuggested - priv -> params . AsyncDepth + 1 ) ; request -> NumFrameMin = request -> NumFrameSuggested ; } else { request = & enc_request ; gst_mfx_task_set_request ( priv -> encode , request ) ; } if ( ! priv -> filter && ( encoder_format != priv -> frame_info . FourCC || priv -> frame_info . PicStruct != MFX_PICSTRUCT_PROGRESSIVE ) ) { priv -> filter = gst_mfx_filter_new_with_task ( priv -> aggregator , priv -> encode , GST_MFX_TASK_VPP_OUT , priv -> input_memtype_is_system , priv -> encoder_memtype_is_system ) ; request -> NumFrameSuggested += ( 1 - priv -> params . AsyncDepth ) ; gst_mfx_task_set_request ( priv -> encode , request ) ; gst_mfx_filter_set_frame_info ( priv -> filter , & priv -> frame_info ) ; gst_mfx_filter_set_async_depth ( priv -> filter , priv -> async_depth ) ; gst_mfx_filter_set_format ( priv -> filter , encoder_format ) ; if ( priv -> frame_info . PicStruct != MFX_PICSTRUCT_PROGRESSIVE ) gst_mfx_filter_set_deinterlace_method ( priv -> filter , GST_MFX_DEINTERLACE_METHOD_ADVANCED_NOREF ) ; if ( ! gst_mfx_filter_prepare ( priv -> filter ) ) return GST_MFX_ENCODER_STATUS_ERROR_OPERATION_FAILED ; priv -> shared = TRUE ; } if ( priv -> shared && ! priv -> encoder_memtype_is_system ) { params = gst_mfx_task_get_video_params ( priv -> encode ) ; priv -> encoder_memtype_is_system = ! ! ( params -> IOPattern & MFX_IOPATTERN_OUT_SYSTEM_MEMORY ) ; } if ( priv -> encoder_memtype_is_system ) { priv -> params . IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY ; gst_mfx_task_ensure_memtype_is_system ( priv -> encode ) ; } else { priv -> params . IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY ; gst_mfx_task_use_video_memory ( priv -> encode ) ; } gst_mfx_task_aggregator_update_peer_memtypes ( priv -> aggregator , priv -> encode , priv -> encoder_memtype_is_system ) ; GST_INFO ( "Preparing<S2SV_blank>MFX<S2SV_blank>encoder<S2SV_blank>task<S2SV_blank>using<S2SV_blank>input<S2SV_blank>%s<S2SV_blank>memory<S2SV_blank>surfaces" , priv -> encoder_memtype_is_system ? "system" : "video" ) ; return GST_MFX_ENCODER_STATUS_SUCCESS ; } | <S2SV_ModStart> = TRUE ; <S2SV_ModEnd> if ( priv <S2SV_ModStart> ) return GST_MFX_ENCODER_STATUS_ERROR_OPERATION_FAILED ; gst_mfx_encoder_set_frame_info ( encoder ) |
4,097 | CWE-000 void my_gc_sweep ( gc_heap * h , int heap_type , size_t * sum_freed_ptr , gc_thread_data * thd ) { size_t freed , heap_freed = 0 , sum_freed = 0 , size ; object p , end ; gc_free_list * q , * r , * s ; # if GC_DEBUG_SHOW_SWEEP_DIAG gc_heap * orig_heap_ptr = h ; # endif gc_heap * prev_h = NULL ; h -> next_free = h ; # if GC_DEBUG_SHOW_SWEEP_DIAG fprintf ( stderr , "\\nBefore<S2SV_blank>sweep<S2SV_blank>-------------------------\\n" ) ; fprintf ( stderr , "Heap<S2SV_blank>%d<S2SV_blank>diagnostics:\\n" , heap_type ) ; gc_print_stats ( orig_heap_ptr ) ; # endif for ( ; h ; prev_h = h , h = h -> next ) { <S2SV_StartBug> int remaining = h -> size - ( h -> size % h -> block_size ) - h -> block_size ; <S2SV_EndBug> char * data_end = h -> data + remaining ; q = h -> free_list ; while ( remaining ) { p = data_end - remaining ; if ( mark ( p ) == TEST_COLOR_CLEAR ) { if ( h -> free_list == NULL ) { q = h -> free_list = p ; h -> free_list -> next = NULL ; } else if ( p <= h -> free_list ) { s = ( gc_free_list * ) p ; s -> next = h -> free_list -> next ; q = h -> free_list = p ; } else { for ( r = q -> next ; r && ( ( char * ) r < ( char * ) p ) ; q = r , r = r -> next ) ; if ( ( char * ) r == ( char * ) p ) { continue ; } s = ( gc_free_list * ) p ; s -> next = r ; q -> next = s ; } } printf ( "sweep<S2SV_blank>remaining=%d<S2SV_blank>p<S2SV_blank>=<S2SV_blank>%p\\n" , remaining , p ) ; remaining -= h -> block_size ; } sum_freed += heap_freed ; heap_freed = 0 ; } # if GC_DEBUG_SHOW_SWEEP_DIAG fprintf ( stderr , "\\nAfter<S2SV_blank>sweep<S2SV_blank>-------------------------\\n" ) ; fprintf ( stderr , "Heap<S2SV_blank>%d<S2SV_blank>diagnostics:\\n" , heap_type ) ; gc_print_stats ( orig_heap_ptr ) ; # endif if ( sum_freed_ptr ) * sum_freed_ptr = sum_freed ; } | <S2SV_ModStart> -> block_size ) <S2SV_ModEnd> ; char * |
4,098 | CWE-000 static int perf_event_parse_addr_filter ( struct perf_event * event , char * fstr , struct list_head * filters ) { struct perf_addr_filter * filter = NULL ; <S2SV_StartBug> char * start , * orig , * filename = NULL ; <S2SV_EndBug> struct path path ; substring_t args [ MAX_OPT_ARGS ] ; int state = IF_STATE_ACTION , token ; unsigned int kernel = 0 ; int ret = - EINVAL ; orig = fstr = kstrdup ( fstr , GFP_KERNEL ) ; if ( ! fstr ) return - ENOMEM ; while ( ( start = strsep ( & fstr , "<S2SV_blank>,\\n" ) ) != NULL ) { static const enum perf_addr_filter_action_t actions [ ] = { [ IF_ACT_FILTER ] = PERF_ADDR_FILTER_ACTION_FILTER , [ IF_ACT_START ] = PERF_ADDR_FILTER_ACTION_START , [ IF_ACT_STOP ] = PERF_ADDR_FILTER_ACTION_STOP , } ; ret = - EINVAL ; if ( ! * start ) continue ; if ( state == IF_STATE_ACTION ) { filter = perf_addr_filter_new ( event , filters ) ; if ( ! filter ) goto fail ; } token = match_token ( start , if_tokens , args ) ; switch ( token ) { case IF_ACT_FILTER : case IF_ACT_START : case IF_ACT_STOP : if ( state != IF_STATE_ACTION ) goto fail ; filter -> action = actions [ token ] ; state = IF_STATE_SOURCE ; break ; case IF_SRC_KERNELADDR : case IF_SRC_KERNEL : kernel = 1 ; case IF_SRC_FILEADDR : case IF_SRC_FILE : if ( state != IF_STATE_SOURCE ) goto fail ; * args [ 0 ] . to = 0 ; ret = kstrtoul ( args [ 0 ] . from , 0 , & filter -> offset ) ; if ( ret ) goto fail ; if ( token == IF_SRC_KERNEL || token == IF_SRC_FILE ) { * args [ 1 ] . to = 0 ; ret = kstrtoul ( args [ 1 ] . from , 0 , & filter -> size ) ; if ( ret ) goto fail ; } if ( token == IF_SRC_FILE || token == IF_SRC_FILEADDR ) { int fpos = token == IF_SRC_FILE ? 2 : 1 ; filename = match_strdup ( & args [ fpos ] ) ; if ( ! filename ) { ret = - ENOMEM ; goto fail ; } } state = IF_STATE_END ; break ; default : goto fail ; } if ( state == IF_STATE_END ) { ret = - EINVAL ; if ( kernel && event -> attr . exclude_kernel ) goto fail ; if ( filter -> action == PERF_ADDR_FILTER_ACTION_FILTER && ! filter -> size ) goto fail ; if ( ! kernel ) { if ( ! filename ) goto fail ; ret = - EOPNOTSUPP ; if ( ! event -> ctx -> task ) goto fail_free_name ; <S2SV_StartBug> ret = kern_path ( filename , LOOKUP_FOLLOW , & path ) ; <S2SV_EndBug> if ( ret ) <S2SV_StartBug> goto fail_free_name ; <S2SV_EndBug> filter -> inode = igrab ( d_inode ( path . dentry ) ) ; path_put ( & path ) ; kfree ( filename ) ; filename = NULL ; ret = - EINVAL ; <S2SV_StartBug> if ( ! filter -> inode || <S2SV_EndBug> <S2SV_StartBug> ! S_ISREG ( filter -> inode -> i_mode ) ) <S2SV_EndBug> goto fail ; event -> addr_filters . nr_file_filters ++ ; } state = IF_STATE_ACTION ; filter = NULL ; } } if ( state != IF_STATE_ACTION ) goto fail ; kfree ( orig ) ; return 0 ; fail_free_name : kfree ( filename ) ; fail : free_filters_list ( filters ) ; kfree ( orig ) ; return ret ; } | <S2SV_ModStart> filename = NULL <S2SV_ModEnd> ; substring_t args <S2SV_ModStart> LOOKUP_FOLLOW , & filter -> <S2SV_ModStart> ) goto fail_free_name <S2SV_ModEnd> ; kfree ( <S2SV_ModStart> ! filter -> path . dentry <S2SV_ModEnd> || ! S_ISREG <S2SV_ModStart> ! S_ISREG ( d_inode ( filter -> path . dentry ) <S2SV_ModEnd> -> i_mode ) |
4,099 | CWE-000 int check_memory ( SIM_coreState * state_inst ) { <S2SV_StartBug> if ( ! mem_ready ) return 0 ; <S2SV_EndBug> mem_ready = SIM_MemDataRead ( state_inst -> pipeStageState [ MEMORY ] . address , & state_inst -> pipeStageState [ MEMORY ] . dstVal ) ; <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> state_inst ) { printf ( "mem<S2SV_blank>ready<S2SV_blank>start:<S2SV_blank>%d\\n" , mem_ready ) ; if ( mem_ready == READY ) return READY ; printf ( "inside<S2SV_blank>mem<S2SV_blank>chk:<S2SV_blank>opcode:<S2SV_blank>%d<S2SV_blank>dst<S2SV_blank>:%d\\n" , state_inst -> pipeStageState [ MEMORY ] . cmd . opcode , state_inst -> pipeStageState [ MEMORY ] . cmd . dst ) <S2SV_ModEnd> ; mem_ready = <S2SV_ModStart> dstVal ) ; printf ( "mem<S2SV_blank>ready<S2SV_blank>end:<S2SV_blank>%d\\n" , mem_ready ) ; return NOT_READY <S2SV_ModEnd> ; } <S2SV_null> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.