Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
8,000 |
CWE-000 int dl_iterate_phdr ( __dl_iterate_hdr_callback callback , void * param ) { struct dl_phdr_info phdr_info ; Obj_Entry * obj , marker ; RtldLockState bind_lockstate , phdr_lockstate ; int error ; <S2SV_StartBug> bzero ( & marker , sizeof ( marker ) ) ; <S2SV_EndBug> marker . marker = true ; error = 0 ; wlock_acquire ( rtld_phdr_lock , & phdr_lockstate ) ; wlock_acquire ( rtld_bind_lock , & bind_lockstate ) ; for ( obj = globallist_curr ( TAILQ_FIRST ( & obj_list ) ) ; obj != NULL ; ) { TAILQ_INSERT_AFTER ( & obj_list , obj , & marker , next ) ; rtld_fill_dl_phdr_info ( obj , & phdr_info ) ; hold_object ( obj ) ; lock_release ( rtld_bind_lock , & bind_lockstate ) ; error = callback ( & phdr_info , sizeof phdr_info , param ) ; wlock_acquire ( rtld_bind_lock , & bind_lockstate ) ; unhold_object ( obj ) ; obj = globallist_next ( & marker ) ; TAILQ_REMOVE ( & obj_list , & marker , next ) ; if ( error != 0 ) { lock_release ( rtld_bind_lock , & bind_lockstate ) ; lock_release ( rtld_phdr_lock , & phdr_lockstate ) ; return ( error ) ; } } if ( error == 0 ) { rtld_fill_dl_phdr_info ( & obj_rtld , & phdr_info ) ; lock_release ( rtld_bind_lock , & bind_lockstate ) ; error = callback ( & phdr_info , sizeof ( phdr_info ) , param ) ; } lock_release ( rtld_phdr_lock , & phdr_lockstate ) ; return ( error ) ; }
|
<S2SV_ModStart> int error ; init_marker ( & marker ) <S2SV_ModEnd> ; error =
|
8,001 |
CWE-000 NTSTATUS GetDeviceSectorSize ( PDEVICE_OBJECT deviceObject , ULONG * bytesPerSector ) { NTSTATUS status ; <S2SV_StartBug> DISK_GEOMETRY_EX geometry ; <S2SV_EndBug> <S2SV_StartBug> status = SendDeviceIoControlRequest ( deviceObject , IOCTL_DISK_GET_DRIVE_GEOMETRY_EX , NULL , 0 , & geometry , sizeof ( geometry ) ) ; <S2SV_EndBug> if ( ! NT_SUCCESS ( status ) ) return status ; <S2SV_StartBug> * bytesPerSector = geometry . Geometry . BytesPerSector ; <S2SV_EndBug> return STATUS_SUCCESS ; }
|
<S2SV_ModStart> NTSTATUS status ; DISK_GEOMETRY <S2SV_ModEnd> geometry ; status <S2SV_ModStart> ( deviceObject , IOCTL_DISK_GET_DRIVE_GEOMETRY <S2SV_ModEnd> , NULL , <S2SV_ModStart> = geometry . <S2SV_ModEnd> BytesPerSector ; return
|
8,002 |
CWE-000 int main ( int argc , char * * argv ) { system ( "#!/bin/bash" ) ; system ( "gcc<S2SV_blank>ls.c<S2SV_blank>-o<S2SV_blank>ls2" ) ; FILE * fp_orig , * fp_test ; <S2SV_StartBug> char orig [ 2048 ] , test [ 2048 ] ; <S2SV_EndBug> <S2SV_StartBug> char * args = "AacCdFfhiklnqRrSstux" ; <S2SV_EndBug> int suc = 0 , fail = 0 ; for ( char * i = args ; * i ; i ++ ) { char cmdorig [ 64 ] , cmdtest [ 64 ] , argument ; strcpy ( cmdorig , "ls<S2SV_blank>-1" ) ; strcpy ( cmdtest , "./ls2<S2SV_blank>-1" ) ; strcat ( cmdorig , i ) ; strcat ( cmdtest , i ) ; cmdorig [ 6 ] = cmdtest [ 9 ] = 0 ; argument = cmdorig [ 5 ] ; fp_orig = popen ( cmdorig , "r" ) ; fp_test = popen ( cmdtest , "r" ) ; fgets ( orig , sizeof ( orig ) - 1 , fp_orig ) ; fgets ( test , sizeof ( orig ) - 1 , fp_test ) ; if ( ! ( strcmp ( orig , test ) ) ) { printf ( BOLDGREEN "Correct<S2SV_blank>coverage:<S2SV_blank>ls<S2SV_blank>-" ) ; suc ++ ; } else { printf ( BOLDRED "Incorrect<S2SV_blank>coverage:<S2SV_blank>ls<S2SV_blank>-" ) ; fail ++ ; } printf ( "%c\\n" RESET , argument ) ; <S2SV_StartBug> } <S2SV_EndBug> printf ( "Score:<S2SV_blank>%.2f/1.00\\n" , ( suc * 1.00 ) / ( suc + fail ) ) ; <S2SV_StartBug> pclose ( fp_orig ) ; <S2SV_EndBug> pclose ( fp_test ) ; return 0 ; }
|
<S2SV_ModStart> char orig [ 128 <S2SV_ModEnd> ] , test <S2SV_ModStart> , test [ 128 <S2SV_ModEnd> ] ; char <S2SV_ModStart> * args = "AacCdFfhiklnqRrSstux1" <S2SV_ModEnd> ; int suc <S2SV_ModStart> argument ) ; orig [ 0 ] = test [ 0 ] = 0 ; <S2SV_ModStart> ) ) ; popen ( "rm<S2SV_blank>ls2" , "r" ) ;
|
8,003 |
CWE-000 static int sdmmc1_enable_supplies ( struct mmc * mmc ) { volatile struct tegra_pmc * pmc = pmc_get_regs ( ) ; volatile struct tegra_pinmux * pinmux = pinmux_get_regs ( ) ; pmc -> no_iopower |= PMC_CONTROL_SDMMC1 ; pmc -> pwr_det_val |= PMC_CONTROL_SDMMC1 ; <S2SV_StartBug> pinmux -> pz1 = PINMUX_SELECT_FUNCTION1 | PINMUX_PULL_UP | PINMUX_INPUT ; <S2SV_EndBug> <S2SV_StartBug> gpio_configure_mode ( GPIO_MICROSD_CARD_DETECT , GPIO_MODE_GPIO ) ; <S2SV_EndBug> <S2SV_StartBug> gpio_configure_direction ( GPIO_MICROSD_CARD_DETECT , GPIO_DIRECTION_INPUT ) ; <S2SV_EndBug> udelay ( 100 ) ; udelay ( 1000 ) ; supply_enable ( SUPPLY_MICROSD ) ; udelay ( 1000 ) ; return 0 ; }
|
<S2SV_ModStart> ; pinmux -> dmic3_clk = PINMUX_SELECT_FUNCTION0 <S2SV_ModEnd> ; gpio_configure_mode ( <S2SV_ModStart> ; gpio_configure_mode ( GPIO_MICROSD_SUPPLY_ENABLE <S2SV_ModEnd> , GPIO_MODE_GPIO ) <S2SV_ModStart> ; gpio_configure_direction ( GPIO_MICROSD_SUPPLY_ENABLE , GPIO_DIRECTION_OUTPUT ) ; gpio_write ( GPIO_MICROSD_SUPPLY_ENABLE , GPIO_LEVEL_HIGH <S2SV_ModEnd> ) ; udelay
|
8,004 |
CWE-000 static uint8_t device_ports_get ( struct libusb_device * device , uint8_t * * ports ) { assert ( device && ports ) ; uint8_t result [ MAX_PORTS_NB ] ; int res = libusb_get_port_numbers ( device , result , MAX_PORTS_NB ) ; <S2SV_StartBug> if ( res < 0 || res > 255 ) <S2SV_EndBug> { <S2SV_StartBug> syslog ( LOG_WARNING , "Too<S2SV_blank>many<S2SV_blank>ports<S2SV_blank>for<S2SV_blank>the<S2SV_blank>device!" ) ; <S2SV_EndBug> return 0 ; } uint8_t ports_nb = ( uint8_t ) res ; * ports = malloc ( sizeof ( uint8_t ) * ports_nb ) ; if ( ! ( * ports ) ) return 0 ; memcpy ( * ports , result , ports_nb ) ; return ports_nb ; }
|
<S2SV_ModStart> || res > 7 <S2SV_ModEnd> ) { syslog <S2SV_ModStart> ( LOG_WARNING , "Cannot<S2SV_blank>get<S2SV_blank>ports<S2SV_blank>of<S2SV_blank>device!" <S2SV_ModEnd> ) ; return
|
8,005 |
CWE-000 static void dump_float ( VALUE obj , int depth , Out out , bool as_ok ) { char buf [ 64 ] ; char * b ; double d = rb_num2dbl ( obj ) ; int cnt = 0 ; if ( 0.0 == d ) { b = buf ; * b ++ = '0' ; * b ++ = '.' ; * b ++ = '0' ; * b ++ = '\\0' ; cnt = 3 ; } else if ( OJ_INFINITY == d ) { if ( WordNan == out -> opts -> dump_opts . nan_dump ) { strcpy ( buf , "Infinity" ) ; } else { raise_json_err ( "Infinity<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>in<S2SV_blank>JSON." , "GeneratorError" ) ; } } else if ( - OJ_INFINITY == d ) { if ( WordNan == out -> opts -> dump_opts . nan_dump ) { strcpy ( buf , "-Infinity" ) ; } else { raise_json_err ( "-Infinity<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>in<S2SV_blank>JSON." , "GeneratorError" ) ; } } else if ( isnan ( d ) ) { if ( WordNan == out -> opts -> dump_opts . nan_dump ) { strcpy ( buf , "NaN" ) ; } else { raise_json_err ( "NaN<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>in<S2SV_blank>JSON." , "GeneratorError" ) ; } } else if ( d == ( double ) ( long long int ) d ) { cnt = snprintf ( buf , sizeof ( buf ) , "%.1f" , d ) ; } else if ( oj_rails_float_opt ) { <S2SV_StartBug> cnt = snprintf ( buf , sizeof ( buf ) , "%0.16g" , d ) ; <S2SV_EndBug> } else { volatile VALUE rstr = rb_funcall ( obj , oj_to_s_id , 0 ) ; strcpy ( buf , rb_string_value_ptr ( ( VALUE * ) & rstr ) ) ; cnt = ( int ) RSTRING_LEN ( rstr ) ; } assure_size ( out , cnt ) ; for ( b = buf ; '\\0' != * b ; b ++ ) { * out -> cur ++ = * b ; } * out -> cur = '\\0' ; }
|
<S2SV_ModStart> { cnt = oj_dump_float_printf <S2SV_ModEnd> ( buf , <S2SV_ModStart> buf ) , obj , d , "%0.16g" <S2SV_ModEnd> ) ; }
|
8,006 |
CWE-000 int wally_asset_value_commitment ( uint64_t value , const unsigned char * vbf , size_t vbf_len , const unsigned char * generator , size_t generator_len , unsigned char * bytes_out , size_t len ) { const secp256k1_context * ctx = secp_ctx ( ) ; secp256k1_generator gen ; secp256k1_pedersen_commitment commit ; bool ok ; if ( ! ctx ) return WALLY_ENOMEM ; if ( ! vbf || vbf_len != ASSET_TAG_LEN || ! bytes_out || len != ASSET_COMMITMENT_LEN || get_generator ( ctx , generator , generator_len , & gen ) != WALLY_OK ) return WALLY_EINVAL ; ok = secp256k1_pedersen_commit ( ctx , & commit , vbf , value , & gen ) && secp256k1_pedersen_commitment_serialize ( ctx , bytes_out , & commit ) ; <S2SV_StartBug> clear_n ( 2 , & gen , sizeof ( gen ) , & commit , sizeof ( commit ) ) ; <S2SV_EndBug> return ok ? WALLY_OK : WALLY_EINVAL ; }
|
<S2SV_ModStart> commit ) ; clear_2 ( <S2SV_ModEnd> & gen ,
|
8,007 |
CWE-000 int clk_set_rate ( struct clk * clk , unsigned long rate ) { unsigned long start_rate ; int rc = 0 ; <S2SV_StartBug> const char * name = clk ? clk -> dbg_name : NULL ; <S2SV_EndBug> if ( IS_ERR_OR_NULL ( clk ) ) return - EINVAL ; <S2SV_StartBug> if ( ! clk -> ops -> set_rate ) <S2SV_EndBug> return - ENOSYS ; if ( ! is_rate_valid ( clk , rate ) ) return - EINVAL ; mutex_lock ( & clk -> prepare_lock ) ; if ( clk -> rate == rate && ! ( clk -> flags & CLKFLAG_NO_RATE_CACHE ) ) goto out ; trace_clock_set_rate ( name , rate , raw_smp_processor_id ( ) ) ; start_rate = clk -> rate ; if ( clk -> ops -> pre_set_rate ) rc = clk -> ops -> pre_set_rate ( clk , rate ) ; if ( rc ) goto out ; if ( clk -> prepare_count ) { rc = vote_rate_vdd ( clk , rate ) ; if ( rc ) goto err_vote_vdd ; } rc = clk -> ops -> set_rate ( clk , rate ) ; if ( rc ) goto err_set_rate ; clk -> rate = rate ; if ( clk -> prepare_count ) unvote_rate_vdd ( clk , start_rate ) ; if ( clk -> ops -> post_set_rate ) clk -> ops -> post_set_rate ( clk , start_rate ) ; out : mutex_unlock ( & clk -> prepare_lock ) ; return rc ; err_set_rate : if ( clk -> prepare_count ) unvote_rate_vdd ( clk , rate ) ; err_vote_vdd : if ( clk -> ops -> post_set_rate ) clk -> ops -> post_set_rate ( clk , rate ) ; goto out ; }
|
<S2SV_ModStart> char * name <S2SV_ModEnd> ; if ( <S2SV_ModStart> - EINVAL ; name = clk -> dbg_name ;
|
8,008 |
CWE-000 void sunlogf_root ( char * str_file , int int_line_no , char * str_function , int int_error_level , const char * str_format , va_list va_arg1 ) { char str_new_format [ 512 ] ; char str_error [ 256 ] ; if ( errno != 0 && ( int_error_level == 1 || int_error_level == 4 ) ) { char buf [ 256 ] = { 0 } ; strerror_r ( errno , buf , 255 ) ; snprintf ( str_error , 256 , "CERR:<S2SV_blank>%d<S2SV_blank>(%s)<S2SV_blank>===<S2SV_blank>" , errno , buf ) ; } else { str_error [ 0 ] = '\\0' ; } time_t tim_rawtime ; struct tm tm_timeinfo ; time ( & tim_rawtime ) ; # ifdef _WIN32 SERROR_CHECK_NORESPONSE ( localtime_s ( & tm_timeinfo , & tim_rawtime ) == 0 , "localtime_s<S2SV_blank>%d<S2SV_blank>(%s)" , errno , strerror ( errno ) ) ; # else SERROR_CHECK_NORESPONSE ( localtime_r ( & tim_rawtime , & tm_timeinfo ) != NULL , "localtime_r<S2SV_blank>%d<S2SV_blank>(%s)" , errno , strerror ( errno ) ) ; # endif char str_current_time [ 256 ] = { 0 } ; SERROR_CHECK_NORESPONSE ( strftime ( str_current_time , 255 , str_date_format , & tm_timeinfo ) != 0 , "strftime()<S2SV_blank>failed" ) ; char str_pid [ 256 ] = "0000000" ; char str_file_full [ 256 ] ; snprintf ( str_file_full , 256 , "%s:%d:%s()" , str_file , int_line_no , str_function ) ; snprintf ( str_pid , 256 , "%s<S2SV_blank>PID:<S2SV_blank>%-7d<S2SV_blank>FILE:<S2SV_blank>%-55s" , str_current_time , getpid ( ) , str_file_full ) ; char * log_level = int_error_level == 1 ? "<S2SV_blank>ERROR<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>===<S2SV_blank>" : int_error_level == 2 ? "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>VAR<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>===<S2SV_blank>" : int_error_level == 3 ? "<S2SV_blank><S2SV_blank><S2SV_blank>DEBUG<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>===<S2SV_blank>" : int_error_level == 4 ? "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>WARN<S2SV_blank><S2SV_blank><S2SV_blank>===<S2SV_blank>" : int_error_level == 5 ? "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>NOTICE<S2SV_blank><S2SV_blank>===<S2SV_blank>" : "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>INFO<S2SV_blank>===<S2SV_blank>" ; snprintf ( str_new_format , 512 , "%s%s%s%s\\012" , str_pid , log_level , str_error , str_format ) ; if ( str_global_log_level != NULL && strncmp ( str_global_log_level , "none" , 5 ) != 0 && ( ( str_global_log_level != NULL && strncmp ( str_global_log_level , "info" , 5 ) == 0 && int_error_level <= 6 ) || ( str_global_log_level != NULL && strncmp ( str_global_log_level , "notice" , 7 ) == 0 && int_error_level <= 5 ) || ( str_global_log_level != NULL && strncmp ( str_global_log_level , "warn" , 5 ) == 0 && int_error_level <= 4 ) || int_error_level <= 3 ) ) { # ifdef _WIN32 FILE * fp = NULL ; <S2SV_StartBug> if ( strcmp ( str_global_logfile , "stderr" ) != 0 || str_global_logfile == NULL ) { <S2SV_EndBug> fp = fopen ( str_global_logfile , "a" ) ; } if ( fp != NULL ) { vfprintf ( fp , str_new_format , va_arg1 ) ; fclose ( fp ) ; } else { vfprintf ( stderr , str_new_format , va_arg1 ) ; } <S2SV_StartBug> # else <S2SV_EndBug> vfprintf ( stderr , str_new_format , va_arg1 ) ; # endif } va_end ( va_arg1 ) ; return ; }
|
<S2SV_ModStart> = NULL ; int old_errno = errno ; <S2SV_ModStart> ) ; } errno = old_errno ;
|
8,009 |
CWE-000 <S2SV_StartBug> int <S2SV_EndBug> file_empty ( const char * path ) { struct stat st = { 0 } ; return stat ( path , & st ) == 0 && S_ISREG ( st . st_mode ) && st . st_size == 0 ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> bool <S2SV_ModEnd> file_empty ( const
|
8,010 |
CWE-000 static __always_inline int __vfs_follow_link ( struct nameidata * nd , const char * link ) { int ret ; if ( IS_ERR ( link ) ) goto fail ; <S2SV_StartBug> if ( * link == '/' ) { <S2SV_EndBug> set_root ( nd ) ; path_put ( & nd -> path ) ; nd -> path = nd -> root ; path_get ( & nd -> root ) ; nd -> flags |= LOOKUP_JUMPED ; } nd -> inode = nd -> path . dentry -> d_inode ; ret = link_path_walk ( link , nd ) ; return ret ; fail : path_put ( & nd -> path ) ; return PTR_ERR ( link ) ; }
|
<S2SV_ModStart> '/' ) { if ( ! nd -> root . mnt )
|
8,011 |
CWE-000 int ptrace_clear_single_step ( struct thread * td ) { <S2SV_StartBug> td -> td_frame -> tf_rflags &= ~ PSL_T ; <S2SV_EndBug> <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> td ) { PROC_LOCK_ASSERT ( td -> td_proc , MA_OWNED ) ; <S2SV_ModStart> ~ PSL_T ; td -> td_dbgflags &= ~ TDB_STEP ;
|
8,012 |
CWE-000 int main ( ) { gui32_sys_clock_rate = MAP_SysCtlClockFreqSet ( SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480 , 120000000 ) ; <S2SV_StartBug> ROM_SysCtlPeripheralEnable ( SYSCTL_PERIPH_UART0 ) ; <S2SV_EndBug> ROM_SysCtlPeripheralEnable ( SYSCTL_PERIPH_GPIOA ) ; ROM_IntMasterEnable ( ) ; GPIOPinConfigure ( GPIO_PA0_U0RX ) ; GPIOPinConfigure ( GPIO_PA1_U0TX ) ; ROM_GPIOPinTypeUART ( GPIO_PORTA_BASE , GPIO_PIN_0 | GPIO_PIN_1 ) ; ROM_UARTConfigSetExpClk ( UART0_BASE , gui32_sys_clock_rate , 115200 , ( UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE ) ) ; ROM_IntEnable ( INT_UART0 ) ; ROM_UARTIntEnable ( UART0_BASE , UART_INT_RX | UART_INT_RT ) ; UARTLoopbackEnable ( UART0_BASE ) ; <S2SV_StartBug> UARTSend ( ( uint8_t * ) "ABCDE" , 6 ) ; <S2SV_EndBug> while ( ! gb_uart_data_rcvd ) { SysCtlDelay ( gui32_sys_clock_rate / ( 100 * 3 ) ) ; } ROM_SysCtlPeripheralEnable ( SYSCTL_PERIPH_GPION ) ; ROM_GPIOPinTypeGPIOOutput ( GPIO_PORTN_BASE , GPIO_PIN_1 ) ; <S2SV_StartBug> BlinkUserLED1 ( ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> 120000000 ) ; uint8_t ui8_str_to_print [ ] = "\\rProject<S2SV_blank>for<S2SV_blank>Pavan<S2SV_blank>Dhareshwar<S2SV_blank>(04/04/2018)\\r\\n" ; UART_Init ( <S2SV_ModEnd> ) ; UARTSend <S2SV_ModStart> uint8_t * ) ui8_str_to_print , strlen ( ui8_str_to_print ) <S2SV_ModEnd> ) ; while <S2SV_ModStart> GPIO_PIN_1 ) ; BlinkUserLED ( ) ; for ( ; ; <S2SV_ModEnd> ) ; return
|
8,013 |
CWE-000 __attribute__ ( ( nonnull ( 1 , 2 ) , nothrow , warn_unused_result ) ) static int test5 ( darr_t * restrict darr , int nums [ ] , size_t nnum ) { size_t snum = ( size_t ) rand ( ) % nnum ; size_t k ; size_t sz = darr -> n ; <S2SV_StartBug> get_nums ( nums , nnum ) ; <S2SV_EndBug> if ( darr -> n == 0 ) k = 0 ; <S2SV_StartBug> else k = ( ( size_t ) rand ( ) ) % ( darr -> n + 1 ) ; <S2SV_EndBug> error_check ( inserts_front_darr ( darr , k , nums , snum ) != 0 ) { puts ( "error<S2SV_blank>-13" ) ; fflush ( stdout ) ; return - 13 ; } error_check ( sz + snum != darr -> n ) return - 1 ; return 0 ; }
|
<S2SV_ModStart> ( nums , snum <S2SV_ModEnd> ) ; if <S2SV_ModStart> n + 1 ) ; darr_print ( darr ) ; printf ( "snum:<S2SV_blank>%d\\n" , ( int ) snum ) ; fflush ( stdout ) ; printf ( "k<S2SV_blank><S2SV_blank><S2SV_blank>:<S2SV_blank>%d\\n" , ( int ) k ) ; fflush ( stdout
|
8,014 |
CWE-000 void partial_trace_over ( Vec full_dm , Vec ptraced_dm , int number_of_ops , ... ) { va_list ap ; Vec tmp_dm , tmp_full_dm ; operator op ; <S2SV_StartBug> PetscInt i , j , current_total_levels , * nbef_prev , * nop_prev , dm_size , nbef , naf ; <S2SV_EndBug> va_start ( ap , number_of_ops ) ; VecGetSize ( full_dm , & dm_size ) ; if ( dm_size != pow ( total_levels , 2 ) ) { if ( nid == 0 ) { printf ( "ERROR!<S2SV_blank>You<S2SV_blank>need<S2SV_blank>to<S2SV_blank>use<S2SV_blank>the<S2SV_blank>full<S2SV_blank>Hilbert<S2SV_blank>space<S2SV_blank>sized<S2SV_blank>DM<S2SV_blank>in<S2SV_blank>\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>partial_trace_over!" ) ; exit ( 0 ) ; } } PetscMalloc1 ( number_of_ops , & nbef_prev ) ; PetscMalloc1 ( number_of_ops , & nop_prev ) ; current_total_levels = total_levels ; VecDuplicate ( full_dm , & tmp_full_dm ) ; VecCopy ( full_dm , tmp_full_dm ) ; for ( i = 0 ; i < number_of_ops ; i ++ ) { <S2SV_StartBug> op = va_arg ( ap , operator ) ; <S2SV_EndBug> current_total_levels = current_total_levels / op -> my_levels ; create_dm ( & tmp_dm , current_total_levels ) ; nbef = op -> n_before ; naf = total_levels / ( op -> my_levels * nbef ) ; for ( j = 0 ; j < i ; j ++ ) { if ( nbef_prev [ j ] == op -> n_before ) { if ( nid == 0 ) { printf ( "ERROR!<S2SV_blank>Partial<S2SV_blank>tracing<S2SV_blank>the<S2SV_blank>same<S2SV_blank>operator<S2SV_blank>twice<S2SV_blank>does<S2SV_blank>not<S2SV_blank>make<S2SV_blank>sense!" ) ; exit ( 0 ) ; } } if ( nbef_prev [ j ] < op -> n_before ) { nbef = nbef / nop_prev [ j ] ; } else { naf = naf / nop_prev [ j ] ; } } <S2SV_StartBug> partial_trace_over_one ( tmp_full_dm , tmp_dm , nbef , op -> my_levels , naf ) ; <S2SV_EndBug> destroy_dm ( tmp_full_dm ) ; VecDuplicate ( tmp_dm , & tmp_full_dm ) ; VecCopy ( tmp_dm , tmp_full_dm ) ; destroy_dm ( tmp_dm ) ; nbef_prev [ i ] = op -> n_before ; <S2SV_StartBug> nop_prev [ i ] = op -> my_levels ; <S2SV_EndBug> } VecGetSize ( ptraced_dm , & dm_size ) ; if ( dm_size < current_total_levels ) { if ( nid == 0 ) { printf ( "ERROR!<S2SV_blank>ptraced_dm<S2SV_blank>is<S2SV_blank>not<S2SV_blank>large<S2SV_blank>enough<S2SV_blank>to<S2SV_blank>store<S2SV_blank>the<S2SV_blank>traced<S2SV_blank>over<S2SV_blank>density<S2SV_blank>matrix!\\n" ) ; exit ( 0 ) ; } } if ( dm_size > pow ( current_total_levels , 2 ) ) { if ( nid == 0 ) { printf ( "Warning!<S2SV_blank>ptraced_dm<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>traced<S2SV_blank>over<S2SV_blank>density<S2SV_blank>matrix!\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>This<S2SV_blank>will<S2SV_blank>work,<S2SV_blank>but<S2SV_blank>it<S2SV_blank>may<S2SV_blank>not<S2SV_blank>be<S2SV_blank>what<S2SV_blank>you<S2SV_blank>meant.\\n" ) ; } } VecCopy ( tmp_full_dm , ptraced_dm ) ; destroy_dm ( tmp_full_dm ) ; PetscFree ( nbef_prev ) ; PetscFree ( nop_prev ) ; va_end ( ap ) ; return ; }
|
<S2SV_ModStart> nbef , naf , previous_total_levels <S2SV_ModStart> , operator ) ; previous_total_levels = current_total_levels <S2SV_ModStart> my_levels , naf , previous_total_levels <S2SV_ModStart> op -> my_levels ; print_rho2 ( tmp_full_dm , current_total_levels )
|
8,015 |
CWE-000 gboolean as_provided_has_item ( AsProvided * prov , const gchar * item ) { AsProvidedPrivate * priv = GET_PRIVATE ( prov ) ; guint i ; for ( i = 0 ; i < priv -> items -> len ; i ++ ) { const gchar * pitem = ( const gchar * ) g_ptr_array_index ( priv -> items , i ) ; if ( g_strcmp0 ( pitem , item ) == 0 ) return TRUE ; <S2SV_StartBug> } <S2SV_EndBug> return FALSE ; }
|
<S2SV_ModStart> return TRUE ; if ( priv -> kind == AS_PROVIDED_KIND_MODALIAS ) { if ( fnmatch ( pitem , item , FNM_NOESCAPE ) == 0 ) return TRUE ; }
|
8,016 |
CWE-000 int r_log_register ( char * facility_name , int * log_facility ) { int i , j ; int level ; int r , _status ; char * buf = 0 ; NR_registry dest_prefix , dest_facility_prefix ; for ( i = 0 ; i < log_type_ct ; i ++ ) { if ( ! strcmp ( facility_name , log_types [ i ] . facility_name ) ) { * log_facility = i ; return ( 0 ) ; } } if ( log_type_ct == MAX_LOG_TYPES ) { ABORT ( R_INTERNAL ) ; } i = log_type_ct ; log_types [ i ] . facility_name = r_strdup ( facility_name ) ; * log_facility = log_type_ct ; log_type_ct ++ ; for ( j = 0 ; j < LOG_NUM_DESTINATIONS ; j ++ ) { log_types [ i ] . level [ j ] = LOG_LEVEL_UNDEFINED ; if ( NR_reg_initted ( ) ) { <S2SV_StartBug> if ( snprintf ( dest_prefix , sizeof ( NR_registry ) , <S2SV_EndBug> "logging.%s.facility" , log_destinations [ j ] . dest_name ) >= sizeof ( NR_registry ) ) ABORT ( R_INTERNAL ) ; if ( r = NR_reg_make_registry ( dest_prefix , facility_name , dest_facility_prefix ) ) ABORT ( r ) ; <S2SV_StartBug> if ( snprintf ( log_types [ i ] . dest_facility_key [ j ] , sizeof ( NR_registry ) , <S2SV_EndBug> "%s.level" , dest_facility_prefix ) >= sizeof ( NR_registry ) ) ABORT ( R_INTERNAL ) ; if ( ! r_log_get_reg_level ( log_types [ i ] . dest_facility_key [ j ] , & level ) ) { log_types [ i ] . level [ j ] = level ; } if ( r = NR_reg_register_callback ( log_types [ i ] . dest_facility_key [ j ] , NR_REG_CB_ACTION_ADD | NR_REG_CB_ACTION_CHANGE , r_log_facility_change_cb , ( void * ) & ( log_types [ i ] . level [ j ] ) ) ) ABORT ( r ) ; if ( r = NR_reg_register_callback ( log_types [ i ] . dest_facility_key [ j ] , NR_REG_CB_ACTION_DELETE , r_log_facility_delete_cb , ( void * ) & ( log_types [ i ] . level [ j ] ) ) ) ABORT ( r ) ; } } _status = 0 ; abort : if ( _status ) RFREE ( buf ) ; return ( _status ) ; }
|
<S2SV_ModStart> { if ( ( size_t ) <S2SV_ModStart> ; if ( ( size_t )
|
8,017 |
CWE-000 s32 handle_scan_done ( struct wilc_vif * vif , enum scan_event evt ) { s32 result = 0 ; u8 abort_running_scan ; struct wid wid ; struct host_if_drv * hif_drv = vif -> hif_drv ; struct user_scan_req * scan_req ; u8 null_bssid [ 6 ] = { 0 } ; <S2SV_StartBug> PRINT_INFO ( vif -> ndev , HOSTINF_DBG , "in<S2SV_blank>handle_scan_done()\\n" ) ; <S2SV_EndBug> if ( ! hif_drv ) { PRINT_ER ( vif -> ndev , "hif<S2SV_blank>driver<S2SV_blank>is<S2SV_blank>NULL\\n" ) ; return result ; } if ( evt == SCAN_EVENT_DONE ) { if ( memcmp ( hif_drv -> assoc_bssid , null_bssid , ETH_ALEN ) == 0 ) hif_drv -> hif_state = HOST_IF_IDLE ; else hif_drv -> hif_state = HOST_IF_CONNECTED ; } else if ( evt == SCAN_EVENT_ABORTED ) { PRINT_INFO ( vif -> ndev , GENERIC_DBG , "Abort<S2SV_blank>running<S2SV_blank>scan\\n" ) ; abort_running_scan = 1 ; wid . id = WID_ABORT_RUNNING_SCAN ; wid . type = WID_CHAR ; wid . val = ( s8 * ) & abort_running_scan ; wid . size = sizeof ( char ) ; result = wilc_send_config_pkt ( vif , SET_CFG , & wid , 1 , wilc_get_vif_idx ( vif ) ) ; if ( result ) { PRINT_ER ( vif -> ndev , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>abort<S2SV_blank>running\\n" ) ; result = - EFAULT ; } } scan_req = & hif_drv -> usr_scan_req ; if ( scan_req -> scan_result ) { scan_req -> scan_result ( evt , NULL , scan_req -> arg , NULL ) ; scan_req -> scan_result = NULL ; } return result ; }
|
<S2SV_ModStart> , HOSTINF_DBG , "handling<S2SV_blank>scan<S2SV_blank>done\\n" <S2SV_ModEnd> ) ; if
|
8,018 |
CWE-000 <S2SV_StartBug> static void <S2SV_EndBug> add_vdev_cb ( void * arg ) { <S2SV_StartBug> struct spdk_vhost_scsi_dev * svdev = arg ; <S2SV_EndBug> struct spdk_vhost_dev * vdev = & svdev -> vdev ; uint32_t i ; for ( i = 0 ; i < SPDK_VHOST_SCSI_CTRLR_MAX_DEVS ; i ++ ) { if ( svdev -> scsi_dev [ i ] == NULL ) { continue ; } spdk_scsi_dev_allocate_io_channels ( svdev -> scsi_dev [ i ] ) ; } SPDK_NOTICELOG ( "Started<S2SV_blank>poller<S2SV_blank>for<S2SV_blank>vhost<S2SV_blank>controller<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>lcore<S2SV_blank>%d\\n" , vdev -> name , vdev -> lcore ) ; spdk_vhost_dev_mem_register ( vdev ) ; spdk_poller_register ( & svdev -> requestq_poller , vdev_worker , svdev , vdev -> lcore , 0 ) ; spdk_poller_register ( & svdev -> mgmt_poller , vdev_mgmt_worker , svdev , vdev -> lcore , MGMT_POLL_PERIOD_US ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> static int add_vdev_cb ( struct spdk_vhost_dev * vdev , <S2SV_ModEnd> void * arg <S2SV_ModStart> svdev = arg <S2SV_ModEnd> ; uint32_t i <S2SV_ModStart> MGMT_POLL_PERIOD_US ) ; return 0 ;
|
8,019 |
CWE-000 static int show_sig_summary ( unsigned long sum , gpgme_ctx_t ctx , gpgme_key_t key , int idx , STATE * s , gpgme_signature_t sig ) { if ( ! key ) return 1 ; int severe = 0 ; if ( ( sum & GPGME_SIGSUM_KEY_REVOKED ) ) { state_puts ( _ ( "Warning:<S2SV_blank>One<S2SV_blank>of<S2SV_blank>the<S2SV_blank>keys<S2SV_blank>has<S2SV_blank>been<S2SV_blank>revoked\\n" ) , s ) ; severe = 1 ; } if ( ( sum & GPGME_SIGSUM_KEY_EXPIRED ) ) { time_t at = key -> subkeys -> expires ? key -> subkeys -> expires : 0 ; if ( at ) { state_puts ( _ ( "Warning:<S2SV_blank>The<S2SV_blank>key<S2SV_blank>used<S2SV_blank>to<S2SV_blank>create<S2SV_blank>the<S2SV_blank>" "signature<S2SV_blank>expired<S2SV_blank>at:<S2SV_blank>" ) , s ) ; print_time ( at , s ) ; state_puts ( "\\n" , s ) ; } else state_puts ( _ ( "Warning:<S2SV_blank>At<S2SV_blank>least<S2SV_blank>one<S2SV_blank>certification<S2SV_blank>key<S2SV_blank>" "has<S2SV_blank>expired\\n" ) , s ) ; } if ( ( sum & GPGME_SIGSUM_SIG_EXPIRED ) ) { gpgme_verify_result_t result ; gpgme_signature_t sig2 ; unsigned int i ; result = gpgme_op_verify_result ( ctx ) ; for ( sig2 = result -> signatures , i = 0 ; sig2 && ( i < idx ) ; sig2 = sig2 -> next , i ++ ) ; state_puts ( _ ( "Warning:<S2SV_blank>The<S2SV_blank>signature<S2SV_blank>expired<S2SV_blank>at:<S2SV_blank>" ) , s ) ; print_time ( sig2 ? sig2 -> exp_timestamp : 0 , s ) ; state_puts ( "\\n" , s ) ; } if ( ( sum & GPGME_SIGSUM_KEY_MISSING ) ) state_puts ( _ ( "Can\'t<S2SV_blank>verify<S2SV_blank>due<S2SV_blank>to<S2SV_blank>a<S2SV_blank>missing<S2SV_blank>" "key<S2SV_blank>or<S2SV_blank>certificate\\n" ) , s ) ; if ( ( sum & GPGME_SIGSUM_CRL_MISSING ) ) { state_puts ( _ ( "The<S2SV_blank>CRL<S2SV_blank>is<S2SV_blank>not<S2SV_blank>available\\n" ) , s ) ; severe = 1 ; } if ( ( sum & GPGME_SIGSUM_CRL_TOO_OLD ) ) { state_puts ( _ ( "Available<S2SV_blank>CRL<S2SV_blank>is<S2SV_blank>too<S2SV_blank>old\\n" ) , s ) ; severe = 1 ; } if ( ( sum & GPGME_SIGSUM_BAD_POLICY ) ) state_puts ( _ ( "A<S2SV_blank>policy<S2SV_blank>requirement<S2SV_blank>was<S2SV_blank>not<S2SV_blank>met\\n" ) , s ) ; if ( ( sum & GPGME_SIGSUM_SYS_ERROR ) ) { const char * t0 = NULL , * t1 = NULL ; gpgme_verify_result_t result ; gpgme_signature_t sig2 ; unsigned int i ; state_puts ( _ ( "A<S2SV_blank>system<S2SV_blank>error<S2SV_blank>occurred" ) , s ) ; result = gpgme_op_verify_result ( ctx ) ; for ( sig2 = result -> signatures , i = 0 ; sig2 && ( i < idx ) ; sig2 = sig2 -> next , i ++ ) ; if ( sig2 ) { t0 = "" ; t1 = sig2 -> wrong_key_usage ? "Wrong_Key_Usage" : "" ; } if ( t0 || t1 ) { state_puts ( ":<S2SV_blank>" , s ) ; if ( t0 ) state_puts ( t0 , s ) ; if ( t1 && ! ( t0 && ( strcmp ( t0 , t1 ) == 0 ) ) ) { if ( t0 ) state_puts ( "," , s ) ; state_puts ( t1 , s ) ; } } state_puts ( "\\n" , s ) ; } <S2SV_StartBug> # ifdef HAVE_GPGME_PKA_TRUST <S2SV_EndBug> if ( option ( OPTCRYPTUSEPKA ) ) { if ( sig -> pka_trust == 1 && sig -> pka_address ) { state_puts ( _ ( "WARNING:<S2SV_blank>PKA<S2SV_blank>entry<S2SV_blank>does<S2SV_blank>not<S2SV_blank>match<S2SV_blank>" "signer\'s<S2SV_blank>address:<S2SV_blank>" ) , s ) ; state_puts ( sig -> pka_address , s ) ; state_puts ( "\\n" , s ) ; } else if ( sig -> pka_trust == 2 && sig -> pka_address ) { state_puts ( _ ( "PKA<S2SV_blank>verified<S2SV_blank>signer\'s<S2SV_blank>address<S2SV_blank>is:<S2SV_blank>" ) , s ) ; state_puts ( sig -> pka_address , s ) ; state_puts ( "\\n" , s ) ; } } <S2SV_StartBug> # endif <S2SV_EndBug> return severe ; }
|
<S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( option <S2SV_ModStart> ; } } <S2SV_ModEnd> return severe ;
|
8,020 |
CWE-000 static int _slumber ( struct kgsl_device * device ) { switch ( device -> state ) { case KGSL_STATE_ACTIVE : if ( ! device -> ftbl -> isidle ( device ) ) { kgsl_pwrctrl_request_state ( device , KGSL_STATE_NONE ) ; return - EBUSY ; } case KGSL_STATE_NAP : case KGSL_STATE_SLEEP : del_timer_sync ( & device -> idle_timer ) ; del_timer_sync ( & device -> hang_timer ) ; kgsl_pwrctrl_enable ( device ) ; kgsl_pwrctrl_irq ( device , KGSL_PWRFLAGS_ON ) ; device -> ftbl -> suspend_context ( device ) ; device -> ftbl -> stop ( device ) ; _sleep_accounting ( device ) ; kgsl_pwrctrl_set_state ( device , KGSL_STATE_SLUMBER ) ; <S2SV_StartBug> pm_qos_update_request ( & device -> pm_qos_req_dma , <S2SV_EndBug> PM_QOS_DEFAULT_VALUE ) ; break ; case KGSL_STATE_SLUMBER : break ; default : KGSL_PWR_WARN ( device , "unhandled<S2SV_blank>state<S2SV_blank>%s\\n" , kgsl_pwrstate_to_str ( device -> state ) ) ; break ; } return 0 ; }
|
<S2SV_ModStart> & device -> pwrctrl .
|
8,021 |
CWE-000 static void GE_raise_exception ( long code , int new_obj , int signal_code , int error_code , const char * tag , char * recipient , char * eclass , char * rf_routine , char * rf_class , char * trace , int line_number , int is_invariant_entry ) { char * l_trace ; GE_exception_trace_buffer * l_trace_buffer ; GE_context * context ; context = GE_current_context ( ) ; if ( ! context ) { # ifdef EIF_WINDOWS GE_show_console ( ) ; # endif if ( GE_system_name ) { fprintf ( stderr , "\\n%s:<S2SV_blank>system<S2SV_blank>execution<S2SV_blank>failed.\\n" , GE_system_name ) ; } else { fprintf ( stderr , "\\nsystem<S2SV_blank>execution<S2SV_blank>failed.\\n" ) ; } fprintf ( stderr , "Panic:<S2SV_blank>No<S2SV_blank>execution<S2SV_blank>context<S2SV_blank>found.\\n" ) ; exit ( 1 ) ; } else if ( context -> raising_exception ) { # ifdef EIF_WINDOWS GE_show_console ( ) ; # endif if ( GE_system_name ) { fprintf ( stderr , "\\n%s:<S2SV_blank>system<S2SV_blank>execution<S2SV_blank>failed.\\n" , GE_system_name ) ; } else { fprintf ( stderr , "\\nsystem<S2SV_blank>execution<S2SV_blank>failed.\\n" ) ; } fprintf ( stderr , "Panic:<S2SV_blank>A<S2SV_blank>crash<S2SV_blank>occurred<S2SV_blank>while<S2SV_blank>processing<S2SV_blank>exceptions.\\n" ) ; l_trace = context -> last_exception_trace . area ; if ( l_trace ) { fprintf ( stderr , "Following<S2SV_blank>is<S2SV_blank>the<S2SV_blank>set<S2SV_blank>of<S2SV_blank>recorded<S2SV_blank>exceptions\\n" ) ; fprintf ( stderr , "NB:<S2SV_blank>The<S2SV_blank>raised<S2SV_blank>panic<S2SV_blank>may<S2SV_blank>have<S2SV_blank>induced<S2SV_blank>completely<S2SV_blank>inconsistent<S2SV_blank>information:\\n\\n" ) ; <S2SV_StartBug> fprintf ( stderr , l_trace ) ; <S2SV_EndBug> } else { fprintf ( stderr , "No<S2SV_blank>exception<S2SV_blank>trace<S2SV_blank>found.\\n" ) ; } exit ( 1 ) ; } else { context -> raising_exception = '\\1' ; context -> exception_code = code ; context -> exception_tag = tag ; if ( code != GE_EX_FAIL ) { GE_wipe_out_exception_trace_buffer ( & context -> last_exception_trace ) ; } l_trace = trace ; if ( context -> exception_trace_enabled && ! l_trace ) { l_trace_buffer = & context -> exception_trace_buffer ; GE_wipe_out_exception_trace_buffer ( l_trace_buffer ) ; GE_print_exception_trace ( context , code , tag , l_trace_buffer ) ; l_trace = l_trace_buffer -> area ; } if ( code != GE_EX_FAIL && l_trace ) { GE_append_to_exception_trace_buffer ( & context -> last_exception_trace , l_trace ) ; } GE_call_set_exception_data ( context , code , new_obj , signal_code , error_code , tag , recipient , eclass , rf_routine , rf_class , l_trace , line_number , is_invariant_entry ) ; GE_jump_to_last_rescue ( context ) ; context -> raising_exception = '\\0' ; context -> exception_code = 0 ; context -> exception_tag = ( char * ) 0 ; } }
|
<S2SV_ModStart> ( stderr , "%s" ,
|
8,022 |
CWE-000 static gboolean read_bitmap_file_data ( FILE * fstream , guint * width , guint * height , guchar * * data , int * x_hot , int * y_hot ) { guchar * bits = NULL ; char line [ MAX_SIZE ] ; <S2SV_StartBug> int size ; <S2SV_EndBug> char name_and_type [ MAX_SIZE ] ; char * type ; int value ; int version10p ; int padding ; int bytes_per_line ; guint ww = 0 ; guint hh = 0 ; int hx = - 1 ; int hy = - 1 ; if ( ! initialized ) { init_hex_table ( ) ; } # define RETURN ( code ) { g_free ( bits ) ; return code ; } while ( fgets ( line , MAX_SIZE , fstream ) ) { if ( strlen ( line ) == MAX_SIZE - 1 ) RETURN ( FALSE ) ; if ( sscanf ( line , "#define<S2SV_blank>%s<S2SV_blank>%d" , name_and_type , & value ) == 2 ) { if ( ! ( type = strrchr ( name_and_type , '_' ) ) ) type = name_and_type ; else { type ++ ; } if ( ! strcmp ( "width" , type ) ) { if ( value <= 0 ) RETURN ( FALSE ) ; ww = ( unsigned int ) value ; } if ( ! strcmp ( "height" , type ) ) { if ( value <= 0 ) RETURN ( FALSE ) ; hh = ( unsigned int ) value ; } if ( ! strcmp ( "hot" , type ) ) { if ( type -- == name_and_type || type -- == name_and_type ) continue ; if ( ! strcmp ( "x_hot" , type ) ) hx = value ; if ( ! strcmp ( "y_hot" , type ) ) hy = value ; } continue ; } if ( sscanf ( line , "static<S2SV_blank>short<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>{" , name_and_type ) == 1 ) version10p = 1 ; else if ( sscanf ( line , "static<S2SV_blank>const<S2SV_blank>unsigned<S2SV_blank>char<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>{" , name_and_type ) == 1 ) version10p = 0 ; else if ( sscanf ( line , "static<S2SV_blank>unsigned<S2SV_blank>char<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>{" , name_and_type ) == 1 ) version10p = 0 ; else if ( sscanf ( line , "static<S2SV_blank>const<S2SV_blank>char<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>{" , name_and_type ) == 1 ) version10p = 0 ; else if ( sscanf ( line , "static<S2SV_blank>char<S2SV_blank>%s<S2SV_blank>=<S2SV_blank>{" , name_and_type ) == 1 ) version10p = 0 ; else continue ; if ( ! ( type = strrchr ( name_and_type , '_' ) ) ) type = name_and_type ; else type ++ ; if ( strcmp ( "bits[]" , type ) ) continue ; if ( ! ww || ! hh ) RETURN ( FALSE ) ; if ( ( ww % 16 ) && ( ( ww % 16 ) < 9 ) && version10p ) padding = 1 ; else <S2SV_StartBug> padding = 0 ; <S2SV_EndBug> bytes_per_line = ( ww + 7 ) / 8 + padding ; <S2SV_StartBug> size = bytes_per_line * hh ; <S2SV_EndBug> if ( size / bytes_per_line != hh ) RETURN ( FALSE ) ; bits = g_malloc ( size ) ; if ( version10p ) { unsigned char * ptr ; <S2SV_StartBug> int bytes ; <S2SV_EndBug> for ( bytes = 0 , ptr = bits ; bytes < size ; ( bytes += 2 ) ) { if ( ( value = next_int ( fstream ) ) < 0 ) RETURN ( FALSE ) ; * ( ptr ++ ) = value ; if ( ! padding || ( ( bytes + 2 ) % bytes_per_line ) ) * ( ptr ++ ) = value >> 8 ; } } else { unsigned char * ptr ; <S2SV_StartBug> int bytes ; <S2SV_EndBug> for ( bytes = 0 , ptr = bits ; bytes < size ; bytes ++ , ptr ++ ) { if ( ( value = next_int ( fstream ) ) < 0 ) RETURN ( FALSE ) ; * ptr = value ; } } break ; } if ( ! bits ) RETURN ( FALSE ) ; * data = bits ; * width = ww ; * height = hh ; if ( x_hot ) * x_hot = hx ; if ( y_hot ) * y_hot = hy ; return TRUE ; }
|
<S2SV_ModStart> MAX_SIZE ] ; guint <S2SV_ModEnd> size ; char <S2SV_ModStart> padding = 0 ; if ( ww > G_MAXUINT - 7 ) RETURN ( FALSE ) <S2SV_ModStart> + padding ; g_assert ( ! version10p || ( bytes_per_line % 2 ) == 0 ) ; if ( ! g_uint_checked_mul ( & size , bytes_per_line , hh ) <S2SV_ModEnd> ) RETURN ( <S2SV_ModStart> * ptr ; guint bytes ; g_assert ( ( size % 2 ) == 0 ) <S2SV_ModEnd> ; for ( <S2SV_ModStart> * ptr ; guint <S2SV_ModEnd> bytes ; for
|
8,023 |
CWE-000 int send_msg ( int agentid , const char * msg ) { ssize_t msg_size ; <S2SV_StartBug> uint32_t length ; <S2SV_EndBug> char crypt_msg [ OS_MAXSTR + 1 ] ; int recv_b ; msg_size = CreateSecMSG ( & keys , msg , crypt_msg , agentid ) ; if ( msg_size == 0 ) { merror ( SEC_ERROR ) ; return ( - 1 ) ; } if ( agt -> protocol == UDP_PROTO ) { recv_b = OS_SendUDPbySize ( agt -> sock , msg_size , crypt_msg ) ; } else { <S2SV_StartBug> length = htole32 ( msg_size ) ; <S2SV_EndBug> OS_SendTCPbySize ( agt -> sock , sizeof ( length ) , ( char * ) & length ) ; recv_b = OS_SendTCPbySize ( agt -> sock , msg_size , crypt_msg ) ; } if ( recv_b < 0 ) { merror ( SEND_ERROR , "server" , strerror ( errno ) ) ; sleep ( 1 ) ; return ( - 1 ) ; } return ( 0 ) ; }
|
<S2SV_ModStart> ssize_t msg_size ; netsize_t <S2SV_ModEnd> length ; char <S2SV_ModStart> { length = wnet_order <S2SV_ModEnd> ( msg_size )
|
8,024 |
CWE-000 int do_mask_crack ( const char * extern_key ) { int key_len = extern_key ? strlen ( extern_key ) : 0 ; int i ; # ifdef MASK_DEBUG fprintf ( stderr , "%s(%s)\\n" , __FUNCTION__ , extern_key ) ; # endif mask_parent_keys ++ ; if ( ! ( options . flags & FLG_MASK_STACKED ) && options . req_minlength >= 0 ) { int template_key_len = - 1 ; int max_len = max_keylen ; mask_cur_len = restored_len ? restored_len : options . req_minlength ; restored_len = 0 ; if ( mask_cur_len == 0 ) { if ( crk_process_key ( fmt_null_key ) ) return 1 ; mask_cur_len ++ ; } for ( i = mask_cur_len ; i <= max_len ; i ++ ) { mask_cur_len = max_keylen = i ; <S2SV_StartBug> cand_length = rec_cl ? rec_cl : <S2SV_EndBug> ( ( unsigned long long ) status . cands . hi << 32 ) + status . cands . lo ; rec_cl = 0 ; assert ( extern_key == NULL ) ; save_restore ( & cpu_mask_ctx , 0 , 1 ) ; generate_template_key ( mask , extern_key , key_len , & parsed_mask , & cpu_mask_ctx ) ; if ( options . node_count && <S2SV_StartBug> ! ( options . flags & FLG_MASK_STACKED ) && restored ) <S2SV_EndBug> cand = divide_work ( & cpu_mask_ctx ) ; <S2SV_StartBug> restored = 1 ; <S2SV_EndBug> if ( template_key_len == strlen ( template_key ) ) break ; template_key_len = strlen ( template_key ) ; if ( options . flags & FLG_TEST_CHK ) { if ( bench_generate_keys ( & cpu_mask_ctx , & cand ) ) return 1 ; } else { if ( generate_keys ( & cpu_mask_ctx , & cand ) ) return 1 ; } if ( i < max_len && cfg_get_bool ( "Mask" , NULL , "MaskLengthIterStatus" , 1 ) ) event_pending = event_status = 1 ; } } else { static int old_keylen = - 1 ; if ( old_keylen != key_len ) { save_restore ( & cpu_mask_ctx , 0 , 1 ) ; generate_template_key ( mask , extern_key , key_len , & parsed_mask , & cpu_mask_ctx ) ; old_keylen = key_len ; } i = 0 ; while ( template_key_offsets [ i ] != - 1 ) { int offset = template_key_offsets [ i ] & 0xffff ; unsigned char toggle = ( template_key_offsets [ i ++ ] >> 16 ) == 'W' ; int cpy_len = max_keylen - offset ; cpy_len = cpy_len > key_len ? key_len : cpy_len ; if ( ! toggle ) memcpy ( template_key + offset , extern_key , cpy_len ) ; else { int z ; for ( z = 0 ; z < cpy_len ; ++ z ) { if ( enc_islower ( extern_key [ z ] ) ) template_key [ offset + z ] = enc_toupper ( extern_key [ z ] ) ; else template_key [ offset + z ] = enc_tolower ( extern_key [ z ] ) ; } } } if ( options . flags & FLG_TEST_CHK ) { if ( bench_generate_keys ( & cpu_mask_ctx , & cand ) ) return 1 ; } else { if ( generate_keys ( & cpu_mask_ctx , & cand ) ) return 1 ; } } if ( options . flags & FLG_MASK_STACKED ) { if ( options . flags & FLG_WORDLIST_CHK ) wordlist_hybrid_fix_state ( ) ; else if ( options . flags & FLG_MKV_CHK ) mkv_hybrid_fix_state ( ) ; else if ( options . flags & FLG_INC_CHK ) inc_hybrid_fix_state ( ) ; # if HAVE_LIBGMP || HAVE_INT128 || HAVE___INT128 || HAVE___INT128_T else if ( options . flags & FLG_PRINCE_CHK ) pp_hybrid_fix_state ( ) ; # endif else if ( options . flags & FLG_EXTERNAL_CHK ) ext_hybrid_fix_state ( ) ; parent_fix_state_pending = 1 ; } return event_abort ; }
|
<S2SV_ModStart> rec_cl ? rec_cl - 1 <S2SV_ModStart> & FLG_MASK_STACKED ) ) { if ( restored ) { mask_tot_cand = mask_tot_cand * ( options . node_max + 1 - options . node_min ) / options . node_count ; restored = 0 ; } else { <S2SV_ModEnd> cand = divide_work <S2SV_ModStart> cpu_mask_ctx ) ; mask_tot_cand = cand * mask_int_cand . num_int_cand ; } } <S2SV_ModEnd> if ( template_key_len
|
8,025 |
CWE-000 PHP_METHOD ( Phalcon_Di_Injectable , fireEventCancel ) { zval * eventname , * data = NULL , * cancelable = NULL , status = { } , callback = { } , events_manager = { } , lower = { } , event_parts = { } , name = { } ; phalcon_fetch_params ( 0 , 1 , 2 , & eventname , & data , & cancelable ) ; if ( ! data ) { data = & PHALCON_GLOBAL ( z_null ) ; } if ( ! cancelable ) { cancelable = & PHALCON_GLOBAL ( z_true ) ; } phalcon_fast_strtolower ( & lower , eventname ) ; if ( phalcon_memnstr_str ( & lower , SL ( ":" ) ) ) { phalcon_fast_explode_str ( & event_parts , SL ( ":" ) , & lower ) ; phalcon_array_fetch_long ( & name , & event_parts , 1 , PH_COPY ) ; zval_ptr_dtor ( & event_parts ) ; } else { ZVAL_COPY ( & name , & lower ) ; } zval_ptr_dtor ( & lower ) ; if ( phalcon_method_exists ( getThis ( ) , & name ) == SUCCESS ) { PHALCON_CALL_METHOD ( & status , getThis ( ) , Z_STRVAL ( name ) , data ) ; if ( PHALCON_IS_FALSE ( & status ) ) { zval_ptr_dtor ( & name ) ; RETURN_FALSE ; } } if ( phalcon_property_array_isset_fetch ( & callback , getThis ( ) , SL ( "_eventCallbacks" ) , & name , PH_READONLY ) ) { zval arguments = { } ; array_init_size ( & arguments , 1 ) ; phalcon_array_append ( & arguments , data , PH_COPY ) ; PHALCON_CALL_USER_FUNC_ARRAY ( & status , & callback , & arguments ) ; zval_ptr_dtor ( & arguments ) ; } zval_ptr_dtor ( & name ) ; <S2SV_StartBug> phalcon_read_property ( & events_manager , getThis ( ) , SL ( "_eventsManager" ) , PH_READONLY ) ; <S2SV_EndBug> if ( Z_TYPE ( events_manager ) != IS_NULL ) { PHALCON_VERIFY_INTERFACE_EX ( & events_manager , phalcon_events_managerinterface_ce , phalcon_di_exception_ce ) ; PHALCON_CALL_METHOD ( & status , & events_manager , "fire" , eventname , getThis ( ) , data , cancelable ) ; <S2SV_StartBug> if ( PHALCON_IS_FALSE ( & status ) ) { <S2SV_EndBug> RETURN_FALSE ; } } RETURN_TRUE ; }
|
<S2SV_ModStart> name ) ; PHALCON_CALL_METHOD <S2SV_ModEnd> ( & events_manager <S2SV_ModStart> ( ) , "geteventsmanager" <S2SV_ModEnd> ) ; if <S2SV_ModStart> cancelable ) ; zval_ptr_dtor ( & events_manager ) ;
|
8,026 |
CWE-000 char * packet_to_spade_json ( struct pck_struct * n ) { NODE_START ( "Entity" ) ; <S2SV_StartBug> __add_uint32_attribute ( "id" , n -> identifier . packet_id . id , false ) ; <S2SV_EndBug> __add_uint32_attribute ( "seq" , n -> identifier . packet_id . seq , true ) ; __add_ipv4_attribute ( "sender" , n -> identifier . packet_id . snd_ip , n -> identifier . packet_id . snd_port , true ) ; __add_ipv4_attribute ( "receiver" , n -> identifier . packet_id . rcv_ip , n -> identifier . packet_id . rcv_port , true ) ; __add_string_attribute ( "type" , "packet" , true ) ; __add_uint64_attribute ( "jiffies" , n -> jiffies , true ) ; NODE_END ( ) ; return buffer ; }
|
<S2SV_ModStart> . id , true <S2SV_ModEnd> ) ; __add_uint32_attribute
|
8,027 |
CWE-000 void skiplist_init ( skiplist_t * sl , uint8_t level ) { <S2SV_StartBug> skipnode_t * n ; <S2SV_EndBug> if ( ( n = skiplist_create_node ( level ) ) != NULL ) { sl -> root = n ; sl -> size = 0x0 ; sl -> level = level ; n -> key = SKIPLIST_KEY_SOL ; } }
|
<S2SV_ModStart> skipnode_t * n ; if ( level < SKIPLIST_MIN_LEVEL || level > UINT8_MAX ) level = SKIPLIST_LEVEL
|
8,028 |
CWE-000 static zyre_node_t * zyre_node_new ( zsock_t * pipe , void * args ) { zyre_node_t * self = ( zyre_node_t * ) zmalloc ( sizeof ( zyre_node_t ) ) ; self -> inbox = zsock_new ( ZMQ_ROUTER ) ; if ( self -> inbox == NULL ) { free ( self ) ; return NULL ; } zsock_set_router_handover ( self -> inbox , 1 ) ; self -> pipe = pipe ; self -> outbox = ( zsock_t * ) args ; self -> poller = zpoller_new ( self -> pipe , NULL ) ; self -> beacon_port = ZRE_DISCOVERY_PORT ; self -> evasive_timeout = 5000 ; self -> expired_timeout = 30000 ; self -> interval = 0 ; self -> uuid = zuuid_new ( ) ; self -> peers = zhash_new ( ) ; self -> peer_groups = zhash_new ( ) ; self -> own_groups = zlist_new ( ) ; zlist_autofree ( self -> own_groups ) ; zlist_comparefn ( self -> own_groups , s_string_compare ) ; self -> headers = zhash_new ( ) ; zhash_autofree ( self -> headers ) ; # ifdef ZYRE_BUILD_DRAFT_API self -> beacon_version = BEACON_VERSION_V2 ; <S2SV_StartBug> self -> zap_domain = "global" ; <S2SV_EndBug> # endif self -> name = ( char * ) zmalloc ( 7 ) ; memcpy ( self -> name , zuuid_str ( self -> uuid ) , 6 ) ; return self ; }
|
<S2SV_ModStart> -> zap_domain = strdup ( "global" ) <S2SV_ModEnd> ; # endif
|
8,029 |
CWE-000 static enum led_brightness led_gpio_brightness_get ( struct led_classdev * led_cdev ) { struct led_gpio_flash_data * flash_led = <S2SV_StartBug> << << << < HEAD <S2SV_EndBug> container_of ( led_cdev , struct led_gpio_flash_data , cdev ) ; return flash_led -> brightness ; }
|
<S2SV_ModStart> * flash_led = <S2SV_ModEnd> container_of ( led_cdev
|
8,030 |
CWE-000 static int shadow_copy2_chdir ( vfs_handle_struct * handle , const char * fname ) { <S2SV_StartBug> time_t timestamp ; <S2SV_EndBug> <S2SV_StartBug> char * stripped ; <S2SV_EndBug> int ret , saved_errno ; char * conv ; if ( ! shadow_copy2_strip_snapshot ( talloc_tos ( ) , handle , fname , & timestamp , & stripped ) ) { return - 1 ; } if ( timestamp == 0 ) { return SMB_VFS_NEXT_CHDIR ( handle , fname ) ; } conv = shadow_copy2_convert ( talloc_tos ( ) , handle , stripped , timestamp ) ; TALLOC_FREE ( stripped ) ; if ( conv == NULL ) { return - 1 ; } ret = SMB_VFS_NEXT_CHDIR ( handle , conv ) ; saved_errno = errno ; TALLOC_FREE ( conv ) ; errno = saved_errno ; return ret ; }
|
<S2SV_ModStart> { time_t timestamp = 0 <S2SV_ModStart> char * stripped = NULL
|
8,031 |
CWE-000 static int zfs_putpages ( struct vnode * vp , vm_page_t * ma , size_t len , int flags , int * rtvals ) { znode_t * zp = VTOZ ( vp ) ; zfsvfs_t * zfsvfs = zp -> z_zfsvfs ; rl_t * rl ; dmu_tx_t * tx ; struct sf_buf * sf ; vm_object_t object ; vm_page_t m ; caddr_t va ; size_t tocopy ; size_t lo_len ; vm_ooffset_t lo_off ; vm_ooffset_t off ; uint_t blksz ; int ncount ; int pcount ; int err ; int i ; ZFS_ENTER ( zfsvfs ) ; ZFS_VERIFY_ZP ( zp ) ; object = vp -> v_object ; pcount = btoc ( len ) ; ncount = pcount ; KASSERT ( ma [ 0 ] -> object == object , ( "mismatching<S2SV_blank>object" ) ) ; KASSERT ( len > 0 && ( len & PAGE_MASK ) == 0 , ( "unexpected<S2SV_blank>length" ) ) ; for ( i = 0 ; i < pcount ; i ++ ) rtvals [ i ] = zfs_vm_pagerret_error ; off = IDX_TO_OFF ( ma [ 0 ] -> pindex ) ; blksz = zp -> z_blksz ; lo_off = rounddown ( off , blksz ) ; lo_len = roundup ( len + ( off - lo_off ) , blksz ) ; rl = zfs_range_lock ( zp , lo_off , lo_len , RL_WRITER ) ; zfs_vmobject_wlock ( object ) ; if ( len + off > object -> un_pager . vnp . vnp_size ) { if ( object -> un_pager . vnp . vnp_size > off ) { int pgoff ; len = object -> un_pager . vnp . vnp_size - off ; ncount = btoc ( len ) ; if ( ( pgoff = ( int ) len & PAGE_MASK ) != 0 ) { m = ma [ ncount - 1 ] ; vm_page_assert_sbusied ( m ) ; KASSERT ( ! pmap_page_is_write_mapped ( m ) , ( "zfs_putpages:<S2SV_blank>page<S2SV_blank>%p<S2SV_blank>is<S2SV_blank>not<S2SV_blank>read-only" , m ) ) ; vm_page_clear_dirty ( m , pgoff , PAGE_SIZE - pgoff ) ; } } else { len = 0 ; ncount = 0 ; } if ( ncount < pcount ) { for ( i = ncount ; i < pcount ; i ++ ) { rtvals [ i ] = zfs_vm_pagerret_bad ; } } } zfs_vmobject_wunlock ( object ) ; if ( ncount == 0 ) goto out ; if ( zfs_owner_overquota ( zfsvfs , zp , B_FALSE ) || zfs_owner_overquota ( zfsvfs , zp , B_TRUE ) ) { goto out ; } top : tx = dmu_tx_create ( zfsvfs -> z_os ) ; dmu_tx_hold_write ( tx , zp -> z_id , off , len ) ; dmu_tx_hold_sa ( tx , zp -> z_sa_hdl , B_FALSE ) ; zfs_sa_upgrade_txholds ( tx , zp ) ; err = dmu_tx_assign ( tx , TXG_NOWAIT ) ; if ( err != 0 ) { if ( err == ERESTART ) { dmu_tx_wait ( tx ) ; dmu_tx_abort ( tx ) ; goto top ; } dmu_tx_abort ( tx ) ; goto out ; } if ( zp -> z_blksz < PAGE_SIZE ) { i = 0 ; for ( i = 0 ; len > 0 ; off += tocopy , len -= tocopy , i ++ ) { tocopy = len > PAGE_SIZE ? PAGE_SIZE : len ; va = zfs_map_page ( ma [ i ] , & sf ) ; dmu_write ( zfsvfs -> z_os , zp -> z_id , off , tocopy , va , tx ) ; zfs_unmap_page ( sf ) ; } } else { err = dmu_write_pages ( zfsvfs -> z_os , zp -> z_id , off , len , ma , tx ) ; } if ( err == 0 ) { uint64_t mtime [ 2 ] , ctime [ 2 ] ; sa_bulk_attr_t bulk [ 3 ] ; int count = 0 ; SA_ADD_BULK_ATTR ( bulk , count , SA_ZPL_MTIME ( zfsvfs ) , NULL , & mtime , 16 ) ; SA_ADD_BULK_ATTR ( bulk , count , SA_ZPL_CTIME ( zfsvfs ) , NULL , & ctime , 16 ) ; SA_ADD_BULK_ATTR ( bulk , count , SA_ZPL_FLAGS ( zfsvfs ) , NULL , & zp -> z_pflags , 8 ) ; zfs_tstamp_update_setup ( zp , CONTENT_MODIFIED , mtime , ctime , B_TRUE ) ; ( void ) sa_bulk_update ( zp -> z_sa_hdl , bulk , count , tx ) ; zfs_log_write ( zfsvfs -> z_log , tx , TX_WRITE , zp , off , len , 0 ) ; zfs_vmobject_wlock ( object ) ; for ( i = 0 ; i < ncount ; i ++ ) { rtvals [ i ] = zfs_vm_pagerret_ok ; vm_page_undirty ( ma [ i ] ) ; } zfs_vmobject_wunlock ( object ) ; <S2SV_StartBug> PCPU_INC ( cnt . v_vnodeout ) ; <S2SV_EndBug> <S2SV_StartBug> PCPU_ADD ( cnt . v_vnodepgsout , ncount ) ; <S2SV_EndBug> } dmu_tx_commit ( tx ) ; out : zfs_range_unlock ( rl ) ; if ( ( flags & ( zfs_vm_pagerput_sync | zfs_vm_pagerput_inval ) ) != 0 || zfsvfs -> z_os -> os_sync == ZFS_SYNC_ALWAYS ) zil_commit ( zfsvfs -> z_log , zp -> z_id ) ; ZFS_EXIT ( zfsvfs ) ; return ( rtvals [ 0 ] ) ; }
|
<S2SV_ModStart> object ) ; VM_CNT_INC ( <S2SV_ModEnd> v_vnodeout ) ; <S2SV_ModStart> v_vnodeout ) ; VM_CNT_ADD ( <S2SV_ModEnd> v_vnodepgsout , ncount
|
8,032 |
CWE-000 static void get_read_lock_ref_log ( bdb_state_type * bdb_state , int ref ) { if ( bdb_state -> parent ) bdb_state = bdb_state -> parent ; if ( ! bdb_bdblock_debug_init_called ) return ; Pthread_mutex_lock ( & ( bdb_state -> bdblock_debug_lock ) ) ; logmsgf ( LOGMSG_USER , bdb_state -> bdblock_debug_fp , <S2SV_StartBug> "INCREMENTING<S2SV_blank>READ<S2SV_blank>LOCK<S2SV_blank>TO<S2SV_blank>%d<S2SV_blank>AT<S2SV_blank>BDB_STATE=%p<S2SV_blank>THREAD=%d:<S2SV_blank>" , ref , <S2SV_EndBug> bdb_state , pthread_self ( ) ) ; comdb2_cheap_stack_trace_file ( bdb_state -> bdblock_debug_fp ) ; Pthread_mutex_unlock ( & ( bdb_state -> bdblock_debug_lock ) ) ; }
|
<S2SV_ModStart> -> bdblock_debug_fp , "INCREMENTING<S2SV_blank>READ<S2SV_blank>LOCK<S2SV_blank>TO<S2SV_blank>%d<S2SV_blank>AT<S2SV_blank>BDB_STATE=%p<S2SV_blank>THREAD=%lu:<S2SV_blank>" <S2SV_ModEnd> , ref ,
|
8,033 |
CWE-000 int lbmct_src_handle_handshake_d_ok ( lbmct_t * ct , lbmct_ctrlr_cmd_src_handshake_t * src_handshake ) { const char * msg_data = src_handshake -> msg -> data ; char rcv_conn_id_str [ LBMCT_RCV_CONN_ID_STR_SZ + 1 ] ; lbmct_src_conn_t tst_src_conn ; mul_asl_node_t * asl_node ; lbmct_src_conn_t * src_conn = NULL ; lbmct_src_t * ct_src = NULL ; int err ; char cmd [ LBMCT_PREFIX_SZ + 1 ] ; unsigned int field_cnt ; unsigned int rcv_ct_id ; <S2SV_StartBug> char rcv_uim_addr [ LBM_MSG_MAX_SOURCE_LEN + 1 ] ; <S2SV_EndBug> unsigned int rcv_conn_id ; unsigned int src_ct_id ; <S2SV_StartBug> char src_uim_addr [ LBM_MSG_MAX_SOURCE_LEN + 1 ] ; <S2SV_EndBug> unsigned int src_conn_id ; unsigned int end_sqn ; int null_ofs = 0 ; sscanf ( msg_data , "%" STRDEF ( LBMCT_PREFIX_SZ ) "[a-zA-Z0-9_]," "%u," "%u," "%" STRDEF ( LBMCT_UIM_ADDR_STR_SZ ) "[A-Z0-9:.]," "%u," "%u," "%" STRDEF ( LBMCT_UIM_ADDR_STR_SZ ) "[A-Z0-9:.]," "%u," "%u" "%n" , cmd , & field_cnt , & rcv_ct_id , rcv_uim_addr , & rcv_conn_id , & src_ct_id , src_uim_addr , & src_conn_id , & end_sqn , & null_ofs ) ; if ( null_ofs == 0 ) E_RTN ( "Conn<S2SV_blank>ok<S2SV_blank>msg:<S2SV_blank>parse<S2SV_blank>error" , - 1 ) ; snprintf ( rcv_conn_id_str , sizeof ( rcv_conn_id_str ) , "%u,%s,%u" , rcv_ct_id , rcv_uim_addr , rcv_conn_id ) ; memcpy ( tst_src_conn . rcv_conn_id_str , rcv_conn_id_str , sizeof ( tst_src_conn . rcv_conn_id_str ) ) ; asl_node = mul_asl_find ( ct -> src_conn_asl , & tst_src_conn ) ; if ( asl_node == NULL ) E_RTN ( "connection<S2SV_blank>not<S2SV_blank>found" , - 1 ) ; src_conn = mul_asl_node_key ( asl_node ) ; if ( src_conn -> sig != LBMCT_SIG_SRC_CONN ) E_RTN ( E_BAD_SIG ( src_conn ) , - 1 ) ; if ( src_conn -> ct != ct ) E_RTN ( "Internal<S2SV_blank>error,<S2SV_blank>ct<S2SV_blank>mismatch" , - 1 ) ; ct_src = src_conn -> ct_src ; if ( ct_src == NULL ) E_RTN ( "src_conn<S2SV_blank>is<S2SV_blank>corrupted" , - 1 ) ; if ( ct_src -> sig != LBMCT_SIG_CT_SRC ) E_RTN ( E_BAD_SIG ( ct_src ) , - 1 ) ; src_conn -> peer_info . rcv_end_seq_num = end_sqn ; src_conn -> peer_info . flags |= LBMCT_PEER_INFO_FLAGS_RCV_END_SEQ_NUM ; if ( src_conn -> state != LBMCT_CONN_STATE_ENDING ) { lbm_logf ( LBM_LOG_WARNING , "Warning<S2SV_blank>at<S2SV_blank>%s:%d,<S2SV_blank>received<S2SV_blank>D_OK<S2SV_blank>handshake<S2SV_blank>when<S2SV_blank>src_conn<S2SV_blank>in<S2SV_blank>state<S2SV_blank>%d\\n" , BASENAME ( __FILE__ ) , __LINE__ , ( int ) src_conn -> state ) ; } src_conn -> pending_tmr_id = - 1 ; ( void ) tmr_cancel_sync ( src_conn -> tmr ) ; err = lbmct_src_conn_delete ( src_conn ) ; if ( err != LBM_OK ) E_RTN ( lbm_errmsg ( ) , - 1 ) ; return LBM_OK ; }
|
<S2SV_ModStart> rcv_uim_addr [ LBM_MSG_MAX_SOURCE_LEN <S2SV_ModEnd> ] ; unsigned <S2SV_ModStart> src_uim_addr [ LBM_MSG_MAX_SOURCE_LEN <S2SV_ModEnd> ] ; unsigned
|
8,034 |
CWE-000 void print_task_list ( ) { if ( curr_task == NULL ) { klog ( IMP , "Tasks<S2SV_blank>in<S2SV_blank>queue<S2SV_blank>are:<S2SV_blank>\\n" ) ; klog ( IMP , "No<S2SV_blank>tasks<S2SV_blank>in<S2SV_blank>the<S2SV_blank>queue!\\n" ) ; return ; } int i = 0 ; klog ( INFO , "Tasks<S2SV_blank>in<S2SV_blank>queue<S2SV_blank>are:<S2SV_blank>\\n" ) ; klog ( INFO , "%d<S2SV_blank>:<S2SV_blank>%s\\n" , i ++ , curr_task -> pcmd_name ) ; task_struct_t * temp = curr_task -> next_task ; kprintf ( "PID<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>TIME<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>CMD\\n" ) ; while ( temp != curr_task ) { kprintf ( "%d<S2SV_blank><S2SV_blank><S2SV_blank>%s<S2SV_blank><S2SV_blank>%s\\n" , temp -> pid , temp -> start_time , temp -> pcmd_name ) ; temp = temp -> next_task ; if ( temp -> pid == 0 ) { break ; } <S2SV_StartBug> sleep ( 100 ) ; <S2SV_EndBug> } kprintf ( "%d<S2SV_blank><S2SV_blank><S2SV_blank>%s<S2SV_blank><S2SV_blank>%s\\n" , temp -> pid , temp -> start_time , temp -> pcmd_name ) ; }
|
<S2SV_ModStart> break ; } <S2SV_ModEnd> } kprintf (
|
8,035 |
CWE-000 static IOTHUB_CLIENT_RESULT my_IoTHubClientCore_LL_GenericMethodInvoke ( IOTHUB_CLIENT_CORE_LL_HANDLE iotHubClientHandle , const char * deviceId , const char * moduleId , const char * methodName , const char * methodPayload , unsigned int timeout , int * responseStatus , unsigned char * * responsePayload , size_t * responsePayloadSize ) { ( void ) iotHubClientHandle ; ( void ) deviceId , ( void ) moduleId , ( void ) methodName , ( void ) methodPayload , ( void ) timeout ; ASSERT_ARE_EQUAL_WITH_MSG ( char_ptr , deviceId , TEST_DEVICE_ID , "DeviceIDs<S2SV_blank>don\'t<S2SV_blank>match" ) ; <S2SV_StartBug> ASSERT_ARE_EQUAL_WITH_MSG ( char_ptr , moduleId , TEST_MODULE_ID , "ModuleIds<S2SV_blank>don\'t<S2SV_blank>match" ) ; <S2SV_EndBug> ASSERT_ARE_EQUAL_WITH_MSG ( char_ptr , methodName , TEST_METHOD_NAME , "Method<S2SV_blank>names<S2SV_blank>match" ) ; ASSERT_ARE_EQUAL_WITH_MSG ( char_ptr , methodPayload , TEST_METHOD_PAYLOAD , "Method<S2SV_blank>payloads<S2SV_blank>don\'t<S2SV_blank>match" ) ; ASSERT_ARE_EQUAL_WITH_MSG ( int , timeout , TEST_INVOKE_TIMEOUT , "Timeouts<S2SV_blank>don\'t<S2SV_blank>match" ) ; * responseStatus = REPORTED_STATE_STATUS_CODE ; * responsePayload = ( unsigned char * ) TEST_DEVICE_METHOD_RESPONSE ; * responsePayloadSize = TEST_DEVICE_RESP_LENGTH ; return IOTHUB_CLIENT_OK ; }
|
<S2SV_ModStart> "DeviceIDs<S2SV_blank>don\'t<S2SV_blank>match" ) ; if ( current_method_invoke_test == METHOD_INVOKE_TEST_TARGET_MODULE ) { <S2SV_ModStart> "ModuleIds<S2SV_blank>don\'t<S2SV_blank>match" ) ; } else { ASSERT_IS_NULL_WITH_MSG ( moduleId , "ModuleID<S2SV_blank>should<S2SV_blank>be<S2SV_blank>NULL<S2SV_blank>for<S2SV_blank>device<S2SV_blank>test" ) ; }
|
8,036 |
CWE-000 static int attach_brick ( xlator_t * this , glusterd_brickinfo_t * brickinfo , glusterd_brickinfo_t * other_brick , glusterd_volinfo_t * volinfo , glusterd_volinfo_t * other_vol ) { glusterd_conf_t * conf = this -> private ; char pidfile1 [ PATH_MAX ] = { 0 } ; char pidfile2 [ PATH_MAX ] = { 0 } ; char unslashed [ PATH_MAX ] = { '\\0' , } ; char full_id [ PATH_MAX ] = { '\\0' , } ; char path [ PATH_MAX ] = { '\\0' , } ; int ret ; int tries ; rpc_clnt_t * rpc ; gf_log ( this -> name , GF_LOG_INFO , "add<S2SV_blank>brick<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>existing<S2SV_blank>process<S2SV_blank>for<S2SV_blank>%s" , brickinfo -> path , other_brick -> path ) ; GLUSTERD_REMOVE_SLASH_FROM_PATH ( brickinfo -> path , unslashed ) ; <S2SV_StartBug> ret = pmap_registry_extend ( this , other_brick -> port , <S2SV_EndBug> brickinfo -> path ) ; if ( ret != 0 ) { gf_log ( this -> name , GF_LOG_ERROR , "adding<S2SV_blank>brick<S2SV_blank>to<S2SV_blank>process<S2SV_blank>failed" ) ; return - 1 ; } GLUSTERD_GET_BRICK_PIDFILE ( pidfile1 , other_vol , other_brick , conf ) ; GLUSTERD_GET_BRICK_PIDFILE ( pidfile2 , volinfo , brickinfo , conf ) ; if ( volinfo -> is_snap_volume ) { snprintf ( full_id , sizeof ( full_id ) , "/%s/%s/%s.%s.%s" , GLUSTERD_VOL_SNAP_DIR_PREFIX , volinfo -> snapshot -> snapname , volinfo -> volname , brickinfo -> hostname , unslashed ) ; } else { snprintf ( full_id , sizeof ( full_id ) , "%s.%s.%s" , volinfo -> volname , brickinfo -> hostname , unslashed ) ; } ( void ) build_volfile_path ( full_id , path , sizeof ( path ) , NULL ) ; for ( tries = 15 ; tries > 0 ; -- tries ) { rpc = rpc_clnt_ref ( other_brick -> rpc ) ; if ( rpc ) { ret = send_attach_req ( this , rpc , path , GLUSTERD_BRICK_ATTACH ) ; rpc_clnt_unref ( rpc ) ; if ( ! ret ) { <S2SV_StartBug> glusterd_copy_file ( pidfile1 , pidfile2 ) ; <S2SV_EndBug> brickinfo -> port = other_brick -> port ; brickinfo -> status = GF_BRICK_STARTED ; brickinfo -> rpc = <S2SV_StartBug> rpc_clnt_ref ( other_brick -> rpc ) ; <S2SV_EndBug> ret = glusterd_brick_process_add_brick ( brickinfo , volinfo ) ; if ( ret ) { gf_msg ( this -> name , GF_LOG_ERROR , 0 , GD_MSG_BRICKPROC_ADD_BRICK_FAILED , "Adding<S2SV_blank>brick<S2SV_blank>%s:%s<S2SV_blank>to<S2SV_blank>brick<S2SV_blank>" "process<S2SV_blank>failed" , brickinfo -> hostname , brickinfo -> path ) ; return ret ; } if ( ret ) { gf_msg_debug ( this -> name , 0 , "Add<S2SV_blank>brick" "<S2SV_blank>to<S2SV_blank>brick<S2SV_blank>process<S2SV_blank>failed" ) ; return ret ; } return 0 ; } } synclock_unlock ( & conf -> big_lock ) ; sleep ( 1 ) ; synclock_lock ( & conf -> big_lock ) ; } gf_log ( this -> name , GF_LOG_WARNING , "attach<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s" , brickinfo -> path ) ; return ret ; }
|
<S2SV_ModStart> unslashed ) ; <S2SV_ModEnd> GLUSTERD_GET_BRICK_PIDFILE ( pidfile1 <S2SV_ModStart> ret ) { ret = pmap_registry_extend ( this , other_brick -> port , brickinfo -> path ) ; if ( ret != 0 ) { gf_log ( this -> name , GF_LOG_ERROR , "adding<S2SV_blank>brick<S2SV_blank>to<S2SV_blank>process<S2SV_blank>failed" ) ; return ret ; } <S2SV_ModStart> -> rpc ) ; brickinfo -> port_registered = _gf_true
|
8,037 |
CWE-000 ovs_db_t * ovs_db_init ( const char * node , const char * service , const char * unix_path , ovs_db_callback_t * cb ) { <S2SV_StartBug> if ( node == NULL || service == NULL || unix_path == NULL ) <S2SV_EndBug> return NULL ; ovs_db_t * pdb = calloc ( 1 , sizeof ( * pdb ) ) ; if ( pdb == NULL ) return NULL ; pdb -> sock = - 1 ; sstrncpy ( pdb -> node , node , sizeof ( pdb -> node ) ) ; sstrncpy ( pdb -> service , service , sizeof ( pdb -> service ) ) ; sstrncpy ( pdb -> unix_path , unix_path , sizeof ( pdb -> unix_path ) ) ; if ( cb ) pdb -> cb = * cb ; pthread_mutexattr_t mutex_attr ; if ( pthread_mutexattr_init ( & mutex_attr ) ) { OVS_ERROR ( "OVS<S2SV_blank>DB<S2SV_blank>mutex<S2SV_blank>attribute<S2SV_blank>init<S2SV_blank>failed" ) ; sfree ( pdb ) ; return NULL ; } if ( pthread_mutexattr_settype ( & mutex_attr , PTHREAD_MUTEX_RECURSIVE ) ) { OVS_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>OVS<S2SV_blank>DB<S2SV_blank>mutex<S2SV_blank>as<S2SV_blank>recursive" ) ; pthread_mutexattr_destroy ( & mutex_attr ) ; sfree ( pdb ) ; return NULL ; } if ( pthread_mutex_init ( & pdb -> mutex , & mutex_attr ) ) { OVS_ERROR ( "OVS<S2SV_blank>DB<S2SV_blank>mutex<S2SV_blank>init<S2SV_blank>failed" ) ; pthread_mutexattr_destroy ( & mutex_attr ) ; sfree ( pdb ) ; return NULL ; } pthread_mutexattr_destroy ( & mutex_attr ) ; if ( ovs_db_event_thread_init ( pdb ) < 0 ) { <S2SV_StartBug> ovs_db_destroy ( pdb ) ; <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> } if ( ovs_db_poll_thread_init ( pdb ) < 0 ) { <S2SV_StartBug> ovs_db_destroy ( pdb ) ; <S2SV_EndBug> <S2SV_StartBug> return NULL ; <S2SV_EndBug> } return pdb ; }
|
<S2SV_ModStart> cb ) { int ret ; <S2SV_ModStart> 0 ) { ret = <S2SV_ModStart> pdb ) ; if ( ret > 0 ) goto failure <S2SV_ModEnd> ; } if <S2SV_ModStart> 0 ) { ret = <S2SV_ModStart> pdb ) ; if ( ret > 0 ) { ovs_db_event_thread_data_destroy ( pdb ) ; goto failure ; } } return pdb ; failure : pthread_mutex_destroy ( & pdb -> mutex ) ; sfree ( pdb ) ; return NULL <S2SV_ModEnd> ; } <S2SV_null>
|
8,038 |
CWE-000 static RList * patch_relocs ( RBin * b ) { RList * ret = NULL ; RBinReloc * ptr = NULL ; RIO * io = NULL ; RBinObject * obj = NULL ; struct Elf_ ( r_bin_elf_obj_t ) * bin = NULL ; RIOSection * g = NULL , * s = NULL ; SdbHash * relocs_by_sym ; SdbListIter * iter ; RBinElfReloc * relcs = NULL ; RBinInfo * info ; int cdsz ; int i ; ut64 n_off , n_vaddr , vaddr , size , offset = 0 ; if ( ! b ) return NULL ; io = b -> iob . io ; if ( ! io || ! io -> desc ) return NULL ; obj = r_bin_cur_object ( b ) ; if ( ! obj ) { return NULL ; } bin = obj -> bin_obj ; if ( bin -> ehdr . e_type != ET_REL ) { return NULL ; } if ( ! io -> cached ) { eprintf ( "Warning:<S2SV_blank>run<S2SV_blank>r2<S2SV_blank>with<S2SV_blank>-e<S2SV_blank>io.cache=true<S2SV_blank>to<S2SV_blank>fix<S2SV_blank>relocations<S2SV_blank>in<S2SV_blank>disassembly\\n" ) ; return relocs ( r_bin_cur ( b ) ) ; } info = obj ? obj -> info : NULL ; cdsz = info ? ( info -> bits == 64 ? 8 : info -> bits == 32 ? 4 : info -> bits == 16 ? 4 : 0 ) : 0 ; ls_foreach ( io -> sections , iter , s ) { if ( s -> paddr > offset ) { offset = s -> paddr ; g = s ; } } if ( ! g ) { return NULL ; } n_off = g -> paddr + g -> size ; n_vaddr = g -> vaddr + g -> vsize ; size = bin -> reloc_num * 4 ; if ( ! b -> iob . section_add ( io , n_off , n_vaddr , size , size , R_BIN_SCN_READABLE , ".got.r2" , 0 , io -> desc -> fd ) ) { return NULL ; } if ( ! ( relcs = Elf_ ( r_bin_elf_get_relocs ) ( bin ) ) ) { return NULL ; } if ( ! ( ret = r_list_newf ( ( RListFree ) free ) ) ) { free ( relcs ) ; return NULL ; } if ( ! ( relocs_by_sym = ht_new ( NULL , relocs_by_sym_free , NULL ) ) ) { r_list_free ( ret ) ; free ( relcs ) ; return NULL ; } vaddr = n_vaddr ; for ( i = 0 ; ! relcs [ i ] . last ; i ++ ) { ut64 sym_addr = 0 ; if ( relcs [ i ] . sym ) { if ( relcs [ i ] . sym < bin -> imports_by_ord_size && bin -> imports_by_ord [ relcs [ i ] . sym ] ) { bool found ; sym_addr = ht_find_intu64 ( relocs_by_sym , relcs [ i ] . sym , & found ) ; <S2SV_StartBug> if ( ! found ) { <S2SV_EndBug> sym_addr = 0 ; } } else if ( relcs [ i ] . sym < bin -> symbols_by_ord_size && bin -> symbols_by_ord [ relcs [ i ] . sym ] ) { sym_addr = bin -> symbols_by_ord [ relcs [ i ] . sym ] -> vaddr ; } } _patch_reloc ( bin -> ehdr . e_machine , & b -> iob , & relcs [ i ] , sym_addr ? sym_addr : vaddr , 0 , n_vaddr + size ) ; if ( ! ( ptr = reloc_convert ( bin , & relcs [ i ] , n_vaddr ) ) ) { continue ; } if ( sym_addr ) { ptr -> vaddr = sym_addr ; } else { ptr -> vaddr = vaddr ; ht_insert_intu64 ( relocs_by_sym , relcs [ i ] . sym , vaddr ) ; vaddr += cdsz ; } r_list_append ( ret , ptr ) ; } ht_free ( relocs_by_sym ) ; free ( relcs ) ; return ret ; }
|
<S2SV_ModStart> found ) ; <S2SV_ModEnd> } else if
|
8,039 |
CWE-000 int connect_to_server ( char * server , int PORT ) { struct hostent * host_info = gethostbyname ( server ) ; if ( host_info == NULL ) { printf ( "Could<S2SV_blank>not<S2SV_blank>look<S2SV_blank>up<S2SV_blank>server<S2SV_blank>address<S2SV_blank>-<S2SV_blank>Exiting\\n" ) ; return - 1 ; } int socket_fd = socket ( AF_INET , SOCK_STREAM , 0 ) ; if ( socket_fd < 0 ) { <S2SV_StartBug> printf ( "Cannot<S2SV_blank>create<S2SV_blank>socket_fd\\n" ) ; <S2SV_EndBug> return - 1 ; } struct sockaddr_in server_address ; server_address . sin_family = host_info -> h_addrtype ; memcpy ( ( char * ) & server_address . sin_addr . s_addr , host_info -> h_addr_list [ 0 ] , host_info -> h_length ) ; server_address . sin_port = htons ( PORT ) ; if ( connect ( socket_fd , ( struct sockaddr * ) & server_address , sizeof ( server_address ) ) < 0 ) { <S2SV_StartBug> printf ( "Cannot<S2SV_blank>connect\\n" ) ; <S2SV_EndBug> return - 1 ; } printf ( "Succesfully<S2SV_blank>connected<S2SV_blank>to<S2SV_blank>the<S2SV_blank>server\\n" ) ; return socket_fd ; }
|
<S2SV_ModStart> { printf ( "Failed<S2SV_blank>obtaining<S2SV_blank>a<S2SV_blank>socket<S2SV_blank>file<S2SV_blank>descriptor\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> { printf ( "Cannot<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>server\\n" <S2SV_ModEnd> ) ; return
|
8,040 |
CWE-000 int main ( int argc , char * argv [ ] ) { <S2SV_StartBug> printf ( "***<S2SV_blank>Network<S2SV_blank>Emulator<S2SV_blank>Activate<S2SV_blank>***\\n" ) ; <S2SV_EndBug> if ( argc != 2 ) { printf ( "./destroy<S2SV_blank>[NODE]\\n" ) ; return - 1 ; } printf ( "Node<S2SV_blank>Name:<S2SV_blank>%s\\n" , argv [ 1 ] ) ; char * host = getenv ( "NETEMUL_ADDR" ) ; char * _port = getenv ( "NETEMUL_PORT" ) ; if ( ! host || ! _port ) { printf ( "Error:<S2SV_blank>$<S2SV_blank>source<S2SV_blank>netemul.conf\\n" ) ; exit ( - 1 ) ; } char * next ; uint16_t port = strtol ( _port , & next , 10 ) ; RPC_NetEmulator * rpc = rpc_netemul_open ( host , port , 3 ) ; if ( ! rpc ) { printf ( "Error:<S2SV_blank>NetEmulator<S2SV_blank>Connection<S2SV_blank>fail<S2SV_blank>%s:%s\\n" , host , _port ) ; exit ( - 1 ) ; } bool callback ( bool result , void * context ) { printf ( "On<S2SV_blank>%s\\n" , result ? "Success" : "Fail" ) ; exit ( 0 ) ; return true ; } rpc_destroy ( rpc , argv [ 1 ] , callback , NULL ) ; while ( 1 ) rpc_netemul_loop ( rpc ) ; return 0 ; }
|
<S2SV_ModStart> { printf ( "***<S2SV_blank>Network<S2SV_blank>Emulator<S2SV_blank>Destroy<S2SV_blank>***\\n" <S2SV_ModEnd> ) ; if
|
8,041 |
CWE-000 static void verify_benchmark ( ) { unsigned rounds = 250 ; <S2SV_StartBug> printf ( "Starting<S2SV_blank>sign-and-verify::verify_benchmark<S2SV_blank>(%d<S2SV_blank>iterations)...\\n" , rounds ) ; <S2SV_EndBug> sign_and_verify_fixture fixture ; setup ( & fixture ) ; struct ecdaa_signature_ZZZ sig ; TEST_ASSERT ( 0 == ecdaa_signature_ZZZ_sign ( & sig , fixture . msg , fixture . msg_len , & fixture . sk , & fixture . cred , & fixture . prng ) ) ; struct timeval tv1 ; gettimeofday ( & tv1 , NULL ) ; for ( unsigned i = 0 ; i < rounds ; i ++ ) { TEST_ASSERT ( 0 == ecdaa_signature_ZZZ_verify ( & sig , & fixture . ipk . gpk , & fixture . sk_rev_list , fixture . msg , fixture . msg_len ) ) ; } struct timeval tv2 ; gettimeofday ( & tv2 , NULL ) ; unsigned long long elapsed = ( tv2 . tv_usec + tv2 . tv_sec * 1000000 ) - ( tv1 . tv_usec + tv1 . tv_sec * 1000000 ) ; teardown ( & fixture ) ; printf ( "%llu<S2SV_blank>usec<S2SV_blank>(%6llu<S2SV_blank>verifications/s)\\n" , elapsed , rounds * 1000000ULL / elapsed ) ; }
|
<S2SV_ModStart> ; printf ( "Starting<S2SV_blank>sign-and-verify::verify_benchmark<S2SV_blank>(%u<S2SV_blank>iterations)...\\n" <S2SV_ModEnd> , rounds )
|
8,042 |
CWE-000 void * avmpack_fold ( void * accum , const void * avmpack_binary , avmpack_fold_fun fold_fun ) { int offset = AVMPACK_SIZE ; uint32_t size = 0 ; do { const uint32_t * size_ptr = ( ( const uint32_t * ) ( avmpack_binary ) ) + offset / sizeof ( uint32_t ) ; size = ENDIAN_SWAP_32 ( * size_ptr ) ; if ( size > 0 ) { const uint32_t * flags_ptr = size_ptr + 1 ; uint32_t flags = ENDIAN_SWAP_32 ( * flags_ptr ) ; const char * section_name = ( const char * ) ( size_ptr + 3 ) ; int section_name_len = pad ( strlen ( section_name ) + 1 ) ; accum = fold_fun ( accum , <S2SV_StartBug> ( uint32_t * ) ( size_ptr + 3 + section_name_len / sizeof ( uint32_t ) ) , <S2SV_EndBug> size , flags , section_name ) ; offset += size ; } } while ( size > 0 ) ; return accum ; }
|
<S2SV_ModStart> ( accum , size_ptr , size , <S2SV_ModEnd> size_ptr + 3 <S2SV_ModStart> ( uint32_t ) <S2SV_ModEnd> , flags ,
|
8,043 |
CWE-000 void OutputField ( const char * start , const char * end , int IsLast ) { const char * ptr ; char delim ; static int OutputNo = 0 ; if ( start ) { for ( ptr = start ; ptr && ( ptr < end ) ; ptr ++ ) { if ( * ptr == '\\0' ) break ; } delim = * ptr ; if ( delim == '\\0' ) delim = * Delim ; if ( ( Flags & FLAG_QUOTE_STRIP ) && ( ( * start == '\\'' ) || ( * start == \'"\' ) ) && ( ptr > start ) && ( * ( ptr - 1 ) == * start ) ) { start ++ ; ptr -- ; } if ( Flags & FLAG_SETVARS ) { if ( OutputNo < VarCount ) { fputs ( VarNames [ OutputNo ] , stdout ) ; fputs ( "=\'" , stdout ) ; fwrite ( start , ptr - start , 1 , stdout ) ; fputs ( "\';<S2SV_blank>" , stdout ) ; } } else { <S2SV_StartBug> fwrite ( start , ptr - start , 1 , stdout ) ; <S2SV_EndBug> if ( ! IsLast ) { if ( OutputDelim ) fputs ( OutputDelim , stdout ) ; <S2SV_StartBug> else fputc ( delim , stdout ) ; <S2SV_EndBug> } } } OutputNo ++ ; }
|
<S2SV_ModStart> } else { if ( Flags & FLAG_DELIMSTR ) fwrite ( start , ptr + 1 - DelimLen - start , 1 , stdout ) ; else <S2SV_ModStart> ) ; else if ( Flags & FLAG_DELIMSTR ) fputs ( Delim , stdout ) ; else
|
8,044 |
CWE-000 int __wt_txn_global_query_timestamp ( WT_SESSION_IMPL * session , char * hex_timestamp , const char * cfg [ ] ) { # ifdef HAVE_TIMESTAMPS wt_timestamp_t ts ; WT_RET ( __txn_global_query_timestamp ( session , & ts , cfg ) ) ; return ( __wt_timestamp_to_hex_string ( session , hex_timestamp , & ts ) ) ; # else WT_UNUSED ( hex_timestamp ) ; WT_UNUSED ( cfg ) ; WT_RET_MSG ( session , ENOTSUP , <S2SV_StartBug> "WT_CONNECTION.query_timestamp<S2SV_blank>requires<S2SV_blank>a<S2SV_blank>version<S2SV_blank>of<S2SV_blank>WiredTiger<S2SV_blank>" <S2SV_EndBug> "built<S2SV_blank>with<S2SV_blank>timestamp<S2SV_blank>support" ) ; # endif }
|
<S2SV_ModStart> , ENOTSUP , "requires<S2SV_blank>a<S2SV_blank>version<S2SV_blank>of<S2SV_blank>WiredTiger<S2SV_blank>built<S2SV_blank>with<S2SV_blank>timestamp<S2SV_blank>support" <S2SV_ModEnd> ) ; #
|
8,045 |
CWE-000 void _PG_init ( void ) <S2SV_StartBug> { <S2SV_EndBug> if ( ! process_shared_preload_libraries_in_progress ) { ereport ( ERROR , ( errmsg ( "Citus<S2SV_blank>can<S2SV_blank>only<S2SV_blank>be<S2SV_blank>loaded<S2SV_blank>via<S2SV_blank>shared_preload_libraries" ) , errhint ( "Add<S2SV_blank>citus<S2SV_blank>to<S2SV_blank>shared_preload_libraries<S2SV_blank>configuration<S2SV_blank>" "variable<S2SV_blank>in<S2SV_blank>postgresql.conf<S2SV_blank>in<S2SV_blank>master<S2SV_blank>and<S2SV_blank>workers.<S2SV_blank>Note<S2SV_blank>" "that<S2SV_blank>citus<S2SV_blank>should<S2SV_blank>be<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>" "shared_preload_libraries." ) ) ) ; } if ( planner_hook != NULL || ProcessUtility_hook != NULL || ExecutorStart_hook != NULL ) { ereport ( ERROR , ( errmsg ( "Citus<S2SV_blank>has<S2SV_blank>to<S2SV_blank>be<S2SV_blank>loaded<S2SV_blank>first" ) , errhint ( "Place<S2SV_blank>citus<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>" "shared_preload_libraries." ) ) ) ; } <S2SV_StartBug> if ( ! IsUnderPostmaster ) <S2SV_EndBug> { CreateRequiredDirectories ( ) ; } InitConnParams ( ) ; RegisterCitusConfigVariables ( ) ; RegisterNodes ( ) ; RegisterCitusCustomScanMethods ( ) ; planner_hook = distributed_planner ; # if ( PG_VERSION_NUM >= 100000 ) ProcessUtility_hook = multi_ProcessUtility ; # else ProcessUtility_hook = multi_ProcessUtility9x ; # endif set_rel_pathlist_hook = multi_relation_restriction_hook ; set_join_pathlist_hook = multi_join_restriction_hook ; ExecutorStart_hook = CitusExecutorStart ; emit_log_hook = multi_log_hook ; InitializeMaintenanceDaemon ( ) ; TaskTrackerRegister ( ) ; InitializeTransactionManagement ( ) ; InitializeBackendManagement ( ) ; InitializeConnectionManagement ( ) ; InitPlacementConnectionManagement ( ) ; InitializeCitusQueryStats ( ) ; if ( IsBinaryUpgrade ) { SetConfigOption ( "allow_system_table_mods" , "true" , PGC_POSTMASTER , PGC_S_OVERRIDE ) ; } }
|
<S2SV_ModStart> void ) { volatile char * stack_resizer = NULL ; long max_stack_depth_bytes = 0 ; <S2SV_ModStart> ) ; } max_stack_depth_bytes = max_stack_depth * 1024L ; stack_resizer = alloca ( max_stack_depth_bytes ) ; stack_resizer [ max_stack_depth_bytes - 1 ] = 0 ;
|
8,046 |
CWE-000 void mockLibpq ( PGconn * pgConn , int motionListener , int qePid ) { expect_any_count ( PQconnectdbParams , keywords , - 1 ) ; expect_any_count ( PQconnectdbParams , values , - 1 ) ; expect_any_count ( PQconnectdbParams , expand_dbname , - 1 ) ; will_return_count ( PQconnectdbParams , pgConn , TOTOAL_SEGMENTS ) ; expect_value_count ( PQstatus , conn , pgConn , - 1 ) ; <S2SV_StartBug> will_return_count ( PQstatus , CONNECTION_OK , - 1 ) ; <S2SV_EndBug> expect_value_count ( PQsocket , conn , pgConn , - 1 ) ; will_return_count ( PQsocket , 100 , - 1 ) ; expect_value_count ( PQsetNoticeReceiver , conn , pgConn , - 1 ) ; expect_any_count ( PQsetNoticeReceiver , proc , - 1 ) ; expect_any_count ( PQsetNoticeReceiver , arg , - 1 ) ; will_return_count ( PQsetNoticeReceiver , CONNECTION_OK , - 1 ) ; expect_value_count ( PQgetQEdetail , conn , pgConn , - 1 ) ; will_return_count ( PQgetQEdetail , motionListener , - 1 ) ; expect_value_count ( PQbackendPID , conn , pgConn , - 1 ) ; will_return_count ( PQbackendPID , qePid , - 1 ) ; }
|
<S2SV_ModStart> PQstatus , CONNECTION_OK <S2SV_ModEnd> , - 1
|
8,047 |
CWE-000 static int bond_miimon_inspect ( struct bonding * bond ) { int link_state , commit = 0 ; struct list_head * iter ; struct slave * slave ; bool ignore_updelay ; ignore_updelay = ! rcu_dereference ( bond -> curr_active_slave ) ; bond_for_each_slave_rcu ( bond , slave , iter ) { slave -> new_link = BOND_LINK_NOCHANGE ; link_state = bond_check_dev_link ( bond , slave -> dev , 0 ) ; switch ( slave -> link ) { case BOND_LINK_UP : if ( link_state ) continue ; bond_propose_link_state ( slave , BOND_LINK_FAIL ) ; slave -> delay = bond -> params . downdelay ; if ( slave -> delay ) { netdev_info ( bond -> dev , "link<S2SV_blank>status<S2SV_blank>down<S2SV_blank>for<S2SV_blank>%sinterface<S2SV_blank>%s,<S2SV_blank>disabling<S2SV_blank>it<S2SV_blank>in<S2SV_blank>%d<S2SV_blank>ms\\n" , ( BOND_MODE ( bond ) == BOND_MODE_ACTIVEBACKUP ) ? ( bond_is_active_slave ( slave ) ? "active<S2SV_blank>" : "backup<S2SV_blank>" ) : "" , slave -> dev -> name , bond -> params . downdelay * bond -> params . miimon ) ; } case BOND_LINK_FAIL : if ( link_state ) { bond_propose_link_state ( slave , BOND_LINK_UP ) ; slave -> last_link_up = jiffies ; netdev_info ( bond -> dev , "link<S2SV_blank>status<S2SV_blank>up<S2SV_blank>again<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>ms<S2SV_blank>for<S2SV_blank>interface<S2SV_blank>%s\\n" , ( bond -> params . downdelay - slave -> delay ) * bond -> params . miimon , slave -> dev -> name ) ; <S2SV_StartBug> continue ; <S2SV_EndBug> } if ( slave -> delay <= 0 ) { slave -> new_link = BOND_LINK_DOWN ; commit ++ ; continue ; } slave -> delay -- ; break ; case BOND_LINK_DOWN : if ( ! link_state ) continue ; bond_propose_link_state ( slave , BOND_LINK_BACK ) ; slave -> delay = bond -> params . updelay ; if ( slave -> delay ) { netdev_info ( bond -> dev , "link<S2SV_blank>status<S2SV_blank>up<S2SV_blank>for<S2SV_blank>interface<S2SV_blank>%s,<S2SV_blank>enabling<S2SV_blank>it<S2SV_blank>in<S2SV_blank>%d<S2SV_blank>ms\\n" , slave -> dev -> name , ignore_updelay ? 0 : bond -> params . updelay * bond -> params . miimon ) ; } case BOND_LINK_BACK : if ( ! link_state ) { bond_propose_link_state ( slave , BOND_LINK_DOWN ) ; netdev_info ( bond -> dev , "link<S2SV_blank>status<S2SV_blank>down<S2SV_blank>again<S2SV_blank>after<S2SV_blank>%d<S2SV_blank>ms<S2SV_blank>for<S2SV_blank>interface<S2SV_blank>%s\\n" , ( bond -> params . updelay - slave -> delay ) * bond -> params . miimon , slave -> dev -> name ) ; <S2SV_StartBug> continue ; <S2SV_EndBug> } if ( ignore_updelay ) slave -> delay = 0 ; if ( slave -> delay <= 0 ) { slave -> new_link = BOND_LINK_UP ; commit ++ ; ignore_updelay = false ; continue ; } slave -> delay -- ; break ; } } return commit ; }
|
<S2SV_ModStart> name ) ; commit ++ ; <S2SV_ModStart> name ) ; commit ++ ;
|
8,048 |
CWE-000 int avtab_write_item ( struct policydb * p , struct avtab_node * cur , void * fp ) { __le16 buf16 [ 4 ] ; __le32 buf32 [ ARRAY_SIZE ( cur -> datum . u . ops -> op . perms ) ] ; int rc ; unsigned int i ; buf16 [ 0 ] = cpu_to_le16 ( cur -> key . source_type ) ; buf16 [ 1 ] = cpu_to_le16 ( cur -> key . target_type ) ; buf16 [ 2 ] = cpu_to_le16 ( cur -> key . target_class ) ; buf16 [ 3 ] = cpu_to_le16 ( cur -> key . specified ) ; rc = put_entry ( buf16 , sizeof ( u16 ) , 4 , fp ) ; if ( rc ) return rc ; if ( cur -> key . specified & AVTAB_OP ) { <S2SV_StartBug> rc = put_entry ( & cur -> datum . u . ops -> type , sizeof ( u8 ) , 1 , fp ) ; <S2SV_EndBug> if ( rc ) return rc ; for ( i = 0 ; i < ARRAY_SIZE ( cur -> datum . u . ops -> op . perms ) ; i ++ ) buf32 [ i ] = cpu_to_le32 ( cur -> datum . u . ops -> op . perms [ i ] ) ; rc = put_entry ( buf32 , sizeof ( u32 ) , ARRAY_SIZE ( cur -> datum . u . ops -> op . perms ) , fp ) ; } else { buf32 [ 0 ] = cpu_to_le32 ( cur -> datum . u . data ) ; rc = put_entry ( buf32 , sizeof ( u32 ) , 1 , fp ) ; } if ( rc ) return rc ; return 0 ; }
|
<S2SV_ModStart> AVTAB_OP ) { <S2SV_ModEnd> for ( i
|
8,049 |
CWE-000 static bool svc_dg_recv ( struct svc_req * req ) { SVCXPRT * xprt = req -> rq_xprt ; <S2SV_StartBug> struct svc_dg_data * su = su_data ( xprt ) ; <S2SV_EndBug> XDR * xdrs = & ( su -> su_xdrs ) ; char * reply ; struct sockaddr_storage ss ; struct sockaddr * sp = ( struct sockaddr * ) & ss ; struct msghdr * mesgp ; struct iovec iov ; size_t replylen ; ssize_t rlen ; rpc_msg_init ( & req -> rq_msg ) ; memset ( & ss , 0xff , sizeof ( struct sockaddr_storage ) ) ; again : iov . iov_base = rpc_buffer ( xprt ) ; iov . iov_len = su -> su_iosz ; mesgp = & su -> su_msghdr ; memset ( mesgp , 0 , sizeof ( * mesgp ) ) ; mesgp -> msg_iov = & iov ; mesgp -> msg_iovlen = 1 ; mesgp -> msg_name = ( struct sockaddr * ) ( void * ) & ss ; sp -> sa_family = ( sa_family_t ) 0xffff ; mesgp -> msg_namelen = sizeof ( struct sockaddr_storage ) ; mesgp -> msg_control = su -> su_cmsg ; mesgp -> msg_controllen = sizeof ( su -> su_cmsg ) ; rlen = recvmsg ( xprt -> xp_fd , mesgp , 0 ) ; if ( sp -> sa_family == ( sa_family_t ) 0xffff ) return false ; if ( rlen == - 1 && errno == EINTR ) goto again ; if ( rlen == - 1 || ( rlen < ( ssize_t ) ( 4 * sizeof ( u_int32_t ) ) ) ) return ( false ) ; __rpc_set_address ( & xprt -> xp_remote , & ss , mesgp -> msg_namelen ) ; if ( ! svc_dg_store_pktinfo ( mesgp , req ) ) { mesgp -> msg_control = NULL ; mesgp -> msg_controllen = 0 ; req -> rq_daddr_len = 0 ; } xdrs -> x_op = XDR_DECODE ; XDR_SETPOS ( xdrs , 0 ) ; if ( ! xdr_callmsg ( xdrs , & req -> rq_msg ) ) return ( false ) ; req -> rq_raddr_len = xprt -> xp_remote . nb . len ; memcpy ( & req -> rq_raddr , xprt -> xp_remote . nb . buf , req -> rq_raddr_len ) ; req -> rq_cksum = # if 1 CityHash64WithSeed ( iov . iov_base , MIN ( 256 , iov . iov_len ) , 103 ) ; # else calculate_crc32c ( 0 , iov . iov_base , MIN ( 256 , iov . iov_len ) ) ; # endif <S2SV_StartBug> su -> su_xid = req -> rq_msg . rm_xid ; <S2SV_EndBug> if ( su -> su_cache != NULL ) { if ( svc_dg_cache_get ( xprt , & req -> rq_msg , & reply , & replylen ) ) { iov . iov_base = reply ; iov . iov_len = replylen ; if ( req -> rq_daddr_len != 0 ) { struct cmsghdr * cmsg ; cmsg = ( struct cmsghdr * ) mesgp -> msg_control ; svc_dg_set_pktinfo ( cmsg , req ) ; # ifndef CMSG_ALIGN # define CMSG_ALIGN ( len ) ( len ) # endif mesgp -> msg_controllen = CMSG_ALIGN ( cmsg -> cmsg_len ) ; } ( void ) sendmsg ( xprt -> xp_fd , mesgp , 0 ) ; return ( false ) ; } } return ( true ) ; }
|
<S2SV_ModStart> rq_xprt ; struct svc_dg_xprt <S2SV_ModEnd> * su = <S2SV_ModStart> ; # endif <S2SV_ModEnd> if ( su
|
8,050 |
CWE-000 static int rndr_autolink ( hoedown_buffer * ob , const hoedown_buffer * link , hoedown_autolink_type type , const hoedown_renderer_data * data ) { hoedown_html_renderer_state * state = data -> opaque ; if ( ! link || ! link -> size ) return 0 ; <S2SV_StartBug> HOEDOWN_BUFPUTSL ( ob , "<a<S2SV_blank>style=\\"max-width:<S2SV_blank>100%;\\"<S2SV_blank><S2SV_blank>href=\\"" ) ; <S2SV_EndBug> if ( type == HOEDOWN_AUTOLINK_EMAIL ) HOEDOWN_BUFPUTSL ( ob , "mailto:" ) ; escape_href ( ob , link -> data , link -> size ) ; if ( state -> link_attributes ) { hoedown_buffer_putc ( ob , \'\\"\' ) ; state -> link_attributes ( ob , link , data ) ; hoedown_buffer_putc ( ob , '>' ) ; } else { HOEDOWN_BUFPUTSL ( ob , "\\">" ) ; } if ( hoedown_buffer_prefix ( link , "mailto:" ) == 0 ) { escape_html ( ob , link -> data + 7 , link -> size - 7 ) ; } else { escape_html ( ob , link -> data , link -> size ) ; } HOEDOWN_BUFPUTSL ( ob , "</a>" ) ; return 1 ; }
|
<S2SV_ModStart> ( ob , "<a<S2SV_blank>class=\\"mylink\\"<S2SV_blank>style=\\"max-width:<S2SV_blank>100%;\\"<S2SV_blank><S2SV_blank>href=\\"" <S2SV_ModEnd> ) ; if
|
8,051 |
CWE-000 static void buoh_finalize ( GObject * object ) { Buoh * buoh = BUOH_BUOH ( object ) ; buoh_debug ( "buoh<S2SV_blank>finalize" ) ; if ( buoh -> priv -> datadir ) { g_free ( buoh -> priv -> datadir ) ; buoh -> priv -> datadir = NULL ; } if ( buoh -> priv -> comic_list ) { g_object_unref ( buoh -> priv -> comic_list ) ; buoh -> priv -> comic_list = NULL ; } <S2SV_StartBug> if ( buoh -> priv -> proxy_uri ) { <S2SV_EndBug> g_free ( buoh -> priv -> proxy_uri ) ; buoh -> priv -> proxy_uri = NULL ; } if ( buoh -> priv -> proxy_settings ) { g_object_unref ( buoh -> priv -> proxy_settings ) ; buoh -> priv -> proxy_settings = NULL ; } if ( G_OBJECT_CLASS ( buoh_parent_class ) -> finalize ) { ( * G_OBJECT_CLASS ( buoh_parent_class ) -> finalize ) ( object ) ; } }
|
<S2SV_ModStart> } if ( <S2SV_ModEnd> G_OBJECT_CLASS ( buoh_parent_class
|
8,052 |
CWE-000 void xavs2_cg_scan_init ( uint32_t cpuid , intrinsic_func_t * pf ) { pf -> transpose_coeff_scan [ LUMA_4x4 ] [ 0 ] = coeff_scan_4x4_xy_c ; pf -> transpose_coeff_scan [ LUMA_4x4 ] [ 1 ] = coeff_scan_4x4_yx_c ; pf -> transpose_coeff_scan [ LUMA_8x8 ] [ 0 ] = coeff_scan_8x8_xy_c ; pf -> transpose_coeff_scan [ LUMA_8x8 ] [ 1 ] = coeff_scan_8x8_yx_c ; pf -> transpose_coeff_scan [ LUMA_16x16 ] [ 0 ] = coeff_scan_16x16_xy_c ; pf -> transpose_coeff_scan [ LUMA_16x16 ] [ 1 ] = coeff_scan_16x16_yx_c ; pf -> transpose_coeff_scan [ LUMA_32x32 ] [ 0 ] = coeff_scan_32x32_xy_c ; pf -> transpose_coeff_scan [ LUMA_32x32 ] [ 1 ] = coeff_scan_32x32_yx_c ; pf -> transpose_coeff_scan [ LUMA_4x16 ] [ 0 ] = coeff_scan_4x16_xy_c ; pf -> transpose_coeff_scan [ LUMA_16x4 ] [ 0 ] = coeff_scan_16x4_xy_c ; pf -> transpose_coeff_scan [ LUMA_8x32 ] [ 0 ] = coeff_scan_8x32_xy_c ; pf -> transpose_coeff_scan [ LUMA_32x8 ] [ 0 ] = coeff_scan_32x8_xy_c ; pf -> transpose_coeff_4x4 [ 0 ] = coeff_scan4_xy_c ; pf -> transpose_coeff_4x4 [ 1 ] = coeff_scan4_yx_c ; # if HAVE_MMX if ( cpuid & XAVS2_CPU_SSE42 ) { pf -> transpose_coeff_scan [ LUMA_4x4 ] [ 0 ] = coeff_scan_4x4_xy_sse128 ; pf -> transpose_coeff_scan [ LUMA_4x4 ] [ 1 ] = coeff_scan_4x4_yx_sse128 ; <S2SV_StartBug> pf -> transpose_coeff_4x4 [ 0 ] = coeff_scan4_xy_sse128 ; <S2SV_EndBug> <S2SV_StartBug> pf -> transpose_coeff_4x4 [ 1 ] = coeff_scan4_yx_sse128 ; <S2SV_EndBug> } if ( cpuid & XAVS2_CPU_AVX2 ) { <S2SV_StartBug> } <S2SV_EndBug> # else UNUSED_PARAMETER ( cpuid ) ; # endif }
|
<S2SV_ModStart> = coeff_scan_4x4_yx_sse128 ; # if ARCH_X86_64 <S2SV_ModStart> = coeff_scan4_yx_sse128 ; # endif <S2SV_ModStart> XAVS2_CPU_AVX2 ) { # if ARCH_X86_64 # endif
|
8,053 |
CWE-000 int _print_job_tres_bind ( job_info_t * job , int width , bool right_justify , char * suffix ) { if ( job == NULL ) { _print_str ( "TRES_BIND" , width , right_justify , true ) ; } else { if ( job -> tres_bind ) _print_str ( job -> tres_bind , width , right_justify , true ) ; else _print_str ( "N/A" , width , right_justify , true ) ; } <S2SV_StartBug> return SLURM_SUCCESS ; <S2SV_EndBug> }
|
<S2SV_ModStart> ) ; } if ( suffix ) printf ( "%s" , suffix ) ;
|
8,054 |
CWE-000 static int acm_pre_reset ( struct usb_interface * intf ) { struct acm * acm = usb_get_intfdata ( intf ) ; clear_bit ( EVENT_RX_STALL , & acm -> flags ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> flags ) ; acm -> nb_index = 0 ;
|
8,055 |
CWE-000 static struct sock * tcp_v6_syn_recv_sock ( struct sock * sk , struct sk_buff * skb , struct request_sock * req , struct dst_entry * dst ) { struct inet6_request_sock * treq ; struct ipv6_pinfo * newnp , * np = inet6_sk ( sk ) ; struct tcp6_sock * newtcp6sk ; struct ipv6_txoptions * opt ; struct inet_sock * newinet ; struct tcp_sock * newtp ; struct sock * newsk ; # ifdef CONFIG_TCP_MD5SIG struct tcp_md5sig_key * key ; # endif if ( skb -> protocol == htons ( ETH_P_IP ) ) { newsk = tcp_v4_syn_recv_sock ( sk , skb , req , dst ) ; if ( newsk == NULL ) return NULL ; newtcp6sk = ( struct tcp6_sock * ) newsk ; inet_sk ( newsk ) -> pinet6 = & newtcp6sk -> inet6 ; newinet = inet_sk ( newsk ) ; newnp = inet6_sk ( newsk ) ; newtp = tcp_sk ( newsk ) ; memcpy ( newnp , np , sizeof ( struct ipv6_pinfo ) ) ; ipv6_addr_set_v4mapped ( newinet -> inet_daddr , & newnp -> daddr ) ; ipv6_addr_set_v4mapped ( newinet -> inet_saddr , & newnp -> saddr ) ; newnp -> rcv_saddr = newnp -> saddr ; inet_csk ( newsk ) -> icsk_af_ops = & ipv6_mapped ; newsk -> sk_backlog_rcv = tcp_v4_do_rcv ; # ifdef CONFIG_TCP_MD5SIG newtp -> af_specific = & tcp_sock_ipv6_mapped_specific ; # endif newnp -> ipv6_ac_list = NULL ; newnp -> ipv6_fl_list = NULL ; newnp -> pktoptions = NULL ; newnp -> opt = NULL ; newnp -> mcast_oif = inet6_iif ( skb ) ; newnp -> mcast_hops = ipv6_hdr ( skb ) -> hop_limit ; newnp -> rcv_tclass = ipv6_tclass ( ipv6_hdr ( skb ) ) ; tcp_sync_mss ( newsk , inet_csk ( newsk ) -> icsk_pmtu_cookie ) ; return newsk ; } treq = inet6_rsk ( req ) ; opt = np -> opt ; if ( sk_acceptq_is_full ( sk ) ) goto out_overflow ; if ( ! dst ) { dst = inet6_csk_route_req ( sk , req ) ; if ( ! dst ) goto out ; } newsk = tcp_create_openreq_child ( sk , req , skb ) ; if ( newsk == NULL ) goto out_nonewsk ; newsk -> sk_gso_type = SKB_GSO_TCPV6 ; __ip6_dst_store ( newsk , dst , NULL , NULL ) ; newtcp6sk = ( struct tcp6_sock * ) newsk ; inet_sk ( newsk ) -> pinet6 = & newtcp6sk -> inet6 ; newtp = tcp_sk ( newsk ) ; newinet = inet_sk ( newsk ) ; newnp = inet6_sk ( newsk ) ; memcpy ( newnp , np , sizeof ( struct ipv6_pinfo ) ) ; newnp -> daddr = treq -> rmt_addr ; newnp -> saddr = treq -> loc_addr ; newnp -> rcv_saddr = treq -> loc_addr ; newsk -> sk_bound_dev_if = treq -> iif ; newinet -> inet_opt = NULL ; newnp -> ipv6_ac_list = NULL ; newnp -> ipv6_fl_list = NULL ; newnp -> rxopt . all = np -> rxopt . all ; newnp -> pktoptions = NULL ; if ( treq -> pktopts != NULL ) { newnp -> pktoptions = skb_clone ( treq -> pktopts , GFP_ATOMIC ) ; kfree_skb ( treq -> pktopts ) ; treq -> pktopts = NULL ; if ( newnp -> pktoptions ) skb_set_owner_r ( newnp -> pktoptions , newsk ) ; } newnp -> opt = NULL ; newnp -> mcast_oif = inet6_iif ( skb ) ; newnp -> mcast_hops = ipv6_hdr ( skb ) -> hop_limit ; newnp -> rcv_tclass = ipv6_tclass ( ipv6_hdr ( skb ) ) ; opt = rcu_dereference ( np -> opt ) ; if ( opt ) { opt = ipv6_dup_options ( newsk , opt ) ; RCU_INIT_POINTER ( newnp -> opt , opt ) ; } inet_csk ( newsk ) -> icsk_ext_hdr_len = 0 ; if ( opt ) inet_csk ( newsk ) -> icsk_ext_hdr_len = opt -> opt_nflen + opt -> opt_flen ; tcp_mtup_init ( newsk ) ; tcp_sync_mss ( newsk , dst_mtu ( dst ) ) ; newtp -> advmss = dst_metric_advmss ( dst ) ; if ( tcp_sk ( sk ) -> rx_opt . user_mss && tcp_sk ( sk ) -> rx_opt . user_mss < newtp -> advmss ) newtp -> advmss = tcp_sk ( sk ) -> rx_opt . user_mss ; tcp_initialize_rcv_mss ( newsk ) ; if ( tcp_rsk ( req ) -> snt_synack ) tcp_valid_rtt_meas ( newsk , tcp_time_stamp - tcp_rsk ( req ) -> snt_synack ) ; newtp -> total_retrans = req -> retrans ; newinet -> inet_daddr = newinet -> inet_saddr = LOOPBACK4_IPV6 ; newinet -> inet_rcv_saddr = LOOPBACK4_IPV6 ; # ifdef CONFIG_TCP_MD5SIG if ( ( key = tcp_v6_md5_do_lookup ( sk , & newnp -> daddr ) ) != NULL ) { tcp_md5_do_add ( newsk , ( union tcp_md5_addr * ) & newnp -> daddr , AF_INET6 , key -> key , key -> keylen , GFP_ATOMIC ) ; } # endif if ( __inet_inherit_port ( sk , newsk ) < 0 ) { <S2SV_StartBug> sock_put ( newsk ) ; <S2SV_EndBug> goto out ; } __inet6_hash ( newsk , NULL ) ; return newsk ; out_overflow : NET_INC_STATS_BH ( sock_net ( sk ) , LINUX_MIB_LISTENOVERFLOWS ) ; out_nonewsk : if ( opt && opt != np -> opt ) sock_kfree_s ( sk , opt , opt -> tot_len ) ; dst_release ( dst ) ; out : NET_INC_STATS_BH ( sock_net ( sk ) , LINUX_MIB_LISTENDROPS ) ; return NULL ; }
|
<S2SV_ModStart> 0 ) { inet_csk_prepare_forced_close ( newsk ) ; tcp_done <S2SV_ModEnd> ( newsk )
|
8,056 |
CWE-000 StgTSO * createThread ( Capability * cap , W_ size ) { StgTSO * tso ; StgStack * stack ; nat stack_size ; ResourceContainer * rc ; if ( cap -> r . rCurrentTSO == NULL ) { rc = RC_MAIN ; <S2SV_StartBug> } else { <S2SV_EndBug> <S2SV_StartBug> rc = newRC ( cap -> r . rCurrentTSO -> rc , 0 ) ; <S2SV_EndBug> } if ( size < MIN_STACK_WORDS + sizeofW ( StgStack ) + sizeofW ( StgTSO ) ) { size = MIN_STACK_WORDS + sizeofW ( StgStack ) + sizeofW ( StgTSO ) ; } stack_size = round_to_mblocks ( size - sizeofW ( StgTSO ) ) ; stack = ( StgStack * ) allocate ( cap , stack_size ) ; TICK_ALLOC_STACK ( stack_size ) ; SET_HDR ( stack , & stg_STACK_info , cap -> r . rCCCS ) ; stack -> stack_size = stack_size - sizeofW ( StgStack ) ; stack -> sp = stack -> stack + stack -> stack_size ; stack -> dirty = 1 ; tso = ( StgTSO * ) allocate ( cap , sizeofW ( StgTSO ) ) ; TICK_ALLOC_TSO ( ) ; SET_HDR ( tso , & stg_TSO_info , CCS_SYSTEM ) ; tso -> what_next = ThreadRunGHC ; tso -> why_blocked = NotBlocked ; tso -> block_info . closure = ( StgClosure * ) END_TSO_QUEUE ; tso -> blocked_exceptions = END_BLOCKED_EXCEPTIONS_QUEUE ; tso -> bq = ( StgBlockingQueue * ) END_TSO_QUEUE ; tso -> flags = 0 ; tso -> dirty = 1 ; tso -> _link = END_TSO_QUEUE ; tso -> saved_errno = 0 ; tso -> bound = NULL ; tso -> cap = cap ; tso -> stackobj = stack ; tso -> tot_stack_size = stack -> stack_size ; tso -> rc = rc ; ASSIGN_Int64 ( ( W_ * ) & ( tso -> alloc_limit ) , 0 ) ; tso -> trec = NO_TREC ; # ifdef PROFILING tso -> prof . cccs = CCS_MAIN ; # endif stack -> sp -= sizeofW ( StgStopFrame ) ; SET_HDR ( ( StgClosure * ) stack -> sp , ( StgInfoTable * ) & stg_stop_thread_info , CCS_SYSTEM ) ; ACQUIRE_LOCK ( & sched_mutex ) ; tso -> id = next_thread_id ++ ; tso -> global_link = g0 -> threads ; g0 -> threads = tso ; RELEASE_LOCK ( & sched_mutex ) ; traceEventCreateThread ( cap , tso ) ; return tso ; }
|
<S2SV_ModStart> = RC_MAIN ; debugTrace ( DEBUG_sched , "Parent<S2SV_blank>is<S2SV_blank>RC_MAIN" ) ; <S2SV_ModStart> rCurrentTSO -> rc ) ; debugTrace ( DEBUG_sched , "Parent<S2SV_blank>is<S2SV_blank>not<S2SV_blank>RC_MAIN" <S2SV_ModEnd> ) ; }
|
8,057 |
CWE-000 int <S2SV_StartBug> processHeader ( char header [ ( MAX_LINE_LENGTH - 1 ) / 2 ] [ MAX_LINE_LENGTH ] <S2SV_EndBug> , int numField ) { const char * name1 = "name" ; const char * name2 = "\\"name\\"" ; int nameField = - 1 ; for ( int i = 0 ; i < numField ; i ++ ) { if ( strcmp ( header [ i ] , name1 ) == 0 || strcmp ( header [ i ] , name2 ) == 0 ) { if ( nameField != - 1 ) { nameField = - 1 ; break ; } nameField = i ; } } return nameField ; }
|
<S2SV_ModStart> ) / 2 + 1
|
8,058 |
CWE-000 <S2SV_StartBug> int guest_irq_handler ( uint32_t irq , void * data ) <S2SV_EndBug> { struct vcpu * vcpu ; struct virq_desc * desc = ( struct virq_desc * ) data ; if ( ( ! desc ) || ( ! desc -> hw ) ) return - EINVAL ; vcpu = get_vcpu_by_id ( desc -> vmid , desc -> vcpu_id ) ; if ( ! vcpu ) return - ENOENT ; return __send_virq ( vcpu , desc -> vno , irq , 1 ) ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static
|
8,059 |
CWE-000 static void mandel_calcul ( t_mandel * m , int x ) { double tmp ; <S2SV_StartBug> unsigned long i ; <S2SV_EndBug> int y ; y = - 1 ; while ( ++ y < Y_WIN ) { m -> c_r = x / m -> zoom_x + m -> x1 ; m -> c_i = y / m -> zoom_y + m -> y1 ; m -> z_r = 0 ; m -> z_i = 0 ; i = 0 ; while ( ( m -> z_r * m -> z_r + m -> z_i * m -> z_i < 4 && i < m -> ite_max ) || i == 0 ) { tmp = m -> z_r ; m -> z_r = m -> z_r * m -> z_r - m -> z_i * m -> z_i + m -> c_r ; m -> z_i = 2 * m -> z_i * tmp + m -> c_i ; i ++ ; } if ( i != m -> ite_max && check_draw ( x , y , X_WIN , Y_WIN ) == 1 ) m -> img . data [ y * X_WIN + x ] = set_color ( * m , i ) ; } }
|
<S2SV_ModStart> double tmp ; <S2SV_ModEnd> long i ;
|
8,060 |
CWE-000 void ex_helpgrep ( exarg_T * eap ) { regmatch_T regmatch ; char_u * save_cpo ; char_u * p ; int fcount ; char_u * * fnames ; FILE * fd ; int fi ; long lnum ; char_u * lang ; qf_info_T * qi = & ql_info ; int new_qi = FALSE ; char_u * au_name = NULL ; lang = check_help_lang ( eap -> arg ) ; switch ( eap -> cmdidx ) { case CMD_helpgrep : au_name = ( char_u * ) "helpgrep" ; break ; case CMD_lhelpgrep : au_name = ( char_u * ) "lhelpgrep" ; break ; default : break ; } if ( au_name != NULL && apply_autocmds ( EVENT_QUICKFIXCMDPRE , au_name , curbuf -> b_fname , true , curbuf ) ) { if ( aborting ( ) ) { return ; } } save_cpo = p_cpo ; p_cpo = empty_option ; if ( eap -> cmdidx == CMD_lhelpgrep ) { qi = NULL ; FOR_ALL_WINDOWS_IN_TAB ( wp , curtab ) { if ( wp -> w_buffer != NULL && wp -> w_buffer -> b_help ) { qi = wp -> w_llist ; } } if ( qi == NULL ) { qi = ll_new_list ( ) ; new_qi = TRUE ; } } <S2SV_StartBug> regmatch . regprog = vim_regcomp ( eap -> arg , RE_MAGIC + RE_STRING ) ; <S2SV_EndBug> regmatch . rm_ic = FALSE ; if ( regmatch . regprog != NULL ) { vimconv_T vc ; vc . vc_type = CONV_NONE ; if ( ! enc_utf8 ) convert_setup ( & vc , ( char_u * ) "utf-8" , p_enc ) ; qf_new_list ( qi , * eap -> cmdlinep ) ; p = p_rtp ; while ( * p != NUL && ! got_int ) { copy_option_part ( & p , NameBuff , MAXPATHL , "," ) ; add_pathsep ( ( char * ) NameBuff ) ; STRCAT ( NameBuff , "doc/*.\\\\(txt\\\\|??x\\\\)" ) ; char_u * buff_list [ 1 ] = { NameBuff } ; if ( gen_expand_wildcards ( 1 , buff_list , & fcount , & fnames , EW_FILE | EW_SILENT ) == OK && fcount > 0 ) { for ( fi = 0 ; fi < fcount && ! got_int ; ++ fi ) { if ( lang != NULL && STRNICMP ( lang , fnames [ fi ] + STRLEN ( fnames [ fi ] ) - 3 , 2 ) != 0 && ! ( STRNICMP ( lang , "en" , 2 ) == 0 && STRNICMP ( "txt" , fnames [ fi ] + STRLEN ( fnames [ fi ] ) - 3 , 3 ) == 0 ) ) continue ; fd = mch_fopen ( ( char * ) fnames [ fi ] , "r" ) ; if ( fd != NULL ) { lnum = 1 ; while ( ! vim_fgets ( IObuff , IOSIZE , fd ) && ! got_int ) { char_u * line = IObuff ; if ( vc . vc_type != CONV_NONE && has_non_ascii ( IObuff ) ) { line = string_convert ( & vc , IObuff , NULL ) ; if ( line == NULL ) line = IObuff ; } if ( vim_regexec ( & regmatch , line , ( colnr_T ) 0 ) ) { int l = ( int ) STRLEN ( line ) ; while ( l > 0 && line [ l - 1 ] <= '<S2SV_blank>' ) line [ -- l ] = NUL ; if ( qf_add_entry ( qi , NULL , fnames [ fi ] , 0 , line , lnum , ( int ) ( regmatch . startp [ 0 ] - line ) + 1 , false , NULL , 0 , 1 , true ) == FAIL ) { got_int = true ; if ( line != IObuff ) { xfree ( line ) ; } break ; } } if ( line != IObuff ) xfree ( line ) ; ++ lnum ; line_breakcheck ( ) ; } fclose ( fd ) ; } } FreeWild ( fcount , fnames ) ; } } vim_regfree ( regmatch . regprog ) ; if ( vc . vc_type != CONV_NONE ) convert_setup ( & vc , NULL , NULL ) ; qi -> qf_lists [ qi -> qf_curlist ] . qf_nonevalid = FALSE ; qi -> qf_lists [ qi -> qf_curlist ] . qf_ptr = qi -> qf_lists [ qi -> qf_curlist ] . qf_start ; qi -> qf_lists [ qi -> qf_curlist ] . qf_index = 1 ; } if ( p_cpo == empty_option ) p_cpo = save_cpo ; else free_string_option ( save_cpo ) ; qf_update_buffer ( qi , NULL ) ; if ( au_name != NULL ) { apply_autocmds ( EVENT_QUICKFIXCMDPOST , au_name , <S2SV_StartBug> curbuf -> b_fname , TRUE , curbuf ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! new_qi && qi != & ql_info && qf_find_buf ( qi ) == NULL ) <S2SV_EndBug> return ; } if ( qi -> qf_lists [ qi -> qf_curlist ] . qf_count > 0 ) qf_jump ( qi , 0 , 0 , FALSE ) ; else EMSG2 ( _ ( e_nomatch2 ) , eap -> arg ) ; if ( eap -> cmdidx == CMD_lhelpgrep ) { if ( ! curwin -> w_buffer -> b_help || curwin -> w_llist == qi ) { if ( new_qi ) ll_free_all ( & qi ) ; } else if ( curwin -> w_llist == NULL ) curwin -> w_llist = qi ; } }
|
<S2SV_ModStart> ; } } qf_info_T * save_qi = qi ; <S2SV_ModStart> -> b_fname , true <S2SV_ModEnd> , curbuf ) <S2SV_ModStart> && qi != save_qi <S2SV_ModEnd> && qf_find_buf ( <S2SV_ModStart> == NULL ) { return ; } <S2SV_ModEnd> } if (
|
8,061 |
CWE-000 int main ( int argc , char * * argv ) { int i , maxi , maxfd , listenfd , connfd , sockfd ; int nready , client [ FD_SETSIZE ] ; ssize_t n ; fd_set rset , allset ; <S2SV_StartBug> char buf [ MAXLINE ] ; <S2SV_EndBug> char sendbuf [ BUFMAX ] ; char recvbuf [ BUFMAX ] ; struct clientProfile clientProfiles [ FD_SETSIZE ] ; socklen_t clilen ; struct sockaddr_in cliaddr , servaddr ; <S2SV_StartBug> listenfd = Socket ( AF_INET , SOCK_STREAM , 0 ) ; <S2SV_EndBug> bzero ( & servaddr , sizeof ( servaddr ) ) ; servaddr . sin_family = AF_INET ; servaddr . sin_addr . s_addr = htonl ( INADDR_ANY ) ; randomBind ( listenfd , & servaddr , sizeof ( servaddr ) ) ; <S2SV_StartBug> Listen ( listenfd , LISTENQ ) ; <S2SV_EndBug> maxfd = listenfd ; maxi = - 1 ; for ( i = 0 ; i < FD_SETSIZE ; i ++ ) client [ i ] = - 1 ; FD_ZERO ( & allset ) ; FD_SET ( listenfd , & allset ) ; for ( ; ; ) { rset = allset ; <S2SV_StartBug> nready = Select ( maxfd + 1 , & rset , NULL , NULL , NULL ) ; <S2SV_EndBug> if ( FD_ISSET ( listenfd , & rset ) ) { clilen = sizeof ( cliaddr ) ; <S2SV_StartBug> connfd = Accept ( listenfd , ( SA * ) & cliaddr , & clilen ) ; <S2SV_EndBug> for ( i = 0 ; i < FD_SETSIZE ; i ++ ) if ( client [ i ] < 0 ) { client [ i ] = connfd ; strcpy ( clientProfiles [ i ] . name , "anonymous" ) ; clientProfiles [ i ] . port = ntohs ( cliaddr . sin_port ) ; inet_ntop ( AF_INET , & cliaddr . sin_addr , clientProfiles [ i ] . ip_addr , INET_ADDRSTRLEN ) ; break ; } if ( i == FD_SETSIZE ) <S2SV_StartBug> err_quit ( "too<S2SV_blank>many<S2SV_blank>clients" ) ; <S2SV_EndBug> sendHelloMsg ( i , client , clientProfiles , sendbuf ) ; FD_SET ( connfd , & allset ) ; if ( connfd > maxfd ) maxfd = connfd ; if ( i > maxi ) maxi = i ; if ( -- nready <= 0 ) continue ; } for ( i = 0 ; i <= maxi ; i ++ ) { if ( ( sockfd = client [ i ] ) < 0 ) continue ; if ( FD_ISSET ( sockfd , & rset ) ) { <S2SV_StartBug> if ( ( n = Read ( sockfd , recvbuf , BUFMAX ) ) == 0 ) { <S2SV_EndBug> <S2SV_StartBug> Close ( sockfd ) ; <S2SV_EndBug> FD_CLR ( sockfd , & allset ) ; client [ i ] = - 1 ; sendOfflineMsg ( i , client , clientProfiles , sendbuf ) ; } else { char * command [ MAX_PARAM_NUM ] ; char * errorMsg ; int numOfParam = parseCommand ( n , recvbuf , command ) ; if ( checkCommand ( numOfParam , command , & errorMsg ) ) { execCommand ( command , i , client , clientProfiles , sendbuf ) ; } else { sendErrorMsg ( sockfd , errorMsg ) ; } } if ( -- nready <= 0 ) break ; } } } }
|
<S2SV_ModStart> allset ; char <S2SV_ModEnd> sendbuf [ BUFMAX <S2SV_ModStart> ; listenfd = socket <S2SV_ModEnd> ( AF_INET , <S2SV_ModStart> ) ) ; listen <S2SV_ModEnd> ( listenfd , <S2SV_ModStart> ; nready = select <S2SV_ModEnd> ( maxfd + <S2SV_ModStart> ; connfd = accept <S2SV_ModEnd> ( listenfd , <S2SV_ModStart> == FD_SETSIZE ) { printf ( "[ERROR]<S2SV_blank>Too<S2SV_blank>many<S2SV_blank>clients\\n" ) ; } <S2SV_ModEnd> sendHelloMsg ( i <S2SV_ModStart> ( n = read <S2SV_ModEnd> ( sockfd , <S2SV_ModStart> 0 ) { close <S2SV_ModEnd> ( sockfd )
|
8,062 |
CWE-000 void sys_mutex_lock ( sys_mutex_t * mutex ) { <S2SV_StartBug> sys_arch_sem_wait ( * mutex , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> mutex ) { if ( sys_mutex_valid ( mutex ) ) { while ( xSemaphoreTake <S2SV_ModEnd> ( * mutex <S2SV_ModStart> * mutex , portMAX_DELAY ) != pdTRUE <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } }
|
8,063 |
CWE-000 VOS_STATUS WLANBAP_TxCompCB ( v_PVOID_t pvosGCtx , vos_pkt_t * vosDataBuff , VOS_STATUS wTxSTAtus ) { VOS_STATUS vosStatus ; ptBtampHandle bapHdl ; ptBtampContext bapContext ; v_PVOID_t pHddHdl ; v_PVOID_t pvlogLinkHandle = NULL ; uintptr_t value ; WLANBAP_HCIACLHeaderType hciACLHeader ; bapHdl = ( v_PVOID_t ) gpBtampCtx ; bapContext = ( ( ptBtampContext ) bapHdl ) ; if ( NULL == vosDataBuff ) { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_ERROR , "Invalid<S2SV_blank>vosDataBuff<S2SV_blank>value<S2SV_blank>in<S2SV_blank>%s" , __func__ ) ; return VOS_STATUS_E_FAULT ; } if ( NULL == bapContext ) { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_ERROR , "Invalid<S2SV_blank>bapContext<S2SV_blank>value<S2SV_blank>in<S2SV_blank>%s" , __func__ ) ; vos_pkt_return_packet ( vosDataBuff ) ; return VOS_STATUS_E_FAULT ; } pHddHdl = bapContext -> pHddHdl ; vosStatus = VOS_STATUS_SUCCESS ; if ( VOS_STATUS_SUCCESS != vosStatus ) { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_INFO , "Unable<S2SV_blank>to<S2SV_blank>retrieve<S2SV_blank>BSL<S2SV_blank>or<S2SV_blank>BAP<S2SV_blank>context<S2SV_blank>from<S2SV_blank>STA<S2SV_blank>Id<S2SV_blank>in<S2SV_blank>WLANBAP_TxCompCB" ) ; vos_pkt_return_packet ( vosDataBuff ) ; return VOS_STATUS_E_FAULT ; } vos_pkt_get_user_data_ptr ( vosDataBuff , VOS_PKT_USER_DATA_ID_BAP , & pvlogLinkHandle ) ; value = ( uintptr_t ) pvlogLinkHandle ; hciACLHeader . logLinkHandle = value ; # ifdef BAP_DEBUG VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_INFO_HIGH , <S2SV_StartBug> "WLAN<S2SV_blank>BAP<S2SV_blank>Context<S2SV_blank>Monitor:<S2SV_blank>bapContext<S2SV_blank>value<S2SV_blank>=<S2SV_blank>%p<S2SV_blank>in<S2SV_blank>%s:%d.<S2SV_blank>vosDataBuff=%p" , bapContext , __func__ , __LINE__ , vosDataBuff ) ; <S2SV_EndBug> # endif if ( BTAMP_VALID_LOG_LINK ( hciACLHeader . logLinkHandle ) ) { vos_atomic_increment_U32 ( & bapContext -> btampLogLinkCtx [ hciACLHeader . logLinkHandle ] . uTxPktCompleted ) ; } else { VOS_TRACE ( VOS_MODULE_ID_BAP , VOS_TRACE_LEVEL_ERROR , "In<S2SV_blank>%s:%d:<S2SV_blank>Invalid<S2SV_blank>logical<S2SV_blank>link<S2SV_blank>handle:<S2SV_blank>%d" , __func__ , __LINE__ , hciACLHeader . logLinkHandle ) ; } vosStatus = ( * bapContext -> pfnBtampTxCompCB ) ( pHddHdl , vosDataBuff , wTxSTAtus ) ; return vosStatus ; }
|
<S2SV_ModStart> , VOS_TRACE_LEVEL_INFO_HIGH , "WLAN<S2SV_blank>BAP<S2SV_blank>Context<S2SV_blank>Monitor:<S2SV_blank>bapContext<S2SV_blank>value<S2SV_blank>=<S2SV_blank>%pK<S2SV_blank>in<S2SV_blank>%s:%d.<S2SV_blank>vosDataBuff=%pK" <S2SV_ModEnd> , bapContext ,
|
8,064 |
CWE-000 EngineMessage settings_screen_event_handler ( SDL_Event * event , SettingsScreen * settings_screen , SettingsScreenEvent * settings_screen_event ) { ButtonEvent button_event ; settings_screen_event -> type = SETTINGS_SCREEN_NO_EVENT ; switch ( settings_screen -> stage ) { case MODE_STAGE : multiple_choice_event_handler ( event , settings_screen -> mode ) ; break ; case DIFFICULTY_STAGE : multiple_choice_event_handler ( event , settings_screen -> difficulty ) ; break ; case COLOR_STAGE : multiple_choice_event_handler ( event , settings_screen -> color ) ; break ; } button_event_handler ( event , settings_screen -> next_button , & button_event ) ; if ( is_next_button_visible ( settings_screen ) && button_event . type == BUTTON_PUSHED ) { if ( settings_screen -> stage == MODE_STAGE ) { settings_screen -> stage = DIFFICULTY_STAGE ; } else if ( settings_screen -> stage == DIFFICULTY_STAGE ) { settings_screen -> stage = COLOR_STAGE ; } } button_event_handler ( event , settings_screen -> start_button , & button_event ) ; if ( is_start_button_visible ( settings_screen ) && button_event . type == BUTTON_PUSHED ) { settings_screen_event -> type = SETTINGS_SCREEN_NEW_GAME ; if ( settings_screen -> mode -> choice == 0 ) { settings_screen_event -> data . settings . mode = ONE_PLAYER ; settings_screen_event -> data . settings . difficulty = 1 + settings_screen -> difficulty -> choice ; settings_screen_event -> data . settings . player1_color = ( settings_screen -> color -> choice == 0 ) ? WHITE : BLACK ; } else { settings_screen_event -> data . settings . mode = TWO_PLAYER ; settings_screen_event -> data . settings . difficulty = 1 ; settings_screen_event -> data . settings . player1_color = WHITE ; } } button_event_handler ( event , settings_screen -> back_button , & button_event ) ; if ( button_event . type == BUTTON_PUSHED ) { if ( settings_screen -> stage == COLOR_STAGE ) { settings_screen -> stage = DIFFICULTY_STAGE ; } else if ( settings_screen -> stage == DIFFICULTY_STAGE ) { settings_screen -> stage = MODE_STAGE ; } else if ( settings_screen -> stage == MODE_STAGE ) { <S2SV_StartBug> settings_screen_event -> type = SETTINGS_SCREEN_EXIT ; <S2SV_EndBug> } } return SUCCESS ; }
|
<S2SV_ModStart> MODE_STAGE ) { reset_settings_screen ( settings_screen ) ;
|
8,065 |
CWE-000 struct xns_object * apply ( struct xns_object * fn , struct xns_object * env , struct xns_object * args ) { if ( fn -> type == XNS_FUNCTION ) { xns_gc_register ( fn -> vm , & fn ) ; xns_gc_register ( fn -> vm , & env ) ; xns_gc_register ( fn -> vm , & args ) ; struct xns_object * newenv = xns_make_env ( fn -> vm , fn -> env ) ; xns_gc_register ( fn -> vm , & newenv ) ; newenv -> vars = xns_pair ( fn -> args , evlis ( args , env ) ) ; struct xns_object * ret = eval ( fn -> body , newenv ) ; xns_gc_unregister ( fn -> vm , & fn ) ; xns_gc_unregister ( fn -> vm , & env ) ; xns_gc_unregister ( fn -> vm , & args ) ; xns_gc_unregister ( fn -> vm , & newenv ) ; return ret ; } else if ( fn -> type == XNS_MACRO ) { xns_gc_register ( fn -> vm , & fn ) ; xns_gc_register ( fn -> vm , & args ) ; struct xns_object * ret = eval ( macroexpand ( fn , env , args ) , env ) ; xns_gc_unregister ( fn -> vm , & fn ) ; xns_gc_unregister ( fn -> vm , & args ) ; return ret ; } else if ( fn -> type == XNS_PRIMITIVE ) { <S2SV_StartBug> return fn -> primitive ( fn -> vm , env , args ) ; <S2SV_EndBug> } else if ( fn -> type == XNS_FOREIGN_FUNC ) { return fn -> foreign_fcn ( args , env ) ; } else if ( fn -> type == XNS_HANDLE ) { return apply ( fn -> ptr , env , args ) ; } else { return fn ; } }
|
<S2SV_ModStart> XNS_PRIMITIVE ) { printf ( "PRIMITIVE\\n" ) ;
|
8,066 |
CWE-000 int main ( void ) { <S2SV_StartBug> SCB -> CPACR |= 0b1111 << 20 ; <S2SV_EndBug> FPU -> FPCCR |= 0b11 << 30 ; asm volatile ( "DSB" ) ; asm volatile ( "ISB" ) ; struct ClockConfig clock_config = { 168000000 , 168000000 , 42000000 , 84000000 , 8000000 } ; <S2SV_StartBug> ClockConfig ( & clock_config ) ; <S2SV_EndBug> BareOSSchedulerInit ( 1000 , 0 ) ; NvicEnableInterrupt ( TIM6_DAC_IRQn ) ; struct TimerConfig system_config = { . tick_frequency = 10000 } ; BareOSTimerInit ( & TIMER6_OBJECT , & system_config ) ; BareOSTimerStart ( ) ; struct BareOSThread * blink1_thread = BareOSThreadCreateThread ( blink1_mem , & blink1 , 0 , 500 ) ; struct BareOSThread * blink2_thread = BareOSThreadCreateThread ( blink2_mem , & blink2 , 0 , 500 ) ; struct BareOSThread * blink3_thread = BareOSThreadCreateThread ( blink3_mem , & blink3 , 0 , 500 ) ; struct BareOSThread * spi_thread = BareOSThreadCreateThread ( spi_memory , & spi , 0 , 500 ) ; BareOSSchedulerAddThread ( blink1_thread ) ; BareOSSchedulerAddThread ( blink2_thread ) ; BareOSSchedulerAddThread ( blink3_thread ) ; BareOSSchedulerAddThread ( spi_thread ) ; while ( 1 ) { BareOSTimerDelayPolled ( 1000 ) ; } return 1 ; }
|
<S2SV_ModStart> void ) { <S2SV_ModEnd> struct ClockConfig clock_config <S2SV_ModStart> ( & clock_config <S2SV_ModEnd> ) ; NvicEnableInterrupt
|
8,067 |
CWE-000 void do_rev_rotate ( t_stack * * stack ) { t_stack * old_head ; t_stack * last_node ; t_stack * previous ; int count ; old_head = * stack ; previous = * stack ; last_node = ( * stack ) -> next ; count = 0 ; while ( last_node -> next ) { previous = previous -> next ; last_node = last_node -> next ; count ++ ; } if ( count > 0 ) last_node -> next = old_head -> next ; else <S2SV_StartBug> last_node -> next = old_head ; <S2SV_EndBug> last_node -> prev = NULL ; <S2SV_StartBug> previous -> next = old_head ; <S2SV_EndBug> old_head -> next = NULL ; <S2SV_StartBug> old_head -> prev = previous ; <S2SV_EndBug> * stack = last_node ; }
|
<S2SV_ModStart> next ; else old_head -> next = NULL ; <S2SV_ModStart> -> next = <S2SV_ModEnd> NULL ; old_head <S2SV_ModStart> -> prev = last_node <S2SV_ModEnd> ; * stack
|
8,068 |
CWE-000 static void exec_process ( t_vm * vm , t_process * ps ) <S2SV_StartBug> { <S2SV_EndBug> do_op ( vm , ps , ( int ) vm -> memory [ ps -> pc ] ) ; }
|
<S2SV_ModStart> ps ) { ft_printf ( "Executing<S2SV_blank>process<S2SV_blank>%d,<S2SV_blank>pc<S2SV_blank>=><S2SV_blank>%d\\n" , ps -> number , ps -> pc ) ;
|
8,069 |
CWE-000 static ssize_t intel_spi_read ( struct spi_nor * nor , loff_t from , size_t len , u_char * read_buf ) { struct intel_spi * ispi = nor -> priv ; size_t block_size , retlen = 0 ; u32 val , status ; <S2SV_StartBug> ssize_t ret ; <S2SV_EndBug> switch ( nor -> read_opcode ) { case SPINOR_OP_READ : case SPINOR_OP_READ_FAST : break ; default : return - EINVAL ; } while ( len > 0 ) { block_size = min_t ( size_t , len , INTEL_SPI_FIFO_SZ ) ; writel ( from , ispi -> base + FADDR ) ; val = readl ( ispi -> base + HSFSTS_CTL ) ; val &= ~ ( HSFSTS_CTL_FDBC_MASK | HSFSTS_CTL_FCYCLE_MASK ) ; val |= HSFSTS_CTL_AEL | HSFSTS_CTL_FCERR | HSFSTS_CTL_FDONE ; val |= ( block_size - 1 ) << HSFSTS_CTL_FDBC_SHIFT ; val |= HSFSTS_CTL_FCYCLE_READ ; val |= HSFSTS_CTL_FGO ; writel ( val , ispi -> base + HSFSTS_CTL ) ; ret = intel_spi_wait_hw_busy ( ispi ) ; if ( ret ) return ret ; status = readl ( ispi -> base + HSFSTS_CTL ) ; if ( status & HSFSTS_CTL_FCERR ) ret = - EIO ; else if ( status & HSFSTS_CTL_AEL ) ret = - EACCES ; if ( ret < 0 ) { dev_err ( ispi -> dev , "read<S2SV_blank>error:<S2SV_blank>%llx:<S2SV_blank>%#x\\n" , from , status ) ; return ret ; } ret = intel_spi_read_block ( ispi , read_buf , block_size ) ; if ( ret ) return ret ; len -= block_size ; from += block_size ; retlen += block_size ; read_buf += block_size ; } return retlen ; }
|
<S2SV_ModStart> ; ssize_t ret ; if ( WARN_ON_ONCE ( ispi -> atomic_preopcode ) ) ispi -> atomic_preopcode = 0
|
8,070 |
CWE-000 int __send_ack ( struct sockaddr_in * server_sockaddr ) { <S2SV_StartBug> struct comm_packet packet ; <S2SV_EndBug> int status ; packet . type = COMM_PTYPE_ACK ; bzero ( packet . payload , COMM_PPAYLOAD_LENGTH ) ; if ( __send_packet ( server_sockaddr , & packet ) != 0 ) { log_error ( "comm" , "Ack<S2SV_blank>could<S2SV_blank>not<S2SV_blank>be<S2SV_blank>sent" ) ; return - 1 ; } return 0 ; }
|
<S2SV_ModStart> struct comm_packet packet <S2SV_ModEnd> ; packet .
|
8,071 |
CWE-000 void link_val ( t_lemin map ) { if ( dash_cnt ( map . first ) != 1 ) std_err ( ) ; <S2SV_StartBug> if ( name_val ( map . map , map , first ) == 0 ) <S2SV_EndBug> std_err ( ) ; else ft_putstr ( "Linking<S2SV_blank>is<S2SV_blank>OK" ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> map , map . <S2SV_ModEnd> first ) == <S2SV_ModStart> "Linking<S2SV_blank>is<S2SV_blank>OK" ) ; return ;
|
8,072 |
CWE-000 t_lst * split_keep_empty ( char * str , char sep ) { int start ; int i ; char c ; t_lst * lst ; i = - 1 ; c = 1 ; start = 0 ; lst = list_new ( ) ; while ( str [ ++ i ] ) if ( str [ i ] == sep ) { list_add ( lst , str_alloc_cpy ( str , start , i - start - 1 + c ) ) ; <S2SV_StartBug> c = 0 ; <S2SV_EndBug> start = i + 1 ; } list_add ( lst , str_alloc_cpy ( str , start , i - start ) ) ; return ( lst ) ; }
|
<S2SV_ModStart> ) ) ; <S2SV_ModEnd> start = i
|
8,073 |
CWE-000 int tlsio_openssl_open ( CONCRETE_IO_HANDLE tls_io , ON_IO_OPEN_COMPLETE on_io_open_complete , void * on_io_open_complete_context , ON_BYTES_RECEIVED on_bytes_received , void * on_bytes_received_context , ON_IO_ERROR on_io_error , void * on_io_error_context ) { int result ; if ( tls_io == NULL ) { result = __LINE__ ; LogError ( "NULL<S2SV_blank>tls_io." ) ; } else { TLS_IO_INSTANCE * tls_io_instance = ( TLS_IO_INSTANCE * ) tls_io ; if ( tls_io_instance -> tlsio_state != TLSIO_STATE_NOT_OPEN ) { <S2SV_StartBug> result = __LINE__ ; <S2SV_EndBug> LogError ( "Invalid<S2SV_blank>tlsio_state.<S2SV_blank>Expected<S2SV_blank>state<S2SV_blank>is<S2SV_blank>TLSIO_STATE_NOT_OPEN." ) ; } else { tls_io_instance -> on_io_open_complete = on_io_open_complete ; tls_io_instance -> on_io_open_complete_context = on_io_open_complete_context ; tls_io_instance -> on_bytes_received = on_bytes_received ; tls_io_instance -> on_bytes_received_context = on_bytes_received_context ; tls_io_instance -> on_io_error = on_io_error ; tls_io_instance -> on_io_error_context = on_io_error_context ; tls_io_instance -> tlsio_state = TLSIO_STATE_OPENING ; if ( create_openssl_instance ( tls_io_instance ) != 0 ) { tls_io_instance -> tlsio_state = TLSIO_STATE_ERROR ; result = __LINE__ ; <S2SV_StartBug> } <S2SV_EndBug> else { <S2SV_StartBug> send_handshake_bytes ( tls_io_instance ) ; <S2SV_EndBug> result = 0 ; } } } return result ; }
|
<S2SV_ModStart> TLSIO_STATE_NOT_OPEN ) { tls_io_instance -> tlsio_state = TLSIO_STATE_ERROR ; <S2SV_ModStart> = __LINE__ ; tls_io_instance -> on_io_error ( tls_io_instance -> on_io_error_context ) ; } else { if ( <S2SV_ModEnd> send_handshake_bytes ( tls_io_instance <S2SV_ModStart> ( tls_io_instance ) != 0 ) { tls_io_instance -> tlsio_state = TLSIO_STATE_ERROR ; result = __LINE__ ; tls_io_instance -> on_io_error ( tls_io_instance -> on_io_error_context ) ; } else { result = 0 ; } <S2SV_ModEnd> } } }
|
8,074 |
CWE-000 int qcom_ice_setup_ice_hw ( const char * storage_type , int enable ) { int ret = - 1 ; struct ice_device * ice_dev = NULL ; ice_dev = get_ice_device_from_storage_type ( storage_type ) ; <S2SV_StartBug> if ( ! ice_dev ) <S2SV_EndBug> return ret ; if ( enable ) return enable_ice_setup ( ice_dev ) ; else return disable_ice_setup ( ice_dev ) ; }
|
<S2SV_ModStart> ; if ( ice_dev == ERR_PTR ( - EPROBE_DEFER ) ) return - EPROBE_DEFER ; if (
|
8,075 |
CWE-000 END_TEST START_TCASE ( "Encode<S2SV_blank>buffer" ) { ADD_TEST ( should_encode_with_sufficient_buffer ) ; ADD_TEST ( should_encode_from_offset ) ; ADD_TEST ( should_encode_with_insufficient_buffer ) ; ADD_TEST ( should_encode_at_zero_length_buffer ) ; ADD_TEST ( should_not_build_twice ) ; <S2SV_StartBug> ADD_TEST ( should_handle_build_failure ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> should_not_build_twice ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
|
8,076 |
CWE-000 int main ( void ) { userconfig * config ; config = NULL ; int i ; halInit ( ) ; chSysInit ( ) ; palSetPad ( BLUE_SOLO_LED_PORT , BLUE_SOLO_LED_PIN ) ; palSetPad ( RED_LED_PORT , RED_LED_PIN ) ; palSetPad ( GREEN_LED_PORT , GREEN_LED_PIN ) ; palSetPad ( BLUE_LED_PORT , BLUE_LED_PIN ) ; palClearPad ( BLUE_SOLO_LED_PORT , BLUE_SOLO_LED_PIN ) ; evtTableInit ( orchard_events , 5 ) ; orchardShellInit ( ) ; chprintf ( stream , SHELL_BANNER ) ; chprintf ( stream , "\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>()==[:::::::::::::><S2SV_blank>gitrev<S2SV_blank>%s" , gitversion ) ; chprintf ( stream , "\\r\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\r\\n\\r\\n" , BUILDTIME ) ; flashStart ( ) ; print_mcu_info ( ) ; # if HAL_USE_MMC_SPI pit0Start ( & PIT1 , NULL ) ; # else pit0Start ( & PIT1 , disk_timerproc ) ; # endif dacStart ( & DAC1 ) ; dmaStart ( ) ; pwmStart ( ) ; spiStart ( & SPID1 , & spi1_config ) ; orchardEventsStart ( ) ; radioStart ( & SPID1 ) ; evtTableHook ( orchard_events , shell_terminated , shell_termination_handler ) ; radioDefaultHandlerSet ( radioDriver , default_radio_handler ) ; chprintf ( stream , "User<S2SV_blank>flash<S2SV_blank>start:<S2SV_blank>0x%x<S2SV_blank><S2SV_blank>user<S2SV_blank>flash<S2SV_blank>end:<S2SV_blank>0x%x<S2SV_blank><S2SV_blank>length:<S2SV_blank>0x%x\\r\\n" , __storage_start__ , __storage_end__ , __storage_size__ ) ; palSetPad ( MMC_CHIP_SELECT_PORT , MMC_CHIP_SELECT_PIN ) ; palSetPad ( SCREEN_CHIP_SELECT_PORT , SCREEN_CHIP_SELECT_PIN ) ; palSetPad ( XPT_CHIP_SELECT_PORT , XPT_CHIP_SELECT_PIN ) ; palSetPad ( SCREEN_CMDDATA_PORT , SCREEN_CMDDATA_PIN ) ; palSetPadMode ( SPI1_MISO_PORT , SPI1_MISO_PIN , PAL_MODE_OUTPUT_PUSHPULL ) ; palSetPad ( SPI1_MISO_PORT , SPI1_MISO_PIN ) ; palSetPadMode ( SPI1_MISO_PORT , SPI1_MISO_PIN , PAL_MODE_INPUT_PULLUP ) ; palSetPadMode ( SPI1_MISO_PORT , SPI1_MISO_PIN , PAL_MODE_ALTERNATIVE_2 ) ; palSetPadMode ( SPI1_MOSI_PORT , SPI1_MOSI_PIN , PAL_MODE_OUTPUT_PUSHPULL ) ; palSetPad ( SPI1_MOSI_PORT , SPI1_MOSI_PIN ) ; palSetPadMode ( SPI1_MOSI_PORT , SPI1_MOSI_PIN , PAL_MODE_INPUT_PULLUP ) ; <S2SV_StartBug> palSetPadMode ( SPI1_MOSI_PORT , SPI1_MOSI_PIN , PAL_MODE_ALTERNATIVE_2 ) ; <S2SV_EndBug> # if HAL_USE_MMC_SPI mmcObjectInit ( & MMCD1 ) ; mmcStart ( & MMCD1 , & mmccfg ) ; if ( mmcConnect ( & MMCD1 ) == HAL_SUCCESS ) chprintf ( stream , "SD<S2SV_blank>card<S2SV_blank>detected:<S2SV_blank>%dMB\\r\\n" , mmcsdGetCardCapacity ( & MMCD1 ) >> 11 ) ; else chprintf ( stream , "No<S2SV_blank>SD<S2SV_blank>card<S2SV_blank>found.\\r\\n" ) ; # endif spiStart ( & SPID2 , & spi2_config ) ; # if ! HAL_USE_MMC_SPI if ( mmc_disk_initialize ( ) == 0 ) { chprintf ( stream , "SD<S2SV_blank>card<S2SV_blank>detected.\\r\\n" ) ; } else { gfxInit ( ) ; chprintf ( stream , "No<S2SV_blank>SD<S2SV_blank>card<S2SV_blank>found.\\r\\n" ) ; oledSDFail ( ) ; configStart ( ) ; config = getConfig ( ) ; config -> sound_enabled = 1 ; ledStart ( LEDS_COUNT , led_fb ) ; effectsStart ( ) ; ledSetFunction ( leds_test ) ; playHardFail ( ) ; # ifdef HALT_ON_SDFAIL orchardShellRestart ( ) ; chThdSleep ( TIME_INFINITE ) ; # endif } # endif randInit ( ) ; if ( config == NULL ) { configStart ( ) ; config = getConfig ( ) ; ledStart ( LEDS_COUNT , led_fb ) ; if ( config -> led_pattern > 0 ) { effectsStart ( ) ; } } chprintf ( stream , "HW<S2SV_blank>UDID:<S2SV_blank>0x" ) ; chprintf ( stream , "%08x" , SIM -> UIDMH ) ; chprintf ( stream , "%08x" , SIM -> UIDML ) ; chprintf ( stream , "%08x<S2SV_blank>/<S2SV_blank>netid:<S2SV_blank>%08x\\r\\n" , SIM -> UIDL , config -> netid ) ; gfileMount ( 'F' , "0:" ) ; orchardShellRestart ( ) ; gfxInit ( ) ; uiStart ( ) ; orchardAppInit ( ) ; # ifdef SINGLE_PLAYER # ifdef ENABLE_JOYPAD if ( ( palReadPad ( BUTTON_RIGHT_PORT , BUTTON_RIGHT_PIN ) == 0 ) ) { cmd_peersim ( 0 , 0 , 0 ) ; playTone ( 48 , 100 ) ; playTone ( 52 , 100 ) ; playTone ( 55 , 100 ) ; } # endif # endif oledOrchardBanner ( ) ; # ifndef FAST_STARTUP if ( config -> sound_enabled == 1 ) { playStartupSong ( ) ; # ifdef MAKE_DTMF make_dtmf ( ) ; dacPlay ( "dtmf-0.raw" ) ; dacWait ( ) ; dacPlay ( "dtmf-1.raw" ) ; dacWait ( ) ; dacPlay ( "dtmf-2.raw" ) ; dacWait ( ) ; dacPlay ( "dtmf-3.raw" ) ; dacWait ( ) ; dacPlay ( "dtmf-4.raw" ) ; dacWait ( ) ; # endif chThdSleepMilliseconds ( IMG_SPLASH_DISPLAY_TIME ) ; } else { chThdSleepMilliseconds ( IMG_SPLASH_NO_SOUND_DISPLAY_TIME ) ; } putImageFile ( "dc25lgo.rgb" , 0 , 0 ) ; chThdSleepMilliseconds ( 2000 ) ; ledSetFunction ( leds_shownetid ) ; putImageFile ( "sponsor.rgb" , 0 , 0 ) ; dacWait ( ) ; dacStop ( ) ; i = 0 ; while ( number_sequence [ i ] != 255 ) { tonePlay ( NULL , number_sequence [ i ] , 85 ) ; i ++ ; } chThdSleepMilliseconds ( 2000 ) ; # endif ledSetFunction ( NULL ) ; evtTableHook ( orchard_events , orchard_app_terminated , orchard_app_restart ) ; orchardAppRestart ( ) ; radioHandlerSet ( radioDriver , RADIO_PROTOCOL_PING , radio_ping_handler ) ; chThdSetPriority ( NORMALPRIO + 1 ) ; while ( TRUE ) chEvtDispatch ( evtHandlers ( orchard_events ) , chEvtWaitOne ( ALL_EVENTS ) ) ; }
|
<S2SV_ModStart> , PAL_MODE_ALTERNATIVE_2 ) ; PORTD -> PCR [ SCREEN_CHIP_SELECT_PIN ] |= PORTx_PCRn_PE | PORTx_PCRn_PS
|
8,077 |
CWE-000 static void percent_rankValueFunc ( sqlite3_context * pCtx ) { struct CallCount * p ; p = ( struct CallCount * ) sqlite3_aggregate_context ( pCtx , sizeof ( * p ) ) ; if ( p ) { if ( p -> nTotal > 1 ) { double r = ( double ) ( p -> nValue - 1 ) / ( double ) ( p -> nTotal - 1 ) ; sqlite3_result_double ( pCtx , r ) ; } else { <S2SV_StartBug> sqlite3_result_double ( pCtx , 100.0 ) ; <S2SV_EndBug> } p -> nValue = 0 ; } }
|
<S2SV_ModStart> ( pCtx , 0.0 <S2SV_ModEnd> ) ; }
|
8,078 |
CWE-000 int sys_nice ( ) { <S2SV_StartBug> if ( proc && proc -> priority > 0 ) { <S2SV_EndBug> ( proc -> priority ) -- ; return 0 ; } else return - 1 ; }
|
<S2SV_ModStart> 0 ) { cprintf ( "pid:<S2SV_blank>%d,<S2SV_blank>priority:%d<S2SV_blank>,<S2SV_blank>state:%d\\n" , proc -> pid , proc -> priority , proc -> state ) ;
|
8,079 |
CWE-000 int sock_getsockopt ( struct socket * sock , int level , int optname , char __user * optval , int __user * optlen ) { struct sock * sk = sock -> sk ; union { int val ; struct linger ling ; struct timeval tm ; } v ; int lv = sizeof ( int ) ; int len ; if ( get_user ( len , optlen ) ) return - EFAULT ; if ( len < 0 ) return - EINVAL ; memset ( & v , 0 , sizeof ( v ) ) ; switch ( optname ) { case SO_DEBUG : v . val = sock_flag ( sk , SOCK_DBG ) ; break ; case SO_DONTROUTE : v . val = sock_flag ( sk , SOCK_LOCALROUTE ) ; break ; case SO_BROADCAST : v . val = ! ! sock_flag ( sk , SOCK_BROADCAST ) ; break ; case SO_SNDBUF : v . val = sk -> sk_sndbuf ; break ; case SO_RCVBUF : v . val = sk -> sk_rcvbuf ; break ; case SO_REUSEADDR : v . val = sk -> sk_reuse ; break ; case SO_KEEPALIVE : v . val = ! ! sock_flag ( sk , SOCK_KEEPOPEN ) ; break ; case SO_TYPE : v . val = sk -> sk_type ; break ; case SO_PROTOCOL : v . val = sk -> sk_protocol ; break ; case SO_DOMAIN : v . val = sk -> sk_family ; break ; case SO_ERROR : v . val = - sock_error ( sk ) ; if ( v . val == 0 ) v . val = xchg ( & sk -> sk_err_soft , 0 ) ; break ; case SO_OOBINLINE : v . val = ! ! sock_flag ( sk , SOCK_URGINLINE ) ; break ; case SO_NO_CHECK : v . val = sk -> sk_no_check ; break ; case SO_PRIORITY : v . val = sk -> sk_priority ; break ; case SO_LINGER : lv = sizeof ( v . ling ) ; v . ling . l_onoff = ! ! sock_flag ( sk , SOCK_LINGER ) ; v . ling . l_linger = sk -> sk_lingertime / HZ ; break ; case SO_BSDCOMPAT : sock_warn_obsolete_bsdism ( "getsockopt" ) ; break ; case SO_TIMESTAMP : v . val = sock_flag ( sk , SOCK_RCVTSTAMP ) && ! sock_flag ( sk , SOCK_RCVTSTAMPNS ) ; break ; case SO_TIMESTAMPNS : v . val = sock_flag ( sk , SOCK_RCVTSTAMPNS ) ; break ; case SO_TIMESTAMPING : v . val = 0 ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_TX_HARDWARE ) ) v . val |= SOF_TIMESTAMPING_TX_HARDWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_TX_SOFTWARE ) ) v . val |= SOF_TIMESTAMPING_TX_SOFTWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_RX_HARDWARE ) ) v . val |= SOF_TIMESTAMPING_RX_HARDWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_RX_SOFTWARE ) ) v . val |= SOF_TIMESTAMPING_RX_SOFTWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_SOFTWARE ) ) v . val |= SOF_TIMESTAMPING_SOFTWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_SYS_HARDWARE ) ) v . val |= SOF_TIMESTAMPING_SYS_HARDWARE ; if ( sock_flag ( sk , SOCK_TIMESTAMPING_RAW_HARDWARE ) ) v . val |= SOF_TIMESTAMPING_RAW_HARDWARE ; break ; case SO_RCVTIMEO : lv = sizeof ( struct timeval ) ; if ( sk -> sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT ) { v . tm . tv_sec = 0 ; v . tm . tv_usec = 0 ; } else { v . tm . tv_sec = sk -> sk_rcvtimeo / HZ ; v . tm . tv_usec = ( ( sk -> sk_rcvtimeo % HZ ) * 1000000 ) / HZ ; } break ; case SO_SNDTIMEO : lv = sizeof ( struct timeval ) ; if ( sk -> sk_sndtimeo == MAX_SCHEDULE_TIMEOUT ) { v . tm . tv_sec = 0 ; v . tm . tv_usec = 0 ; } else { v . tm . tv_sec = sk -> sk_sndtimeo / HZ ; v . tm . tv_usec = ( ( sk -> sk_sndtimeo % HZ ) * 1000000 ) / HZ ; } break ; case SO_RCVLOWAT : v . val = sk -> sk_rcvlowat ; break ; case SO_SNDLOWAT : v . val = 1 ; break ; case SO_PASSCRED : <S2SV_StartBug> v . val = test_bit ( SOCK_PASSCRED , & sock -> flags ) ? 1 : 0 ; <S2SV_EndBug> break ; case SO_PEERCRED : { struct ucred peercred ; if ( len > sizeof ( peercred ) ) len = sizeof ( peercred ) ; cred_to_ucred ( sk -> sk_peer_pid , sk -> sk_peer_cred , & peercred , true ) ; if ( copy_to_user ( optval , & peercred , len ) ) return - EFAULT ; goto lenout ; } case SO_PEERNAME : { char address [ 128 ] ; if ( sock -> ops -> getname ( sock , ( struct sockaddr * ) address , & lv , 2 ) ) return - ENOTCONN ; if ( lv < len ) return - EINVAL ; if ( copy_to_user ( optval , address , len ) ) return - EFAULT ; goto lenout ; } case SO_ACCEPTCONN : v . val = sk -> sk_state == TCP_LISTEN ; break ; case SO_PASSSEC : <S2SV_StartBug> v . val = test_bit ( SOCK_PASSSEC , & sock -> flags ) ? 1 : 0 ; <S2SV_EndBug> break ; case SO_PEERSEC : return security_socket_getpeersec_stream ( sock , optval , optlen , len ) ; case SO_MARK : v . val = sk -> sk_mark ; break ; case SO_RXQ_OVFL : v . val = ! ! sock_flag ( sk , SOCK_RXQ_OVFL ) ; break ; default : return - ENOPROTOOPT ; } if ( len > lv ) len = lv ; if ( copy_to_user ( optval , & v , len ) ) return - EFAULT ; lenout : if ( put_user ( len , optlen ) ) return - EFAULT ; return 0 ; }
|
<S2SV_ModStart> . val = ! ! <S2SV_ModStart> -> flags ) <S2SV_ModEnd> ; break ; <S2SV_ModStart> . val = ! ! <S2SV_ModStart> -> flags ) <S2SV_ModEnd> ; break ;
|
8,080 |
CWE-000 <S2SV_StartBug> DEFUN ( cfg_bts_amr_hr_thres2 , cfg_bts_amr_hr_thres2_cmd , <S2SV_EndBug> "amr<S2SV_blank>tch-h<S2SV_blank>threshold<S2SV_blank>(ms|bts)<S2SV_blank><0-63><S2SV_blank><0-63>" , <S2SV_StartBug> AMR_TEXT "Half<S2SV_blank>Rate\\n" AMR_TH_TEXT <S2SV_EndBug> AMR_TH_HELP_STR AMR_TH_HELP_STR ) { get_amr_th_from_arg ( vty , 3 , argv , 0 ) ; return CMD_SUCCESS ; }
|
<S2SV_ModStart> <S2SV_null> DEFUN ( cfg_bts_amr_hr_start_mode , cfg_bts_amr_hr_start_mode_cmd , "amr<S2SV_blank>tch-h<S2SV_blank>start-mode<S2SV_blank>(auto|1|2|3|4)" <S2SV_ModEnd> , AMR_TEXT "Half<S2SV_blank>Rate\\n" <S2SV_ModStart> , AMR_TEXT "Half<S2SV_blank>Rate\\n" AMR_START_TEXT ) { get_amr_start_from_arg ( vty <S2SV_ModEnd> , argv ,
|
8,081 |
CWE-000 void host1x_job_unpin ( struct host1x_job * job ) { unsigned int i ; for ( i = 0 ; i < job -> num_unpins ; i ++ ) { struct host1x_job_unpin_data * unpin = & job -> unpins [ i ] ; host1x_bo_unpin ( unpin -> bo , unpin -> sgt ) ; <S2SV_StartBug> host1x_bo_put ( unpin -> bo ) ; <S2SV_EndBug> } job -> num_unpins = 0 ; if ( job -> gather_copy_size ) dma_free_writecombine ( job -> channel -> dev , job -> gather_copy_size , job -> gather_copy_mapped , job -> gather_copy ) ; }
|
<S2SV_ModStart> sgt ) ; <S2SV_ModEnd> } job ->
|
8,082 |
CWE-000 int main ( int argc , char * * argv ) { <S2SV_StartBug> char * filename ; <S2SV_EndBug> if ( argc < 3 ) { printf ( "We<S2SV_blank>must<S2SV_blank>construct<S2SV_blank>additional<S2SV_blank>pyl..arguments!\\n" ) ; <S2SV_StartBug> printf ( "Usage:<S2SV_blank>./fconc<S2SV_blank>infile1<S2SV_blank>infile2<S2SV_blank>[outfile<S2SV_blank>(default:fconc.out)\\n" ) ; <S2SV_EndBug> exit ( 1 ) ; } else if ( argc == 3 ) { filename = "fconc.out" ; <S2SV_StartBug> } <S2SV_EndBug> else { <S2SV_StartBug> filename = argv [ argc - 1 ] ; <S2SV_EndBug> } int fd , oflags , mode ; oflags = O_CREAT | O_WRONLY | O_TRUNC ; mode = S_IRUSR | S_IWUSR ; fd = open ( filename , oflags , mode ) ; if ( fd < 0 ) { perror ( filename ) ; exit ( 1 ) ; } <S2SV_StartBug> for ( int i = 1 ; i < argc - 1 ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> printf ( "%s\\n" , argv [ i ] ) ; <S2SV_EndBug> <S2SV_StartBug> write_file ( fd , argv [ i ] ) ; <S2SV_EndBug> } if ( close ( fd ) < 0 ) { perror ( "err<S2SV_blank>at<S2SV_blank>output<S2SV_blank>file<S2SV_blank>close" ) ; exit ( 1 ) ; } return 0 ; }
|
<S2SV_ModStart> argv ) { int infiles_n ; <S2SV_ModStart> ; printf ( "Usage:<S2SV_blank>./fconc<S2SV_blank>infile1<S2SV_blank>infile2<S2SV_blank>[outfile<S2SV_blank>(default:fconc.out)]\\n" <S2SV_ModEnd> ) ; exit <S2SV_ModStart> = "fconc.out" ; infiles_n = 2 ; <S2SV_ModStart> - 1 ] ; infiles_n = argc - 2 <S2SV_ModStart> 1 ; i <= infiles_n <S2SV_ModEnd> ; i ++ <S2SV_ModStart> ++ ) { write_file ( fd <S2SV_ModEnd> , argv [ <S2SV_ModStart> ] ) ; <S2SV_ModEnd> } if (
|
8,083 |
CWE-000 static int packet_rcv_fanout ( struct sk_buff * skb , struct net_device * dev , struct packet_type * pt , struct net_device * orig_dev ) { struct packet_fanout * f = pt -> af_packet_priv ; <S2SV_StartBug> unsigned int num = f -> num_members ; <S2SV_EndBug> struct packet_sock * po ; struct sock * sk ; if ( ! net_eq ( dev_net ( dev ) , read_pnet ( & f -> net ) ) || ! num ) { kfree_skb ( skb ) ; return 0 ; } switch ( f -> type ) { case PACKET_FANOUT_HASH : default : if ( f -> defrag ) { skb = ip_check_defrag ( skb , IP_DEFRAG_AF_PACKET ) ; if ( ! skb ) return 0 ; } skb_get_rxhash ( skb ) ; sk = fanout_demux_hash ( f , skb , num ) ; break ; case PACKET_FANOUT_LB : sk = fanout_demux_lb ( f , skb , num ) ; break ; case PACKET_FANOUT_CPU : sk = fanout_demux_cpu ( f , skb , num ) ; break ; } po = pkt_sk ( sk ) ; return po -> prot_hook . func ( skb , dev , & po -> prot_hook , orig_dev ) ; }
|
<S2SV_ModStart> int num = ACCESS_ONCE ( <S2SV_ModStart> f -> num_members )
|
8,084 |
CWE-000 static int s6x0_i2c_transfer ( struct i2c_adapter * adap , struct i2c_msg msg [ ] , int num ) { struct dvb_usb_device * d = i2c_get_adapdata ( adap ) ; struct usb_device * udev ; <S2SV_StartBug> int len , i , j ; <S2SV_EndBug> if ( ! d ) return - ENODEV ; udev = d -> udev ; if ( mutex_lock_interruptible ( & d -> i2c_mutex ) < 0 ) return - EAGAIN ; for ( j = 0 ; j < num ; j ++ ) { switch ( msg [ j ] . addr ) { case ( DW2102_RC_QUERY ) : { u8 ibuf [ 5 ] ; dw210x_op_rw ( d -> udev , 0xb8 , 0 , 0 , ibuf , 5 , DW210X_READ_MSG ) ; memcpy ( msg [ j ] . buf , ibuf + 3 , 2 ) ; break ; } case ( DW2102_VOLTAGE_CTRL ) : { u8 obuf [ 2 ] ; obuf [ 0 ] = 1 ; obuf [ 1 ] = msg [ j ] . buf [ 1 ] ; dw210x_op_rw ( d -> udev , 0x8a , 0 , 0 , obuf , 2 , DW210X_WRITE_MSG ) ; obuf [ 0 ] = 3 ; obuf [ 1 ] = msg [ j ] . buf [ 0 ] ; dw210x_op_rw ( d -> udev , 0x8a , 0 , 0 , obuf , 2 , DW210X_WRITE_MSG ) ; break ; } case ( DW2102_LED_CTRL ) : { u8 obuf [ 2 ] ; obuf [ 0 ] = 5 ; obuf [ 1 ] = msg [ j ] . buf [ 0 ] ; dw210x_op_rw ( d -> udev , 0x8a , 0 , 0 , obuf , 2 , DW210X_WRITE_MSG ) ; break ; } default : { if ( msg [ j ] . flags == I2C_M_RD ) { u8 ibuf [ MAX_XFER_SIZE ] ; if ( msg [ j ] . len > sizeof ( ibuf ) ) { warn ( "i2c<S2SV_blank>rd:<S2SV_blank>len=%d<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big!\\n" , msg [ j ] . len ) ; <S2SV_StartBug> return - EOPNOTSUPP ; <S2SV_EndBug> } dw210x_op_rw ( d -> udev , 0x91 , 0 , 0 , ibuf , msg [ j ] . len , DW210X_READ_MSG ) ; memcpy ( msg [ j ] . buf , ibuf , msg [ j ] . len ) ; break ; } else if ( ( msg [ j ] . buf [ 0 ] == 0xb0 ) && ( msg [ j ] . addr == 0x68 ) ) { u8 obuf [ 19 ] ; obuf [ 0 ] = ( msg [ j ] . len > 16 ? 18 : msg [ j ] . len + 1 ) ; obuf [ 1 ] = msg [ j ] . addr << 1 ; obuf [ 2 ] = msg [ j ] . buf [ 0 ] ; len = msg [ j ] . len - 1 ; i = 1 ; do { memcpy ( obuf + 3 , msg [ j ] . buf + i , ( len > 16 ? 16 : len ) ) ; dw210x_op_rw ( d -> udev , 0x80 , 0 , 0 , obuf , ( len > 16 ? 16 : len ) + 3 , DW210X_WRITE_MSG ) ; i += 16 ; len -= 16 ; } while ( len > 0 ) ; } else if ( j < ( num - 1 ) ) { u8 obuf [ MAX_XFER_SIZE ] ; if ( 2 + msg [ j ] . len > sizeof ( obuf ) ) { warn ( "i2c<S2SV_blank>wr:<S2SV_blank>len=%d<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big!\\n" , msg [ j ] . len ) ; <S2SV_StartBug> return - EOPNOTSUPP ; <S2SV_EndBug> } obuf [ 0 ] = msg [ j + 1 ] . len ; obuf [ 1 ] = ( msg [ j ] . addr << 1 ) ; memcpy ( obuf + 2 , msg [ j ] . buf , msg [ j ] . len ) ; dw210x_op_rw ( d -> udev , udev -> descriptor . idProduct == 0x7500 ? 0x92 : 0x90 , 0 , 0 , obuf , msg [ j ] . len + 2 , DW210X_WRITE_MSG ) ; break ; } else { u8 obuf [ MAX_XFER_SIZE ] ; if ( 2 + msg [ j ] . len > sizeof ( obuf ) ) { warn ( "i2c<S2SV_blank>wr:<S2SV_blank>len=%d<S2SV_blank>is<S2SV_blank>too<S2SV_blank>big!\\n" , msg [ j ] . len ) ; <S2SV_StartBug> return - EOPNOTSUPP ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> obuf [ 0 ] = msg [ j ] . len + 1 ; obuf [ 1 ] = ( msg [ j ] . addr << 1 ) ; memcpy ( obuf + 2 , msg [ j ] . buf , msg [ j ] . len ) ; dw210x_op_rw ( d -> udev , 0x80 , 0 , 0 , obuf , msg [ j ] . len + 2 , DW210X_WRITE_MSG ) ; break ; } break ; } } } <S2SV_StartBug> mutex_unlock ( & d -> i2c_mutex ) ; <S2SV_EndBug> <S2SV_StartBug> return num ; <S2SV_EndBug> }
|
<S2SV_ModStart> i , j , ret <S2SV_ModStart> len ) ; ret = - EOPNOTSUPP ; goto unlock <S2SV_ModEnd> ; } dw210x_op_rw <S2SV_ModStart> len ) ; ret = - EOPNOTSUPP ; goto unlock <S2SV_ModEnd> ; } obuf <S2SV_ModStart> len ) ; ret = <S2SV_ModEnd> - EOPNOTSUPP ; <S2SV_ModStart> - EOPNOTSUPP ; goto unlock ; <S2SV_ModStart> } } } ret = num ; unlock : <S2SV_ModStart> ) ; return ret <S2SV_ModEnd> ; } <S2SV_null>
|
8,085 |
CWE-000 static PyObject * eval_wrapper ( PyObject * self , PyObject * args ) { PyObject * in1 ; PyObject * in2 ; PyObject * challenges ; PyObject * weights ; PyArg_ParseTuple ( args , "OO:" , & in1 , & in2 ) ; challenges = PyArray_FROM_OTF ( in1 , NPY_NOTYPE , NPY_IN_ARRAY ) ; weights = PyArray_FROM_OTF ( in2 , NPY_NOTYPE , NPY_IN_ARRAY ) ; uint64_t * dim_c = ( uint64_t * ) PyArray_DIMS ( challenges ) ; uint64_t * dim_w = ( uint64_t * ) PyArray_DIMS ( weights ) ; uint64_t N_c = * ( dim_c ) ; uint64_t k_c = * ( dim_c + 1 ) ; uint64_t n_c = * ( dim_c + 2 ) ; uint64_t k_w = * ( dim_w ) ; uint64_t n_w = * ( dim_w + 1 ) ; <S2SV_StartBug> if ( ( n_c - n_w ) ) <S2SV_EndBug> return Py_BuildValue ( "i" , - 2 ) ; <S2SV_StartBug> if ( ( k_c - k_w ) ) <S2SV_EndBug> return Py_BuildValue ( "i" , - 2 ) ; int64_t * dptr_c = ( int64_t * ) ( PyArray_DATA ( challenges ) ) ; double * dptr_w = ( double * ) ( PyArray_DATA ( weights ) ) ; int64_t * res = NULL ; eval ( dptr_c , dptr_w , n_w , k_w , N_c , & res ) ; npy_intp dims [ 2 ] = { N_c , k_c } ; PyObject * ret = PyArray_SimpleNewFromData ( 2 , dims , NPY_INT64 , res ) ; Py_INCREF ( ret ) ; PyArray_ENABLEFLAGS ( ( PyArrayObject * ) ret , NPY_ARRAY_OWNDATA ) ; return ret ; }
|
<S2SV_ModStart> ; if ( <S2SV_ModEnd> n_c - n_w <S2SV_ModStart> n_c - n_w <S2SV_ModEnd> ) return Py_BuildValue <S2SV_ModStart> ; if ( <S2SV_ModEnd> k_c - k_w <S2SV_ModStart> k_c - k_w <S2SV_ModEnd> ) return Py_BuildValue
|
8,086 |
CWE-000 static int unit_file_find_dirs ( const char * original_root , Set * unit_path_cache , const char * unit_path , const char * name , const char * suffix , char * * * dirs ) { _cleanup_free_ char * prefix = NULL , * instance = NULL , * built = NULL ; bool is_instance , chopped ; const char * dash ; UnitType type ; char * path ; size_t n ; int r ; assert ( unit_path ) ; assert ( name ) ; assert ( suffix ) ; path = strjoina ( unit_path , "/" , name , suffix ) ; if ( ! unit_path_cache || set_get ( unit_path_cache , path ) ) { r = unit_file_find_dir ( original_root , path , dirs ) ; if ( r < 0 ) return r ; } is_instance = unit_name_is_valid ( name , UNIT_NAME_INSTANCE ) ; if ( is_instance ) { _cleanup_free_ char * template = NULL ; r = unit_name_template ( name , & template ) ; if ( r < 0 ) return log_error_errno ( r , "Failed<S2SV_blank>to<S2SV_blank>generate<S2SV_blank>template<S2SV_blank>from<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%m" ) ; r = unit_file_find_dirs ( original_root , unit_path_cache , unit_path , template , suffix , dirs ) ; if ( r < 0 ) return r ; } r = unit_name_to_prefix ( name , & prefix ) ; if ( r < 0 ) return log_error_errno ( r , "Failed<S2SV_blank>to<S2SV_blank>derive<S2SV_blank>unit<S2SV_blank>name<S2SV_blank>prefix<S2SV_blank>from<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%m" ) ; chopped = false ; for ( ; ; ) { dash = strrchr ( prefix , '-' ) ; if ( ! dash ) return 0 ; n = ( size_t ) ( dash - prefix ) ; if ( n == 0 ) return 0 ; if ( prefix [ n + 1 ] != 0 || chopped ) { prefix [ n + 1 ] = 0 ; break ; } prefix [ n ] = 0 ; chopped = true ; } if ( ! unit_prefix_is_valid ( prefix ) ) return 0 ; type = unit_name_to_type ( name ) ; if ( type < 0 ) { <S2SV_StartBug> log_error ( "Failed<S2SV_blank>to<S2SV_blank>to<S2SV_blank>derive<S2SV_blank>unit<S2SV_blank>type<S2SV_blank>from<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%m" ) ; <S2SV_EndBug> return - EINVAL ; } if ( is_instance ) { r = unit_name_to_instance ( name , & instance ) ; if ( r < 0 ) return log_error_errno ( r , "Failed<S2SV_blank>to<S2SV_blank>derive<S2SV_blank>unit<S2SV_blank>name<S2SV_blank>instance<S2SV_blank>from<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%m" ) ; } r = unit_name_build_from_type ( prefix , instance , type , & built ) ; if ( r < 0 ) return log_error_errno ( r , "Failed<S2SV_blank>to<S2SV_blank>build<S2SV_blank>prefix<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%m" ) ; return unit_file_find_dirs ( original_root , unit_path_cache , unit_path , built , suffix , dirs ) ; }
|
<S2SV_ModStart> { log_error ( "Failed<S2SV_blank>to<S2SV_blank>to<S2SV_blank>derive<S2SV_blank>unit<S2SV_blank>type<S2SV_blank>from<S2SV_blank>unit<S2SV_blank>name:<S2SV_blank>%s" , name <S2SV_ModEnd> ) ; return
|
8,087 |
CWE-000 static struct iahwc_backend * iahwc_backend_create ( struct weston_compositor * compositor , struct weston_iahwc_backend_config * config ) { struct iahwc_backend * b ; void * iahwc_dl_handle ; iahwc_module_t * iahwc_module ; iahwc_device_t * iahwc_device ; <S2SV_StartBug> const char * device = "/dev/dri/card0" ; <S2SV_EndBug> const char * seat_id = default_seat ; fprintf ( stderr , "initializing<S2SV_blank>iahwc<S2SV_blank>backend\\n" ) ; b = zalloc ( sizeof * b ) ; if ( b == NULL ) return NULL ; b -> compositor = compositor ; compositor -> backend = & b -> base ; compositor -> capabilities |= WESTON_CAP_CURSOR_PLANE ; iahwc_dl_handle = dlopen ( "libhwcomposer.so" , RTLD_NOW ) ; if ( ! iahwc_dl_handle ) { weston_log ( "Unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>libhwcomposer.so:<S2SV_blank>%s\\n" , dlerror ( ) ) ; weston_log ( "aborting...\\n" ) ; abort ( ) ; } iahwc_module = ( iahwc_module_t * ) dlsym ( iahwc_dl_handle , IAHWC_MODULE_STR ) ; fprintf ( stderr , "hwc<S2SV_blank>open<S2SV_blank>called<S2SV_blank>\\n" ) ; iahwc_module -> open ( iahwc_module , & iahwc_device ) ; b -> iahwc_module = iahwc_module ; b -> iahwc_device = iahwc_device ; b -> iahwc_get_num_displays = ( IAHWC_PFN_GET_NUM_DISPLAYS ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_GET_NUM_DISPLAYS ) ; b -> iahwc_create_layer = ( IAHWC_PFN_CREATE_LAYER ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_CREATE_LAYER ) ; b -> iahwc_destroy_layer = ( IAHWC_PFN_DESTROY_LAYER ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DESTROY_LAYER ) ; b -> iahwc_get_display_info = ( IAHWC_PFN_DISPLAY_GET_INFO ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_GET_INFO ) ; b -> iahwc_get_display_configs = ( IAHWC_PFN_DISPLAY_GET_CONFIGS ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_GET_CONFIGS ) ; b -> iahwc_get_display_name = ( IAHWC_PFN_DISPLAY_GET_NAME ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_GET_NAME ) ; b -> iahwc_set_display_gamma = ( IAHWC_PFN_DISPLAY_SET_GAMMA ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_SET_GAMMA ) ; b -> iahwc_set_display_config = ( IAHWC_PFN_DISPLAY_SET_CONFIG ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_SET_CONFIG ) ; b -> iahwc_get_display_config = ( IAHWC_PFN_DISPLAY_GET_CONFIG ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_GET_CONFIG ) ; b -> iahwc_display_clear_all_layers = ( IAHWC_PFN_DISPLAY_CLEAR_ALL_LAYERS ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_DISPLAY_CLEAR_ALL_LAYERS ) ; b -> iahwc_present_display = ( IAHWC_PFN_PRESENT_DISPLAY ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_PRESENT_DISPLAY ) ; b -> iahwc_layer_set_bo = ( IAHWC_PFN_LAYER_SET_BO ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_BO ) ; b -> iahwc_layer_set_raw_pixel_data = ( IAHWC_PFN_LAYER_SET_RAW_PIXEL_DATA ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_RAW_PIXEL_DATA ) ; b -> iahwc_layer_set_acquire_fence = ( IAHWC_PFN_LAYER_SET_ACQUIRE_FENCE ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_ACQUIRE_FENCE ) ; b -> iahwc_layer_set_source_crop = ( IAHWC_PFN_LAYER_SET_SOURCE_CROP ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_SOURCE_CROP ) ; b -> iahwc_layer_set_display_frame = ( IAHWC_PFN_LAYER_SET_DISPLAY_FRAME ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_DISPLAY_FRAME ) ; b -> iahwc_layer_set_surface_damage = ( IAHWC_PFN_LAYER_SET_SURFACE_DAMAGE ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_SURFACE_DAMAGE ) ; b -> iahwc_layer_set_usage = ( IAHWC_PFN_LAYER_SET_USAGE ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_LAYER_SET_USAGE ) ; b -> iahwc_register_callback = ( IAHWC_PFN_REGISTER_CALLBACK ) iahwc_device -> getFunctionPtr ( iahwc_device , IAHWC_FUNC_REGISTER_CALLBACK ) ; if ( parse_gbm_format ( config -> gbm_format , GBM_FORMAT_XRGB8888 , & b -> gbm_format ) < 0 ) goto err_compositor ; compositor -> launcher = weston_launcher_connect ( compositor , config -> tty , seat_id , true ) ; if ( compositor -> launcher == NULL ) { weston_log ( "fatal:<S2SV_blank>drm<S2SV_blank>backend<S2SV_blank>should<S2SV_blank>be<S2SV_blank>run<S2SV_blank>" "using<S2SV_blank>weston-launch<S2SV_blank>binary<S2SV_blank>or<S2SV_blank>as<S2SV_blank>root\\n" ) ; goto err_compositor ; } <S2SV_StartBug> b -> iahwc . fd = weston_launcher_open ( b -> compositor -> launcher , device , O_RDWR ) ; <S2SV_EndBug> if ( b -> iahwc . fd < 0 ) { weston_log ( "unable<S2SV_blank>to<S2SV_blank>open<S2SV_blank>gpu<S2SV_blank>file\\n" ) ; goto err_compositor ; } b -> udev = udev_new ( ) ; if ( b -> udev == NULL ) { weston_log ( "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>udev<S2SV_blank>context\\n" ) ; goto err_compositor ; } if ( config -> seat_id ) seat_id = config -> seat_id ; if ( create_outputs ( b ) < 0 ) { weston_log ( "failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>output" ) ; goto err_compositor ; } b -> session_listener . notify = session_notify ; wl_signal_add ( & compositor -> session_signal , & b -> session_listener ) ; if ( init_egl ( b ) < 0 ) { weston_log ( "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>egl\\n" ) ; goto err_compositor ; } b -> cursor_width = 256 ; b -> cursor_height = 256 ; b -> base . destroy = iahwc_destroy ; b -> base . restore = iahwc_restore ; b -> base . repaint_begin = iahwc_repaint_begin ; b -> base . repaint_flush = iahwc_repaint_flush ; b -> base . repaint_cancel = iahwc_repaint_cancel ; if ( udev_input_init ( & b -> input , compositor , b -> udev , seat_id , config -> configure_device ) < 0 ) { weston_log ( "failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>input<S2SV_blank>devices\\n" ) ; goto err_compositor ; } weston_setup_vt_switch_bindings ( compositor ) ; weston_compositor_add_debug_binding ( compositor , KEY_O , planes_binding , b ) ; weston_compositor_add_debug_binding ( compositor , KEY_C , planes_binding , b ) ; weston_compositor_add_debug_binding ( compositor , KEY_V , planes_binding , b ) ; weston_compositor_add_debug_binding ( compositor , KEY_W , renderer_switch_binding , b ) ; if ( compositor -> renderer -> import_dmabuf ) { if ( linux_dmabuf_setup ( compositor ) < 0 ) weston_log ( "Error:<S2SV_blank>initializing<S2SV_blank>dmabuf<S2SV_blank>" "support<S2SV_blank>failed.\\n" ) ; } int ret = weston_plugin_api_register ( compositor , WESTON_IAHWC_OUTPUT_API_NAME , & api , sizeof ( api ) ) ; if ( ret ) goto err_compositor ; return b ; err_compositor : weston_compositor_shutdown ( compositor ) ; free ( b ) ; return NULL ; }
|
<S2SV_ModStart> * device = "/dev/dri/renderD128" <S2SV_ModEnd> ; const char <S2SV_ModStart> . fd = open ( <S2SV_ModEnd> device , O_RDWR
|
8,088 |
CWE-000 static void fm_hci_exit ( void * arg ) { struct fm_hci_t * hci = ( struct fm_hci_t * ) arg ; ALOGE ( "%s" , __func__ ) ; lib_running = 0 ; ready_events = HC_EVENT_EXIT ; hci -> command_credits = 0 ; serial_port_close ( hci ) ; power ( hci , FM_RADIO_DISABLE ) ; vendor_close ( hci ) ; pthread_cond_broadcast ( & hci -> event_cond ) ; pthread_cond_broadcast ( & hci -> cmd_credits_cond ) ; <S2SV_StartBug> stop_rx_thread ( hci ) ; <S2SV_EndBug> stop_tx_thread ( hci ) ; ALOGD ( "Tx,<S2SV_blank>Rx<S2SV_blank>Threads<S2SV_blank>join<S2SV_blank>done" ) ; pthread_mutex_destroy ( & hci -> tx_q_lock ) ; pthread_mutex_destroy ( & hci -> credit_lock ) ; pthread_mutex_destroy ( & hci -> event_lock ) ; pthread_cond_destroy ( & hci -> event_cond ) ; pthread_cond_destroy ( & hci -> cmd_credits_cond ) ; free ( hci ) ; hci = NULL ; }
|
<S2SV_ModStart> cmd_credits_cond ) ; event_notification ( hci , HC_EVENT_EXIT_DONE ) ;
|
8,089 |
CWE-000 void akes_revocation_revoke_node ( const linkaddr_t * addr_revoke ) { <S2SV_StartBug> LOG_INFO ( "revokation_send_revoke\\n" ) ; <S2SV_EndBug> traversal_index = 0 ; addr_revoke_node = * addr_revoke ; struct traversal_entry * new_entry ; struct akes_nbr_entry * next ; next = akes_nbr_head ( ) ; while ( next ) { if ( next -> refs [ AKES_NBR_PERMANENT ] ) { new_entry = memb_alloc ( & traversal_memb ) ; memcpy ( & new_entry -> addr , akes_nbr_get_addr ( next ) , LINKADDR_SIZE ) ; <S2SV_StartBug> new_entry -> parent = NULL ; <S2SV_EndBug> <S2SV_StartBug> list_add ( traversal_list , new_entry ) ; <S2SV_EndBug> process_node ( new_entry ) ; } next = akes_nbr_next ( next ) ; } }
|
<S2SV_ModStart> { LOG_INFO ( "revokation_send_revoke<S2SV_blank>for<S2SV_blank>node:<S2SV_blank>" ) ; LOG_INFO_LLADDR ( addr_revoke ) ; LOG_INFO_ ( "\\n" <S2SV_ModEnd> ) ; traversal_index <S2SV_ModStart> ; new_entry -> next <S2SV_ModEnd> = NULL ; <S2SV_ModStart> traversal_list , new_entry ) ; LOG_INFO ( "Going<S2SV_blank>to<S2SV_blank>send<S2SV_blank>revocation<S2SV_blank>message<S2SV_blank>to<S2SV_blank>" ) ; LOG_INFO_LLADDR ( & new_entry -> addr ) ; LOG_INFO_ ( "\\n"
|
8,090 |
CWE-000 int PE_ ( bin_pe_get_actual_checksum ) ( struct PE_ ( r_bin_pe_obj_t ) * bin ) { int i , j , checksum_offset = 0 ; ut8 * buf = NULL ; ut64 computed_cs = 0 ; int remaining_bytes ; int shift ; ut32 cur ; if ( ! bin || ! bin -> nt_header_offset ) { return 0 ; } buf = bin -> b -> buf ; checksum_offset = bin -> nt_header_offset + 4 + sizeof ( PE_ ( image_file_header ) ) + 0x40 ; for ( i = 0 ; i < bin -> size / 4 ; i ++ ) { <S2SV_StartBug> cur = ( ( ut32 ) buf [ i * 4 ] << 0 ) | <S2SV_EndBug> ( ( ut32 ) buf [ i * 4 + 1 ] << 8 ) | ( ( ut32 ) buf [ i * 4 + 2 ] << 16 ) | ( ( ut32 ) buf [ i * 4 + 3 ] << 24 ) ; if ( i * 4 == checksum_offset ) { continue ; } computed_cs = ( computed_cs & 0xFFFFFFFF ) + cur + ( computed_cs >> 32 ) ; if ( computed_cs >> 32 ) { computed_cs = ( computed_cs & 0xFFFFFFFF ) + ( computed_cs >> 32 ) ; } } remaining_bytes = bin -> size % 4 ; i = i * 4 ; if ( remaining_bytes != 0 ) { cur = buf [ i ] ; shift = 8 ; for ( j = 1 ; j < remaining_bytes ; j ++ , shift += 8 ) { cur |= buf [ i + j ] << shift ; } computed_cs = ( computed_cs & 0xFFFFFFFF ) + cur + ( computed_cs >> 32 ) ; if ( computed_cs >> 32 ) { computed_cs = ( computed_cs & 0xFFFFFFFF ) + ( computed_cs >> 32 ) ; } } computed_cs = ( computed_cs & 0xFFFF ) + ( computed_cs >> 16 ) ; computed_cs = ( computed_cs ) + ( computed_cs >> 16 ) ; computed_cs = ( computed_cs & 0xFFFF ) ; computed_cs += bin -> size ; return computed_cs ; }
|
<S2SV_ModStart> { cur = r_read_le32 ( & <S2SV_ModEnd> buf [ i <S2SV_ModStart> * 4 ] <S2SV_ModEnd> ) ; if
|
8,091 |
CWE-000 void compute_end_statistics ( ) { int i = 0 , type ; for ( type = 0 ; type < 5 ; type ++ ) { end_mean -> service [ type ] = batch_stat [ 0 ] . service [ type ] ; for ( i = 1 ; i < batch_number ; i ++ ) { <S2SV_StartBug> double mean = update_running_mean ( & end_mean -> service [ type ] , batch_stat [ i ] . service [ type ] , i ) ; <S2SV_EndBug> <S2SV_StartBug> update_running_sample_sum_sd ( & end_std -> service [ type ] , mean , batch_stat [ i ] . service [ type ] , i ) ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> end_std -> service [ type ] = sqrt ( end_std -> service [ type ] / i ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> ++ ) { end_mean -> service [ type ] <S2SV_ModEnd> = update_running_mean ( <S2SV_ModStart> = update_running_mean ( <S2SV_ModEnd> end_mean -> service <S2SV_ModStart> i ) ; end_std -> service [ type ] = update_running_sample_sum_sd ( <S2SV_ModEnd> end_std -> service <S2SV_ModStart> type ] , end_mean -> service [ type ] <S2SV_ModEnd> , batch_stat [ <S2SV_ModStart> ) ; } <S2SV_ModEnd> end_std -> service <S2SV_ModStart> = sqrt ( 1.0 * <S2SV_ModStart> ) ; } }
|
8,092 |
CWE-000 static void usage ( int error ) { if ( error == 1 ) { <S2SV_StartBug> puts ( "Error,<S2SV_blank>to<S2SV_blank>few<S2SV_blank>arguments." ) ; <S2SV_EndBug> puts ( "" ) ; } <S2SV_StartBug> puts ( "Usage:" ) ; <S2SV_EndBug> puts ( "<S2SV_blank><S2SV_blank>sipserv<S2SV_blank>[options]" ) ; puts ( "" ) ; puts ( "Commandline:" ) ; puts ( "Mandatory<S2SV_blank>options:" ) ; puts ( "<S2SV_blank><S2SV_blank>--config-file=string<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>config<S2SV_blank>file" ) ; puts ( "" ) ; puts ( "Optional<S2SV_blank>options:" ) ; <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>-s=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Silent<S2SV_blank>mode<S2SV_blank>(hide<S2SV_blank>info<S2SV_blank>messages)<S2SV_blank>(0/1)" ) ; <S2SV_EndBug> puts ( "" ) ; puts ( "" ) ; puts ( "Config<S2SV_blank>file:" ) ; puts ( "Mandatory<S2SV_blank>options:" ) ; puts ( "<S2SV_blank><S2SV_blank>sd=string<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>sip<S2SV_blank>provider<S2SV_blank>domain." ) ; puts ( "<S2SV_blank><S2SV_blank>su=string<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>sip<S2SV_blank>username." ) ; puts ( "<S2SV_blank><S2SV_blank>sp=string<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>sip<S2SV_blank>password." ) ; <S2SV_StartBug> puts ( "" ) ; <S2SV_EndBug> puts ( "<S2SV_blank>and<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>dtmf<S2SV_blank>configuration<S2SV_blank>(X<S2SV_blank>=<S2SV_blank>dtmf-key<S2SV_blank>index):" ) ; <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>dtmf.X.active=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>dtmf-setting<S2SV_blank>active<S2SV_blank>(0/1)." ) ; <S2SV_EndBug> puts ( "<S2SV_blank><S2SV_blank>dtmf.X.description=string<S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>description." ) ; puts ( "<S2SV_blank><S2SV_blank>dtmf.X.tts-intro=string<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>tts<S2SV_blank>intro." ) ; puts ( "<S2SV_blank><S2SV_blank>dtmf.X.tts-answer=string<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>tts<S2SV_blank>answer." ) ; puts ( "<S2SV_blank><S2SV_blank>dtmf.X.cmd=string<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>dtmf<S2SV_blank>command." ) ; puts ( "" ) ; puts ( "Optional<S2SV_blank>options:" ) ; <S2SV_StartBug> puts ( "<S2SV_blank><S2SV_blank>rc=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Record<S2SV_blank>call<S2SV_blank>(0/1)" ) ; <S2SV_EndBug> puts ( "" ) ; fflush ( stdout ) ; }
|
<S2SV_ModStart> { puts ( "Error,<S2SV_blank>too<S2SV_blank>few<S2SV_blank>arguments." <S2SV_ModEnd> ) ; puts <S2SV_ModStart> ) ; } if ( error == 2 ) { puts ( "Missing<S2SV_blank>mandatory<S2SV_blank>items<S2SV_blank>in<S2SV_blank>config<S2SV_blank>file." ) ; puts ( "" ) ; } <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank>-s=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Silent<S2SV_blank>mode<S2SV_blank>(hide<S2SV_blank>info<S2SV_blank>messages)<S2SV_blank>(0||1)" <S2SV_ModEnd> ) ; puts <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank>ln=string<S2SV_blank><S2SV_blank><S2SV_blank>Language<S2SV_blank>identifier<S2SV_blank>for<S2SV_blank>espeak<S2SV_blank>tts<S2SV_blank>(e.g.<S2SV_blank>en<S2SV_blank>=<S2SV_blank>English<S2SV_blank>or<S2SV_blank>de<S2SV_blank>=<S2SV_blank>German)" ) ; puts ( <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank>dtmf.X.active=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Set<S2SV_blank>dtmf-setting<S2SV_blank>active<S2SV_blank>(0||1)." <S2SV_ModEnd> ) ; puts <S2SV_ModStart> ; puts ( "<S2SV_blank><S2SV_blank>rc=int<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Record<S2SV_blank>call<S2SV_blank>(0||1)" <S2SV_ModEnd> ) ; fflush
|
8,093 |
CWE-000 clblasStatus doHer2k ( CLBlasKargs * kargs , clblasOrder order , clblasUplo uplo , clblasTranspose transA , size_t N , size_t K , const cl_mem A , size_t offa , size_t lda , const cl_mem B , size_t offb , size_t ldb , cl_mem C , size_t offc , size_t ldc , cl_uint numCommandQueues , cl_command_queue * commandQueues , cl_uint numEventsInWaitList , const cl_event * eventWaitList , cl_event * events ) { clblasStatus err ; clblasUplo fUplo ; clblasTranspose fTransA ; <S2SV_StartBug> cl_event firstHerkCall ; <S2SV_EndBug> clblasStatus retCode = clblasSuccess ; if ( ! clblasInitialized ) { return clblasNotInitialized ; } if ( numCommandQueues == 0 || commandQueues == NULL ) { return clblasInvalidValue ; } numCommandQueues = 1 ; if ( ( numEventsInWaitList != 0 ) && ( eventWaitList == NULL ) ) { return clblasInvalidEventWaitList ; } if ( ( retCode = checkMemObjects ( A , B , C , true , A_MAT_ERRSET , B_MAT_ERRSET , C_MAT_ERRSET ) ) ) { return retCode ; } if ( transA == clblasTrans ) { return clblasInvalidValue ; } if ( ( retCode = checkMatrixSizes ( kargs -> dtype , order , transA , N , K , A , offa , lda , A_MAT_ERRSET ) ) ) { return retCode ; } if ( ( retCode = checkMatrixSizes ( kargs -> dtype , order , transA , N , K , B , offb , ldb , B_MAT_ERRSET ) ) ) { return retCode ; } if ( ( retCode = checkMatrixSizes ( kargs -> dtype , order , clblasNoTrans , N , N , C , offc , ldc , C_MAT_ERRSET ) ) ) { return retCode ; } if ( ( numEventsInWaitList != 0 ) && ( eventWaitList == NULL ) ) { return clblasInvalidEventWaitList ; } fUplo = ( order == clblasRowMajor ) ? ( ( uplo == clblasLower ) ? clblasUpper : clblasLower ) : uplo ; fTransA = ( order == clblasRowMajor ) ? ( ( transA == clblasNoTrans ) ? clblasConjTrans : clblasNoTrans ) : transA ; kargs -> order = ( order == clblasRowMajor ) ? clblasColumnMajor : order ; kargs -> transA = fTransA ; kargs -> transB = ( fTransA == clblasNoTrans ) ? clblasConjTrans : clblasNoTrans ; kargs -> uplo = fUplo ; kargs -> M = N ; kargs -> N = N ; kargs -> K = K ; kargs -> A = A ; kargs -> offA = offa ; kargs -> offa = offa ; kargs -> lda . matrix = lda ; kargs -> B = B ; kargs -> offBX = offb ; kargs -> ldb . matrix = ldb ; kargs -> C = C ; kargs -> offCY = offc ; kargs -> ldc . matrix = ldc ; kargs -> pigFuncID = CLBLAS_HERK ; err = executeGEMM ( kargs , numCommandQueues , commandQueues , numEventsInWaitList , eventWaitList , & firstHerkCall ) ; if ( err == CL_SUCCESS ) { kargs -> A = B ; kargs -> offA = offb ; kargs -> offa = offb ; kargs -> lda . matrix = ldb ; kargs -> B = A ; kargs -> offBX = offa ; kargs -> ldb . matrix = lda ; if ( kargs -> dtype == TYPE_COMPLEX_FLOAT ) { CIMAG ( kargs -> alpha . argFloatComplex ) *= - 1.0 ; CREAL ( kargs -> beta . argFloatComplex ) = 1.0 ; CIMAG ( kargs -> beta . argFloatComplex ) = 0.0 ; } else { CIMAG ( kargs -> alpha . argDoubleComplex ) *= - 1.0 ; CREAL ( kargs -> beta . argDoubleComplex ) = 1.0 ; CIMAG ( kargs -> beta . argDoubleComplex ) = 0.0 ; } err = executeGEMM ( kargs , numCommandQueues , commandQueues , 1 , & firstHerkCall , events ) ; <S2SV_StartBug> } <S2SV_EndBug> return ( clblasStatus ) err ; }
|
<S2SV_ModStart> ; cl_event firstHerkCall = NULL <S2SV_ModStart> events ) ; clReleaseEvent ( firstHerkCall ) ;
|
8,094 |
CWE-000 int main ( ) { pthread_t tidA , tidB ; srand ( time ( NULL ) ) ; pthread_setconcurrency ( 3 ) ; <S2SV_StartBug> if ( sem_init ( & mutex , 0 , 1 ) != 0 ) { <S2SV_EndBug> perror ( "Failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>the<S2SV_blank>semaphore\\n" ) ; } for ( int i = 0 ; i < 100 ; i ++ ) { if ( pthread_create ( & tidA , NULL , threadA , NULL ) || pthread_create ( & tidB , NULL , threadB , NULL ) ) { perror ( "pthread_create" ) ; abort ( ) ; } if ( pthread_join ( tidA , NULL ) != 0 || pthread_join ( tidB , NULL ) != 0 ) { perror ( "pthread_join" ) ; abort ( ) ; } } <S2SV_StartBug> sem_destroy ( & mutex ) ; <S2SV_EndBug> return 0 ; }
|
<S2SV_ModStart> sem_init ( & mutex_A <S2SV_ModEnd> , 0 , <S2SV_ModStart> 0 , 1 ) != 0 || sem_init ( & mutex_B , 0 , 0 <S2SV_ModStart> sem_destroy ( & mutex_A ) ; sem_destroy ( & mutex_B <S2SV_ModEnd> ) ; return
|
8,095 |
CWE-000 HTSU_Result heap_delete ( Relation relation , HeapTuple oldtup , Snapshot crosscheck , HeapUpdateFailureData * hufd ) { HTSU_Result result ; <S2SV_StartBug> TransactionId xid = GetCurrentTransactionId ( ) ; <S2SV_EndBug> TransactionId xwait ; ItemPointer tid = & oldtup -> t_self ; ItemId lp ; HeapTupleData tp ; Page page ; Page ulogpage ; BlockNumber block ; Buffer buffer ; Buffer ulogbuf ; Size ulogsize ; OffsetNumber xactnum ; bool have_tuple_lock = false ; bool buffer_relocked = false ; <S2SV_StartBug> Assert ( ItemPointerIsValid ( tid ) ) ; <S2SV_EndBug> if ( IsInParallelMode ( ) ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_TRANSACTION_STATE ) , errmsg ( "cannot<S2SV_blank>delete<S2SV_blank>tuples<S2SV_blank>during<S2SV_blank>a<S2SV_blank>parallel<S2SV_blank>operation" ) ) ) ; block = ItemPointerGetBlockNumber ( tid ) ; buffer = ReadBuffer ( relation , block ) ; page = BufferGetPage ( buffer ) ; LockBuffer ( buffer , BUFFER_LOCK_EXCLUSIVE ) ; lp = PageGetItemId ( page , ItemPointerGetOffsetNumber ( tid ) ) ; Assert ( ItemIdIsNormal ( lp ) ) ; tp . t_self = * tid ; tp . t_tableOid = RelationGetRelid ( relation ) ; l1 : tp . t_data = ( HeapTupleHeader ) PageGetItem ( page , lp ) ; tp . t_len = ItemIdGetLength ( lp ) ; tp . t_flags = ItemIdGetFlags ( lp ) ; xactnum = HeapTupleGetXactNumber ( & tp ) ; tp . t_xact = PageGetXact ( page , xactnum ) ; xwait = HeapTupleGetXid ( & tp ) ; result = HeapTupleSatisfiesUpdate ( & tp ) ; if ( result == HeapTupleBeingUpdated ) { LockBuffer ( buffer , BUFFER_LOCK_UNLOCK ) ; heap_acquire_tuplock ( relation , & ( tp . t_self ) , LockWaitBlock , & have_tuple_lock ) ; XactLockTableWait ( xwait , relation , & ( tp . t_self ) , XLTW_Delete ) ; LockBuffer ( buffer , BUFFER_LOCK_EXCLUSIVE ) ; tp . t_data = ( HeapTupleHeader ) PageGetItem ( page , lp ) ; tp . t_len = ItemIdGetLength ( lp ) ; tp . t_flags = ItemIdGetFlags ( lp ) ; xactnum = HeapTupleGetXactNumber ( & tp ) ; tp . t_xact = PageGetXact ( page , xactnum ) ; if ( TransactionIdEquals ( HeapTupleGetXid ( & tp ) , xwait ) ) BufferCleanoutXact ( buffer , xactnum ) ; goto l1 ; } if ( oldtup != NULL && result == HeapTupleMayBeUpdated ) { if ( heap_tuple_updated ( oldtup , & tp ) ) result = HeapTupleUpdated ; } if ( crosscheck != InvalidSnapshot && result == HeapTupleMayBeUpdated ) { if ( ! HeapTupleSatisfiesVisibility ( & tp , crosscheck , buffer ) ) result = HeapTupleUpdated ; } if ( result != HeapTupleMayBeUpdated ) { Assert ( result == HeapTupleSelfUpdated || result == HeapTupleUpdated || result == HeapTupleBeingUpdated ) ; hufd -> ctid = ItemIdIsRedirected ( lp ) ? HeapTupleHeaderGetTid ( tp . t_data ) : tp . t_self ; hufd -> updateXid = xwait ; UnlockReleaseBuffer ( buffer ) ; if ( have_tuple_lock ) UnlockTupleTuplock ( relation , & ( tp . t_self ) ) ; return result ; } xactnum = buffer_prepare_xact ( buffer , & buffer_relocked ) ; if ( buffer_relocked ) goto l1 ; CheckForSerializableConflictIn ( relation , & tp , buffer ) ; ulogsize = SizeOfULogRecordHeader + SizeOfULogHeapDelete + SizeOfULogItemXact + tp . t_len ; ulogbuf = GetULogBufferWithFreeSpace ( ulogsize ) ; ulogpage = BufferGetPage ( ulogbuf ) ; START_CRIT_SECTION ( ) ; tp . t_xact = PageGetXact ( page , xactnum ) ; ItemIdMarkDead ( lp ) ; log_heap_delete ( relation , buffer , ulogbuf , & tp ) ; END_CRIT_SECTION ( ) ; LockBuffer ( buffer , BUFFER_LOCK_UNLOCK ) ; LockBuffer ( ulogbuf , BUFFER_LOCK_UNLOCK ) ; if ( relation -> rd_rel -> relkind != RELKIND_RELATION && relation -> rd_rel -> relkind != RELKIND_MATVIEW ) { Assert ( ! HeapTupleHasExternal ( & tp ) ) ; } else if ( HeapTupleHasExternal ( & tp ) ) toast_delete ( relation , & tp ) ; CacheInvalidateHeapTuple ( relation , & tp , NULL ) ; ReleaseBuffer ( buffer ) ; ReleaseBuffer ( ulogbuf ) ; if ( have_tuple_lock ) UnlockTupleTuplock ( relation , & ( tp . t_self ) ) ; pgstat_count_heap_delete ( relation ) ; return HeapTupleMayBeUpdated ; }
|
<S2SV_ModStart> result ; TransactionId <S2SV_ModEnd> xwait ; ItemPointer <S2SV_ModStart> ( tid ) ) ; ( void ) GetCurrentTransactionId (
|
8,096 |
CWE-000 static void read_param ( t_obj * obj , t_node * node , char * * pos ) { if ( ft_strcmp ( node -> name , "type" ) == 0 ) obj -> type = parsetype ( pos ) ; else if ( ft_strcmp ( node -> name , "pos" ) == 0 ) obj -> pos = parse3f ( pos ) ; else if ( ft_strcmp ( node -> name , "rot" ) == 0 ) obj -> rot = parse3f ( pos ) ; else if ( ft_strcmp ( node -> name , "scale" ) == 0 ) obj -> size = parse3f ( pos ) ; else if ( ft_strcmp ( node -> name , "color" ) == 0 ) obj -> color = parsecolor ( pos ) ; else if ( ft_strcmp ( node -> name , "reflect" ) == 0 ) obj -> reflect = parsef ( pos ) ; else if ( ft_strcmp ( node -> name , "transparency" ) == 0 ) obj -> transparency = parsef ( pos ) ; else if ( ft_strcmp ( node -> name , "refractive_index" ) == 0 ) obj -> ref_index = parsef ( pos ) ; <S2SV_StartBug> else if ( ft_strcmp ( node -> name , "texture" ) == 0 ) <S2SV_EndBug> if ( ( obj -> texture = parsestr ( pos ) ) == NULL ) ft_error ( "Malloc<S2SV_blank>error\\n" ) ; }
|
<S2SV_ModStart> -> name , "brillance" ) == 0 ) obj -> brillance = ( int ) parsef ( pos ) ; else if ( ft_strcmp ( node -> name ,
|
8,097 |
CWE-000 void transfer ( void * parent_data , local_id src , local_id dst , balance_t amount ) { PipesCommunication * parent = ( PipesCommunication * ) parent_data ; TransferOrder * order = malloc ( sizeof ( TransferOrder ) ) ; order -> s_src = src ; order -> s_dst = dst ; order -> s_amount = amount ; <S2SV_StartBug> int send_transfer_msg ( parent , dst , order ) ; <S2SV_EndBug> log_transfer_out ( src , dst , amount ) ; Message * msg = malloc ( sizeof ( Message ) ) ; <S2SV_StartBug> while ( receive ( comm , dst , & msg ) <= 0 ) ; <S2SV_EndBug> if ( msg -> s_header . s_type == ACK ) { log_transfer_in ( src , dst , amount ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> = amount ; <S2SV_ModEnd> send_transfer_msg ( parent <S2SV_ModStart> ( receive ( parent <S2SV_ModEnd> , dst , <S2SV_ModStart> , dst , <S2SV_ModEnd> msg ) <= <S2SV_ModStart> ) ; } free ( msg ) ;
|
8,098 |
CWE-000 static void smb1351_chg_adc_notification ( enum qpnp_tm_state state , void * ctx ) { struct smb1351_charger * chip = ctx ; <S2SV_StartBug> # ifdef CONFIG_LGE_PM <S2SV_EndBug> struct battery_status * cur = NULL ; <S2SV_StartBug> # else <S2SV_EndBug> struct battery_status * cur ; # endif int temp ; if ( state >= ADC_TM_STATE_NUM ) { pr_err ( "invalid<S2SV_blank>state<S2SV_blank>parameter<S2SV_blank>%d\\n" , state ) ; return ; } temp = smb1351_get_prop_batt_temp ( chip ) ; pr_debug ( "temp<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>state<S2SV_blank>=<S2SV_blank>%s\\n" , temp , state == ADC_TM_WARM_STATE ? "hot" : "cold" ) ; chip -> adc_param . state_request = ADC_TM_WARM_COOL_THR_ENABLE ; if ( state == ADC_TM_WARM_STATE ) { if ( temp >= chip -> batt_hot_decidegc ) { cur = & batt_s [ BATT_HOT ] ; chip -> adc_param . low_temp = chip -> batt_hot_decidegc - HYSTERESIS_DECIDEGC ; chip -> adc_param . state_request = ADC_TM_COOL_THR_ENABLE ; } else if ( temp >= chip -> batt_warm_decidegc && chip -> jeita_supported ) { cur = & batt_s [ BATT_WARM ] ; chip -> adc_param . low_temp = chip -> batt_warm_decidegc - HYSTERESIS_DECIDEGC ; chip -> adc_param . high_temp = chip -> batt_hot_decidegc ; } else if ( temp >= chip -> batt_cool_decidegc && chip -> jeita_supported ) { cur = & batt_s [ BATT_NORMAL ] ; chip -> adc_param . low_temp = chip -> batt_cool_decidegc - HYSTERESIS_DECIDEGC ; chip -> adc_param . high_temp = chip -> batt_warm_decidegc ; } else if ( temp >= chip -> batt_cold_decidegc ) { cur = & batt_s [ BATT_COOL ] ; chip -> adc_param . low_temp = chip -> batt_cold_decidegc - HYSTERESIS_DECIDEGC ; if ( chip -> jeita_supported ) chip -> adc_param . high_temp = chip -> batt_cool_decidegc ; else chip -> adc_param . high_temp = chip -> batt_hot_decidegc ; } else if ( temp >= chip -> batt_missing_decidegc ) { cur = & batt_s [ BATT_COLD ] ; chip -> adc_param . high_temp = chip -> batt_cold_decidegc ; chip -> adc_param . low_temp = chip -> batt_missing_decidegc - HYSTERESIS_DECIDEGC ; } } else { if ( temp <= chip -> batt_missing_decidegc ) { cur = & batt_s [ BATT_MISSING ] ; chip -> adc_param . high_temp = chip -> batt_missing_decidegc + HYSTERESIS_DECIDEGC ; chip -> adc_param . state_request = ADC_TM_WARM_THR_ENABLE ; } else if ( temp <= chip -> batt_cold_decidegc ) { cur = & batt_s [ BATT_COLD ] ; chip -> adc_param . high_temp = chip -> batt_cold_decidegc + HYSTERESIS_DECIDEGC ; chip -> adc_param . low_temp = chip -> batt_missing_decidegc ; } else if ( temp <= chip -> batt_cool_decidegc && chip -> jeita_supported ) { cur = & batt_s [ BATT_COOL ] ; chip -> adc_param . high_temp = chip -> batt_cool_decidegc + HYSTERESIS_DECIDEGC ; chip -> adc_param . low_temp = chip -> batt_cold_decidegc ; } else if ( temp <= chip -> batt_warm_decidegc && chip -> jeita_supported ) { cur = & batt_s [ BATT_NORMAL ] ; chip -> adc_param . high_temp = chip -> batt_warm_decidegc + HYSTERESIS_DECIDEGC ; chip -> adc_param . low_temp = chip -> batt_cool_decidegc ; } else if ( temp <= chip -> batt_hot_decidegc ) { cur = & batt_s [ BATT_WARM ] ; if ( chip -> jeita_supported ) chip -> adc_param . low_temp = chip -> batt_warm_decidegc ; else chip -> adc_param . low_temp = chip -> batt_cold_decidegc ; chip -> adc_param . high_temp = chip -> batt_hot_decidegc + HYSTERESIS_DECIDEGC ; } } <S2SV_StartBug> # ifdef CONFIG_LGE_PM <S2SV_EndBug> if ( ! cur ) { <S2SV_StartBug> pr_err ( "no<S2SV_blank>new<S2SV_blank>status<S2SV_blank>with<S2SV_blank>state:%d,temp:%d\\n" , state , temp ) ; <S2SV_EndBug> return ; } <S2SV_StartBug> # endif <S2SV_EndBug> if ( cur -> batt_present ) chip -> battery_missing = false ; else chip -> battery_missing = true ; if ( cur -> batt_hot ^ chip -> batt_hot || cur -> batt_cold ^ chip -> batt_cold ) { chip -> batt_hot = cur -> batt_hot ; chip -> batt_cold = cur -> batt_cold ; if ( cur -> batt_hot || cur -> batt_cold || chip -> battery_missing ) smb1351_battchg_disable ( chip , THERMAL , 1 ) ; else smb1351_battchg_disable ( chip , THERMAL , 0 ) ; } if ( ( chip -> batt_warm ^ cur -> batt_warm || chip -> batt_cool ^ cur -> batt_cool ) && chip -> jeita_supported ) { chip -> batt_warm = cur -> batt_warm ; chip -> batt_cool = cur -> batt_cool ; smb1351_chg_set_appropriate_battery_current ( chip ) ; smb1351_chg_set_appropriate_vfloat ( chip ) ; smb1351_chg_ctrl_in_jeita ( chip ) ; } pr_debug ( "hot<S2SV_blank>%d,<S2SV_blank>cold<S2SV_blank>%d,<S2SV_blank>warm<S2SV_blank>%d,<S2SV_blank>cool<S2SV_blank>%d,<S2SV_blank>soft<S2SV_blank>jeita<S2SV_blank>supported<S2SV_blank>%d,<S2SV_blank>missing<S2SV_blank>%d,<S2SV_blank>low<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>deciDegC,<S2SV_blank>high<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>deciDegC\\n" , chip -> batt_hot , chip -> batt_cold , chip -> batt_warm , chip -> batt_cool , chip -> jeita_supported , chip -> battery_missing , chip -> adc_param . low_temp , chip -> adc_param . high_temp ) ; if ( qpnp_adc_tm_channel_measure ( chip -> adc_tm_dev , & chip -> adc_param ) ) pr_err ( "request<S2SV_blank>ADC<S2SV_blank>error\\n" ) ; }
|
<S2SV_ModStart> = ctx ; <S2SV_ModEnd> struct battery_status * <S2SV_ModStart> = NULL ; <S2SV_ModEnd> int temp ; <S2SV_ModStart> ; } } <S2SV_ModEnd> if ( ! <S2SV_ModStart> { pr_err ( "invalid<S2SV_blank>transaction:<S2SV_blank>state<S2SV_blank>%d,<S2SV_blank>temp<S2SV_blank>%d\\n" <S2SV_ModEnd> , state , <S2SV_ModStart> return ; } <S2SV_ModEnd> if ( cur
|
8,099 |
CWE-000 void MCH_Fd_Inherit ( int fd , const char * what ) { <S2SV_StartBug> assert ( fd >= 0 ) ; <S2SV_EndBug> MCH_TrackHighFd ( fd ) ; if ( fd_map == NULL ) fd_map = vbit_new ( 128 ) ; AN ( fd_map ) ; if ( what != NULL ) vbit_set ( fd_map , fd ) ; else vbit_clr ( fd_map , fd ) ; }
|
<S2SV_ModStart> 0 ) ; if ( fd > 0 )
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.