Datasets:
xin1997
/
bugfix_pretraining

Dataset card Data Studio Files Community
Unnamed: 0
int64
0
535k
source
stringlengths
50
89.8k
target
stringlengths
23
37.7k
6,700
CWE-000 Plan * <S2SV_StartBug> apply_shareinput_dag_to_tree ( PlannerGlobal * glob , Plan * plan , List * rtable ) <S2SV_EndBug> { <S2SV_StartBug> glob -> share . curr_rtable = rtable ; <S2SV_EndBug> <S2SV_StartBug> shareinput_walker ( shareinput_mutator_dag_to_tree , ( Node * ) plan , glob ) ; <S2SV_EndBug> return plan ; }
<S2SV_ModStart> * apply_shareinput_dag_to_tree ( PlannerInfo * root <S2SV_ModEnd> , Plan * <S2SV_ModStart> Plan * plan ) { PlannerGlobal * glob = root -> glob ; <S2SV_ModEnd> glob -> share <S2SV_ModStart> . curr_rtable = root -> parse -> <S2SV_ModStart> ) plan , root <S2SV_ModEnd> ) ; return
6,701
CWE-000 int destination_connect ( ) { struct sockaddr_in dest_socket ; char dest_servername [ 255 ] ; int dest_rc , dest_sd ; if ( strcmp ( PROTOCOL , "TCP" ) == 0 ) { if ( ( dest_sd = socket ( AF_INET , SOCK_STREAM , 0 ) ) < 0 ) { perror ( "socket<S2SV_blank>error" ) ; return - 1 ; } <S2SV_StartBug> } <S2SV_EndBug> else { if ( ( dest_sd = socket ( AF_INET , SOCK_DGRAM , 0 ) ) < 0 ) { perror ( "socket<S2SV_blank>error" ) ; return - 1 ; } } strcpy ( dest_servername , SERVER ) ; memset ( & dest_socket , 0x00 , sizeof ( struct sockaddr_in ) ) ; dest_socket . sin_family = AF_INET ; <S2SV_StartBug> dest_socket . sin_port = htons ( SERVPORT ) ; <S2SV_EndBug> if ( ( dest_rc = connect ( dest_sd , ( struct sockaddr * ) & dest_socket , sizeof ( dest_socket ) ) ) < 0 ) { perror ( "connect<S2SV_blank>error" ) ; close ( dest_sd ) ; return - 1 ; } <S2SV_StartBug> sendlogs ( LOG_INFO , "Connected<S2SV_blank>to<S2SV_blank>destination." ) ; <S2SV_EndBug> return dest_sd ; }
<S2SV_ModStart> 1 ; } <S2SV_ModEnd> dest_socket . sin_family <S2SV_ModStart> SERVPORT ) ; if ( inet_aton ( SERVER , & dest_socket . sin_addr ) == 0 ) { perror ( "inet_aton<S2SV_blank>error" ) ; return - 1 ; } <S2SV_ModStart> 1 ; } } else { if ( ( dest_sd = socket ( AF_INET , SOCK_DGRAM , IPPROTO_UDP ) ) < 0 ) { perror ( "socket<S2SV_blank>error" ) ; return - 1 ; } }
6,702
CWE-000 <S2SV_StartBug> int main ( void ) { <S2SV_EndBug> <S2SV_StartBug> calc ( TRUE , FALSE , '|' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( TRUE , FALSE , '&' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( TRUE , turnStringToInt ( "oi" ) , '^' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( TRUE , FALSE , 'x' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( TRUE , FALSE , '>' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( 0 , 021 , 'N' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( 2 , 3 , '+' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( 3 , 444 , '-' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( turnFloatToInt ( 444451.0 ) , 0x545 , '/' ) ; <S2SV_EndBug> <S2SV_StartBug> calc ( 5 , 23 , '*' ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> int main ( <S2SV_ModEnd> ) { calc <S2SV_ModStart> , FALSE , "|" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , FALSE , "&" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> "oi" ) , "^" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , FALSE , "x" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , FALSE , ">" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , 021 , "N" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , 3 , "+" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , 444 , "-" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , 0x545 , "/" <S2SV_ModEnd> ) ; calc <S2SV_ModStart> , 23 , "*" <S2SV_ModEnd> ) ; return
6,703
CWE-000 extern void UpdateNormExp ( int state , void * ss , hmm_t * hmm ) { <S2SV_StartBug> Rprintf ( "[UpdateNormExp]<S2SV_blank>START" ) ; <S2SV_EndBug> ssNormExp * SS = ( ssNormExp * ) ss ; double epsilon = 0.00001 ; double * stateParams = hmm [ 0 ] . em_args [ state ] ; double * sp = ( double * ) calloc ( 4 , sizeof ( double ) ) ; double * fmin = ( double * ) calloc ( 1 , sizeof ( double ) ) ; int * fail = ( int * ) calloc ( 1 , sizeof ( int ) ) ; int MAXIT = 100 ; double tol = 1e-3 ; double * ex = SS [ 0 ] . ex ; int * fncount = ( int * ) calloc ( 1 , sizeof ( int ) ) , * grcount = ( int * ) calloc ( 1 , sizeof ( int ) ) ; cgmin ( 4 , stateParams , sp , fmin , normal_exp_optimfn , normal_exp_optimgr , fail , tol , tol , ex , 1 , 0 , fncount , grcount , MAXIT ) ; if ( fail [ 0 ] != 0 ) { <S2SV_StartBug> Rprintf ( "[UpdateNormExp]<S2SV_blank>WARNING::Updates<S2SV_blank>failed<S2SV_blank>w/<S2SV_blank>message<S2SV_blank>%d.<S2SV_blank><S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fncount=<S2SV_blank>%d<S2SV_blank>;<S2SV_blank>grcount=<S2SV_blank>%d\\n" , fail [ 0 ] , fncount [ 0 ] , grcount [ 0 ] ) ; <S2SV_EndBug> } stateParams = sp ; <S2SV_StartBug> Rprintf ( "[UpdateNormExp]\\t--><S2SV_blank>Alpha:<S2SV_blank>%f;<S2SV_blank>Mean:<S2SV_blank>%f;<S2SV_blank>Stdev:<S2SV_blank>%f;<S2SV_blank>Lambda:<S2SV_blank>%f\\n" , <S2SV_EndBug> hmm [ 0 ] . em_args [ state ] [ 0 ] , hmm [ 0 ] . em_args [ state ] [ 1 ] , hmm [ 0 ] . em_args [ state ] [ 2 ] , hmm [ 0 ] . em_args [ state ] [ 3 ] ) ; }
<S2SV_ModStart> hmm ) { if ( hmm -> verb ) <S2SV_ModStart> { Rprintf ( "[UpdateNormExp]<S2SV_blank>WARNING::Updates<S2SV_blank>failed<S2SV_blank>w/<S2SV_blank>message<S2SV_blank>%d.<S2SV_blank><S2SV_blank>\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>fncount=<S2SV_blank>%d<S2SV_blank>;<S2SV_blank>grcount=<S2SV_blank>%d\\n" <S2SV_ModEnd> , fail [ <S2SV_ModStart> = sp ; if ( hmm -> verb )
6,704
CWE-000 static void gsc_src_set_transf ( struct gsc_context * ctx , unsigned int rotation ) { unsigned int degree = rotation & DRM_MODE_ROTATE_MASK ; u32 cfg ; cfg = gsc_read ( GSC_IN_CON ) ; cfg &= ~ GSC_IN_ROT_MASK ; switch ( degree ) { case DRM_MODE_ROTATE_0 : <S2SV_StartBug> if ( rotation & DRM_MODE_REFLECT_Y ) <S2SV_EndBug> cfg |= GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_X ) cfg |= GSC_IN_ROT_YFLIP ; break ; case DRM_MODE_ROTATE_90 : cfg |= GSC_IN_ROT_90 ; <S2SV_StartBug> if ( rotation & DRM_MODE_REFLECT_Y ) <S2SV_EndBug> cfg |= GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_X ) cfg |= GSC_IN_ROT_YFLIP ; break ; case DRM_MODE_ROTATE_180 : cfg |= GSC_IN_ROT_180 ; <S2SV_StartBug> if ( rotation & DRM_MODE_REFLECT_Y ) <S2SV_EndBug> cfg &= ~ GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_X ) cfg &= ~ GSC_IN_ROT_YFLIP ; break ; case DRM_MODE_ROTATE_270 : cfg |= GSC_IN_ROT_270 ; <S2SV_StartBug> if ( rotation & DRM_MODE_REFLECT_Y ) <S2SV_EndBug> cfg &= ~ GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_X ) cfg &= ~ GSC_IN_ROT_YFLIP ; break ; } gsc_write ( cfg , GSC_IN_CON ) ; ctx -> rotation = ( cfg & GSC_IN_ROT_90 ) ? 1 : 0 ; }
<S2SV_ModStart> ( rotation & DRM_MODE_REFLECT_X ) cfg |= GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_Y <S2SV_ModEnd> ) cfg |= <S2SV_ModStart> ( rotation & DRM_MODE_REFLECT_X ) cfg |= GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_Y <S2SV_ModEnd> ) cfg |= <S2SV_ModStart> ( rotation & DRM_MODE_REFLECT_X ) cfg &= ~ GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_Y <S2SV_ModEnd> ) cfg &= <S2SV_ModStart> ( rotation & DRM_MODE_REFLECT_X ) cfg &= ~ GSC_IN_ROT_XFLIP ; if ( rotation & DRM_MODE_REFLECT_Y <S2SV_ModEnd> ) cfg &=
6,705
CWE-000 static av_cold int libopenjpeg_encode_init ( AVCodecContext * avctx ) { LibOpenJPEGContext * ctx = avctx -> priv_data ; int err = 0 ; opj_set_default_encoder_parameters ( & ctx -> enc_params ) ; # if HAVE_OPENJPEG_2_1_OPENJPEG_H switch ( ctx -> cinema_mode ) { case OPJ_CINEMA2K_24 : ctx -> enc_params . rsiz = OPJ_PROFILE_CINEMA_2K ; ctx -> enc_params . max_cs_size = OPJ_CINEMA_24_CS ; ctx -> enc_params . max_comp_size = OPJ_CINEMA_24_COMP ; break ; case OPJ_CINEMA2K_48 : ctx -> enc_params . rsiz = OPJ_PROFILE_CINEMA_2K ; ctx -> enc_params . max_cs_size = OPJ_CINEMA_48_CS ; ctx -> enc_params . max_comp_size = OPJ_CINEMA_48_COMP ; break ; case OPJ_CINEMA4K_24 : ctx -> enc_params . rsiz = OPJ_PROFILE_CINEMA_4K ; ctx -> enc_params . max_cs_size = OPJ_CINEMA_24_CS ; ctx -> enc_params . max_comp_size = OPJ_CINEMA_24_COMP ; break ; } switch ( ctx -> profile ) { case OPJ_CINEMA2K : if ( ctx -> enc_params . rsiz == OPJ_PROFILE_CINEMA_4K ) { err = AVERROR ( EINVAL ) ; break ; } ctx -> enc_params . rsiz = OPJ_PROFILE_CINEMA_2K ; break ; case OPJ_CINEMA4K : if ( ctx -> enc_params . rsiz == OPJ_PROFILE_CINEMA_2K ) { err = AVERROR ( EINVAL ) ; break ; } ctx -> enc_params . rsiz = OPJ_PROFILE_CINEMA_4K ; break ; } if ( err ) { av_log ( avctx , AV_LOG_ERROR , "Invalid<S2SV_blank>parameter<S2SV_blank>pairing:<S2SV_blank>cinema_mode<S2SV_blank>and<S2SV_blank>profile<S2SV_blank>conflict.\\n" ) ; goto fail ; } # else ctx -> enc_params . cp_rsiz = ctx -> profile ; ctx -> enc_params . cp_cinema = ctx -> cinema_mode ; # endif <S2SV_StartBug> ctx -> enc_params . mode = ! ! avctx -> global_quality ; <S2SV_EndBug> ctx -> enc_params . prog_order = ctx -> prog_order ; ctx -> enc_params . numresolution = ctx -> numresolution ; ctx -> enc_params . cp_disto_alloc = ctx -> disto_alloc ; ctx -> enc_params . cp_fixed_alloc = ctx -> fixed_alloc ; ctx -> enc_params . cp_fixed_quality = ctx -> fixed_quality ; ctx -> enc_params . tcp_numlayers = ctx -> numlayers ; ctx -> enc_params . tcp_rates [ 0 ] = FFMAX ( avctx -> compression_level , 0 ) * 2 ; if ( ctx -> cinema_mode > 0 ) { cinema_parameters ( & ctx -> enc_params ) ; } ctx -> image = mj2_create_image ( avctx , & ctx -> enc_params ) ; if ( ! ctx -> image ) { av_log ( avctx , AV_LOG_ERROR , "Error<S2SV_blank>creating<S2SV_blank>the<S2SV_blank>mj2<S2SV_blank>image\\n" ) ; err = AVERROR ( EINVAL ) ; goto fail ; } return 0 ; fail : opj_image_destroy ( ctx -> image ) ; ctx -> image = NULL ; return err ; }
<S2SV_ModStart> ; # endif if ( ! ctx -> numresolution ) { ctx -> numresolution = 6 ; while ( FFMIN ( avctx -> width , avctx -> height ) >> ctx -> numresolution < 1 ) ctx -> numresolution -- ; }
6,706
CWE-000 enum gru_error gru_z64fs_vprev ( struct gru_z64fs * z64fs , size_t index , size_t * index_out ) { if ( index >= z64fs -> files . size ) return GRU_ERROR_RANGE ; struct z64_file * file = vector_at ( & z64fs -> files , index ) ; size_t vrom_order = file -> vrom_order ; if ( vrom_order == 0 ) return GRU_ERROR_RANGE ; <S2SV_StartBug> for ( size_t i = vrom_order - 1 ; i >= 0 ; -- i ) { <S2SV_EndBug> size_t i_index ; <S2SV_StartBug> gru_z64fs_vindex ( z64fs , i , & i_index ) ; <S2SV_EndBug> * index_out = i_index ; return GRU_SUCCESS ; } <S2SV_StartBug> return GRU_ERROR_RANGE ; <S2SV_EndBug> }
<S2SV_ModStart> return GRU_ERROR_RANGE ; <S2SV_ModEnd> gru_z64fs_vindex ( z64fs <S2SV_ModStart> ( z64fs , vrom_order - 1 , index_out ) <S2SV_ModEnd> ; return GRU_SUCCESS <S2SV_ModStart> GRU_SUCCESS ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
6,707
CWE-000 static pointer do_wait_process ( scheme * sc , pointer args ) { FFI_PROLOG ( ) ; const char * name ; pid_t pid ; int hang ; int retcode ; FFI_ARG_OR_RETURN ( sc , const char * , name , string , args ) ; FFI_ARG_OR_RETURN ( sc , pid_t , pid , number , args ) ; FFI_ARG_OR_RETURN ( sc , int , hang , bool , args ) ; FFI_ARGS_DONE_OR_RETURN ( sc , args ) ; <S2SV_StartBug> err = gnupg_wait_process ( name , pid , hang , & retcode ) ; <S2SV_EndBug> if ( err == GPG_ERR_GENERAL ) err = 0 ; FFI_RETURN_INT ( sc , retcode ) ; }
<S2SV_ModStart> ; err = gpgrt_wait_process <S2SV_ModEnd> ( name ,
6,708
CWE-000 <S2SV_StartBug> static void keygen ( unsigned char * send , poly * sk , OQS_RAND * rand ) { <S2SV_EndBug> poly a , e , r , pk ; unsigned char seed [ NEWHOPE_SEEDBYTES ] ; rand -> rand_n ( rand , seed , NEWHOPE_SEEDBYTES ) ; gen_a ( & a , seed ) ; poly_getnoise ( sk , rand ) ; poly_ntt ( sk ) ; poly_getnoise ( & e , rand ) ; poly_ntt ( & e ) ; poly_pointwise ( & r , sk , & a ) ; poly_add ( & pk , & e , & r ) ; encode_a ( send , & pk , seed ) ; }
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> void keygen (
6,709
CWE-000 void stm32_clock_init ( void ) { # if ! STM32_NO_INIT RCC -> CR |= RCC_CR_HSION ; while ( ! ( RCC -> CR & RCC_CR_HSIRDY ) ) ; RCC -> CFGR &= ~ RCC_CFGR_SW ; RCC -> CFGR |= RCC_CFGR_SWS_HSI ; while ( ( RCC -> CFGR & RCC_CFGR_SWS ) != RCC_CFGR_SWS_HSI ) ; RCC -> CR &= RCC_CR_HSITRIM | RCC_CR_HSION ; RCC -> CFGR = 0 ; # if STM32_HSE_ENABLED # if defined ( STM32_HSE_BYPASS ) RCC -> CR |= RCC_CR_HSEON | RCC_CR_HSEBYP ; # else RCC -> CR |= RCC_CR_HSEON ; # endif while ( ! ( RCC -> CR & RCC_CR_HSERDY ) ) ; # endif # if STM32_HSI14_ENABLED RCC -> CR2 |= RCC_CR2_HSI14ON ; while ( ! ( RCC -> CR2 & RCC_CR2_HSI14RDY ) ) ; # endif # if STM32_HSI48_ENABLED RCC -> CR2 |= RCC_CR2_HSI48ON ; while ( ! ( RCC -> CR2 & RCC_CR2_HSI48RDY ) ) ; # endif # if STM32_LSI_ENABLED RCC -> CSR |= RCC_CSR_LSION ; while ( ( RCC -> CSR & RCC_CSR_LSIRDY ) == 0 ) ; # endif RCC -> CFGR2 = STM32_PREDIV ; RCC -> CFGR = STM32_PLLNODIV | STM32_MCOPRE | STM32_MCOSEL | STM32_PLLMUL | <S2SV_StartBug> STM32_PLLSRC | STM32_PPRE | STM32_HPRE ; <S2SV_EndBug> # if STM32_CECSW == STM32_CECSW_OFF RCC -> CFGR3 = STM32_USBSW | STM32_I2C1SW | STM32_USART1SW ; # else RCC -> CFGR3 = STM32_USBSW | STM32_CECSW | STM32_I2C1SW | STM32_USART1SW ; # endif # if STM32_ACTIVATE_PLL RCC -> CR |= RCC_CR_PLLON ; while ( ! ( RCC -> CR & RCC_CR_PLLRDY ) ) ; # endif FLASH -> ACR = STM32_FLASHBITS ; # if ( STM32_SW != STM32_SW_HSI ) RCC -> CFGR |= STM32_SW ; while ( ( RCC -> CFGR & RCC_CFGR_SWS ) != ( STM32_SW << 2 ) ) ; # endif rccEnableAPB2 ( RCC_APB2ENR_SYSCFGEN , TRUE ) ; # endif }
<S2SV_ModStart> STM32_PPRE | STM32_HPRE | ( ( STM32_PREDIV & STM32_PLLXTPRE_MASK ) << STM32_PLLXTPRE_OFFSET )
6,710
CWE-000 void EditEscapeCChars ( HWND hwnd ) { if ( SendMessage ( hwnd , SCI_GETSELECTIONEND , 0 , 0 ) - SendMessage ( hwnd , SCI_GETSELECTIONSTART , 0 , 0 ) ) { if ( SC_SEL_RECTANGLE != SendMessage ( hwnd , SCI_GETSELECTIONMODE , 0 , 0 ) ) { <S2SV_StartBug> EDITFINDREPLACE efr = { "" , "" , "" , "" , 0 , 0 , 0 , 0 , 0 , 0 , 0 , NULL } ; <S2SV_EndBug> efr . hwnd = hwnd ; SendMessage ( hwnd , SCI_BEGINUNDOACTION , 0 , 0 ) ; StringCchCopyA ( efr . szFind , FNDRPL_BUFFER , "\\\\" ) ; StringCchCopyA ( efr . szReplace , FNDRPL_BUFFER , "\\\\\\\\" ) ; EditReplaceAllInSelection ( hwnd , & efr , FALSE ) ; StringCchCopyA ( efr . szFind , FNDRPL_BUFFER , "\\"" ) ; StringCchCopyA ( efr . szReplace , FNDRPL_BUFFER , "\\\\\\"" ) ; EditReplaceAllInSelection ( hwnd , & efr , FALSE ) ; StringCchCopyA ( efr . szFind , FNDRPL_BUFFER , "\\\'" ) ; StringCchCopyA ( efr . szReplace , FNDRPL_BUFFER , "\\\\\\\'" ) ; EditReplaceAllInSelection ( hwnd , & efr , FALSE ) ; SendMessage ( hwnd , SCI_ENDUNDOACTION , 0 , 0 ) ; } else MsgBox ( MBWARN , IDS_SELRECT ) ; } }
<S2SV_ModStart> , 0 , 0 ,
6,711
CWE-000 int32_t get_free_pages ( struct ftl_base_t * _ftl_base , struct ftl_context_t * ptr_ftl_context , uint32_t nr_pages , uint32_t * ptr_bus , uint32_t * ptr_chip , uint32_t * ptr_block , uint32_t * ptr_page ) { if ( _ftl_base -> ftl_get_free_physical_page_address ( ptr_ftl_context , nr_pages , ptr_bus , ptr_chip , ptr_block , ptr_page ) == - 1 ) { <S2SV_StartBug> if ( _ftl_base -> ftl_trigger_gc != NULL ) { <S2SV_EndBug> if ( _ftl_base -> ftl_trigger_gc ( ptr_ftl_context , * ptr_bus , * ptr_chip ) == - 1 ) { printf ( "bluessd:<S2SV_blank>oops!<S2SV_blank>garbage<S2SV_blank>collection<S2SV_blank>failed.\\n" ) ; goto err ; } if ( _ftl_base -> ftl_get_free_physical_page_address ( ptr_ftl_context , nr_pages , ptr_bus , ptr_chip , ptr_block , ptr_page ) == - 1 ) { printf ( "bluessd:<S2SV_blank>there<S2SV_blank>is<S2SV_blank>not<S2SV_blank>sufficient<S2SV_blank>space<S2SV_blank>in<S2SV_blank>flash<S2SV_blank>memory.\\n" ) ; goto err ; } } else { printf ( "bluessd:<S2SV_blank>garbage<S2SV_blank>collection<S2SV_blank>is<S2SV_blank>not<S2SV_blank>registered\\n" ) ; goto err ; } } return 0 ; err : return - 1 ; }
<S2SV_ModStart> NULL ) { printf ( "start<S2SV_blank>GC\\n" ) ;
6,712
CWE-000 str compileString ( Symbol * fcn , Client cntxt , str s ) { Client c ; int len = ( int ) strlen ( s ) ; buffer * b ; str msg = MAL_SUCCEED ; str qry ; str old = s ; ( void ) cntxt ; s = mal_cmdline ( s , & len ) ; mal_unquote ( qry = GDKstrdup ( s ) ) ; if ( old != s ) GDKfree ( s ) ; b = ( buffer * ) GDKmalloc ( sizeof ( buffer ) ) ; if ( b == NULL ) { GDKfree ( qry ) ; return MAL_MALLOC_FAIL ; } buffer_init ( b , qry , len ) ; <S2SV_StartBug> c = MCinitClient ( ( oid ) 0 , bstream_create ( buffer_rastream ( b , "callString" ) , b -> len ) , 0 ) ; <S2SV_EndBug> if ( c == NULL ) { GDKfree ( b ) ; GDKfree ( qry ) ; throw ( MAL , "mal.eval" , "Can<S2SV_blank>not<S2SV_blank>create<S2SV_blank>user<S2SV_blank>context" ) ; } <S2SV_StartBug> c -> curmodule = c -> usermodule = userModule ( ) ; <S2SV_EndBug> c -> promptlength = 0 ; <S2SV_StartBug> if ( ( msg = defaultScenario ( c ) ) ) { <S2SV_EndBug> <S2SV_StartBug> MCcloseClient ( c ) ; <S2SV_EndBug> throw ( MAL , "mal.compile" , "%s" , msg ) ; } <S2SV_StartBug> MSinitClientPrg ( c , "user" , "main" ) ; <S2SV_EndBug> msg = ( str ) ( * c -> phase [ MAL_SCENARIO_READER ] ) ( c ) ; if ( msg == MAL_SUCCEED && c -> phase [ MAL_SCENARIO_PARSER ] ) msg = ( str ) ( * c -> phase [ MAL_SCENARIO_PARSER ] ) ( c ) ; if ( msg == MAL_SUCCEED && c -> phase [ MAL_SCENARIO_OPTIMIZE ] ) msg = ( str ) ( * c -> phase [ MAL_SCENARIO_OPTIMIZE ] ) ( c ) ; * fcn = c -> curprg ; c -> curprg = 0 ; <S2SV_StartBug> MCcloseClient ( c ) ; <S2SV_EndBug> GDKfree ( qry ) ; GDKfree ( b ) ; return msg ; }
<S2SV_ModStart> ( b , "compileString" <S2SV_ModEnd> ) , b <S2SV_ModStart> -> usermodule = cntxt -> usermodule <S2SV_ModEnd> ; c -> <S2SV_ModStart> = 0 ; c -> listing = 0 ; <S2SV_ModStart> ) ) { c -> usermodule = 0 ; <S2SV_ModStart> "user" , "main" <S2SV_ModEnd> ) ; if <S2SV_ModStart> = 0 ; c -> usermodule = 0 ;
6,713
CWE-000 static void gen_lea_v_seg ( DisasContext * s , TCGMemOp aflag , TCGv a0 , int def_seg , int ovr_seg ) { switch ( aflag ) { # ifdef TARGET_X86_64 case MO_64 : if ( ovr_seg < 0 ) { tcg_gen_mov_tl ( cpu_A0 , a0 ) ; return ; } break ; # endif case MO_32 : <S2SV_StartBug> if ( ovr_seg < 0 ) { <S2SV_EndBug> if ( s -> addseg ) { ovr_seg = def_seg ; <S2SV_StartBug> } else { <S2SV_EndBug> tcg_gen_ext32u_tl ( cpu_A0 , a0 ) ; return ; <S2SV_StartBug> } <S2SV_EndBug> } break ; case MO_16 : tcg_gen_ext16u_tl ( cpu_A0 , a0 ) ; a0 = cpu_A0 ; if ( ovr_seg < 0 ) { if ( s -> addseg ) { ovr_seg = def_seg ; } else { return ; } } break ; default : tcg_abort ( ) ; } if ( ovr_seg >= 0 ) { TCGv seg = cpu_seg_base [ ovr_seg ] ; if ( aflag == MO_64 ) { tcg_gen_add_tl ( cpu_A0 , a0 , seg ) ; } else if ( CODE64 ( s ) ) { tcg_gen_ext32u_tl ( cpu_A0 , a0 ) ; tcg_gen_add_tl ( cpu_A0 , cpu_A0 , seg ) ; } else { tcg_gen_add_tl ( cpu_A0 , a0 , seg ) ; tcg_gen_ext32u_tl ( cpu_A0 , cpu_A0 ) ; } } }
<S2SV_ModStart> ovr_seg < 0 && <S2SV_ModEnd> s -> addseg <S2SV_ModStart> def_seg ; } if ( ovr_seg < 0 ) <S2SV_ModEnd> { tcg_gen_ext32u_tl ( <S2SV_ModStart> ; return ; <S2SV_ModEnd> } break ;
6,714
CWE-000 static matrix * matrix_create ( size_t rows , size_t columns ) { <S2SV_StartBug> matrix * instance = malloc ( sizeof ( matrix ) ) ; <S2SV_EndBug> instance -> type = MATRIX_TYPE ; instance -> rows = rows ; instance -> columns = columns ; instance -> vector = Vector . create ( rows * columns ) ; return instance ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> columns ) { check ( rows > 0 && columns > 0 , "Wrong<S2SV_blank>matrix<S2SV_blank>size" ) ; <S2SV_ModStart> ( matrix ) ) ; check_memory ( instance <S2SV_ModStart> return instance ; error : return NULL ;
6,715
CWE-000 static int nmea_reader_handler ( zloop_t * zloop , zsock_t * zsock , void * arg ) { ( void ) zloop ; ( void ) arg ; zmsg_t * msg ; while ( 1 ) { msg = zmsg_recv ( zsock ) ; if ( msg != NULL ) { break ; } else if ( errno == EINTR ) { continue ; } else { sbp_log ( LOG_ERR , "error<S2SV_blank>in<S2SV_blank>zmsg_recv()" ) ; exit ( EXIT_FAILURE ) ; } } size_t frame_count = zmsg_size ( msg ) ; if ( frame_count != 1 ) { sbp_log ( LOG_ERR , "zmsg<S2SV_blank>frame<S2SV_blank>count<S2SV_blank>was<S2SV_blank>invalid" ) ; exit ( EXIT_FAILURE ) ; } zframe_t * frame = zmsg_first ( msg ) ; size_t frame_length = 0 ; { const char * frame_data = ( char * ) zframe_data ( frame ) ; frame_length = zframe_size ( frame ) ; if ( frame_length == 0 || frame_length > ( MAX_BUFFER - 1 ) ) { sbp_log ( LOG_ERR , "invalid<S2SV_blank>frame<S2SV_blank>size:<S2SV_blank>%lu" , frame_length ) ; exit ( EXIT_FAILURE ) ; } memcpy ( buffer , frame_data , MAX_BUFFER - 1 ) ; buffer [ frame_length ] = '\\0' ; } if ( strstr ( buffer , "GGA" ) == NULL ) { if ( nmea_debug ) { piksi_log ( LOG_DEBUG , "ignoring<S2SV_blank>non-GGA<S2SV_blank>message" ) ; } goto exit_success ; } if ( nmea_debug ) { piksi_log ( LOG_DEBUG , "got<S2SV_blank>GGA<S2SV_blank>message:<S2SV_blank>%s" , buffer ) ; } char tmp_file_name [ ] = BASE_DIRECTORY "/temp_nmea_gga.XXXXXX" ; int fd_temp = mkstemp ( tmp_file_name ) ; if ( fd_temp < 0 ) { sbp_log ( LOG_ERR , "error<S2SV_blank>creating<S2SV_blank>temp<S2SV_blank>file" ) ; exit ( EXIT_FAILURE ) ; } FILE * fp = fdopen ( fd_temp , "w+" ) ; if ( strstr ( buffer , "\\r\\n" ) != NULL ) { fprintf ( fp , "%s" , buffer ) ; } else { fprintf ( fp , "%s\\r\\n" , buffer ) ; } fclose ( fp ) ; if ( rename ( tmp_file_name , NMEA_GGA_OUTPUT_PATH ) < 0 ) { sbp_log ( LOG_WARNING , "rename<S2SV_blank>failed:<S2SV_blank>%s" , strerror ( errno ) ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } <S2SV_StartBug> exit_success : <S2SV_EndBug> zmsg_destroy ( & msg ) ; return 0 ; }
<S2SV_ModStart> ) ) ; } exit_success : zmsg_destroy ( & msg ) ; <S2SV_ModStart> 0 ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
6,716
CWE-000 int rpc_get_block_callback ( void * data , int flags , xdag_hash_t hash , xdag_amount_t amount , xdag_time_t time , const xdag_remark_t remark ) { cJSON * callback_data = ( cJSON * ) data ; if ( ! callback_data ) { return - 1 ; } char address_buf [ 33 ] = { 0 } ; xdag_hash2address ( hash , address_buf ) ; cJSON * json_address = cJSON_CreateString ( address_buf ) ; cJSON_AddItemToObject ( callback_data , "address" , json_address ) ; char str [ 128 ] = { 0 } ; sprintf ( str , "%.9Lf" , amount2xdags ( amount ) ) ; cJSON * json_amount = cJSON_CreateString ( str ) ; cJSON_AddItemToObject ( callback_data , "amount" , json_amount ) ; sprintf ( str , "%x" , flags & ~ BI_OURS ) ; cJSON * json_flags = cJSON_CreateString ( str ) ; cJSON_AddItemToObject ( callback_data , "flags" , json_flags ) ; sprintf ( str , "%s" , xdag_get_block_state_info ( flags ) ) ; cJSON * json_state = cJSON_CreateString ( str ) ; cJSON_AddItemToObject ( callback_data , "state" , json_state ) ; <S2SV_StartBug> cJSON * json_remark = cJSON_CreateString ( remark ) ; <S2SV_EndBug> cJSON_AddItemToObject ( callback_data , "remark" , json_remark ) ; struct tm tm ; char buf [ 64 ] = { 0 } , tbuf [ 64 ] = { 0 } ; time_t t = time >> 10 ; localtime_r ( & t , & tm ) ; strftime ( buf , 64 , "%Y-%m-%d<S2SV_blank>%H:%M:%S" , & tm ) ; sprintf ( tbuf , "%s.%03d<S2SV_blank>UTC" , buf , ( int ) ( ( time & 0x3ff ) * 1000 ) >> 10 ) ; cJSON * json_time = cJSON_CreateString ( tbuf ) ; cJSON_AddItemToObject ( callback_data , "timestamp" , json_time ) ; return 0 ; }
<S2SV_ModStart> json_state ) ; char remark_buf [ 33 ] = { 0 } ; memcpy ( remark_buf , remark , 32 ) ; <S2SV_ModStart> = cJSON_CreateString ( remark_buf <S2SV_ModEnd> ) ; cJSON_AddItemToObject
6,717
CWE-000 static UA_StatusCode typeCheckVariableNode ( UA_Server * server , UA_Session * session , const UA_VariableNode * node , const UA_NodeId * typeDef ) { const UA_VariableTypeNode * vt = ( const UA_VariableTypeNode * ) UA_NodestoreSwitch_getNode ( server , typeDef ) ; if ( ! vt || vt -> nodeClass != UA_NODECLASS_VARIABLETYPE ) { UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return UA_STATUSCODE_BADTYPEDEFINITIONINVALID ; } if ( node -> nodeClass == UA_NODECLASS_VARIABLE && vt -> isAbstract ) { UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return UA_STATUSCODE_BADTYPEDEFINITIONINVALID ; } UA_DataValue value ; UA_DataValue_init ( & value ) ; UA_StatusCode retval = readValueAttribute ( server , node , & value ) ; if ( retval != UA_STATUSCODE_GOOD ) { UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return retval ; } if ( node -> valueRank == 0 && ( ! value . hasValue || ! value . value . type || UA_Variant_isScalar ( & value . value ) ) ) { UA_LOG_INFO_SESSION ( server -> config . logger , session , "AddNodes:<S2SV_blank>Use<S2SV_blank>a<S2SV_blank>default<S2SV_blank>ValueRank<S2SV_blank>of<S2SV_blank>-2" , NULL ) ; UA_RCU_UNLOCK ( ) ; retval = UA_Server_writeValueRank ( server , node -> nodeId , - 2 ) ; UA_RCU_LOCK ( ) ; if ( retval != UA_STATUSCODE_GOOD ) { UA_DataValue_deleteMembers ( & value ) ; UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return retval ; } } if ( ! value . hasValue || ! value . value . type ) { retval = readValueAttribute ( server , ( const UA_VariableNode * ) vt , & value ) ; if ( retval == UA_STATUSCODE_GOOD && value . hasValue && value . value . type ) { UA_RCU_UNLOCK ( ) ; retval = UA_Server_writeValue ( server , node -> nodeId , value . value ) ; UA_RCU_LOCK ( ) ; } if ( retval != UA_STATUSCODE_GOOD ) { UA_DataValue_deleteMembers ( & value ) ; UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return retval ; } } if ( UA_NodeId_isNull ( & node -> dataType ) ) { UA_LOG_INFO_SESSION ( server -> config . logger , session , "AddNodes:<S2SV_blank>" "Use<S2SV_blank>a<S2SV_blank>default<S2SV_blank>DataType<S2SV_blank>(from<S2SV_blank>the<S2SV_blank>TypeDefinition)" , NULL ) ; UA_RCU_UNLOCK ( ) ; retval = UA_Server_writeDataType ( server , node -> nodeId , vt -> dataType ) ; UA_RCU_LOCK ( ) ; if ( retval != UA_STATUSCODE_GOOD ) { UA_DataValue_deleteMembers ( & value ) ; UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; return retval ; } } <S2SV_StartBug> UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) node ) ; <S2SV_EndBug> <S2SV_StartBug> node = ( const UA_VariableNode * ) UA_NodestoreSwitch_getNode ( server , & node -> nodeId ) ; <S2SV_EndBug> retval = typeCheckVariableNodeWithValue ( server , session , node , vt , & value ) ; UA_DataValue_deleteMembers ( & value ) ; UA_NodestoreSwitch_releaseNode ( server , ( const UA_Node * ) vt ) ; <S2SV_StartBug> return retval ; <S2SV_EndBug> }
<S2SV_ModStart> ; } } const UA_Node * nodeUpdate = UA_NodestoreSwitch_getNode ( server , & node -> nodeId ) ; retval = typeCheckVariableNodeWithValue ( server , session , <S2SV_ModEnd> ( const UA_VariableNode <S2SV_ModStart> UA_VariableNode * ) nodeUpdate <S2SV_ModEnd> , vt , <S2SV_ModStart> vt ) ; UA_NodestoreSwitch_releaseNode ( server , nodeUpdate ) ;
6,718
CWE-000 void log_vemit ( config_t * conf , int priority , const char * fmt , va_list ap ) { FILE * stream ; if ( conf -> cf_flags & CONFIG_LOG_INITIALIZED ) { # if HAVE_VSYSLOG vsyslog ( priority , fmt , ap ) ; # else char msg_buf [ LOGMSG_BUF ] ; vsnprintf ( msg_buf , sizeof ( msg_buf ) , fmt , ap ) ; msg_buf [ sizeof ( msg_buf ) - 1 ] = '\\0' ; syslog ( priority , "%s" , msg_buf ) ; # endif return ; } if ( ! ( conf -> cf_flags & CONFIG_DEBUG ) && priority > LOG_INFO ) return ; stream = priority <= LOG_WARNING ? stderr : stdout ; <S2SV_StartBug> vfprintf ( stream , fmt , ap ) ; <S2SV_EndBug> fputc ( '\\n' , stream ) ; fflush ( stream ) ; }
<S2SV_ModStart> : stdout ; fprintf ( stream , prefixes [ priority ] ) ;
6,719
CWE-000 static void enable_odl_phy_mux ( uint32_t gcid , int index ) { uint64_t reg ; uint64_t phy_config_scom ; prlog ( PR_DEBUG , "OCAPI:<S2SV_blank>%s:<S2SV_blank>Enabling<S2SV_blank>ODL<S2SV_blank>to<S2SV_blank>PHY<S2SV_blank>MUXes\\n" , __func__ ) ; switch ( index ) { case 2 : case 3 : phy_config_scom = OBUS_LL0_IOOL_PHY_CONFIG ; break ; case 4 : case 5 : phy_config_scom = OBUS_LL3_IOOL_PHY_CONFIG ; break ; default : assert ( false ) ; } xscom_read ( gcid , phy_config_scom , & reg ) ; switch ( index ) { case 2 : case 5 : reg |= OBUS_IOOL_PHY_CONFIG_ODL0_ENABLED ; break ; case 3 : case 4 : reg |= OBUS_IOOL_PHY_CONFIG_ODL1_ENABLED ; break ; } if ( platform . ocapi -> odl_phy_swap ) reg |= OBUS_IOOL_PHY_CONFIG_ODL_PHY_SWAP ; else reg &= ~ OBUS_IOOL_PHY_CONFIG_ODL_PHY_SWAP ; reg &= ~ OBUS_IOOL_PHY_CONFIG_LINK0_OLL_ENABLED ; reg &= ~ OBUS_IOOL_PHY_CONFIG_LINK1_OLL_ENABLED ; <S2SV_StartBug> reg &= ~ OBUS_IOOL_PHY_CONFIG_NV0_NPU_ENABLED ; <S2SV_EndBug> reg &= ~ OBUS_IOOL_PHY_CONFIG_NV1_NPU_ENABLED ; reg &= ~ OBUS_IOOL_PHY_CONFIG_NV2_NPU_ENABLED ; xscom_write ( gcid , phy_config_scom , reg ) ; }
<S2SV_ModStart> ~ OBUS_IOOL_PHY_CONFIG_LINK1_OLL_ENABLED ; <S2SV_ModEnd> xscom_write ( gcid
6,720
CWE-000 void selectBestState ( int * parentOne ) { int leastAttacked = - 1 ; int leastAttackedPairs = ( nqueens - 1 ) * nqueens / 2 ; for ( int i = 0 ; i < popSize ; i ++ ) { <S2SV_StartBug> if ( leastAttackedPairs > countConflicts ( i ) ) { <S2SV_EndBug> leastAttacked = i ; <S2SV_StartBug> leastAttackedPairs = countConflicts ( i ) ; <S2SV_EndBug> } } for ( int k = 0 ; k < nqueens ; k ++ ) { parentOne [ k ] = population [ leastAttacked ] [ k ] ; } }
<S2SV_ModStart> ( leastAttackedPairs > nConflicts [ i ] <S2SV_ModEnd> ) { leastAttacked <S2SV_ModStart> ; leastAttackedPairs = nConflicts [ i ] <S2SV_ModEnd> ; } }
6,721
CWE-000 static PyObject * unicode_encode_locale ( PyObject * unicode , const char * errors , int current_locale ) { _Py_error_handler error_handler = _Py_GetErrorHandler ( errors ) ; Py_ssize_t wlen ; wchar_t * wstr = PyUnicode_AsWideCharString ( unicode , & wlen ) ; if ( wstr == NULL ) { return NULL ; } Py_ssize_t wlen2 = wcslen ( wstr ) ; if ( wlen2 != wlen ) { PyMem_Free ( wstr ) ; PyErr_SetString ( PyExc_ValueError , "embedded<S2SV_blank>null<S2SV_blank>character" ) ; return NULL ; } char * str ; size_t error_pos ; const char * reason ; PyInterpreterState * interp = _PyInterpreterState_GET_UNSAFE ( ) ; int res = _Py_EncodeLocaleEx ( & interp -> core_config . ctx , wstr , & str , & error_pos , & reason , current_locale , error_handler ) ; if ( res != 0 ) { if ( res == - 2 ) { PyObject * exc ; exc = PyObject_CallFunction ( PyExc_UnicodeEncodeError , "sOnns" , "locale" , unicode , ( Py_ssize_t ) error_pos , ( Py_ssize_t ) ( error_pos + 1 ) , reason ) ; if ( exc != NULL ) { PyCodec_StrictErrors ( exc ) ; Py_DECREF ( exc ) ; } return NULL ; } else if ( res == - 3 ) { PyErr_SetString ( PyExc_ValueError , "unsupported<S2SV_blank>error<S2SV_blank>handler" ) ; } else { PyErr_NoMemory ( ) ; PyMem_Free ( wstr ) ; return NULL ; } } PyMem_Free ( wstr ) ; PyObject * bytes = PyBytes_FromString ( str ) ; <S2SV_StartBug> PyMem_RawFree ( str ) ; <S2SV_EndBug> return bytes ; }
<S2SV_ModStart> str ) ; _PyMem_RawFreeCtx ( & interp -> core_config . ctx , <S2SV_ModEnd> str ) ;
6,722
CWE-000 int cpuidle_idle_call ( void ) { struct cpuidle_device * dev = __this_cpu_read ( cpuidle_devices ) ; struct cpuidle_driver * drv ; int next_state , entered_state ; if ( off ) return - ENODEV ; if ( ! initialized ) return - ENODEV ; if ( ! dev || ! dev -> enabled ) return - EBUSY ; drv = cpuidle_get_cpu_driver ( dev ) ; <S2SV_StartBug> next_state = cpuidle_curr_governor -> select ( drv , dev ) ; <S2SV_EndBug> if ( need_resched ( ) ) { dev -> last_residency = 0 ; if ( cpuidle_curr_governor -> reflect ) cpuidle_curr_governor -> reflect ( dev , next_state ) ; local_irq_enable ( ) ; return 0 ; } trace_cpu_idle_rcuidle ( next_state , dev -> cpu ) ; if ( need_resched ( ) ) { dev -> last_residency = 0 ; local_irq_enable ( ) ; entered_state = next_state ; goto exit ; } if ( drv -> states [ next_state ] . flags & CPUIDLE_FLAG_TIMER_STOP ) clockevents_notify ( CLOCK_EVT_NOTIFY_BROADCAST_ENTER , & dev -> cpu ) ; if ( cpuidle_state_is_coupled ( dev , drv , next_state ) ) entered_state = cpuidle_enter_state_coupled ( dev , drv , next_state ) ; else entered_state = cpuidle_enter_state ( dev , drv , next_state ) ; if ( drv -> states [ next_state ] . flags & CPUIDLE_FLAG_TIMER_STOP ) clockevents_notify ( CLOCK_EVT_NOTIFY_BROADCAST_EXIT , & dev -> cpu ) ; exit : trace_cpu_idle_rcuidle ( PWR_EVENT_EXIT , dev -> cpu ) ; if ( cpuidle_curr_governor -> reflect ) cpuidle_curr_governor -> reflect ( dev , entered_state ) ; return 0 ; }
<S2SV_ModStart> , dev ) ; if ( next_state < 0 ) return - EBUSY
6,723
CWE-000 static bool decode_unix_diag_inode ( struct tcb * const tcp , const kernel_ulong_t addr , const unsigned int len , const void * const opaque_data ) { uint32_t inode ; const size_t nmemb = len / sizeof ( inode ) ; if ( ! nmemb ) return false ; print_array ( tcp , addr , nmemb , & inode , sizeof ( inode ) , <S2SV_StartBug> umoven_or_printaddr , print_inode , 0 ) ; <S2SV_EndBug> return true ; }
<S2SV_ModStart> inode ) , ucopyn_for_print <S2SV_ModEnd> , print_inode ,
6,724
CWE-000 static inline bool vector_check_bounds ( struct qb_vector * vector , const int index ) { <S2SV_StartBug> return ( index < vector -> size ) ; <S2SV_EndBug> }
<S2SV_ModStart> vector -> size && index >= 0
6,725
CWE-000 static void test_Image_2D ( void * * state ) { ( void ) state ; Image image2D ; char * * image1 = { "" } ; <S2SV_StartBug> Image_init_2D ( & image2D , 1 , 1 , image1 ) ; <S2SV_EndBug> assert_int_equal ( image2D . get_height ( & image2D ) , 1 ) ; <S2SV_StartBug> assert_int_equal ( image2D . get_width ( & image2D ) , 1 ) ; <S2SV_EndBug> assert_int_equal ( image2D . get_pixels ( & image2D ) [ 0 ] [ 0 ] , '\\0' ) ; Image image2D_2 ; char * * testString = { "test" } ; size_t lenTestString = strlen ( testString [ 0 ] ) ; Image_init_2D ( & image2D_2 , lenTestString , 1 , testString ) ; assert_int_equal ( image2D_2 . get_height ( & image2D_2 ) , 1 ) ; assert_int_equal ( image2D_2 . get_width ( & image2D_2 ) , lenTestString ) ; assert_memory_equal ( image2D_2 . get_pixels ( & image2D_2 ) [ 0 ] , testString , lenTestString ) ; Image image2D_3 ; char * * testString3 = { "AAA" , "BBB" , "CCC" } ; size_t lenTestString3 = strlen ( testString3 [ 0 ] ) ; Image_init_2D ( & image2D_3 , lenTestString3 , lenTestString3 , testString3 ) ; assert_memory_equal ( image2D_3 . get_pixels ( & image2D_3 ) [ 0 ] , "AAA" , 3 ) ; assert_memory_equal ( image2D_3 . get_pixels ( & image2D_3 ) [ 1 ] , "BBB" , 3 ) ; assert_memory_equal ( image2D_3 . get_pixels ( & image2D_3 ) [ 2 ] , "CCC" , 3 ) ; assert_int_equal ( image2D_3 . get_height ( & image2D_3 ) , lenTestString3 ) ; assert_int_equal ( image2D_3 . get_width ( & image2D_3 ) , lenTestString3 ) ; assert_memory_equal ( image2D_3 . get_pixels ( & image2D_3 ) [ 0 ] , testString3 , lenTestString3 ) ; image2D_2 . free ( & image2D_2 ) ; assert_int_equal ( image2D_2 . get_width ( & image2D_2 ) , 0 ) ; assert_int_equal ( image2D_2 . get_height ( & image2D_2 ) , 0 ) ; assert_null ( image2D_2 . get_pixels ( & image2D_2 ) ) ; }
<S2SV_ModStart> & image2D , 0 <S2SV_ModEnd> , 1 , <S2SV_ModStart> image2D ) , 0 <S2SV_ModEnd> ) ; assert_int_equal
6,726
CWE-000 void get_info ( WINDOW * win , int devid , char * address ) { myLog ( LOG_DEBUG , "--><S2SV_blank>%s" , __FUNCTION__ ) ; int _dd , _timeout = 20000 , _connected = 0 , _scroll = 0 ; bdaddr_t _bdaddr ; uint16_t _handle ; struct hci_conn_info_req * _cr ; struct hci_version _ver ; uint8_t _features [ 8 ] ; struct hci_dev_info _devinfo ; uint16_t _ptype ; char _name [ 248 ] , _buf [ MAXLEN ] ; if ( address == NULL ) { myLog ( LOG_ERR , "address<S2SV_blank>is<S2SV_blank>Null" ) ; return ; } str2ba ( address , & _bdaddr ) ; if ( ( _cr = malloc ( sizeof ( * _cr ) + sizeof ( struct hci_conn_info ) ) ) == NULL ) { myLog ( LOG_ERR , "Out<S2SV_blank>of<S2SV_blank>memory" ) ; return ; } memset ( _cr , 0 , sizeof ( * _cr ) + sizeof ( struct hci_conn_info ) ) ; memset ( _buf , 0 , MAXLEN ) ; werase ( win ) ; print_window ( win , "Information" ) ; if ( ( _dd = hci_open_dev ( devid ) ) == BT_ERROR ) { print_status ( "Can\'t<S2SV_blank>open<S2SV_blank>device" ) ; goto clear ; } bacpy ( & _cr -> bdaddr , & _bdaddr ) ; _cr -> type = ACL_LINK ; if ( ioctl ( _dd , HCIGETCONNINFO , ( unsigned long ) _cr ) == BT_ERROR ) { if ( hci_devinfo ( devid , & _devinfo ) == BT_ERROR ) { print_status ( "Can\'t<S2SV_blank>get<S2SV_blank>device<S2SV_blank>information" ) ; goto clear ; } _ptype = htobs ( _devinfo . pkt_type & ACL_PTYPE_MASK ) ; if ( hci_create_connection ( _dd , & _bdaddr , _ptype , 0 , 1 , & _handle , 25000 ) == BT_ERROR ) { print_status ( "Unable<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>device" ) ; goto clear ; } _connected = 1 ; } else { _handle = htobs ( _cr -> conn_info -> handle ) ; } if ( hci_read_remote_name ( _dd , & _bdaddr , ( sizeof ( _name ) - 1 ) , _name , 100000 ) == BT_ERROR ) { strncpy ( _name , "Unknow" , sizeof ( _name ) - 1 ) ; } snprintf ( ( _buf + strlen ( _buf ) ) , ( MAXLEN - strlen ( _buf ) - 1 ) , "Device<S2SV_blank>Name:<S2SV_blank>%s\\n" , _name ) ; if ( hci_read_remote_version ( _dd , _handle , & _ver , _timeout ) != BT_ERROR ) { snprintf ( ( _buf + strlen ( _buf ) ) , ( MAXLEN - strlen ( _buf ) - 1 ) , "Version:<S2SV_blank>%s\\nSubversion:<S2SV_blank>0x%x\\nManufacture:<S2SV_blank>%s\\n" , lmp_vertostr ( _ver . lmp_ver ) , _ver . lmp_subver , bt_compidtostr ( _ver . manufacturer ) ) ; } if ( hci_read_remote_features ( _dd , _handle , _features , _timeout ) != BT_ERROR ) { snprintf ( ( _buf + strlen ( _buf ) ) , ( MAXLEN - strlen ( _buf ) - 1 ) , "Features:\\n%s\\n" , lmp_featurestostr ( _features , "\\t\\t" , 50 ) ) ; } print_text ( win , _buf , _scroll ) ; print_window ( win , "Information" ) ; while ( TRUE ) { switch ( wgetch ( win ) ) { case KEY_UP : { if ( _scroll > 0 ) { _scroll -- ; } break ; } case KEY_DOWN : { _scroll ++ ; break ; } default : { goto clear ; } } werase ( win ) ; print_text ( win , _buf , _scroll ) ; print_window ( win , "Information" ) ; } clear : werase ( win ) ; wrefresh ( win ) ; if ( _connected ) { hci_disconnect ( _dd , _handle , HCI_OE_USER_ENDED_CONNECTION , _timeout ) ; } <S2SV_StartBug> close ( _dd ) ; <S2SV_EndBug> }
<S2SV_ModStart> ) ; } free ( _cr ) ;
6,727
CWE-000 static void rtwn_newassoc ( struct ieee80211_node * ni , int isnew __unused ) { struct rtwn_softc * sc = ni -> ni_ic -> ic_softc ; struct rtwn_node * un = RTWN_NODE ( ni ) ; int id ; if ( un -> id != RTWN_MACID_UNDEFINED ) return ; RTWN_NT_LOCK ( sc ) ; for ( id = 0 ; id <= sc -> macid_limit ; id ++ ) { if ( id != RTWN_MACID_BC && sc -> node_list [ id ] == NULL ) { un -> id = id ; sc -> node_list [ id ] = ni ; break ; } } RTWN_NT_UNLOCK ( sc ) ; if ( id > sc -> macid_limit ) { device_printf ( sc -> sc_dev , "%s:<S2SV_blank>node<S2SV_blank>table<S2SV_blank>is<S2SV_blank>full\\n" , __func__ ) ; return ; } <S2SV_StartBug> # ifndef RTWN_WITHOUT_UCODE <S2SV_EndBug> id |= RTWN_MACID_VALID ; rtwn_cmd_sleepable ( sc , & id , sizeof ( id ) , rtwn_set_media_status ) ; <S2SV_StartBug> # endif <S2SV_EndBug> }
<S2SV_ModStart> return ; } <S2SV_ModEnd> id |= RTWN_MACID_VALID <S2SV_ModStart> rtwn_set_media_status ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
6,728
CWE-000 void pg_set_regex_collation ( Oid collation ) { if ( lc_ctype_is_c ( collation ) ) { pg_regex_strategy = PG_REGEX_LOCALE_C ; pg_regex_locale = 0 ; } else { if ( collation == DEFAULT_COLLATION_OID ) pg_regex_locale = 0 ; else if ( OidIsValid ( collation ) ) { pg_regex_locale = pg_newlocale_from_collation ( collation ) ; } else { <S2SV_StartBug> ereport ( ERROR , <S2SV_EndBug> ( errcode ( ERRCODE_INDETERMINATE_COLLATION ) , errmsg ( "could<S2SV_blank>not<S2SV_blank>determine<S2SV_blank>which<S2SV_blank>collation<S2SV_blank>to<S2SV_blank>use<S2SV_blank>for<S2SV_blank>regular<S2SV_blank>expression" ) , errhint ( "Use<S2SV_blank>the<S2SV_blank>COLLATE<S2SV_blank>clause<S2SV_blank>to<S2SV_blank>set<S2SV_blank>the<S2SV_blank>collation<S2SV_blank>explicitly." ) ) ) ; } # ifdef USE_WIDE_UPPER_LOWER if ( GetDatabaseEncoding ( ) == PG_UTF8 ) { if ( pg_regex_locale ) pg_regex_strategy = PG_REGEX_LOCALE_WIDE_L ; else pg_regex_strategy = PG_REGEX_LOCALE_WIDE ; } else # endif { if ( pg_regex_locale ) pg_regex_strategy = PG_REGEX_LOCALE_1BYTE_L ; else pg_regex_strategy = PG_REGEX_LOCALE_1BYTE ; } } }
<S2SV_ModStart> { ereport ( WARNING <S2SV_ModEnd> , ( errcode
6,729
CWE-000 static char * * create_tmp_env ( t_sh * sh , int size , t_token * token ) { char * * tmp_env ; int i ; if ( ! token ) { sh -> current_token = NULL ; return ( NULL ) ; } else if ( size == 1 ) { token = text_rules ( sh ) ; return ( NULL ) ; } if ( ft_strcmp ( token -> value , "env" ) ) ++ size ; tmp_env = ( char * * ) malloc ( sizeof ( char * ) * size ) ; tmp_env [ size - 1 ] = NULL ; i = 0 ; -- size ; <S2SV_StartBug> while ( i ++ < size ) <S2SV_EndBug> { token = text_rules ( sh ) ; <S2SV_StartBug> tmp_env [ i ] = token -> value ; <S2SV_EndBug> } return ( tmp_env ) ; }
<S2SV_ModStart> while ( i <S2SV_ModEnd> < size ) <S2SV_ModStart> tmp_env [ i ++
6,730
CWE-000 static int write ( devfs_dev_t * dev , fs_filed_t * fd , void * buf , size_t n ) { <S2SV_StartBug> n = ringbuf_write ( & loop_buf , buf , n ) ; <S2SV_EndBug> DEBUG ( "copy<S2SV_blank>to<S2SV_blank>buffer<S2SV_blank>\\"%*.*s\\"\\n" , n , n , buf ) ; return n ; }
<S2SV_ModStart> ringbuf_write ( & buf <S2SV_ModEnd> , buf ,
6,731
CWE-000 esp_err_t touch_pad_read ( touch_pad_t touch_num , uint16_t * touch_value ) { RTC_MODULE_CHECK ( touch_num < TOUCH_PAD_MAX , "Touch_Pad<S2SV_blank>Num<S2SV_blank>Err" , ESP_ERR_INVALID_ARG ) ; <S2SV_StartBug> RTC_MODULE_CHECK ( touch_value != NULL , "touch_value" , ESP_ERR_INVALID_ARG ) ; <S2SV_EndBug> uint32_t v0 = READ_PERI_REG ( SENS_SAR_TOUCH_ENABLE_REG ) ; portENTER_CRITICAL ( & rtc_spinlock ) ; SET_PERI_REG_MASK ( SENS_SAR_TOUCH_ENABLE_REG , ( 1 << ( touch_num ) ) ) ; CLEAR_PERI_REG_MASK ( SENS_SAR_TOUCH_ENABLE_REG , ( 1 << ( touch_num + SENS_TOUCH_PAD_OUTEN2_S ) ) | ( ( 1 << ( touch_num + SENS_TOUCH_PAD_OUTEN1_S ) ) ) ) ; toch_pad_io_init ( touch_num ) ; touch_pad_counter_init ( touch_num ) ; touch_pad_power_on ( touch_num ) ; SET_PERI_REG_MASK ( SENS_SAR_TOUCH_CTRL2_REG , SENS_TOUCH_START_EN_M ) ; SET_PERI_REG_MASK ( SENS_SAR_TOUCH_CTRL2_REG , SENS_TOUCH_START_FORCE_M ) ; SET_PERI_REG_BITS ( SENS_SAR_TOUCH_CTRL1_REG , SENS_TOUCH_XPD_WAIT , 10 , SENS_TOUCH_XPD_WAIT_S ) ; <S2SV_StartBug> while ( GET_PERI_REG_MASK ( SENS_SAR_TOUCH_CTRL2_REG , SENS_TOUCH_MEAS_DONE ) == 0 ) { } ; <S2SV_EndBug> uint8_t shift = ( touch_num & 1 ) ? SENS_TOUCH_MEAS_OUT1_S : SENS_TOUCH_MEAS_OUT0_S ; * touch_value = READ_PERI_REG ( SENS_SAR_TOUCH_OUT1_REG + ( touch_num / 2 ) * 4 ) >> shift ; WRITE_PERI_REG ( SENS_SAR_TOUCH_ENABLE_REG , v0 ) ; <S2SV_StartBug> CLEAR_PERI_REG_MASK ( SENS_SAR_TOUCH_CTRL2_REG , SENS_TOUCH_START_EN_M ) ; <S2SV_EndBug> CLEAR_PERI_REG_MASK ( SENS_SAR_TOUCH_CTRL2_REG , SENS_TOUCH_START_FORCE_M ) ; <S2SV_StartBug> portEXIT_CRITICAL ( & rtc_spinlock ) ; <S2SV_EndBug> return ESP_OK ; }
<S2SV_ModStart> "touch_value" , ESP_ERR_INVALID_ARG ) ; RTC_MODULE_CHECK ( rtc_touch_sem != NULL , "Touch<S2SV_blank>pad<S2SV_blank>not<S2SV_blank>initialized" , ESP_FAIL ) ; xSemaphoreTake ( rtc_touch_sem , portMAX_DELAY <S2SV_ModStart> SENS_TOUCH_XPD_WAIT_S ) ; portEXIT_CRITICAL ( & rtc_spinlock ) ; <S2SV_ModStart> v0 ) ; portENTER_CRITICAL ( & rtc_spinlock ) ; <S2SV_ModStart> ( & rtc_spinlock ) ; xSemaphoreGive ( rtc_touch_sem
6,732
CWE-000 static void imx6_pcie_init_phy ( struct pcie_port * pp ) { int ret ; struct imx6_pcie * imx6_pcie = to_imx6_pcie ( pp ) ; if ( is_imx7d_pcie ( imx6_pcie ) ) { regulator_set_voltage ( imx6_pcie -> pcie_phy_regulator , <S2SV_StartBug> 1030000 , 1030000 ) ; <S2SV_EndBug> ret = regulator_enable ( imx6_pcie -> pcie_phy_regulator ) ; if ( ret ) dev_err ( pp -> dev , "failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>pcie<S2SV_blank>regulator.\\n" ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , BIT ( 5 ) , imx6_pcie -> phy_refclk ? BIT ( 5 ) : 0 ) ; regmap_update_bits ( imx6_pcie -> reg_src , 0x2c , BIT ( 1 ) , 0 ) ; regmap_update_bits ( imx6_pcie -> reg_src , 0x2c , BIT ( 2 ) , 0 ) ; regmap_update_bits ( imx6_pcie -> reg_src , 0x2c , BIT ( 6 ) , 0 ) ; } else if ( is_imx6sx_pcie ( imx6_pcie ) ) { regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR5 , IMX6SX_GPR5_PCIE_BTNRST , IMX6SX_GPR5_PCIE_BTNRST ) ; regulator_set_voltage ( imx6_pcie -> pcie_phy_regulator , 1100000 , 1100000 ) ; ret = regulator_enable ( imx6_pcie -> pcie_phy_regulator ) ; if ( ret ) dev_err ( pp -> dev , "failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>pcie<S2SV_blank>regulator.\\n" ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , IMX6SX_GPR12_RX_EQ_MASK , IMX6SX_GPR12_RX_EQ_2 ) ; } if ( imx6_pcie -> pcie_bus_regulator != NULL ) { ret = regulator_enable ( imx6_pcie -> pcie_bus_regulator ) ; if ( ret ) dev_err ( pp -> dev , "failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>pcie<S2SV_blank>regulator.\\n" ) ; } if ( ! is_imx7d_pcie ( imx6_pcie ) ) { regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , IMX6Q_GPR12_PCIE_CTL_2 , 0 << 10 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , IMX6Q_GPR12_LOS_LEVEL , IMX6Q_GPR12_LOS_LEVEL_9 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR8 , IMX6Q_GPR8_TX_DEEMPH_GEN1 , 20 << 0 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR8 , IMX6Q_GPR8_TX_DEEMPH_GEN2_3P5DB , 20 << 6 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR8 , IMX6Q_GPR8_TX_DEEMPH_GEN2_6DB , 20 << 12 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR8 , IMX6Q_GPR8_TX_SWING_FULL , 115 << 18 ) ; regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR8 , IMX6Q_GPR8_TX_SWING_LOW , 115 << 25 ) ; } if ( IS_ENABLED ( CONFIG_EP_MODE_IN_EP_RC_SYS ) ) regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , IMX6Q_GPR12_DEVICE_TYPE , PCI_EXP_TYPE_ENDPOINT << 12 ) ; else regmap_update_bits ( imx6_pcie -> iomuxc_gpr , IOMUXC_GPR12 , IMX6Q_GPR12_DEVICE_TYPE , PCI_EXP_TYPE_ROOT_PORT << 12 ) ; }
<S2SV_ModStart> -> pcie_phy_regulator , 1000000 , 1000000 <S2SV_ModEnd> ) ; ret
6,733
CWE-000 int timebar_click ( int x , int y ) { <S2SV_StartBug> if ( screenHeight - y < VP_timebar . height && nglobal_times > 0 ) { <S2SV_EndBug> int timebar_right_pos ; int timebar_left_pos ; timebar_left_pos = VP_timebar . left + timebar_left_width ; timebar_right_pos = VP_timebar . right - timebar_right_width ; if ( timebar_right_pos > timebar_left_pos ) { itimes = ( float ) nglobal_times * ( float ) ( x - timebar_left_pos ) / ( float ) ( timebar_right_pos - timebar_left_pos ) ; } else { itimes = 0 ; } checktimebound ( ) ; timebar_drag = 1 ; stept = 0 ; Idle_CB ( ) ; return 1 ; } return 0 ; }
<S2SV_ModStart> - y < titlesafe_offset +
6,734
CWE-000 static int mt7697_wext_siwencodeext ( struct net_device * ndev , struct iw_request_info * info , struct iw_point * erq , char * extra ) { struct mt7697_cfg80211_info * cfg = mt7697_priv ( ndev ) ; struct wireless_dev * wdev = ndev -> ieee80211_ptr ; struct mt7697_vif * vif = mt7697_vif_from_wdev ( wdev ) ; struct iw_encode_ext * ext = ( struct iw_encode_ext * ) extra ; int ret = 0 ; dev_dbg ( cfg -> dev , "%s():<S2SV_blank>iftype(%u)\\n" , __func__ , wdev -> iftype ) ; if ( wdev -> iftype != NL80211_IFTYPE_STATION && wdev -> iftype != NL80211_IFTYPE_AP ) { dev_err ( cfg -> dev , "%s():<S2SV_blank>iftype(%d)<S2SV_blank>not<S2SV_blank>supported\\n" , __func__ , wdev -> iftype ) ; ret = - EOPNOTSUPP ; goto cleanup ; } dev_dbg ( cfg -> dev , "%s():<S2SV_blank>alg(%u)\\n" , __func__ , ext -> alg ) ; if ( ext -> alg == IW_ENCODE_ALG_PMK ) { print_hex_dump ( KERN_DEBUG , DRVNAME "<S2SV_blank>PMK<S2SV_blank>" , DUMP_PREFIX_OFFSET , 16 , 1 , ext -> key , ext -> key_len , 0 ) ; memcpy ( vif -> pmk , ext -> key , ext -> key_len ) ; <S2SV_StartBug> if ( wdev -> iftype == NL80211_IFTYPE_AP ) { <S2SV_EndBug> ret = mt7697_wr_set_security_mode_req ( cfg , MT7697_WIFI_AUTH_MODE_WPA2_PSK , MT7697_WIFI_ENCRYPT_TYPE_AES_ENABLED ) ; if ( ret < 0 ) { dev_err ( cfg -> dev , "%s():<S2SV_blank>mt7697_wr_set_security_mode_req()<S2SV_blank>failed(%d)\\n" , __func__ , ret ) ; goto cleanup ; } } } cleanup : return ret ; }
<S2SV_ModStart> key_len ) ; <S2SV_ModEnd> } cleanup :
6,735
CWE-000 static SSIZE_T nio_ethernet_recv ( nio_ethernet_t * nio_ethernet , void * pkt , SSIZE_T max_len ) { struct pcap_pkthdr * pkt_info ; const u_char * pkt_data ; SSIZE_T rlen ; <S2SV_StartBug> int res ; <S2SV_EndBug> timedout : <S2SV_StartBug> res = pcap_next_ex ( nio_ethernet -> pcap_dev , & pkt_info , & pkt_data ) ; <S2SV_EndBug> if ( res == 0 ) { goto timedout ; } if ( res == - 1 ) { fprintf ( stderr , "pcap_next_ex:<S2SV_blank>%s\\n" , pcap_geterr ( nio_ethernet -> pcap_dev ) ) ; return ( - 1 ) ; } <S2SV_StartBug> rlen = m_min ( max_len , pkt_info -> caplen ) ; <S2SV_EndBug> memcpy ( pkt , pkt_data , rlen ) ; return ( rlen ) ; }
<S2SV_ModStart> ; int res = 0 ; while ( res == 0 ) { <S2SV_ModEnd> res = pcap_next_ex <S2SV_ModStart> & pkt_data ) <S2SV_ModEnd> ; } if <S2SV_ModStart> ( max_len , ( SSIZE_T )
6,736
CWE-000 void config_set_value ( t_config * self , char * key , char * value ) { <S2SV_StartBug> t_dictionary * dictionary = self -> properties ; <S2SV_EndBug> if ( dictionary_has_key ( dictionary , key ) ) { void * element = dictionary_remove ( dictionary , key ) ; free ( element ) ; } <S2SV_StartBug> dictionary_put ( self -> properties , key , value ) ; <S2SV_EndBug> }
<S2SV_ModStart> self -> properties ; char * duplicate_key ; char * duplicate_value ; duplicate_key = string_duplicate ( key ) ; duplicate_value = string_duplicate ( value ) <S2SV_ModStart> -> properties , duplicate_key , ( void * ) duplicate_value <S2SV_ModEnd> ) ; }
6,737
CWE-000 size_t binary_tree_height ( const binary_tree_t * tree ) { size_t count = 0 , count2 = 0 ; <S2SV_StartBug> if ( ( tree == NULL ) || ( tree -> left == NULL && tree -> right == NULL ) ) <S2SV_EndBug> <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> if ( binary_tree_is_leaf ( tree -> left ) != 1 ) <S2SV_StartBug> { <S2SV_EndBug> ++ count ; binary_tree_height ( tree -> left ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( binary_tree_is_leaf ( tree -> right ) != 1 ) <S2SV_StartBug> { <S2SV_EndBug> ++ count ; <S2SV_StartBug> binary_tree_height ( tree -> right ) ; <S2SV_EndBug> } if ( count >= count2 ) return ( count ) ; return ( count2 ) ; }
<S2SV_ModStart> ; if ( <S2SV_ModEnd> tree == NULL <S2SV_ModStart> tree == NULL <S2SV_ModEnd> ) return ( <S2SV_ModStart> 0 ) ; if ( tree -> left != NULL ) { <S2SV_ModStart> != 1 ) <S2SV_ModEnd> ++ count ; <S2SV_ModStart> left ) ; ++ count ; } if ( tree -> right != NULL ) { <S2SV_ModEnd> if ( binary_tree_is_leaf <S2SV_ModStart> != 1 ) ++ count2 <S2SV_ModEnd> ; binary_tree_height ( <S2SV_ModStart> -> right ) ; ++ count2
6,738
CWE-000 <S2SV_StartBug> static void _on_timer_retry ( void * source , zRPC_event event , void * param ) { <S2SV_EndBug> zRPC_resolved_param * resolved_param = param ; zRPC_resolved * resolved = resolved_param -> resolved ; blocking_resolve_address_impl ( resolved -> resolve_name , & resolved -> inetaddres ) ; if ( & resolved -> inetaddres . naddrs != 0 ) { free ( resolved_param ) ; complete_runnable ( resolved ) ; } else { zRPC_timespec deadline = zRPC_now ( zRPC_CLOCK_MONOTONIC ) ; deadline = zRPC_time_add ( deadline , zRPC_time_from_seconds ( 10 , zRPC_CLOCK_MONOTONIC ) ) ; <S2SV_StartBug> resolved -> retry_timer = zRPC_timer_create ( resolved_param -> scheduler , deadline ) ; <S2SV_EndBug> <S2SV_StartBug> zRPC_source_register_listener ( & resolved -> retry_timer -> source , EV_TIMER , 1 , _on_timer_retry , param ) ; <S2SV_EndBug> <S2SV_StartBug> zRPC_scheduler_register_source ( resolved_param -> scheduler , & resolved -> retry_timer -> source ) ; <S2SV_EndBug> } }
<S2SV_ModStart> void _on_timer_retry ( zRPC_timespec deadline <S2SV_ModEnd> , void * <S2SV_ModStart> resolved_param -> scheduler ) ; zRPC_timer_deadline ( <S2SV_ModEnd> resolved -> retry_timer <S2SV_ModStart> resolved -> retry_timer , deadline <S2SV_ModEnd> , _on_timer_retry , <S2SV_ModStart> param ) ; <S2SV_ModEnd> } } <S2SV_null>
6,739
CWE-000 static ssize_t hwmon_attr_show ( struct device * dev , struct device_attribute * devattr , char * buf ) { struct hwmon_device_attribute * hattr = to_hwmon_attr ( devattr ) ; long val ; int ret ; ret = hattr -> ops -> read ( dev , hattr -> type , hattr -> attr , hattr -> index , & val ) ; if ( ret < 0 ) return ret ; <S2SV_StartBug> return sprintf ( buf , "%ld\\n" , val ) ; <S2SV_EndBug> }
<S2SV_ModStart> return ret ; trace_hwmon_attr_show ( hattr -> index + hwmon_attr_base ( hattr -> type ) , hattr -> name , val ) ;
6,740
CWE-000 static int lo_init_request ( struct blk_mq_tag_set * set , struct request * rq , unsigned int hctx_idx , unsigned int numa_node ) { <S2SV_StartBug> struct loop_cmd * cmd = blk_mq_rq_to_pdu ( rq ) ; <S2SV_EndBug> cmd -> rq = rq ; kthread_init_work ( & cmd -> work , loop_queue_work ) ; return 0 ; }
<S2SV_ModStart> ) { struct lo_cmd <S2SV_ModEnd> * cmd =
6,741
CWE-000 bool isMyKingSafe ( boardGame * board ) { assert ( board != NULL ) ; bool safe = false ; int position = - 1 ; if ( board -> curPlayer == 1 ) { position = trackKingPosition ( board , WhiteKing ) ; if ( position == - 1 ) { printf ( "whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found" ) ; return true ; } safe = safeArea ( board , position , WhiteKing ) ; <S2SV_StartBug> } <S2SV_EndBug> else if ( board -> curPlayer == 0 ) { position = trackKingPosition ( board , BlackKing ) ; if ( position == - 1 ) { printf ( "whiteKing<S2SV_blank>wasn\'t<S2SV_blank>found" ) ; return true ; } safe = safeArea ( board , position , BlackKing ) ; } return safe ; }
<S2SV_ModStart> WhiteKing ) ; if ( ! safe ) printf ( "not<S2SV_blank>safe\\n" ) ;
6,742
CWE-000 static void init_shared_dict ( DictInfo * info , char * dictFile , char * affFile , char * stopFile ) { int size ; SharedIspellDict * shdict = NULL ; SharedStopList * shstop = NULL ; <S2SV_StartBug> IspellDict * dict ; <S2SV_EndBug> StopList stoplist ; shdict = get_shared_dict ( dictFile , affFile ) ; clean_dict_affix ( & ( info -> dict ) ) ; NIStartBuild ( & ( info -> dict ) ) ; NIImportAffixes ( & ( info -> dict ) , get_tsearch_config_filename ( affFile , "affix" ) ) ; if ( shdict == NULL ) <S2SV_StartBug> { <S2SV_EndBug> dict = ( IspellDict * ) palloc0 ( sizeof ( IspellDict ) ) ; NIStartBuild ( dict ) ; NIImportDictionary ( dict , get_tsearch_config_filename ( dictFile , "dict" ) ) ; dict -> usecompound = info -> dict . usecompound ; dict -> nCompoundAffixFlag = dict -> mCompoundAffixFlag = info -> dict . nCompoundAffixFlag ; dict -> CompoundAffixFlags = ( CompoundAffixFlag * ) palloc0 ( dict -> nCompoundAffixFlag * sizeof ( CompoundAffixFlag ) ) ; memcpy ( dict -> CompoundAffixFlags , info -> dict . CompoundAffixFlags , dict -> nCompoundAffixFlag * sizeof ( CompoundAffixFlag ) ) ; if ( info -> dict . useFlagAliases ) { int i ; dict -> useFlagAliases = true ; dict -> lenAffixData = info -> dict . lenAffixData ; dict -> nAffixData = info -> dict . nAffixData ; dict -> AffixData = ( char * * ) palloc0 ( dict -> nAffixData * sizeof ( char * ) ) ; for ( i = 0 ; i < dict -> nAffixData ; i ++ ) { dict -> AffixData [ i ] = palloc0 ( strlen ( info -> dict . AffixData [ i ] ) + 1 ) ; strcpy ( dict -> AffixData [ i ] , info -> dict . AffixData [ i ] ) ; } } NISortDictionary ( dict ) ; NIFinishBuild ( dict ) ; size = sizeIspellDict ( dict , dictFile , affFile ) ; if ( size > segment_info -> available ) elog ( ERROR , "shared<S2SV_blank>dictionary<S2SV_blank>%s.dict<S2SV_blank>/<S2SV_blank>%s.affix<S2SV_blank>needs<S2SV_blank>%d<S2SV_blank>B,<S2SV_blank>only<S2SV_blank>%zd<S2SV_blank>B<S2SV_blank>available" , dictFile , affFile , size , segment_info -> available ) ; shdict = copyIspellDict ( dict , dictFile , affFile , size , dict -> nspell ) ; shdict -> dict . naffixes = info -> dict . naffixes ; shdict -> next = segment_info -> shdict ; segment_info -> shdict = shdict ; } info -> dict . lenAffixData = shdict -> dict . lenAffixData ; info -> dict . nAffixData = shdict -> dict . nAffixData ; info -> dict . AffixData = shdict -> dict . AffixData ; info -> dict . Dictionary = shdict -> dict . Dictionary ; NISortAffixes ( & ( info -> dict ) ) ; NIFinishBuild ( & ( info -> dict ) ) ; if ( stopFile && * stopFile ) { shstop = get_shared_stop_list ( stopFile ) ; if ( shstop == NULL ) { <S2SV_StartBug> readstoplist ( stopFile , & stoplist , lowerstr ) ; <S2SV_EndBug> size = sizeStopList ( & stoplist , stopFile ) ; if ( size > segment_info -> available ) elog ( ERROR , "shared<S2SV_blank>stoplist<S2SV_blank>%s.stop<S2SV_blank>needs<S2SV_blank>%d<S2SV_blank>B,<S2SV_blank>only<S2SV_blank>%zd<S2SV_blank>B<S2SV_blank>available" , stopFile , size , segment_info -> available ) ; shstop = copyStopList ( & stoplist , stopFile , size ) ; shstop -> next = segment_info -> shstop ; segment_info -> shstop = shstop ; } } info -> shdict = shdict ; info -> shstop = shstop ; info -> lookup = GetCurrentTimestamp ( ) ; memcpy ( info -> dictFile , dictFile , strlen ( dictFile ) + 1 ) ; <S2SV_StartBug> memcpy ( info -> affixFile , dictFile , strlen ( affFile ) + 1 ) ; <S2SV_EndBug> if ( stopFile != NULL ) <S2SV_StartBug> memcpy ( info -> stopFile , dictFile , strlen ( stopFile ) + 1 ) ; <S2SV_EndBug> else memset ( info -> stopFile , 0 , sizeof ( info -> stopFile ) ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> = NULL ; <S2SV_ModEnd> shdict = get_shared_dict <S2SV_ModStart> NULL ) { IspellDict * dict ; <S2SV_ModStart> NULL ) { StopList stoplist ; <S2SV_ModStart> -> affixFile , affFile <S2SV_ModEnd> , strlen ( <S2SV_ModStart> -> stopFile , stopFile <S2SV_ModEnd> , strlen ( <S2SV_ModStart> ) ) ; info -> saveCntx = CurrentMemoryContext ;
6,743
CWE-000 s_map * * filenames_to_table ( char * * filenames ) { int y ; int i ; s_map * * files ; i = 0 ; y = i ; if ( ! ( files = ( s_map * * ) malloc ( sizeof ( s_map * ) * MAX_FILES_PER_DIR + 1 ) ) ) error ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory.<S2SV_blank>(Filenames<S2SV_blank>to<S2SV_blank>table)\\n" , 1 ) ; while ( filenames [ y ] != NULL ) { <S2SV_StartBug> if ( ( files [ i ] = create_file_node ( filenames [ y ] , filenames [ y ] ) ) != NULL ) <S2SV_EndBug> i ++ ; y ++ ; } files [ i ] = NULL ; return ( files ) ; }
<S2SV_ModStart> NULL ) { my_printf_fd ( 1 , "Creating<S2SV_blank>node<S2SV_blank>for<S2SV_blank>:<S2SV_blank>%s\\n" , filenames [ y ] ) ;
6,744
CWE-000 static void test_string_strappstream ( void ) { <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> void ) { struct cap_string * s = cap_strnew ( ) ; assert ( s != NULL ) ; cap_strdel ( s ) ;
6,745
CWE-000 void vm_init ( struct VM * vm , char * filepath , char * filename , struct GarbageCollector * gc ) { vm -> valueStack = valuestack_make ( ) ; vm -> callStack = valuestack_make ( ) ; vm -> envStack = envstack_make ( ) ; envstack_push ( vm -> envStack , 0 ) ; vm -> globalEnv = malloc ( sizeof ( struct Env ) ) ; * vm -> globalEnv = * envstack_peek ( vm -> envStack ) ; * vm -> globalEnv -> inUse = 1 ; vm -> gc = gc ; <S2SV_StartBug> vm -> contextStack = contextstack_make ( ) ; <S2SV_EndBug> vm -> dir = ( uint8_t * ) filepath ; <S2SV_StartBug> struct Value * dummy = value_make ( FUN ) ; <S2SV_EndBug> dummy -> funEnvStack = vm -> envStack ; valuestack_push ( vm -> callStack , dummy ) ; char * file ; uint64_t pathlen = strlen ( filepath ) ; uint64_t namelen = strlen ( filename ) ; file = malloc ( pathlen + namelen + 1 ) ; strcpy ( file , filepath ) ; strcat ( file , filename ) ; file [ pathlen + namelen ] = 0 ; FILE * f = fopen ( file , "r" ) ; fseek ( f , 0 , SEEK_END ) ; uint64_t filesize = ftell ( f ) ; rewind ( f ) ; vm -> mainMemSize = filesize ; vm -> mainMem = malloc ( sizeof ( uint8_t ) * filesize ) ; for ( uint64_t i = 0 ; i < filesize ; i ++ ) vm -> mainMem [ i ] = fgetc ( f ) ; fclose ( f ) ; free ( file ) ; vm -> pc = 0 ; vm -> halt = 0 ; vm -> lastCleaned = 0 ; vm -> debug = VM_DEBUG ; vm -> debugValueStack = VM_DEBUGVALUESTACK ; vm -> debugCallStack = VM_DEBUGCALLSTACK ; vm -> debugEnvStacks = VM_DEBUGENVSTACKS ; vm -> debugGarbage = VM_DEBUGGARBAGE ; vm -> cleanPeriod = VM_CLEANPERIOD ; vm -> maxCallStack = VM_MAXCALLSTACK ; exec_func [ AND ] = exec_and ; exec_func [ OR ] = exec_or ; exec_func [ NOT ] = exec_not ; exec_func [ LT ] = exec_lt ; exec_func [ LTE ] = exec_lte ; exec_func [ GT ] = exec_gt ; exec_func [ GTE ] = exec_gte ; exec_func [ NE ] = exec_ne ; exec_func [ EQ ] = exec_eq ; exec_func [ ADD ] = exec_add ; exec_func [ SUB ] = exec_sub ; exec_func [ MUL ] = exec_mul ; exec_func [ DIV ] = exec_div ; exec_func [ PLUS ] = exec_plus ; exec_func [ MINUS ] = exec_minus ; exec_func [ FUN_CALL ] = exec_fun_call ; exec_func [ GET_ATTR ] = exec_get_attr ; exec_func [ ARR_IDX ] = exec_arr_idx ; exec_func [ LOAD_INT ] = exec_load_int ; exec_func [ LOAD_FLOAT ] = exec_load_float ; exec_func [ LOAD_NAME ] = exec_load_name ; exec_func [ LOAD_BOOL ] = exec_load_bool ; exec_func [ LOAD_NULL ] = exec_load_null ; exec_func [ LOAD_STRING ] = exec_load_string ; exec_func [ MAKE_FUN ] = exec_make_fun ; exec_func [ MAKE_STRUCT ] = exec_make_struct ; exec_func [ MAKE_ARR ] = exec_make_arr ; exec_func [ PUSH_ENV ] = exec_push_env ; exec_func [ POP_ENV ] = exec_pop_env ; exec_func [ ASSIGN_NAME ] = exec_assign_name ; exec_func [ STORE_ARR ] = exec_store_arr ; exec_func [ STORE_ATTR ] = exec_store_attr ; exec_func [ STORE_NAME ] = exec_store_name ; exec_func [ RETURN ] = exec_return ; exec_func [ PRINT ] = exec_print ; exec_func [ USE_FILE ] = exec_use_file ; exec_func [ BTRUE ] = exec_btrue ; exec_func [ BFALSE ] = exec_bfalse ; exec_func [ JMP ] = exec_jmp ; exec_func [ HALT ] = exec_halt ; exec_func [ LEN_ARR ] = exec_len_arr ; vmerror_vm = vm ; }
<S2SV_ModStart> = gc ; value_gc = gc ; <S2SV_ModStart> value_make ( FUN ) ; dummy -> funValue = 0 ; dummy -> funArgc = 0 ; dummy -> funArgs = malloc ( 1 ) ; dummy -> funClosureStack = valuestack_make (
6,746
CWE-000 static int get_free_inum ( struct fsmem * fsm , fs_u64_t * inump ) { fs_u64_t off = 0 , blkno , len ; fs_u64_t inum = 0 ; fs_u32_t rd ; char * buf = NULL , bit ; int i , j , error = 0 , nbytes = 0 ; * inump = 0 ; if ( ( fsm -> fsm_imapip -> mino_size << 3 ) > fsm -> fsm_sb -> iused ) { buf = ( char * ) malloc ( ONE_K ) ; if ( ! buf ) { fprintf ( stderr , "ERROR:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>" "for<S2SV_blank>imap<S2SV_blank>buffer\\n" ) ; return ENOMEM ; } memset ( buf , 0 , ONE_K ) ; while ( 1 ) { if ( off >= fsm -> fsm_imapip -> mino_size ) { assert ( 0 ) ; free ( buf ) ; return EINVAL ; } if ( ( rd = internal_read ( fsm -> fsm_devfd , fsm -> fsm_imapip , buf , off , ONE_K ) ) != ONE_K ) { fprintf ( stderr , "ERROR:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>imap<S2SV_blank>" "file<S2SV_blank>for<S2SV_blank>%s\\n" , fsm -> fsm_mntpt ) ; return errno ; } for ( i = 0 ; i < ONE_K ; i ++ ) { <S2SV_StartBug> printf ( "buf[%d]<S2SV_blank>=<S2SV_blank>%d\\n" , i , buf [ i ] ) ; <S2SV_EndBug> if ( buf [ i ] != 0 ) { break ; } } <S2SV_StartBug> inum += ( fs_u64_t ) i << 3 ; <S2SV_EndBug> printf ( "inum<S2SV_blank>value:<S2SV_blank>%llu\\n" , inum ) ; if ( i != ONE_K ) { for ( bit = 1 , j = 0 ; j < 8 ; j ++ ) { if ( bit & buf [ i ] ) { buf [ i ] &= ~ bit ; break ; } <S2SV_StartBug> bit <<= 1 ; <S2SV_EndBug> printf ( "In<S2SV_blank>the<S2SV_blank>loop\\n" ) ; inum ++ ; } break ; } off += ONE_K ; } fprintf ( stdout , "Found<S2SV_blank>the<S2SV_blank>inode<S2SV_blank>%llu<S2SV_blank>free\\n" , inum ) ; if ( metadata_write ( fsm , off , buf , ONE_K , fsm -> fsm_imapip ) != ONE_K ) { error = errno ; free ( buf ) ; return error ; } fsm -> fsm_sb -> iused ++ ; lseek ( fsm -> fsm_devfd , SB_OFFSET , SEEK_SET ) ; if ( write ( fsm -> fsm_devfd , fsm -> fsm_sb , sizeof ( struct super_block ) ) != sizeof ( struct super_block ) ) { fprintf ( stderr , "get_free_inum:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>" "super<S2SV_blank>block\\n" ) ; error = errno ; } * inump = inum ; free ( buf ) ; return error ; } if ( ( error = bmap_alloc ( fsm , fsm -> fsm_imapip , IMAP_EXTSIZE , & blkno , & len ) ) != 0 ) { fprintf ( stderr , "get_free_inum:<S2SV_blank>imap<S2SV_blank>allocation<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s\\n" , fsm -> fsm_mntpt ) ; return error ; } nbytes = IMAP_EXTSIZE << LOG_ONE_K ; buf = ( char * ) malloc ( nbytes ) ; if ( ! buf ) { fprintf ( stderr , "get_free_inum:<S2SV_blank>memory<S2SV_blank>allocation<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>" "imap<S2SV_blank>extent<S2SV_blank>for<S2SV_blank>%s\\n" , fsm -> fsm_mntpt ) ; return ENOMEM ; } memset ( buf , - 1 , nbytes ) ; buf [ 0 ] &= ~ ( 0x1 ) ; lseek ( fsm -> fsm_devfd , blkno << LOG_ONE_K , SEEK_SET ) ; if ( write ( fsm -> fsm_devfd , buf , nbytes ) != nbytes ) { error = errno ; fprintf ( stderr , "get_free_inum:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>new<S2SV_blank>imap<S2SV_blank>extent" "<S2SV_blank>at<S2SV_blank>%llu<S2SV_blank>for<S2SV_blank>%s\\n" , blkno , fsm -> fsm_mntpt ) ; free ( buf ) ; return error ; } fsm -> fsm_sb -> iused ++ ; lseek ( fsm -> fsm_devfd , SB_OFFSET , SEEK_SET ) ; if ( write ( fsm -> fsm_devfd , fsm -> fsm_sb , sizeof ( struct super_block ) ) != sizeof ( struct super_block ) ) { fprintf ( stderr , "get_free_inum:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>write<S2SV_blank>super<S2SV_blank>block" "<S2SV_blank>for<S2SV_blank>%s\\n" , fsm -> fsm_mntpt ) ; error = errno ; } else { * inump = inum ; } fsm -> fsm_imapip -> mino_size += IMAP_EXTSIZE << LOG_ONE_K ; error = iwrite ( fsm -> fsm_imapip ) ; free ( buf ) ; return error ; }
<S2SV_ModStart> ++ ) { <S2SV_ModEnd> if ( buf <S2SV_ModStart> i << 3 <S2SV_ModEnd> ; if ( <S2SV_ModStart> bit <<= 1 <S2SV_ModEnd> ; inum ++
6,747
CWE-000 irqreturn_t inv_mpu6050_read_fifo ( int irq , void * p ) { struct iio_poll_func * pf = p ; struct iio_dev * indio_dev = pf -> indio_dev ; struct inv_mpu6050_state * st = iio_priv ( indio_dev ) ; size_t bytes_per_datum ; int result ; u8 data [ INV_MPU6050_OUTPUT_DATA_SIZE ] ; u16 fifo_count ; s64 timestamp ; u64 * tmp ; mutex_lock ( & indio_dev -> mlock ) ; if ( ! ( st -> chip_config . accl_fifo_enable | st -> chip_config . gyro_fifo_enable ) ) goto end_session ; bytes_per_datum = 0 ; if ( st -> chip_config . accl_fifo_enable ) bytes_per_datum += INV_MPU6050_BYTES_PER_3AXIS_SENSOR ; if ( st -> chip_config . gyro_fifo_enable ) bytes_per_datum += INV_MPU6050_BYTES_PER_3AXIS_SENSOR ; result = i2c_smbus_read_i2c_block_data ( st -> client , st -> reg -> fifo_count_h , INV_MPU6050_FIFO_COUNT_BYTE , data ) ; if ( result != INV_MPU6050_FIFO_COUNT_BYTE ) goto end_session ; fifo_count = be16_to_cpup ( ( __be16 * ) ( & data [ 0 ] ) ) ; if ( fifo_count < bytes_per_datum ) goto end_session ; if ( fifo_count & 1 ) goto flush_fifo ; if ( fifo_count > INV_MPU6050_FIFO_THRESHOLD ) goto flush_fifo ; if ( kfifo_len ( & st -> timestamps ) > fifo_count / bytes_per_datum + INV_MPU6050_TIME_STAMP_TOR ) goto flush_fifo ; while ( fifo_count >= bytes_per_datum ) { result = i2c_smbus_read_i2c_block_data ( st -> client , st -> reg -> fifo_r_w , bytes_per_datum , data ) ; if ( result != bytes_per_datum ) goto flush_fifo ; result = kfifo_out ( & st -> timestamps , & timestamp , 1 ) ; if ( 0 == result ) timestamp = 0 ; tmp = ( u64 * ) data ; tmp [ DIV_ROUND_UP ( bytes_per_datum , 8 ) ] = timestamp ; result = iio_push_to_buffers ( indio_dev , data ) ; if ( result ) goto flush_fifo ; fifo_count -= bytes_per_datum ; } end_session : mutex_unlock ( & indio_dev -> mlock ) ; iio_trigger_notify_done ( indio_dev -> trig ) ; return IRQ_HANDLED ; flush_fifo : inv_reset_fifo ( indio_dev ) ; <S2SV_StartBug> inv_clear_kfifo ( st ) ; <S2SV_EndBug> mutex_unlock ( & indio_dev -> mlock ) ; iio_trigger_notify_done ( indio_dev -> trig ) ; return IRQ_HANDLED ; }
<S2SV_ModStart> indio_dev ) ; <S2SV_ModEnd> mutex_unlock ( &
6,748
CWE-000 void hidinput_hid_event ( struct hid_device * hid , struct hid_field * field , struct hid_usage * usage , __s32 value ) { struct input_dev * input ; unsigned * quirks = & hid -> quirks ; if ( ! field -> hidinput ) return ; input = field -> hidinput -> input ; if ( ! usage -> type ) return ; if ( usage -> hat_min < usage -> hat_max || usage -> hat_dir ) { int hat_dir = usage -> hat_dir ; if ( ! hat_dir ) hat_dir = ( value - usage -> hat_min ) * 8 / ( usage -> hat_max - usage -> hat_min + 1 ) + 1 ; if ( hat_dir < 0 || hat_dir > 8 ) hat_dir = 0 ; input_event ( input , usage -> type , usage -> code , hid_hat_to_axis [ hat_dir ] . x ) ; input_event ( input , usage -> type , usage -> code + 1 , hid_hat_to_axis [ hat_dir ] . y ) ; return ; } if ( usage -> hid == ( HID_UP_DIGITIZER | 0x003c ) ) { * quirks = value ? ( * quirks | HID_QUIRK_INVERT ) : ( * quirks & ~ HID_QUIRK_INVERT ) ; return ; } if ( usage -> hid == ( HID_UP_DIGITIZER | 0x0032 ) ) { if ( value ) { input_event ( input , usage -> type , ( * quirks & HID_QUIRK_INVERT ) ? BTN_TOOL_RUBBER : usage -> code , 1 ) ; return ; } input_event ( input , usage -> type , usage -> code , 0 ) ; input_event ( input , usage -> type , BTN_TOOL_RUBBER , 0 ) ; return ; } if ( usage -> hid == ( HID_UP_DIGITIZER | 0x0030 ) && ( * quirks & HID_QUIRK_NOTOUCH ) ) { int a = field -> logical_minimum ; int b = field -> logical_maximum ; input_event ( input , EV_KEY , BTN_TOUCH , value > a + ( ( b - a ) >> 3 ) ) ; } if ( usage -> hid == ( HID_UP_PID | 0x83UL ) ) { dbg_hid ( "Maximum<S2SV_blank>Effects<S2SV_blank>-<S2SV_blank>%d\\n" , value ) ; return ; } if ( usage -> hid == ( HID_UP_PID | 0x7fUL ) ) { dbg_hid ( "PID<S2SV_blank>Pool<S2SV_blank>Report\\n" ) ; return ; } if ( ( usage -> type == EV_KEY ) && ( usage -> code == 0 ) ) return ; if ( ( usage -> type == EV_ABS ) && ( field -> flags & HID_MAIN_ITEM_RELATIVE ) && ( usage -> code == ABS_VOLUME ) ) { int count = abs ( value ) ; int direction = value > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN ; int i ; for ( i = 0 ; i < count ; i ++ ) { input_event ( input , EV_KEY , direction , 1 ) ; input_sync ( input ) ; input_event ( input , EV_KEY , direction , 0 ) ; input_sync ( input ) ; } return ; } if ( ( field -> flags & HID_MAIN_ITEM_VARIABLE ) && <S2SV_StartBug> ( field -> logical_minimum < field -> logical_maximum ) && <S2SV_EndBug> ( value < field -> logical_minimum || value > field -> logical_maximum ) ) { dbg_hid ( "Ignoring<S2SV_blank>out-of-range<S2SV_blank>value<S2SV_blank>%x\\n" , value ) ; return ; } if ( ! ( field -> flags & ( HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_BUFFERED_BYTE ) ) && ( field -> flags & HID_MAIN_ITEM_VARIABLE ) && usage -> usage_index < field -> maxusage && value == field -> value [ usage -> usage_index ] ) return ; if ( usage -> type == EV_KEY && ! ! test_bit ( usage -> code , input -> key ) != value ) input_event ( input , EV_MSC , MSC_SCAN , usage -> hid ) ; input_event ( input , usage -> type , usage -> code , value ) ; if ( ( field -> flags & HID_MAIN_ITEM_RELATIVE ) && ( usage -> type == EV_KEY ) ) input_event ( input , usage -> type , usage -> code , 0 ) ; }
<S2SV_ModStart> ( field -> flags & HID_MAIN_ITEM_NULL_STATE ) && ( field ->
6,749
CWE-000 int main ( ) { char * cmd_str = ( char * ) malloc ( MAX_COMMAND_SIZE ) ; while ( 1 ) { printf ( "msh><S2SV_blank>" ) ; while ( ! fgets ( cmd_str , MAX_COMMAND_SIZE , stdin ) ) ; char * token [ MAX_NUM_ARGUMENTS + 1 ] ; int token_count = 0 ; char * arg_ptr ; char * working_str = strdup ( cmd_str ) ; char * working_root = working_str ; while ( ( ( arg_ptr = strsep ( & working_str , WHITESPACE ) ) != NULL ) && ( token_count <= MAX_NUM_ARGUMENTS ) ) { token [ token_count ] = strndup ( arg_ptr , MAX_COMMAND_SIZE ) ; if ( strlen ( token [ token_count ] ) == 0 ) { token [ token_count ] = NULL ; } token_count ++ ; } if ( DEBUGMODE ) { int token_index = 0 ; for ( token_index = 0 ; token_index < token_count ; token_index ++ ) { printf ( "token[%d]<S2SV_blank>=<S2SV_blank>%s\\n" , token_index , token [ token_index ] ) ; } } char * command = token [ 0 ] ; <S2SV_StartBug> if ( strcmp ( command , "quit" ) || strcmp ( command , "exit" ) ) <S2SV_EndBug> { free ( working_root ) ; break ; } free ( working_root ) ; } return 0 ; }
<S2SV_ModStart> , "quit" ) == 0 <S2SV_ModStart> , "exit" ) == 0
6,750
CWE-000 int piControlGetVariableInfo ( SPIVariable * pSpiVariable ) { piControlOpen ( ) ; if ( PiControlHandle_g < 0 ) <S2SV_StartBug> return PiControlHandle_g ; <S2SV_EndBug> return ioctl ( PiControlHandle_g , KB_FIND_VARIABLE , pSpiVariable ) ; }
<S2SV_ModStart> 0 ) return - errno <S2SV_ModEnd> ; return ioctl
6,751
CWE-000 int pool_set_file_write ( struct pool_set_file * file , void * buff , size_t nbytes , uint64_t off ) { if ( off + nbytes > file -> size ) return - 1 ; if ( file -> fileio ) { ssize_t num = pwrite ( file -> fd , buff , nbytes , ( off_t ) off ) ; if ( num < ( ssize_t ) nbytes ) return - 1 ; } else { memcpy ( ( char * ) file -> addr + off , buff , nbytes ) ; <S2SV_StartBug> } <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> nbytes ) ; util_persist_auto ( 0 , ( char * ) file -> addr + off , nbytes ) ;
6,752
CWE-000 void sy ( Input * I , Output * O , char * prec ) { Stack ostack ; Stack_Init ( & ostack ) ; while ( I -> sum [ I -> position ] != '\\0' ) { char currentToken = I -> sum [ I -> position ] ; if ( currentToken == '(' ) { Stack_Push ( & ostack , currentToken ) ; } else if ( currentToken == ')' ) { while ( Stack_Top ( & ostack ) != '(' ) { atoo ( O -> rpn , '|' , & ( O -> counter ) ) ; atoo ( O -> rpn , Stack_Pop ( & ostack ) , & ( O -> counter ) ) ; } Stack_Pop ( & ostack ) ; } else if ( ! isOperator ( currentToken ) ) { atoo ( O -> rpn , '|' , & ( O -> counter ) ) ; <S2SV_StartBug> while ( ! isOperator ( currentToken ) && currentToken != ')' && currentToken != '(' ) { <S2SV_EndBug> atoo ( O -> rpn , currentToken , & ( O -> counter ) ) ; I -> position ++ ; currentToken = I -> sum [ I -> position ] ; } continue ; } else if ( isOperator ( currentToken ) ) { while ( ! Stack_empty ( & ostack ) && prec [ currentToken ] < prec [ Stack_Top ( & ostack ) ] && Stack_Top ( & ostack ) != '(' ) { atoo ( O -> rpn , '|' , & ( O -> counter ) ) ; atoo ( O -> rpn , Stack_Pop ( & ostack ) , & ( O -> counter ) ) ; } Stack_Push ( & ostack , currentToken ) ; } I -> position ++ ; } while ( ! Stack_empty ( & ostack ) ) { <S2SV_StartBug> char x = Stack_Pop ( & ostack ) ; <S2SV_EndBug> atoo ( O -> rpn , '|' , & ( O -> counter ) ) ; atoo ( O -> rpn , Stack_Pop ( & ostack ) , & ( O -> counter ) ) ; } O -> rpn [ O -> counter ] = '\\0' ; }
<S2SV_ModStart> currentToken != '(' && currentToken != '\\0' <S2SV_ModStart> ) ) { <S2SV_ModEnd> atoo ( O
6,753
CWE-000 IOR_test_t * ReadConfigScript ( char * scriptName ) { int test_num = 0 ; int runflag = 0 ; char linebuf [ MAX_STR ] ; char empty [ MAX_STR ] ; <S2SV_StartBug> FILE * file ; <S2SV_EndBug> IOR_test_t * head = NULL ; IOR_test_t * tail = NULL ; head = CreateTest ( & initialTestParams , test_num ++ ) ; tail = head ; file = fopen ( scriptName , "r" ) ; if ( file == NULL ) ERR ( "fopen()<S2SV_blank>failed" ) ; while ( fgets ( linebuf , MAX_STR , file ) != NULL ) { if ( contains_only ( linebuf , "ior<S2SV_blank>start" ) ) { break ; } } while ( fgets ( linebuf , MAX_STR , file ) != NULL ) { <S2SV_StartBug> if ( sscanf ( linebuf , "%s" , empty ) == - 1 ) <S2SV_EndBug> continue ; <S2SV_StartBug> if ( sscanf ( linebuf , "<S2SV_blank>#%s" , empty ) == 1 ) <S2SV_EndBug> continue ; <S2SV_StartBug> if ( contains_only ( linebuf , "ior<S2SV_blank>stop" ) ) { <S2SV_EndBug> break ; <S2SV_StartBug> } else if ( contains_only ( linebuf , "run" ) ) { <S2SV_EndBug> if ( runflag ) { tail -> next = CreateTest ( & tail -> params , test_num ++ ) ; AllocResults ( tail ) ; tail = tail -> next ; } runflag = 1 ; } else if ( runflag ) { runflag = 0 ; tail -> next = CreateTest ( & tail -> params , test_num ++ ) ; AllocResults ( tail ) ; tail = tail -> next ; <S2SV_StartBug> ParseLine ( linebuf , & tail -> params ) ; <S2SV_EndBug> } else { <S2SV_StartBug> ParseLine ( linebuf , & tail -> params ) ; <S2SV_EndBug> } } if ( fclose ( file ) != 0 ) ERR ( "fclose()<S2SV_blank>of<S2SV_blank>script<S2SV_blank>file<S2SV_blank>failed" ) ; AllocResults ( tail ) ; return head ; }
<S2SV_ModStart> MAX_STR ] ; char * ptr ; <S2SV_ModStart> NULL ) { ptr = linebuf ; while ( isspace ( * ptr ) ) ptr ++ ; <S2SV_ModStart> ( sscanf ( ptr <S2SV_ModEnd> , "%s" , <S2SV_ModStart> ( sscanf ( ptr <S2SV_ModEnd> , "<S2SV_blank>#%s" , <S2SV_ModStart> ( contains_only ( ptr <S2SV_ModEnd> , "ior<S2SV_blank>stop" ) <S2SV_ModStart> ( contains_only ( ptr <S2SV_ModEnd> , "run" ) <S2SV_ModStart> ; ParseLine ( ptr <S2SV_ModEnd> , & tail <S2SV_ModStart> { ParseLine ( ptr <S2SV_ModEnd> , & tail
6,754
CWE-000 int is_banned ( struct Channel * chptr , struct Client * who , struct membership * msptr , const char * s , const char * s2 , const char * * forward ) <S2SV_StartBug> { <S2SV_EndBug> if ( chptr -> last_checked_client != NULL && who == chptr -> last_checked_client && chptr -> last_checked_type == CHFL_BAN && chptr -> last_checked_ts > chptr -> bants ) return chptr -> last_checked_result ; chptr -> last_checked_client = who ; chptr -> last_checked_type = CHFL_BAN ; chptr -> last_checked_result = is_banned_list ( chptr , & chptr -> banlist , who , msptr , s , s2 , forward ) ; chptr -> last_checked_ts = rb_current_time ( ) ; return chptr -> last_checked_result ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> forward ) { # if 0 <S2SV_ModStart> -> last_checked_result ; # else return is_banned_list ( chptr , & chptr -> banlist , who , msptr , s , s2 , forward ) ; # endif
6,755
CWE-000 void mlAdvance ( MovLayer * ml , Region * fence , Region * pad1Fence , Region * pad2Fence ) { Vec2 newPos ; u_char axis ; Region shapeBoundary ; char hitPaddle = 0 ; for ( ; ml ; ml = ml -> next ) { vec2Add ( & newPos , & ml -> layer -> posNext , & ml -> velocity ) ; abShapeGetBounds ( ml -> layer -> abShape , & newPos , & shapeBoundary ) ; for ( axis = 0 ; axis < 2 ; axis ++ ) { if ( ( shapeBoundary . topLeft . axes [ axis ] < fence -> topLeft . axes [ axis ] ) || ( shapeBoundary . botRight . axes [ axis ] > fence -> botRight . axes [ axis ] ) ) { int velocity = ml -> velocity . axes [ axis ] = - ml -> velocity . axes [ axis ] ; newPos . axes [ axis ] += ( 2 * velocity ) ; } if ( ( shapeBoundary . topLeft . axes [ 0 ] < pad1Fence -> botRight . axes [ 0 ] ) && ( shapeBoundary . botRight . axes [ 1 ] > pad1Fence -> topLeft . axes [ 1 ] ) && ( shapeBoundary . topLeft . axes [ 1 ] < pad1Fence -> botRight . axes [ 1 ] ) ) { int velocity = ml -> velocity . axes [ axis ] = - ml -> velocity . axes [ axis ] ; newPos . axes [ axis ] += ( 2 * velocity ) ; hitPaddle = 1 ; <S2SV_StartBug> } <S2SV_EndBug> if ( ( shapeBoundary . botRight . axes [ 0 ] > pad2Fence -> topLeft . axes [ 0 ] ) && ( shapeBoundary . botRight . axes [ 1 ] > pad2Fence -> topLeft . axes [ 1 ] ) && ( shapeBoundary . topLeft . axes [ 1 ] < pad2Fence -> botRight . axes [ 1 ] ) ) { int velocity = ml -> velocity . axes [ axis ] = - ml -> velocity . axes [ axis ] ; newPos . axes [ axis ] += ( 2 * velocity ) ; <S2SV_StartBug> hitPaddle = 1 ; <S2SV_EndBug> } if ( ( shapeBoundary . topLeft . axes [ 0 ] <= fence -> topLeft . axes [ 0 ] ) || ( shapeBoundary . botRight . axes [ 0 ] >= fence -> botRight . axes [ 0 ] ) ) { score = 0 ; Vec2 temp = { screenWidth / 2 , screenHeight / 2 } ; newPos = temp ; } } if ( hitPaddle ) score ++ ; ml -> layer -> posNext = newPos ; } }
<S2SV_ModStart> = 1 ; break ; <S2SV_ModStart> hitPaddle = 1 ; break
6,756
CWE-000 static void determine_decryption_key ( genaro_download_state_t * state ) { if ( ! state -> env -> encrypt_options || ! state -> env -> encrypt_options -> priv_key ) { state -> decryption_key_ctr -> key = NULL ; state -> decryption_key_ctr -> ctr = NULL ; <S2SV_StartBug> } else if ( state -> decryption_key_ctr && state -> decryption_key_ctr -> key && state -> decryption_key_ctr -> ctr ) { <S2SV_EndBug> return ; } else if ( state -> info -> index ) { determine_decryption_key_v1 ( state ) ; } else { determine_decryption_key_v0 ( state ) ; } }
<S2SV_ModStart> -> decryption_key_ctr -> key_len != 0 <S2SV_ModEnd> && state -> <S2SV_ModStart> -> decryption_key_ctr -> ctr_len != 0 <S2SV_ModEnd> ) { return
6,757
CWE-000 s32 igb_pll_workaround_i210 ( struct e1000_hw * hw ) { s32 ret_val ; u32 wuc , mdicnfg , ctrl , ctrl_ext , reg_val ; u16 nvm_word , phy_word , pci_word , tmp_nvm ; int i ; wuc = rd32 ( E1000_WUC ) ; mdicnfg = rd32 ( E1000_MDICNFG ) ; reg_val = mdicnfg & ~ E1000_MDICNFG_EXT_MDIO ; wr32 ( E1000_MDICNFG , reg_val ) ; ret_val = igb_read_invm_word_i210 ( hw , E1000_INVM_AUTOLOAD , & nvm_word ) ; if ( ret_val ) nvm_word = E1000_INVM_DEFAULT_AL ; tmp_nvm = nvm_word | E1000_INVM_PLL_WO_VAL ; igb_write_phy_reg_82580 ( hw , I347AT4_PAGE_SELECT , E1000_PHY_PLL_FREQ_PAGE ) ; <S2SV_StartBug> for ( i = 0 ; i < E1000_MAX_PLL_TRIES ; i ++ ) { <S2SV_EndBug> igb_read_phy_reg_82580 ( hw , E1000_PHY_PLL_FREQ_REG , & phy_word ) ; if ( ( phy_word & E1000_PHY_PLL_UNCONF ) != E1000_PHY_PLL_UNCONF ) { ret_val = 0 ; break ; } else { ret_val = - E1000_ERR_PHY ; } ctrl = rd32 ( E1000_CTRL ) ; wr32 ( E1000_CTRL , ctrl | E1000_CTRL_PHY_RST ) ; ctrl_ext = rd32 ( E1000_CTRL_EXT ) ; ctrl_ext |= ( E1000_CTRL_EXT_PHYPDEN | E1000_CTRL_EXT_SDLPE ) ; wr32 ( E1000_CTRL_EXT , ctrl_ext ) ; wr32 ( E1000_WUC , 0 ) ; reg_val = ( E1000_INVM_AUTOLOAD << 4 ) | ( tmp_nvm << 16 ) ; wr32 ( E1000_EEARBC_I210 , reg_val ) ; igb_read_pci_cfg ( hw , E1000_PCI_PMCSR , & pci_word ) ; pci_word |= E1000_PCI_PMCSR_D3 ; igb_write_pci_cfg ( hw , E1000_PCI_PMCSR , & pci_word ) ; usleep_range ( 1000 , 2000 ) ; pci_word &= ~ E1000_PCI_PMCSR_D3 ; igb_write_pci_cfg ( hw , E1000_PCI_PMCSR , & pci_word ) ; reg_val = ( E1000_INVM_AUTOLOAD << 4 ) | ( nvm_word << 16 ) ; wr32 ( E1000_EEARBC_I210 , reg_val ) ; wr32 ( E1000_WUC , wuc ) ; } igb_write_phy_reg_82580 ( hw , I347AT4_PAGE_SELECT , 0 ) ; wr32 ( E1000_MDICNFG , mdicnfg ) ; return ret_val ; }
<S2SV_ModStart> E1000_PHY_PLL_FREQ_PAGE ) ; phy_word = E1000_PHY_PLL_UNCONF ;
6,758
CWE-000 static int secretUndefine ( virSecretPtr secret ) { int ret = - 1 ; virSecretObjPtr obj ; virSecretDefPtr def ; virObjectEventPtr event = NULL ; if ( ! ( obj = secretObjFromSecret ( secret ) ) ) goto cleanup ; def = virSecretObjGetDef ( obj ) ; if ( virSecretUndefineEnsureACL ( secret -> conn , def ) < 0 ) goto cleanup ; if ( virSecretObjDeleteConfig ( obj ) < 0 ) goto cleanup ; event = virSecretEventLifecycleNew ( def -> uuid , def -> usage_type , def -> usage_id , VIR_SECRET_EVENT_UNDEFINED , 0 ) ; virSecretObjDeleteData ( obj ) ; virSecretObjListRemove ( driver -> secrets , obj ) ; <S2SV_StartBug> ret = 0 ; <S2SV_EndBug> cleanup : virSecretObjEndAPI ( & obj ) ; if ( event ) virObjectEventStateQueue ( driver -> secretEventState , event ) ; return ret ; }
<S2SV_ModStart> obj ) ; virObjectUnref ( obj ) ; obj = NULL ;
6,759
CWE-000 int file_read ( struct node * n , struct sample * smps [ ] , unsigned cnt , unsigned * release ) { struct file * f = ( struct file * ) n -> _vd ; int ret ; uint64_t steps ; assert ( cnt == 1 ) ; retry : ret = io_scan ( & f -> io , smps , cnt ) ; <S2SV_StartBug> if ( ret = 0 ) { <S2SV_EndBug> if ( io_eof ( & f -> io ) ) { switch ( f -> eof ) { case FILE_EOF_REWIND : info ( "Rewind<S2SV_blank>input<S2SV_blank>file<S2SV_blank>of<S2SV_blank>node<S2SV_blank>%s" , node_name ( n ) ) ; f -> offset = file_calc_offset ( & f -> first , & f -> epoch , f -> epoch_mode ) ; io_rewind ( & f -> io ) ; goto retry ; case FILE_EOF_WAIT : usleep ( 100000 ) ; if ( f -> io . mode == IO_MODE_ADVIO ) adownload ( f -> io . in . stream . adv , 1 ) ; goto retry ; case FILE_EOF_EXIT : info ( "Reached<S2SV_blank>end-of-file<S2SV_blank>of<S2SV_blank>node<S2SV_blank>%s" , node_name ( n ) ) ; killme ( SIGTERM ) ; pause ( ) ; } } else warn ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>messages<S2SV_blank>from<S2SV_blank>node<S2SV_blank>%s:<S2SV_blank>reason=%d" , node_name ( n ) , ret ) ; return 0 ; } if ( f -> epoch_mode == FILE_EPOCH_ORIGINAL ) return cnt ; if ( f -> rate ) { steps = task_wait ( & f -> task ) ; smps [ 0 ] -> ts . origin = time_now ( ) ; } else { smps [ 0 ] -> ts . origin = time_add ( & smps [ 0 ] -> ts . origin , & f -> offset ) ; task_set_next ( & f -> task , & smps [ 0 ] -> ts . origin ) ; steps = task_wait ( & f -> task ) ; } if ( steps == 0 ) serror ( "Failed<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>timer" ) ; else if ( steps != 1 ) warn ( "Missed<S2SV_blank>steps:<S2SV_blank>%" PRIu64 , steps - 1 ) ; return cnt ; }
<S2SV_ModStart> if ( ret <= <S2SV_ModEnd> 0 ) {
6,760
CWE-000 static int dvb_device_open ( struct inode * inode , struct file * file ) { struct dvb_device * dvbdev ; mutex_lock ( & dvbdev_mutex ) ; down_read ( & minor_rwsem ) ; dvbdev = dvb_minors [ iminor ( inode ) ] ; if ( dvbdev && dvbdev -> fops ) { int err = 0 ; <S2SV_StartBug> const struct file_operations * old_fops ; <S2SV_EndBug> file -> private_data = dvbdev ; old_fops = file -> f_op ; file -> f_op = fops_get ( dvbdev -> fops ) ; <S2SV_StartBug> if ( file -> f_op == NULL ) { <S2SV_EndBug> file -> f_op = old_fops ; goto fail ; <S2SV_StartBug> } <S2SV_EndBug> if ( file -> f_op -> open ) <S2SV_StartBug> err = file -> f_op -> open ( inode , file ) ; <S2SV_EndBug> if ( err ) { fops_put ( file -> f_op ) ; file -> f_op = fops_get ( old_fops ) ; } fops_put ( old_fops ) ; up_read ( & minor_rwsem ) ; mutex_unlock ( & dvbdev_mutex ) ; return err ; } fail : up_read ( & minor_rwsem ) ; mutex_unlock ( & dvbdev_mutex ) ; return - ENODEV ; }
<S2SV_ModStart> struct file_operations * new_fops ; new_fops <S2SV_ModEnd> = fops_get ( <S2SV_ModStart> ; if ( ! new_fops ) <S2SV_ModEnd> goto fail ; <S2SV_ModStart> goto fail ; file -> private_data = dvbdev ; replace_fops ( file , new_fops ) ; <S2SV_ModEnd> if ( file <S2SV_ModStart> inode , file <S2SV_ModEnd> ) ; up_read
6,761
CWE-000 static int upathmatch ( struct tcb * const tcp , const kernel_ulong_t upath ) { char path [ PATH_MAX + 1 ] ; <S2SV_StartBug> return umovestr ( tcp , upath , sizeof path , path ) > 0 && <S2SV_EndBug> pathmatch ( path ) ; }
<S2SV_ModStart> upath , sizeof ( path ) <S2SV_ModEnd> , path )
6,762
CWE-000 static int khttpd_file_get_exchange_get ( struct khttpd_exchange * exchange , void * arg , ssize_t space , struct mbuf * * data_out ) { struct khttpd_mbuf_json logent ; struct khttpd_file_get_exchange_data * data ; struct thread * td ; struct mbuf * hd , * mb , * lmb ; struct sf_buf * sf ; struct vm_page * * pages ; unsigned io_size , len ; int error , i , n , pageoff ; KHTTPD_ENTRY ( "khttpd_file_get_exchange_get(%p,%p,%#x)" , exchange , arg , space ) ; data = arg ; td = curthread ; <S2SV_StartBug> if ( data -> xmit_residual == 0 ) { <S2SV_EndBug> * data_out = NULL ; return ( 0 ) ; } if ( data -> io_size == 0 ) { <S2SV_StartBug> data -> io_size = MIN ( space , data -> xmit_residual ) ; <S2SV_EndBug> khttpd_file_read_file ( data ) ; } mtx_lock ( & data -> lock ) ; if ( data -> in_progress != 0 ) { data -> paused = TRUE ; mtx_unlock ( & data -> lock ) ; return ( EWOULDBLOCK ) ; } mtx_unlock ( & data -> lock ) ; error = data -> error ; if ( error != 0 ) { khttpd_mbuf_json_copy ( & logent , khttpd_exchange_log_entry ( exchange ) ) ; khttpd_problem_set ( & logent , LOG_ERR , "io_error" , "I/O<S2SV_blank>error" ) ; khttpd_problem_set_detail ( & logent , "file<S2SV_blank>read<S2SV_blank>failure" ) ; khttpd_problem_set_errno ( & logent , error ) ; khttpd_mbuf_json_property ( & logent , "path" ) ; khttpd_mbuf_json_cstr ( & logent , TRUE , sbuf_data ( & data -> path ) ) ; khttpd_mbuf_json_property ( & logent , "offset" ) ; khttpd_mbuf_json_format ( & logent , FALSE , "%jd" , ( intmax_t ) data -> io_offset ) ; khttpd_mbuf_json_property ( & logent , "size" ) ; khttpd_mbuf_json_format ( & logent , FALSE , "%jd" , ( intmax_t ) data -> io_size ) ; khttpd_http_error ( & logent ) ; return ( error ) ; } pages = data -> pages ; n = data -> npages ; pageoff = data -> io_offset & PAGE_MASK ; io_size = data -> io_size ; hd = lmb = NULL ; for ( i = 0 ; i < n ; ++ i ) { retry : sf = sf_buf_alloc ( pages [ i ] , i == 0 ? 0 : SFB_NOWAIT ) ; if ( sf == NULL ) { m_freem ( hd ) ; i = 0 ; goto retry ; } mb = m_get ( M_WAITOK , MT_DATA ) ; mb -> m_flags |= M_EXT | M_RDONLY ; mb -> m_ext . ext_buf = ( char * ) sf_buf_kva ( sf ) ; mb -> m_ext . ext_size = PAGE_SIZE ; mb -> m_ext . ext_arg1 = sf ; mb -> m_ext . ext_arg2 = NULL ; mb -> m_ext . ext_type = EXT_SFBUF ; mb -> m_ext . ext_flags = EXT_FLAG_EMBREF ; mb -> m_ext . ext_count = 1 ; mb -> m_data = mb -> m_ext . ext_buf + ( i == 0 ? pageoff : 0 ) ; mb -> m_len = i == 0 ? MIN ( PAGE_SIZE - pageoff , io_size ) : i < n - 1 ? PAGE_SIZE : ( ( pageoff + io_size - 1 ) & PAGE_MASK ) + 1 ; if ( lmb != NULL ) lmb -> m_next = mb ; else hd = mb ; lmb = mb ; } * data_out = hd ; len = data -> io_size ; <S2SV_StartBug> data -> xmit_residual -= len ; <S2SV_EndBug> data -> io_offset += len ; KASSERT ( 0 < len , ( "data->io_size<S2SV_blank>==<S2SV_blank>0" ) ) ; KASSERT ( 0 < space , ( "space<S2SV_blank>is<S2SV_blank>%#zx,<S2SV_blank>is<S2SV_blank>not<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>0" , space ) ) ; KASSERT ( m_length ( hd , NULL ) == len , ( "m_length(mbufs[0],<S2SV_blank>NULL)=%#x,<S2SV_blank>data->io_size=%#x" , m_length ( hd , NULL ) , len ) ) ; if ( data -> io_offset < data -> end_offset ) { <S2SV_StartBug> data -> io_size = MIN ( nitems ( data -> pages ) * PAGE_SIZE , <S2SV_EndBug> MIN ( space , data -> end_offset - data -> io_offset ) ) ; khttpd_file_read_file ( data ) ; } return ( 0 ) ; }
<S2SV_ModStart> ( data -> io_offset == data -> end_offset <S2SV_ModEnd> ) { * <S2SV_ModStart> = MIN ( ptoa ( nitems ( data -> pages ) ) - ( data -> io_offset & PAGE_MASK ) , MIN ( <S2SV_ModStart> , data -> end_offset - data -> io_offset ) <S2SV_ModEnd> ) ; khttpd_file_read_file <S2SV_ModStart> ; data -> <S2SV_ModEnd> io_offset += len <S2SV_ModStart> = MIN ( ptoa ( <S2SV_ModStart> -> pages ) ) - ( data -> io_offset & PAGE_MASK ) <S2SV_ModEnd> , MIN (
6,763
CWE-000 static void gf_enable_irq ( struct gf_dev * gf_dev ) <S2SV_StartBug> { <S2SV_EndBug> if ( gf_dev -> irq_enabled ) { pr_warn ( "IRQ<S2SV_blank>has<S2SV_blank>been<S2SV_blank>enabled.\\n" ) ; } else { <S2SV_StartBug> enable_irq ( gf_dev -> irq ) ; <S2SV_EndBug> gf_dev -> irq_enabled = 1 ; <S2SV_StartBug> } <S2SV_EndBug> }
<S2SV_ModStart> gf_dev ) { struct irq_desc * desc ; <S2SV_ModStart> } else { desc = irq_to_desc ( gf_dev -> irq ) ; if ( desc && desc -> depth > 0 ) { <S2SV_ModStart> = 1 ; pr_info ( "%s:<S2SV_blank>irq_enabled:%d" , __func__ , gf_dev -> irq_enabled ) ; }
6,764
CWE-000 json_t * get_ob_campaigns_all ( void ) { int ret ; char * sql ; json_t * j_res ; json_t * j_tmp ; asprintf ( & sql , "select<S2SV_blank>*<S2SV_blank>from<S2SV_blank>ob_campaign<S2SV_blank>where<S2SV_blank>in_use=%d;" , E_USE_OK ) ; <S2SV_StartBug> ret = db_ctx_query ( g_db_ob , sql ) ; <S2SV_EndBug> if ( ret == false ) { slog ( LOG_WARNING , "Could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>correct<S2SV_blank>ob_campaign." ) ; return NULL ; } j_res = json_array ( ) ; while ( 1 ) { j_tmp = db_ctx_get_record ( g_db_ob ) ; if ( j_tmp == NULL ) { break ; } json_array_append_new ( j_res , j_tmp ) ; } db_ctx_free ( g_db_ob ) ; return j_res ; }
<S2SV_ModStart> ( g_db_ob , sql ) ; sfree (
6,765
CWE-000 int rnl_set_destroy ( struct rnl_set * set ) { int i ; size_t count ; if ( ! set ) { LOG_ERR ( "Bogus<S2SV_blank>set<S2SV_blank>passed,<S2SV_blank>cannot<S2SV_blank>destroy" ) ; return - 1 ; } count = 0 ; for ( i = 0 ; i < ARRAY_SIZE ( set -> handlers ) ; i ++ ) { if ( set -> handlers [ i ] . cb != NULL ) { count ++ ; <S2SV_StartBug> LOG_DBG ( "Set<S2SV_blank>%pK<S2SV_blank>has<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>hander<S2SV_blank>still<S2SV_blank>" <S2SV_EndBug> "registered,<S2SV_blank>it<S2SV_blank>will<S2SV_blank>be<S2SV_blank>unregistered" , set ) ; break ; } } if ( count ) LOG_WARN ( "Set<S2SV_blank>%pK<S2SV_blank>had<S2SV_blank>%zd<S2SV_blank>handler(s)<S2SV_blank>that<S2SV_blank>have<S2SV_blank>not<S2SV_blank>been<S2SV_blank>" "unregistered<S2SV_blank>..." , set , count ) ; rkfree ( set ) ; <S2SV_StartBug> LOG_DBG ( "Set<S2SV_blank>%pK<S2SV_blank>destroyed<S2SV_blank>%s" , set , count ? "" : "successfully" ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> count ++ ; LOG_WARN <S2SV_ModEnd> ( "Set<S2SV_blank>%pK<S2SV_blank>has<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>hander<S2SV_blank>still<S2SV_blank>" "registered,<S2SV_blank>it<S2SV_blank>will<S2SV_blank>be<S2SV_blank>unregistered" <S2SV_ModStart> set ) ; LOG_INFO <S2SV_ModEnd> ( "Set<S2SV_blank>%pK<S2SV_blank>destroyed<S2SV_blank>%s" ,
6,766
CWE-000 extern void UpdateGamma_SCALE1 ( int state , void * ss , hmm_t * hmm ) { ssGamma * SS = ( ssGamma * ) ss ; MLEGamma_SCALE1 ( SS [ 0 ] . N , SS [ 0 ] . sumPiXi , SS [ 0 ] . sumLogPiXi , & ( hmm [ 0 ] . em_args [ state ] [ 0 ] ) , & ( hmm [ 0 ] . em_args [ state ] [ 1 ] ) ) ; <S2SV_StartBug> Rprintf ( "[UpdateGamma_Scale1]\\t--><S2SV_blank>Shape:<S2SV_blank>%f;<S2SV_blank>Scale:<S2SV_blank>%f\\n" , <S2SV_EndBug> hmm [ 0 ] . em_args [ state ] [ 0 ] , hmm [ 0 ] . em_args [ state ] [ 1 ] ) ; }
<S2SV_ModStart> ) ) ; if ( hmm -> verb )
6,767
CWE-000 static int s_Adjust ( SConnNetInfo * net_info , void * data , unsigned int n ) { SServiceConnector * uuu = ( SServiceConnector * ) data ; const char * user_header ; char * iter_header ; SSERV_InfoCPtr info ; assert ( n || uuu -> extra . adjust ) ; assert ( ! net_info -> firewall || net_info -> stateless ) ; if ( ! n || n == ( unsigned int ) ( - 1 ) ) <S2SV_StartBug> return uuu -> extra . adjust ( net_info , uuu -> extra . data , 0 ) ; <S2SV_EndBug> uuu -> warned = 1 ; if ( uuu -> retry >= uuu -> net_info -> max_try ) return 0 ; uuu -> retry ++ ; if ( ! ( info = s_GetNextInfo ( uuu , 1 ) ) ) return 0 ; iter_header = SERV_Print ( uuu -> iter , 0 , 0 ) ; switch ( info -> type ) { case fSERV_Ncbid : user_header = "Connection-Mode:<S2SV_blank>STATELESS\\r\\n" ; user_header = s_AdjustNetParams ( uuu -> service , net_info , eReqMethod_Post , NCBID_WEBPATH , SERV_NCBID_ARGS ( & info -> u . ncbid ) , uuu -> net_info -> args , user_header , info -> mime_t , info -> mime_s , info -> mime_e , iter_header ) ; break ; case fSERV_Http : case fSERV_HttpGet : case fSERV_HttpPost : user_header = "Client-Mode:<S2SV_blank>STATELESS_ONLY\\r\\n" ; user_header = s_AdjustNetParams ( uuu -> service , net_info , info -> type == fSERV_HttpPost ? eReqMethod_Post : ( info -> type == fSERV_HttpGet ? eReqMethod_Get : eReqMethod_Any ) , SERV_HTTP_PATH ( & info -> u . http ) , SERV_HTTP_ARGS ( & info -> u . http ) , uuu -> net_info -> args , user_header , info -> mime_t , info -> mime_s , info -> mime_e , iter_header ) ; break ; case fSERV_Firewall : case fSERV_Standalone : user_header = "Client-Mode:<S2SV_blank>STATELESS_ONLY\\r\\n" ; user_header = s_AdjustNetParams ( uuu -> service , net_info , eReqMethod_Any , uuu -> net_info -> path , 0 , uuu -> net_info -> args , user_header , info -> mime_t , info -> mime_s , info -> mime_e , iter_header ) ; break ; default : user_header = 0 ; assert ( 0 ) ; break ; } if ( iter_header ) free ( iter_header ) ; if ( ! user_header ) return 0 ; if ( uuu -> user_header ) { assert ( * uuu -> user_header ) ; ConnNetInfo_DeleteUserHeader ( net_info , uuu -> user_header ) ; free ( ( void * ) uuu -> user_header ) ; } if ( * user_header ) { uuu -> user_header = user_header ; if ( ! ConnNetInfo_OverrideUserHeader ( net_info , user_header ) ) return 0 ; } else uuu -> user_header = 0 ; if ( info -> type != fSERV_Ncbid && ! ( info -> type & fSERV_Http ) ) { strcpy ( net_info -> host , uuu -> net_info -> host ) ; net_info -> port = uuu -> net_info -> port ; } else if ( ! x_SetHostPort ( net_info , info ) ) return 0 ; return uuu -> extra . adjust && ! uuu -> extra . adjust ( net_info , uuu -> extra . data , uuu -> retry ) ? 0 : 1 ; }
<S2SV_ModStart> . data , n <S2SV_ModEnd> ) ; uuu
6,768
CWE-000 static bool variable_matches ( const char * var_name , size_t len , const char * match_name , int * match ) { for ( * match = 0 ; ; ( * match ) ++ ) { char c = match_name [ * match ] ; <S2SV_StartBug> char u = var_name [ * match ] ; <S2SV_EndBug> if ( c == '*' ) return true ; if ( ! c && * match == len ) return true ; if ( c != u ) return false ; <S2SV_StartBug> if ( ! c ) <S2SV_EndBug> return true ; } return true ; }
<S2SV_ModStart> match ] ; switch ( c ) { case '*' : return true ; case '\\0' : return ( * match == len ) ; default : if ( * match < len && c == <S2SV_ModEnd> var_name [ * <S2SV_ModStart> * match ] ) continue ; <S2SV_ModEnd> return false ; <S2SV_ModStart> return false ; } } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
6,769
CWE-000 static void dbg_print_value ( struct json_value * v ) { if ( v == ROOT_VALUE ) { printf ( "ROOT_VALUE<S2SV_blank>sentinel\\n" ) ; return ; } if ( v == RESUME_ARRAY ) { printf ( "RESUME_ARRAY<S2SV_blank>sentinel\\n" ) ; return ; } if ( v == RESUME_OBJ ) { printf ( "RESUME_OBJ<S2SV_blank>sentinel\\n" ) ; return ; } switch ( v -> type ) { case JSON_TYPE_UNDEFINED : printf ( "undefined\\n" ) ; break ; case JSON_TYPE_NULL : printf ( "null\\n" ) ; break ; case JSON_TYPE_INT : printf ( "int:<S2SV_blank>%d\\n" , ( int ) v -> v . integer ) ; break ; case JSON_TYPE_DOUBLE : printf ( "double<S2SV_blank>%f\\n" , v -> v . dbl ) ; break ; case JSON_TYPE_STRING : printf ( "string:<S2SV_blank>\\"%s\\"\\n" , v -> v . str ) ; break ; case JSON_TYPE_OBJ : printf ( "object<S2SV_blank>[%d]\\n" , ( int ) v -> v . obj -> fill ) ; break ; case JSON_TYPE_ARRAY : printf ( "array<S2SV_blank>[%d]\\n" , ( int ) v -> v . arr -> length ) ; break ; case JSON_TYPE_COMMENT_SINGLE : printf ( "comment,<S2SV_blank>single\\n" ) ; break ; case JSON_TYPE_COMMENT_MULTI : printf ( "comment,<S2SV_blank>multiline\\n" ) ; break ; <S2SV_StartBug> } <S2SV_EndBug> }
<S2SV_ModStart> ; break ; default : printf ( "unknown<S2SV_blank>enum:<S2SV_blank>%d\\n" , v -> type ) ;
6,770
CWE-000 int search_read_title_file_partial ( search_workspace_t * p_s_ws ) { assert ( p_s_ws -> index . next_unused_id > LINKED_LIST_FIRST_ID ) ; assert ( p_s_ws -> searchable_strings_len > 0 ) ; assert ( p_s_ws -> searchable_strings . fd > - 1 ) ; title_chunks_t * p_chunks = & p_s_ws -> chunks ; int const fd = p_s_ws -> searchable_strings . fd ; if ( p_chunks -> len > 0 ) { <S2SV_StartBug> buf_string_copy_t * p_topic = & p_s_ws -> prev_topic ; <S2SV_EndBug> if ( p_topic -> target && p_topic -> target != p_topic -> _copy ) { charcpy ( & p_topic -> _copy , & p_topic -> _copy_size , p_topic -> target , strlen ( p_topic -> target ) ) ; p_topic -> target = p_topic -> _copy ; } int i ; for ( i = p_chunks -> partial_i ; i <= p_chunks -> partial_i ; ++ i ) { char_buffer_t * p_x = & p_chunks -> bufs [ i ] ; if ( p_x -> p ) { char_buffer_clear ( p_x ) ; } } ++ p_chunks -> partial_i ; } else { init_chunks ( p_s_ws ) ; } char_buffer_t * p_current_chunk = & p_chunks -> bufs [ p_chunks -> partial_i ] ; uint32_t * p_current_seek = & p_chunks -> start_seeks [ p_chunks -> partial_i ] ; uint32_t * p_current_chunk_start_id = & p_chunks -> start_ids [ p_chunks -> partial_i ] ; uint32_t * p_next_chunk_start_id = p_current_chunk_start_id + 1 ; uint32_t threshold = SEARCH_TITLE_ARR_LEN * ( 1 + p_chunks -> partial_i ) ; uint32_t current_seek , next_seek ; int finish_decompressing = 0 ; current_seek = * p_current_seek ; next_seek = current_seek ; if ( next_seek >= p_s_ws -> searchable_strings_len ) { fprintf ( stderr , "Read<S2SV_blank>after<S2SV_blank>end<S2SV_blank>of<S2SV_blank>title<S2SV_blank>file.<S2SV_blank>File<S2SV_blank>to<S2SV_blank>short?!\\n" ) ; return - 1 ; } next_seek = find_lowest_seek_over_threshold ( p_s_ws , threshold , * p_current_chunk_start_id , p_next_chunk_start_id ) ; if ( p_current_chunk -> p != NULL ) { free ( p_current_chunk -> p ) ; fprintf ( stderr , "%s\\n" , "(search_read_title_file)<S2SV_blank>buffer<S2SV_blank>already<S2SV_blank>alloc\'d." ) ; } assert ( next_seek > current_seek ) ; assert ( p_current_chunk -> p == NULL ) ; p_current_chunk -> len = ( next_seek - current_seek ) ; p_current_chunk -> p = ( char * ) malloc ( p_current_chunk -> len * sizeof ( char ) ) ; p_current_chunk -> used = 0 ; # ifdef COMPRESS_BROTLI if ( brotli_read_buffer ( fd , & p_s_ws -> brotli_title , p_current_chunk , & finish_decompressing ) ) { fprintf ( stderr , "%s<S2SV_blank>Current<S2SV_blank>byte<S2SV_blank>range:<S2SV_blank>[%i,%i)\\n" , "(search_read_title_file)<S2SV_blank>decompressing<S2SV_blank>failed." , current_seek , next_seek ) ; return - 1 ; } # else ssize_t n = read ( fd , p_current_chunk -> p , p_current_chunk -> len ) ; if ( ( ssize_t ) p_current_chunk -> len > n ) { fprintf ( stderr , "%s<S2SV_blank>Current<S2SV_blank>byte<S2SV_blank>range:<S2SV_blank>[%i,%i).<S2SV_blank>Number<S2SV_blank>read<S2SV_blank>bytes:<S2SV_blank>%zu\\n" , "(search_read_title_file)<S2SV_blank>file<S2SV_blank>reading<S2SV_blank>failed." , current_seek , next_seek , n ) ; } finish_decompressing = ( next_seek >= p_s_ws -> searchable_strings_len ) ; # endif * ( p_current_seek + 1 ) = * ( p_current_seek ) + p_current_chunk -> len ; if ( finish_decompressing ) { ++ p_current_chunk ; ++ p_current_seek ; * p_current_chunk = * ( p_current_chunk - 1 ) ; * p_current_seek = * ( p_current_seek - 1 ) ; } return finish_decompressing ? 1 : 0 ; }
<S2SV_ModStart> 0 ) { _save_latest_topic_string ( p_s_ws ) ; <S2SV_ModEnd> int i ;
6,771
CWE-000 void AddVarDec2SymbolTable ( ParserTreeNode * x , Type typex ) { if ( x -> m_childrennum == 1 ) { <S2SV_StartBug> AddVar2SymbolTable ( x -> m_lineno , ( x -> m_firstchild ) -> IDname , typex ) ; <S2SV_EndBug> } else { ParserTreeNode * temp = x -> m_firstchild ; temp = temp -> m_nextsibiling ; temp = temp -> m_nextsibiling ; Type newType = malloc ( sizeof ( Type_ ) ) ; newType -> kind = ARRAY ; newType -> u . array . size = temp -> int_value ; newType -> u . array . elem = typex ; <S2SV_StartBug> AddVarDec2SymbolTable ( x -> m_firstchild , newType ) ; <S2SV_EndBug> } }
<S2SV_ModStart> 1 ) { if ( checkparentstruct ( x ) == 0 ) AddVar2SymbolTable ( x -> m_lineno , ( x -> m_firstchild ) -> IDname , typex ) ; else AddStructVar2SymbolTable <S2SV_ModEnd> ( x -> <S2SV_ModStart> = typex ; if ( checkparentstruct ( x ) == 0 ) AddVar2SymbolTable ( x -> m_lineno , <S2SV_ModEnd> ( x -> <S2SV_ModStart> x -> m_firstchild ) -> IDname , typex ) ; else AddStructVar2SymbolTable ( x -> m_lineno , ( x -> m_firstchild ) -> IDname , typex <S2SV_ModEnd> ) ; }
6,772
CWE-000 static bool max_parallel_hazard_walker ( Node * node , max_parallel_hazard_context * context ) { if ( node == NULL ) return false ; if ( check_functions_in_node ( node , max_parallel_hazard_checker , context ) ) return true ; if ( IsA ( node , CoerceToDomain ) ) { <S2SV_StartBug> if ( max_parallel_hazard_test ( PROPARALLEL_RESTRICTED , context ) ) <S2SV_EndBug> return true ; } else if ( IsA ( node , RestrictInfo ) ) { RestrictInfo * rinfo = ( RestrictInfo * ) node ; return max_parallel_hazard_walker ( ( Node * ) rinfo -> clause , context ) ; } else if ( IsA ( node , SubLink ) ) { if ( max_parallel_hazard_test ( PROPARALLEL_RESTRICTED , context ) ) return true ; } else if ( IsA ( node , SubPlan ) ) { SubPlan * subplan = ( SubPlan * ) node ; List * save_safe_param_ids ; if ( ! subplan -> parallel_safe && max_parallel_hazard_test ( PROPARALLEL_RESTRICTED , context ) ) return true ; save_safe_param_ids = context -> safe_param_ids ; context -> safe_param_ids = list_concat ( list_copy ( subplan -> paramIds ) , context -> safe_param_ids ) ; if ( max_parallel_hazard_walker ( subplan -> testexpr , context ) ) return true ; context -> safe_param_ids = save_safe_param_ids ; if ( max_parallel_hazard_walker ( ( Node * ) subplan -> args , context ) ) return true ; return false ; } else if ( IsA ( node , Param ) ) { Param * param = ( Param * ) node ; if ( param -> paramkind != PARAM_EXEC || ! list_member_int ( context -> safe_param_ids , param -> paramid ) ) { if ( max_parallel_hazard_test ( PROPARALLEL_RESTRICTED , context ) ) return true ; } return false ; } else if ( IsA ( node , Query ) ) { Query * query = ( Query * ) node ; if ( query -> rowMarks != NULL ) { context -> max_hazard = PROPARALLEL_UNSAFE ; return true ; } return query_tree_walker ( query , max_parallel_hazard_walker , context , 0 ) ; } return expression_tree_walker ( node , max_parallel_hazard_walker , context ) ; }
<S2SV_ModStart> max_parallel_hazard_test ( PROPARALLEL_RESTRICTED , context ) ) return true ; } if ( IsA ( node , NextValueExpr ) ) { if ( max_parallel_hazard_test ( PROPARALLEL_UNSAFE
6,773
CWE-000 int picoquic_tlsinput_stream_zero ( picoquic_cnx_t * cnx ) { int ret = 0 ; picoquic_stream_data * data = cnx -> first_stream . stream_data ; struct st_ptls_buffer_t sendbuf ; if ( data == NULL || data -> offset > cnx -> first_stream . consumed_offset ) { return 0 ; } ptls_buffer_init ( & sendbuf , "" , 0 ) ; while ( ( ret == 0 || ret == PTLS_ERROR_IN_PROGRESS ) && data != NULL && data -> offset <= cnx -> first_stream . consumed_offset ) { size_t start = ( size_t ) ( cnx -> first_stream . consumed_offset - data -> offset ) ; size_t consumed = 0 ; ret = picoquic_tlsinput_segment ( cnx , data -> bytes + start , data -> length - start , & consumed , & sendbuf ) ; cnx -> first_stream . consumed_offset += consumed ; if ( start + consumed >= data -> length ) { free ( data -> bytes ) ; cnx -> first_stream . stream_data = data -> next_stream_data ; free ( data ) ; data = cnx -> first_stream . stream_data ; } } if ( ret == 0 ) { switch ( cnx -> cnx_state ) { case picoquic_state_client_hrr_received : break ; case picoquic_state_client_init : case picoquic_state_client_init_sent : case picoquic_state_client_renegotiate : case picoquic_state_client_init_resent : case picoquic_state_client_handshake_start : case picoquic_state_client_handshake_progress : if ( cnx -> remote_parameters_received == 0 ) { ret = picoquic_connection_error ( cnx , PICOQUIC_TRANSPORT_TRANSPORT_PARAMETER_ERROR ) ; } else { cnx -> cnx_state = picoquic_state_client_almost_ready ; ret = picoquic_setup_1RTT_aead_contexts ( cnx , 0 ) ; } break ; case picoquic_state_server_init : picoquic_setup_0RTT_aead_contexts ( cnx , 1 ) ; <S2SV_StartBug> cnx -> cnx_state = picoquic_state_server_almost_ready ; <S2SV_EndBug> ret = picoquic_setup_1RTT_aead_contexts ( cnx , 1 ) ; break ; case picoquic_state_client_almost_ready : case picoquic_state_handshake_failure : case picoquic_state_client_ready : case picoquic_state_server_almost_ready : case picoquic_state_server_ready : case picoquic_state_disconnecting : case picoquic_state_closing_received : case picoquic_state_closing : case picoquic_state_draining : case picoquic_state_disconnected : break ; default : DBG_PRINTF ( "Unexpected<S2SV_blank>connection<S2SV_blank>state:<S2SV_blank>%d\\n" , cnx -> cnx_state ) ; break ; } } else if ( ret == PTLS_ERROR_IN_PROGRESS && ( cnx -> cnx_state == picoquic_state_client_init || cnx -> cnx_state == picoquic_state_client_init_sent || cnx -> cnx_state == picoquic_state_client_init_resent ) ) { } else if ( ret == PTLS_ERROR_IN_PROGRESS && ( cnx -> cnx_state == picoquic_state_client_hrr_received ) ) { cnx -> cnx_state = picoquic_state_client_init ; while ( cnx -> retransmit_newest != NULL ) { picoquic_dequeue_retransmit_packet ( cnx , cnx -> retransmit_newest , 1 ) ; } picoquic_clear_stream ( & cnx -> first_stream ) ; cnx -> first_stream . consumed_offset = 0 ; cnx -> first_stream . stream_flags = 0 ; cnx -> first_stream . fin_offset = 0 ; cnx -> first_stream . sent_offset = 0 ; } else if ( ret == PTLS_ERROR_STATELESS_RETRY ) { cnx -> cnx_state = picoquic_state_server_send_hrr ; } else if ( ret == PTLS_ERROR_IN_PROGRESS && cnx -> cnx_state == picoquic_state_server_init ) { picoquic_tls_ctx_t * ctx = ( picoquic_tls_ctx_t * ) cnx -> tls_ctx ; if ( ptls_handshake_is_complete ( ctx -> tls ) ) { picoquic_setup_0RTT_aead_contexts ( cnx , 1 ) ; cnx -> cnx_state = picoquic_state_server_almost_ready ; ret = picoquic_setup_1RTT_aead_contexts ( cnx , 1 ) ; } } if ( ( ret == 0 || ret == PTLS_ERROR_IN_PROGRESS || ret == PTLS_ERROR_STATELESS_RETRY ) ) { if ( sendbuf . off > 0 ) { ret = picoquic_add_to_stream ( cnx , 0 , sendbuf . base , sendbuf . off , 0 ) ; } ret = 0 ; } else { ( void ) picoquic_connection_error ( cnx , PICOQUIC_TLS_HANDSHAKE_FAILED ) ; ret = 0 ; } ptls_buffer_dispose ( & sendbuf ) ; return ret ; }
<S2SV_ModStart> 1 ) ; if ( sendbuf . off == 0 && ( ( ptls_context_t * ) cnx -> quic -> tls_master_ctx ) -> require_client_authentication == 1 ) { cnx -> cnx_state = picoquic_state_server_ready ; } else { <S2SV_ModStart> = picoquic_state_server_almost_ready ; }
6,774
CWE-000 static void ImageDisplay ( ClientData clientData , Display * display , Drawable drawable , int imageX , int imageY , int width , int height , int drawableX , int drawableY ) { TImageInstance * instPtr = ( TImageInstance * ) clientData ; char buffer [ 200 + TCL_INTEGER_SPACE * 6 ] ; sprintf ( buffer , "%s<S2SV_blank>display<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d" , instPtr -> masterPtr -> imageName , imageX , imageY , width , height ) ; Tcl_SetVar2 ( instPtr -> masterPtr -> interp , instPtr -> masterPtr -> varName , NULL , buffer , TCL_GLOBAL_ONLY | TCL_APPEND_VALUE | TCL_LIST_ELEMENT ) ; if ( width > ( instPtr -> masterPtr -> width - imageX ) ) { width = instPtr -> masterPtr -> width - imageX ; } if ( height > ( instPtr -> masterPtr -> height - imageY ) ) { height = instPtr -> masterPtr -> height - imageY ; } <S2SV_StartBug> XDrawRectangle ( display , drawable , instPtr -> gc , drawableX , drawableY , <S2SV_EndBug> ( unsigned ) ( width - 1 ) , ( unsigned ) ( height - 1 ) ) ; XDrawLine ( display , drawable , instPtr -> gc , drawableX , drawableY , ( int ) ( drawableX + width - 1 ) , ( int ) ( drawableY + height - 1 ) ) ; XDrawLine ( display , drawable , instPtr -> gc , drawableX , ( int ) ( drawableY + height - 1 ) , ( int ) ( drawableX + width - 1 ) , drawableY ) ; }
<S2SV_ModStart> imageY ; } SIMULATE_DRAWING
6,775
CWE-000 int main ( int argc , char * * argv ) { struct dirent * ent ; DIR * directory ; if ( argc == 1 ) { directory = opendir ( "." ) ; } if ( argc == 2 ) { directory = opendir ( argv [ 1 ] ) ; } if ( directory == NULL ) { printf ( "Cannot<S2SV_blank>open<S2SV_blank>directory." ) ; <S2SV_StartBug> exit ( 0 ) ; <S2SV_EndBug> } <S2SV_StartBug> ent = readdir ( directory ) ; <S2SV_EndBug> while ( ent != NULL ) { <S2SV_StartBug> printf ( "%scheck\\n" , ent -> d_name ) ; <S2SV_EndBug> } closedir ( directory ) ; return 0 ; }
<S2SV_ModStart> ; exit ( 1 <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } while ( ( <S2SV_ModStart> ( directory ) ) <S2SV_ModEnd> != NULL ) <S2SV_ModStart> { printf ( "%s\\n" <S2SV_ModEnd> , ent ->
6,776
CWE-000 UInt ExecProccall5args ( Stat call ) { Obj func ; Obj arg1 ; Obj arg2 ; Obj arg3 ; Obj arg4 ; Obj arg5 ; SET_BRK_CURR_STAT ( call ) ; func = EVAL_EXPR ( FUNC_CALL ( call ) ) ; <S2SV_StartBug> while ( TNUM_OBJ ( func ) != T_FUNCTION ) { <S2SV_EndBug> func = ErrorReturnObj ( "Function<S2SV_blank>Calls:<S2SV_blank><func><S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>function<S2SV_blank>(not<S2SV_blank>a<S2SV_blank>%s)" , ( Int ) TNAM_OBJ ( func ) , 0L , "you<S2SV_blank>can<S2SV_blank>replace<S2SV_blank><func><S2SV_blank>via<S2SV_blank>\'return<S2SV_blank><func>;\'" ) ; } arg1 = EVAL_EXPR ( ARGI_CALL ( call , 1 ) ) ; arg2 = EVAL_EXPR ( ARGI_CALL ( call , 2 ) ) ; arg3 = EVAL_EXPR ( ARGI_CALL ( call , 3 ) ) ; arg4 = EVAL_EXPR ( ARGI_CALL ( call , 4 ) ) ; arg5 = EVAL_EXPR ( ARGI_CALL ( call , 5 ) ) ; if ( TNUM_OBJ ( func ) != T_FUNCTION ) DispatchFuncCall ( func , 5 , ( Obj ) arg1 , ( Obj ) arg2 , ( Obj ) arg3 , ( Obj ) arg4 , ( Obj ) arg5 , ( Obj ) 0L ) ; else { SET_BRK_CALL_TO ( call ) ; CALL_5ARGS ( func , arg1 , arg2 , arg3 , arg4 , arg5 ) ; } if ( STATE ( UserHasQuit ) || STATE ( UserHasQUIT ) ) ReadEvalError ( ) ; return 0 ; }
<S2SV_ModStart> ) ) ; arg1 = EVAL_EXPR ( ARGI_CALL ( call , 1 ) ) ; arg2 = EVAL_EXPR ( ARGI_CALL ( call , 2 ) ) ; arg3 = EVAL_EXPR ( ARGI_CALL ( call , 3 ) ) ; arg4 = EVAL_EXPR ( ARGI_CALL ( call , 4 ) ) ; arg5 = EVAL_EXPR ( ARGI_CALL ( call , 5 ) ) ; if <S2SV_ModEnd> ( TNUM_OBJ ( <S2SV_ModStart> != T_FUNCTION ) <S2SV_ModEnd> DispatchFuncCall ( func
6,777
CWE-000 int raxIteratorNextStep ( raxIterator * it , int noup ) { if ( it -> flags & RAX_ITER_EOF ) { return 0 ; } else if ( it -> flags & RAX_ITER_JUST_SEEKED ) { <S2SV_StartBug> it -> flags &= ~ RAX_ITER_JUST_SEEKED ; <S2SV_EndBug> return 1 ; } size_t orig_key_len = it -> key_len ; size_t orig_stack_items = it -> stack . items ; raxNode * orig_node = it -> node ; it -> flags &= ~ RAX_ITER_EOF ; while ( 1 ) { int children = it -> node -> iscompr ? 1 : it -> node -> size ; if ( ! noup && children ) { debugf ( "GO<S2SV_blank>DEEPER\\n" ) ; if ( ! raxStackPush ( & it -> stack , it -> node ) ) return 0 ; raxNode * * cp = raxNodeFirstChildPtr ( it -> node ) ; if ( ! raxIteratorAddChars ( it , it -> node -> data , it -> node -> iscompr ? it -> node -> size : 1 ) ) return 0 ; memcpy ( & it -> node , cp , sizeof ( it -> node ) ) ; if ( it -> node -> iskey ) { it -> data = raxGetData ( it -> node ) ; return 1 ; } } else { while ( 1 ) { int old_noup = noup ; if ( ! noup && it -> node == it -> rt -> head ) { it -> flags |= RAX_ITER_EOF ; it -> stack . items = orig_stack_items ; it -> key_len = orig_key_len ; it -> node = orig_node ; return 1 ; } unsigned char prevchild = it -> key [ it -> key_len - 1 ] ; if ( ! noup ) { it -> node = raxStackPop ( & it -> stack ) ; } else { noup = 0 ; } int todel = it -> node -> iscompr ? it -> node -> size : 1 ; raxIteratorDelChars ( it , todel ) ; if ( ! it -> node -> iscompr && it -> node -> size > ( old_noup ? 0 : 1 ) ) { raxNode * * cp = raxNodeFirstChildPtr ( it -> node ) ; int i = 0 ; while ( i < it -> node -> size ) { debugf ( "SCAN<S2SV_blank>NEXT<S2SV_blank>%c\\n" , it -> node -> data [ i ] ) ; if ( it -> node -> data [ i ] > prevchild ) break ; i ++ ; cp ++ ; } if ( i != it -> node -> size ) { debugf ( "SCAN<S2SV_blank>found<S2SV_blank>a<S2SV_blank>new<S2SV_blank>node\\n" ) ; raxIteratorAddChars ( it , it -> node -> data + i , 1 ) ; if ( ! raxStackPush ( & it -> stack , it -> node ) ) return 0 ; memcpy ( & it -> node , cp , sizeof ( it -> node ) ) ; if ( it -> node -> iskey ) { it -> data = raxGetData ( it -> node ) ; return 1 ; } break ; } } } } } }
<S2SV_ModStart> &= ~ RAX_ITER_JUST_SEEKED ; it -> data = raxGetData ( it -> node )
6,778
CWE-000 <S2SV_StartBug> static void NRF_CE_RESETPIN ( nrf24L01_Dev * dev ) { <S2SV_EndBug> HAL_GPIO_WritePin ( dev -> NRF_CE_GPIOx , dev -> NRF_CE_GPIO_PIN , GPIO_PIN_RESET ) ; }
<S2SV_ModStart> void NRF_CE_RESETPIN ( nrf24l01_dev <S2SV_ModEnd> * dev )
6,779
CWE-000 static zx_status_t cdc_ethmac_queue_tx ( void * cookie , uint32_t options , ethmac_netbuf_t * netbuf ) { usb_cdc_t * cdc = cookie ; <S2SV_StartBug> size_t length = netbuf -> len ; <S2SV_EndBug> if ( ! cdc -> online || length > ETH_MTU || length == 0 ) { return ZX_ERR_INVALID_ARGS ; } zxlogf ( LTRACE , "%s:<S2SV_blank>sending<S2SV_blank>%zu<S2SV_blank>bytes\\n" , __FUNCTION__ , length ) ; mtx_lock ( & cdc -> tx_mutex ) ; <S2SV_StartBug> zx_status_t status = cdc_send_locked ( cdc , netbuf ) ; <S2SV_EndBug> if ( status == ZX_ERR_SHOULD_WAIT ) { list_add_tail ( & cdc -> tx_pending_infos , & netbuf -> node ) ; } <S2SV_StartBug> mtx_unlock ( & cdc -> tx_mutex ) ; <S2SV_EndBug> return status ; }
<S2SV_ModStart> netbuf -> len ; zx_status_t status <S2SV_ModStart> tx_mutex ) ; if ( cdc -> unbound ) { status = ZX_ERR_IO_NOT_PRESENT ; } else { <S2SV_ModEnd> status = cdc_send_locked <S2SV_ModStart> ) ; } }
6,780
CWE-000 static int goldfish_pipe_release ( struct inode * inode , struct file * filp ) { unsigned long flags ; struct goldfish_pipe * pipe = filp -> private_data ; <S2SV_StartBug> struct goldfish_pipe_dev * dev = pipe -> dev ; <S2SV_EndBug> pr_debug ( "%s<S2SV_blank>on<S2SV_blank>0x%p\\n" , __func__ , pipe ) ; ( void ) goldfish_cmd ( pipe , PIPE_CMD_CLOSE ) ; spin_lock_irqsave ( & dev -> lock , flags ) ; dev -> pipes [ pipe -> id ] = NULL ; signalled_pipes_remove_locked ( dev , pipe ) ; spin_unlock_irqrestore ( & dev -> lock , flags ) ; filp -> private_data = NULL ; free_page ( ( unsigned long ) pipe -> command_buffer ) ; kfree ( pipe ) ; return 0 ; }
<S2SV_ModStart> pipe -> dev <S2SV_ModEnd> ; ( void
6,781
CWE-000 int rx_produce ( World * world , uint32_t pport , const struct iovec * iov , int iovcnt , uint8_t copy_to_cpu ) { Rocker * r = world_rocker ( world ) ; PCIDevice * dev = ( PCIDevice * ) r ; DescRing * ring = rocker_get_rx_ring_by_pport ( r , pport ) ; DescInfo * info = desc_ring_fetch_desc ( ring ) ; char * data ; size_t data_size = iov_size ( iov , iovcnt ) ; char * buf ; uint16_t rx_flags = 0 ; uint16_t rx_csum = 0 ; size_t tlv_size ; RockerTlv * tlvs [ ROCKER_TLV_RX_MAX + 1 ] ; hwaddr frag_addr ; uint16_t frag_max_len ; int pos ; int err ; if ( ! info ) { return - ROCKER_ENOBUFS ; } buf = desc_get_buf ( info , false ) ; if ( ! buf ) { err = - ROCKER_ENXIO ; goto out ; } rocker_tlv_parse ( tlvs , ROCKER_TLV_RX_MAX , buf , desc_tlv_size ( info ) ) ; if ( ! tlvs [ ROCKER_TLV_RX_FRAG_ADDR ] || ! tlvs [ ROCKER_TLV_RX_FRAG_MAX_LEN ] ) { err = - ROCKER_EINVAL ; goto out ; } frag_addr = rocker_tlv_get_le64 ( tlvs [ ROCKER_TLV_RX_FRAG_ADDR ] ) ; frag_max_len = rocker_tlv_get_le16 ( tlvs [ ROCKER_TLV_RX_FRAG_MAX_LEN ] ) ; if ( data_size > frag_max_len ) { err = - ROCKER_EMSGSIZE ; goto out ; } if ( copy_to_cpu ) { rx_flags |= ROCKER_RX_FLAGS_FWD_OFFLOAD ; } tlv_size = rocker_tlv_total_size ( sizeof ( uint16_t ) ) + rocker_tlv_total_size ( sizeof ( uint16_t ) ) + rocker_tlv_total_size ( sizeof ( uint64_t ) ) + rocker_tlv_total_size ( sizeof ( uint16_t ) ) + rocker_tlv_total_size ( sizeof ( uint16_t ) ) ; if ( tlv_size > desc_buf_size ( info ) ) { err = - ROCKER_EMSGSIZE ; goto out ; } data = g_malloc ( data_size ) ; <S2SV_StartBug> if ( ! data ) { <S2SV_EndBug> err = - ROCKER_ENOMEM ; goto out ; } iov_to_buf ( iov , iovcnt , 0 , data , data_size ) ; pci_dma_write ( dev , frag_addr , data , data_size ) ; g_free ( data ) ; pos = 0 ; rocker_tlv_put_le16 ( buf , & pos , ROCKER_TLV_RX_FLAGS , rx_flags ) ; rocker_tlv_put_le16 ( buf , & pos , ROCKER_TLV_RX_CSUM , rx_csum ) ; rocker_tlv_put_le64 ( buf , & pos , ROCKER_TLV_RX_FRAG_ADDR , frag_addr ) ; rocker_tlv_put_le16 ( buf , & pos , ROCKER_TLV_RX_FRAG_MAX_LEN , frag_max_len ) ; rocker_tlv_put_le16 ( buf , & pos , ROCKER_TLV_RX_FRAG_LEN , data_size ) ; err = desc_set_buf ( info , tlv_size ) ; out : if ( desc_ring_post_desc ( ring , err ) ) { rocker_msix_irq ( r , ROCKER_MSIX_VEC_RX ( pport - 1 ) ) ; } return err ; }
<S2SV_ModStart> data_size ) ; <S2SV_ModEnd> iov_to_buf ( iov
6,782
CWE-000 static int whitelist_device ( BPFProgram * prog , const char * path , const char * node , const char * acc ) { struct stat st ; bool ignore_notfound ; int r ; assert ( path ) ; assert ( acc ) ; if ( node [ 0 ] == '-' ) { node ++ ; ignore_notfound = true ; } else ignore_notfound = false ; if ( stat ( node , & st ) < 0 ) { if ( errno == ENOENT && ignore_notfound ) return 0 ; return log_warning_errno ( errno , "Couldn\'t<S2SV_blank>stat<S2SV_blank>device<S2SV_blank>%s:<S2SV_blank>%m" , node ) ; } if ( ! S_ISCHR ( st . st_mode ) && ! S_ISBLK ( st . st_mode ) ) { log_warning ( "%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>device." , node ) ; return - ENODEV ; } if ( cg_all_unified ( ) > 0 ) { if ( ! prog ) return 0 ; <S2SV_StartBug> cgroup_bpf_whitelist_device ( prog , S_ISCHR ( st . st_mode ) ? BPF_DEVCG_DEV_CHAR : BPF_DEVCG_DEV_BLOCK , <S2SV_EndBug> major ( st . st_rdev ) , minor ( st . st_rdev ) , acc ) ; } else { char buf [ 2 + DECIMAL_STR_MAX ( dev_t ) * 2 + 2 + 4 ] ; sprintf ( buf , "%c<S2SV_blank>%u:%u<S2SV_blank>%s" , S_ISCHR ( st . st_mode ) ? 'c' : 'b' , major ( st . st_rdev ) , minor ( st . st_rdev ) , acc ) ; r = cg_set_attribute ( "devices" , path , "devices.allow" , buf ) ; if ( r < 0 ) <S2SV_StartBug> log_full_errno ( IN_SET ( r , - ENOENT , - EROFS , - EINVAL , - EACCES ) ? LOG_DEBUG : LOG_WARNING , <S2SV_EndBug> r , "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>devices.allow<S2SV_blank>on<S2SV_blank>%s:<S2SV_blank>%m" , path ) ; <S2SV_StartBug> } <S2SV_EndBug> return r ; }
<S2SV_ModStart> return 0 ; return <S2SV_ModStart> < 0 ) return <S2SV_ModStart> path ) ; return 0 ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
6,783
CWE-000 static void mono_class_setup_basic_field_info ( MonoClass * klass ) { MonoGenericClass * gklass ; MonoClassField * field ; MonoClassField * fields ; MonoClass * gtd ; MonoImage * image ; int i , top ; if ( klass -> fields ) return ; gklass = mono_class_try_get_generic_class ( klass ) ; gtd = gklass ? mono_class_get_generic_type_definition ( klass ) : NULL ; image = klass -> image ; if ( gklass && image_is_dynamic ( gklass -> container_class -> image ) && ! gklass -> container_class -> wastypebuilder ) { return ; } if ( gtd ) { mono_class_setup_basic_field_info ( gtd ) ; mono_loader_lock ( ) ; mono_class_set_field_count ( klass , mono_class_get_field_count ( gtd ) ) ; mono_loader_unlock ( ) ; } top = mono_class_get_field_count ( klass ) ; fields = ( MonoClassField * ) mono_class_alloc0 ( klass , sizeof ( MonoClassField ) * top ) ; <S2SV_StartBug> int first_field_idx = mono_class_has_static_metadata ( klass ) ? mono_class_get_first_field_idx ( klass ) : 0 ; <S2SV_EndBug> for ( i = 0 ; i < top ; i ++ ) { field = & fields [ i ] ; field -> parent = klass ; if ( gtd ) { field -> name = mono_field_get_name ( & gtd -> fields [ i ] ) ; } else { int idx = first_field_idx + i ; guint32 name_idx = mono_metadata_decode_table_row_col ( image , MONO_TABLE_FIELD , idx , MONO_FIELD_NAME ) ; field -> name = mono_metadata_string_heap ( image , name_idx ) ; } } mono_memory_barrier ( ) ; mono_loader_lock ( ) ; if ( ! klass -> fields ) klass -> fields = fields ; mono_loader_unlock ( ) ; }
<S2SV_ModStart> int first_field_idx = mono_class_has_metadata <S2SV_ModEnd> ( klass )
6,784
CWE-000 PHP_FUNCTION ( sodium_crypto_aead_chacha20poly1305_encrypt ) { zend_string * ciphertext ; unsigned char * ad ; unsigned char * msg ; unsigned char * npub ; unsigned char * secretkey ; unsigned long long ciphertext_real_len ; size_t ad_len ; size_t ciphertext_len ; size_t msg_len ; size_t npub_len ; size_t secretkey_len ; if ( zend_parse_parameters_throw ( ZEND_NUM_ARGS ( ) , "ssss" , & msg , & msg_len , & ad , & ad_len , & npub , & npub_len , & secretkey , & secretkey_len ) == FAILURE ) { sodium_remove_param_values_from_backtrace ( EG ( exception ) ) ; return ; } if ( npub_len != crypto_aead_chacha20poly1305_NPUBBYTES ) { zend_throw_exception ( sodium_exception_ce , "public<S2SV_blank>nonce<S2SV_blank>size<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" <S2SV_StartBug> "CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES<S2SV_blank>bytes" , <S2SV_EndBug> 0 ) ; return ; } if ( secretkey_len != crypto_aead_chacha20poly1305_KEYBYTES ) { zend_throw_exception ( sodium_exception_ce , "secret<S2SV_blank>key<S2SV_blank>size<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" <S2SV_StartBug> "CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES<S2SV_blank>bytes" , <S2SV_EndBug> 0 ) ; return ; } if ( SIZE_MAX - msg_len <= crypto_aead_chacha20poly1305_ABYTES ) { zend_throw_exception ( sodium_exception_ce , "arithmetic<S2SV_blank>overflow" , 0 ) ; return ; } ciphertext_len = msg_len + crypto_aead_chacha20poly1305_ABYTES ; ciphertext = zend_string_alloc ( ( size_t ) ciphertext_len , 0 ) ; if ( crypto_aead_chacha20poly1305_encrypt ( ( unsigned char * ) ZSTR_VAL ( ciphertext ) , & ciphertext_real_len , msg , ( unsigned long long ) msg_len , ad , ( unsigned long long ) ad_len , NULL , npub , secretkey ) != 0 ) { zend_string_free ( ciphertext ) ; zend_throw_exception ( sodium_exception_ce , "internal<S2SV_blank>error" , 0 ) ; return ; } if ( ciphertext_real_len <= 0U || ciphertext_real_len >= SIZE_MAX || ciphertext_real_len > ciphertext_len ) { zend_string_free ( ciphertext ) ; zend_throw_exception ( sodium_exception_ce , "arithmetic<S2SV_blank>overflow" , 0 ) ; return ; } PHP_SODIUM_ZSTR_TRUNCATE ( ciphertext , ( size_t ) ciphertext_real_len ) ; ZSTR_VAL ( ciphertext ) [ ciphertext_real_len ] = 0 ; RETURN_STR ( ciphertext ) ; }
<S2SV_ModStart> sodium_exception_ce , "public<S2SV_blank>nonce<S2SV_blank>size<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" "SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES<S2SV_blank>bytes" <S2SV_ModEnd> , 0 ) <S2SV_ModStart> sodium_exception_ce , "secret<S2SV_blank>key<S2SV_blank>size<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" "SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES<S2SV_blank>bytes" <S2SV_ModEnd> , 0 )
6,785
CWE-000 static uint32_t init ( void * base_of_flash ) # endif { uint8_t vendorID = 0 ; flexspi_config_t config = { . rxSampleClock = kFLEXSPI_ReadSampleClkLoopbackInternally , . enableSckFreeRunning = false , . enableCombination = false , . enableDoze = true , . enableHalfSpeedAccess = false , . enableSckBDiffOpt = false , . enableSameConfigForAll = false , . seqTimeoutCycle = 0xFFFFU , . ipGrantTimeoutCycle = 0xFFU , . txWatermark = 8 , . rxWatermark = 8 , . ahbConfig . enableAHBWriteIpTxFifo = false , . ahbConfig . enableAHBWriteIpRxFifo = false , . ahbConfig . ahbGrantTimeoutCycle = 0xFFU , . ahbConfig . ahbBusTimeoutCycle = 0xFFFFU , . ahbConfig . resumeWaitCycle = 0x20U , . ahbConfig . buffer = { 0 , 0 , 0 , 0 } , . ahbConfig . enableClearAHBBufferOpt = false , . ahbConfig . enableAHBPrefetch = false , . ahbConfig . enableAHBBufferable = false , . ahbConfig . enableAHBCachable = false , } ; flexspi_device_config_t QSPIFlash_25Q256JVEQ_config = { . flexspiRootClk = 10000000UL , . flashSize = FLASH_SIZE , . CSIntervalUnit = kFLEXSPI_CsIntervalUnit1SckCycle , . CSInterval = 2 , . CSHoldTime = 3 , . CSSetupTime = 3 , . dataValidTime = 0 , . columnspace = 0 , . enableWordAddress = 0 , . AWRSeqIndex = 0 , . AWRSeqNumber = 0 , . ARDSeqIndex = NOR_CMD_LUT_SEQ_IDX_READ_FAST_QUAD , . ARDSeqNumber = 1 , . AHBWriteWaitUnit = kFLEXSPI_AhbWriteWaitUnit2AhbCycle , . AHBWriteWaitInterval = 0 , } ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_06_FLEXSPIA_SS0_B , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_06_FLEXSPIA_SS0_B , 0x10F1 ) ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_07_FLEXSPIA_SCLK , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_07_FLEXSPIA_SCLK , 0x10F1 ) ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_08_FLEXSPIA_DATA00 , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_08_FLEXSPIA_DATA00 , 0x10F1 ) ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_09_FLEXSPIA_DATA01 , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_09_FLEXSPIA_DATA01 , 0x10F1 ) ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_10_FLEXSPIA_DATA02 , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_10_FLEXSPIA_DATA02 , 0x10F1 ) ; IOMUXC_SetPinMux ( IOMUXC_GPIO_SD_B1_11_FLEXSPIA_DATA03 , 1U ) ; IOMUXC_SetPinConfig ( IOMUXC_GPIO_SD_B1_11_FLEXSPIA_DATA03 , 0x10F1 ) ; BOARD_BootClockRUN ( ) ; CLOCK_InitUsb1Pll ( & ( clock_usb_pll_config_t ) { . loopDivider = 0U } ) ; CLOCK_InitUsb1Pfd ( kCLOCK_Pfd0 , 24 ) ; CLOCK_SetMux ( kCLOCK_FlexspiMux , 0x3 ) ; CLOCK_SetDiv ( kCLOCK_FlexspiDiv , 2 ) ; <S2SV_StartBug> SCB_DisableDCache ( ) ; <S2SV_EndBug> FLEXSPI_Init ( FLEXSPI , & config ) ; FLEXSPI_SetFlashConfig ( FLEXSPI , & QSPIFlash_25Q256JVEQ_config , kFLEXSPI_PortA1 ) ; FLEXSPI_UpdateLUT ( FLEXSPI , 0 , QSPIFlash_25Q256JVEQ_LUT , sizeof ( QSPIFlash_25Q256JVEQ_LUT ) / sizeof ( uint32_t ) ) ; if ( kStatus_Success != flexspi_nor_Get_VendorID ( FLEXSPI , & vendorID ) ) { return RESULT_ERROR ; } else { return vendorID ; } }
<S2SV_ModStart> 2 ) ; <S2SV_ModEnd> FLEXSPI_Init ( FLEXSPI
6,786
CWE-000 void xml_data_normale ( t_env * e , char * * attributes , int * i , t_node * node ) { if ( node && attributes && e ) { if ( attributes [ ( * i ) ] == NULL ) s_error ( "\\x1b[2;31mError<S2SV_blank>reading<S2SV_blank>NORMALE<S2SV_blank>value\\x1b[0m" , e ) ; node -> normale . x = ft_atof ( attributes [ ( * i ) ++ ] + 9 ) ; node -> normale . y = ft_atof ( attributes [ ( * i ) ++ ] ) ; if ( attributes [ * i ] [ ft_strlen ( attributes [ * i ] ) - 1 ] != \'\\"\' ) s_error ( "\\x1b[2;31mError<S2SV_blank>in<S2SV_blank>NORMALE<S2SV_blank>vector<S2SV_blank>from<S2SV_blank>scene\\x1b[0m" , e ) ; node -> normale . z = ft_atof ( attributes [ ( * i ) ++ ] ) ; } else s_error ( "\\x1b[2;31mError<S2SV_blank>reading<S2SV_blank>NORMALE<S2SV_blank>vector<S2SV_blank>from<S2SV_blank>scene\\x1b[0m" , e ) ; <S2SV_StartBug> if ( node -> pos . x == 0 && node -> pos . y == 0 && node -> pos . z == 0 ) <S2SV_EndBug> <S2SV_StartBug> node -> pos . x = 1 ; <S2SV_EndBug> }
<S2SV_ModStart> ( node -> normale <S2SV_ModEnd> . x == <S2SV_ModStart> && node -> normale <S2SV_ModEnd> . y == <S2SV_ModStart> && node -> normale <S2SV_ModEnd> . z == <S2SV_ModStart> ) node -> normale <S2SV_ModEnd> . x =
6,787
CWE-000 QDF_STATUS wma_pre_start ( void * cds_ctx ) { QDF_STATUS qdf_status = QDF_STATUS_SUCCESS ; A_STATUS status = A_OK ; tp_wma_handle wma_handle ; cds_msg_t wma_msg = { 0 } ; WMA_LOGD ( "%s:<S2SV_blank>Enter" , __func__ ) ; wma_handle = cds_get_context ( QDF_MODULE_ID_WMA ) ; if ( NULL == wma_handle ) { WMA_LOGP ( "%s:<S2SV_blank>invalid<S2SV_blank>argument" , __func__ ) ; qdf_status = QDF_STATUS_E_INVAL ; goto end ; } status = wmi_unified_connect_htc_service ( wma_handle -> wmi_handle , wma_handle -> htc_handle ) ; if ( A_OK != status ) { WMA_LOGP ( "%s:<S2SV_blank>wmi_unified_connect_htc_service" , __func__ ) ; <S2SV_StartBug> qdf_status = QDF_STATUS_E_FAULT ; <S2SV_EndBug> goto end ; } WMA_LOGD ( "WMA<S2SV_blank>--><S2SV_blank>wmi_unified_connect_htc_service<S2SV_blank>-<S2SV_blank>success" ) ; wma_msg . type = WNI_CFG_DNLD_REQ ; wma_msg . bodyptr = NULL ; wma_msg . bodyval = 0 ; qdf_status = cds_mq_post_message ( CDS_MQ_ID_WMA , & wma_msg ) ; if ( QDF_STATUS_SUCCESS != qdf_status ) { WMA_LOGP ( "%s:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>post<S2SV_blank>WNI_CFG_DNLD_REQ<S2SV_blank>msg" , __func__ ) ; QDF_ASSERT ( 0 ) ; qdf_status = QDF_STATUS_E_FAILURE ; } end : WMA_LOGD ( "%s:<S2SV_blank>Exit" , __func__ ) ; return qdf_status ; }
<S2SV_ModStart> __func__ ) ; if ( ! cds_is_fw_down ( ) ) QDF_BUG ( 0 ) ;
6,788
CWE-000 condesc_t * condesc_add ( ConTable * ct , const char * constring ) { if ( 0 == ct -> size ) { condesc_table_alloc ( ct , ct -> num_con ) ; ct -> num_con = 0 ; ct -> mempool = pool_new ( __func__ , "ConTable" , 1024 , sizeof ( condesc_t ) , true , true , false ) ; } uint32_t hash = ( connector_hash_size ) connector_str_hash ( constring ) ; condesc_t * * h = condesc_find ( ct , constring , hash ) ; if ( NULL == * h ) { <S2SV_StartBug> lgdebug ( + 11 , "Creating<S2SV_blank>connector<S2SV_blank>\'%s\'\\n" , constring ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! condesc_insert ( ct , h , constring , hash ) ) return NULL ; <S2SV_EndBug> <S2SV_StartBug> if ( ( 8 * ct -> num_con ) > ( 3 * ct -> size ) ) <S2SV_EndBug> { if ( ! condesc_grow ( ct ) ) return NULL ; h = condesc_find ( ct , constring , hash ) ; } } return * h ; }
<S2SV_ModStart> h ) { assert ( 0 == ct -> num_uc , "Trying<S2SV_blank>to<S2SV_blank>add<S2SV_blank>a<S2SV_blank>connector<S2SV_blank>(%s)<S2SV_blank>" "after<S2SV_blank>reading<S2SV_blank>the<S2SV_blank>dict.\\n" , constring ) ; <S2SV_ModStart> + 11 , "Creating<S2SV_blank>connector<S2SV_blank>\'%s\'<S2SV_blank>(%zu)\\n" , constring , ct -> num_con ) ; condesc_insert ( ct , h , constring , hash ) ; if ( ( 8 * ct -> num_con ) > ( 3 * ct -> size ) ) { <S2SV_ModEnd> if ( ! <S2SV_ModStart> if ( ! condesc_grow ( ct <S2SV_ModEnd> ) ) return <S2SV_ModStart> return NULL ; h = condesc_find ( ct , constring , hash ) ; } } return <S2SV_ModEnd> * h ;
6,789
CWE-000 static int get_coll_element ( char_u * * pp ) { int c ; int l = 1 ; char_u * p = * pp ; if ( p [ 0 ] != NUL && p [ 1 ] == '.' ) { <S2SV_StartBug> l = ( * mb_ptr2len ) ( p + 2 ) ; <S2SV_EndBug> if ( p [ l + 2 ] == '.' && p [ l + 3 ] == ']' ) { c = utf_ptr2char ( p + 2 ) ; * pp += l + 4 ; return c ; } } return 0 ; }
<S2SV_ModStart> { l = utfc_ptr2len <S2SV_ModEnd> ( p +
6,790
CWE-000 LoRaMacStatus_t RegionAS923NextChannel ( NextChanParams_t * nextChanParams , uint8_t * channel , TimerTime_t * time , TimerTime_t * aggregatedTimeOff ) { uint8_t channelNext = 0 ; uint8_t nbEnabledChannels = 0 ; uint8_t delayTx = 0 ; uint8_t enabledChannels [ AS923_MAX_NB_CHANNELS ] = { 0 } ; TimerTime_t nextTxDelay = 0 ; if ( RegionCommonCountChannels ( NvmCtx . ChannelsMask , 0 , 1 ) == 0 ) { NvmCtx . ChannelsMask [ 0 ] |= LC ( 1 ) + LC ( 2 ) ; } <S2SV_StartBug> if ( nextChanParams -> AggrTimeOff <= TimerGetElapsedTime ( nextChanParams -> LastAggrTx ) ) <S2SV_EndBug> { * aggregatedTimeOff = 0 ; nextTxDelay = RegionCommonUpdateBandTimeOff ( nextChanParams -> Joined , nextChanParams -> DutyCycleEnabled , NvmCtx . Bands , AS923_MAX_NB_BANDS ) ; nbEnabledChannels = CountNbOfEnabledChannels ( nextChanParams -> Joined , nextChanParams -> Datarate , NvmCtx . ChannelsMask , NvmCtx . Channels , NvmCtx . Bands , enabledChannels , & delayTx ) ; } else { delayTx ++ ; <S2SV_StartBug> nextTxDelay = nextChanParams -> AggrTimeOff - TimerGetElapsedTime ( nextChanParams -> LastAggrTx ) ; <S2SV_EndBug> } if ( nbEnabledChannels > 0 ) { for ( uint8_t i = 0 , j = randr ( 0 , nbEnabledChannels - 1 ) ; i < AS923_MAX_NB_CHANNELS ; i ++ ) { channelNext = enabledChannels [ j ] ; j = ( j + 1 ) % nbEnabledChannels ; if ( Radio . IsChannelFree ( MODEM_LORA , NvmCtx . Channels [ channelNext ] . Frequency , AS923_RSSI_FREE_TH , AS923_CARRIER_SENSE_TIME ) == true ) { * channel = channelNext ; * time = 0 ; return LORAMAC_STATUS_OK ; } } return LORAMAC_STATUS_NO_FREE_CHANNEL_FOUND ; } else { if ( delayTx > 0 ) { * time = nextTxDelay ; return LORAMAC_STATUS_DUTYCYCLE_RESTRICTED ; } NvmCtx . ChannelsMask [ 0 ] |= LC ( 1 ) + LC ( 2 ) ; * time = 0 ; return LORAMAC_STATUS_NO_CHANNEL_FOUND ; } }
<S2SV_ModStart> ) ; } TimerTime_t elapsed = TimerGetElapsedTime ( nextChanParams -> LastAggrTx ) ; <S2SV_ModStart> -> AggrTimeOff <= elapsed <S2SV_ModEnd> ) { * <S2SV_ModStart> -> AggrTimeOff - elapsed <S2SV_ModEnd> ; } if
6,791
CWE-000 t_bool dir_file ( t_ls * env , char * file_name ) { if ( S_ISDIR ( env -> f_stat . st_mode ) ) { if ( ! ( env -> cur_dir = opendir ( file_name ) ) ) <S2SV_StartBug> exit_error ( ERRDIR , 0 , file_name ) ; <S2SV_EndBug> env -> cur_file = readdir ( env -> cur_dir ) ; get_file_name ( env -> my_stat . file_name , file_name ) ; return ( TRUE ) ; } return ( FALSE ) ; }
<S2SV_ModStart> ) ) ) { get_file_name ( env -> my_stat . file_name <S2SV_ModEnd> , file_name ) <S2SV_ModStart> file_name ) ; return ( FALSE ) ; }
6,792
CWE-000 void * thread_4 ( void * j ) { t_env * e ; t_trd * all ; e = j ; all = ( t_trd * ) malloc ( sizeof ( t_trd ) ) ; all -> x = WIDTH / 2 ; add_julia_ab ( all , e ) ; while ( all -> x ++ != WIDTH ) { all -> y = 0 ; while ( all -> y ++ != WIDTH / 2 ) { find_julia_ab ( all , e ) ; while ( ++ all -> n != e -> iter && ( sqrt ( ( all -> a * all -> a ) + ( all -> b * all -> b ) ) < 2.0 ) ) square_thread ( all ) ; all -> n == e -> iter ? pixel_put_img ( e , all -> x , all -> y , 0 ) : pixel_put_img ( e , all -> x , all -> y , all -> n * e -> man -> color ) ; } } free ( all ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> }
<S2SV_ModStart> ; return ( NULL <S2SV_ModEnd> ) ; }
6,793
CWE-000 void lim_send_deauth_mgmt_frame ( tpAniSirGlobal pMac , uint16_t nReason , tSirMacAddr peer , tpPESession psessionEntry , bool waitForAck ) { tDot11fDeAuth frm ; uint8_t * pFrame ; tpSirMacMgmtHdr pMacHdr ; uint32_t nBytes , nPayload , nStatus ; void * pPacket ; QDF_STATUS qdf_status ; uint8_t txFlag = 0 ; uint32_t val = 0 ; # ifdef FEATURE_WLAN_TDLS uint16_t aid ; tpDphHashNode pStaDs ; # endif uint8_t smeSessionId = 0 ; if ( NULL == psessionEntry ) { return ; } if ( ( ( psessionEntry -> pePersona == QDF_SAP_MODE ) || ( psessionEntry -> pePersona == QDF_P2P_GO_MODE ) ) && ( true == pMac -> sap . SapDfsInfo . is_dfs_cac_timer_running ) ) { QDF_TRACE ( QDF_MODULE_ID_SAP , QDF_TRACE_LEVEL_INFO , FL ( "CAC<S2SV_blank>timer<S2SV_blank>is<S2SV_blank>running,<S2SV_blank>drop<S2SV_blank>the<S2SV_blank>deauth<S2SV_blank>from<S2SV_blank>going<S2SV_blank>out" ) ) ; return ; } smeSessionId = psessionEntry -> smeSessionId ; qdf_mem_set ( ( uint8_t * ) & frm , sizeof ( frm ) , 0 ) ; frm . Reason . code = nReason ; nStatus = dot11f_get_packed_de_auth_size ( pMac , & frm , & nPayload ) ; if ( DOT11F_FAILED ( nStatus ) ) { lim_log ( pMac , LOGP , FL ( "Failed<S2SV_blank>to<S2SV_blank>calculate<S2SV_blank>the<S2SV_blank>packed<S2SV_blank>size<S2SV_blank>f" "or<S2SV_blank>a<S2SV_blank>De-Authentication<S2SV_blank>(0x%08x)." ) , nStatus ) ; nPayload = sizeof ( tDot11fDeAuth ) ; } else if ( DOT11F_WARNED ( nStatus ) ) { lim_log ( pMac , LOGW , FL ( "There<S2SV_blank>were<S2SV_blank>warnings<S2SV_blank>while<S2SV_blank>calculating<S2SV_blank>" "the<S2SV_blank>packed<S2SV_blank>size<S2SV_blank>for<S2SV_blank>a<S2SV_blank>De-Authentication<S2SV_blank>" "(0x%08x)." ) , nStatus ) ; } nBytes = nPayload + sizeof ( tSirMacMgmtHdr ) ; qdf_status = cds_packet_alloc ( ( uint16_t ) nBytes , ( void * * ) & pFrame , ( void * * ) & pPacket ) ; if ( ! QDF_IS_STATUS_SUCCESS ( qdf_status ) ) { lim_log ( pMac , LOGP , FL ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>for<S2SV_blank>a<S2SV_blank>De-" "Authentication." ) , nBytes ) ; return ; } qdf_mem_set ( pFrame , nBytes , 0 ) ; lim_populate_mac_header ( pMac , pFrame , SIR_MAC_MGMT_FRAME , SIR_MAC_MGMT_DEAUTH , peer , psessionEntry -> selfMacAddr ) ; pMacHdr = ( tpSirMacMgmtHdr ) pFrame ; sir_copy_mac_addr ( pMacHdr -> bssId , psessionEntry -> bssId ) ; # ifdef WLAN_FEATURE_11W lim_set_protected_bit ( pMac , psessionEntry , peer , pMacHdr ) ; # endif nStatus = dot11f_pack_de_auth ( pMac , & frm , pFrame + sizeof ( tSirMacMgmtHdr ) , nPayload , & nPayload ) ; if ( DOT11F_FAILED ( nStatus ) ) { lim_log ( pMac , LOGE , FL ( "Failed<S2SV_blank>to<S2SV_blank>pack<S2SV_blank>a<S2SV_blank>DeAuthentication<S2SV_blank>(0x%08x)." ) , nStatus ) ; cds_packet_free ( ( void * ) pPacket ) ; return ; } else if ( DOT11F_WARNED ( nStatus ) ) { lim_log ( pMac , LOGW , FL ( "There<S2SV_blank>were<S2SV_blank>warnings<S2SV_blank>while<S2SV_blank>packing<S2SV_blank>a<S2SV_blank>D" "e-Authentication<S2SV_blank>(0x%08x)." ) , nStatus ) ; } lim_log ( pMac , LOG1 , FL ( "***Sessionid<S2SV_blank>%d<S2SV_blank>Sending<S2SV_blank>Deauth<S2SV_blank>frame<S2SV_blank>with<S2SV_blank>" "reason<S2SV_blank>%u<S2SV_blank>and<S2SV_blank>waitForAck<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>" MAC_ADDRESS_STR "<S2SV_blank>,From<S2SV_blank>" MAC_ADDRESS_STR ) , psessionEntry -> peSessionId , nReason , waitForAck , MAC_ADDR_ARRAY ( pMacHdr -> da ) , MAC_ADDR_ARRAY ( psessionEntry -> selfMacAddr ) ) ; if ( ( SIR_BAND_5_GHZ == lim_get_rf_band ( psessionEntry -> currentOperChannel ) ) || ( psessionEntry -> pePersona == QDF_P2P_CLIENT_MODE ) || ( psessionEntry -> pePersona == QDF_P2P_GO_MODE ) ) { txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME ; } txFlag |= HAL_USE_PEER_STA_REQUESTED_MASK ; # ifdef FEATURE_WLAN_TDLS pStaDs = dph_lookup_hash_entry ( pMac , peer , & aid , & psessionEntry -> dph . dphHashTable ) ; # endif if ( waitForAck ) { MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_MGMT , psessionEntry -> peSessionId , pMacHdr -> fc . subType ) ) ; qdf_status = wma_tx_frameWithTxComplete ( pMac , pPacket , ( uint16_t ) nBytes , TXRX_FRM_802_11_MGMT , ANI_TXDIR_TODS , 7 , lim_tx_complete , pFrame , lim_deauth_tx_complete_cnf , <S2SV_StartBug> txFlag , smeSessionId , false , 0 ) ; <S2SV_EndBug> MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_COMPLETE , psessionEntry -> peSessionId , qdf_status ) ) ; if ( ! QDF_IS_STATUS_SUCCESS ( qdf_status ) ) { lim_log ( pMac , LOGE , FL ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>De-Authentication<S2SV_blank>(%X)!" ) , qdf_status ) ; lim_process_deauth_ack_timeout ( pMac ) ; return ; } val = SYS_MS_TO_TICKS ( LIM_DISASSOC_DEAUTH_ACK_TIMEOUT ) ; if ( tx_timer_change ( & pMac -> lim . limTimers . gLimDeauthAckTimer , val , 0 ) != TX_SUCCESS ) { lim_log ( pMac , LOGP , FL ( "Unable<S2SV_blank>to<S2SV_blank>change<S2SV_blank>Deauth<S2SV_blank>ack<S2SV_blank>Timer<S2SV_blank>val" ) ) ; return ; } else if ( TX_SUCCESS != tx_timer_activate ( & pMac -> lim . limTimers . gLimDeauthAckTimer ) ) { lim_log ( pMac , LOGP , FL ( "Unable<S2SV_blank>to<S2SV_blank>activate<S2SV_blank>Deauth<S2SV_blank>ack<S2SV_blank>Timer" ) ) ; lim_deactivate_and_change_timer ( pMac , eLIM_DEAUTH_ACK_TIMER ) ; return ; } } else { MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_MGMT , psessionEntry -> peSessionId , pMacHdr -> fc . subType ) ) ; # ifdef FEATURE_WLAN_TDLS if ( ( NULL != pStaDs ) && ( STA_ENTRY_TDLS_PEER == pStaDs -> staType ) ) { qdf_status = wma_tx_frame ( pMac , pPacket , ( uint16_t ) nBytes , TXRX_FRM_802_11_MGMT , ANI_TXDIR_IBSS , 7 , lim_tx_complete , pFrame , txFlag , <S2SV_StartBug> smeSessionId , 0 ) ; <S2SV_EndBug> } else { # endif qdf_status = wma_tx_frame ( pMac , pPacket , ( uint16_t ) nBytes , TXRX_FRM_802_11_MGMT , ANI_TXDIR_TODS , 7 , lim_tx_complete , pFrame , txFlag , <S2SV_StartBug> smeSessionId , 0 ) ; <S2SV_EndBug> # ifdef FEATURE_WLAN_TDLS } # endif MTRACE ( qdf_trace ( QDF_MODULE_ID_PE , TRACE_CODE_TX_COMPLETE , psessionEntry -> peSessionId , qdf_status ) ) ; if ( ! QDF_IS_STATUS_SUCCESS ( qdf_status ) ) { lim_log ( pMac , LOGE , FL ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>De-Authentication<S2SV_blank>(%X)!" ) , qdf_status ) ; } } }
<S2SV_ModStart> false , 0 , RATEID_DEFAULT <S2SV_ModStart> smeSessionId , 0 , RATEID_DEFAULT <S2SV_ModStart> smeSessionId , 0 , RATEID_DEFAULT
6,794
CWE-000 int rdbSaveRio ( rio * rdb , int * error , int flags , rdbSaveInfo * rsi ) { dictIterator * di = NULL ; dictEntry * de ; char magic [ 10 ] ; int j ; long long now = mstime ( ) ; uint64_t cksum ; size_t processed = 0 ; if ( server . rdb_checksum ) rdb -> update_cksum = rioGenericUpdateChecksum ; snprintf ( magic , sizeof ( magic ) , "REDIS%04d" , RDB_VERSION ) ; if ( rdbWriteRaw ( rdb , magic , 9 ) == - 1 ) goto werr ; if ( rdbSaveInfoAuxFields ( rdb , flags , rsi ) == - 1 ) goto werr ; for ( j = 0 ; j < server . dbnum ; j ++ ) { redisDb * db = server . db + j ; dict * d = db -> dict ; if ( dictSize ( d ) == 0 ) continue ; di = dictGetSafeIterator ( d ) ; <S2SV_StartBug> if ( ! di ) return C_ERR ; <S2SV_EndBug> if ( rdbSaveType ( rdb , RDB_OPCODE_SELECTDB ) == - 1 ) goto werr ; if ( rdbSaveLen ( rdb , j ) == - 1 ) goto werr ; uint32_t db_size , expires_size ; db_size = ( dictSize ( db -> dict ) <= UINT32_MAX ) ? dictSize ( db -> dict ) : UINT32_MAX ; expires_size = ( dictSize ( db -> expires ) <= UINT32_MAX ) ? dictSize ( db -> expires ) : UINT32_MAX ; if ( rdbSaveType ( rdb , RDB_OPCODE_RESIZEDB ) == - 1 ) goto werr ; if ( rdbSaveLen ( rdb , db_size ) == - 1 ) goto werr ; if ( rdbSaveLen ( rdb , expires_size ) == - 1 ) goto werr ; while ( ( de = dictNext ( di ) ) != NULL ) { sds keystr = dictGetKey ( de ) ; robj key , * o = dictGetVal ( de ) ; long long expire ; initStaticStringObject ( key , keystr ) ; expire = getExpire ( db , & key ) ; if ( rdbSaveKeyValuePair ( rdb , & key , o , expire , now ) == - 1 ) goto werr ; if ( flags & RDB_SAVE_AOF_PREAMBLE && rdb -> processed_bytes > processed + AOF_READ_DIFF_INTERVAL_BYTES ) { processed = rdb -> processed_bytes ; aofReadDiffFromParent ( ) ; } } dictReleaseIterator ( di ) ; <S2SV_StartBug> } <S2SV_EndBug> di = NULL ; if ( rsi && dictSize ( server . lua_scripts ) ) { di = dictGetIterator ( server . lua_scripts ) ; while ( ( de = dictNext ( di ) ) != NULL ) { robj * body = dictGetVal ( de ) ; if ( rdbSaveAuxField ( rdb , "lua" , 3 , body -> ptr , sdslen ( body -> ptr ) ) == - 1 ) goto werr ; } dictReleaseIterator ( di ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( rdbSaveType ( rdb , RDB_OPCODE_EOF ) == - 1 ) goto werr ; cksum = rdb -> cksum ; memrev64ifbe ( & cksum ) ; if ( rioWrite ( rdb , & cksum , 8 ) == 0 ) goto werr ; return C_OK ; werr : if ( error ) * error = errno ; if ( di ) dictReleaseIterator ( di ) ; return C_ERR ; }
<S2SV_ModStart> ; if ( <S2SV_ModEnd> rdbSaveType ( rdb <S2SV_ModStart> di ) ; di = NULL ; } <S2SV_ModEnd> if ( rsi <S2SV_ModStart> di ) ; di = NULL ;
6,795
CWE-000 ion_err_t ion_linear_hash_increment_num_records ( ion_linear_hash_table_t * table ) { # if LINEAR_HASH_DEBUG_INCREMENT printf ( "Incrementing<S2SV_blank>the<S2SV_blank>number<S2SV_blank>of<S2SV_blank>records\\n" ) ; # endif table -> num_records ++ ; <S2SV_StartBug> float load = ( 100.0f * table -> num_records ) / ( table -> current_size * table -> records_per_bucket ) ; <S2SV_EndBug> ion_boolean_t above_threshold = ( load > table -> split_threshold ) ; # if LINEAR_HASH_DEBUG_INCREMENT <S2SV_StartBug> printf ( "\\tIncremented<S2SV_blank>number<S2SV_blank>of<S2SV_blank>records<S2SV_blank>to<S2SV_blank>%d\\n" , table -> num_records ) ; <S2SV_EndBug> printf ( "\\tLoad<S2SV_blank>is<S2SV_blank>now:<S2SV_blank>%d\\n" , ( int ) load ) ; # endif <S2SV_StartBug> if ( above_threshold ) { <S2SV_EndBug> return ion_linear_hash_split ( table ) ; } return err_ok ; }
<S2SV_ModStart> num_records ++ ; ion_boolean_t above_threshold = ion_linear_hash_check_above_threshold ( table ) ; if ( boolean_true == above_threshold ) { <S2SV_ModEnd> # if LINEAR_HASH_DEBUG_INCREMENT <S2SV_ModStart> LINEAR_HASH_DEBUG_INCREMENT printf ( "\\tTriggering<S2SV_blank>Split\\n" <S2SV_ModEnd> ) ; # <S2SV_ModStart> ; # endif <S2SV_ModEnd> return ion_linear_hash_split (
6,796
CWE-000 static void append_name ( char * send_buf , char * client_name ) { <S2SV_StartBug> memcpy ( & send_buf [ strlen ( client_name ) ] , send_buf , strlen ( send_buf ) + 1 ) ; <S2SV_EndBug> memcpy ( send_buf , client_name , strlen ( client_name ) ) ; }
<S2SV_ModStart> client_name ) { char temp_buf [ BUF_SIZE ] ; memcpy ( temp_buf , send_buf , strlen ( send_buf ) + 1 ) ; <S2SV_ModStart> ) ] , temp_buf <S2SV_ModEnd> , strlen ( <S2SV_ModStart> , strlen ( temp_buf <S2SV_ModEnd> ) + 1
6,797
CWE-000 void genprim_array_serialise_trace ( compile_t * c , reach_type_t * t ) { compile_type_t * c_t = ( compile_type_t * ) t -> c_type ; c_t -> serialise_trace_fn = codegen_addfun ( c , genname_serialise_trace ( t -> name ) , c -> trace_type , true ) ; codegen_startfun ( c , c_t -> serialise_trace_fn , NULL , NULL , false ) ; LLVMSetFunctionCallConv ( c_t -> serialise_trace_fn , LLVMCCallConv ) ; LLVMSetLinkage ( c_t -> serialise_trace_fn , LLVMExternalLinkage ) ; LLVMValueRef ctx = LLVMGetParam ( c_t -> serialise_trace_fn , 0 ) ; LLVMValueRef arg = LLVMGetParam ( c_t -> serialise_trace_fn , 1 ) ; LLVMValueRef object = LLVMBuildBitCast ( c -> builder , arg , c_t -> use_type , "" ) ; LLVMValueRef size = field_value ( c , object , 1 ) ; LLVMBasicBlockRef trace_block = codegen_block ( c , "trace" ) ; LLVMBasicBlockRef post_block = codegen_block ( c , "post" ) ; LLVMValueRef cond = LLVMBuildICmp ( c -> builder , LLVMIntNE , size , <S2SV_StartBug> LLVMConstInt ( c -> intptr , 0 , false ) , "" ) ; <S2SV_EndBug> LLVMBuildCondBr ( c -> builder , cond , trace_block , post_block ) ; LLVMPositionBuilderAtEnd ( c -> builder , trace_block ) ; ast_t * typeargs = ast_childidx ( t -> ast , 2 ) ; ast_t * typearg = ast_child ( typeargs ) ; compile_type_t * t_elem = ( compile_type_t * ) reach_type ( c -> reach , typearg ) -> c_type ; size_t abisize = ( size_t ) LLVMABISizeOfType ( c -> target_data , t_elem -> use_type ) ; LLVMValueRef l_size = LLVMConstInt ( c -> intptr , abisize , false ) ; LLVMValueRef pointer = field_value ( c , object , 3 ) ; LLVMValueRef args [ 3 ] ; args [ 0 ] = ctx ; args [ 1 ] = pointer ; args [ 2 ] = LLVMBuildMul ( c -> builder , size , l_size , "" ) ; gencall_runtime ( c , "pony_serialise_reserve" , args , 3 , "" ) ; trace_array_elements ( c , t , ctx , object , pointer ) ; LLVMBuildBr ( c -> builder , post_block ) ; LLVMPositionBuilderAtEnd ( c -> builder , post_block ) ; LLVMBuildRetVoid ( c -> builder ) ; codegen_finishfun ( c ) ; }
<S2SV_ModStart> -> intptr , PONY_TRACE_OPAQUE <S2SV_ModEnd> , false )
6,798
CWE-000 int bic_get_sdr ( uint8_t slot_id , ipmi_sel_sdr_req_t * req , ipmi_sel_sdr_res_t * res , uint8_t * rlen ) { int ret ; uint8_t tbuf [ MAX_IPMB_RES_LEN ] = { 0 } ; <S2SV_StartBug> uint8_t tlen ; <S2SV_EndBug> uint8_t len ; ipmi_sel_sdr_res_t * tres ; sdr_rec_hdr_t * hdr ; tres = ( ipmi_sel_sdr_res_t * ) tbuf ; <S2SV_StartBug> ret = _get_sdr_rsv ( slot_id , & req -> rsv_id ) ; <S2SV_EndBug> if ( ret ) { # ifdef DEBUG syslog ( LOG_ERR , "bic_read_sdr:<S2SV_blank>_get_sdr_rsv<S2SV_blank>returns<S2SV_blank>%d\\n" , ret ) ; # endif return ret ; } <S2SV_StartBug> * rlen = 0 ; <S2SV_EndBug> req -> offset = 0 ; req -> nbytes = sizeof ( sdr_rec_hdr_t ) ; ret = _get_sdr ( slot_id , req , tbuf , & tlen ) ; if ( ret ) { # ifdef DEBUG syslog ( LOG_ERR , "bic_read_sdr:<S2SV_blank>_get_sdr<S2SV_blank>returns<S2SV_blank>%d\\n" , ret ) ; # endif return ret ; } res -> next_rec_id = tres -> next_rec_id ; memcpy ( res -> data , tres -> data , tlen - 2 ) ; * rlen += tlen - 2 ; req -> offset = tlen - 2 ; hdr = ( sdr_rec_hdr_t * ) tres -> data ; len = hdr -> len ; while ( len > 0 ) { if ( len > SDR_READ_COUNT_MAX ) { req -> nbytes = SDR_READ_COUNT_MAX ; } else { req -> nbytes = len ; } ret = _get_sdr ( slot_id , req , tbuf , & tlen ) ; if ( ret ) { # ifdef DEBUG syslog ( LOG_ERR , "bic_read_sdr:<S2SV_blank>_get_sdr<S2SV_blank>returns<S2SV_blank>%d\\n" , ret ) ; # endif return ret ; } memcpy ( & res -> data [ req -> offset ] , tres -> data , tlen - 2 ) ; * rlen += tlen - 2 ; req -> offset += tlen - 2 ; len -= tlen - 2 ; } if ( * rlen == 0 ) { syslog ( LOG_ERR , "%s:<S2SV_blank>FRU<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>SDR<S2SV_blank>size<S2SV_blank>is<S2SV_blank>zero\\n" , __func__ , slot_id ) ; } return 0 ; }
<S2SV_ModStart> } ; uint8_t rbuf [ MAX_IPMB_RES_LEN ] = { 0 } ; uint8_t <S2SV_ModStart> ( slot_id , rbuf <S2SV_ModEnd> ) ; if <S2SV_ModStart> ret ; } req -> rsv_id = ( rbuf [ 1 ] << 8 ) | rbuf [ 0 ] ;
6,799
CWE-000 static void EvaluateNode ( const size_t block_start , const size_t pos , const size_t max_backward_limit , <S2SV_StartBug> const int * starting_dist_cache , const ZopfliCostModel * model , <S2SV_EndBug> StartPosQueue * queue , ZopfliNode * nodes ) { float node_cost = nodes [ pos ] . u . cost ; nodes [ pos ] . u . shortcut = ComputeDistanceShortcut ( <S2SV_StartBug> block_start , pos , max_backward_limit , nodes ) ; <S2SV_EndBug> if ( node_cost <= ZopfliCostModelGetLiteralCosts ( model , 0 , pos ) ) { PosData posdata ; posdata . pos = pos ; posdata . cost = node_cost ; posdata . costdiff = node_cost - ZopfliCostModelGetLiteralCosts ( model , 0 , pos ) ; ComputeDistanceCache ( pos , starting_dist_cache , nodes , posdata . distance_cache ) ; StartPosQueuePush ( queue , & posdata ) ; } }
<S2SV_ModStart> max_backward_limit , const size_t gap , const <S2SV_ModStart> pos , max_backward_limit , gap