Dataset Viewer
Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
0 | CWE-000 static int bnxt_req_msix_vecs ( struct bnxt_en_dev * edev , int ulp_id , struct bnxt_msix_entry * ent , int num_msix ) { struct net_device * dev = edev -> net ; struct bnxt * bp = netdev_priv ( dev ) ; int max_idx , max_cp_rings ; int avail_msix , idx ; int rc = 0 ; ASSERT_RTNL ( ) ; if ( ulp_id != BNXT_ROCE_ULP ) return - EINVAL ; if ( ! ( bp -> flags & BNXT_FLAG_USING_MSIX ) ) return - ENODEV ; if ( edev -> ulp_tbl [ ulp_id ] . msix_requested ) return - EAGAIN ; max_cp_rings = bnxt_get_max_func_cp_rings ( bp ) ; avail_msix = bnxt_get_avail_msix ( bp , num_msix ) ; if ( ! avail_msix ) return - ENOMEM ; if ( avail_msix > num_msix ) avail_msix = num_msix ; if ( bp -> flags & BNXT_FLAG_NEW_RM ) { idx = bp -> cp_nr_rings ; } else { max_idx = min_t ( int , bp -> total_irqs , max_cp_rings ) ; idx = max_idx - avail_msix ; } edev -> ulp_tbl [ ulp_id ] . msix_base = idx ; edev -> ulp_tbl [ ulp_id ] . msix_requested = avail_msix ; if ( bp -> total_irqs < ( idx + avail_msix ) ) { if ( netif_running ( dev ) ) { bnxt_close_nic ( bp , true , false ) ; rc = bnxt_open_nic ( bp , true , false ) ; } else { rc = bnxt_reserve_rings ( bp ) ; } } if ( rc ) { edev -> ulp_tbl [ ulp_id ] . msix_requested = 0 ; return - EAGAIN ; } if ( bp -> flags & BNXT_FLAG_NEW_RM ) { struct bnxt_hw_resc * hw_resc = & bp -> hw_resc ; avail_msix = hw_resc -> resv_cp_rings - bp -> cp_nr_rings ; edev -> ulp_tbl [ ulp_id ] . msix_requested = avail_msix ; } bnxt_fill_msix_vecs ( bp , ent ) ; <S2SV_StartBug> bnxt_set_max_func_irqs ( bp , bnxt_get_max_func_irqs ( bp ) - avail_msix ) ; <S2SV_EndBug> bnxt_set_max_func_cp_rings ( bp , max_cp_rings - avail_msix ) ; edev -> flags |= BNXT_EN_FLAG_MSIX_REQUESTED ; return avail_msix ; } | <S2SV_ModStart> ent ) ; <S2SV_ModEnd> bnxt_set_max_func_cp_rings ( bp |
1 | CWE-000 static int read_word ( int addr , int * data ) { unsigned char request [ 8 ] ; unsigned char response [ 8 ] ; sim_interval -= UNIBUS_MEM_CYCLE ; if ( ( ten11_action_unit -> flags & UNIT_ATT ) == 0 ) { * data = 0 ; return 0 ; } if ( ten11_action_unit -> flags & UNIT_SHMEM ) { * data = ten11_M [ addr >> 1 ] ; return 0 ; } memset ( request , 0 , sizeof request ) ; build ( request , DATI ) ; build ( request , addr >> 16 ) ; build ( request , addr >> 8 ) ; build ( request , addr ) ; transaction ( request , response ) ; switch ( response [ 0 ] ) { case ACK : <S2SV_StartBug> * data = response [ 4 ] ; <S2SV_EndBug> <S2SV_StartBug> * data |= response [ 3 ] << 8 ; <S2SV_EndBug> break ; case ERR : fprintf ( stderr , "TEN11:<S2SV_blank>Read<S2SV_blank>error<S2SV_blank>%06o\\r\\n" , addr ) ; * data = 0 ; break ; case TIMEOUT : fprintf ( stderr , "TEN11:<S2SV_blank>Read<S2SV_blank>timeout<S2SV_blank>%06o\\r\\n" , addr ) ; * data = 0 ; break ; default : return error ( "Protocol<S2SV_blank>error" ) ; } return 0 ; } | <S2SV_ModStart> = response [ 2 <S2SV_ModEnd> ] ; * <S2SV_ModStart> |= response [ 1 <S2SV_ModEnd> ] << 8 <S2SV_ModStart> ] << 8 ; sim_debug ( DEBUG_TEN11 , & cpu_dev , "Read<S2SV_blank>word<S2SV_blank>%06o\\n" , * data ) |
2 | CWE-000 static void bind_vars ( tpl_query * q , unsigned point1 , unsigned point2 ) { point1 -= q -> envs [ point1 ] . binding ; point2 -= q -> envs [ point2 ] . binding ; q -> envs [ point2 ] . binding = ( signed ) point2 - ( signed ) point1 ; <S2SV_StartBug> q -> trails [ q -> trail_point + q -> trail_size ++ ] = point2 ; <S2SV_EndBug> } | <S2SV_ModStart> ) point1 ; if ( ( point2 < q -> curr_frame ) || ( point2 >= ( q -> curr_frame + q -> frame_size ) ) ) |
3 | CWE-000 void rtc_clk_cpu_freq_set_fast ( rtc_cpu_freq_t cpu_freq ) { if ( cpu_freq == s_cur_freq ) { return ; } else if ( cpu_freq == RTC_CPU_FREQ_2M || s_cur_freq == RTC_CPU_FREQ_2M ) { rtc_clk_cpu_freq_set ( cpu_freq ) ; } else if ( cpu_freq == RTC_CPU_FREQ_XTAL ) { rtc_clk_cpu_freq_to_xtal ( ) ; } else if ( cpu_freq > RTC_CPU_FREQ_XTAL ) { rtc_clk_cpu_freq_to_pll ( cpu_freq ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> cpu_freq ) ; rtc_clk_wait_for_slow_cycle ( ) ; |
4 | CWE-000 static inline int static_same_rte ( struct static_route * x , struct static_route * y ) { <S2SV_StartBug> return static_same_dest ( x , y ) && i_same ( x -> cmds , y -> cmds ) ; <S2SV_EndBug> } | <S2SV_ModStart> && i_same ( y <S2SV_ModEnd> -> cmds , <S2SV_ModStart> -> cmds , x <S2SV_ModEnd> -> cmds ) |
5 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Db_Adapter , releaseSavepoint ) { <S2SV_EndBug> zend_long ZEPHIR_LAST_CALL_STATUS ; zval * name_param = NULL , dialect , _0 , _1 , _2 ; zval name ; <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> ZVAL_UNDEF ( & name ) ; ZVAL_UNDEF ( & dialect ) ; ZVAL_UNDEF ( & _0 ) ; ZVAL_UNDEF ( & _1 ) ; ZVAL_UNDEF ( & _2 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & name_param ) ; if ( UNEXPECTED ( Z_TYPE_P ( name_param ) != IS_STRING && Z_TYPE_P ( name_param ) != IS_NULL ) ) { zephir_throw_exception_string ( spl_ce_InvalidArgumentException , SL ( "Parameter<S2SV_blank>\'name\'<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>string" ) TSRMLS_CC ) ; RETURN_MM_NULL ( ) ; } if ( EXPECTED ( Z_TYPE_P ( name_param ) == IS_STRING ) ) { zephir_get_strval ( & name , name_param ) ; } else { ZEPHIR_INIT_VAR ( & name ) ; ZVAL_EMPTY_STRING ( & name ) ; } ZEPHIR_OBS_VAR ( & dialect ) ; zephir_read_property ( & dialect , this_ptr , SL ( "_dialect" ) , PH_NOISY_CC ) ; ZEPHIR_CALL_METHOD ( & _0 , & dialect , "supportssavepoints" , NULL , 0 ) ; zephir_check_call_status ( ) ; if ( ! ( zephir_is_true ( & _0 ) ) ) { ZEPHIR_THROW_EXCEPTION_DEBUG_STR ( phalcon_db_exception_ce , "Savepoints<S2SV_blank>are<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>this<S2SV_blank>database<S2SV_blank>adapter" , "phalcon/db/adapter.zep" , 1037 ) ; return ; } ZEPHIR_CALL_METHOD ( & _1 , & dialect , "supportsreleasesavepoints" , NULL , 0 ) ; zephir_check_call_status ( ) ; if ( ! ( zephir_is_true ( & _1 ) ) ) { RETURN_MM_BOOL ( 0 ) ; } ZEPHIR_CALL_METHOD ( & _2 , & dialect , "releasesavepoint" , NULL , 0 , & name ) ; zephir_check_call_status ( ) ; ZEPHIR_RETURN_CALL_METHOD ( this_ptr , "execute" , NULL , 0 , & _2 ) ; zephir_check_call_status ( ) ; RETURN_MM ( ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Assets_Collection , getAttributes ) { RETURN_MEMBER ( <S2SV_ModEnd> getThis ( ) <S2SV_ModStart> getThis ( ) , "_attributes" <S2SV_ModEnd> ) ; } |
6 | CWE-000 <S2SV_StartBug> int ep_curve_opt_b ( ) { <S2SV_EndBug> return core_get ( ) -> ep_opt_b ; } | <S2SV_ModStart> int ep_curve_opt_b ( void |
7 | CWE-000 static int msm_lsm_ioctl ( struct snd_pcm_substream * substream , unsigned int cmd , void * arg ) { unsigned long flags ; int ret ; struct snd_lsm_sound_model snd_model ; int rc = 0 ; int xchg = 0 ; int size = 0 ; struct snd_lsm_event_status * event_status = NULL ; struct snd_pcm_runtime * runtime = substream -> runtime ; struct lsm_priv * prtd = runtime -> private_data ; struct snd_lsm_event_status * user = arg ; mutex_lock ( & prtd -> lsm_api_lock ) ; pr_debug ( "%s:<S2SV_blank>enter<S2SV_blank>cmd<S2SV_blank>%x\\n" , __func__ , cmd ) ; switch ( cmd ) { case SNDRV_LSM_REG_SND_MODEL : pr_debug ( "%s:<S2SV_blank>Registering<S2SV_blank>sound<S2SV_blank>model\\n" , __func__ ) ; if ( copy_from_user ( & snd_model , ( void * ) arg , sizeof ( struct snd_lsm_sound_model ) ) ) { rc = - EFAULT ; pr_err ( "%s:<S2SV_blank>copy<S2SV_blank>from<S2SV_blank>user<S2SV_blank>failed,<S2SV_blank>size<S2SV_blank>%d\\n" , __func__ , sizeof ( struct snd_lsm_sound_model ) ) ; break ; } rc = q6lsm_snd_model_buf_alloc ( prtd -> lsm_client , snd_model . data_size ) ; if ( rc ) { pr_err ( "%s:<S2SV_blank>q6lsm<S2SV_blank>buffer<S2SV_blank>alloc<S2SV_blank>failed,<S2SV_blank>size<S2SV_blank>%d\\n" , __func__ , snd_model . data_size ) ; break ; } if ( copy_from_user ( prtd -> lsm_client -> sound_model . data , snd_model . data , snd_model . data_size ) ) { pr_err ( "%s:<S2SV_blank>copy<S2SV_blank>from<S2SV_blank>user<S2SV_blank>data<S2SV_blank>failed<S2SV_blank>data<S2SV_blank>%p<S2SV_blank>size<S2SV_blank>%d\\n" , __func__ , snd_model . data , snd_model . data_size ) ; rc = - EFAULT ; break ; } rc = q6lsm_register_sound_model ( prtd -> lsm_client , snd_model . detection_mode , snd_model . min_keyw_confidence , snd_model . min_user_confidence , snd_model . detect_failure ) ; if ( rc < 0 ) { pr_err ( "%s:<S2SV_blank>q6lsm_register_sound_model<S2SV_blank>failed<S2SV_blank>=%d\\n" , __func__ , rc ) ; q6lsm_snd_model_buf_free ( prtd -> lsm_client ) ; } break ; case SNDRV_LSM_DEREG_SND_MODEL : pr_debug ( "%s:<S2SV_blank>Deregistering<S2SV_blank>sound<S2SV_blank>model\\n" , __func__ ) ; rc = q6lsm_deregister_sound_model ( prtd -> lsm_client ) ; break ; case SNDRV_LSM_EVENT_STATUS : pr_debug ( "%s:<S2SV_blank>Get<S2SV_blank>event<S2SV_blank>status\\n" , __func__ ) ; atomic_set ( & prtd -> event_wait_stop , 0 ) ; mutex_unlock ( & prtd -> lsm_api_lock ) ; <S2SV_StartBug> rc = wait_event_interruptible ( prtd -> event_wait , <S2SV_EndBug> ( cmpxchg ( & prtd -> event_avail , 1 , 0 ) || ( xchg = atomic_cmpxchg ( & prtd -> event_wait_stop , 1 , 0 ) ) ) ) ; mutex_lock ( & prtd -> lsm_api_lock ) ; <S2SV_StartBug> pr_debug ( "%s:<S2SV_blank>wait_event_interruptible<S2SV_blank>%d<S2SV_blank>event_wait_stop<S2SV_blank>%d\\n" , <S2SV_EndBug> __func__ , rc , xchg ) ; if ( ! rc && ! xchg ) { pr_debug ( "%s:<S2SV_blank>New<S2SV_blank>event<S2SV_blank>available<S2SV_blank>%ld\\n" , __func__ , prtd -> event_avail ) ; spin_lock_irqsave ( & prtd -> event_lock , flags ) ; if ( prtd -> event_status ) { size = sizeof ( * event_status ) + prtd -> event_status -> payload_size ; event_status = kmemdup ( prtd -> event_status , size , GFP_ATOMIC ) ; } spin_unlock_irqrestore ( & prtd -> event_lock , flags ) ; if ( ! event_status ) { pr_err ( "%s:<S2SV_blank>Couldn\'t<S2SV_blank>allocate<S2SV_blank>%d<S2SV_blank>bytes\\n" , __func__ , size ) ; rc = - EFAULT ; } else { if ( ! access_ok ( VERIFY_READ , user , sizeof ( struct snd_lsm_event_status ) ) ) rc = - EFAULT ; if ( user -> payload_size < event_status -> payload_size ) { pr_debug ( "%s:<S2SV_blank>provided<S2SV_blank>%dbytes<S2SV_blank>isn\'t<S2SV_blank>enough,<S2SV_blank>needs<S2SV_blank>%dbytes\\n" , __func__ , user -> payload_size , size ) ; rc = - ENOMEM ; } else if ( ! access_ok ( VERIFY_WRITE , arg , size ) ) { rc = - EFAULT ; } else { rc = copy_to_user ( arg , event_status , size ) ; if ( rc ) pr_err ( "%s:<S2SV_blank>copy<S2SV_blank>to<S2SV_blank>user<S2SV_blank>failed<S2SV_blank>%d\\n" , __func__ , rc ) ; } kfree ( event_status ) ; } } else if ( xchg ) { pr_debug ( "%s:<S2SV_blank>Wait<S2SV_blank>aborted\\n" , __func__ ) ; rc = 0 ; } break ; case SNDRV_LSM_ABORT_EVENT : pr_debug ( "%s:<S2SV_blank>Aborting<S2SV_blank>event<S2SV_blank>status<S2SV_blank>wait\\n" , __func__ ) ; atomic_set ( & prtd -> event_wait_stop , 1 ) ; wake_up ( & prtd -> event_wait ) ; break ; case SNDRV_LSM_START : pr_debug ( "%s:<S2SV_blank>Starting<S2SV_blank>LSM<S2SV_blank>client<S2SV_blank>session\\n" , __func__ ) ; if ( ! prtd -> lsm_client -> started ) { ret = q6lsm_start ( prtd -> lsm_client , true ) ; if ( ! ret ) { prtd -> lsm_client -> started = true ; pr_debug ( "%s:<S2SV_blank>LSM<S2SV_blank>client<S2SV_blank>session<S2SV_blank>started\\n" , __func__ ) ; } } break ; case SNDRV_LSM_STOP : pr_debug ( "%s:<S2SV_blank>Stopping<S2SV_blank>LSM<S2SV_blank>client<S2SV_blank>session\\n" , __func__ ) ; if ( prtd -> lsm_client -> started ) { ret = q6lsm_stop ( prtd -> lsm_client , true ) ; if ( ! ret ) pr_debug ( "%s:<S2SV_blank>LSM<S2SV_blank>client<S2SV_blank>session<S2SV_blank>stopped<S2SV_blank>%d\\n" , __func__ , ret ) ; prtd -> lsm_client -> started = false ; } break ; default : pr_debug ( "%s:<S2SV_blank>Falling<S2SV_blank>into<S2SV_blank>default<S2SV_blank>snd_lib_ioctl<S2SV_blank>cmd<S2SV_blank>0x%x\\n" , __func__ , cmd ) ; rc = snd_pcm_lib_ioctl ( substream , cmd , arg ) ; break ; } if ( ! rc ) pr_debug ( "%s:<S2SV_blank>leave<S2SV_blank>(%d)\\n" , __func__ , rc ) ; else pr_err ( "%s:<S2SV_blank>cmd<S2SV_blank>0x%x<S2SV_blank>failed<S2SV_blank>%d\\n" , __func__ , cmd , rc ) ; mutex_unlock ( & prtd -> lsm_api_lock ) ; return rc ; } | <S2SV_ModStart> ; rc = wait_event_freezable <S2SV_ModEnd> ( prtd -> <S2SV_ModStart> ; pr_debug ( "%s:<S2SV_blank>wait_event_freezable<S2SV_blank>%d<S2SV_blank>event_wait_stop<S2SV_blank>%d\\n" <S2SV_ModEnd> , __func__ , |
8 | CWE-000 int main ( int argc , char * argv [ ] ) { int c , error , gdb_port , err ; int max_vcpus , mptgen , memflags ; struct vmctx * ctx ; size_t memsize ; char * optstr ; int option_idx = 0 ; progname = basename ( argv [ 0 ] ) ; gdb_port = 0 ; guest_ncpus = 1 ; memsize = 256 * MB ; mptgen = 1 ; memflags = 0 ; quit_vm_loop = 0 ; hugetlb = 0 ; <S2SV_StartBug> if ( signal ( SIGINT , sig_handler_term ) == SIG_ERR ) <S2SV_EndBug> fprintf ( stderr , "cannot<S2SV_blank>register<S2SV_blank>handler<S2SV_blank>for<S2SV_blank>SIGINT\\n" ) ; optstr = "abehuwxACHIMPSTWYvk:r:B:p:g:c:s:m:l:U:G:i:" ; while ( ( c = getopt_long ( argc , argv , optstr , long_options , & option_idx ) ) != - 1 ) { switch ( c ) { case 'a' : x2apic_mode = 0 ; break ; case 'A' : acpi = 1 ; break ; case 'b' : enable_bvmcons ( ) ; break ; case 'p' : if ( pincpu_parse ( optarg ) != 0 ) { errx ( EX_USAGE , "invalid<S2SV_blank>vcpu<S2SV_blank>pinning<S2SV_blank>configuration<S2SV_blank>\'%s\'" , optarg ) ; } break ; case 'c' : guest_ncpus = atoi ( optarg ) ; break ; case 'C' : memflags |= VM_MEM_F_INCORE ; break ; case 'g' : gdb_port = atoi ( optarg ) ; break ; case 'i' : ioc_parse ( optarg ) ; break ; case 'l' : if ( lpc_device_parse ( optarg ) != 0 ) { errx ( EX_USAGE , "invalid<S2SV_blank>lpc<S2SV_blank>device<S2SV_blank>configuration<S2SV_blank>\'%s\'" , optarg ) ; } break ; case 's' : if ( pci_parse_slot ( optarg ) != 0 ) exit ( 1 ) ; else break ; case 'S' : memflags |= VM_MEM_F_WIRED ; break ; case 'm' : error = vm_parse_memsize ( optarg , & memsize ) ; if ( error ) errx ( EX_USAGE , "invalid<S2SV_blank>memsize<S2SV_blank>\'%s\'" , optarg ) ; break ; case 'H' : guest_vmexit_on_hlt = 1 ; break ; case 'I' : break ; case 'P' : guest_vmexit_on_pause = 1 ; break ; case 'e' : strictio = 1 ; break ; case 'u' : vrtc_enable_localtime ( 0 ) ; break ; case 'U' : guest_uuid_str = optarg ; break ; case 'w' : strictmsr = 0 ; break ; case 'W' : virtio_msix = 0 ; break ; case 'T' : if ( check_hugetlb_support ( ) ) hugetlb = 1 ; break ; case 'x' : x2apic_mode = 1 ; break ; case 'Y' : mptgen = 0 ; break ; case 'k' : if ( acrn_parse_kernel ( optarg ) != 0 ) exit ( 1 ) ; else break ; case 'r' : if ( acrn_parse_ramdisk ( optarg ) != 0 ) exit ( 1 ) ; else break ; case 'B' : if ( acrn_parse_bootargs ( optarg ) != 0 ) exit ( 1 ) ; else break ; break ; case 'M' : ptdev_prefer_msi ( false ) ; break ; case 'v' : print_version ( ) ; break ; case CMD_OPT_VSBL : if ( acrn_parse_vsbl ( optarg ) != 0 ) { errx ( EX_USAGE , "invalid<S2SV_blank>vsbl<S2SV_blank>param<S2SV_blank>%s" , optarg ) ; exit ( 1 ) ; } break ; case CMD_OPT_PART_INFO : if ( acrn_parse_guest_part_info ( optarg ) != 0 ) { errx ( EX_USAGE , "invalid<S2SV_blank>guest<S2SV_blank>partition<S2SV_blank>info<S2SV_blank>param<S2SV_blank>%s" , optarg ) ; exit ( 1 ) ; } break ; case CMD_OPT_TRUSTY_ENABLE : trusty_enabled = 1 ; break ; case 'h' : usage ( 0 ) ; default : usage ( 1 ) ; } } argc -= optind ; argv += optind ; if ( argc != 1 ) usage ( 1 ) ; vmname = argv [ 0 ] ; for ( ; ; ) { ctx = do_open ( vmname ) ; error = vm_set_shared_io_page ( ctx , ( unsigned long ) vhm_req_buf ) ; if ( error ) goto fail ; if ( guest_ncpus < 1 ) { fprintf ( stderr , "Invalid<S2SV_blank>guest<S2SV_blank>vCPUs<S2SV_blank>(%d)\\n" , guest_ncpus ) ; goto fail ; } max_vcpus = num_vcpus_allowed ( ctx ) ; if ( guest_ncpus > max_vcpus ) { fprintf ( stderr , "%d<S2SV_blank>vCPUs<S2SV_blank>requested<S2SV_blank>but<S2SV_blank>%d<S2SV_blank>available\\n" , guest_ncpus , max_vcpus ) ; goto fail ; } vm_set_memflags ( ctx , memflags ) ; err = vm_setup_memory ( ctx , memsize , VM_MMAP_ALL ) ; if ( err ) { fprintf ( stderr , "Unable<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>memory<S2SV_blank>(%d)\\n" , errno ) ; goto fail ; } err = mevent_init ( ) ; if ( err ) { fprintf ( stderr , "Unable<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>mevent<S2SV_blank>(%d)\\n" , errno ) ; goto mevent_fail ; } if ( gdb_port != 0 ) fprintf ( stderr , "dbgport<S2SV_blank>not<S2SV_blank>supported\\n" ) ; if ( vm_init_vdevs ( ctx ) < 0 ) { fprintf ( stderr , "Unable<S2SV_blank>to<S2SV_blank>init<S2SV_blank>vdev<S2SV_blank>(%d)\\n" , errno ) ; goto dev_fail ; } if ( mptgen ) { error = mptable_build ( ctx , guest_ncpus ) ; if ( error ) { goto vm_fail ; } } error = smbios_build ( ctx ) ; if ( error ) goto vm_fail ; if ( acpi ) { error = acpi_build ( ctx , guest_ncpus ) ; if ( error ) goto vm_fail ; } error = acrn_sw_load ( ctx ) ; if ( error ) goto vm_fail ; add_cpu ( ctx , guest_ncpus ) ; _ctx = ctx ; mevent_dispatch ( ) ; vm_pause ( ctx ) ; delete_cpu ( ctx , BSP ) ; if ( vm_get_suspend_mode ( ) != VM_SUSPEND_RESET ) break ; vm_deinit_vdevs ( ctx ) ; mevent_deinit ( ) ; vm_unsetup_memory ( ctx ) ; vm_destroy ( ctx ) ; vm_close ( ctx ) ; _ctx = 0 ; vm_set_suspend_mode ( VM_SUSPEND_NONE ) ; } vm_fail : vm_deinit_vdevs ( ctx ) ; dev_fail : mevent_deinit ( ) ; mevent_fail : vm_unsetup_memory ( ctx ) ; fail : vm_destroy ( ctx ) ; vm_close ( ctx ) ; exit ( 0 ) ; } | <S2SV_ModStart> ( signal ( SIGHUP , sig_handler_term ) == SIG_ERR ) fprintf ( stderr , "cannot<S2SV_blank>register<S2SV_blank>handler<S2SV_blank>for<S2SV_blank>SIGHUP\\n" ) ; if ( signal ( |
9 | CWE-000 CipherBlock * cipherBlockNew ( CipherMode mode , const char * cipherName , const unsigned char * pass , int passSize , const char * digestName ) { <S2SV_StartBug> if ( ! openSslInitDone ) <S2SV_EndBug> { ERR_load_crypto_strings ( ) ; OpenSSL_add_all_algorithms ( ) ; openSslInitDone = true ; } const EVP_CIPHER * cipher = EVP_get_cipherbyname ( cipherName ) ; if ( ! cipher ) THROW ( AssertError , "unable<S2SV_blank>to<S2SV_blank>load<S2SV_blank>cipher<S2SV_blank>\'%s\'" , cipherName ) ; const EVP_MD * digest = NULL ; if ( digestName ) digest = EVP_get_digestbyname ( digestName ) ; else digest = EVP_sha1 ( ) ; if ( ! digest ) THROW ( AssertError , "unable<S2SV_blank>to<S2SV_blank>load<S2SV_blank>digest<S2SV_blank>\'%s\'" , digestName ) ; CipherBlock * this = NULL ; MEM_CONTEXT_NEW_BEGIN ( "cipherBlock" ) { this = memNew ( sizeof ( CipherBlock ) ) ; this -> memContext = MEM_CONTEXT_NEW ( ) ; this -> mode = mode ; this -> cipher = cipher ; this -> digest = digest ; this -> passSize = passSize ; this -> pass = memNewRaw ( this -> passSize ) ; memcpy ( this -> pass , pass , this -> passSize ) ; } MEM_CONTEXT_NEW_END ( ) ; return this ; } | <S2SV_ModStart> if ( ! cipherIsInit ( ) ) cipherInit ( ) ; <S2SV_ModEnd> const EVP_CIPHER * |
10 | CWE-000 void basicOperations ( struct sockaddr_in6 * targetIP ) { struct config myConf = get_bb_config ( ) ; uint64_t alloc_latency [ myConf . num_hosts ] ; uint64_t * read_latency = calloc ( NUM_ITERATIONS , sizeof ( uint64_t ) ) ; uint64_t * write_latency = calloc ( NUM_ITERATIONS , sizeof ( uint64_t ) ) ; uint64_t free_latency [ myConf . num_hosts ] ; struct in6_memaddr * r_addr = malloc ( sizeof ( struct in6_memaddr ) * NUM_ITERATIONS ) ; if ( ! r_addr ) perror ( "Allocation<S2SV_blank>too<S2SV_blank>large" ) ; uint64_t split = NUM_ITERATIONS / myConf . num_hosts ; <S2SV_StartBug> int length ; <S2SV_EndBug> for ( int i = 0 ; i < myConf . num_hosts ; i ++ ) { uint64_t start = getns ( ) ; uint64_t offset = split * i ; if ( i == myConf . num_hosts - 1 ) length = NUM_ITERATIONS - offset ; else length = split ; struct in6_addr * ipv6Pointer = gen_ip6_target ( i ) ; memcpy ( & ( targetIP -> sin6_addr ) , ipv6Pointer , sizeof ( * ipv6Pointer ) ) ; struct in6_memaddr * temp = allocate_rmem_bulk ( targetIP , length ) ; memcpy ( & r_addr [ offset ] , temp , length * sizeof ( struct in6_memaddr ) ) ; free ( temp ) ; alloc_latency [ i ] = getns ( ) - start ; } <S2SV_StartBug> for ( int i = 0 ; i < NUM_ITERATIONS ; i ++ ) { <S2SV_EndBug> struct in6_memaddr remoteMemory = r_addr [ i ] ; print_debug ( "Creating<S2SV_blank>payload" ) ; <S2SV_StartBug> char * payload = malloc ( 4096 ) ; <S2SV_EndBug> snprintf ( payload , 50 , "HELLO<S2SV_blank>WORLD!<S2SV_blank>How<S2SV_blank>are<S2SV_blank>you?<S2SV_blank>%d" , i ) ; uint64_t wStart = getns ( ) ; write_rmem ( targetIP , payload , & remoteMemory ) ; write_latency [ i ] = getns ( ) - wStart ; free ( payload ) ; } char test [ BLOCK_SIZE ] ; <S2SV_StartBug> for ( int i = 0 ; i < NUM_ITERATIONS ; i ++ ) { <S2SV_EndBug> struct in6_memaddr remoteMemory = r_addr [ i ] ; uint64_t rStart = getns ( ) ; get_rmem ( test , BLOCK_SIZE , targetIP , & remoteMemory ) ; read_latency [ i ] = getns ( ) - rStart ; <S2SV_StartBug> char * payload = malloc ( 4096 ) ; <S2SV_EndBug> snprintf ( payload , 50 , "HELLO<S2SV_blank>WORLD!<S2SV_blank>How<S2SV_blank>are<S2SV_blank>you?<S2SV_blank>%d" , i ) ; print_debug ( "Results<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>store:<S2SV_blank>%.50s" , test ) ; if ( strncmp ( test , payload , 50 ) < 0 ) { perror ( KRED "ERROR:<S2SV_blank>WRONG<S2SV_blank>RESULT" RESET ) ; exit ( 1 ) ; } free ( payload ) ; } <S2SV_StartBug> for ( int i = 0 ; i < myConf . num_hosts ; i ++ ) { <S2SV_EndBug> uint64_t fStart = getns ( ) ; uint64_t offset = split * i ; free_rmem ( targetIP , & r_addr [ offset ] ) ; free_latency [ i ] = getns ( ) - fStart ; } save_time ( "alloc_t0" , alloc_latency , myConf . num_hosts ) ; save_time ( "read_t0" , read_latency , NUM_ITERATIONS ) ; save_time ( "write_t0" , write_latency , NUM_ITERATIONS ) ; save_time ( "free_t0" , free_latency , myConf . num_hosts ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; int length ; printf ( "Allocating...\\n" ) <S2SV_ModStart> start ; } printf ( "Starting<S2SV_blank>write<S2SV_blank>test...\\n" ) ; <S2SV_ModStart> = malloc ( BLOCK_SIZE <S2SV_ModEnd> ) ; snprintf <S2SV_ModStart> BLOCK_SIZE ] ; printf ( "Starting<S2SV_blank>read<S2SV_blank>test...\\n" ) ; <S2SV_ModStart> = malloc ( BLOCK_SIZE <S2SV_ModEnd> ) ; snprintf <S2SV_ModStart> ) ; } printf ( "Freeing...\\n" ) ; <S2SV_ModStart> num_hosts ) ; free ( read_latency ) ; free ( write_latency ) ; |
11 | CWE-000 int intel_hdcp_enable ( struct intel_connector * connector ) { struct intel_hdcp * hdcp = & connector -> hdcp ; <S2SV_StartBug> int ret ; <S2SV_EndBug> if ( ! hdcp -> shim ) return - ENOENT ; mutex_lock ( & hdcp -> mutex ) ; <S2SV_StartBug> ret = _intel_hdcp_enable ( connector ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ret ) <S2SV_EndBug> goto out ; hdcp -> value = DRM_MODE_CONTENT_PROTECTION_ENABLED ; schedule_work ( & hdcp -> prop_work ) ; <S2SV_StartBug> schedule_delayed_work ( & hdcp -> check_work , <S2SV_EndBug> DRM_HDCP_CHECK_PERIOD_MS ) ; out : mutex_unlock ( & hdcp -> mutex ) ; return ret ; } | <S2SV_ModStart> ; int ret = - EINVAL <S2SV_ModStart> mutex ) ; if ( intel_hdcp2_capable ( connector ) ) ret = _intel_hdcp2_enable ( connector ) ; if ( ret && intel_hdcp_capable ( connector ) ) { <S2SV_ModStart> ; if ( ! ret ) schedule_delayed_work ( & hdcp -> check_work , DRM_HDCP_CHECK_PERIOD_MS ) ; } if ( ! ret ) { <S2SV_ModEnd> hdcp -> value <S2SV_ModStart> prop_work ) ; } <S2SV_ModEnd> mutex_unlock ( & |
12 | CWE-000 static void captureToOffset ( RContext * c , Instr * instr , int offset , bool generated ) { assert ( offset >= 0 ) ; Instr * newInstr ; Rewriter * r = c -> r ; CBB * cbb = r -> currentCapBB ; if ( cbb == 0 ) return ; Instr restoreRegInstr ; bool saveTmpReg = false ; Operand * indOp = 0 ; Operand * otherOp ; switch ( instr -> form ) { break ; case OF_1 : if ( opIsInd ( & instr -> dst ) ) { indOp = & instr -> dst ; otherOp = 0 ; } break ; case OF_2 : if ( opIsInd ( & instr -> src ) ) { indOp = & instr -> src ; otherOp = & instr -> dst ; } else if ( opIsInd ( & instr -> dst ) ) { indOp = & instr -> dst ; otherOp = & instr -> src ; } break ; default : break ; } if ( indOp && ( ( int64_t ) indOp -> val > INT32_MAX ) ) { RegIndex freeReg = getUnusedReg ( c , otherOp , & saveTmpReg ) ; Reg tmpReg = getReg ( RT_GP64 , freeReg ) ; Operand * tmpRegOp = getRegOp ( tmpReg ) ; if ( saveTmpReg ) { Instr push ; initUnaryInstr ( & restoreRegInstr , IT_POP , tmpRegOp ) ; initUnaryInstr ( & push , IT_PUSH , tmpRegOp ) ; capture ( c , & push ) ; } Instr mov ; Operand * immOp = getImmOp ( VT_64 , indOp -> val ) ; initBinaryInstr ( & mov , IT_MOV , VT_64 , tmpRegOp , immOp ) ; indOp -> val = 0 ; indOp -> reg = tmpReg ; capture ( c , & mov ) ; } if ( r -> showEmuSteps ) cprintf ( CABright | CFMagenta , "Capture<S2SV_blank>\'%s\'<S2SV_blank>(into<S2SV_blank>%s<S2SV_blank>+<S2SV_blank>%d)\\n" , instr2string ( instr , 0 , c -> r , cbb -> fc ) , cbb_prettyName ( cbb ) , cbb -> count - offset ) ; ElfAddrInfo * info = addCaptureInfo ( c , offset ) ; <S2SV_StartBug> if ( generated ) { <S2SV_EndBug> strncpy ( info -> filePath , "<generated>" , ELF_MAX_NAMELEN ) ; info -> fileName = info -> filePath ; info -> lineno = 0 ; } if ( c -> e ) return ; if ( offset == 0 ) { newInstr = newCapInstr ( c ) ; if ( c -> e ) return ; if ( cbb -> instr == 0 ) { cbb -> instr = newInstr ; assert ( cbb -> count == 0 ) ; } if ( cbb -> info == NULL ) { cbb -> info = info ; } } else { newInstr = insertCapInstr ( c , offset ) ; if ( c -> e ) return ; } copyInstr ( newInstr , instr ) ; cbb -> count ++ ; if ( saveTmpReg ) { capture ( c , & restoreRegInstr ) ; } } | <S2SV_ModStart> ; if ( info && |
13 | CWE-000 <S2SV_StartBug> void mlxsw_sp_port_vrf_leave ( struct mlxsw_sp_port * mlxsw_sp_port ) <S2SV_EndBug> { <S2SV_StartBug> struct mlxsw_sp_port * mlxsw_sp_vport ; <S2SV_EndBug> mlxsw_sp_vport = mlxsw_sp_port_vport_find ( mlxsw_sp_port , 1 ) ; <S2SV_StartBug> if ( WARN_ON ( ! mlxsw_sp_vport ) ) <S2SV_EndBug> return ; <S2SV_StartBug> mlxsw_sp_vport_vrf_leave ( mlxsw_sp_vport ) ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> mlxsw_sp_port_vrf_leave ( struct mlxsw_sp * mlxsw_sp , struct net_device * l3_dev <S2SV_ModEnd> ) { struct <S2SV_ModStart> ) { struct mlxsw_sp_rif * rif ; rif = mlxsw_sp_rif_find_by_dev ( mlxsw_sp , l3_dev <S2SV_ModEnd> ) ; if <S2SV_ModStart> ; if ( ! rif <S2SV_ModEnd> ) return ; <S2SV_ModStart> ) return ; __mlxsw_sp_inetaddr_event ( l3_dev , NETDEV_DOWN <S2SV_ModEnd> ) ; } |
14 | CWE-000 void av1_fht32x16_c ( const int16_t * input , tran_low_t * output , int stride , int tx_type ) { static const transform_2d FHT [ ] = { { fdct16 , fdct32 } , { fadst16 , fdct32 } , { fdct16 , fhalfright32 } , { fadst16 , fhalfright32 } , # if CONFIG_EXT_TX { fadst16 , fdct32 } , { fdct16 , fhalfright32 } , { fadst16 , fhalfright32 } , { fadst16 , fhalfright32 } , { fadst16 , fhalfright32 } , { fidtx16 , fidtx32 } , { fdct16 , fidtx32 } , { fidtx16 , fdct32 } , { fadst16 , fidtx32 } , { fidtx16 , fhalfright32 } , { fadst16 , fidtx32 } , { fidtx16 , fhalfright32 } , # endif } ; const transform_2d ht = FHT [ tx_type ] ; const int n = 16 ; const int n2 = 32 ; tran_low_t out [ 32 * 16 ] ; tran_low_t temp_in [ 32 ] , temp_out [ 32 ] ; int i , j ; # if CONFIG_EXT_TX int16_t flipped_input [ 32 * 16 ] ; maybe_flip_input ( & input , & stride , n , n2 , flipped_input , tx_type ) ; # endif for ( i = 0 ; i < n2 ; ++ i ) { for ( j = 0 ; j < n ; ++ j ) temp_in [ j ] = ( tran_low_t ) fdct_round_shift ( input [ j * stride + i ] * Sqrt2 ) ; ht . cols ( temp_in , temp_out ) ; for ( j = 0 ; j < n ; ++ j ) out [ j * n2 + i ] = temp_out [ j ] ; } for ( i = 0 ; i < n ; ++ i ) { for ( j = 0 ; j < n2 ; ++ j ) temp_in [ j ] = out [ j + i * n2 ] ; ht . rows ( temp_in , temp_out ) ; for ( j = 0 ; j < n2 ; ++ j ) output [ j + i * n2 ] = <S2SV_StartBug> ( tran_low_t ) ( ( temp_out [ j ] + 1 + ( temp_out [ j ] < 0 ) ) >> 2 ) ; <S2SV_EndBug> } } | <S2SV_ModStart> n2 ] = <S2SV_ModEnd> temp_out [ j <S2SV_ModStart> [ j ] >> 2 <S2SV_ModEnd> ; } } |
15 | CWE-000 static void started_cb ( enum modules module ) { <S2SV_StartBug> while ( modules [ module ] . num_dependent > 0 ) { <S2SV_EndBug> <S2SV_StartBug> enum modules m = modules [ module ] . dependent_m [ 0 ] . dep ; <S2SV_EndBug> <S2SV_StartBug> if ( modules [ module ] . num_dependent > 1 ) { <S2SV_EndBug> memmove ( & modules [ module ] . dependent_m [ 0 ] , & modules [ module ] . dependent_m [ 1 ] , ( modules [ module ] . num_dependent - 1 ) * sizeof ( struct dependency ) ) ; } modules [ module ] . dependent_m = realloc ( modules [ module ] . dependent_m , ( -- modules [ module ] . num_dependent ) * sizeof ( struct dependency ) ) ; if ( is_idle ( m ) ) { <S2SV_StartBug> modules [ m ] . self -> satisfied_deps ++ ; <S2SV_EndBug> <S2SV_StartBug> DEBUG ( "Trying<S2SV_blank>to<S2SV_blank>start<S2SV_blank>%s<S2SV_blank>module<S2SV_blank>as<S2SV_blank>its<S2SV_blank>%s<S2SV_blank>dependency<S2SV_blank>was<S2SV_blank>loaded...\\n" , modules [ m ] . self -> name , modules [ module ] . self -> name ) ; <S2SV_EndBug> <S2SV_StartBug> init_modules ( m ) ; <S2SV_EndBug> } } } | <S2SV_ModStart> module ) { for ( int i = 0 ; i < MODULES_NUM ; i ++ ) { const enum dep_type type <S2SV_ModEnd> = modules [ <S2SV_ModStart> . dependent_m [ i ] <S2SV_ModEnd> ; if ( <S2SV_ModStart> ; if ( type != NO_DEP && is_idle ( i <S2SV_ModEnd> ) ) { <S2SV_ModStart> { modules [ i <S2SV_ModEnd> ] . self <S2SV_ModStart> , modules [ i <S2SV_ModEnd> ] . self <S2SV_ModStart> ; init_modules ( i <S2SV_ModEnd> ) ; } |
16 | CWE-000 int enc_jpeg2000 ( unsigned char * cin , g2int * pwidth , g2int * pheight , g2int * pnbits , g2int * ltype , g2int * ratio , g2int * retry , char * outjpc , g2int * jpclen ) { int rwcnt = 0 ; # ifdef USE_JPEG2000 int ier ; jas_image_t image ; jas_stream_t * jpcstream , * istream ; jas_image_cmpt_t cmpt , * pcmpt ; # define MAXOPTSSIZE 1024 char opts [ MAXOPTSSIZE ] ; g2int width , height , nbits ; width = * pwidth ; height = * pheight ; nbits = * pnbits ; if ( * ltype != 1 ) { opts [ 0 ] = ( char ) 0 ; } else { snprintf ( opts , MAXOPTSSIZE , "mode=real\\nrate=%f" , 1.0 / ( float ) * ratio ) ; } if ( * retry == 1 ) { strcat ( opts , "\\nnumgbits=4" ) ; } image . tlx_ = 0 ; image . tly_ = 0 ; # ifdef JAS_1_500_4 image . brx_ = ( uint_fast32_t ) width ; image . bry_ = ( uint_fast32_t ) height ; # endif # ifdef JAS_1_700_2 image . brx_ = ( jas_image_coord_t ) width ; image . bry_ = ( jas_image_coord_t ) height ; # endif image . numcmpts_ = 1 ; image . maxcmpts_ = 1 ; # ifdef JAS_1_500_4 image . colormodel_ = JAS_IMAGE_CM_GRAY ; # endif # ifdef JAS_1_700_2 image . clrspc_ = JAS_CLRSPC_SGRAY ; image . cmprof_ = 0 ; # endif <S2SV_StartBug> image . inmem_ = 1 ; <S2SV_EndBug> cmpt . tlx_ = 0 ; cmpt . tly_ = 0 ; cmpt . hstep_ = 1 ; cmpt . vstep_ = 1 ; # ifdef JAS_1_500_4 cmpt . width_ = ( uint_fast32_t ) width ; cmpt . height_ = ( uint_fast32_t ) height ; # endif # ifdef JAS_1_700_2 cmpt . width_ = ( jas_image_coord_t ) width ; cmpt . height_ = ( jas_image_coord_t ) height ; cmpt . type_ = JAS_IMAGE_CT_COLOR ( JAS_CLRSPC_CHANIND_GRAY_Y ) ; # endif cmpt . prec_ = nbits ; cmpt . sgnd_ = 0 ; cmpt . cps_ = ( nbits + 7 ) / 8 ; pcmpt = & cmpt ; image . cmpts_ = & pcmpt ; istream = jas_stream_memopen ( ( char * ) cin , height * width * cmpt . cps_ ) ; cmpt . stream_ = istream ; jpcstream = jas_stream_memopen ( outjpc , ( int ) ( * jpclen ) ) ; ier = jpc_encode ( & image , jpcstream , opts ) ; if ( ier != 0 ) { printf ( "<S2SV_blank>jpc_encode<S2SV_blank>return<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>\\n" , ier ) ; return - 3 ; } rwcnt = jpcstream -> rwcnt_ ; ier = jas_stream_close ( istream ) ; ier = jas_stream_close ( jpcstream ) ; # endif return ( rwcnt ) ; } | <S2SV_ModStart> ; # endif <S2SV_ModEnd> cmpt . tlx_ |
17 | CWE-000 static void goto_folder_cb ( GtkAction * action , gpointer data ) { MainWindow * mainwin = ( MainWindow * ) data ; FolderItem * to_folder ; <S2SV_StartBug> to_folder = foldersel_folder_sel ( NULL , FOLDER_SEL_ALL , NULL , FALSE ) ; <S2SV_EndBug> if ( to_folder ) folderview_select ( mainwin -> folderview , to_folder ) ; } | <S2SV_ModStart> NULL , FALSE , _ ( "Select<S2SV_blank>folder<S2SV_blank>to<S2SV_blank>go<S2SV_blank>to" ) |
18 | CWE-000 int main ( int argc , char * * argv ) { int nodeCount = 1 ; int i ; AddressBookList * list ; AddressBookNode * tempNode ; char tempStr [ 20 ] ; char * testPhone = "3543252366" ; showStudentInformation ( ) ; printf ( "creating<S2SV_blank>list\\n" ) ; list = createAddressBookList ( ) ; <S2SV_StartBug> printf ( "creating<S2SV_blank>fake<S2SV_blank>nodes\\n" ) ; <S2SV_EndBug> for ( i = 0 ; i < nodeCount ; i ++ ) { sprintf ( tempStr , "node:<S2SV_blank>%d" , i ) ; tempNode = createAddressBookNode ( i , tempStr ) ; addTelephone ( tempNode -> array , "0123456789" ) ; addTelephone ( tempNode -> array , "3423454346" ) ; addTelephone ( tempNode -> array , testPhone ) ; addTelephone ( tempNode -> array , "3196432827" ) ; removeTelephone ( tempNode -> array , testPhone ) ; insertNode ( list , tempNode ) ; } printf ( "sizeof<S2SV_blank>array:<S2SV_blank>%d\\n" , ( int ) sizeof ( list -> head -> array ) ) ; <S2SV_StartBug> freeAddressBookList ( list ) ; <S2SV_EndBug> list = commandLoad ( "sml.txt" ) ; commandDisplay ( list ) ; printf ( "\\nFREEING\\n" ) ; freeAddressBookList ( list ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> ( ) ; commandDisplay ( list ) ; <S2SV_ModStart> ) ) ; commandDisplay ( list ) ; |
19 | CWE-000 static int open_file ( AVFormatContext * avf , unsigned fileno ) { ConcatContext * cat = avf -> priv_data ; ConcatFile * file = & cat -> files [ fileno ] ; AVFormatContext * new_avf = NULL ; int ret ; AVDictionary * tmp = NULL ; new_avf = avformat_alloc_context ( ) ; if ( ! new_avf ) return AVERROR ( ENOMEM ) ; new_avf -> interrupt_callback = avf -> interrupt_callback ; if ( ( ret = ff_copy_whiteblacklists ( new_avf , avf ) ) < 0 ) return ret ; if ( cat -> options ) <S2SV_StartBug> av_dict_copy ( & tmp , cat -> options , 0 ) ; <S2SV_EndBug> ret = avformat_open_input ( & new_avf , file -> url , NULL , & tmp ) ; av_dict_free ( & tmp ) ; if ( ret < 0 || ( ret = avformat_find_stream_info ( new_avf , NULL ) ) < 0 ) { av_log ( avf , AV_LOG_ERROR , "Impossible<S2SV_blank>to<S2SV_blank>open<S2SV_blank>\'%s\'\\n" , file -> url ) ; avformat_close_input ( & new_avf ) ; return ret ; } if ( ! new_avf ) return 0 ; if ( cat -> avf ) avformat_close_input ( & cat -> avf ) ; avf -> bit_rate = new_avf -> bit_rate ; cat -> avf = new_avf ; cat -> cur_file = file ; if ( file -> start_time == AV_NOPTS_VALUE ) file -> start_time = ! fileno ? 0 : cat -> files [ fileno - 1 ] . start_time + cat -> files [ fileno - 1 ] . duration ; file -> file_start_time = ( cat -> avf -> start_time == AV_NOPTS_VALUE ) ? 0 : cat -> avf -> start_time ; file -> file_inpoint = ( file -> inpoint == AV_NOPTS_VALUE ) ? file -> file_start_time : file -> inpoint ; if ( file -> duration == AV_NOPTS_VALUE && file -> outpoint != AV_NOPTS_VALUE ) file -> duration = file -> outpoint - file -> file_inpoint ; if ( cat -> segment_time_metadata ) { av_dict_set_int ( & file -> metadata , "lavf.concatdec.start_time" , file -> start_time , 0 ) ; if ( file -> duration != AV_NOPTS_VALUE ) av_dict_set_int ( & file -> metadata , "lavf.concatdec.duration" , file -> duration , 0 ) ; } if ( ( ret = match_streams ( avf ) ) < 0 ) return ret ; if ( file -> inpoint != AV_NOPTS_VALUE ) { if ( ( ret = avformat_seek_file ( cat -> avf , - 1 , INT64_MIN , file -> inpoint , file -> inpoint , 0 ) ) < 0 ) return ret ; } return 0 ; } | <S2SV_ModStart> cat -> options , 0 ) ; av_dict_set_int ( & tmp , "cur_file_no" , fileno |
20 | CWE-000 void runAlg ( Proc * * procs , int numProcs , int preemp , int ( * nextProc ) ( Proc * * procs , int numProc , int quantum ) ) { int quantum , curNdx = - 1 , numStarted = 0 ; <S2SV_StartBug> for ( quantum = 0 ; quantum < QUANT_MAX || curNdx >= 0 || numStarted > 0 ; quantum ++ ) { <S2SV_EndBug> printf ( "%i<S2SV_blank>" , quantum ) ; if ( curNdx >= 0 ) { ( * ( procs + curNdx ) ) -> run ++ ; if ( ( * ( procs + curNdx ) ) -> run >= ( * ( procs + curNdx ) ) -> exp ) { numStarted -- ; ( * ( procs + curNdx ) ) -> end = quantum ; procs = removeProc ( procs , numProcs , curNdx ) ; numProcs -- ; if ( quantum < QUANT_MAX ) curNdx = ( * nextProc ) ( procs , numProcs , quantum ) ; else curNdx = - 1 ; } else if ( preemp == TRUE ) curNdx = changeCurrProc ( procs , numProcs - 1 , quantum , curNdx ) ; } else { curNdx = ( * nextProc ) ( procs , numProcs , quantum ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( curNdx > 0 && ( * ( procs + curNdx ) ) -> start < 0 ) numStarted ++ ; setProcStart ( procs , curNdx , quantum ) ; printProcName ( procs , curNdx ) ; printf ( "\\n" ) ; } } | <S2SV_ModStart> = 0 ; ( <S2SV_ModStart> curNdx >= 0 ) && numProcs <S2SV_ModEnd> > 0 ; <S2SV_ModStart> quantum ) ; if ( curNdx >= 0 ) ( * ( procs + curNdx ) ) -> run ++ ; |
21 | CWE-000 int spParserGetMove ( const SPCommand * command ) { int locations = 0 ; locations |= spParserGetBoardLocationFromString ( command -> arguments ) ; locations <<= 8 ; <S2SV_StartBug> locations |= spParserGetBoardLocationFromString ( command -> arguments + 6 ) ; <S2SV_EndBug> return spParserDestroyLocationIfNeeded ( locations ) ; } | <S2SV_ModStart> |= spParserGetBoardLocationFromString ( & <S2SV_ModStart> command -> arguments [ 5 ] <S2SV_ModEnd> ) ; return |
22 | CWE-000 void ft_printf ( const char * format , ... ) { va_list ap ; char tmp ; va_start ( ap , format ) ; while ( * format ) { while ( * format && * format != '%' ) { ft_putchar ( * format ) ; ++ format ; } if ( * format == '%' ) { t_mods mods = { } ; int moved ; char * tmpptr = ( char * ) ( format + 1 ) ; tmp = * tmpptr ; moved = 0 ; if ( tmp == 'h' ) { if ( has_mods ( mods ) ) exit ( 0 ) ; ++ tmpptr ; ++ moved ; tmp = * tmpptr ; mods . h = 1 ; if ( tmp == 'h' ) { ++ tmpptr ; ++ moved ; mods . h = 0 ; mods . hh = 1 ; tmp = * tmpptr ; } } else if ( tmp == 'l' ) { if ( has_mods ( mods ) ) exit ( 0 ) ; ++ tmpptr ; ++ moved ; tmp = * tmpptr ; mods . l = 1 ; if ( tmp == 'l' ) { ++ tmpptr ; ++ moved ; mods . l = 0 ; mods . ll = 1 ; tmp = * tmpptr ; } } else if ( tmp == 'j' ) { if ( has_mods ( mods ) ) exit ( 0 ) ; ++ tmpptr ; ++ moved ; tmp = * tmpptr ; mods . j = 1 ; } else if ( tmp == 'z' ) { if ( has_mods ( mods ) ) exit ( 0 ) ; ++ tmpptr ; ++ moved ; tmp = * tmpptr ; mods . z = 1 ; } else if ( tmp == 'D' ) mods . l = 1 ; if ( tmp == 's' ) ft_putstr ( va_arg ( ap , char * ) ) ; if ( tmp == '%' ) ft_putchar ( '%' ) ; if ( tmp == 'd' || tmp == 'i' || tmp == 'D' ) { if ( mods . hh ) ft_putnbr ( va_arg ( ap , int ) ) ; else if ( mods . h ) ft_putnbr ( va_arg ( ap , int ) ) ; else if ( mods . l ) <S2SV_StartBug> ft_putnbr ( va_arg ( ap , long int ) ) ; <S2SV_EndBug> else if ( mods . ll ) <S2SV_StartBug> ft_putnbr ( va_arg ( ap , long long ) ) ; <S2SV_EndBug> else if ( mods . j ) <S2SV_StartBug> ft_putnbr ( va_arg ( ap , intmax_t ) ) ; <S2SV_EndBug> else if ( mods . z ) <S2SV_StartBug> ft_putnbr ( va_arg ( ap , size_t ) ) ; <S2SV_EndBug> else ft_putnbr ( va_arg ( ap , int ) ) ; } if ( tmp == 'u' ) { if ( mods . hh ) ft_putunsigned ( va_arg ( ap , unsigned int ) ) ; else if ( mods . h ) ft_putunsigned ( va_arg ( ap , unsigned int ) ) ; else if ( mods . l ) ft_putunsignedlong ( va_arg ( ap , unsigned long int ) ) ; else if ( mods . ll ) ft_putunsignedlong ( va_arg ( ap , unsigned long long int ) ) ; else if ( mods . j ) ft_putunsignedlong ( va_arg ( ap , uintmax_t ) ) ; else if ( mods . z ) ft_putunsignedlong ( va_arg ( ap , size_t ) ) ; else ft_putunsigned ( va_arg ( ap , unsigned int ) ) ; } if ( tmp == 'c' ) ft_putchar ( va_arg ( ap , int ) ) ; if ( tmp == 'p' ) { void * ptr = va_arg ( ap , void * ) ; ft_putaddr ( ptr ) ; } if ( tmp == 'x' || tmp == 'X' ) ft_putnbr_hex ( va_arg ( ap , t_ull ) , tmp ) ; if ( tmp == 'o' ) ft_putnbr_oct ( va_arg ( ap , t_ull ) ) ; if ( tmp == 'f' ) ft_putfloat ( va_arg ( ap , double ) ) ; format += moved ; format += 2 ; } } va_end ( ap ) ; } | <S2SV_ModStart> . l ) ft_putlong <S2SV_ModEnd> ( va_arg ( <S2SV_ModStart> . ll ) ft_putlong <S2SV_ModEnd> ( va_arg ( <S2SV_ModStart> . j ) ft_putlong <S2SV_ModEnd> ( va_arg ( <S2SV_ModStart> . z ) ft_putlong <S2SV_ModEnd> ( va_arg ( |
23 | CWE-000 Texture * r_target_get_attachment ( RenderTarget * target , RenderTargetAttachment attachment ) { <S2SV_StartBug> assert ( attachment >= 0 && attachment < RENDERTARGET_MAX_ATTACHMENTS ) ; <S2SV_EndBug> <S2SV_StartBug> return target -> attachments [ attachment ] ; <S2SV_EndBug> } | <S2SV_ModStart> { assert ( target -> impl != NULL ) ; assert ( <S2SV_ModStart> RENDERTARGET_MAX_ATTACHMENTS ) ; if ( ! target -> impl -> initialized ) { RenderTarget * prev_target = r_target_current ( ) ; r_target ( target ) ; gl33_sync_render_target ( ) ; r_target ( prev_target ) ; } return target -> impl <S2SV_ModEnd> -> attachments [ |
24 | CWE-000 static int smb1360_get_prop_batt_resistance ( struct smb1360_chip * chip ) { u8 reg [ 2 ] ; u16 temp ; int rc ; <S2SV_StartBug> int64_t resistance ; <S2SV_EndBug> rc = smb1360_read_bytes ( chip , SHDW_FG_ESR_ACTUAL , reg , 2 ) ; if ( rc ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>FG_ESR_ACTUAL<S2SV_blank>rc=%d\\n" , rc ) ; return rc ; } temp = ( reg [ 1 ] << 8 ) | reg [ 0 ] ; resistance = float_decode ( temp ) * 2 ; pr_debug ( "reg=0x%02x<S2SV_blank>resistance=%lld\\n" , temp , resistance ) ; <S2SV_StartBug> return resistance ; <S2SV_EndBug> } | <S2SV_ModStart> ; int64_t resistance ; if ( is_device_suspended ( chip ) ) return chip -> resistance_now <S2SV_ModStart> resistance ) ; chip -> resistance_now = resistance ; return chip -> resistance_now <S2SV_ModEnd> ; } <S2SV_null> |
25 | CWE-000 static int adsp_probe ( struct platform_device * pdev ) { const struct adsp_data * desc ; struct qcom_adsp * adsp ; struct rproc * rproc ; int ret ; desc = of_device_get_match_data ( & pdev -> dev ) ; if ( ! desc ) return - EINVAL ; if ( ! qcom_scm_is_available ( ) ) return - EPROBE_DEFER ; rproc = rproc_alloc ( & pdev -> dev , pdev -> name , & adsp_ops , desc -> firmware_name , sizeof ( * adsp ) ) ; if ( ! rproc ) { dev_err ( & pdev -> dev , "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>remoteproc\\n" ) ; return - ENOMEM ; } rproc -> fw_ops = & adsp_fw_ops ; adsp = ( struct qcom_adsp * ) rproc -> priv ; adsp -> dev = & pdev -> dev ; adsp -> rproc = rproc ; adsp -> pas_id = desc -> pas_id ; adsp -> crash_reason_smem = desc -> crash_reason_smem ; adsp -> has_aggre2_clk = desc -> has_aggre2_clk ; platform_set_drvdata ( pdev , adsp ) ; init_completion ( & adsp -> start_done ) ; init_completion ( & adsp -> stop_done ) ; ret = adsp_alloc_memory_region ( adsp ) ; if ( ret ) goto free_rproc ; ret = adsp_init_clock ( adsp ) ; if ( ret ) goto free_rproc ; ret = adsp_init_regulator ( adsp ) ; if ( ret ) goto free_rproc ; ret = adsp_request_irq ( adsp , pdev , "wdog" , adsp_wdog_interrupt ) ; if ( ret < 0 ) goto free_rproc ; adsp -> wdog_irq = ret ; ret = adsp_request_irq ( adsp , pdev , "fatal" , adsp_fatal_interrupt ) ; if ( ret < 0 ) goto free_rproc ; adsp -> fatal_irq = ret ; ret = adsp_request_irq ( adsp , pdev , "ready" , adsp_ready_interrupt ) ; if ( ret < 0 ) goto free_rproc ; adsp -> ready_irq = ret ; ret = adsp_request_irq ( adsp , pdev , "handover" , adsp_handover_interrupt ) ; if ( ret < 0 ) goto free_rproc ; adsp -> handover_irq = ret ; ret = adsp_request_irq ( adsp , pdev , "stop-ack" , adsp_stop_ack_interrupt ) ; if ( ret < 0 ) goto free_rproc ; adsp -> stop_ack_irq = ret ; adsp -> state = qcom_smem_state_get ( & pdev -> dev , "stop" , & adsp -> stop_bit ) ; if ( IS_ERR ( adsp -> state ) ) { ret = PTR_ERR ( adsp -> state ) ; goto free_rproc ; } <S2SV_StartBug> qcom_add_smd_subdev ( rproc , & adsp -> smd_subdev ) ; <S2SV_EndBug> qcom_add_ssr_subdev ( rproc , & adsp -> ssr_subdev , desc -> ssr_name ) ; ret = rproc_add ( rproc ) ; if ( ret ) goto free_rproc ; return 0 ; free_rproc : rproc_free ( rproc ) ; return ret ; } | <S2SV_ModStart> free_rproc ; } qcom_add_glink_subdev ( rproc , & adsp -> glink_subdev ) ; |
26 | CWE-000 static int do_tpm_nv_write ( cmd_tbl_t * cmdtp , int flag , int argc , char * const argv [ ] ) { <S2SV_StartBug> uint32_t index , count , err ; <S2SV_EndBug> void * data ; if ( argc < 3 ) return CMD_RET_USAGE ; if ( argc != 3 + type_string_get_num_values ( argv [ 1 ] ) ) return CMD_RET_USAGE ; index = simple_strtoul ( argv [ 2 ] , NULL , 0 ) ; data = type_string_alloc ( argv [ 1 ] , & count ) ; if ( ! data ) { printf ( "Couldn\'t<S2SV_blank>parse<S2SV_blank>arguments\\n" ) ; return CMD_RET_USAGE ; } if ( type_string_pack ( argv [ 1 ] , argv + 3 , data ) ) { printf ( "Couldn\'t<S2SV_blank>parse<S2SV_blank>arguments\\n" ) ; free ( data ) ; return CMD_RET_USAGE ; } err = tpm_nv_write_value ( index , data , count ) ; free ( data ) ; return report_return_code ( err ) ; } | <S2SV_ModStart> ] ) { u32 <S2SV_ModEnd> index , count |
27 | CWE-000 static void * def_msm8x16_wcd_mbhc_cal ( void ) { void * msm8x16_wcd_cal ; struct wcd_mbhc_btn_detect_cfg * btn_cfg ; u16 * btn_low , * btn_high ; msm8x16_wcd_cal = kzalloc ( WCD_MBHC_CAL_SIZE ( WCD_MBHC_DEF_BUTTONS , WCD_MBHC_DEF_RLOADS ) , GFP_KERNEL ) ; if ( ! msm8x16_wcd_cal ) { pr_err ( "%s:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory\\n" , __func__ ) ; return NULL ; } # define S ( X , Y ) ( ( WCD_MBHC_CAL_PLUG_TYPE_PTR ( msm8x16_wcd_cal ) -> X ) = ( Y ) ) # ifdef CONFIG_MACH_CP8675 S ( v_hs_max , 2550 ) ; # elif defined CONFIG_MACH_WT88047 S ( v_hs_max , 1700 ) ; # else S ( v_hs_max , 1500 ) ; <S2SV_StartBug> # undef S <S2SV_EndBug> # define S ( X , Y ) ( ( WCD_MBHC_CAL_BTN_DET_PTR ( msm8x16_wcd_cal ) -> X ) = ( Y ) ) S ( num_btn , WCD_MBHC_DEF_BUTTONS ) ; # undef S btn_cfg = WCD_MBHC_CAL_BTN_DET_PTR ( msm8x16_wcd_cal ) ; btn_low = btn_cfg -> _v_btn_low ; btn_high = ( ( void * ) & btn_cfg -> _v_btn_low ) + ( sizeof ( btn_cfg -> _v_btn_low [ 0 ] ) * btn_cfg -> num_btn ) ; # ifdef CONFIG_MACH_JALEBI btn_low [ 0 ] = 0 ; btn_high [ 0 ] = 150 ; btn_low [ 1 ] = 150 ; btn_high [ 1 ] = 150 ; btn_low [ 2 ] = 150 ; btn_high [ 2 ] = 150 ; btn_low [ 3 ] = 150 ; btn_high [ 3 ] = 150 ; btn_low [ 4 ] = 150 ; btn_high [ 4 ] = 150 ; # elif defined ( CONFIG_MACH_CP8675 ) btn_low [ 0 ] = 50 ; btn_high [ 0 ] = 50 ; btn_low [ 1 ] = 87 ; btn_high [ 1 ] = 87 ; btn_low [ 2 ] = 75 ; btn_high [ 2 ] = 75 ; btn_low [ 3 ] = 112 ; btn_high [ 3 ] = 112 ; btn_low [ 4 ] = 137 ; btn_high [ 4 ] = 137 ; # elif defined ( CONFIG_MACH_OPPO ) btn_low [ 0 ] = 25 ; btn_high [ 0 ] = 137 ; btn_low [ 1 ] = 137 ; btn_high [ 1 ] = 138 ; btn_low [ 2 ] = 138 ; btn_high [ 2 ] = 139 ; btn_low [ 3 ] = 139 ; btn_high [ 3 ] = 140 ; if ( is_project ( OPPO_15011 ) || is_project ( OPPO_15018 ) || is_project ( OPPO_15022 ) ) { btn_low [ 4 ] = 175 ; } else { btn_low [ 4 ] = 140 ; } btn_high [ 4 ] = 315 ; # elif defined ( CONFIG_MACH_WT88047 ) btn_low [ 0 ] = 25 ; btn_high [ 0 ] = 75 ; btn_low [ 1 ] = 200 ; btn_high [ 1 ] = 225 ; btn_low [ 2 ] = 325 ; btn_high [ 2 ] = 400 ; btn_low [ 3 ] = 375 ; btn_high [ 3 ] = 410 ; btn_low [ 4 ] = 430 ; btn_high [ 4 ] = 450 ; # else btn_low [ 0 ] = 75 ; btn_high [ 0 ] = 75 ; btn_low [ 1 ] = 150 ; btn_high [ 1 ] = 150 ; btn_low [ 2 ] = 237 ; btn_high [ 2 ] = 237 ; btn_low [ 3 ] = 450 ; btn_high [ 3 ] = 450 ; btn_low [ 4 ] = 500 ; btn_high [ 4 ] = 500 ; # endif return msm8x16_wcd_cal ; } | <S2SV_ModStart> ) ; # endif # |
28 | CWE-000 void buscainterna_LFREQ ( LFREQ * l , int x , No_LFREQ * * p ) { * p = l -> ini ; <S2SV_StartBug> while ( * p != NULL && ( * p ) -> info != x ) { <S2SV_EndBug> * p = ( * p ) -> prox ; <S2SV_StartBug> } <S2SV_EndBug> return ; } | <S2SV_ModStart> -> ini ; int count = 0 ; do <S2SV_ModEnd> { * p <S2SV_ModStart> -> prox ; count ++ ; } while ( * p != l -> ini && ( * p ) -> info != x ) ; if ( count > 1 && * p == l -> ini ) * p = NULL ; <S2SV_ModEnd> return ; } |
29 | CWE-000 static acpi_status acpi_ev_delete_gpe_xrupt ( struct acpi_gpe_xrupt_info * gpe_xrupt ) { <S2SV_StartBug> acpi_status status ; <S2SV_EndBug> ACPI_FUNCTION_TRACE ( "ev_delete_gpe_xrupt" ) ; if ( gpe_xrupt -> interrupt_number == acpi_gbl_FADT -> sci_int ) { gpe_xrupt -> gpe_block_list_head = NULL ; return_ACPI_STATUS ( AE_OK ) ; } status = acpi_os_remove_interrupt_handler ( gpe_xrupt -> interrupt_number , acpi_ev_gpe_xrupt_handler ) ; if ( ACPI_FAILURE ( status ) ) { return_ACPI_STATUS ( status ) ; } <S2SV_StartBug> acpi_os_acquire_lock ( acpi_gbl_gpe_lock , ACPI_NOT_ISR ) ; <S2SV_EndBug> if ( gpe_xrupt -> previous ) { gpe_xrupt -> previous -> next = gpe_xrupt -> next ; } if ( gpe_xrupt -> next ) { gpe_xrupt -> next -> previous = gpe_xrupt -> previous ; } <S2SV_StartBug> acpi_os_release_lock ( acpi_gbl_gpe_lock , ACPI_NOT_ISR ) ; <S2SV_EndBug> ACPI_MEM_FREE ( gpe_xrupt ) ; return_ACPI_STATUS ( AE_OK ) ; } | <S2SV_ModStart> { acpi_status status ; u32 flags <S2SV_ModStart> ) ; } flags = <S2SV_ModStart> acpi_os_acquire_lock ( acpi_gbl_gpe_lock <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( acpi_gbl_gpe_lock , flags <S2SV_ModEnd> ) ; ACPI_MEM_FREE |
30 | CWE-000 void * mm_malloc ( size_t size ) { # ifdef DEBUG printf ( "Calling<S2SV_blank>malloc<S2SV_blank>with<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%d\\n" , size ) ; # endif size_t asize ; size_t extendsize ; char * bp ; if ( size == 0 ) return NULL ; <S2SV_StartBug> if ( size <= MIN_BIGBLK_SIZE ) <S2SV_EndBug> asize = MIN_BIGBLK_SIZE ; else asize = DSIZE * ( ( size + ( DSIZE ) + ( DSIZE - 1 ) ) / DSIZE ) ; if ( ( bp = find_fit ( asize ) ) != NULL ) { remove_from_sizeclass ( bp ) ; place ( bp , asize ) ; # ifdef DEBUG printf ( "\\tCreated<S2SV_blank>new<S2SV_blank>block<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>with<S2SV_blank>%d<S2SV_blank>bytes\\n\\n" , bp , GET_SIZE ( HDRP ( bp ) ) ) ; traverse_lists ( ) ; traverse_blocks ( ) ; mm_check ( ) ; # endif return bp ; } extendsize = MAX ( asize , mem_pagesize ( ) ) ; if ( ( bp = extend_heap ( extendsize / WSIZE ) ) == NULL ) return NULL ; remove_from_sizeclass ( bp ) ; place ( bp , asize ) ; # ifdef DEBUG printf ( "\\tCreated<S2SV_blank>new<S2SV_blank>block<S2SV_blank>at<S2SV_blank>%p<S2SV_blank>with<S2SV_blank>%d<S2SV_blank>bytes\\n\\n" , bp , GET_SIZE ( HDRP ( bp ) ) ) ; traverse_lists ( ) ; traverse_blocks ( ) ; # endif return bp ; } | <S2SV_ModStart> return NULL ; size += WSIZE ; |
31 | CWE-000 void game_over ( ) { <S2SV_StartBug> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>_____<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>__<S2SV_blank><S2SV_blank>__<S2SV_blank>______<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>______<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>________<S2SV_blank>_____<S2SV_blank><S2SV_blank>_<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" ) ; <S2SV_EndBug> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/<S2SV_blank>____|<S2SV_blank><S2SV_blank><S2SV_blank>/\\\\<S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank><S2SV_blank>\\\\/<S2SV_blank><S2SV_blank>|<S2SV_blank><S2SV_blank>____|<S2SV_blank><S2SV_blank>/<S2SV_blank>__<S2SV_blank>\\\\<S2SV_blank>\\\\<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/<S2SV_blank>/<S2SV_blank><S2SV_blank>____|<S2SV_blank><S2SV_blank>__<S2SV_blank>\\\\|<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>__<S2SV_blank><S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank>\\\\<S2SV_blank><S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank><S2SV_blank>/<S2SV_blank>|<S2SV_blank>|__<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank>\\\\<S2SV_blank><S2SV_blank>/<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>\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank>|_<S2SV_blank>|<S2SV_blank>/<S2SV_blank>/\\\\<S2SV_blank>\\\\<S2SV_blank>|<S2SV_blank>|\\\\/|<S2SV_blank>|<S2SV_blank><S2SV_blank>__|<S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>|<S2SV_blank>|\\\\<S2SV_blank>\\\\/<S2SV_blank>/<S2SV_blank>|<S2SV_blank><S2SV_blank>__|<S2SV_blank>|<S2SV_blank><S2SV_blank>_<S2SV_blank><S2SV_blank>/|<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|__|<S2SV_blank>|/<S2SV_blank>____<S2SV_blank>\\\\|<S2SV_blank>|<S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank>|____<S2SV_blank><S2SV_blank>|<S2SV_blank>|__|<S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank>|<S2SV_blank>|____|<S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank>\\\\|_|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" ) ; printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\\\_____/_/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\\\_\\\\_|<S2SV_blank><S2SV_blank>|_|______|<S2SV_blank><S2SV_blank>\\\\____/<S2SV_blank><S2SV_blank><S2SV_blank>\\\\/<S2SV_blank><S2SV_blank><S2SV_blank>|______|_|<S2SV_blank><S2SV_blank>\\\\_(_)<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" ) ; printf ( "<S2SV_blank>________________________________________________________________________<S2SV_blank>\\n" ) ; printf ( "|________________________________________________________________________|\\n" ) ; } | <S2SV_ModStart> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>_____<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>__<S2SV_blank><S2SV_blank>__<S2SV_blank>______<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>______<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>________<S2SV_blank>_____<S2SV_blank><S2SV_blank>_<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><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><S2SV_blank>____|<S2SV_blank><S2SV_blank>/<S2SV_blank>__<S2SV_blank>\\\\<S2SV_blank>\\\\<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>/<S2SV_blank>/<S2SV_blank><S2SV_blank>____|<S2SV_blank><S2SV_blank>__<S2SV_blank>\\\\|<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>__<S2SV_blank><S2SV_blank><S2SV_blank>/<S2SV_blank><S2SV_blank>\\\\<S2SV_blank><S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank><S2SV_blank>/<S2SV_blank>|<S2SV_blank>|__<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>|<S2SV_blank>\\\\<S2SV_blank>\\\\<S2SV_blank><S2SV_blank>/<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>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank>|_<S2SV_blank>|<S2SV_blank>/<S2SV_blank>/\\\\<S2SV_blank>\\\\<S2SV_blank>|<S2SV_blank>|\\\\/|<S2SV_blank>|<S2SV_blank><S2SV_blank>__|<S2SV_blank><S2SV_blank><S2SV_blank>|<S2SV_blank>|<S2SV_blank><S2SV_blank>|<S2SV_blank>|\\\\<S2SV_blank>\\\\/<S2SV_blank>/<S2SV_blank>|<S2SV_blank><S2SV_blank>__|<S2SV_blank>|<S2SV_blank><S2SV_blank>_<S2SV_blank><S2SV_blank>/|<S2SV_blank>|<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><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>|<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>\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\\\_____/_/<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\\\_\\\\_|<S2SV_blank><S2SV_blank>|_|______|<S2SV_blank><S2SV_blank>\\\\____/<S2SV_blank><S2SV_blank><S2SV_blank>\\\\/<S2SV_blank><S2SV_blank><S2SV_blank>|______|_|<S2SV_blank><S2SV_blank>\\\\_(_)<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>\\n" "<S2SV_blank>________________________________________________________________________<S2SV_blank>\\n" <S2SV_ModEnd> "|________________________________________________________________________|\\n" ) ; |
32 | CWE-000 START_TEST ( test_get_username_list_ok ) { char * url = TALIESIN_SERVER_URI "/users" ; <S2SV_StartBug> json_t * j_body = json_string ( ADMIN_LOGIN ) ; <S2SV_EndBug> <S2SV_StartBug> int res = run_simple_authenticated_test ( & admin_req , "GET" , url , j_body , NULL , 200 , NULL , NULL , NULL ) ; <S2SV_EndBug> json_decref ( j_body ) ; ck_assert_int_eq ( res , 1 ) ; } | <S2SV_ModStart> * j_body = json_pack ( "{ss}" , "username" , <S2SV_ModEnd> ADMIN_LOGIN ) ; <S2SV_ModStart> , url , NULL <S2SV_ModEnd> , NULL , <S2SV_ModStart> , 200 , j_body <S2SV_ModEnd> , NULL , |
33 | CWE-000 static int procfs_getonecpu ( int xcpu , struct cpu_info * ci , char * bf , size_t * len ) { size_t left , l , size ; char featurebuf [ 1024 ] , * p ; p = featurebuf ; left = sizeof ( featurebuf ) ; size = * len ; procfs_getonecpufeatures ( ci , p , & left ) ; p = bf ; left = * len ; size = 0 ; l = snprintf ( p , left , "processor\\t:<S2SV_blank>%d\\n" "vendor_id\\t:<S2SV_blank>%s\\n" "cpu<S2SV_blank>family\\t:<S2SV_blank>%d\\n" "model\\t\\t:<S2SV_blank>%d\\n" "model<S2SV_blank>name\\t:<S2SV_blank>%s\\n" "stepping\\t:<S2SV_blank>" , xcpu , ( char * ) ci -> ci_vendor , CPUID_TO_FAMILY ( ci -> ci_signature ) , CPUID_TO_MODEL ( ci -> ci_signature ) , cpu_brand_string ) ; size += l ; if ( l < left ) { left -= l ; p += l ; } else left = 0 ; if ( cpuid_level >= 0 ) l = snprintf ( p , left , "%d\\n" , CPUID_TO_STEPPING ( ci -> ci_signature ) ) ; else l = snprintf ( p , left , "unknown\\n" ) ; size += l ; if ( l < left ) { left -= l ; p += l ; } else left = 0 ; if ( ci -> ci_data . cpu_cc_freq != 0 ) { uint64_t freq , fraq ; freq = ( ci -> ci_data . cpu_cc_freq + 4999 ) / 1000000 ; fraq = ( ( ci -> ci_data . cpu_cc_freq + 4999 ) / 10000 ) % 100 ; l = snprintf ( p , left , "cpu<S2SV_blank>MHz\\t\\t:<S2SV_blank>%" PRIu64 ".%02" PRIu64 "\\n" , freq , fraq ) ; } else l = snprintf ( p , left , "cpu<S2SV_blank>MHz\\t\\t:<S2SV_blank>unknown\\n" ) ; size += l ; if ( l < left ) { left -= l ; p += l ; } else left = 0 ; l = snprintf ( p , left , "apicid\\t\\t:<S2SV_blank>%d\\n" "initial<S2SV_blank>apicid\\t:<S2SV_blank>%d\\n" , ci -> ci_acpiid , ci -> ci_initapicid ) ; size += l ; if ( l < left ) { left -= l ; p += l ; } else left = 0 ; l = snprintf ( p , left , # ifdef __i386__ "fdiv_bug\\t:<S2SV_blank>%s\\n" # endif "fpu\\t\\t:<S2SV_blank>%s\\n" "fpu_exception\\t:<S2SV_blank>yes\\n" "cpuid<S2SV_blank>level\\t:<S2SV_blank>%d\\n" "wp\\t\\t:<S2SV_blank>%s\\n" "flags\\t\\t:<S2SV_blank>%s\\n" "clflush<S2SV_blank>size\\t:<S2SV_blank>%d\\n" , # ifdef __i386__ i386_fpu_fdivbug ? "yes" : "no" , # endif i386_fpu_present ? "yes" : "no" , <S2SV_StartBug> cpuid_level , <S2SV_EndBug> ( rcr0 ( ) & CR0_WP ) ? "yes" : "no" , featurebuf , ci -> ci_cflush_lsize ) ; size += l ; left = * len ; * len = size ; return left < * len ? - 1 : 0 ; } | <S2SV_ModStart> : "no" , ci -> ci_max_cpuid <S2SV_ModEnd> , ( rcr0 |
34 | CWE-000 void key_backspace ( ) { if ( editor . col + cursor . col > 0 ) { cursor . left ( & cursor ) ; for ( int i = editor . col + cursor . col ; i < strlen ( doc . buf [ editor . row + cursor . row ] ) ; i ++ ) { doc . buf [ editor . row + cursor . row ] [ i ] = doc . buf [ editor . row + cursor . row ] [ i + 1 ] ; } } else { if ( editor . row + cursor . row > 0 ) { cursor . left ( & cursor ) ; strcpy ( & doc . buf [ editor . row + cursor . row ] [ strlen ( doc . buf [ editor . row + cursor . row ] ) ] , doc . buf [ editor . row + cursor . row + 1 ] ) ; <S2SV_StartBug> for ( int i = editor . row + cursor . row + 1 ; i < doc . rows - 1 ; i ++ ) { <S2SV_EndBug> memset ( doc . buf [ i ] , 0 , sizeof ( char ) * DOC_MAXIMUM_COLS ) ; strcpy ( doc . buf [ i ] , doc . buf [ i + 1 ] ) ; <S2SV_StartBug> } <S2SV_EndBug> doc . rows -- ; } } } | <S2SV_ModStart> ; i < DOC_MAXIMUM_ROWS <S2SV_ModEnd> - 1 ; <S2SV_ModStart> ] ) ; memset ( doc . buf [ i + 1 ] , 0 , sizeof ( char ) * DOC_MAXIMUM_COLS ) ; |
35 | CWE-000 static void btc_init_bluetooth ( void ) { <S2SV_StartBug> bte_main_boot_entry ( btc_init_callback ) ; <S2SV_EndBug> } | <S2SV_ModStart> void ) { osi_alarm_create_mux ( ) ; osi_alarm_init ( ) ; |
36 | CWE-000 int semanage_create_store ( semanage_handle_t * sh , int create ) { <S2SV_StartBug> struct stat sb ; <S2SV_EndBug> int mode_mask = R_OK | W_OK | X_OK ; const char * path = semanage_files [ SEMANAGE_ROOT ] ; int fd ; if ( stat ( path , & sb ) == - 1 ) { if ( errno == ENOENT && create ) { if ( mkdir ( path , S_IRWXU ) == - 1 ) { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>module<S2SV_blank>store<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 2 ; } } else { if ( create ) ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>module<S2SV_blank>store<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 1 ; } } else { <S2SV_StartBug> if ( ! S_ISDIR ( sb . st_mode ) || access ( path , mode_mask ) == - 1 ) { <S2SV_EndBug> ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>access<S2SV_blank>module<S2SV_blank>store<S2SV_blank>at<S2SV_blank>%s,<S2SV_blank>or<S2SV_blank>it<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." , path ) ; return - 1 ; } } path = semanage_path ( SEMANAGE_ACTIVE , SEMANAGE_TOPLEVEL ) ; if ( stat ( path , & sb ) == - 1 ) { if ( errno == ENOENT && create ) { if ( mkdir ( path , S_IRWXU ) == - 1 ) { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>module<S2SV_blank>store,<S2SV_blank>active<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 2 ; } } else { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>module<S2SV_blank>store,<S2SV_blank>active<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 1 ; } } else { <S2SV_StartBug> if ( ! S_ISDIR ( sb . st_mode ) || access ( path , mode_mask ) == - 1 ) { <S2SV_EndBug> ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>access<S2SV_blank>module<S2SV_blank>store<S2SV_blank>active<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s,<S2SV_blank>or<S2SV_blank>it<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." , path ) ; return - 1 ; } } path = semanage_path ( SEMANAGE_ACTIVE , SEMANAGE_MODULES ) ; if ( stat ( path , & sb ) == - 1 ) { if ( errno == ENOENT && create ) { if ( mkdir ( path , S_IRWXU ) == - 1 ) { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>module<S2SV_blank>store,<S2SV_blank>active<S2SV_blank>modules<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 2 ; } } else { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>from<S2SV_blank>module<S2SV_blank>store,<S2SV_blank>active<S2SV_blank>modules<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 1 ; } } else { <S2SV_StartBug> if ( ! S_ISDIR ( sb . st_mode ) || access ( path , mode_mask ) == - 1 ) { <S2SV_EndBug> ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>access<S2SV_blank>module<S2SV_blank>store<S2SV_blank>active<S2SV_blank>modules<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s,<S2SV_blank>or<S2SV_blank>it<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." , path ) ; return - 1 ; } } path = semanage_files [ SEMANAGE_READ_LOCK ] ; if ( stat ( path , & sb ) == - 1 ) { if ( errno == ENOENT && create ) { if ( ( fd = creat ( path , S_IRUSR | S_IWUSR ) ) == - 1 ) { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 2 ; } close ( fd ) ; } else { ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 1 ; } } else { <S2SV_StartBug> if ( ! S_ISREG ( sb . st_mode ) || access ( path , R_OK | W_OK ) == - 1 ) { <S2SV_EndBug> ERR ( sh , "Could<S2SV_blank>not<S2SV_blank>access<S2SV_blank>lock<S2SV_blank>file<S2SV_blank>at<S2SV_blank>%s." , path ) ; return - 1 ; } } return 0 ; } | <S2SV_ModStart> struct stat sb <S2SV_ModEnd> ; const char <S2SV_ModStart> . st_mode ) ) { ERR ( sh , "Module<S2SV_blank>store<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." <S2SV_ModEnd> , path ) <S2SV_ModStart> . st_mode ) ) { ERR ( sh , "Module<S2SV_blank>store<S2SV_blank>active<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." <S2SV_ModEnd> , path ) <S2SV_ModStart> . st_mode ) ) { ERR ( sh , "Module<S2SV_blank>store<S2SV_blank>active<S2SV_blank>modules<S2SV_blank>subdirectory<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>directory." <S2SV_ModEnd> , path ) <S2SV_ModStart> . st_mode ) ) { ERR ( sh , "Lock<S2SV_blank>file<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>missing." <S2SV_ModEnd> , path ) |
37 | CWE-000 static int inno_hdmi_phy_rk3328_power_on ( struct inno_hdmi_phy * inno , const struct post_pll_config * cfg , const struct phy_config * phy_cfg ) { u32 val ; inno_update_bits ( inno , 0x02 , 1 , 0 ) ; inno_update_bits ( inno , 0xaa , 1 , 1 ) ; val = cfg -> fbdiv & 0xff ; inno_write ( inno , 0xac , val ) ; if ( cfg -> postdiv == 1 ) { inno_write ( inno , 0xaa , 2 ) ; val = ( cfg -> fbdiv >> 8 ) | cfg -> prediv ; inno_write ( inno , 0xab , val ) ; } else { val = ( cfg -> postdiv / 2 ) - 1 ; inno_write ( inno , 0xad , val ) ; val = ( cfg -> fbdiv >> 8 ) | cfg -> prediv ; inno_write ( inno , 0xab , val ) ; inno_write ( inno , 0xaa , 0x0e ) ; } for ( val = 0 ; val < 14 ; val ++ ) inno_write ( inno , 0xb5 + val , phy_cfg -> regs [ val ] ) ; inno_write ( inno , 0xc8 , 0 ) ; inno_write ( inno , 0xc9 , 0 ) ; inno_write ( inno , 0xca , 0 ) ; inno_write ( inno , 0xcb , 0 ) ; if ( phy_cfg -> tmdsclock > 340000000 ) { val = 75000000 / 100000 ; inno_write ( inno , 0xc5 , ( ( val >> 8 ) & 0xff ) | 0x80 ) ; inno_write ( inno , 0xc6 , val & 0xff ) ; inno_write ( inno , 0xc7 , 3 << 1 ) ; inno_write ( inno , 0xc5 , ( ( val >> 8 ) & 0xff ) ) ; } else if ( phy_cfg -> tmdsclock > 165000000 ) { inno_write ( inno , 0xc5 , 0x81 ) ; inno_write ( inno , 0xc8 , 0x30 ) ; inno_write ( inno , 0xc9 , 0x10 ) ; inno_write ( inno , 0xca , 0x10 ) ; inno_write ( inno , 0xcb , 0x10 ) ; } else { inno_write ( inno , 0xc5 , 0x81 ) ; } inno_update_bits ( inno , 0xaa , 1 , 0 ) ; inno_update_bits ( inno , 0xb0 , 4 , 4 ) ; inno_write ( inno , 0xb2 , 0x0f ) ; for ( val = 0 ; val < 5 ; val ++ ) { if ( inno_read ( inno , 0xaf ) & 1 ) break ; udelay ( 1000 ) ; } if ( ! ( inno_read ( inno , 0xaf ) & 1 ) ) { printf ( "HDMI<S2SV_blank>PHY<S2SV_blank>Post<S2SV_blank>PLL<S2SV_blank>unlock\\n" ) ; return - ETIMEDOUT ; } if ( phy_cfg -> tmdsclock > 340000000 ) <S2SV_StartBug> udelay ( 100000 ) ; <S2SV_EndBug> inno_update_bits ( inno , 0x02 , 1 , 1 ) ; return 0 ; } | <S2SV_ModStart> > 340000000 ) mdelay ( 100 <S2SV_ModEnd> ) ; inno_update_bits |
38 | CWE-000 NPY_NO_EXPORT PyObject * PyArray_Nonzero ( PyArrayObject * self ) { int i , ndim = PyArray_NDIM ( self ) ; PyArrayObject * ret = NULL ; PyObject * ret_tuple ; npy_intp ret_dims [ 2 ] ; PyArray_NonzeroFunc * nonzero = PyArray_DESCR ( self ) -> f -> nonzero ; npy_intp nonzero_count ; NpyIter * iter ; NpyIter_IterNextFunc * iternext ; NpyIter_GetMultiIndexFunc * get_multi_index ; char * * dataptr ; int is_empty = 0 ; nonzero_count = PyArray_CountNonzero ( self ) ; if ( nonzero_count < 0 ) { return NULL ; } ret_dims [ 0 ] = nonzero_count ; ret_dims [ 1 ] = ( ndim == 0 ) ? 1 : ndim ; ret = ( PyArrayObject * ) PyArray_New ( & PyArray_Type , 2 , ret_dims , NPY_INTP , NULL , NULL , 0 , 0 , NULL ) ; if ( ret == NULL ) { return NULL ; } if ( ndim <= 1 ) { npy_intp * multi_index = ( npy_intp * ) PyArray_DATA ( ret ) ; char * data = PyArray_BYTES ( self ) ; npy_intp stride = ( ndim == 0 ) ? 0 : PyArray_STRIDE ( self , 0 ) ; npy_intp count = ( ndim == 0 ) ? 1 : PyArray_DIM ( self , 0 ) ; NPY_BEGIN_THREADS_DEF ; if ( nonzero_count == 0 ) { goto finish ; } NPY_BEGIN_THREADS_THRESHOLDED ( count ) ; if ( PyArray_ISBOOL ( self ) ) { if ( ( ( double ) nonzero_count / count ) <= 0.1 ) { npy_intp subsize ; npy_intp j = 0 ; while ( 1 ) { npy_memchr ( data + j * stride , 0 , stride , count - j , & subsize , 1 ) ; j += subsize ; if ( j >= count ) { break ; } * multi_index ++ = j ++ ; } } else { npy_intp j ; for ( j = 0 ; j < count ; ++ j ) { if ( * data != 0 ) { * multi_index ++ = j ; } data += stride ; } } } else { npy_intp j ; for ( j = 0 ; j < count ; ++ j ) { if ( nonzero ( data , self ) ) { * multi_index ++ = j ; } data += stride ; } } NPY_END_THREADS ; goto finish ; } iter = NpyIter_New ( self , NPY_ITER_READONLY | NPY_ITER_MULTI_INDEX | NPY_ITER_ZEROSIZE_OK | NPY_ITER_REFS_OK , NPY_CORDER , NPY_NO_CASTING , NULL ) ; if ( iter == NULL ) { Py_DECREF ( ret ) ; return NULL ; } if ( NpyIter_GetIterSize ( iter ) != 0 ) { npy_intp * multi_index ; NPY_BEGIN_THREADS_DEF ; iternext = NpyIter_GetIterNext ( iter , NULL ) ; if ( iternext == NULL ) { NpyIter_Deallocate ( iter ) ; Py_DECREF ( ret ) ; return NULL ; } get_multi_index = NpyIter_GetGetMultiIndex ( iter , NULL ) ; if ( get_multi_index == NULL ) { NpyIter_Deallocate ( iter ) ; Py_DECREF ( ret ) ; return NULL ; } NPY_BEGIN_THREADS_NDITER ( iter ) ; dataptr = NpyIter_GetDataPtrArray ( iter ) ; multi_index = ( npy_intp * ) PyArray_DATA ( ret ) ; if ( PyArray_ISBOOL ( self ) ) { do { if ( * * dataptr != 0 ) { get_multi_index ( iter , multi_index ) ; multi_index += ndim ; } } while ( iternext ( iter ) ) ; } else { do { if ( nonzero ( * dataptr , self ) ) { get_multi_index ( iter , multi_index ) ; multi_index += ndim ; } } while ( iternext ( iter ) ) ; } NPY_END_THREADS ; } NpyIter_Deallocate ( iter ) ; finish : if ( ndim == 0 ) { ndim = 1 ; } ret_tuple = PyTuple_New ( ndim ) ; if ( ret_tuple == NULL ) { Py_DECREF ( ret ) ; return NULL ; } <S2SV_StartBug> for ( i = 0 ; i < ndim ; ++ i ) { <S2SV_EndBug> if ( PyArray_DIMS ( ret ) [ i ] == 0 ) { is_empty = 1 ; break ; } } for ( i = 0 ; i < ndim ; ++ i ) { npy_intp stride = ndim * NPY_SIZEOF_INTP ; npy_intp data_offset = is_empty ? 0 : i * NPY_SIZEOF_INTP ; PyArrayObject * view = ( PyArrayObject * ) PyArray_New ( Py_TYPE ( ret ) , 1 , & nonzero_count , NPY_INTP , & stride , PyArray_BYTES ( ret ) + data_offset , 0 , PyArray_FLAGS ( ret ) , ( PyObject * ) ret ) ; if ( view == NULL ) { Py_DECREF ( ret ) ; Py_DECREF ( ret_tuple ) ; return NULL ; } Py_INCREF ( ret ) ; if ( PyArray_SetBaseObject ( view , ( PyObject * ) ret ) < 0 ) { Py_DECREF ( ret ) ; Py_DECREF ( ret_tuple ) ; return NULL ; } PyTuple_SET_ITEM ( ret_tuple , i , ( PyObject * ) view ) ; } Py_DECREF ( ret ) ; return ret_tuple ; } | <S2SV_ModStart> ; i < PyArray_NDIM ( ret ) <S2SV_ModEnd> ; ++ i |
39 | CWE-000 void print_state ( NordicRF24 * pRadio ) { int i = 0 ; uint8_t addr_width = pRadio -> get_address_width ( ) ; uint8_t address [ 5 ] , w = 0 ; printf ( "Data<S2SV_blank>Ready<S2SV_blank>Interrupt:<S2SV_blank>%s\\n" , pRadio -> use_interrupt_data_ready ( ) ? "true" : "false" ) ; printf ( "Data<S2SV_blank>Sent<S2SV_blank>Interrupt:<S2SV_blank>%s\\n" , pRadio -> use_interrupt_data_sent ( ) ? "true" : "false" ) ; printf ( "Max<S2SV_blank>Retry<S2SV_blank>Interrupt:<S2SV_blank>%s\\n" , pRadio -> use_interrupt_max_retry ( ) ? "true" : "false" ) ; printf ( "CRC<S2SV_blank>Enabled:<S2SV_blank>%s\\n" , pRadio -> is_crc_enabled ( ) ? "true" : "false" ) ; printf ( "Is<S2SV_blank>Powered<S2SV_blank>Up:<S2SV_blank>%s\\n" , pRadio -> is_powered_up ( ) ? "true" : "false" ) ; printf ( "Is<S2SV_blank>Receiver:<S2SV_blank>%s\\n" , pRadio -> is_receiver ( ) ? "true" : "false" ) ; printf ( "2<S2SV_blank>byte<S2SV_blank>CRC:<S2SV_blank>%s\\n" , pRadio -> is_2_byte_crc ( ) ? "true" : "false" ) ; printf ( "Address<S2SV_blank>Width:<S2SV_blank>%d\\n" , addr_width ) ; printf ( "Retry<S2SV_blank>Delay:<S2SV_blank>%d\\n" , pRadio -> get_retry_delay ( ) ) ; printf ( "Retry<S2SV_blank>Count:<S2SV_blank>%d\\n" , pRadio -> get_retry_count ( ) ) ; printf ( "Channel:<S2SV_blank>%d\\n" , pRadio -> get_channel ( ) ) ; printf ( "Power<S2SV_blank>Level:<S2SV_blank>%d\\n" , pRadio -> get_power_level ( ) ) ; printf ( "Data<S2SV_blank>Rate:<S2SV_blank>%d\\n" , pRadio -> get_data_rate ( ) ) ; printf ( "Continuous<S2SV_blank>Carrier:<S2SV_blank>%s\\n" , pRadio -> is_continuous_carrier_transmit ( ) ? "true" : "false" ) ; printf ( "Dynamic<S2SV_blank>Payloads:<S2SV_blank>%s\\n" , pRadio -> dynamic_payloads_enabled ( ) ? "true" : "false" ) ; printf ( "Payload<S2SV_blank>ACK:<S2SV_blank>%s\\n" , pRadio -> payload_ack_enabled ( ) ? "true" : "false" ) ; printf ( "TX<S2SV_blank>No<S2SV_blank>ACK:<S2SV_blank>%s\\n" , pRadio -> tx_noack_cmd_enabled ( ) ? "true" : "false" ) ; for ( i = 0 ; i < RF24_PIPES ; i ++ ) { printf ( "Pipe<S2SV_blank>%d<S2SV_blank>Enabled:<S2SV_blank>%s\\n" , i , pRadio -> is_pipe_enabled ( i ) ? "true" : "false" ) ; printf ( "Pipe<S2SV_blank>%d<S2SV_blank>ACK:<S2SV_blank>%s\\n" , i , pRadio -> is_pipe_ack ( i ) ? "true" : "false" ) ; pRadio -> get_rx_address ( i , address , & addr_width ) ; printf ( "Pipe<S2SV_blank>%d<S2SV_blank>Address:<S2SV_blank>[" , i ) ; <S2SV_StartBug> for ( int j = 0 ; j < addr_width ; j ++ ) { <S2SV_EndBug> printf ( "<S2SV_blank>%X<S2SV_blank>" , address [ j ] ) ; } printf ( "]\\n" ) ; pRadio -> get_payload_width ( i , & w ) ; printf ( "Pipe<S2SV_blank>%d<S2SV_blank>Payload<S2SV_blank>Width:<S2SV_blank>%d\\n" , i , w ) ; printf ( "Pipe<S2SV_blank>%d<S2SV_blank>Dynamic<S2SV_blank>Payloads:<S2SV_blank>%s\\n\\n" , i , pRadio -> is_dynamic_payload ( i ) ? "true" : "false" ) ; } pRadio -> get_tx_address ( address , & addr_width ) ; printf ( "Transmit<S2SV_blank>Address:<S2SV_blank>[" ) ; <S2SV_StartBug> for ( int j = 0 ; j < addr_width ; j ++ ) { <S2SV_EndBug> printf ( "<S2SV_blank>%X<S2SV_blank>" , address [ j ] ) ; } printf ( "]\\n" ) ; } | <S2SV_ModStart> int j = addr_width - 1 ; j >= <S2SV_ModStart> 0 ; j -- <S2SV_ModEnd> ) { printf <S2SV_ModStart> int j = addr_width - 1 ; j >= <S2SV_ModStart> 0 ; j -- <S2SV_ModEnd> ) { printf |
40 | CWE-000 <S2SV_StartBug> bool blk_mq_dispatch_rq_list ( struct blk_mq_hw_ctx * hctx , struct list_head * list ) <S2SV_EndBug> { struct request_queue * q = hctx -> queue ; struct request * rq ; LIST_HEAD ( driver_list ) ; struct list_head * dptr ; int errors , queued , ret = BLK_MQ_RQ_QUEUE_OK ; <S2SV_StartBug> dptr = NULL ; <S2SV_EndBug> errors = queued = 0 ; <S2SV_StartBug> while ( ! list_empty ( list ) ) { <S2SV_EndBug> struct blk_mq_queue_data bd ; rq = list_first_entry ( list , struct request , queuelist ) ; if ( ! blk_mq_get_driver_tag ( rq , & hctx , false ) ) { if ( ! queued && reorder_tags_to_front ( list ) ) continue ; if ( blk_mq_dispatch_wait_add ( hctx ) ) { if ( ! blk_mq_get_driver_tag ( rq , & hctx , false ) ) break ; } else { break ; } } list_del_init ( & rq -> queuelist ) ; bd . rq = rq ; bd . list = dptr ; if ( list_empty ( list ) ) bd . last = true ; else { struct request * nxt ; nxt = list_first_entry ( list , struct request , queuelist ) ; bd . last = ! blk_mq_get_driver_tag ( nxt , NULL , false ) ; } ret = q -> mq_ops -> queue_rq ( hctx , & bd ) ; switch ( ret ) { case BLK_MQ_RQ_QUEUE_OK : queued ++ ; break ; case BLK_MQ_RQ_QUEUE_BUSY : blk_mq_put_driver_tag_hctx ( hctx , rq ) ; list_add ( & rq -> queuelist , list ) ; __blk_mq_requeue_request ( rq ) ; break ; default : pr_err ( "blk-mq:<S2SV_blank>bad<S2SV_blank>return<S2SV_blank>on<S2SV_blank>queue:<S2SV_blank>%d\\n" , ret ) ; case BLK_MQ_RQ_QUEUE_ERROR : errors ++ ; rq -> errors = - EIO ; blk_mq_end_request ( rq , rq -> errors ) ; break ; } if ( ret == BLK_MQ_RQ_QUEUE_BUSY ) break ; if ( ! dptr && list -> next != list -> prev ) dptr = & driver_list ; <S2SV_StartBug> } <S2SV_EndBug> hctx -> dispatched [ queued_to_index ( queued ) ] ++ ; if ( ! list_empty ( list ) ) { rq = list_first_entry ( list , struct request , queuelist ) ; blk_mq_put_driver_tag ( rq ) ; spin_lock ( & hctx -> lock ) ; list_splice_init ( list , & hctx -> dispatch ) ; spin_unlock ( & hctx -> lock ) ; if ( ! blk_mq_sched_needs_restart ( hctx ) && ! test_bit ( BLK_MQ_S_TAG_WAITING , & hctx -> state ) ) blk_mq_run_hw_queue ( hctx , true ) ; } return ( queued + errors ) != 0 ; } | <S2SV_ModStart> blk_mq_dispatch_rq_list ( struct request_queue * q , struct list_head * list ) { struct <S2SV_ModStart> blk_mq_hw_ctx * hctx ; struct request * rq ; LIST_HEAD ( driver_list ) ; <S2SV_ModEnd> struct list_head * <S2SV_ModStart> struct list_head * <S2SV_ModEnd> dptr ; int <S2SV_ModStart> = BLK_MQ_RQ_QUEUE_OK ; if ( list_empty ( list ) ) return false ; <S2SV_ModStart> = 0 ; do <S2SV_ModEnd> { struct blk_mq_queue_data <S2SV_ModStart> driver_list ; } while ( ! list_empty ( list ) ) ; |
41 | CWE-000 size_t AllocateInBitmap ( Bitmap * bitmap , size_t len ) { assert ( bitmap ) ; size_t first = FindInBitmap ( bitmap , len ) ; <S2SV_StartBug> MarkInBitmap ( bitmap , first , len , true ) ; <S2SV_EndBug> return first ; } | <S2SV_ModStart> len ) ; if ( first == BITMAP_INVALID_WORD_IX ) { return BITMAP_INVALID_WORD_IX ; } |
42 | CWE-000 static FuDeviceItem * fu_device_list_find_by_id ( FuDeviceList * self , const gchar * device_id , gboolean * multiple_matches ) { FuDeviceItem * item = NULL ; gsize device_id_len ; device_id_len = strlen ( device_id ) ; for ( guint i = 0 ; i < self -> devices -> len ; i ++ ) { FuDeviceItem * item_tmp = g_ptr_array_index ( self -> devices , i ) ; const gchar * ids [ ] = { fu_device_get_id ( item_tmp -> device ) , fu_device_get_equivalent_id ( item_tmp -> device ) , NULL } ; for ( guint j = 0 ; ids [ j ] != NULL ; j ++ ) { if ( strncmp ( ids [ j ] , device_id , device_id_len ) == 0 ) { if ( item != NULL && multiple_matches != NULL ) * multiple_matches = TRUE ; item = item_tmp ; } } } for ( guint i = 0 ; i < self -> devices -> len ; i ++ ) { FuDeviceItem * item_tmp = g_ptr_array_index ( self -> devices , i ) ; <S2SV_StartBug> const gchar * ids [ ] = { <S2SV_EndBug> fu_device_get_id ( item_tmp -> device ) , fu_device_get_equivalent_id ( item_tmp -> device ) , NULL } ; if ( item_tmp -> device_old == NULL ) continue ; <S2SV_StartBug> for ( guint j = 0 ; ids [ j ] != NULL ; j ++ ) { <S2SV_EndBug> if ( strncmp ( ids [ j ] , device_id , device_id_len ) == 0 ) { if ( item != NULL && multiple_matches != NULL ) * multiple_matches = TRUE ; item = item_tmp ; } } } return item ; } | <S2SV_ModStart> * ids [ 3 ] = { <S2SV_ModEnd> NULL } ; <S2SV_ModStart> ) continue ; ids [ 0 ] = fu_device_get_id ( item_tmp -> device_old ) ; ids [ 1 ] = fu_device_get_equivalent_id ( item_tmp -> device_old ) ; |
43 | CWE-000 static TPM_RC StartAuthSession ( TSS2_SYS_CONTEXT * sapi_context , SESSION * session ) { TPM_RC rval ; TPM2B_ENCRYPTED_SECRET key ; char label [ ] = "ATH" ; UINT16 bytes ; int i ; key . t . size = 0 ; if ( session -> nonceOlder . t . size == 0 ) { session -> nonceOlder . t . size = GetDigestSize ( TPM_ALG_SHA1 ) ; for ( i = 0 ; i < session -> nonceOlder . t . size ; i ++ ) session -> nonceOlder . t . buffer [ i ] = 0 ; } session -> nonceNewer . t . size = session -> nonceOlder . t . size ; rval = Tss2_Sys_StartAuthSession ( sapi_context , session -> tpmKey , session -> bind , 0 , & ( session -> nonceOlder ) , & ( session -> encryptedSalt ) , session -> sessionType , & ( session -> symmetric ) , session -> authHash , & ( session -> sessionHandle ) , & ( session -> nonceNewer ) , 0 ) ; if ( rval == TPM_RC_SUCCESS ) { if ( session -> tpmKey == TPM_RH_NULL ) session -> salt . t . size = 0 ; if ( session -> bind == TPM_RH_NULL ) session -> authValueBind . t . size = 0 ; if ( session -> tpmKey == TPM_RH_NULL && session -> bind == TPM_RH_NULL ) { session -> sessionKey . b . size = 0 ; } else { bool result = string_bytes_concat_buffer ( ( TPM2B_MAX_BUFFER * ) & key , & ( session -> authValueBind . b ) ) ; if ( ! result ) { return TSS2_SYS_RC_BAD_VALUE ; } result = string_bytes_concat_buffer ( ( TPM2B_MAX_BUFFER * ) & key , & ( session -> salt . b ) ) ; if ( ! result ) { return TSS2_SYS_RC_BAD_VALUE ; } bytes = GetDigestSize ( session -> authHash ) ; if ( key . t . size == 0 ) { session -> sessionKey . t . size = 0 ; } else { <S2SV_StartBug> rval = tpm_kdfa ( sapi_context , session -> authHash , & ( key . b ) , label , & ( session -> nonceNewer . b ) , <S2SV_EndBug> & ( session -> nonceOlder . b ) , bytes * 8 , ( TPM2B_MAX_BUFFER * ) & ( session -> sessionKey ) ) ; } if ( rval != TPM_RC_SUCCESS ) { return ( TSS2_APP_RC_CREATE_SESSION_KEY_FAILED ) ; } } session -> nonceTpmDecrypt . b . size = 0 ; session -> nonceTpmEncrypt . b . size = 0 ; session -> nvNameChanged = 0 ; } return rval ; } | <S2SV_ModStart> = tpm_kdfa ( <S2SV_ModEnd> session -> authHash |
44 | CWE-000 int ft_numlen ( int n , int base ) { int len ; <S2SV_StartBug> long nb ; <S2SV_EndBug> len = 0 ; nb = ( long ) n ; if ( nb <= 0 ) nb *= - 1 ; while ( nb != 0 ) { len ++ ; nb /= base ; } return ( len ) ; } | <S2SV_ModStart> ; long nb ; if ( n == 0 ) return ( 1 ) |
45 | CWE-000 int adcusb_start ( struct adcusb_device * dev ) { <S2SV_StartBug> g_assert_nonnull ( dev ) ; <S2SV_EndBug> <S2SV_StartBug> dev -> ad_running = true ; <S2SV_EndBug> dev -> ad_libusb_thread = g_thread_new ( "adcusb" , adcusb_libusb_thread , dev ) ; dev -> ad_transfer = true ; for ( int i = 0 ; i < ADCUSB_NUM_XFERS ; i ++ ) { dev -> ad_buffers [ i ] = g_malloc0 ( dev -> ad_num_descs * ADCUSB_PACKET_SIZE ) ; dev -> ad_xfers [ i ] = libusb_alloc_transfer ( ADCUSB_PACKET_SIZE ) ; dev -> ad_buffer_size = ( int ) ( ADCUSB_PACKET_SIZE * dev -> ad_num_descs ) ; libusb_fill_iso_transfer ( dev -> ad_xfers [ i ] , dev -> ad_handle , ADCUSB_EP_NUM | LIBUSB_ENDPOINT_IN , ( uint8_t * ) dev -> ad_buffers [ i ] , ADCUSB_PACKET_SIZE , ( int ) dev -> ad_num_descs , adcusb_transfer_cb , dev , 1000 ) ; libusb_set_iso_packet_lengths ( dev -> ad_xfers [ i ] , ADCUSB_PACKET_SIZE ) ; if ( libusb_submit_transfer ( dev -> ad_xfers [ i ] ) != 0 ) <S2SV_StartBug> return ( - 1 ) ; <S2SV_EndBug> } <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> dev ) { g_mutex_lock ( & dev -> ad_mtx ) ; <S2SV_ModStart> dev ) ; if ( dev -> ad_transfer ) goto done ; if ( ! <S2SV_ModStart> dev -> ad_running ) goto fail ; if ( libusb_claim_interface ( dev -> ad_handle , 1 ) != 0 ) goto fail <S2SV_ModEnd> ; dev -> <S2SV_ModStart> != 0 ) goto fail ; } done : g_mutex_unlock ( & dev -> ad_mtx ) ; return ( 0 ) ; fail : g_mutex_unlock ( & dev -> ad_mtx ) ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
46 | CWE-000 static Worker * worker_init ( void ) { Worker * result = ( Worker * ) safe_alloc ( 1 , sizeof ( Worker ) ) ; pthread_mutex_init ( & ( result -> access_lock ) , NULL ) ; <S2SV_StartBug> result -> fifo_path = NULL ; <S2SV_EndBug> return result ; } | <S2SV_ModStart> ; result -> fifo_in_path = NULL ; result -> fifo_out_path <S2SV_ModEnd> = NULL ; |
47 | CWE-000 int initMp3 ( const char * file ) { int err = 0 ; int encoding = 0 ; if ( ( err = mpg123_init ( ) ) != MPG123_OK ) return err ; if ( ( mh = mpg123_new ( NULL , & err ) ) == NULL ) { <S2SV_StartBug> return err ; <S2SV_EndBug> } if ( mpg123_open ( mh , file ) != MPG123_OK || mpg123_getformat ( mh , ( long * ) & rate , ( int * ) & channels , & encoding ) != MPG123_OK ) { <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } mpg123_format_none ( mh ) ; mpg123_format ( mh , rate , channels , encoding ) ; * buffSize = mpg123_outblock ( mh ) * 16 ; return 0 ; } | <S2SV_ModStart> NULL ) { printf ( "Error:<S2SV_blank>%s\\n" , mpg123_plain_strerror ( err ) ) ; <S2SV_ModStart> MPG123_OK ) { printf ( "Trouble<S2SV_blank>with<S2SV_blank>mpg123:<S2SV_blank>%s\\n" , mpg123_strerror ( mh ) ) ; |
48 | CWE-000 static void controlCruise ( void ) { static float accumDecay ; if ( lastRawSensorData == 0 || lastRawSensorData == 255 ) { accumDecay *= decayRate ; internalSpeedSetpoint = speedSetpoint * accumDecay + 15 * ( 1 - accumDecay ) ; } else { accumDecay = 1 ; internalSpeedSetpoint = speedSetpoint ; internalLastSensorPosition = lastSensorPosition ; } float sensorError = 0 - internalLastSensorPosition ; float dSensorError = sensorError - lastSensorError ; <S2SV_StartBug> int newSpeed ; <S2SV_EndBug> <S2SV_StartBug> newSpeed = internalSpeedSetpoint * ( 1 - abs ( dSensorError ) * corneringDBrakeFactor - abs ( sensorError ) * corneringPBrakeFactor ) ; <S2SV_EndBug> int newCurveRadius ; newCurveRadius = - sharpestCurve / ( cruiseKp * sensorError + cruiseKd * dSensorError ) ; double newSharpness ; newSharpness = cruiseKi * lastSharpness + 1 / ( ( double ) newCurveRadius ) ; if ( newSharpness > 1 / ( ( double ) sharpestCurve ) ) { newSharpness = 1 / ( ( double ) sharpestCurve ) ; } else if ( newSharpness < - 1 / ( ( double ) sharpestCurve ) ) { newSharpness = - 1 / ( ( double ) sharpestCurve ) ; } lastSharpness = newSharpness ; newCurveRadius = 1 / newSharpness ; diffDrive ( newSpeed , newCurveRadius ) ; lastSensorError = sensorError ; } | <S2SV_ModStart> - lastSensorError ; float newSpeed ; float absSensorError ; float absDSensorError ; if ( sensorError < 0 ) { absSensorError = - sensorError ; } else { absSensorError = sensorError ; } if ( dSensorError < 0 ) { absDSensorError = - dSensorError ; } else { absDSensorError = dSensorError ; } newSpeed = ( ( float ) internalSpeedSetpoint ) * ( 1 - absDSensorError <S2SV_ModEnd> * corneringDBrakeFactor - <S2SV_ModStart> * corneringDBrakeFactor - absSensorError <S2SV_ModEnd> * corneringPBrakeFactor ) |
49 | CWE-000 int iwl_mvm_rm_snif_sta ( struct iwl_mvm * mvm , struct ieee80211_vif * vif ) { int ret ; <S2SV_StartBug> lockdep_assert_held ( & mvm -> mutex ) ; <S2SV_EndBug> ret = iwl_mvm_rm_sta_common ( mvm , mvm -> snif_sta . sta_id ) ; if ( ret ) IWL_WARN ( mvm , "Failed<S2SV_blank>sending<S2SV_blank>remove<S2SV_blank>station\\n" ) ; return ret ; } | <S2SV_ModStart> mvm -> mutex ) ; iwl_mvm_disable_txq ( mvm , mvm -> snif_queue , mvm -> snif_queue , IWL_MAX_TID_COUNT , 0 |
50 | CWE-000 void x_ae_context_add_polygon ( X_AE_Context * context , X_Polygon3 * polygon , X_BspSurface * bspSurface , X_BoundBoxFrustumFlags geoFlags , int * edgeIds , int bspKey , _Bool inSubmodel ) { X_Vec3 clippedV [ X_POLYGON3_MAX_VERTS ] ; <S2SV_StartBug> X_Polygon3 clipped = x_polygon3_make ( clippedV , X_POLYGON3_MAX_VERTS ) ; <S2SV_EndBug> ++ context -> renderContext -> renderer -> totalSurfacesRendered ; int tempEdgeIds [ X_POLYGON3_MAX_VERTS ] = { 0 } ; int * clippedEdgeIds = tempEdgeIds ; if ( geoFlags == X_BOUNDBOX_TOTALLY_INSIDE_FRUSTUM ) { clipped = * polygon ; clippedEdgeIds = edgeIds ; } else if ( ! x_polygon3_clip_to_frustum_edge_ids ( polygon , context -> renderContext -> viewFrustum , & clipped , geoFlags , edgeIds , clippedEdgeIds ) ) { return ; } X_AE_Surface * surface = create_ae_surface ( context , bspSurface , bspKey ) ; surface -> inSubmodel = inSubmodel ; X_Vec2_fp16x16 v2d [ X_POLYGON3_MAX_VERTS ] ; if ( ! project_polygon3 ( & clipped , & context -> renderContext -> cam -> viewMatrix , & context -> renderContext -> cam -> viewport , surface , v2d ) ) return ; X_Vec3 camPos = x_cameraobject_get_position ( context -> renderContext -> cam ) ; <S2SV_StartBug> x_ae_surface_calculate_inverse_z_gradient ( surface , & camPos , & context -> renderContext -> cam -> viewport , context -> renderContext -> viewMatrix ) ; <S2SV_EndBug> emit_edges ( context , surface , v2d , clipped . totalVertices , clippedEdgeIds ) ; } | <S2SV_ModStart> , X_POLYGON3_MAX_VERTS ) ; X_Vec3 firstVertex = polygon -> vertices [ 0 ] <S2SV_ModStart> renderContext -> viewMatrix , & firstVertex |
51 | CWE-000 static int htm_decode_one ( struct htm_decode_state * state ) { uint64_t value ; unsigned int tag ; int ret ; ret = htm_decode_fetch ( state , & value ) ; if ( ret < 0 ) { return ret ; } if ( value == 0 ) return 1 ; tag = htm_uint32 ( htm_bits ( value , 0 , 19 ) ) ; if ( tag == 0xACEFF ) { ret = htm_decode_stamp ( state , value ) ; } else { ret = htm_decode_insn ( state , value ) ; if ( ret == - 2 ) { htm_rewind ( state , value ) ; } } if ( ret < 0 ) { <S2SV_StartBug> printf ( "Invalid<S2SV_blank>record<S2SV_blank>%d<S2SV_blank>%016" PRIx64 "\\n" , state -> nr , value ) ; <S2SV_EndBug> if ( state -> error_count ++ > 100 ) { printf ( "Trace<S2SV_blank>corrupted<S2SV_blank>too<S2SV_blank>badly<S2SV_blank>to<S2SV_blank>parse\\n" ) ; assert ( 0 ) ; } return 1 ; } else { state -> error_count = 0 ; } return 1 ; } | <S2SV_ModStart> { printf ( "Invalid<S2SV_blank>record:%d<S2SV_blank>offset:%li<S2SV_blank>data:%016" PRIx64 "<S2SV_blank>\\n" , <S2SV_ModEnd> state -> nr <S2SV_ModStart> state -> nr , ftell ( state -> fd ) |
52 | CWE-000 int adj_graph_max_vertex_index ( adj_graph_t * graph ) { if ( graph -> max_vertex_index == - 1 ) { graph -> max_vertex_index = adj_graph_num_vertices ( graph ) - 1 ; int i_max = ( int ) ( graph -> vtx_dist [ graph -> rank + 1 ] - graph -> vtx_dist [ graph -> rank ] ) ; for ( int i = 0 ; i < i_max ; ++ i ) <S2SV_StartBug> graph -> max_vertex_index = MAX ( graph -> max_vertex_index , graph -> adjacency [ i ] ) ; <S2SV_EndBug> } return graph -> max_vertex_index ; } | <S2SV_ModStart> ++ i ) { for ( int j = graph -> xadj [ i ] ; j < graph -> xadj [ i + 1 ] ; ++ j ) <S2SV_ModStart> -> adjacency [ j <S2SV_ModEnd> ] ) ; <S2SV_ModStart> ] ) ; } |
53 | CWE-000 int lxc_setup ( struct lxc_handler * handler ) { int ret ; const char * lxcpath = handler -> lxcpath , * name = handler -> name ; struct lxc_conf * lxc_conf = handler -> conf ; ret = do_rootfs_setup ( lxc_conf , name , lxcpath ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>rootfs" ) ; return - 1 ; } if ( handler -> nsfd [ LXC_NS_UTS ] == - 1 ) { ret = setup_utsname ( lxc_conf -> utsname ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>the<S2SV_blank>utsname<S2SV_blank>%s" , name ) ; return - 1 ; } } ret = lxc_setup_network_in_child_namespaces ( lxc_conf , & lxc_conf -> network ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>network" ) ; return - 1 ; } ret = lxc_network_send_name_and_ifindex_to_parent ( handler ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>network<S2SV_blank>device<S2SV_blank>names<S2SV_blank>and<S2SV_blank>ifindices<S2SV_blank>to<S2SV_blank>parent" ) ; return - 1 ; } if ( lxc_conf -> autodev > 0 ) { ret = mount_autodev ( name , & lxc_conf -> rootfs , lxcpath ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>mount<S2SV_blank>\\"/dev\\"" ) ; return - 1 ; } } ret = lxc_mount_auto_mounts ( lxc_conf , lxc_conf -> auto_mounts & ~ LXC_AUTO_CGROUP_MASK , handler ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>first<S2SV_blank>automatic<S2SV_blank>mounts" ) ; return - 1 ; } ret = setup_mount ( lxc_conf , & lxc_conf -> rootfs , lxc_conf -> fstab , name , lxcpath ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>mounts" ) ; return - 1 ; } if ( ! verify_start_hooks ( lxc_conf ) ) return - 1 ; if ( lxc_conf -> is_execute ) { <S2SV_StartBug> ret = lxc_execute_bind_init ( lxc_conf ) ; <S2SV_EndBug> if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>bind-mount<S2SV_blank>the<S2SV_blank>lxc<S2SV_blank>init<S2SV_blank>system" ) ; return - 1 ; } } ret = lxc_mount_auto_mounts ( lxc_conf , lxc_conf -> auto_mounts & LXC_AUTO_CGROUP_MASK , handler ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>remaining<S2SV_blank>automatic<S2SV_blank>mounts" ) ; return - 1 ; } ret = run_lxc_hooks ( name , "mount" , lxc_conf , NULL ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>run<S2SV_blank>mount<S2SV_blank>hooks" ) ; return - 1 ; } if ( lxc_conf -> autodev > 0 ) { ret = run_lxc_hooks ( name , "autodev" , lxc_conf , NULL ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>run<S2SV_blank>autodev<S2SV_blank>hooks" ) ; return - 1 ; } ret = lxc_fill_autodev ( & lxc_conf -> rootfs ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>populate<S2SV_blank>\\"/dev\\"" ) ; return - 1 ; } } if ( ! lxc_list_empty ( & lxc_conf -> mount_list ) ) { ret = setup_mount_entries ( lxc_conf , & lxc_conf -> rootfs , & lxc_conf -> mount_list , name , lxcpath ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>mount<S2SV_blank>entries" ) ; return - 1 ; } } ret = lxc_setup_console ( & lxc_conf -> rootfs , & lxc_conf -> console , lxc_conf -> ttydir ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>console" ) ; return - 1 ; } ret = lxc_setup_dev_symlinks ( & lxc_conf -> rootfs ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>\\"/dev\\"<S2SV_blank>symlinks" ) ; return - 1 ; } ret = lxc_create_tmp_proc_mount ( lxc_conf ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>\\"/proc\\"<S2SV_blank>LSMs" ) ; return - 1 ; } ret = setup_pivot_root ( & lxc_conf -> rootfs ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>pivot<S2SV_blank>root<S2SV_blank>into<S2SV_blank>rootfs" ) ; return - 1 ; } ret = lxc_setup_devpts ( lxc_conf ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>new<S2SV_blank>devpts<S2SV_blank>instance" ) ; return - 1 ; } ret = lxc_create_ttys ( handler ) ; if ( ret < 0 ) return - 1 ; ret = setup_personality ( lxc_conf -> personality ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>personality" ) ; return - 1 ; } if ( ! lxc_list_empty ( & lxc_conf -> sysctls ) ) { ret = setup_sysctl_parameters ( & lxc_conf -> sysctls ) ; if ( ret < 0 ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>sysctl<S2SV_blank>parameters" ) ; return - 1 ; } } if ( ! lxc_list_empty ( & lxc_conf -> keepcaps ) ) { if ( ! lxc_list_empty ( & lxc_conf -> caps ) ) { ERROR ( "Container<S2SV_blank>requests<S2SV_blank>lxc.cap.drop<S2SV_blank>and<S2SV_blank>" "lxc.cap.keep:<S2SV_blank>either<S2SV_blank>use<S2SV_blank>lxc.cap.drop<S2SV_blank>or<S2SV_blank>" "lxc.cap.keep,<S2SV_blank>not<S2SV_blank>both" ) ; return - 1 ; } if ( dropcaps_except ( & lxc_conf -> keepcaps ) ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>keep<S2SV_blank>capabilities" ) ; return - 1 ; } } else if ( setup_caps ( & lxc_conf -> caps ) ) { ERROR ( "Failed<S2SV_blank>to<S2SV_blank>drop<S2SV_blank>capabilities" ) ; return - 1 ; } NOTICE ( "The<S2SV_blank>container<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>set<S2SV_blank>up" , name ) ; return 0 ; } | <S2SV_ModStart> = lxc_execute_bind_init ( handler <S2SV_ModEnd> ) ; if |
54 | CWE-000 static char * escape ( char * str ) { char * output = ( char * ) calloc ( strlen ( str ) * 6 , sizeof ( char ) ) ; char seq [ 7 ] ; for ( int i = 0 ; i < strlen ( str ) ; i ++ ) { switch ( str [ i ] ) { case '\\\\' : strcat ( output , "\\\\\\\\" ) ; break ; case '\\n' : strcat ( output , "\\\\n" ) ; break ; case '\\r' : strcat ( output , "\\\\r" ) ; break ; case '\\f' : strcat ( output , "\\\\f" ) ; break ; default : <S2SV_StartBug> if ( ( str [ i ] >= 32 && str [ i ] <= 127 ) || ( str [ i ] >= 192 && str [ i ] <= 223 ) ) { <S2SV_EndBug> output [ strlen ( output ) ] = str [ i ] ; } else { sprintf ( seq , "\\\\{%d}" , ( unsigned char ) str [ i ] ) ; strcat ( output , seq ) ; } } } return output ; } | <S2SV_ModStart> 127 ) || ( ( ( unsigned char ) str [ i ] ) <S2SV_ModEnd> >= 192 && <S2SV_ModStart> >= 192 && ( ( unsigned char ) str [ i ] ) <S2SV_ModEnd> <= 223 ) |
55 | CWE-000 void start_camera_streaming ( int fd ) { # ifdef DO_PIN_CONFIG wiringPiSetupGpio ( ) ; pinModeAlt ( 0 , INPUT ) ; pinModeAlt ( 1 , INPUT ) ; pinModeAlt ( 28 , INPUT ) ; pinModeAlt ( 28 , 4 ) ; pinModeAlt ( 29 , INPUT ) ; pinModeAlt ( 29 , 4 ) ; digitalWrite ( 41 , 1 ) ; digitalWrite ( 32 , 1 ) ; # endif # define ENABLE_DATALANE_1 0x0 # define DISABLE_DATALANE_1 0x1 u8 _s_v_format = i2c_rd8 ( fd , VI_STATUS ) & 0x0F ; vcos_log_error ( "VI_STATUS<S2SV_blank>to<S2SV_blank>select<S2SV_blank>cfg.data_lanes:<S2SV_blank>%u" , _s_v_format ) ; u16 r0006 ; u8 r0148 ; u32 r0500 ; if ( _s_v_format < 12 ) { r0006 = 0x0080 ; r0148 = DISABLE_DATALANE_1 ; r0500 = 0xA3008080 ; vcos_log_error ( "Selected<S2SV_blank>Sub<S2SV_blank>720p<S2SV_blank>registers" ) ; } else { r0006 = 0x0008 ; r0148 = ENABLE_DATALANE_1 ; r0500 = 0xA3008082 ; vcos_log_error ( "Selected<S2SV_blank>720p+<S2SV_blank>registers" ) ; } struct cmds_t cmds [ ] = { { 0x0004 , 0x0000 , 2 } , { 0x0002 , 0x0F00 , 2 } , { 0x0000 , 1 , 0xFFFF } , { 0x0002 , 0x0000 , 2 } , { 0x0006 , r0006 , 2 } , { 0x0008 , 0x005f , 2 } , { 0x0014 , 0xFFFF , 2 } , { 0x0016 , 0x051f , 2 } , { 0x0020 , 0x8111 , 2 } , { 0x0022 , 0x0213 , 2 } , { 0x0004 , r0004 , 2 } , { 0x0140 , 0x0 , 4 } , { 0x0144 , 0x0 , 4 } , { 0x0148 , r0148 , 4 } , { 0x014C , 0x1 , 4 } , { 0x0150 , 0x1 , 4 } , { 0x0210 , 0x00002988 , 4 } , { 0x0214 , 0x00000005 , 4 } , { 0x0218 , 0x00001d04 , 4 } , { 0x021C , 0x00000002 , 4 } , { 0x0220 , 0x00000504 , 4 } , { 0x0224 , 0x00004600 , 4 } , { 0x0228 , 0x0000000A , 4 } , { 0x022C , 0x00000004 , 4 } , { 0x0234 , 0x0000001F , 4 } , { 0x0204 , 0x00000001 , 4 } , { 0x0518 , 0x00000001 , 4 } , { 0x0500 , r0500 , 4 } , { 0x8502 , 0x01 , 1 } , { 0x8512 , 0xFE , 1 } , { 0x8513 , ( uint8_t ) ~ 0x20 , 1 } , { 0x8515 , ( uint8_t ) ~ 0x02 , 1 } , { 0x8531 , 0x01 , 1 } , { 0x8540 , 0x0A8C , 2 } , { 0x8630 , 0x00041eb0 , 4 } , { 0x8670 , 0x01 , 1 } , { 0x8532 , 0x80 , 1 } , { 0x8536 , 0x40 , 1 } , { 0x853F , 0x0A , 1 } , { 0x8543 , 0x32 , 1 } , { 0x8544 , 0x10 , 1 } , { 0x8545 , 0x31 , 1 } , { 0x8546 , 0x2D , 1 } , { 0x85C7 , 0x01 , 1 } , { 0x85CB , 0x01 , 1 } , } ; # define NUM_REGS_CMD ( sizeof ( cmds ) / sizeof ( cmds [ 0 ] ) ) write_regs ( fd , cmds , NUM_REGS_CMD ) ; { u8 edid [ 256 ] ; int i , j ; unsigned char checksum = 0 ; for ( i = 0 ; i < sizeof ( TOSHH2C_DEFAULT_EDID ) / 2 ; i += 16 ) { for ( j = 0 ; j < 15 ; j ++ ) { <S2SV_StartBug> edid [ i + j ] = ( ascii_to_hex ( TOSHH2C_DEFAULT_EDID [ i + j * 2 ] ) << 4 ) + <S2SV_EndBug> <S2SV_StartBug> ascii_to_hex ( TOSHH2C_DEFAULT_EDID [ i + j * 2 + 1 ] ) ; <S2SV_EndBug> checksum -= edid [ i + j ] ; } if ( i == ( 7 * 16 ) || i == ( 15 * 16 ) ) { edid [ i + 15 ] = checksum ; checksum = 0 ; } else { checksum -= edid [ i + 15 ] ; } i2c_wr ( fd , 0x8C00 + i , & edid [ i ] , 16 ) ; } } write_regs ( fd , cmds2 , NUM_REGS_CMD2 ) ; } | <S2SV_ModStart> ( TOSHH2C_DEFAULT_EDID [ ( <S2SV_ModStart> i + j ) <S2SV_ModStart> ( TOSHH2C_DEFAULT_EDID [ ( <S2SV_ModStart> i + j ) |
56 | CWE-000 void resize ( Client * c , int x , int y , int w , int h , Bool interact ) { int halfgap = windowgap / 2 ; <S2SV_StartBug> int nc = 0 ; <S2SV_EndBug> Client * cother ; Client * first = NULL ; <S2SV_StartBug> Bool changed = False ; <S2SV_EndBug> <S2SV_StartBug> for ( cother = c -> mon -> clients ; cother ; cother = cother -> next ) <S2SV_EndBug> if ( ISVISIBLE ( cother ) && ! cother -> nofocus ) { if ( first == NULL ) { first = cother ; if ( first -> bw != 0 ) { changed = True ; first -> bw = 0 ; } } else { if ( ! first -> noborder ) { if ( changed ) changed = False ; first -> bw = borderpx ; } if ( ! cother -> noborder && cother -> bw != borderpx ) { cother -> bw = borderpx ; changed = True ; } } ++ nc ; } if ( nc > 1 ) { x += halfgap ; y += halfgap ; w -= windowgap ; h -= windowgap ; } if ( changed ) arrange ( c -> mon ) ; else <S2SV_StartBug> resize_nogap ( c , x , y , w , h , interact ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; int nc <S2SV_ModEnd> ; Bool changed <S2SV_ModStart> Bool changed = updateborderwidth ( <S2SV_ModEnd> c -> mon <S2SV_ModStart> c -> mon , & nc ) ; <S2SV_ModEnd> if ( nc <S2SV_ModStart> ) ; else if ( applysizehints ( c , & x , & y , & w , & h , interact ) ) resizeclient <S2SV_ModEnd> ( c , <S2SV_ModStart> w , h <S2SV_ModEnd> ) ; } |
57 | CWE-000 static void test_getPathGradientPresetBlend ( ) { GpStatus status ; GpPathGradient * brush ; <S2SV_StartBug> ARGB blend [ 1 ] ; <S2SV_EndBug> <S2SV_StartBug> REAL positions [ 1 ] ; <S2SV_EndBug> <S2SV_StartBug> GdipCreatePathGradient ( threePoints , 3 , WrapModeTileFlipX , & brush ) ; <S2SV_EndBug> status = GdipGetPathGradientPresetBlend ( NULL , blend , positions , 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , NULL , positions , 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , NULL , 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , positions , 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , positions , 0 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , positions , - 1 ) ; assertEqualInt ( status , OutOfMemory ) ; status = GdipGetPathGradientPresetBlend ( NULL , blend , positions , - 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , NULL , positions , - 1 ) ; assertEqualInt ( status , InvalidParameter ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , NULL , - 1 ) ; assertEqualInt ( status , OutOfMemory ) ; GdipDeleteBrush ( ( GpBrush * ) brush ) ; } | <S2SV_ModStart> ARGB blend [ 2 <S2SV_ModEnd> ] ; REAL <S2SV_ModStart> REAL positions [ 2 <S2SV_ModEnd> ] ; GdipCreatePathGradient <S2SV_ModStart> , & brush ) ; status = GdipGetPathGradientPresetBlend ( brush , blend , positions , 2 ) ; assertEqualInt ( status , GenericError |
58 | CWE-000 static int ext4_tmpfile ( struct inode * dir , struct dentry * dentry , umode_t mode ) { handle_t * handle ; struct inode * inode ; int err , retries = 0 ; dquot_initialize ( dir ) ; retry : handle = ext4_journal_start ( dir , EXT4_MAXQUOTAS_INIT_BLOCKS ( dir -> i_sb ) + 4 + EXT4_XATTR_TRANS_BLOCKS ) ; if ( IS_ERR ( handle ) ) return PTR_ERR ( handle ) ; if ( IS_DIRSYNC ( dir ) ) ext4_handle_sync ( handle ) ; inode = ext4_new_inode ( handle , dir , mode , NULL , 0 , NULL ) ; err = PTR_ERR ( inode ) ; if ( ! IS_ERR ( inode ) ) { inode -> i_op = & ext4_file_inode_operations ; inode -> i_fop = & ext4_file_operations ; ext4_set_aops ( inode ) ; <S2SV_StartBug> err = ext4_orphan_add ( handle , inode ) ; <S2SV_EndBug> if ( err ) goto err_drop_inode ; <S2SV_StartBug> mark_inode_dirty ( inode ) ; <S2SV_EndBug> d_tmpfile ( dentry , inode ) ; unlock_new_inode ( inode ) ; } if ( handle ) ext4_journal_stop ( handle ) ; if ( err == - ENOSPC && ext4_should_retry_alloc ( dir -> i_sb , & retries ) ) goto retry ; return err ; err_drop_inode : ext4_journal_stop ( handle ) ; unlock_new_inode ( inode ) ; iput ( inode ) ; return err ; } | <S2SV_ModStart> inode ) ; d_tmpfile ( dentry , inode ) ; <S2SV_ModStart> ; mark_inode_dirty ( <S2SV_ModEnd> inode ) ; |
59 | CWE-000 int comp_regex ( char * string , char * reg ) { regex_t regex ; int err_reg = 0 ; err_reg = regcomp ( & regex , reg , REG_NOSUB | REG_EXTENDED | REG_NEWLINE ) ; if ( err_reg ) { err ( 1 , "Error<S2SV_blank>initialising<S2SV_blank>function<S2SV_blank>regex" ) ; } err_reg = regexec ( & regex , string , 0 , NULL , 0 ) ; <S2SV_StartBug> if ( ! err_reg ) <S2SV_EndBug> return 1 ; else if ( err_reg == REG_NOMATCH ) return 0 ; else err ( 1 , "Error<S2SV_blank>executing<S2SV_blank>function<S2SV_blank>regex" ) ; } | <S2SV_ModStart> 0 ) ; regfree ( & regex ) ; |
60 | CWE-000 static void prv_launch_exit_data_write ( DictionaryIterator * out ) { s_curr_time = time ( NULL ) ; <S2SV_StartBug> dict_write_int ( out , AppKeyLaunchReason , & e_launch_reason , sizeof ( int ) , true ) ; <S2SV_EndBug> <S2SV_StartBug> dict_write_int ( out , AppKeyLaunchTime , & e_launch_time , sizeof ( int ) , true ) ; <S2SV_EndBug> dict_write_int ( out , AppKeyExitReason , & e_exit_reason , sizeof ( int ) , true ) ; <S2SV_StartBug> dict_write_int ( out , AppKeyExitTime , & s_exit_time , sizeof ( int ) , true ) ; <S2SV_EndBug> <S2SV_StartBug> dict_write_int ( out , AppKeyDate , & s_curr_time , sizeof ( int ) , true ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( out , AppKeyDate , & s_curr_time <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> AppKeyLaunchTime , & s_t_launch <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> AppKeyExitTime , & s_t_exit <S2SV_ModEnd> , sizeof ( <S2SV_ModStart> true ) ; dict_write_uint8 <S2SV_ModEnd> ( out , <S2SV_ModStart> ( out , AppKeyLaunchReason , s_lr ) ; dict_write_uint8 ( out , AppKeyExitReason , s_er ) ; dict_write_cstring ( out , AppKeyRandomMessage , s_msg_id <S2SV_ModEnd> ) ; } |
61 | CWE-000 void nfc_ncif_proc_deactivate ( UINT8 status , UINT8 deact_type , BOOLEAN is_ntf ) { tNFC_DISCOVER evt_data ; tNFC_DEACTIVATE_DEVT * p_deact ; tNFC_CONN_CB * p_cb = & nfc_cb . conn_cb [ NFC_RF_CONN_ID ] ; void * p_data ; nfc_set_state ( NFC_STATE_IDLE ) ; p_deact = & evt_data . deactivate ; p_deact -> status = status ; p_deact -> type = deact_type ; p_deact -> is_ntf = is_ntf ; while ( ( p_data = GKI_dequeue ( & p_cb -> rx_q ) ) != NULL ) { GKI_freebuf ( p_data ) ; } while ( ( p_data = GKI_dequeue ( & p_cb -> tx_q ) ) != NULL ) { GKI_freebuf ( p_data ) ; } if ( p_cb -> p_cback ) ( * p_cb -> p_cback ) ( NFC_RF_CONN_ID , NFC_DEACTIVATE_CEVT , ( tNFC_CONN * ) p_deact ) ; <S2SV_StartBug> if ( nfc_cb . p_discv_cback ) <S2SV_EndBug> { ( * nfc_cb . p_discv_cback ) ( NFC_DEACTIVATE_DEVT , & evt_data ) ; } } | <S2SV_ModStart> ; if ( ( nfc_cb . flags & ( NFC_FL_DISCOVER_PENDING | NFC_FL_CONTROL_REQUESTED ) ) && ( deact_type == NFC_DEACTIVATE_TYPE_DISCOVERY ) && ( is_ntf == TRUE ) ) { NFC_TRACE_DEBUG0 ( "Abnormal<S2SV_blank>State,<S2SV_blank>Deactivate<S2SV_blank>NTF<S2SV_blank>is<S2SV_blank>ignored,<S2SV_blank>MW<S2SV_blank>is<S2SV_blank>already<S2SV_blank>going<S2SV_blank>to<S2SV_blank>Discovery<S2SV_blank>state" ) ; return ; } if ( |
62 | CWE-000 static int isert_connect_request ( struct rdma_cm_id * cma_id , struct rdma_cm_event * event ) { struct iscsi_np * np = cma_id -> context ; struct isert_np * isert_np = np -> np_context ; struct isert_conn * isert_conn ; struct isert_device * device ; struct ib_device * ib_dev = cma_id -> device ; int ret = 0 ; pr_debug ( "Entering<S2SV_blank>isert_connect_request<S2SV_blank>cma_id:<S2SV_blank>%p,<S2SV_blank>context:<S2SV_blank>%p\\n" , cma_id , cma_id -> context ) ; isert_conn = kzalloc ( sizeof ( struct isert_conn ) , GFP_KERNEL ) ; if ( ! isert_conn ) { pr_err ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>isert_conn\\n" ) ; return - ENOMEM ; } isert_conn -> state = ISER_CONN_INIT ; INIT_LIST_HEAD ( & isert_conn -> conn_accept_node ) ; init_completion ( & isert_conn -> conn_login_comp ) ; <S2SV_StartBug> init_waitqueue_head ( & isert_conn -> conn_wait ) ; <S2SV_EndBug> <S2SV_StartBug> init_waitqueue_head ( & isert_conn -> conn_wait_comp_err ) ; <S2SV_EndBug> kref_init ( & isert_conn -> conn_kref ) ; kref_get ( & isert_conn -> conn_kref ) ; mutex_init ( & isert_conn -> conn_mutex ) ; cma_id -> context = isert_conn ; isert_conn -> conn_cm_id = cma_id ; isert_conn -> responder_resources = event -> param . conn . responder_resources ; isert_conn -> initiator_depth = event -> param . conn . initiator_depth ; pr_debug ( "Using<S2SV_blank>responder_resources:<S2SV_blank>%u<S2SV_blank>initiator_depth:<S2SV_blank>%u\\n" , isert_conn -> responder_resources , isert_conn -> initiator_depth ) ; isert_conn -> login_buf = kzalloc ( ISCSI_DEF_MAX_RECV_SEG_LEN + ISER_RX_LOGIN_SIZE , GFP_KERNEL ) ; if ( ! isert_conn -> login_buf ) { pr_err ( "Unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>isert_conn->login_buf\\n" ) ; ret = - ENOMEM ; goto out ; } isert_conn -> login_req_buf = isert_conn -> login_buf ; isert_conn -> login_rsp_buf = isert_conn -> login_buf + ISCSI_DEF_MAX_RECV_SEG_LEN ; pr_debug ( "Set<S2SV_blank>login_buf:<S2SV_blank>%p<S2SV_blank>login_req_buf:<S2SV_blank>%p<S2SV_blank>login_rsp_buf:<S2SV_blank>%p\\n" , isert_conn -> login_buf , isert_conn -> login_req_buf , isert_conn -> login_rsp_buf ) ; isert_conn -> login_req_dma = ib_dma_map_single ( ib_dev , ( void * ) isert_conn -> login_req_buf , ISCSI_DEF_MAX_RECV_SEG_LEN , DMA_FROM_DEVICE ) ; ret = ib_dma_mapping_error ( ib_dev , isert_conn -> login_req_dma ) ; if ( ret ) { pr_err ( "ib_dma_mapping_error<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>login_req_dma:<S2SV_blank>%d\\n" , ret ) ; isert_conn -> login_req_dma = 0 ; goto out_login_buf ; } isert_conn -> login_rsp_dma = ib_dma_map_single ( ib_dev , ( void * ) isert_conn -> login_rsp_buf , ISER_RX_LOGIN_SIZE , DMA_TO_DEVICE ) ; ret = ib_dma_mapping_error ( ib_dev , isert_conn -> login_rsp_dma ) ; if ( ret ) { pr_err ( "ib_dma_mapping_error<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>login_rsp_dma:<S2SV_blank>%d\\n" , ret ) ; isert_conn -> login_rsp_dma = 0 ; goto out_req_dma_map ; } device = isert_device_find_by_ib_dev ( cma_id ) ; if ( IS_ERR ( device ) ) { ret = PTR_ERR ( device ) ; goto out_rsp_dma_map ; } isert_conn -> conn_device = device ; isert_conn -> conn_pd = device -> dev_pd ; isert_conn -> conn_mr = device -> dev_mr ; ret = isert_conn_setup_qp ( isert_conn , cma_id ) ; if ( ret ) goto out_conn_dev ; mutex_lock ( & isert_np -> np_accept_mutex ) ; list_add_tail ( & isert_np -> np_accept_list , & isert_conn -> conn_accept_node ) ; mutex_unlock ( & isert_np -> np_accept_mutex ) ; pr_debug ( "isert_connect_request()<S2SV_blank>waking<S2SV_blank>up<S2SV_blank>np_accept_wq:<S2SV_blank>%p\\n" , np ) ; wake_up ( & isert_np -> np_accept_wq ) ; return 0 ; out_conn_dev : isert_device_try_release ( device ) ; out_rsp_dma_map : ib_dma_unmap_single ( ib_dev , isert_conn -> login_rsp_dma , ISER_RX_LOGIN_SIZE , DMA_TO_DEVICE ) ; out_req_dma_map : ib_dma_unmap_single ( ib_dev , isert_conn -> login_req_dma , ISCSI_DEF_MAX_RECV_SEG_LEN , DMA_FROM_DEVICE ) ; out_login_buf : kfree ( isert_conn -> login_buf ) ; out : kfree ( isert_conn ) ; return ret ; } | <S2SV_ModStart> conn_login_comp ) ; init_completion <S2SV_ModEnd> ( & isert_conn <S2SV_ModStart> conn_wait ) ; init_completion <S2SV_ModEnd> ( & isert_conn |
63 | CWE-000 static inline gint process_one_element_last_access ( cache_line * cp , GHashTable * hash_table , guint64 ts ) { gpointer gp ; gp = g_hash_table_lookup ( hash_table , cp -> item ) ; gint ret ; if ( gp == NULL ) { ret = - 1 ; guint64 * value = g_new ( guint64 , 1 ) ; * value = ts ; if ( cp -> type == 'c' ) g_hash_table_insert ( hash_table , g_strdup ( ( gchar * ) ( cp -> item_p ) ) , ( gpointer ) value ) ; else if ( cp -> type == 'l' ) { guint64 * key = g_new ( guint64 , 1 ) ; * key = * ( guint64 * ) ( cp -> item_p ) ; g_hash_table_insert ( hash_table , ( gpointer ) ( key ) , ( gpointer ) value ) ; } else { printf ( "unknown<S2SV_blank>cache<S2SV_blank>line<S2SV_blank>content<S2SV_blank>type:<S2SV_blank>%c\\n" , cp -> type ) ; exit ( 1 ) ; } } else { guint64 old_ts = * ( guint64 * ) gp ; ret = ( gint ) ( ts - old_ts ) ; <S2SV_StartBug> * ( guint64 * ) gp = cp -> ts ; <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> ) gp = <S2SV_ModEnd> ts ; } |
64 | CWE-000 int main ( int argc , char * argv [ ] ) { int i , flag = 0 ; if ( argc < 2 ) { printf ( 2 , "Usage:<S2SV_blank>rm<S2SV_blank>files...\\n" ) ; exit ( ) ; } for ( i = 1 ; i < argc ; i ++ ) { flag = unlink ( argv [ i ] ) ; if ( flag < 0 ) { if ( flag == - 2 ) <S2SV_StartBug> printf ( 2 , "rm:<S2SV_blank>premission<S2SV_blank>deny\\n" ) ; <S2SV_EndBug> else if ( flag != - 2 ) printf ( 2 , "rm:<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>delete\\n" , argv [ i ] ) ; break ; } else printf ( 2 , "rm<S2SV_blank>sucess\\n" ) ; } exit ( ) ; } | <S2SV_ModStart> ( 2 , "rm:<S2SV_blank>permission<S2SV_blank>deny\\n" <S2SV_ModEnd> ) ; else |
65 | CWE-000 static void init ( ) { <S2SV_StartBug> unhook ++ ; <S2SV_EndBug> <S2SV_StartBug> libc . malloc = dlsym ( RTLD_NEXT , "malloc" ) ; <S2SV_EndBug> <S2SV_StartBug> libc . calloc = dlsym ( RTLD_NEXT , "calloc" ) ; <S2SV_EndBug> <S2SV_StartBug> libc . realloc = dlsym ( RTLD_NEXT , "realloc" ) ; <S2SV_EndBug> <S2SV_StartBug> libc . memalign = dlsym ( RTLD_NEXT , "memalign" ) ; <S2SV_EndBug> <S2SV_StartBug> libc . free = dlsym ( RTLD_NEXT , "free" ) ; <S2SV_EndBug> unhook -- ; if ( ! libc . malloc || ! libc . realloc || ! libc . free || ! libc . calloc || ! libc . memalign ) fail ( "%s:<S2SV_blank>dyld<S2SV_blank>error:<S2SV_blank>%s\\n" , __FUNCTION__ , dlerror ( ) ) ; <S2SV_StartBug> atexit ( memstat_atexit ) ; <S2SV_EndBug> mjfilter_add ( & memlimit ) ; mjtrace_add ( & memstat ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { void * handle ; if ( unhook ) return ; unhook ++ ; handle = dlopen ( LIBC_SO , RTLD_NOW ) <S2SV_ModEnd> ; libc . <S2SV_ModStart> = dlsym ( handle <S2SV_ModEnd> , "malloc" ) <S2SV_ModStart> = dlsym ( handle <S2SV_ModEnd> , "calloc" ) <S2SV_ModStart> = dlsym ( handle <S2SV_ModEnd> , "realloc" ) <S2SV_ModStart> = dlsym ( handle <S2SV_ModEnd> , "memalign" ) <S2SV_ModStart> = dlsym ( handle , "free" ) ; dlclose ( handle <S2SV_ModEnd> ) ; unhook <S2SV_ModStart> ) ) ; <S2SV_ModEnd> mjfilter_add ( & <S2SV_ModStart> memstat ) ; atexit ( memstat_atexit ) ; |
66 | CWE-000 void games_expose_bots ( MFD * m , uchar control ) { bots_state * bs = ( bots_state * ) GAME_DATA ; uiEvent fake_event ; int i , j ; # ifdef SVGA_SUPPORT extern char convert_use_mode ; # endif for ( ; games_time_diff >= PONG_CYCLE ; games_time_diff -= PONG_CYCLE ) { games_run_bots ( bs ) ; ui_mouse_get_xy ( & fake_event . pos . x , & fake_event . pos . y ) ; games_handle_pong ( m , & fake_event ) ; } if ( ! full_game_3d ) <S2SV_StartBug> draw_hires_resource_bm ( REF_IMG_bmBlankMFD , 0 , 0 ) ; <S2SV_EndBug> for ( j = 0 ; j < BOTS_NUM_ROWS ; ++ j ) { gr_set_fcolor ( WHITE ) ; for ( i = 0 ; i < BOTS_NUM_COLUMNS ; ++ i ) { if ( bs -> rows [ j ] & ( 1 << i ) ) { # ifdef SVGA_SUPPORT draw_res_bm_core ( invader [ j ] + INVADER_TYPES * convert_use_mode , HPOS + BOT_WIDTH * i , BOT_HEIGHT * j + BOT_TOP - ( j == 1 ) , FALSE ) ; # else draw_res_bm ( invader [ j ] , HPOS + BOT_WIDTH * i , BOT_HEIGHT * j + BOT_TOP - ( j == 1 ) ) ; # endif } } } gr_set_fcolor ( ORANGE_YELLOW_BASE ) ; ss_rect ( bs -> p_pos - PLY_PADDLE_XRAD , MFD_VIEW_HGT - PONG_BORDER - PLY_PADDLE_YRAD * 2 , bs -> p_pos + PLY_PADDLE_XRAD , MFD_VIEW_HGT - PONG_BORDER ) ; gr_set_fcolor ( GRAY_8_BASE ) ; ss_rect ( bs -> ball_pos_x - PONG_BALL_XRAD , bs -> ball_pos_y - PONG_BALL_YRAD , bs -> ball_pos_x + PONG_BALL_XRAD , bs -> ball_pos_y + PONG_BALL_YRAD ) ; mfd_add_rect ( 0 , 0 , MFD_VIEW_WID , MFD_VIEW_HGT ) ; mfd_notify_func ( MFD_GAMES_FUNC , MFD_INFO_SLOT , FALSE , MFD_ACTIVE , FALSE ) ; return ; } | <S2SV_ModStart> ! full_game_3d ) draw_res_bm <S2SV_ModEnd> ( REF_IMG_bmBlankMFD , |
67 | CWE-000 static inline int __mr_cache_entry_put ( gnix_mr_cache_t * cache , gnix_mr_cache_entry_t * entry ) { RbtIterator iter ; int rc ; gni_return_t grc = GNI_RC_SUCCESS ; RbtIterator found ; gnix_mr_cache_entry_t * parent = NULL ; struct dlist_entry * next ; GNIX_TRACE ( FI_LOG_MR , "\\n" ) ; if ( cache -> attr . lazy_deregistration ) { __clear_notifier_events ( cache ) ; } <S2SV_StartBug> if ( ofi_atomic_dec32 ( & entry -> ref_cnt ) == 0 ) { <S2SV_EndBug> next = entry -> siblings . next ; dlist_remove ( & entry -> children ) ; dlist_remove ( & entry -> siblings ) ; if ( next != & entry -> siblings && dlist_empty ( next ) ) { parent = container_of ( next , gnix_mr_cache_entry_t , children ) ; grc = __mr_cache_entry_put ( cache , parent ) ; if ( OFI_UNLIKELY ( grc != GNI_RC_SUCCESS ) ) { GNIX_ERR ( FI_LOG_MR , "failed<S2SV_blank>to<S2SV_blank>release<S2SV_blank>reference<S2SV_blank>to<S2SV_blank>parent,<S2SV_blank>" "parent=%p<S2SV_blank>refs=%d\\n" , parent , ofi_atomic_get32 ( & parent -> ref_cnt ) ) ; } } ofi_atomic_dec32 ( & cache -> inuse . elements ) ; if ( ! __entry_is_retired ( entry ) ) { iter = rbtFind ( cache -> inuse . rb_tree , & entry -> key ) ; if ( OFI_UNLIKELY ( ! iter ) ) { GNIX_ERR ( FI_LOG_MR , "failed<S2SV_blank>to<S2SV_blank>find<S2SV_blank>entry<S2SV_blank>in<S2SV_blank>the<S2SV_blank>inuse<S2SV_blank>cache\\n" ) ; } else { rc = rbtErase ( cache -> inuse . rb_tree , iter ) ; if ( OFI_UNLIKELY ( rc != RBT_STATUS_OK ) ) { GNIX_ERR ( FI_LOG_MR , "failed<S2SV_blank>to<S2SV_blank>erase<S2SV_blank>lru<S2SV_blank>entry" "<S2SV_blank>from<S2SV_blank>stale<S2SV_blank>tree\\n" ) ; } } } if ( cache -> attr . lazy_deregistration && ! ( __entry_is_retired ( entry ) ) ) { GNIX_DEBUG ( FI_LOG_MR , "moving<S2SV_blank>key<S2SV_blank>%llx:%llx<S2SV_blank>to<S2SV_blank>stale\\n" , entry -> key . address , entry -> key . length ) ; found = rbtFindLeftmost ( cache -> stale . rb_tree , & entry -> key , __find_overlapping_addr ) ; if ( found ) { __resolve_stale_entry_collision ( cache , found , entry ) ; } else { grc = __insert_entry_into_stale ( cache , entry ) ; } } else { GNIX_DEBUG ( FI_LOG_MR , "destroying<S2SV_blank>entry,<S2SV_blank>key=%llx:%llx\\n" , entry -> key . address , entry -> key . length ) ; grc = __mr_cache_entry_destroy ( cache , entry ) ; } if ( OFI_UNLIKELY ( grc != GNI_RC_SUCCESS ) ) { GNIX_INFO ( FI_LOG_MR , "dereg<S2SV_blank>callback<S2SV_blank>returned<S2SV_blank>\'%s\'\\n" , gni_err_str [ grc ] ) ; } } return grc ; } | <S2SV_ModStart> ) ; } GNIX_DEBUG ( FI_LOG_MR , "Decrease<S2SV_blank>ref<S2SV_blank>cnt<S2SV_blank>on<S2SV_blank>entry<S2SV_blank>%p\\n" , entry ) ; |
68 | CWE-000 static void zdb_leak_init ( spa_t * spa , zdb_cb_t * zcb ) { zcb -> zcb_spa = spa ; uint64_t c , m ; if ( ! dump_opt [ 'L' ] ) { vdev_t * rvd = spa -> spa_root_vdev ; spa -> spa_normal_class -> mc_ops = & zdb_metaslab_ops ; spa -> spa_log_class -> mc_ops = & zdb_metaslab_ops ; for ( c = 0 ; c < rvd -> vdev_children ; c ++ ) { vdev_t * vd = rvd -> vdev_child [ c ] ; ASSERTV ( metaslab_group_t * mg = vd -> vdev_mg ) ; for ( m = 0 ; m < vd -> vdev_ms_count ; m ++ ) { metaslab_t * msp = vd -> vdev_ms [ m ] ; <S2SV_StartBug> ASSERT3P ( msp -> ms_group , == , mg ) ; <S2SV_EndBug> mutex_enter ( & msp -> ms_lock ) ; metaslab_unload ( msp ) ; if ( msp -> ms_sm != NULL ) { ( void ) fprintf ( stderr , "\\rloading<S2SV_blank>space<S2SV_blank>map<S2SV_blank>for<S2SV_blank>" "vdev<S2SV_blank>%llu<S2SV_blank>of<S2SV_blank>%llu,<S2SV_blank>" "metaslab<S2SV_blank>%llu<S2SV_blank>of<S2SV_blank>%llu<S2SV_blank>..." , ( longlong_t ) c , ( longlong_t ) rvd -> vdev_children , ( longlong_t ) m , ( longlong_t ) vd -> vdev_ms_count ) ; msp -> ms_tree -> rt_ops = NULL ; VERIFY0 ( space_map_load ( msp -> ms_sm , msp -> ms_tree , SM_ALLOC ) ) ; if ( ! msp -> ms_loaded ) msp -> ms_loaded = B_TRUE ; } mutex_exit ( & msp -> ms_lock ) ; } } ( void ) fprintf ( stderr , "\\n" ) ; } spa_config_enter ( spa , SCL_CONFIG , FTAG , RW_READER ) ; zdb_ddt_leak_init ( spa , zcb ) ; spa_config_exit ( spa , SCL_CONFIG , FTAG ) ; } | <S2SV_ModStart> m ] ; ASSERT <S2SV_ModEnd> ( msp -> <S2SV_ModStart> msp -> ms_group == mg || vd -> vdev_alloc_bias == VDEV_BIAS_SEGREGATE <S2SV_ModEnd> ) ; mutex_enter |
69 | CWE-000 Scheme_Object * optimize_for_inline ( Optimize_Info * info , Scheme_Object * le , int argc , Scheme_App_Rec * app , Scheme_App2_Rec * app2 , Scheme_App3_Rec * app3 , int context , int optimized_rator ) { int single_use = 0 , psize = 0 ; <S2SV_StartBug> Scheme_Object * prev = NULL , * orig_le = le , * le2 ; <S2SV_EndBug> int already_opt = optimized_rator ; if ( ( info -> inline_fuel < 0 ) && info -> has_nonleaf ) return NULL ; if ( already_opt ) extract_tail_inside ( & le , & prev ) ; le = extract_specialized_proc ( le , le ) ; if ( ! already_opt && SCHEME_LAMBDAP ( le ) ) { return NULL ; } le2 = le ; <S2SV_StartBug> le = do_lookup_constant_proc ( info , le , argc , 1 , 0 , & single_use ) ; <S2SV_EndBug> if ( ! le ) { info -> has_nonleaf = 1 ; return NULL ; } if ( SCHEME_WILL_BE_LAMBDAP ( le ) ) { psize = SCHEME_WILL_BE_LAMBDA_SIZE ( le ) ; LOG_INLINE ( fprintf ( stderr , "Potential<S2SV_blank>inline<S2SV_blank>%d<S2SV_blank>%d\\n" , psize , info -> inline_fuel * ( argc + 2 ) ) ) ; if ( psize <= ( info -> inline_fuel * ( argc + 2 ) ) ) info -> psize += psize ; info -> has_nonleaf = 1 ; return NULL ; } if ( SAME_OBJ ( le , scheme_true ) ) { int len ; const char * pname = NULL , * context ; info -> escapes = 1 ; <S2SV_StartBug> le2 = do_lookup_constant_proc ( info , le2 , argc , 1 , 1 , & single_use ) ; <S2SV_EndBug> if ( ! SAME_TYPE ( SCHEME_TYPE ( le2 ) , scheme_struct_proc_shape_type ) && ! SAME_TYPE ( SCHEME_TYPE ( le2 ) , scheme_struct_prop_proc_shape_type ) ) { pname = scheme_get_proc_name ( le2 , & len , 0 ) ; } context = scheme_optimize_context_to_string ( info -> context ) ; scheme_log ( info -> logger , SCHEME_LOG_WARNING , 0 , "warning%s:<S2SV_blank>optimizer<S2SV_blank>detects<S2SV_blank>procedure<S2SV_blank>incorrectly<S2SV_blank>applied<S2SV_blank>to<S2SV_blank>%d<S2SV_blank>arguments%s%s" , context , argc , pname ? ":<S2SV_blank>" : "" , pname ? pname : "" ) ; return NULL ; } if ( SAME_TYPE ( SCHEME_TYPE ( le ) , scheme_ir_lambda_type ) && ( info -> inline_fuel >= 0 ) ) { Scheme_Lambda * lam = ( Scheme_Lambda * ) le ; int sz , threshold , is_leaf = 0 ; sz = lambda_body_size_plus_info ( lam , 1 , info , & is_leaf ) ; if ( is_leaf ) { sz >>= 2 ; } threshold = info -> inline_fuel * ( 2 + argc ) ; if ( ( sz >= 0 ) && ( single_use || ( sz <= threshold ) ) ) { Optimize_Info * sub_info ; sub_info = info ; le = optimize_clone ( single_use , ( Scheme_Object * ) lam , sub_info , empty_eq_hash_tree , 0 ) ; if ( le ) { LOG_INLINE ( fprintf ( stderr , "Inline<S2SV_blank>%d[%d]<=%d@%d<S2SV_blank>%d<S2SV_blank>%s\\n" , sz , is_leaf , threshold , info -> inline_fuel , single_use , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) ) ) ; if ( scheme_log_level_p ( info -> logger , SCHEME_LOG_DEBUG ) ) scheme_log ( info -> logger , SCHEME_LOG_DEBUG , 0 , "inlining<S2SV_blank>%s<S2SV_blank>size:<S2SV_blank>%d<S2SV_blank>threshold:<S2SV_blank>%d#<separator>%s" , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) , sz , threshold , scheme_optimize_context_to_string ( info -> context ) ) ; <S2SV_StartBug> le = apply_inlined ( ( Scheme_Lambda * ) le , sub_info , argc , app , app2 , app3 , context , <S2SV_EndBug> orig_le , prev , single_use ) ; return le ; } else { LOG_INLINE ( fprintf ( stderr , "No<S2SV_blank>inline<S2SV_blank>%s\\n" , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) ) ) ; if ( scheme_log_level_p ( info -> logger , SCHEME_LOG_DEBUG ) ) scheme_log ( info -> logger , SCHEME_LOG_DEBUG , 0 , "no-inlining<S2SV_blank>%s<S2SV_blank>size:<S2SV_blank>%d<S2SV_blank>threshold:<S2SV_blank>%d#<separator>%s" , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) , sz , threshold , scheme_optimize_context_to_string ( info -> context ) ) ; } } else { LOG_INLINE ( fprintf ( stderr , "No<S2SV_blank>fuel<S2SV_blank>%s<S2SV_blank>%d[%d]>%d@%d<S2SV_blank>%d\\n" , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) , sz , is_leaf , threshold , info -> inline_fuel , info -> use_psize ) ) ; if ( scheme_log_level_p ( info -> logger , SCHEME_LOG_DEBUG ) ) scheme_log ( info -> logger , SCHEME_LOG_DEBUG , 0 , "out-of-fuel<S2SV_blank>%s<S2SV_blank>size:<S2SV_blank>%d<S2SV_blank>threshold:<S2SV_blank>%d#<separator>%s" , scheme_write_to_string ( lam -> name ? lam -> name : scheme_false , NULL ) , sz , threshold , scheme_optimize_context_to_string ( info -> context ) ) ; } } if ( ! scheme_check_leaf_rator ( le ) ) info -> has_nonleaf = 1 ; return NULL ; } | <S2SV_ModStart> , * le2 , * single_use_var = NULL <S2SV_ModStart> , & single_use , & single_use_var <S2SV_ModStart> , & single_use , & single_use_var <S2SV_ModStart> ) ) ; if ( single_use_var ) SCHEME_VAR ( single_use_var ) -> optimize_used = 0 ; |
70 | CWE-000 void initGame ( XStuff * xs , GameState * gs ) { int ww , wh ; srand ( ( unsigned int ) time ( NULL ) ) ; json_gl_init_lookup ( ) ; glerr ( "left<S2SV_blank>over<S2SV_blank>error<S2SV_blank>on<S2SV_blank>game<S2SV_blank>init" ) ; # ifndef DISABLE_SOUND gs -> sound = SoundManager_alloc ( ) ; SoundManager_readConfigFile ( gs -> sound , "assets/config/sound.json" ) ; SoundManager_start ( gs -> sound ) ; # endif struct { char * name ; size_t size ; } defaultComponents [ ] = { { "meshIndex" , sizeof ( uint16_t ) } , { "position" , sizeof ( Vector ) } , { "rotation" , sizeof ( C_Rotation ) } , { "mapHeightUpdate" , sizeof ( uint8_t ) } , { "angularVelocity" , sizeof ( float ) } , { "pathFollow" , sizeof ( C_PathFollow ) } , { 0 , 0 } , } ; CES_init ( & gs -> ces ) ; for ( int i = 0 ; defaultComponents [ i ] . name != NULL ; i ++ ) { CES_addComponentManager ( & gs -> ces , ComponentManager_alloc ( defaultComponents [ i ] . name , defaultComponents [ i ] . size , 1024 * 8 , 1 ) ) ; } json_file_t * j_ces_conf = json_load_path ( "assets/config/CES.json" ) ; ComponentManager_loadConfig ( & gs -> ces , j_ces_conf -> root ) ; json_free ( j_ces_conf -> root ) ; free ( j_ces_conf ) ; waterProg = loadCombinedProgram ( "mg_water" ) ; erodeProg = loadCombinedProgram ( "mg_erode" ) ; soilProg = loadCombinedProgram ( "mg_soil" ) ; gs -> hasMoved = 1 ; gs -> lastSelectionFrame = 0 ; gs -> frameCount = 0 ; gs -> activeTool = 0 ; gs -> debugMode = 0 ; gs -> sunSpeed = 0 ; gs -> sunTheta = 2.2 ; gs -> nearClipPlane = .5 ; gs -> farClipPlane = 1700 ; ww = xs -> winAttr . width ; wh = xs -> winAttr . height ; gs -> screen . wh . x = ( float ) ww ; gs -> screen . wh . y = ( float ) wh ; gs -> screen . aspect = gs -> screen . wh . x / gs -> screen . wh . y ; gs -> screen . resized = 0 ; gs -> defaultInputHandlers = calloc ( 1 , sizeof ( * gs -> defaultInputHandlers ) ) ; gs -> defaultInputHandlers -> dragStop = main_drag_handler ; gs -> defaultInputHandlers -> keyUp = main_key_handler ; gs -> defaultInputHandlers -> perFrame = main_perframe_handler ; gs -> defaultInputHandlers -> click = main_click_handler ; InputFocusStack_PushTarget ( & gs -> ifs , gs , defaultInputHandlers ) ; initUniformBuffers ( ) ; uniformBuffer_init ( & gs -> perViewUB , sizeof ( PerViewUniforms ) ) ; uniformBuffer_init ( & gs -> perFrameUB , sizeof ( PerFrameUniforms ) ) ; initRenderLoop ( gs ) ; initRenderPipeline ( ) ; MatrixStack * view , * proj ; view = & gs -> view ; proj = & gs -> proj ; msAlloc ( 2 , view ) ; msAlloc ( 2 , proj ) ; msIdent ( view ) ; msIdent ( proj ) ; gs -> zoom = - 600.0 ; gs -> direction = 0.0f ; gs -> lookCenter . x = 128 ; gs -> lookCenter . y = 128 ; initTextures ( ) ; initStaticMeshes ( ) ; initDynamicMeshes ( ) ; initLighting ( ) ; initWaterPlane ( ) ; initDecals ( ) ; initCustomDecals ( ) ; Scene_init ( & gs -> scene ) ; gui_Init ( ) ; gt = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.01 } , 4.0f , "Arial" ) ; gt_terrain = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.04 } , 3.0f , "Arial" ) ; gt_solids = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.06 } , 3.0f , "Arial" ) ; gt_selection = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.28 } , 3.0f , "Arial" ) ; gt_decals = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.08 } , 3.0f , "Arial" ) ; gt_emitters = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.10 } , 3.0f , "Arial" ) ; gt_effects = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.10 } , 3.0f , "Arial" ) ; gt_lighting = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.12 } , 3.0f , "Arial" ) ; <S2SV_StartBug> gt_shading = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.14 } , 3.0f , "Arial" ) ; <S2SV_EndBug> gt_gui = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.16 } , 3.0f , "Arial" ) ; gtRenderMode = guiTextNew ( "" , ( Vector2 ) { 0.1 , 0.9 } , 6.0f , "Arial" ) ; gtSelectionDisabled = guiTextNew ( "" , ( Vector2 ) { 0.5 , 0.1 } , 6.0f , "Arial" ) ; gswTest = guiSimpleWindowNew ( ( Vector2 ) { .2 , .2 } , ( Vector2 ) { .7 , .7 } , 0 ) ; gclTest = guiColumnLayoutNew ( ( Vector2 ) { .01 , .01 } , .02 , 0 ) ; guiRegisterObject ( gclTest , NULL ) ; guiRegisterObject ( gt_terrain , gclTest ) ; guiRegisterObject ( gt_solids , gclTest ) ; guiRegisterObject ( gt_decals , gclTest ) ; <S2SV_StartBug> guiRegisterObject ( gt_emitters , gclTest ) ; <S2SV_EndBug> <S2SV_StartBug> guiRegisterObject ( gt_effects , gclTest ) ; <S2SV_EndBug> <S2SV_StartBug> guiRegisterObject ( gt_lighting , gclTest ) ; <S2SV_EndBug> guiRegisterObject ( gt_shading , gclTest ) ; guiRegisterObject ( gt_gui , gclTest ) ; guiRegisterObject ( gtRenderMode , NULL ) ; guiRegisterObject ( gtSelectionDisabled , NULL ) ; gs -> world = calloc ( 1 , sizeof ( * gs -> world ) ) ; gs -> world -> gs = gs ; World_init ( gs -> world ) ; } | <S2SV_ModStart> "Arial" ) ; gt_sunShadow = guiTextNew ( "gui!" , ( Vector2 ) { 0.010 , 0.14 } , 3.0f , "Arial" ) ; <S2SV_ModStart> ; guiRegisterObject ( gt_effects <S2SV_ModEnd> , gclTest ) <S2SV_ModStart> ; guiRegisterObject ( gt_lighting <S2SV_ModEnd> , gclTest ) <S2SV_ModStart> ; guiRegisterObject ( gt_sunShadow <S2SV_ModEnd> , gclTest ) |
71 | CWE-000 int32_t mz_zip_time_t_to_tm ( time_t unix_time , struct tm * ptm ) { struct tm * ltm = NULL ; if ( ptm == NULL ) return MZ_PARAM_ERROR ; ltm = localtime ( & unix_time ) ; if ( ltm == NULL ) <S2SV_StartBug> return MZ_INTERNAL_ERROR ; <S2SV_EndBug> memcpy ( ptm , ltm , sizeof ( struct tm ) ) ; return MZ_OK ; } | <S2SV_ModStart> == NULL ) { memset ( ptm , 0 , sizeof ( struct tm ) ) ; <S2SV_ModStart> return MZ_INTERNAL_ERROR ; } |
72 | CWE-000 int xbf_init ( struct xbf_softc * sc ) { unsigned long long res ; const char * action , * prop ; char pbuf [ sizeof ( "ring-refXX" ) ] ; int i , error ; prop = "max-ring-page-order" ; error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ; if ( error == 0 ) sc -> sc_xr_size = 1 << res ; if ( error == ENOENT ) { prop = "max-ring-pages" ; error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ; if ( error == 0 ) sc -> sc_xr_size = res ; } if ( error ) sc -> sc_xr_size = XBF_MIN_RING_SIZE ; if ( sc -> sc_xr_size < XBF_MIN_RING_SIZE ) sc -> sc_xr_size = XBF_MIN_RING_SIZE ; if ( sc -> sc_xr_size > XBF_MAX_RING_SIZE ) sc -> sc_xr_size = XBF_MAX_RING_SIZE ; if ( ! powerof2 ( sc -> sc_xr_size ) ) sc -> sc_xr_size = 1 << ( fls ( sc -> sc_xr_size ) - 1 ) ; sc -> sc_xr_ndesc = ( ( sc -> sc_xr_size * PAGE_SIZE ) - sizeof ( struct xbf_ring ) ) / sizeof ( union xbf_ring_desc ) ; if ( ! powerof2 ( sc -> sc_xr_ndesc ) ) sc -> sc_xr_ndesc = 1 << ( fls ( sc -> sc_xr_ndesc ) - 1 ) ; if ( sc -> sc_xr_ndesc > XBF_MAX_REQS ) sc -> sc_xr_ndesc = XBF_MAX_REQS ; DPRINTF ( "%s:<S2SV_blank>%u<S2SV_blank>ring<S2SV_blank>pages,<S2SV_blank>%u<S2SV_blank>requests\\n" , sc -> sc_dev . dv_xname , sc -> sc_xr_size , sc -> sc_xr_ndesc ) ; if ( xbf_ring_create ( sc ) ) return ( - 1 ) ; action = "set" ; for ( i = 0 ; i < sc -> sc_xr_size ; i ++ ) { if ( i == 0 && sc -> sc_xr_size == 1 ) snprintf ( pbuf , sizeof ( pbuf ) , "ring-ref" ) ; else <S2SV_StartBug> snprintf ( pbuf , sizeof ( pbuf ) , "ring-ref%u" , i ) ; <S2SV_EndBug> prop = pbuf ; if ( xs_setnum ( sc -> sc_parent , sc -> sc_node , prop , sc -> sc_xr_ref [ i ] ) ) goto errout ; } if ( sc -> sc_xr_size > 1 ) { prop = "num-ring-pages" ; if ( xs_setnum ( sc -> sc_parent , sc -> sc_node , prop , sc -> sc_xr_size ) ) goto errout ; prop = "ring-page-order" ; if ( xs_setnum ( sc -> sc_parent , sc -> sc_node , prop , fls ( sc -> sc_xr_size ) - 1 ) ) goto errout ; } prop = "event-channel" ; if ( xs_setnum ( sc -> sc_parent , sc -> sc_node , prop , sc -> sc_xih ) ) goto errout ; prop = "protocol" ; # ifdef __amd64__ if ( xs_setprop ( sc -> sc_parent , sc -> sc_node , prop , "x86_64-abi" , strlen ( "x86_64-abi" ) ) ) goto errout ; # else if ( xs_setprop ( sc -> sc_parent , sc -> sc_node , prop , "x86_32-abi" , strlen ( "x86_32-abi" ) ) ) goto errout ; # endif if ( xs_setprop ( sc -> sc_parent , sc -> sc_node , "state" , XEN_STATE_INITIALIZED , strlen ( XEN_STATE_INITIALIZED ) ) ) { printf ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>state<S2SV_blank>to<S2SV_blank>INITIALIZED\\n" , sc -> sc_dev . dv_xname ) ; xbf_ring_destroy ( sc ) ; return ( - 1 ) ; } if ( xs_await_transition ( sc -> sc_parent , sc -> sc_backend , "state" , XEN_STATE_CONNECTED , 10000 ) ) { printf ( "%s:<S2SV_blank>timed<S2SV_blank>out<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>backend<S2SV_blank>to<S2SV_blank>connect\\n" , sc -> sc_dev . dv_xname ) ; xbf_ring_destroy ( sc ) ; return ( - 1 ) ; } action = "read" ; prop = "sectors" ; if ( ( error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ) != 0 ) goto errout ; sc -> sc_disk_size = res ; prop = "sector-size" ; if ( ( error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ) != 0 ) goto errout ; sc -> sc_block_size = res ; prop = "feature-barrier" ; if ( ( error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ) != 0 && error != ENOENT ) goto errout ; if ( error == 0 && res == 1 ) sc -> sc_caps |= XBF_CAP_BARRIER ; prop = "feature-flush-cache" ; if ( ( error = xs_getnum ( sc -> sc_parent , sc -> sc_backend , prop , & res ) ) != 0 && error != ENOENT ) goto errout ; if ( error == 0 && res == 1 ) sc -> sc_caps |= XBF_CAP_FLUSH ; # ifdef XBF_DEBUG if ( sc -> sc_caps ) { printf ( "%s:<S2SV_blank>features:" , sc -> sc_dev . dv_xname ) ; if ( sc -> sc_caps & XBF_CAP_BARRIER ) printf ( "<S2SV_blank>BARRIER" ) ; if ( sc -> sc_caps & XBF_CAP_FLUSH ) printf ( "<S2SV_blank>FLUSH" ) ; printf ( "\\n" ) ; } # endif if ( xs_setprop ( sc -> sc_parent , sc -> sc_node , "state" , XEN_STATE_CONNECTED , strlen ( XEN_STATE_CONNECTED ) ) ) { printf ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>state<S2SV_blank>to<S2SV_blank>CONNECTED\\n" , sc -> sc_dev . dv_xname ) ; return ( - 1 ) ; } sc -> sc_state = XBF_CONNECTED ; return ( 0 ) ; errout : printf ( "%s:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>\\"%s\\"<S2SV_blank>property<S2SV_blank>(%d)\\n" , sc -> sc_dev . dv_xname , action , prop , error ) ; xbf_ring_destroy ( sc ) ; return ( - 1 ) ; } | <S2SV_ModStart> pbuf ) , "ring-ref%d" <S2SV_ModEnd> , i ) |
73 | CWE-000 static int read_request ( int fd , debugger_request_t * out_request ) { struct ucred cr ; int len = sizeof ( cr ) ; int status = getsockopt ( fd , SOL_SOCKET , SO_PEERCRED , & cr , & len ) ; if ( status != 0 ) { LOG ( "cannot<S2SV_blank>get<S2SV_blank>credentials\\n" ) ; return - 1 ; } XLOG ( "reading<S2SV_blank>tid\\n" ) ; fcntl ( fd , F_SETFL , O_NONBLOCK ) ; struct pollfd pollfds [ 1 ] ; pollfds [ 0 ] . fd = fd ; pollfds [ 0 ] . events = POLLIN ; pollfds [ 0 ] . revents = 0 ; status = TEMP_FAILURE_RETRY ( poll ( pollfds , 1 , 3000 ) ) ; if ( status != 1 ) { LOG ( "timed<S2SV_blank>out<S2SV_blank>reading<S2SV_blank>tid<S2SV_blank>(from<S2SV_blank>pid=%d<S2SV_blank>uid=%d)\\n" , cr . pid , cr . uid ) ; return - 1 ; } debugger_msg_t msg ; memset ( & msg , 0 , sizeof ( msg ) ) ; status = TEMP_FAILURE_RETRY ( read ( fd , & msg , sizeof ( msg ) ) ) ; if ( status < 0 ) { LOG ( "read<S2SV_blank>failure?<S2SV_blank>%s<S2SV_blank>(pid=%d<S2SV_blank>uid=%d)\\n" , strerror ( errno ) , cr . pid , cr . uid ) ; return - 1 ; } if ( status == sizeof ( debugger_msg_t ) ) { XLOG ( "crash<S2SV_blank>request<S2SV_blank>of<S2SV_blank>size<S2SV_blank>%d<S2SV_blank>abort_msg_address=%#08x\\n" , status , msg . abort_msg_address ) ; } else { LOG ( "invalid<S2SV_blank>crash<S2SV_blank>request<S2SV_blank>of<S2SV_blank>size<S2SV_blank>%d<S2SV_blank>(from<S2SV_blank>pid=%d<S2SV_blank>uid=%d)\\n" , status , cr . pid , cr . uid ) ; return - 1 ; } out_request -> action = msg . action ; out_request -> tid = msg . tid ; out_request -> pid = cr . pid ; out_request -> uid = cr . uid ; out_request -> gid = cr . gid ; out_request -> abort_msg_address = msg . abort_msg_address ; if ( msg . action == DEBUGGER_ACTION_CRASH ) { <S2SV_StartBug> char buf [ 64 ] ; <S2SV_EndBug> struct stat s ; snprintf ( buf , sizeof buf , "/proc/%d/task/%d" , out_request -> pid , out_request -> tid ) ; if ( stat ( buf , & s ) ) { LOG ( "tid<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist<S2SV_blank>in<S2SV_blank>pid<S2SV_blank>%d.<S2SV_blank>ignoring<S2SV_blank>debug<S2SV_blank>request\\n" , <S2SV_StartBug> out_request -> tid , out_request -> pid ) ; <S2SV_EndBug> return - 1 ; } } else if ( cr . uid == 0 || ( cr . uid == AID_SYSTEM && msg . action == DEBUGGER_ACTION_DUMP_BACKTRACE ) ) { status = get_process_info ( out_request -> tid , & out_request -> pid , & out_request -> uid , & out_request -> gid ) ; if ( status < 0 ) { LOG ( "tid<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist.<S2SV_blank>ignoring<S2SV_blank>explicit<S2SV_blank>dump<S2SV_blank>request\\n" , out_request -> tid ) ; return - 1 ; } } else { return - 1 ; } return 0 ; } | <S2SV_ModStart> DEBUGGER_ACTION_CRASH ) { if ( ! pid_contains_tid ( out_request -> pid , out_request -> tid ) ) { XLOG <S2SV_ModEnd> ( "tid<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist<S2SV_blank>in<S2SV_blank>pid<S2SV_blank>%d.<S2SV_blank>ignoring<S2SV_blank>debug<S2SV_blank>request\\n" , <S2SV_ModStart> ( "tid<S2SV_blank>%d<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist<S2SV_blank>in<S2SV_blank>pid<S2SV_blank>%d.<S2SV_blank>ignoring<S2SV_blank>debug<S2SV_blank>request\\n" , out_request -> tid , <S2SV_ModEnd> out_request -> pid |
74 | CWE-000 void executeTests ( ) { if ( currentSuite -> parent ) { fail ( "Not<S2SV_blank>all<S2SV_blank>describe<S2SV_blank>blocks<S2SV_blank>have<S2SV_blank>been<S2SV_blank>closed." ) ; } <S2SV_StartBug> traverseTests ( currentSuite ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } if ( currentSuite -> children ) { DescribeBlock * currentDescribe = currentSuite -> children ; while ( currentDescribe -> next ) { traverseTests ( currentDescribe -> next ) ; currentDescribe = currentDescribe -> next ; } } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
75 | CWE-000 static void check_respawn ( void ) { time_t t = time ( NULL ) ; static time_t timestamp ; static int counter ; <S2SV_StartBug> if ( timestamp >= t - 120 ) <S2SV_EndBug> ++ counter ; else { timestamp = t ; counter = 0 ; } <S2SV_StartBug> if ( counter >= 10 ) { <S2SV_EndBug> unsigned int time_left = 300 ; syslog ( LOG_ERR , "Error:<S2SV_blank>collectd<S2SV_blank>is<S2SV_blank>respawning<S2SV_blank>too<S2SV_blank>fast<S2SV_blank>-<S2SV_blank>" "disabled<S2SV_blank>for<S2SV_blank>%i<S2SV_blank>seconds" , time_left ) ; <S2SV_StartBug> while ( ( ( time_left = sleep ( time_left ) ) >= 0 ) && loop == 0 ) <S2SV_EndBug> ; } return ; } | <S2SV_ModStart> if ( timestamp > <S2SV_ModEnd> t - 120 <S2SV_ModStart> if ( counter > <S2SV_ModEnd> 10 ) { <S2SV_ModStart> time_left ) ) > <S2SV_ModEnd> 0 ) && |
76 | CWE-000 void get_rte_attribute_type ( RangeTblEntry * rte , AttrNumber attnum , Oid * vartype , int32 * vartypmod , Oid * varcollid ) { switch ( rte -> rtekind ) { case RTE_RELATION : { HeapTuple tp ; Form_pg_attribute att_tup ; tp = SearchSysCache2 ( ATTNUM , ObjectIdGetDatum ( rte -> relid ) , Int16GetDatum ( attnum ) ) ; if ( ! HeapTupleIsValid ( tp ) ) elog ( ERROR , "cache<S2SV_blank>lookup<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>attribute<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>%u" , attnum , rte -> relid ) ; att_tup = ( Form_pg_attribute ) GETSTRUCT ( tp ) ; if ( att_tup -> attisdropped ) ereport ( ERROR , ( errcode ( ERRCODE_UNDEFINED_COLUMN ) , errmsg ( "column<S2SV_blank>\\"%s\\"<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>\\"%s\\"<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , NameStr ( att_tup -> attname ) , get_rel_name ( rte -> relid ) ) ) ) ; * vartype = att_tup -> atttypid ; * vartypmod = att_tup -> atttypmod ; * varcollid = att_tup -> attcollation ; ReleaseSysCache ( tp ) ; } break ; case RTE_SUBQUERY : { TargetEntry * te = get_tle_by_resno ( rte -> subquery -> targetList , attnum ) ; if ( te == NULL || te -> resjunk ) elog ( ERROR , "subquery<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>have<S2SV_blank>attribute<S2SV_blank>%d" , rte -> eref -> aliasname , attnum ) ; * vartype = exprType ( ( Node * ) te -> expr ) ; * vartypmod = exprTypmod ( ( Node * ) te -> expr ) ; * varcollid = exprCollation ( ( Node * ) te -> expr ) ; } break ; case RTE_FUNCTION : { ListCell * lc ; int atts_done = 0 ; foreach ( lc , rte -> functions ) { RangeTblFunction * rtfunc = ( RangeTblFunction * ) lfirst ( lc ) ; if ( attnum > atts_done && attnum <= atts_done + rtfunc -> funccolcount ) { TypeFuncClass functypclass ; Oid funcrettype ; TupleDesc tupdesc ; attnum -= atts_done ; functypclass = get_expr_result_type ( rtfunc -> funcexpr , & funcrettype , & tupdesc ) ; if ( functypclass == TYPEFUNC_COMPOSITE ) { Form_pg_attribute att_tup ; Assert ( tupdesc ) ; Assert ( attnum <= tupdesc -> natts ) ; att_tup = TupleDescAttr ( tupdesc , attnum - 1 ) ; if ( att_tup -> attisdropped ) ereport ( ERROR , ( errcode ( ERRCODE_UNDEFINED_COLUMN ) , errmsg ( "column<S2SV_blank>\\"%s\\"<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>\\"%s\\"<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , NameStr ( att_tup -> attname ) , rte -> eref -> aliasname ) ) ) ; * vartype = att_tup -> atttypid ; * vartypmod = att_tup -> atttypmod ; * varcollid = att_tup -> attcollation ; } else if ( functypclass == TYPEFUNC_SCALAR ) { * vartype = funcrettype ; * vartypmod = - 1 ; * varcollid = exprCollation ( rtfunc -> funcexpr ) ; } else if ( functypclass == TYPEFUNC_RECORD ) { * vartype = list_nth_oid ( rtfunc -> funccoltypes , attnum - 1 ) ; * vartypmod = list_nth_int ( rtfunc -> funccoltypmods , attnum - 1 ) ; * varcollid = list_nth_oid ( rtfunc -> funccolcollations , attnum - 1 ) ; } else { elog ( ERROR , "function<S2SV_blank>in<S2SV_blank>FROM<S2SV_blank>has<S2SV_blank>unsupported<S2SV_blank>return<S2SV_blank>type" ) ; } return ; } atts_done += rtfunc -> funccolcount ; } if ( rte -> funcordinality && attnum == atts_done + 1 ) { * vartype = INT8OID ; * vartypmod = - 1 ; * varcollid = InvalidOid ; return ; } ereport ( ERROR , ( errcode ( ERRCODE_UNDEFINED_COLUMN ) , errmsg ( "column<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>\\"%s\\"<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , attnum , rte -> eref -> aliasname ) ) ) ; } break ; case RTE_JOIN : { Node * aliasvar ; Assert ( attnum > 0 && attnum <= list_length ( rte -> joinaliasvars ) ) ; aliasvar = ( Node * ) list_nth ( rte -> joinaliasvars , attnum - 1 ) ; Assert ( aliasvar != NULL ) ; * vartype = exprType ( aliasvar ) ; * vartypmod = exprTypmod ( aliasvar ) ; * varcollid = exprCollation ( aliasvar ) ; } break ; case RTE_TABLEFUNC : case RTE_VALUES : case RTE_CTE : case RTE_NAMEDTUPLESTORE : { Assert ( attnum > 0 && attnum <= list_length ( rte -> coltypes ) ) ; * vartype = list_nth_oid ( rte -> coltypes , attnum - 1 ) ; * vartypmod = list_nth_int ( rte -> coltypmods , attnum - 1 ) ; * varcollid = list_nth_oid ( rte -> colcollations , attnum - 1 ) ; <S2SV_StartBug> } <S2SV_EndBug> break ; default : elog ( ERROR , "unrecognized<S2SV_blank>RTE<S2SV_blank>kind:<S2SV_blank>%d" , ( int ) rte -> rtekind ) ; } } | <S2SV_ModStart> 1 ) ; if ( ! OidIsValid ( * vartype ) ) ereport ( ERROR , ( errcode ( ERRCODE_UNDEFINED_COLUMN ) , errmsg ( "column<S2SV_blank>%d<S2SV_blank>of<S2SV_blank>relation<S2SV_blank>\\"%s\\"<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist" , attnum , rte -> eref -> aliasname ) ) ) ; |
77 | CWE-000 void P2 ( ) { <S2SV_StartBug> char * xx = "hello<S2SV_blank>world,<S2SV_blank>I\'m<S2SV_blank>P2\\n" ; <S2SV_EndBug> write ( 0 , xx , 20 ) ; while ( 1 ) { for ( uint32_t x = ( 1 << 8 ) ; x < ( 1 << 24 ) ; x ++ ) { uint32_t r = weight ( x ) ; } } return ; } | <S2SV_ModStart> xx = "hello<S2SV_blank>world,<S2SV_blank>I\'m<S2SV_blank>P2\\n" <S2SV_ModEnd> ; while ( |
78 | CWE-000 static int iw_softap_set_channel_range ( struct net_device * dev , int startChannel , int endChannel , int band ) { VOS_STATUS status ; int ret = 0 ; hdd_adapter_t * pHostapdAdapter = ( netdev_priv ( dev ) ) ; tHalHandle hHal = WLAN_HDD_GET_HAL_CTX ( pHostapdAdapter ) ; hdd_context_t * pHddCtx = WLAN_HDD_GET_CTX ( pHostapdAdapter ) ; <S2SV_StartBug> status = WLANSAP_SetChannelRange ( hHal , startChannel , endChannel , band ) ; <S2SV_EndBug> if ( VOS_STATUS_SUCCESS != status ) { ret = - EINVAL ; } pHddCtx -> is_dynamic_channel_range_set = 1 ; return ret ; } | <S2SV_ModStart> pHostapdAdapter ) ; if ( ! capable ( CAP_NET_ADMIN ) ) { VOS_TRACE ( VOS_MODULE_ID_HDD , VOS_TRACE_LEVEL_ERROR , FL ( "permission<S2SV_blank>check<S2SV_blank>failed" ) ) ; return - EPERM ; } |
79 | CWE-000 struct alloc_class_collection * alloc_class_collection_new ( void ) { struct alloc_class_collection * ac = Malloc ( sizeof ( * ac ) ) ; if ( ac == NULL ) return NULL ; memset ( ac -> aclasses , 0 , sizeof ( ac -> aclasses ) ) ; ac -> last_run_max_size = MAX_RUN_SIZE ; if ( alloc_class_new ( ac , CLASS_HUGE , CHUNKSIZE , 0 , 0 ) == NULL ) goto error_alloc_class_create ; struct alloc_class * predefined_class = alloc_class_new ( ac , CLASS_RUN , MIN_RUN_SIZE , RUN_UNIT_MAX , RUN_UNIT_MAX_ALLOC ) ; if ( predefined_class == NULL ) goto error_alloc_class_create ; for ( size_t i = 0 ; i < FIRST_GENERATED_CLASS_SIZE ; ++ i ) { ac -> class_map_by_unit_size [ i ] = predefined_class -> id ; ac -> class_map_by_alloc_size [ i ] = predefined_class -> id ; } size_t size = 0 ; for ( int c = 1 ; c < MAX_ALLOC_CATEGORIES ; ++ c ) { for ( size_t i = categories [ c - 1 ] . size + 1 ; i <= categories [ c ] . size ; i += categories [ c ] . step ) { size = i + ( categories [ c ] . step - 1 ) ; if ( alloc_class_find_or_create ( ac , size * ALLOC_BLOCK_SIZE ) == NULL ) goto error_alloc_class_create ; } } uint8_t largest_aclass_slot ; for ( largest_aclass_slot = MAX_ALLOCATION_CLASSES - 1 ; largest_aclass_slot > 0 && ac -> aclasses [ largest_aclass_slot ] == NULL ; -- largest_aclass_slot ) { } struct alloc_class * c = ac -> aclasses [ largest_aclass_slot ] ; size_t real_unit_max = c -> run . bitmap_nallocs < c -> run . unit_max_alloc ? c -> run . bitmap_nallocs : c -> run . unit_max_alloc ; size_t theoretical_run_max_size = c -> unit_size * real_unit_max ; ac -> last_run_max_size = MAX_RUN_SIZE > theoretical_run_max_size ? theoretical_run_max_size : MAX_RUN_SIZE ; for ( size_t i = FIRST_GENERATED_CLASS_SIZE ; i <= ac -> last_run_max_size / ALLOC_BLOCK_SIZE ; ++ i ) { struct alloc_class * c = alloc_class_find_min_frag ( ac , i * ALLOC_BLOCK_SIZE ) ; ac -> class_map_by_unit_size [ i ] = c -> id ; size_t header_offset = CALC_SIZE_IDX ( ALLOC_BLOCK_SIZE , header_type_to_size [ c -> header_type ] ) ; ac -> class_map_by_alloc_size [ i - header_offset ] = c -> id ; ac -> class_map_by_alloc_size [ i ] = c -> id ; } <S2SV_StartBug> # ifndef DEBUG <S2SV_EndBug> for ( size_t i = 0 ; i < MAX_ALLOCATION_CLASSES ; ++ i ) { struct alloc_class * c = ac -> aclasses [ i ] ; <S2SV_StartBug> ASSERTeq ( i , c -> id ) ; <S2SV_EndBug> <S2SV_StartBug> if ( c != NULL ) { <S2SV_EndBug> uint8_t class_id = ac -> class_map_by_unit_size [ SIZE_TO_CLASS_MAP_INDEX ( c -> unit_size ) ] ; ASSERTeq ( class_id , c -> id ) ; } } # endif return ac ; error_alloc_class_create : alloc_class_collection_delete ( ac ) ; return NULL ; } | <S2SV_ModStart> ; } # ifdef <S2SV_ModEnd> DEBUG for ( <S2SV_ModStart> i ] ; if ( c != NULL ) { <S2SV_ModStart> id ) ; <S2SV_ModEnd> uint8_t class_id = |
80 | CWE-000 static int trans_exc ( struct kvm_vcpu * vcpu , int code , unsigned long gva , <S2SV_StartBug> ar_t ar , enum gacc_mode mode , enum prot_type prot ) <S2SV_EndBug> { struct kvm_s390_pgm_info * pgm = & vcpu -> arch . pgm ; struct trans_exc_code_bits * tec ; memset ( pgm , 0 , sizeof ( * pgm ) ) ; pgm -> code = code ; tec = ( struct trans_exc_code_bits * ) & pgm -> trans_exc_code ; switch ( code ) { case PGM_PROTECTION : switch ( prot ) { <S2SV_StartBug> case PROT_TYPE_ALC : <S2SV_EndBug> tec -> b60 = 1 ; case PROT_TYPE_DAT : tec -> b61 = 1 ; <S2SV_StartBug> break ; <S2SV_EndBug> default : return code ; } case PGM_ASCE_TYPE : case PGM_PAGE_TRANSLATION : case PGM_REGION_FIRST_TRANS : case PGM_REGION_SECOND_TRANS : case PGM_REGION_THIRD_TRANS : case PGM_SEGMENT_TRANSLATION : tec -> addr = gva >> PAGE_SHIFT ; tec -> fsi = mode == GACC_STORE ? FSI_STORE : FSI_FETCH ; tec -> as = psw_bits ( vcpu -> arch . sie_block -> gpsw ) . as ; case PGM_ALEN_TRANSLATION : case PGM_ALE_SEQUENCE : case PGM_ASTE_VALIDITY : case PGM_ASTE_SEQUENCE : case PGM_EXTENDED_AUTHORITY : pgm -> exc_access_id = ar ; break ; } return code ; } | <S2SV_ModStart> long gva , u8 <S2SV_ModEnd> ar , enum <S2SV_ModStart> ) { case PROT_TYPE_LA : tec -> b56 = 1 ; break ; case PROT_TYPE_KEYC : tec -> b60 = 1 ; break ; case <S2SV_ModStart> 1 ; break <S2SV_ModEnd> ; } case |
81 | CWE-000 static int b53_mmap_write16 ( struct b53_device * dev , u8 page , u8 reg , u16 value ) { <S2SV_StartBug> u8 __iomem * regs = dev -> priv ; <S2SV_EndBug> if ( WARN_ON ( reg % 2 ) ) return - EINVAL ; if ( dev -> pdata && dev -> pdata -> big_endian ) iowrite16be ( value , regs + ( page << 8 ) + reg ) ; else writew ( value , regs + ( page << 8 ) + reg ) ; return 0 ; } | <S2SV_ModStart> value ) { struct b53_mmap_priv * priv = dev -> priv ; void <S2SV_ModEnd> __iomem * regs <S2SV_ModStart> * regs = priv -> regs <S2SV_ModEnd> ; if ( |
82 | CWE-000 static void attachToSlot ( ResGroupData * group , ResGroupSlotData * slot ) { <S2SV_StartBug> int32 slotMemUsage ; <S2SV_EndBug> int32 sharedMemUsage ; pg_atomic_add_fetch_u32 ( ( pg_atomic_uint32 * ) & slot -> nProcs , 1 ) ; <S2SV_StartBug> slotMemUsage = pg_atomic_add_fetch_u32 ( ( pg_atomic_uint32 * ) & slot -> memUsage , <S2SV_EndBug> <S2SV_StartBug> self -> memUsage ) ; <S2SV_EndBug> <S2SV_StartBug> sharedMemUsage = slotMemUsage - slot -> memQuota ; <S2SV_EndBug> if ( sharedMemUsage > 0 ) { sharedMemUsage = Min ( sharedMemUsage , self -> memUsage ) ; <S2SV_StartBug> pg_atomic_add_fetch_u32 ( ( pg_atomic_uint32 * ) & group -> memSharedUsage , <S2SV_EndBug> sharedMemUsage ) ; } <S2SV_StartBug> pg_atomic_add_fetch_u32 ( ( pg_atomic_uint32 * ) & group -> memUsage , <S2SV_EndBug> self -> memUsage ) ; } | <S2SV_ModStart> slot ) { <S2SV_ModEnd> int32 sharedMemUsage ; <S2SV_ModStart> 1 ) ; S_LOCK ( & group -> lock ) ; <S2SV_ModEnd> slot -> memUsage <S2SV_ModStart> slot -> memUsage += <S2SV_ModEnd> self -> memUsage <S2SV_ModStart> self -> memUsage <S2SV_ModEnd> ; sharedMemUsage = <S2SV_ModStart> ; sharedMemUsage = slot -> memUsage <S2SV_ModEnd> - slot -> <S2SV_ModStart> memUsage ) ; <S2SV_ModEnd> group -> memSharedUsage <S2SV_ModStart> group -> memSharedUsage += sharedMemUsage ; } group -> memUsage += self -> memUsage ; S_UNLOCK ( <S2SV_ModEnd> & group -> <S2SV_ModStart> & group -> lock <S2SV_ModEnd> ) ; } |
83 | CWE-000 void help_list ( void ) { int i ; int j ; i = 0 ; j = 0 ; cmd_title ( ) ; while ( g_builtin_list [ i ] != '\\0' ) { j ++ ; if ( i >= 0 && i < 6 ) <S2SV_StartBug> printf ( "\\n(%d)<S2SV_blank>Only<S2SV_blank>if<S2SV_blank>I\'m<S2SV_blank>\\033[37;1m%s\\033[0m\\n\\n" , j , g_builtin_list [ i ] ) ; <S2SV_EndBug> i ++ ; } } | <S2SV_ModStart> < 6 ) ft_printf ( 1 , <S2SV_ModEnd> "\\n(%d)<S2SV_blank>Only<S2SV_blank>if<S2SV_blank>I\'m<S2SV_blank>\\033[37;1m%s\\033[0m\\n\\n" , j |
84 | CWE-000 static gboolean nm_vpn_connection_apply_config ( NMVpnConnection * self ) { NMVpnConnectionPrivate * priv = NM_VPN_CONNECTION_GET_PRIVATE ( self ) ; if ( priv -> ip_ifindex > 0 ) { nm_platform_link_set_up ( NM_PLATFORM_GET , priv -> ip_ifindex , NULL ) ; if ( priv -> ip4_config ) { if ( ! nm_ip4_config_commit ( priv -> ip4_config , priv -> ip_ifindex , TRUE , nm_vpn_connection_get_ip4_route_metric ( self ) ) ) return FALSE ; } if ( priv -> ip6_config ) { if ( ! nm_ip6_config_commit ( priv -> ip6_config , priv -> ip_ifindex , TRUE ) ) return FALSE ; } if ( priv -> mtu && priv -> mtu != nm_platform_link_get_mtu ( NM_PLATFORM_GET , priv -> ip_ifindex ) ) nm_platform_link_set_mtu ( NM_PLATFORM_GET , priv -> ip_ifindex , priv -> mtu ) ; } apply_parent_device_config ( self ) ; <S2SV_StartBug> nm_default_route_manager_ip4_update_default_route ( priv -> default_route_manager , self , FALSE ) ; <S2SV_EndBug> <S2SV_StartBug> nm_default_route_manager_ip6_update_default_route ( priv -> default_route_manager , self , FALSE ) ; <S2SV_EndBug> _LOGI ( "VPN<S2SV_blank>connection:<S2SV_blank>(IP<S2SV_blank>Config<S2SV_blank>Get)<S2SV_blank>complete" ) ; if ( priv -> vpn_state < STATE_PRE_UP ) _set_vpn_state ( self , STATE_PRE_UP , NM_VPN_CONNECTION_STATE_REASON_NONE , FALSE ) ; return TRUE ; } | <S2SV_ModStart> default_route_manager , self <S2SV_ModEnd> ) ; nm_default_route_manager_ip6_update_default_route <S2SV_ModStart> default_route_manager , self <S2SV_ModEnd> ) ; _LOGI |
85 | CWE-000 GtkWidget * xed_externally_modified_saving_error_message_area_new ( const gchar * uri , const GError * error ) { GtkWidget * message_area ; GtkWidget * hbox_content ; GtkWidget * image ; GtkWidget * vbox ; gchar * primary_markup ; gchar * secondary_markup ; GtkWidget * primary_label ; GtkWidget * secondary_label ; gchar * primary_text ; const gchar * secondary_text ; gchar * full_formatted_uri ; gchar * uri_for_display ; gchar * temp_uri_for_display ; g_return_val_if_fail ( uri != NULL , NULL ) ; g_return_val_if_fail ( error != NULL , NULL ) ; g_return_val_if_fail ( error -> domain == XED_DOCUMENT_ERROR , NULL ) ; g_return_val_if_fail ( error -> code == XED_DOCUMENT_ERROR_EXTERNALLY_MODIFIED , NULL ) ; full_formatted_uri = xed_utils_uri_for_display ( uri ) ; temp_uri_for_display = xed_utils_str_middle_truncate ( full_formatted_uri , MAX_URI_IN_DIALOG_LENGTH ) ; g_free ( full_formatted_uri ) ; uri_for_display = g_markup_printf_escaped ( "<i>%s</i>" , temp_uri_for_display ) ; g_free ( temp_uri_for_display ) ; message_area = gtk_info_bar_new ( ) ; <S2SV_StartBug> info_bar_add_stock_button_with_text ( GTK_INFO_BAR ( message_area ) , _ ( "S_ave<S2SV_blank>Anyway" ) , <S2SV_EndBug> <S2SV_StartBug> GTK_STOCK_SAVE , GTK_RESPONSE_YES ) ; <S2SV_EndBug> gtk_info_bar_add_button ( GTK_INFO_BAR ( message_area ) , _ ( "D_on\'t<S2SV_blank>Save" ) , GTK_RESPONSE_CANCEL ) ; gtk_info_bar_set_message_type ( GTK_INFO_BAR ( message_area ) , GTK_MESSAGE_WARNING ) ; hbox_content = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL , 8 ) ; <S2SV_StartBug> image = gtk_image_new_from_stock ( "gtk-dialog-warning" , GTK_ICON_SIZE_DIALOG ) ; <S2SV_EndBug> gtk_box_pack_start ( GTK_BOX ( hbox_content ) , image , FALSE , FALSE , 0 ) ; gtk_widget_set_halign ( image , GTK_ALIGN_CENTER ) ; gtk_widget_set_valign ( image , GTK_ALIGN_START ) ; vbox = gtk_box_new ( GTK_ORIENTATION_VERTICAL , 6 ) ; gtk_box_pack_start ( GTK_BOX ( hbox_content ) , vbox , TRUE , TRUE , 0 ) ; primary_text = g_strdup_printf ( _ ( "The<S2SV_blank>file<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>been<S2SV_blank>modified<S2SV_blank>since<S2SV_blank>reading<S2SV_blank>it." ) , uri_for_display ) ; g_free ( uri_for_display ) ; primary_markup = g_strdup_printf ( "<b>%s</b>" , primary_text ) ; g_free ( primary_text ) ; primary_label = gtk_label_new ( primary_markup ) ; g_free ( primary_markup ) ; gtk_box_pack_start ( GTK_BOX ( vbox ) , primary_label , TRUE , TRUE , 0 ) ; gtk_label_set_use_markup ( GTK_LABEL ( primary_label ) , TRUE ) ; gtk_label_set_line_wrap ( GTK_LABEL ( primary_label ) , TRUE ) ; gtk_misc_set_alignment ( GTK_MISC ( primary_label ) , 0.0 , 0.5 ) ; gtk_widget_set_can_focus ( primary_label , TRUE ) ; gtk_label_set_selectable ( GTK_LABEL ( primary_label ) , TRUE ) ; secondary_text = _ ( "If<S2SV_blank>you<S2SV_blank>save<S2SV_blank>it,<S2SV_blank>all<S2SV_blank>the<S2SV_blank>external<S2SV_blank>changes<S2SV_blank>could<S2SV_blank>be<S2SV_blank>lost.<S2SV_blank>Save<S2SV_blank>it<S2SV_blank>anyway?" ) ; secondary_markup = g_strdup_printf ( "<small>%s</small>" , secondary_text ) ; secondary_label = gtk_label_new ( secondary_markup ) ; g_free ( secondary_markup ) ; gtk_box_pack_start ( GTK_BOX ( vbox ) , secondary_label , TRUE , TRUE , 0 ) ; gtk_widget_set_can_focus ( secondary_label , TRUE ) ; gtk_label_set_use_markup ( GTK_LABEL ( secondary_label ) , TRUE ) ; gtk_label_set_line_wrap ( GTK_LABEL ( secondary_label ) , TRUE ) ; gtk_label_set_selectable ( GTK_LABEL ( secondary_label ) , TRUE ) ; gtk_misc_set_alignment ( GTK_MISC ( secondary_label ) , 0.0 , 0.5 ) ; gtk_widget_show_all ( hbox_content ) ; set_contents ( message_area , hbox_content ) ; return message_area ; } | <S2SV_ModStart> ( ) ; info_bar_add_button_with_text <S2SV_ModEnd> ( GTK_INFO_BAR ( <S2SV_ModStart> "S_ave<S2SV_blank>Anyway" ) , "document-save-symbolic" <S2SV_ModEnd> , GTK_RESPONSE_YES ) <S2SV_ModStart> ; image = gtk_image_new_from_icon_name ( "dialog-warning-symbolic" <S2SV_ModEnd> , GTK_ICON_SIZE_DIALOG ) |
86 | CWE-000 <S2SV_StartBug> err_t httpd_post_receive_data ( void * connection , struct pbuf * p ) { <S2SV_EndBug> if ( ! strcmp ( req_uri , "/kyChu/print.cgi" ) ) { int i = 0 , j = 0 ; while ( i < p -> len && ( ( char * ) p -> payload ) [ i ] != '=' ) i ++ ; do { i ++ ; cache [ j ++ ] = ( ( char * ) p -> payload ) [ i ] ; } while ( i < p -> len && ( ( char * ) p -> payload ) [ i ] != '&' ) ; cache [ j - 1 ] = 0 ; printf ( "%s\\n" , cache ) ; memcpy ( req_uri , default_uri , strlen ( default_uri ) ) ; req_uri [ strlen ( default_uri ) ] = 0 ; } else if ( ! strcmp ( req_uri , "/upgrade/wifi.cgi" ) ) { <S2SV_StartBug> printf ( "upload<S2SV_blank>%s.\\n" , p -> payload ) ; <S2SV_EndBug> memcpy ( req_uri , default_uri , strlen ( default_uri ) ) ; req_uri [ strlen ( default_uri ) ] = 0 ; } else if ( ! strcmp ( req_uri , "/upgrade/fc.cgi" ) ) { memcpy ( req_uri , default_uri , strlen ( default_uri ) ) ; req_uri [ strlen ( default_uri ) ] = 0 ; } return ERR_OK ; } | <S2SV_ModStart> p ) { ( ( char * ) p -> payload ) [ p -> len ] = 0 ; printf ( "payload<S2SV_blank>is<S2SV_blank>%s.\\n" , p -> payload ) ; <S2SV_ModStart> ) ) { <S2SV_ModEnd> memcpy ( req_uri |
87 | CWE-000 static inline void disable_rx ( C161_Serial * ser ) { if ( ser -> ifh_is_active ) { <S2SV_StartBug> FIO_RemoveFileHandler ( & ser -> input_fh ) ; <S2SV_EndBug> } ser -> ifh_is_active = 0 ; } | <S2SV_ModStart> ifh_is_active ) { AsyncManager_PollStop ( <S2SV_ModEnd> ser -> input_fh |
88 | CWE-000 static inline u_int <S2SV_StartBug> mtp_get_subzone ( const char * desc ) <S2SV_EndBug> { return ( 0 ) ; } | <S2SV_ModStart> u_int mtp_get_subzone ( struct malloc_type * mtp <S2SV_ModEnd> ) { return |
89 | CWE-000 int main ( int argc , char * * argv ) { int i , max , offset ; byte dec [ 256 ] = { 0 } , enc [ 256 ] = { 0 } ; char string [ 2048 ] = { 0 } ; offset = 8 ; if ( argc > 2 ) { if ( argv [ 1 ] [ 0 ] == 'd' ) { <S2SV_StartBug> if ( strlen ( argv [ 2 ] ) > 256 * 8 ) return - 1 ; <S2SV_EndBug> memcpy ( string , argv [ 2 ] , strlen ( argv [ 2 ] ) ) ; for ( i = 0 ; i < strlen ( string ) - 3 ; i += 8 ) enc [ i / 8 ] = str2byte ( & string [ i ] ) ; max = i / 8 ; memcpy ( & dec , & enc , 256 ) ; dec [ offset + 0 ] = enc [ offset + 0 ] ; dec [ offset + 1 ] = ( ~ enc [ offset + 1 ] ) ^ 0x89 ; for ( i = offset + 2 ; i < max ; i ++ ) dec [ i ] = ( enc [ i - 1 ] + 0xdc ) ^ enc [ i ] ; dec [ offset + i ] = enc [ offset + i ] ^ dec [ offset + 2 ] ; dec [ max - 1 ] = 0 ; dec [ max - 2 ] = 0 ; for ( i = 0 ; i < max ; i ++ ) print_binary ( dec [ i ] ) ; } else { <S2SV_StartBug> if ( strlen ( argv [ 2 ] ) > 256 * 8 ) return - 1 ; <S2SV_EndBug> memcpy ( string , argv [ 2 ] , strlen ( argv [ 2 ] ) ) ; for ( i = 0 ; i < strlen ( string ) - 3 ; i += 8 ) dec [ i / 8 ] = str2byte ( & string [ i ] ) ; max = i / 8 ; memcpy ( & enc , & dec , 256 ) ; enc [ offset + 0 ] = dec [ offset + 0 ] ; enc [ offset + 1 ] = ~ ( dec [ offset + 1 ] ^ 0x89 ) ; for ( i = offset + 2 ; i < max ; i ++ ) enc [ i ] = ( enc [ i - 1 ] + 0xdc ) ^ dec [ i ] ; enc [ offset + i ] = dec [ offset + i ] ^ dec [ offset + 2 ] ; enc [ max - 1 ] = 0 ; enc [ max - 2 ] = 0 ; for ( i = 0 ; i < max ; i ++ ) print_binary ( enc [ i ] ) ; } } else printf ( "Usage:<S2SV_blank>%s<S2SV_blank><d/e><S2SV_blank><bit<S2SV_blank>sequence>\\n\\td<S2SV_blank>-<S2SV_blank>decode\\n\\te<S2SV_blank>-<S2SV_blank>encode\\n\\tbit<S2SV_blank>sequence<S2SV_blank>as<S2SV_blank>string<S2SV_blank>of<S2SV_blank>0<S2SV_blank>and<S2SV_blank>1.\\n" , argv [ 0 ] ) ; return 0 ; } | <S2SV_ModStart> 256 * 8 || strlen ( argv [ 2 ] ) < 4 <S2SV_ModStart> 256 * 8 || strlen ( argv [ 2 ] ) < 4 |
90 | CWE-000 <S2SV_StartBug> static int receivedata ( struct spi_slave * slave , u8 * buffer , u32 size ) <S2SV_EndBug> { u32 read_data , base ; int ret ; base = container_of ( slave , struct img_spi_slave , slave ) -> base ; write32 ( base + SPFI_INT_CLEAR_REG_OFFSET , SPFI_GDEX32BIT_MASK ) ; while ( size >= sizeof ( u32 ) ) { ret = wait_status ( base + SPFI_INT_STATUS_REG_OFFSET , SPFI_GDEX32BIT_SHIFT ) ; if ( ret ) return ret ; read_data = read32 ( base + SPFI_GET_LONG_REG_OFFSET ) ; memcpy ( buffer , & read_data , sizeof ( u32 ) ) ; buffer += sizeof ( u32 ) ; size -= sizeof ( u32 ) ; write32 ( base + SPFI_INT_CLEAR_REG_OFFSET , SPFI_GDEX32BIT_MASK ) ; } write32 ( base + SPFI_INT_CLEAR_REG_OFFSET , SPFI_GDEX8BIT_MASK ) ; while ( size ) { ret = wait_status ( base + SPFI_INT_STATUS_REG_OFFSET , SPFI_GDEX8BIT_SHIFT ) ; if ( ret ) return ret ; * buffer = read32 ( base + SPFI_GET_BYTE_REG_OFFSET ) ; buffer ++ ; size -- ; write32 ( base + SPFI_INT_CLEAR_REG_OFFSET , SPFI_GDEX8BIT_MASK ) ; } return SPIM_OK ; } | <S2SV_ModStart> int receivedata ( const |
91 | CWE-000 static void spapr_memory_pre_plug ( HotplugHandler * hotplug_dev , DeviceState * dev , Error * * errp ) { const sPAPRMachineClass * smc = SPAPR_MACHINE_GET_CLASS ( hotplug_dev ) ; sPAPRMachineState * spapr = SPAPR_MACHINE ( hotplug_dev ) ; PCDIMMDevice * dimm = PC_DIMM ( dev ) ; PCDIMMDeviceClass * ddc = PC_DIMM_GET_CLASS ( dimm ) ; MemoryRegion * mr ; uint64_t size ; Object * memdev ; hwaddr pagesize ; if ( ! smc -> dr_lmb_enabled ) { error_setg ( errp , "Memory<S2SV_blank>hotplug<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>for<S2SV_blank>this<S2SV_blank>machine" ) ; return ; } mr = ddc -> get_memory_region ( dimm , errp ) ; if ( ! mr ) { return ; } size = memory_region_size ( mr ) ; if ( size % SPAPR_MEMORY_BLOCK_SIZE ) { error_setg ( errp , "Hotplugged<S2SV_blank>memory<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>a<S2SV_blank>multiple<S2SV_blank>of<S2SV_blank>" <S2SV_StartBug> "%lld<S2SV_blank>MB" , SPAPR_MEMORY_BLOCK_SIZE / M_BYTE ) ; <S2SV_EndBug> return ; } memdev = object_property_get_link ( OBJECT ( dimm ) , PC_DIMM_MEMDEV_PROP , & error_abort ) ; pagesize = host_memory_backend_pagesize ( MEMORY_BACKEND ( memdev ) ) ; spapr_check_pagesize ( spapr , pagesize , errp ) ; } | <S2SV_ModStart> , SPAPR_MEMORY_BLOCK_SIZE / MiB <S2SV_ModEnd> ) ; return |
92 | CWE-000 static inline void ipv6_store_devconf ( struct ipv6_devconf * cnf , __s32 * array , int bytes ) { BUG_ON ( bytes < ( DEVCONF_MAX * 4 ) ) ; memset ( array , 0 , bytes ) ; array [ DEVCONF_FORWARDING ] = cnf -> forwarding ; array [ DEVCONF_HOPLIMIT ] = cnf -> hop_limit ; array [ DEVCONF_MTU6 ] = cnf -> mtu6 ; array [ DEVCONF_ACCEPT_RA ] = cnf -> accept_ra ; array [ DEVCONF_ACCEPT_REDIRECTS ] = cnf -> accept_redirects ; array [ DEVCONF_AUTOCONF ] = cnf -> autoconf ; array [ DEVCONF_DAD_TRANSMITS ] = cnf -> dad_transmits ; array [ DEVCONF_RTR_SOLICITS ] = cnf -> rtr_solicits ; array [ DEVCONF_RTR_SOLICIT_INTERVAL ] = jiffies_to_msecs ( cnf -> rtr_solicit_interval ) ; array [ DEVCONF_RTR_SOLICIT_MAX_INTERVAL ] = jiffies_to_msecs ( cnf -> rtr_solicit_max_interval ) ; array [ DEVCONF_RTR_SOLICIT_DELAY ] = jiffies_to_msecs ( cnf -> rtr_solicit_delay ) ; array [ DEVCONF_FORCE_MLD_VERSION ] = cnf -> force_mld_version ; array [ DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL ] = jiffies_to_msecs ( cnf -> mldv1_unsolicited_report_interval ) ; array [ DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL ] = jiffies_to_msecs ( cnf -> mldv2_unsolicited_report_interval ) ; array [ DEVCONF_USE_TEMPADDR ] = cnf -> use_tempaddr ; array [ DEVCONF_TEMP_VALID_LFT ] = cnf -> temp_valid_lft ; array [ DEVCONF_TEMP_PREFERED_LFT ] = cnf -> temp_prefered_lft ; array [ DEVCONF_REGEN_MAX_RETRY ] = cnf -> regen_max_retry ; array [ DEVCONF_MAX_DESYNC_FACTOR ] = cnf -> max_desync_factor ; array [ DEVCONF_MAX_ADDRESSES ] = cnf -> max_addresses ; array [ DEVCONF_ACCEPT_RA_DEFRTR ] = cnf -> accept_ra_defrtr ; array [ DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT ] = cnf -> accept_ra_min_hop_limit ; array [ DEVCONF_ACCEPT_RA_PINFO ] = cnf -> accept_ra_pinfo ; # ifdef CONFIG_IPV6_ROUTER_PREF array [ DEVCONF_ACCEPT_RA_RTR_PREF ] = cnf -> accept_ra_rtr_pref ; array [ DEVCONF_RTR_PROBE_INTERVAL ] = jiffies_to_msecs ( cnf -> rtr_probe_interval ) ; # ifdef CONFIG_IPV6_ROUTE_INFO <S2SV_StartBug> array [ DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN ] = cnf -> accept_ra_rt_info_max_plen ; <S2SV_EndBug> # endif # endif array [ DEVCONF_ACCEPT_RA_RT_TABLE ] = cnf -> accept_ra_rt_table ; array [ DEVCONF_PROXY_NDP ] = cnf -> proxy_ndp ; array [ DEVCONF_ACCEPT_SOURCE_ROUTE ] = cnf -> accept_source_route ; # ifdef CONFIG_IPV6_OPTIMISTIC_DAD array [ DEVCONF_OPTIMISTIC_DAD ] = cnf -> optimistic_dad ; array [ DEVCONF_USE_OPTIMISTIC ] = cnf -> use_optimistic ; # endif # ifdef CONFIG_IPV6_MROUTE array [ DEVCONF_MC_FORWARDING ] = cnf -> mc_forwarding ; # endif array [ DEVCONF_DISABLE_IPV6 ] = cnf -> disable_ipv6 ; array [ DEVCONF_ACCEPT_DAD ] = cnf -> accept_dad ; array [ DEVCONF_FORCE_TLLAO ] = cnf -> force_tllao ; array [ DEVCONF_NDISC_NOTIFY ] = cnf -> ndisc_notify ; array [ DEVCONF_SUPPRESS_FRAG_NDISC ] = cnf -> suppress_frag_ndisc ; array [ DEVCONF_ACCEPT_RA_FROM_LOCAL ] = cnf -> accept_ra_from_local ; array [ DEVCONF_ACCEPT_RA_MTU ] = cnf -> accept_ra_mtu ; array [ DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN ] = cnf -> ignore_routes_with_linkdown ; array [ DEVCONF_USE_OIF_ADDRS_ONLY ] = cnf -> use_oif_addrs_only ; array [ DEVCONF_DROP_UNICAST_IN_L2_MULTICAST ] = cnf -> drop_unicast_in_l2_multicast ; array [ DEVCONF_DROP_UNSOLICITED_NA ] = cnf -> drop_unsolicited_na ; array [ DEVCONF_KEEP_ADDR_ON_DOWN ] = cnf -> keep_addr_on_down ; } | <S2SV_ModStart> CONFIG_IPV6_ROUTE_INFO array [ DEVCONF_ACCEPT_RA_RT_INFO_MIN_PLEN ] = cnf -> accept_ra_rt_info_min_plen ; array [ |
93 | CWE-000 void stat_update ( batch_request * preq , struct stat_cntl * cntl ) { svr_job * pjob ; struct batch_reply * preply ; struct brp_status * pstatus ; svrattrl * sattrl ; int oldsid ; int bad = 0 ; time_t time_now = time ( NULL ) ; char * msg_ptr = NULL ; char log_buf [ LOCAL_LOG_BUF_SIZE ] ; preply = & preq -> rq_reply ; if ( ( preply -> brp_choice != BATCH_REPLY_CHOICE_Queue ) && ( preply -> brp_un . brp_txt . brp_str != NULL ) ) { msg_ptr = strstr ( preply -> brp_un . brp_txt . brp_str , PBS_MSG_EQUAL ) ; if ( msg_ptr != NULL ) msg_ptr += strlen ( PBS_MSG_EQUAL ) ; } if ( preply -> brp_choice == BATCH_REPLY_CHOICE_Status ) { pstatus = ( struct brp_status * ) GET_NEXT ( preply -> brp_un . brp_status ) ; while ( pstatus != NULL ) { if ( ( pjob = svr_find_job ( pstatus -> brp_objname , FALSE ) ) != NULL ) { mutex_mgr job_mutex ( pjob -> ji_mutex , true ) ; sattrl = ( svrattrl * ) GET_NEXT ( pstatus -> brp_attr ) ; oldsid = pjob -> get_long_attr ( JOB_ATR_session_id ) ; modify_job_attr ( pjob , sattrl , ATR_DFLAG_MGWR | ATR_DFLAG_SvWR , & bad ) ; if ( oldsid != pjob -> get_long_attr ( JOB_ATR_session_id ) ) { svr_job_save ( pjob ) ; } # ifdef USESAVEDRESOURCES else { svr_job_save ( pjob ) ; } # endif pjob -> ji_momstat = time_now ; } pstatus = ( struct brp_status * ) GET_NEXT ( pstatus -> brp_stlink ) ; } } else if ( ( preply -> brp_choice == BATCH_REPLY_CHOICE_Text ) && ( preply -> brp_code == PBSE_UNKJOBID ) && ( msg_ptr != NULL ) && ( ! strcmp ( msg_ptr , preq -> rq_ind . rq_status . rq_id ) ) ) { if ( ( pjob = svr_find_job ( preq -> rq_ind . rq_status . rq_id , FALSE ) ) != NULL ) { mutex_mgr job_mutex ( pjob -> ji_mutex , true ) ; <S2SV_StartBug> if ( pjob -> ji_qs . ji_state != JOB_STATE_RUNNING ) <S2SV_EndBug> { if ( LOGLEVEL >= 6 ) { snprintf ( log_buf , sizeof ( log_buf ) , "stat_update():<S2SV_blank>job<S2SV_blank>%s<S2SV_blank>is<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>in<S2SV_blank>running<S2SV_blank>state.<S2SV_blank>Ignoring<S2SV_blank>unknown<S2SV_blank>job<S2SV_blank>id<S2SV_blank>reply<S2SV_blank>from<S2SV_blank>mom." , preq -> rq_ind . rq_status . rq_id ) ; log_event ( PBSEVENT_SYSTEM , PBS_EVENTCLASS_JOB , __func__ , log_buf ) ; } } else { snprintf ( log_buf , sizeof ( log_buf ) , "mother<S2SV_blank>superior<S2SV_blank>no<S2SV_blank>longer<S2SV_blank>recognizes<S2SV_blank>%s<S2SV_blank>as<S2SV_blank>a<S2SV_blank>valid<S2SV_blank>job,<S2SV_blank>aborting.<S2SV_blank>Last<S2SV_blank>reported<S2SV_blank>time<S2SV_blank>was<S2SV_blank>%ld" , preq -> rq_ind . rq_status . rq_id , pjob -> ji_last_reported_time ) ; log_event ( PBSEVENT_JOB , PBS_EVENTCLASS_JOB , __func__ , log_buf ) ; svr_setjobstate ( pjob , JOB_STATE_QUEUED , JOB_SUBSTATE_ABORT , FALSE ) ; rel_resc ( pjob ) ; job_mutex . set_unlock_on_exit ( false ) ; job_abt ( & pjob , "Job<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist<S2SV_blank>on<S2SV_blank>node" ) ; } } } else { if ( preply -> brp_choice == BATCH_REPLY_CHOICE_Queue ) { snprintf ( log_buf , sizeof ( log_buf ) , "Unexpected<S2SV_blank>reply:<S2SV_blank>reply<S2SV_blank>was<S2SV_blank>on<S2SV_blank>queue" ) ; log_event ( PBSEVENT_JOB , PBS_EVENTCLASS_JOB , __func__ , log_buf ) ; } else { snprintf ( log_buf , sizeof ( log_buf ) , "Poll<S2SV_blank>job<S2SV_blank>request<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>job<S2SV_blank>%s" , preq -> rq_ind . rq_status . rq_id ) ; log_err ( preply -> brp_code , __func__ , log_buf ) ; } } cntl -> sc_conn = - 1 ; if ( cntl -> sc_post ) cntl -> sc_post ( cntl ) ; return ; } | <S2SV_ModStart> ( pjob -> get_state ( ) <S2SV_ModEnd> != JOB_STATE_RUNNING ) |
94 | CWE-000 pgp_seckey_t * pgp_decrypt_seckey ( const pgp_key_t * key , FILE * passfp ) { <S2SV_StartBug> pgp_stream_t * stream ; <S2SV_EndBug> const int printerrors = 1 ; decrypt_t decrypt ; if ( key -> packetc == 0 ) { <S2SV_StartBug> return ( pgp_seckey_t * ) & key -> key . seckey ; <S2SV_EndBug> } ( void ) memset ( & decrypt , 0x0 , sizeof ( decrypt ) ) ; decrypt . key = key ; stream = pgp_new ( sizeof ( * stream ) ) ; pgp_key_reader_set ( stream , key ) ; pgp_set_callback ( stream , decrypt_cb_empty , & decrypt ) ; stream -> readinfo . accumulate = 1 ; pgp_parse ( stream , ! printerrors ) ; if ( decrypt . seckey != NULL ) { pgp_stream_delete ( stream ) ; return decrypt . seckey ; } pgp_stream_delete ( stream ) ; decrypt . passfp = passfp ; stream = pgp_new ( sizeof ( * stream ) ) ; pgp_key_reader_set ( stream , key ) ; pgp_set_callback ( stream , decrypt_cb , & decrypt ) ; stream -> readinfo . accumulate = 1 ; pgp_parse ( stream , ! printerrors ) ; pgp_stream_delete ( stream ) ; return decrypt . seckey ; } | <S2SV_ModStart> passfp ) { if ( <S2SV_ModEnd> key -> key <S2SV_ModStart> key . seckey . decrypt_cb == NULL ) { return NULL ; } return key -> key . seckey . decrypt_cb ( key , passfp ) <S2SV_ModEnd> ; } <S2SV_null> |
95 | CWE-000 static void print_last_error ( void ) { DWORD errorMessageID = GetLastError ( ) ; if ( errorMessageID != 0 ) { LPSTR messageBuffer = NULL ; size_t size = FormatMessageA ( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS , NULL , errorMessageID , MAKELANGID ( LANG_NEUTRAL , SUBLANG_DEFAULT ) , ( LPSTR ) & messageBuffer , 0 , NULL ) ; <S2SV_StartBug> printf ( "Last<S2SV_blank>error:<S2SV_blank>%s\\n" , messageBuffer ) ; <S2SV_EndBug> LocalFree ( messageBuffer ) ; } } | <S2SV_ModStart> NULL ) ; pDEBUG <S2SV_ModEnd> ( "Last<S2SV_blank>error:<S2SV_blank>%s\\n" , |
96 | CWE-000 AWS_TEST_CASE ( mqtt_topic_tree_unsubscribe , s_mqtt_topic_tree_unsubscribe_fn ) static int s_mqtt_topic_tree_unsubscribe_fn ( struct aws_allocator * allocator , void * ctx ) { ( void ) ctx ; struct aws_mqtt_topic_tree tree ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_init ( & tree , allocator ) ) ; struct aws_string * topic_a_a = aws_string_new_from_array ( allocator , s_topic_a_a . ptr , s_topic_a_a . len ) ; struct aws_string * topic_a_a_a = aws_string_new_from_array ( allocator , s_topic_a_a_a . ptr , s_topic_a_a_a . len ) ; struct aws_string * topic_a_a_b = aws_string_new_from_array ( allocator , s_topic_a_a_b . ptr , s_topic_a_a_b . len ) ; AWS_VARIABLE_LENGTH_ARRAY ( uint8_t , transaction_buf , aws_mqtt_topic_tree_action_size * 3 ) ; struct aws_array_list transaction ; aws_array_list_init_static ( & transaction , transaction_buf , 3 , aws_mqtt_topic_tree_action_size ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_insert ( & tree , topic_a_a_a , AWS_MQTT_QOS_AT_MOST_ONCE , & on_publish , NULL , NULL ) ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_remove ( & tree , & s_topic_a_a_a ) ) ; topic_a_a_a = aws_string_new_from_array ( allocator , s_topic_a_a_a . ptr , s_topic_a_a_a . len ) ; ASSERT_UINT_EQUALS ( 0 , aws_hash_table_get_entry_count ( & tree . root -> subtopics ) ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_transaction_insert ( & tree , & transaction , topic_a_a_a , AWS_MQTT_QOS_AT_MOST_ONCE , & on_publish , NULL , NULL ) ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_transaction_insert ( & tree , & transaction , topic_a_a , AWS_MQTT_QOS_AT_MOST_ONCE , & on_publish , NULL , NULL ) ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_transaction_insert ( & tree , & transaction , topic_a_a_b , AWS_MQTT_QOS_AT_MOST_ONCE , & on_publish , NULL , NULL ) ) ; aws_mqtt_topic_tree_transaction_commit ( & tree , & transaction ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_transaction_remove ( & tree , & transaction , & s_topic_a_a_a ) ) ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_transaction_remove ( & tree , & transaction , & s_topic_a_a ) ) ; aws_mqtt_topic_tree_transaction_commit ( & tree , & transaction ) ; struct aws_mqtt_packet_publish publish ; aws_mqtt_packet_publish_init ( & publish , false , AWS_MQTT_QOS_AT_MOST_ONCE , false , s_topic_a_a_a , 1 , s_topic_a_a_a ) ; <S2SV_StartBug> was_called = false ; <S2SV_EndBug> ASSERT_SUCCESS ( aws_mqtt_topic_tree_publish ( & tree , & publish ) ) ; <S2SV_StartBug> ASSERT_FALSE ( was_called ) ; <S2SV_EndBug> publish . topic_name = s_topic_a_a_b ; was_called = false ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_publish ( & tree , & publish ) ) ; ASSERT_TRUE ( was_called ) ; aws_mqtt_topic_tree_clean_up ( & tree ) ; return AWS_OP_SUCCESS ; } | <S2SV_ModStart> s_topic_a_a_a ) ; times_called = 0 ; ASSERT_SUCCESS ( aws_mqtt_topic_tree_publish ( & tree , & publish ) ) ; ASSERT_INT_EQUALS ( times_called , 0 ) ; publish . topic_name = s_topic_a_a_b ; times_called <S2SV_ModEnd> = false ; <S2SV_ModStart> ) ) ; ASSERT_INT_EQUALS ( times_called , 1 <S2SV_ModEnd> ) ; aws_mqtt_topic_tree_clean_up |
97 | CWE-000 static void emit_got ( MonoAotCompile * acfg ) { char symbol [ MAX_SYMBOL_SIZE ] ; if ( acfg -> aot_opts . llvm_only ) return ; sprintf ( symbol , "%s" , acfg -> got_symbol ) ; # ifdef TARGET_MACH emit_unset_mode ( acfg ) ; fprintf ( acfg -> fp , ".section<S2SV_blank>__DATA,<S2SV_blank>__bss\\n" ) ; emit_alignment ( acfg , 8 ) ; if ( acfg -> llvm ) <S2SV_StartBug> emit_info_symbol ( acfg , "jit_got" ) ; <S2SV_EndBug> fprintf ( acfg -> fp , ".lcomm<S2SV_blank>%s,<S2SV_blank>%d\\n" , acfg -> got_symbol , ( int ) ( acfg -> got_offset * sizeof ( gpointer ) ) ) ; # else emit_section_change ( acfg , ".bss" , 0 ) ; emit_alignment ( acfg , 8 ) ; if ( acfg -> aot_opts . write_symbols ) emit_local_symbol ( acfg , symbol , "got_end" , FALSE ) ; emit_label ( acfg , symbol ) ; if ( acfg -> llvm ) emit_info_symbol ( acfg , "jit_got" , FALSE ) ; if ( acfg -> got_offset > 0 ) emit_zero_bytes ( acfg , ( int ) ( acfg -> got_offset * sizeof ( gpointer ) ) ) ; # endif sprintf ( symbol , "got_end" ) ; emit_label ( acfg , symbol ) ; } | <S2SV_ModStart> acfg , "jit_got" , FALSE |
98 | CWE-000 int main ( ) { inputPars par ; image * img = NULL ; <S2SV_StartBug> int nImages ; <S2SV_EndBug> silent = 0 ; mallocInputPars ( & par ) ; nImages = initParImg ( & par , & img ) ; run ( par , img , nImages ) ; free ( img ) ; free ( par . collPartIds ) ; free ( par . nMolWeights ) ; free ( par . dustWeights ) ; free ( par . moldatfile ) ; return 0 ; } | <S2SV_ModStart> ; int nImages <S2SV_ModEnd> ; mallocInputPars ( |
99 | CWE-000 static bool c_parser_gimple_compound_statement ( c_parser * parser , gimple_seq * seq ) { bool return_p = false ; if ( ! c_parser_require ( parser , CPP_OPEN_BRACE , "expected<S2SV_blank>%<{%>" ) ) return false ; while ( c_parser_next_tokens_start_declaration ( parser ) ) { c_parser_gimple_declaration ( parser ) ; if ( ! c_parser_require ( parser , CPP_SEMICOLON , "expected<S2SV_blank>%<;%>" ) ) return false ; } while ( c_parser_next_token_is_not ( parser , CPP_CLOSE_BRACE ) ) { if ( c_parser_error ( parser ) ) { c_parser_skip_until_found ( parser , CPP_CLOSE_BRACE , NULL ) ; return return_p ; } else if ( c_parser_next_token_is ( parser , CPP_EOF ) ) { c_parser_error ( parser , "expected<S2SV_blank>declaration<S2SV_blank>or<S2SV_blank>statement" ) ; return return_p ; } switch ( c_parser_peek_token ( parser ) -> type ) { case CPP_KEYWORD : switch ( c_parser_peek_token ( parser ) -> keyword ) { case RID_IF : c_parser_gimple_if_stmt ( parser , seq ) ; break ; case RID_SWITCH : c_parser_gimple_switch_stmt ( parser , seq ) ; break ; case RID_GOTO : { location_t loc = c_parser_peek_token ( parser ) -> location ; c_parser_consume_token ( parser ) ; if ( c_parser_next_token_is ( parser , CPP_NAME ) ) { c_parser_gimple_goto_stmt ( loc , c_parser_peek_token ( parser ) -> value , seq ) ; c_parser_consume_token ( parser ) ; if ( ! c_parser_require ( parser , CPP_SEMICOLON , "expected<S2SV_blank>%<;%>" ) ) return return_p ; } } break ; case RID_RETURN : return_p = true ; c_parser_gimple_return_stmt ( parser , seq ) ; if ( ! c_parser_require ( parser , CPP_SEMICOLON , "expected<S2SV_blank>%<;%>" ) ) return return_p ; break ; default : goto expr_stmt ; } break ; case CPP_NAME : if ( c_parser_peek_2nd_token ( parser ) -> type == CPP_COLON ) { c_parser_gimple_label ( parser , seq ) ; break ; } goto expr_stmt ; default : expr_stmt : c_parser_gimple_statement ( parser , seq ) ; if ( ! c_parser_require ( parser , CPP_SEMICOLON , "expected<S2SV_blank>%<;%>" ) ) <S2SV_StartBug> return return_p ; <S2SV_EndBug> } } c_parser_consume_token ( parser ) ; return return_p ; } | <S2SV_ModStart> "expected<S2SV_blank>%<;%>" ) ) c_parser_skip_until_found ( parser , CPP_SEMICOLON , NULL ) <S2SV_ModEnd> ; } } |
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 15