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
3,500
CWE-000 static void fs_open ( char * device ) { unsigned long long int state , extended ; if ( libreiser4_init ( ) ) { log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>Can\'t<S2SV_blank>initialize<S2SV_blank>libreiser4.\\n" , __FILE__ ) ; } if ( ! ( fs_device = aal_device_open ( & file_ops , device , 512 , O_RDONLY ) ) ) { log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>Cannot<S2SV_blank>open<S2SV_blank>the<S2SV_blank>partition<S2SV_blank>(%s).\\n" , __FILE__ , device ) ; } if ( ! ( fs = reiser4_fs_open ( fs_device , 0 ) ) ) { log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>Can\'t<S2SV_blank>open<S2SV_blank>reiser4<S2SV_blank>on<S2SV_blank>%s\\n" , __FILE__ , device ) ; } if ( ! ( fs -> journal = reiser4_journal_open ( fs , fs_device ) ) ) { log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>Can\'t<S2SV_blank>open<S2SV_blank>journal<S2SV_blank>on<S2SV_blank>%s" , __FILE__ , device ) ; } state = get_ss_status ( STATUS ( fs -> status ) ) ; extended = get_ss_extended ( STATUS ( fs -> status ) ) ; if ( fs_opt . ignore_fschk ) { log_mesg ( 1 , 0 , 0 , fs_opt . debug , "%s:<S2SV_blank>Ignore<S2SV_blank>filesystem<S2SV_blank>check\\n" , __FILE__ ) ; } else { if ( ! state ) <S2SV_StartBug> log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>REISER4<S2SV_blank>can\'t<S2SV_blank>get<S2SV_blank>status\\n" , __FILE__ ) ; <S2SV_EndBug> if ( state ) <S2SV_StartBug> log_mesg ( 3 , 0 , 0 , fs_opt . debug , "%s:<S2SV_blank>REISER4<S2SV_blank>stat<S2SV_blank>:<S2SV_blank>%i\\n" , __FILE__ , state ) ; <S2SV_EndBug> if ( state != FS_OK ) log_mesg ( 0 , 1 , 1 , fs_opt . debug , "%s:<S2SV_blank>Filesystem<S2SV_blank>isn\'t<S2SV_blank>in<S2SV_blank>valid<S2SV_blank>state.<S2SV_blank>May<S2SV_blank>be<S2SV_blank>it<S2SV_blank>is<S2SV_blank>not<S2SV_blank>cleanly<S2SV_blank>unmounted.\\n\\n" , __FILE__ ) ; if ( extended ) log_mesg ( 3 , 0 , 0 , fs_opt . debug , "%s:<S2SV_blank>Extended<S2SV_blank>status:<S2SV_blank>%0xllx\\n" , extended , __FILE__ ) ; } fs -> format = reiser4_format_open ( fs ) ; }
<S2SV_ModStart> ) log_mesg ( 1 , 0 , 0 , fs_opt . debug , "%s:<S2SV_blank>REISER4:<S2SV_blank>FS<S2SV_blank>marked<S2SV_blank>consistent\\n" <S2SV_ModEnd> , __FILE__ ) <S2SV_ModStart> . debug , "%s:<S2SV_blank>REISER4:<S2SV_blank>stat<S2SV_blank>:<S2SV_blank>%i\\n" <S2SV_ModEnd> , __FILE__ ,
3,501
CWE-000 int main ( int argc , char * argv [ ] ) { int n_updates = ( argc >= 2 ) ? atoi ( argv [ 1 ] ) : 100000 ; int n_dims = ( argc >= 3 ) ? atoi ( argv [ 2 ] ) : 3 ; int n_Ts = ( argc >= 4 ) ? atoi ( argv [ 3 ] ) : 3 ; if ( n_Ts < 1 ) { n_Ts = 1 ; } double Thot = ( argc >= 5 ) ? atof ( argv [ 4 ] ) : 2.0 ; double Tratio = ( n_Ts > 1 ) ? pow ( Thot , 1.0 / ( n_Ts - 1 ) ) : 1.0 ; int n_peaks = ( argc >= 6 ) ? atoi ( argv [ 5 ] ) : 2 ; double peak_separation = ( argc >= 7 ) ? atof ( argv [ 6 ] ) : 1.0 ; double peak_width = ( argc >= 8 ) ? atof ( argv [ 7 ] ) : 0.2 ; double height_ratio = ( argc >= 9 ) ? atof ( argv [ 8 ] ) : 0.25 ; double shape_param = ( argc >= 10 ) ? atof ( argv [ 9 ] ) : 1.0 ; double prop_w = ( argc >= 11 ) ? atof ( argv [ 10 ] ) : 0.2 ; int seed = ( argc >= 12 ) ? atoi ( argv [ 11 ] ) : 12345 ; int n_thin = ( argc >= 13 ) ? atoi ( argv [ 12 ] ) : 128 ; char * output_order = ( char * ) malloc ( 32 * sizeof ( char ) ) ; sprintf ( output_order , "%s" , ( argc >= 14 ) ? argv [ 13 ] : "unknown" ) ; double kernel_scale = ( argc >= 15 ) ? atof ( argv [ 14 ] ) : 0.5 * peak_separation ; <S2SV_StartBug> Lsq = pow ( kernel_scale , 2.0 ) ; <S2SV_EndBug> double * inverse_Temperatures = ( double * ) malloc ( n_Ts * sizeof ( double ) ) ; inverse_Temperatures [ 0 ] = 1.0 ; for ( int i = 1 ; i < n_Ts ; i ++ ) { inverse_Temperatures [ i ] = inverse_Temperatures [ i - 1 ] / Tratio ; } printf ( "#<S2SV_blank>n<S2SV_blank>updates:<S2SV_blank>%5i,<S2SV_blank>n_dims:<S2SV_blank>%2i,<S2SV_blank>n_Ts:<S2SV_blank>%2i,<S2SV_blank>Thot:<S2SV_blank>%6.3f,<S2SV_blank>Tratio:<S2SV_blank>%6.3f<S2SV_blank>Kernel_scale:<S2SV_blank>%5.3f\\n" , n_updates , n_dims , n_Ts , Thot , Tratio , kernel_scale ) ; printf ( "#<S2SV_blank>n<S2SV_blank>peaks:<S2SV_blank>%3i,<S2SV_blank>peak<S2SV_blank>separation:<S2SV_blank>%5.3f,<S2SV_blank>peak<S2SV_blank>width:<S2SV_blank>%5.3f,<S2SV_blank>height<S2SV_blank>ratio:<S2SV_blank>%5.3f<S2SV_blank>shape<S2SV_blank>param:<S2SV_blank>%5.3f<S2SV_blank><S2SV_blank>\\n" , n_peaks , peak_separation , peak_width , height_ratio , shape_param ) ; printf ( "#<S2SV_blank>proposal<S2SV_blank>width:<S2SV_blank>%5.3f,<S2SV_blank>rng<S2SV_blank>seed:<S2SV_blank>%8i,<S2SV_blank><S2SV_blank>thin:<S2SV_blank>%5i,<S2SV_blank>output<S2SV_blank>order:<S2SV_blank>%12s<S2SV_blank>\\n" , prop_w , seed , n_thin , output_order ) ; <S2SV_StartBug> gsl_rng_env_setup ( ) ; <S2SV_EndBug> const gsl_rng_type * rng_type = gsl_rng_default ; g_rng = gsl_rng_alloc ( rng_type ) ; gsl_rng_set ( g_rng , seed ) ; peaks * the_peaks = set_up_peaks ( n_dims , n_peaks , 0.5 * peak_separation , peak_width , height_ratio , shape_param ) ; double init_width = 2.0 * peak_width ; chain_state * the_chain_state = set_up_chain_state ( n_dims , n_Ts , the_peaks , init_width , inverse_Temperatures ) ; for ( int i = 0 ; i <= n_updates ; i ++ ) { if ( 0 ) { for ( int j = 0 ; j < 2 * n_Ts ; j ++ ) { update_x ( the_peaks , the_chain_state , inverse_Temperatures [ the_chain_state -> w_ts [ j ] ] , prop_w , j ) ; } T_swap ( the_chain_state , inverse_Temperatures ) ; } else { for ( int j = 0 ; j < n_Ts ; j ++ ) { update_x_2b ( the_peaks , the_chain_state , inverse_Temperatures [ j ] , prop_w , j ) ; } <S2SV_StartBug> T_swap_2b ( the_chain_state , inverse_Temperatures ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> check_state_consistency ( the_chain_state ) ; if ( i % n_thin == 0 ) { <S2SV_StartBug> printf ( "%5i<S2SV_blank>" , i ) ; <S2SV_EndBug> if ( strcmp ( output_order , "T" ) == 0 ) { print_states_T_order ( the_chain_state ) ; } else if ( strcmp ( output_order , "walker" ) == 0 ) { print_states_walker_order ( the_chain_state ) ; } else { print_states_cold_only ( the_chain_state ) ; } printf ( "\\n" ) ; } } printf ( "#<S2SV_blank>" ) ; for ( int iw = 0 ; iw < 2 * n_Ts ; iw ++ ) { printf ( "<S2SV_blank><S2SV_blank>%2i<S2SV_blank>%5.3f" , iw , the_chain_state -> w_accepts [ iw ] / ( 1.0 * n_updates ) ) ; } printf ( "\\n" ) ; printf ( "#<S2SV_blank>X-move<S2SV_blank>acceptance<S2SV_blank>rates:\\n" ) ; for ( int it = 0 ; it < n_Ts ; it ++ ) { printf ( "#<S2SV_blank><S2SV_blank><S2SV_blank>T-level:<S2SV_blank>%1i<S2SV_blank>P_A:<S2SV_blank>L,<S2SV_blank>R,<S2SV_blank>avg:<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>\\n" , it , the_chain_state -> t_Laccepts [ it ] / ( 1.0 * n_updates ) , the_chain_state -> t_Raccepts [ it ] / ( 1.0 * n_updates ) , the_chain_state -> t_accepts [ it ] / ( 2.0 * n_updates ) ) ; } printf ( "#<S2SV_blank>T-swap<S2SV_blank>acceptance<S2SV_blank>rates:\\n" ) ; for ( int it = 0 ; it < n_Ts - 1 ; it ++ ) { <S2SV_StartBug> printf ( "#<S2SV_blank><S2SV_blank><S2SV_blank>T-levels:<S2SV_blank>%1i-%1i<S2SV_blank>P_A<S2SV_blank>L,R,avg:<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>\\n" , it , it + 1 , <S2SV_EndBug> the_chain_state -> t_Tswap_Laccepts [ it ] / ( 1.0 * n_updates ) , the_chain_state -> t_Tswap_Raccepts [ it ] / ( 1.0 * n_updates ) , the_chain_state -> t_Tswap_accepts [ it ] / ( 2.0 * n_updates ) ) ; } }
<S2SV_ModStart> , 2.0 ) ; two_body_interpolation_type = ( argc >= 16 ) ? atoi ( argv [ 15 ] ) : 0 <S2SV_ModStart> output_order ) ; printf ( "#<S2SV_blank>interpolation<S2SV_blank>type:<S2SV_blank>%s<S2SV_blank>\\n" , ( two_body_interpolation_type == 0 ) ? "geometric" : "linear" ) ; <S2SV_ModStart> ) ; } T_swap_2b_A <S2SV_ModEnd> ( the_chain_state , <S2SV_ModStart> inverse_Temperatures ) ; T_swap_2b_B ( the_chain_state , inverse_Temperatures ) ; } <S2SV_ModEnd> if ( i <S2SV_ModStart> 0 ) { check_state_consistency ( the_chain_state , inverse_Temperatures ) ; <S2SV_ModStart> { printf ( "#<S2SV_blank><S2SV_blank><S2SV_blank>T-levels:<S2SV_blank>%1i-%1i<S2SV_blank>P_A<S2SV_blank>L,R,both:<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>%5.3f<S2SV_blank>\\n" <S2SV_ModEnd> , it ,
3,502
CWE-000 void writeNID ( void ) { uint32_t value ; <S2SV_StartBug> if ( nid_port_out == LPUART1 ) { <S2SV_EndBug> if ( ( USART_ISR ( LPUART1 ) & USART_ISR_TCF ) != 0 ) { value = write_buffer . nid [ 0 ] . message & ( 0xFF << 24 ) ; value >>= 24 ; write_buffer . nid [ 0 ] . message <<= 8 ; write_buffer . write_count += 8 ; writeNIDByte ( value ) ; <S2SV_StartBug> } <S2SV_EndBug> } else { value = NEXT_BIT ( write_buffer . nid [ 0 ] ) ; write_buffer . nid [ 0 ] . message <<= 1 ; if ( value != 0 ) { gpio_set ( nid_port_out , nid_pin_out ) ; } else { gpio_clear ( nid_port_out , nid_pin_out ) ; } } }
<S2SV_ModStart> nid_port_out == LPUART1 <S2SV_ModEnd> ) { value <S2SV_ModStart> value ) ; <S2SV_ModEnd> } else {
3,503
CWE-000 void execute_JSR ( size_t operand ) { <S2SV_StartBug> PUSH ( ( uint8_t ) ( ( NES -> PC ) >> 8 ) ) ; <S2SV_EndBug> <S2SV_StartBug> PUSH ( ( uint8_t ) NES -> PC ) ; <S2SV_EndBug> }
<S2SV_ModStart> NES -> PC - 1 <S2SV_ModStart> NES -> PC - 1
3,504
CWE-000 static void print_help ( void ) { puts ( "Usage:<S2SV_blank>gem_wsim<S2SV_blank>[OPTIONS]\\n" "\\n" "Runs<S2SV_blank>a<S2SV_blank>simulated<S2SV_blank>workload<S2SV_blank>on<S2SV_blank>the<S2SV_blank>GPU.\\n" <S2SV_StartBug> "When<S2SV_blank>ran<S2SV_blank>without<S2SV_blank>arguments<S2SV_blank>performs<S2SV_blank>a<S2SV_blank>GPU<S2SV_blank>calibration<S2SV_blank>result<S2SV_blank>of<S2SV_blank>which<S2SV_blank>needs\\n" <S2SV_EndBug> "to<S2SV_blank>be<S2SV_blank>provided<S2SV_blank>when<S2SV_blank>running<S2SV_blank>the<S2SV_blank>simulation<S2SV_blank>in<S2SV_blank>subsequent<S2SV_blank>invocations.\\n" "\\n" "Options:\\n" "\t-h\t\tThis<S2SV_blank>text.\\n" "\t-q\t\tBe<S2SV_blank>quiet<S2SV_blank>-<S2SV_blank>do<S2SV_blank>not<S2SV_blank>output<S2SV_blank>anything<S2SV_blank>to<S2SV_blank>stdout.\\n" "\t-n<S2SV_blank><n>\t\tNop<S2SV_blank>calibration<S2SV_blank>value.\\n" "\t-t<S2SV_blank><n>\t\tNop<S2SV_blank>calibration<S2SV_blank>tolerance<S2SV_blank>percentage.\\n" "\t\t\tUse<S2SV_blank>when<S2SV_blank>there<S2SV_blank>is<S2SV_blank>a<S2SV_blank>difficulty<S2SV_blank>obtaining<S2SV_blank>calibration\\n" "\t\t\twith<S2SV_blank>the<S2SV_blank>default<S2SV_blank>settings.\\n" "\t-w<S2SV_blank><desc|path>\tFilename<S2SV_blank>or<S2SV_blank>a<S2SV_blank>workload<S2SV_blank>descriptor.\\n" "\t\t\tCan<S2SV_blank>be<S2SV_blank>given<S2SV_blank>multiple<S2SV_blank>times.\\n" "\t-W<S2SV_blank><desc|path>\tFilename<S2SV_blank>or<S2SV_blank>a<S2SV_blank>master<S2SV_blank>workload<S2SV_blank>descriptor.\\n" "\t\t\tOnly<S2SV_blank>one<S2SV_blank>master<S2SV_blank>workload<S2SV_blank>can<S2SV_blank>be<S2SV_blank>optinally<S2SV_blank>specified\\n" "\t\t\tin<S2SV_blank>which<S2SV_blank>case<S2SV_blank>all<S2SV_blank>other<S2SV_blank>workloads<S2SV_blank>become<S2SV_blank>background\\n" "\t\t\tones<S2SV_blank>and<S2SV_blank>run<S2SV_blank>as<S2SV_blank>long<S2SV_blank>as<S2SV_blank>the<S2SV_blank>master.\\n" "\t-r<S2SV_blank><n>\t\tHow<S2SV_blank>many<S2SV_blank>times<S2SV_blank>to<S2SV_blank>emit<S2SV_blank>the<S2SV_blank>workload.\\n" "\t-c<S2SV_blank><n>\t\tFork<S2SV_blank>N<S2SV_blank>clients<S2SV_blank>emitting<S2SV_blank>the<S2SV_blank>workload<S2SV_blank>simultaneously.\\n" "\t-x\t\tSwap<S2SV_blank>VCS1<S2SV_blank>and<S2SV_blank>VCS2<S2SV_blank>engines<S2SV_blank>in<S2SV_blank>every<S2SV_blank>other<S2SV_blank>client.\\n" "\t-b<S2SV_blank><n>\t\tLoad<S2SV_blank>balancing<S2SV_blank>to<S2SV_blank>use.<S2SV_blank>(0:<S2SV_blank>rr,<S2SV_blank>1:<S2SV_blank>qd,<S2SV_blank>2:<S2SV_blank>rt,<S2SV_blank>3:<S2SV_blank>rtr)\\n" "\t\t\tBalancers<S2SV_blank>can<S2SV_blank>be<S2SV_blank>specified<S2SV_blank>either<S2SV_blank>as<S2SV_blank>names<S2SV_blank>or<S2SV_blank>as<S2SV_blank>their\\n" "\t\t\tid<S2SV_blank>numbers<S2SV_blank>as<S2SV_blank>listed<S2SV_blank>above.\\n" "\t-2\t\tRemap<S2SV_blank>VCS2<S2SV_blank>to<S2SV_blank>BCS.\\n" "\t-R\t\tRound-robin<S2SV_blank>initial<S2SV_blank>VCS<S2SV_blank>assignment<S2SV_blank>per<S2SV_blank>client.\\n" "\t-S\t\tSynchronize<S2SV_blank>the<S2SV_blank>sequence<S2SV_blank>of<S2SV_blank>random<S2SV_blank>batch<S2SV_blank>durations\\n" "\t\t\tbetween<S2SV_blank>clients.\\n" ) ; }
<S2SV_ModStart> "Usage:<S2SV_blank>gem_wsim<S2SV_blank>[OPTIONS]\\n" "\\n" "Runs<S2SV_blank>a<S2SV_blank>simulated<S2SV_blank>workload<S2SV_blank>on<S2SV_blank>the<S2SV_blank>GPU.\\n" "When<S2SV_blank>ran<S2SV_blank>without<S2SV_blank>arguments<S2SV_blank>performs<S2SV_blank>a<S2SV_blank>GPU<S2SV_blank>calibration<S2SV_blank>result<S2SV_blank>of<S2SV_blank>which<S2SV_blank>needs<S2SV_blank>to\\n" "be<S2SV_blank>provided<S2SV_blank>when<S2SV_blank>running<S2SV_blank>the<S2SV_blank>simulation<S2SV_blank>in<S2SV_blank>subsequent<S2SV_blank>invocations.\\n" "\\n" "Options:\\n" "<S2SV_blank><S2SV_blank>-h<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>This<S2SV_blank>text.\\n" "<S2SV_blank><S2SV_blank>-q<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Be<S2SV_blank>quiet<S2SV_blank>-<S2SV_blank>do<S2SV_blank>not<S2SV_blank>output<S2SV_blank>anything<S2SV_blank>to<S2SV_blank>stdout.\\n" "<S2SV_blank><S2SV_blank>-n<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Nop<S2SV_blank>calibration<S2SV_blank>value.\\n" "<S2SV_blank><S2SV_blank>-t<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Nop<S2SV_blank>calibration<S2SV_blank>tolerance<S2SV_blank>percentage.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Use<S2SV_blank>when<S2SV_blank>there<S2SV_blank>is<S2SV_blank>a<S2SV_blank>difficulty<S2SV_blank>obtaining<S2SV_blank>calibration<S2SV_blank>with<S2SV_blank>the\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>default<S2SV_blank>settings.\\n" "<S2SV_blank><S2SV_blank>-w<S2SV_blank><desc|path><S2SV_blank><S2SV_blank>Filename<S2SV_blank>or<S2SV_blank>a<S2SV_blank>workload<S2SV_blank>descriptor.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Can<S2SV_blank>be<S2SV_blank>given<S2SV_blank>multiple<S2SV_blank>times.\\n" "<S2SV_blank><S2SV_blank>-W<S2SV_blank><desc|path><S2SV_blank><S2SV_blank>Filename<S2SV_blank>or<S2SV_blank>a<S2SV_blank>master<S2SV_blank>workload<S2SV_blank>descriptor.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Only<S2SV_blank>one<S2SV_blank>master<S2SV_blank>workload<S2SV_blank>can<S2SV_blank>be<S2SV_blank>optinally<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>which\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>case<S2SV_blank>all<S2SV_blank>other<S2SV_blank>workloads<S2SV_blank>become<S2SV_blank>background<S2SV_blank>ones<S2SV_blank>and<S2SV_blank>run<S2SV_blank>as\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>long<S2SV_blank>as<S2SV_blank>the<S2SV_blank>master.\\n" "<S2SV_blank><S2SV_blank>-r<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>How<S2SV_blank>many<S2SV_blank>times<S2SV_blank>to<S2SV_blank>emit<S2SV_blank>the<S2SV_blank>workload.\\n" "<S2SV_blank><S2SV_blank>-c<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Fork<S2SV_blank>N<S2SV_blank>clients<S2SV_blank>emitting<S2SV_blank>the<S2SV_blank>workload<S2SV_blank>simultaneously.\\n" "<S2SV_blank><S2SV_blank>-x<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Swap<S2SV_blank>VCS1<S2SV_blank>and<S2SV_blank>VCS2<S2SV_blank>engines<S2SV_blank>in<S2SV_blank>every<S2SV_blank>other<S2SV_blank>client.\\n" "<S2SV_blank><S2SV_blank>-b<S2SV_blank><n><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Load<S2SV_blank>balancing<S2SV_blank>to<S2SV_blank>use.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Available<S2SV_blank>load<S2SV_blank>balancers<S2SV_blank>are:\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>0/<S2SV_blank><S2SV_blank><S2SV_blank>rr:<S2SV_blank>Simple<S2SV_blank>round-robin.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>1/<S2SV_blank><S2SV_blank><S2SV_blank>qd:<S2SV_blank>Queue<S2SV_blank>depth<S2SV_blank>estimation.<S2SV_blank>Round-robin<S2SV_blank>on<S2SV_blank>equal\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>queue<S2SV_blank>depth.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>2/<S2SV_blank><S2SV_blank><S2SV_blank>rt:<S2SV_blank>Like<S2SV_blank>qd<S2SV_blank>but<S2SV_blank>with<S2SV_blank>added<S2SV_blank>last<S2SV_blank>run-time<S2SV_blank>estimation.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>3/<S2SV_blank><S2SV_blank>rtr:<S2SV_blank>Like<S2SV_blank>rt<S2SV_blank>but<S2SV_blank>with<S2SV_blank>random<S2SV_blank>selection<S2SV_blank>on<S2SV_blank>equal<S2SV_blank>queue\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>depth.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>4/rtavg:<S2SV_blank>Improved<S2SV_blank>version<S2SV_blank>of<S2SV_blank>rt<S2SV_blank>tracking<S2SV_blank>average<S2SV_blank>latency\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>per<S2SV_blank>engine.\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Balancers<S2SV_blank>can<S2SV_blank>be<S2SV_blank>specified<S2SV_blank>either<S2SV_blank>as<S2SV_blank>names<S2SV_blank>or<S2SV_blank>as<S2SV_blank>their<S2SV_blank>id\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>number<S2SV_blank>as<S2SV_blank>listed<S2SV_blank>above.\\n" "<S2SV_blank><S2SV_blank>-2<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Remap<S2SV_blank>VCS2<S2SV_blank>to<S2SV_blank>BCS.\\n" "<S2SV_blank><S2SV_blank>-R<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Round-robin<S2SV_blank>initial<S2SV_blank>VCS<S2SV_blank>assignment<S2SV_blank>per<S2SV_blank>client.\\n" "<S2SV_blank><S2SV_blank>-S<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Synchronize<S2SV_blank>the<S2SV_blank>sequence<S2SV_blank>of<S2SV_blank>random<S2SV_blank>batch<S2SV_blank>durations<S2SV_blank>between\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>clients.\\n" <S2SV_ModEnd> ) ; }
3,505
CWE-000 void detector_free ( detector_t * d ) <S2SV_StartBug> { <S2SV_EndBug> free ( d -> name ) ; free ( d -> author ) ; free ( d -> version ) ; array_free ( d -> rules , detector_rule_finalize ) ; free ( d -> buf ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> d ) { if ( d == NULL ) { return ; } <S2SV_ModStart> buf ) ; free ( d ) ;
3,506
CWE-000 int main ( ) { player * emma ; <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < 5 ; i ++ ) { <S2SV_StartBug> strcpy ( emma -> hand [ i ] -> type , "heart" ) ; <S2SV_EndBug> <S2SV_StartBug> emma -> hand [ i ] -> value = i ; <S2SV_EndBug> } <S2SV_StartBug> for ( i = 5 ; i ++ ; i < 17 ) { <S2SV_EndBug> emma -> hand [ i ] = NULL ; } run_human_turn ( emma , 1 ) ; return 0 ; }
<S2SV_ModStart> ; int i ; printf ( "GETTING<S2SV_blank>THIS<S2SV_blank>FAR\\n" ) <S2SV_ModStart> ++ ) { printf ( "GETTING<S2SV_blank>THIS<S2SV_blank>FAR\\n" ) ; printf ( "What<S2SV_blank>type?:<S2SV_blank>%s\\n" , emma -> hand [ i ] . type ) ; <S2SV_ModStart> [ i ] . <S2SV_ModEnd> type , "heart" <S2SV_ModStart> type , "heart" ) ; printf ( "GETTING<S2SV_blank>THIS<S2SV_blank>FAR\\n" <S2SV_ModStart> [ i ] . <S2SV_ModEnd> value = i <S2SV_ModStart> i ; } printf ( "GETTING<S2SV_blank>THIS<S2SV_blank>FAR\\n" ) ; <S2SV_ModEnd> run_human_turn ( emma
3,507
CWE-000 static void _releaseWindow ( WndInfo * wi ) { if ( wi == NULL ) return ; if ( wi -> menuPath == NULL ) { _error ( "try<S2SV_blank>to<S2SV_blank>release<S2SV_blank>empty<S2SV_blank>WndInfo" ) ; return ; } free ( wi -> menuPath ) ; wi -> menuPath = NULL ; if ( wi -> menuroot != NULL ) { _releaseMenuItem ( wi -> menuroot ) ; wi -> menuroot = NULL ; } if ( wi -> server != NULL ) { g_object_unref ( wi -> server ) ; wi -> server = NULL ; } if ( wi -> registrar != NULL ) { <S2SV_StartBug> g_object_unref ( wi -> registrar ) ; <S2SV_EndBug> wi -> registrar = NULL ; } <S2SV_StartBug> free ( wi ) ; <S2SV_EndBug> }
<S2SV_ModStart> NULL ) { _unregisterWindow ( wi -> xid , wi -> registrar ) ; if ( wi -> linkedXids != NULL ) { for ( GList * l = wi -> linkedXids ; l != NULL ; l = l -> next ) _unregisterWindow ( l -> data , wi -> registrar ) ; } <S2SV_ModStart> NULL ; } if ( wi -> linkedXids != NULL ) { g_list_free ( wi -> linkedXids ) ; wi -> linkedXids = NULL ; }
3,508
CWE-000 int main ( ) { int act , vertex1 , vertex2 , paths ; Graph * g ; <S2SV_StartBug> int num = check_vertex ( ) ; <S2SV_EndBug> if ( num == - 1 ) { return 0 ; } <S2SV_StartBug> g = graph_create ( num ) ; <S2SV_EndBug> if ( g == NULL ) { graph_free ( g ) ; return 0 ; } if ( input_validation ( g ) == - 1 ) { free ( g ) ; return 0 ; } Results * res = results_create ( g ) ; printf ( "Меню\\n" ) ; printf ( "1)<S2SV_blank>Найти<S2SV_blank>минимальное<S2SV_blank>растояние<S2SV_blank>между<S2SV_blank>городами\\n" ) ; printf ( "2)<S2SV_blank>Найти<S2SV_blank>максимальное<S2SV_blank>растояние<S2SV_blank>между<S2SV_blank>городами\\n" ) ; printf ( "3)<S2SV_blank>Найти<S2SV_blank>колличество<S2SV_blank>различных<S2SV_blank>путей<S2SV_blank>между<S2SV_blank>городами\\n" ) ; printf ( "Выберите<S2SV_blank>дейсвие:<S2SV_blank>" ) ; scanf ( "%d" , & act ) ; printf ( "Введите<S2SV_blank>города<S2SV_blank>между<S2SV_blank>которыми<S2SV_blank>будем<S2SV_blank>совершать<S2SV_blank>действие.\\n" ) ; printf ( "Vertex<S2SV_blank>1:<S2SV_blank>" ) ; scanf ( "%d" , & vertex1 ) ; printf ( "Vertex<S2SV_blank>2:<S2SV_blank>" ) ; scanf ( "%d" , & vertex2 ) ; switch ( act ) { case 1 : printf ( "Минимальное<S2SV_blank>расстояние<S2SV_blank>между<S2SV_blank>%d<S2SV_blank>и<S2SV_blank>%d:<S2SV_blank>%d\\n" , vertex1 , vertex2 , min_distance ( g , vertex1 , vertex2 , res ) ) ; printf ( "Paths:<S2SV_blank>%d\\n" , res -> count ) ; output_path ( g , res , act ) ; break ; case 2 : printf ( "Максимальное<S2SV_blank>расстояние<S2SV_blank>между<S2SV_blank>%d<S2SV_blank>и<S2SV_blank>%d:<S2SV_blank>%d\\n" , vertex1 , vertex2 , max_distance ( g , vertex1 , vertex2 , res ) ) ; printf ( "Paths:<S2SV_blank>%d\\n" , res -> count ) ; output_path ( g , res , act ) ; break ; case 3 : paths = all_paths ( vertex1 , vertex2 , g , res ) ; printf ( "Кол-во<S2SV_blank>путей<S2SV_blank>из<S2SV_blank>%d<S2SV_blank>в<S2SV_blank>%d:<S2SV_blank>%d\\n" , vertex1 , vertex2 , paths ) ; output_path ( g , res , act ) ; break ; default : break ; } graph_free ( g ) ; results_free ( res ) ; return 0 ; }
<S2SV_ModStart> * g ; if ( ( g = input_validation ( ) ) == NULL <S2SV_ModEnd> ) { return <S2SV_ModStart> 0 ; } for ( int i = 0 ; i < g -> sity ; i ++ ) { printf ( "%d<S2SV_blank>" , g -> vertex [ i ] ) ; } printf ( "\\n" ) ; <S2SV_ModEnd> Results * res
3,509
CWE-000 static void multi_ctrl_scroll_work_fn ( struct work_struct * ws ) { struct multi_ctrl_data * ctrl_data ; int bit = 0 ; static u64 update_bits = ~ 0 ; <S2SV_StartBug> if ( ! multi_ctrl_scroll_info -> data_valid ) { <S2SV_EndBug> <S2SV_StartBug> pr_err ( "%s,<S2SV_blank>scroll<S2SV_blank>data<S2SV_blank>is<S2SV_blank>invalid,<S2SV_blank>exit\\n" , __func__ ) ; <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> } down_read ( & multi_leds_list_lock ) ; if ( unlikely ( update_bits > ( bits ( led_num ) - 1 ) ) ) { pr_warn ( "%s,update_bits<S2SV_blank>is<S2SV_blank>exceed<S2SV_blank>the<S2SV_blank>max<S2SV_blank>led<S2SV_blank>numbers!\\n" , __func__ ) ; update_bits = bits ( led_num ) - 1 ; } if ( leds_pre_mode != LEDS_MODE_MULTI_SCROLL ) { update_bits = bits ( led_num ) - 1 ; leds_pre_mode = LEDS_MODE_MULTI_SCROLL ; } list_for_each_entry ( ctrl_data , & multi_leds_list , node ) { struct led_classdev * led_cdev = ctrl_data -> led_cdev ; if ( bit >= led_num ) { dev_err ( led_cdev -> dev , "exceed<S2SV_blank>the<S2SV_blank>max<S2SV_blank>number<S2SV_blank>of<S2SV_blank>muti_leds_list\\n" ) ; break ; } cancel_delayed_work_sync ( & ctrl_data -> delay_trig_work ) ; if ( update_bits & bits ( bit ) ) { if ( leds_scroll_data . init_bitmap & bits ( bit ) ) { led_trigger_set_by_name ( led_cdev , mult_ctrl_trigger [ TRIG_DEF_ON ] ) ; } else { led_trigger_remove ( led_cdev ) ; } } bit ++ ; } update_bits = leds_scroll_data . init_bitmap ; leds_scroll_data . init_bitmap = multi_ctrl_calc_next_scroll_bitmap ( update_bits ) ; update_bits ^= leds_scroll_data . init_bitmap ; up_read ( & multi_leds_list_lock ) ; schedule_delayed_work ( & multi_ctrl_scroll_info -> scroll_work , msecs_to_jiffies ( leds_scroll_data . shift_delay_ms ) ) ; }
<S2SV_ModStart> ~ 0 ; down_read ( & multi_leds_list_lock ) ; <S2SV_ModStart> data_valid ) { update_bits = bits ( led_num ) - 1 ; multi_ctrl_scroll_info -> data_valid = true ; pr_info ( "%s,<S2SV_blank>new<S2SV_blank>scroll<S2SV_blank>work<S2SV_blank>is<S2SV_blank>queued\\n" <S2SV_ModEnd> , __func__ ) <S2SV_ModStart> __func__ ) ; } <S2SV_ModEnd> if ( unlikely
3,510
CWE-000 void sched_halt ( void ) { int i ; for ( i = 0 ; i < NENV ; i ++ ) { if ( ( envs [ i ] . env_status == ENV_RUNNABLE || envs [ i ] . env_status == ENV_RUNNING || envs [ i ] . env_status == ENV_DYING ) ) break ; } if ( i == NENV ) { cprintf ( "No<S2SV_blank>runnable<S2SV_blank>environments<S2SV_blank>in<S2SV_blank>the<S2SV_blank>system!\\n" ) ; while ( 1 ) monitor ( NULL ) ; } curenv = NULL ; lcr3 ( PADDR ( kern_pgdir ) ) ; xchg ( & thiscpu -> cpu_status , CPU_HALTED ) ; unlock_kernel ( ) ; asm volatile ( "movl<S2SV_blank>$0,<S2SV_blank>%%ebp\\n" "movl<S2SV_blank>%0,<S2SV_blank>%%esp\\n" "pushl<S2SV_blank>$0\\n" "pushl<S2SV_blank>$0\\n" "sti\\n" <S2SV_StartBug> "hlt\\n" <S2SV_EndBug> : : "a" ( thiscpu -> cpu_ts . ts_esp0 ) ) ; }
<S2SV_ModStart> "pushl<S2SV_blank>$0\\n" "pushl<S2SV_blank>$0\\n" "sti\\n" "1:\\n" "hlt\\n" "jmp<S2SV_blank>1b\\n" <S2SV_ModEnd> : : "a"
3,511
CWE-000 void hbridge2stop ( ) { <S2SV_StartBug> gpio_toogle_off ( HBRIDGE2_EN_PORT , HBRIDGE2_EN_PIN ) ; <S2SV_EndBug> <S2SV_StartBug> gpio_toogle_off ( HBRIDGE2_DIR_PORT , HBRIDGE2_DIR_PIN ) ; <S2SV_EndBug> stop_pwm_channel ( & timer , HBRIDGE2_PWM_CHANNEL ) ; }
<S2SV_ModStart> ( ) { gpio_toggle_off <S2SV_ModEnd> ( HBRIDGE2_EN_PORT , <S2SV_ModStart> HBRIDGE2_EN_PIN ) ; gpio_toggle_off <S2SV_ModEnd> ( HBRIDGE2_DIR_PORT ,
3,512
CWE-000 int main ( void ) { <S2SV_StartBug> cpl_test_init ( PACKAGE_BUGREPORT , CPL_MSG_WARNING ) ; <S2SV_EndBug> test_cr2res_image_insert_rect ( ) ; return cpl_test_end ( 0 ) ; }
<S2SV_ModStart> ( PACKAGE_BUGREPORT , CPL_MSG_DEBUG <S2SV_ModEnd> ) ; test_cr2res_image_insert_rect
3,513
CWE-000 unsigned int __kfifo_dma_out_prepare_r ( struct __kfifo * fifo , struct scatterlist * sgl , int nents , unsigned int len , size_t recsize ) { <S2SV_StartBug> if ( ! nents ) <S2SV_EndBug> BUG ( ) ; len = __kfifo_max_r ( len , recsize ) ; if ( len + recsize > fifo -> in - fifo -> out ) return 0 ; return setup_sgl ( fifo , sgl , nents , len , fifo -> out + recsize ) ; }
<S2SV_ModStart> recsize ) { BUG_ON <S2SV_ModEnd> ( ! nents <S2SV_ModStart> ( ! nents <S2SV_ModEnd> ) ; len
3,514
CWE-000 <S2SV_StartBug> int UNIFYCR_WRAP ( munmap ) ( void * addr , size_t length ) <S2SV_EndBug> { fprintf ( stderr , "Function<S2SV_blank>not<S2SV_blank>yet<S2SV_blank>supported<S2SV_blank>@<S2SV_blank>%s:%d\\n" , __FILE__ , __LINE__ ) ; errno = ENOSYS ; return ENODEV ; }
<S2SV_ModStart> int UNIFYCR_WRAP ( flock ) ( int fd , int operation ) { int ret ; if ( unifycr_intercept_fd ( & fd ) ) { return 0 ; } else { MAP_OR_FAIL ( flock ) ; ret = UNIFYCR_REAL ( flock ) ( fd , operation ) ; return ret ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
3,515
CWE-000 static pixman_image_t * _pixman_image_for_surface ( cairo_image_surface_t * dst , const cairo_surface_pattern_t * pattern , cairo_bool_t is_mask , const cairo_rectangle_int_t * extents , const cairo_rectangle_int_t * sample , int * ix , int * iy ) { cairo_extend_t extend = pattern -> base . extend ; pixman_image_t * pixman_image ; TRACE ( ( stderr , "%s\\n" , __FUNCTION__ ) ) ; * ix = * iy = 0 ; pixman_image = NULL ; if ( pattern -> surface -> type == CAIRO_SURFACE_TYPE_RECORDING ) return _pixman_image_for_recording ( dst , pattern , is_mask , extents , sample , ix , iy ) ; if ( pattern -> surface -> type == CAIRO_SURFACE_TYPE_IMAGE && ( ! is_mask || ! pattern -> base . has_component_alpha || ( pattern -> surface -> content & CAIRO_CONTENT_COLOR ) == 0 ) ) { cairo_surface_t * defer_free = NULL ; cairo_image_surface_t * source = ( cairo_image_surface_t * ) pattern -> surface ; cairo_surface_type_t type ; <S2SV_StartBug> if ( _cairo_surface_is_snapshot ( & source -> base ) ) { <S2SV_EndBug> defer_free = _cairo_surface_snapshot_get_target ( & source -> base ) ; source = ( cairo_image_surface_t * ) defer_free ; } type = source -> base . backend -> type ; if ( type == CAIRO_SURFACE_TYPE_IMAGE ) { if ( extend != CAIRO_EXTEND_NONE && sample -> x >= 0 && sample -> y >= 0 && sample -> x + sample -> width <= source -> width && sample -> y + sample -> height <= source -> height ) { extend = CAIRO_EXTEND_NONE ; } if ( sample -> width == 1 && sample -> height == 1 ) { if ( sample -> x < 0 || sample -> y < 0 || sample -> x >= source -> width || sample -> y >= source -> height ) { if ( extend == CAIRO_EXTEND_NONE ) { cairo_surface_destroy ( defer_free ) ; return _pixman_transparent_image ( ) ; } } else { pixman_image = _pixel_to_solid ( source , sample -> x , sample -> y ) ; if ( pixman_image ) { cairo_surface_destroy ( defer_free ) ; return pixman_image ; } } } # if PIXMAN_HAS_ATOMIC_OPS if ( extend == CAIRO_EXTEND_NONE && _cairo_matrix_is_pixman_translation ( & pattern -> base . matrix , pattern -> base . filter , ix , iy ) ) { cairo_surface_destroy ( defer_free ) ; return pixman_image_ref ( source -> pixman_image ) ; } # endif pixman_image = pixman_image_create_bits ( source -> pixman_format , source -> width , source -> height , ( uint32_t * ) source -> data , source -> stride ) ; if ( unlikely ( pixman_image == NULL ) ) { cairo_surface_destroy ( defer_free ) ; return NULL ; } if ( defer_free ) { pixman_image_set_destroy_function ( pixman_image , _defer_free_cleanup , defer_free ) ; } } else if ( type == CAIRO_SURFACE_TYPE_SUBSURFACE ) { cairo_surface_subsurface_t * sub ; cairo_bool_t is_contained = FALSE ; sub = ( cairo_surface_subsurface_t * ) source ; source = ( cairo_image_surface_t * ) sub -> target ; if ( sample -> x >= 0 && sample -> y >= 0 && sample -> x + sample -> width <= sub -> extents . width && sample -> y + sample -> height <= sub -> extents . height ) { is_contained = TRUE ; } if ( sample -> width == 1 && sample -> height == 1 ) { if ( is_contained ) { pixman_image = _pixel_to_solid ( source , sub -> extents . x + sample -> x , sub -> extents . y + sample -> y ) ; if ( pixman_image ) return pixman_image ; } else { if ( extend == CAIRO_EXTEND_NONE ) return _pixman_transparent_image ( ) ; } } # if PIXMAN_HAS_ATOMIC_OPS * ix = sub -> extents . x ; * iy = sub -> extents . y ; if ( is_contained && _cairo_matrix_is_pixman_translation ( & pattern -> base . matrix , pattern -> base . filter , ix , iy ) ) { return pixman_image_ref ( source -> pixman_image ) ; } # endif if ( PIXMAN_FORMAT_BPP ( source -> pixman_format ) >= 8 ) { if ( is_contained ) { void * data = source -> data + sub -> extents . x * PIXMAN_FORMAT_BPP ( source -> pixman_format ) / 8 + sub -> extents . y * source -> stride ; pixman_image = pixman_image_create_bits ( source -> pixman_format , sub -> extents . width , sub -> extents . height , data , source -> stride ) ; if ( unlikely ( pixman_image == NULL ) ) return NULL ; } else { } } } } if ( pixman_image == NULL ) { struct acquire_source_cleanup * cleanup ; cairo_image_surface_t * image ; void * extra ; cairo_status_t status ; status = _cairo_surface_acquire_source_image ( pattern -> surface , & image , & extra ) ; if ( unlikely ( status ) ) return NULL ; pixman_image = pixman_image_create_bits ( image -> pixman_format , image -> width , image -> height , ( uint32_t * ) image -> data , image -> stride ) ; if ( unlikely ( pixman_image == NULL ) ) { _cairo_surface_release_source_image ( pattern -> surface , image , extra ) ; return NULL ; } cleanup = malloc ( sizeof ( * cleanup ) ) ; if ( unlikely ( cleanup == NULL ) ) { _cairo_surface_release_source_image ( pattern -> surface , image , extra ) ; pixman_image_unref ( pixman_image ) ; return NULL ; } cleanup -> surface = pattern -> surface ; cleanup -> image = image ; cleanup -> image_extra = extra ; pixman_image_set_destroy_function ( pixman_image , _acquire_source_cleanup , cleanup ) ; } if ( ! _pixman_image_set_properties ( pixman_image , & pattern -> base , extents , ix , iy ) ) { pixman_image_unref ( pixman_image ) ; pixman_image = NULL ; } return pixman_image ; }
<S2SV_ModStart> cairo_surface_type_t type ; <S2SV_ModEnd> type = source
3,516
CWE-000 void at_input ( register uint8_t c ) { switch ( c ) { case '\\r' : <S2SV_StartBug> putchar ( '\\n' ) ; <S2SV_EndBug> at_cmd [ at_cmd_len ] = 0 ; at_cmd_ready = true ; break ; case '\\b' : case '\\x7f' : if ( at_cmd_len > 0 ) { <S2SV_StartBug> putchar ( '\\b' ) ; <S2SV_EndBug> <S2SV_StartBug> putchar ( '<S2SV_blank>' ) ; <S2SV_EndBug> <S2SV_StartBug> putchar ( '\\b' ) ; <S2SV_EndBug> at_cmd_len -- ; } break ; default : if ( at_cmd_len < AT_CMD_MAXLEN ) { if ( isprint ( c ) ) { c = toupper ( c ) ; at_cmd [ at_cmd_len ++ ] = c ; <S2SV_StartBug> putchar ( c ) ; <S2SV_EndBug> } break ; } at_mode_active = 0 ; at_cmd_len = 0 ; break ; } }
<S2SV_ModStart> case '\\r' : putchar_r <S2SV_ModEnd> ( '\\n' ) <S2SV_ModStart> 0 ) { putchar_r <S2SV_ModEnd> ( '\\b' ) <S2SV_ModStart> '\\b' ) ; putchar_r <S2SV_ModEnd> ( '<S2SV_blank>' ) <S2SV_ModStart> '<S2SV_blank>' ) ; putchar_r <S2SV_ModEnd> ( '\\b' ) <S2SV_ModStart> = c ; putchar_r <S2SV_ModEnd> ( c )
3,517
CWE-000 void pkey_mm_init ( struct mm_struct * mm ) { if ( static_branch_likely ( & pkey_disabled ) ) return ; mm_pkey_allocation_map ( mm ) = initial_allocation_mask ; <S2SV_StartBug> mm -> context . execute_only_pkey = - 1 ; <S2SV_EndBug> }
<S2SV_ModStart> . execute_only_pkey = EXECUTE_ONLY_KEY <S2SV_ModEnd> ; } <S2SV_null>
3,518
CWE-000 struct timeval thread_timer_remain ( struct thread * thread ) { <S2SV_StartBug> quagga_get_relative ( NULL ) ; <S2SV_EndBug> return timeval_subtract ( thread -> u . sands , relative_time ) ; }
<S2SV_ModStart> thread ) { relative_time = frr_monotonic <S2SV_ModEnd> ( NULL )
3,519
CWE-000 int vlc_threadvar_set ( vlc_threadvar_t key , void * value ) { int saved = GetLastError ( ) ; <S2SV_StartBug> int val = TlsSetValue ( key -> id , value ) ? ENOMEM : 0 ; <S2SV_EndBug> if ( val == 0 ) SetLastError ( saved ) ; <S2SV_StartBug> return val ; <S2SV_EndBug> }
<S2SV_ModStart> ( ) ; if ( ! <S2SV_ModEnd> TlsSetValue ( key <S2SV_ModStart> , value ) ) return ENOMEM ; <S2SV_ModEnd> SetLastError ( saved <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } <S2SV_null>
3,520
CWE-000 static t_roomlist * ft_select_next ( t_instlist * cont , t_roomlist * curr_room ) { t_roomlist * next_room ; int a ; <S2SV_StartBug> int i ; <S2SV_EndBug> int weight ; t_roomlist * this_road ; <S2SV_StartBug> weight = 2147483647 ; <S2SV_EndBug> i = 0 ; a = 0 ; next_room = NULL ; if ( curr_room -> index != cont -> start -> index ) { while ( cont -> matrix [ curr_room -> index ] [ a ] ) { if ( cont -> matrix [ curr_room -> index ] [ a ] == '1' ) return ( ft_frby_id ( cont -> rooms [ 0 ] , 4 , a ) ) ; a ++ ; } } else { while ( cont -> matrix [ cont -> start -> index ] [ a ] ) { if ( cont -> matrix [ cont -> start -> index ] [ a ] == '1' ) { this_road = ft_frby_id ( cont -> rooms [ 0 ] , 4 , a ) ; if ( this_road -> nc + this_road -> imp < weight ) { next_room = this_road ; weight = this_road -> nc + this_road -> imp ; } } a ++ ; } } return ( next_room ) ; }
<S2SV_ModStart> a ; int <S2SV_ModEnd> weight ; t_roomlist <S2SV_ModStart> weight = 2147483647 <S2SV_ModEnd> ; a =
3,521
CWE-000 void history_push ( char * * args , pid_t pid , uid_t uid ) { # ifdef DEBUG printf ( "____________history_push____________\\n" ) ; <S2SV_StartBug> # endif <S2SV_EndBug> command_hist [ history_current_push_pointer ] . _command = command_to_string ( args ) ; command_hist [ history_current_push_pointer ] . _timeinfo = localtime ( & current_time ) ; command_hist [ history_current_push_pointer ] . _process_info = pid ; command_hist [ history_current_push_pointer ] . _user_info = uid ; total_executed ++ ; history_current_push_pointer = ( ( history_current_push_pointer + 1 ) % HISTORY_MAX ) ; }
<S2SV_ModStart> ; # endif time_t current_time = time ( NULL ) ;
3,522
CWE-000 int af_alg_get_rsgl ( struct sock * sk , struct msghdr * msg , int flags , struct af_alg_async_req * areq , size_t maxsize , size_t * outlen ) { struct alg_sock * ask = alg_sk ( sk ) ; struct af_alg_ctx * ctx = ask -> private ; size_t len = 0 ; while ( maxsize > len && msg_data_left ( msg ) ) { struct af_alg_rsgl * rsgl ; size_t seglen ; int err ; if ( ! af_alg_readable ( sk ) ) break ; <S2SV_StartBug> if ( ! ctx -> used ) { <S2SV_EndBug> err = af_alg_wait_for_data ( sk , flags ) ; if ( err ) return err ; } seglen = min_t ( size_t , ( maxsize - len ) , msg_data_left ( msg ) ) ; if ( list_empty ( & areq -> rsgl_list ) ) { rsgl = & areq -> first_rsgl ; } else { rsgl = sock_kmalloc ( sk , sizeof ( * rsgl ) , GFP_KERNEL ) ; if ( unlikely ( ! rsgl ) ) return - ENOMEM ; } rsgl -> sgl . npages = 0 ; list_add_tail ( & rsgl -> list , & areq -> rsgl_list ) ; err = af_alg_make_sg ( & rsgl -> sgl , & msg -> msg_iter , seglen ) ; if ( err < 0 ) return err ; if ( areq -> last_rsgl ) af_alg_link_sg ( & areq -> last_rsgl -> sgl , & rsgl -> sgl ) ; areq -> last_rsgl = rsgl ; len += err ; ctx -> rcvused += err ; rsgl -> sg_num_bytes = err ; iov_iter_advance ( & msg -> msg_iter , err ) ; } * outlen = len ; return 0 ; }
<S2SV_ModStart> ) break ; <S2SV_ModEnd> seglen = min_t
3,523
CWE-000 static gboolean applications_menu_plugin_menu ( GtkWidget * button , GdkEventButton * event , ApplicationsMenuPlugin * plugin ) { panel_return_val_if_fail ( XFCE_IS_APPLICATIONS_MENU_PLUGIN ( plugin ) , FALSE ) ; panel_return_val_if_fail ( button == NULL || plugin -> button == button , FALSE ) ; if ( event != NULL && ! ( event -> button == 1 && event -> type == GDK_BUTTON_PRESS && ! PANEL_HAS_FLAG ( event -> state , GDK_CONTROL_MASK ) ) ) return FALSE ; if ( button != NULL ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( button ) , TRUE ) ; # if GTK_CHECK_VERSION ( 3 , 22 , 0 ) gtk_menu_popup_at_widget ( GTK_MENU ( plugin -> menu ) , button , <S2SV_StartBug> GDK_GRAVITY_SOUTH_WEST , <S2SV_EndBug> GDK_GRAVITY_NORTH_WEST , ( GdkEvent * ) event ) ; # else gtk_menu_popup ( GTK_MENU ( plugin -> menu ) , NULL , NULL , button != NULL ? xfce_panel_plugin_position_menu : NULL , plugin , 1 , event != NULL ? event -> time : gtk_get_current_event_time ( ) ) ; # endif return TRUE ; }
<S2SV_ModStart> , button , xfce_panel_plugin_get_orientation ( XFCE_PANEL_PLUGIN ( plugin ) ) == GTK_ORIENTATION_VERTICAL ? GDK_GRAVITY_WEST : GDK_GRAVITY_NORTH , xfce_panel_plugin_get_orientation ( XFCE_PANEL_PLUGIN ( plugin ) ) == GTK_ORIENTATION_VERTICAL ? GDK_GRAVITY_EAST : GDK_GRAVITY_SOUTH <S2SV_ModEnd> , ( GdkEvent
3,524
CWE-000 static int cpufreq_set_policy ( struct cpufreq_policy * policy , struct cpufreq_policy * new_policy ) { int ret = 0 , failed = 1 ; struct cpufreq_policy * cpu0_policy = NULL ; pr_debug ( "setting<S2SV_blank>new<S2SV_blank>policy<S2SV_blank>for<S2SV_blank>CPU<S2SV_blank>%u:<S2SV_blank>%u<S2SV_blank>-<S2SV_blank>%u<S2SV_blank>kHz\\n" , new_policy -> cpu , new_policy -> min , new_policy -> max ) ; memcpy ( & new_policy -> cpuinfo , & policy -> cpuinfo , sizeof ( policy -> cpuinfo ) ) ; if ( new_policy -> min > policy -> user_policy . max || new_policy -> max < policy -> user_policy . min ) { ret = - EINVAL ; goto error_out ; } ret = cpufreq_driver -> verify ( new_policy ) ; if ( ret ) goto error_out ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_ADJUST , new_policy ) ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_INCOMPATIBLE , new_policy ) ; ret = cpufreq_driver -> verify ( new_policy ) ; if ( ret ) goto error_out ; blocking_notifier_call_chain ( & cpufreq_policy_notifier_list , CPUFREQ_NOTIFY , new_policy ) ; if ( new_policy -> cpu ) { cpu0_policy = cpufreq_cpu_get ( 0 ) ; policy -> min = cpu0_policy -> min ; policy -> max = cpu0_policy -> max ; } else { policy -> min = new_policy -> min ; policy -> max = new_policy -> max ; } <S2SV_StartBug> trace_cpu_frequency_limits ( policy -> max , policy -> min , policy -> cpu ) ; <S2SV_EndBug> pr_debug ( "new<S2SV_blank>min<S2SV_blank>and<S2SV_blank>max<S2SV_blank>freqs<S2SV_blank>are<S2SV_blank>%u<S2SV_blank>-<S2SV_blank>%u<S2SV_blank>kHz\\n" , policy -> min , policy -> max ) ; if ( cpufreq_driver -> setpolicy ) { policy -> policy = new_policy -> policy ; pr_debug ( "setting<S2SV_blank>range\\n" ) ; ret = cpufreq_driver -> setpolicy ( new_policy ) ; } else { if ( new_policy -> governor != policy -> governor ) { struct cpufreq_governor * old_gov = policy -> governor ; pr_debug ( "governor<S2SV_blank>switch\\n" ) ; if ( policy -> governor ) { __cpufreq_governor ( policy , CPUFREQ_GOV_STOP ) ; up_write ( & policy -> rwsem ) ; __cpufreq_governor ( policy , CPUFREQ_GOV_POLICY_EXIT ) ; down_write ( & policy -> rwsem ) ; } if ( new_policy -> cpu && cpu0_policy ) policy -> governor = cpu0_policy -> governor ; else policy -> governor = new_policy -> governor ; if ( ! __cpufreq_governor ( policy , CPUFREQ_GOV_POLICY_INIT ) ) { if ( ! __cpufreq_governor ( policy , CPUFREQ_GOV_START ) ) { failed = 0 ; } else { up_write ( & policy -> rwsem ) ; __cpufreq_governor ( policy , CPUFREQ_GOV_POLICY_EXIT ) ; down_write ( & policy -> rwsem ) ; } } if ( failed ) { pr_debug ( "starting<S2SV_blank>governor<S2SV_blank>%s<S2SV_blank>failed\\n" , policy -> governor -> name ) ; if ( old_gov ) { policy -> governor = old_gov ; __cpufreq_governor ( policy , CPUFREQ_GOV_POLICY_INIT ) ; __cpufreq_governor ( policy , CPUFREQ_GOV_START ) ; } ret = - EINVAL ; goto error_out ; } } pr_debug ( "governor:<S2SV_blank>change<S2SV_blank>or<S2SV_blank>update<S2SV_blank>limits\\n" ) ; ret = __cpufreq_governor ( policy , CPUFREQ_GOV_LIMITS ) ; } error_out : return ret ; }
<S2SV_ModStart> policy -> cpu ) ; if ( new_policy -> cpu ) cpu0_policy = cpufreq_cpu_get ( 0
3,525
CWE-000 static int handle_packet ( struct nfq_q_handle * qh , struct nfgenmsg * nfmsg , struct nfq_data * nfad , void * data ) { if ( ! nfad ) return 0 ; dnspacket * p = NULL ; unsigned char * payload_data = NULL ; int id = 0 ; uint32_t payload_len = 0 ; int result = 0 , result_parsing = 0 ; payload_len = handle_getdata ( nfad , & p , & payload_data ) ; if ( payload_len <= 0 ) { nfq_set_verdict ( qh , id , NF_ACCEPT , 0 , 0 ) ; <S2SV_StartBug> return MNL_CB_OK ; <S2SV_EndBug> } result_parsing = dnspacket_parse ( p ) ; if ( result_parsing != 0 ) { <S2SV_StartBug> SLOGL_vprint ( SLOGL_LVL_ERROR , "[worker<S2SV_blank>%d]<S2SV_blank>\\\n<S2SV_blank>La<S2SV_blank>trame<S2SV_blank>re\\U000000e7u<S2SV_blank>ne<S2SV_blank>sera<S2SV_blank>pas<S2SV_blank>trait\\U000000e9e." , ME -> number ) ; <S2SV_EndBug> nfq_set_verdict ( qh , id , NF_ACCEPT , 0 , 0 ) ; <S2SV_StartBug> return MNL_CB_OK ; <S2SV_EndBug> } if ( p -> nb_queries != 0 && p -> nb_replies == 0 ) { result = handle_dns ( p , payload_len , payload_data , REWRITE_Q ) ; if ( result < 0 ) { nfq_set_verdict ( qh , id , NF_ACCEPT , 0 , 0 ) ; } else { nfq_set_verdict ( qh , id , NF_ACCEPT , payload_len , payload_data ) ; } } else if ( p -> nb_queries != 0 && p -> nb_replies != 0 ) { result = handle_dns ( p , payload_len , payload_data , REWRITE_R ) ; if ( result < 0 ) nfq_set_verdict ( qh , id , NF_ACCEPT , 0 , 0 ) ; else { nfq_set_verdict ( qh , id , NF_ACCEPT , payload_len , payload_data ) ; } } else { result = - 1 ; } destroy_dnspacket ( p ) ; return result ; }
<S2SV_ModStart> ) ; return 1 <S2SV_ModEnd> ; } result_parsing <S2SV_ModStart> ( SLOGL_LVL_ERROR , "[worker<S2SV_blank>%d]<S2SV_blank>\\\nLa<S2SV_blank>trame<S2SV_blank>re\\U000000e7u<S2SV_blank>ne<S2SV_blank>sera<S2SV_blank>pas<S2SV_blank>trait\\U000000e9e." <S2SV_ModEnd> , ME -> <S2SV_ModStart> ) ; return 1 <S2SV_ModEnd> ; } if
3,526
CWE-000 static ssize_t sysfs_parse_nvme ( uint8_t * buf , ssize_t size , ssize_t * off , const char * pbuf , ssize_t psize , ssize_t * poff , struct disk_info * info ) { int rc ; int psz = 0 ; uint8_t * filebuf = NULL ; * poff = 0 ; * off = 0 ; char * newpbuf ; newpbuf = strndupa ( pbuf , psize + 1 ) ; if ( ! newpbuf ) return - 1 ; newpbuf [ psize ] = '\\0' ; int32_t tosser0 ; int32_t ctrl_id ; int32_t ns_id ; rc = sscanf ( newpbuf , "nvme/nvme%d/nvme%dn%d%n" , & tosser0 , & ctrl_id , & ns_id , & psz ) ; if ( rc != 3 ) return - 1 ; * poff += psz ; info -> nvme_info . ctrl_id = ctrl_id ; info -> nvme_info . ns_id = ns_id ; info -> nvme_info . has_eui = 0 ; info -> interface_type = nvme ; rc = read_sysfs_file ( & filebuf , "/sys/class/block/nvme%dn%d/device/eui" , ctrl_id , ns_id ) ; if ( rc >= 0 ) { uint8_t eui [ 8 ] ; if ( rc < 23 ) { errno = EINVAL ; return - 1 ; } rc = sscanf ( ( char * ) filebuf , <S2SV_StartBug> "%02hhx-%02hhx-%02hhx-%02hhx-" <S2SV_EndBug> "%02hhx-%02hhx-%02hhx-%02hhx" , & eui [ 0 ] , & eui [ 1 ] , & eui [ 2 ] , & eui [ 3 ] , & eui [ 4 ] , & eui [ 5 ] , & eui [ 6 ] , & eui [ 7 ] ) ; if ( rc < 8 ) { errno = EINVAL ; return - 1 ; } info -> nvme_info . has_eui = 1 ; memcpy ( info -> nvme_info . eui , eui , sizeof ( eui ) ) ; } * off = efidp_make_nvme ( buf , size , info -> nvme_info . ns_id , info -> nvme_info . has_eui ? info -> nvme_info . eui : NULL ) ; return * off ; }
<S2SV_ModStart> ) filebuf , "%02hhx<S2SV_blank>%02hhx<S2SV_blank>%02hhx<S2SV_blank>%02hhx<S2SV_blank>" "%02hhx<S2SV_blank>%02hhx<S2SV_blank>%02hhx<S2SV_blank>%02hhx" <S2SV_ModEnd> , & eui
3,527
CWE-000 static node_t * if1 ( lexer_t * l ) { node_t * r ; assert ( l ) ; r = node_new ( SYM_IF1 , 2 ) ; r -> o [ 0 ] = statements ( l ) ; <S2SV_StartBug> if ( accept ( l , LEX_ELSE ) ) <S2SV_EndBug> r -> o [ 1 ] = statements ( l ) ; expect ( l , LEX_THEN ) ; return r ; }
<S2SV_ModStart> ; if ( accept_token <S2SV_ModEnd> ( l ,
3,528
CWE-000 int draw ( t_env * all ) { t_env * current ; current = all ; <S2SV_StartBug> ft_sky ( current ) ; <S2SV_EndBug> draw_all ( current ) ; <S2SV_StartBug> mlx_clear_window ( current -> mlx -> mlx , current -> mlx -> window ) ; <S2SV_EndBug> mlx_put_image_to_window ( current -> mlx -> mlx , current -> mlx -> window , current -> mlx -> image , 0 , 0 ) ; return ( 1 ) ; }
<S2SV_ModStart> = all ; mlx_clear_window ( current -> t_mlx -> mlx , current -> t_mlx -> window ) ; <S2SV_ModStart> current ) ; <S2SV_ModEnd> return ( 1
3,529
CWE-000 tree_cell * nasl_pread ( lex_ctxt * lexic ) { tree_cell * retc = NULL , * a ; anon_nasl_var * v ; nasl_array * av ; int i , j , n , sz , sz2 , cd , fd = 0 ; char * * args = NULL , * cmd , * str , * str2 , buf [ 8192 ] ; FILE * fp ; char cwd [ MAXPATHLEN ] , newdir [ MAXPATHLEN ] ; if ( pid != 0 ) { nasl_perror ( lexic , "nasl_pread<S2SV_blank>is<S2SV_blank>not<S2SV_blank>reentrant!\\n" ) ; return NULL ; } a = get_variable_by_name ( lexic , "argv" ) ; cmd = get_str_local_var_by_name ( lexic , "cmd" ) ; if ( cmd == NULL || a == NULL || ( v = a -> x . ref_val ) == NULL ) { deref_cell ( a ) ; nasl_perror ( lexic , "pread()<S2SV_blank>usage:<S2SV_blank>cmd:...,<S2SV_blank>argv:...\\n" ) ; return NULL ; } deref_cell ( a ) ; if ( v -> var_type == VAR2_ARRAY ) av = & v -> v . v_arr ; else { nasl_perror ( lexic , "pread:<S2SV_blank>argv<S2SV_blank>element<S2SV_blank>must<S2SV_blank>be<S2SV_blank>an<S2SV_blank>array<S2SV_blank>(0x%x)\\n" , v -> var_type ) ; return NULL ; } cd = get_int_local_var_by_name ( lexic , "cd" , 0 ) ; cwd [ 0 ] = '\\0' ; if ( cd ) { char * p ; if ( cmd [ 0 ] == '/' ) { strncpy ( newdir , cmd , sizeof ( newdir ) - 1 ) ; p = strrchr ( newdir , '/' ) ; if ( p != newdir ) * p = '\\0' ; } else { p = find_in_path ( cmd , 0 ) ; if ( p != NULL ) strncpy ( newdir , p , sizeof ( newdir ) - 1 ) ; else { nasl_perror ( lexic , "pread:<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>found<S2SV_blank>in<S2SV_blank>$PATH\\n" , cmd ) ; return NULL ; } } newdir [ sizeof ( newdir ) - 1 ] = '\\0' ; if ( getcwd ( cwd , sizeof ( cwd ) ) == NULL ) { nasl_perror ( lexic , "pread():<S2SV_blank>getcwd:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; * cwd = '\\0' ; } if ( chdir ( newdir ) < 0 ) { nasl_perror ( lexic , "pread:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>chdir<S2SV_blank>to<S2SV_blank>%s\\n" , newdir ) ; return NULL ; } if ( cmd [ 0 ] != '/' && strlen ( newdir ) + strlen ( cmd ) + 1 < sizeof ( newdir ) ) { strcat ( newdir , "/" ) ; strcat ( newdir , cmd ) ; cmd = newdir ; } } if ( av -> hash_elt != NULL ) nasl_perror ( lexic , "pread:<S2SV_blank>named<S2SV_blank>elements<S2SV_blank>in<S2SV_blank>\'cmd\'<S2SV_blank>are<S2SV_blank>ignored!\\n" ) ; n = av -> max_idx ; <S2SV_StartBug> args = g_malloc0 ( sizeof ( char * * ) * ( n + 2 ) ) ; <S2SV_EndBug> for ( j = 0 , i = 0 ; i < n ; i ++ ) { str = ( char * ) var2str ( av -> num_elt [ i ] ) ; if ( str != NULL ) args [ j ++ ] = g_strdup ( str ) ; } args [ j ] = NULL ; old_sig_t = signal ( SIGTERM , sig_h ) ; old_sig_i = signal ( SIGINT , sig_h ) ; old_sig_c = signal ( SIGCHLD , sig_c ) ; if ( g_spawn_async_with_pipes ( NULL , args , NULL , G_SPAWN_SEARCH_PATH , NULL , NULL , & pid , NULL , & fd , NULL , NULL ) == FALSE ) goto finish_pread ; fp = fdopen ( fd , "r" ) ; if ( fp != NULL ) { sz = 0 ; str = g_malloc0 ( 1 ) ; errno = 0 ; while ( ( n = fread ( buf , 1 , sizeof ( buf ) , fp ) ) > 0 || errno == EINTR ) { if ( errno == EINTR ) { errno = 0 ; continue ; } sz2 = sz + n ; str2 = g_realloc ( str , sz2 ) ; str = str2 ; memcpy ( str + sz , buf , n ) ; sz = sz2 ; } if ( ferror ( fp ) && errno != EINTR ) nasl_perror ( lexic , "nasl_pread:<S2SV_blank>fread():<S2SV_blank>%s\\n" , strerror ( errno ) ) ; if ( * cwd != '\\0' ) if ( chdir ( cwd ) < 0 ) nasl_perror ( lexic , "pread():<S2SV_blank>chdir(%s):<S2SV_blank>%s\\n" , cwd , strerror ( errno ) ) ; retc = alloc_typed_cell ( CONST_DATA ) ; retc -> x . str_val = str ; retc -> size = sz ; } finish_pread : for ( i = 0 ; i < n ; i ++ ) g_free ( args [ i ] ) ; g_free ( args ) ; fclose ( fp ) ; g_spawn_close_pid ( pid ) ; pid = 0 ; signal ( SIGINT , old_sig_i ) ; signal ( SIGTERM , old_sig_t ) ; signal ( SIGCHLD , old_sig_c ) ; return retc ; }
<S2SV_ModStart> ( char * <S2SV_ModEnd> ) * (
3,530
CWE-000 int main ( void ) { DATA_T data ; t_list * head ; t_list * tmphead ; data = 1 ; head = ft_lstnew ( & data , sizeof ( data ) ) ; data = 2 ; ft_lstadd ( & head , ft_lstnew ( & data , sizeof ( data ) ) ) ; data = 3 ; ft_lstadd ( & head , ft_lstnew ( & data , sizeof ( data ) ) ) ; data = 3 ; tmphead = head ; head = head -> next ; ft_lstdelone ( & tmphead , deldata ) ; <S2SV_StartBug> ft_lstdel ( & head , deldata ) ; <S2SV_EndBug> <S2SV_StartBug> show_alloc_mem ( ) ; <S2SV_EndBug> }
<S2SV_ModStart> deldata ) ; show_alloc_mem ( ) ; <S2SV_ModStart> deldata ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
3,531
CWE-000 static PyObject * l_ldap_abandon_ext ( LDAPObject * self , PyObject * args ) { int msgid ; PyObject * serverctrls = Py_None ; PyObject * clientctrls = Py_None ; LDAPControl * * server_ldcs = NULL ; LDAPControl * * client_ldcs = NULL ; int ldaperror ; if ( ! PyArg_ParseTuple ( args , "i|OO" , & msgid , & serverctrls , & clientctrls ) ) return NULL ; if ( not_valid ( self ) ) return NULL ; if ( ! PyNone_Check ( serverctrls ) ) { if ( ! LDAPControls_from_object ( serverctrls , & server_ldcs ) ) return NULL ; } if ( ! PyNone_Check ( clientctrls ) ) { if ( ! LDAPControls_from_object ( clientctrls , & client_ldcs ) ) <S2SV_StartBug> return NULL ; <S2SV_EndBug> } LDAP_BEGIN_ALLOW_THREADS ( self ) ; ldaperror = ldap_abandon_ext ( self -> ldap , msgid , server_ldcs , client_ldcs ) ; LDAP_END_ALLOW_THREADS ( self ) ; LDAPControl_List_DEL ( server_ldcs ) ; LDAPControl_List_DEL ( client_ldcs ) ; if ( ldaperror != LDAP_SUCCESS ) return LDAPerror ( self -> ldap , "ldap_abandon_ext" ) ; Py_INCREF ( Py_None ) ; return Py_None ; }
<S2SV_ModStart> client_ldcs ) ) { LDAPControl_List_DEL ( server_ldcs ) ; return NULL ; } <S2SV_ModEnd> } LDAP_BEGIN_ALLOW_THREADS (
3,532
CWE-000 static int do_page_crypto ( struct inode * inode , fscrypt_direction_t rw , pgoff_t index , <S2SV_StartBug> struct page * src_page , struct page * dest_page ) <S2SV_EndBug> { u8 xts_tweak [ FS_XTS_TWEAK_SIZE ] ; struct ablkcipher_request * req = NULL ; DECLARE_FS_COMPLETION_RESULT ( ecr ) ; struct scatterlist dst , src ; struct fscrypt_info * ci = inode -> i_crypt_info ; struct crypto_ablkcipher * tfm = ci -> ci_ctfm ; int res = 0 ; <S2SV_StartBug> req = ablkcipher_request_alloc ( tfm , GFP_NOFS ) ; <S2SV_EndBug> if ( ! req ) { printk_ratelimited ( KERN_ERR "%s:<S2SV_blank>crypto_request_alloc()<S2SV_blank>failed\\n" , __func__ ) ; return - ENOMEM ; } ablkcipher_request_set_callback ( req , CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP , fscrypt_complete , & ecr ) ; BUILD_BUG_ON ( FS_XTS_TWEAK_SIZE < sizeof ( index ) ) ; memcpy ( xts_tweak , & index , sizeof ( index ) ) ; memset ( & xts_tweak [ sizeof ( index ) ] , 0 , FS_XTS_TWEAK_SIZE - sizeof ( index ) ) ; sg_init_table ( & dst , 1 ) ; sg_set_page ( & dst , dest_page , PAGE_CACHE_SIZE , 0 ) ; sg_init_table ( & src , 1 ) ; sg_set_page ( & src , src_page , PAGE_CACHE_SIZE , 0 ) ; ablkcipher_request_set_crypt ( req , & src , & dst , PAGE_CACHE_SIZE , xts_tweak ) ; if ( rw == FS_DECRYPT ) res = crypto_ablkcipher_decrypt ( req ) ; else res = crypto_ablkcipher_encrypt ( req ) ; if ( res == - EINPROGRESS || res == - EBUSY ) { BUG_ON ( req -> base . data != & ecr ) ; wait_for_completion ( & ecr . completion ) ; res = ecr . res ; } ablkcipher_request_free ( req ) ; if ( res ) { printk_ratelimited ( KERN_ERR "%s:<S2SV_blank>crypto_ablkcipher_encrypt()<S2SV_blank>returned<S2SV_blank>%d\\n" , __func__ , res ) ; return res ; } return 0 ; }
<S2SV_ModStart> page * dest_page , gfp_t gfp_flags <S2SV_ModStart> ( tfm , gfp_flags <S2SV_ModEnd> ) ; if
3,533
CWE-000 static int pppol2tp_connect ( struct socket * sock , struct sockaddr * uservaddr , int sockaddr_len , int flags ) { struct sock * sk = sock -> sk ; struct sockaddr_pppol2tp * sp = ( struct sockaddr_pppol2tp * ) uservaddr ; struct pppox_sock * po = pppox_sk ( sk ) ; struct l2tp_session * session = NULL ; struct l2tp_tunnel * tunnel ; struct pppol2tp_session * ps ; struct dst_entry * dst ; struct l2tp_session_cfg cfg = { 0 , } ; int error = 0 ; u32 tunnel_id , peer_tunnel_id ; u32 session_id , peer_session_id ; int ver = 2 ; int fd ; lock_sock ( sk ) ; error = - EINVAL ; if ( sp -> sa_protocol != PX_PROTO_OL2TP ) goto end ; error = - EBUSY ; if ( sk -> sk_state & PPPOX_CONNECTED ) goto end ; error = - EALREADY ; if ( sk -> sk_user_data ) goto end ; peer_tunnel_id = 0 ; if ( sockaddr_len == sizeof ( struct sockaddr_pppol2tp ) ) { fd = sp -> pppol2tp . fd ; tunnel_id = sp -> pppol2tp . s_tunnel ; peer_tunnel_id = sp -> pppol2tp . d_tunnel ; session_id = sp -> pppol2tp . s_session ; peer_session_id = sp -> pppol2tp . d_session ; } else if ( sockaddr_len == sizeof ( struct sockaddr_pppol2tpv3 ) ) { struct sockaddr_pppol2tpv3 * sp3 = ( struct sockaddr_pppol2tpv3 * ) sp ; ver = 3 ; fd = sp3 -> pppol2tp . fd ; tunnel_id = sp3 -> pppol2tp . s_tunnel ; peer_tunnel_id = sp3 -> pppol2tp . d_tunnel ; session_id = sp3 -> pppol2tp . s_session ; peer_session_id = sp3 -> pppol2tp . d_session ; } else if ( sockaddr_len == sizeof ( struct sockaddr_pppol2tpin6 ) ) { struct sockaddr_pppol2tpin6 * sp6 = ( struct sockaddr_pppol2tpin6 * ) sp ; fd = sp6 -> pppol2tp . fd ; tunnel_id = sp6 -> pppol2tp . s_tunnel ; peer_tunnel_id = sp6 -> pppol2tp . d_tunnel ; session_id = sp6 -> pppol2tp . s_session ; peer_session_id = sp6 -> pppol2tp . d_session ; } else if ( sockaddr_len == sizeof ( struct sockaddr_pppol2tpv3in6 ) ) { struct sockaddr_pppol2tpv3in6 * sp6 = ( struct sockaddr_pppol2tpv3in6 * ) sp ; ver = 3 ; fd = sp6 -> pppol2tp . fd ; tunnel_id = sp6 -> pppol2tp . s_tunnel ; peer_tunnel_id = sp6 -> pppol2tp . d_tunnel ; session_id = sp6 -> pppol2tp . s_session ; peer_session_id = sp6 -> pppol2tp . d_session ; } else { error = - EINVAL ; goto end ; } error = - EINVAL ; if ( tunnel_id == 0 ) goto end ; tunnel = l2tp_tunnel_find ( sock_net ( sk ) , tunnel_id ) ; if ( ( session_id == 0 ) && ( peer_session_id == 0 ) ) { if ( tunnel == NULL ) { struct l2tp_tunnel_cfg tcfg = { . encap = L2TP_ENCAPTYPE_UDP , . debug = 0 , } ; error = l2tp_tunnel_create ( sock_net ( sk ) , fd , ver , tunnel_id , peer_tunnel_id , & tcfg , & tunnel ) ; if ( error < 0 ) goto end ; } } else { error = - ENOENT ; if ( tunnel == NULL ) goto end ; if ( tunnel -> sock == NULL ) goto end ; } if ( tunnel -> recv_payload_hook == NULL ) tunnel -> recv_payload_hook = pppol2tp_recv_payload_hook ; if ( tunnel -> peer_tunnel_id == 0 ) tunnel -> peer_tunnel_id = peer_tunnel_id ; session = l2tp_session_find ( sock_net ( sk ) , tunnel , session_id ) ; if ( session == NULL ) { cfg . mtu = cfg . mru = 1500 - PPPOL2TP_HEADER_OVERHEAD ; session = l2tp_session_create ( sizeof ( struct pppol2tp_session ) , tunnel , session_id , peer_session_id , & cfg ) ; if ( session == NULL ) { error = - ENOMEM ; goto end ; } } else { ps = l2tp_session_priv ( session ) ; error = - EEXIST ; if ( ps -> sock != NULL ) goto end ; if ( ps -> tunnel_sock != tunnel -> sock ) goto end ; } ps = l2tp_session_priv ( session ) ; ps -> owner = current -> pid ; ps -> sock = sk ; ps -> tunnel_sock = tunnel -> sock ; session -> recv_skb = pppol2tp_recv ; session -> session_close = pppol2tp_session_close ; # if defined ( CONFIG_L2TP_DEBUGFS ) || defined ( CONFIG_L2TP_DEBUGFS_MODULE ) session -> show = pppol2tp_show ; # endif session -> ref = pppol2tp_session_sock_hold ; session -> deref = pppol2tp_session_sock_put ; dst = sk_dst_get ( tunnel -> sock ) ; if ( dst != NULL ) { <S2SV_StartBug> u32 pmtu = dst_mtu ( __sk_dst_get ( tunnel -> sock ) ) ; <S2SV_EndBug> if ( pmtu != 0 ) session -> mtu = session -> mru = pmtu - PPPOL2TP_HEADER_OVERHEAD ; dst_release ( dst ) ; } if ( ( session -> session_id == 0 ) && ( session -> peer_session_id == 0 ) ) { error = 0 ; goto out_no_ppp ; } po -> chan . hdrlen = PPPOL2TP_L2TP_HDR_SIZE_NOSEQ ; po -> chan . private = sk ; po -> chan . ops = & pppol2tp_chan_ops ; po -> chan . mtu = session -> mtu ; error = ppp_register_net_channel ( sock_net ( sk ) , & po -> chan ) ; if ( error ) goto end ; out_no_ppp : sk -> sk_user_data = session ; sk -> sk_state = PPPOX_CONNECTED ; l2tp_info ( session , PPPOL2TP_MSG_CONTROL , "%s:<S2SV_blank>created\\n" , session -> name ) ; end : release_sock ( sk ) ; return error ; }
<S2SV_ModStart> = dst_mtu ( dst <S2SV_ModEnd> ) ; if
3,534
CWE-000 static void handle_clear_accept ( struct ev_loop * loop , ev_io * w , int revents ) { ( void ) revents ; ( void ) loop ; struct sockaddr_storage addr ; struct frontend * fr ; sslctx * so ; proxystate * ps ; socklen_t sl = sizeof ( addr ) ; int client = accept ( w -> fd , ( struct sockaddr * ) & addr , & sl ) ; if ( client == - 1 ) { switch ( errno ) { case EMFILE : ERR ( "{client}<S2SV_blank>accept()<S2SV_blank>failed;<S2SV_blank>" "too<S2SV_blank>many<S2SV_blank>open<S2SV_blank>files<S2SV_blank>for<S2SV_blank>this<S2SV_blank>process\\n" ) ; break ; case ENFILE : ERR ( "{client}<S2SV_blank>accept()<S2SV_blank>failed;<S2SV_blank>" "too<S2SV_blank>many<S2SV_blank>open<S2SV_blank>files<S2SV_blank>for<S2SV_blank>this<S2SV_blank>system\\n" ) ; break ; default : if ( errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN && errno != ECONNABORTED ) { SOCKERR ( "{client}<S2SV_blank>accept()<S2SV_blank>failed" ) ; } break ; } return ; } int flag = 1 ; int ret = setsockopt ( client , IPPROTO_TCP , TCP_NODELAY , ( char * ) & flag , sizeof ( flag ) ) ; if ( ret == - 1 ) { ERR ( "Couldn\'t<S2SV_blank>setsockopt<S2SV_blank>on<S2SV_blank>client<S2SV_blank>(TCP_NODELAY):<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } # ifdef TCP_CWND int cwnd = 10 ; ret = setsockopt ( client , IPPROTO_TCP , TCP_CWND , & cwnd , sizeof ( cwnd ) ) ; if ( ret == - 1 ) { ERR ( "Couldn\'t<S2SV_blank>setsockopt<S2SV_blank>on<S2SV_blank>client<S2SV_blank>(TCP_CWND):<S2SV_blank>%s\\n" , strerror ( errno ) ) ; } # endif if ( setnonblocking ( client ) ) { SOCKERR ( "{client}<S2SV_blank>setnonblocking<S2SV_blank>failed" ) ; ( void ) close ( client ) ; return ; } settcpkeepalive ( client ) ; ALLOC_OBJ ( ps , PROXYSTATE_MAGIC ) ; ps -> backend = backend_ref ( ) ; ps -> fd_down = create_back_socket ( ps -> backend ) ; if ( ps -> fd_down == - 1 ) { backend_deref ( & ps -> backend ) ; close ( client ) ; free ( ps ) ; ERR ( "{backend-socket}:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return ; } CAST_OBJ_NOTNULL ( fr , w -> data , FRONTEND_MAGIC ) ; <S2SV_StartBug> if ( fr -> ssl_ctxs != NULL ) <S2SV_EndBug> <S2SV_StartBug> CAST_OBJ_NOTNULL ( so , fr -> ssl_ctxs , SSLCTX_MAGIC ) ; <S2SV_EndBug> else CAST_OBJ_NOTNULL ( so , default_ctx , SSLCTX_MAGIC ) ; SSL * ssl = SSL_new ( so -> ctx ) ; long mode = SSL_MODE_ENABLE_PARTIAL_WRITE ; # ifdef SSL_MODE_RELEASE_BUFFERS mode |= SSL_MODE_RELEASE_BUFFERS ; # endif SSL_set_mode ( ssl , mode ) ; SSL_set_connect_state ( ssl ) ; SSL_set_fd ( ssl , ps -> fd_down ) ; if ( client_session ) SSL_set_session ( ssl , client_session ) ; ps -> fd_up = client ; ps -> ssl = ssl ; ps -> want_shutdown = 0 ; ps -> clear_connected = 1 ; ps -> handshaked = 0 ; ps -> renegotiation = 0 ; ps -> remote_ip = addr ; ringbuffer_init ( & ps -> ring_clear2ssl , CONFIG -> RING_SLOTS , CONFIG -> RING_DATA_LEN ) ; ringbuffer_init ( & ps -> ring_ssl2clear , CONFIG -> RING_SLOTS , CONFIG -> RING_DATA_LEN ) ; ev_io_init ( & ps -> ev_r_clear , clear_read , client , EV_READ ) ; ev_io_init ( & ps -> ev_w_clear , clear_write , client , EV_WRITE ) ; ev_io_init ( & ps -> ev_w_connect , handle_connect , ps -> fd_down , EV_WRITE ) ; ev_timer_init ( & ps -> ev_t_connect , connect_timeout , CONFIG -> BACKEND_CONNECT_TIMEOUT , 0. ) ; ev_io_init ( & ps -> ev_r_handshake , client_handshake , ps -> fd_down , EV_READ ) ; ev_io_init ( & ps -> ev_w_handshake , client_handshake , ps -> fd_down , EV_WRITE ) ; ev_timer_init ( & ps -> ev_t_handshake , handshake_timeout , CONFIG -> SSL_HANDSHAKE_TIMEOUT , 0. ) ; ev_io_init ( & ps -> ev_w_ssl , ssl_write , ps -> fd_down , EV_WRITE ) ; ev_io_init ( & ps -> ev_r_ssl , ssl_read , ps -> fd_down , EV_READ ) ; ps -> ev_r_ssl . data = ps ; ps -> ev_w_ssl . data = ps ; ps -> ev_r_clear . data = ps ; ps -> ev_w_clear . data = ps ; ps -> ev_w_connect . data = ps ; ps -> ev_r_handshake . data = ps ; ps -> ev_w_handshake . data = ps ; ps -> ev_t_handshake . data = ps ; SSL_set_app_data ( ssl , ps ) ; n_conns ++ ; ev_io_start ( loop , & ps -> ev_r_clear ) ; start_connect ( ps ) ; }
<S2SV_ModStart> ( fr -> default_ctx <S2SV_ModEnd> != NULL ) <S2SV_ModStart> , fr -> default_ctx <S2SV_ModEnd> , SSLCTX_MAGIC )
3,535
CWE-000 static sqInt scanMethod ( void ) { BytecodeDescriptor * descriptor ; sqInt distance ; BytecodeFixup * fixup ; sqInt framelessStackDelta ; sqInt latestContinuation ; sqInt nExts ; sqInt numBlocks ; sqInt pc ; sqInt seenInstVarStore ; sqInt targetPC ; needsFrame = ( useTwoPaths = ( seenInstVarStore = 0 ) ) ; prevBCDescriptor = null ; numIRCs = 0 ; if ( ( primitiveIndex > 0 ) && ( isQuickPrimitiveIndex ( primitiveIndex ) ) ) { return 0 ; } pc = ( latestContinuation = initialPC ) ; numBlocks = ( framelessStackDelta = ( nExts = ( extA = ( numExtB = ( extB = 0 ) ) ) ) ) ; while ( pc <= endPC ) { byte0 = ( fetchByteofObject ( pc , methodObj ) ) + bytecodeSetOffset ; descriptor = generatorAt ( byte0 ) ; if ( ( descriptor -> isExtension ) ) { if ( ( ( descriptor -> opcode ) ) == Nop ) { return EncounteredUnknownBytecode ; } loadSubsequentBytesForDescriptorat ( descriptor , pc ) ; ( ( descriptor -> generator ) ) ( ) ; } if ( ( ( descriptor -> isReturn ) ) && ( pc >= latestContinuation ) ) { endPC = pc ; } if ( ! needsFrame ) { if ( ( ( ( descriptor -> needsFrameFunction ) ) == null ) || ( ( ( descriptor -> needsFrameFunction ) ) ( framelessStackDelta ) ) ) { # if IMMUTABILITY if ( ( descriptor -> is1ByteInstVarStore ) ) { useTwoPaths = 1 ; } else { needsFrame = 1 ; useTwoPaths = 0 ; } # else needsFrame = 1 ; useTwoPaths = 0 ; # endif } else { framelessStackDelta += ( descriptor -> stackDelta ) ; # if IMMUTABILITY # else if ( ( descriptor -> is1ByteInstVarStore ) ) { if ( seenInstVarStore ) { useTwoPaths = 1 ; } else { seenInstVarStore = 1 ; } } # endif } } if ( isBranch ( descriptor ) ) { distance = ( ( descriptor -> spanFunction ) ) ( descriptor , pc , nExts , methodObj ) ; targetPC = ( pc + ( ( descriptor -> numBytes ) ) ) + distance ; if ( ( assert ( ( ( descriptor -> spanFunction ) ) != null ) , ( ( ( descriptor -> spanFunction ) ) ( descriptor , pc , nExts , methodObj ) ) < 0 ) ) { fixup = fixupAtIndex ( targetPC - initialPC ) ; ( fixup -> targetInstruction ) = ( ( AbstractInstruction * ) NeedsMergeFixupFlag ) ; ( fixup -> isTargetOfBackwardBranch ) = 1 ; } else { latestContinuation = ( ( latestContinuation < targetPC ) ? targetPC : latestContinuation ) ; } } <S2SV_StartBug> if ( ( descriptor -> isBlockCreation ) ) { <S2SV_EndBug> numBlocks += 1 ; distance = ( ( descriptor -> spanFunction ) ) ( descriptor , pc , nExts , methodObj ) ; targetPC = ( pc + ( ( descriptor -> numBytes ) ) ) + distance ; latestContinuation = ( ( latestContinuation < targetPC ) ? targetPC : latestContinuation ) ; } if ( ( descriptor -> hasIRC ) ) { numIRCs += 1 ; } pc += ( descriptor -> numBytes ) ; nExts = ( ( descriptor -> isExtension ) ? nExts + 1 : ( extA = ( numExtB = ( extB = 0 ) ) ) ) ; prevBCDescriptor = descriptor ; } return numBlocks ; }
<S2SV_ModStart> ; } } latestContinuation = latestContinuation ;
3,536
CWE-000 static PyObject * _ssl__SSLSocket_pending_impl ( PySSLSocket * self ) { int count = 0 ; <S2SV_StartBug> PySSL_BEGIN_ALLOW_THREADS <S2SV_EndBug> count = SSL_pending ( self -> ssl ) ; <S2SV_StartBug> _PySSL_UPDATE_ERRNO_IF ( count < 0 , self , count ) ; <S2SV_EndBug> <S2SV_StartBug> PySSL_END_ALLOW_THREADS <S2SV_EndBug> if ( count < 0 ) return PySSL_SetError ( self , count , __FILE__ , __LINE__ ) ; else return PyLong_FromLong ( count ) ; }
<S2SV_ModStart> = 0 ; _PySSLError err ; <S2SV_ModStart> ssl ) ; err = _PySSL_errno <S2SV_ModEnd> ( count < <S2SV_ModStart> 0 , self -> ssl <S2SV_ModStart> ) ; PySSL_END_ALLOW_THREADS self -> err = err ;
3,537
CWE-000 void bitbuffer_add_row ( bitbuffer_t * bits ) { <S2SV_StartBug> if ( bits -> num_rows == 0 ) bits -> num_rows ++ ; <S2SV_EndBug> <S2SV_StartBug> if ( bits -> num_rows < BITBUF_ROWS ) { <S2SV_EndBug> bits -> num_rows ++ ; <S2SV_StartBug> } <S2SV_EndBug> else { bits -> bits_per_row [ bits -> num_rows - 1 ] = 0 ; } <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> num_rows == 0 || <S2SV_ModEnd> ( bits -> <S2SV_ModStart> num_rows < BITBUF_ROWS && bits -> bits_per_row [ bits -> num_rows - 1 ] > 0 ) ) <S2SV_ModEnd> bits -> num_rows <S2SV_ModStart> num_rows ++ ; <S2SV_ModEnd> bits -> bits_per_row <S2SV_ModStart> 0 ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
3,538
CWE-000 struct supplemental_page_table * vm_supt_create ( void ) { struct supplemental_page_table * supt = ( struct supplemental_page_table * ) malloc ( sizeof ( struct supplemental_page_table ) ) ; hash_init ( & supt -> page_map , spte_hash_func , spte_less_func , NULL ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> NULL ) ; return supt ;
3,539
CWE-000 void ofi_mr_cache_cleanup ( struct ofi_mr_cache * cache ) { struct ofi_mr_entry * entry ; struct dlist_entry * tmp ; FI_INFO ( cache -> domain -> prov , FI_LOG_MR , "MR<S2SV_blank>cache<S2SV_blank>stats:<S2SV_blank>" "searches<S2SV_blank>%zu,<S2SV_blank>deletes<S2SV_blank>%zu,<S2SV_blank>hits<S2SV_blank>%zu\\n" , cache -> search_cnt , cache -> delete_cnt , cache -> hit_cnt ) ; util_mr_cache_process_events ( cache ) ; dlist_foreach_container_safe ( & cache -> lru_list , struct ofi_mr_entry , entry , lru_entry , tmp ) { assert ( entry -> use_cnt == 0 ) ; util_mr_uncache_entry ( cache , entry ) ; dlist_remove_init ( & entry -> lru_entry ) ; util_mr_free_entry ( cache , entry ) ; } <S2SV_StartBug> rbtDelete ( cache -> mr_tree ) ; <S2SV_EndBug> ofi_monitor_del_queue ( & cache -> nq ) ; ofi_atomic_dec32 ( & cache -> domain -> ref ) ; util_buf_pool_destroy ( cache -> entry_pool ) ; assert ( cache -> cached_cnt == 0 ) ; assert ( cache -> cached_size == 0 ) ; }
<S2SV_ModStart> ) ; } cache -> mr_storage . destroy ( & cache -> mr_storage <S2SV_ModEnd> ) ; ofi_monitor_del_queue
3,540
CWE-000 void * get_phys_page ( void * virtaddr ) { void * off = ( void * ) ( ( u32 ) virtaddr & 0x00000FFF ) ; virtaddr = ( void * ) ( ( u32 ) virtaddr & 0xFFFFF000 ) ; u32 pdindex = ( u32 ) virtaddr >> 22 ; u32 ptindex = ( u32 ) virtaddr >> 12 & 0x03FF ; if ( pagedir [ pdindex ] & 0x01 ) { <S2SV_StartBug> if ( ( ( u32 * ) pagedir [ pdindex ] ) [ ptindex ] & 0x01 ) <S2SV_EndBug> <S2SV_StartBug> return ( void * ) ( ( ( ( u32 * ) pagedir [ pdindex ] ) [ ptindex ] & 0xFFFFF000 ) | ( u32 ) off ) ; <S2SV_EndBug> else return NULL ; } else return NULL ; }
<S2SV_ModStart> u32 * ) ( <S2SV_ModStart> [ pdindex ] & 0xFFFFF000 ) <S2SV_ModStart> u32 * ) ( <S2SV_ModStart> [ pdindex ] & 0xFFFFF000 )
3,541
CWE-000 int main ( int argc , char * * argv ) { u32 * framebuf ; u32 cnt = 0 ; gfxInitDefault ( ) ; int player = 1 ; int points [ 9 ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; int win ; win = 0 ; u32 focused = 3 ; int start = 0 ; while ( appletMainLoop ( ) ) { hidScanInput ( ) ; u32 kDown = hidKeysDown ( CONTROLLER_P1_AUTO ) ; if ( kDown & KEY_PLUS ) break ; else if ( kDown & KEY_DDOWN ) { if ( focused % 3 < 2 ) focused ++ ; else focused -= 2 ; } else if ( kDown & KEY_DRIGHT ) { if ( focused + 3 <= 9 ) { focused += 3 ; } else focused -= 6 ; } else if ( kDown & KEY_DLEFT ) { <S2SV_StartBug> if ( focused - 3 >= 0 ) { <S2SV_EndBug> focused -= 3 ; <S2SV_StartBug> } else focused += 6 ; <S2SV_EndBug> } else if ( kDown & KEY_DUP ) { if ( focused % 3 > 0 ) focused -- ; else focused += 2 ; } <S2SV_StartBug> else if ( kDown & KEY_JOYCON_DOWN ) { <S2SV_EndBug> memset ( points , 0 , sizeof points ) ; } else if ( kDown & KEY_JOYCON_RIGHT ) { <S2SV_StartBug> if ( points [ focused ] == 0 ) { <S2SV_EndBug> points [ focused ] = player ; player %= 2 ; player += 1 ; } <S2SV_StartBug> if ( win ) { <S2SV_EndBug> memset ( points , 0 , sizeof points ) ; win = 0 ; player = 1 ; focused = 4 ; } } <S2SV_StartBug> if ( focused > 8 || focused < 0 ) focused = 4 ; <S2SV_EndBug> u32 width , height ; u32 pos ; framebuf = ( u32 * ) gfxGetFramebuffer ( ( u32 * ) & width , ( u32 * ) & height ) ; if ( start == 0 ) { start = 1 ; focused ++ ; } if ( cnt == 15 ) { cnt = 0 ; } else { cnt ++ ; } u32 color ; u32 x , y ; int s = height / 5 ; int b = 5 ; int d = height / 5 / 10 ; if ( testwin ( 0 , 1 , 2 , points ) || testwin ( 3 , 4 , 5 , points ) || testwin ( 6 , 7 , 8 , points ) || testwin ( 0 , 3 , 6 , points ) || testwin ( 1 , 4 , 7 , points ) || testwin ( 2 , 5 , 8 , points ) || testwin ( 0 , 4 , 8 , points ) || testwin ( 2 , 4 , 6 , points ) ) win = 1 ; int un = 1 ; for ( int i = 0 ; i < 9 ; i ++ ) { if ( points [ i ] == 0 ) { un = 0 ; } } if ( un ) win = 1 ; u32 wincolor ; wincolor = 0xFFFF0000 ; if ( cnt > 7 ) { wincolor = 0x33FFF000 ; } if ( win ) focused = - 1 ; for ( y = 0 ; y < height ; y ++ ) { for ( x = 0 ; x < width ; x ++ ) { pos = y * width + x ; color = 0x00000000 ; framebuf [ pos ] = color ; for ( int rx = 0 ; rx < 3 ; rx ++ ) { for ( int ry = 0 ; ry < 3 ; ry ++ ) { int id = ry + rx * 3 ; if ( pointInSquareC ( x , y , width / 2 - s - d + ( s + d ) * rx , height / 2 - s - d + ( s + d ) * ry , s + b * 2 ) ) { color = 0x00000000 ; if ( focused == id ) color = 0xFFFFFFFF ; else color = 0x00000000 ; if ( points [ id ] > 2 ) color = wincolor ; framebuf [ pos ] = color ; } if ( pointInSquareC ( x , y , width / 2 - s - d + ( s + d ) * rx , height / 2 - s - d + ( s + d ) * ry , s ) ) { if ( points [ id ] % 3 == 0 ) color = 0x99999999 ; if ( points [ id ] % 3 == 1 ) color = 0x1111FFFF ; if ( points [ id ] % 3 == 2 ) color = 0x1111FF11 ; framebuf [ pos ] = color ; } } } } } gfxFlushBuffers ( ) ; gfxSwapBuffers ( ) ; gfxWaitForVsync ( ) ; } gfxExit ( ) ; return 0 ; }
<S2SV_ModStart> if ( focused >= 3 <S2SV_ModEnd> ) { focused <S2SV_ModStart> } else focused = 6 + focused % 3 <S2SV_ModEnd> ; } else <S2SV_ModStart> ( kDown & <S2SV_ModEnd> KEY_JOYCON_RIGHT ) { <S2SV_ModStart> KEY_JOYCON_RIGHT ) { if ( win ) { main ( argc , argv ) ; return 0 ; } else <S2SV_ModStart> 1 ; } } if ( kDown & KEY_MINUS ) { main ( argc , argv ) ; return 0 ; <S2SV_ModEnd> } if ( <S2SV_ModStart> ) focused = 0 <S2SV_ModEnd> ; u32 width
3,542
CWE-000 <S2SV_StartBug> static int hashmap_hash ( map_t in , char * key ) { <S2SV_EndBug> hashmap_map * m = ( hashmap_map * ) in ; if ( m -> size >= m -> table_size / 2 ) { return MAP_FULL ; } int curr = hashmap_hash_int ( m , key ) ; for ( int i = 0 ; i < MAX_CHAIN_LENGTH ; i ++ ) { if ( ! m -> data [ curr ] . in_use || ! strcmp ( m -> data [ curr ] . key , key ) ) { return curr ; } curr = ( curr + 1 ) % m -> table_size ; } return MAP_FULL ; }
<S2SV_ModStart> map_t in , const
3,543
CWE-000 static PyObject * pacifica_archiveinterface_ping_core ( PyObject * self , PyObject * args ) <S2SV_StartBug> { <S2SV_EndBug> PyObject * latency = PyTuple_New ( 4 ) ; int ret ; <S2SV_StartBug> hpss_uuid_t uuid ; <S2SV_EndBug> struct timeval tv ; unsigned32 secs , usecs ; <S2SV_StartBug> uuid . time_low = 0xe52ea34e ; <S2SV_EndBug> uuid . time_mid = 0xc9aa ; uuid . time_hi_and_version = 0x11de ; uuid . clock_seq_hi_and_reserved = 0xb4 ; uuid . clock_seq_low = 0x08 ; uuid . node [ 0 ] = 0x00 ; uuid . node [ 1 ] = 0x21 ; uuid . node [ 2 ] = 0x5e ; uuid . node [ 3 ] = 0xdc ; uuid . node [ 4 ] = 0x76 ; uuid . node [ 5 ] = 0x4c ; gettimeofday ( & tv , NULL ) ; ret = hpss_PingCore ( & uuid , & secs , & usecs ) ; if ( ret < 0 ) { PyErr_SetString ( archiveInterfaceError , strerror ( errno ) ) ; return NULL ; } PyTuple_SetItem ( latency , 0 , Py_BuildValue ( "i" , secs ) ) ; PyTuple_SetItem ( latency , 1 , Py_BuildValue ( "i" , usecs ) ) ; PyTuple_SetItem ( latency , 2 , Py_BuildValue ( "i" , tv . tv_sec ) ) ; PyTuple_SetItem ( latency , 3 , Py_BuildValue ( "i" , tv . tv_usec ) ) ; return latency ; }
<S2SV_ModStart> args ) { char * sitename ; <S2SV_ModStart> int ret ; hpss_srvr_id_t <S2SV_ModEnd> uuid ; struct <S2SV_ModStart> , usecs ; if ( ! PyArg_ParseTuple ( args , "s" , & sitename ) ) { PyErr_SetString ( archiveInterfaceError , "Error<S2SV_blank>parsing<S2SV_blank>sitename<S2SV_blank>argument" ) ; return NULL ; } ret = hpss_LookupRootCS ( sitename , & uuid ) ; if ( ret < 0 ) { PyErr_SetString ( archiveInterfaceError , strerror ( errno ) ) ; return NULL ; } <S2SV_ModEnd> gettimeofday ( &
3,544
CWE-000 static int npyiter_ass_subscript ( NewNpyArrayIterObject * self , PyObject * op , PyObject * value ) { if ( value == NULL ) { PyErr_SetString ( PyExc_TypeError , "Cannot<S2SV_blank>delete<S2SV_blank>iterator<S2SV_blank>elements" ) ; return - 1 ; } if ( self -> iter == NULL || self -> finished ) { PyErr_SetString ( PyExc_ValueError , "Iterator<S2SV_blank>is<S2SV_blank>past<S2SV_blank>the<S2SV_blank>end" ) ; return - 1 ; } if ( NpyIter_HasDelayedBufAlloc ( self -> iter ) ) { PyErr_SetString ( PyExc_ValueError , "Iterator<S2SV_blank>construction<S2SV_blank>used<S2SV_blank>delayed<S2SV_blank>buffer<S2SV_blank>allocation,<S2SV_blank>" "and<S2SV_blank>no<S2SV_blank>reset<S2SV_blank>has<S2SV_blank>been<S2SV_blank>done<S2SV_blank>yet" ) ; return - 1 ; } <S2SV_StartBug> if ( self -> managed == CONTEXT_EXITED ) { <S2SV_EndBug> PyErr_SetString ( PyExc_ValueError , "Iterator<S2SV_blank>is<S2SV_blank>closed" ) ; return - 1 ; } if ( PyInt_Check ( op ) || PyLong_Check ( op ) || ( PyIndex_Check ( op ) && ! PySequence_Check ( op ) ) ) { npy_intp i = PyArray_PyIntAsIntp ( op ) ; if ( error_converting ( i ) ) { return - 1 ; } return npyiter_seq_ass_item ( self , i , value ) ; } else if ( PySlice_Check ( op ) ) { Py_ssize_t istart = 0 , iend = 0 , istep = 0 , islicelength = 0 ; if ( NpySlice_GetIndicesEx ( op , NpyIter_GetNOp ( self -> iter ) , & istart , & iend , & istep , & islicelength ) < 0 ) { return - 1 ; } if ( istep != 1 ) { PyErr_SetString ( PyExc_ValueError , "Iterator<S2SV_blank>slice<S2SV_blank>assignment<S2SV_blank>only<S2SV_blank>supports<S2SV_blank>a<S2SV_blank>step<S2SV_blank>of<S2SV_blank>1" ) ; return - 1 ; } return npyiter_seq_ass_slice ( self , istart , iend , value ) ; } PyErr_SetString ( PyExc_TypeError , "invalid<S2SV_blank>index<S2SV_blank>type<S2SV_blank>for<S2SV_blank>iterator<S2SV_blank>indexing" ) ; return - 1 ; }
<S2SV_ModStart> -> managed == CLOSED <S2SV_ModEnd> ) { PyErr_SetString
3,545
CWE-000 static uint64_t arm_ldq_ptw ( CPUState * cs , hwaddr addr , bool is_secure , ARMMMUIdx mmu_idx , ARMMMUFaultInfo * fi ) { ARMCPU * cpu = ARM_CPU ( cs ) ; CPUARMState * env = & cpu -> env ; MemTxAttrs attrs = { } ; MemTxResult result = MEMTX_OK ; AddressSpace * as ; <S2SV_StartBug> uint32_t data ; <S2SV_EndBug> attrs . secure = is_secure ; as = arm_addressspace ( cs , attrs ) ; addr = S1_ptw_translate ( env , mmu_idx , addr , attrs , fi ) ; if ( fi -> s1ptw ) { return 0 ; } if ( regime_translation_big_endian ( env , mmu_idx ) ) { data = address_space_ldq_be ( as , addr , attrs , & result ) ; } else { data = address_space_ldq_le ( as , addr , attrs , & result ) ; } if ( result == MEMTX_OK ) { return data ; } fi -> type = ARMFault_SyncExternalOnWalk ; fi -> ea = arm_extabort_type ( result ) ; return 0 ; }
<S2SV_ModStart> * as ; uint64_t <S2SV_ModEnd> data ; attrs
3,546
CWE-000 local int unzCheckCurrentFileCoherencyHeader ( unz64_s * s , uint32_t * psize_variable , uint64_t * poffset_local_extrafield , uint16_t * psize_local_extrafield ) { uint32_t magic = 0 ; uint16_t value16 = 0 ; uint32_t value32 = 0 ; uint32_t flags = 0 ; ; uint16_t size_filename = 0 ; uint16_t size_extra_field = 0 ; uint16_t compression_method = 0 ; int err = UNZ_OK ; if ( psize_variable == NULL ) return UNZ_PARAMERROR ; * psize_variable = 0 ; if ( poffset_local_extrafield == NULL ) return UNZ_PARAMERROR ; * poffset_local_extrafield = 0 ; if ( psize_local_extrafield == NULL ) return UNZ_PARAMERROR ; * psize_local_extrafield = 0 ; err = unzGoToNextDisk ( ( unzFile ) s ) ; if ( err != UNZ_OK ) return err ; if ( ZSEEK64 ( s -> z_filefunc , s -> filestream , s -> cur_file_info_internal . offset_curfile + s -> cur_file_info_internal . byte_before_the_zipfile , ZLIB_FILEFUNC_SEEK_SET ) != 0 ) return UNZ_ERRNO ; if ( err == UNZ_OK ) { if ( unzReadUInt32 ( & s -> z_filefunc , s -> filestream , & magic ) != UNZ_OK ) err = UNZ_ERRNO ; else if ( magic != LOCALHEADERMAGIC ) err = UNZ_BADZIPFILE ; } if ( unzReadUInt16 ( & s -> z_filefunc , s -> filestream , & value16 ) != UNZ_OK ) err = UNZ_ERRNO ; if ( unzReadUInt16 ( & s -> z_filefunc , s -> filestream , & value16 ) != UNZ_OK ) err = UNZ_ERRNO ; flags = value16 ; if ( unzReadUInt16 ( & s -> z_filefunc , s -> filestream , & value16 ) != UNZ_OK ) err = UNZ_ERRNO ; <S2SV_StartBug> else if ( ( err == UNZ_OK ) && ( value32 != s -> cur_file_info . compression_method ) ) <S2SV_EndBug> err = UNZ_BADZIPFILE ; compression_method = s -> cur_file_info . compression_method ; # ifdef HAVE_AES if ( compression_method == AES_METHOD ) compression_method = s -> cur_file_info_internal . aes_compression_method ; # endif if ( ( err == UNZ_OK ) && ( compression_method != 0 ) && # ifdef HAVE_BZIP2 ( compression_method != Z_BZIP2ED ) && # endif ( compression_method != Z_DEFLATED ) ) err = UNZ_BADZIPFILE ; if ( unzReadUInt32 ( & s -> z_filefunc , s -> filestream , & value32 ) != UNZ_OK ) err = UNZ_ERRNO ; if ( unzReadUInt32 ( & s -> z_filefunc , s -> filestream , & value32 ) != UNZ_OK ) err = UNZ_ERRNO ; else if ( ( err == UNZ_OK ) && ( value32 != s -> cur_file_info . crc ) && ( ( flags & 8 ) == 0 ) ) err = UNZ_BADZIPFILE ; if ( unzReadUInt32 ( & s -> z_filefunc , s -> filestream , & value32 ) != UNZ_OK ) err = UNZ_ERRNO ; else if ( ( value32 != UINT32_MAX ) && ( err == UNZ_OK ) && ( value32 != s -> cur_file_info . compressed_size ) && ( ( flags & 8 ) == 0 ) ) err = UNZ_BADZIPFILE ; if ( unzReadUInt32 ( & s -> z_filefunc , s -> filestream , & value32 ) != UNZ_OK ) err = UNZ_ERRNO ; else if ( ( value32 != UINT32_MAX ) && ( err == UNZ_OK ) && ( value32 != s -> cur_file_info . uncompressed_size ) && ( ( flags & 8 ) == 0 ) ) err = UNZ_BADZIPFILE ; if ( unzReadUInt16 ( & s -> z_filefunc , s -> filestream , & size_filename ) != UNZ_OK ) err = UNZ_ERRNO ; else if ( ( err == UNZ_OK ) && ( size_filename != s -> cur_file_info . size_filename ) ) err = UNZ_BADZIPFILE ; * psize_variable += size_filename ; if ( unzReadUInt16 ( & s -> z_filefunc , s -> filestream , & size_extra_field ) != UNZ_OK ) err = UNZ_ERRNO ; * poffset_local_extrafield = s -> cur_file_info_internal . offset_curfile + SIZEZIPLOCALHEADER + size_filename ; * psize_local_extrafield = size_extra_field ; * psize_variable += size_extra_field ; return err ; }
<S2SV_ModStart> ) && ( value16 <S2SV_ModEnd> != s ->
3,547
CWE-000 static ServiceMetadata * GetPathogenomicsServiceMetadata ( Service * service_p ) { const char * term_url_s = CONTEXT_PREFIX_EDAM_ONTOLOGY_S "topic_0625" ; SchemaTerm * category_p = AllocateSchemaTerm ( term_url_s , "Genotype<S2SV_blank>and<S2SV_blank>phenotype" , "The<S2SV_blank>study<S2SV_blank>of<S2SV_blank>genetic<S2SV_blank>constitution<S2SV_blank>of<S2SV_blank>a<S2SV_blank>living<S2SV_blank>entity,<S2SV_blank>such<S2SV_blank>as<S2SV_blank>an<S2SV_blank>individual,<S2SV_blank>and<S2SV_blank>organism,<S2SV_blank>a<S2SV_blank>cell<S2SV_blank>and<S2SV_blank>so<S2SV_blank>on,<S2SV_blank>" "typically<S2SV_blank>with<S2SV_blank>respect<S2SV_blank>to<S2SV_blank>a<S2SV_blank>particular<S2SV_blank>observable<S2SV_blank>phenotypic<S2SV_blank>traits,<S2SV_blank>or<S2SV_blank>resources<S2SV_blank>concerning<S2SV_blank>such<S2SV_blank>traits,<S2SV_blank>which<S2SV_blank>" "might<S2SV_blank>be<S2SV_blank>an<S2SV_blank>aspect<S2SV_blank>of<S2SV_blank>biochemistry,<S2SV_blank>physiology,<S2SV_blank>morphology,<S2SV_blank>anatomy,<S2SV_blank>development<S2SV_blank>and<S2SV_blank>so<S2SV_blank>on." ) ; if ( category_p ) { SchemaTerm * subcategory_p ; term_url_s = CONTEXT_PREFIX_EDAM_ONTOLOGY_S "operation_0304" ; subcategory_p = AllocateSchemaTerm ( term_url_s , "Query<S2SV_blank>and<S2SV_blank>retrieval" , "Search<S2SV_blank>or<S2SV_blank>query<S2SV_blank>a<S2SV_blank>data<S2SV_blank>resource<S2SV_blank>and<S2SV_blank>retrieve<S2SV_blank>entries<S2SV_blank>and<S2SV_blank>/<S2SV_blank>or<S2SV_blank>annotation." ) ; if ( subcategory_p ) { ServiceMetadata * metadata_p = AllocateServiceMetadata ( category_p , subcategory_p ) ; if ( metadata_p ) { SchemaTerm * input_p ; term_url_s = CONTEXT_PREFIX_EDAM_ONTOLOGY_S "data_0968" ; input_p = AllocateSchemaTerm ( term_url_s , "Keyword" , "Boolean<S2SV_blank>operators<S2SV_blank>(AND,<S2SV_blank>OR<S2SV_blank>and<S2SV_blank>NOT)<S2SV_blank>and<S2SV_blank>wildcard<S2SV_blank>characters<S2SV_blank>may<S2SV_blank>be<S2SV_blank>allowed.<S2SV_blank>Keyword(s)<S2SV_blank>or<S2SV_blank>phrase(s)<S2SV_blank>used<S2SV_blank>(typically)<S2SV_blank>for<S2SV_blank>text-searching<S2SV_blank>purposes." ) ; if ( input_p ) { if ( AddSchemaTermToServiceMetadataInput ( metadata_p , input_p ) ) { SchemaTerm * output_p ; term_url_s = CONTEXT_PREFIX_SCHEMA_ORG_S "Place" ; output_p = AllocateSchemaTerm ( term_url_s , "Place" , "Entities<S2SV_blank>that<S2SV_blank>have<S2SV_blank>a<S2SV_blank>somewhat<S2SV_blank>fixed,<S2SV_blank>physical<S2SV_blank>extension." ) ; if ( output_p ) { if ( AddSchemaTermToServiceMetadataOutput ( metadata_p , output_p ) ) { term_url_s = CONTEXT_PREFIX_SCHEMA_ORG_S "Date" ; output_p = AllocateSchemaTerm ( term_url_s , "Date" , "A<S2SV_blank>date<S2SV_blank>value<S2SV_blank>in<S2SV_blank>ISO<S2SV_blank>8601<S2SV_blank>date<S2SV_blank>format." ) ; if ( output_p ) { if ( AddSchemaTermToServiceMetadataOutput ( metadata_p , output_p ) ) { term_url_s = CONTEXT_PREFIX_EXPERIMENTAL_FACTOR_ONTOLOGY_S "EFO_0000643" ; output_p = AllocateSchemaTerm ( term_url_s , "pathogen" , "A<S2SV_blank>biological<S2SV_blank>agent<S2SV_blank>that<S2SV_blank>causes<S2SV_blank>disease<S2SV_blank>or<S2SV_blank>illness<S2SV_blank>to<S2SV_blank>its<S2SV_blank>host." ) ; if ( output_p ) { if ( AddSchemaTermToServiceMetadataOutput ( metadata_p , output_p ) ) { term_url_s = CONTEXT_PREFIX_EXPERIMENTAL_FACTOR_ONTOLOGY_S "EFO_0000651" ; output_p = AllocateSchemaTerm ( term_url_s , "phenotype" , "The<S2SV_blank>observable<S2SV_blank>form<S2SV_blank>taken<S2SV_blank>by<S2SV_blank>some<S2SV_blank>character<S2SV_blank>(or<S2SV_blank>group<S2SV_blank>of<S2SV_blank>characters)<S2SV_blank>" "in<S2SV_blank>an<S2SV_blank>individual<S2SV_blank>or<S2SV_blank>an<S2SV_blank>organism,<S2SV_blank>excluding<S2SV_blank>pathology<S2SV_blank>and<S2SV_blank>disease.<S2SV_blank>The<S2SV_blank>detectable<S2SV_blank>outward<S2SV_blank>manifestations<S2SV_blank>of<S2SV_blank>a<S2SV_blank>specific<S2SV_blank>genotype." ) ; if ( output_p ) { if ( AddSchemaTermToServiceMetadataOutput ( metadata_p , output_p ) ) { term_url_s = CONTEXT_PREFIX_EXPERIMENTAL_FACTOR_ONTOLOGY_S "EFO_0000513" ; output_p = AllocateSchemaTerm ( term_url_s , "genotype" , "Information,<S2SV_blank>making<S2SV_blank>the<S2SV_blank>distinction<S2SV_blank>between<S2SV_blank>the<S2SV_blank>actual<S2SV_blank>physical<S2SV_blank>material<S2SV_blank>" "(e.g.<S2SV_blank>a<S2SV_blank>cell)<S2SV_blank>and<S2SV_blank>the<S2SV_blank>information<S2SV_blank>about<S2SV_blank>the<S2SV_blank>genetic<S2SV_blank>content<S2SV_blank>(genotype)." ) ; if ( output_p ) { if ( AddSchemaTermToServiceMetadataOutput ( metadata_p , output_p ) ) { return metadata_p ; } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( output_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( output_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( output_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( output_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( output_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>output<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>add<S2SV_blank>input<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; FreeSchemaTerm ( input_p ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>input<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } <S2SV_StartBug> } <S2SV_EndBug> else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>service<S2SV_blank>metadata" ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>sub-category<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } } else { PrintErrors ( STM_LEVEL_SEVERE , __FILE__ , __LINE__ , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>category<S2SV_blank>term<S2SV_blank>%s<S2SV_blank>for<S2SV_blank>service<S2SV_blank>metadata" , term_url_s ) ; } return NULL ; }
<S2SV_ModStart> ) ; } FreeServiceMetadata ( metadata_p ) ;
3,548
CWE-000 Bool HgfsServerStatFs ( const char * pathName , size_t pathLength , uint64 * freeBytes , uint64 * totalBytes ) { WiperPartition p ; unsigned char * wiperError ; ASSERT ( pathName ) ; ASSERT ( freeBytes ) ; ASSERT ( totalBytes ) ; Wiper_Init ( NULL ) ; if ( pathLength >= sizeof p . mountPoint ) { LOG ( 4 , ( "%s:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>get<S2SV_blank>the<S2SV_blank>volume<S2SV_blank>name\\n" , __FUNCTION__ ) ) ; return FALSE ; } Str_Strcpy ( p . mountPoint , pathName , sizeof p . mountPoint ) ; <S2SV_StartBug> wiperError = WiperSinglePartition_GetSpace ( & p , freeBytes , totalBytes ) ; <S2SV_EndBug> if ( strlen ( wiperError ) > 0 ) { LOG ( 4 , ( "%s:<S2SV_blank>error<S2SV_blank>using<S2SV_blank>wiper<S2SV_blank>lib:<S2SV_blank>%s\\n" , __FUNCTION__ , wiperError ) ) ; return FALSE ; } return TRUE ; }
<S2SV_ModStart> & p , NULL ,
3,549
CWE-000 static void resume_upcall ( PAL_PTR event , PAL_NUM arg , PAL_CONTEXT * context ) { if ( IS_INTERNAL_TID ( get_cur_tid ( ) ) ) goto ret_exception ; <S2SV_StartBug> shim_tcb_t * tcb = SHIM_GET_TLS ( ) ; <S2SV_EndBug> __disable_preempt ( tcb ) ; if ( ( tcb -> context . preempt & ~ SIGNAL_DELAYED ) > 1 ) { tcb -> context . preempt |= SIGNAL_DELAYED ; __enable_preempt ( tcb ) ; goto ret_exception ; } __handle_signal ( tcb , 0 , NULL ) ; __enable_preempt ( tcb ) ; ret_exception : DkExceptionReturn ( event ) ; }
<S2SV_ModStart> SHIM_GET_TLS ( ) ; if ( ! tcb || ! tcb -> tp ) return
3,550
CWE-000 static u64 opal_scom_unmangle ( u64 addr ) { <S2SV_StartBug> if ( addr & ( 0x1full << 59 ) ) <S2SV_EndBug> addr = ( addr & ~ ( 0xffull << 56 ) ) | ( 1ull << 63 ) ; return addr ; }
<S2SV_ModStart> addr ) { u64 tmp ; tmp = addr ; tmp &= 0x0f00000000000000 ; addr &= 0xf0ffffffffffffff ; addr |= tmp << 4 <S2SV_ModEnd> ; return addr
3,551
CWE-000 int main ( ) { RPiContext * RPi ; PC104Context * PC104 ; <S2SV_StartBug> RCErrorContext * errcont = malloc ( sizeof ( RCErrorContext ) ) ; <S2SV_EndBug> if ( rpi_init ( & RPi ) == RC_EINIT ) { rcerror ( errcont , RPi , RC_EXIT ) ; } if ( pc104_init ( & PC104 ) == RC_EINIT ) { <S2SV_StartBug> rcerror ( errcont , PC104 , RC_EXIT ) ; <S2SV_EndBug> } int status ; if ( ( status = open_i2c ( RPi , PC104 ) ) != RC_SUCCESS ) <S2SV_StartBug> { <S2SV_EndBug> rcerror ( errcont , RPi , RC_EXIT ) ; } while ( receive_from_slave_via_i2c ( PC104 ) == RC_SUCCESS ) { printf ( "Data<S2SV_blank>read:<S2SV_blank>%lu\\n" , PC104 -> distance_from_IR_sensor ) ; } close ( RPi -> i2c_bus_descriptor ) ; <S2SV_StartBug> free ( errcont ) ; <S2SV_EndBug> rpi_destruct ( RPi ) ; pc104_destruct ( PC104 ) ; <S2SV_StartBug> rcerror ( errcont , PC104 , RC_CONT ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> RCErrorContext * errcont ; if ( error_context_init ( & errcont ) == RC_EINIT ) { rcerror ( errcont , NULL , RC_EXIT ) ; } <S2SV_ModEnd> if ( rpi_init <S2SV_ModStart> RC_EINIT ) { rpi_destruct ( RPi ) ; <S2SV_ModStart> RC_SUCCESS ) { pc104_destruct ( PC104 ) ; <S2SV_ModStart> i2c_bus_descriptor ) ; <S2SV_ModEnd> rpi_destruct ( RPi <S2SV_ModStart> PC104 ) ; error_context_destruct ( errcont <S2SV_ModEnd> ) ; return
3,552
CWE-000 static bool dpdk_init__ ( const struct smap * ovs_other_config ) { char * * argv = NULL , * * argv_to_release = NULL ; int result ; int argc , argc_tmp ; bool auto_determine = true ; int err = 0 ; cpu_set_t cpuset ; char * sock_dir_subcomponent ; log_stream = fopencookie ( NULL , "w+" , dpdk_log_func ) ; if ( log_stream == NULL ) { VLOG_ERR ( "Can\'t<S2SV_blank>redirect<S2SV_blank>DPDK<S2SV_blank>log:<S2SV_blank>%s." , ovs_strerror ( errno ) ) ; } else { setbuf ( log_stream , NULL ) ; rte_openlog_stream ( log_stream ) ; } if ( process_vhost_flags ( "vhost-sock-dir" , ovs_rundir ( ) , NAME_MAX , ovs_other_config , & sock_dir_subcomponent ) ) { struct stat s ; if ( ! strstr ( sock_dir_subcomponent , ".." ) ) { vhost_sock_dir = xasprintf ( "%s/%s" , ovs_rundir ( ) , sock_dir_subcomponent ) ; err = stat ( vhost_sock_dir , & s ) ; if ( err ) { VLOG_ERR ( "vhost-user<S2SV_blank>sock<S2SV_blank>directory<S2SV_blank>\'%s\'<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist." , vhost_sock_dir ) ; } } else { vhost_sock_dir = xstrdup ( ovs_rundir ( ) ) ; VLOG_ERR ( "vhost-user<S2SV_blank>sock<S2SV_blank>directory<S2SV_blank>request<S2SV_blank>\'%s/%s\'<S2SV_blank>has<S2SV_blank>invalid" "characters<S2SV_blank>\'..\'<S2SV_blank>-<S2SV_blank>using<S2SV_blank>%s<S2SV_blank>instead." , ovs_rundir ( ) , sock_dir_subcomponent , ovs_rundir ( ) ) ; } free ( sock_dir_subcomponent ) ; } else { vhost_sock_dir = sock_dir_subcomponent ; } vhost_iommu_enabled = smap_get_bool ( ovs_other_config , "vhost-iommu-support" , false ) ; VLOG_INFO ( "IOMMU<S2SV_blank>support<S2SV_blank>for<S2SV_blank>vhost-user-client<S2SV_blank>%s." , vhost_iommu_enabled ? "enabled" : "disabled" ) ; <S2SV_StartBug> argv = grow_argv ( & argv , 0 , 1 ) ; <S2SV_EndBug> argc = 1 ; argv [ 0 ] = xstrdup ( ovs_get_program_name ( ) ) ; argc_tmp = get_dpdk_args ( ovs_other_config , & argv , argc ) ; while ( argc_tmp != argc ) { if ( ! strcmp ( "-c" , argv [ argc ] ) || ! strcmp ( "-l" , argv [ argc ] ) ) { auto_determine = false ; break ; } argc ++ ; } argc = argc_tmp ; if ( auto_determine ) { int i ; CPU_ZERO ( & cpuset ) ; err = pthread_getaffinity_np ( pthread_self ( ) , sizeof ( cpu_set_t ) , & cpuset ) ; if ( ! err ) { for ( i = 0 ; i < CPU_SETSIZE ; i ++ ) { if ( CPU_ISSET ( i , & cpuset ) ) { argv = grow_argv ( & argv , argc , 2 ) ; argv [ argc ++ ] = xstrdup ( "-c" ) ; argv [ argc ++ ] = xasprintf ( "0x%08llX" , ( 1ULL << i ) ) ; i = CPU_SETSIZE ; } } } else { VLOG_ERR ( "Thread<S2SV_blank>getaffinity<S2SV_blank>error<S2SV_blank>%d.<S2SV_blank>Using<S2SV_blank>core<S2SV_blank>0x1" , err ) ; argv = grow_argv ( & argv , argc , 2 ) ; argv [ argc ++ ] = xstrdup ( "-c" ) ; argv [ argc ++ ] = xasprintf ( "0x%X" , 1 ) ; } } argv = grow_argv ( & argv , argc , 1 ) ; argv [ argc ] = NULL ; optind = 1 ; if ( VLOG_IS_INFO_ENABLED ( ) ) { struct ds eal_args ; int opt ; ds_init ( & eal_args ) ; ds_put_cstr ( & eal_args , "EAL<S2SV_blank>ARGS:" ) ; for ( opt = 0 ; opt < argc ; ++ opt ) { ds_put_cstr ( & eal_args , "<S2SV_blank>" ) ; ds_put_cstr ( & eal_args , argv [ opt ] ) ; } VLOG_INFO ( "%s" , ds_cstr_ro ( & eal_args ) ) ; ds_destroy ( & eal_args ) ; } argv_to_release = grow_argv ( & argv_to_release , 0 , argc ) ; for ( argc_tmp = 0 ; argc_tmp < argc ; ++ argc_tmp ) { argv_to_release [ argc_tmp ] = argv [ argc_tmp ] ; } result = rte_eal_init ( argc , argv ) ; argv_release ( argv , argv_to_release , argc ) ; if ( auto_determine && ! err ) { err = pthread_setaffinity_np ( pthread_self ( ) , sizeof ( cpu_set_t ) , & cpuset ) ; if ( err ) { VLOG_ERR ( "Thread<S2SV_blank>setaffinity<S2SV_blank>error<S2SV_blank>%d" , err ) ; } } if ( result < 0 ) { VLOG_EMER ( "Unable<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>DPDK:<S2SV_blank>%s" , ovs_strerror ( rte_errno ) ) ; return false ; } rte_memzone_dump ( stdout ) ; RTE_PER_LCORE ( _lcore_id ) = NON_PMD_CORE_ID ; # ifdef DPDK_PDUMP VLOG_INFO ( "DPDK<S2SV_blank>pdump<S2SV_blank>packet<S2SV_blank>capture<S2SV_blank>enabled" ) ; err = rte_pdump_init ( ovs_rundir ( ) ) ; if ( err ) { VLOG_INFO ( "Error<S2SV_blank>initialising<S2SV_blank>DPDK<S2SV_blank>pdump" ) ; rte_pdump_uninit ( ) ; } else { char * server_socket_path ; server_socket_path = xasprintf ( "%s/%s" , ovs_rundir ( ) , "pdump_server_socket" ) ; fatal_signal_add_file_to_unlink ( server_socket_path ) ; free ( server_socket_path ) ; } # endif netdev_dpdk_register ( ) ; return true ; }
<S2SV_ModStart> "disabled" ) ; per_port_memory = smap_get_bool ( ovs_other_config , "per-port-memory" , false ) ; VLOG_INFO ( "Per<S2SV_blank>port<S2SV_blank>mempool<S2SV_blank>for<S2SV_blank>DPDK<S2SV_blank>devices<S2SV_blank>%s." , per_port_memory ? "enabled" : "disabled" ) ;
3,553
CWE-000 char * getContentType ( char * mybuf ) { printf ( "%ld\\n" , strlen ( mybuf ) ) ; int dot_pos = strcspn ( mybuf , "." ) ; printf ( "%d\\n" , dot_pos ) ; printf ( "%s\\n" , & mybuf [ dot_pos ] ) ; <S2SV_StartBug> char content_type [ 16 ] ; <S2SV_EndBug> strcpy ( content_type , & mybuf [ dot_pos ] ) ; printf ( "GOT<S2SV_blank>CONTENT<S2SV_blank>TYPE:<S2SV_blank>%s\\n" , content_type ) ; if ( strcmp ( content_type , ".html" ) == 0 ) { return "text/html" ; } else if ( strcmp ( content_type , ".jpg" ) == 0 ) { return "image/jpeg" ; } else if ( strcmp ( content_type , ".gif" ) == 0 ) { return "image/gif" ; } <S2SV_StartBug> else { <S2SV_EndBug> return "text/plain" ; } }
<S2SV_ModStart> [ 16 ] ; strcpy ( content_type , "\\0" ) <S2SV_ModStart> ; } else if ( strcmp ( content_type , ".cache" ) == 0 ) { printCache ( ) ; return "C" ; } else
3,554
CWE-000 static int _HandleIncomingClient ( Listener_t * listenerInstance ) { struct sockaddr_in clientInfo ; ServingData_t * sd ; pthread_t servingThread ; SOCKET s = listenerInstance -> s , c ; socklen_t addrlen ; addrlen = sizeof ( clientInfo ) ; c = accept ( s , ( struct sockaddr * ) & clientInfo , & addrlen ) ; if ( c != INVALID_SOCKET ) { sd = ( ServingData_t * ) Mmalloc ( sizeof ( * sd ) ) ; sd -> clientSocket = c ; <S2SV_StartBug> memcpy ( & ( sd -> clientInfo ) , & clientInfo , sizeof ( clientInfo ) ) ; <S2SV_EndBug> if ( ! pthread_create ( & servingThread , NULL , _ServingThreadEntry , sd ) ) { if ( pthread_detach ( servingThread ) ) { abort ( ) ; return 1 ; } } else { Mfree ( sd ) ; return 1 ; } } return 0 ; }
<S2SV_ModStart> = c ; sd -> server = listenerInstance -> server ;
3,555
CWE-000 char * mrk_basename ( const char * a_path ) { char * basename = NULL ; int path_len = strlen ( a_path ) ; char error_message [ 1024 ] ; int is_not_found = 1 ; size_t idx = - 1 ; size_t i = - 1 ; for ( i = path_len - 1 ; i >= 0 && idx < 0 ; -- i ) { if ( a_path [ i ] == '/' || a_path [ i ] == '\\\\' ) { idx = i ; } } if ( idx >= 0 && idx < path_len - 1 ) { ++ idx ; basename = ( char * ) malloc ( strlen ( & a_path [ idx ] ) + 1 ) ; if ( basename == NULL ) { sprintf ( error_message , "SX_BAD_ALLOC:<S2SV_blank>In<S2SV_blank>mrk_basename(),<S2SV_blank>malloc()<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>pointer<S2SV_blank>basename.\\n" , strlen ( & a_path [ idx ] ) + 1 ) ; perror ( error_message ) ; } strcpy ( basename , & a_path [ idx ] ) ; } else if ( idx < 0 ) { basename = ( char * ) malloc ( strlen ( a_path ) + 1 ) ; if ( basename == NULL ) { sprintf ( error_message , "SX_BAD_ALLOC:<S2SV_blank>In<S2SV_blank>mrk_basename(),<S2SV_blank>malloc()<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>pointer<S2SV_blank>basename.\\n" , strlen ( a_path ) + 1 ) ; perror ( error_message ) ; } strcpy ( basename , a_path ) ; } else { basename = ( char * ) malloc ( 1 ) ; if ( basename == NULL ) { sprintf ( error_message , "SX_BAD_ALLOC:<S2SV_blank>In<S2SV_blank>mrk_basename(),<S2SV_blank>malloc()<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>pointer<S2SV_blank>basename.\\n" , 1 ) ; perror ( error_message ) ; } <S2SV_StartBug> basename [ 0 ] = '\\0' <S2SV_EndBug> } return basename ; }
<S2SV_ModStart> ] = '\\0' ;
3,556
CWE-000 <S2SV_StartBug> double fux3 ( int tA , int tB , int tC , int tD , int tE ) { <S2SV_EndBug> return 0.2 * ( ( 4 - 2 * COS144 - 2 * COS72 ) * ( tA - ( 1 - tA ) ) + ( ( - 1 + 3 * COS144 - 2 * COS72 ) * ( ( tB - ( 1 - tB ) ) + ( tE - ( 1 - tE ) ) ) ) + ( ( - 1 - 2 * COS144 + 3 * COS72 ) * ( ( tC - ( 1 - tC ) ) + ( tD - ( 1 - tD ) ) ) ) ) ; }
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> inline
3,557
CWE-000 <S2SV_StartBug> void * _oph_sleep ( void * data ) <S2SV_EndBug> { # if defined ( _POSIX_THREADS ) || defined ( _SC_THREADS ) pthread_detach ( pthread_self ( ) ) ; # endif <S2SV_StartBug> UNUSED ( data ) ; <S2SV_EndBug> sleep ( 1 ) ; <S2SV_StartBug> pthread_mutex_lock ( & global_flag ) ; <S2SV_EndBug> pthread_cond_broadcast ( & waiting_flag ) ; pthread_mutex_unlock ( & global_flag ) ; return NULL ; }
<S2SV_ModStart> * _oph_sleep ( char * * response <S2SV_ModEnd> ) { # <S2SV_ModStart> ; # endif if ( ! response ) return NULL <S2SV_ModEnd> ; sleep ( <S2SV_ModStart> ( & global_flag ) ; * response = strdup ( OPH_DEFAULT_REPLY ) ; if ( ! * response ) pmesg_safe ( & global_flag , LOG_ERROR , __FILE__ , __LINE__ , "Memory<S2SV_blank>error\\n"
3,558
CWE-000 static struct ra_param_s * <S2SV_StartBug> ra_param_from_xml ( xmlNode * param_xml , struct ra_metadata_s * md ) <S2SV_EndBug> { const char * param_name = crm_element_value ( param_xml , "name" ) ; const char * value ; struct ra_param_s * p ; p = calloc ( 1 , sizeof ( struct ra_param_s ) ) ; if ( p == NULL ) { crm_crit ( "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>resource<S2SV_blank>metadata" ) ; return NULL ; } p -> rap_name = strdup ( param_name ) ; if ( p -> rap_name == NULL ) { crm_crit ( "Could<S2SV_blank>not<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>resource<S2SV_blank>metadata" ) ; free ( p ) ; return NULL ; } value = crm_element_value ( param_xml , "unique" ) ; <S2SV_StartBug> if ( ! crm_is_true ( value ) ) { <S2SV_EndBug> <S2SV_StartBug> set_bit ( p -> rap_flags , ra_param_reloadable ) ; <S2SV_EndBug> } value = crm_element_value ( param_xml , "private" ) ; if ( crm_is_true ( value ) ) { set_bit ( p -> rap_flags , ra_param_private ) ; <S2SV_StartBug> set_bit ( md -> ra_flags , ra_uses_private ) ; <S2SV_EndBug> } return p ; }
<S2SV_ModStart> xmlNode * param_xml <S2SV_ModEnd> ) { const <S2SV_ModStart> ; if ( <S2SV_ModEnd> crm_is_true ( value <S2SV_ModStart> -> rap_flags , ra_param_unique <S2SV_ModEnd> ) ; } <S2SV_ModStart> ra_param_private ) ; <S2SV_ModEnd> } return p
3,559
CWE-000 int common_timer_set ( struct k_itimer * timr , int flags , struct itimerspec64 * new_setting , struct itimerspec64 * old_setting ) { const struct k_clock * kc = timr -> kclock ; bool sigev_none ; ktime_t expires ; if ( old_setting ) common_timer_get ( timr , old_setting ) ; timr -> it_interval = 0 ; if ( kc -> timer_try_to_cancel ( timr ) < 0 ) return TIMER_RETRY ; timr -> it_active = 0 ; timr -> it_requeue_pending = ( timr -> it_requeue_pending + 2 ) & ~ REQUEUE_PENDING ; timr -> it_overrun_last = 0 ; if ( ! new_setting -> it_value . tv_sec && ! new_setting -> it_value . tv_nsec ) return 0 ; timr -> it_interval = timespec64_to_ktime ( new_setting -> it_interval ) ; expires = timespec64_to_ktime ( new_setting -> it_value ) ; <S2SV_StartBug> sigev_none = ( timr -> it_sigev_notify & ~ SIGEV_THREAD_ID ) == SIGEV_NONE ; <S2SV_EndBug> kc -> timer_arm ( timr , expires , flags & TIMER_ABSTIME , sigev_none ) ; timr -> it_active = ! sigev_none ; return 0 ; }
<S2SV_ModStart> ; sigev_none = <S2SV_ModEnd> timr -> it_sigev_notify <S2SV_ModStart> timr -> it_sigev_notify <S2SV_ModEnd> == SIGEV_NONE ;
3,560
CWE-000 static int selinux_socket_sock_rcv_skb ( struct sock * sk , struct sk_buff * skb ) { int err ; struct sk_security_struct * sksec = sk -> sk_security ; u16 family = sk -> sk_family ; u32 sk_sid = sksec -> sid ; struct common_audit_data ad ; struct lsm_network_audit net = { 0 , } ; char * addrp ; u8 secmark_active ; u8 peerlbl_active ; if ( family != PF_INET && family != PF_INET6 ) return 0 ; if ( family == PF_INET6 && skb -> protocol == htons ( ETH_P_IP ) ) family = PF_INET ; if ( ! selinux_policycap_netpeer ) return selinux_sock_rcv_skb_compat ( sk , skb , family ) ; secmark_active = selinux_secmark_enabled ( ) ; peerlbl_active = netlbl_enabled ( ) || selinux_xfrm_enabled ( ) ; if ( ! secmark_active && ! peerlbl_active ) return 0 ; ad . type = LSM_AUDIT_DATA_NET ; ad . u . net = & net ; ad . u . net -> netif = skb -> skb_iif ; ad . u . net -> family = family ; err = selinux_parse_skb ( skb , & ad , & addrp , 1 , NULL ) ; if ( err ) return err ; if ( peerlbl_active ) { u32 peer_sid ; err = selinux_skb_peerlbl_sid ( skb , family , & peer_sid ) ; if ( err ) return err ; err = selinux_inet_sys_rcv_skb ( skb -> skb_iif , addrp , family , peer_sid , & ad ) ; if ( err ) { selinux_netlbl_err ( skb , err , 0 ) ; return err ; } err = avc_has_perm ( sk_sid , peer_sid , SECCLASS_PEER , PEER__RECV , & ad ) ; <S2SV_StartBug> if ( err ) <S2SV_EndBug> selinux_netlbl_err ( skb , err , 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( secmark_active ) { err = avc_has_perm ( sk_sid , skb -> secmark , SECCLASS_PACKET , PACKET__RECV , & ad ) ; if ( err ) return err ; } return err ; }
<S2SV_ModStart> ( err ) { <S2SV_ModStart> 0 ) ; return err ; }
3,561
CWE-000 Algorithm * AlgorithmLoad ( Algorithm * algorithm , FILE * stream ) { if ( ! algorithm ) { algorithm = ( Algorithm * ) malloc ( sizeof ( Algorithm ) ) ; <S2SV_StartBug> } <S2SV_EndBug> Cube * state = & algorithm -> state ; CubeLoad ( state , stream ) ; algorithm -> mask = CubeMask ( state ) ; algorithm -> corner_cycles = CubeCornerCycles ( state ) ; algorithm -> edge_cycles = CubeEdgeCycles ( state ) ; size_t size ; fread ( & size , sizeof ( size_t ) , 1 , stream ) ; algorithm -> size = size ; algorithm -> capacity = size ; algorithm -> formula_list = ( Formula * ) realloc ( algorithm -> formula_list , size * sizeof ( Formula ) ) ; <S2SV_StartBug> for ( size_t i = 0 ; i < algorithm -> size ; ++ i ) { <S2SV_EndBug> FormulaLoad ( & algorithm -> formula_list [ i ] , stream ) ; } return algorithm ; }
<S2SV_ModStart> ) ) ; algorithm -> formula_list = NULL ; <S2SV_ModStart> i ) { algorithm -> formula_list [ i ] . move = NULL ;
3,562
CWE-000 void add_topic ( HashTable * ht , <S2SV_StartBug> char * topic , <S2SV_EndBug> int fd , pthread_rwlock_t * ht_lock ) { struct list_entry * entry = ( struct list_entry * ) malloc ( sizeof ( struct list_entry ) ) ; entry -> fd = fd ; entry -> topic = ( char * ) malloc ( sizeof ( strlen ( topic ) ) ) ; memcpy ( entry -> topic , topic , 128 ) ; struct hash_node * node = NULL ; pthread_rwlock_rdlock ( ht_lock ) ; hash_find ( ht , topic , & node ) ; pthread_rwlock_unlock ( ht_lock ) ; if ( node == NULL ) { node = ( struct hash_node * ) malloc ( sizeof ( struct hash_node ) ) ; TGAP_RWLIST_HEAD_INIT ( & ( node -> fd_list_head ) ) ; TGAP_RWLIST_WRLOCK ( & ( node -> fd_list_head ) ) ; TGAP_LIST_INSERT_TAIL ( & ( node -> fd_list_head ) , entry , field ) ; TGAP_RWLIST_UNLOCK ( & ( node -> fd_list_head ) ) ; pthread_rwlock_wrlock ( ht_lock ) ; hash_add ( ht , topic , node ) ; pthread_rwlock_unlock ( ht_lock ) ; } else { TGAP_RWLIST_WRLOCK ( & ( node -> fd_list_head ) ) ; TGAP_LIST_INSERT_TAIL ( & ( node -> fd_list_head ) , entry , field ) ; TGAP_RWLIST_UNLOCK ( & ( node -> fd_list_head ) ) ; } }
<S2SV_ModStart> * ht , uint8_t <S2SV_ModEnd> * topic ,
3,563
CWE-000 static void draw_last_health_change ( void ) { char str [ 20 ] ; static const Uint32 timeoutms = 2 * 60 * 1000 ; static const int yoff = ( int ) ( - ( SMALL_FONT_Y_LEN + 5 ) ) ; if ( my_last_health . d != 0 ) { <S2SV_StartBug> if ( abs ( SDL_GetTicks ( ) - my_last_health . dt ) > timeoutms ) <S2SV_EndBug> my_last_health . d = 0 ; else { safe_snprintf ( str , sizeof ( str ) , "<S2SV_blank>%d<S2SV_blank>" , my_last_health . d ) ; show_help_coloured ( str , health_bar_start_x + stats_bar_len / 2 - strlen ( str ) * SMALL_FONT_X_LEN , yoff , 1.0f , 0.0f , 0.0f ) ; } } if ( my_last_health . h != 0 ) { <S2SV_StartBug> if ( abs ( SDL_GetTicks ( ) - my_last_health . ht ) > timeoutms ) <S2SV_EndBug> my_last_health . h = 0 ; else { safe_snprintf ( str , sizeof ( str ) , "<S2SV_blank>%d<S2SV_blank>" , my_last_health . h ) ; show_help_coloured ( str , health_bar_start_x + stats_bar_len / 2 , yoff , 0.0f , 1.0f , 0.0f ) ; } } }
<S2SV_ModStart> { if ( <S2SV_ModEnd> ( SDL_GetTicks ( <S2SV_ModStart> { if ( <S2SV_ModEnd> ( SDL_GetTicks (
3,564
CWE-000 int test_exe ( struct bfd_link_info * info ) { if ( bfd_link_executable ( info ) ) result ++ ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> result ++ ; return 0 ;
3,565
CWE-000 static int menu_select ( struct cpuidle_driver * drv , struct cpuidle_device * dev ) { struct menu_device * data = this_cpu_ptr ( & menu_devices ) ; int latency_req = pm_qos_request ( PM_QOS_CPU_DMA_LATENCY ) ; int i ; unsigned int interactivity_req ; unsigned long nr_iowaiters , cpu_load ; if ( data -> needs_update ) { menu_update ( drv , dev ) ; data -> needs_update = 0 ; } <S2SV_StartBug> data -> last_state_idx = CPUIDLE_DRIVER_STATE_START - 1 ; <S2SV_EndBug> if ( unlikely ( latency_req == 0 ) ) return 0 ; data -> next_timer_us = ktime_to_us ( tick_nohz_get_sleep_length ( ) ) ; get_iowait_load ( & nr_iowaiters , & cpu_load ) ; data -> bucket = which_bucket ( data -> next_timer_us , nr_iowaiters ) ; data -> predicted_us = DIV_ROUND_CLOSEST_ULL ( ( uint64_t ) data -> next_timer_us * data -> correction_factor [ data -> bucket ] , RESOLUTION * DECAY ) ; get_typical_interval ( data ) ; interactivity_req = data -> predicted_us / performance_multiplier ( nr_iowaiters , cpu_load ) ; if ( latency_req > interactivity_req ) latency_req = interactivity_req ; <S2SV_StartBug> if ( interactivity_req > 20 && <S2SV_EndBug> ! drv -> states [ CPUIDLE_DRIVER_STATE_START ] . disabled && dev -> states_usage [ CPUIDLE_DRIVER_STATE_START ] . disable == 0 ) data -> last_state_idx = CPUIDLE_DRIVER_STATE_START ; <S2SV_StartBug> for ( i = CPUIDLE_DRIVER_STATE_START ; i < drv -> state_count ; i ++ ) { <S2SV_EndBug> struct cpuidle_state * s = & drv -> states [ i ] ; struct cpuidle_state_usage * su = & dev -> states_usage [ i ] ; if ( s -> disabled || su -> disable ) continue ; if ( s -> target_residency > data -> predicted_us ) continue ; if ( s -> exit_latency > latency_req ) continue ; data -> last_state_idx = i ; } return data -> last_state_idx ; }
<S2SV_ModStart> 0 ; } <S2SV_ModEnd> if ( unlikely <S2SV_ModStart> ; if ( CPUIDLE_DRIVER_STATE_START > 0 ) { data -> last_state_idx = CPUIDLE_DRIVER_STATE_START - 1 ; if ( <S2SV_ModStart> = CPUIDLE_DRIVER_STATE_START ; } else { data -> last_state_idx = CPUIDLE_DRIVER_STATE_START ; }
3,566
CWE-000 static void dump_inode_blk ( struct f2fs_sb_info * sbi , u32 nid , struct f2fs_node * node_blk ) { u32 i = 0 ; u64 ofs = 0 ; if ( ( node_blk -> i . i_inline & F2FS_INLINE_DATA ) ) { DBG ( 3 , "ino[0x%x]<S2SV_blank>has<S2SV_blank>inline<S2SV_blank>data!\\n" , nid ) ; dev_write_dump ( ( ( unsigned char * ) node_blk ) + INLINE_DATA_OFFSET , 0 , MAX_INLINE_DATA ) ; return ; } for ( i = 0 ; i < ADDRS_PER_INODE ( & node_blk -> i ) ; i ++ , ofs ++ ) <S2SV_StartBug> dump_data_blk ( ofs * F2FS_BLKSIZE , <S2SV_EndBug> le32_to_cpu ( node_blk -> i . i_addr [ i ] ) ) ; for ( i = 0 ; i < 5 ; i ++ ) { if ( i == 0 || i == 1 ) dump_node_blk ( sbi , TYPE_DIRECT_NODE , node_blk -> i . i_nid [ i ] , & ofs ) ; else if ( i == 2 || i == 3 ) dump_node_blk ( sbi , TYPE_INDIRECT_NODE , node_blk -> i . i_nid [ i ] , & ofs ) ; else if ( i == 4 ) dump_node_blk ( sbi , TYPE_DOUBLE_INDIRECT_NODE , node_blk -> i . i_nid [ i ] , & ofs ) ; else ASSERT ( 0 ) ; } }
<S2SV_ModStart> ) dump_data_blk ( sbi ,
3,567
CWE-000 void adc_sample ( void ) { ret_code_t ret_code ; uint32_t p_is_running = 0 ; ret_code = nrf_drv_adc_buffer_convert ( adc_buffer , ADC_BUFFER_SIZE ) ; APP_ERROR_CHECK ( ret_code ) ; sd_clock_hfclk_request ( ) ; while ( ! p_is_running ) { sd_clock_hfclk_is_running ( ( & p_is_running ) ) ; } for ( uint32_t i = 0 ; i < ADC_BUFFER_SIZE ; i ++ ) { while ( ( NRF_ADC -> BUSY & ADC_BUSY_BUSY_Msk ) == ADC_BUSY_BUSY_Busy ) { } <S2SV_StartBug> printf ( "Start<S2SV_blank>sampling<S2SV_blank>...<S2SV_blank>\\r\\n" ) ; <S2SV_EndBug> nrf_drv_adc_sample ( ) ; } }
<S2SV_ModStart> ) { } NRF_LOG_INFO <S2SV_ModEnd> ( "Start<S2SV_blank>sampling<S2SV_blank>...<S2SV_blank>\\r\\n" )
3,568
CWE-000 static void parse_line ( Line * l , char * buffer ) { <S2SV_StartBug> l -> line_state = 0 ; <S2SV_EndBug> l -> arg_buf_size = 3 ; l -> argv = salloc ( sizeof ( char * ) * l -> arg_buf_size ) ; l -> argc = 0 ; register char * c ; for ( c = buffer ; * c != '\\0' ; c ++ ) { switch ( * c ) { case '\\n' : case '\\t' : case '<S2SV_blank>' : case ',' : if ( c != buffer ) { if ( ! ( l -> line_state & MNEMONIC_STATE ) ) { if ( * c == ',' ) { die ( "Error<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%ld.<S2SV_blank>Unexpected<S2SV_blank>\',\'<S2SV_blank>character\\n" , line_num ) ; } l -> mnemonic = buffer ; l -> line_state |= MNEMONIC_STATE ; } else { if ( l -> argc == l -> arg_buf_size ) { l -> arg_buf_size += 2 ; srealloc ( l -> argv , sizeof ( char * ) * l -> arg_buf_size ) ; } l -> argv [ l -> argc ++ ] = buffer ; } * c = '\\0' ; buffer = c ; } buffer ++ ; break ; case ':' : if ( l -> line_state & MNEMONIC_STATE ) { die ( "Error<S2SV_blank>on<S2SV_blank>line<S2SV_blank>%ld.<S2SV_blank>Label<S2SV_blank>must<S2SV_blank>occur<S2SV_blank>at<S2SV_blank>the<S2SV_blank>beginning<S2SV_blank>of<S2SV_blank>a<S2SV_blank>line.\\n" , line_num ) ; } l -> label = buffer ; * c = '\\0' ; buffer = c ; buffer ++ ; l -> line_state |= LABEL_STATE ; break ; case ';' : return ; } } }
<S2SV_ModStart> buffer ) { <S2SV_ModEnd> register char *
3,569
CWE-000 static NTSTATUS get_trust_credentials ( struct winbindd_domain * domain , TALLOC_CTX * mem_ctx , bool netlogon , struct cli_credentials * * _creds ) { const struct winbindd_domain * creds_domain = NULL ; struct cli_credentials * creds ; NTSTATUS status ; bool force_machine_account = false ; <S2SV_StartBug> bool ok ; <S2SV_EndBug> if ( ! domain -> active_directory ) { if ( ! netlogon ) { force_machine_account = true ; } } if ( IS_DC && ! force_machine_account ) { creds_domain = domain ; } else { creds_domain = find_our_domain ( ) ; if ( creds_domain == NULL ) { return NT_STATUS_INVALID_SERVER_STATE ; } } status = pdb_get_trust_credentials ( creds_domain -> name , creds_domain -> alt_name , mem_ctx , & creds ) ; if ( ! NT_STATUS_IS_OK ( status ) ) { goto ipc_fallback ; } if ( domain -> primary && lp_security ( ) == SEC_ADS ) { cli_credentials_set_kerberos_state ( creds , CRED_AUTO_USE_KERBEROS ) ; } else if ( domain -> active_directory ) { cli_credentials_set_kerberos_state ( creds , CRED_MUST_USE_KERBEROS ) ; } else { cli_credentials_set_kerberos_state ( creds , CRED_DONT_USE_KERBEROS ) ; } <S2SV_StartBug> ok = winbindd_can_contact_domain ( domain ) ; <S2SV_EndBug> if ( ! ok ) { cli_credentials_set_secure_channel_type ( creds , SEC_CHAN_NULL ) ; } * _creds = creds ; return NT_STATUS_OK ; ipc_fallback : if ( netlogon ) { return NT_STATUS_CANT_ACCESS_DOMAIN_INFO ; } status = cm_get_ipc_credentials ( mem_ctx , & creds ) ; if ( ! NT_STATUS_IS_OK ( status ) ) { return status ; } * _creds = creds ; return NT_STATUS_OK ; }
<S2SV_ModStart> = false ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> ) ; } if ( creds_domain != domain <S2SV_ModEnd> ) { cli_credentials_set_secure_channel_type
3,570
CWE-000 int Iic_transfer ( iic_priv_s * iic_priv , const uint8_t * send , unsigned send_len , uint8_t * recv , unsigned recv_len , unsigned regaddrflag ) { XIicPs * InstancePtr = iic_priv -> iicbus ; u8 dev = iic_priv -> devaddr ; u8 reg = iic_priv -> regaddr ; u8 buf [ 32 ] ; u32 clk = iic_priv -> frequency ; u32 actclk = XIicPs_GetSClk ( InstancePtr ) ; portBASE_TYPE xHigherPriorityTaskWoken ; xHigherPriorityTaskWoken = pdFALSE ; int Status = - 1 ; <S2SV_StartBug> xSemaphoreTake ( iic_priv -> iic_mutex , portMAX_DELAY ) ; <S2SV_EndBug> if ( clk == 100000 ) { if ( actclk > 300000 ) { Status = XIicPs_SetSClk ( InstancePtr , clk ) ; if ( Status == XST_SUCCESS ) { xSemaphoreGive ( iic_priv -> iic_mutex ) ; return XST_FAILURE ; } } } else if ( clk == 400000 ) { if ( actclk < 100000 ) { Status = XIicPs_SetSClk ( InstancePtr , clk ) ; if ( Status == XST_SUCCESS ) { xSemaphoreGive ( iic_priv -> iic_mutex ) ; return XST_FAILURE ; } } } if ( send_len > 0 ) { Xil_AssertNonvoid ( send != NULL ) ; if ( regaddrflag == 1 ) { buf [ 0 ] = reg ; memcpy ( & buf [ 1 ] , send , send_len ) ; XIicPs_MasterSendPolled ( InstancePtr , buf , send_len + 1 , dev ) ; } else XIicPs_MasterSendPolled ( InstancePtr , ( u8 * ) send , send_len , dev ) ; } if ( recv_len > 0 ) { Xil_AssertNonvoid ( recv != NULL ) ; if ( regaddrflag == 1 ) { XIicPs_MasterSendPolled ( InstancePtr , & reg , 1 , dev ) ; XIicPs_MasterRecvPolled ( InstancePtr , recv , recv_len , dev ) ; } else XIicPs_MasterRecvPolled ( InstancePtr , recv , recv_len , dev ) ; } xSemaphoreGive ( iic_priv -> iic_mutex ) ; return XST_SUCCESS ; }
<S2SV_ModStart> - 1 ; if ( ( sizeof ( buf ) < send_len + 1 ) && ( regaddrflag == 1 ) ) { Print_Err ( "iic<S2SV_blank>send<S2SV_blank>buf<S2SV_blank>too<S2SV_blank>long:%d\\n" , send_len ) ; return XST_FAILURE ; }
3,571
CWE-000 int main ( ) { int errors = 0 ; DynaTree ctree ; <S2SV_StartBug> DynaStatus status = dtree_create ( ( DynaTree * ) & ctree , 6 , sizeof ( uint8_t ) ) ; <S2SV_EndBug> errors += status ? 1 : 0 ; DynaTree itree ; <S2SV_StartBug> status = dtree_create ( ( DynaTree * ) & itree , 16 , sizeof ( int ) ) ; <S2SV_EndBug> errors += status ? 1 : 0 ; DynaNode croot = dtree_root ( ) ; uint8_t c = 0 ; status = dtree_add ( ctree , croot , & c ) ; errors += status ? 1 : 0 ; c = 1 ; DynaNode cl = dtree_left ( croot ) ; status = dtree_add ( ctree , cl , & c ) ; errors += status ? 1 : 0 ; c = 2 ; DynaNode cr = dtree_right ( croot ) ; status = dtree_add ( ctree , cr , & c ) ; errors += status ? 1 : 0 ; c = 3 ; DynaNode cll = dtree_left ( cl ) ; status = dtree_add ( ctree , cll , & c ) ; errors += status ? 1 : 0 ; c = 4 ; DynaNode clr = dtree_right ( cl ) ; status = dtree_add ( ctree , clr , & c ) ; errors += status ? 1 : 0 ; c = 5 ; DynaNode crl = dtree_left ( cr ) ; status = dtree_add ( ctree , crl , & c ) ; errors += status ? 1 : 0 ; c = 6 ; DynaNode crr = dtree_right ( cr ) ; status = dtree_add ( ctree , crr , & c ) ; errors += status ? 1 : 0 ; errors += ( dtree_nodes ( ctree ) != 7 ) ; errors += ( ! checkTree ( ctree , dtree_root ( ) , 0 , 3 ) ? 1 : 0 ) ; errors += fillTree ( itree , dtree_root ( ) , 0 ) ; errors += ( dtree_nodes ( itree ) != 31 ) ; checkTree ( itree , dtree_root ( ) , 0 , 5 ) ; dtree_free ( ctree ) ; dtree_free ( itree ) ; return errors ; }
<S2SV_ModStart> = dtree_create ( & ctree , NULL , 6 , sizeof ( uint8_t ) ) ; errors += status ? 1 : 0 ; DynaTree <S2SV_ModEnd> itree ; status <S2SV_ModStart> = dtree_create ( & itree , NULL <S2SV_ModEnd> , 16 ,
3,572
CWE-000 static InterCodes * translateCond ( TreeNode * p , Operand * labeltrue , <S2SV_StartBug> Operand * labelfalse ) { <S2SV_EndBug> Assert ( isSyntax ( p , Exp ) ) ; getChilds ( p ) ; if ( isSyntax ( childs [ 1 ] , NOT ) ) { return translateCond ( childs [ 2 ] , labelfalse , labeltrue ) ; } else if ( isSyntax ( childs [ 2 ] , RELOP ) ) { Operand * op1 = newTempOperand ( ) ; Operand * op2 = newTempOperand ( ) ; InterCodes * irs = translateExp ( childs [ 1 ] , op1 ) ; InterCodes * irs2 = translateExp ( childs [ 3 ] , op2 ) ; interCodesBind ( irs , irs2 ) ; InterCode * ir = newInterCode3 ( GOTO_WITH_COND , labeltrue , op1 , op2 ) ; ir -> relop = childs [ 2 ] -> text ; interCodeInsert ( irs , ir ) ; return interCodeInsert ( irs , newInterCode1 ( GOTO , labelfalse ) ) ; } else if ( isSyntax ( childs [ 2 ] , AND ) ) { Operand * label = newLabelOperand ( ) ; InterCodes * irs = translateCond ( childs [ 1 ] , label , labelfalse ) ; interCodeInsert ( irs , newInterCode1 ( DEF_LABEL , label ) ) ; return interCodesBind ( irs , translateCond ( childs [ 3 ] , labeltrue , labelfalse ) ) ; } else if ( isSyntax ( childs [ 2 ] , OR ) ) { Operand * label = newLabelOperand ( ) ; InterCodes * irs = translateCond ( childs [ 1 ] , labeltrue , label ) ; interCodeInsert ( irs , newInterCode1 ( DEF_LABEL , label ) ) ; return interCodesBind ( irs , translateCond ( childs [ 3 ] , labeltrue , labelfalse ) ) ; } else { Operand * op = newTempOperand ( ) ; InterCodes * irs = translateExp ( p , op ) ; InterCode * ir = newInterCode3 ( GOTO_WITH_COND , labeltrue , op , CONST_ZERO ) ; ir -> relop = "!=" ; interCodeInsert ( irs , ir ) ; ir = newInterCode1 ( GOTO , labelfalse ) ; return interCodeInsert ( irs , ir ) ; } }
<S2SV_ModStart> labelfalse ) { if ( ! isSyntax ( p , Exp ) ) printf ( "%s<S2SV_blank>%d\\n" , p -> name , p -> token ) ;
3,573
CWE-000 void getListDataInfo ( char * thePath , DYNV_VectorGenericDataType * directoryInfo ) { int i ; int fileAndFoldersCount = 0 ; ftpListDataType data ; FILE_GetDirectoryInodeList ( thePath , & data . fileList , & fileAndFoldersCount , 0 ) ; <S2SV_StartBug> for ( i = 0 ; i < fileAndFoldersCount ; i ++ ) <S2SV_EndBug> { data . owner = NULL ; data . groupOwner = NULL ; data . inodePermissionString = NULL ; data . fileNameWithPath = NULL ; data . finalStringPath = NULL ; data . linkPath = NULL ; data . numberOfSubDirectories = 1 ; data . isFile = 0 ; data . isDirectory = 0 ; <S2SV_StartBug> if ( FILE_IsDirectory ( data . fileList [ i ] ) == 1 ) <S2SV_EndBug> { <S2SV_StartBug> data . isDirectory = 1 ; <S2SV_EndBug> data . isFile = 0 ; data . isLink = 0 ; data . fileSize = 4096 ; } else if ( FILE_IsFile ( data . fileList [ i ] ) == 1 ) { <S2SV_StartBug> data . isDirectory = 0 ; <S2SV_EndBug> data . isFile = 1 ; data . isLink = 0 ; data . fileSize = FILE_GetFileSizeFromPath ( data . fileList [ i ] ) ; } if ( data . isDirectory == 0 && data . isFile == 0 ) { <S2SV_StartBug> continue ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> data . owner = FILE_GetOwner ( data . fileList [ i ] ) ; data . groupOwner = FILE_GetGroupOwner ( data . fileList [ i ] ) ; data . fileNameWithPath = data . fileList [ i ] ; data . fileNameNoPath = FILE_GetFilenameFromPath ( data . fileList [ i ] ) ; data . inodePermissionString = FILE_GetListPermissionsString ( data . fileList [ i ] ) ; data . lastModifiedData = FILE_GetLastModifiedData ( data . fileList [ i ] ) ; if ( strlen ( data . fileNameNoPath ) > 0 ) { data . finalStringPath = ( char * ) malloc ( strlen ( data . fileNameNoPath ) + 1 ) ; strcpy ( data . finalStringPath , data . fileNameNoPath ) ; } if ( data . inodePermissionString != NULL && strlen ( data . inodePermissionString ) > 0 && data . inodePermissionString [ 0 ] == 'l' ) { int len = 0 ; data . isLink = 1 ; data . linkPath = ( char * ) malloc ( CLIENT_COMMAND_STRING_SIZE * sizeof ( char ) ) ; if ( ( len = readlink ( data . fileList [ i ] , data . linkPath , CLIENT_COMMAND_STRING_SIZE ) ) > 0 ) { data . linkPath [ len ] = 0 ; FILE_AppendToString ( & data . finalStringPath , "<S2SV_blank>-><S2SV_blank>" ) ; FILE_AppendToString ( & data . finalStringPath , data . linkPath ) ; } } memset ( data . lastModifiedDataString , 0 , LIST_DATA_TYPE_MODIFIED_DATA_STR_SIZE ) ; strftime ( data . lastModifiedDataString , 80 , "%b<S2SV_blank>%d<S2SV_blank>%Y" , localtime ( & data . lastModifiedData ) ) ; directoryInfo -> PushBack ( directoryInfo , & data , sizeof ( ftpListDataType ) ) ; } }
<S2SV_ModStart> 0 ) ; printf ( "\\nNUMBER<S2SV_blank>OF<S2SV_blank>FILES:<S2SV_blank>%d" , fileAndFoldersCount ) ; fflush ( 0 ) ; <S2SV_ModStart> = 0 ; printf ( "\\nPROCESSING:<S2SV_blank>%s" , data . fileList [ i ] ) ; fflush ( 0 ) ; <S2SV_ModStart> 1 ) { printf ( "\\nis<S2SV_blank>file" ) ; fflush ( 0 ) ; <S2SV_ModStart> 1 ) { printf ( "\\nis<S2SV_blank>file" ) ; fflush ( 0 ) ; <S2SV_ModStart> 0 ) { printf ( "\\nNot<S2SV_blank>a<S2SV_blank>directory,<S2SV_blank>not<S2SV_blank>a<S2SV_blank>file,<S2SV_blank>broken<S2SV_blank>link" ) ; <S2SV_ModStart> continue ; } printf ( "\\nFILE<S2SV_blank>SIZE<S2SV_blank>:<S2SV_blank>%lld" , data . fileSize ) ;
3,574
CWE-000 static int _resize_resv ( slurmctld_resv_t * resv_ptr , uint32_t node_cnt ) { bitstr_t * tmp1_bitmap = NULL , * tmp2_bitmap = NULL ; bitstr_t * core_bitmap = NULL ; int delta_node_cnt , i ; resv_desc_msg_t resv_desc ; delta_node_cnt = resv_ptr -> node_cnt - node_cnt ; if ( delta_node_cnt == 0 ) return SLURM_SUCCESS ; if ( delta_node_cnt > 0 ) { if ( bit_overlap ( resv_ptr -> node_bitmap , idle_node_bitmap ) ) { tmp1_bitmap = bit_copy ( resv_ptr -> node_bitmap ) ; bit_and ( tmp1_bitmap , idle_node_bitmap ) ; i = bit_set_count ( tmp1_bitmap ) ; if ( i > delta_node_cnt ) { tmp2_bitmap = bit_pick_cnt ( tmp1_bitmap , delta_node_cnt ) ; bit_not ( tmp2_bitmap ) ; bit_and ( resv_ptr -> node_bitmap , tmp2_bitmap ) ; FREE_NULL_BITMAP ( tmp1_bitmap ) ; FREE_NULL_BITMAP ( tmp2_bitmap ) ; delta_node_cnt = 0 ; } else if ( i ) { bit_not ( idle_node_bitmap ) ; bit_and ( resv_ptr -> node_bitmap , idle_node_bitmap ) ; bit_not ( idle_node_bitmap ) ; resv_ptr -> node_cnt = bit_set_count ( resv_ptr -> node_bitmap ) ; delta_node_cnt = resv_ptr -> node_cnt - node_cnt ; } FREE_NULL_BITMAP ( tmp1_bitmap ) ; } if ( delta_node_cnt > 0 ) { tmp1_bitmap = bit_pick_cnt ( resv_ptr -> node_bitmap , node_cnt ) ; FREE_NULL_BITMAP ( resv_ptr -> node_bitmap ) ; resv_ptr -> node_bitmap = tmp1_bitmap ; } xfree ( resv_ptr -> node_list ) ; resv_ptr -> node_list = bitmap2node_name ( resv_ptr -> node_bitmap ) ; resv_ptr -> node_cnt = node_cnt ; return SLURM_SUCCESS ; } memset ( & resv_desc , 0 , sizeof ( resv_desc_msg_t ) ) ; resv_desc . start_time = resv_ptr -> start_time ; resv_desc . end_time = resv_ptr -> end_time ; resv_desc . features = resv_ptr -> features ; resv_desc . flags = resv_ptr -> flags ; resv_desc . node_cnt = xmalloc ( sizeof ( uint32_t ) * 2 ) ; resv_desc . node_cnt [ 0 ] = 0 - delta_node_cnt ; <S2SV_StartBug> i = _select_nodes ( & resv_desc , & resv_ptr -> part_ptr , & tmp1_bitmap , <S2SV_EndBug> & core_bitmap ) ; xfree ( resv_desc . node_cnt ) ; xfree ( resv_desc . node_list ) ; xfree ( resv_desc . partition ) ; if ( i == SLURM_SUCCESS ) { bit_or ( resv_ptr -> node_bitmap , tmp1_bitmap ) ; FREE_NULL_BITMAP ( tmp1_bitmap ) ; FREE_NULL_BITMAP ( resv_ptr -> core_bitmap ) ; resv_ptr -> core_bitmap = core_bitmap ; free_job_resources ( & resv_ptr -> core_resrcs ) ; xfree ( resv_ptr -> node_list ) ; resv_ptr -> node_list = bitmap2node_name ( resv_ptr -> node_bitmap ) ; resv_ptr -> node_cnt = node_cnt ; } return i ; }
<S2SV_ModStart> - delta_node_cnt ; tmp1_bitmap = bit_copy ( resv_ptr -> part_ptr -> node_bitmap ) ; bit_and_not ( tmp1_bitmap , resv_ptr -> node_bitmap ) ;
3,575
CWE-000 static int wiimod_rumble_probe ( const struct wiimod_ops * ops , struct wiimote_data * wdata ) <S2SV_StartBug> { <S2SV_EndBug> set_bit ( FF_RUMBLE , wdata -> input -> ffbit ) ; if ( input_ff_create_memless ( wdata -> input , NULL , wiimod_rumble_play ) ) return - ENOMEM ; return 0 ; }
<S2SV_ModStart> wdata ) { INIT_WORK ( & wdata -> rumble_worker , wiimod_rumble_worker ) ;
3,576
CWE-000 uint32_t istgt_iovec_crc32c ( const struct iovec * iovp , int iovc , uint32_t offset , uint32_t len ) { const uint8_t * p ; uint32_t total ; uint32_t pos ; uint32_t n ; uint32_t crc32c ; int i ; pos = 0 ; total = 0 ; crc32c = istgt_crc32c_initial ; for ( i = 0 ; i < iovc ; i ++ ) { if ( len == 0 ) break ; if ( pos + iovp [ i ] . iov_len > offset ) { p = ( const uint8_t * ) iovp [ i ] . iov_base + ( offset - pos ) ; if ( iovp [ i ] . iov_len > len ) { n = len ; len = 0 ; } else { n = iovp [ i ] . iov_len ; len -= n ; } crc32c = istgt_update_crc32c ( p , n , crc32c ) ; offset += n ; total += n ; } pos += iovp [ i ] . iov_len ; } # if 0 printf ( "update<S2SV_blank>%d<S2SV_blank>bytes\\n" , total ) ; # endif crc32c = istgt_fixup_crc32c ( total , crc32c ) ; crc32c = crc32c ^ istgt_crc32c_xor ; <S2SV_StartBug> return crc32c ; <S2SV_EndBug> }
<S2SV_ModStart> istgt_crc32c_xor ; return ( crc32c ) <S2SV_ModEnd> ; } <S2SV_null>
3,577
CWE-000 int configure_blocks ( struct block * blocks , int num_blocks , const char * blocks_dir ) { <S2SV_StartBug> for ( int i = 0 ; i < num_blocks ; ++ i ) <S2SV_EndBug> { <S2SV_StartBug> configure_block ( & blocks [ i ] , blocks_dir ) ; <S2SV_EndBug> } }
<S2SV_ModStart> blocks_dir ) { int num_blocks_configured = 0 ; <S2SV_ModStart> i ) { num_blocks_configured += ( <S2SV_ModStart> , blocks_dir ) == 0 ) ? 1 : 0 ; } return num_blocks_configured ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
3,578
CWE-000 static void j2c_integer_info_set_property ( GObject * object , guint property_id , const GValue * value , GParamSpec * pspec ) { J2cIntegerInfo * self = J2C_INTEGER_INFO ( object ) ; switch ( property_id ) { case PROP_VALUE : <S2SV_StartBug> self -> value = ( gint32 ) g_value_get_int64 ( value ) ; <S2SV_EndBug> break ; default : G_OBJECT_WARN_INVALID_PROPERTY_ID ( object , property_id , pspec ) ; break ; } }
<S2SV_ModStart> ( gint32 ) g_value_get_int <S2SV_ModEnd> ( value )
3,579
CWE-000 static void stackframe_to_zval ( zval * return_value , stackdriver_debugger_stackframe_t * stackframe ) { int i ; array_init ( return_value ) ; if ( stackframe -> function ) { <S2SV_StartBug> add_assoc_str ( return_value , "function" , stackframe -> function ) ; <S2SV_EndBug> } <S2SV_StartBug> add_assoc_str ( return_value , "filename" , stackframe -> filename ) ; <S2SV_EndBug> add_assoc_long ( return_value , "line" , stackframe -> lineno ) ; zval locals ; array_init ( & locals ) ; stackdriver_debugger_variable_t * local_variable ; ZEND_HASH_FOREACH_PTR ( stackframe -> locals , local_variable ) { zval local ; variable_to_zval ( & local , local_variable ) ; add_next_index_zval ( & locals , & local ) ; } ZEND_HASH_FOREACH_END ( ) ; add_assoc_zval ( return_value , "locals" , & locals ) ; }
<S2SV_ModStart> , "function" , zend_string_dup ( <S2SV_ModStart> stackframe -> function , 0 ) <S2SV_ModStart> , "filename" , zend_string_copy ( <S2SV_ModStart> stackframe -> filename )
3,580
CWE-000 void create_plot_info_new ( struct dive * dive , struct divecomputer * dc , struct plot_info * pi , bool fast , struct deco_state * planner_ds ) { int o2 , he , o2max ; # ifndef SUBSURFACE_MOBILE struct deco_state plot_deco_state ; <S2SV_StartBug> init_decompression ( & plot_deco_state , dive ) ; <S2SV_EndBug> # endif free ( ( void * ) last_pi_entry_new ) ; get_dive_gas ( dive , & o2 , & he , & o2max ) ; if ( dc -> divemode == FREEDIVE ) { pi -> dive_type = FREEDIVE ; } else if ( he > 0 ) { pi -> dive_type = TRIMIX ; } else { if ( o2 ) pi -> dive_type = NITROX ; else pi -> dive_type = AIR ; } last_pi_entry_new = populate_plot_entries ( dive , dc , pi ) ; check_setpoint_events ( dive , dc , pi ) ; setup_gas_sensor_pressure ( dive , dc , pi ) ; if ( ! fast ) { for ( int cyl = 0 ; cyl < MAX_CYLINDERS ; cyl ++ ) populate_pressure_information ( dive , dc , pi , cyl ) ; } fill_o2_values ( dive , dc , pi ) ; calculate_sac ( dive , dc , pi ) ; # ifndef SUBSURFACE_MOBILE calculate_deco_information ( & plot_deco_state , planner_ds , dive , dc , pi , false ) ; # endif calculate_gas_information_new ( dive , dc , pi ) ; # ifdef DEBUG_GAS debug_print_profiledata ( pi ) ; # endif pi -> meandepth = dive -> dc . meandepth . mm ; analyze_plot_info ( pi ) ; }
<S2SV_ModStart> , dive ) ; # else ( void ) planner_ds
3,581
CWE-000 static void ForwardIndex_HandleToken ( ForwardIndex * idx , const char * tok , size_t tokLen , uint32_t pos , float fieldScore , t_fieldId fieldId , int isStem , <S2SV_StartBug> int shouldCopy ) { <S2SV_EndBug> ForwardIndexEntry * h = NULL ; int isNew = 0 ; uint32_t hash = hashKey ( tok , tokLen ) ; khIdxEntry * kh = makeEntry ( idx , tok , tokLen , hash , & isNew ) ; h = & kh -> ent ; if ( isNew ) { h -> fieldMask = 0 ; h -> hash = hash ; h -> next = NULL ; if ( shouldCopy ) { h -> term = copyTempString ( idx , tok , tokLen ) ; } else { h -> term = tok ; } h -> len = tokLen ; h -> freq = 0 ; if ( hasOffsets ( idx ) ) { h -> vw = mempool_get ( idx -> vvwPool ) ; VVW_Reset ( h -> vw ) ; } else { h -> vw = NULL ; } <S2SV_StartBug> } else { <S2SV_EndBug> } h -> fieldMask |= ( ( t_fieldMask ) 1 ) << fieldId ; float score = ( float ) fieldScore ; if ( isStem ) { score *= STEM_TOKEN_FACTOR ; } h -> freq += MAX ( 1 , ( uint32_t ) score ) ; idx -> maxFreq = MAX ( h -> freq , idx -> maxFreq ) ; idx -> totalFreq += h -> freq ; if ( h -> vw ) { VVW_Write ( h -> vw , pos ) ; } }
<S2SV_ModStart> , int shouldCopy , bool addToTermsTrie <S2SV_ModStart> NULL ; } h -> addToTermsTrie = addToTermsTrie ;
3,582
CWE-000 int MPI_Intercomm_merge ( MPI_Comm intercomm , int high , MPI_Comm * newintracomm ) { int mpi_errno = MPI_SUCCESS ; if ( intercomm == MPI_COMM_WORLD ) intercomm = CSP_COMM_USER_WORLD ; CSP_CALLMPI ( JUMP , PMPI_Intercomm_merge ( intercomm , high , newintracomm ) ) ; <S2SV_StartBug> mpi_errno = CSPU_comm_errhan_inherit ( intercomm , * newintracomm ) ; <S2SV_EndBug> CSP_CHKMPIFAIL_JUMP ( mpi_errno ) ; <S2SV_StartBug> fn_exit : <S2SV_EndBug> return mpi_errno ; fn_fail : goto fn_exit ; }
<S2SV_ModStart> ) ) ; if ( ( * newintracomm ) != MPI_COMM_NULL ) { <S2SV_ModStart> mpi_errno ) ; }
3,583
CWE-000 void gen_call ( char * sname ) { output_with_tab ( "call<S2SV_blank>" ) ; <S2SV_StartBug> output_string ( sname ) ; <S2SV_EndBug> newline ( ) ; }
<S2SV_ModStart> "call<S2SV_blank>" ) ; output_label_name <S2SV_ModEnd> ( sname )
3,584
CWE-000 <S2SV_StartBug> int ce_adventurer ( struct gameState * state , int * drawntreasure , int currentPlayer , int * z , int * temphand ) { <S2SV_EndBug> int cardDrawn ; while ( * drawntreasure < 2 ) { if ( state -> deckCount [ currentPlayer ] < 1 ) { shuffle ( currentPlayer , state ) ; } drawCard ( currentPlayer , state ) ; cardDrawn = state -> hand [ currentPlayer ] [ state -> handCount [ currentPlayer ] - 1 ] ; if ( cardDrawn == copper || cardDrawn == silver || cardDrawn == gold ) ( * drawntreasure ) ++ ; else { temphand [ * z ] = cardDrawn ; state -> handCount [ currentPlayer ] -- ; ( * z ) ++ ; } } while ( * z - 1 >= 0 ) { state -> discard [ currentPlayer ] [ state -> discardCount [ currentPlayer ] ++ ] = temphand [ * z - 1 ] ; * z = * z - 1 ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
<S2SV_ModStart> int * temphand , int handPos <S2SV_ModStart> 1 ; } discardCard ( handPos , currentPlayer , state , 0 ) ;
3,585
CWE-000 void gic_set_pri_per_cpu ( void ) { int i ; for ( i = 0 ; i < 32 ; i += 4 ) { <S2SV_StartBug> * ( ( volatile unsigned int * ) ( ( void __iomem * ) GICD_BASE + <S2SV_EndBug> GIC_DIST_PRI + ( i / 4 ) * 4 ) ) = 0x80808080 ; } <S2SV_StartBug> * ( ( volatile unsigned int * ) ( ( void __iomem * ) GICC_BASE + <S2SV_EndBug> GIC_CPU_PRIMASK ) ) = 0xf0 ; }
<S2SV_ModStart> ) ( ( u32 ) gic_d . gicd_base <S2SV_ModEnd> + GIC_DIST_PRI + <S2SV_ModStart> ) ( ( u32 ) gic_d . gicc_base <S2SV_ModEnd> + GIC_CPU_PRIMASK )
3,586
CWE-000 static int f2fs_mkdir ( struct inode * dir , struct dentry * dentry , umode_t mode ) { struct f2fs_sb_info * sbi = F2FS_I_SB ( dir ) ; struct inode * inode ; int err ; dquot_initialize ( dir ) ; inode = f2fs_new_inode ( dir , S_IFDIR | mode ) ; if ( IS_ERR ( inode ) ) return PTR_ERR ( inode ) ; inode -> i_op = & f2fs_dir_inode_operations ; inode -> i_fop = & f2fs_dir_operations ; inode -> i_mapping -> a_ops = & f2fs_dblock_aops ; <S2SV_StartBug> mapping_set_gfp_mask ( inode -> i_mapping , GFP_F2FS_HIGH_ZERO ) ; <S2SV_EndBug> set_inode_flag ( inode , FI_INC_LINK ) ; f2fs_lock_op ( sbi ) ; err = f2fs_add_link ( dentry , inode ) ; if ( err ) goto out_fail ; f2fs_unlock_op ( sbi ) ; alloc_nid_done ( sbi , inode -> i_ino ) ; d_instantiate ( dentry , inode ) ; unlock_new_inode ( inode ) ; if ( IS_DIRSYNC ( dir ) ) f2fs_sync_fs ( sbi -> sb , 1 ) ; f2fs_balance_fs ( sbi , true ) ; return 0 ; out_fail : clear_inode_flag ( inode , FI_INC_LINK ) ; handle_failed_inode ( inode ) ; return err ; }
<S2SV_ModStart> & f2fs_dblock_aops ; inode_nohighmem ( inode <S2SV_ModEnd> ) ; set_inode_flag
3,587
CWE-000 void runSelfTests ( ) { debug_log ( "Running<S2SV_blank>self-tests.\\r\\n" ) ; nrf_gpio_pin_write ( GREEN_LED , LED_ON ) ; nrf_gpio_pin_write ( RED_LED , LED_ON ) ; nrf_delay_ms ( LED_BLINK_MS ) ; nrf_gpio_pin_write ( GREEN_LED , LED_OFF ) ; nrf_gpio_pin_write ( RED_LED , LED_OFF ) ; nrf_delay_ms ( LED_BLINK_MS ) ; debug_log ( "Testing<S2SV_blank>internal<S2SV_blank>flash\\r\\n" ) ; nrf_gpio_pin_write ( GREEN_LED , LED_ON ) ; <S2SV_StartBug> if ( storer_test ( ) ) <S2SV_EndBug> { debug_log ( "<S2SV_blank><S2SV_blank>Success\\r\\n" ) ; } else { debug_log ( "<S2SV_blank><S2SV_blank>Failed\\r\\n" ) ; while ( 1 ) { } ; } nrf_delay_ms ( LED_BLINK_MS ) ; nrf_gpio_pin_write ( GREEN_LED , LED_OFF ) ; nrf_delay_ms ( LED_BLINK_MS ) ; debug_log ( "Testing<S2SV_blank>external<S2SV_blank>flash\\r\\n" ) ; nrf_gpio_pin_write ( GREEN_LED , LED_ON ) ; if ( testExternalEEPROM ( ) ) { debug_log ( "<S2SV_blank><S2SV_blank>Success\\r\\n" ) ; } else { debug_log ( "<S2SV_blank><S2SV_blank>Failed\\r\\n" ) ; while ( 1 ) { } ; } nrf_delay_ms ( LED_BLINK_MS ) ; nrf_gpio_pin_write ( GREEN_LED , LED_OFF ) ; nrf_delay_ms ( LED_BLINK_MS ) ; debug_log ( "Push<S2SV_blank>button<S2SV_blank>to<S2SV_blank>test<S2SV_blank>button<S2SV_blank>and<S2SV_blank>mic.\\r\\n" ) ; while ( nrf_gpio_pin_read ( BUTTON_1 ) != 0 ) ; testMicInit ( MIC_ZERO ) ; while ( 1 ) { testMicAddSample ( ) ; if ( testMicAboveThreshold ( ) ) { nrf_gpio_pin_write ( RED_LED , LED_ON ) ; nrf_delay_ms ( 100 ) ; } else { nrf_gpio_pin_write ( RED_LED , LED_OFF ) ; } if ( nrf_gpio_pin_read ( BUTTON_1 ) == 0 ) { nrf_gpio_pin_write ( GREEN_LED , LED_ON ) ; } else { nrf_gpio_pin_write ( GREEN_LED , LED_OFF ) ; } nrf_delay_ms ( 10 ) ; } while ( 1 ) { } ; }
<S2SV_ModStart> LED_ON ) ; debug_log ( "...<S2SV_blank>Skipping<S2SV_blank>test\\r\\n" ) ; <S2SV_ModEnd> nrf_delay_ms ( LED_BLINK_MS
3,588
CWE-000 void * myallocate ( size_t size , char * file , size_t line , unsigned int requester ) { if ( size == 0 || size > 4096 - sizeof ( struct MemEntry ) - sizeof ( struct Page ) ) { fprintf ( stderr , "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>this<S2SV_blank>many<S2SV_blank>bytes<S2SV_blank>in<S2SV_blank>FILE:<S2SV_blank>\'%s\'<S2SV_blank>on<S2SV_blank>LINE:<S2SV_blank>%zu\\n" , file , line ) ; return 0 ; } int i = 0 ; for ( ; i < MEMSIZE - ( 4 * 4096 ) ; i += 4096 ) { struct Page * pageptr = ( struct Page * ) ( memblock + i ) ; if ( pageptr -> ownerTread == requester || pageptr -> isfree ) { if ( pageptr -> freeSpace >= size ) { struct MemEntry * memptr = ( struct MemEntry * ) ( memblock + i + sizeof ( struct Page ) ) ; for ( ; memptr != NULL ; memptr = memptr -> next ) { if ( memptr -> isfree && memptr -> size >= size ) { if ( pageptr -> isfree ) { pageptr -> ownerTread = requester ; pageptr -> isfree = 0 ; } pageptr -> freeSpace -= size ; if ( pageptr -> freeSpace < sizeof ( struct MemEntry ) ) { memptr -> next = NULL ; } else if ( memptr -> next != NULL ) { size_t freeSize = memptr -> size - size ; if ( freeSize <= sizeof ( struct MemEntry ) ) { pageptr -> freeSpace -= freeSize ; } else { struct MemEntry * memptr_next = memptr -> next ; memptr -> next = ( struct MemEntry * ) ( ( char * ) memptr + sizeof ( struct MemEntry ) + size ) ; memptr -> next -> isfree = 1 ; memptr -> next -> size = memptr -> size - size - sizeof ( struct MemEntry ) ; memptr -> next -> prev = memptr ; memptr -> next -> next = memptr_next ; memptr_next -> prev = memptr -> next ; pageptr -> freeSpace -= sizeof ( struct MemEntry ) ; } } else { memptr -> next = ( struct MemEntry * ) ( ( char * ) memptr + sizeof ( struct MemEntry ) + size ) ; uintptr_t nextpageadr = ( uintptr_t ) ( pageptr + 4096 ) ; uintptr_t nextmemptr = ( uintptr_t ) ( memptr -> next + sizeof ( struct MemEntry ) ) ; uintptr_t diff = nextpageadr - nextmemptr ; memptr -> next -> isfree = 1 ; pageptr -> freeSpace -= sizeof ( struct MemEntry ) ; memptr -> next -> size = ( unsigned int ) diff ; memptr -> next -> prev = memptr ; memptr -> next -> next = NULL ; } memptr -> size = size ; memptr -> isfree = 0 ; return ( char * ) memptr + sizeof ( struct MemEntry ) ; } } } } } FILE * fp ; fp = fopen ( SWAP_FILE , "w" ) ; char copymemblock [ 16384 ] ; ( char * ) memcpy ( & copymemblock , & memblock , 16384 ) ; fwrite ( copymemblock , 16384 , sizeof ( char ) , fp ) ; struct Page * temp ; struct MemEntry * firstEntry ; <S2SV_StartBug> for ( int i = 0 ; i < 16384 ; i += 4096 ) { <S2SV_EndBug> temp = ( struct Page * ) ( memblock + i ) ; temp -> isfree = 1 ; temp -> freeSpace = 4096 - sizeof ( struct Page ) - sizeof ( struct MemEntry ) ; temp -> ownerTread = 0 ; firstEntry = ( struct MemEntry * ) ( memblock + i + sizeof ( struct Page ) ) ; firstEntry -> isfree = 1 ; firstEntry -> size = temp -> freeSpace ; firstEntry -> next = NULL ; firstEntry -> prev = NULL ; } return malloc ( size ) ; }
<S2SV_ModStart> ; for ( <S2SV_ModEnd> i = 0
3,589
CWE-000 static void R_ParticleGeometryVerts ( const r_particle_t * p , r_geometry_particle_interleave_vertex_t * verts ) { verts -> scale = p -> scale ; VectorCopy ( p -> org , verts -> start ) ; verts -> type = p -> type ; verts -> roll = p -> roll ; <S2SV_StartBug> if ( p -> type == PARTICLE_BEAM || p -> type == PARTICLE_SPARK ) { <S2SV_EndBug> VectorCopy ( p -> end , verts -> end ) ; } }
<S2SV_ModStart> type == PARTICLE_SPARK || p -> type == PARTICLE_WIRE
3,590
CWE-000 dart_ret_t dart_get_blocking ( void * dest , dart_gptr_t gptr , size_t nelem , dart_datatype_t dtype ) { MPI_Win win ; MPI_Datatype mpi_dtype = dart_mpi_datatype ( dtype ) ; dart_team_unit_t team_unit_id = DART_TEAM_UNIT_ID ( gptr . unitid ) ; uint64_t offset = gptr . addr_or_offs . offset ; int16_t seg_id = gptr . segid ; if ( nelem > INT_MAX ) { DART_LOG_ERROR ( "dart_get_blocking<S2SV_blank>!<S2SV_blank>failed:<S2SV_blank>nelem<S2SV_blank>><S2SV_blank>INT_MAX" ) ; return DART_ERR_INVAL ; } dart_team_data_t * team_data = dart_adapt_teamlist_get ( gptr . teamid ) ; if ( team_data == NULL ) { DART_LOG_ERROR ( "dart_get_blocking<S2SV_blank>!<S2SV_blank>failed:<S2SV_blank>Unknown<S2SV_blank>team<S2SV_blank>%i!" , gptr . teamid ) ; return DART_ERR_INVAL ; } DART_LOG_DEBUG ( "dart_get_blocking()<S2SV_blank>uid:%d<S2SV_blank>" "o:%" PRIu64 "<S2SV_blank>s:%d<S2SV_blank>t:%u,<S2SV_blank>nelem:%zu" , team_unit_id . id , offset , seg_id , gptr . teamid , nelem ) ; # if ! defined ( DART_MPI_DISABLE_SHARED_WINDOWS ) DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank>shared<S2SV_blank>windows<S2SV_blank>enabled" ) ; if ( seg_id >= 0 && team_data -> sharedmem_tab [ gptr . unitid ] . id >= 0 ) { return get_shared_mem ( team_data , dest , gptr , nelem , dtype ) ; } # else DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank>shared<S2SV_blank>windows<S2SV_blank>disabled" ) ; # endif if ( seg_id ) { MPI_Aint disp_s ; if ( dart_segment_get_disp ( & team_data -> segdata , seg_id , team_unit_id , & disp_s ) != DART_OK ) { DART_LOG_ERROR ( "dart_get_blocking<S2SV_blank>!<S2SV_blank>" "dart_adapt_transtable_get_disp<S2SV_blank>failed" ) ; return DART_ERR_INVAL ; } win = team_data -> window ; offset += disp_s ; DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank><S2SV_blank>nelem:%zu<S2SV_blank>" <S2SV_StartBug> "source<S2SV_blank>(coll.):<S2SV_blank>win:%p<S2SV_blank>unit:%d<S2SV_blank>offset:%p" <S2SV_EndBug> "-><S2SV_blank>dest:<S2SV_blank>%p" , nelem , win , team_unit_id . id , offset , dest ) ; } else { win = dart_win_local_alloc ; DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank><S2SV_blank>nelem:%zu<S2SV_blank>" <S2SV_StartBug> "source<S2SV_blank>(local):<S2SV_blank>win:%p<S2SV_blank>unit:%d<S2SV_blank>offset:%p<S2SV_blank>" <S2SV_EndBug> "-><S2SV_blank>dest:<S2SV_blank>%p" , nelem , win , team_unit_id . id , offset , dest ) ; } DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank>MPI_Get" ) ; if ( MPI_Get ( dest , nelem , mpi_dtype , team_unit_id . id , offset , nelem , mpi_dtype , win ) != MPI_SUCCESS ) { DART_LOG_ERROR ( "dart_get_blocking<S2SV_blank>!<S2SV_blank>MPI_Get<S2SV_blank>failed" ) ; return DART_ERR_INVAL ; } DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank>MPI_Win_flush" ) ; if ( MPI_Win_flush ( team_unit_id . id , win ) != MPI_SUCCESS ) { DART_LOG_ERROR ( "dart_get_blocking<S2SV_blank>!<S2SV_blank>MPI_Win_flush<S2SV_blank>failed" ) ; return DART_ERR_INVAL ; } DART_LOG_DEBUG ( "dart_get_blocking<S2SV_blank>><S2SV_blank>finished" ) ; return DART_OK ; }
<S2SV_ModStart> DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank><S2SV_blank>nelem:%zu<S2SV_blank>" "source<S2SV_blank>(coll.):<S2SV_blank>win:%p<S2SV_blank>unit:%d<S2SV_blank>offset:%lu<S2SV_blank>" <S2SV_ModEnd> "-><S2SV_blank>dest:<S2SV_blank>%p" , nelem <S2SV_ModStart> DART_LOG_DEBUG ( "dart_get_blocking:<S2SV_blank><S2SV_blank>nelem:%zu<S2SV_blank>" "source<S2SV_blank>(local):<S2SV_blank>win:%p<S2SV_blank>unit:%d<S2SV_blank>offset:%lu<S2SV_blank>" <S2SV_ModEnd> "-><S2SV_blank>dest:<S2SV_blank>%p" , nelem
3,591
CWE-000 int hasPressedUpSingle ( int i ) { if ( gData . mCurrentKeyStates == NULL ) return 0 ; int state = gData . mCurrentKeyStates [ gKeys [ i ] [ 6 ] ] ; if ( gData . mControllers [ i ] . mIsUsingController ) { double axis = getSingleLeftStickNormalizedY ( i ) ; state |= ( axis < - 0.5 ) ; <S2SV_StartBug> } <S2SV_EndBug> return state ; }
<S2SV_ModStart> 0.5 ) ; state |= SDL_GameControllerGetButton ( gData . mControllers [ i ] . mController , SDL_CONTROLLER_BUTTON_DPAD_UP ) ;
3,592
CWE-000 static void be_check_online_done ( struct tevent_req * req ) { struct be_ctx * be_ctx ; struct dp_reply_std * reply ; errno_t ret ; <S2SV_StartBug> be_ctx = tevent_req_callback_data ( req , struct be_ctx ) ; <S2SV_EndBug> ret = dp_req_recv_ptr ( be_ctx , req , struct dp_reply_std , & reply ) ; talloc_zfree ( req ) ; if ( ret != EOK ) { goto done ; } switch ( reply -> dp_error ) { case DP_ERR_OK : <S2SV_StartBug> DEBUG ( SSSDBG_TRACE_FUNC , "Backend<S2SV_blank>is<S2SV_blank>online\\n" ) ; <S2SV_EndBug> break ; <S2SV_StartBug> case DP_ERR_OFFLINE : <S2SV_EndBug> DEBUG ( SSSDBG_TRACE_FUNC , "Backend<S2SV_blank>is<S2SV_blank>offline\\n" ) ; break ; default : DEBUG ( SSSDBG_TRACE_FUNC , "Error<S2SV_blank>during<S2SV_blank>online<S2SV_blank>check<S2SV_blank>[%d]:<S2SV_blank>%s\\n" , ret , sss_strerror ( ret ) ) ; break ; } be_ctx -> check_online_ref_count -- ; if ( reply -> dp_error != DP_ERR_OK && be_ctx -> check_online_ref_count > 0 ) { ret = be_check_online_request ( be_ctx ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>check<S2SV_blank>online<S2SV_blank>req.\\n" ) ; goto done ; } return ; } done : be_ctx -> check_online_ref_count = 0 ; if ( reply -> dp_error != DP_ERR_OFFLINE ) { if ( reply -> dp_error != DP_ERR_OK ) { reset_fo ( be_ctx ) ; } be_reset_offline ( be_ctx ) ; } }
<S2SV_ModStart> errno_t ret ; static int last_dp_state = - 1 ; <S2SV_ModStart> case DP_ERR_OK : if ( last_dp_state != DP_ERR_OK ) { last_dp_state = DP_ERR_OK ; sss_log ( SSS_LOG_INFO , "Backend<S2SV_blank>is<S2SV_blank>online\\n" ) ; } <S2SV_ModStart> case DP_ERR_OFFLINE : if ( last_dp_state != DP_ERR_OFFLINE ) { last_dp_state = DP_ERR_OFFLINE ; sss_log ( SSS_LOG_INFO , "Backend<S2SV_blank>is<S2SV_blank>offline\\n" ) ; }
3,593
CWE-000 static void add_clause ( gfc_symbol * sym , gfc_omp_map_op map_op ) { gfc_omp_namelist * n ; if ( ! module_oacc_clauses ) <S2SV_StartBug> module_oacc_clauses = gfc_get_omp_clauses ( ) ; <S2SV_EndBug> for ( n = module_oacc_clauses -> lists [ OMP_LIST_MAP ] ; n != NULL ; n = n -> next ) if ( n -> sym -> backend_decl == sym -> backend_decl ) return ; n = gfc_get_omp_namelist ( ) ; n -> sym = sym ; n -> u . map_op = map_op ; if ( module_oacc_clauses -> lists [ OMP_LIST_MAP ] ) n -> next = module_oacc_clauses -> lists [ OMP_LIST_MAP ] ; module_oacc_clauses -> lists [ OMP_LIST_MAP ] = n ; }
<S2SV_ModStart> = gfc_get_omp_clauses ( ) ; if ( sym -> backend_decl == NULL ) gfc_get_symbol_decl ( sym
3,594
CWE-000 static void draw_switch ( switch_t * s ) <S2SV_StartBug> { <S2SV_EndBug> double msz = s -> radius * 0.6 ; double off = ( s -> radius - msz ) / 2.0 ; draw_rectangle_filled ( s -> x + off , s -> on ? ( s -> y + s -> radius ) - off : s -> y + off , msz , msz , s -> on ? GREEN : RED ) ; draw_rectangle_filled ( s -> x + off , s -> y + off , msz , msz * 2. , BLACK ) ; draw_rectangle_filled ( s -> x , s -> y , s -> radius , s -> radius * 2 , BLUE ) ; }
<S2SV_ModStart> s ) { assert ( s ) ;
3,595
CWE-000 int msm_spm_drv_set_vdd ( struct msm_spm_driver_data * dev , unsigned int vlevel ) { uint32_t timeout_us , new_level ; <S2SV_StartBug> bool avs_enabled = msm_spm_drv_is_avs_enabled ( dev ) ; <S2SV_EndBug> if ( ! dev ) <S2SV_StartBug> return - EINVAL ; <S2SV_EndBug> if ( ! msm_spm_pmic_arb_present ( dev ) ) return - ENOSYS ; if ( msm_spm_debug_mask & MSM_SPM_DEBUG_VCTL ) pr_info ( "%s:<S2SV_blank>requesting<S2SV_blank>vlevel<S2SV_blank>%#x\\n" , __func__ , vlevel ) ; if ( avs_enabled ) msm_spm_drv_disable_avs ( dev ) ; dev -> reg_shadow [ MSM_SPM_REG_SAW2_RST ] = 1 ; msm_spm_drv_flush_shadow ( dev , MSM_SPM_REG_SAW2_RST ) ; msm_spm_drv_apcs_set_vctl ( dev , vlevel ) ; msm_spm_drv_flush_shadow ( dev , MSM_SPM_REG_SAW2_VCTL ) ; msm_spm_drv_flush_shadow ( dev , MSM_SPM_REG_SAW2_PMIC_DATA_0 ) ; msm_spm_drv_flush_shadow ( dev , MSM_SPM_REG_SAW2_PMIC_DATA_1 ) ; timeout_us = dev -> vctl_timeout_us ; do { new_level = msm_spm_drv_get_sts_curr_pmic_data ( dev ) ; if ( new_level == vlevel ) break ; udelay ( 1 ) ; } while ( -- timeout_us ) ; if ( ! timeout_us ) { pr_info ( "Wrong<S2SV_blank>level<S2SV_blank>%#x\\n" , new_level ) ; goto set_vdd_bail ; } if ( msm_spm_debug_mask & MSM_SPM_DEBUG_VCTL ) pr_info ( "%s:<S2SV_blank>done,<S2SV_blank>remaining<S2SV_blank>timeout<S2SV_blank>%uus\\n" , __func__ , timeout_us ) ; if ( avs_enabled ) { msm_spm_drv_set_avs_vlevel ( dev , vlevel ) ; msm_spm_drv_enable_avs ( dev ) ; } return 0 ; set_vdd_bail : if ( avs_enabled ) msm_spm_drv_enable_avs ( dev ) ; pr_err ( "%s:<S2SV_blank>failed<S2SV_blank>%#x,<S2SV_blank>remaining<S2SV_blank>timeout<S2SV_blank>%uus,<S2SV_blank>vlevel<S2SV_blank>%#x\\n" , __func__ , vlevel , timeout_us , new_level ) ; return - EIO ; }
<S2SV_ModStart> ; bool avs_enabled <S2SV_ModEnd> ; if ( <S2SV_ModStart> return - EINVAL ; avs_enabled = msm_spm_drv_is_avs_enabled ( dev )
3,596
CWE-000 static bool has_tostring ( lua_State * L , int index ) { bool has_tostring_mm = false ; <S2SV_StartBug> bool has_metatable = ( lua_getmetatable ( L , index ) != 0 ) ; <S2SV_EndBug> if ( has_metatable ) { lua_getfield ( L , - 1 , "__tostring" ) ; if ( lua_isfunction ( L , - 1 ) ) has_tostring_mm = true ; lua_pop ( L , 2 ) ; } return has_tostring_mm ; }
<S2SV_ModStart> , index ) == 1 <S2SV_ModEnd> ) ; if
3,597
CWE-000 void UpdatePC ( DecodedInstr * d , int val ) { switch ( ( opcode ) ( d -> op ) ) { case 0 : switch ( ( funct ) ( d -> regs . r . funct ) ) { case jr : mips . pc = val ; return ; default : mips . pc += 4 ; return ; } break ; case beq : case bne : if ( val ) { mips . pc = mips . pc + 4 + ( ( short ) ( d -> regs . i . addr_or_immed ) << 2 ) ; return ; } <S2SV_StartBug> case j : <S2SV_EndBug> case jal : mips . pc = ( mips . pc & 0xf0000000 ) | ( d -> regs . j . target << 2 ) ; return ; default : mips . pc += 4 ; return ; } }
<S2SV_ModStart> return ; } else { mips . pc += 4 ; return ; }
3,598
CWE-000 <S2SV_StartBug> static void print_xml_comment ( FILE * xml_file , ulong len , <S2SV_EndBug> const char * comment_string ) { const char * end ; fputs ( "<!--<S2SV_blank>" , xml_file ) ; for ( end = comment_string + len ; comment_string != end ; comment_string ++ ) { switch ( * comment_string ) { case '-' : if ( * ( comment_string + 1 ) == '-' ) break ; default : fputc ( * comment_string , xml_file ) ; break ; } } fputs ( "<S2SV_blank>-->\\n" , xml_file ) ; check_io ( xml_file ) ; }
<S2SV_ModStart> * xml_file , size_t <S2SV_ModEnd> len , const
3,599
CWE-000 static hFILE * hpreload_fd ( const char * filename , const char * mode ) { <S2SV_StartBug> if ( ! strchr ( mode , 'r' ) ) <S2SV_EndBug> { return NULL ; } hFILE_fd * fp = NULL ; FILE * file = fopen ( filename , mode ) ; if ( ! file ) goto error ; if ( fseek ( file , 0 , SEEK_END ) != 0 ) goto error ; int len = ftell ( file ) ; fseek ( file , 0 , SEEK_SET ) ; char * buffer = malloc ( len ) ; if ( buffer == NULL ) goto error ; if ( fread ( buffer , 1 , len , file ) != len ) goto error ; fp = ( hFILE_fd * ) hfile_init_fixed ( sizeof ( hFILE_fd ) , mode , buffer , len , len ) ; if ( fp == NULL ) goto error ; fp -> fd = fileno ( file ) ; fp -> is_socket = 0 ; fp -> base . backend = & fd_backend ; return & fp -> base ; error : if ( file ) { int save = errno ; ( void ) fclose ( file ) ; errno = save ; } hfile_destroy ( ( hFILE * ) fp ) ; return NULL ; }
<S2SV_ModStart> { if ( mode == NULL ||