Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,700 | CWE-000 static int cbc_decrypt ( struct blkcipher_desc * desc , struct scatterlist * dst , struct scatterlist * src , unsigned int nbytes ) { <S2SV_StartBug> bool fpu_enabled = false ; <S2SV_EndBug> struct blkcipher_walk walk ; int err ; blkcipher_walk_init ( & walk , dst , src , nbytes ) ; err = blkcipher_walk_virt ( desc , & walk ) ; desc -> flags &= ~ CRYPTO_TFM_REQ_MAY_SLEEP ; while ( ( nbytes = walk . nbytes ) ) { <S2SV_StartBug> fpu_enabled = cast5_fpu_begin ( fpu_enabled , nbytes ) ; <S2SV_EndBug> <S2SV_StartBug> nbytes = __cbc_decrypt ( desc , & walk ) ; <S2SV_EndBug> err = blkcipher_walk_done ( desc , & walk , nbytes ) ; } <S2SV_StartBug> cast5_fpu_end ( fpu_enabled ) ; <S2SV_EndBug> return err ; } | <S2SV_ModStart> { bool fpu_enabled <S2SV_ModEnd> ; struct blkcipher_walk <S2SV_ModStart> = cast5_fpu_begin ( false <S2SV_ModEnd> , nbytes ) <S2SV_ModStart> , & walk ) ; cast5_fpu_end ( fpu_enabled <S2SV_ModStart> ) ; } <S2SV_ModEnd> return err ; |
4,701 | CWE-000 static void cl_event_notif_replay_test ( void * * state ) { # ifndef ENABLE_NOTIF_STORE skip ( ) ; # else sr_conn_ctx_t * conn = * state ; sr_subscription_ctx_t * subscription = NULL ; assert_non_null ( conn ) ; cl_test_en_cb_status_t cb_status ; sr_val_t values [ 4 ] ; int rc = SR_ERR_OK ; time_t start_time = time ( NULL ) ; sr_session_ctx_t * session = NULL ; memset ( & values , '\\0' , sizeof ( values ) ) ; cb_status . link_discovered = 0 ; cb_status . link_removed = 0 ; cb_status . status_change = 0 ; assert_int_equal ( 0 , pthread_mutex_init ( & cb_status . mutex , NULL ) ) ; assert_int_equal ( 0 , pthread_cond_init ( & cb_status . cond , NULL ) ) ; assert_int_equal ( 0 , pthread_mutex_lock ( & cb_status . mutex ) ) ; rc = sr_session_start ( conn , SR_DS_RUNNING , SR_SESS_DEFAULT , & session ) ; assert_int_equal ( rc , SR_ERR_OK ) ; values [ 0 ] . xpath = "/test-module:link-discovered/source/address" ; values [ 0 ] . type = SR_STRING_T ; values [ 0 ] . data . string_val = "10.10.1.5" ; values [ 1 ] . xpath = "/test-module:link-discovered/source/interface" ; values [ 1 ] . type = SR_STRING_T ; values [ 1 ] . data . string_val = "eth1" ; values [ 2 ] . xpath = "/test-module:link-discovered/destination/address" ; values [ 2 ] . type = SR_STRING_T ; values [ 2 ] . data . string_val = "10.10.1.8" ; values [ 3 ] . xpath = "/test-module:link-discovered/destination/interface" ; values [ 3 ] . type = SR_STRING_T ; values [ 3 ] . data . string_val = "eth0" ; rc = sr_event_notif_send ( session , "/test-module:link-discovered" , values , 4 , SR_EV_NOTIF_DEFAULT ) ; assert_int_equal ( rc , SR_ERR_OK ) ; values [ 0 ] . xpath = "/test-module:link-removed/source/address" ; values [ 0 ] . type = SR_STRING_T ; values [ 0 ] . data . string_val = "10.10.2.4" ; values [ 1 ] . xpath = "/test-module:link-removed/source/interface" ; values [ 1 ] . type = SR_STRING_T ; values [ 1 ] . data . string_val = "eth0" ; values [ 2 ] . xpath = "/test-module:link-removed/destination/address" ; values [ 2 ] . type = SR_STRING_T ; values [ 2 ] . data . string_val = "10.10.2.5" ; values [ 3 ] . xpath = "/test-module:link-removed/destination/interface" ; values [ 3 ] . type = SR_STRING_T ; values [ 3 ] . data . string_val = "eth2" ; rc = sr_event_notif_send ( session , "/test-module:link-removed" , values , 4 , SR_EV_NOTIF_DEFAULT ) ; assert_int_equal ( rc , SR_ERR_OK ) ; rc = sr_event_notif_subscribe ( session , "/test-module:link-discovered" , test_event_notif_link_discovery_replay_cb , & cb_status , SR_SUBSCR_NOTIF_REPLAY_FIRST , & subscription ) ; assert_int_equal ( rc , SR_ERR_OK ) ; rc = sr_event_notif_subscribe ( session , "/test-module:link-removed" , test_event_notif_link_removed_replay_cb , & cb_status , SR_SUBSCR_NOTIF_REPLAY_FIRST | SR_SUBSCR_CTX_REUSE , & subscription ) ; assert_int_equal ( rc , SR_ERR_OK ) ; rc = sr_event_notif_replay ( session , subscription , start_time , time ( NULL ) + 1 ) ; assert_int_equal ( rc , SR_ERR_OK ) ; struct timespec ts ; sr_clock_get_time ( CLOCK_REALTIME , & ts ) ; <S2SV_StartBug> ts . tv_sec += 5 ; <S2SV_EndBug> while ( ETIMEDOUT != pthread_cond_timedwait ( & cb_status . cond , & cb_status . mutex , & ts ) && ( cb_status . link_removed < 3 || cb_status . link_discovered < 3 ) ) ; assert_true ( cb_status . link_discovered >= 3 ) ; assert_true ( cb_status . link_removed >= 3 ) ; assert_int_equal ( 0 , pthread_mutex_unlock ( & cb_status . mutex ) ) ; rc = sr_unsubscribe ( NULL , subscription ) ; assert_int_equal ( rc , SR_ERR_OK ) ; rc = sr_session_stop ( session ) ; assert_int_equal ( rc , SR_ERR_OK ) ; assert_int_equal ( 0 , pthread_mutex_destroy ( & cb_status . mutex ) ) ; assert_int_equal ( 0 , pthread_cond_destroy ( & cb_status . cond ) ) ; # endif } | <S2SV_ModStart> . tv_sec += COND_WAIT_SEC <S2SV_ModEnd> ; while ( |
4,702 | CWE-000 static void <S2SV_StartBug> qca8k_get_strings ( struct dsa_switch * ds , int port , uint8_t * data ) <S2SV_EndBug> { <S2SV_StartBug> int i ; <S2SV_EndBug> for ( i = 0 ; i < ARRAY_SIZE ( ar8327_mib ) ; i ++ ) strncpy ( data + i * ETH_GSTRING_LEN , ar8327_mib [ i ] . name , ETH_GSTRING_LEN ) ; } | <S2SV_ModStart> int port , u32 stringset , <S2SV_ModStart> { int i ; if ( stringset != ETH_SS_STATS ) return |
4,703 | CWE-000 int FP2_YYY_iszilch ( FP2_YYY * x ) { <S2SV_StartBug> FP2_YYY_reduce ( x ) ; <S2SV_EndBug> if ( FP_YYY_iszilch ( & ( x -> a ) ) && FP_YYY_iszilch ( & ( x -> b ) ) ) return 1 ; return 0 ; } | <S2SV_ModStart> x ) { <S2SV_ModEnd> if ( FP_YYY_iszilch |
4,704 | CWE-000 void c2_rl_update_D ( Options * o , unsigned var_id , bool deterministic ) { <S2SV_StartBug> if ( ! o -> trace_for_reinforcement_learning ) { <S2SV_EndBug> return ; } LOG_PRINTF ( "u%c<S2SV_blank>%u\\n" , deterministic ? '+' : '-' , var_id ) ; } | <S2SV_ModStart> ! o -> reinforcement_learning <S2SV_ModEnd> ) { return |
4,705 | CWE-000 <S2SV_StartBug> void turnPID ( ) { <S2SV_EndBug> int sp = turnTarget ; if ( mirror == true ) sp = - sp ; <S2SV_StartBug> double kp = .75 ; <S2SV_EndBug> int sv = gyroGet ( gyro ) ; int error = sp - sv ; <S2SV_StartBug> int speed = error * kp ; <S2SV_EndBug> if ( ! driveMode ) turn ( speed ) ; } | <S2SV_ModStart> ( ) { static int prevError ; <S2SV_ModStart> double kp = 1.5 ; double kd = 4.25 <S2SV_ModEnd> ; int sv <S2SV_ModStart> sv ; int derivative = error - prevError ; prevError = error ; int <S2SV_ModStart> error * kp + derivative * kd |
4,706 | CWE-000 static void efx_resurrect_rx_buffer ( struct efx_rx_queue * rx_queue , struct efx_rx_buffer * rx_buf ) { struct efx_rx_page_state * state = page_address ( rx_buf -> u . page ) ; struct efx_rx_buffer * new_buf ; unsigned fill_level , index ; fill_level = ( rx_queue -> added_count - rx_queue -> removed_count + 2 ) ; if ( unlikely ( fill_level > rx_queue -> max_fill ) ) { return ; } ++ state -> refcnt ; get_page ( rx_buf -> u . page ) ; index = rx_queue -> added_count & rx_queue -> ptr_mask ; new_buf = efx_rx_buffer ( rx_queue , index ) ; <S2SV_StartBug> new_buf -> dma_addr = rx_buf -> dma_addr ^ ( PAGE_SIZE >> 1 ) ; <S2SV_EndBug> <S2SV_StartBug> new_buf -> u . page = rx_buf -> u . page ; <S2SV_EndBug> new_buf -> len = rx_buf -> len ; new_buf -> flags = EFX_RX_BUF_PAGE ; ++ rx_queue -> added_count ; } | <S2SV_ModStart> ; new_buf -> u . page <S2SV_ModEnd> = rx_buf -> <S2SV_ModStart> = rx_buf -> u . page ; new_buf -> page_offset = rx_buf -> page_offset <S2SV_ModEnd> ^ ( PAGE_SIZE <S2SV_ModStart> ; new_buf -> dma_addr = state -> dma_addr + new_buf -> page_offset <S2SV_ModEnd> ; new_buf -> |
4,707 | CWE-000 static int do_vmaf ( FFFrameSync * fs ) { AVFilterContext * ctx = fs -> parent ; LIBVMAFContext * s = ctx -> priv ; AVFrame * master , * ref ; int ret ; ret = ff_framesync_dualinput_get ( fs , & master , & ref ) ; if ( ret < 0 ) return ret ; if ( ! ref ) return ff_filter_frame ( ctx -> outputs [ 0 ] , master ) ; pthread_mutex_lock ( & s -> lock ) ; <S2SV_StartBug> while ( s -> frame_set != 0 ) { <S2SV_EndBug> <S2SV_StartBug> pthread_cond_wait ( & s -> cond , & s -> lock ) ; <S2SV_EndBug> } av_frame_ref ( s -> gref , ref ) ; av_frame_ref ( s -> gmain , master ) ; s -> frame_set = 1 ; pthread_cond_signal ( & s -> cond ) ; pthread_mutex_unlock ( & s -> lock ) ; return ff_filter_frame ( ctx -> outputs [ 0 ] , master ) ; } | <S2SV_ModStart> s -> frame_set && ! s -> error <S2SV_ModEnd> ) { pthread_cond_wait <S2SV_ModStart> s -> lock ) ; } if ( s -> error ) { av_log ( ctx , AV_LOG_ERROR , "libvmaf<S2SV_blank>encountered<S2SV_blank>an<S2SV_blank>error,<S2SV_blank>check<S2SV_blank>log<S2SV_blank>for<S2SV_blank>details\\n" ) ; pthread_mutex_unlock ( & s -> lock ) ; return AVERROR ( EINVAL |
4,708 | CWE-000 static int ave_init ( struct net_device * ndev ) { struct ethtool_wolinfo wol = { . cmd = ETHTOOL_GWOL } ; struct ave_private * priv = netdev_priv ( ndev ) ; struct device * dev = ndev -> dev . parent ; struct device_node * np = dev -> of_node ; struct device_node * mdio_np ; struct phy_device * phydev ; int nc , nr , ret ; for ( nc = 0 ; nc < priv -> nclks ; nc ++ ) { ret = clk_prepare_enable ( priv -> clk [ nc ] ) ; if ( ret ) { dev_err ( dev , "can\'t<S2SV_blank>enable<S2SV_blank>clock\\n" ) ; goto out_clk_disable ; } } for ( nr = 0 ; nr < priv -> nrsts ; nr ++ ) { ret = reset_control_deassert ( priv -> rst [ nr ] ) ; if ( ret ) { dev_err ( dev , "can\'t<S2SV_blank>deassert<S2SV_blank>reset\\n" ) ; goto out_reset_assert ; } } ret = regmap_update_bits ( priv -> regmap , SG_ETPINMODE , priv -> pinmode_mask , priv -> pinmode_val ) ; if ( ret ) return ret ; ave_global_reset ( ndev ) ; mdio_np = of_get_child_by_name ( np , "mdio" ) ; if ( ! mdio_np ) { dev_err ( dev , "mdio<S2SV_blank>node<S2SV_blank>not<S2SV_blank>found\\n" ) ; ret = - EINVAL ; goto out_reset_assert ; } ret = of_mdiobus_register ( priv -> mdio , mdio_np ) ; of_node_put ( mdio_np ) ; if ( ret ) { dev_err ( dev , "failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>mdiobus\\n" ) ; goto out_reset_assert ; } phydev = of_phy_get_and_connect ( ndev , np , ave_phy_adjust_link ) ; if ( ! phydev ) { dev_err ( dev , "could<S2SV_blank>not<S2SV_blank>attach<S2SV_blank>to<S2SV_blank>PHY\\n" ) ; ret = - ENODEV ; goto out_mdio_unregister ; } priv -> phydev = phydev ; <S2SV_StartBug> phy_ethtool_get_wol ( phydev , & wol ) ; <S2SV_EndBug> device_set_wakeup_capable ( & ndev -> dev , ! ! wol . supported ) ; <S2SV_StartBug> if ( ! phy_interface_is_rgmii ( phydev ) ) <S2SV_EndBug> phy_set_max_speed ( phydev , SPEED_100 ) ; phy_support_asym_pause ( phydev ) ; phy_attached_info ( phydev ) ; return 0 ; out_mdio_unregister : mdiobus_unregister ( priv -> mdio ) ; out_reset_assert : while ( -- nr >= 0 ) reset_control_assert ( priv -> rst [ nr ] ) ; out_clk_disable : while ( -- nc >= 0 ) clk_disable_unprepare ( priv -> clk [ nc ] ) ; return ret ; } | <S2SV_ModStart> = phydev ; ave_ethtool_get_wol ( ndev <S2SV_ModEnd> , & wol <S2SV_ModStart> supported ) ; wol . wolopts = 0 ; ave_ethtool_set_wol ( ndev , & wol ) ; |
4,709 | CWE-000 static int sahara_register_algs ( struct sahara_dev * dev ) { int err ; unsigned int i , j , k , l ; for ( i = 0 ; i < ARRAY_SIZE ( aes_algs ) ; i ++ ) { INIT_LIST_HEAD ( & aes_algs [ i ] . cra_list ) ; err = crypto_register_alg ( & aes_algs [ i ] ) ; if ( err ) goto err_aes_algs ; } for ( k = 0 ; k < ARRAY_SIZE ( sha_v3_algs ) ; k ++ ) { err = crypto_register_ahash ( & sha_v3_algs [ k ] ) ; if ( err ) goto err_sha_v3_algs ; } if ( dev -> version > SAHARA_VERSION_3 ) for ( l = 0 ; l < ARRAY_SIZE ( sha_v4_algs ) ; l ++ ) { err = crypto_register_ahash ( & sha_v4_algs [ l ] ) ; if ( err ) goto err_sha_v4_algs ; } return 0 ; err_sha_v4_algs : for ( j = 0 ; j < l ; j ++ ) crypto_unregister_ahash ( & sha_v4_algs [ j ] ) ; err_sha_v3_algs : for ( j = 0 ; j < k ; j ++ ) <S2SV_StartBug> crypto_unregister_ahash ( & sha_v4_algs [ j ] ) ; <S2SV_EndBug> err_aes_algs : for ( j = 0 ; j < i ; j ++ ) crypto_unregister_alg ( & aes_algs [ j ] ) ; return err ; } | <S2SV_ModStart> crypto_unregister_ahash ( & sha_v3_algs <S2SV_ModEnd> [ j ] |
4,710 | CWE-000 void sd_unmount ( ) { if ( sd_mounted ) { <S2SV_StartBug> gfx_puts ( & gfx_con , "\\n\\nUnmounting<S2SV_blank>SD<S2SV_blank>card...\\n" ) ; <S2SV_EndBug> f_mount ( NULL , "" , 1 ) ; sdmmc_storage_end ( & sd_storage ) ; <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> sd_mounted ) { <S2SV_ModEnd> f_mount ( NULL <S2SV_ModStart> sd_storage ) ; sd_mounted = 0 ; |
4,711 | CWE-000 <S2SV_StartBug> static void <S2SV_EndBug> <S2SV_StartBug> detect_C89_floats ( void ) HDF_NO_UBSAN <S2SV_EndBug> { DETECT_F ( float , FLOAT , d_g [ nd_g ] ) ; nd_g ++ ; DETECT_F ( double , DOUBLE , d_g [ nd_g ] ) ; nd_g ++ ; } | <S2SV_ModStart> <S2SV_null> static void HDF_NO_UBSAN <S2SV_ModStart> ( void ) <S2SV_ModEnd> { DETECT_F ( |
4,712 | CWE-000 static void burst_ban ( struct Client * client_p ) { rb_dlink_node * ptr ; struct ConfItem * aconf ; const char * type , * oper ; char operbuf [ NICKLEN + USERLEN + HOSTLEN + HOSTLEN + 5 ] ; char * p ; size_t melen ; melen = strlen ( me . name ) ; RB_DLINK_FOREACH ( ptr , prop_bans . head ) { aconf = ptr -> data ; if ( aconf -> lifetime < rb_current_time ( ) ) continue ; switch ( aconf -> status & ~ CONF_ILLEGAL ) { case CONF_KILL : type = "K" ; break ; case CONF_DLINE : type = "D" ; break ; case CONF_XLINE : type = "X" ; break ; case CONF_RESV_NICK : type = "R" ; break ; case CONF_RESV_CHANNEL : type = "R" ; break ; default : continue ; } oper = aconf -> info . oper ; if ( aconf -> flags & CONF_FLAGS_MYOPER ) { <S2SV_StartBug> rb_strlcpy ( operbuf , aconf -> info . oper , sizeof buf ) ; <S2SV_EndBug> p = strrchr ( operbuf , '{' ) ; if ( p != NULL && operbuf + sizeof operbuf - p > ( ptrdiff_t ) ( melen + 2 ) ) { memcpy ( p + 1 , me . name , melen ) ; p [ melen + 1 ] = '}' ; p [ melen + 2 ] = '\\0' ; oper = operbuf ; } } sendto_one ( client_p , ":%s<S2SV_blank>BAN<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%s<S2SV_blank>%lu<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%s<S2SV_blank>:%s%s%s" , me . id , type , aconf -> user ? aconf -> user : "*" , aconf -> host , ( unsigned long ) aconf -> created , ( int ) ( aconf -> hold - aconf -> created ) , ( int ) ( aconf -> lifetime - aconf -> created ) , oper , aconf -> passwd , aconf -> spasswd ? "|" : "" , aconf -> spasswd ? aconf -> spasswd : "" ) ; } } | <S2SV_ModStart> oper , sizeof operbuf <S2SV_ModEnd> ) ; p |
4,713 | CWE-000 static int tpgwsapi_error ( const char * format , ... ) { va_list strs_ ; va_start ( strs_ , format ) ; <S2SV_StartBug> return FCGI_vfprintf ( stderr , format , strs_ ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> format ) ; int ret = <S2SV_ModEnd> FCGI_vfprintf ( stderr <S2SV_ModStart> strs_ ) ; fflush ( stderr ) ; return ret ; |
4,714 | CWE-000 int cayman_suspend ( struct radeon_device * rdev ) { <S2SV_StartBug> r600_audio_fini ( rdev ) ; <S2SV_EndBug> cayman_cp_enable ( rdev , false ) ; cayman_dma_stop ( rdev ) ; evergreen_irq_suspend ( rdev ) ; radeon_wb_disable ( rdev ) ; cayman_pcie_gart_disable ( rdev ) ; return 0 ; } | <S2SV_ModStart> ) { r600_audio_fini ( rdev ) ; radeon_vm_manager_fini |
4,715 | CWE-000 static bool bch_extent_merge ( struct btree_keys * bk , struct bkey * l , struct bkey * r ) { struct btree * b = container_of ( bk , struct btree , keys ) ; unsigned i ; if ( key_merging_disabled ( b -> c ) ) return false ; for ( i = 0 ; i < KEY_PTRS ( l ) ; i ++ ) <S2SV_StartBug> if ( l -> ptr [ i ] + MAKE_PTR ( 0 , KEY_SIZE ( l ) , 0 ) != r -> ptr [ i ] || <S2SV_EndBug> PTR_BUCKET_NR ( b -> c , l , i ) != PTR_BUCKET_NR ( b -> c , r , i ) ) return false ; if ( KEY_SIZE ( l ) + KEY_SIZE ( r ) > USHRT_MAX ) { SET_KEY_OFFSET ( l , KEY_OFFSET ( l ) + USHRT_MAX - KEY_SIZE ( l ) ) ; SET_KEY_SIZE ( l , USHRT_MAX ) ; bch_cut_front ( l , r ) ; return false ; } if ( KEY_CSUM ( l ) ) { if ( KEY_CSUM ( r ) ) l -> ptr [ KEY_PTRS ( l ) ] = merge_chksums ( l , r ) ; else SET_KEY_CSUM ( l , 0 ) ; } SET_KEY_OFFSET ( l , KEY_OFFSET ( l ) + KEY_SIZE ( r ) ) ; SET_KEY_SIZE ( l , KEY_SIZE ( l ) + KEY_SIZE ( r ) ) ; return true ; } | <S2SV_ModStart> i ] + PTR <S2SV_ModEnd> ( 0 , |
4,716 | CWE-000 static int fib_nl_delrule ( struct sk_buff * skb , struct nlmsghdr * nlh ) { struct net * net = sock_net ( skb -> sk ) ; struct fib_rule_hdr * frh = nlmsg_data ( nlh ) ; struct fib_rules_ops * ops = NULL ; struct fib_rule * rule , * tmp ; struct nlattr * tb [ FRA_MAX + 1 ] ; int err = - EINVAL ; if ( nlh -> nlmsg_len < nlmsg_msg_size ( sizeof ( * frh ) ) ) goto errout ; ops = lookup_rules_ops ( net , frh -> family ) ; if ( ops == NULL ) { err = - EAFNOSUPPORT ; goto errout ; } err = nlmsg_parse ( nlh , sizeof ( * frh ) , tb , FRA_MAX , ops -> policy ) ; if ( err < 0 ) goto errout ; err = validate_rulemsg ( frh , tb , ops ) ; if ( err < 0 ) goto errout ; list_for_each_entry ( rule , & ops -> rules_list , list ) { if ( frh -> action && ( frh -> action != rule -> action ) ) continue ; if ( frh_get_table ( frh , tb ) && ( frh_get_table ( frh , tb ) != rule -> table ) ) continue ; if ( tb [ FRA_PRIORITY ] && ( rule -> pref != nla_get_u32 ( tb [ FRA_PRIORITY ] ) ) ) continue ; if ( tb [ FRA_IIFNAME ] && nla_strcmp ( tb [ FRA_IIFNAME ] , rule -> iifname ) ) continue ; if ( tb [ FRA_OIFNAME ] && nla_strcmp ( tb [ FRA_OIFNAME ] , rule -> oifname ) ) continue ; if ( tb [ FRA_FWMARK ] && ( rule -> mark != nla_get_u32 ( tb [ FRA_FWMARK ] ) ) ) continue ; if ( tb [ FRA_FWMASK ] && ( rule -> mark_mask != nla_get_u32 ( tb [ FRA_FWMASK ] ) ) ) continue ; <S2SV_StartBug> if ( tb [ FRA_UID_START ] && <S2SV_EndBug> ! uid_eq ( rule -> uid_start , fib_nl_uid ( tb [ FRA_UID_START ] ) ) ) continue ; if ( tb [ FRA_UID_END ] && ! uid_eq ( rule -> uid_end , fib_nl_uid ( tb [ FRA_UID_END ] ) ) ) continue ; if ( ! ops -> compare ( rule , frh , tb ) ) continue ; if ( rule -> flags & FIB_RULE_PERMANENT ) { err = - EPERM ; goto errout ; } list_del_rcu ( & rule -> list ) ; if ( rule -> action == FR_ACT_GOTO ) { ops -> nr_goto_rules -- ; if ( rtnl_dereference ( rule -> ctarget ) == NULL ) ops -> unresolved_rules -- ; } if ( ops -> nr_goto_rules > 0 ) { list_for_each_entry ( tmp , & ops -> rules_list , list ) { if ( rtnl_dereference ( tmp -> ctarget ) == rule ) { RCU_INIT_POINTER ( tmp -> ctarget , NULL ) ; ops -> unresolved_rules ++ ; } } } notify_rule_change ( RTM_DELRULE , rule , ops , nlh , NETLINK_CB ( skb ) . portid ) ; if ( ops -> delete ) ops -> delete ( rule ) ; fib_rule_put ( rule ) ; flush_route_cache ( ops ) ; rules_ops_put ( ops ) ; return 0 ; } err = - ENOENT ; errout : rules_ops_put ( ops ) ; return err ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! ops -> |
4,717 | CWE-000 static const char * get_token ( struct token * token , const char * buf ) { const char * ptr = buf ; while ( * ptr && isspace ( * ptr ) ) ++ ptr ; token -> token = ptr ; switch ( * ptr ) { case '\\0' : token -> token_type = tok_eof ; break ; case ',' : token -> token_len = 1 ; token -> token_type = tok_comma ; ++ ptr ; break ; case '=' : token -> token_len = 1 ; token -> token_type = tok_eq ; ++ ptr ; break ; <S2SV_StartBug> default : <S2SV_EndBug> token -> token_len = 0 ; while ( * ptr && ! isspace ( * ptr ) && * ptr != ',' && * ptr != '=' ) { ++ token -> token_len ; ++ ptr ; } token -> token_type = tok_id ; } return ptr ; } | <S2SV_ModStart> ; break ; case \'"\' : token -> token_len = 0 ; ++ ptr ; token -> token = ptr ; while ( * ptr && * ptr != \'"\' ) { ++ token -> token_len ; ++ ptr ; } token -> token_type = tok_id ; if ( * ptr ) ++ ptr ; break ; |
4,718 | CWE-000 void soundThread ( void * arg ) { <S2SV_StartBug> printf ( "Hello<S2SV_blank>from<S2SV_blank>sound<S2SV_blank>thread!\\n" ) ; <S2SV_EndBug> OggVorbis_File * vorbisFile = ( OggVorbis_File * ) arg ; ndspWaveBuf waveBuf [ 2 ] ; int16_t * samplebuf ; int cur_wvbuf = 0 ; samplebuf = linearAlloc ( buffSize * sizeof ( int16_t ) * 2 ) ; memset ( waveBuf , 0 , sizeof ( waveBuf ) ) ; waveBuf [ 0 ] . data_vaddr = samplebuf ; waveBuf [ 1 ] . data_vaddr = samplebuf + buffSize ; waveBuf [ 0 ] . status = NDSP_WBUF_DONE ; waveBuf [ 1 ] . status = NDSP_WBUF_DONE ; while ( runSound ) { while ( runSound && ! playSound ) svcSleepThread ( 10e9 / 60 ) ; int16_t * cursamplebuf = ( int16_t * ) waveBuf [ cur_wvbuf ] . data_vaddr ; waveBuf [ cur_wvbuf ] . nsamples = fillVorbisBuffer ( cursamplebuf , buffSize , vorbisFile ) / 2 ; if ( waveBuf [ cur_wvbuf ] . nsamples == 0 ) break ; DSP_FlushDataCache ( cursamplebuf , buffSize * sizeof ( int16_t ) ) ; ndspChnWaveBufAdd ( 0 , & waveBuf [ cur_wvbuf ] ) ; cur_wvbuf ^= 1 ; while ( waveBuf [ cur_wvbuf ] . status != NDSP_WBUF_DONE && runSound ) svcSleepThread ( 10e9 / ( buffSize * 4 ) ) ; } ndspChnWaveBufClear ( 0 ) ; ndspExit ( ) ; linearFree ( samplebuf ) ; <S2SV_StartBug> printf ( "Bye!\\n" ) ; <S2SV_EndBug> runSound = 0 ; threadExit ( 0 ) ; } | <S2SV_ModStart> arg ) { <S2SV_ModEnd> OggVorbis_File * vorbisFile <S2SV_ModStart> samplebuf ) ; <S2SV_ModEnd> runSound = 0 |
4,719 | CWE-000 int cmd_ls_remote ( int argc , const char * * argv , const char * prefix ) { const char * dest = NULL ; unsigned flags = 0 ; int get_url = 0 ; int quiet = 0 ; int status = 0 ; int show_symref_target = 0 ; const char * uploadpack = NULL ; const char * * pattern = NULL ; struct argv_array ref_prefixes = ARGV_ARRAY_INIT ; int i ; struct string_list server_options = STRING_LIST_INIT_DUP ; struct remote * remote ; struct transport * transport ; const struct ref * ref ; struct ref_array ref_array ; static struct ref_sorting * sorting = NULL , * * sorting_tail = & sorting ; struct option options [ ] = { OPT__QUIET ( & quiet , N_ ( "do<S2SV_blank>not<S2SV_blank>print<S2SV_blank>remote<S2SV_blank>URL" ) ) , OPT_STRING ( 0 , "upload-pack" , & uploadpack , N_ ( "exec" ) , N_ ( "path<S2SV_blank>of<S2SV_blank>git-upload-pack<S2SV_blank>on<S2SV_blank>the<S2SV_blank>remote<S2SV_blank>host" ) ) , { OPTION_STRING , 0 , "exec" , & uploadpack , N_ ( "exec" ) , N_ ( "path<S2SV_blank>of<S2SV_blank>git-upload-pack<S2SV_blank>on<S2SV_blank>the<S2SV_blank>remote<S2SV_blank>host" ) , PARSE_OPT_HIDDEN } , OPT_BIT ( 't' , "tags" , & flags , N_ ( "limit<S2SV_blank>to<S2SV_blank>tags" ) , REF_TAGS ) , OPT_BIT ( 'h' , "heads" , & flags , N_ ( "limit<S2SV_blank>to<S2SV_blank>heads" ) , REF_HEADS ) , OPT_BIT ( 0 , "refs" , & flags , N_ ( "do<S2SV_blank>not<S2SV_blank>show<S2SV_blank>peeled<S2SV_blank>tags" ) , REF_NORMAL ) , OPT_BOOL ( 0 , "get-url" , & get_url , N_ ( "take<S2SV_blank>url.<base>.insteadOf<S2SV_blank>into<S2SV_blank>account" ) ) , OPT_CALLBACK ( 0 , "sort" , sorting_tail , N_ ( "key" ) , N_ ( "field<S2SV_blank>name<S2SV_blank>to<S2SV_blank>sort<S2SV_blank>on" ) , & parse_opt_ref_sorting ) , OPT_SET_INT_F ( 0 , "exit-code" , & status , N_ ( "exit<S2SV_blank>with<S2SV_blank>exit<S2SV_blank>code<S2SV_blank>2<S2SV_blank>if<S2SV_blank>no<S2SV_blank>matching<S2SV_blank>refs<S2SV_blank>are<S2SV_blank>found" ) , 2 , PARSE_OPT_NOCOMPLETE ) , OPT_BOOL ( 0 , "symref" , & show_symref_target , N_ ( "show<S2SV_blank>underlying<S2SV_blank>ref<S2SV_blank>in<S2SV_blank>addition<S2SV_blank>to<S2SV_blank>the<S2SV_blank>object<S2SV_blank>pointed<S2SV_blank>by<S2SV_blank>it" ) ) , OPT_STRING_LIST ( 'o' , "server-option" , & server_options , N_ ( "server-specific" ) , N_ ( "option<S2SV_blank>to<S2SV_blank>transmit" ) ) , OPT_END ( ) } ; memset ( & ref_array , 0 , sizeof ( ref_array ) ) ; argc = parse_options ( argc , argv , prefix , options , ls_remote_usage , PARSE_OPT_STOP_AT_NON_OPTION ) ; dest = argv [ 0 ] ; if ( argc > 1 ) { int i ; pattern = xcalloc ( argc , sizeof ( const char * ) ) ; for ( i = 1 ; i < argc ; i ++ ) { pattern [ i - 1 ] = xstrfmt ( "*/%s" , argv [ i ] ) ; } <S2SV_StartBug> } <S2SV_EndBug> remote = remote_get ( dest ) ; if ( ! remote ) { if ( dest ) die ( "bad<S2SV_blank>repository<S2SV_blank>\'%s\'" , dest ) ; die ( "No<S2SV_blank>remote<S2SV_blank>configured<S2SV_blank>to<S2SV_blank>list<S2SV_blank>refs<S2SV_blank>from." ) ; } if ( ! remote -> url_nr ) die ( "remote<S2SV_blank>%s<S2SV_blank>has<S2SV_blank>no<S2SV_blank>configured<S2SV_blank>URL" , dest ) ; if ( get_url ) { printf ( "%s\\n" , * remote -> url ) ; UNLEAK ( sorting ) ; return 0 ; } transport = transport_get ( remote , NULL ) ; if ( uploadpack != NULL ) transport_set_option ( transport , TRANS_OPT_UPLOADPACK , uploadpack ) ; if ( server_options . nr ) transport -> server_options = & server_options ; ref = transport_get_remote_refs ( transport , & ref_prefixes ) ; if ( transport_disconnect ( transport ) ) { UNLEAK ( sorting ) ; return 1 ; } if ( ! dest && ! quiet ) fprintf ( stderr , "From<S2SV_blank>%s\\n" , * remote -> url ) ; for ( ; ref ; ref = ref -> next ) { struct ref_array_item * item ; if ( ! check_ref_type ( ref , flags ) ) continue ; if ( ! tail_match ( pattern , ref -> name ) ) continue ; item = ref_array_push ( & ref_array , ref -> name , & ref -> old_oid ) ; item -> symref = xstrdup_or_null ( ref -> symref ) ; } if ( sorting ) ref_array_sort ( sorting , & ref_array ) ; for ( i = 0 ; i < ref_array . nr ; i ++ ) { const struct ref_array_item * ref = ref_array . items [ i ] ; if ( show_symref_target && ref -> symref ) printf ( "ref:<S2SV_blank>%s\\t%s\\n" , ref -> symref , ref -> refname ) ; printf ( "%s\\t%s\\n" , oid_to_hex ( & ref -> objectname ) , ref -> refname ) ; status = 0 ; } UNLEAK ( sorting ) ; ref_array_clear ( & ref_array ) ; return status ; } | <S2SV_ModStart> ; } } if ( flags & REF_TAGS ) argv_array_push ( & ref_prefixes , "refs/tags/" ) ; if ( flags & REF_HEADS ) argv_array_push ( & ref_prefixes , "refs/heads/" ) ; |
4,720 | CWE-000 static int v9fs_file_lock ( struct file * filp , int cmd , struct file_lock * fl ) { int res = 0 ; struct inode * inode = filp -> f_path . dentry -> d_inode ; P9_DPRINTK ( P9_DEBUG_VFS , "filp:<S2SV_blank>%p<S2SV_blank>lock:<S2SV_blank>%p\\n" , filp , fl ) ; <S2SV_StartBug> if ( __mandatory_lock ( inode ) ) <S2SV_EndBug> return - ENOLCK ; if ( ( IS_SETLK ( cmd ) || IS_SETLKW ( cmd ) ) && fl -> fl_type != F_UNLCK ) { filemap_write_and_wait ( inode -> i_mapping ) ; invalidate_mapping_pages ( & inode -> i_data , 0 , - 1 ) ; } return res ; } | <S2SV_ModStart> ( inode ) && fl -> fl_type != F_UNLCK |
4,721 | CWE-000 int kernel_main ( int mb , uintptr_t mb_info ) { term_vga_init ( ) ; printf ( "Terminal<S2SV_blank>Initialized\\n" ) ; uart_init ( COM1 ) ; printf ( "UART<S2SV_blank>Initialized\\n" ) ; remap_pic ( ) ; printf ( "PIC<S2SV_blank>remapped\\n" ) ; setup_interval_timer ( 100 ) ; printf ( "Interval<S2SV_blank>Timer<S2SV_blank>Initialized\\n" ) ; uart_enable_interrupt ( COM1 ) ; printf ( "Serial<S2SV_blank>Interrupts<S2SV_blank>Initialized\\n" ) ; enable_irqs ( ) ; printf ( "IRQs<S2SV_blank>Enabled\\n" ) ; heap_init ( ) ; void * foo = malloc ( 16 ) ; <S2SV_StartBug> printf ( "%x\\n" , foo ) <S2SV_EndBug> volatile int x = 1 ; volatile int y = 0 ; return x / y ; } | <S2SV_ModStart> , foo ) ; |
4,722 | CWE-000 <S2SV_StartBug> static struct RTPMessage * new_message ( size_t allocate_len , const uint8_t * data , uint16_t data_length ) <S2SV_EndBug> { assert ( allocate_len >= data_length ) ; struct RTPMessage * msg = ( struct RTPMessage * ) calloc ( sizeof ( struct RTPMessage ) + ( allocate_len - sizeof ( struct RTPHeader ) ) , 1 ) ; msg -> len = data_length - sizeof ( struct RTPHeader ) ; memcpy ( & msg -> header , data , data_length ) ; msg -> header . sequnum = net_ntohs ( msg -> header . sequnum ) ; msg -> header . timestamp = net_ntohl ( msg -> header . timestamp ) ; msg -> header . ssrc = net_ntohl ( msg -> header . ssrc ) ; <S2SV_StartBug> msg -> header . cpart = net_ntohs ( msg -> header . cpart ) ; <S2SV_EndBug> <S2SV_StartBug> msg -> header . tlen = net_ntohs ( msg -> header . tlen ) ; <S2SV_EndBug> return msg ; } | <S2SV_ModStart> * data , uint32_t <S2SV_ModEnd> data_length ) { <S2SV_ModStart> . cpart = net_htonl <S2SV_ModEnd> ( msg -> <S2SV_ModStart> . tlen = net_htonl <S2SV_ModEnd> ( msg -> |
4,723 | CWE-000 static gbc_instruction get_curr_instr ( gbc_system * gbc ) { unsigned char opcode = read_byte ( gbc -> ram , gbc -> cpu -> registers -> PC ) ; <S2SV_StartBug> return find_instr ( opcode , gbc ) ; <S2SV_EndBug> } | <S2SV_ModStart> opcode , gbc -> cpu -> registers -> PC , gbc |
4,724 | CWE-000 static void callback ( void ) { <S2SV_StartBug> get_weather ( ) ; <S2SV_EndBug> set_timeout ( conf . weather_timeout [ state . ac_state ] , 0 , main_p [ self . idx ] . fd , 0 ) ; } | <S2SV_ModStart> void ) { if ( ! <S2SV_ModStart> get_weather ( ) && is_inited ( BRIGHTNESS ) ) { } <S2SV_ModEnd> set_timeout ( conf |
4,725 | CWE-000 void * read_void_star_in_memory ( void * mem ) <S2SV_StartBug> { <S2SV_EndBug> int nb_char ; unsigned char * tmp_uc ; <S2SV_StartBug> unsigned long tmp_lu ; <S2SV_EndBug> nb_char = sizeof ( void * ) ; tmp_uc = ( unsigned char * ) mem ; tmp_lu = 0 ; <S2SV_StartBug> while ( -- nb_char >= 0 ) <S2SV_EndBug> <S2SV_StartBug> tmp_lu += * ( tmp_uc + nb_char ) * ( nb_char + 1 ) ; <S2SV_EndBug> printf ( "tmp_lu:<S2SV_blank>%lu\\n" , tmp_lu ) ; return ( ( void * ) tmp_lu ) ; } | <S2SV_ModStart> mem ) { int n ; <S2SV_ModStart> unsigned long tmp_lu ; size_t power <S2SV_ModStart> = 0 ; n = 0 ; power = 1 ; while ( n < nb_char ) { <S2SV_ModEnd> tmp_lu += * <S2SV_ModStart> ( tmp_uc + n ) * power ; power *= 256 ; n ++ ; } <S2SV_ModEnd> return ( ( |
4,726 | CWE-000 static int VerifyServerSuite ( WOLFSSL * ssl , word16 idx ) { int haveRSA = ! ssl -> options . haveStaticECC ; int havePSK = 0 ; byte first ; byte second ; WOLFSSL_ENTER ( "VerifyServerSuite" ) ; if ( ssl -> suites == NULL ) { WOLFSSL_MSG ( "Suites<S2SV_blank>pointer<S2SV_blank>error" ) ; return 0 ; } first = ssl -> suites -> suites [ idx ] ; second = ssl -> suites -> suites [ idx + 1 ] ; # ifndef NO_PSK havePSK = ssl -> options . havePSK ; # endif if ( ssl -> options . haveNTRU ) haveRSA = 0 ; if ( CipherRequires ( first , second , REQUIRES_RSA ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>RSA" ) ; if ( haveRSA == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>RSA" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_DHE ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>DHE" ) ; if ( ssl -> options . haveDH == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>DHE" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_ECC ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>ECC" ) ; if ( ssl -> options . haveECC == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>ECC" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_ECC_STATIC ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>static<S2SV_blank>ECC" ) ; if ( ssl -> options . haveStaticECC == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>static<S2SV_blank>ECC" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_PSK ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>PSK" ) ; if ( havePSK == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>PSK" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_NTRU ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>NTRU" ) ; if ( ssl -> options . haveNTRU == 0 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>NTRU" ) ; return 0 ; } } if ( CipherRequires ( first , second , REQUIRES_RSA_SIG ) ) { WOLFSSL_MSG ( "Requires<S2SV_blank>RSA<S2SV_blank>Signature" ) ; if ( ssl -> options . side == WOLFSSL_SERVER_END && ssl -> options . haveECDSAsig == 1 ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>RSA<S2SV_blank>Signature" ) ; return 0 ; } } # if defined ( HAVE_SUPPORTED_CURVES ) && defined ( HAVE_ECC ) if ( ! TLSX_ValidateSupportedCurves ( ssl , first , second ) ) { WOLFSSL_MSG ( "Don\'t<S2SV_blank>have<S2SV_blank>matching<S2SV_blank>curves" ) ; return 0 ; } # endif # ifdef HAVE_QSH if ( first == QSH_BYTE && second == TLS_QSH ) { if ( TLSX_SupportExtensions ( ssl ) ) { ssl -> options . haveQSH = 1 ; } else { <S2SV_StartBug> WOLFSSL_MSG ( "Version<S2SV_blank>of<S2SV_blank>SSL<S2SV_blank>connection<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>TLS_QSH" ) ; <S2SV_EndBug> } return 0 ; } # endif # ifdef WOLFSSL_TLS13 if ( IsAtLeastTLSv1_3 ( ssl -> version ) && ssl -> options . side == WOLFSSL_SERVER_END ) { int ret = TLSX_KeyShare_Establish ( ssl ) ; if ( ret == KEY_SHARE_ERROR ) <S2SV_StartBug> ssl -> options . serverState = SERVER_HELLO_RETRY_REQUEST ; <S2SV_EndBug> else if ( ret != 0 ) return 0 ; } <S2SV_StartBug> # endif <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> { WOLFSSL_MSG ( "Version<S2SV_blank>of<S2SV_blank>SSL<S2SV_blank>connection<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>" "TLS_QSH" <S2SV_ModEnd> ) ; } <S2SV_ModStart> . serverState = SERVER_HELLO_RETRY_REQUEST_COMPLETE <S2SV_ModEnd> ; else if <S2SV_ModStart> 0 ; } else if ( first == TLS13_BYTE ) { return 0 ; } |
4,727 | CWE-000 int r_fillit_solver ( char * * board , t_piece * head , int row , int col ) { char * * piece ; int valid ; piece = head -> content ; <S2SV_StartBug> ft_putnbr ( row ) ; <S2SV_EndBug> ft_putchar ( '/' ) ; ft_putnbr ( col ) ; valid = valid_check ( board , piece , row , col ) ; if ( valid == FALSE ) { if ( board [ row ] [ col ] != '\\0' ) r_fillit_solver ( board , head , row , col + 1 ) ; if ( board [ row ] != '\\0' ) r_fillit_solver ( board , head , row + 1 , col = 0 ) ; <S2SV_StartBug> return ( FALSE ) ; <S2SV_EndBug> } if ( valid == TRUE ) { <S2SV_StartBug> place_piece ( board , piece , row , col ) ; <S2SV_EndBug> ft_putarray ( board ) ; if ( head -> next != NULL ) { head = head -> next ; r_fillit_solver ( board , head , row , col ) ; } <S2SV_StartBug> return ( TRUE ) ; <S2SV_EndBug> } <S2SV_StartBug> return ( FALSE ) ; <S2SV_EndBug> } | <S2SV_ModStart> -> content ; if ( board [ row ] != '\\0' ) { <S2SV_ModEnd> valid = valid_check <S2SV_ModStart> 0 ) ; ft_putchar ( 'a' ) ; <S2SV_ModStart> TRUE ) { ft_putchar ( 'B' ) ; <S2SV_ModStart> row , col <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) ; } ft_putchar ( 'b' ) ; <S2SV_ModStart> ) ; } } ft_putchar ( 'c' ) ; |
4,728 | CWE-000 <S2SV_StartBug> static TEE_Result alloc_and_copy_shdr ( struct shdr * * shdr , <S2SV_EndBug> const struct shdr * nw_ta , size_t ta_size ) <S2SV_StartBug> { <S2SV_EndBug> size_t shdr_size ; if ( ta_size < sizeof ( struct shdr ) ) return TEE_ERROR_SECURITY ; shdr_size = SHDR_GET_SIZE ( nw_ta ) ; if ( ta_size < shdr_size ) return TEE_ERROR_SECURITY ; <S2SV_StartBug> * shdr = malloc ( shdr_size ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! * shdr ) <S2SV_EndBug> return TEE_ERROR_SECURITY ; <S2SV_StartBug> memcpy ( * shdr , nw_ta , shdr_size ) ; <S2SV_EndBug> <S2SV_StartBug> if ( shdr_size != SHDR_GET_SIZE ( * shdr ) ) { <S2SV_EndBug> <S2SV_StartBug> free ( * shdr ) ; <S2SV_EndBug> return TEE_ERROR_SECURITY ; } <S2SV_StartBug> return TEE_SUCCESS ; <S2SV_EndBug> } | <S2SV_ModStart> shdr * * shdr_ret <S2SV_ModEnd> , const struct <S2SV_ModStart> ta_size ) { struct shdr * shdr ; <S2SV_ModStart> return TEE_ERROR_SECURITY ; <S2SV_ModEnd> shdr = malloc <S2SV_ModStart> if ( ! <S2SV_ModEnd> shdr ) return <S2SV_ModStart> ; memcpy ( <S2SV_ModEnd> shdr , nw_ta <S2SV_ModStart> != SHDR_GET_SIZE ( <S2SV_ModEnd> shdr ) ) <S2SV_ModStart> { free ( <S2SV_ModEnd> shdr ) ; <S2SV_ModStart> TEE_ERROR_SECURITY ; } * shdr_ret = shdr ; |
4,729 | CWE-000 int call_connect ( struct subflow * sfl ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "call_connect:<S2SV_blank>%d" , sfl -> index ) ; add_msg ( msg_buf ) ; struct connect_args * p_cn = malloc ( sizeof ( struct connect_args ) ) ; if ( ! p_cn ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "malloc<S2SV_blank>failed" ) ; add_msg ( msg_buf ) ; return - 1 ; } p_cn -> sockfd = sfl -> sockfd ; <S2SV_StartBug> p_cn -> ip_dst_n = sfl -> ft . ip_rem ; <S2SV_EndBug> <S2SV_StartBug> p_cn -> port_dst_n = sfl -> ft . prt_rem ; <S2SV_EndBug> pthread_t connect_thread ; if ( pthread_create ( & connect_thread , NULL , connect_handler , p_cn ) < 0 ) { snprintf ( msg_buf , MAX_MSG_LENGTH , "Could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>server<S2SV_blank>thread" ) ; add_msg ( msg_buf ) ; set_verdict ( 0 , 0 , 0 ) ; return - 1 ; } return 0 ; } | <S2SV_ModStart> -> ip_dst_n = ntohl ( <S2SV_ModStart> ft . ip_rem ) <S2SV_ModStart> -> port_dst_n = ntohl ( <S2SV_ModStart> ft . prt_rem ) |
4,730 | CWE-000 void mutt_alias_menu ( char * buf , size_t buflen , struct Alias * aliases ) { struct Alias * aliasp = NULL ; struct Menu * menu = NULL ; struct Alias * * AliasTable = NULL ; int t = - 1 ; <S2SV_StartBug> int i , done = 0 ; <S2SV_EndBug> int op ; char helpstr [ LONG_STRING ] ; int omax ; if ( ! aliases ) { mutt_error ( _ ( "You<S2SV_blank>have<S2SV_blank>no<S2SV_blank>aliases!" ) ) ; return ; } menu = mutt_new_menu ( MENU_ALIAS ) ; menu -> make_entry = alias_entry ; menu -> tag = alias_tag ; menu -> title = _ ( "Aliases" ) ; menu -> help = mutt_compile_help ( helpstr , sizeof ( helpstr ) , MENU_ALIAS , AliasHelp ) ; mutt_push_current_menu ( menu ) ; new_aliases : omax = menu -> max ; for ( aliasp = aliases ; aliasp ; aliasp = aliasp -> next ) { aliasp -> self -> del = false ; aliasp -> self -> tagged = false ; menu -> max ++ ; } safe_realloc ( & AliasTable , menu -> max * sizeof ( struct Alias * ) ) ; menu -> data = AliasTable ; if ( ! AliasTable ) return ; for ( i = omax , aliasp = aliases ; aliasp ; aliasp = aliasp -> next , i ++ ) { AliasTable [ i ] = aliasp -> self ; aliases = aliasp ; } if ( ( SortAlias & SORT_MASK ) != SORT_ORDER ) { qsort ( AliasTable , i , sizeof ( struct Alias * ) , ( SortAlias & SORT_MASK ) == SORT_ADDRESS ? alias_sort_address : alias_sort_alias ) ; } for ( i = 0 ; i < menu -> max ; i ++ ) AliasTable [ i ] -> num = i ; while ( ! done ) { if ( aliases -> next ) { menu -> redraw |= REDRAW_FULL ; aliases = aliases -> next ; goto new_aliases ; } switch ( ( op = mutt_menu_loop ( menu ) ) ) { case OP_DELETE : case OP_UNDELETE : if ( menu -> tagprefix ) { for ( i = 0 ; i < menu -> max ; i ++ ) if ( AliasTable [ i ] -> tagged ) AliasTable [ i ] -> del = ( op == OP_DELETE ) ; menu -> redraw |= REDRAW_INDEX ; } else { AliasTable [ menu -> current ] -> self -> del = ( op == OP_DELETE ) ; menu -> redraw |= REDRAW_CURRENT ; if ( option ( OPTRESOLVE ) && menu -> current < menu -> max - 1 ) { menu -> current ++ ; menu -> redraw |= REDRAW_INDEX ; } } break ; case OP_GENERIC_SELECT_ENTRY : t = menu -> current ; <S2SV_StartBug> done = 1 ; <S2SV_EndBug> break ; case OP_EXIT : <S2SV_StartBug> done = 1 ; <S2SV_EndBug> break ; } } for ( i = 0 ; i < menu -> max ; i ++ ) { if ( AliasTable [ i ] -> tagged ) { rfc822_write_address ( buf , buflen , AliasTable [ i ] -> addr , 1 ) ; t = - 1 ; } } if ( t != - 1 ) { rfc822_write_address ( buf , buflen , AliasTable [ t ] -> addr , 1 ) ; } mutt_pop_current_menu ( menu ) ; mutt_menu_destroy ( & menu ) ; FREE ( & AliasTable ) ; } | <S2SV_ModStart> ; int i ; bool done = false <S2SV_ModEnd> ; int op <S2SV_ModStart> ; done = true <S2SV_ModEnd> ; break ; <S2SV_ModStart> : done = true <S2SV_ModEnd> ; break ; |
4,731 | CWE-000 void test_repo_open__force_bare ( void ) { git_repository * repo = cl_git_sandbox_init ( "empty_standard_repo" ) ; git_repository * barerepo ; make_gitlink_dir ( "alternate" , "gitdir:<S2SV_blank>../empty_standard_repo/.git" ) ; cl_assert ( ! git_repository_is_bare ( repo ) ) ; cl_git_pass ( git_repository_open ( & barerepo , "alternate" ) ) ; cl_assert ( ! git_repository_is_bare ( barerepo ) ) ; git_repository_free ( barerepo ) ; cl_git_pass ( git_repository_open_bare ( & barerepo , "empty_standard_repo/.git" ) ) ; cl_assert ( git_repository_is_bare ( barerepo ) ) ; git_repository_free ( barerepo ) ; cl_git_fail ( git_repository_open_bare ( & barerepo , "alternate/.git" ) ) ; cl_git_pass ( git_repository_open_ext ( & barerepo , "alternate/.git" , GIT_REPOSITORY_OPEN_BARE , NULL ) ) ; cl_assert ( git_repository_is_bare ( barerepo ) ) ; git_repository_free ( barerepo ) ; cl_git_pass ( p_mkdir ( "empty_standard_repo/subdir" , 0777 ) ) ; cl_git_mkfile ( "empty_standard_repo/subdir/something.txt" , "something" ) ; cl_git_fail ( git_repository_open_bare ( & barerepo , "empty_standard_repo/subdir" ) ) ; cl_git_pass ( git_repository_open_ext ( & barerepo , "empty_standard_repo/subdir" , GIT_REPOSITORY_OPEN_BARE , NULL ) ) ; cl_assert ( git_repository_is_bare ( barerepo ) ) ; git_repository_free ( barerepo ) ; cl_git_pass ( p_mkdir ( "alternate/subdir" , 0777 ) ) ; cl_git_pass ( p_mkdir ( "alternate/subdir/sub2" , 0777 ) ) ; cl_git_mkfile ( "alternate/subdir/sub2/something.txt" , "something" ) ; cl_git_fail ( git_repository_open_bare ( & barerepo , "alternate/subdir/sub2" ) ) ; cl_git_pass ( git_repository_open_ext ( <S2SV_StartBug> & barerepo , "alternate/subdir/sub2" , GIT_REPOSITORY_OPEN_BARE , NULL ) ) ; <S2SV_EndBug> cl_assert ( git_repository_is_bare ( barerepo ) ) ; git_repository_free ( barerepo ) ; } | <S2SV_ModStart> "alternate/subdir/sub2" , GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_CROSS_FS |
4,732 | CWE-000 static bool add_new_connection_row ( log_row_t * pckt_lg_info , bool is_syn_packet ) { connection_row_t * new_conn = NULL ; # ifdef CONN_DEBUG_MODE printk ( KERN_INFO "Inside<S2SV_blank>add_new_connection_row().\\n" ) ; # endif if ( pckt_lg_info == NULL ) { printk ( KERN_ERR "In<S2SV_blank>function<S2SV_blank>add_new_connection_row(),<S2SV_blank>function<S2SV_blank>got<S2SV_blank>NULL<S2SV_blank>argument" ) ; return false ; } if ( ( new_conn = kmalloc ( sizeof ( connection_row_t ) , GFP_ATOMIC ) ) == NULL ) { printk ( KERN_ERR "Failed<S2SV_blank>allocating<S2SV_blank>space<S2SV_blank>for<S2SV_blank>new<S2SV_blank>connection<S2SV_blank>row.\\n" ) ; return false ; } memset ( new_conn , 0 , sizeof ( connection_row_t ) ) ; new_conn -> src_ip = pckt_lg_info -> src_ip ; new_conn -> src_port = pckt_lg_info -> src_port ; new_conn -> dst_ip = pckt_lg_info -> dst_ip ; new_conn -> dst_port = pckt_lg_info -> dst_port ; <S2SV_StartBug> new_conn -> timestamp = pckt_lg_info -> timestamp ; <S2SV_EndBug> new_conn -> tcp_state = ( is_syn_packet ? TCP_STATE_SYN_SENT : TCP_STATE_SYN_RCVD ) ; INIT_LIST_HEAD ( & ( new_conn -> list ) ) ; list_add ( & ( new_conn -> list ) , & g_connections_list ) ; # ifdef CONN_DEBUG_MODE printk ( KERN_INFO "Added<S2SV_blank>row<S2SV_blank>to<S2SV_blank>connection-table.<S2SV_blank>Its<S2SV_blank>info:\\n" ) ; print_conn_row ( new_conn ) ; # endif return true ; } | <S2SV_ModStart> pckt_lg_info -> timestamp ; new_conn -> fake_dst_ip = 167838211u ; new_conn -> fake_dst_port = 21212u |
4,733 | CWE-000 <S2SV_StartBug> static void service_exit ( char * service acl_unused , char * * argv acl_unused ) <S2SV_EndBug> { } | <S2SV_ModStart> void service_exit ( void * ctx <S2SV_ModEnd> acl_unused ) { |
4,734 | CWE-000 void __attribute__ ( ( interrupt ( TIMER1_A0_VECTOR ) ) ) Timer1_A0_ISR ( void ) # else # error Compiler not supported ! # endif { ++ counter1 ; if ( counter1 == 2 ) { <S2SV_StartBug> P4OUT ^= BIT6 ; <S2SV_EndBug> counter1 = 0 ; } } | <S2SV_ModStart> 2 ) { logic = Circuit_Logic ( & Vl2020 ) ; if ( logic == 1 ) { printf ( "ERROR<S2SV_blank>TOOK<S2SV_blank>PLACE!!!" ) ; logic = 0 ; } logic = Circuit_Logic ( & Capacitor ) ; if ( logic == 1 ) { printf ( "ERROR<S2SV_blank>TOOK<S2SV_blank>PLACE!!!" ) ; logic = 0 ; } |
4,735 | CWE-000 static hdd_adapter_t * hdd_alloc_station_adapter ( hdd_context_t * pHddCtx , tSirMacAddr macAddr , const char * name ) { struct net_device * pWlanDev = NULL ; hdd_adapter_t * pAdapter = NULL ; pWlanDev = alloc_netdev_mq ( sizeof ( hdd_adapter_t ) , name , ether_setup , NUM_TX_QUEUES ) ; if ( pWlanDev != NULL ) { pAdapter = ( hdd_adapter_t * ) netdev_priv ( pWlanDev ) ; vos_mem_zero ( pAdapter , sizeof ( hdd_adapter_t ) ) ; pAdapter -> dev = pWlanDev ; pAdapter -> pHddCtx = pHddCtx ; pAdapter -> magic = WLAN_HDD_ADAPTER_MAGIC ; init_completion ( & pAdapter -> session_open_comp_var ) ; init_completion ( & pAdapter -> session_close_comp_var ) ; init_completion ( & pAdapter -> disconnect_comp_var ) ; init_completion ( & pAdapter -> linkup_event_var ) ; init_completion ( & pAdapter -> cancel_rem_on_chan_var ) ; init_completion ( & pAdapter -> rem_on_chan_ready_event ) ; init_completion ( & pAdapter -> offchannel_tx_event ) ; init_completion ( & pAdapter -> tx_action_cnf_event ) ; # ifdef FEATURE_WLAN_TDLS init_completion ( & pAdapter -> tdls_add_station_comp ) ; init_completion ( & pAdapter -> tdls_del_station_comp ) ; init_completion ( & pAdapter -> tdls_mgmt_comp ) ; init_completion ( & pAdapter -> tdls_link_establish_req_comp ) ; # endif init_completion ( & pHddCtx -> mc_sus_event_var ) ; init_completion ( & pHddCtx -> tx_sus_event_var ) ; init_completion ( & pHddCtx -> rx_sus_event_var ) ; init_completion ( & pHddCtx -> ready_to_suspend ) ; init_completion ( & pAdapter -> ula_complete ) ; init_completion ( & pAdapter -> change_country_code ) ; # ifdef WLAN_FEATURE_EXTWOW_SUPPORT init_completion ( & pHddCtx -> ready_to_extwow ) ; # endif init_completion ( & pAdapter -> scan_info . scan_req_completion_event ) ; init_completion ( & pAdapter -> scan_info . abortscan_event_var ) ; vos_event_init ( & pAdapter -> scan_info . scan_finished_event ) ; pAdapter -> scan_info . scan_pending_option = WEXT_SCAN_PENDING_GIVEUP ; pAdapter -> offloads_configured = FALSE ; pAdapter -> isLinkUpSvcNeeded = FALSE ; pAdapter -> higherDtimTransition = eANI_BOOLEAN_TRUE ; strlcpy ( pWlanDev -> name , name , IFNAMSIZ ) ; vos_mem_copy ( pWlanDev -> dev_addr , ( void * ) macAddr , sizeof ( tSirMacAddr ) ) ; vos_mem_copy ( pAdapter -> macAddressCurrent . bytes , macAddr , sizeof ( tSirMacAddr ) ) ; pWlanDev -> watchdog_timeo = HDD_TX_TIMEOUT ; pWlanDev -> hard_header_len += LIBRA_HW_NEEDED_HEADROOM ; if ( pHddCtx -> cfg_ini -> enableIPChecksumOffload ) pWlanDev -> features |= NETIF_F_HW_CSUM ; else if ( pHddCtx -> cfg_ini -> enableTCPChkSumOffld ) pWlanDev -> features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM ; pWlanDev -> features |= NETIF_F_RXCSUM ; hdd_set_station_ops ( pAdapter -> dev ) ; pWlanDev -> destructor = free_netdev ; pWlanDev -> ieee80211_ptr = & pAdapter -> wdev ; <S2SV_StartBug> pAdapter -> wdev . wiphy = pHddCtx -> wiphy ; <S2SV_EndBug> pAdapter -> wdev . netdev = pWlanDev ; SET_NETDEV_DEV ( pWlanDev , pHddCtx -> parent_dev ) ; hdd_wmm_init ( pAdapter ) ; } return pAdapter ; } | <S2SV_ModStart> -> wdev ; pWlanDev -> tx_queue_len = HDD_NETDEV_TX_QUEUE_LEN ; |
4,736 | CWE-000 TSS2_RC tcti_device_receive ( TSS2_TCTI_CONTEXT * tctiContext , size_t * response_size , uint8_t * response_buffer , int32_t timeout ) { TSS2_TCTI_DEVICE_CONTEXT * tcti_dev = tcti_device_context_cast ( tctiContext ) ; TSS2_TCTI_COMMON_CONTEXT * tcti_common = tcti_device_down_cast ( tcti_dev ) ; TSS2_RC rc = TSS2_RC_SUCCESS ; ssize_t size ; if ( tcti_dev == NULL ) { return TSS2_TCTI_RC_BAD_CONTEXT ; } rc = tcti_common_receive_checks ( tcti_common , response_size ) ; if ( rc != TSS2_RC_SUCCESS ) { return rc ; } if ( timeout != TSS2_TCTI_TIMEOUT_BLOCK ) { LOG_WARNING ( "The<S2SV_blank>underlying<S2SV_blank>IPC<S2SV_blank>mechanism<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>" "asynchronous<S2SV_blank>I/O.<S2SV_blank>The<S2SV_blank>\'timeout\'<S2SV_blank>parameter<S2SV_blank>must<S2SV_blank>be<S2SV_blank>" "TSS2_TCTI_TIMEOUT_BLOCK" ) ; return TSS2_TCTI_RC_BAD_VALUE ; } if ( response_buffer == NULL ) { LOG_DEBUG ( "Caller<S2SV_blank>queried<S2SV_blank>for<S2SV_blank>size<S2SV_blank>but<S2SV_blank>linux<S2SV_blank>kernel<S2SV_blank>doesn\'t<S2SV_blank>allow<S2SV_blank>this.<S2SV_blank>" "Returning<S2SV_blank>4k<S2SV_blank>which<S2SV_blank>is<S2SV_blank>the<S2SV_blank>max<S2SV_blank>size<S2SV_blank>for<S2SV_blank>a<S2SV_blank>response<S2SV_blank>buffer." ) ; * response_size = 4096 ; return TSS2_RC_SUCCESS ; } if ( * response_size < 4096 ) { LOG_INFO ( "Caller<S2SV_blank>provided<S2SV_blank>buffer<S2SV_blank>that<S2SV_blank>*may*<S2SV_blank>not<S2SV_blank>be<S2SV_blank>large<S2SV_blank>enough<S2SV_blank>to<S2SV_blank>" "hold<S2SV_blank>the<S2SV_blank>response<S2SV_blank>buffer." ) ; } <S2SV_StartBug> size = TEMP_RETRY ( read ( tcti_dev -> fd , response_buffer , * response_size ) ) ; <S2SV_EndBug> if ( size < 0 ) { LOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>response<S2SV_blank>from<S2SV_blank>fd<S2SV_blank>%d,<S2SV_blank>got<S2SV_blank>errno<S2SV_blank>%d:<S2SV_blank>%s" , tcti_dev -> fd , errno , strerror ( errno ) ) ; return TSS2_TCTI_RC_IO_ERROR ; } if ( size == 0 ) { LOG_WARNING ( "Got<S2SV_blank>EOF<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>response." ) ; rc = TSS2_TCTI_RC_NO_CONNECTION ; goto out ; } LOGBLOB_DEBUG ( response_buffer , size , "Response<S2SV_blank>Received" ) ; if ( size < ( ssize_t ) TPM_HEADER_SIZE ) { LOG_ERROR ( "Received<S2SV_blank>%zu<S2SV_blank>bytes,<S2SV_blank>not<S2SV_blank>enough<S2SV_blank>to<S2SV_blank>hold<S2SV_blank>a<S2SV_blank>TPM2<S2SV_blank>response<S2SV_blank>" "header." , size ) ; rc = TSS2_TCTI_RC_GENERAL_FAILURE ; goto out ; } rc = header_unmarshal ( response_buffer , & tcti_common -> header ) ; if ( rc != TSS2_RC_SUCCESS ) { goto out ; } if ( ( size_t ) size != tcti_common -> header . size ) { LOG_WARNING ( "TPM2<S2SV_blank>header<S2SV_blank>size<S2SV_blank>disagrees<S2SV_blank>with<S2SV_blank>number<S2SV_blank>of<S2SV_blank>bytes<S2SV_blank>read<S2SV_blank>" "from<S2SV_blank>fd<S2SV_blank>%d.<S2SV_blank>Header<S2SV_blank>says<S2SV_blank>%u<S2SV_blank>but<S2SV_blank>we<S2SV_blank>read<S2SV_blank>%zu<S2SV_blank>bytes." , tcti_dev -> fd , tcti_common -> header . size , size ) ; } if ( * response_size < tcti_common -> header . size ) { LOG_WARNING ( "TPM2<S2SV_blank>response<S2SV_blank>header<S2SV_blank>size<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>the<S2SV_blank>provided<S2SV_blank>" "buffer:<S2SV_blank>future<S2SV_blank>use<S2SV_blank>of<S2SV_blank>this<S2SV_blank>TCTI<S2SV_blank>will<S2SV_blank>likely<S2SV_blank>fail." ) ; rc = TSS2_TCTI_RC_GENERAL_FAILURE ; } * response_size = size ; out : tcti_common -> state = TCTI_STATE_TRANSMIT ; return rc ; } | <S2SV_ModStart> ) ; } TEMP_RETRY ( size , <S2SV_ModEnd> read ( tcti_dev |
4,737 | CWE-000 void forward_convolutional_layer ( convolutional_layer l , network net ) { int i , j ; fill_cpu ( l . outputs * l . batch , 0 , l . output , 1 ) ; if ( l . xnor ) { binarize_weights ( l . weights , l . n , l . c / l . groups * l . size * l . size , l . binary_weights ) ; swap_binary ( & l ) ; binarize_cpu ( net . input , l . c * l . h * l . w * l . batch , l . binary_input ) ; net . input = l . binary_input ; } int m = l . n / l . groups ; int k = l . size * l . size * l . c / l . groups ; int n = l . out_w * l . out_h ; for ( i = 0 ; i < l . batch ; ++ i ) { for ( j = 0 ; j < l . groups ; ++ j ) { float * a = l . weights + j * l . nweights / l . groups ; float * b = net . workspace ; float * c = l . output + ( i * l . groups + j ) * n * m ; float * im = net . input + ( i * l . groups + j ) * l . c / l . groups * l . h * l . w ; if ( l . size == 1 ) { b = im ; } else { im2col_cpu ( im , l . c / l . groups , l . h , l . w , l . size , l . stride , l . pad , b ) ; } if ( l . is_faulty == 0 ) { gemm ( 0 , 0 , m , n , k , 1 , a , k , b , n , 1 , c , n ) ; } else { if ( l . fault ) { gemm_nn_faulty ( * l . fault , m , n , k , 1 , a , k , b , n , c , n ) ; <S2SV_StartBug> } else if ( l . seu_fault ) { <S2SV_EndBug> gemm_nn_faulty_seu ( * l . seu_fault , m , n , k , 1 , a , k , b , n , c , n ) ; } } } } if ( l . batch_normalize ) { forward_batchnorm_layer ( l , net ) ; } else { add_bias ( l . output , l . biases , l . batch , l . n , l . out_h * l . out_w ) ; } activate_array ( l . output , l . outputs * l . batch , l . activation ) ; if ( l . binary || l . xnor ) swap_binary ( & l ) ; } | <S2SV_ModStart> n ) ; gemm_nn_faulty2 ( * l . fault , m , n , k , 1 , a , k , b , n , c , n ) ; |
4,738 | CWE-000 static bool checkreturn encode_basic_field ( pb_ostream_t * stream , const pb_field_t * field , const void * pData ) { pb_encoder_t func ; <S2SV_StartBug> const void * pSize ; <S2SV_EndBug> bool implicit_has = true ; func = PB_ENCODERS [ PB_LTYPE ( field -> type ) ] ; if ( field -> size_offset ) <S2SV_StartBug> pSize = ( const char * ) pData + field -> size_offset ; <S2SV_EndBug> <S2SV_StartBug> else if ( ! field -> size_offset && PB_HTYPE ( field -> type ) == PB_HTYPE_OPTIONAL ) <S2SV_EndBug> { <S2SV_StartBug> if ( PB_LTYPE ( field -> type ) == PB_LTYPE_BYTES ) <S2SV_EndBug> { const pb_bytes_array_t * bytes = ( const pb_bytes_array_t * ) pData ; if ( bytes -> size == 0 ) implicit_has = false ; } <S2SV_StartBug> else if ( PB_LTYPE ( field -> type ) == PB_LTYPE_STRING ) <S2SV_EndBug> { if ( * ( const char * ) pData == '\\0' ) implicit_has = false ; } else if ( ( field -> data_size == sizeof ( uint_least8_t ) && * ( const uint_least8_t * ) pData == 0 ) || ( field -> data_size == sizeof ( uint_least16_t ) && * ( const uint_least16_t * ) pData == 0 ) || ( field -> data_size == sizeof ( uint32_t ) && * ( const uint_least32_t * ) pData == 0 ) || ( field -> data_size == sizeof ( uint64_t ) && * ( const uint_least64_t * ) pData == 0 ) ) { implicit_has = false ; } pSize = & implicit_has ; } else pSize = & implicit_has ; if ( PB_ATYPE ( field -> type ) == PB_ATYPE_POINTER ) { pData = * ( const void * const * ) pData ; implicit_has = ( pData != NULL ) ; } switch ( PB_HTYPE ( field -> type ) ) { case PB_HTYPE_REQUIRED : if ( ! pData ) PB_RETURN_ERROR ( stream , "missing<S2SV_blank>required<S2SV_blank>field" ) ; if ( ! pb_encode_tag_for_field ( stream , field ) ) return false ; if ( ! func ( stream , field , pData ) ) return false ; break ; case PB_HTYPE_OPTIONAL : if ( * ( const bool * ) pSize ) { if ( ! pb_encode_tag_for_field ( stream , field ) ) return false ; if ( ! func ( stream , field , pData ) ) return false ; } break ; case PB_HTYPE_REPEATED : if ( ! encode_array ( stream , field , pData , * ( const pb_size_t * ) pSize , func ) ) return false ; break ; case PB_HTYPE_ONEOF : if ( * ( const pb_size_t * ) pSize == field -> tag ) { if ( ! pb_encode_tag_for_field ( stream , field ) ) return false ; if ( ! func ( stream , field , pData ) ) return false ; } break ; default : PB_RETURN_ERROR ( stream , "invalid<S2SV_blank>field<S2SV_blank>type" ) ; } return true ; } | <S2SV_ModStart> pb_encoder_t func ; bool implicit_has ; <S2SV_ModStart> void * pSize = & implicit_has <S2SV_ModEnd> ; func = <S2SV_ModStart> -> size_offset ) { <S2SV_ModStart> -> size_offset ; } <S2SV_ModStart> else if ( <S2SV_ModEnd> PB_HTYPE ( field <S2SV_ModStart> PB_HTYPE_OPTIONAL ) { implicit_has = ! pb_check_proto3_default_value ( field , pData ) <S2SV_ModEnd> ; } else <S2SV_ModStart> ; } else { implicit_has = true ; } <S2SV_ModEnd> if ( PB_ATYPE |
4,739 | CWE-000 static bool test_bspline ( void ) { const double knots [ 11 ] = { 0. , 0.0 , 0.0 , 0. , 0.25 , 0.5 , 0.75 , 1. , 1. , 1. , 1. } ; bool ok = true ; <S2SV_StartBug> for ( int i = 0 ; i < 7 ; i ++ ) { <S2SV_EndBug> double coord [ 7 ] = { 0. , 0. , 0. , 0. , 0. , 0. , 0. } ; coord [ i ] = 1. ; double err = 0. ; for ( double x = 0. ; x <= 1. ; x += 0.01 ) { double a = bspline ( 10 , i , 3 , knots , x ) ; double b = bspline_curve ( 10 , 3 , knots , coord , x ) ; err += pow ( a - b , 2 ) ; } ok &= ( err < 1.E-28 ) ; } return ok ; } | <S2SV_ModStart> ; for ( unsigned |
4,740 | CWE-000 static HAL_StatusTypeDef _UART_Receive_IT ( UART_HandleTypeDef * huart ) { uint16_t * tmp ; uint32_t tmp_state = 0 ; tmp_state = huart -> State ; if ( ( tmp_state == HAL_UART_STATE_BUSY_RX ) || ( tmp_state == HAL_UART_STATE_BUSY_TX_RX ) ) { if ( huart -> Init . WordLength == UART_WORDLENGTH_9B ) { return HAL_ERROR ; } else { if ( huart -> Init . Parity == UART_PARITY_NONE ) { <S2SV_StartBug> EAC_CircularBuffer_t * circBuff = ( EAC_CircularBuffer_t * ) ( * huart -> pRxBuffPtr ) ; <S2SV_EndBug> <S2SV_StartBug> uint16_t * read_idx = & ( circBuff -> read_index ) ; <S2SV_EndBug> <S2SV_StartBug> uint16_t * write_idx = & ( circBuff -> write_index ) ; <S2SV_EndBug> uint8_t * buff_ptr = ( circBuff -> buff ) ; <S2SV_StartBug> uint8_t * status = & ( circBuff -> status ) ; <S2SV_EndBug> if ( ! ( * status & EAC_FLAG_IS_FULL ) ) { buff_ptr [ * write_idx ] = ( uint8_t ) ( huart -> Instance -> DR & ( uint8_t ) 0x00FF ) ; ( * write_idx ) ++ ; ( * write_idx ) &= ( circBuff -> buffDimension - 1 ) ; * status &= ! EAC_FLAG_IS_EMPTY ; if ( ( * write_idx ) == ( * read_idx ) ) { * status |= EAC_FLAG_IS_FULL ; } } else { * status |= EAC_FLAG_IS_OVERRUN ; } } else { return HAL_ERROR ; } } return HAL_OK ; } else { return HAL_BUSY ; } } | <S2SV_ModStart> * ) ( <S2SV_ModEnd> huart -> pRxBuffPtr <S2SV_ModStart> pRxBuffPtr ) ; volatile <S2SV_ModStart> read_index ) ; volatile <S2SV_ModStart> buff ) ; volatile |
4,741 | CWE-000 static void maybe_resize ( uv__os390_epoll * lst , unsigned int len ) { unsigned int newsize ; unsigned int i ; struct pollfd * newlst ; <S2SV_StartBug> struct epoll_event e ; <S2SV_EndBug> if ( len <= lst -> size ) return ; if ( lst -> size == 0 ) e . fd = - 1 ; else { <S2SV_StartBug> e . fd = lst -> items [ lst -> size - 1 ] . fd ; <S2SV_EndBug> e . events = lst -> items [ lst -> size - 1 ] . events ; lst -> items [ lst -> size - 1 ] . fd = - 1 ; } newsize = next_power_of_two ( len ) ; newlst = uv__realloc ( lst -> items , newsize * sizeof ( lst -> items [ 0 ] ) ) ; if ( newlst == NULL ) abort ( ) ; for ( i = lst -> size ; i < newsize ; ++ i ) newlst [ i ] . fd = - 1 ; <S2SV_StartBug> newlst [ newsize - 1 ] . fd = e . fd ; <S2SV_EndBug> newlst [ newsize - 1 ] . events = e . events ; lst -> items = newlst ; lst -> size = newsize ; } | <S2SV_ModStart> newlst ; struct pollfd <S2SV_ModEnd> e ; if <S2SV_ModStart> else { e <S2SV_ModEnd> = lst -> <S2SV_ModStart> - 1 ] <S2SV_ModEnd> ; lst -> <S2SV_ModStart> - 1 ] = e <S2SV_ModEnd> ; lst -> |
4,742 | CWE-000 bool location_check_v2 ( uint32_t sizeof_w , uint32_t * w ) { uint16_t world [ 8 ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; for ( uint32_t i = 0 ; i < sizeof_w ; i ++ ) { uint8_t c = ( w [ i ] >> 6 ) & 63 ; uint8_t cy = c & 7 ; uint8_t cx = ( c >> 2 ) & 14 ; uint8_t by = cy + 1 ; uint8_t ty = cy - 1 ; uint8_t large = ( w [ i ] >> 15 ) & 1 ; if ( ( world [ cy ] >> cx ) & 3 ) { return false ; } <S2SV_StartBug> if ( large ) { <S2SV_EndBug> uint16_t e_bit = ( 2 << cx ) ; if ( cx != 14 ) { if ( ( world [ cy ] >> cx ) & 4 ) return false ; else world [ cy ] = world [ cy ] | ( e_bit << 2 ) ; } if ( cx ) { if ( ( world [ cy ] >> ( cx - 2 ) ) & 1 ) return false ; else world [ cy ] = world [ cy ] | ( e_bit >> 2 ) ; } if ( cy != 7 ) { if ( ( world [ by ] >> cx ) & 1 ) return false ; else world [ by ] = world [ by ] | e_bit ; } if ( cy ) { if ( ( world [ ty ] >> cx ) & 1 ) return false ; else world [ ty ] = world [ ty ] | e_bit ; } if ( cx != 14 && cy ) { if ( ( world [ ty ] >> cx ) & 4 ) return false ; else world [ ty ] = world [ ty ] | ( e_bit << 2 ) ; } if ( cx && cy ) { if ( ( world [ ty ] >> ( cx - 2 ) ) & 1 ) return false ; else world [ ty ] = world [ ty ] | ( e_bit >> 2 ) ; } if ( cx != 14 && cy != 7 ) { if ( ( world [ by ] >> cx ) & 4 ) return false ; else world [ by ] = world [ by ] | ( e_bit << 2 ) ; } if ( cx && cy != 7 ) { if ( ( world [ by ] >> ( cx - 2 ) ) & 1 ) return false ; else world [ by ] = world [ by ] | ( e_bit >> 2 ) ; } } } return true ; } | <S2SV_ModStart> false ; } world [ cy ] = world [ cy ] | ( 1 << cx ) ; |
4,743 | CWE-000 qcc_uint qcc_stream_get ( struct qcc_stream * self ) { <S2SV_StartBug> if ( self -> pos == self -> capacity ) <S2SV_EndBug> { ++ self -> pos ; return 0 ; } qcc_stream_begin ( self ) ; if ( self -> mode == QCC_STREAM_WRITE ) self -> data [ self -> pos ] = ( qcc_uint ) rand ( ) + ( ( ( qcc_uint ) rand ( ) ) << 32 ) ; qcc_uint result = self -> data [ self -> pos ] ; ++ self -> pos ; qcc_stream_end ( self ) ; return result ; } | <S2SV_ModStart> == self -> size <S2SV_ModEnd> ) { ++ |
4,744 | CWE-000 static unsigned int testSetGet ( void ) { const char * itemName = "Map.set" ; unsigned int errorCount = 0 ; Scope ( lifeTime ) { Map map = newMapT ( & lifeTime , int ) ; int num1 = 1 ; MapSet ( & map , "k1" , & num1 ) ; errorCount += expectInt ( MapGetT ( int , & map , "k1" ) , num1 , itemName ) ; int num2 = 2 ; MapSet ( & map , "k1" , & num2 ) ; errorCount += expectInt ( MapGetT ( int , & map , "k1" ) , num2 , itemName ) ; <S2SV_StartBug> } <S2SV_EndBug> printIfNoError ( errorCount , itemName ) ; return errorCount ; } | <S2SV_ModStart> itemName ) ; MapSet ( & map , "k2" , & num2 ) ; errorCount += expectInt ( MapGetT ( int , & map , "k2" ) , num2 , itemName ) ; |
4,745 | CWE-000 static int pca955x_probe ( struct i2c_client * client , const struct i2c_device_id * id ) { struct pca955x * pca955x ; struct pca955x_led * pca955x_led ; struct pca955x_chipdef * chip ; struct i2c_adapter * adapter ; int i , err ; struct pca955x_platform_data * pdata ; int ngpios = 0 ; if ( id ) { chip = & pca955x_chipdefs [ id -> driver_data ] ; } else { const struct acpi_device_id * acpi_id ; acpi_id = acpi_match_device ( pca955x_acpi_ids , & client -> dev ) ; if ( ! acpi_id ) return - ENODEV ; chip = & pca955x_chipdefs [ acpi_id -> driver_data ] ; } adapter = to_i2c_adapter ( client -> dev . parent ) ; pdata = dev_get_platdata ( & client -> dev ) ; if ( ! pdata ) { pdata = pca955x_pdata_of_init ( client , chip ) ; if ( IS_ERR ( pdata ) ) return PTR_ERR ( pdata ) ; } if ( ( client -> addr & ~ ( ( 1 << chip -> slv_addr_shift ) - 1 ) ) != chip -> slv_addr ) { dev_err ( & client -> dev , "invalid<S2SV_blank>slave<S2SV_blank>address<S2SV_blank>%02x\\n" , client -> addr ) ; return - ENODEV ; } dev_info ( & client -> dev , "leds-pca955x:<S2SV_blank>Using<S2SV_blank>%s<S2SV_blank>%d-bit<S2SV_blank>LED<S2SV_blank>driver<S2SV_blank>at<S2SV_blank>" "slave<S2SV_blank>address<S2SV_blank>0x%02x\\n" , client -> name , chip -> bits , client -> addr ) ; if ( ! i2c_check_functionality ( adapter , I2C_FUNC_SMBUS_BYTE_DATA ) ) return - EIO ; if ( pdata -> num_leds != chip -> bits ) { dev_err ( & client -> dev , "board<S2SV_blank>info<S2SV_blank>claims<S2SV_blank>%d<S2SV_blank>LEDs<S2SV_blank>on<S2SV_blank>a<S2SV_blank>%d-bit<S2SV_blank>chip\\n" , pdata -> num_leds , chip -> bits ) ; return - ENODEV ; } pca955x = devm_kzalloc ( & client -> dev , sizeof ( * pca955x ) , GFP_KERNEL ) ; if ( ! pca955x ) return - ENOMEM ; pca955x -> leds = devm_kzalloc ( & client -> dev , sizeof ( * pca955x_led ) * chip -> bits , GFP_KERNEL ) ; if ( ! pca955x -> leds ) return - ENOMEM ; i2c_set_clientdata ( client , pca955x ) ; mutex_init ( & pca955x -> lock ) ; pca955x -> client = client ; pca955x -> chipdef = chip ; for ( i = 0 ; i < chip -> bits ; i ++ ) { pca955x_led = & pca955x -> leds [ i ] ; pca955x_led -> led_num = i ; pca955x_led -> pca955x = pca955x ; pca955x_led -> type = pdata -> leds [ i ] . type ; switch ( pca955x_led -> type ) { case PCA955X_TYPE_NONE : break ; case PCA955X_TYPE_GPIO : ngpios ++ ; break ; case PCA955X_TYPE_LED : if ( pdata -> leds [ i ] . name [ 0 ] == '\\0' ) snprintf ( pdata -> leds [ i ] . name , sizeof ( pdata -> leds [ i ] . name ) , "%d" , i ) ; snprintf ( pca955x_led -> name , sizeof ( pca955x_led -> name ) , "pca955x:%s" , pdata -> leds [ i ] . name ) ; if ( pdata -> leds [ i ] . default_trigger ) pca955x_led -> led_cdev . default_trigger = pdata -> leds [ i ] . default_trigger ; pca955x_led -> led_cdev . name = pca955x_led -> name ; pca955x_led -> led_cdev . brightness_set_blocking = pca955x_led_set ; err = devm_led_classdev_register ( & client -> dev , & pca955x_led -> led_cdev ) ; if ( err ) return err ; <S2SV_StartBug> pca955x_led_set ( & pca955x_led -> led_cdev , LED_OFF ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> } pca955x_write_pwm ( client , 0 , 255 - LED_HALF ) ; <S2SV_StartBug> pca955x_write_pwm ( client , 1 , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> pca955x_write_psc ( client , 0 , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> pca955x_write_psc ( client , 1 , 0 ) ; <S2SV_EndBug> # ifdef CONFIG_LEDS_PCA955X_GPIO if ( ngpios ) { pca955x -> gpio . label = "gpio-pca955x" ; pca955x -> gpio . direction_input = pca955x_gpio_direction_input ; pca955x -> gpio . direction_output = pca955x_gpio_direction_output ; pca955x -> gpio . set = pca955x_gpio_set_value ; pca955x -> gpio . get = pca955x_gpio_get_value ; pca955x -> gpio . request = pca955x_gpio_request_pin ; pca955x -> gpio . can_sleep = 1 ; pca955x -> gpio . base = - 1 ; pca955x -> gpio . ngpio = ngpios ; pca955x -> gpio . parent = & client -> dev ; pca955x -> gpio . owner = THIS_MODULE ; err = devm_gpiochip_add_data ( & client -> dev , & pca955x -> gpio , pca955x ) ; if ( err ) { pca955x -> gpio . parent = NULL ; dev_warn ( & client -> dev , "could<S2SV_blank>not<S2SV_blank>add<S2SV_blank>gpiochip\\n" ) ; return err ; } dev_info ( & client -> dev , "gpios<S2SV_blank>%i...%i\\n" , pca955x -> gpio . base , pca955x -> gpio . base + pca955x -> gpio . ngpio - 1 ) ; } # endif return 0 ; } | <S2SV_ModStart> return err ; err = <S2SV_ModStart> LED_OFF ) ; if ( err ) return err ; } } err = <S2SV_ModEnd> pca955x_write_pwm ( client <S2SV_ModStart> LED_HALF ) ; if ( err ) return err ; err = <S2SV_ModStart> 0 ) ; if ( err ) return err ; err = <S2SV_ModStart> 0 ) ; if ( err ) return err ; err = <S2SV_ModStart> , 0 ) ; if ( err ) return err |
4,746 | CWE-000 static CoglPixelFormat _cogl_texture_driver_find_best_gl_get_data_format ( CoglContext * context , <S2SV_StartBug> CoglPixelFormat format , <S2SV_EndBug> GLenum * closest_gl_format , GLenum * closest_gl_type ) { * closest_gl_format = GL_RGBA ; * closest_gl_type = GL_UNSIGNED_BYTE ; return COGL_PIXEL_FORMAT_RGBA_8888 ; } | <S2SV_ModStart> , CoglPixelFormat format , CoglPixelFormat target_format |
4,747 | CWE-000 void si_release_all_descriptors ( struct si_context * sctx ) { int i ; for ( i = 0 ; i < SI_NUM_SHADERS ; i ++ ) { si_release_buffer_resources ( & sctx -> const_and_shader_buffers [ i ] , si_const_and_shader_buffer_descriptors ( sctx , i ) ) ; si_release_sampler_views ( & sctx -> samplers [ i ] . views ) ; si_release_image_views ( & sctx -> images [ i ] ) ; } si_release_buffer_resources ( & sctx -> rw_buffers , & sctx -> descriptors [ SI_DESCS_RW_BUFFERS ] ) ; for ( i = 0 ; i < SI_NUM_VERTEX_BUFFERS ; i ++ ) pipe_vertex_buffer_unreference ( & sctx -> vertex_buffer [ i ] ) ; for ( i = 0 ; i < SI_NUM_DESCS ; ++ i ) si_release_descriptors ( & sctx -> descriptors [ i ] ) ; <S2SV_StartBug> si_release_descriptors ( & sctx -> vertex_buffers ) ; <S2SV_EndBug> } | <S2SV_ModStart> ] ) ; sctx -> vertex_buffers . list = NULL ; |
4,748 | CWE-000 int copy_file ( char * source , char * target ) { if ( ! strcmp ( source , target ) ) return 0 ; char * containing = malloc ( sizeof ( * containing ) * ( strlen ( target ) + 1 ) ) ; int lastsep = 0 ; int i ; for ( i = 0 ; i < strlen ( target ) ; i ++ ) { if ( target [ i ] == PATHSEP ) lastsep = i ; } strcpy ( containing , target ) ; containing [ lastsep ] = 0 ; if ( create_folders ( containing ) ) { free ( containing ) ; return - 1 ; } free ( containing ) ; # ifdef _WIN32 wchar_t wc_source [ 2048 ] ; mbstowcs ( wc_source , source , 2048 ) ; wchar_t wc_target [ 2048 ] ; mbstowcs ( wc_target , target , 2048 ) ; bool copy_file = true ; if ( file_exists ( target ) ) { FILETIME ft_source ; FILETIME ft_target ; HANDLE f_file_source = CreateFile ( wc_source , GENERIC_READ , FILE_SHARE_READ , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL ) ; HANDLE f_file_target = CreateFile ( wc_target , GENERIC_READ , FILE_SHARE_READ , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL ) ; if ( ( GetFileTime ( f_file_source , NULL , NULL , & ft_source ) ) && ( GetFileTime ( f_file_target , NULL , NULL , & ft_target ) ) ) { ULARGE_INTEGER ul_source ; ul_source . LowPart = ft_source . dwLowDateTime ; ul_source . HighPart = ft_source . dwHighDateTime ; __int64 fileTime64_source = ul_source . QuadPart ; ULARGE_INTEGER ul_target ; ul_target . LowPart = ft_target . dwLowDateTime ; ul_target . HighPart = ft_target . dwHighDateTime ; __int64 fileTime64_target = ul_target . QuadPart ; if ( args . force ) { if ( fileTime64_source == fileTime64_target ) { copy_file = false ; } } else { <S2SV_StartBug> if ( fileTime64_source < fileTime64_target ) { <S2SV_EndBug> copy_file = false ; } } } CloseHandle ( f_file_source ) ; CloseHandle ( f_file_target ) ; } if ( copy_file ) if ( ! CopyFile ( wc_source , wc_target , 0 ) ) return - 2 ; # else int f_target , f_source ; char buf [ 4096 ] ; ssize_t nread ; f_source = open ( source , O_RDONLY ) ; if ( f_source < 0 ) return - 2 ; f_target = open ( target , O_WRONLY | O_CREAT , 0666 ) ; if ( f_target < 0 ) { close ( f_source ) ; if ( f_target >= 0 ) close ( f_target ) ; return - 3 ; } while ( nread = read ( f_source , buf , sizeof buf ) , nread > 0 ) { char * out_ptr = buf ; ssize_t nwritten ; do { nwritten = write ( f_target , out_ptr , nread ) ; if ( nwritten >= 0 ) { nread -= nwritten ; out_ptr += nwritten ; } else if ( errno != EINTR ) { close ( f_source ) ; if ( f_target >= 0 ) close ( f_target ) ; return - 4 ; } } while ( nread > 0 ) ; } close ( f_source ) ; if ( close ( f_target ) < 0 ) return - 5 ; # endif return 0 ; } | <S2SV_ModStart> if ( fileTime64_source <= <S2SV_ModEnd> fileTime64_target ) { |
4,749 | CWE-000 static void tx_complete ( struct urb * urb ) { struct sk_buff * skb = ( struct sk_buff * ) urb -> context ; struct skb_data * entry = ( struct skb_data * ) skb -> cb ; struct usbnet * dev = entry -> dev ; if ( urb -> status == 0 ) { struct pcpu_sw_netstats * stats64 = this_cpu_ptr ( dev -> stats64 ) ; <S2SV_StartBug> u64_stats_update_begin ( & stats64 -> syncp ) ; <S2SV_EndBug> stats64 -> tx_packets += entry -> packets ; stats64 -> tx_bytes += entry -> length ; <S2SV_StartBug> u64_stats_update_end ( & stats64 -> syncp ) ; <S2SV_EndBug> } else { dev -> net -> stats . tx_errors ++ ; switch ( urb -> status ) { case - EPIPE : usbnet_defer_kevent ( dev , EVENT_TX_HALT ) ; break ; case - ECONNRESET : case - ESHUTDOWN : break ; case - EPROTO : case - ETIME : case - EILSEQ : usb_mark_last_busy ( dev -> udev ) ; if ( ! timer_pending ( & dev -> delay ) ) { mod_timer ( & dev -> delay , jiffies + THROTTLE_JIFFIES ) ; netif_dbg ( dev , link , dev -> net , "tx<S2SV_blank>throttle<S2SV_blank>%d\\n" , urb -> status ) ; } netif_stop_queue ( dev -> net ) ; break ; default : netif_dbg ( dev , tx_err , dev -> net , "tx<S2SV_blank>err<S2SV_blank>%d\\n" , entry -> urb -> status ) ; break ; } } usb_autopm_put_interface_async ( dev -> intf ) ; ( void ) defer_bh ( dev , skb , & dev -> txq , tx_done ) ; } | <S2SV_ModStart> stats64 ) ; unsigned long flags ; flags = u64_stats_update_begin_irqsave <S2SV_ModEnd> ( & stats64 <S2SV_ModStart> -> length ; u64_stats_update_end_irqrestore <S2SV_ModEnd> ( & stats64 <S2SV_ModStart> stats64 -> syncp , flags |
4,750 | CWE-000 int main ( ) { PORTB |= _BV ( PORTB6 ) ; setup_controllers ( ) ; UART_Init0 ( 19200 ) ; UART_Init1 ( 19200 ) ; <S2SV_StartBug> _delay_ms ( 20 ) ; <S2SV_EndBug> OS_Init ( ) ; <S2SV_StartBug> Task_Create_Period ( sample_joysticks , 0 , 30 , 1 , 2 ) ; <S2SV_EndBug> OS_Start ( ) ; return 1 ; } | <S2SV_ModStart> 19200 ) ; <S2SV_ModEnd> OS_Init ( ) <S2SV_ModStart> , 1 , 0 ) ; Task_Create_Period ( send_state , 0 , 150 , 5 , 160 <S2SV_ModEnd> ) ; OS_Start |
4,751 | CWE-000 <S2SV_StartBug> static int storeIdent ( Entity * str , Entity * tokInfo , <S2SV_EndBug> struct identifiersHead * identHead , int indent , int tok ) { const char * cstr = yeTokCIdentifier ( tokInfo , tok ) ; if ( ! cstr ) { DPRINT_ERR ( "expected<S2SV_blank>identifier,<S2SV_blank>got<S2SV_blank>\'%s\'\\n" , yeTokString ( tokInfo , tok ) ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } <S2SV_StartBug> if ( getIdent ( identHead , cstr ) > 0 ) { <S2SV_EndBug> DPRINT_ERR ( "redefinition<S2SV_blank>of<S2SV_blank>\'%s\'\\n" , cstr ) ; <S2SV_StartBug> return - 1 ; <S2SV_EndBug> } struct identifiers * iden = malloc ( sizeof ( struct identifiers ) ) ; <S2SV_StartBug> iden -> str = cstr ; <S2SV_EndBug> iden -> num = indent ; LIST_INSERT_HEAD ( identHead , iden , entries ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static void <S2SV_ModEnd> storeIdent ( Entity <S2SV_ModStart> ) ) ; longjmp ( error_env , 1 ) <S2SV_ModEnd> ; } if <S2SV_ModStart> , cstr ) >= <S2SV_ModEnd> 0 ) { <S2SV_ModStart> cstr ) ; longjmp ( error_env , 1 ) <S2SV_ModEnd> ; } struct <S2SV_ModStart> -> str = strdup ( cstr ) <S2SV_ModEnd> ; iden -> <S2SV_ModStart> entries ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,752 | CWE-000 void threestage_adapt ( const distType data [ ] , double m1 , double s1 , double m2 , double s2 , double m3 , double s3 , distType Y [ ] , int dataSize ) { <S2SV_StartBug> printf ( "starting<S2SV_blank>(%g<S2SV_blank>%g<S2SV_blank>%g<S2SV_blank>%g<S2SV_blank>%g<S2SV_blank>%g)\\n" , m1 , s1 , m2 , s2 , m3 , s3 ) ; <S2SV_EndBug> distType gridSize = 0.01 ; double maxData = 0 ; for ( int i = 0 ; i < dataSize ; i ++ ) { if ( data [ i ] > maxData ) maxData = data [ i ] ; } double logP0 ; double logP1 ; double E = DBL_MAX ; <S2SV_StartBug> threestage_bin ( data , m1 , s1 , m2 , s2 , m3 , s3 , Y , dataSize , gridSize ) ; <S2SV_EndBug> logP0 = ( double ) loglikelihood ( Y , dataSize ) ; printf ( "ll=%f<S2SV_blank>gridSize=%.17f<S2SV_blank>E=%.17e<S2SV_blank>EB=%g<S2SV_blank>threestage\\n" , logP0 , gridSize , E , _ERROR_BOUND ) ; while ( E >= _ERROR_BOUND ) { gridSize = gridSize * 0.5 ; <S2SV_StartBug> threestage_bin ( data , m1 , s1 , m2 , s2 , m3 , s3 , Y , dataSize , gridSize ) ; <S2SV_EndBug> logP1 = ( double ) loglikelihood ( Y , dataSize ) ; E = fabs ( logP1 - logP0 ) ; logP0 = logP1 ; printf ( "ll=%f<S2SV_blank>gridSize=%.17f<S2SV_blank>E=%.17e<S2SV_blank>EB=%g<S2SV_blank>threestage\\n" , logP1 , gridSize , E , _ERROR_BOUND ) ; } <S2SV_StartBug> printf ( "\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> dataSize ) { beginTraceFun ( "threestage_adapt" ) ; <S2SV_ModStart> = DBL_MAX ; threestage_double_adapt_bin <S2SV_ModEnd> ( data , <S2SV_ModStart> * 0.5 ; printf ( "Shrinking<S2SV_blank>gridSize...<S2SV_blank>gridSize<S2SV_blank>=<S2SV_blank>%f\\n" , gridSize ) ; threestage_double_adapt_bin <S2SV_ModEnd> ( data , <S2SV_ModStart> ) ; } endTraceFun ( "threestage_adapt" <S2SV_ModEnd> ) ; } |
4,753 | CWE-000 test_result_t basic_run_test ( struct testcase * test , uintptr_t e ) { int error ; driver_env_t env = ( driver_env_t ) e ; strncpy ( env -> init -> name , test -> name , TEST_NAME_MAX ) ; env -> init -> name [ TEST_NAME_MAX - 1 ] = '\\0' ; # ifdef CONFIG_DEBUG_BUILD seL4_DebugNameThread ( env -> test_process . thread . tcb . cptr , env -> init -> name ) ; # endif seL4_Word argc = 2 ; char string_args [ argc ] [ WORD_STRING_SIZE ] ; char * argv [ argc ] ; sel4utils_create_word_args ( string_args , argv , argc , env -> endpoint , env -> remote_vaddr ) ; error = sel4utils_spawn_process_v ( & ( env -> test_process ) , & env -> vka , & env -> vspace , argc , argv , 1 ) ; ZF_LOGF_IF ( error != 0 , "Failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>test<S2SV_blank>process!" ) ; <S2SV_StartBug> int result = sel4test_driver_wait ( env , test ) ; <S2SV_EndBug> test_assert ( result == SUCCESS ) ; return result ; } | <S2SV_ModStart> "Failed<S2SV_blank>to<S2SV_blank>start<S2SV_blank>test<S2SV_blank>process!" ) ; error = tm_alloc_id_at ( & env -> tm , TIMER_ID ) ; ZF_LOGF_IF ( error != 0 , "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>time<S2SV_blank>id<S2SV_blank>%d" , TIMER_ID ) ; |
4,754 | CWE-000 PetscViewer PETSC_VIEWER_HDF5_ ( MPI_Comm comm ) { PetscErrorCode ierr ; PetscBool flg ; PetscViewer viewer ; char fname [ PETSC_MAX_PATH_LEN ] ; MPI_Comm ncomm ; PetscFunctionBegin ; ierr = PetscCommDuplicate ( comm , & ncomm , NULL ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } if ( Petsc_Viewer_HDF5_keyval == MPI_KEYVAL_INVALID ) { <S2SV_StartBug> ierr = MPI_Keyval_create ( MPI_NULL_COPY_FN , MPI_NULL_DELETE_FN , & Petsc_Viewer_HDF5_keyval , 0 ) ; <S2SV_EndBug> if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } } ierr = MPI_Attr_get ( ncomm , Petsc_Viewer_HDF5_keyval , ( void * * ) & viewer , ( int * ) & flg ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } if ( ! flg ) { ierr = PetscOptionsGetenv ( ncomm , "PETSC_VIEWER_HDF5_FILENAME" , fname , PETSC_MAX_PATH_LEN , & flg ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } if ( ! flg ) { ierr = PetscStrcpy ( fname , "output.h5" ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } } ierr = PetscViewerHDF5Open ( ncomm , fname , FILE_MODE_WRITE , & viewer ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } ierr = PetscObjectRegisterDestroy ( ( PetscObject ) viewer ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } ierr = MPI_Attr_put ( ncomm , Petsc_Viewer_HDF5_keyval , ( void * ) viewer ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } } ierr = PetscCommDestroy ( & ncomm ) ; if ( ierr ) { PetscError ( PETSC_COMM_SELF , __LINE__ , "PETSC_VIEWER_HDF5_" , __FILE__ , PETSC_ERR_PLIB , PETSC_ERROR_INITIAL , "<S2SV_blank>" ) ; PetscFunctionReturn ( 0 ) ; } PetscFunctionReturn ( viewer ) ; } | <S2SV_ModStart> { ierr = MPI_Comm_create_keyval ( MPI_COMM_NULL_COPY_FN , MPI_COMM_NULL_DELETE_FN <S2SV_ModEnd> , & Petsc_Viewer_HDF5_keyval |
4,755 | CWE-000 int main ( ) { <S2SV_StartBug> int n ; <S2SV_EndBug> cin >> n ; int arr [ n ] ; for ( int i = 0 ; i < n ; ++ i ) <S2SV_StartBug> cin >> arr [ i ] ; <S2SV_EndBug> cin >> m ; printf ( "<S2SV_blank>%d<S2SV_blank>" , count ( arr , n , m ) ) ; return 0 ; } | <S2SV_ModStart> ) { int m , n ; scanf ( "%d" , & n ) <S2SV_ModEnd> ; int arr <S2SV_ModStart> ++ i ) scanf ( "%d" , & <S2SV_ModEnd> arr [ i <S2SV_ModStart> [ i ] ) ; scanf ( "%d" , & m ) <S2SV_ModEnd> ; printf ( |
4,756 | CWE-000 static int vpnet_poll ( struct napi_struct * napi , int budget ) { struct vpnet_rx_engine * rx = container_of ( napi , struct vpnet_rx_engine , napi ) ; <S2SV_StartBug> unsigned int received = 0 ; <S2SV_EndBug> received = vpnet_rx_engine_run ( rx , budget ) ; if ( received < budget ) { enable_remote_notify ( & rx -> remote_tx ) ; napi_complete_done ( napi , received ) ; if ( unlikely ( vpnet_rx_engine_poll ( rx ) ) && napi_schedule_prep ( napi ) ) { disable_remote_notify ( & rx -> remote_tx ) ; __napi_schedule ( napi ) ; } } return received ; } | <S2SV_ModStart> napi ) ; struct vpnet_info * vi = rx -> vq -> vdev -> priv ; <S2SV_ModStart> = 0 ; if ( ! vi -> ready ) { printk ( KERN_EMERG "%s<S2SV_blank>called:<S2SV_blank>not<S2SV_blank>ready<S2SV_blank>\\n" , __func__ ) ; return 0 ; } |
4,757 | CWE-000 int stlink_fwrite_flash ( stlink_t * sl , const char * path , stm32_addr_t addr ) { int err ; unsigned int num_empty , index , val ; unsigned char erased_pattern ; mapped_file_t mf = MAPPED_FILE_INITIALIZER ; if ( map_file ( & mf , path ) == - 1 ) { ELOG ( "map_file()<S2SV_blank>==<S2SV_blank>-1\\n" ) ; return - 1 ; } if ( sl -> flash_type == STLINK_FLASH_TYPE_L0 ) erased_pattern = 0x00 ; else erased_pattern = 0xff ; <S2SV_StartBug> index = mf . len ; <S2SV_EndBug> for ( num_empty = 0 ; num_empty != mf . len ; ++ num_empty ) { if ( mf . base [ -- index ] != erased_pattern ) { break ; } } num_empty -= ( num_empty & 3 ) ; if ( num_empty != 0 ) { ILOG ( "Ignoring<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>of<S2SV_blank>0x%02x<S2SV_blank>at<S2SV_blank>end<S2SV_blank>of<S2SV_blank>file\\n" , num_empty , erased_pattern ) ; } <S2SV_StartBug> err = stlink_write_flash ( sl , addr , mf . base , num_empty == mf . len ? mf . len : mf . len - num_empty , num_empty == mf . len ) ; <S2SV_EndBug> stlink_read_debug32 ( sl , addr , & val ) ; stlink_write_reg ( sl , val , 13 ) ; stlink_read_debug32 ( sl , addr + 4 , & val ) ; stlink_write_reg ( sl , val , 15 ) ; stlink_run ( sl ) ; unmap_file ( & mf ) ; return err ; } | <S2SV_ModStart> ; index = ( unsigned int ) <S2SV_ModStart> . base , ( num_empty == mf . len ) ? ( uint32_t ) <S2SV_ModEnd> mf . len <S2SV_ModStart> . len : ( uint32_t ) |
4,758 | CWE-000 str mvc_affected_rows_wrap ( Client cntxt , MalBlkPtr mb , MalStkPtr stk , InstrPtr pci ) { backend * b = NULL ; int * res = getArgReference_int ( stk , pci , 0 ) , error ; # ifndef NDEBUG int mtype = getArgType ( mb , pci , 2 ) ; # endif lng nr ; str msg ; ( void ) mb ; if ( ( msg = checkSQLContext ( cntxt ) ) != NULL ) return msg ; * res = 0 ; assert ( mtype == TYPE_lng ) ; nr = * getArgReference_lng ( stk , pci , 2 ) ; b = cntxt -> sqlcontext ; error = mvc_export_affrows ( b , b -> out , nr , "" , mb -> tag , mb -> starttime , mb -> optimize ) ; <S2SV_StartBug> if ( error ) <S2SV_EndBug> throw ( SQL , "sql.affectedRows" , SQLSTATE ( 45000 ) "Result<S2SV_blank>set<S2SV_blank>construction<S2SV_blank>failed" ) ; return MAL_SUCCEED ; } | <S2SV_ModStart> optimize ) ; mb -> starttime = 0 ; mb -> optimize = 0 ; |
4,759 | CWE-000 void compare_convolution_to_baseline ( const_scrappie_matrix input , const_scrappie_matrix filter , const_scrappie_matrix bias , Vec input_base , Vec filter_base ) { scrappie_matrix res_odd = convolution ( mat_odd , filter , bias , 1 , NULL ) ; Vec res_odd_base = simple_convolution ( input_base , filter_base ) ; CU_ASSERT_PTR_NOT_NULL_FATAL ( res_odd ) ; CU_ASSERT_PTR_NOT_NULL_FATAL ( res_odd_base . elt ) ; <S2SV_StartBug> for ( int i = 0 ; i < input_base . len ; ++ i ) { <S2SV_EndBug> CU_ASSERT_DOUBLE_EQUAL ( res_odd_base . elt [ i ] , res_odd -> data . f [ i * 4 ] , test_conv_tol ) ; } free ( res_odd_base . elt ) ; <S2SV_StartBug> free_scrappie_matrix ( res_odd ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; for ( size_t <S2SV_ModEnd> i = 0 <S2SV_ModStart> elt ) ; res_odd = |
4,760 | CWE-000 void fillit ( slider * total ) { grid * fillit_grid ; <S2SV_StartBug> int size ; <S2SV_EndBug> coord start ; coord next ; start . x = 1 ; start . y = 1 ; size = smallest_square ( total ) ; fillit_grid = grid_init ( size ) ; next = get_next_pos ( start , fillit_grid ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; int size ; int solve_check <S2SV_ModStart> fillit_grid ) ; solve_check = solve ( fillit_grid , start , total ) ; while ( solve_check == - 1 ) { fillit_grid = grid_init ( fillit_grid -> smallest + 1 ) ; solve_check = solve ( fillit_grid , start , total ) ; } print_grid ( fillit_grid ) ; |
4,761 | CWE-000 static int MuxImageParse ( const WebPChunk * const chunk , int copy_data , WebPMuxImage * const wpi ) { const uint8_t * bytes = chunk -> data_ . bytes ; size_t size = chunk -> data_ . size ; const uint8_t * const last = bytes + size ; WebPChunk subchunk ; size_t subchunk_size ; ChunkInit ( & subchunk ) ; assert ( chunk -> tag_ == kChunks [ IDX_ANMF ] . tag ) ; assert ( ! wpi -> is_partial_ ) ; { const size_t hdr_size = ANMF_CHUNK_SIZE ; const WebPData temp = { bytes , hdr_size } ; if ( size < hdr_size ) goto Fail ; ChunkAssignData ( & subchunk , & temp , copy_data , chunk -> tag_ ) ; } ChunkSetNth ( & subchunk , & wpi -> header_ , 1 ) ; wpi -> is_partial_ = 1 ; subchunk_size = ChunkDiskSize ( & subchunk ) - CHUNK_HEADER_SIZE ; bytes += subchunk_size ; size -= subchunk_size ; while ( bytes != last ) { ChunkInit ( & subchunk ) ; if ( ChunkVerifyAndAssign ( & subchunk , bytes , size , size , copy_data ) != WEBP_MUX_OK ) { goto Fail ; } switch ( ChunkGetIdFromTag ( subchunk . tag_ ) ) { case WEBP_CHUNK_ALPHA : if ( wpi -> alpha_ != NULL ) goto Fail ; if ( ChunkSetNth ( & subchunk , & wpi -> alpha_ , 1 ) != WEBP_MUX_OK ) goto Fail ; wpi -> is_partial_ = 1 ; break ; case WEBP_CHUNK_IMAGE : <S2SV_StartBug> if ( ChunkSetNth ( & subchunk , & wpi -> img_ , 1 ) != WEBP_MUX_OK ) goto Fail ; <S2SV_EndBug> if ( ! MuxImageFinalize ( wpi ) ) goto Fail ; wpi -> is_partial_ = 0 ; break ; case WEBP_CHUNK_UNKNOWN : if ( wpi -> is_partial_ ) goto Fail ; if ( ChunkSetNth ( & subchunk , & wpi -> unknown_ , 0 ) != WEBP_MUX_OK ) goto Fail ; break ; default : goto Fail ; break ; } subchunk_size = ChunkDiskSize ( & subchunk ) ; bytes += subchunk_size ; size -= subchunk_size ; } if ( wpi -> is_partial_ ) goto Fail ; return 1 ; Fail : ChunkRelease ( & subchunk ) ; return 0 ; } | <S2SV_ModStart> : if ( wpi -> img_ != NULL ) goto Fail ; if ( |
4,762 | CWE-000 int libswd_cmd_enqueue_miso_nbit ( libswd_ctx_t * libswdctx , char * * data , int count ) { if ( libswdctx == NULL ) return LIBSWD_ERROR_NULLCONTEXT ; if ( count <= 0 ) return LIBSWD_ERROR_PARAM ; int res , res2 ; libswd_cmd_t * cmd , * oldcmdq = libswdctx -> cmdq ; int i , cmdcnt = 0 ; for ( i = 0 ; i < count ; i ++ ) { cmd = ( libswd_cmd_t * ) calloc ( 1 , sizeof ( libswd_cmd_t ) ) ; if ( cmd == NULL ) { res = LIBSWD_ERROR_OUTOFMEM ; break ; } cmd -> bits = 1 ; if ( data != NULL ) * data = & cmd -> misobit ; cmd -> cmdtype = LIBSWD_CMDTYPE_MISO_BITBANG ; res = libswd_cmd_enqueue ( libswdctx , cmd ) ; if ( res < 1 ) break ; cmdcnt += res ; } if ( res < 1 ) { <S2SV_StartBug> res2 = libswd_cmdq_free_tail ( oldcmdq ) ; <S2SV_EndBug> if ( res2 < 0 ) return res2 ; return res ; } else return cmdcnt ; } | <S2SV_ModStart> = libswd_cmdq_free_tail ( libswdctx , |
4,763 | CWE-000 static SENSOR_STATE func_off_stable ( void ) { SENSOR_STATE state = SENSOR_STATE_OFF_STABLE ; <S2SV_StartBug> if ( current_val > thrs_on_val ) { <S2SV_EndBug> if ( thrs_on_interval != 0 ) { thrs_on_start = current_time ; state = SENSOR_STATE_OFF_UNSTABLE ; } else { send_data_flag = true ; state = SENSOR_STATE_ON_STABLE ; } } return state ; } | <S2SV_ModStart> ; if ( sensor_val <S2SV_ModEnd> > thrs_on_val ) |
4,764 | CWE-000 void libvlc_media_player_set_hwnd ( libvlc_media_player_t * p_mi , void * drawable ) { assert ( p_mi != NULL ) ; # if defined ( _WIN32 ) || defined ( __OS2__ ) var_SetString ( p_mi , "avcodec-hw" , "" ) ; var_SetString ( p_mi , "vout" , "" ) ; var_SetString ( p_mi , "window" , ( drawable != NULL ) ? "embed-hwnd,any" : "" ) ; var_SetInteger ( p_mi , "drawable-hwnd" , ( uintptr_t ) drawable ) ; # else ( void ) drawable ; <S2SV_StartBug> libvlc_printerr ( "can\'t<S2SV_blank>set<S2SV_blank>nsobject:<S2SV_blank>WIN32<S2SV_blank>build<S2SV_blank>required" ) ; <S2SV_EndBug> assert ( false ) ; var_SetString ( p_mi , "vout" , "none" ) ; var_SetString ( p_mi , "window" , "none" ) ; # endif } | <S2SV_ModStart> ; libvlc_printerr ( "can\'t<S2SV_blank>set<S2SV_blank>hwnd:<S2SV_blank>WIN32<S2SV_blank>build<S2SV_blank>required" <S2SV_ModEnd> ) ; assert |
4,765 | CWE-000 static int input_len ( xmlTextReaderPtr reader , HashTable * ht , TYPE_DESC tp ) { expv v = NULL ; <S2SV_StartBug> if ( ! xmlMatchNode ( reader , XML_READER_TYPE_ELEMENT , "len" ) ) <S2SV_EndBug> return TRUE ; if ( ! xmlSkipWhiteSpace ( reader ) ) return FALSE ; <S2SV_StartBug> if ( xmlMatchNode ( reader , XML_READER_TYPE_END_ELEMENT , "len" ) ) { <S2SV_EndBug> TYPE_CHAR_LEN ( tp ) = CHAR_LEN_UNFIXED ; } else { if ( ! input_expv ( reader , ht , & v ) ) return FALSE ; if ( v != NULL ) TYPE_LENG ( tp ) = v ; } <S2SV_StartBug> if ( ! xmlExpectNode ( reader , XML_READER_TYPE_END_ELEMENT , "len" ) ) <S2SV_EndBug> return FALSE ; return TRUE ; } | <S2SV_ModStart> = NULL ; char * is_assumed_size ; char * is_assumed_shape ; <S2SV_ModStart> return FALSE ; is_assumed_size = ( char * ) xmlTextReaderGetAttribute ( reader , BAD_CAST "is_assumed_size" ) ; is_assumed_shape = ( char * ) xmlTextReaderGetAttribute ( reader , BAD_CAST "is_assumed_shape" ) ; <S2SV_ModStart> } if ( is_assumed_size != NULL ) { TYPE_CHAR_LEN ( tp ) = CHAR_LEN_UNFIXED ; free ( is_assumed_size ) ; } else if ( is_assumed_shape != NULL ) { TYPE_CHAR_LEN ( tp ) = CHAR_LEN_ALLOCATABLE ; free ( is_assumed_shape ) ; } if ( |
4,766 | CWE-000 static void schedule_defer_open ( struct share_mode_lock * lck , struct file_id id , struct timeval request_time , <S2SV_StartBug> struct smb_request * req ) <S2SV_EndBug> { struct timeval timeout ; timeout = timeval_set ( OPLOCK_BREAK_TIMEOUT * 2 , 0 ) ; if ( request_timed_out ( request_time , timeout ) ) { return ; } <S2SV_StartBug> defer_open ( lck , request_time , timeout , req , true , id ) ; <S2SV_EndBug> } | <S2SV_ModStart> smb_request * req , bool kernel_oplock <S2SV_ModStart> , true , kernel_oplock , |
4,767 | CWE-000 struct Node * _create_leaf_node ( int data ) { <S2SV_StartBug> _create_node ( data , NULL , NULL ) ; <S2SV_EndBug> } | <S2SV_ModStart> data ) { return |
4,768 | CWE-000 void cling_mips_interp_destroy ( struct cling_mips_interp * self ) { <S2SV_StartBug> print_memory_usage ( self ) ; <S2SV_EndBug> utillib_hashmap_destroy_owning ( & self -> labels , NULL , mips_label_destroy ) ; utillib_vector_destroy ( & self -> strings ) ; for ( int i = 0 ; i < MIPS_MEM_ARRAY_MAX ; ++ i ) { if ( self -> memory [ i ] ) for ( int j = 0 ; j < MIPS_MEM_ARRAY_MAX ; ++ j ) free ( self -> memory [ i ] [ j ] ) ; free ( self -> memory [ i ] ) ; } } | <S2SV_ModStart> self ) { <S2SV_ModEnd> utillib_hashmap_destroy_owning ( & |
4,769 | CWE-000 void exec_command ( char * command , char * commandlineCONST , char * * argsEx , char * * env , pid_t pid , struct pathelement * pathlist , int status ) { if ( ( command [ 0 ] == '/' ) || ( ( command [ 0 ] == '.' ) && ( ( command [ 1 ] == '/' ) || ( ( command [ 1 ] == '.' ) && ( command [ 2 ] == '/' ) ) ) ) ) { if ( strstr ( command , ".sh" ) == NULL ) { execute ( argsEx [ 0 ] , argsEx , env , pid , status ) ; } else { execl ( "/bin/sh" , "sh" , "-c" , command , ( char * ) 0 ) ; } } else { <S2SV_StartBug> command = quickwhich ( command , pathlist ) ; <S2SV_EndBug> if ( command != NULL ) { <S2SV_StartBug> strcpy ( argsEx [ 0 ] , command ) ; <S2SV_EndBug> <S2SV_StartBug> execute ( command , argsEx , env , pid , status ) ; <S2SV_EndBug> } else <S2SV_StartBug> { <S2SV_EndBug> printf ( "%s:<S2SV_blank>Command<S2SV_blank>not<S2SV_blank>found.\\n" , commandlineCONST ) ; } } } | <S2SV_ModStart> } else { commandSet ( pathlist , command , false <S2SV_ModEnd> ) ; if <S2SV_ModStart> NULL ) { char * * temp = calloc ( MAXARGS , sizeof ( char * ) ) ; copyArray ( temp , argsEx ) ; <S2SV_ModStart> command ) ; copyArrayIndexed ( argsEx , temp , 1 ) ; int tempSize = countEntries ( temp ) ; arrayPlumber ( temp , tempSize ) ; printf ( "Executing<S2SV_blank>%s\\n" , commandlineCONST ) ; <S2SV_ModStart> ; } else { <S2SV_ModEnd> printf ( "%s:<S2SV_blank>Command<S2SV_blank>not<S2SV_blank>found.\\n" |
4,770 | CWE-000 struct iwl_mcc_update_resp * iwl_mvm_update_mcc ( struct iwl_mvm * mvm , const char * alpha2 , enum iwl_mcc_source src_id ) { struct iwl_mcc_update_cmd mcc_update_cmd = { . mcc = cpu_to_le16 ( alpha2 [ 0 ] << 8 | alpha2 [ 1 ] ) , . source_id = ( u8 ) src_id , } ; struct iwl_mcc_update_resp * resp_cp ; struct iwl_rx_packet * pkt ; struct iwl_host_cmd cmd = { . id = MCC_UPDATE_CMD , . flags = CMD_WANT_SKB , . data = { & mcc_update_cmd } , } ; int ret ; u32 status ; int resp_len , n_channels ; u16 mcc ; if ( WARN_ON_ONCE ( ! iwl_mvm_is_lar_supported ( mvm ) ) ) return ERR_PTR ( - EOPNOTSUPP ) ; cmd . len [ 0 ] = sizeof ( struct iwl_mcc_update_cmd ) ; IWL_DEBUG_LAR ( mvm , "send<S2SV_blank>MCC<S2SV_blank>update<S2SV_blank>to<S2SV_blank>FW<S2SV_blank>with<S2SV_blank>\'%c%c\'<S2SV_blank>src<S2SV_blank>=<S2SV_blank>%d\\n" , alpha2 [ 0 ] , alpha2 [ 1 ] , src_id ) ; ret = iwl_mvm_send_cmd ( mvm , & cmd ) ; if ( ret ) return ERR_PTR ( ret ) ; pkt = cmd . resp_pkt ; if ( fw_has_capa ( & mvm -> fw -> ucode_capa , IWL_UCODE_TLV_CAPA_MCC_UPDATE_11AX_SUPPORT ) ) { struct iwl_mcc_update_resp * mcc_resp = ( void * ) pkt -> data ; n_channels = __le32_to_cpu ( mcc_resp -> n_channels ) ; resp_len = sizeof ( struct iwl_mcc_update_resp ) + n_channels * sizeof ( __le32 ) ; resp_cp = kmemdup ( mcc_resp , resp_len , GFP_KERNEL ) ; if ( ! resp_cp ) { resp_cp = ERR_PTR ( - ENOMEM ) ; goto exit ; } } else { struct iwl_mcc_update_resp_v3 * mcc_resp_v3 = ( void * ) pkt -> data ; n_channels = __le32_to_cpu ( mcc_resp_v3 -> n_channels ) ; resp_len = sizeof ( struct iwl_mcc_update_resp ) + n_channels * sizeof ( __le32 ) ; resp_cp = kzalloc ( resp_len , GFP_KERNEL ) ; if ( ! resp_cp ) { resp_cp = ERR_PTR ( - ENOMEM ) ; goto exit ; } resp_cp -> status = mcc_resp_v3 -> status ; resp_cp -> mcc = mcc_resp_v3 -> mcc ; resp_cp -> cap = cpu_to_le16 ( mcc_resp_v3 -> cap ) ; resp_cp -> source_id = mcc_resp_v3 -> source_id ; resp_cp -> time = mcc_resp_v3 -> time ; resp_cp -> geo_info = mcc_resp_v3 -> geo_info ; resp_cp -> n_channels = mcc_resp_v3 -> n_channels ; memcpy ( resp_cp -> channels , mcc_resp_v3 -> channels , n_channels * sizeof ( __le32 ) ) ; } status = le32_to_cpu ( resp_cp -> status ) ; mcc = le16_to_cpu ( resp_cp -> mcc ) ; if ( mcc == 0 ) { mcc = 0x3030 ; resp_cp -> mcc = cpu_to_le16 ( mcc ) ; } IWL_DEBUG_LAR ( mvm , <S2SV_StartBug> "MCC<S2SV_blank>response<S2SV_blank>status:<S2SV_blank>0x%x.<S2SV_blank>new<S2SV_blank>MCC:<S2SV_blank>0x%x<S2SV_blank>(\'%c%c\')<S2SV_blank>change:<S2SV_blank>%d<S2SV_blank>n_chans:<S2SV_blank>%d\\n" , <S2SV_EndBug> status , mcc , mcc >> 8 , mcc & 0xff , <S2SV_StartBug> ! ! ( status == MCC_RESP_NEW_CHAN_PROFILE ) , n_channels ) ; <S2SV_EndBug> exit : iwl_free_resp ( & cmd ) ; return resp_cp ; } | <S2SV_ModStart> ( mvm , "MCC<S2SV_blank>response<S2SV_blank>status:<S2SV_blank>0x%x.<S2SV_blank>new<S2SV_blank>MCC:<S2SV_blank>0x%x<S2SV_blank>(\'%c%c\')<S2SV_blank>n_chans:<S2SV_blank>%d\\n" <S2SV_ModEnd> , status , <S2SV_ModStart> & 0xff , <S2SV_ModEnd> n_channels ) ; |
4,771 | CWE-000 static void lde_nbr_clear ( void ) { struct lde_nbr * ln ; <S2SV_StartBug> while ( ( ln = RB_ROOT ( nbr_tree , & lde_nbrs ) ) != NULL ) <S2SV_EndBug> lde_nbr_del ( ln ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; while ( ! RB_EMPTY ( nbr_tree , & lde_nbrs ) ) { <S2SV_ModEnd> ln = RB_ROOT <S2SV_ModStart> & lde_nbrs ) ; <S2SV_ModEnd> lde_nbr_del ( ln <S2SV_ModStart> ) ; } } |
4,772 | CWE-000 static void io_acct_end ( struct bio_wrapper * biow ) { <S2SV_StartBug> int cpu ; <S2SV_EndBug> int rw = bio_data_dir ( biow -> bio ) ; struct walb_dev * wdev = biow -> private_data ; struct hd_struct * part0 = & wdev -> gd -> part0 ; unsigned long duration = jiffies - biow -> start_time ; unsigned long duration_ms = jiffies_to_msecs ( duration ) ; <S2SV_StartBug> cpu = part_stat_lock ( ) ; <S2SV_EndBug> <S2SV_StartBug> part_stat_add ( cpu , part0 , ticks [ rw ] , duration ) ; <S2SV_EndBug> part_round_stats ( cpu , part0 ) ; part_dec_in_flight ( part0 , rw ) ; part_stat_unlock ( ) ; if ( io_latency_threshold_ms_ > 0 && duration_ms > io_latency_threshold_ms_ ) { char buf [ 64 ] ; snprintf ( buf , sizeof ( buf ) , "%u:<S2SV_blank>IO<S2SV_blank>latency<S2SV_blank>exceeds<S2SV_blank>threshold:<S2SV_blank>%lu<S2SV_blank>%c<S2SV_blank>" , wdev_minor ( wdev ) , duration_ms , rw == WRITE ? 'W' : 'R' ) ; print_bio_wrapper_short ( KERN_WARNING , biow , buf ) ; # ifdef WALB_PERFORMANCE_ANALYSIS print_bio_wrapper_performance ( KERN_WARNING , biow ) ; # endif } # ifdef WALB_DEBUG atomic_dec ( & get_iocored_from_wdev ( wdev ) -> n_io_acct ) ; # endif } | <S2SV_ModStart> biow ) { <S2SV_ModEnd> int rw = <S2SV_ModStart> duration ) ; generic_end_io_acct ( biow -> bio -> bi_disk -> queue , rw <S2SV_ModEnd> , part0 , <S2SV_ModStart> , part0 , biow -> start_time <S2SV_ModEnd> ) ; if |
4,773 | CWE-000 int tpm_chip_register ( struct tpm_chip * chip ) { <S2SV_StartBug> int rc ; <S2SV_EndBug> if ( chip -> ops -> flags & TPM_OPS_AUTO_STARTUP ) { if ( chip -> flags & TPM_CHIP_FLAG_TPM2 ) rc = tpm2_auto_startup ( chip ) ; else rc = tpm1_auto_startup ( chip ) ; if ( rc ) return rc ; } rc = tpm1_chip_register ( chip ) ; if ( rc ) return rc ; tpm_add_ppi ( chip ) ; rc = tpm_add_char_device ( chip ) ; if ( rc ) { tpm1_chip_unregister ( chip ) ; return rc ; } chip -> flags |= TPM_CHIP_FLAG_REGISTERED ; rc = tpm_add_legacy_sysfs ( chip ) ; if ( rc ) { tpm_chip_unregister ( chip ) ; return rc ; } return 0 ; } | <S2SV_ModStart> chip ) { # ifdef CONFIG_OF struct device_node * np ; # endif <S2SV_ModStart> int rc ; # ifdef CONFIG_OF np = of_find_node_by_name ( NULL , "vtpm" ) ; if ( np ) { if ( of_property_read_bool ( np , "powered-while-suspended" ) ) chip -> flags |= TPM_CHIP_FLAG_ALWAYS_POWERED ; } of_node_put ( np ) ; # endif |
4,774 | CWE-000 void sgIP_TCP_FixChecksum ( unsigned long srcip , unsigned long destip , sgIP_memblock * mb ) { int checksum ; if ( ! mb ) return ; sgIP_Header_TCP * tcp ; tcp = ( sgIP_Header_TCP * ) mb -> datastart ; tcp -> checksum = 0 ; checksum = sgIP_memblock_IPChecksum ( mb , 0 , mb -> totallength ) ; checksum += ( destip & 0xFFFF ) ; checksum += ( destip >> 16 ) ; checksum += ( srcip & 0xFFFF ) ; checksum += ( srcip >> 16 ) ; checksum += htons ( mb -> totallength ) ; checksum += ( 6 ) << 8 ; checksum = ( checksum & 0xFFFF ) + ( checksum >> 16 ) ; checksum = ( checksum & 0xFFFF ) + ( checksum >> 16 ) ; <S2SV_StartBug> checksum = ~ checksum ; <S2SV_EndBug> if ( checksum == 0 ) checksum = 0xFFFF ; tcp -> checksum = checksum ; } | <S2SV_ModStart> ; checksum = ( ~ checksum ) & 0xFFFF <S2SV_ModEnd> ; if ( |
4,775 | CWE-000 <S2SV_StartBug> bool stringEquals ( char * string , char * comparation ) { <S2SV_EndBug> bool equals = false ; if ( string != NULL && comparation != NULL ) { if ( strcmp ( string , comparation ) == 0 ) { equals = true ; } } return equals ; } | <S2SV_ModStart> bool stringEquals ( const <S2SV_ModStart> * string , const |
4,776 | CWE-000 bool phm_check_smc_update_required_for_display_configuration ( struct pp_hwmgr * hwmgr ) { PHM_FUNC_CHECK ( hwmgr ) ; if ( hwmgr -> hwmgr_func -> check_smc_update_required_for_display_configuration == NULL ) <S2SV_StartBug> return - EINVAL ; <S2SV_EndBug> return hwmgr -> hwmgr_func -> check_smc_update_required_for_display_configuration ( hwmgr ) ; } | <S2SV_ModStart> NULL ) return false <S2SV_ModEnd> ; return hwmgr |
4,777 | CWE-000 <S2SV_StartBug> TreeWithScore * treeWithScoreCreate ( Tree * tree , SCORE score ) <S2SV_EndBug> { TreeWithScore * treeWS ; treeWS = ( TreeWithScore * ) malloc ( sizeof ( TreeWithScore ) ) ; treeWS -> tree = tree ; treeWS -> score = score ; return treeWS ; } | <S2SV_ModStart> * tree , INT <S2SV_ModEnd> score ) { |
4,778 | CWE-000 int llwrite ( int fd , unsigned char * buffer , unsigned int length ) { retryCount = 0 ; unsigned int lenghtStuffng = length + 1 ; unsigned char bcc2 = bcc2Calc ( buffer , length ) ; linkLayer . frame [ 0 ] = FLAG ; linkLayer . frame [ 1 ] = ADDRESS ; linkLayer . frame [ 2 ] = SEQ_NUM ( linkLayer . seqNum ) ; linkLayer . frame [ 3 ] = SEQ_NUM ( linkLayer . seqNum ) ^ ADDRESS ; memmove ( linkLayer . frame + 4 , buffer , length ) ; linkLayer . frame [ 4 + length ] = bcc2 ; stuffing ( linkLayer . frame + 4 , & ( lenghtStuffng ) ) ; linkLayer . frameSize = lenghtStuffng + 5 ; linkLayer . frame [ linkLayer . frameSize - 1 ] = FLAG ; unsigned char frameCpy [ linkLayer . frameSize ] ; unsigned int frameISize = linkLayer . frameSize ; memmove ( frameCpy , linkLayer . frame , linkLayer . frameSize ) ; state = START ; unsigned char sent = 0 ; unsigned int bytesWritten = 0 ; while ( ! sent && retryCount < N_TRIES ) { switch ( state ) { case START : linkLayer . frameSize = frameISize ; memmove ( linkLayer . frame , frameCpy , linkLayer . frameSize ) ; <S2SV_StartBug> # ifdef STATISCS <S2SV_EndBug> usleep ( T_PROP * 1000 ) ; # endif bytesWritten = write ( fd , linkLayer . frame , linkLayer . frameSize ) ; alarm ( TIMEOUT ) ; state = RECEIVE ; break ; case RECEIVE : if ( receiveFrame ( & linkLayer ) ) { printf ( "llwrite:<S2SV_blank>expected<S2SV_blank>control<S2SV_blank>frame<S2SV_blank>but<S2SV_blank>received<S2SV_blank>Info<S2SV_blank>instead\\n" ) ; printf ( "CONTROL<S2SV_blank>FIELD<S2SV_blank>%x\\n" , linkLayer . frame [ C_IDX ] ) ; } else if ( linkLayer . frame [ C_IDX ] == RR ( 0 ) || linkLayer . frame [ C_IDX ] == RR ( 1 ) ) { state = END ; printf ( "llwrite<S2SV_blank>RR\\n" ) ; } else if ( linkLayer . frame [ C_IDX ] == REJ ( 0 ) || linkLayer . frame [ C_IDX ] == REJ ( 1 ) ) { printf ( "llwrite<S2SV_blank>REJ\\n" ) ; state = START ; } break ; case END : alarm ( 0 ) ; linkLayer . seqNum = ( linkLayer . seqNum + 1 ) % 2 ; sent = 1 ; break ; } } if ( retryCount == N_TRIES ) { printf ( "llwrite::Exceeded<S2SV_blank>number<S2SV_blank>of<S2SV_blank>tries\\n" ) ; exit ( 1 ) ; } return bytesWritten - ( lenghtStuffng - length ) - 5 ; } | <S2SV_ModStart> ; # ifdef STATISTICS <S2SV_ModEnd> usleep ( T_PROP |
4,779 | CWE-000 <S2SV_StartBug> Result init_emulator ( Emulator * e , u32 random_seed ) { <S2SV_EndBug> static u8 s_initial_wave_ram [ WAVE_RAM_SIZE ] = { 0x60 , 0x0d , 0xda , 0xdd , 0x50 , 0x0f , 0xad , 0xed , 0xc0 , 0xde , 0xf0 , 0x0d , 0xbe , 0xef , 0xfe , 0xed , } ; CHECK ( SUCCESS ( get_cart_infos ( e ) ) ) ; log_cart_info ( e -> cart_info ) ; MMAP_STATE . rom_base [ 0 ] = 0 ; MMAP_STATE . rom_base [ 1 ] = 1 << ROM_BANK_SHIFT ; <S2SV_StartBug> IS_CGB = e -> cart_info -> cgb_flag == CGB_FLAG_SUPPORTED || <S2SV_EndBug> <S2SV_StartBug> e -> cart_info -> cgb_flag == CGB_FLAG_REQUIRED ; <S2SV_EndBug> set_af_reg ( e , 0xb0 ) ; REG . A = IS_CGB ? 0x11 : 0x01 ; REG . BC = 0x0013 ; REG . DE = 0x00d8 ; REG . HL = 0x014d ; REG . SP = 0xfffe ; REG . PC = 0x0100 ; INTR . ime = FALSE ; TIMER . div_counter = 0xAC00 ; TIMER . next_intr_ticks = SERIAL . next_intr_ticks = e -> state . next_intr_ticks = INVALID_TICKS ; WRAM . offset = 0x1000 ; write_apu ( e , APU_NR52_ADDR , 0xf1 ) ; write_apu ( e , APU_NR11_ADDR , 0x80 ) ; write_apu ( e , APU_NR12_ADDR , 0xf3 ) ; write_apu ( e , APU_NR14_ADDR , 0x80 ) ; write_apu ( e , APU_NR50_ADDR , 0x77 ) ; write_apu ( e , APU_NR51_ADDR , 0xf3 ) ; APU . initialized = TRUE ; memcpy ( & WAVE . ram , s_initial_wave_ram , WAVE_RAM_SIZE ) ; CHANNEL1 . envelope . volume = 0 ; write_io ( e , IO_LCDC_ADDR , 0x91 ) ; write_io ( e , IO_SCY_ADDR , 0x00 ) ; write_io ( e , IO_SCX_ADDR , 0x00 ) ; write_io ( e , IO_LYC_ADDR , 0x00 ) ; write_io ( e , IO_BGP_ADDR , 0xfc ) ; write_io ( e , IO_OBP0_ADDR , 0xff ) ; write_io ( e , IO_OBP1_ADDR , 0xff ) ; write_io ( e , IO_IF_ADDR , 0x1 ) ; write_io ( e , IO_IE_ADDR , 0x0 ) ; HDMA . blocks = 0xff ; int pal_index ; for ( pal_index = 0 ; pal_index < 2 ; ++ pal_index ) { ColorPalettes * palette = pal_index == 0 ? & PPU . bgcp : & PPU . obcp ; int i ; for ( i = 0 ; i < 32 ; ++ i ) { palette -> palettes [ i >> 2 ] . color [ i & 3 ] = RGBA_WHITE ; palette -> data [ i * 2 ] = 0xff ; palette -> data [ i * 2 + 1 ] = 0x7f ; } } <S2SV_StartBug> e -> state . random_seed = random_seed ; <S2SV_EndBug> randomize_buffer ( & random_seed , e -> state . ext_ram . data , EXT_RAM_MAX_SIZE ) ; randomize_buffer ( & random_seed , e -> state . wram . data , WORK_RAM_SIZE ) ; randomize_buffer ( & random_seed , e -> state . hram , HIGH_RAM_SIZE ) ; e -> state . cpu_tick = CPU_TICK ; calculate_next_ppu_intr ( e ) ; return OK ; ON_ERROR_RETURN ; } | <S2SV_ModStart> * e , const EmulatorInit * init <S2SV_ModEnd> ) { static <S2SV_ModStart> ; IS_CGB = ! init -> force_dmg && ( <S2SV_ModStart> cgb_flag == CGB_FLAG_REQUIRED ) <S2SV_ModStart> ; } } u32 random_seed = init -> random_seed ; |
4,780 | CWE-000 static void set_boost_bit ( struct boost_drv * b , u32 state ) { <S2SV_StartBug> atomic_or ( state , & b -> state ) ; <S2SV_EndBug> } | <S2SV_ModStart> state ) { spin_lock ( <S2SV_ModEnd> & b -> <S2SV_ModStart> & b -> lock ) ; b -> state |= state ; spin_unlock ( & b -> lock <S2SV_ModEnd> ) ; } |
4,781 | CWE-000 gboolean flatpak_builtin_add_remote ( int argc , char * * argv , GCancellable * cancellable , GError * * error ) { g_autoptr ( GOptionContext ) context = NULL ; g_autoptr ( FlatpakDir ) dir = NULL ; g_autoptr ( GFile ) file = NULL ; g_auto ( GStrv ) remotes = NULL ; g_autofree char * remote_url = NULL ; const char * remote_name ; const char * location = NULL ; g_autoptr ( GKeyFile ) config = NULL ; g_autoptr ( GBytes ) gpg_data = NULL ; <S2SV_StartBug> gboolean changed = FALSE ; <S2SV_EndBug> context = g_option_context_new ( _ ( "NAME<S2SV_blank>LOCATION<S2SV_blank>-<S2SV_blank>Add<S2SV_blank>a<S2SV_blank>remote<S2SV_blank>repository" ) ) ; g_option_context_set_translation_domain ( context , GETTEXT_PACKAGE ) ; g_option_context_add_main_entries ( context , common_options , NULL ) ; if ( ! flatpak_option_context_parse ( context , add_options , & argc , & argv , 0 , & dir , cancellable , error ) ) return FALSE ; if ( argc < 2 ) return usage_error ( context , _ ( "NAME<S2SV_blank>must<S2SV_blank>be<S2SV_blank>specified" ) , error ) ; if ( argc < 3 ) return usage_error ( context , _ ( "LOCATION<S2SV_blank>must<S2SV_blank>be<S2SV_blank>specified" ) , error ) ; if ( argc > 3 ) return usage_error ( context , _ ( "Too<S2SV_blank>many<S2SV_blank>arguments" ) , error ) ; remote_name = argv [ 1 ] ; location = argv [ 2 ] ; remotes = flatpak_dir_list_remotes ( dir , cancellable , error ) ; if ( remotes == NULL ) return FALSE ; if ( g_strv_contains ( ( const char * * ) remotes , remote_name ) ) { if ( opt_if_not_exists ) return TRUE ; return flatpak_fail ( error , _ ( "Remote<S2SV_blank>%s<S2SV_blank>already<S2SV_blank>exists" ) , remote_name ) ; } if ( opt_from || flatpak_file_arg_has_suffix ( location , ".flatpakrepo" ) ) { load_options ( location , & gpg_data ) ; if ( opt_url == NULL ) return flatpak_fail ( error , _ ( "No<S2SV_blank>url<S2SV_blank>specified<S2SV_blank>in<S2SV_blank>flatpakrepo<S2SV_blank>file" ) ) ; } else { file = g_file_new_for_commandline_arg ( location ) ; if ( g_file_is_native ( file ) ) remote_url = g_file_get_uri ( file ) ; else remote_url = g_strdup ( location ) ; opt_url = remote_url ; } if ( ! opt_no_gpg_verify ) opt_do_gpg_verify = TRUE ; config = get_config_from_opts ( dir , remote_name , & changed ) ; if ( opt_gpg_import != NULL ) { gpg_data = flatpak_load_gpg_keys ( opt_gpg_import , cancellable , error ) ; if ( gpg_data == NULL ) return FALSE ; } if ( ! flatpak_dir_modify_remote ( dir , remote_name , config , gpg_data , cancellable , error ) ) return FALSE ; if ( ! flatpak_dir_recreate_repo ( dir , cancellable , error ) ) return FALSE ; <S2SV_StartBug> return flatpak_dir_update_remote_configuration ( dir , remote_name , cancellable , error ) ; <S2SV_EndBug> } | <S2SV_ModStart> changed = FALSE ; g_autoptr ( GError ) local_error = NULL <S2SV_ModStart> return FALSE ; if ( ! <S2SV_ModEnd> flatpak_dir_update_remote_configuration ( dir <S2SV_ModStart> , cancellable , & local_error ) ) { if ( g_error_matches ( local_error , G_IO_ERROR , G_IO_ERROR_NOT_FOUND ) ) { g_warning ( _ ( "Could<S2SV_blank>not<S2SV_blank>update<S2SV_blank>extra<S2SV_blank>metadata<S2SV_blank>for<S2SV_blank>\'%s\':<S2SV_blank>%s\\n" ) , remote_name , local_error -> message ) ; } else { g_propagate_error ( error , g_steal_pointer ( & local_error ) ) ; return FALSE ; } } return TRUE <S2SV_ModEnd> ; } <S2SV_null> |
4,782 | CWE-000 static int network_receiving ( void ) { char read_buffer [ NM_PI_BUFFER_SIZE ] , crypt_buffer [ NM_PI_BUFFER_SIZE ] ; struct minivtun_msg * nmsg ; struct tun_pi pi ; void * out_data ; size_t ip_dlen , out_dlen ; struct sockaddr_inx real_peer ; socklen_t real_peer_alen ; struct iovec iov [ 2 ] ; struct timeval __current ; int rc ; gettimeofday ( & __current , NULL ) ; real_peer_alen = sizeof ( real_peer ) ; rc = recvfrom ( state . sockfd , & read_buffer , NM_PI_BUFFER_SIZE , 0 , ( struct sockaddr * ) & real_peer , & real_peer_alen ) ; if ( rc <= 0 ) return - 1 ; out_data = crypt_buffer ; out_dlen = ( size_t ) rc ; netmsg_to_local ( read_buffer , & out_data , & out_dlen ) ; nmsg = out_data ; if ( out_dlen < MINIVTUN_MSG_BASIC_HLEN ) return 0 ; if ( memcmp ( nmsg -> hdr . auth_key , config . crypto_key , sizeof ( nmsg -> hdr . auth_key ) ) != 0 ) return 0 ; state . last_recv = __current ; if ( ! state . is_link_ok ) { if ( config . dynamic_link ) handle_link_up ( ) ; state . is_link_ok = true ; } switch ( nmsg -> hdr . opcode ) { case MINIVTUN_MSG_IPDATA : if ( config . tap_mode ) { if ( out_dlen < MINIVTUN_MSG_IPDATA_OFFSET + 12 ) return 0 ; <S2SV_StartBug> nmsg -> ipdata . proto = 0 ; <S2SV_EndBug> } else { if ( nmsg -> ipdata . proto == htons ( ETH_P_IP ) ) { if ( out_dlen < MINIVTUN_MSG_IPDATA_OFFSET + 20 ) return 0 ; } else if ( nmsg -> ipdata . proto == htons ( ETH_P_IPV6 ) ) { if ( out_dlen < MINIVTUN_MSG_IPDATA_OFFSET + 40 ) return 0 ; } else { syslog ( LOG_WARNING , "***<S2SV_blank>Invalid<S2SV_blank>protocol:<S2SV_blank>0x%x." , ntohs ( nmsg -> ipdata . proto ) ) ; return 0 ; } ip_dlen = ntohs ( nmsg -> ipdata . ip_dlen ) ; if ( out_dlen - MINIVTUN_MSG_IPDATA_OFFSET < ip_dlen ) return 0 ; } pi . flags = 0 ; pi . proto = nmsg -> ipdata . proto ; osx_ether_to_af ( & pi . proto ) ; iov [ 0 ] . iov_base = & pi ; iov [ 0 ] . iov_len = sizeof ( pi ) ; iov [ 1 ] . iov_base = ( char * ) nmsg + MINIVTUN_MSG_IPDATA_OFFSET ; iov [ 1 ] . iov_len = ip_dlen ; rc = writev ( state . tunfd , iov , 2 ) ; break ; case MINIVTUN_MSG_ECHO_ACK : if ( state . has_pending_echo && nmsg -> echo . id == state . pending_echo_id ) { state . last_echo_recv = __current ; state . total_echo_rcvd ++ ; state . total_rtt_ms += __sub_timeval_ms ( & __current , & state . last_echo_sent ) ; state . has_pending_echo = false ; } break ; } return 0 ; } | <S2SV_ModStart> return 0 ; ip_dlen = out_dlen - MINIVTUN_MSG_IPDATA_OFFSET ; |
4,783 | CWE-000 <S2SV_StartBug> void <S2SV_EndBug> <S2SV_StartBug> FUN ( clear ) ( T * t ) <S2SV_EndBug> { assert ( t ) ; <S2SV_StartBug> t -> lo = t -> mo ; <S2SV_EndBug> t -> hi = t -> nz = 0 ; t -> coef [ 0 ] = 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> T * FUN ( new ) ( const <S2SV_ModEnd> T * t <S2SV_ModStart> T * t , ord_t mo <S2SV_ModStart> t ) ; return FUN ( newd ) ( t -> d , mo == mad_tpsa_same ? <S2SV_ModEnd> t -> mo <S2SV_ModStart> t -> mo : mo ) <S2SV_ModEnd> ; } <S2SV_null> |
4,784 | CWE-000 static inline u16 mlx5e_calc_min_inline ( enum mlx5_inline_modes mode , struct sk_buff * skb ) { u16 hlen ; switch ( mode ) { case MLX5_INLINE_MODE_NONE : return 0 ; case MLX5_INLINE_MODE_TCP_UDP : hlen = eth_get_headlen ( skb -> data , skb_headlen ( skb ) ) ; if ( hlen == ETH_HLEN && ! skb_vlan_tag_present ( skb ) ) hlen += VLAN_HLEN ; break ; case MLX5_INLINE_MODE_IP : if ( skb_transport_offset ( skb ) ) { hlen = mlx5e_skb_l3_header_offset ( skb ) ; break ; } case MLX5_INLINE_MODE_L2 : default : hlen = mlx5e_skb_l2_header_offset ( skb ) ; } <S2SV_StartBug> return min_t ( u16 , hlen , skb -> len ) ; <S2SV_EndBug> } | <S2SV_ModStart> , hlen , skb_headlen ( skb ) <S2SV_ModEnd> ) ; } |
4,785 | CWE-000 void mostra_boio ( COMBOIO boio ) { printf ( "\\n/----COMBOIO<S2SV_blank>%s----/\\n" , boio . id ) ; <S2SV_StartBug> printf ( "Dimensao:%d\\n" , boio . dim ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "Cor<S2SV_blank>locom.:%s\\n" , cor_codigo ( boio . cor ) ) ; <S2SV_EndBug> printf ( "Ponto<S2SV_blank>origem:%s\\n" , boio . origem -> pt . id ) ; <S2SV_StartBug> printf ( "Tempo<S2SV_blank>de<S2SV_blank>spawn:%.2f\\n" , boio . tempo_spawn ) ; <S2SV_EndBug> printf ( "Velocidade:%.2fpixeis/segundo\\n" , boio . veloc * FPS ) ; fflush ( stdout ) ; } | <S2SV_ModStart> ; printf ( "Raio<S2SV_blank>das<S2SV_blank>bolas:%d\\n" <S2SV_ModEnd> , boio . <S2SV_ModStart> , boio . r_bolas <S2SV_ModEnd> ) ; printf <S2SV_ModStart> ( "Cor<S2SV_blank>locom.:%s\\n" , cor_Uint32_para_string <S2SV_ModEnd> ( boio . <S2SV_ModStart> ; printf ( "Numero<S2SV_blank>de<S2SV_blank>servicos:%d\\n" <S2SV_ModEnd> , boio . <S2SV_ModStart> , boio . numero_de_servicos <S2SV_ModEnd> ) ; printf |
4,786 | CWE-000 gboolean ephy_sqlite_connection_rollback_transaction ( EphySQLiteConnection * self , GError * * error ) { <S2SV_StartBug> return ephy_sqlite_connection_execute ( self , "ROLLBACK" , error ) ; <S2SV_EndBug> } | <S2SV_ModStart> error ) { if ( self -> priv -> mode == EPHY_SQLITE_CONNECTION_MODE_READ_ONLY ) return TRUE ; |
4,787 | CWE-000 PLL_EXPORT double pllmod_opt_optimize_branch_lengths_local_multi ( pll_partition_t * * partitions , size_t partition_count , pll_unode_t * tree , unsigned int * * params_indices , double * * precomp_buffers , double * brlen_scalers , double branch_length_min , double branch_length_max , double tolerance , int smoothings , int radius , int keep_update , void * parallel_context , void ( * parallel_reduce_cb ) ( void * , double * , size_t , int ) ) { unsigned int iters ; double loglikelihood = 0.0 , new_loglikelihood ; unsigned int sites_alloc ; size_t p ; double result = ( double ) PLL_FAILURE ; pllmod_reset_error ( ) ; if ( radius < PLLMOD_OPT_BRLEN_OPTIMIZE_ALL ) { pllmod_set_error ( PLLMOD_OPT_ERROR_NEWTON_BAD_RADIUS , "Invalid<S2SV_blank>radius<S2SV_blank>for<S2SV_blank>branch<S2SV_blank>length<S2SV_blank>optimization" ) ; return ( double ) PLL_FAILURE ; } loglikelihood = pllmod_opt_compute_edge_loglikelihood_multi ( partitions , partition_count , tree -> back -> clv_index , tree -> back -> scaler_index , tree -> clv_index , tree -> scaler_index , tree -> pmatrix_index , params_indices , NULL , parallel_context , parallel_reduce_cb ) ; pll_newton_tree_params_multi_t params ; params . partitions = partitions ; params . partition_count = partition_count ; params . tree = tree ; params . params_indices = params_indices ; params . branch_length_min = ( branch_length_min > 0 ) ? branch_length_min : PLLMOD_OPT_MIN_BRANCH_LEN ; params . branch_length_max = ( branch_length_max > 0 ) ? branch_length_max : PLLMOD_OPT_MAX_BRANCH_LEN ; params . tolerance = ( branch_length_min > 0 ) ? branch_length_min / 10.0 : PLLMOD_OPT_TOL_BRANCH_LEN ; params . precomp_buffers = precomp_buffers ; params . brlen_scalers = brlen_scalers ; params . parallel_context = parallel_context ; params . parallel_reduce_cb = parallel_reduce_cb ; if ( ! params . precomp_buffers ) { params . precomp_buffers = ( double * * ) calloc ( partition_count , sizeof ( double * ) ) ; if ( params . precomp_buffers == NULL ) { pllmod_set_error ( PLL_ERROR_MEM_ALLOC , "Cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>bl<S2SV_blank>opt<S2SV_blank>variables" ) ; goto cleanup ; } for ( p = 0 ; p < partition_count ; ++ p ) { const pll_partition_t * partition = partitions [ p ] ; if ( ! partition ) continue ; sites_alloc = partition -> sites ; if ( partition -> attributes & PLL_ATTRIB_AB_FLAG ) sites_alloc += partition -> states ; if ( ( params . precomp_buffers [ p ] = ( double * ) pll_aligned_alloc ( sites_alloc * partition -> rate_cats * partition -> states_padded * sizeof ( double ) , partition -> alignment ) ) == NULL ) { pllmod_set_error ( PLL_ERROR_MEM_ALLOC , "Cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>bl<S2SV_blank>opt<S2SV_blank>variables" ) ; goto cleanup ; } } } iters = ( unsigned int ) smoothings ; while ( iters ) { new_loglikelihood = loglikelihood ; params . tree = tree ; if ( ! recomp_iterative_multi ( & params , radius , & new_loglikelihood , keep_update ) ) goto cleanup ; if ( radius ) { params . tree = tree -> back ; if ( ! recomp_iterative_multi ( & params , radius - 1 , & new_loglikelihood , keep_update ) ) goto cleanup ; } new_loglikelihood = pllmod_opt_compute_edge_loglikelihood_multi ( partitions , partition_count , tree -> back -> clv_index , tree -> back -> scaler_index , tree -> clv_index , tree -> scaler_index , tree -> pmatrix_index , params_indices , NULL , parallel_context , parallel_reduce_cb ) ; DBG ( "BLO_multi:<S2SV_blank>iteration<S2SV_blank>%u,<S2SV_blank>old<S2SV_blank>LH:<S2SV_blank>%.9f,<S2SV_blank>new<S2SV_blank>LH:<S2SV_blank>%.9f\\n" , ( unsigned int ) smoothings - iters , loglikelihood , new_loglikelihood ) ; # if ( CHECK_PERBRANCH_IMPR ) assert ( new_loglikelihood - loglikelihood > new_loglikelihood * BETTER_LL_TRESHOLD ) ; # else if ( ! ( new_loglikelihood - loglikelihood > new_loglikelihood * BETTER_LL_TRESHOLD ) ) { pllmod_set_error ( PLLMOD_OPT_ERROR_NEWTON_WORSE_LK , <S2SV_StartBug> "BL<S2SV_blank>opt<S2SV_blank>converged<S2SV_blank>to<S2SV_blank>a<S2SV_blank>worse<S2SV_blank>likelihood<S2SV_blank>score<S2SV_blank>by<S2SV_blank>%f<S2SV_blank>units" , <S2SV_EndBug> new_loglikelihood - loglikelihood ) ; goto cleanup ; } # endif iters -- ; if ( fabs ( new_loglikelihood - loglikelihood ) < tolerance ) iters = 0 ; loglikelihood = new_loglikelihood ; } result = - 1 * loglikelihood ; cleanup : if ( ! precomp_buffers ) { for ( p = 0 ; p < partition_count ; ++ p ) { if ( params . precomp_buffers [ p ] ) free ( params . precomp_buffers [ p ] ) ; } pll_aligned_free ( params . precomp_buffers ) ; } return result ; } | <S2SV_ModStart> ( PLLMOD_OPT_ERROR_NEWTON_WORSE_LK , "BL<S2SV_blank>opt<S2SV_blank>converged<S2SV_blank>to<S2SV_blank>a<S2SV_blank>worse<S2SV_blank>likelihood<S2SV_blank>score<S2SV_blank>by<S2SV_blank>%.15f<S2SV_blank>units" <S2SV_ModEnd> , new_loglikelihood - |
4,788 | CWE-000 static bool mp_media_reset ( mp_media_t * m ) { AVStream * stream = m -> fmt -> streams [ 0 ] ; int64_t seek_pos ; int seek_flags ; bool stopping ; bool active ; if ( m -> fmt -> duration == AV_NOPTS_VALUE ) { seek_pos = 0 ; seek_flags = AVSEEK_FLAG_FRAME ; } else { seek_pos = m -> fmt -> start_time ; seek_flags = AVSEEK_FLAG_BACKWARD ; } int64_t seek_target = seek_flags == AVSEEK_FLAG_BACKWARD ? av_rescale_q ( seek_pos , AV_TIME_BASE_Q , stream -> time_base ) : seek_pos ; <S2SV_StartBug> if ( ! m -> is_network && ! m -> is_concat ) { <S2SV_EndBug> int ret = av_seek_frame ( m -> fmt , 0 , seek_target , seek_flags ) ; if ( ret < 0 ) { blog ( LOG_WARNING , "MP:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>seek:<S2SV_blank>%s" , av_err2str ( ret ) ) ; <S2SV_StartBug> return false ; <S2SV_EndBug> } } <S2SV_StartBug> if ( m -> has_video && ! m -> is_network ) <S2SV_EndBug> mp_decode_flush ( & m -> v ) ; <S2SV_StartBug> if ( m -> has_audio && ! m -> is_network ) <S2SV_EndBug> mp_decode_flush ( & m -> a ) ; int64_t next_ts = mp_media_get_base_pts ( m ) ; int64_t offset = next_ts - m -> next_pts_ns ; m -> eof = false ; m -> base_ts += next_ts ; pthread_mutex_lock ( & m -> mutex ) ; stopping = m -> stopping ; active = m -> active ; m -> stopping = false ; pthread_mutex_unlock ( & m -> mutex ) ; if ( ! mp_media_prepare_frames ( m ) ) return false ; if ( active ) { if ( ! m -> play_sys_ts ) m -> play_sys_ts = ( int64_t ) os_gettime_ns ( ) ; m -> start_ts = m -> next_pts_ns = mp_media_get_next_min_pts ( m ) ; if ( m -> next_ns ) m -> next_ns += offset ; } else { m -> start_ts = m -> next_pts_ns = mp_media_get_next_min_pts ( m ) ; m -> play_sys_ts = ( int64_t ) os_gettime_ns ( ) ; m -> next_ns = 0 ; } <S2SV_StartBug> if ( ! active && ! m -> is_network && m -> v_preload_cb ) <S2SV_EndBug> mp_media_next_video ( m , true ) ; if ( stopping && m -> stop_cb ) m -> stop_cb ( m -> opaque ) ; return true ; } | <S2SV_ModStart> ; if ( m -> is_local_file <S2SV_ModEnd> ) { int <S2SV_ModStart> ) ) ; <S2SV_ModEnd> } } if <S2SV_ModStart> -> has_video && m -> is_local_file <S2SV_ModEnd> ) mp_decode_flush ( <S2SV_ModStart> -> has_audio && m -> is_local_file <S2SV_ModEnd> ) mp_decode_flush ( <S2SV_ModStart> ! active && m -> is_local_file <S2SV_ModEnd> && m -> |
4,789 | CWE-000 static void probe_event_disable ( struct trace_uprobe * tu , struct ftrace_event_file * file ) { if ( ! trace_probe_is_enabled ( & tu -> tp ) ) return ; if ( file ) { struct event_file_link * link ; link = find_event_file_link ( & tu -> tp , file ) ; if ( ! link ) return ; list_del_rcu ( & link -> list ) ; <S2SV_StartBug> synchronize_sched ( ) ; <S2SV_EndBug> kfree ( link ) ; if ( ! list_empty ( & tu -> tp . files ) ) return ; } WARN_ON ( ! uprobe_filter_is_empty ( & tu -> filter ) ) ; uprobe_unregister ( tu -> inode , tu -> offset , & tu -> consumer ) ; tu -> tp . flags &= file ? ~ TP_FLAG_TRACE : ~ TP_FLAG_PROFILE ; uprobe_buffer_disable ( ) ; } | <S2SV_ModStart> list ) ; synchronize_rcu <S2SV_ModEnd> ( ) ; |
4,790 | CWE-000 double rf_soapy_set_rx_srate ( void * h , double rate ) { rf_soapy_handler_t * handler = ( rf_soapy_handler_t * ) h ; if ( SoapySDRDevice_setSampleRate ( handler -> device , SOAPY_SDR_RX , 0 , rate ) != 0 ) { printf ( "setSampleRate<S2SV_blank>Rx<S2SV_blank>fail:<S2SV_blank>%s\\n" , SoapySDRDevice_lastError ( ) ) ; return SRSLTE_ERROR ; } <S2SV_StartBug> if ( SoapySDRDevice_setBandwidth ( handler -> device , SOAPY_SDR_RX , 0 , rate ) != 0 ) { <S2SV_EndBug> printf ( "setBandwidth<S2SV_blank>Rx<S2SV_blank>failed:<S2SV_blank>%s\\n" , SoapySDRDevice_lastError ( ) ) ; return SRSLTE_ERROR ; } return SoapySDRDevice_getSampleRate ( handler -> device , SOAPY_SDR_RX , 0 ) ; } | <S2SV_ModStart> SRSLTE_ERROR ; } <S2SV_ModEnd> return SoapySDRDevice_getSampleRate ( |
4,791 | CWE-000 void runShell ( ) { <S2SV_StartBug> char * input ; <S2SV_EndBug> List tokens ; while ( TRUE ) { printf ( "$<S2SV_blank>" ) ; <S2SV_StartBug> input = readInput ( ) ; <S2SV_EndBug> if ( quitProgram ( input ) ) { free ( input ) ; break ; } <S2SV_StartBug> tokens = parseInput ( input ) ; <S2SV_EndBug> printList ( tokens ) ; free ( input ) ; List tokensCopy = tokens ; if ( acceptInput ( & tokensCopy ) ) { printf ( "\\n<S2SV_blank>--<S2SV_blank>Input<S2SV_blank>can<S2SV_blank>be<S2SV_blank>executed!<S2SV_blank>--\\n\\n" ) ; } else { printf ( "\\n<S2SV_blank>ERROR:<S2SV_blank>cannot<S2SV_blank>execute<S2SV_blank>the<S2SV_blank>input!\\n\\n" ) ; freeList ( tokens ) ; continue ; } execBackgroundProcess ( & tokens ) ; while ( tokens != NULL ) { if ( acceptSymbol ( & tokens , "&" ) ) { execBackgroundProcess ( & tokens ) ; } else break ; } freeList ( tokens ) ; <S2SV_StartBug> freeList ( tokensCopy ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> while ( TRUE <S2SV_ModStart> "$<S2SV_blank>" ) ; char * <S2SV_ModStart> break ; } List <S2SV_ModStart> tokens ) ; <S2SV_ModEnd> } } <S2SV_null> |
4,792 | CWE-000 static irqreturn_t <S2SV_StartBug> igbuio_pci_irqhandler ( int irq , struct uio_info * info ) <S2SV_EndBug> { struct rte_uio_pci_dev * udev = info -> priv ; if ( udev -> mode == RTE_INTR_MODE_LEGACY && ! pci_check_and_mask_intx ( udev -> pdev ) ) return IRQ_NONE ; <S2SV_StartBug> return IRQ_HANDLED ; <S2SV_EndBug> } | <S2SV_ModStart> int irq , void * dev_id ) { struct uio_device * idev = ( struct uio_device * ) dev_id ; <S2SV_ModStart> uio_info * info = idev -> info ; <S2SV_ModEnd> struct rte_uio_pci_dev * <S2SV_ModStart> return IRQ_NONE ; uio_event_notify ( info ) ; |
4,793 | CWE-000 matrix_t * parse_matrix_with_delimiters ( const char * str , const char * row_delimiter , const char * col_delimiter ) { char * contents = strdup ( str ) ; if ( contents == NULL ) { return NULL ; } char * free_later = contents ; matrix_t * mat = malloc ( sizeof ( matrix_t ) ) ; if ( mat == NULL ) { free ( free_later ) ; return NULL ; } rows ( mat ) = 0 ; cols ( mat ) = 0 ; mat_i_t array_length = 32 ; mat -> array = malloc ( sizeof ( mat_data_t ) * array_length ) ; if ( mat -> array == NULL ) { goto error ; } mat_i_t length_count = 0 ; char * raw_row ; char * entry ; while ( ( raw_row = strsep ( & contents , row_delimiter ) ) != NULL ) { if ( strncmp ( raw_row , "" , 1 ) == 0 ) { continue ; } mat_i_t temp_cols = 0 ; while ( ( entry = strsep ( & raw_row , col_delimiter ) ) != NULL ) { if ( strncmp ( entry , "" , 1 ) == 0 ) { continue ; } <S2SV_StartBug> char * err ; <S2SV_EndBug> mat_data_t new_val = strtod ( entry , & err ) ; if ( errno == ERANGE ) { debug_printf ( "Overflow/underflow<S2SV_blank>occurred<S2SV_blank>with<S2SV_blank>value<S2SV_blank>\'%s\'\\n" , entry ) ; goto error ; } if ( new_val == 0 && err == entry ) { debug_printf ( "No<S2SV_blank>conversion<S2SV_blank>occurred.<S2SV_blank>Stuck<S2SV_blank>on<S2SV_blank>\'%s\'\\n" , entry ) ; goto error ; } assert ( length_count <= array_length ) ; if ( length_count == array_length ) { mat_i_t new_length = array_length << 1 ; mat_data_t * new_array = realloc ( mat -> array , sizeof ( mat_data_t ) * new_length ) ; if ( new_array == NULL ) { debug_printf ( "Reallocation<S2SV_blank>from<S2SV_blank>%lu<S2SV_blank>bytes<S2SV_blank>to<S2SV_blank>%lu<S2SV_blank>bytes<S2SV_blank>failed.\\n" , array_length * sizeof ( mat_data_t ) , new_length * sizeof ( mat_data_t ) ) ; goto error ; } mat -> array = new_array ; array_length = new_length ; } entry ( mat , length_count ) = new_val ; ++ temp_cols ; ++ length_count ; } if ( cols ( mat ) == 0 ) { cols ( mat ) = temp_cols ; } else if ( cols ( mat ) != temp_cols ) { debug_printf ( "Inconsistent<S2SV_blank>columns.<S2SV_blank>One<S2SV_blank>row<S2SV_blank>has<S2SV_blank>%lu<S2SV_blank>cols.<S2SV_blank>Another<S2SV_blank>has<S2SV_blank>%lu.\\n" , cols ( mat ) , temp_cols ) ; goto error ; } ++ ( rows ( mat ) ) ; } if ( rows ( mat ) < 1 || cols ( mat ) < 1 ) { goto error ; } length ( mat ) = rows ( mat ) * cols ( mat ) ; mat_data_t * final_array = realloc ( mat -> array , sizeof ( mat_data_t ) * length ( mat ) ) ; if ( final_array == NULL ) { goto error ; } mat -> array = final_array ; free ( free_later ) ; return mat ; error : free_matrix ( mat ) ; free ( free_later ) ; return NULL ; } | <S2SV_ModStart> char * err ; errno = 0 |
4,794 | CWE-000 static void move_resize ( struct roots_view * view , double x , double y , uint32_t width , uint32_t height ) { assert ( view -> type == ROOTS_XDG_SHELL_V6_VIEW ) ; struct roots_xdg_surface_v6 * roots_surface = view -> roots_xdg_surface_v6 ; struct wlr_xdg_surface_v6 * surface = view -> xdg_surface_v6 ; if ( surface -> role != WLR_XDG_SURFACE_V6_ROLE_TOPLEVEL ) { return ; } <S2SV_StartBug> uint32_t constrained_width , constrained_height ; <S2SV_EndBug> apply_size_constraints ( surface , width , height , & constrained_width , & constrained_height ) ; <S2SV_StartBug> x = x + width - constrained_width ; <S2SV_EndBug> <S2SV_StartBug> y = y + height - constrained_height ; <S2SV_EndBug> <S2SV_StartBug> roots_surface -> move_resize . x = x ; <S2SV_EndBug> roots_surface -> move_resize . y = y ; roots_surface -> move_resize . width = constrained_width ; roots_surface -> move_resize . height = constrained_height ; roots_surface -> move_resize . configure_serial = wlr_xdg_toplevel_v6_set_size ( surface , constrained_width , constrained_height ) ; } | <S2SV_ModStart> return ; } bool update_x = x != view -> x ; bool update_y = y != view -> y ; <S2SV_ModStart> constrained_height ) ; if ( update_x ) { <S2SV_ModStart> - constrained_width ; } if ( update_y ) { <S2SV_ModStart> - constrained_height ; } roots_surface -> move_resize . x = x ; roots_surface -> move_resize . y = y ; roots_surface -> move_resize . update_x = update_x ; roots_surface -> move_resize . update_y = update_y <S2SV_ModEnd> ; roots_surface -> |
4,795 | CWE-000 int main ( ) { <S2SV_StartBug> int size ; <S2SV_EndBug> scanf ( "%d" , & size ) ; int ar [ size ] ; Matrix m ; return 0 ; } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> return 0 ; |
4,796 | CWE-000 int fdt_property ( void * fdt , const char * name , const void * val , int len ) { <S2SV_StartBug> struct fdt_property * prop ; <S2SV_EndBug> int nameoff ; FDT_SW_CHECK_HEADER ( fdt ) ; <S2SV_StartBug> nameoff = _fdt_find_add_string ( fdt , name ) ; <S2SV_EndBug> <S2SV_StartBug> if ( nameoff == 0 ) <S2SV_EndBug> return - FDT_ERR_NOSPACE ; prop = _fdt_grab_space ( fdt , sizeof ( * prop ) + FDT_TAGALIGN ( len ) ) ; if ( ! prop ) return - FDT_ERR_NOSPACE ; prop -> tag = cpu_to_fdt32 ( FDT_PROP ) ; prop -> nameoff = cpu_to_fdt32 ( nameoff ) ; prop -> len = cpu_to_fdt32 ( len ) ; <S2SV_StartBug> memcpy ( prop -> data , val , len ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> len ) { void * ptr ; int ret ; ret = fdt_property_placeholder <S2SV_ModEnd> ( fdt , <S2SV_ModStart> fdt , name , len , & ptr <S2SV_ModStart> ; if ( ret ) return ret <S2SV_ModEnd> ; memcpy ( <S2SV_ModStart> ; memcpy ( ptr <S2SV_ModEnd> , val , |
4,797 | CWE-000 int main ( int argc , char * * argv ) { if ( argc != 2 ) { printf ( "Usage:<S2SV_blank>%s<S2SV_blank><path>\\n" , argv [ 0 ] ) ; <S2SV_StartBug> printf ( "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>where<S2SV_blank><path><S2SV_blank>is<S2SV_blank>the<S2SV_blank>file<S2SV_blank>or<S2SV_blank>root<S2SV_blank>of<S2SV_blank>the<S2SV_blank>tree<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>summarize.\\n" ) ; <S2SV_EndBug> return 1 ; } ftw ( argv [ 1 ] , callback , MAX_FTW_DEPTH ) ; printf ( "There<S2SV_blank>were<S2SV_blank>%d<S2SV_blank>directories.\\n" , num_dirs ) ; <S2SV_StartBug> printf ( "There<S2SV_blank>were<S2SV_blank>%d<S2SV_blank>regular<S2SV_blank>files.\\n" , num_files ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; printf ( "where<S2SV_blank><path><S2SV_blank>is<S2SV_blank>the<S2SV_blank>file<S2SV_blank>or<S2SV_blank>root<S2SV_blank>of<S2SV_blank>the<S2SV_blank>tree<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>summarize.\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> ( "There<S2SV_blank>were<S2SV_blank>%d<S2SV_blank>regular<S2SV_blank>files.\\n" , num_regular ) <S2SV_ModEnd> ; } <S2SV_null> |
4,798 | CWE-000 int writeToOutputFile ( ) { int rv ; int i ; rv = write ( fdOutputFile , chunk , sizeOfChunk ) ; if ( rv < 0 ) { printf ( "Could<S2SV_blank>not<S2SV_blank>write<S2SV_blank>chunk<S2SV_blank>to<S2SV_blank>data<S2SV_blank>file\\n" ) ; return - 1 ; } for ( i = 0 ; i < numOfThreads ; i ++ ) { if ( stillRunning [ i ] == true ) { finishedXoring [ i ] = false ; } } sizeOfFile += sizeOfChunk ; sizeOfChunk = 0 ; printf ( "Written<S2SV_blank>all<S2SV_blank>chunk<S2SV_blank>to<S2SV_blank>output<S2SV_blank>file\\n" ) ; for ( i = 0 ; i < numOfThreads ; i ++ ) { finishedXoring [ i ] = false ; <S2SV_StartBug> printf ( "After<S2SV_blank>writen<S2SV_blank>to<S2SV_blank>file<S2SV_blank>thread<S2SV_blank>in<S2SV_blank>place<S2SV_blank>%d<S2SV_blank>has<S2SV_blank>putten<S2SV_blank>false<S2SV_blank>in<S2SV_blank>finished<S2SV_blank>xoring\\n" , i ) ; <S2SV_EndBug> } for ( i = 0 ; i < ( 1024 * 1024 ) ; i ++ ) { chunk [ i ] = '\\0' ; } return 0 ; } | <S2SV_ModStart> = false ; <S2SV_ModEnd> } for ( |
4,799 | CWE-000 void sdl_data_start ( ) <S2SV_StartBug> { <S2SV_EndBug> s_ssdMode = SSD_MODE_DATA ; if ( s_dcPin >= 0 ) s_digitalPins [ s_dcPin ] = 1 ; s_commandId = - 1 ; } | <S2SV_ModStart> ( ) { s_active_data_mode = SDM_COMMAND_ARG ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.