Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,500 | CWE-000 int32_t base6encode ( BYTE * payload , size_t payload_len , uint8_t * encoded ) { const uint8_t base6table [ 6 ] = { '0' , '1' , '2' , '3' , '4' , '5' } ; int8_t payload_hexstr [ payload_len * 2 ] ; int8_t raw_encoded [ payload_len * 2 ] ; BIGNUM * bn = BN_new ( ) ; BIGNUM * bn0 = BN_new ( ) ; BIGNUM * bn6 = BN_new ( ) ; BN_init ( bn ) ; BN_init ( bn0 ) ; BN_init ( bn6 ) ; BIGNUM * dv = BN_new ( ) ; BIGNUM * rem = BN_new ( ) ; BN_init ( dv ) ; BN_init ( rem ) ; BN_CTX * ctx = BN_CTX_new ( ) ; BN_CTX_init ( ctx ) ; if ( bytearr_to_hexstr ( payload , payload_len , payload_hexstr ) != 0 ) return - 1 ; BN_hex2bn ( & bn , ( const char * ) payload_hexstr ) ; BN_set_word ( bn0 , 0 ) ; BN_set_word ( bn6 , 6 ) ; BN_set_word ( dv , 1 ) ; int32_t encoded_len = 0 ; while ( BN_cmp ( dv , bn0 ) > 0 ) { BN_div ( dv , rem , bn , bn6 , ctx ) ; BN_copy ( bn , dv ) ; raw_encoded [ encoded_len ] = base6table [ BN_get_word ( rem ) ] ; encoded_len ++ ; } <S2SV_StartBug> if ( encoded == NULL ) <S2SV_EndBug> <S2SV_StartBug> return encoded_len ; <S2SV_EndBug> for ( int32_t i = 0 ; i < encoded_len ; ++ i ) encoded [ encoded_len - 1 - i ] = raw_encoded [ i ] ; encoded [ encoded_len ] = '\\0' ; BN_free ( bn ) ; BN_free ( bn0 ) ; BN_free ( bn6 ) ; BN_free ( dv ) ; BN_free ( rem ) ; BN_CTX_free ( ctx ) ; <S2SV_StartBug> free ( bn ) ; free ( bn0 ) ; free ( bn6 ) ; <S2SV_EndBug> free ( dv ) ; free ( rem ) ; free ( ctx ) ; return 0 ; } | <S2SV_ModStart> == NULL ) { BN_free ( bn ) ; BN_free ( bn0 ) ; BN_free ( bn6 ) ; BN_free ( dv ) ; BN_free ( rem ) ; BN_CTX_free ( ctx ) ; OPENSSL_free ( bn ) ; OPENSSL_free ( bn0 ) ; OPENSSL_free ( bn6 ) ; OPENSSL_free ( dv ) ; OPENSSL_free ( rem ) ; <S2SV_ModStart> return encoded_len ; } <S2SV_ModStart> ctx ) ; OPENSSL_free ( bn ) ; OPENSSL_free ( bn0 ) ; OPENSSL_free ( bn6 ) ; OPENSSL_free ( dv ) ; OPENSSL_free ( rem <S2SV_ModEnd> ) ; return |
1,501 | CWE-000 static inline void hst2bbc ( const char * host_fn , char * acorn_fn ) { int ch ; const char * ptr ; char * end = acorn_fn + MAX_FILE_NAME ; while ( ( ch = * host_fn ++ ) && acorn_fn < end ) { if ( ( ptr = strchr ( hst_chars , ch ) ) ) ch = bbc_chars [ ptr - hst_chars ] ; * acorn_fn ++ = ch ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ch ; } * acorn_fn = '\\0' ; |
1,502 | CWE-000 void swWorker_try_to_exit ( ) { swServer * serv = SwooleG . serv ; <S2SV_StartBug> int expect_event_num = SwooleG . use_signalfd ? 1 : 0 ; <S2SV_EndBug> uint8_t call_worker_exit_func = 0 ; while ( 1 ) { if ( SwooleG . main_reactor -> event_num == expect_event_num ) { SwooleG . main_reactor -> running = 0 ; SwooleG . running = 0 ; } else { if ( serv -> onWorkerExit && call_worker_exit_func == 0 ) { serv -> onWorkerExit ( serv , SwooleWG . id ) ; call_worker_exit_func = 1 ; continue ; } } break ; } } | <S2SV_ModStart> : 0 ; if ( SwooleAIO . init && SwooleAIO . task_num == 0 ) { swAio_free ( ) ; } |
1,503 | CWE-000 static int tier_migrate_files_using_qfile ( migration_args_t * comp , query_cbk_args_t * query_cbk_args ) { int ret = - 1 ; tier_brick_list_t * local_brick = NULL ; tier_brick_list_t * temp = NULL ; char query_file_path_err [ PATH_MAX + 128 ] = { 0 , } ; struct tm tm = { 0 , } ; gfdb_time_t current_time = { 0 , } ; char time_str [ 128 ] = { 0 , } ; ssize_t qfile_array_size = 0 ; int count = 0 ; int temp_fd = 0 ; gf_tier_conf_t * tier_conf = NULL ; tier_conf = & ( query_cbk_args -> defrag -> tier_conf ) ; gettimeofday ( & current_time , NULL ) ; gmtime_r ( & current_time . tv_sec , & tm ) ; strftime ( time_str , sizeof ( time_str ) , "%F-%T" , & tm ) ; list_for_each_entry_safe ( local_brick , temp , comp -> brick_list , list ) { qfile_array_size ++ ; } query_cbk_args -> qfile_array = qfile_array_new ( qfile_array_size ) ; if ( ! query_cbk_args -> qfile_array ) { gf_msg ( "tier" , GF_LOG_ERROR , 0 , DHT_MSG_LOG_TIER_ERROR , "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>new<S2SV_blank>" "qfile_array" ) ; goto out ; } count = 0 ; query_cbk_args -> qfile_array -> exhausted_count = 0 ; list_for_each_entry_safe ( local_brick , temp , comp -> brick_list , list ) { temp_fd = query_cbk_args -> qfile_array -> fd_array [ count ] ; temp_fd = open ( local_brick -> qfile_path , O_RDONLY , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ) ; if ( temp_fd < 0 ) { gf_msg ( "tier" , GF_LOG_ERROR , errno , DHT_MSG_LOG_TIER_ERROR , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>" "%s<S2SV_blank>to<S2SV_blank>the<S2SV_blank>query<S2SV_blank>file" , local_brick -> qfile_path ) ; query_cbk_args -> qfile_array -> exhausted_count ++ ; } query_cbk_args -> qfile_array -> fd_array [ count ] = temp_fd ; count ++ ; } query_cbk_args -> qfile_array -> next_index = ( query_cbk_args -> is_promotion ) ? tier_conf -> last_promote_qfile_index : tier_conf -> last_demote_qfile_index ; shift_next_index ( query_cbk_args -> qfile_array ) ; if ( query_cbk_args -> is_promotion ) { tier_conf -> last_promote_qfile_index = query_cbk_args -> qfile_array -> next_index ; } else { tier_conf -> last_demote_qfile_index = query_cbk_args -> qfile_array -> next_index ; } ret = tier_migrate_using_query_file ( ( void * ) query_cbk_args ) ; out : qfile_array_free ( query_cbk_args -> qfile_array ) ; if ( ret ) { list_for_each_entry_safe ( local_brick , temp , comp -> brick_list , list ) { snprintf ( query_file_path_err , sizeof ( query_file_path_err ) , "%s-%s.err" , local_brick -> qfile_path , time_str ) ; <S2SV_StartBug> sys_rename ( local_brick -> qfile_path , <S2SV_EndBug> <S2SV_StartBug> query_file_path_err ) ; <S2SV_EndBug> } } query_cbk_args -> qfile_array = NULL ; return ret ; } | <S2SV_ModStart> time_str ) ; if ( <S2SV_ModStart> qfile_path , query_file_path_err ) == - 1 ) gf_msg_debug ( "tier" , 0 , "rename<S2SV_blank>" "failed" |
1,504 | CWE-000 <S2SV_StartBug> int <S2SV_EndBug> fdt_fixup ( void ) { const char * env ; char * ethstr ; int chosen , err , eth_no , len ; struct sys_info * si ; env = NULL ; eth_no = 0 ; ethstr = NULL ; len = 0 ; <S2SV_StartBug> if ( ! fdtp ) { <S2SV_EndBug> err = fdt_setup_fdtp ( ) ; if ( err ) { <S2SV_StartBug> sprintf ( command_errbuf , "Could<S2SV_blank>not<S2SV_blank>perform<S2SV_blank>blob<S2SV_blank>" <S2SV_EndBug> "fixups.<S2SV_blank>Error<S2SV_blank>code:<S2SV_blank>%d\\n" , err ) ; <S2SV_StartBug> return ( err ) ; <S2SV_EndBug> } } if ( ( chosen = fdt_subnode_offset ( fdtp , 0 , "chosen" ) ) == - FDT_ERR_NOTFOUND ) chosen = fdt_add_subnode ( fdtp , 0 , "chosen" ) ; if ( fdt_getprop ( fdtp , chosen , "fixup-applied" , NULL ) ) <S2SV_StartBug> return ( CMD_OK ) ; <S2SV_EndBug> si = ub_get_sys_info ( ) ; while ( ( env = ub_env_enum ( env ) ) != NULL ) { if ( strncmp ( env , "eth" , 3 ) == 0 && strncmp ( env + ( strlen ( env ) - 4 ) , "addr" , 4 ) == 0 ) { if ( ! eth_no ) { len = strlen ( STRINGIFY ( TMP_MAX_ETH ) ) + strlen ( "ethernet" ) ; ethstr = ( char * ) malloc ( len * sizeof ( char ) ) ; bzero ( ethstr , len * sizeof ( char ) ) ; strcpy ( ethstr , "ethernet0" ) ; } fixup_ethernet ( env , ethstr , & eth_no , len ) ; } else if ( strcmp ( env , "consoledev" ) == 0 ) fixup_stdout ( env ) ; } fixup_cpubusfreqs ( si -> clk_cpu , si -> clk_bus ) ; fixup_memory ( si ) ; fdt_setprop ( fdtp , chosen , "fixup-applied" , NULL , 0 ) ; <S2SV_StartBug> return ( CMD_OK ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void * <S2SV_ModEnd> fdt_fixup ( void <S2SV_ModStart> = 0 ; <S2SV_ModEnd> err = fdt_setup_fdtp <S2SV_ModStart> ( command_errbuf , "No<S2SV_blank>valid<S2SV_blank>device<S2SV_blank>tree<S2SV_blank>blob<S2SV_blank>found!" <S2SV_ModEnd> ) ; return <S2SV_ModStart> ; return ( NULL ) ; <S2SV_ModEnd> } if ( <S2SV_ModStart> NULL ) ) goto success <S2SV_ModEnd> ; si = <S2SV_ModStart> 0 ) ; success : return ( fdtp <S2SV_ModEnd> ) ; } |
1,505 | CWE-000 <S2SV_StartBug> int execute_command ( char * command , char * * argv , int argc ) { <S2SV_EndBug> char command_path [ 256 ] = "" ; int pid = fork ( ) ; if ( pid == - 1 ) { fprintf ( stderr , "%s:<S2SV_blank>unknown<S2SV_blank>error;<S2SV_blank>fork<S2SV_blank>failed\\n" , command ) ; return - 1 ; } else if ( pid == 0 ) { execv ( command , argv ) ; for ( int i = 0 ; i < g_path_count ; ++ i ) { sprintf ( command_path , "%s/%s" , g_paths [ i ] , command ) ; execv ( command_path , argv ) ; } fprintf ( stderr , "%s:<S2SV_blank>command<S2SV_blank>not<S2SV_blank>found\\n" , command ) ; return - 1 ; } else { int status ; wait ( & status ) ; } return 0 ; } | <S2SV_ModStart> * * argv <S2SV_ModEnd> ) { char |
1,506 | CWE-000 static int pocl_binary_deserialize_kernel_from_buffer ( unsigned char * * buf , pocl_binary_kernel * kernel , const char * name_match , size_t name_len , char * basedir ) { unsigned i ; unsigned char * buffer = * buf ; memset ( kernel , 0 , sizeof ( pocl_binary_kernel ) ) ; BUFFER_READ ( kernel -> struct_size , uint64_t ) ; BUFFER_READ ( kernel -> binaries_size , uint64_t ) ; BUFFER_READ ( kernel -> arginfo_size , uint32_t ) ; BUFFER_READ_STR2 ( kernel -> kernel_name , kernel -> sizeof_kernel_name ) ; BUFFER_READ ( kernel -> num_args , uint32_t ) ; BUFFER_READ ( kernel -> num_locals , uint32_t ) ; if ( name_len > 0 && name_match ) { <S2SV_StartBug> if ( strncmp ( kernel -> kernel_name , name_match , kernel -> sizeof_kernel_name ) ) <S2SV_EndBug> { <S2SV_StartBug> * buf = * buf + kernel -> struct_size ; <S2SV_EndBug> return - 11111 ; <S2SV_StartBug> } <S2SV_EndBug> kernel -> dyn_arguments = calloc ( ( kernel -> num_args + kernel -> num_locals ) , sizeof ( struct pocl_argument ) ) ; POCL_RETURN_ERROR_COND ( ( ! kernel -> dyn_arguments ) , CL_OUT_OF_HOST_MEMORY ) ; for ( i = 0 ; i < ( kernel -> num_args + kernel -> num_locals ) ; i ++ ) { BUFFER_READ ( kernel -> dyn_arguments [ i ] . size , uint64_t ) ; kernel -> dyn_arguments [ i ] . value = NULL ; } kernel -> arg_info = calloc ( kernel -> num_args , sizeof ( struct pocl_argument_info ) ) ; POCL_RETURN_ERROR_COND ( ( ! kernel -> arg_info ) , CL_OUT_OF_HOST_MEMORY ) ; for ( i = 0 ; i < kernel -> num_args ; i ++ ) { pocl_argument_info * ai = & kernel -> arg_info [ i ] ; BUFFER_READ ( ai -> access_qualifier , cl_kernel_arg_access_qualifier ) ; BUFFER_READ ( ai -> address_qualifier , cl_kernel_arg_address_qualifier ) ; BUFFER_READ ( ai -> type_qualifier , cl_kernel_arg_type_qualifier ) ; BUFFER_READ ( ai -> is_local , char ) ; BUFFER_READ ( ai -> is_set , char ) ; BUFFER_READ ( ai -> type , uint32_t ) ; BUFFER_READ_STR ( ai -> name ) ; BUFFER_READ_STR ( ai -> type_name ) ; } } else { buffer += ( ( kernel -> num_args + kernel -> num_locals ) * sizeof ( uint64_t ) ) ; buffer += kernel -> arginfo_size ; buffer = deserialize_kernel_cachedir ( basedir , buffer , kernel -> binaries_size ) ; } * buf = buffer ; return CL_SUCCESS ; } | <S2SV_ModStart> name_match ) { <S2SV_ModEnd> * buf = <S2SV_ModStart> -> struct_size ; if ( kernel -> sizeof_kernel_name != name_len ) return - 11222 ; if ( strncmp ( kernel -> kernel_name , name_match , kernel -> sizeof_kernel_name ) ) <S2SV_ModStart> - 11111 ; <S2SV_ModEnd> kernel -> dyn_arguments |
1,507 | CWE-000 NodeValues betweennessCentralityNormalised ( Graph g ) { NodeValues centrality = betweennessCentrality ( g ) ; <S2SV_StartBug> for ( int v = 0 ; v < g -> nV ; v ++ ) { <S2SV_EndBug> <S2SV_StartBug> centrality . values [ v ] = ( centrality . values [ v ] ) / ( ( g -> nV - 1 ) * ( g -> nV - 2 ) ) ; <S2SV_EndBug> } return centrality ; } | <S2SV_ModStart> ; v < numVerticies ( g ) <S2SV_ModEnd> ; v ++ <S2SV_ModStart> / ( ( numVerticies ( g ) <S2SV_ModEnd> - 1 ) <S2SV_ModStart> ) * ( numVerticies ( g ) <S2SV_ModEnd> - 2 ) |
1,508 | CWE-000 dword_t _sys_execve ( addr_t filename_addr , addr_t argv_addr , addr_t envp_addr ) { char filename [ MAX_PATH ] ; if ( user_read_string ( filename_addr , filename , sizeof ( filename ) ) ) return _EFAULT ; char * argv [ MAX_ARGS ] ; int i ; addr_t arg ; for ( i = 0 ; ; i ++ ) { if ( user_get ( argv_addr + i * 4 , arg ) ) return _EFAULT ; <S2SV_StartBug> if ( i > MAX_ARGS ) <S2SV_EndBug> return _E2BIG ; argv [ i ] = malloc ( MAX_PATH ) ; if ( user_read_string ( arg , argv [ i ] , MAX_PATH ) ) return _EFAULT ; <S2SV_StartBug> if ( arg == 0 ) <S2SV_EndBug> break ; } argv [ i ] = NULL ; char * envp [ MAX_ARGS ] ; for ( i = 0 ; ; i ++ ) { if ( user_get ( envp_addr + i * 4 , arg ) ) return _EFAULT ; <S2SV_StartBug> if ( i > MAX_ARGS ) <S2SV_EndBug> return _E2BIG ; envp [ i ] = malloc ( MAX_PATH ) ; if ( user_read_string ( arg , envp [ i ] , MAX_PATH ) ) return _EFAULT ; <S2SV_StartBug> if ( arg == 0 ) <S2SV_EndBug> break ; } envp [ i ] = NULL ; int res = sys_execve ( filename , argv , envp ) ; for ( i = 0 ; argv [ i ] != NULL ; i ++ ) free ( argv [ i ] ) ; for ( i = 0 ; envp [ i ] != NULL ; i ++ ) free ( envp [ i ] ) ; return res ; } | <S2SV_ModStart> ; if ( arg == 0 ) break ; if ( <S2SV_ModStart> return _EFAULT ; <S2SV_ModEnd> } argv [ <S2SV_ModStart> ; if ( arg == 0 ) break ; if ( <S2SV_ModStart> return _EFAULT ; <S2SV_ModEnd> } envp [ |
1,509 | CWE-000 char * strchr ( char * s , char c ) { while ( * s != 0 ) { if ( * s == c ) { return s ; <S2SV_StartBug> } <S2SV_EndBug> } return NULL ; } | <S2SV_ModStart> s ; } else { s ++ ; } |
1,510 | CWE-000 int must_be_root ( void ) { if ( geteuid ( ) == 0 ) return 0 ; <S2SV_StartBug> log_error ( "Need<S2SV_blank>to<S2SV_blank>be<S2SV_blank>root." ) ; <S2SV_EndBug> <S2SV_StartBug> return - EPERM ; <S2SV_EndBug> } | <S2SV_ModStart> return 0 ; return log_error_errno ( SYNTHETIC_ERRNO ( EPERM ) , <S2SV_ModEnd> "Need<S2SV_blank>to<S2SV_blank>be<S2SV_blank>root." ) ; <S2SV_ModStart> "Need<S2SV_blank>to<S2SV_blank>be<S2SV_blank>root." ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,511 | CWE-000 char * SERV_ServiceName ( const char * service ) { <S2SV_StartBug> return s_ServiceName ( service , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> service , 0 , 0 |
1,512 | CWE-000 int main ( void ) { int n ; printf ( "Enter<S2SV_blank>array<S2SV_blank>length:<S2SV_blank>" ) ; scanf ( "%d" , & n ) ; getchar ( ) ; char * * array = makearray ( n ) ; printf ( "\\nYour<S2SV_blank>array:<S2SV_blank>" ) ; printarray ( array , n ) ; DestroyLongestString ( array , n ) ; char * * results = FormResults ( array , n - 1 ) ; <S2SV_StartBug> printf ( "Your<S2SV_blank>array<S2SV_blank>wothout<S2SV_blank>longest<S2SV_blank>string:<S2SV_blank>" ) ; <S2SV_EndBug> printarray ( results , n - 1 ) ; for ( int i = 0 ; i < n ; i ++ ) { if ( array [ i ] ) free ( array [ i ] ) ; } free ( array ) ; for ( int i = 0 ; i < n ; i ++ ) { free ( results [ i ] ) ; } free ( results ) ; printf ( "\\n" ) ; } | <S2SV_ModStart> ; printf ( "Your<S2SV_blank>array<S2SV_blank>without<S2SV_blank>longest<S2SV_blank>string:<S2SV_blank>" <S2SV_ModEnd> ) ; printarray |
1,513 | CWE-000 static void sd_spinup_disk ( struct scsi_disk * sdkp ) { unsigned char cmd [ 10 ] ; unsigned long spintime_expire = 0 ; int retries , spintime ; unsigned int the_result ; struct scsi_sense_hdr sshdr ; int sense_valid = 0 ; spintime = 0 ; do { retries = 0 ; do { cmd [ 0 ] = TEST_UNIT_READY ; memset ( ( void * ) & cmd [ 1 ] , 0 , 9 ) ; the_result = scsi_execute_req ( sdkp -> device , cmd , DMA_NONE , NULL , 0 , & sshdr , SD_TIMEOUT , SD_MAX_RETRIES , NULL ) ; if ( media_not_present ( sdkp , & sshdr ) ) return ; if ( the_result ) sense_valid = scsi_sense_valid ( & sshdr ) ; retries ++ ; } while ( retries < 3 && ( ! scsi_status_is_good ( the_result ) || ( ( driver_byte ( the_result ) & DRIVER_SENSE ) && sense_valid && sshdr . sense_key == UNIT_ATTENTION ) ) ) ; if ( ( driver_byte ( the_result ) & DRIVER_SENSE ) == 0 ) { if ( ! spintime && ! scsi_status_is_good ( the_result ) ) { sd_printk ( KERN_NOTICE , sdkp , "Unit<S2SV_blank>Not<S2SV_blank>Ready\\n" ) ; sd_print_result ( sdkp , the_result ) ; } break ; } if ( sdkp -> device -> no_start_on_add ) break ; if ( sense_valid && sshdr . sense_key == NOT_READY ) { if ( sshdr . asc == 4 && sshdr . ascq == 3 ) break ; if ( sshdr . asc == 4 && sshdr . ascq == 0xb ) break ; <S2SV_StartBug> if ( sshdr . asc == 4 && sshdr . ascq == 0xc ) <S2SV_EndBug> break ; if ( ! spintime ) { sd_printk ( KERN_NOTICE , sdkp , "Spinning<S2SV_blank>up<S2SV_blank>disk..." ) ; cmd [ 0 ] = START_STOP ; cmd [ 1 ] = 1 ; memset ( ( void * ) & cmd [ 2 ] , 0 , 8 ) ; cmd [ 4 ] = 1 ; if ( sdkp -> device -> start_stop_pwr_cond ) cmd [ 4 ] |= 1 << 4 ; scsi_execute_req ( sdkp -> device , cmd , DMA_NONE , NULL , 0 , & sshdr , SD_TIMEOUT , SD_MAX_RETRIES , NULL ) ; spintime_expire = jiffies + 100 * HZ ; spintime = 1 ; } msleep ( 1000 ) ; printk ( "." ) ; } else if ( sense_valid && sshdr . sense_key == UNIT_ATTENTION && sshdr . asc == 0x28 ) { if ( ! spintime ) { spintime_expire = jiffies + 5 * HZ ; spintime = 1 ; } msleep ( 1000 ) ; } else { if ( ! spintime ) { sd_printk ( KERN_NOTICE , sdkp , "Unit<S2SV_blank>Not<S2SV_blank>Ready\\n" ) ; sd_print_sense_hdr ( sdkp , & sshdr ) ; } break ; } } while ( spintime && time_before_eq ( jiffies , spintime_expire ) ) ; if ( spintime ) { if ( scsi_status_is_good ( the_result ) ) printk ( "ready\\n" ) ; else printk ( "not<S2SV_blank>responding...\\n" ) ; } } | <S2SV_ModStart> ascq == 0xc ) break ; if ( sshdr . asc == 4 && sshdr . ascq == 0x1b |
1,514 | CWE-000 static int axienet_open ( struct net_device * ndev ) { int ret = 0 , i ; struct axienet_local * lp = netdev_priv ( ndev ) ; struct phy_device * phydev = NULL ; struct axienet_dma_q * q ; dev_dbg ( & ndev -> dev , "axienet_open()\\n" ) ; if ( lp -> axienet_config -> mactype == XAXIENET_10G_25G ) axienet_device_reset ( ndev ) ; else ret = axienet_mii_init ( ndev ) ; if ( ret < 0 ) return ret ; if ( lp -> phy_node ) { if ( lp -> phy_type == XAE_PHY_TYPE_GMII ) { phydev = of_phy_connect ( lp -> ndev , lp -> phy_node , axienet_adjust_link , 0 , PHY_INTERFACE_MODE_GMII ) ; } else if ( lp -> phy_type == XAE_PHY_TYPE_RGMII_2_0 ) { phydev = of_phy_connect ( lp -> ndev , lp -> phy_node , axienet_adjust_link , 0 , PHY_INTERFACE_MODE_RGMII_ID ) ; } else if ( ( lp -> axienet_config -> mactype == XAXIENET_1G ) || ( lp -> axienet_config -> mactype == XAXIENET_2_5G ) ) { phydev = of_phy_connect ( lp -> ndev , lp -> phy_node , axienet_adjust_link , lp -> phy_flags , lp -> phy_interface ) ; } if ( ! phydev ) dev_err ( lp -> dev , "of_phy_connect()<S2SV_blank>failed\\n" ) ; else phy_start ( phydev ) ; } if ( ! lp -> is_tsn || lp -> temac_no == XAE_TEMAC1 ) { for_each_dma_queue ( lp , i ) { tasklet_init ( & lp -> dma_err_tasklet [ i ] , axienet_dma_err_handler , ( unsigned long ) lp -> dq [ i ] ) ; napi_enable ( & lp -> napi [ i ] ) ; } for_each_dma_queue ( lp , i ) { struct axienet_dma_q * q = lp -> dq [ i ] ; ret = request_irq ( q -> tx_irq , axienet_tx_irq , 0 , ndev -> name , ndev ) ; if ( ret ) goto err_tx_irq ; ret = request_irq ( q -> rx_irq , axienet_rx_irq , 0 , ndev -> name , ndev ) ; if ( ret ) goto err_rx_irq ; } } # ifdef CONFIG_XILINX_TSN_PTP if ( lp -> is_tsn ) { INIT_WORK ( & lp -> tx_tstamp_work , axienet_tx_tstamp ) ; skb_queue_head_init ( & lp -> ptp_txq ) ; lp -> ptp_rx_hw_pointer = 0 ; lp -> ptp_rx_sw_pointer = 0xff ; axienet_iow ( lp , PTP_RX_CONTROL_OFFSET , PTP_RX_PACKET_CLEAR ) ; ret = request_irq ( lp -> ptp_rx_irq , axienet_ptp_rx_irq , 0 , "ptp_rx" , ndev ) ; if ( ret ) goto err_ptp_rx_irq ; ret = request_irq ( lp -> ptp_tx_irq , axienet_ptp_tx_irq , 0 , "ptp_tx" , ndev ) ; if ( ret ) goto err_ptp_rx_irq ; } # endif if ( ! lp -> eth_hasnobuf && ( lp -> axienet_config -> mactype == XAXIENET_1G ) ) { ret = request_irq ( lp -> eth_irq , axienet_err_irq , 0 , ndev -> name , ndev ) ; if ( ret ) goto err_eth_irq ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> err_eth_irq : while ( i -- ) { q = lp -> dq [ i ] ; free_irq ( q -> rx_irq , ndev ) ; } i = lp -> num_queues ; err_rx_irq : while ( i -- ) { q = lp -> dq [ i ] ; free_irq ( q -> tx_irq , ndev ) ; } err_tx_irq : for_each_dma_queue ( lp , i ) napi_disable ( & lp -> napi [ i ] ) ; # ifdef CONFIG_XILINX_TSN_PTP err_ptp_rx_irq : # endif if ( phydev ) phy_disconnect ( phydev ) ; phydev = NULL ; for_each_dma_queue ( lp , i ) tasklet_kill ( & lp -> dma_err_tasklet [ i ] ) ; dev_err ( lp -> dev , "request_irq()<S2SV_blank>failed\\n" ) ; return ret ; } | <S2SV_ModStart> err_eth_irq ; } netif_tx_start_all_queues ( ndev ) ; |
1,515 | CWE-000 static gboolean gst_omx_video_dec_stop ( GstVideoDecoder * decoder ) { GstOMXVideoDec * self ; self = GST_OMX_VIDEO_DEC ( decoder ) ; GST_DEBUG_OBJECT ( self , "Stopping<S2SV_blank>decoder" ) ; gst_omx_port_set_flushing ( self -> dec_in_port , 5 * GST_SECOND , TRUE ) ; gst_omx_port_set_flushing ( self -> dec_out_port , 5 * GST_SECOND , TRUE ) ; # if defined ( USE_OMX_TARGET_RPI ) && defined ( HAVE_GST_GL ) gst_omx_port_set_flushing ( self -> egl_in_port , 5 * GST_SECOND , TRUE ) ; gst_omx_port_set_flushing ( self -> egl_out_port , 5 * GST_SECOND , TRUE ) ; # endif gst_pad_stop_task ( GST_VIDEO_DECODER_SRC_PAD ( decoder ) ) ; if ( gst_omx_component_get_state ( self -> dec , 0 ) > OMX_StateIdle ) gst_omx_component_set_state ( self -> dec , OMX_StateIdle ) ; # if defined ( USE_OMX_TARGET_RPI ) && defined ( HAVE_GST_GL ) if ( gst_omx_component_get_state ( self -> egl_render , 0 ) > OMX_StateIdle ) gst_omx_component_set_state ( self -> egl_render , OMX_StateIdle ) ; # endif self -> downstream_flow_ret = GST_FLOW_FLUSHING ; self -> started = FALSE ; <S2SV_StartBug> self -> eos = FALSE ; <S2SV_EndBug> g_mutex_lock ( & self -> drain_lock ) ; self -> draining = FALSE ; g_cond_broadcast ( & self -> drain_cond ) ; g_mutex_unlock ( & self -> drain_lock ) ; gst_omx_component_get_state ( self -> dec , 5 * GST_SECOND ) ; # if defined ( USE_OMX_TARGET_RPI ) && defined ( HAVE_GST_GL ) gst_omx_component_get_state ( self -> egl_render , 1 * GST_SECOND ) ; # endif gst_buffer_replace ( & self -> codec_data , NULL ) ; if ( self -> input_state ) gst_video_codec_state_unref ( self -> input_state ) ; self -> input_state = NULL ; GST_DEBUG_OBJECT ( self , "Stopped<S2SV_blank>decoder" ) ; return TRUE ; } | <S2SV_ModStart> = FALSE ; <S2SV_ModEnd> g_mutex_lock ( & |
1,516 | CWE-000 static void vfsspi_ioctl_power_on ( struct vfsspi_device_data * vfsspi_device ) <S2SV_StartBug> { <S2SV_EndBug> if ( vfsspi_device -> ldocontrol && ! vfsspi_device -> ldo_onoff ) vfsspi_regulator_onoff ( vfsspi_device , true ) ; else { if ( vfsspi_device -> ldocontrol ) pr_info ( "%s<S2SV_blank>already<S2SV_blank>on\\n" , __func__ ) ; else pr_info ( "%s<S2SV_blank>can\'t<S2SV_blank>turn<S2SV_blank>on<S2SV_blank>ldo<S2SV_blank>in<S2SV_blank>this<S2SV_blank>rev\\n" , __func__ ) ; } } | <S2SV_ModStart> vfsspi_device ) { VFS7XXX_CHECK_SYSFS_RESTRICTION ( regulator ) ; |
1,517 | CWE-000 static void fold_va_start ( expr * e , symtable * stab ) { expr * va_l ; if ( dynarray_count ( e -> funcargs ) != 2 ) die_at ( & e -> where , "%s<S2SV_blank>requires<S2SV_blank>two<S2SV_blank>arguments" , BUILTIN_SPEL ( e -> expr ) ) ; va_l = e -> funcargs [ 0 ] ; fold_inc_writes_if_sym ( va_l , stab ) ; fold_expr_nodecay ( e -> funcargs [ 0 ] , stab ) ; FOLD_EXPR ( e -> funcargs [ 1 ] , stab ) ; va_l = e -> funcargs [ 0 ] ; va_type_check ( va_l , e -> expr , stab , 0 ) ; va_ensure_variadic ( e , stab ) ; { sym * second = NULL ; <S2SV_StartBug> decl * * args = symtab_func_root ( stab ) -> decls ; <S2SV_EndBug> sym * arg = args [ dynarray_count ( args ) - 1 ] -> sym ; expr * last_exp = expr_skip_casts ( e -> funcargs [ 1 ] ) ; if ( expr_kind ( last_exp , identifier ) ) second = last_exp -> bits . ident . bits . ident . sym ; if ( second != arg ) cc1_warn_at ( & last_exp -> where , builtin_va_start , "second<S2SV_blank>parameter<S2SV_blank>to<S2SV_blank>va_start<S2SV_blank>" "isn\'t<S2SV_blank>last<S2SV_blank>named<S2SV_blank>argument" ) ; } # ifndef UCC_VA_ABI { stmt * assigns = stmt_set_where ( stmt_new_wrapper ( code , symtab_new ( stab , & e -> where ) ) , & e -> where ) ; expr * assign ; # define W ( exp ) expr_set_where ( ( exp ) , & e -> where ) # define ADD_ASSIGN ( memb , exp ) assign = W ( expr_new_assign ( W ( expr_new_struct ( expr_new_deref ( va_l ) , 1 , W ( expr_new_identifier ( memb ) ) ) ) , exp ) ) ; dynarray_add ( & assigns -> bits . code . stmts , stmt_set_where ( expr_to_stmt ( assign , stab ) , & e -> where ) ) # define ADD_ASSIGN_VAL ( memb , val ) ADD_ASSIGN ( memb , W ( expr_new_val ( val ) ) ) const int ws = platform_word_size ( ) ; struct { unsigned gp , fp ; } nargs = { 0 , 0 } ; funcargs * const fa = type_funcargs ( symtab_func ( stab ) -> ref ) ; funcargs_ty_calc ( fa , & nargs . gp , & nargs . fp ) ; ADD_ASSIGN_VAL ( "gp_offset" , nargs . gp * ws ) ; ADD_ASSIGN_VAL ( "fp_offset" , ( 6 + nargs . fp ) * ws ) ; ADD_ASSIGN ( "reg_save_area" , W ( expr_new_op2 ( op_minus , W ( builtin_new_reg_save_area ( ) ) , W ( expr_new_val ( ( nargs . gp + nargs . fp ) * ws ) ) ) ) ) ; ADD_ASSIGN ( "overflow_arg_area" , W ( expr_new_op2 ( op_plus , W ( builtin_new_frame_address ( 0 ) ) , W ( expr_new_val ( ws * 2 ) ) ) ) ) ; fold_stmt ( assigns ) ; e -> bits . variadic_setup = assigns ; } # undef ADD_ASSIGN # undef ADD_ASSIGN_VAL # undef W # endif e -> tree_type = type_nav_btype ( cc1_type_nav , type_void ) ; } | <S2SV_ModStart> * args = symtab_decls ( <S2SV_ModStart> ( stab ) ) <S2SV_ModEnd> ; sym * |
1,518 | CWE-000 void std_print ( void * pointer ) { if ( SIMPLE_API_PARACOUNT != 2 ) { SIMPLE_API_ERROR ( SIMPLE_API_MISS2PARA ) ; } else { FILE * std_output = ( FILE * ) SIMPLE_API_GETCPOINTER ( 1 , "SIMPLE_CONSOLE_" ) ; <S2SV_StartBug> fprintf ( std_output , SIMPLE_API_GETSTRING ( 2 ) ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ( std_output , "%s" , |
1,519 | CWE-000 static void stmt_trans_return ( trans_t * trans , ast_stmt_t * stmt ) <S2SV_StartBug> { <S2SV_EndBug> exp_trans ( trans , stmt -> u_ret . arg_exp ) ; bb_add_stmt ( trans -> bb , stmt ) ; bb_add_branch ( trans -> bb , NULL , trans -> fn -> exit_bb ) ; fn_add_basic_blk ( trans -> fn , trans -> bb ) ; trans -> bb = NULL ; } | <S2SV_ModStart> stmt ) { if ( stmt -> u_ret . arg_exp != NULL ) |
1,520 | CWE-000 int main ( ) { char buf [ 8096 ] ; int argc ; char * * argv ; while ( 1 ) { fgets ( buf , 8096 , stdin ) ; mysh_parse_command ( buf , & argc , & argv ) ; if ( strcmp ( buf , "" ) == 0 ) { goto release_and_continue ; } else if ( strcmp ( argv [ 0 ] , "cd" ) == 0 ) { if ( do_cd ( argc , argv ) ) { fprintf ( stderr , "cd:<S2SV_blank>Invalid<S2SV_blank>arguments\\n" ) ; } } else if ( strcmp ( argv [ 0 ] , "pwd" ) == 0 ) { if ( do_pwd ( argc , argv ) ) { fprintf ( stderr , "pwd:<S2SV_blank>Invalid<S2SV_blank>arguments\\n" ) ; } } else if ( strcmp ( argv [ 0 ] , "exit" ) == 0 ) { <S2SV_StartBug> goto release_and_continue ; <S2SV_EndBug> } else { fprintf ( stderr , "%s:<S2SV_blank>command<S2SV_blank>not<S2SV_blank>found\\n" , argv [ 0 ] ) ; } release_and_continue : <S2SV_StartBug> release_argv ( argc , argv ) ; <S2SV_EndBug> continue ; release_and_exit : <S2SV_StartBug> release_argv ( argc , argv ) ; <S2SV_EndBug> break ; } return 0 ; } | <S2SV_ModStart> ) { goto release_and_exit <S2SV_ModEnd> ; } else <S2SV_ModStart> ( argc , & <S2SV_ModStart> ( argc , & |
1,521 | CWE-000 int omap_gem_get_paddr ( struct drm_gem_object * obj , dma_addr_t * paddr , bool remap ) { struct omap_drm_private * priv = obj -> dev -> dev_private ; struct omap_gem_object * omap_obj = to_omap_bo ( obj ) ; int ret = 0 ; mutex_lock ( & obj -> dev -> struct_mutex ) ; if ( remap && is_shmem ( obj ) && priv -> has_dmm ) { if ( omap_obj -> paddr_cnt == 0 ) { struct page * * pages ; uint32_t npages = obj -> size >> PAGE_SHIFT ; enum tiler_fmt fmt = gem2fmt ( omap_obj -> flags ) ; struct tiler_block * block ; BUG_ON ( omap_obj -> block ) ; ret = get_pages ( obj , & pages ) ; if ( ret ) goto fail ; if ( omap_obj -> flags & OMAP_BO_TILED ) { block = tiler_reserve_2d ( fmt , omap_obj -> width , omap_obj -> height , 0 ) ; } else { block = tiler_reserve_1d ( obj -> size ) ; } if ( IS_ERR ( block ) ) { ret = PTR_ERR ( block ) ; dev_err ( obj -> dev -> dev , "could<S2SV_blank>not<S2SV_blank>remap:<S2SV_blank>%d<S2SV_blank>(%d)\\n" , ret , fmt ) ; goto fail ; } ret = tiler_pin ( block , pages , npages , omap_obj -> roll , true ) ; if ( ret ) { tiler_release ( block ) ; dev_err ( obj -> dev -> dev , "could<S2SV_blank>not<S2SV_blank>pin:<S2SV_blank>%d\\n" , ret ) ; goto fail ; } omap_obj -> paddr = tiler_ssptr ( block ) ; omap_obj -> block = block ; <S2SV_StartBug> DBG ( "got<S2SV_blank>paddr:<S2SV_blank>%08x" , omap_obj -> paddr ) ; <S2SV_EndBug> } omap_obj -> paddr_cnt ++ ; * paddr = omap_obj -> paddr ; } else if ( omap_obj -> flags & OMAP_BO_DMA ) { * paddr = omap_obj -> paddr ; } else { ret = - EINVAL ; goto fail ; } fail : mutex_unlock ( & obj -> dev -> struct_mutex ) ; return ret ; } | <S2SV_ModStart> ; DBG ( "got<S2SV_blank>paddr:<S2SV_blank>%pad" , & <S2SV_ModEnd> omap_obj -> paddr |
1,522 | CWE-000 void fan_pwm_init ( struct fsd_dev * p ) { ktime_t ktime ; int i ; <S2SV_StartBug> int pg5_input ; <S2SV_EndBug> int pg13_input ; pg5_input = 0 ; if ( pg5_input != 0 ) p -> use_hw_pwm = 1 ; else p -> use_hw_pwm = 0 ; printk ( "Use<S2SV_blank>%s<S2SV_blank>PWM<S2SV_blank>for<S2SV_blank>fan\\n" , p -> use_hw_pwm ? "hardware" : "software" ) ; if ( p -> use_hw_pwm ) { set_pd28_as_pwm ( p ) ; p -> hw_pwm_duty = 100 ; p -> hw_pwm_cycles = HW_PWM_ENTIRE_CYCLE_NUM ; enable_hw_pwm ( p ) ; } else { pl10_enable_output_high ( p ) ; pd28_enable_output_high ( p ) ; p -> pwm_period_cnt = GPIO_PWM_PERIOD_CNT ; for ( i = 0 ; i < FAN_COUNT ; i ++ ) { p -> pwm_duty [ i ] = PWM_DUTY_DEFAULT ; p -> pwm_duty_cnt [ i ] = p -> pwm_period_cnt * p -> pwm_duty [ i ] / 100 ; p -> pwm_time_cnt [ i ] = 0 ; } p -> pwm_timer_period_us = 200 ; printk ( "Set<S2SV_blank>the<S2SV_blank>period<S2SV_blank>of<S2SV_blank>fan\'s<S2SV_blank>htimer<S2SV_blank>to<S2SV_blank>%ldus\\n" , p -> pwm_timer_period_us ) ; ktime = ktime_set ( 0 , p -> pwm_timer_period_us * 1000 ) ; hrtimer_init ( & p -> pwm_timer , CLOCK_MONOTONIC , HRTIMER_MODE_REL ) ; p -> pwm_timer . function = & pwm_timer_handler ; hrtimer_start ( & p -> pwm_timer , ktime , HRTIMER_MODE_REL ) ; } } | <S2SV_ModStart> ; int pg5_input <S2SV_ModEnd> ; pg5_input = |
1,523 | CWE-000 A jtapip ( J jt , A a , A w , A self ) { F2PREFIP ; A h ; C * av , * wv ; I ak , at , ar , * as , k , p , * u , * v , wk , wm , wn , wt , wr , * ws ; RZ ( a && w ) ; <S2SV_StartBug> if ( ( ( ( I ) jtinplace & JTINPLACEA ) && ( ACIPISOK ( a ) || jt -> assignsym && jt -> assignsym -> val == a && ( ( AC ( a ) <= 1 && notonupperstack ( a ) ) || ( AFNJA & AFLAG ( a ) && AC ( a ) == 2 ) ) ) ) && AT ( a ) & ( DIRECT | BOX ) ) { I an = AN ( a ) ; <S2SV_EndBug> if ( AT ( a ) & BOX ) { I oldac = ACUC ( a ) ; ra0 ( w ) ; if ( AC ( a ) > oldac || ! ( ( AFLAG ( a ) & AFLAG ( w ) ) & AFNOSMREL ) ) an = 0 ; } if ( an && ( ar = AR ( a ) ) && ar >= ( wr = AR ( w ) ) && ! TYPESGT ( wt = AT ( w ) , at = AT ( a ) ) && ! jt -> rank ) { I naxes = MIN ( wr , ar - 1 ) ; u = ar + ( as = AS ( a ) ) - naxes ; v = wr + ( ws = AS ( w ) ) - naxes ; k = bp ( at ) ; ak = k * an ; wm = ar == wr ? * ws : 1 ; wn = wm * aii ( a ) ; wk = k * wn ; p = 0 ; DO ( naxes , p |= * u ++ - * v ++ ; ) ; if ( p >= 0 ) { if ( allosize ( a ) >= ak + wk + ( 1 && at & LAST0 ) ) { if ( TYPESGT ( at , wt ) ) RZ ( w = cvt ( at , w ) ) ; if ( p ) { RZ ( h = vec ( INT , wr , as + ar - wr ) ) ; if ( ar == wr ) * AV ( h ) = * ws ; RZ ( w = take ( h , w ) ) ; } av = ak + CAV ( a ) ; wv = CAV ( w ) ; I wlen = k * AN ( w ) ; if ( wr && ar > 1 + wr ) { RZ ( setfv ( a , w ) ) ; mvc ( wk - wlen , av + wlen , k , jt -> fillv ) ; } if ( wr ) MC ( av , wv , wlen ) ; else mvc ( wk , av , k , wv ) ; if ( UCISRECUR ( a ) ) { A * aav = ( A * ) av ; DO ( wn , ras ( aav [ i ] ) ; ) } * as += wm ; AN ( a ) += wn ; if ( at & LAST0 ) * ( av + wk ) = 0 ; RETF ( a ) ; } } } } R ( over ( a , w ) ) ; } | <S2SV_ModStart> JTINPLACEA ) && ASGNINPLACENJA ( a <S2SV_ModEnd> ) ) && |
1,524 | CWE-000 static GF_Err HEVC_GetCapabilities ( GF_BaseDecoder * ifcg , GF_CodecCapability * capability ) { HEVCDec * ctx = ( HEVCDec * ) ifcg -> privateStack ; switch ( capability -> CapCode ) { case GF_CODEC_RESILIENT : capability -> cap . valueInt = 1 ; break ; case GF_CODEC_WIDTH : capability -> cap . valueInt = ctx -> width ; if ( ctx -> pack_mode ) { capability -> cap . valueInt *= 2 ; } break ; case GF_CODEC_HEIGHT : capability -> cap . valueInt = ctx -> height ; if ( ctx -> pack_mode ) { capability -> cap . valueInt *= 2 ; } break ; case GF_CODEC_STRIDE : capability -> cap . valueInt = ctx -> stride ; if ( ctx -> pack_mode ) { capability -> cap . valueInt *= 2 ; } break ; case GF_CODEC_PAR : capability -> cap . valueInt = ctx -> pixel_ar ; break ; case GF_CODEC_OUTPUT_SIZE : capability -> cap . valueInt = ctx -> out_size ; if ( ctx -> pack_mode ) { capability -> cap . valueInt *= 4 ; } break ; case GF_CODEC_NBVIEWS : capability -> cap . valueInt = ctx -> nb_views ; break ; case GF_CODEC_NBLAYERS : capability -> cap . valueInt = ctx -> nb_layers ; break ; case GF_CODEC_PIXEL_FORMAT : capability -> cap . valueInt = HEVC_GetPixelFormat ( ctx -> luma_bpp , ctx -> chroma_format_idc ) ; break ; case GF_CODEC_BUFFER_MIN : capability -> cap . valueInt = 1 ; break ; case GF_CODEC_BUFFER_MAX : capability -> cap . valueInt = ctx -> output_cb_size ; break ; case GF_CODEC_WANTS_THREAD : capability -> cap . valueBool = GF_TRUE ; break ; case GF_CODEC_PADDING_BYTES : capability -> cap . valueInt = 32 ; break ; case GF_CODEC_REORDER : capability -> cap . valueInt = 1 ; break ; case GF_CODEC_TRUSTED_CTS : capability -> cap . valueInt = 1 ; break ; case GF_CODEC_RAW_MEMORY : capability -> cap . valueBool = GF_TRUE ; break ; case GF_CODEC_FORCE_ANNEXB : <S2SV_StartBug> capability -> cap . valueBool = ctx -> force_annex_b ; <S2SV_EndBug> break ; case GF_CODEC_CU_DURATION : default : capability -> cap . valueInt = 0 ; break ; } return GF_OK ; } | <S2SV_ModStart> case GF_CODEC_FORCE_ANNEXB : { const char * opt = gf_modules_get_option ( ( GF_BaseInterface * ) ifcg , "OpenHEVC" , "ForceAnnexB" ) ; if ( ! opt ) gf_modules_set_option ( ( GF_BaseInterface * ) ifcg , "OpenHEVC" , "ForceAnnexB" , "no" ) ; else if ( ! strcmp ( opt , "yes" ) ) <S2SV_ModStart> . valueBool = GF_TRUE ; } <S2SV_ModEnd> break ; case |
1,525 | CWE-000 reloc_howto_type * bfd_default_reloc_type_lookup ( bfd * abfd , bfd_reloc_code_real_type code ) { switch ( code ) { case BFD_RELOC_CTOR : switch ( bfd_arch_bits_per_address ( abfd ) ) { case 64 : BFD_FAIL ( ) ; <S2SV_StartBug> case 32 : <S2SV_EndBug> return & bfd_howto_32 ; case 16 : <S2SV_StartBug> BFD_FAIL ( ) ; <S2SV_EndBug> default : BFD_FAIL ( ) ; } default : BFD_FAIL ( ) ; } return NULL ; } | <S2SV_ModStart> ( ) ; break ; <S2SV_ModStart> BFD_FAIL ( ) ; break |
1,526 | CWE-000 Bitmapset * ExecFindInitialMatchingSubPlans ( PartitionPruneState * prunestate , int nsubplans ) { PartitionPruningData * pprune ; MemoryContext oldcontext ; Bitmapset * result = NULL ; Assert ( prunestate -> do_initial_prune ) ; pprune = prunestate -> partprunedata ; oldcontext = MemoryContextSwitchTo ( prunestate -> prune_context ) ; find_matching_subplans_recurse ( prunestate , pprune , true , & result ) ; MemoryContextSwitchTo ( oldcontext ) ; result = bms_copy ( result ) ; MemoryContextReset ( prunestate -> prune_context ) ; ResetExprContext ( pprune -> context . planstate -> ps_ExprContext ) ; if ( bms_num_members ( result ) < nsubplans ) { int * new_subplan_indexes ; int i ; int newidx ; new_subplan_indexes = ( int * ) palloc ( sizeof ( int ) * nsubplans ) ; newidx = 0 ; for ( i = 0 ; i < nsubplans ; i ++ ) { if ( bms_is_member ( i , result ) ) new_subplan_indexes [ i ] = newidx ++ ; else new_subplan_indexes [ i ] = - 1 ; } <S2SV_StartBug> for ( i = 0 ; i < prunestate -> num_partprunedata ; i ++ ) <S2SV_EndBug> { int nparts ; int j ; pprune = & prunestate -> partprunedata [ i ] ; nparts = pprune -> context . nparts ; bms_free ( pprune -> present_parts ) ; pprune -> present_parts = NULL ; for ( j = 0 ; j < nparts ; j ++ ) { int oldidx = pprune -> subplan_map [ j ] ; <S2SV_StartBug> if ( oldidx >= 0 ) <S2SV_EndBug> { <S2SV_StartBug> pprune -> subplan_map [ j ] = new_subplan_indexes [ oldidx ] ; <S2SV_EndBug> if ( new_subplan_indexes [ oldidx ] >= 0 ) pprune -> present_parts = bms_add_member ( pprune -> present_parts , j ) ; } <S2SV_StartBug> } <S2SV_EndBug> } if ( prunestate -> num_partprunedata > 1 ) { for ( i = 0 ; i < prunestate -> num_partprunedata ; i ++ ) { int nparts ; int j ; pprune = & prunestate -> partprunedata [ i ] ; nparts = pprune -> context . nparts ; for ( j = 0 ; j < nparts ; j ++ ) { <S2SV_StartBug> int subidx = pprune -> subpart_map [ j ] ; <S2SV_EndBug> if ( subidx >= 0 ) { PartitionPruningData * subprune ; subprune = & prunestate -> partprunedata [ subidx ] ; if ( ! bms_is_empty ( subprune -> present_parts ) ) pprune -> present_parts = bms_add_member ( pprune -> present_parts , j ) ; } } } <S2SV_StartBug> } <S2SV_EndBug> pfree ( new_subplan_indexes ) ; } return result ; } | <S2SV_ModStart> ( i = <S2SV_ModEnd> prunestate -> num_partprunedata <S2SV_ModStart> prunestate -> num_partprunedata - 1 ; i >= 0 ; i -- <S2SV_ModEnd> ) { int <S2SV_ModStart> j ] ; int subidx ; <S2SV_ModStart> 0 ) { Assert ( oldidx < nsubplans ) ; <S2SV_ModStart> ) ; } else if ( ( <S2SV_ModEnd> subidx = pprune <S2SV_ModStart> [ j ] ) <S2SV_ModEnd> >= 0 ) <S2SV_ModStart> } } } <S2SV_ModEnd> pfree ( new_subplan_indexes |
1,527 | CWE-000 ENCODER_INIT ( hz ) { <S2SV_StartBug> state -> i = 0 ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> { state -> c [ CN_STATE_OFFSET ] <S2SV_ModEnd> = 0 ; |
1,528 | CWE-000 int tls_set_sw_offload ( struct sock * sk , struct tls_context * ctx ) { char keyval [ TLS_CIPHER_AES_GCM_128_KEY_SIZE ] ; struct tls_crypto_info * crypto_info ; struct tls12_crypto_info_aes_gcm_128 * gcm_128_info ; struct tls_sw_context * sw_ctx ; u16 nonce_size , tag_size , iv_size , rec_seq_size ; char * iv , * rec_seq ; int rc = 0 ; if ( ! ctx ) { rc = - EINVAL ; goto out ; } if ( ctx -> priv_ctx ) { rc = - EEXIST ; goto out ; } sw_ctx = kzalloc ( sizeof ( * sw_ctx ) , GFP_KERNEL ) ; if ( ! sw_ctx ) { rc = - ENOMEM ; goto out ; } ctx -> priv_ctx = ( struct tls_offload_context * ) sw_ctx ; crypto_info = & ctx -> crypto_send ; switch ( crypto_info -> cipher_type ) { case TLS_CIPHER_AES_GCM_128 : { nonce_size = TLS_CIPHER_AES_GCM_128_IV_SIZE ; tag_size = TLS_CIPHER_AES_GCM_128_TAG_SIZE ; iv_size = TLS_CIPHER_AES_GCM_128_IV_SIZE ; iv = ( ( struct tls12_crypto_info_aes_gcm_128 * ) crypto_info ) -> iv ; rec_seq_size = TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE ; rec_seq = ( ( struct tls12_crypto_info_aes_gcm_128 * ) crypto_info ) -> rec_seq ; gcm_128_info = ( struct tls12_crypto_info_aes_gcm_128 * ) crypto_info ; break ; } default : rc = - EINVAL ; goto out ; } ctx -> prepend_size = TLS_HEADER_SIZE + nonce_size ; ctx -> tag_size = tag_size ; ctx -> overhead_size = ctx -> prepend_size + ctx -> tag_size ; ctx -> iv_size = iv_size ; <S2SV_StartBug> ctx -> iv = kmalloc ( iv_size , GFP_KERNEL ) ; <S2SV_EndBug> if ( ! ctx -> iv ) { rc = - ENOMEM ; goto out ; } memcpy ( ctx -> iv , gcm_128_info -> salt , TLS_CIPHER_AES_GCM_128_SALT_SIZE ) ; memcpy ( ctx -> iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE , iv , iv_size ) ; ctx -> rec_seq_size = rec_seq_size ; ctx -> rec_seq = kmalloc ( rec_seq_size , GFP_KERNEL ) ; if ( ! ctx -> rec_seq ) { rc = - ENOMEM ; goto free_iv ; } memcpy ( ctx -> rec_seq , rec_seq , rec_seq_size ) ; sg_init_table ( sw_ctx -> sg_encrypted_data , ARRAY_SIZE ( sw_ctx -> sg_encrypted_data ) ) ; sg_init_table ( sw_ctx -> sg_plaintext_data , ARRAY_SIZE ( sw_ctx -> sg_plaintext_data ) ) ; sg_init_table ( sw_ctx -> sg_aead_in , 2 ) ; sg_set_buf ( & sw_ctx -> sg_aead_in [ 0 ] , sw_ctx -> aad_space , sizeof ( sw_ctx -> aad_space ) ) ; sg_unmark_end ( & sw_ctx -> sg_aead_in [ 1 ] ) ; sg_chain ( sw_ctx -> sg_aead_in , 2 , sw_ctx -> sg_plaintext_data ) ; sg_init_table ( sw_ctx -> sg_aead_out , 2 ) ; sg_set_buf ( & sw_ctx -> sg_aead_out [ 0 ] , sw_ctx -> aad_space , sizeof ( sw_ctx -> aad_space ) ) ; sg_unmark_end ( & sw_ctx -> sg_aead_out [ 1 ] ) ; sg_chain ( sw_ctx -> sg_aead_out , 2 , sw_ctx -> sg_encrypted_data ) ; if ( ! sw_ctx -> aead_send ) { sw_ctx -> aead_send = crypto_alloc_aead ( "gcm(aes)" , 0 , 0 ) ; if ( IS_ERR ( sw_ctx -> aead_send ) ) { rc = PTR_ERR ( sw_ctx -> aead_send ) ; sw_ctx -> aead_send = NULL ; goto free_rec_seq ; } } sk -> sk_destruct = tls_sw_sk_destruct ; ctx -> push_pending_record = tls_sw_push_pending_record ; memcpy ( keyval , gcm_128_info -> key , TLS_CIPHER_AES_GCM_128_KEY_SIZE ) ; rc = crypto_aead_setkey ( sw_ctx -> aead_send , keyval , TLS_CIPHER_AES_GCM_128_KEY_SIZE ) ; if ( rc ) goto free_aead ; rc = crypto_aead_setauthsize ( sw_ctx -> aead_send , ctx -> tag_size ) ; if ( ! rc ) goto out ; free_aead : crypto_free_aead ( sw_ctx -> aead_send ) ; sw_ctx -> aead_send = NULL ; free_rec_seq : kfree ( ctx -> rec_seq ) ; ctx -> rec_seq = NULL ; free_iv : kfree ( ctx -> iv ) ; ctx -> iv = NULL ; out : return rc ; } | <S2SV_ModStart> kmalloc ( iv_size + TLS_CIPHER_AES_GCM_128_SALT_SIZE , <S2SV_ModEnd> GFP_KERNEL ) ; |
1,529 | CWE-000 <S2SV_StartBug> IO_METHOD ( IoNumber , isUppercase ) <S2SV_EndBug> { <S2SV_StartBug> return IOBOOL ( self , isupper ( ( int ) DATA ( self ) ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( IoNumber , isLowercase <S2SV_ModEnd> ) { return <S2SV_ModStart> ( self , islower <S2SV_ModEnd> ( ( int |
1,530 | CWE-000 s32 javax_mini_reflect_Field_mapField ( Runtime * runtime , Class * clazz ) { int pos = 0 ; Instance * ins = ( Instance * ) ( runtime -> localVariables + pos ++ ) -> refer ; Long2Double l2d ; l2d . i2l . i1 = ( runtime -> localVariables + pos ++ ) -> integer ; l2d . i2l . i0 = ( runtime -> localVariables + pos ++ ) -> integer ; FieldInfo * fieldInfo = ( __refer ) ( long ) l2d . l ; if ( ins && fieldInfo ) { c8 * ptr ; ptr = getFieldPtr_byName_c ( ins , JDWP_CLASS_FIELD , "fieldName" , "Ljava/lang/String;" ) ; <S2SV_StartBug> Instance * fieldName = jstring_create ( fieldInfo -> name , runtime ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ptr ) setFieldRefer ( ptr , fieldName ) ; <S2SV_EndBug> garbage_refer ( fieldName , ins ) ; <S2SV_StartBug> ptr = getFieldPtr_byName_c ( ins , JDWP_CLASS_FIELD , "accessFlags" , "S" ) ; <S2SV_EndBug> if ( ptr ) setFieldShort ( ptr , fieldInfo -> access_flags ) ; ptr = getFieldPtr_byName_c ( ins , JDWP_CLASS_FIELD , "signature" , "Ljava/lang/String;" ) ; <S2SV_StartBug> Instance * signature = jstring_create ( fieldInfo -> descriptor , runtime ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ptr ) setFieldRefer ( ptr , signature ) ; <S2SV_EndBug> <S2SV_StartBug> garbage_refer ( signature , ins ) ; <S2SV_EndBug> } return 0 ; } | <S2SV_ModStart> "Ljava/lang/String;" ) ; if ( ptr ) { <S2SV_ModStart> runtime ) ; <S2SV_ModEnd> setFieldRefer ( ptr <S2SV_ModStart> ins ) ; } <S2SV_ModStart> "Ljava/lang/String;" ) ; if ( ptr ) { <S2SV_ModStart> runtime ) ; <S2SV_ModEnd> setFieldRefer ( ptr <S2SV_ModStart> ins ) ; } |
1,531 | CWE-000 int main ( ) { Hashable * hashable1 = make_hashable_int ( 1 ) ; Hashable * hashable2 = make_hashable_string ( "Apple" ) ; Hashable * hashable3 = make_hashable_int ( 2 ) ; <S2SV_StartBug> Value * value1 = make_int_value ( 17 ) ; <S2SV_EndBug> Node * node1 = make_node ( hashable1 , value1 , NULL ) ; print_node ( node1 ) ; <S2SV_StartBug> Value * value2 = make_string_value ( "Orange" ) ; <S2SV_EndBug> Node * list = prepend ( hashable2 , value2 , node1 ) ; <S2SV_StartBug> print_list ( list ) ; <S2SV_EndBug> Value * value = list_lookup ( list , hashable1 ) ; print_lookup ( value ) ; value = list_lookup ( list , hashable2 ) ; print_lookup ( value ) ; value = list_lookup ( list , hashable3 ) ; print_lookup ( value ) ; Map * map = make_map ( 10 ) ; map_add ( map , hashable1 , value1 ) ; map_add ( map , hashable2 , value2 ) ; printf ( "Map\\n" ) ; print_map ( map ) ; value = map_lookup ( map , hashable1 ) ; print_lookup ( value ) ; value = map_lookup ( map , hashable2 ) ; print_lookup ( value ) ; value = map_lookup ( map , hashable3 ) ; print_lookup ( value ) ; return 0 ; } | <S2SV_ModStart> 2 ) ; printf ( "Node<S2SV_blank>1\\n" ) ; <S2SV_ModStart> node1 ) ; printf ( "List\\n" ) ; <S2SV_ModStart> print_list ( list ) ; printf ( "Test<S2SV_blank>lookup\\n" |
1,532 | CWE-000 static int arc_hdr_decrypt ( arc_buf_hdr_t * hdr , spa_t * spa , const zbookmark_phys_t * zb ) { int ret ; abd_t * cabd = NULL ; void * tmp = NULL ; boolean_t no_crypt = B_FALSE ; boolean_t bswap = ( hdr -> b_l1hdr . b_byteswap != DMU_BSWAP_NUMFUNCS ) ; <S2SV_StartBug> ASSERT ( MUTEX_HELD ( HDR_LOCK ( hdr ) ) || HDR_EMPTY ( hdr ) ) ; <S2SV_EndBug> ASSERT ( HDR_ENCRYPTED ( hdr ) ) ; arc_hdr_alloc_abd ( hdr , B_FALSE ) ; ret = spa_do_crypt_abd ( B_FALSE , spa , zb , hdr -> b_crypt_hdr . b_ot , B_FALSE , bswap , hdr -> b_crypt_hdr . b_salt , hdr -> b_crypt_hdr . b_iv , hdr -> b_crypt_hdr . b_mac , HDR_GET_PSIZE ( hdr ) , hdr -> b_l1hdr . b_pabd , hdr -> b_crypt_hdr . b_rabd , & no_crypt ) ; if ( ret != 0 ) goto error ; if ( no_crypt ) { abd_copy ( hdr -> b_l1hdr . b_pabd , hdr -> b_crypt_hdr . b_rabd , HDR_GET_PSIZE ( hdr ) ) ; } if ( HDR_GET_COMPRESS ( hdr ) != ZIO_COMPRESS_OFF && ! HDR_COMPRESSION_ENABLED ( hdr ) ) { cabd = arc_get_data_abd ( hdr , arc_hdr_size ( hdr ) , hdr ) ; tmp = abd_borrow_buf ( cabd , arc_hdr_size ( hdr ) ) ; ret = zio_decompress_data ( HDR_GET_COMPRESS ( hdr ) , hdr -> b_l1hdr . b_pabd , tmp , HDR_GET_PSIZE ( hdr ) , HDR_GET_LSIZE ( hdr ) ) ; if ( ret != 0 ) { abd_return_buf ( cabd , tmp , arc_hdr_size ( hdr ) ) ; goto error ; } abd_return_buf_copy ( cabd , tmp , arc_hdr_size ( hdr ) ) ; arc_free_data_abd ( hdr , hdr -> b_l1hdr . b_pabd , arc_hdr_size ( hdr ) , hdr ) ; hdr -> b_l1hdr . b_pabd = cabd ; } return ( 0 ) ; error : arc_hdr_free_abd ( hdr , B_FALSE ) ; if ( cabd != NULL ) arc_free_data_buf ( hdr , cabd , arc_hdr_size ( hdr ) , hdr ) ; return ( ret ) ; } | <S2SV_ModStart> ; ASSERT ( HDR_EMPTY_OR_LOCKED <S2SV_ModEnd> ( hdr ) |
1,533 | CWE-000 static int bif_iso_findall ( tpl_query * q ) { node * args = get_args ( q ) ; node * term1 = get_term ( term1 ) ; node * term2 = get_callable ( term2 ) ; node * term3 = get_term ( term3 ) ; tpl_query * subq = query_create_subquery ( q ) ; if ( ! subq ) { QABORT ( ABORT_OUTOFMEMORY ) ; return 0 ; } int did_lock = 0 ; if ( is_dynamic ( term2 ) && ! q -> in_tran ) { did_lock = 1 ; DBLOCK ( q -> c . curr_db ) ; } node * from = copy_term ( q , term2 ) ; begin_query ( subq , from ) ; int ok = query_run ( subq ) ; node * save_l = NULL , * l = NULL ; while ( ok && ! g_abort ) { node * from = subst ( subq , term1 , FUDGE_FACTOR ) ; node * res2 = copy_term ( subq , from ) ; node * res = skim_copy_term ( q , res2 ) ; term_heapcheck ( res2 ) ; if ( ! l ) { save_l = l = make_list ( ) ; term_append ( l , res ) ; } else { node * tmp = make_list ( ) ; term_append ( tmp , res ) ; l = term_append ( l , tmp ) ; } ok = query_continue ( subq ) ; } if ( did_lock ) DBUNLOCK ( q -> c . curr_db ) ; if ( l ) term_append ( l , make_const_atom ( "[]" ) ) ; else save_l = make_const_atom ( "[]" ) ; <S2SV_StartBug> ok = unify ( q , term3 , term3_ctx , save_l , term1_ctx ) ; <S2SV_EndBug> term_heapcheck ( save_l ) ; term_heapcheck ( from ) ; query_destroy ( subq ) ; return ok ; } | <S2SV_ModStart> , save_l , term3_ctx <S2SV_ModEnd> ) ; term_heapcheck |
1,534 | CWE-000 void nvs_light_state_save ( void ) { <S2SV_StartBug> if ( nvs_write ( & fs , NVS_LED_STATE_ID , & light_state_current , sizeof ( struct light_state_t ) ) == sizeof ( struct light_state_t ) ) <S2SV_EndBug> { printk ( "\\n\\rLight<S2SV_blank>state<S2SV_blank>has<S2SV_blank>saved<S2SV_blank>!!\\n\\r" ) ; } else { printk ( "\\n\\rLight<S2SV_blank>state<S2SV_blank>has<S2SV_blank>not<S2SV_blank>saved<S2SV_blank>!!\\n\\r" ) ; } } | <S2SV_ModStart> light_state_t ) ) > 0 <S2SV_ModEnd> ) { printk |
1,535 | CWE-000 int rp_dt_get_values_wrapper ( rp_ctx_t * rp_ctx , rp_session_t * rp_session , sr_mem_ctx_t * sr_mem , const char * xpath , sr_val_t * * values , size_t * count ) { CHECK_NULL_ARG4 ( rp_ctx , rp_ctx -> dm_ctx , rp_session , rp_session -> dm_session ) ; CHECK_NULL_ARG3 ( xpath , values , count ) ; SR_LOG_INF ( "Get<S2SV_blank>items<S2SV_blank>request<S2SV_blank>%s<S2SV_blank>datastore,<S2SV_blank>xpath:<S2SV_blank>%s" , sr_ds_to_str ( rp_session -> datastore ) , xpath ) ; int rc = SR_ERR_OK ; struct lyd_node * data_tree = NULL ; rc = rp_dt_prepare_data ( rp_ctx , rp_session , xpath , SR_API_VALUES , 0 , & data_tree ) ; CHECK_RC_MSG_GOTO ( rc , cleanup , "rp_dt_prepare_data<S2SV_blank>failed" ) ; if ( RP_REQ_WAITING_FOR_DATA == rp_session -> state ) { SR_LOG_DBG ( "Session<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%u<S2SV_blank>is<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>the<S2SV_blank>data" , rp_session -> id ) ; return rc ; } if ( NULL == data_tree ) { rc = SR_ERR_NOT_FOUND ; goto cleanup ; } rc = rp_dt_get_values ( rp_ctx -> dm_ctx , rp_session , data_tree , sr_mem , xpath , dm_is_running_ds_session ( rp_session -> dm_session ) , values , count ) ; <S2SV_StartBug> if ( SR_ERR_OK != rc && SR_ERR_NOT_FOUND != rc ) { <S2SV_EndBug> SR_LOG_ERR ( "Get<S2SV_blank>values<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>xpath<S2SV_blank>\'%s\'" , xpath ) ; <S2SV_StartBug> } else if ( SR_ERR_UNAUTHORIZED == rc ) { <S2SV_EndBug> rc = SR_ERR_NOT_FOUND ; } cleanup : rp_session -> state = RP_REQ_FINISHED ; free ( rp_session -> module_name ) ; rp_session -> module_name = NULL ; return rc ; } | <S2SV_ModStart> count ) ; if ( SR_ERR_UNAUTHORIZED == rc ) { rc = SR_ERR_NOT_FOUND ; } else <S2SV_ModStart> ) ; } <S2SV_ModEnd> cleanup : rp_session |
1,536 | CWE-000 <S2SV_StartBug> static int seaslog_init_stream_list ( TSRMLS_D ) <S2SV_EndBug> { zval * z_stream_list ; # if PHP_VERSION_ID >= 70000 array_init ( & SEASLOG_G ( stream_list ) ) ; # else MAKE_STD_ZVAL ( z_stream_list ) ; array_init ( z_stream_list ) ; SEASLOG_G ( stream_list ) = z_stream_list ; # endif } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static void <S2SV_ModEnd> seaslog_init_stream_list ( TSRMLS_D |
1,537 | CWE-000 static bool collectMatchBitmap ( GinBtreeData * btree , GinBtreeStack * stack , GinScanEntry scanEntry , Snapshot snapshot ) { OffsetNumber attnum ; Form_pg_attribute attr ; scanEntry -> matchBitmap = tbm_create ( work_mem * 1024L , NULL ) ; if ( scanEntry -> isPartialMatch && scanEntry -> queryCategory != GIN_CAT_NORM_KEY ) return true ; attnum = scanEntry -> attnum ; attr = TupleDescAttr ( btree -> ginstate -> origTupdesc , attnum - 1 ) ; <S2SV_StartBug> GinPredicateLockPage ( btree -> index , stack -> buffer , snapshot ) ; <S2SV_EndBug> for ( ; ; ) { Page page ; IndexTuple itup ; Datum idatum ; GinNullCategory icategory ; if ( moveRightIfItNeeded ( btree , stack , snapshot ) == false ) return true ; page = BufferGetPage ( stack -> buffer ) ; TestForOldSnapshot ( snapshot , btree -> index , page ) ; itup = ( IndexTuple ) PageGetItem ( page , PageGetItemId ( page , stack -> off ) ) ; if ( gintuple_get_attrnum ( btree -> ginstate , itup ) != attnum ) return true ; idatum = gintuple_get_key ( btree -> ginstate , itup , & icategory ) ; if ( scanEntry -> isPartialMatch ) { int32 cmp ; if ( icategory != GIN_CAT_NORM_KEY ) return true ; cmp = DatumGetInt32 ( FunctionCall4Coll ( & btree -> ginstate -> comparePartialFn [ attnum - 1 ] , btree -> ginstate -> supportCollation [ attnum - 1 ] , scanEntry -> queryKey , idatum , UInt16GetDatum ( scanEntry -> strategy ) , PointerGetDatum ( scanEntry -> extra_data ) ) ) ; if ( cmp > 0 ) return true ; else if ( cmp < 0 ) { stack -> off ++ ; continue ; } } else if ( scanEntry -> searchMode == GIN_SEARCH_MODE_ALL ) { if ( icategory == GIN_CAT_NULL_ITEM ) return true ; } if ( GinIsPostingTree ( itup ) ) { BlockNumber rootPostingTree = GinGetPostingTree ( itup ) ; if ( icategory == GIN_CAT_NORM_KEY ) idatum = datumCopy ( idatum , attr -> attbyval , attr -> attlen ) ; <S2SV_StartBug> LockBuffer ( stack -> buffer , GIN_UNLOCK ) ; <S2SV_EndBug> scanPostingTree ( btree -> index , scanEntry , rootPostingTree , snapshot ) ; LockBuffer ( stack -> buffer , GIN_SHARE ) ; page = BufferGetPage ( stack -> buffer ) ; if ( ! GinPageIsLeaf ( page ) ) { return false ; } for ( ; ; ) { Datum newDatum ; GinNullCategory newCategory ; if ( moveRightIfItNeeded ( btree , stack , snapshot ) == false ) elog ( ERROR , "lost<S2SV_blank>saved<S2SV_blank>point<S2SV_blank>in<S2SV_blank>index" ) ; page = BufferGetPage ( stack -> buffer ) ; itup = ( IndexTuple ) PageGetItem ( page , PageGetItemId ( page , stack -> off ) ) ; if ( gintuple_get_attrnum ( btree -> ginstate , itup ) != attnum ) elog ( ERROR , "lost<S2SV_blank>saved<S2SV_blank>point<S2SV_blank>in<S2SV_blank>index" ) ; newDatum = gintuple_get_key ( btree -> ginstate , itup , & newCategory ) ; if ( ginCompareEntries ( btree -> ginstate , attnum , newDatum , newCategory , idatum , icategory ) == 0 ) break ; stack -> off ++ ; } if ( icategory == GIN_CAT_NORM_KEY && ! attr -> attbyval ) pfree ( DatumGetPointer ( idatum ) ) ; } else { ItemPointer ipd ; int nipd ; ipd = ginReadTuple ( btree -> ginstate , scanEntry -> attnum , itup , & nipd ) ; tbm_add_tuples ( scanEntry -> matchBitmap , ipd , nipd , false ) ; scanEntry -> predictNumberResult += GinGetNPosting ( itup ) ; pfree ( ipd ) ; } stack -> off ++ ; } } | <S2SV_ModStart> 1 ) ; PredicateLockPage <S2SV_ModEnd> ( btree -> <S2SV_ModStart> buffer , GIN_UNLOCK ) ; PredicateLockPage ( btree -> index , rootPostingTree , snapshot |
1,538 | CWE-000 static void tegra_xudc_handle_transfer_completion ( struct tegra_xudc * xudc , struct tegra_xudc_ep * ep , struct tegra_xudc_trb * event ) { struct tegra_xudc_request * req ; struct tegra_xudc_trb * trb ; bool short_packet ; short_packet = ( trb_read_cmpl_code ( event ) == TRB_CMPL_CODE_SHORT_PACKET ) ; trb = trb_phys_to_virt ( ep , trb_read_data_ptr ( event ) ) ; req = trb_to_request ( ep , trb ) ; if ( req && ( short_packet || ( ! trb_read_chain ( trb ) && ( req -> trbs_needed == req -> trbs_queued ) ) ) ) { struct tegra_xudc_trb * last = req -> last_trb ; unsigned int residual ; residual = trb_read_transfer_len ( event ) ; req -> usb_req . actual = req -> usb_req . length - residual ; dev_dbg ( xudc -> dev , "bytes<S2SV_blank>transfered<S2SV_blank>%u<S2SV_blank>/<S2SV_blank>%u\\n" , req -> usb_req . actual , req -> usb_req . length ) ; tegra_xudc_req_done ( ep , req , 0 ) ; <S2SV_StartBug> if ( usb_endpoint_xfer_control ( ep -> desc ) ) <S2SV_EndBug> tegra_xudc_ep0_req_done ( xudc ) ; if ( short_packet ) { ep -> deq_ptr = ( last - ep -> transfer_ring ) + 1 ; if ( ep -> deq_ptr == XUDC_TRANSFER_RING_SIZE - 1 ) ep -> deq_ptr = 0 ; } } else if ( ! req ) { dev_warn ( xudc -> dev , "transfer<S2SV_blank>event<S2SV_blank>on<S2SV_blank>dequeued<S2SV_blank>request\\n" ) ; } tegra_xudc_ep_kick_queue ( ep ) ; } | <S2SV_ModStart> ; if ( ep -> desc && |
1,539 | CWE-000 static void gen_implied_qual ( PlannerInfo * root , RestrictInfo * old_rinfo , Node * old_expr , Node * new_expr ) { Node * new_clause ; ReplaceExpressionMutatorReplacement ctx ; Relids new_qualscope ; ListCell * lc ; RestrictInfo * new_rinfo ; Relids required_relids ; Assert ( exprType ( old_expr ) == exprType ( new_expr ) && exprTypmod ( old_expr ) == exprTypmod ( new_expr ) ) ; ctx . replaceThis = old_expr ; ctx . withThis = new_expr ; ctx . numReplacementsDone = 0 ; new_clause = ( Node * ) replace_expression_mutator ( ( Node * ) old_rinfo -> clause , & ctx ) ; if ( ctx . numReplacementsDone == 0 ) return ; new_qualscope = pull_varnos ( new_clause ) ; if ( new_qualscope == NULL ) return ; if ( subexpression_match ( ( Expr * ) new_expr , old_rinfo -> clause ) ) return ; if ( old_rinfo -> ojscope_relids && ! bms_is_subset ( new_qualscope , old_rinfo -> ojscope_relids ) ) return ; foreach ( lc , root -> non_eq_clauses ) { RestrictInfo * r = ( RestrictInfo * ) lfirst ( lc ) ; if ( equal ( r -> clause , new_clause ) ) return ; } required_relids = bms_union ( new_qualscope , old_rinfo -> ojscope_relids ) ; new_rinfo = make_restrictinfo ( ( Expr * ) new_clause , old_rinfo -> is_pushed_down , old_rinfo -> outerjoin_delayed , old_rinfo -> pseudoconstant , required_relids , old_rinfo -> nullable_relids , old_rinfo -> ojscope_relids ) ; if ( bms_membership ( new_qualscope ) == BMS_MULTIPLE ) { <S2SV_StartBug> List * vars = pull_var_clause ( new_clause , PVC_INCLUDE_PLACEHOLDERS ) ; <S2SV_EndBug> add_vars_to_targetlist ( root , vars , required_relids ) ; list_free ( vars ) ; } distribute_restrictinfo_to_rels ( root , new_rinfo ) ; } | <S2SV_ModStart> ( new_clause , PVC_RECURSE_AGGREGATES , |
1,540 | CWE-000 int main ( void ) { WDTCTL = WDTPW | WDTHOLD ; P1DIR |= BIT0 ; P1OUT &= ~ BIT0 ; CSCTL0 = CSKEY ; CSCTL1 &= ~ DCOFSEL ; CSCTL1 |= DCOFSEL_6 ; CSCTL3 &= ~ ( DIVS | DIVM ) ; struct fann * ann ; struct fann_train_data * data ; fann_type * calc_out ; unsigned int i ; ann = fann_create_from_header ( ) ; if ( ! ann ) { return - 1 ; } fann_reset_MSE ( ann ) ; for ( i = 0 ; i < num_data ; i ++ ) { calc_out = fann_test ( ann , input [ i ] , output [ i ] ) ; # ifdef DEBUG printf ( "Test<S2SV_blank>result:<S2SV_blank>%f,<S2SV_blank>expected:<S2SV_blank>%f,<S2SV_blank>difference<S2SV_blank>=<S2SV_blank>%f\\n" , calc_out [ 2 ] , output [ i ] [ 2 ] , ( float ) fann_abs ( calc_out [ 2 ] - output [ i ] [ 2 ] ) ) ; <S2SV_StartBug> } <S2SV_EndBug> # endif printf ( "MSE<S2SV_blank>error<S2SV_blank>on<S2SV_blank>%d<S2SV_blank>test<S2SV_blank>data:<S2SV_blank>%f\\n" , num_data , fann_get_MSE ( ann ) ) ; fann_destroy ( ann ) ; __no_operation ( ) ; P1OUT |= BIT0 ; return 0 ; } | <S2SV_ModStart> ) ) ; # else __no_operation ( ) ; # endif } <S2SV_ModEnd> printf ( "MSE<S2SV_blank>error<S2SV_blank>on<S2SV_blank>%d<S2SV_blank>test<S2SV_blank>data:<S2SV_blank>%f\\n" |
1,541 | CWE-000 int main ( void ) { HAL_Init ( ) ; SystemClock_Config ( ) ; <S2SV_StartBug> MX_GPIO_Init ( ) ; <S2SV_EndBug> MX_CAN1_Init ( ) ; MX_ADC1_Init ( ) ; MX_TIM16_Init ( ) ; carInit ( ) ; CANFilterConfig ( ) ; initRTOSObjects ( ) ; osThreadDef ( defaultTask , StartDefaultTask , osPriorityNormal , 0 , 128 ) ; defaultTaskHandle = osThreadCreate ( osThread ( defaultTask ) , NULL ) ; osKernelStart ( ) ; while ( 1 ) { } } | <S2SV_ModStart> ) ; MX_GPIO_Init ( ) ; MX_DMA_Init |
1,542 | CWE-000 void * fd5_zsa_state_create ( struct pipe_context * pctx , const struct pipe_depth_stencil_alpha_state * cso ) { struct fd5_zsa_stateobj * so ; so = CALLOC_STRUCT ( fd5_zsa_stateobj ) ; if ( ! so ) return NULL ; so -> base = * cso ; so -> rb_depth_cntl |= A5XX_RB_DEPTH_CNTL_ZFUNC ( cso -> depth . func ) ; if ( cso -> depth . enabled ) so -> rb_depth_cntl |= A5XX_RB_DEPTH_CNTL_Z_ENABLE | A5XX_RB_DEPTH_CNTL_Z_TEST_ENABLE ; if ( cso -> depth . writemask ) so -> rb_depth_cntl |= A5XX_RB_DEPTH_CNTL_Z_WRITE_ENABLE ; if ( cso -> stencil [ 0 ] . enabled ) { const struct pipe_stencil_state * s = & cso -> stencil [ 0 ] ; so -> rb_stencil_control |= A5XX_RB_STENCIL_CONTROL_STENCIL_READ | A5XX_RB_STENCIL_CONTROL_STENCIL_ENABLE | A5XX_RB_STENCIL_CONTROL_FUNC ( s -> func ) | A5XX_RB_STENCIL_CONTROL_FAIL ( fd_stencil_op ( s -> fail_op ) ) | A5XX_RB_STENCIL_CONTROL_ZPASS ( fd_stencil_op ( s -> zpass_op ) ) | A5XX_RB_STENCIL_CONTROL_ZFAIL ( fd_stencil_op ( s -> zfail_op ) ) ; so -> rb_stencilrefmask |= A5XX_RB_STENCILREFMASK_STENCILWRITEMASK ( s -> writemask ) | A5XX_RB_STENCILREFMASK_STENCILMASK ( s -> valuemask ) ; if ( cso -> stencil [ 1 ] . enabled ) { const struct pipe_stencil_state * bs = & cso -> stencil [ 1 ] ; so -> rb_stencil_control |= A5XX_RB_STENCIL_CONTROL_STENCIL_ENABLE_BF | A5XX_RB_STENCIL_CONTROL_FUNC_BF ( bs -> func ) | A5XX_RB_STENCIL_CONTROL_FAIL_BF ( fd_stencil_op ( bs -> fail_op ) ) | A5XX_RB_STENCIL_CONTROL_ZPASS_BF ( fd_stencil_op ( bs -> zpass_op ) ) | A5XX_RB_STENCIL_CONTROL_ZFAIL_BF ( fd_stencil_op ( bs -> zfail_op ) ) ; } } if ( cso -> alpha . enabled ) { uint32_t ref = cso -> alpha . ref_value * 255.0 ; <S2SV_StartBug> so -> gras_su_depth_plane_cntl = <S2SV_EndBug> A5XX_GRAS_SU_DEPTH_PLANE_CNTL_ALPHA_TEST_ENABLE ; so -> rb_alpha_control = A5XX_RB_ALPHA_CONTROL_ALPHA_TEST | A5XX_RB_ALPHA_CONTROL_ALPHA_REF ( ref ) | A5XX_RB_ALPHA_CONTROL_ALPHA_TEST_FUNC ( cso -> alpha . func ) ; } return so ; } | <S2SV_ModStart> ; so -> <S2SV_ModEnd> rb_alpha_control = A5XX_RB_ALPHA_CONTROL_ALPHA_TEST |
1,543 | CWE-000 static void BossGlow ( Projectile * p , int t ) { <S2SV_StartBug> float s = 1.0 + t / p -> args [ 0 ] * 0.5 ; <S2SV_EndBug> float fade = 1 - ( 1.5 - s ) ; float deform = 5 - 10 * fade * fade ; r_draw_sprite ( & ( SpriteParams ) { . pos = { creal ( p -> pos ) , cimag ( p -> pos ) } , . sprite_ptr = p -> sprite , . scale . both = s , . blend = BLEND_ADD , . color = derive_color ( p -> color , CLRMASK_A , rgba ( 0 , 0 , 0 , 1.5 - s ) ) , . custom = deform , . shader = "sprite_silhouette" , } ) ; } | <S2SV_ModStart> + t / ( double ) p -> timeout <S2SV_ModEnd> * 0.5 ; |
1,544 | CWE-000 <S2SV_StartBug> void BKE_sequencer_editing_free ( Scene * scene ) <S2SV_EndBug> { Editing * ed = scene -> ed ; Sequence * seq ; if ( ed == NULL ) return ; BKE_sequencer_cache_cleanup ( ) ; SEQ_BEGIN ( ed , seq ) { <S2SV_StartBug> BKE_sequence_free_ex ( scene , seq , false ) ; <S2SV_EndBug> } SEQ_END BLI_freelistN ( & ed -> metastack ) ; MEM_freeN ( ed ) ; scene -> ed = NULL ; } | <S2SV_ModStart> Scene * scene , const bool do_id_user <S2SV_ModStart> seq , false , do_id_user |
1,545 | CWE-000 static struct type * <S2SV_StartBug> set_cobol_attr ( struct type * type , char * name ) <S2SV_EndBug> { int buf_len = strlen ( name ) , count = 1 ; char * buf = ( char * ) alloca ( buf_len ) ; <S2SV_StartBug> buf = name ; <S2SV_EndBug> char * content = strtok ( buf , "!" ) ; while ( content != NULL ) { type = set_cobol_attr2 ( type , content , count ) ; content = strtok ( NULL , "!" ) ; count ++ ; } return type ; } | <S2SV_ModStart> * type , const <S2SV_ModStart> buf_len ) ; char * content = NULL ; memcpy ( buf , name , buf_len ) ; <S2SV_ModEnd> content = strtok |
1,546 | CWE-000 static u32 cake_classify ( struct Qdisc * sch , struct cake_tin_data * * t , struct sk_buff * skb , int flow_mode , int * qerr ) { struct cake_sched_data * q = qdisc_priv ( sch ) ; struct tcf_proto * filter ; struct tcf_result res ; u32 flow = 0 ; int result ; filter = rcu_dereference_bh ( q -> filter_list ) ; if ( ! filter ) goto hash ; * qerr = NET_XMIT_SUCCESS | __NET_XMIT_BYPASS ; <S2SV_StartBug> # if LINUX_VERSION_CODE < KERNEL_VERSION ( 4 , 12 , 0 ) <S2SV_EndBug> result = tc_classify ( skb , filter , & res , false ) ; # else result = tcf_classify ( skb , filter , & res , false ) ; # endif if ( result >= 0 ) { # ifdef CONFIG_NET_CLS_ACT switch ( result ) { case TC_ACT_STOLEN : case TC_ACT_QUEUED : <S2SV_StartBug> # if LINUX_VERSION_CODE >= KERNEL_VERSION ( 4 , 12 , 0 ) <S2SV_EndBug> case TC_ACT_TRAP : # endif * qerr = NET_XMIT_SUCCESS | __NET_XMIT_STOLEN ; case TC_ACT_SHOT : return 0 ; } # endif if ( TC_H_MIN ( res . classid ) <= CAKE_QUEUES ) flow = TC_H_MIN ( res . classid ) ; } hash : * t = cake_select_tin ( sch , skb ) ; return flow ? : cake_hash ( * t , skb , flow_mode ) + 1 ; } | <S2SV_ModStart> ( 4 , 13 <S2SV_ModEnd> , 0 ) <S2SV_ModStart> ( 4 , 13 <S2SV_ModEnd> , 0 ) |
1,547 | CWE-000 int main ( int argc , char * argv [ ] ) { if ( argc != 4 ) { <S2SV_StartBug> printf ( "\\n\\t\\tError:<S2SV_blank>None<S2SV_blank>or<S2SV_blank>too<S2SV_blank>many<S2SV_blank>arguments<S2SV_blank>provided.\\n\\n<S2SV_blank>\\\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>Use:<S2SV_blank>\'%s<S2SV_blank>file1<S2SV_blank>file2<S2SV_blank>column\'\\n\\n<S2SV_blank>\\\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>where<S2SV_blank>file1<S2SV_blank>=<S2SV_blank>file<S2SV_blank>we<S2SV_blank>are<S2SV_blank>writing<S2SV_blank>from\\n<S2SV_blank>\\\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>file2<S2SV_blank>=<S2SV_blank>file<S2SV_blank>we<S2SV_blank>are<S2SV_blank>merging<S2SV_blank>into\\n<S2SV_blank>\\\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>and<S2SV_blank>column<S2SV_blank>=<S2SV_blank>number<S2SV_blank>of<S2SV_blank>the<S2SV_blank>column<S2SV_blank>(note:<S2SV_blank>must<S2SV_blank>be<S2SV_blank>empty<S2SV_blank>in<S2SV_blank>the<S2SV_blank>mergefile)\\n<S2SV_blank>\\\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>" , argv [ 0 ] ) ; <S2SV_EndBug> return 1 ; } printf ( "Attempting<S2SV_blank>to<S2SV_blank>write<S2SV_blank>contents<S2SV_blank>of<S2SV_blank>\'%s\'<S2SV_blank>into<S2SV_blank><S2SV_blank>column<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>\'%s\'...\\n" , argv [ 1 ] , argv [ 3 ] , argv [ 2 ] ) ; const char * input_file_name = argv [ 1 ] ; const char * merge_file_name = argv [ 2 ] ; long column ; column = strtol ( argv [ 3 ] , NULL , 10 ) ; if ( ! ( fileExist ( input_file_name ) ) ) { printf ( "Cannot<S2SV_blank>find<S2SV_blank>input<S2SV_blank>file:<S2SV_blank>\'%s\'!\\n<S2SV_blank>Exiting.\\n" , input_file_name ) ; return 1 ; } else if ( ! ( fileExist ( merge_file_name ) ) ) { printf ( "Cannot<S2SV_blank>find<S2SV_blank>mergefile:<S2SV_blank>\'%s\'!\\n<S2SV_blank>Exiting.\\n" , merge_file_name ) ; return 1 ; } FILE * merge_file ; merge_file = fopen ( merge_file_name , "r" ) ; FILE * input_file ; input_file = fopen ( input_file_name , "r" ) ; FILE * output_file ; output_file = fopen ( OUTPUT_FILE_NAME , "w" ) ; char mergebuff [ 512 ] ; char inpbuff [ 255 ] ; char outbuff [ 512 ] ; int m , n ; for ( m = 0 ; m < MERGE_FILE_LINES_TOSKIP ; m ++ ) { fgets ( mergebuff , 512 , ( FILE * ) merge_file ) ; fputs ( mergebuff , output_file ) ; } for ( n = 0 ; n < INPUT_FILE_LINES_TOSKIP ; n ++ ) { fgets ( inpbuff , 255 , ( FILE * ) input_file ) ; } fgets ( mergebuff , 512 , ( FILE * ) merge_file ) ; fgets ( inpbuff , 255 , ( FILE * ) input_file ) ; while ( 1 ) { <S2SV_StartBug> if ( feof ( input_file ) ) <S2SV_EndBug> break ; <S2SV_StartBug> if ( feof ( merge_file ) ) <S2SV_EndBug> break ; if ( check_date ( inpbuff , mergebuff ) ) { merge_line ( inpbuff , mergebuff , outbuff , column ) ; fputs ( outbuff , output_file ) ; fgets ( mergebuff , 512 , ( FILE * ) merge_file ) ; fgets ( inpbuff , 255 , ( FILE * ) input_file ) ; } else { fputs ( mergebuff , output_file ) ; fgets ( mergebuff , 512 , ( FILE * ) merge_file ) ; } } fclose ( merge_file ) ; fclose ( input_file ) ; fclose ( output_file ) ; printf ( "Success!<S2SV_blank>The<S2SV_blank>output<S2SV_blank>is<S2SV_blank>in<S2SV_blank>\'merge_out.csv\'" ) ; return 0 ; } | <S2SV_ModStart> { printf ( "\\n\\t\\tError:<S2SV_blank>None<S2SV_blank>or<S2SV_blank>too<S2SV_blank>many<S2SV_blank>arguments<S2SV_blank>provided.\\n\\n<S2SV_blank>\\\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>Use:<S2SV_blank>\'%s<S2SV_blank>file1<S2SV_blank>file2<S2SV_blank>column\'\\n\\n<S2SV_blank>\\\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>where<S2SV_blank>file1<S2SV_blank>=<S2SV_blank>file<S2SV_blank>we<S2SV_blank>are<S2SV_blank>writing<S2SV_blank>from\\n<S2SV_blank>\\\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>file2<S2SV_blank>=<S2SV_blank>file<S2SV_blank>we<S2SV_blank>are<S2SV_blank>merging<S2SV_blank>into\\n<S2SV_blank>\\\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>and<S2SV_blank>column<S2SV_blank>=<S2SV_blank>number<S2SV_blank>of<S2SV_blank>the<S2SV_blank>column<S2SV_blank>(note:<S2SV_blank>must<S2SV_blank>be<S2SV_blank>empty<S2SV_blank>in<S2SV_blank>the<S2SV_blank>mergefile)\\n<S2SV_blank>\\\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_ModEnd> , argv [ <S2SV_ModStart> ( feof ( merge_file <S2SV_ModEnd> ) ) break <S2SV_ModStart> ( feof ( input_file ) ) { fputs ( mergebuff , output_file ) ; fgets ( mergebuff , 512 , ( FILE * ) merge_file ) ; continue ; } <S2SV_ModEnd> if ( check_date |
1,548 | CWE-000 static MXS_MONITORED_SERVER * get_candidate_master ( MXS_MONITOR * mon ) { MXS_MONITORED_SERVER * moitor_servers = mon -> monitored_servers ; MXS_MONITORED_SERVER * candidate_master = NULL ; GALERA_MONITOR * handle = mon -> handle ; long min_id = - 1 ; int minval = INT_MAX ; int currval ; while ( moitor_servers ) { if ( ! SERVER_IN_MAINT ( moitor_servers -> server ) && SERVER_IS_JOINED ( moitor_servers -> server ) ) { moitor_servers -> server -> depth = 0 ; char buf [ 50 ] ; <S2SV_StartBug> if ( handle -> use_priority && server_get_parameter ( moitor_servers -> server , "priority" , buf , sizeof ( buf ) ) ) <S2SV_EndBug> { if ( ( currval = atoi ( buf ) ) > 0 ) { if ( currval < minval && currval > 0 ) { minval = currval ; candidate_master = moitor_servers ; } } } else if ( moitor_servers -> server -> node_id >= 0 && ( ! handle -> use_priority || candidate_master == NULL || <S2SV_StartBug> ! server_get_parameter ( moitor_servers -> server , "priority" , buf , sizeof ( buf ) ) ) ) <S2SV_EndBug> { if ( min_id < 0 || moitor_servers -> server -> node_id < min_id ) { min_id = moitor_servers -> server -> node_id ; candidate_master = moitor_servers ; } } } moitor_servers = moitor_servers -> next ; } if ( ! handle -> use_priority && ! handle -> disableMasterFailback && handle -> root_node_as_master && min_id > 0 ) { candidate_master = NULL ; } return candidate_master ; } | <S2SV_ModStart> -> use_priority && server_get_parameter_nolock <S2SV_ModEnd> ( moitor_servers -> <S2SV_ModStart> NULL || ! server_get_parameter_nolock <S2SV_ModEnd> ( moitor_servers -> |
1,549 | CWE-000 gboolean g_socket_condition_timed_wait ( GSocket * socket , GIOCondition condition , gint64 timeout , GCancellable * cancellable , GError * * error ) { gint64 start_time ; g_return_val_if_fail ( G_IS_SOCKET ( socket ) , FALSE ) ; if ( ! check_socket ( socket , error ) ) return FALSE ; if ( g_cancellable_set_error_if_cancelled ( cancellable , error ) ) return FALSE ; if ( socket -> priv -> timeout && ( timeout < 0 || socket -> priv -> timeout < timeout / G_USEC_PER_SEC ) ) timeout = ( gint64 ) socket -> priv -> timeout * 1000 ; else if ( timeout != - 1 ) timeout = timeout / 1000 ; start_time = g_get_monotonic_time ( ) ; # ifdef G_OS_WIN32 { GIOCondition current_condition ; WSAEVENT events [ 2 ] ; DWORD res ; GPollFD cancel_fd ; int num_events ; condition |= G_IO_ERR | G_IO_HUP ; add_condition_watch ( socket , & condition ) ; num_events = 0 ; events [ num_events ++ ] = socket -> priv -> event ; if ( g_cancellable_make_pollfd ( cancellable , & cancel_fd ) ) events [ num_events ++ ] = ( WSAEVENT ) cancel_fd . fd ; if ( timeout == - 1 ) timeout = WSA_INFINITE ; <S2SV_StartBug> g_mutex_lock ( & socket -> priv -> win32_source_lock ) ; <S2SV_EndBug> current_condition = update_condition_unlocked ( socket ) ; while ( ( condition & current_condition ) == 0 ) { <S2SV_StartBug> if ( ! socket -> priv -> waiting ) <S2SV_EndBug> { socket -> priv -> waiting = TRUE ; socket -> priv -> waiting_result = 0 ; g_mutex_unlock ( & socket -> priv -> win32_source_lock ) ; res = WSAWaitForMultipleEvents ( num_events , events , FALSE , timeout , FALSE ) ; <S2SV_StartBug> g_mutex_lock ( & socket -> priv -> win32_source_lock ) ; <S2SV_EndBug> socket -> priv -> waiting = FALSE ; socket -> priv -> waiting_result = res ; g_cond_broadcast ( & socket -> priv -> win32_source_cond ) ; } else { if ( timeout != WSA_INFINITE ) { if ( ! g_cond_wait_until ( & socket -> priv -> win32_source_cond , & socket -> priv -> win32_source_lock , timeout ) ) { res = WSA_WAIT_TIMEOUT ; break ; } else { res = socket -> priv -> waiting_result ; } } else { g_cond_wait ( & socket -> priv -> win32_source_cond , & socket -> priv -> win32_source_lock ) ; res = socket -> priv -> waiting_result ; } } if ( res == WSA_WAIT_FAILED ) { int errsv = get_socket_errno ( ) ; g_set_error ( error , G_IO_ERROR , socket_io_error_from_errno ( errsv ) , _ ( "Waiting<S2SV_blank>for<S2SV_blank>socket<S2SV_blank>condition:<S2SV_blank>%s" ) , socket_strerror ( errsv ) ) ; break ; } else if ( res == WSA_WAIT_TIMEOUT ) { g_set_error_literal ( error , G_IO_ERROR , G_IO_ERROR_TIMED_OUT , _ ( "Socket<S2SV_blank>I/O<S2SV_blank>timed<S2SV_blank>out" ) ) ; break ; } if ( g_cancellable_set_error_if_cancelled ( cancellable , error ) ) break ; <S2SV_StartBug> current_condition = update_condition_unlocked ( socket ) ; <S2SV_EndBug> if ( timeout != WSA_INFINITE ) { timeout -= ( g_get_monotonic_time ( ) - start_time ) * 1000 ; if ( timeout < 0 ) timeout = 0 ; } } <S2SV_StartBug> g_mutex_unlock ( & socket -> priv -> win32_source_lock ) ; <S2SV_EndBug> remove_condition_watch ( socket , & condition ) ; if ( num_events > 1 ) g_cancellable_release_fd ( cancellable ) ; return ( condition & current_condition ) != 0 ; } # else { GPollFD poll_fd [ 2 ] ; gint result ; gint num ; poll_fd [ 0 ] . fd = socket -> priv -> fd ; poll_fd [ 0 ] . events = condition ; num = 1 ; if ( g_cancellable_make_pollfd ( cancellable , & poll_fd [ 1 ] ) ) num ++ ; while ( TRUE ) { result = g_poll ( poll_fd , num , timeout ) ; if ( result != - 1 || errno != EINTR ) break ; if ( timeout != - 1 ) { timeout -= ( g_get_monotonic_time ( ) - start_time ) / 1000 ; if ( timeout < 0 ) timeout = 0 ; } } if ( num > 1 ) g_cancellable_release_fd ( cancellable ) ; if ( result == 0 ) { g_set_error_literal ( error , G_IO_ERROR , G_IO_ERROR_TIMED_OUT , _ ( "Socket<S2SV_blank>I/O<S2SV_blank>timed<S2SV_blank>out" ) ) ; return FALSE ; } return ! g_cancellable_set_error_if_cancelled ( cancellable , error ) ; } # endif } | <S2SV_ModStart> = WSA_INFINITE ; current_condition = update_condition <S2SV_ModEnd> ( socket ) <S2SV_ModStart> 0 ) { <S2SV_ModEnd> res = WSAWaitForMultipleEvents <S2SV_ModStart> FALSE ) ; <S2SV_ModEnd> if ( res <S2SV_ModStart> ; current_condition = update_condition <S2SV_ModEnd> ( socket ) <S2SV_ModStart> ; } } <S2SV_ModEnd> remove_condition_watch ( socket |
1,550 | CWE-000 <S2SV_StartBug> uint8_t main_times ( uint8_t argc , char * argv [ ] ) <S2SV_EndBug> { unsigned long t1 ; uint8_t i = 0 ; t1 = millis ( ) ; <S2SV_StartBug> if ( argc > 0 ) <S2SV_EndBug> { <S2SV_StartBug> i = execve ( argv [ 1 ] , ( const char * * ) & argv [ 2 ] , NULL ) ; <S2SV_EndBug> } printf_P ( PSTR ( "millis:<S2SV_blank>%ld\\n" ) , millis ( ) - t1 ) ; return i ; } | <S2SV_ModStart> uint8_t main_times ( <S2SV_ModEnd> char * argv <S2SV_ModStart> ; if ( argv [ 1 ] != NULL <S2SV_ModEnd> ) { i <S2SV_ModStart> = execve ( <S2SV_ModEnd> ( const char <S2SV_ModStart> & argv [ 1 <S2SV_ModEnd> ] , NULL |
1,551 | CWE-000 static int ext4_readdir ( struct file * file , struct dir_context * ctx ) { unsigned int offset ; int i ; struct ext4_dir_entry_2 * de ; int err ; struct inode * inode = file_inode ( file ) ; struct super_block * sb = inode -> i_sb ; struct buffer_head * bh = NULL ; int dir_has_error = 0 ; struct ext4_str fname_crypto_str = { . name = NULL , . len = 0 } ; if ( ext4_encrypted_inode ( inode ) ) { err = ext4_get_encryption_info ( inode ) ; if ( err && err != - ENOKEY ) return err ; } if ( is_dx_dir ( inode ) ) { err = ext4_dx_readdir ( file , ctx ) ; if ( err != ERR_BAD_DX_DIR ) { return err ; } ext4_clear_inode_flag ( file_inode ( file ) , EXT4_INODE_INDEX ) ; } if ( ext4_has_inline_data ( inode ) ) { int has_inline_data = 1 ; err = ext4_read_inline_dir ( file , ctx , & has_inline_data ) ; if ( has_inline_data ) return err ; } if ( ext4_encrypted_inode ( inode ) ) { err = ext4_fname_crypto_alloc_buffer ( inode , EXT4_NAME_LEN , & fname_crypto_str ) ; if ( err < 0 ) return err ; } offset = ctx -> pos & ( sb -> s_blocksize - 1 ) ; while ( ctx -> pos < inode -> i_size ) { <S2SV_StartBug> struct ext4_map_blocks map ; <S2SV_EndBug> map . m_lblk = ctx -> pos >> EXT4_BLOCK_SIZE_BITS ( sb ) ; map . m_len = 1 ; err = ext4_map_blocks ( NULL , inode , & map , 0 ) ; if ( err > 0 ) { pgoff_t index = map . m_pblk >> ( PAGE_CACHE_SHIFT - inode -> i_blkbits ) ; if ( ! ra_has_index ( & file -> f_ra , index ) ) page_cache_sync_readahead ( sb -> s_bdev -> bd_inode -> i_mapping , & file -> f_ra , file , index , 1 ) ; file -> f_ra . prev_pos = ( loff_t ) index << PAGE_CACHE_SHIFT ; bh = ext4_bread ( NULL , inode , map . m_lblk , 0 ) ; if ( IS_ERR ( bh ) ) { err = PTR_ERR ( bh ) ; bh = NULL ; goto errout ; } } if ( ! bh ) { if ( ! dir_has_error ) { EXT4_ERROR_FILE ( file , 0 , "directory<S2SV_blank>contains<S2SV_blank>a<S2SV_blank>" "hole<S2SV_blank>at<S2SV_blank>offset<S2SV_blank>%llu" , ( unsigned long long ) ctx -> pos ) ; dir_has_error = 1 ; } if ( ctx -> pos > inode -> i_blocks << 9 ) break ; ctx -> pos += sb -> s_blocksize - offset ; continue ; } if ( ! buffer_verified ( bh ) && ! ext4_dirent_csum_verify ( inode , ( struct ext4_dir_entry * ) bh -> b_data ) ) { EXT4_ERROR_FILE ( file , 0 , "directory<S2SV_blank>fails<S2SV_blank>checksum<S2SV_blank>" "at<S2SV_blank>offset<S2SV_blank>%llu" , ( unsigned long long ) ctx -> pos ) ; ctx -> pos += sb -> s_blocksize - offset ; brelse ( bh ) ; bh = NULL ; continue ; } set_buffer_verified ( bh ) ; if ( file -> f_version != inode -> i_version ) { for ( i = 0 ; i < sb -> s_blocksize && i < offset ; ) { de = ( struct ext4_dir_entry_2 * ) ( bh -> b_data + i ) ; if ( ext4_rec_len_from_disk ( de -> rec_len , sb -> s_blocksize ) < EXT4_DIR_REC_LEN ( 1 ) ) break ; i += ext4_rec_len_from_disk ( de -> rec_len , sb -> s_blocksize ) ; } offset = i ; ctx -> pos = ( ctx -> pos & ~ ( sb -> s_blocksize - 1 ) ) | offset ; file -> f_version = inode -> i_version ; } while ( ctx -> pos < inode -> i_size && offset < sb -> s_blocksize ) { de = ( struct ext4_dir_entry_2 * ) ( bh -> b_data + offset ) ; if ( ext4_check_dir_entry ( inode , file , de , bh , bh -> b_data , bh -> b_size , offset ) ) { ctx -> pos = ( ctx -> pos | ( sb -> s_blocksize - 1 ) ) + 1 ; break ; } offset += ext4_rec_len_from_disk ( de -> rec_len , sb -> s_blocksize ) ; if ( le32_to_cpu ( de -> inode ) ) { if ( ! ext4_encrypted_inode ( inode ) ) { if ( ! dir_emit ( ctx , de -> name , de -> name_len , le32_to_cpu ( de -> inode ) , get_dtype ( sb , de -> file_type ) ) ) goto done ; } else { int save_len = fname_crypto_str . len ; err = ext4_fname_disk_to_usr ( inode , NULL , de , & fname_crypto_str ) ; fname_crypto_str . len = save_len ; if ( err < 0 ) goto errout ; if ( ! dir_emit ( ctx , fname_crypto_str . name , err , le32_to_cpu ( de -> inode ) , get_dtype ( sb , de -> file_type ) ) ) goto done ; } } ctx -> pos += ext4_rec_len_from_disk ( de -> rec_len , sb -> s_blocksize ) ; } if ( ( ctx -> pos < inode -> i_size ) && ! dir_relax ( inode ) ) goto done ; brelse ( bh ) ; bh = NULL ; offset = 0 ; } done : err = 0 ; errout : # ifdef CONFIG_EXT4_FS_ENCRYPTION ext4_fname_crypto_free_buffer ( & fname_crypto_str ) ; # endif brelse ( bh ) ; return err ; } | <S2SV_ModStart> struct ext4_map_blocks map ; if ( fatal_signal_pending ( current ) ) { err = - ERESTARTSYS ; goto errout ; } cond_resched ( ) |
1,552 | CWE-000 SYSCALL_DEFINE3 ( inotify_add_watch , int , fd , const char __user * , pathname , u32 , mask ) { struct fsnotify_group * group ; struct inode * inode ; struct path path ; struct file * filp ; <S2SV_StartBug> int ret , fput_needed ; <S2SV_EndBug> unsigned flags = 0 ; if ( unlikely ( ! ( mask & ALL_INOTIFY_BITS ) ) ) return - EINVAL ; filp = fget_light ( fd , & fput_needed ) ; if ( unlikely ( ! filp ) ) return - EBADF ; if ( unlikely ( filp -> f_op != & inotify_fops ) ) { ret = - EINVAL ; goto fput_and_out ; } if ( ! ( mask & IN_DONT_FOLLOW ) ) flags |= LOOKUP_FOLLOW ; if ( mask & IN_ONLYDIR ) flags |= LOOKUP_DIRECTORY ; ret = inotify_find_inode ( pathname , & path , flags ) ; if ( ret ) goto fput_and_out ; <S2SV_StartBug> inode = path . dentry -> d_inode ; <S2SV_EndBug> group = filp -> private_data ; ret = inotify_update_watch ( group , inode , mask ) ; <S2SV_StartBug> path_put ( & path ) ; <S2SV_EndBug> fput_and_out : fput_light ( filp , fput_needed ) ; return ret ; } | <S2SV_ModStart> * filp ; struct path alteredpath ; struct path * canonical_path = & path ; <S2SV_ModStart> goto fput_and_out ; if ( path . dentry && path . dentry -> d_op ) { if ( path . dentry -> d_op -> d_canonical_path ) { path . dentry -> d_op -> d_canonical_path ( & path , & alteredpath ) ; canonical_path = & alteredpath ; path_put ( & path ) ; } } inode = canonical_path -> <S2SV_ModEnd> dentry -> d_inode <S2SV_ModStart> ; path_put ( canonical_path <S2SV_ModEnd> ) ; fput_and_out |
1,553 | CWE-000 static int ztest_get_data ( void * arg , lr_write_t * lr , char * buf , zio_t * zio ) { ztest_ds_t * zd = arg ; objset_t * os = zd -> zd_os ; uint64_t object = lr -> lr_foid ; uint64_t offset = lr -> lr_offset ; <S2SV_StartBug> uint64_t size = lr -> lr_length ; <S2SV_EndBug> blkptr_t * bp = & lr -> lr_blkptr ; uint64_t txg = lr -> lr_common . lrc_txg ; uint64_t crtxg ; dmu_object_info_t doi ; dmu_buf_t * db ; zgd_t * zgd ; int error ; ztest_object_lock ( zd , object , RL_READER ) ; error = dmu_bonus_hold ( os , object , FTAG , & db ) ; if ( error ) { ztest_object_unlock ( zd , object ) ; return ( error ) ; } crtxg = ztest_bt_bonus ( db ) -> bt_crtxg ; if ( crtxg == 0 || crtxg > txg ) { dmu_buf_rele ( db , FTAG ) ; ztest_object_unlock ( zd , object ) ; return ( ENOENT ) ; } dmu_object_info_from_db ( db , & doi ) ; dmu_buf_rele ( db , FTAG ) ; db = NULL ; zgd = umem_zalloc ( sizeof ( * zgd ) , UMEM_NOFAIL ) ; zgd -> zgd_zilog = zd -> zd_zilog ; zgd -> zgd_private = zd ; if ( buf != NULL ) { zgd -> zgd_rl = ztest_range_lock ( zd , object , offset , size , RL_READER ) ; error = dmu_read ( os , object , offset , size , buf , DMU_READ_NO_PREFETCH ) ; ASSERT ( error == 0 ) ; } else { size = doi . doi_data_block_size ; if ( ISP2 ( size ) ) { offset = P2ALIGN ( offset , size ) ; } else { ASSERT ( offset < size ) ; offset = 0 ; } zgd -> zgd_rl = ztest_range_lock ( zd , object , offset , size , RL_READER ) ; error = dmu_buf_hold ( os , object , offset , zgd , & db , DMU_READ_NO_PREFETCH ) ; if ( error == 0 ) { <S2SV_StartBug> blkptr_t * obp = dmu_buf_get_blkptr ( db ) ; <S2SV_EndBug> if ( obp ) { ASSERT ( BP_IS_HOLE ( bp ) ) ; * bp = * obp ; } zgd -> zgd_db = db ; zgd -> zgd_bp = bp ; ASSERT ( db -> db_offset == offset ) ; ASSERT ( db -> db_size == size ) ; error = dmu_sync ( zio , lr -> lr_common . lrc_txg , ztest_get_done , zgd ) ; if ( error == 0 ) return ( 0 ) ; } } ztest_get_done ( zgd , error ) ; return ( error ) ; } | <S2SV_ModStart> lr -> lr_length <S2SV_ModEnd> ; uint64_t txg <S2SV_ModStart> { blkptr_t * bp = & lr -> lr_blkptr ; <S2SV_ModEnd> zgd -> zgd_db |
1,554 | CWE-000 static int vklog ( int level , const char * format , va_list ap ) { char buf [ KLOG_MAX_MSG_LEN ] ; struct klog_entry * entry ; int len ; len = vsnprintf ( buf , sizeof buf , format , ap ) ; if ( buf [ len - 1 ] == '\\n' ) -- len ; mutex_lock ( & klog_mutex ) ; if ( ! klog_has_space ( len ) ) { next_entry -> msg_len = KLOG_WRAPAROUND ; next_entry = ( struct klog_entry * ) klog_buffer ; } if ( klog_written ) klog_advance_first ( len ) ; klog_written = 1 ; entry = next_entry ; next_entry = klog_next_entry ( next_entry ) ; entry -> timestamp = 0 ; entry -> msg_len = len ; entry -> level = level ; entry -> flags = 0 ; entry -> seqno = klog_sequence_number ++ ; memcpy ( entry -> message , buf , len ) ; mutex_unlock ( & klog_mutex ) ; <S2SV_StartBug> return len ; <S2SV_EndBug> } | <S2SV_ModStart> klog_mutex ) ; if ( klog_console ) klog_console_write ( entry ) ; |
1,555 | CWE-000 inline rpc_object_t rpc_dictionary_create ( const char * const * keys , const rpc_object_t * values , size_t count ) { union rpc_value val ; <S2SV_StartBug> val . rv_dict = g_hash_table_new_full ( NULL , g_str_equal , NULL , <S2SV_EndBug> ( GDestroyNotify ) rpc_release ) ; return ( rpc_prim_create ( RPC_TYPE_DICTIONARY , val , 0 ) ) ; } | <S2SV_ModStart> = g_hash_table_new_full ( g_str_hash <S2SV_ModEnd> , g_str_equal , |
1,556 | CWE-000 void fmpz_mpoly_set_term_fmpz ( fmpz_mpoly_t poly , ulong const * exp , const fmpz_t c , const fmpz_mpoly_ctx_t ctx ) { slong i , N , index , bits , exp_bits ; int exists ; ulong sum = 0 , max_exp = 0 ; <S2SV_StartBug> ulong * packed_exp , * exps ; <S2SV_EndBug> int deg , rev ; TMP_INIT ; TMP_START ; degrev_from_ord ( deg , rev , ctx -> ord ) ; if ( deg ) { for ( i = 0 ; i < ctx -> n - 1 ; i ++ ) { sum += exp [ i ] ; if ( sum < exp [ i ] ) flint_throw ( FLINT_EXPOF , "Exponent<S2SV_blank>overflow<S2SV_blank>in<S2SV_blank>fmpz_mpoly_set_term_fmpz" ) ; } max_exp = sum ; } else { for ( i = 0 ; i < ctx -> n ; i ++ ) { if ( exp [ i ] > max_exp ) max_exp = exp [ i ] ; } } if ( 0 > ( slong ) max_exp ) flint_throw ( FLINT_EXPOF , "Exponent<S2SV_blank>overflow<S2SV_blank>in<S2SV_blank>fmpz_mpoly_set_term_fmpz" ) ; bits = FLINT_BIT_COUNT ( max_exp ) ; exp_bits = 8 ; while ( bits >= exp_bits ) exp_bits *= 2 ; <S2SV_StartBug> if ( exp_bits > poly -> bits ) <S2SV_EndBug> { exps = mpoly_unpack_monomials ( exp_bits , poly -> exps , poly -> length , ctx -> n , poly -> bits ) ; N = ( exp_bits * ctx -> n - 1 ) / FLINT_BITS + 1 ; <S2SV_StartBug> if ( exps != poly -> exps ) <S2SV_EndBug> { flint_free ( poly -> exps ) ; if ( poly -> alloc > poly -> length ) exps = ( ulong * ) flint_realloc ( exps , poly -> alloc * N * sizeof ( ulong ) ) ; } poly -> exps = exps ; poly -> bits = exp_bits ; } N = ( poly -> bits * ctx -> n - 1 ) / FLINT_BITS + 1 ; packed_exp = ( ulong * ) TMP_ALLOC ( N * sizeof ( ulong ) ) ; mpoly_set_monomial ( packed_exp , exp , poly -> bits , ctx -> n , deg , rev ) ; exists = mpoly_monomial_exists ( & index , poly -> exps , packed_exp , poly -> length , N ) ; if ( ! exists ) { if ( ! fmpz_is_zero ( c ) ) { fmpz_mpoly_fit_length ( poly , poly -> length + 1 , ctx ) ; for ( i = poly -> length ; i >= index + 1 ; i -- ) { fmpz_set ( poly -> coeffs + i , poly -> coeffs + i - 1 ) ; mpoly_monomial_set ( poly -> exps + N * i , poly -> exps + N * ( i - 1 ) , N ) ; } mpoly_monomial_set ( poly -> exps + N * index , packed_exp , N ) ; poly -> length ++ ; fmpz_mpoly_set_coeff_fmpz ( poly , index , c , ctx ) ; } } else if ( fmpz_is_zero ( c ) ) { for ( i = index ; i < poly -> length - 1 ; i ++ ) { fmpz_set ( poly -> coeffs + i , poly -> coeffs + i + 1 ) ; mpoly_monomial_set ( poly -> exps + N * i , poly -> exps + N * ( i + 1 ) , N ) ; } _fmpz_mpoly_set_length ( poly , poly -> length - 1 , ctx ) ; } else fmpz_mpoly_set_coeff_fmpz ( poly , index , c , ctx ) ; TMP_END ; } | <S2SV_ModStart> ulong * packed_exp <S2SV_ModEnd> ; int deg <S2SV_ModStart> *= 2 ; fmpz_mpoly_fit_bits ( poly , exp_bits , ctx ) ; N = ( <S2SV_ModEnd> poly -> bits <S2SV_ModStart> poly -> bits <S2SV_ModEnd> * ctx -> <S2SV_ModStart> + 1 ; <S2SV_ModEnd> packed_exp = ( |
1,557 | CWE-000 int vop_stdclose ( struct vop_close_args * ap ) { struct vnode * vp = ap -> a_vp ; KASSERT ( vp -> v_opencount > 0 , ( "VOP_STDCLOSE:<S2SV_blank>BAD<S2SV_blank>OPENCOUNT<S2SV_blank>%p<S2SV_blank>%d<S2SV_blank>type=%d<S2SV_blank>ops=%p<S2SV_blank>flgs=%08x" , vp , vp -> v_opencount , vp -> v_type , * vp -> v_ops , vp -> v_flag ) ) ; if ( ap -> a_fflag & FWRITE ) { KASSERT ( vp -> v_writecount > 0 , ( "VOP_STDCLOSE:<S2SV_blank>BAD<S2SV_blank>WRITECOUNT<S2SV_blank>%p<S2SV_blank>%d" , vp , vp -> v_writecount ) ) ; <S2SV_StartBug> vfs_timestamp ( & vp -> v_lastwrite_ts ) ; <S2SV_EndBug> atomic_add_int ( & vp -> v_writecount , - 1 ) ; } atomic_add_int ( & vp -> v_opencount , - 1 ) ; return ( 0 ) ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> atomic_add_int ( & |
1,558 | CWE-000 int transform_validate ( struct augeas * aug , struct tree * xfm ) { struct tree * l = NULL ; for ( struct tree * t = xfm -> children ; t != NULL ; ) { if ( streqv ( t -> label , "lens" ) ) { l = t ; } else if ( ( is_incl ( t ) || ( is_excl ( t ) && strchr ( t -> value , SEP ) != NULL ) ) && t -> value [ 0 ] != SEP ) { int r ; r = REALLOC_N ( t -> value , strlen ( t -> value ) + 2 ) ; ERR_NOMEM ( r < 0 , aug ) ; memmove ( t -> value + 1 , t -> value , strlen ( t -> value ) + 1 ) ; t -> value [ 0 ] = SEP ; } if ( streqv ( t -> label , "error" ) ) { struct tree * del = t ; t = del -> next ; tree_unlink ( aug , del ) ; } else { t = t -> next ; } } if ( l == NULL ) { xfm_error ( xfm , "missing<S2SV_blank>a<S2SV_blank>child<S2SV_blank>with<S2SV_blank>label<S2SV_blank>\'lens\'" ) ; return - 1 ; } if ( l -> value == NULL ) { xfm_error ( xfm , "the<S2SV_blank>\'lens\'<S2SV_blank>node<S2SV_blank>does<S2SV_blank>not<S2SV_blank>contain<S2SV_blank>a<S2SV_blank>lens<S2SV_blank>name" ) ; return - 1 ; } lens_from_name ( aug , l -> value ) ; ERR_BAIL ( aug ) ; return 0 ; error : xfm_error ( xfm , aug -> error -> details ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } | <S2SV_ModStart> details ) ; reset_error ( aug -> error ) ; |
1,559 | CWE-000 static int nf_tables_dump_flowtable ( struct sk_buff * skb , struct netlink_callback * cb ) { const struct nfgenmsg * nfmsg = nlmsg_data ( cb -> nlh ) ; struct nft_flowtable_filter * filter = cb -> data ; unsigned int idx = 0 , s_idx = cb -> args [ 0 ] ; struct net * net = sock_net ( skb -> sk ) ; int family = nfmsg -> nfgen_family ; struct nft_flowtable * flowtable ; const struct nft_table * table ; rcu_read_lock ( ) ; cb -> seq = net -> nft . base_seq ; list_for_each_entry_rcu ( table , & net -> nft . tables , list ) { if ( family != NFPROTO_UNSPEC && family != table -> family ) continue ; list_for_each_entry_rcu ( flowtable , & table -> flowtables , list ) { if ( ! nft_is_active ( net , flowtable ) ) goto cont ; if ( idx < s_idx ) goto cont ; if ( idx > s_idx ) memset ( & cb -> args [ 1 ] , 0 , sizeof ( cb -> args ) - sizeof ( cb -> args [ 0 ] ) ) ; <S2SV_StartBug> if ( filter && filter -> table [ 0 ] && <S2SV_EndBug> strcmp ( filter -> table , table -> name ) ) goto cont ; if ( nf_tables_fill_flowtable_info ( skb , net , NETLINK_CB ( cb -> skb ) . portid , cb -> nlh -> nlmsg_seq , NFT_MSG_NEWFLOWTABLE , NLM_F_MULTI | NLM_F_APPEND , table -> family , flowtable ) < 0 ) goto done ; nl_dump_check_consistent ( cb , nlmsg_hdr ( skb ) ) ; cont : idx ++ ; } } done : rcu_read_unlock ( ) ; cb -> args [ 0 ] = idx ; return skb -> len ; } | <S2SV_ModStart> filter -> table <S2SV_ModEnd> && strcmp ( |
1,560 | CWE-000 <S2SV_StartBug> uint24_t getIndexOffset ( uint24_t offset ) { <S2SV_EndBug> return * ( p2 + offset ) ; } | <S2SV_ModStart> uint24_t getIndexOffset ( int24_t <S2SV_ModEnd> offset ) { |
1,561 | CWE-000 void tcp_fastopen_cache_set ( struct sock * sk , u16 mss , struct tcp_fastopen_cookie * cookie , bool syn_lost ) { <S2SV_StartBug> struct tcp_metrics_block * tm ; <S2SV_EndBug> rcu_read_lock ( ) ; <S2SV_StartBug> tm = tcp_get_metrics ( sk , __sk_dst_get ( sk ) , true ) ; <S2SV_EndBug> if ( tm ) { struct tcp_fastopen_metrics * tfom = & tm -> tcpm_fastopen ; write_seqlock_bh ( & fastopen_seqlock ) ; tfom -> mss = mss ; if ( cookie -> len > 0 ) tfom -> cookie = * cookie ; if ( syn_lost ) { ++ tfom -> syn_loss ; tfom -> last_syn_loss = jiffies ; } else tfom -> syn_loss = 0 ; write_sequnlock_bh ( & fastopen_seqlock ) ; } rcu_read_unlock ( ) ; } | <S2SV_ModStart> ) { struct dst_entry * dst = __sk_dst_get ( sk ) ; struct <S2SV_ModStart> tcp_metrics_block * tm ; if ( ! dst ) return <S2SV_ModStart> ( sk , dst <S2SV_ModEnd> , true ) |
1,562 | CWE-000 int main ( ) { srand ( time ( 0 ) ) ; printf ( "Creating<S2SV_blank>brain...\\t" ) ; struct brain * b = init_brain ( 1000 ) ; printf ( "<S2SV_blank>done\\n" ) ; int a = 0 ; printf ( "Making<S2SV_blank>random<S2SV_blank>connections...\\t" ) ; for ( int i = 0 ; i < 100 ; i ++ ) { int src = rand_int ( 0 , b -> size - 1 ) ; int des = rand_int ( 0 , b -> size - 1 ) ; if ( checkexist ( des , b -> neurons [ src ] -> links , b -> neurons [ src ] -> lc ) == 0 ) { link_neuron ( b -> neurons [ src ] , b -> neurons [ des ] , rand_int ( 1 , 10 ) ) ; } } printf ( "<S2SV_blank>done\\n" ) ; while ( a == 0 ) { <S2SV_StartBug> accum_neuron ( b -> neurons [ rand_int ( 0 , b -> size - 1 ) ] , 20 ) ; <S2SV_EndBug> update_all ( b ) ; } return 0 ; } | <S2SV_ModStart> -> neurons [ b -> neurons [ <S2SV_ModStart> 1 ) ] ] |
1,563 | CWE-000 <S2SV_StartBug> int vv ( int * v ) { <S2SV_EndBug> <S2SV_StartBug> if ( * v < 10 ) <S2SV_EndBug> <S2SV_StartBug> printf ( "ERROR" ) ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> void <S2SV_ModEnd> vv ( int <S2SV_ModStart> ( int * srok , int * vklad <S2SV_ModEnd> ) { if <S2SV_ModStart> if ( * srok > 365 <S2SV_ModEnd> ) printf ( <S2SV_ModStart> ) printf ( "ERROR\\n" ) ; if ( * vklad < 10000 ) printf ( "ERROR\\n" ) <S2SV_ModEnd> ; } <S2SV_null> |
1,564 | CWE-000 bool testDefaultValues ( ) { SPConfig config ; SP_CONFIG_MSG msg ; char buffer [ STRING_MAX_LENGTH ] ; buffer [ STRING_MAX_LENGTH - 1 ] = '\\0' ; config = spConfigCreate ( DV_CONFIG_NAME , & msg ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; ASSERT_FALSE ( NULL == config ) ; <S2SV_StartBug> msg = SP_CONFIG_ALLOC_FAIL ; <S2SV_EndBug> ASSERT_TRUE ( 20 == spConfigGetPCADim ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; msg = spConfigGetPCAPath ( buffer , config ) ; ASSERT_TRUE ( 0 == strcmp ( "./images/pca.yml" , buffer ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( 100 == spConfigGetNumOfFeatures ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( true == spConfigIsExtractionMode ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( 1 == spConfigGetNumSimilarImages ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( 1 == spConfigGetKNN ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( MAX_SPREAD == spConfigGetSplitMethod ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( false == spConfigMinimalGui ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; ASSERT_TRUE ( 3 == spConfigGetLoggerLevel ( config , & msg ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = SP_CONFIG_ALLOC_FAIL ; msg = spConfigGetLoggerFilename ( buffer , config ) ; ASSERT_TRUE ( 0 == strcmp ( "stdout" , buffer ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; spConfigDestroy ( config ) ; return true ; } | <S2SV_ModStart> ; msg = spConfigGetImagePath ( buffer , config , 0 ) ; ASSERT_FALSE ( 0 == strcmp ( "./images/img0.jpg" , buffer ) ) ; ASSERT_TRUE ( SP_CONFIG_INDEX_OUT_OF_RANGE == msg ) ; msg = spConfigGetImagePath ( buffer , config , 1 ) ; ASSERT_TRUE ( 0 == strcmp ( "./images/img1.jpg" , buffer ) ) ; ASSERT_TRUE ( SP_CONFIG_SUCCESS == msg ) ; msg = spConfigGetImagePath ( buffer , config , 2 ) ; ASSERT_FALSE ( 0 == strcmp ( "./images/img2.jpg" , buffer ) ) ; ASSERT_TRUE ( SP_CONFIG_INDEX_OUT_OF_RANGE == msg ) ; msg = |
1,565 | CWE-000 char * nodetype2str ( NodeType t ) { # define CASE_STR ( t , x ) case NODE_ ## t : return x ; switch ( t ) { CASE_STR ( FUNCTIONCALL , "functioncall" ) ; CASE_STR ( IDENTIFIER , "identifier" ) ; <S2SV_StartBug> CASE_STR ( UNARYOPERATOR , "unary<S2SV_blank>operator" ) ; <S2SV_EndBug> <S2SV_StartBug> CASE_STR ( BINARYOPERATOR , "binary<S2SV_blank>operator" ) ; <S2SV_EndBug> CASE_STR ( STRING , "string" ) ; CASE_STR ( INTEGER , "integer" ) ; CASE_STR ( FLOAT , "float" ) ; CASE_STR ( NONE , "none" ) ; default : return "????" ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( UNARYOPERATOR , "unaryoperator" <S2SV_ModEnd> ) ; CASE_STR <S2SV_ModStart> ( BINARYOPERATOR , "binaryoperator" <S2SV_ModEnd> ) ; CASE_STR <S2SV_ModStart> "????" ; } # undef CASE_STR |
1,566 | CWE-000 <S2SV_StartBug> void CQdSubtreeProcess ( CQdState state , int p ) <S2SV_EndBug> { state -> cProcessed += p ; } | <S2SV_ModStart> CQdState state , CmiInt8 <S2SV_ModEnd> p ) { |
1,567 | CWE-000 json_t * jukebox_get_info ( struct _t_jukebox * jukebox ) { json_t * j_stream = NULL , * j_client ; if ( jukebox != NULL ) { j_stream = json_pack ( "{sis{sssssosisssosisisisi}}" , "result" , T_OK , "jukebox" , "name" , jukebox -> name , "display_name" , jukebox -> display_name , "webradio" , json_false ( ) , "elements" , jukebox -> file_list -> nb_files , "format" , jukebox -> stream_format , "stereo" , jukebox -> stream_channels == 2 ? json_true ( ) : json_false ( ) , "sample_rate" , jukebox -> stream_sample_rate , "bitrate" , jukebox -> stream_bitrate , "nb_client" , jukebox -> nb_client , "last_seen" , jukebox -> last_seen ) ; <S2SV_StartBug> if ( jukebox -> playlist_name != NULL ) { <S2SV_EndBug> json_object_set_new ( json_object_get ( j_stream , "jukebox" ) , "stored_playlist" , json_string ( jukebox -> playlist_name ) ) ; <S2SV_StartBug> j_client = jukebox_get_clients ( jukebox ) ; <S2SV_EndBug> if ( check_result_value ( j_client , T_OK ) ) { json_object_set ( json_object_get ( j_stream , "jukebox" ) , "clients" , json_object_get ( j_client , "clients" ) ) ; } else { <S2SV_StartBug> y_log_message ( Y_LOG_LEVEL_ERROR , "jukebox_get_info<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>jukebox_get_clients" ) ; <S2SV_EndBug> } json_decref ( j_client ) ; } } else { y_log_message ( Y_LOG_LEVEL_ERROR , "jukebox_get_info<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>jukebox<S2SV_blank>is<S2SV_blank>invalid" ) ; j_stream = json_pack ( "{si}" , "result" , T_ERROR_PARAM ) ; } return j_stream ; } | <S2SV_ModStart> last_seen ) ; j_client = jukebox_get_clients ( jukebox ) ; if ( check_result_value ( j_client , T_OK ) ) { json_object_set ( json_object_get ( j_stream , "jukebox" ) , "clients" , json_object_get ( j_client , "clients" ) ) ; } else { y_log_message ( Y_LOG_LEVEL_ERROR , "jukebox_get_info<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>jukebox_get_clients" ) ; } json_decref ( j_client ) ; <S2SV_ModStart> ) ) ; } <S2SV_ModEnd> } else { <S2SV_ModStart> ( Y_LOG_LEVEL_ERROR , <S2SV_ModEnd> "jukebox_get_info<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>jukebox<S2SV_blank>is<S2SV_blank>invalid" ) ; |
1,568 | CWE-000 static inline void _slot_property_extract ( const uint8_t * buf ) { <S2SV_StartBug> _byte_copy ( & __G_slot . LogicalSenderSlot , buf , 2 ) ; <S2SV_EndBug> <S2SV_StartBug> __G_slot . LogicalSenderSlot &= 0x0000ffff ; <S2SV_EndBug> _byte_copy ( & __G_slot . LogicalSenderMultiplexID , buf + 2 , 2 ) ; __G_slot . LogicalSenderMultiplexID &= 0x0000ffff ; _byte_copy ( & __G_slot . SlotDuration , buf + 4 , 2 ) ; __G_slot . SlotDuration &= 0x0000ffff ; __G_slot . PSPDuration = buf [ 6 ] ; __G_slot . TransmissionDuration = buf [ 7 ] ; _byte_copy ( & __G_slot . DelayCorrectionTerms , buf + 8 , 2 ) ; __G_slot . DelayCorrectionTerms &= 0x0000ffff ; __G_slot . AppDataLength = buf [ 10 ] ; _byte_copy ( & __G_slot . CNIAddressOffset , buf + 12 , 2 ) ; __G_slot . FlagPosition = buf [ 16 ] ; __G_slot . FrameType = buf [ 17 ] & 0x01 ; __G_slot . ModeChangePermission = ( buf [ 17 ] & 0x02 ) >> 1 ; __G_slot . ReintegrationAllow = ( buf [ 17 ] & 0x04 ) >> 2 ; __G_slot . ClockSynchronization = ( buf [ 17 ] & 0x08 ) >> 3 ; __G_slot . SynchronizationFrame = ( buf [ 17 ] & 0x10 ) >> 4 ; _byte_copy ( & __G_slot . AtTime , buf + 18 , 2 ) ; __G_slot . AtTime &= 0x0000ffff ; } | <S2SV_ModStart> & __G_slot . LogicalSenderMultiplexID , buf , 2 ) ; __G_slot . LogicalSenderSlot &= 0x0000ffff ; _byte_copy ( & <S2SV_ModEnd> __G_slot . LogicalSenderSlot <S2SV_ModStart> __G_slot . LogicalSenderSlot <S2SV_ModEnd> , buf + |
1,569 | CWE-000 static ERL_NIF_TERM restore_commands ( ErlNifEnv * env , int argc , const ERL_NIF_TERM argv [ ] ) { ERL_NIF_TERM * lines = NULL ; <S2SV_StartBug> FILE * file = fopen ( DB_FILE_NAME , "rt" ) ; <S2SV_EndBug> CHECK_OUTCOME ( file ) ; if ( file == NULL ) { return NO_RESTORED_LINES ; } int character = 0 ; int lines_count = 0 ; do { character = fgetc ( file ) ; if ( character == '\\n' ) { lines_count ++ ; } } while ( character != EOF ) ; rewind ( file ) ; <S2SV_StartBug> CHECK_OUTCOME ( file ) ; <S2SV_EndBug> <S2SV_StartBug> lines = ( ERL_NIF_TERM * ) enif_alloc ( lines_count * sizeof ( ERL_NIF_TERM ) ) ; <S2SV_EndBug> CHECK_OUTCOME ( lines ) ; long char_line_length = 0 ; char * char_line = NULL ; char line [ 256 ] ; for ( int i = 0 ; i < lines_count ; ++ i ) { long result = getline ( & char_line , & char_line_length , file ) ; memcpy ( line , char_line , strlen ( char_line ) - 1 ) ; line [ strlen ( char_line ) - 1 ] = 0 ; lines [ i ] = enif_make_string ( env , line , ERL_NIF_LATIN1 ) ; if ( result == - 1 ) { break ; } } free ( char_line ) ; return enif_make_tuple2 ( env , enif_make_atom ( env , "ok" ) , enif_make_list_from_array ( env , lines , lines_count ) ) ; } | <S2SV_ModStart> DB_FILE_NAME , "rt" <S2SV_ModEnd> ) ; if <S2SV_ModStart> file ) ; <S2SV_ModEnd> lines = ( <S2SV_ModStart> ( ERL_NIF_TERM ) <S2SV_ModEnd> ) ; long |
1,570 | CWE-000 static int try_to_wake_up ( struct task_struct * p , unsigned int state , int wake_flags ) { unsigned long flags ; int cpu , src_cpu , success = 0 ; smp_wmb ( ) ; raw_spin_lock_irqsave ( & p -> pi_lock , flags ) ; src_cpu = cpu = task_cpu ( p ) ; if ( ! ( p -> state & state ) ) goto out ; success = 1 ; if ( p -> on_rq && ttwu_remote ( p , wake_flags ) ) goto stat ; # ifdef CONFIG_SMP <S2SV_StartBug> while ( p -> on_cpu ) { <S2SV_EndBug> # ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW if ( ttwu_activate_remote ( p , wake_flags ) ) goto stat ; # else cpu_relax ( ) ; # endif } smp_rmb ( ) ; p -> sched_contributes_to_load = ! ! task_contributes_to_load ( p ) ; p -> state = TASK_WAKING ; if ( p -> sched_class -> task_waking ) p -> sched_class -> task_waking ( p ) ; cpu = select_task_rq ( p , SD_BALANCE_WAKE , wake_flags ) ; src_cpu = task_cpu ( p ) ; if ( src_cpu != cpu ) { wake_flags |= WF_MIGRATED ; set_task_cpu ( p , cpu ) ; } # endif ttwu_queue ( p , cpu ) ; stat : ttwu_stat ( p , cpu , wake_flags ) ; out : raw_spin_unlock_irqrestore ( & p -> pi_lock , flags ) ; if ( src_cpu != cpu && task_notify_on_migrate ( p ) ) atomic_notifier_call_chain ( & migration_notifier_head , cpu , ( void * ) src_cpu ) ; return success ; } | <S2SV_ModStart> # ifdef CONFIG_SMP smp_rmb ( ) ; |
1,571 | CWE-000 RealmTree * makeRealmTree ( MRIS const * mris ) { RealmTree * rt = ( RealmTree * ) calloc ( 1 , sizeof ( RealmTree ) ) ; rt -> mris = mris ; rt -> fnv_hash = computeRealmTreeHash ( mris ) ; rt -> vnoToRealmTreeNode = ( RealmTreeNode * * ) calloc ( mris -> nvertices , sizeof ( RealmTreeNode * ) ) ; if ( mris -> nvertices == 0 ) return rt ; int vno = 0 ; VERTEX const * vertex0 = & mris -> vertices [ vno ] ; float xLo = vertex0 -> x , xHi = xLo , yLo = vertex0 -> y , yHi = yLo , zLo = vertex0 -> z , zHi = zHi ; for ( vno = 1 ; vno < mris -> nvertices ; vno ++ ) { VERTEX const * vertex = & mris -> vertices [ vno ] ; float const x = vertex -> x , y = vertex -> y , z = vertex -> z ; xLo = MIN ( xLo , x ) ; yLo = MIN ( yLo , y ) ; zLo = MIN ( zLo , z ) ; xHi = MAX ( xHi , x ) ; yHi = MAX ( yHi , y ) ; zHi = MAX ( zHi , z ) ; } <S2SV_StartBug> xHi += ( xHi - xLo ) / 100.0 ; <S2SV_EndBug> yHi += ( yHi - yLo ) / 100.0 ; zHi += ( zHi - zLo ) / 100.0 ; RealmTreeNode * recentNode = & rt -> root ; recentNode -> xLo = xLo ; recentNode -> yLo = yLo ; recentNode -> zLo = zLo ; recentNode -> xHi = xHi ; recentNode -> yHi = yHi ; recentNode -> zHi = zHi ; for ( vno = 0 ; vno < mris -> nvertices ; vno ++ ) { VERTEX const * vertex = & mris -> vertices [ vno ] ; int const x = vertex -> x , y = vertex -> y , z = vertex -> z ; while ( ! nodeContains ( recentNode , x , y , z ) ) { recentNode = recentNode -> parent ; } recentNode = insertIntoNode ( rt , recentNode , vno , x , y , z ) ; } return rt ; } | <S2SV_ModStart> ; } xHi = widenHi ( xLo , xHi ) ; yHi = widenHi ( yLo , yHi ) ; zHi = widenHi ( zLo , zHi ) <S2SV_ModEnd> ; RealmTreeNode * |
1,572 | CWE-000 int td_write_keyhead ( td_t * td , unsigned off , const struct keyhead * keyhead ) <S2SV_StartBug> { <S2SV_EndBug> CHECK ( td_write ( td , off , keyhead , sizeof ( struct keyhead ) ) ) ; return 0 ; } | <S2SV_ModStart> keyhead ) { TDLOG ( "%s<S2SV_blank>At<S2SV_blank>%u,<S2SV_blank>value=%u,<S2SV_blank>size=%u,<S2SV_blank>checksum=%u,<S2SV_blank>next=%u,<S2SV_blank>previous=%u\\n" , __FILE__ , off , keyhead -> value , keyhead -> size , keyhead -> checksum , keyhead -> next , keyhead -> previous ) ; |
1,573 | CWE-000 static enum Tfa98xx_Error tfa9897_tfa_dsp_write_tables ( Tfa98xx_handle_t dev_idx , int sample_rate ) { <S2SV_StartBug> enum Tfa98xx_Error error ; <S2SV_EndBug> sample_rate = sample_rate ; error = tfa9897_dsp_write_vsfwdelay_table ( dev_idx ) ; if ( error == Tfa98xx_Error_Ok ) { error = tfa9897_dsp_write_cvfracdelay_table ( dev_idx ) ; } tfa98xx_dsp_reset ( dev_idx , 1 ) ; tfa98xx_dsp_reset ( dev_idx , 0 ) ; return error ; } | <S2SV_ModStart> enum Tfa98xx_Error error <S2SV_ModEnd> ; error = |
1,574 | CWE-000 void cec_delete_adapter ( struct cec_adapter * adap ) { if ( IS_ERR_OR_NULL ( adap ) ) return ; mutex_lock ( & adap -> lock ) ; __cec_s_phys_addr ( adap , CEC_PHYS_ADDR_INVALID , false ) ; mutex_unlock ( & adap -> lock ) ; kthread_stop ( adap -> kthread ) ; if ( adap -> kthread_config ) kthread_stop ( adap -> kthread_config ) ; <S2SV_StartBug> # if IS_REACHABLE ( CONFIG_RC_CORE ) <S2SV_EndBug> rc_free_device ( adap -> rc ) ; # endif kfree ( adap ) ; } | <S2SV_ModStart> ; # if 0 <S2SV_ModEnd> rc_free_device ( adap |
1,575 | CWE-000 <S2SV_StartBug> void parse_char ( char * line , char * res , char start , char end ) { <S2SV_EndBug> int i = 0 ; int j = 0 ; if ( line == NULL ) { printf ( "not<S2SV_blank>status\\n" ) ; return ; <S2SV_StartBug> } <S2SV_EndBug> while ( line [ i ] != start ) { i ++ ; } i ++ ; while ( line [ i ] != end ) { res [ j ] = line [ i ] ; j ++ ; i ++ ; } res [ j ] = '\\0' ; } | <S2SV_ModStart> end ) { << << << < HEAD <S2SV_ModStart> return ; } == == == = int i = 0 ; int j = 0 ; if ( line == NULL ) { printf ( "not<S2SV_blank>status\\n" ) ; return ; } >> >> >> > upstream / master |
1,576 | CWE-000 static int do_sata ( cmd_tbl_t * cmdtp , int flag , int argc , char * const argv [ ] ) { int rc = 0 ; if ( argc == 2 && strcmp ( argv [ 1 ] , "stop" ) == 0 ) return sata_stop ( ) ; if ( argc == 2 && strcmp ( argv [ 1 ] , "init" ) == 0 ) { if ( sata_curr_device != - 1 ) sata_stop ( ) ; <S2SV_StartBug> return sata_initialize ( ) ; <S2SV_EndBug> } if ( sata_curr_device == - 1 ) { rc = sata_initialize ( ) ; if ( rc == - 1 ) <S2SV_StartBug> return rc ; <S2SV_EndBug> sata_curr_device = rc ; } switch ( argc ) { case 0 : case 1 : return CMD_RET_USAGE ; case 2 : if ( strncmp ( argv [ 1 ] , "inf" , 3 ) == 0 ) { blk_list_devices ( IF_TYPE_SATA ) ; return 0 ; } else if ( strncmp ( argv [ 1 ] , "dev" , 3 ) == 0 ) { if ( blk_print_device_num ( IF_TYPE_SATA , sata_curr_device ) ) { printf ( "\\nno<S2SV_blank>SATA<S2SV_blank>devices<S2SV_blank>available\\n" ) ; return CMD_RET_FAILURE ; } return 0 ; } else if ( strncmp ( argv [ 1 ] , "part" , 4 ) == 0 ) { if ( blk_list_part ( IF_TYPE_SATA ) ) puts ( "\\nno<S2SV_blank>SATA<S2SV_blank>devices<S2SV_blank>available\\n" ) ; return 0 ; } return CMD_RET_USAGE ; case 3 : if ( strncmp ( argv [ 1 ] , "dev" , 3 ) == 0 ) { int dev = ( int ) simple_strtoul ( argv [ 2 ] , NULL , 10 ) ; if ( ! blk_show_device ( IF_TYPE_SATA , dev ) ) { sata_curr_device = dev ; printf ( "...<S2SV_blank>is<S2SV_blank>now<S2SV_blank>current<S2SV_blank>device\\n" ) ; } else { return CMD_RET_FAILURE ; } return 0 ; } else if ( strncmp ( argv [ 1 ] , "part" , 4 ) == 0 ) { int dev = ( int ) simple_strtoul ( argv [ 2 ] , NULL , 10 ) ; if ( blk_print_part_devnum ( IF_TYPE_SATA , dev ) ) { printf ( "\\nSATA<S2SV_blank>device<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>available\\n" , dev ) ; return CMD_RET_FAILURE ; } return rc ; } return CMD_RET_USAGE ; default : if ( strcmp ( argv [ 1 ] , "read" ) == 0 ) { ulong addr = simple_strtoul ( argv [ 2 ] , NULL , 16 ) ; ulong cnt = simple_strtoul ( argv [ 4 ] , NULL , 16 ) ; ulong n ; lbaint_t blk = simple_strtoul ( argv [ 3 ] , NULL , 16 ) ; printf ( "\\nSATA<S2SV_blank>read:<S2SV_blank>device<S2SV_blank>%d<S2SV_blank>block<S2SV_blank>#<S2SV_blank>%ld,<S2SV_blank>count<S2SV_blank>%ld<S2SV_blank>...<S2SV_blank>" , sata_curr_device , blk , cnt ) ; n = blk_read_devnum ( IF_TYPE_SATA , sata_curr_device , blk , cnt , ( ulong * ) addr ) ; printf ( "%ld<S2SV_blank>blocks<S2SV_blank>read:<S2SV_blank>%s\\n" , n , ( n == cnt ) ? "OK" : "ERROR" ) ; return ( n == cnt ) ? 0 : 1 ; } else if ( strcmp ( argv [ 1 ] , "write" ) == 0 ) { ulong addr = simple_strtoul ( argv [ 2 ] , NULL , 16 ) ; ulong cnt = simple_strtoul ( argv [ 4 ] , NULL , 16 ) ; ulong n ; lbaint_t blk = simple_strtoul ( argv [ 3 ] , NULL , 16 ) ; printf ( "\\nSATA<S2SV_blank>write:<S2SV_blank>device<S2SV_blank>%d<S2SV_blank>block<S2SV_blank>#<S2SV_blank>%ld,<S2SV_blank>count<S2SV_blank>%ld<S2SV_blank>...<S2SV_blank>" , sata_curr_device , blk , cnt ) ; n = blk_write_devnum ( IF_TYPE_SATA , sata_curr_device , blk , cnt , ( ulong * ) addr ) ; printf ( "%ld<S2SV_blank>blocks<S2SV_blank>written:<S2SV_blank>%s\\n" , n , ( n == cnt ) ? "OK" : "ERROR" ) ; return ( n == cnt ) ? 0 : 1 ; } else { return CMD_RET_USAGE ; } return rc ; } } | <S2SV_ModStart> ) ; return ( <S2SV_ModStart> sata_initialize ( ) < 0 ) ? CMD_RET_FAILURE : CMD_RET_SUCCESS <S2SV_ModStart> 1 ) return CMD_RET_FAILURE <S2SV_ModEnd> ; sata_curr_device = |
1,577 | CWE-000 void board_san ( board_t * board , move_t move , char * san ) { uint8_t from = move_from ( move ) ; uint8_t to = move_to ( move ) ; piece_type_t pt = board_piece_type_at ( board , from ) ; if ( ! move || ! pt ) { sprintf ( san , "--" ) ; return ; } if ( pt == kPawn ) { if ( square_file ( from ) != square_file ( to ) ) { * san ++ = 'a' + square_file ( from ) ; * san ++ = 'x' ; } } else { <S2SV_StartBug> * san ++ = PCHR [ pt ] ; <S2SV_EndBug> if ( board -> occupied [ kAll ] & BB_SQUARE ( to ) ) * san ++ = 'x' ; uint64_t candidates = 0 ; if ( pt == kKing ) candidates = attacks_sliding ( KING_DELTAS , to , board -> occupied [ kAll ] ) ; if ( pt == kKnight ) candidates = attacks_sliding ( KNIGHT_DELTAS , to , BB_ALL ) ; if ( pt == kRook || pt == kQueen ) candidates |= attacks_sliding ( ROOK_DELTAS , to , board -> occupied [ kAll ] ) ; if ( pt == kBishop || pt == kQueen ) candidates |= attacks_sliding ( BISHOP_DELTAS , to , board -> occupied [ kAll ] ) ; candidates &= board -> occupied [ pt ] & board -> occupied_co [ board -> turn ] ; bool rank = false , file = false ; while ( candidates ) { uint8_t square = bb_poplsb ( & candidates ) ; if ( square == from ) continue ; if ( square_rank ( from ) == square_rank ( square ) ) file = true ; if ( square_file ( from ) == square_file ( square ) ) rank = true ; else file = true ; } if ( file ) * san ++ = 'a' + square_file ( from ) ; if ( rank ) * san ++ = '1' + square_rank ( from ) ; <S2SV_StartBug> } <S2SV_EndBug> * san ++ = 'a' + square_file ( to ) ; * san ++ = '1' + square_rank ( to ) ; if ( move_promotion ( move ) ) { * san ++ = '=' ; * san ++ = PCHR [ move_promotion ( move ) ] ; } board_t board_after = * board ; board_move ( & board_after , move ) ; if ( board_is_game_over ( & board_after ) ) * san ++ = '#' ; * san ++ = 0 ; } | <S2SV_ModStart> [ pt ] <S2SV_ModEnd> ; uint64_t candidates <S2SV_ModStart> from ) ; if ( board -> occupied [ kAll ] & BB_SQUARE ( to ) ) * san ++ = 'x' ; |
1,578 | CWE-000 int decrypt_data ( const char * passphrase , const char * salt , const char * data , char * * result ) { uint8_t * key = key_from_passphrase ( passphrase , salt ) ; if ( ! key ) { return 1 ; } int len = strlen ( data ) ; if ( len / 2 < GCM_DIGEST_SIZE + SHA256_DIGEST_SIZE + 1 ) { <S2SV_StartBug> return 1 ; <S2SV_EndBug> } int enc_len = len / 2 ; int data_size = enc_len - GCM_DIGEST_SIZE - SHA256_DIGEST_SIZE ; uint8_t * enc = str2hex ( len , ( char * ) data ) ; <S2SV_StartBug> if ( ! enc ) { <S2SV_EndBug> return 1 ; } uint8_t digest [ GCM_DIGEST_SIZE ] ; uint8_t data_iv [ SHA256_DIGEST_SIZE ] ; uint8_t cipher_text [ data_size ] ; memcpy ( & digest , enc , GCM_DIGEST_SIZE ) ; memcpy ( & data_iv , enc + GCM_DIGEST_SIZE , SHA256_DIGEST_SIZE ) ; memcpy ( & cipher_text , enc + GCM_DIGEST_SIZE + SHA256_DIGEST_SIZE , data_size ) ; free ( enc ) ; struct gcm_aes256_ctx gcm_ctx ; gcm_aes256_set_key ( & gcm_ctx , key ) ; gcm_aes256_set_iv ( & gcm_ctx , SHA256_DIGEST_SIZE , data_iv ) ; free ( key ) ; * result = calloc ( data_size + 1 , sizeof ( char ) ) ; int pos = 0 ; size_t remain = data_size ; while ( pos < data_size ) { int len = AES_BLOCK_SIZE ; if ( remain < AES_BLOCK_SIZE ) { len = remain ; } gcm_aes256_decrypt ( & gcm_ctx , len , ( uint8_t * ) * result + pos , cipher_text + pos ) ; pos += AES_BLOCK_SIZE ; remain -= AES_BLOCK_SIZE ; } uint8_t actual_digest [ GCM_DIGEST_SIZE ] ; gcm_aes256_digest ( & gcm_ctx , GCM_DIGEST_SIZE , actual_digest ) ; int digest_match = memcmp ( actual_digest , digest , GCM_DIGEST_SIZE ) ; if ( digest_match != 0 ) { return 1 ; } return 0 ; } | <S2SV_ModStart> 1 ) { free ( key ) ; <S2SV_ModStart> enc ) { free ( key ) ; |
1,579 | CWE-000 GLubyte * _mesa_make_extension_string ( struct gl_context * ctx ) { char * exts = 0 ; size_t length = 0 ; unsigned count ; <S2SV_StartBug> extension_index * extension_indices ; <S2SV_EndBug> const char * extra_extensions = get_extension_override ( ctx ) ; unsigned k ; unsigned j ; unsigned maxYear = ~ 0 ; { const char * env = getenv ( "MESA_EXTENSION_MAX_YEAR" ) ; if ( env ) { maxYear = atoi ( env ) ; _mesa_debug ( ctx , "Note:<S2SV_blank>limiting<S2SV_blank>GL<S2SV_blank>extensions<S2SV_blank>to<S2SV_blank>%u<S2SV_blank>or<S2SV_blank>earlier\\n" , maxYear ) ; } } count = 0 ; for ( k = 0 ; k < MESA_EXTENSION_COUNT ; ++ k ) { const struct mesa_extension * i = _mesa_extension_table + k ; if ( i -> year <= maxYear && _mesa_extension_supported ( ctx , k ) ) { length += strlen ( i -> name ) + 1 ; <S2SV_StartBug> ++ count ; <S2SV_EndBug> } } if ( extra_extensions != NULL ) length += 1 + strlen ( extra_extensions ) ; exts = calloc ( ALIGN ( length + 1 , 4 ) , sizeof ( char ) ) ; if ( exts == NULL ) { return NULL ; } <S2SV_StartBug> extension_indices = malloc ( count * sizeof ( extension_index ) ) ; <S2SV_EndBug> if ( extension_indices == NULL ) { free ( exts ) ; return NULL ; } j = 0 ; for ( k = 0 ; k < MESA_EXTENSION_COUNT ; ++ k ) { if ( _mesa_extension_table [ k ] . year <= maxYear && _mesa_extension_supported ( ctx , k ) ) { extension_indices [ j ++ ] = k ; } } assert ( j == count ) ; qsort ( extension_indices , count , sizeof * extension_indices , extension_compare ) ; for ( j = 0 ; j < count ; ++ j ) { const struct mesa_extension * i = & _mesa_extension_table [ extension_indices [ j ] ] ; assert ( _mesa_extension_supported ( ctx , extension_indices [ j ] ) ) ; strcat ( exts , i -> name ) ; strcat ( exts , "<S2SV_blank>" ) ; } <S2SV_StartBug> free ( extension_indices ) ; <S2SV_EndBug> if ( extra_extensions != 0 ) { strcat ( exts , extra_extensions ) ; } return ( GLubyte * ) exts ; } | <S2SV_ModStart> count ; extension_index extension_indices [ MESA_EXTENSION_COUNT ] <S2SV_ModEnd> ; const char <S2SV_ModStart> + 1 ; extension_indices [ count ++ ] = k <S2SV_ModEnd> ; } } <S2SV_ModStart> NULL ; } <S2SV_ModEnd> for ( j <S2SV_ModStart> ) ; } <S2SV_ModEnd> if ( extra_extensions |
1,580 | CWE-000 set_t * closure ( set_t * * set_state ) { if ( ! set_state ) { return ( EMPTY_SET ) ; } set_t * last = EMPTY_SET ; do { del_set ( last ) ; last = cpy_set ( * set_state ) ; set_t * it = last ; while ( it ) { set_t * pass_state = edges ( ( state_t * ) it -> item , EPSILON ) ; union_set ( set_state , pass_state ) ; <S2SV_StartBug> it = it -> next ; <S2SV_EndBug> } } while ( ! equal_set ( * set_state , last ) ) ; del_set ( last ) ; return ( * set_state ) ; } | <S2SV_ModStart> pass_state ) ; del_set ( pass_state ) ; |
1,581 | CWE-000 static void send_ack ( struct dhcps_msg * m , u16_t len ) { u8_t * end ; struct pbuf * p , * q ; u8_t * data ; u16_t cnt = 0 ; u16_t i ; err_t SendAck_err_t ; create_msg ( m ) ; end = add_msg_type ( & m -> options [ 4 ] , DHCPACK ) ; end = add_offer_options ( end ) ; end = add_end ( end ) ; p = dhcps_pbuf_alloc ( len ) ; # if DHCPS_DEBUG DHCPS_LOG ( "udhcp:<S2SV_blank>send_ack>>p->ref<S2SV_blank>=<S2SV_blank>%d\\n" , p -> ref ) ; # endif if ( p != NULL ) { # if DHCPS_DEBUG DHCPS_LOG ( "dhcps:<S2SV_blank>send_ack>>pbuf_alloc<S2SV_blank>succeed\\n" ) ; DHCPS_LOG ( "dhcps:<S2SV_blank>send_ack>>p->tot_len<S2SV_blank>=<S2SV_blank>%d\\n" , p -> tot_len ) ; DHCPS_LOG ( "dhcps:<S2SV_blank>send_ack>>p->len<S2SV_blank>=<S2SV_blank>%d\\n" , p -> len ) ; # endif q = p ; while ( q != NULL ) { data = ( u8_t * ) q -> payload ; for ( i = 0 ; i < q -> len ; i ++ ) { data [ i ] = ( ( u8_t * ) m ) [ cnt ++ ] ; # if DHCPS_DEBUG DHCPS_LOG ( "%02x<S2SV_blank>" , data [ i ] ) ; if ( ( i + 1 ) % 16 == 0 ) { DHCPS_LOG ( "\\n" ) ; } # endif } q = q -> next ; } } else { # if DHCPS_DEBUG DHCPS_LOG ( "dhcps:<S2SV_blank>send_ack>>pbuf_alloc<S2SV_blank>failed\\n" ) ; # endif return ; } SendAck_err_t = udp_sendto ( pcb_dhcps , p , IP_ADDR_BROADCAST , DHCPS_CLIENT_PORT ) ; <S2SV_StartBug> DHCPS_LOG ( "dhcps:<S2SV_blank>send_ack>>udp_sendto<S2SV_blank>result<S2SV_blank>%x\\n" , SendAck_err_t ) ; <S2SV_EndBug> # if DHCPS_DEBUG udp_sendto ( pcb_dhcps , p , IP_ADDR_BROADCAST , DHCPS_CLIENT_PORT ) ; # endif if ( SendAck_err_t == ERR_OK ) { dhcps_cb ( m -> yiaddr ) ; } if ( p -> ref != 0 ) { # if DHCPS_DEBUG DHCPS_LOG ( "udhcp:<S2SV_blank>send_ack>>free<S2SV_blank>pbuf\\n" ) ; # endif pbuf_free ( p ) ; } } | <S2SV_ModStart> DHCPS_CLIENT_PORT ) ; # if DHCPS_DEBUG <S2SV_ModStart> "dhcps:<S2SV_blank>send_ack>>udp_sendto<S2SV_blank>result<S2SV_blank>%x\\n" , SendAck_err_t <S2SV_ModEnd> ) ; # |
1,582 | CWE-000 int aiPlaceShips ( Board * map ) { FILE * test_data = fopen ( "../../test/test_map_fill_data.txt" , "r" ) ; if ( test_data == NULL ) { printf ( "File<S2SV_blank>err\\n" ) ; return - 1 ; } fpos_t fpos ; fgetpos ( test_data , & fpos ) ; char * buffer = NULL ; size_t len ; while ( getline ( & buffer , & len , test_data ) != - 1 ) { char * ship_t = strtok ( buffer , ":" ) ; char * coordinates_text = strtok ( NULL , ":" ) ; printf ( "Trying<S2SV_blank>to<S2SV_blank>place<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>...<S2SV_blank>" , ship_t , coordinates_text ) ; eShipType shipType = NONE ; if ( strcmp ( ship_t , "Lincor" ) == 0 ) { shipType = LINCOR ; } else if ( ! strcmp ( ship_t , "Destroyer" ) ) { shipType = DESTROYER ; } else if ( ! strcmp ( ship_t , "Cruiser" ) ) { shipType = CRUISER ; } else if ( ! strcmp ( ship_t , "Boat" ) ) { shipType = BOAT ; } sShipCoordinates shipCoordinates = * getShipCoordinates ( coordinates_text ) ; if ( & shipCoordinates == NULL ) { return 0 ; } int res = placeShip ( map , shipCoordinates , shipType , PLAYER_SHIP ) ; if ( res != 1 ) { puts ( "OK" ) ; } else { puts ( "FAIL" ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> ) ; return - 1 ; } } return <S2SV_ModStart> 0 ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
1,583 | CWE-000 static sqInt NoDbgRegParms genClearAndSetSmallIntegerTagsIn ( sqInt scratchReg ) { AbstractInstruction * anInstruction ; AbstractInstruction * anInstruction1 ; sqInt quickConstant ; quickConstant = - 1 - ( tagMask ( ) ) ; <S2SV_StartBug> anInstruction = genoperandoperand ( AndCqR , quickConstant , scratchReg ) ; <S2SV_EndBug> <S2SV_StartBug> anInstruction1 = genoperandoperand ( OrCqR , 1 , scratchReg ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ) ) ; anInstruction1 <S2SV_ModEnd> = genoperandoperand ( <S2SV_ModStart> scratchReg ) ; anInstruction <S2SV_ModEnd> = genoperandoperand ( |
1,584 | CWE-000 <S2SV_StartBug> static entry_t new_entry_seq ( sequence_t seq , char * name ) { <S2SV_EndBug> entry_t r = ( entry_t ) malloc ( sizeof ( struct entry ) ) ; r -> type_tag = ENTRY_SEQ ; r -> name = name ; r -> e . seq = seq ; return r ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> entry_t new_entry_seq ( |
1,585 | CWE-000 int mwGetVarValueInt ( HttpVariables * vars , const char * varname , int defval ) { int i ; if ( vars && varname ) { for ( i = 0 ; ( vars + i ) -> name ; i ++ ) { if ( ! strcmp ( ( vars + i ) -> name , varname ) ) { char * p = ( vars + i ) -> value ; <S2SV_StartBug> return p ? atoi ( p ) : defval ; <S2SV_EndBug> } } } return defval ; } | <S2SV_ModStart> value ; return * |
1,586 | CWE-000 int iput ( MINODE * mip ) { int blk , disp ; char buf [ BLKSIZE ] ; INODE * ip ; mip -> refCount -- ; if ( mip -> refCount > 0 ) return ; if ( ! mip -> dirty ) return ; printf ( "iput:<S2SV_blank>dev=%d<S2SV_blank>ino=%d\\n" , mip -> dev , mip -> ino ) ; blk = ( mip -> ino - 1 ) / 8 + iblock ; disp = ( mip -> ino - 1 ) % 8 ; <S2SV_StartBug> get_block ( mip -> dev , block , buf ) ; <S2SV_EndBug> ip = ( INODE * ) buf + disp ; * ip = mip -> INODE ; <S2SV_StartBug> put_block ( mip -> dev , block , buf ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> dev , blk <S2SV_ModEnd> , buf ) <S2SV_ModStart> -> dev , blk <S2SV_ModEnd> , buf ) |
1,587 | CWE-000 void GuiSingleton_sdl_draw ( ) { assert ( imgSurface != NULL ) ; assert ( winSurface != NULL ) ; <S2SV_StartBug> assert ( win != NULL ) ; <S2SV_EndBug> assert ( ! fullscreen ) ; SDL_Rect imgRect = ( SDL_Rect ) { . x = 0 , . y = 0 , . w = dim . w , . h = dim . h } , winRect = ( SDL_Rect ) { . x = 0 , . y = 0 , . w = ( int ) ( scaleFactor * ( double ) dim . w ) , . h = ( int ) ( scaleFactor * ( double ) dim . h ) } ; SDL_BlitScaled ( imgSurface , & imgRect , winSurface , & winRect ) ; SDL_UpdateWindowSurface ( win ) ; } | <S2SV_ModStart> win != NULL <S2SV_ModEnd> ) ; SDL_Rect |
1,588 | CWE-000 xi_state_t xi_bsp_io_fs_open ( const char * const resource_name , const uint32_t size , const xi_fs_open_flags_t open_flags , xi_fs_resource_handle_t * resource_handle_out ) { ( void ) open_flags ; # ifdef XI_DEBUG__FOR_FIRMWARE_UPDATE_TESTING_PURPOSES _ReadBootInfo ( & sBootInfo ) ; # endif if ( 1 == xi_bsp_fwu_is_firmware ( resource_name ) ) { if ( 0 != sl_extlib_FlcOpenFile ( "/sys/mcuimgA.bin" , size , NULL , & firmware_file_handle_last_opened , FS_MODE_OPEN_WRITE ) ) { firmware_file_handle_last_opened = 0 ; * resource_handle_out = 0 ; return XI_FS_OPEN_ERROR ; } * resource_handle_out = firmware_file_handle_last_opened ; } else { <S2SV_StartBug> if ( 0 != sl_FsOpen ( ( _u8 * ) resource_name , <S2SV_EndBug> xi_bsp_io_fs_open_flags_to_sl_flags ( size , open_flags ) , <S2SV_StartBug> NULL , ( _i32 * ) * resource_handle_out ) ) <S2SV_EndBug> { * resource_handle_out = 0 ; return XI_FS_OPEN_ERROR ; } <S2SV_StartBug> } <S2SV_EndBug> return XI_STATE_OK ; } | <S2SV_ModStart> } else { _i32 file_handle = 0 ; <S2SV_ModStart> , NULL , & file_handle <S2SV_ModEnd> ) ) { <S2SV_ModStart> XI_FS_OPEN_ERROR ; } * resource_handle_out = file_handle ; |
1,589 | CWE-000 static void apply_peer_transport_params ( quicly_conn_t * conn ) { conn -> egress . max_data . permitted = conn -> super . peer . transport_params . initial_max_data ; conn -> egress . max_stream_id_bidi = conn -> super . peer . transport_params . initial_max_streams_bidi * 4 - ( quicly_is_client ( conn ) ? 4 : 3 ) ; conn -> egress . max_stream_id_uni = <S2SV_StartBug> conn -> super . peer . transport_params . initial_max_streams_uni * 4 + ( quicly_is_client ( conn ) ? 2 : 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> initial_max_streams_uni * 4 - <S2SV_ModEnd> ( quicly_is_client ( |
1,590 | CWE-000 void family_0 ( Chip8 * const chip8 ) { switch ( chip8 -> opcode & 0x00FF ) { case 0xE0 : memset ( chip8 -> gfx , 0 , 2048 ) ; chip8 -> shouldDraw = true ; break ; case 0xEE : chip8 -> pc = chip8 -> stack [ -- chip8 -> sp ] ; break ; default : <S2SV_StartBug> fprintf ( stderr , "[0x0000]<S2SV_blank>OPCODE<S2SV_blank>0x%04X<S2SV_blank>NOT<S2SV_blank>RECOGNIZED\\n" , chip8 -> opcode ) ; <S2SV_EndBug> exit ( 1 ) ; } chip8 -> pc += 2 ; } | <S2SV_ModStart> ; default : die ( <S2SV_ModEnd> "[0x0000]<S2SV_blank>OPCODE<S2SV_blank>0x%04X<S2SV_blank>NOT<S2SV_blank>RECOGNIZED\\n" , chip8 <S2SV_ModStart> chip8 -> opcode <S2SV_ModEnd> ) ; } |
1,591 | CWE-000 void ft_putchar ( char c ) { <S2SV_StartBug> write ( 1 , & c , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> c ) { unsigned char a ; a = ( unsigned char ) c ; <S2SV_ModStart> 1 , & a <S2SV_ModEnd> , 1 ) |
1,592 | CWE-000 static int __cpufreq_stats_create_table ( struct cpufreq_policy * policy , <S2SV_StartBug> struct cpufreq_frequency_table * table , int count ) <S2SV_EndBug> { unsigned int i , j , ret = 0 ; struct cpufreq_stats * stat ; <S2SV_StartBug> unsigned int alloc_size ; <S2SV_EndBug> unsigned int cpu = policy -> cpu ; if ( per_cpu ( cpufreq_stats_table , cpu ) ) return - EBUSY ; stat = kzalloc ( sizeof ( * stat ) , GFP_KERNEL ) ; if ( ( stat ) == NULL ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>cpufreq_stats<S2SV_blank>table\\n" ) ; return - ENOMEM ; } ret = sysfs_create_group ( & policy -> kobj , & stats_attr_group ) ; <S2SV_StartBug> if ( ret ) { <S2SV_EndBug> pr_err ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>cpufreq_stats<S2SV_blank>sysfs\\n" ) ; goto error_out ; } stat -> cpu = cpu ; per_cpu ( cpufreq_stats_table , cpu ) = stat ; alloc_size = count * sizeof ( int ) + count * sizeof ( u64 ) ; # ifdef CONFIG_CPU_FREQ_STAT_DETAILS alloc_size += count * count * sizeof ( int ) ; # endif stat -> max_state = count ; stat -> time_in_state = kzalloc ( alloc_size , GFP_KERNEL ) ; if ( ! stat -> time_in_state ) { ret = - ENOMEM ; pr_err ( "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>cpufreq_stats<S2SV_blank>table\\n" ) ; goto error_alloc ; } stat -> freq_table = ( unsigned int * ) ( stat -> time_in_state + count ) ; # ifdef CONFIG_CPU_FREQ_STAT_DETAILS stat -> trans_table = stat -> freq_table + count ; # endif j = 0 ; for ( i = 0 ; table [ i ] . frequency != CPUFREQ_TABLE_END ; i ++ ) { unsigned int freq = table [ i ] . frequency ; if ( freq == CPUFREQ_ENTRY_INVALID ) continue ; if ( freq_table_get_index ( stat , freq ) == - 1 ) stat -> freq_table [ j ++ ] = freq ; } stat -> state_num = j ; spin_lock ( & cpufreq_stats_lock ) ; stat -> last_time = get_jiffies_64 ( ) ; stat -> last_index = freq_table_get_index ( stat , policy -> cur ) ; spin_unlock ( & cpufreq_stats_lock ) ; return 0 ; error_alloc : sysfs_remove_group ( & policy -> kobj , & stats_attr_group ) ; <S2SV_StartBug> error_out : <S2SV_EndBug> kfree ( stat ) ; per_cpu ( cpufreq_stats_table , cpu ) = NULL ; return ret ; } | <S2SV_ModStart> * policy , int cpu , <S2SV_ModStart> unsigned int alloc_size <S2SV_ModEnd> ; if ( <S2SV_ModStart> stats_attr_group ) ; <S2SV_ModEnd> stat -> cpu <S2SV_ModStart> stats_attr_group ) ; <S2SV_ModEnd> kfree ( stat |
1,593 | CWE-000 static void uwsc_timer_cb ( struct ev_loop * loop , struct ev_timer * w , int revents ) { struct uwsc_client * cl = container_of ( w , struct uwsc_client , timer ) ; <S2SV_StartBug> static time_t connect_time ; <S2SV_EndBug> static time_t last_ping ; static int ntimeout ; time_t now = time ( NULL ) ; if ( unlikely ( cl -> state == CLIENT_STATE_CONNECTING ) ) { <S2SV_StartBug> if ( connect_time == 0 ) { <S2SV_EndBug> connect_time = now ; return ; } if ( now - connect_time > 5 ) { uwsc_error ( cl , UWSC_ERROR_CONNECT , "Connect<S2SV_blank>timeout" ) ; return ; } } if ( unlikely ( cl -> state != CLIENT_STATE_MESSAGE ) ) return ; <S2SV_StartBug> if ( cl -> ping_interval == 0 ) <S2SV_EndBug> return ; if ( unlikely ( cl -> wait_pong ) ) { <S2SV_StartBug> if ( now - last_ping < 3 ) <S2SV_EndBug> return ; <S2SV_StartBug> uwsc_log_err ( "ping<S2SV_blank>timeout<S2SV_blank>%d\\n" , ++ ntimeout ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ntimeout > 2 ) { <S2SV_EndBug> uwsc_error ( cl , UWSC_ERROR_PING_TIMEOUT , "ping<S2SV_blank>timeout" ) ; return ; } } else { <S2SV_StartBug> ntimeout = 0 ; <S2SV_EndBug> } <S2SV_StartBug> if ( now - last_ping < cl -> ping_interval ) <S2SV_EndBug> return ; <S2SV_StartBug> last_ping = now ; <S2SV_EndBug> <S2SV_StartBug> cl -> ping ( cl ) ; <S2SV_EndBug> cl -> wait_pong = true ; } | <S2SV_ModStart> timer ) ; ev_tstamp now = ev_now ( loop <S2SV_ModEnd> ) ; if <S2SV_ModStart> { if ( now - cl -> start_time > UWSC_MAX_CONNECT_TIME <S2SV_ModEnd> ) { uwsc_error <S2SV_ModStart> cl -> ping_interval < 1 <S2SV_ModEnd> ) return ; <S2SV_ModStart> ( now - cl -> <S2SV_ModStart> "ping<S2SV_blank>timeout<S2SV_blank>%d\\n" , ++ cl -> <S2SV_ModStart> ; if ( cl -> <S2SV_ModStart> } else { cl -> <S2SV_ModStart> ( now - cl -> <S2SV_ModStart> ) return ; cl -> ping ( cl ) ; cl -> <S2SV_ModStart> ; cl -> <S2SV_ModEnd> wait_pong = true |
1,594 | CWE-000 int ssl_connect ( thread_t * thread , int new_req ) { checker_t * checker = THREAD_ARG ( thread ) ; http_checker_t * http_get_check = CHECKER_ARG ( checker ) ; request_t * req = http_get_check -> req ; # ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_ url_t * url = list_element ( http_get_check -> url , http_get_check -> url_it ) ; char * vhost = NULL ; # endif int ret = 0 ; if ( new_req ) { int bio_fd ; <S2SV_StartBug> req -> ssl = SSL_new ( check_data -> ssl -> ctx ) ; <S2SV_EndBug> <S2SV_StartBug> req -> bio = BIO_new_socket ( thread -> u . fd , BIO_NOCLOSE ) ; <S2SV_EndBug> BIO_get_fd ( req -> bio , & bio_fd ) ; fcntl ( bio_fd , F_SETFD , fcntl ( bio_fd , F_GETFD ) | FD_CLOEXEC ) ; # if HAVE_SSL_SET0_RBIO BIO_up_ref ( req -> bio ) ; SSL_set0_rbio ( req -> ssl , req -> bio ) ; SSL_set0_wbio ( req -> ssl , req -> bio ) ; # else SSL_set_bio ( req -> ssl , req -> bio , req -> bio ) ; # endif # ifdef _HAVE_SSL_SET_TLSEXT_HOST_NAME_ if ( http_get_check -> enable_sni ) { if ( url && url -> virtualhost ) vhost = url -> virtualhost ; else if ( http_get_check -> virtualhost ) vhost = http_get_check -> virtualhost ; else if ( checker -> vs -> virtualhost ) vhost = checker -> vs -> virtualhost ; if ( vhost ) SSL_set_tlsext_host_name ( req -> ssl , vhost ) ; } # endif } ret = SSL_connect ( req -> ssl ) ; return ret ; } | <S2SV_ModStart> int bio_fd ; if ( ! ( <S2SV_ModStart> -> ctx ) ) ) { log_message ( LOG_INFO , "Unable<S2SV_blank>to<S2SV_blank>establish<S2SV_blank>ssl<S2SV_blank>connection<S2SV_blank>-<S2SV_blank>SSL_new()<S2SV_blank>failed" ) ; return 0 ; } if ( ! ( <S2SV_ModEnd> req -> bio <S2SV_ModStart> , BIO_NOCLOSE ) ) ) { log_message ( LOG_INFO , "Unable<S2SV_blank>to<S2SV_blank>establish<S2SV_blank>ssl<S2SV_blank>connection<S2SV_blank>-<S2SV_blank>BIO_new_socket()<S2SV_blank>failed" ) ; return 0 ; } <S2SV_ModEnd> BIO_get_fd ( req |
1,595 | CWE-000 int fht_set ( int fd , const struct hauscode * hauscode , const char * command , const char * payload ) { const struct fht_command * fht_command ; unsigned char fht_val ; bool found = false ; int i , err ; for_each_fht_command ( fht_commands , fht_command , i ) <S2SV_StartBug> if ( ! strcmp ( fht_command -> name , command ) ) { <S2SV_EndBug> found = true ; break ; } if ( ! found ) return - EINVAL ; err = fht_command -> input_conversion ( payload ) ; if ( err < 0 ) return err ; fht_val = err ; return fht_send ( fd , hauscode , fht_command -> function_id , fht_val ) ; } | <S2SV_ModStart> ) if ( fht_command -> name && |
1,596 | CWE-000 int qat_rsa_decrypt ( CpaCyRsaDecryptOpData * dec_op_data , int rsa_len , CpaFlatBuffer * output_buf ) { <S2SV_StartBug> struct op_done op_done ; <S2SV_EndBug> CpaStatus sts = CPA_STATUS_FAIL ; CpaInstanceHandle instance_handle = NULL ; int job_ret = 0 ; int sync_mode_ret = 0 ; DEBUG ( "-<S2SV_blank>Started\\n" ) ; if ( qat_use_signals ( ) ) { qat_atomic_inc ( num_requests_in_flight ) ; if ( pthread_kill ( timer_poll_func_thread , SIGUSR1 ) != 0 ) { WARN ( "pthread_kill<S2SV_blank>error\\n" ) ; QATerr ( QAT_F_QAT_RSA_DECRYPT , ERR_R_INTERNAL_ERROR ) ; qat_atomic_dec ( num_requests_in_flight ) ; return 0 ; } } qat_init_op_done ( & op_done ) ; if ( op_done . job != NULL ) { if ( qat_setup_async_event_notification ( 0 ) == 0 ) { WARN ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>async<S2SV_blank>event<S2SV_blank>notifications\\n" ) ; QATerr ( QAT_F_QAT_RSA_DECRYPT , ERR_R_INTERNAL_ERROR ) ; qat_cleanup_op_done ( & op_done ) ; qat_atomic_dec_if_polling ( num_requests_in_flight ) ; return 0 ; } } else { qat_cleanup_op_done ( & op_done ) ; sync_mode_ret = qat_rsa_decrypt_CRT ( dec_op_data , rsa_len , output_buf ) ; qat_atomic_dec_if_polling ( num_requests_in_flight ) ; return sync_mode_ret ; } CRYPTO_QAT_LOG ( "-<S2SV_blank>RSA\\n" ) ; do { if ( NULL == ( instance_handle = get_next_inst ( ) ) ) { WARN ( "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>an<S2SV_blank>instance\\n" ) ; QATerr ( QAT_F_QAT_RSA_DECRYPT , ERR_R_INTERNAL_ERROR ) ; qat_clear_async_event_notification ( ) ; qat_cleanup_op_done ( & op_done ) ; qat_atomic_dec_if_polling ( num_requests_in_flight ) ; return 0 ; } DUMP_RSA_DECRYPT ( instance_handle , & op_done , dec_op_data , output_buf ) ; sts = cpaCyRsaDecrypt ( instance_handle , qat_rsaCallbackFn , & op_done , dec_op_data , output_buf ) ; if ( sts == CPA_STATUS_RETRY ) { if ( ( qat_wake_job ( op_done . job , 0 ) == 0 ) || ( qat_pause_job ( op_done . job , 0 ) == 0 ) ) { WARN ( "qat_wake_job<S2SV_blank>or<S2SV_blank>qat_pause_job<S2SV_blank>failed\\n" ) ; break ; } } } while ( sts == CPA_STATUS_RETRY ) ; if ( sts != CPA_STATUS_SUCCESS ) { WARN ( "Failed<S2SV_blank>to<S2SV_blank>submit<S2SV_blank>request<S2SV_blank>to<S2SV_blank>qat<S2SV_blank>-<S2SV_blank>status<S2SV_blank>=<S2SV_blank>%d\\n" , sts ) ; QATerr ( QAT_F_QAT_RSA_DECRYPT , ERR_R_INTERNAL_ERROR ) ; qat_clear_async_event_notification ( ) ; qat_cleanup_op_done ( & op_done ) ; qat_atomic_dec_if_polling ( num_requests_in_flight ) ; return 0 ; } do { if ( ( job_ret = qat_pause_job ( op_done . job , 0 ) ) == 0 ) pthread_yield ( ) ; } while ( ! op_done . flag || QAT_CHK_JOB_RESUMED_UNEXPECTEDLY ( job_ret ) ) ; DUMP_RSA_DECRYPT_OUTPUT ( output_buf ) ; qat_cleanup_op_done ( & op_done ) ; qat_atomic_dec_if_polling ( num_requests_in_flight ) ; if ( op_done . verifyResult != CPA_TRUE ) { WARN ( "Verification<S2SV_blank>of<S2SV_blank>result<S2SV_blank>failed\\n" ) ; QATerr ( QAT_F_QAT_RSA_DECRYPT , ERR_R_INTERNAL_ERROR ) ; return 0 ; } DEBUG ( "-<S2SV_blank>Finished\\n" ) ; return 1 ; } | <S2SV_ModStart> output_buf ) { op_done_t <S2SV_ModEnd> op_done ; CpaStatus |
1,597 | CWE-000 void counting_sorting ( struct int_array * A , struct int_array * B , struct int_array * C ) { int i = 0 ; for ( i = 0 ; i < C -> size ; i ++ ) { C -> data [ i ] = 0 ; } for ( i = 0 ; i < A -> size ; i ++ ) { C -> data [ A -> data [ i ] ] = C -> data [ A -> data [ i ] ] + 1 ; } for ( i = 1 ; i < C -> size ; i ++ ) { C -> data [ i ] = C -> data [ i ] + C -> data [ i - 1 ] ; } for ( i = A -> size - 1 ; i >= 0 ; i -- ) { <S2SV_StartBug> B -> data [ C -> data [ A -> data [ i ] ] ] = A -> data [ i ] ; <S2SV_EndBug> C -> data [ A -> data [ i ] ] = C -> data [ A -> data [ i ] ] - 1 ; } } | <S2SV_ModStart> i ] ] - 1 |
1,598 | CWE-000 sctp_disposition_t sctp_sf_do_5_1D_ce ( struct net * net , const struct sctp_endpoint * ep , const struct sctp_association * asoc , const sctp_subtype_t type , void * arg , sctp_cmd_seq_t * commands ) { struct sctp_chunk * chunk = arg ; struct sctp_association * new_asoc ; sctp_init_chunk_t * peer_init ; struct sctp_chunk * repl ; struct sctp_ulpevent * ev , * ai_ev = NULL ; int error = 0 ; struct sctp_chunk * err_chk_p ; struct sock * sk ; if ( ep == sctp_sk ( net -> sctp . ctl_sock ) -> ep ) { SCTP_INC_STATS ( net , SCTP_MIB_OUTOFBLUES ) ; return sctp_sf_tabort_8_4_8 ( net , ep , asoc , type , arg , commands ) ; } if ( ! sctp_chunk_length_valid ( chunk , sizeof ( sctp_chunkhdr_t ) ) ) return sctp_sf_pdiscard ( net , ep , asoc , type , arg , commands ) ; sk = ep -> base . sk ; if ( ! sctp_sstate ( sk , LISTENING ) || ( sctp_style ( sk , TCP ) && sk_acceptq_is_full ( sk ) ) ) return sctp_sf_tabort_8_4_8 ( net , ep , asoc , type , arg , commands ) ; chunk -> subh . cookie_hdr = ( struct sctp_signed_cookie * ) chunk -> skb -> data ; if ( ! pskb_pull ( chunk -> skb , ntohs ( chunk -> chunk_hdr -> length ) - sizeof ( sctp_chunkhdr_t ) ) ) goto nomem ; new_asoc = sctp_unpack_cookie ( ep , asoc , chunk , GFP_ATOMIC , & error , & err_chk_p ) ; if ( ! new_asoc ) { switch ( error ) { case - SCTP_IERROR_NOMEM : goto nomem ; case - SCTP_IERROR_STALE_COOKIE : sctp_send_stale_cookie_err ( net , ep , asoc , chunk , commands , err_chk_p ) ; return sctp_sf_pdiscard ( net , ep , asoc , type , arg , commands ) ; case - SCTP_IERROR_BAD_SIG : default : return sctp_sf_pdiscard ( net , ep , asoc , type , arg , commands ) ; } } peer_init = & chunk -> subh . cookie_hdr -> c . peer_init [ 0 ] ; if ( ! sctp_process_init ( new_asoc , chunk , & chunk -> subh . cookie_hdr -> c . peer_addr , peer_init , GFP_ATOMIC ) ) goto nomem_init ; error = sctp_auth_asoc_init_active_key ( new_asoc , GFP_ATOMIC ) ; if ( error ) goto nomem_init ; if ( chunk -> auth_chunk ) { struct sctp_chunk auth ; sctp_ierror_t ret ; <S2SV_StartBug> auth . skb = chunk -> auth_chunk ; <S2SV_EndBug> auth . asoc = chunk -> asoc ; auth . sctp_hdr = chunk -> sctp_hdr ; auth . chunk_hdr = ( sctp_chunkhdr_t * ) skb_push ( chunk -> auth_chunk , sizeof ( sctp_chunkhdr_t ) ) ; skb_pull ( chunk -> auth_chunk , sizeof ( sctp_chunkhdr_t ) ) ; auth . transport = chunk -> transport ; ret = sctp_sf_authenticate ( net , ep , new_asoc , type , & auth ) ; kfree_skb ( chunk -> auth_chunk ) ; if ( ret != SCTP_IERROR_NO_ERROR ) { sctp_association_free ( new_asoc ) ; return sctp_sf_pdiscard ( net , ep , asoc , type , arg , commands ) ; } } repl = sctp_make_cookie_ack ( new_asoc , chunk ) ; if ( ! repl ) goto nomem_init ; ev = sctp_ulpevent_make_assoc_change ( new_asoc , 0 , SCTP_COMM_UP , 0 , new_asoc -> c . sinit_num_ostreams , new_asoc -> c . sinit_max_instreams , NULL , GFP_ATOMIC ) ; if ( ! ev ) goto nomem_ev ; if ( new_asoc -> peer . adaptation_ind ) { ai_ev = sctp_ulpevent_make_adaptation_indication ( new_asoc , GFP_ATOMIC ) ; if ( ! ai_ev ) goto nomem_aiev ; } sctp_add_cmd_sf ( commands , SCTP_CMD_NEW_ASOC , SCTP_ASOC ( new_asoc ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_NEW_STATE , SCTP_STATE ( SCTP_STATE_ESTABLISHED ) ) ; SCTP_INC_STATS ( net , SCTP_MIB_CURRESTAB ) ; SCTP_INC_STATS ( net , SCTP_MIB_PASSIVEESTABS ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_HB_TIMERS_START , SCTP_NULL ( ) ) ; if ( new_asoc -> autoclose ) sctp_add_cmd_sf ( commands , SCTP_CMD_TIMER_START , SCTP_TO ( SCTP_EVENT_TIMEOUT_AUTOCLOSE ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_REPLY , SCTP_CHUNK ( repl ) ) ; sctp_add_cmd_sf ( commands , SCTP_CMD_EVENT_ULP , SCTP_ULPEVENT ( ev ) ) ; if ( ai_ev ) sctp_add_cmd_sf ( commands , SCTP_CMD_EVENT_ULP , SCTP_ULPEVENT ( ai_ev ) ) ; return SCTP_DISPOSITION_CONSUME ; nomem_aiev : sctp_ulpevent_free ( ev ) ; nomem_ev : sctp_chunk_free ( repl ) ; nomem_init : sctp_association_free ( new_asoc ) ; nomem : return SCTP_DISPOSITION_NOMEM ; } | <S2SV_ModStart> sctp_ierror_t ret ; if ( ! net -> sctp . auth_enable || ! new_asoc -> peer . auth_capable ) { kfree_skb ( chunk -> auth_chunk ) ; sctp_association_free ( new_asoc ) ; return sctp_sf_pdiscard ( net , ep , asoc , type , arg , commands ) ; } |
1,599 | CWE-000 VISIBILITY_SOURCE_BEGIN # ifdef ANJAY_TEST # include "test/mock_coap_stream.h" # endif int anjay_register_object ( anjay_t * anjay , const anjay_dm_object_def_t * const * def_ptr ) { assert ( ! anjay -> transaction_state . depth ) ; assert ( ! anjay -> transaction_state . objs_in_transaction ) ; if ( ! def_ptr || ! * def_ptr ) { anjay_log ( ERROR , "invalid<S2SV_blank>object<S2SV_blank>pointer" ) ; return - 1 ; } AVS_LIST ( const anjay_dm_object_def_t * const * ) * obj_iter ; AVS_LIST_FOREACH_PTR ( obj_iter , & anjay -> dm . objects ) { assert ( * obj_iter && * * obj_iter ) ; if ( ( * * * obj_iter ) -> oid >= ( * def_ptr ) -> oid ) { break ; } } if ( * obj_iter && ( * * * obj_iter ) -> oid == ( * def_ptr ) -> oid ) { anjay_log ( ERROR , "data<S2SV_blank>model<S2SV_blank>object<S2SV_blank>/%u<S2SV_blank>already<S2SV_blank>registered" , ( * def_ptr ) -> oid ) ; return - 1 ; } AVS_LIST ( const anjay_dm_object_def_t * const * ) new_elem = AVS_LIST_NEW_ELEMENT ( const anjay_dm_object_def_t * const * ) ; if ( ! new_elem ) { anjay_log ( ERROR , "out<S2SV_blank>of<S2SV_blank>memory" ) ; return - 1 ; } * new_elem = def_ptr ; AVS_LIST_INSERT ( obj_iter , new_elem ) ; anjay_log ( INFO , "successfully<S2SV_blank>registered<S2SV_blank>object<S2SV_blank>/%u" , ( * * new_elem ) -> oid ) ; if ( anjay_notify_instances_changed ( anjay , ( * * new_elem ) -> oid ) ) { anjay_log ( WARNING , "anjay_notify_instances_changed()<S2SV_blank>failed<S2SV_blank>on<S2SV_blank>/%u" , ( * * new_elem ) -> oid ) ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( anjay_schedule_registration_update ( anjay , ANJAY_SSID_ANY ) ) { anjay_log ( WARNING , "anjay_schedule_registration_update()<S2SV_blank>failed" ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.