Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
---|---|---|
7,600 |
CWE-000 static void fec_restart ( struct net_device * ndev ) { struct fec_enet_private * fep = netdev_priv ( ndev ) ; u32 val ; u32 temp_mac [ 2 ] ; u32 rcntl = OPT_FRAME_SIZE | 0x04 ; u32 ecntl = FEC_ENET_ETHEREN ; if ( fep -> quirks & FEC_QUIRK_HAS_AVB ) { writel ( 0 , fep -> hwp + FEC_ECNTRL ) ; } else { writel ( 1 , fep -> hwp + FEC_ECNTRL ) ; udelay ( 10 ) ; } if ( fep -> quirks & FEC_QUIRK_ENET_MAC ) { memcpy ( & temp_mac , ndev -> dev_addr , ETH_ALEN ) ; writel ( ( __force u32 ) cpu_to_be32 ( temp_mac [ 0 ] ) , fep -> hwp + FEC_ADDR_LOW ) ; writel ( ( __force u32 ) cpu_to_be32 ( temp_mac [ 1 ] ) , fep -> hwp + FEC_ADDR_HIGH ) ; } writel ( 0xffffffff , fep -> hwp + FEC_IEVENT ) ; fec_enet_bd_init ( ndev ) ; fec_enet_enable_ring ( ndev ) ; fec_enet_reset_skb ( ndev ) ; if ( fep -> full_duplex == DUPLEX_FULL ) { writel ( 0x04 , fep -> hwp + FEC_X_CNTRL ) ; } else { rcntl |= 0x02 ; writel ( 0x0 , fep -> hwp + FEC_X_CNTRL ) ; } writel ( fep -> phy_speed , fep -> hwp + FEC_MII_SPEED ) ; # if ! defined ( CONFIG_M5272 ) if ( fep -> quirks & FEC_QUIRK_HAS_RACC ) { val = readl ( fep -> hwp + FEC_RACC ) ; <S2SV_StartBug> if ( fep -> csum_flags & FLAG_RX_CSUM_ENABLED ) <S2SV_EndBug> val |= FEC_RACC_OPTIONS ; else val &= ~ FEC_RACC_OPTIONS ; writel ( val , fep -> hwp + FEC_RACC ) ; writel ( PKT_MAXBUF_SIZE , fep -> hwp + FEC_FTRL ) ; } # endif if ( fep -> quirks & FEC_QUIRK_ENET_MAC ) { rcntl |= 0x40000000 | 0x00000020 ; if ( fep -> phy_interface == PHY_INTERFACE_MODE_RGMII || fep -> phy_interface == PHY_INTERFACE_MODE_RGMII_ID || fep -> phy_interface == PHY_INTERFACE_MODE_RGMII_RXID || fep -> phy_interface == PHY_INTERFACE_MODE_RGMII_TXID ) rcntl |= ( 1 << 6 ) ; else if ( fep -> phy_interface == PHY_INTERFACE_MODE_RMII ) rcntl |= ( 1 << 8 ) ; else rcntl &= ~ ( 1 << 8 ) ; if ( fep -> phy_dev ) { if ( fep -> phy_dev -> speed == SPEED_1000 ) ecntl |= ( 1 << 5 ) ; else if ( fep -> phy_dev -> speed == SPEED_100 ) rcntl &= ~ ( 1 << 9 ) ; else rcntl |= ( 1 << 9 ) ; } } else { # ifdef FEC_MIIGSK_ENR if ( fep -> quirks & FEC_QUIRK_USE_GASKET ) { u32 cfgr ; writel ( 0 , fep -> hwp + FEC_MIIGSK_ENR ) ; while ( readl ( fep -> hwp + FEC_MIIGSK_ENR ) & 4 ) udelay ( 1 ) ; cfgr = ( fep -> phy_interface == PHY_INTERFACE_MODE_RMII ) ? BM_MIIGSK_CFGR_RMII : BM_MIIGSK_CFGR_MII ; if ( fep -> phy_dev && fep -> phy_dev -> speed == SPEED_10 ) cfgr |= BM_MIIGSK_CFGR_FRCONT_10M ; writel ( cfgr , fep -> hwp + FEC_MIIGSK_CFGR ) ; writel ( 2 , fep -> hwp + FEC_MIIGSK_ENR ) ; } # endif } # if ! defined ( CONFIG_M5272 ) if ( ( fep -> pause_flag & FEC_PAUSE_FLAG_ENABLE ) || ( ( fep -> pause_flag & FEC_PAUSE_FLAG_AUTONEG ) && fep -> phy_dev && fep -> phy_dev -> pause ) ) { rcntl |= FEC_ENET_FCE ; writel ( FEC_ENET_RSEM_V , fep -> hwp + FEC_R_FIFO_RSEM ) ; writel ( FEC_ENET_RSFL_V , fep -> hwp + FEC_R_FIFO_RSFL ) ; writel ( FEC_ENET_RAEM_V , fep -> hwp + FEC_R_FIFO_RAEM ) ; writel ( FEC_ENET_RAFL_V , fep -> hwp + FEC_R_FIFO_RAFL ) ; writel ( FEC_ENET_OPD_V , fep -> hwp + FEC_OPD ) ; } else { rcntl &= ~ FEC_ENET_FCE ; } # endif writel ( rcntl , fep -> hwp + FEC_R_CNTRL ) ; set_multicast_list ( ndev ) ; # ifndef CONFIG_M5272 writel ( 0 , fep -> hwp + FEC_HASH_TABLE_HIGH ) ; writel ( 0 , fep -> hwp + FEC_HASH_TABLE_LOW ) ; # endif if ( fep -> quirks & FEC_QUIRK_ENET_MAC ) { ecntl |= ( 1 << 8 ) ; writel ( 1 << 8 , fep -> hwp + FEC_X_WMRK ) ; } if ( fep -> bufdesc_ex ) ecntl |= ( 1 << 4 ) ; # ifndef CONFIG_M5272 writel ( 0 << 31 , fep -> hwp + FEC_MIB_CTRLSTAT ) ; # endif writel ( ecntl , fep -> hwp + FEC_ECNTRL ) ; fec_enet_active_rxring ( ndev ) ; if ( fep -> bufdesc_ex ) fec_ptp_start_cyclecounter ( ndev ) ; if ( fep -> link ) writel ( FEC_DEFAULT_IMASK , fep -> hwp + FEC_IMASK ) ; else writel ( FEC_ENET_MII , fep -> hwp + FEC_IMASK ) ; fec_enet_itr_coal_init ( ndev ) ; }
|
<S2SV_ModStart> FEC_RACC ) ; val |= FEC_RACC_SHIFT16 ;
|
7,601 |
CWE-000 int ft_get_type ( char * arg ) { int type ; type = 0 ; <S2SV_StartBug> if ( ft_is_reg ( arg ) > 0 ) <S2SV_EndBug> type = T_REG ; else if ( ft_is_dir ( arg ) > 0 ) type = T_DIR ; else if ( ft_is_ind ( arg ) > 0 ) type = T_IND ; else if ( ft_is_op ( arg ) > 0 ) type = T_OP ; else type = ft_is_label ( arg ) ; return ( type ) ; }
|
<S2SV_ModStart> ( arg ) != <S2SV_ModEnd> 0 ) type
|
7,602 |
CWE-000 <S2SV_StartBug> int32_t print_char ( display_5110 * display , const char chr ) <S2SV_EndBug> { switch_to_data_mode ( display ) ; <S2SV_StartBug> uint8_t * byte = small_ascii_font + ( ( uint8_t ) chr - 0x20 ) * 6 ; <S2SV_EndBug> for ( int i = 0 ; i < 6 ; i ++ ) { HAL_GPIO_WritePin ( display -> SCE_BASE , display -> SCE_PIN , GPIO_PIN_RESET ) ; HAL_SPI_Transmit ( & hspi3 , byte + i , 1 , 100 ) ; HAL_GPIO_WritePin ( display -> SCE_BASE , display -> SCE_PIN , GPIO_PIN_SET ) ; } return 0 ; }
|
<S2SV_ModStart> * display , char * <S2SV_ModEnd> chr ) { <S2SV_ModStart> ( uint8_t ) *
|
7,603 |
CWE-000 void GEX_Poll ( GexClient * gex ) { <S2SV_StartBug> uint8_t pollbuffer [ TF_MAX_PAYLOAD_RX ] ; <S2SV_EndBug> assert ( gex != NULL ) ; bool first = true ; # define MAX_RETRIES 10 int cycle = 0 ; do { if ( first ) serial_shouldwait ( gex -> acm_fd , gex -> ser_timeout ) ; ssize_t len = read ( gex -> acm_fd , pollbuffer , TF_MAX_PAYLOAD_RX ) ; if ( first ) { serial_noblock ( gex -> acm_fd ) ; first = false ; } if ( len < 0 ) { fprintf ( stderr , "ERROR<S2SV_blank>%d<S2SV_blank>in<S2SV_blank>GEX<S2SV_blank>Poll:<S2SV_blank>%s\\n" , errno , strerror ( errno ) ) ; break ; } else { if ( len == 0 ) { fprintf ( stderr , "No<S2SV_blank>more<S2SV_blank>data<S2SV_blank>to<S2SV_blank>read.\\n" ) ; if ( gex -> tf -> state != 0 ) { if ( cycle < MAX_RETRIES ) { cycle ++ ; first = true ; } else { break ; } } else { break ; } } else { fprintf ( stderr , "rx<S2SV_blank>%d<S2SV_blank>bytes\\n" , ( int ) len ) ; hexDump ( "TF_Receive" , pollbuffer , ( uint32_t ) len ) ; TF_Accept ( gex -> tf , pollbuffer , ( size_t ) len ) ; } } } while ( 1 ) ; }
|
<S2SV_ModStart> gex ) { static
|
7,604 |
CWE-000 static inline void ip6addrlbl_put ( struct ip6addrlbl_entry * p ) { <S2SV_StartBug> if ( atomic_dec_and_test ( & p -> refcnt ) ) <S2SV_EndBug> call_rcu ( & p -> rcu , ip6addrlbl_free_rcu ) ; }
|
<S2SV_ModStart> { if ( refcount_dec_and_test <S2SV_ModEnd> ( & p
|
7,605 |
CWE-000 static int hwsim_new_radio_nl ( struct sk_buff * msg , struct genl_info * info ) { struct hwsim_new_radio_params param = { 0 } ; <S2SV_StartBug> param . reg_strict = info -> attrs [ HWSIM_ATTR_REG_STRICT_REG ] ; <S2SV_EndBug> param . p2p_device = info -> attrs [ HWSIM_ATTR_SUPPORT_P2P_DEVICE ] ; param . channels = channels ; param . destroy_on_close = info -> attrs [ HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE ] ; if ( info -> attrs [ HWSIM_ATTR_CHANNELS ] ) param . channels = nla_get_u32 ( info -> attrs [ HWSIM_ATTR_CHANNELS ] ) ; if ( info -> attrs [ HWSIM_ATTR_NO_VIF ] ) param . no_vif = true ; if ( info -> attrs [ HWSIM_ATTR_RADIO_NAME ] ) <S2SV_StartBug> param . hwname = nla_data ( info -> attrs [ HWSIM_ATTR_RADIO_NAME ] ) ; <S2SV_EndBug> if ( info -> attrs [ HWSIM_ATTR_USE_CHANCTX ] ) param . use_chanctx = true ; else param . use_chanctx = ( param . channels > 1 ) ; if ( info -> attrs [ HWSIM_ATTR_REG_HINT_ALPHA2 ] ) param . reg_alpha2 = nla_data ( info -> attrs [ HWSIM_ATTR_REG_HINT_ALPHA2 ] ) ; if ( info -> attrs [ HWSIM_ATTR_REG_CUSTOM_REG ] ) { u32 idx = nla_get_u32 ( info -> attrs [ HWSIM_ATTR_REG_CUSTOM_REG ] ) ; if ( idx >= ARRAY_SIZE ( hwsim_world_regdom_custom ) ) return - EINVAL ; param . regd = hwsim_world_regdom_custom [ idx ] ; } return mac80211_hwsim_new_radio ( info , & param ) ; }
|
<S2SV_ModStart> 0 } ; const char * hwname = NULL ; <S2SV_ModStart> HWSIM_ATTR_RADIO_NAME ] ) { hwname = kasprintf ( GFP_KERNEL , "%.*s" , nla_len ( info -> attrs [ HWSIM_ATTR_RADIO_NAME ] ) , ( char * ) <S2SV_ModEnd> nla_data ( info <S2SV_ModStart> HWSIM_ATTR_RADIO_NAME ] ) ) ; if ( ! hwname ) return - ENOMEM ; param . hwname = hwname ; } <S2SV_ModEnd> if ( info
|
7,606 |
CWE-000 static void i915_surface_copy_render ( struct pipe_context * pipe , struct pipe_resource * dst , unsigned dst_level , unsigned dstx , unsigned dsty , unsigned dstz , struct pipe_resource * src , unsigned src_level , const struct pipe_box * src_box ) { struct i915_context * i915 = i915_context ( pipe ) ; unsigned src_width0 = src -> width0 ; unsigned src_height0 = src -> height0 ; unsigned dst_width0 = dst -> width0 ; unsigned dst_height0 = dst -> height0 ; struct pipe_box dstbox ; struct pipe_sampler_view src_templ , * src_view ; struct pipe_surface dst_templ , * dst_view ; const struct util_format_description * desc ; if ( dst -> target == PIPE_BUFFER && src -> target == PIPE_BUFFER ) goto fallback ; desc = util_format_description ( src -> format ) ; if ( desc -> colorspace == UTIL_FORMAT_COLORSPACE_ZS ) goto fallback ; desc = util_format_description ( dst -> format ) ; if ( desc -> colorspace == UTIL_FORMAT_COLORSPACE_ZS ) goto fallback ; util_blitter_default_dst_texture ( & dst_templ , dst , dst_level , dstz ) ; <S2SV_StartBug> util_blitter_default_src_texture ( & src_templ , src , src_level ) ; <S2SV_EndBug> if ( ! util_blitter_is_copy_supported ( i915 -> blitter , dst , src ) ) goto fallback ; i915_util_blitter_save_states ( i915 ) ; dst_view = i915_create_surface_custom ( pipe , dst , & dst_templ , dst_width0 , dst_height0 ) ; src_view = i915_create_sampler_view_custom ( pipe , src , & src_templ , src_width0 , src_height0 ) ; u_box_3d ( dstx , dsty , dstz , abs ( src_box -> width ) , abs ( src_box -> height ) , abs ( src_box -> depth ) , & dstbox ) ; util_blitter_blit_generic ( i915 -> blitter , dst_view , & dstbox , src_view , src_box , src_width0 , src_height0 , PIPE_MASK_RGBAZS , PIPE_TEX_FILTER_NEAREST , NULL , FALSE ) ; return ; fallback : util_resource_copy_region ( pipe , dst , dst_level , dstx , dsty , dstz , src , src_level , src_box ) ; }
|
<S2SV_ModStart> ; util_blitter_default_src_texture ( i915 -> blitter ,
|
7,607 |
CWE-000 static inline void srv_fb_update ( RfbConnection * rcon ) { if ( ( rcon -> state != CONSTAT_IDLE ) ) { return ; <S2SV_StartBug> } <S2SV_EndBug> switch ( rcon -> current_encoding ) { case ENC_RAW : srv_fb_encode_update_raw ( rcon ) ; break ; # ifndef NO_ZLIB case ENC_ZRLE : srv_fb_encode_update_zrle ( rcon ) ; break ; # endif case ENC_HEXTILE : default : fprintf ( stderr , "encoding<S2SV_blank>%d<S2SV_blank>not<S2SV_blank>implemented\\n" , rcon -> current_encoding ) ; } }
|
<S2SV_ModStart> return ; } dbgprintf ( "SRV<S2SV_blank>update<S2SV_blank>display<S2SV_blank>enc<S2SV_blank>%d\\n" , rcon -> current_encoding ) ;
|
7,608 |
CWE-000 VNIC * nicdev_unregister_vnic ( NICDevice * dev , uint32_t id ) { VNIC * vnic ; int i , j ; for ( i = 0 ; i < MAX_VNIC_COUNT ; i ++ ) { if ( ! nic_devices [ i ] ) return NULL ; if ( dev -> vnics [ i ] -> id == id ) { vnic = dev -> vnics [ i ] ; dev -> vnics [ i ] = NULL ; for ( j = i ; j + 1 < MAX_VNIC_COUNT ; j ++ ) { if ( dev -> vnics [ j + 1 ] ) { dev -> vnics [ j ] = dev -> vnics [ j + 1 ] ; dev -> vnics [ j + 1 ] = NULL ; } } <S2SV_StartBug> id_free ( id ) ; <S2SV_EndBug> return vnic ; } } return NULL ; }
|
<S2SV_ModStart> ; } } <S2SV_ModEnd> return vnic ;
|
7,609 |
CWE-000 static int slots_gc_compact ( int used , int ptype , size_t size ) { int i , nextgc = used ; for ( i = 0 ; i < used ; i ++ ) if ( GARBAGE ( i , ptype ) ) { nextgc = i ; break ; } int ngc = 0 ; while ( nextgc < used ) { int i ; int lastgc = nextgc ; int src = used ; for ( i = lastgc + 1 ; i < used ; i ++ ) if ( ! GARBAGE ( i , ptype ) ) { src = i ; break ; } if ( src == used ) { <S2SV_StartBug> ngc ++ ; <S2SV_EndBug> break ; } int dest = lastgc - ngc ; nextgc = used ; for ( i = src + 1 ; i < used ; i ++ ) if ( GARBAGE ( i , ptype ) ) { nextgc = i ; break ; } ngc += src - lastgc ; int nmove = nextgc - src + 1 ; memmove ( PART ( dest , ptype ) , PART ( src , ptype ) , nmove * size ) ; } return ngc ; }
|
<S2SV_ModStart> ) { ngc += src - lastgc <S2SV_ModEnd> ; break ;
|
7,610 |
CWE-000 void msm_isp_notify ( struct vfe_device * vfe_dev , uint32_t event_type , enum msm_vfe_input_src frame_src , struct msm_isp_timestamp * ts ) { struct msm_isp_event_data event_data ; struct msm_vfe_sof_info * sof_info = NULL , * self_sof = NULL ; enum msm_vfe_dual_hw_ms_type ms_type ; struct msm_vfe_axi_shared_data * axi_data = & vfe_dev -> axi_data ; int i , j ; unsigned long flags ; memset ( & event_data , 0 , sizeof ( event_data ) ) ; switch ( event_type ) { case ISP_EVENT_SOF : for ( i = 0 ; i < VFE_AXI_SRC_MAX ; i ++ ) { if ( SRC_TO_INTF ( axi_data -> stream_info [ i ] . stream_src ) == frame_src ) { axi_data -> stream_info [ i ] . sw_sof_ping_pong_bit = axi_data -> stream_info [ i ] . sw_ping_pong_bit ; } } if ( frame_src == VFE_PIX_0 ) { if ( vfe_dev -> isp_sof_debug < ISP_SOF_DEBUG_COUNT ) pr_err ( "%s:<S2SV_blank>PIX0<S2SV_blank>frame<S2SV_blank>id:<S2SV_blank>%u\\n" , __func__ , vfe_dev -> axi_data . src_info [ VFE_PIX_0 ] . frame_id ) ; vfe_dev -> isp_sof_debug ++ ; } else if ( frame_src == VFE_RAW_0 ) { if ( vfe_dev -> isp_raw0_debug < ISP_SOF_DEBUG_COUNT ) pr_err ( "%s:<S2SV_blank>RAW_0<S2SV_blank>frame<S2SV_blank>id:<S2SV_blank>%u\\n" , __func__ , vfe_dev -> axi_data . src_info [ VFE_RAW_0 ] . frame_id ) ; vfe_dev -> isp_raw0_debug ++ ; } else if ( frame_src == VFE_RAW_1 ) { if ( vfe_dev -> isp_raw1_debug < ISP_SOF_DEBUG_COUNT ) pr_err ( "%s:<S2SV_blank>RAW_1<S2SV_blank>frame<S2SV_blank>id:<S2SV_blank>%u\\n" , __func__ , vfe_dev -> axi_data . src_info [ VFE_RAW_1 ] . frame_id ) ; vfe_dev -> isp_raw1_debug ++ ; } else if ( frame_src == VFE_RAW_2 ) { if ( vfe_dev -> isp_raw2_debug < ISP_SOF_DEBUG_COUNT ) pr_err ( "%s:<S2SV_blank>RAW_2<S2SV_blank>frame<S2SV_blank>id:<S2SV_blank>%u\\n" , __func__ , vfe_dev -> axi_data . src_info [ VFE_RAW_2 ] . frame_id ) ; vfe_dev -> isp_raw2_debug ++ ; } ISP_DBG ( "%s:<S2SV_blank>vfe<S2SV_blank>%d<S2SV_blank>frame_src<S2SV_blank>%d<S2SV_blank>frame<S2SV_blank>id:<S2SV_blank>%u\\n" , __func__ , vfe_dev -> pdev -> id , frame_src , vfe_dev -> axi_data . src_info [ frame_src ] . frame_id ) ; trace_msm_cam_isp_bufcount ( "msm_isp_notify:" , vfe_dev -> pdev -> id , vfe_dev -> axi_data . src_info [ frame_src ] . frame_id , frame_src ) ; if ( vfe_dev -> axi_data . src_info [ frame_src ] . dual_hw_type == DUAL_HW_MASTER_SLAVE ) { spin_lock_irqsave ( & vfe_dev -> common_data -> common_dev_data_lock , flags ) ; self_sof = vfe_dev -> axi_data . src_info [ frame_src ] . dual_hw_ms_info . sof_info ; if ( ! self_sof ) { spin_unlock_irqrestore ( & vfe_dev -> common_data -> common_dev_data_lock , flags ) ; break ; } ms_type = vfe_dev -> axi_data . src_info [ frame_src ] . dual_hw_ms_info . dual_hw_ms_type ; if ( ms_type == MS_TYPE_MASTER ) { for ( i = 0 , j = 0 ; i < MS_NUM_SLAVE_MAX ; i ++ ) { if ( ! ( vfe_dev -> common_data -> ms_resource . slave_active_mask & ( 1 << i ) ) ) continue ; sof_info = & vfe_dev -> common_data -> ms_resource . slave_sof_info [ i ] ; event_data . u . sof_info . ms_delta_info . delta [ j ] = self_sof -> mono_timestamp_ms - sof_info -> mono_timestamp_ms ; j ++ ; if ( j == vfe_dev -> common_data -> ms_resource . num_slave ) break ; } event_data . u . sof_info . ms_delta_info . num_delta_info = j ; } else { sof_info = & vfe_dev -> common_data -> ms_resource . master_sof_info ; event_data . u . sof_info . ms_delta_info . num_delta_info = 1 ; event_data . u . sof_info . ms_delta_info . delta [ 0 ] = self_sof -> mono_timestamp_ms - sof_info -> mono_timestamp_ms ; } spin_unlock_irqrestore ( & vfe_dev -> common_data -> common_dev_data_lock , flags ) ; } else { if ( frame_src <= VFE_RAW_2 ) { msm_isp_check_for_output_error ( vfe_dev , ts , <S2SV_StartBug> & event_data . u . sof_info ) ; <S2SV_EndBug> } } msm_isp_update_pd_stats_idx ( vfe_dev , frame_src ) ; break ; default : break ; } event_data . frame_id = vfe_dev -> axi_data . src_info [ frame_src ] . frame_id ; event_data . timestamp = ts -> event_time ; event_data . mono_timestamp = ts -> buf_time ; msm_isp_send_event ( vfe_dev , event_type | frame_src , & event_data ) ; }
|
<S2SV_ModStart> u . sof_info , frame_src
|
7,611 |
CWE-000 static int pl330_test ( struct pl330_softc * sc ) { uint8_t * ibuf ; uint8_t dbuf [ 6 ] ; uint8_t * buf1 ; uint8_t * buf2 ; uint32_t offs ; uint32_t reg ; bus_space_handle_t sram ; if ( bus_space_map ( fdtbus_bs_tag , 0xFFE00000 , 1024 , 0 , & sram ) != 0 ) { printf ( "failed\\n" ) ; } bus_space_write_4 ( fdtbus_bs_tag , sram , 0 , 0xab ) ; <S2SV_StartBug> printf ( "CRD<S2SV_blank>%x\\n" , READ4 ( sc , CRD ) ) ; <S2SV_EndBug> # if 0 dbuf = ( void * ) kmem_alloc_contig ( kernel_arena , PAGE_SIZE , M_ZERO , 0 , ~ 0 , PAGE_SIZE , 0 , VM_MEMATTR_UNCACHEABLE ) ; # endif ibuf = ( void * ) kmem_alloc_contig ( kernel_arena , PAGE_SIZE , M_ZERO , 0 , ~ 0 , PAGE_SIZE , 0 , VM_MEMATTR_UNCACHEABLE ) ; printf ( "ibuf<S2SV_blank>is<S2SV_blank>%x\\n" , ( uint32_t ) ibuf ) ; buf1 = ( void * ) kmem_alloc_contig ( kernel_arena , PAGE_SIZE , M_ZERO , 0 , ~ 0 , PAGE_SIZE , 0 , VM_MEMATTR_UNCACHEABLE ) ; buf1 [ 0 ] = 0xaa ; buf2 = ( void * ) kmem_alloc_contig ( kernel_arena , PAGE_SIZE , M_ZERO , 0 , ~ 0 , PAGE_SIZE , 0 , VM_MEMATTR_UNCACHEABLE ) ; printf ( "buf1<S2SV_blank>%x\\n" , vtophys ( buf1 ) ) ; printf ( "buf2<S2SV_blank>%x\\n" , vtophys ( buf2 ) ) ; printf ( "ibuf<S2SV_blank>%x\\n" , vtophys ( ibuf ) ) ; reg = ( 1 << 8 ) | ( 1 << 9 ) | ( 1 << 10 ) ; reg |= ( 1 << 22 ) | ( 1 << 23 ) | ( 1 << 24 ) ; reg = ( 1 << 0 ) | ( 1 << 14 ) ; reg |= ( 2 << 1 ) ; reg |= ( 2 << 15 ) ; offs = 0 ; offs += emit_mov ( & ibuf [ offs ] , R_CCR , reg ) ; <S2SV_StartBug> offs += emit_mov ( & ibuf [ offs ] , R_SAR , vtophys ( buf1 ) ) ; <S2SV_EndBug> offs += emit_mov ( & ibuf [ offs ] , R_DAR , vtophys ( buf2 ) ) ; <S2SV_StartBug> offs += emit_ld ( & ibuf [ offs ] ) ; <S2SV_EndBug> offs += emit_st ( & ibuf [ offs ] ) ; <S2SV_StartBug> offs += emit_end ( & ibuf [ offs ] ) ; <S2SV_EndBug> emit_go ( dbuf , vtophys ( ibuf ) ) ; reg = ( dbuf [ 1 ] << 24 ) | ( dbuf [ 0 ] << 16 ) ; WRITE4 ( sc , DBGINST0 , reg ) ; reg = ( dbuf [ 5 ] << 24 ) | ( dbuf [ 4 ] << 16 ) | ( dbuf [ 3 ] << 8 ) | dbuf [ 2 ] ; WRITE4 ( sc , DBGINST1 , reg ) ; printf ( "DSR<S2SV_blank>%x,<S2SV_blank>DBGSTATUS<S2SV_blank>%x<S2SV_blank>FTRD<S2SV_blank>%x<S2SV_blank>FTR(0)<S2SV_blank>%x\\n" , READ4 ( sc , DSR ) , READ4 ( sc , DBGSTATUS ) , READ4 ( sc , FTRD ) , READ4 ( sc , FTR ( 0 ) ) ) ; WRITE4 ( sc , DBGCMD , 0 ) ; DELAY ( 100000 ) ; DELAY ( 100000 ) ; DELAY ( 100000 ) ; DELAY ( 100000 ) ; DELAY ( 100000 ) ; DELAY ( 100000 ) ; printf ( "DSR<S2SV_blank>%x,<S2SV_blank>DBGSTATUS<S2SV_blank>%x<S2SV_blank>FTRD<S2SV_blank>%x<S2SV_blank>FTR(0)<S2SV_blank>%x\\n" , READ4 ( sc , DSR ) , READ4 ( sc , DBGSTATUS ) , READ4 ( sc , FTRD ) , READ4 ( sc , FTR ( 0 ) ) ) ; printf ( "CSR(0)<S2SV_blank>%x\\n" , READ4 ( sc , CSR ( 0 ) ) ) ; printf ( "RESULT:<S2SV_blank>buf2<S2SV_blank>is<S2SV_blank>%x\\n" , buf2 [ 0 ] ) ; printf ( "%s:<S2SV_blank>SAR(0)<S2SV_blank>%x\\n" , __func__ , READ4 ( sc , SAR ( 0 ) ) ) ; printf ( "%s:<S2SV_blank>DAR(0)<S2SV_blank>%x\\n" , __func__ , READ4 ( sc , DAR ( 0 ) ) ) ; printf ( "%s:<S2SV_blank>CCR(0)<S2SV_blank>%x\\n" , __func__ , READ4 ( sc , CCR ( 0 ) ) ) ; printf ( "res<S2SV_blank>%x\\n" , bus_space_read_4 ( fdtbus_bs_tag , sram , 0x10 ) ) ; return ( 0 ) ; }
|
<S2SV_ModStart> 0xab ) ; WRITE4 ( sc , INTEN , ( 1 << 0 ) ) ; <S2SV_ModStart> , R_SAR , 0xffa00000 <S2SV_ModEnd> ) ; offs <S2SV_ModStart> ; offs += emit_wfp ( & ibuf [ offs ] , 25 ) ; offs += <S2SV_ModStart> ; offs += emit_sev ( & ibuf [ offs ] , 0 ) ; offs +=
|
7,612 |
CWE-000 static void _cont_obj_mouse_move ( void * data , Evas * e EINA_UNUSED , Evas_Object * obj EINA_UNUSED , void * event_info ) { cnp_debug ( "In\\n" ) ; Item_Container_Drag_Info * st = data ; Evas_Event_Mouse_Move * ev = event_info ; if ( ev -> event_flags & EVAS_EVENT_FLAG_ON_HOLD ) { <S2SV_StartBug> cnp_debug ( "event<S2SV_blank>on<S2SV_blank>hold<S2SV_blank>or<S2SV_blank>-<S2SV_blank>have<S2SV_blank>to<S2SV_blank>cancel<S2SV_blank>DnD\\n" ) ; <S2SV_EndBug> _abort_drag ( obj , st ) ; st = NULL ; } if ( st && evas_device_class_get ( ev -> dev ) == EVAS_DEVICE_CLASS_TOUCH ) { int dx = ev -> cur . canvas . x - st -> x_down , dy = ev -> cur . canvas . y - st -> y_down ; int finger_size = elm_config_finger_size_get ( ) ; if ( ( dx * dx + dy * dy > finger_size * finger_size ) ) { cnp_debug ( "mouse<S2SV_blank>moved<S2SV_blank>too<S2SV_blank>much<S2SV_blank>-<S2SV_blank>have<S2SV_blank>to<S2SV_blank>cancel<S2SV_blank>DnD\\n" ) ; _abort_drag ( obj , st ) ; st = NULL ; } } cnp_debug ( "Out\\n" ) ; }
|
<S2SV_ModStart> { cnp_debug ( "event<S2SV_blank>on<S2SV_blank>hold<S2SV_blank>-<S2SV_blank>have<S2SV_blank>to<S2SV_blank>cancel<S2SV_blank>DnD\\n" <S2SV_ModEnd> ) ; _abort_drag
|
7,613 |
CWE-000 static int cpp_close_node ( struct v4l2_subdev * sd , struct v4l2_subdev_fh * fh ) { uint32_t i ; struct cpp_device * cpp_dev = v4l2_get_subdevdata ( sd ) ; struct msm_device_queue * processing_q = NULL ; struct msm_device_queue * eventData_q = NULL ; if ( ! cpp_dev ) { <S2SV_StartBug> pr_err ( "failed:<S2SV_blank>cpp_dev<S2SV_blank>%p\\n" , cpp_dev ) ; <S2SV_EndBug> return - EINVAL ; } mutex_lock ( & cpp_dev -> mutex ) ; processing_q = & cpp_dev -> processing_q ; eventData_q = & cpp_dev -> eventData_q ; if ( cpp_dev -> cpp_open_cnt == 0 ) { mutex_unlock ( & cpp_dev -> mutex ) ; return 0 ; } for ( i = 0 ; i < MAX_ACTIVE_CPP_INSTANCE ; i ++ ) { if ( cpp_dev -> cpp_subscribe_list [ i ] . active == 1 ) { cpp_dev -> cpp_subscribe_list [ i ] . active = 0 ; cpp_dev -> cpp_subscribe_list [ i ] . vfh = NULL ; break ; } } if ( i == MAX_ACTIVE_CPP_INSTANCE ) { pr_err ( "Invalid<S2SV_blank>close\\n" ) ; mutex_unlock ( & cpp_dev -> mutex ) ; return - ENODEV ; } cpp_dev -> cpp_open_cnt -- ; if ( cpp_dev -> cpp_open_cnt == 0 ) { pr_debug ( "irq_status:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x4 ) ) ; pr_debug ( "DEBUG_SP:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x40 ) ) ; pr_debug ( "DEBUG_T:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x44 ) ) ; pr_debug ( "DEBUG_N:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x48 ) ) ; pr_debug ( "DEBUG_R:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x4C ) ) ; pr_debug ( "DEBUG_OPPC:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x50 ) ) ; pr_debug ( "DEBUG_MO:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x54 ) ) ; pr_debug ( "DEBUG_TIMER0:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x60 ) ) ; pr_debug ( "DEBUG_TIMER1:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x64 ) ) ; pr_debug ( "DEBUG_GPI:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x70 ) ) ; pr_debug ( "DEBUG_GPO:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x74 ) ) ; pr_debug ( "DEBUG_T0:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x80 ) ) ; pr_debug ( "DEBUG_R0:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x84 ) ) ; pr_debug ( "DEBUG_T1:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x88 ) ) ; pr_debug ( "DEBUG_R1:<S2SV_blank>0x%x\\n" , msm_camera_io_r ( cpp_dev -> cpp_hw_base + 0x8C ) ) ; msm_camera_io_w ( 0x0 , cpp_dev -> base + MSM_CPP_MICRO_CLKEN_CTL ) ; cpp_deinit_mem ( cpp_dev ) ; iommu_detach_device ( cpp_dev -> domain , cpp_dev -> iommu_ctx ) ; cpp_release_hardware ( cpp_dev ) ; msm_cpp_empty_list ( processing_q , list_frame ) ; msm_cpp_empty_list ( eventData_q , list_eventdata ) ; cpp_dev -> state = CPP_STATE_OFF ; } mutex_unlock ( & cpp_dev -> mutex ) ; return 0 ; }
|
<S2SV_ModStart> { pr_err ( "failed:<S2SV_blank>cpp_dev<S2SV_blank>%pK\\n" <S2SV_ModEnd> , cpp_dev )
|
7,614 |
CWE-000 struct TRI_Bones_Per_Vertex * allocTransformTRIBonesToVertexBoneFormat ( struct TRI_Model * in ) { struct TRI_Bones_Per_Vertex * out = ( struct TRI_Bones_Per_Vertex * ) malloc ( sizeof ( struct TRI_Bones_Per_Vertex ) ) ; if ( out == 0 ) { return 0 ; } out -> numberOfBones = in -> header . numberOfBones ; out -> numberOfVertices = in -> header . numberOfVertices ; out -> bonesPerVertex = ( struct TRI_Bones_Per_Vertex_Vertice_Item * ) malloc ( sizeof ( struct TRI_Bones_Per_Vertex_Vertice_Item ) * in -> header . numberOfVertices ) ; <S2SV_StartBug> if ( out -> bonesPerVertex == 0 ) { return 0 ; } <S2SV_EndBug> memset ( out -> bonesPerVertex , 0 , sizeof ( struct TRI_Bones_Per_Vertex_Vertice_Item ) * in -> header . numberOfVertices ) ; unsigned int b = 0 , w = 0 , outOfSpace = 0 ; for ( b = 0 ; b < in -> header . numberOfBones ; b ++ ) { for ( w = 0 ; w < in -> bones [ b ] . info -> boneWeightsNumber ; w ++ ) { unsigned int boneIndex = in -> bones [ b ] . weightIndex [ w ] ; struct TRI_Bones_Per_Vertex_Vertice_Item * bone = & out -> bonesPerVertex [ boneIndex ] ; if ( bone -> bonesOfthisVertex < MAX_BONES_PER_VERTICE ) { bone -> indicesOfThisVertex [ bone -> bonesOfthisVertex ] = in -> bones [ b ] . weightIndex [ w ] ; bone -> weightsOfThisVertex [ bone -> bonesOfthisVertex ] = in -> bones [ b ] . weightValue [ w ] ; bone -> boneIDOfThisVertex [ bone -> bonesOfthisVertex ] = b ; ++ bone -> bonesOfthisVertex ; } else { ++ outOfSpace ; } } } if ( outOfSpace > 0 ) { fprintf ( stderr , "Vertices<S2SV_blank>are<S2SV_blank>set<S2SV_blank>up<S2SV_blank>to<S2SV_blank>accomodate<S2SV_blank>at<S2SV_blank>most<S2SV_blank>%u<S2SV_blank>bones<S2SV_blank>,<S2SV_blank>%u<S2SV_blank>vertices<S2SV_blank>where<S2SV_blank>too<S2SV_blank>small<S2SV_blank>for<S2SV_blank>our<S2SV_blank>input<S2SV_blank>..<S2SV_blank>\\n" , MAX_BONES_PER_VERTICE , outOfSpace ) ; } return out ; }
|
<S2SV_ModStart> 0 ) { free ( out ) ;
|
7,615 |
CWE-000 static bool write_block_buffer ( block_t * ptObj , const void * pchSrc , uint_fast16_t hwSize , uint_fast16_t hwOffsite ) { class_internal ( ptObj , ptThis , block_t ) ; bool bResult = false ; do { if ( NULL == ptThis || NULL == pchSrc || 0 == hwSize ) { break ; } uint_fast16_t hwMaxSize = this . wBlockSize - hwOffsite ; if ( hwSize > hwMaxSize ) { hwSize = hwMaxSize ; } <S2SV_StartBug> memcpy ( get_block_buffer ( ptObj ) , pchSrc , hwSize ) ; <S2SV_EndBug> this . wSize = hwSize + hwOffsite ; bResult = true ; } while ( false ) ; return bResult ; }
|
<S2SV_ModStart> ( ptObj ) + hwOffsite
|
7,616 |
CWE-000 size_t DPA_stream_getLength ( const DPA_stream_t * stream , size_t max_ret , bool * has_more ) { DPA_buffer_ringbuffer_t tmp = * stream -> buffer_buffer ; size_t n = 0 ; while ( ! DPA_ringbuffer_eof ( & tmp . super ) ) { <S2SV_StartBug> size_t s = DPA_RINGBUFFER_GET ( & tmp ) . range . size ; <S2SV_EndBug> if ( s + n < n || s + n > max_ret ) { if ( has_more ) * has_more = true ; return max_ret ; } n += s ; } if ( has_more ) * has_more = false ; return n ; }
|
<S2SV_ModStart> ) ) { const DPA_buffer_range_t range <S2SV_ModEnd> = DPA_RINGBUFFER_GET ( <S2SV_ModStart> ) . range ; size_t s = range . size > range . offset ? range . size - range . offset : 0 <S2SV_ModEnd> ; if (
|
7,617 |
CWE-000 static void __purge_vmap_area_lazy ( unsigned long * start , unsigned long * end , int sync , int force_flush ) { static DEFINE_SPINLOCK ( purge_lock ) ; LIST_HEAD ( valist ) ; struct vmap_area * va ; struct vmap_area * n_va ; <S2SV_StartBug> int nr = 0 ; <S2SV_EndBug> if ( ! sync && ! force_flush ) { if ( ! spin_trylock ( & purge_lock ) ) return ; } else spin_lock ( & purge_lock ) ; if ( sync ) purge_fragmented_blocks_allcpus ( ) ; rcu_read_lock ( ) ; list_for_each_entry_rcu ( va , & vmap_area_list , list ) { if ( va -> flags & VM_LAZY_FREE ) { if ( va -> va_start < * start ) * start = va -> va_start ; if ( va -> va_end > * end ) * end = va -> va_end ; <S2SV_StartBug> nr += ( va -> va_end - va -> va_start ) >> PAGE_SHIFT ; <S2SV_EndBug> list_add_tail ( & va -> purge_list , & valist ) ; va -> flags |= VM_LAZY_FREEING ; va -> flags &= ~ VM_LAZY_FREE ; } } rcu_read_unlock ( ) ; <S2SV_StartBug> if ( nr ) <S2SV_EndBug> atomic_sub ( nr , & vmap_lazy_nr ) ; if ( nr || force_flush ) flush_tlb_kernel_range ( * start , * end ) ; <S2SV_StartBug> if ( nr ) { <S2SV_EndBug> spin_lock ( & vmap_area_lock ) ; <S2SV_StartBug> list_for_each_entry_safe ( va , n_va , & valist , purge_list ) <S2SV_EndBug> __free_vmap_area ( va ) ; spin_unlock ( & vmap_area_lock ) ; } spin_unlock ( & purge_lock ) ; }
|
<S2SV_ModStart> * n_va ; bool do_free = false <S2SV_ModEnd> ; if ( <S2SV_ModStart> -> va_end ; do_free = true <S2SV_ModEnd> ; list_add_tail ( <S2SV_ModStart> ; if ( do_free <S2SV_ModEnd> || force_flush ) <S2SV_ModStart> ; if ( do_free ) { spin_lock ( & vmap_area_lock ) ; list_for_each_entry_safe ( va , n_va , & valist , purge_list ) { int nr = ( va -> va_end - va -> va_start ) >> PAGE_SHIFT ; __free_vmap_area ( va ) ; atomic_sub ( nr , & vmap_lazy_nr ) ; cond_resched_lock <S2SV_ModEnd> ( & vmap_area_lock <S2SV_ModStart> vmap_area_lock ) ; } <S2SV_ModEnd> spin_unlock ( &
|
7,618 |
CWE-000 static int exec_burst ( uint32_t flags , int lcore ) { unsigned i , portid , nb_tx = 0 ; struct lcore_conf * conf ; uint32_t pkt_per_port ; int num , idx = 0 ; int diff_tsc ; conf = & lcore_conf [ lcore ] ; pkt_per_port = MAX_TRAFFIC_BURST ; <S2SV_StartBug> num = pkt_per_port ; <S2SV_EndBug> rte_atomic64_init ( & start ) ; rte_eal_remote_launch ( poll_burst , ( void * ) & pkt_per_port , lcore ) ; if ( flags == SC_BURST_POLL_FIRST ) rte_atomic64_set ( & start , 1 ) ; while ( num ) { nb_tx = RTE_MIN ( MAX_PKT_BURST , num ) ; for ( i = 0 ; i < conf -> nb_ports ; i ++ ) { portid = conf -> portlist [ i ] ; <S2SV_StartBug> rte_eth_tx_burst ( portid , 0 , <S2SV_EndBug> & tx_burst [ idx ] , nb_tx ) ; idx += nb_tx ; <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> num -= nb_tx ; <S2SV_EndBug> } sleep ( 5 ) ; if ( flags == SC_BURST_XMIT_FIRST ) rte_atomic64_set ( & start , 1 ) ; diff_tsc = rte_eal_wait_lcore ( lcore ) ; if ( diff_tsc < 0 ) { printf ( "exec_burst:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>measure<S2SV_blank>cycles<S2SV_blank>per<S2SV_blank>packet\\n" ) ; return - 1 ; } printf ( "Result:<S2SV_blank>%d<S2SV_blank>cycles<S2SV_blank>per<S2SV_blank>packet\\n" , diff_tsc ) ; return 0 ; }
|
<S2SV_ModStart> num = pkt_per_port * conf -> nb_ports <S2SV_ModStart> i ] ; nb_tx = <S2SV_ModStart> += nb_tx ; <S2SV_ModEnd> num -= nb_tx <S2SV_ModStart> -= nb_tx ; }
|
7,619 |
CWE-000 static void __handle_cifsd_work ( struct cifsd_work * work , struct cifsd_tcp_conn * conn ) { unsigned int command = 0 ; int rc ; bool conn_valid = false ; struct smb_version_cmds * cmds ; if ( conn -> ops -> allocate_rsp_buf ( work ) ) return ; if ( conn -> ops -> is_transform_hdr && conn -> ops -> is_transform_hdr ( REQUEST_BUF ( work ) ) ) { rc = conn -> ops -> decrypt_req ( work ) ; if ( rc < 0 ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_DATA_ERROR ) ; goto send ; } work -> encrypted = true ; } rc = conn -> ops -> init_rsp_hdr ( work ) ; if ( rc ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_INVALID_HANDLE ) ; goto send ; } if ( conn -> ops -> check_user_session ) { rc = conn -> ops -> check_user_session ( work ) ; if ( rc < 0 ) { command = conn -> ops -> get_cmd_val ( work ) ; conn -> ops -> set_rsp_status ( work , NT_STATUS_USER_SESSION_DELETED ) ; goto send ; } else if ( rc > 0 ) { rc = conn -> ops -> get_cifsd_tcon ( work ) ; if ( rc < 0 ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_NETWORK_NAME_DELETED ) ; goto send ; } } } chained : rc = check_conn_state ( work ) ; if ( rc ) goto send ; if ( cifsd_verify_smb_message ( work ) ) { cifsd_err ( "Malformed<S2SV_blank>smb<S2SV_blank>request\\n" ) ; return ; } conn_valid = true ; command = conn -> ops -> get_cmd_val ( work ) ; again : if ( command >= conn -> max_cmds ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_INVALID_PARAMETER ) ; goto send ; } cmds = & conn -> cmds [ command ] ; if ( cmds -> proc == NULL ) { cifsd_err ( "***<S2SV_blank>not<S2SV_blank>implemented<S2SV_blank>yet<S2SV_blank>cmd<S2SV_blank>=<S2SV_blank>%x\\n" , command ) ; conn -> ops -> set_rsp_status ( work , NT_STATUS_NOT_IMPLEMENTED ) ; goto send ; } <S2SV_StartBug> mutex_unlock ( & conn -> srv_mutex ) ; <S2SV_EndBug> if ( work -> sess && conn -> ops -> is_sign_req && conn -> ops -> is_sign_req ( work , command ) ) { rc = conn -> ops -> check_sign_req ( work ) ; if ( ! rc ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_DATA_ERROR ) ; goto send ; } } <S2SV_StartBug> rc = cmds -> proc ( work ) ; <S2SV_EndBug> mutex_lock ( & conn -> srv_mutex ) ; if ( conn -> need_neg && ( conn -> dialect == CIFSD_SMB20_PROT_ID || conn -> dialect == CIFSD_SMB21_PROT_ID || conn -> dialect == CIFSD_SMB2X_PROT_ID || conn -> dialect == CIFSD_SMB30_PROT_ID || conn -> dialect == CIFSD_SMB302_PROT_ID || conn -> dialect == CIFSD_SMB311_PROT_ID ) ) { cifsd_debug ( "Need<S2SV_blank>to<S2SV_blank>send<S2SV_blank>the<S2SV_blank>smb2<S2SV_blank>negotiate<S2SV_blank>response\\n" ) ; init_smb2_neg_rsp ( work ) ; goto send ; } if ( rc > 0 ) { command = rc ; goto again ; } else if ( rc < 0 ) cifsd_debug ( "error(%d)<S2SV_blank>while<S2SV_blank>processing<S2SV_blank>cmd<S2SV_blank>%u\\n" , rc , command ) ; if ( work -> send_no_response ) return ; send : if ( is_chained_smb2_message ( work ) ) goto chained ; if ( is_smb2_rsp ( work ) ) conn -> ops -> set_rsp_credits ( work ) ; if ( conn -> dialect == CIFSD_SMB311_PROT_ID ) smb3_preauth_hash_rsp ( work ) ; if ( work -> sess && work -> sess -> enc && work -> encrypted && conn -> ops -> encrypt_resp ) { rc = conn -> ops -> encrypt_resp ( work ) ; if ( rc < 0 ) { conn -> ops -> set_rsp_status ( work , NT_STATUS_DATA_ERROR ) ; goto send ; } } else if ( work -> sess && ( work -> sess -> sign || ( conn -> ops -> is_sign_req && conn -> ops -> is_sign_req ( work , command ) ) ) ) conn -> ops -> set_sign_rsp ( work ) ; cifsd_tcp_write ( work ) ; }
|
<S2SV_ModStart> send ; } <S2SV_ModEnd> if ( work <S2SV_ModStart> proc ( work <S2SV_ModEnd> ) ; if
|
7,620 |
CWE-000 void sql_parser_create ( struct Parse * parser , sqlite3 * db ) { memset ( parser , 0 , sizeof ( struct Parse ) ) ; parser -> db = db ; rlist_create ( & parser -> new_fkey ) ; <S2SV_StartBug> region_create ( & parser -> region , & cord ( ) -> slabc ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> new_fkey ) ; rlist_create ( & parser -> record_list ) ;
|
7,621 |
CWE-000 void CE_disable_any_copy_compl_intr ( struct hif_pci_softc * sc ) { <S2SV_StartBug> adf_os_spin_lock ( & sc -> target_lock ) ; <S2SV_EndBug> CE_disable_any_copy_compl_intr_nolock ( sc ) ; <S2SV_StartBug> adf_os_spin_unlock ( & sc -> target_lock ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> sc ) { adf_os_spin_lock_bh <S2SV_ModEnd> ( & sc <S2SV_ModStart> sc ) ; adf_os_spin_unlock_bh <S2SV_ModEnd> ( & sc
|
7,622 |
CWE-000 static NMDevice * get_device_for_connection ( NMClient * client , NMConnection * conn ) { const GPtrArray * devices ; NMSettingConnection * s_con ; int i ; devices = nm_client_get_devices ( client ) ; if ( ! devices ) return NULL ; s_con = nm_connection_get_setting_connection ( conn ) ; if ( ! nm_setting_connection_get_interface_name ( s_con ) && ! nm_connection_get_interface_name ( conn ) ) { NMSetting * s_hw ; <S2SV_StartBug> GByteArray * mac_address ; <S2SV_EndBug> s_hw = nm_connection_get_setting_by_name ( conn , nm_setting_connection_get_connection_type ( s_con ) ) ; if ( ! s_hw || ! g_object_class_find_property ( G_OBJECT_GET_CLASS ( s_hw ) , "mac-address" ) ) return NULL ; g_object_get ( G_OBJECT ( s_hw ) , "mac-address" , & mac_address , NULL ) ; <S2SV_StartBug> if ( ! mac_address ) <S2SV_EndBug> return NULL ; g_byte_array_unref ( mac_address ) ; } for ( i = 0 ; i < devices -> len ; i ++ ) { NMDevice * device = devices -> pdata [ i ] ; if ( nm_device_connection_compatible ( device , conn , NULL ) ) return device ; } return NULL ; }
|
<S2SV_ModStart> * s_hw ; gchar <S2SV_ModEnd> * mac_address ; <S2SV_ModStart> ( ! mac_address || ! mac_address [ 0 ] ) { g_free ( mac_address ) ; return NULL ; } g_free <S2SV_ModEnd> ( mac_address )
|
7,623 |
CWE-000 void handle_pending_usb_setup ( ) { __xdata struct usb_req_setup * req = ( __xdata struct usb_req_setup * ) SETUPDAT ; <S2SV_StartBug> if ( req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT && <S2SV_EndBug> req -> bRequest == USB_REQ_CYPRESS_RENUMERATE ) { pending_setup = false ; USBCS |= _DISCON ; delay_ms ( 10 ) ; USBCS &= ~ _DISCON ; return ; } <S2SV_StartBug> if ( req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT && <S2SV_EndBug> req -> bRequest == USB_REQ_LIBFX2_PAGE_SIZE ) { page_size = req -> wValue ; pending_setup = false ; ACK_EP0 ( ) ; return ; } <S2SV_StartBug> if ( ( req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_IN || <S2SV_EndBug> <S2SV_StartBug> req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT ) && <S2SV_EndBug> ( req -> bRequest == USB_REQ_CYPRESS_EEPROM_SB || req -> bRequest == USB_REQ_CYPRESS_EEPROM_DB ) ) { bool arg_read = ( req -> bmRequestType & USB_DIR_IN ) ; bool arg_dbyte = ( req -> bRequest == USB_REQ_CYPRESS_EEPROM_DB ) ; uint8_t arg_chip = arg_dbyte ? 0x51 : 0x50 ; uint16_t arg_addr = req -> wValue ; uint16_t arg_len = req -> wLength ; pending_setup = false ; while ( arg_len > 0 ) { uint8_t len = arg_len < 64 ? arg_len : 64 ; if ( arg_read ) { while ( EP0CS & _BUSY ) ; if ( ! eeprom_read ( arg_chip , arg_addr , EP0BUF , len , arg_dbyte ) ) { STALL_EP0 ( ) ; break ; } SETUP_EP0_BUF ( len ) ; } else { SETUP_EP0_BUF ( 0 ) ; while ( EP0CS & _BUSY ) ; if ( ! eeprom_write ( arg_chip , arg_addr , EP0BUF , len , arg_dbyte , page_size , 166 ) ) { STALL_EP0 ( ) ; break ; } } arg_len -= len ; arg_addr += len ; } return ; } <S2SV_StartBug> if ( ( req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_IN || <S2SV_EndBug> <S2SV_StartBug> req -> bmRequestType == USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT ) && <S2SV_EndBug> req -> bRequest == USB_REQ_CYPRESS_EXT_RAM ) { bool arg_read = ( req -> bmRequestType & USB_DIR_IN ) ; uint16_t arg_addr = req -> wValue ; uint16_t arg_len = req -> wLength ; pending_setup = false ; while ( arg_len > 0 ) { uint8_t len = arg_len < 64 ? arg_len : 64 ; if ( arg_read ) { while ( EP0CS & _BUSY ) ; xmemcpy ( EP0BUF , ( __xdata void * ) arg_addr , len ) ; SETUP_EP0_BUF ( len ) ; } else { SETUP_EP0_BUF ( 0 ) ; while ( EP0CS & _BUSY ) ; xmemcpy ( ( __xdata void * ) arg_addr , EP0BUF , arg_len ) ; } arg_len -= len ; arg_addr += len ; } return ; } STALL_EP0 ( ) ; }
|
<S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_OUT ) <S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_OUT ) <S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_IN ) <S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_OUT ) <S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_IN ) <S2SV_ModStart> -> bmRequestType == ( <S2SV_ModStart> USB_TYPE_VENDOR | USB_DIR_OUT )
|
7,624 |
CWE-000 int main ( ) { int fd ; <S2SV_StartBug> char buffer [ Taille ] ; <S2SV_EndBug> fd = open ( "/dev/ttyS0" , O_RDONLY ) ; if ( fd == - 1 ) { perror ( "Ouverture<S2SV_blank>impossible" ) ; return ( EXIT_FAILURE ) ; } <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> while ( i < 200 ) { <S2SV_StartBug> result = read ( fd , buffer , sizeof ( buffer ) - 1 ) ; <S2SV_EndBug> if ( result == - 1 ) { perror ( "ERROR<S2SV_blank>(read<S2SV_blank>process)<S2SV_blank>" ) ; exit ( EXIT_FAILURE ) ; } if ( ! result ) { printf ( "no<S2SV_blank>data\\n" ) ; <S2SV_StartBug> i ++ ; <S2SV_EndBug> } if ( result > 0 ) { buffer [ result ] = 0 ; printf ( "string<S2SV_blank>:<S2SV_blank>%s<S2SV_blank>number<S2SV_blank>:<S2SV_blank>%d\\n" , buffer , result ) ; } } <S2SV_StartBug> close ( fd1 ) ; <S2SV_EndBug> close ( fd2 ) ; return ( EXIT_SUCCESS ) ; }
|
<S2SV_ModStart> [ Taille ] ; ssize_t result ; printf ( "test" ) <S2SV_ModStart> ) ; } while ( 1 <S2SV_ModEnd> ) { result <S2SV_ModStart> ( buffer ) <S2SV_ModEnd> ) ; if <S2SV_ModStart> "no<S2SV_blank>data\\n" ) ; <S2SV_ModEnd> } if ( <S2SV_ModStart> } close ( fd <S2SV_ModEnd> ) ; return
|
7,625 |
CWE-000 static void pnfs_list_write_lseg ( struct inode * inode , struct list_head * listp ) { struct pnfs_layout_segment * lseg ; list_for_each_entry ( lseg , & NFS_I ( inode ) -> layout -> plh_segs , pls_list ) { if ( lseg -> pls_range . iomode == IOMODE_RW && <S2SV_StartBug> test_bit ( NFS_LSEG_LAYOUTCOMMIT , & lseg -> pls_flags ) ) <S2SV_EndBug> list_add ( & lseg -> pls_lc_list , listp ) ; } }
|
<S2SV_ModStart> == IOMODE_RW && test_and_clear_bit <S2SV_ModEnd> ( NFS_LSEG_LAYOUTCOMMIT ,
|
7,626 |
CWE-000 <S2SV_StartBug> DEFUN ( cfg_bts_depends_on , cfg_bts_depends_on_cmd , <S2SV_EndBug> "depends-on-bts<S2SV_blank><0-255>" , "This<S2SV_blank>BTS<S2SV_blank>can<S2SV_blank>only<S2SV_blank>be<S2SV_blank>started<S2SV_blank>if<S2SV_blank>another<S2SV_blank>one<S2SV_blank>is<S2SV_blank>up\\n" "BTS<S2SV_blank>Number\\n" ) { struct gsm_bts * bts = vty -> index ; struct gsm_bts * other_bts ; int dep = atoi ( argv [ 0 ] ) ; if ( ! is_ipaccess_bts ( bts ) ) { <S2SV_StartBug> vty_out ( vty , "This<S2SV_blank>feature<S2SV_blank>is<S2SV_blank>only<S2SV_blank>available<S2SV_blank>for<S2SV_blank>IP<S2SV_blank>systems.%s" , <S2SV_EndBug> VTY_NEWLINE ) ; return CMD_WARNING ; } other_bts = gsm_bts_num ( bts -> network , dep ) ; if ( ! other_bts || ! is_ipaccess_bts ( other_bts ) ) { vty_out ( vty , "This<S2SV_blank>feature<S2SV_blank>is<S2SV_blank>only<S2SV_blank>available<S2SV_blank>for<S2SV_blank>IP<S2SV_blank>systems.%s" , VTY_NEWLINE ) ; return CMD_WARNING ; } if ( dep >= bts -> nr ) { vty_out ( vty , "%%Need<S2SV_blank>to<S2SV_blank>depend<S2SV_blank>on<S2SV_blank>an<S2SV_blank>already<S2SV_blank>declared<S2SV_blank>unit.%s" , VTY_NEWLINE ) ; return CMD_WARNING ; } bts_depend_mark ( bts , dep ) ; return CMD_SUCCESS ; }
|
<S2SV_ModStart> <S2SV_null> DEFUN ( cfg_bts_codec3 , cfg_bts_codec3_cmd , "codec-support<S2SV_blank>fr" CODEC_PAR_STR CODEC_PAR_STR CODEC_PAR_STR , "Codec<S2SV_blank>Support<S2SV_blank>settings\\nFullrate\\n" CODEC_HELP_STR CODEC_HELP_STR CODEC_HELP_STR ) { _get_codec_from_arg <S2SV_ModEnd> ( vty , <S2SV_ModStart> ( vty , 3 , argv <S2SV_ModEnd> ) ; return
|
7,627 |
CWE-000 static inline void symtbl_clearTemp ( symtbl sym , varloc_st vlc ) { <S2SV_StartBug> if ( vlc . frame == 0 && sym -> fr -> vars -> vals [ vlc . index ] == FVR_TEMP_INUSE ) <S2SV_EndBug> sym -> fr -> vars -> vals [ vlc . index ] = FVR_TEMP_AVAIL ; }
|
<S2SV_ModStart> { if ( <S2SV_ModEnd> sym -> fr
|
7,628 |
CWE-000 bool sequenceinsert ( struct sequence * s , size_t pos , const uint8_t * data , size_t len ) { ssize_t p , pprev , pnext , n , l , r ; size_t i ; p = piecefind ( s , SEQ_start , pos , & i ) ; if ( p == - 1 ) { return false ; } if ( sequenceappend ( s , p , pos , data , len ) ) { return true ; } pprev = s -> pieces [ p ] . prev ; pnext = s -> pieces [ p ] . next ; n = pieceadd ( s , pos , s -> dlen , len ) ; if ( p == - 1 ) { return false ; } if ( ! appenddata ( s , data , len ) ) { <S2SV_StartBug> s -> plen -- ; <S2SV_EndBug> return false ; } if ( i == s -> pieces [ p ] . len ) { s -> pieces [ p ] . next = n ; s -> pieces [ n ] . prev = p ; s -> pieces [ n ] . next = pnext ; s -> pieces [ pnext ] . prev = n ; } else { l = pieceadd ( s , s -> pieces [ p ] . pos , s -> pieces [ p ] . off , i ) ; if ( l == - 1 ) { return false ; } r = pieceadd ( s , pos + len , s -> pieces [ p ] . off + i , s -> pieces [ p ] . len - i ) ; if ( r == - 1 ) { return false ; } s -> pieces [ pprev ] . next = l ; s -> pieces [ l ] . prev = pprev ; s -> pieces [ l ] . next = n ; s -> pieces [ n ] . prev = l ; s -> pieces [ n ] . next = r ; s -> pieces [ r ] . prev = n ; s -> pieces [ r ] . next = pnext ; <S2SV_StartBug> } <S2SV_EndBug> shiftpieces ( s , n , pos ) ; return true ; }
|
<S2SV_ModStart> ) ) { <S2SV_ModEnd> return false ; <S2SV_ModStart> = pnext ; s -> pieces [ pnext ] . prev = r ;
|
7,629 |
CWE-000 int ft_printf ( const char * str , ... ) { va_list ap ; t_format * format ; int length ; format = NULL ; length = 0 ; va_start ( ap , str ) ; while ( * str ) { if ( * str == '%' ) { str ++ ; format = create_format ( ) ; save_flag ( format , ( char * ) str ) ; while ( is_flag ( * str ) ) str ++ ; str = str + is_length ( ( char * ) str , format ) ; if ( is_conv ( * str ) == 1 ) { format -> conv = * str ; if ( * str == 'i' || * str == 'd' ) ft_putstr ( dispatcher ( format , va_arg ( ap , long long ) ) ) ; if ( * str == 'u' || * str == 'o' || * str == 'x' || * str == 'X' ) ft_putstr ( u_dispatcher ( format , va_arg ( ap , unsigned long ) ) ) ; length += format -> strlength ; str ++ ; } else if ( * str != '%' ) return ( 0 ) ; free ( format ) ; } <S2SV_StartBug> ft_putchar ( * str ) ; <S2SV_EndBug> length ++ ; str ++ ; } <S2SV_StartBug> va_end ( ap ) ; <S2SV_EndBug> return ( length ) ; }
|
<S2SV_ModStart> ) ; } if ( * str ) { <S2SV_ModStart> ++ ; } }
|
7,630 |
CWE-000 void * handleResults ( void * rejected_fd ) { request_t request ; while ( 1 ) { char all_handled = 1 ; for ( uint32 i = 0 ; i < num_requests ; i ++ ) { if ( ! isHandled ( info . requests [ i ] ) ) all_handled = 0 ; } if ( all_handled ) return 0 ; if ( read ( * ( ( int * ) rejected_fd ) , & request , sizeof ( request_t ) ) == sizeof ( request_t ) ) { if ( request . status & REJECTED ) { info . n_rejects [ ( request . gender == 'M' ? 1 : 2 ) ] ++ ; info . n_rejects [ 0 ] ++ ; char * tmp = buildLogString ( requestToStruct ( & request , "REJECTED" ) ) ; if ( write ( log_fd , tmp , sizeof ( char ) * strlen ( tmp ) ) < 0 ) { perror ( "GEN<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>writing<S2SV_blank>rejected<S2SV_blank>to<S2SV_blank>log<S2SV_blank>file!<S2SV_blank>" ) ; exit ( 5 ) ; } } pthread_mutex_lock ( & mutex ) ; memmove ( info . requests [ request . serial_number ] , & request , sizeof ( request_t ) ) ; pthread_mutex_unlock ( & mutex ) ; } <S2SV_StartBug> else { <S2SV_EndBug> perror ( "GEN<S2SV_blank>-<S2SV_blank>Error<S2SV_blank>reading<S2SV_blank>from<S2SV_blank>FIFO!<S2SV_blank>" ) ; exit ( 3 ) ; } } }
|
<S2SV_ModStart> ; } else if ( errno != EAGAIN && errno != EWOULDBLOCK )
|
7,631 |
CWE-000 void buf_cur_mvf ( struct buffer * b , unsigned int n ) { <S2SV_StartBug> if ( b -> cur < b -> size - 2 ) { <S2SV_EndBug> b -> cur ++ ; } }
|
<S2SV_ModStart> -> size - b -> gaplen <S2SV_ModEnd> ) { b
|
7,632 |
CWE-000 int lfs_deorphan ( lfs_t * lfs ) { lfs -> deorphaned = true ; if ( lfs_pairisnull ( lfs -> root ) ) { return 0 ; } lfs_dir_t pdir = { . d . size = 0x80000000 } ; lfs_dir_t cwd = { . d . tail [ 0 ] = 0 , . d . tail [ 1 ] = 1 } ; while ( ! lfs_pairisnull ( cwd . d . tail ) ) { int err = lfs_dir_fetch ( lfs , & cwd , cwd . d . tail ) ; if ( err ) { return err ; } if ( ! ( 0x80000000 & pdir . d . size ) ) { lfs_dir_t parent ; lfs_entry_t entry ; int res = lfs_parent ( lfs , pdir . d . tail , & parent , & entry ) ; if ( res < 0 ) { return res ; } if ( ! res ) { LFS_DEBUG ( "Found<S2SV_blank>orphan<S2SV_blank>%ld<S2SV_blank>%ld" , pdir . d . tail [ 0 ] , pdir . d . tail [ 1 ] ) ; pdir . d . tail [ 0 ] = cwd . d . tail [ 0 ] ; pdir . d . tail [ 1 ] = cwd . d . tail [ 1 ] ; err = lfs_dir_commit ( lfs , & pdir , NULL , 0 ) ; if ( err ) { return err ; } break ; } if ( ! lfs_pairsync ( entry . d . u . dir , pdir . d . tail ) ) { LFS_DEBUG ( "Found<S2SV_blank>desync<S2SV_blank>%ld<S2SV_blank>%ld" , entry . d . u . dir [ 0 ] , entry . d . u . dir [ 1 ] ) ; pdir . d . tail [ 0 ] = entry . d . u . dir [ 0 ] ; pdir . d . tail [ 1 ] = entry . d . u . dir [ 1 ] ; err = lfs_dir_commit ( lfs , & pdir , NULL , 0 ) ; if ( err ) { return err ; } break ; } } lfs_entry_t entry ; while ( true ) { int err = lfs_dir_next ( lfs , & cwd , & entry ) ; if ( err && err != LFS_ERR_NOENT ) { return err ; } if ( err == LFS_ERR_NOENT ) { break ; } if ( entry . d . type & 0x80 ) { int moved = lfs_moved ( lfs , & entry . d . u ) ; if ( moved < 0 ) { return moved ; } if ( moved ) { <S2SV_StartBug> LFS_DEBUG ( "Found<S2SV_blank>move<S2SV_blank>%d<S2SV_blank>%d" , <S2SV_EndBug> entry . d . u . dir [ 0 ] , entry . d . u . dir [ 1 ] ) ; int err = lfs_dir_remove ( lfs , & cwd , & entry ) ; if ( err ) { return err ; } } else { <S2SV_StartBug> LFS_DEBUG ( "Found<S2SV_blank>partial<S2SV_blank>move<S2SV_blank>%d<S2SV_blank>%d" , <S2SV_EndBug> entry . d . u . dir [ 0 ] , entry . d . u . dir [ 1 ] ) ; entry . d . type &= ~ 0x80 ; int err = lfs_dir_update ( lfs , & cwd , & entry , NULL ) ; if ( err ) { return err ; } } } } memcpy ( & pdir , & cwd , sizeof ( pdir ) ) ; } return 0 ; }
|
<S2SV_ModStart> { LFS_DEBUG ( "Found<S2SV_blank>move<S2SV_blank>%ld<S2SV_blank>%ld" <S2SV_ModEnd> , entry . <S2SV_ModStart> { LFS_DEBUG ( "Found<S2SV_blank>partial<S2SV_blank>move<S2SV_blank>%ld<S2SV_blank>%ld" <S2SV_ModEnd> , entry .
|
7,633 |
CWE-000 void printPCB ( PCB * pcb ) { <S2SV_StartBug> printf ( "\\n*<S2SV_blank>--><S2SV_blank>PID:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Iinitial<S2SV_blank>Burst:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Actual<S2SV_blank>burst:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Priority:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Arrival<S2SV_blank>time:<S2SV_blank>%d\\n" , <S2SV_EndBug> pcb -> pid , pcb -> burst , pcb -> burstLeft , pcb -> priority , pcb -> arrival_time ) ; }
|
<S2SV_ModStart> { printf ( "\\n*<S2SV_blank>--><S2SV_blank>PID:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Initial<S2SV_blank>Burst:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Actual<S2SV_blank>burst:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Priority:<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>Arrival<S2SV_blank>time:<S2SV_blank>%d\\n" <S2SV_ModEnd> , pcb ->
|
7,634 |
CWE-000 int tty_init ( void ) { if ( ( tty_fd = open ( tty0 , O_WRONLY ) ) < 0 ) { perror ( "open(" tty0 ")" ) ; return 6 ; } if ( ioctl ( tty_fd , TIOCGWINSZ , & tty_win ) < 0 ) { perror ( "ioctl(TIOCGWINSZ)" ) ; return 7 ; } fprintf ( stderr , "TTY<S2SV_blank>cols<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>rows<S2SV_blank>=<S2SV_blank>%d\\n" , tty_win . ws_col , tty_win . ws_row ) ; ux_settty ( ) ; write ( tty_fd , ANSI_RIS , 2 ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> }
|
<S2SV_ModStart> 2 ) ; ux_ts_update_extents ( 0 , tty_win . ws_col , 0 , tty_win . ws_row ) ;
|
7,635 |
CWE-000 API void lydict_remove ( struct ly_ctx * ctx , const char * value ) { size_t len ; int ret ; uint32_t hash ; struct dict_rec rec , * match = NULL ; char * val_p ; if ( ! value || ! ctx ) { return ; } len = strlen ( value ) ; hash = dict_hash ( value , len ) ; rec . value = ( char * ) value ; rec . refcount = 0 ; pthread_mutex_lock ( & ctx -> dict . lock ) ; lyht_set_cb_data ( ctx -> dict . hash_tab , ( void * ) & len ) ; ret = lyht_find ( ctx -> dict . hash_tab , & rec , hash , ( void * * ) & match ) ; if ( ret == 0 ) { <S2SV_StartBug> if ( ! match ) { <S2SV_EndBug> <S2SV_StartBug> LOGINT ( ctx ) ; <S2SV_EndBug> pthread_mutex_unlock ( & ctx -> dict . lock ) ; return ; } match -> refcount -- ; if ( match -> refcount == 0 ) { val_p = match -> value ; ret = lyht_remove ( ctx -> dict . hash_tab , & rec , hash ) ; free ( val_p ) ; <S2SV_StartBug> LY_CHECK_ERR_RETURN ( ret != 0 , LOGINT ( ctx ) , ) ; <S2SV_EndBug> } } pthread_mutex_unlock ( & ctx -> dict . lock ) ; }
|
<S2SV_ModStart> 0 ) { LY_CHECK_ERR_GOTO <S2SV_ModEnd> ( ! match <S2SV_ModStart> ( ! match , <S2SV_ModEnd> LOGINT ( ctx <S2SV_ModStart> ( ctx ) , finish ) ; <S2SV_ModEnd> match -> refcount <S2SV_ModStart> val_p ) ; LY_CHECK_ERR_GOTO ( ret <S2SV_ModEnd> , LOGINT ( <S2SV_ModStart> ctx ) , finish ) ; } } finish : <S2SV_ModEnd> pthread_mutex_unlock ( &
|
7,636 |
CWE-000 static gboolean icd_scan_network ( struct icd_network_module * module , const gchar * network_type ) { GSList * l ; if ( module -> scan_progress ) return TRUE ; if ( ! module -> nw . start_search ) { ILOG_WARN ( "module<S2SV_blank>\'%s\'<S2SV_blank>does<S2SV_blank>not<S2SV_blank>have<S2SV_blank>a<S2SV_blank>scan<S2SV_blank>function" , module -> name ) ; return FALSE ; } for ( l = module -> network_types ; l ; l = l -> next ) { if ( l -> data ) { ILOG_INFO ( "scan<S2SV_blank>start<S2SV_blank>for<S2SV_blank>type<S2SV_blank>\'%s\'" , ( const gchar * ) l -> data ) ; icd_status_scan_start ( ( const gchar * ) l -> data ) ; } <S2SV_StartBug> l = l -> next ; <S2SV_EndBug> } module -> scan_progress = TRUE ; module -> nw . start_search ( NULL , module -> scope , icd_scan_cb , module , & module -> nw . private ) ; return TRUE ; }
|
<S2SV_ModStart> ) ; } <S2SV_ModEnd> } module ->
|
7,637 |
CWE-000 void * worker_routine ( void * in ) { worker_input * input = ( worker_input * ) in ; request * req ; while ( 1 ) { printf ( "Worker<S2SV_blank>%d:<S2SV_blank>Sleeping.\\n" , input -> id ) ; pthread_mutex_lock ( input -> request_lock ) ; pthread_cond_wait ( input -> condition , input -> request_lock ) ; printf ( "Worker<S2SV_blank>%d:<S2SV_blank>Awake.\\n" , input -> id ) ; req = input -> req ; if ( req != NULL ) { printf ( "Worker<S2SV_blank>%d:<S2SV_blank>Request<S2SV_blank>found,<S2SV_blank>serving<S2SV_blank>fd:<S2SV_blank>%d,<S2SV_blank>file<S2SV_blank>size<S2SV_blank>%d.\\n" , input -> id , req -> fd_client , req -> priority ) ; worker_serve_client ( input -> id , req -> fd_client , req -> file , req -> buffer , & req -> len ) ; if ( req -> len != MAX_HTTP_SIZE ) { <S2SV_StartBug> free ( req -> buffer ) ; <S2SV_EndBug> free ( req ) ; input -> req = NULL ; } <S2SV_StartBug> printf ( "Worker<S2SV_blank>%d:<S2SV_blank>Done.\\n" , input -> id ) ; <S2SV_EndBug> } pthread_mutex_unlock ( input -> request_lock ) ; } }
|
<S2SV_ModStart> MAX_HTTP_SIZE ) { printf ( "Worker<S2SV_blank>%d:<S2SV_blank>Done.\\n" , input -> id ) ; <S2SV_ModStart> NULL ; } <S2SV_ModEnd> } pthread_mutex_unlock (
|
7,638 |
CWE-000 int piControlGetDeviceInfoList ( SDeviceInfo * pDev ) { piControlOpen ( ) ; if ( PiControlHandle_g < 0 ) <S2SV_StartBug> return PiControlHandle_g ; <S2SV_EndBug> return ioctl ( PiControlHandle_g , KB_GET_DEVICE_INFO_LIST , pDev ) ; }
|
<S2SV_ModStart> 0 ) return - errno <S2SV_ModEnd> ; return ioctl
|
7,639 |
CWE-000 void * CuRealloc ( void * old , CuSize_t n ) { assert ( old ) ; if ( old == NULL ) { return CuAlloc ( n ) ; } else { register CuAlloc_t * ptr = CuAlloc_getHeaderAddr ( old ) ; CuAlloc_t * ptr2 ; switch ( CuAlloc_getBufferValidity ( old ) ) { case true : ptr2 = ( CuAlloc_t * ) malloc ( CuAlloc_calculateTotalSize ( n ) ) ; if ( ptr2 ) { void * data = CuAlloc_getDataAddr ( ptr2 ) ; memcpy ( ptr2 , ptr , CuAlloc_calculateTotalSize ( n ) ) ; <S2SV_StartBug> memset ( ptr , 0x55 , CuAlloc_getTotalSize ( ptr ) ) ; <S2SV_EndBug> free ( ptr ) ; ++ realloccount ; CuAlloc_initHeader ( ptr2 , n ) ; return data ; } default : return NULL ; } } }
|
<S2SV_ModStart> , CuAlloc_getTotalSize ( old <S2SV_ModEnd> ) ) ;
|
7,640 |
CWE-000 void vAssertCalled ( const char * pcFile , unsigned long ulLine ) { volatile unsigned long ul = 0 ; ( void ) pcFile ; ( void ) ulLine ; taskENTER_CRITICAL ( ) ; { <S2SV_StartBug> arm_printf ( "%s:<S2SV_blank>file=%s,<S2SV_blank>line=%d!\\n" , __func__ , pcFile , ulLine ) ; <S2SV_EndBug> while ( ul == 0 ) { portNOP ( ) ; } } taskEXIT_CRITICAL ( ) ; }
|
<S2SV_ModStart> ) ; { basic_printf <S2SV_ModEnd> ( "%s:<S2SV_blank>file=%s,<S2SV_blank>line=%d!\\n" , <S2SV_ModStart> , pcFile , ( int )
|
7,641 |
CWE-000 void retro_cheat_set ( unsigned index , bool enabled , const char * codeLine ) { char name [ 256 ] ; m64p_cheat_code mupenCode [ 256 ] ; int matchLength = 0 , partCount = 0 ; unsigned int codeParts [ 256 ] ; int cursor ; sprintf ( name , "cheat_%u" , index ) ; <S2SV_StartBug> printf ( "!!!<S2SV_blank>-<S2SV_blank>Cheat<S2SV_blank>%u<S2SV_blank>name:<S2SV_blank>%s\\n" , index , name ) ; <S2SV_EndBug> for ( cursor = 0 ; ; cursor ++ ) { if ( ISHEXDEC ) { matchLength ++ ; } else { if ( matchLength ) { char codePartS [ matchLength ] ; strncpy ( codePartS , codeLine + cursor - matchLength , matchLength ) ; codePartS [ matchLength ] = 0 ; codeParts [ partCount ++ ] = strtoul ( codePartS , NULL , 16 ) ; <S2SV_StartBug> matchLength = 0 ; <S2SV_EndBug> printf ( "!!!<S2SV_blank>-<S2SV_blank>Cheat<S2SV_blank>part<S2SV_blank>%i<S2SV_blank>found:<S2SV_blank>%s,<S2SV_blank>decoded<S2SV_blank>as<S2SV_blank>%X\\n" , partCount - 1 , codePartS , codeParts [ partCount - 1 ] ) ; } } if ( ! codeLine [ cursor ] ) { break ; } } for ( cursor = 0 ; 2 * cursor + 1 < partCount ; cursor ++ ) { mupenCode [ cursor ] . address = codeParts [ 2 * cursor ] ; mupenCode [ cursor ] . value = codeParts [ 2 * cursor + 1 ] ; <S2SV_StartBug> printf ( "!!!<S2SV_blank>-<S2SV_blank>Cheat<S2SV_blank>Line<S2SV_blank>%i:<S2SV_blank>%X<S2SV_blank>%X\\n" , cursor , mupenCode [ cursor ] . address , mupenCode [ cursor ] . value ) ; <S2SV_EndBug> } cheat_add_new ( name , mupenCode , partCount / 2 ) ; cheat_set_enabled ( name , enabled ) ; }
|
<S2SV_ModStart> index ) ; <S2SV_ModEnd> for ( cursor <S2SV_ModStart> matchLength = 0 <S2SV_ModEnd> ; } } <S2SV_ModStart> 1 ] ; <S2SV_ModEnd> } cheat_add_new (
|
7,642 |
CWE-000 int main ( int argc , char * * argv ) { t_server * srv ; t_fds * fds ; int ret ; fds = ( t_fds * ) malloc ( sizeof ( t_fds ) ) ; ret = 0 ; if ( ! ( srv = server_create ( argc , argv ) ) || srv -> socket < 0 ) return ( return_msg ( srv ? NULL : error_msg [ 0 ] , srv ? srv -> socket : - 1 ) ) ; while ( ret >= 0 ) { if ( ! ( srv -> clt = set_clients_list ( srv ) ) ) return ( - 1 ) ; clear_and_set ( fds , srv ) ; if ( ( ret = select ( fds -> max , & fds -> rd , & fds -> wr , & fds -> ex , NULL ) ) < 0 ) return ( return_msg ( error_msg [ 1 ] , ret ) ) ; <S2SV_StartBug> else if ( recv_client ( fds , srv , ret ) ) <S2SV_EndBug> continue ; <S2SV_StartBug> else if ( send_client ( fds , srv , ret ) ) <S2SV_EndBug> continue ; } return ( ret ) ; }
|
<S2SV_ModStart> ) ) ; <S2SV_ModEnd> recv_client ( fds <S2SV_ModStart> , ret ) ; <S2SV_ModEnd> send_client ( fds <S2SV_ModStart> , ret ) <S2SV_ModEnd> ; } return
|
7,643 |
CWE-000 bool split_element ( doc_element * a_element , uint32_t req_depth ) { bool splittable ; doc_element * split_el ; text_line * cur_line ; text_line * last ; uint32_t count ; uint32_t cur_depth ; count = 0 ; <S2SV_StartBug> cur_depth = 0 ; <S2SV_EndBug> last = NULL ; splittable = true ; switch ( a_element -> type ) { case el_binc : case el_dbox : case el_graph : case el_hline : case el_vline : splittable = false ; break ; case el_text : cur_line = a_element -> element . text . first ; if ( ( cur_line -> line_height + cur_line -> spacing ) > old_max_depth ) { xx_err ( err_text_line_too_deep ) ; break ; } while ( cur_line != NULL ) { if ( ( cur_depth + cur_line -> line_height + cur_line -> spacing ) > req_depth ) { break ; } count ++ ; cur_depth += cur_line -> line_height + cur_line -> spacing ; last = cur_line ; cur_line = cur_line -> next ; } if ( cur_line != NULL ) { if ( count < g_cur_threshold ) { splittable = false ; a_element -> blank_lines = 0 ; break ; } } <S2SV_StartBug> if ( last == NULL ) { <S2SV_EndBug> break ; } split_el = alloc_doc_el ( el_text ) ; split_el -> depth = a_element -> depth - cur_depth ; split_el -> element . text . first = cur_line ; last -> next = NULL ; a_element -> depth = cur_depth ; if ( a_element -> next == NULL ) { a_element -> next = split_el ; } else { split_el -> next = a_element -> next ; a_element -> next = split_el ; } break ; default : internal_err ( __FILE__ , __LINE__ ) ; } return ( splittable ) ; }
|
<S2SV_ModStart> cur_depth = 0 <S2SV_ModEnd> ; splittable = <S2SV_ModStart> } if ( cur_line <S2SV_ModEnd> == NULL )
|
7,644 |
CWE-000 void freeProcess ( Process * process ) { <S2SV_StartBug> while ( process != NULL ) { <S2SV_EndBug> <S2SV_StartBug> Process * temp = process ; <S2SV_EndBug> process = process -> next ; freeArgs ( temp -> args ) ; temp -> args = NULL ; free ( temp ) ; temp = NULL ; } }
|
<S2SV_ModStart> process ) { Process * temp = process ; <S2SV_ModStart> NULL ) { <S2SV_ModEnd> process = process
|
7,645 |
CWE-000 EXPORTED int cyrus_acl_set ( char * * acl , const char * identifier , int mode , int access , cyrus_acl_canonproc_t * canonproc , void * canonrock ) { const char * canonid ; char * newidentifier = 0 ; char * newacl ; char * thisid , * nextid ; int oldaccess = 0 ; char * rights ; if ( ! identifier ) return - 1 ; canonid = auth_canonifyid ( * identifier == '-' ? identifier + 1 : identifier , 0 ) ; if ( canonid ) { if ( * identifier == '-' ) { newidentifier = xmalloc ( strlen ( canonid ) + 2 ) ; newidentifier [ 0 ] = '-' ; strcpy ( newidentifier + 1 , canonid ) ; identifier = newidentifier ; } else { identifier = canonid ; } } else if ( access != 0L ) { return - 1 ; } else { } for ( thisid = nextid = * acl ; * thisid ; thisid = nextid ) { rights = strchr ( thisid , '\\t' ) ; if ( ! rights ) { * thisid = '\\0' ; nextid = thisid ; break ; } * rights ++ = '\\0' ; nextid = strchr ( rights , '\\t' ) ; if ( ! nextid ) { * thisid = '\\0' ; nextid = thisid ; break ; } * nextid ++ = '\\0' ; if ( strcmp ( identifier , thisid ) == 0 ) { <S2SV_StartBug> oldaccess = cyrus_acl_strtomask ( rights ) ; <S2SV_EndBug> break ; } rights [ - 1 ] = '\\t' ; nextid [ - 1 ] = '\\t' ; } switch ( mode ) { case ACL_MODE_SET : break ; case ACL_MODE_ADD : access |= oldaccess ; break ; case ACL_MODE_REMOVE : access = oldaccess & ~ access ; break ; } if ( canonproc ) { if ( * identifier == '-' ) access = ~ ( canonproc ( canonrock , identifier + 1 , ~ access ) ) ; else access = canonproc ( canonrock , identifier , access ) ; } if ( access == 0L ) { newacl = xmalloc ( strlen ( * acl ) + strlen ( nextid ) - strlen ( thisid ) + 1 ) ; strncpy ( newacl , * acl , ( thisid - * acl ) ) ; strcpy ( newacl + ( thisid - * acl ) , nextid ) ; free ( * acl ) ; * acl = newacl ; } else { newacl = xmalloc ( ( thisid - * acl ) + strlen ( identifier ) + 40 + strlen ( nextid ) ) ; strncpy ( newacl , * acl , ( thisid - * acl ) ) ; strcpy ( newacl + ( thisid - * acl ) , identifier ) ; strcat ( newacl , "\\t" ) ; ( void ) cyrus_acl_masktostr ( access , newacl + strlen ( newacl ) ) ; strcat ( newacl , "\\t" ) ; strcat ( newacl , nextid ) ; free ( * acl ) ; * acl = newacl ; } if ( newidentifier ) free ( newidentifier ) ; return 0 ; }
|
<S2SV_ModStart> 0 ) { cyrus_acl_strtomask ( rights , & oldaccess <S2SV_ModEnd> ) ; break
|
7,646 |
CWE-000 void sha256Result ( Sha256State * state , char * result ) <S2SV_StartBug> { <S2SV_EndBug> sprintf ( result , "%08x%08x%08x%08x%08x%08x%08x%08x" , state -> A , state -> B , state -> C , state -> D , state -> E , state -> F , state -> G , state -> H ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> result ) { # if UINT32_MAX == UINT_MAX <S2SV_ModStart> H ) ; # elif UINT32_MAX == ULONG_MAX sprintf ( result , "%08lx%08lx%08lx%08lx%08lx%08lx%08lx%08lx" , state -> A , state -> B , state -> C , state -> D , state -> E , state -> F , state -> G , state -> H ) ; # else # error uint32_t is not unsigned int or unsigned long in current compiler . # endif
|
7,647 |
CWE-000 void dg_setup_prog_manual ( void ) { int ret = 0 ; hints = fi_allocinfo ( ) ; <S2SV_StartBug> cr_assert ( hints , "fi_allocinfo" ) ; <S2SV_EndBug> hints -> domain_attr -> cq_data_size = 4 ; hints -> domain_attr -> control_progress = FI_PROGRESS_MANUAL ; hints -> mode = mode_bits ; hints -> fabric_attr -> prov_name = strdup ( "gni" ) ; ret = fi_getinfo ( fi_version ( ) , NULL , 0 , 0 , hints , & fi ) ; cr_assert ( ! ret , "fi_getinfo" ) ; ret = fi_fabric ( fi -> fabric_attr , & fab , NULL ) ; cr_assert ( ! ret , "fi_fabric" ) ; ret = fi_domain ( fab , fi , & dom , NULL ) ; cr_assert ( ! ret , "fi_domain" ) ; ret = fi_endpoint ( dom , fi , & ep , NULL ) ; cr_assert ( ! ret , "fi_endpoint" ) ; }
|
<S2SV_ModStart> , "fi_allocinfo" ) ; hints -> domain_attr -> mr_mode = GNIX_DEFAULT_MR_MODE
|
7,648 |
CWE-000 int state_handle_cache_lookup ( TSCont contp , TSEvent event , TSVConn vc ) { TxnSM * txn_sm = ( TxnSM * ) TSContDataGet ( contp ) ; int64_t response_size ; int ret_val ; TSDebug ( PLUGIN_NAME , "enter<S2SV_blank>state_handle_cache_lookup" ) ; switch ( event ) { case TS_EVENT_CACHE_OPEN_READ : TSDebug ( PLUGIN_NAME , "cache<S2SV_blank>hit!!!" ) ; ret_val = TSTextLogObjectWrite ( protocol_plugin_log , "%s<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>\\n" , txn_sm -> q_file_name , txn_sm -> q_server_name , 1 ) ; if ( ret_val != TS_SUCCESS ) { TSError ( "[%s]<S2SV_blank>Fail<S2SV_blank>to<S2SV_blank>write<S2SV_blank>into<S2SV_blank>log" , PLUGIN_NAME ) ; } txn_sm -> q_cache_vc = vc ; txn_sm -> q_pending_action = NULL ; response_size = TSVConnCacheObjectSizeGet ( txn_sm -> q_cache_vc ) ; txn_sm -> q_client_response_buffer = TSIOBufferCreate ( ) ; <S2SV_StartBug> txn_sm -> q_client_response_buffer_reader = TSIOBufferReaderAlloc ( txn_sm -> q_client_response_buffer ) ; <S2SV_EndBug> <S2SV_StartBug> txn_sm -> q_cache_read_buffer = TSIOBufferCreate ( ) ; <S2SV_EndBug> <S2SV_StartBug> txn_sm -> q_cache_read_buffer_reader = TSIOBufferReaderAlloc ( txn_sm -> q_cache_read_buffer ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! txn_sm -> q_client_response_buffer || ! txn_sm -> q_client_response_buffer_reader || ! txn_sm -> q_cache_read_buffer || <S2SV_EndBug> ! txn_sm -> q_cache_read_buffer_reader ) { return prepare_to_die ( contp ) ; } set_handler ( txn_sm -> q_current_handler , ( TxnSMHandler ) & state_handle_cache_read_response ) ; txn_sm -> q_cache_read_vio = TSVConnRead ( txn_sm -> q_cache_vc , contp , txn_sm -> q_cache_read_buffer , response_size ) ; break ; case TS_EVENT_CACHE_OPEN_READ_FAILED : TSDebug ( PLUGIN_NAME , "cache<S2SV_blank>miss<S2SV_blank>or<S2SV_blank>error!!!" ) ; ret_val = TSTextLogObjectWrite ( protocol_plugin_log , "%s<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>\\n" , txn_sm -> q_file_name , txn_sm -> q_server_name , 0 ) ; if ( ret_val != TS_SUCCESS ) { TSError ( "[%s]<S2SV_blank>Fail<S2SV_blank>to<S2SV_blank>write<S2SV_blank>into<S2SV_blank>log" , PLUGIN_NAME ) ; } set_handler ( txn_sm -> q_current_handler , ( TxnSMHandler ) & state_handle_cache_prepare_for_write ) ; txn_sm -> q_pending_action = TSCacheWrite ( contp , txn_sm -> q_key ) ; break ; default : return prepare_to_die ( contp ) ; } return TS_SUCCESS ; }
|
<S2SV_ModStart> ( ) ; if ( ! txn_sm -> q_client_response_buffer ) { return prepare_to_die ( contp ) ; } <S2SV_ModStart> q_client_response_buffer ) ; if ( ! txn_sm -> q_client_response_buffer_reader ) { return prepare_to_die ( contp ) ; } <S2SV_ModStart> ( ) ; if ( ! txn_sm -> q_cache_read_buffer ) { return prepare_to_die ( contp ) ; } <S2SV_ModStart> ; if ( <S2SV_ModEnd> ! txn_sm ->
|
7,649 |
CWE-000 <S2SV_StartBug> static void addrconf_dad_completed ( struct inet6_ifaddr * ifp , bool bump_id ) <S2SV_EndBug> { struct net_device * dev = ifp -> idev -> dev ; struct in6_addr lladdr ; bool send_rs , send_mld ; addrconf_del_dad_work ( ifp ) ; ipv6_ifa_notify ( RTM_NEWADDR , ifp ) ; read_lock_bh ( & ifp -> idev -> lock ) ; send_mld = ifp -> scope == IFA_LINK && ipv6_lonely_lladdr ( ifp ) ; send_rs = send_mld && ipv6_accept_ra ( ifp -> idev ) && ifp -> idev -> cnf . rtr_solicits != 0 && ( dev -> flags & IFF_LOOPBACK ) == 0 ; read_unlock_bh ( & ifp -> idev -> lock ) ; if ( send_mld ) ipv6_mc_dad_complete ( ifp -> idev ) ; <S2SV_StartBug> if ( send_rs ) { <S2SV_EndBug> if ( ipv6_get_lladdr ( dev , & lladdr , IFA_F_TENTATIVE ) ) return ; ndisc_send_rs ( dev , & lladdr , & in6addr_linklocal_allrouters ) ; write_lock_bh ( & ifp -> idev -> lock ) ; spin_lock ( & ifp -> lock ) ; ifp -> idev -> rs_interval = rfc3315_s14_backoff_init ( ifp -> idev -> cnf . rtr_solicit_interval ) ; ifp -> idev -> rs_probes = 1 ; ifp -> idev -> if_flags |= IF_RS_SENT ; addrconf_mod_rs_timer ( ifp -> idev , ifp -> idev -> rs_interval ) ; spin_unlock ( & ifp -> lock ) ; write_unlock_bh ( & ifp -> idev -> lock ) ; } if ( bump_id ) rt_genid_bump_ipv6 ( dev_net ( dev ) ) ; if ( ifp -> flags & IFA_F_TEMPORARY ) addrconf_verify_rtnl ( ) ; }
|
<S2SV_ModStart> , bool bump_id , bool send_na <S2SV_ModStart> ; if ( send_na && ( ifp -> idev -> cnf . ndisc_notify || dev_net ( dev ) -> ipv6 . devconf_all -> ndisc_notify ) ) { ndisc_send_na ( dev , & in6addr_linklocal_allnodes , & ifp -> addr , ! ! ifp -> idev -> cnf . forwarding , false , true , true ) ; } if (
|
7,650 |
CWE-000 static void deparseScalarArrayOpExpr ( ScalarArrayOpExpr * node , deparse_expr_cxt * context ) { StringInfo buf = context -> buf ; HeapTuple tuple ; Form_pg_operator form ; Expr * arg1 ; Expr * arg2 ; char * opname ; tuple = SearchSysCache1 ( OPEROID , ObjectIdGetDatum ( node -> opno ) ) ; if ( ! HeapTupleIsValid ( tuple ) ) elog ( ERROR , "cache<S2SV_blank>lookup<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>operator<S2SV_blank>%u" , node -> opno ) ; form = ( Form_pg_operator ) GETSTRUCT ( tuple ) ; Assert ( list_length ( node -> args ) == 2 ) ; opname = NameStr ( form -> oprname ) ; <S2SV_StartBug> if ( strcmp ( opname , "=" ) != 0 || ! node -> useOr ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> <S2SV_StartBug> elog ( ERROR , "ANY/SOME<S2SV_blank>with<S2SV_blank>other<S2SV_blank>than<S2SV_blank>\'=\'<S2SV_blank>and<S2SV_blank>ALL<S2SV_blank>are<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>yet" ) ; <S2SV_EndBug> } arg1 = linitial ( node -> args ) ; arg2 = lsecond ( node -> args ) ; switch ( nodeTag ( ( Node * ) arg2 ) ) { case T_Const : { Const * c ; deparseExpr ( arg1 , context ) ; c = ( Const * ) arg2 ; <S2SV_StartBug> appendStringInfo ( buf , "<S2SV_blank>IN<S2SV_blank>(" ) ; <S2SV_EndBug> if ( ! c -> constisnull ) { Oid typoutput ; bool typIsVarlena ; char * extval ; getTypeOutputInfo ( c -> consttype , & typoutput , & typIsVarlena ) ; extval = OidOutputFunctionCall ( typoutput , c -> constvalue ) ; switch ( c -> consttype ) { case INT4ARRAYOID : case OIDARRAYOID : td_deparse_string ( buf , extval , false ) ; break ; default : td_deparse_string ( buf , extval , true ) ; break ; } } else { appendStringInfoString ( buf , "NULL" ) ; } appendStringInfoChar ( buf , ')' ) ; } break ; default : if ( context -> query_engine_type == QUERY_ENGINE_HIVE ) { appendStringInfoString ( buf , "array_contains(" ) ; } else { appendStringInfoString ( buf , "contains(" ) ; } deparseExpr ( arg2 , context ) ; appendStringInfoString ( buf , ",<S2SV_blank>" ) ; deparseExpr ( arg1 , context ) ; appendStringInfoChar ( buf , ')' ) ; break ; } ReleaseSysCache ( tuple ) ; }
|
<S2SV_ModStart> ; if ( ! ( <S2SV_ModStart> , "=" ) == 0 && node -> useOr ) && ! ( strcmp ( opname , "<>" ) == 0 && ! <S2SV_ModEnd> node -> useOr <S2SV_ModStart> -> useOr ) ) <S2SV_ModEnd> elog ( ERROR <S2SV_ModStart> ( ERROR , "Unsupported<S2SV_blank>operator<S2SV_blank>combination<S2SV_blank>in<S2SV_blank>scalar<S2SV_blank>array.<S2SV_blank>opname=[%s],<S2SV_blank>node->useOr=%d" , opname , node -> useOr ) ; <S2SV_ModEnd> arg1 = linitial <S2SV_ModStart> ) arg2 ; if ( strcmp ( opname , "<>" ) == 0 ) appendStringInfo ( buf , "<S2SV_blank>NOT" ) ;
|
7,651 |
CWE-000 static void expand_schema_name_patterns ( Archive * fout , SimpleStringList * patterns , SimpleOidList * oids , bool strict_names ) { PQExpBuffer query ; PGresult * res ; SimpleStringListCell * cell ; int i ; if ( patterns -> head == NULL ) return ; if ( fout -> remoteVersion < 70300 ) exit_horribly ( NULL , "server<S2SV_blank>version<S2SV_blank>must<S2SV_blank>be<S2SV_blank>at<S2SV_blank>least<S2SV_blank>7.3<S2SV_blank>to<S2SV_blank>use<S2SV_blank>schema<S2SV_blank>selection<S2SV_blank>switches\\n" ) ; query = createPQExpBuffer ( ) ; for ( cell = patterns -> head ; cell ; cell = cell -> next ) { appendPQExpBuffer ( query , "SELECT<S2SV_blank>oid<S2SV_blank>FROM<S2SV_blank>pg_catalog.pg_namespace<S2SV_blank>n\\n" ) ; processSQLNamePattern ( GetConnection ( fout ) , query , cell -> val , false , false , NULL , "n.nspname" , NULL , NULL ) ; res = ExecuteSqlQuery ( fout , query -> data , PGRES_TUPLES_OK ) ; if ( strict_names && PQntuples ( res ) == 0 ) <S2SV_StartBug> exit_horribly ( NULL , "no<S2SV_blank>matching<S2SV_blank>tables<S2SV_blank>were<S2SV_blank>found<S2SV_blank>for<S2SV_blank>pattern<S2SV_blank>\\"%s\\"\\n" , cell -> val ) ; <S2SV_EndBug> for ( i = 0 ; i < PQntuples ( res ) ; i ++ ) { simple_oid_list_append ( oids , atooid ( PQgetvalue ( res , i , 0 ) ) ) ; } PQclear ( res ) ; resetPQExpBuffer ( query ) ; } destroyPQExpBuffer ( query ) ; }
|
<S2SV_ModStart> ( NULL , "no<S2SV_blank>matching<S2SV_blank>schemas<S2SV_blank>were<S2SV_blank>found<S2SV_blank>for<S2SV_blank>pattern<S2SV_blank>\\"%s\\"\\n" <S2SV_ModEnd> , cell ->
|
7,652 |
CWE-000 void set_text ( cairo_t * cr , dk_control * control , char * text ) { switch ( control -> type ) { <S2SV_StartBug> case CT_LABEL : <S2SV_EndBug> break ; case CT_TEXT_BOX : text_box_set_text ( cr , control , text ) ; break ; case CT_FINGER_TEXT_BOX : break ; case CT_BUTTON : break ; case CT_IMAGE_BUTTON : break ; case CT_FINGER_BUTTON : break ; case CT_FINGER_IMAGE_BUTTON : break ; case CT_CHECK_BOX : break ; case CT_RADIO : break ; case CT_FINGER_CHECK_BOX : break ; case CT_FINGER_RADIO : break ; } }
|
<S2SV_ModStart> case CT_LABEL : label_set_text ( cr , control , text ) ;
|
7,653 |
CWE-000 <S2SV_StartBug> static char * * get_dmenu ( FILE * fd , unsigned int * length ) <S2SV_EndBug> { TICK_N ( "Read<S2SV_blank>stdin<S2SV_blank>START" ) ; char * * retv = NULL ; unsigned int rvlength = 1 ; * length = 0 ; gchar * data = NULL ; size_t data_l = 0 ; ssize_t l = 0 ; <S2SV_StartBug> while ( ( l = getdelim ( & data , & data_l , config . separator , fd ) ) > 0 ) { <S2SV_EndBug> if ( rvlength < ( * length + 2 ) ) { rvlength *= 2 ; retv = g_realloc ( retv , ( rvlength ) * sizeof ( char * ) ) ; } <S2SV_StartBug> if ( data [ l - 1 ] == config . separator ) { <S2SV_EndBug> data [ l - 1 ] = '\\0' ; l -- ; } if ( ! g_utf8_validate ( data , l , NULL ) ) { fprintf ( stderr , "String:<S2SV_blank>\'%s\'<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>utf-8\\n" , data ) ; continue ; } retv [ ( * length ) ] = data ; data = NULL ; data_l = 0 ; ( * length ) ++ ; if ( ( * length ) >= DMENU_MAX_ROWS ) { break ; } } if ( data != NULL ) { free ( data ) ; data = NULL ; } if ( retv != NULL ) { retv = g_realloc ( retv , ( * length + 1 ) * sizeof ( char * ) ) ; retv [ ( * length ) ] = NULL ; } TICK_N ( "Read<S2SV_blank>stdin<S2SV_blank>STOP" ) ; return retv ; }
|
<S2SV_ModStart> * get_dmenu ( DmenuModePrivateData * pd , <S2SV_ModStart> & data_l , pd -> <S2SV_ModEnd> separator , fd <S2SV_ModStart> 1 ] == pd -> <S2SV_ModEnd> separator ) {
|
7,654 |
CWE-000 void new_ellipse_dst ( t_rt * rt , int type , double tmp ) { rt -> inter -> dst = tmp ; if ( type == 0 ) cam_ellipse_inter ( rt ) ; <S2SV_StartBug> if ( type == 1 && rt -> inter -> num == rt -> ellipse -> id ) <S2SV_EndBug> light_ellipse_inter ( rt ) ; }
|
<S2SV_ModStart> type == 1 ) <S2SV_ModEnd> rt -> inter <S2SV_ModStart> -> inter -> light = <S2SV_ModEnd> rt -> ellipse <S2SV_ModStart> ellipse -> id <S2SV_ModEnd> ; } <S2SV_null>
|
7,655 |
CWE-000 bool sensorsAutodetect ( void ) { if ( ! gyroInit ( ) ) { return false ; } accInit ( gyro . targetLooptime ) ; # ifdef MAG compassInit ( ) ; # endif # ifdef BARO baroDetect ( & baro . dev , barometerConfig ( ) -> baro_hardware ) ; # endif # ifdef SONAR if ( sonarDetect ( ) ) { sonarInit ( sonarConfig ( ) ) ; } # endif <S2SV_StartBug> # ifdef LEDDAR <S2SV_EndBug> if ( feature ( FEATURE_LEDDAR ) ) { sensorsSet ( SENSOR_LEDDAR ) ; <S2SV_StartBug> } <S2SV_EndBug> # endif return true ; }
|
<S2SV_ModStart> } # endif <S2SV_ModEnd> sensorsSet ( SENSOR_LEDDAR <S2SV_ModStart> SENSOR_LEDDAR ) ; <S2SV_ModEnd> return true ;
|
7,656 |
CWE-000 void hci_le_ltk_reply ( struct hci_conn * conn , u8 ltk [ 16 ] ) { struct hci_dev * hdev = conn -> hdev ; struct hci_cp_le_ltk_reply cp ; BT_DBG ( "%p" , conn ) ; memset ( & cp , 0 , sizeof ( cp ) ) ; cp . handle = cpu_to_le16 ( conn -> handle ) ; <S2SV_StartBug> memcpy ( cp . ltk , ltk , sizeof ( ltk ) ) ; <S2SV_EndBug> hci_send_cmd ( hdev , HCI_OP_LE_LTK_REPLY , sizeof ( cp ) , & cp ) ; }
|
<S2SV_ModStart> , sizeof ( *
|
7,657 |
CWE-000 int ROE_CCDA_VRD ( packet_t * p ) { record ( "Request<S2SV_blank>for<S2SV_blank>ROE<S2SV_blank>CCDA_VRD<S2SV_blank>current<S2SV_blank>received\\n" ) ; char * temp = malloc ( sizeof ( char ) * 20 ) ; strcpy ( temp , CCDA_VRD ) ; double x = getHK ( CCDA_VRDC ) ; double y = 10.05 * x ; char response [ 15 ] ; sprintf ( response , "%3.2f<S2SV_blank>V" , y ) ; strcat ( temp , response ) ; <S2SV_StartBug> packet_t * r = constructPacket ( HK_RSP , CCDA_VRD , temp ) ; <S2SV_EndBug> enqueue ( & lqueue [ hkdown ] , r ) ; free ( temp ) ; return GOOD_PACKET ; }
|
<S2SV_ModStart> , CCDA_VRD , response <S2SV_ModEnd> ) ; enqueue
|
7,658 |
CWE-000 vm_t * vm_new ( ) { vm_t * vm = ( vm_t * ) scm_realloc ( NULL , sizeof ( vm_t ) ) ; memset ( vm , 0 , sizeof ( vm_t ) ) ; vm -> allocated = 0 ; <S2SV_StartBug> vm -> gc_threshold = 4096 ; <S2SV_EndBug> vm -> symbol_table = NULL ; vm -> env = NULL ; vm -> reader = NULL ; vm -> curval = NIL_VAL ; return vm ; }
|
<S2SV_ModStart> -> gc_threshold = 8192 <S2SV_ModEnd> ; vm ->
|
7,659 |
CWE-000 <S2SV_StartBug> const char * MVM_io_get_sockopt_name ( int option ) { <S2SV_EndBug> switch ( option ) { case SO_BROADCAST : return "SO_BROADCAST" ; case SO_KEEPALIVE : return "SO_KEEPALIVE" ; case SO_LINGER : return "SO_LINGER" ; <S2SV_StartBug> case SO_RCVBUF : return "SO_RCVBUF" ; <S2SV_EndBug> <S2SV_StartBug> case SO_REUSEADDR : return "SO_REUSEADDR" ; <S2SV_EndBug> case SO_SNDBUF : return "SO_SNDBUF" ; <S2SV_StartBug> case SO_DEBUG : return "SO_DEBUG" ; <S2SV_EndBug> case SO_DONTROUTE : return "SO_DONTROUTE" ; <S2SV_StartBug> case SO_OOBINLINE : return "SO_OOBINLINE" ; <S2SV_EndBug> default : return "unknown" ; } }
|
<S2SV_ModStart> * MVM_io_get_sockopt_name ( MVMint32 <S2SV_ModEnd> option ) { <S2SV_ModStart> "SO_LINGER" ; case <S2SV_ModEnd> SO_REUSEADDR : return <S2SV_ModStart> : return "SO_REUSEADDR" ; case SO_DONTROUTE : return "SO_DONTROUTE" <S2SV_ModStart> "SO_SNDBUF" ; case SO_RCVBUF : return "SO_RCVBUF" <S2SV_ModEnd> ; case SO_OOBINLINE <S2SV_ModStart> : return "SO_OOBINLINE" ; case TCP_NODELAY : return "TCP_NODELAY"
|
7,660 |
CWE-000 static int update_buffers ( struct dri2_egl_surface * dri2_surf ) <S2SV_StartBug> { <S2SV_EndBug> if ( dri2_surf -> base . Type != EGL_WINDOW_BIT ) return 0 ; if ( ! dri2_surf -> buffer && ! droid_window_dequeue_buffer ( dri2_surf ) ) { <S2SV_StartBug> _eglLog ( _EGL_WARNING , "Could<S2SV_blank>not<S2SV_blank>dequeue<S2SV_blank>buffer<S2SV_blank>from<S2SV_blank>native<S2SV_blank>window" ) ; <S2SV_EndBug> return - 1 ; } if ( dri2_surf -> base . Width != dri2_surf -> buffer -> width || dri2_surf -> base . Height != dri2_surf -> buffer -> height ) { droid_free_local_buffers ( dri2_surf ) ; dri2_surf -> base . Width = dri2_surf -> buffer -> width ; dri2_surf -> base . Height = dri2_surf -> buffer -> height ; } return 0 ; }
|
<S2SV_ModStart> dri2_surf ) { if ( dri2_surf -> base . Lost ) return - 1 ; <S2SV_ModStart> , "Could<S2SV_blank>not<S2SV_blank>dequeue<S2SV_blank>buffer<S2SV_blank>from<S2SV_blank>native<S2SV_blank>window" ) ; dri2_surf -> base . Lost = EGL_TRUE
|
7,661 |
CWE-000 static int check_input ( HREAL * evals , SCALAR * evecs , HREAL * resNorms , primme_params * primme ) { int ret ; ret = 0 ; if ( primme == NULL ) ret = - 4 ; else if ( primme -> n < 0 || primme -> nLocal < 0 || primme -> nLocal > primme -> n ) ret = - 5 ; else if ( primme -> numProcs < 1 ) ret = - 6 ; else if ( primme -> matrixMatvec == NULL ) ret = - 7 ; else if ( primme -> applyPreconditioner == NULL && primme -> correctionParams . precondition > 0 ) ret = - 8 ; else if ( primme -> numEvals > primme -> n ) ret = - 10 ; else if ( primme -> numEvals < 0 ) ret = - 11 ; else if ( fabs ( primme -> eps ) != 0.0L && primme -> eps < MACHINE_EPSILON ) ret = - 12 ; else if ( primme -> target != primme_smallest && primme -> target != primme_largest && primme -> target != primme_largest_abs && primme -> target != primme_closest_geq && primme -> target != primme_closest_leq && primme -> target != primme_closest_abs ) ret = - 13 ; else if ( primme -> numOrthoConst < 0 || primme -> numOrthoConst > primme -> n ) ret = - 16 ; <S2SV_StartBug> else if ( primme -> maxBasisSize <= 2 && primme -> maxBasisSize + primme -> numOrthoConst != primme -> n ) <S2SV_EndBug> ret = - 17 ; else if ( primme -> minRestartSize < 0 || ( primme -> minRestartSize == 0 && primme -> n > 2 && primme -> numEvals > 0 ) ) ret = - 18 ; else if ( primme -> maxBlockSize < 0 || ( primme -> maxBlockSize == 0 && primme -> numEvals > 0 ) ) ret = - 19 ; else if ( primme -> restartingParams . maxPrevRetain < 0 ) ret = - 20 ; else if ( primme -> initSize < 0 ) ret = - 22 ; else if ( primme -> locking == 0 && primme -> initSize > primme -> maxBasisSize ) ret = - 23 ; else if ( primme -> locking > 0 && primme -> initSize > primme -> numEvals ) ret = - 24 ; else if ( primme -> minRestartSize + primme -> restartingParams . maxPrevRetain >= primme -> maxBasisSize && primme -> n > primme -> maxBasisSize ) ret = - 25 ; else if ( primme -> minRestartSize > primme -> n && primme -> n > 2 ) ret = - 26 ; else if ( primme -> printLevel < 0 || primme -> printLevel > 5 ) ret = - 27 ; else if ( primme -> correctionParams . convTest != primme_full_LTolerance && primme -> correctionParams . convTest != primme_decreasing_LTolerance && primme -> correctionParams . convTest != primme_adaptive_ETolerance && primme -> correctionParams . convTest != primme_adaptive ) ret = - 28 ; else if ( primme -> correctionParams . convTest == primme_decreasing_LTolerance && primme -> correctionParams . relTolBase <= 1.0L ) ret = - 29 ; else if ( evals == NULL ) ret = - 30 ; else if ( evecs == NULL ) ret = - 31 ; else if ( resNorms == NULL ) ret = - 32 ; else if ( primme -> locking == 0 && primme -> minRestartSize < primme -> numEvals && primme -> n > 2 ) ret = - 33 ; else if ( primme -> ldevecs < primme -> nLocal ) ret = - 34 ; else if ( primme -> ldOPs != 0 && primme -> ldOPs < primme -> nLocal ) ret = - 35 ; else if ( primme -> locking == 0 && ( primme -> target == primme_closest_leq || primme -> target == primme_closest_geq ) ) ret = - 38 ; else if ( primme -> massMatrixMatvec && primme -> projectionParams . projection != primme_proj_RR ) ret = - 39 ; else if ( primme -> target == primme_largest_abs || primme -> target == primme_closest_geq || primme -> target == primme_closest_leq || primme -> target == primme_closest_abs ) { if ( primme -> numTargetShifts <= 0 ) { ret = - 14 ; } else if ( primme -> targetShifts == NULL ) { ret = - 15 ; } } return ret ; }
|
<S2SV_ModStart> primme -> maxBasisSize < <S2SV_ModEnd> 2 && primme <S2SV_ModStart> && primme -> n > 2 <S2SV_ModEnd> ) ret =
|
7,662 |
CWE-000 void msm_isp_process_iommu_page_fault ( struct vfe_device * vfe_dev ) { struct msm_isp_event_data error_event ; struct msm_vfe_axi_halt_cmd halt_cmd ; uint32_t i ; memset ( & halt_cmd , 0 , sizeof ( struct msm_vfe_axi_halt_cmd ) ) ; halt_cmd . stop_camif = 1 ; halt_cmd . overflow_detected = 0 ; halt_cmd . blocking_halt = 0 ; msm_isp_axi_halt ( vfe_dev , & halt_cmd ) ; for ( i = 0 ; i < MAX_NUM_STREAM ; i ++ ) vfe_dev -> axi_data . stream_info [ i ] . state = INACTIVE ; <S2SV_StartBug> pr_err ( "%s:%d]<S2SV_blank>vfe_dev<S2SV_blank>%p<S2SV_blank>id<S2SV_blank>%d\\n" , __func__ , <S2SV_EndBug> __LINE__ , vfe_dev , vfe_dev -> pdev -> id ) ; error_event . frame_id = vfe_dev -> axi_data . src_info [ VFE_PIX_0 ] . frame_id ; vfe_dev -> buf_mgr -> ops -> buf_mgr_debug ( vfe_dev -> buf_mgr , vfe_dev -> page_fault_addr ) ; msm_isp_print_ping_pong_address ( vfe_dev ) ; vfe_dev -> hw_info -> vfe_ops . axi_ops . read_wm_ping_pong_addr ( vfe_dev ) ; msm_isp_send_event ( vfe_dev , ISP_EVENT_IOMMU_P_FAULT , & error_event ) ; }
|
<S2SV_ModStart> ; pr_err ( "%s:%d]<S2SV_blank>vfe_dev<S2SV_blank>%pK<S2SV_blank>id<S2SV_blank>%d\\n" <S2SV_ModEnd> , __func__ ,
|
7,663 |
CWE-000 void lib_whilestar ( AStack * stack , AVarBuffer * buffer ) { <S2SV_StartBug> AValue * condpart = stack_get ( stack , 0 ) ; <S2SV_EndBug> <S2SV_StartBug> AValue * looppart = stack_get ( stack , 1 ) ; <S2SV_EndBug> AValue * top = stack_get ( stack , 2 ) ; stack_pop ( stack , 2 ) ; eval_block ( stack , buffer , condpart ) ; AValue * condition = stack_get ( stack , 0 ) ; stack_pop ( stack , 1 ) ; while ( condition -> data . i ) { delete_ref ( condition ) ; stack_push ( stack , top ) ; eval_block ( stack , buffer , looppart ) ; top = stack_get ( stack , 0 ) ; eval_block ( stack , buffer , condpart ) ; condition = stack_get ( stack , 0 ) ; stack_pop ( stack , 1 ) ; } stack_push ( stack , top ) ; delete_ref ( condpart ) ; delete_ref ( condition ) ; delete_ref ( looppart ) ; }
|
<S2SV_ModStart> ( stack , 1 <S2SV_ModEnd> ) ; AValue <S2SV_ModStart> ( stack , 0 <S2SV_ModEnd> ) ; AValue
|
7,664 |
CWE-000 int parse_escape_sequence ( WINDOW * win , int kbinput ) { int retval , * seq ; size_t seq_len ; unget_input ( & kbinput , 1 ) ; seq_len = key_buffer_len ; seq = get_input ( NULL , seq_len ) ; retval = convert_sequence ( seq , seq_len ) ; free ( seq ) ; if ( retval == ERR ) { if ( win == edit ) { statusline ( ALERT , _ ( "Unknown<S2SV_blank>sequence" ) ) ; suppress_cursorpos = FALSE ; lastmessage = HUSH ; if ( currmenu == MMAIN ) { <S2SV_StartBug> place_the_cursor ( ) ; <S2SV_EndBug> curs_set ( 1 ) ; } } } # ifdef DEBUG fprintf ( stderr , "parse_escape_sequence():<S2SV_blank>kbinput<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>seq_len<S2SV_blank>=<S2SV_blank>%lu,<S2SV_blank>retval<S2SV_blank>=<S2SV_blank>%d\\n" , kbinput , ( unsigned long ) seq_len , retval ) ; # endif return retval ; }
|
<S2SV_ModStart> { place_the_cursor ( TRUE
|
7,665 |
CWE-000 static struct its_device * its_create_device ( struct its_node * its , u32 dev_id , int nvecs ) { struct its_device * dev ; unsigned long * lpi_map ; void * itt ; <S2SV_StartBug> int lpi_base ; <S2SV_EndBug> int nr_lpis ; int nr_ites ; int cpu ; int sz ; dev = kzalloc ( sizeof ( * dev ) , GFP_KERNEL ) ; nr_ites = max ( 2UL , roundup_pow_of_two ( nvecs ) ) ; sz = nr_ites * its -> ite_size ; sz = max ( sz , ITS_ITT_ALIGN ) + ITS_ITT_ALIGN - 1 ; itt = kmalloc ( sz , GFP_KERNEL ) ; lpi_map = its_lpi_alloc_chunks ( nvecs , & lpi_base , & nr_lpis ) ; if ( ! dev || ! itt || ! lpi_map ) { kfree ( dev ) ; kfree ( itt ) ; kfree ( lpi_map ) ; return NULL ; } dev -> its = its ; dev -> itt = itt ; dev -> nr_ites = nr_ites ; dev -> lpi_map = lpi_map ; dev -> lpi_base = lpi_base ; dev -> nr_lpis = nr_lpis ; dev -> device_id = dev_id ; INIT_LIST_HEAD ( & dev -> entry ) ; raw_spin_lock ( & its -> lock ) ; list_add ( & dev -> entry , & its -> its_device_list ) ; raw_spin_unlock ( & its -> lock ) ; cpu = cpumask_first ( cpu_online_mask ) ; dev -> collection = & its -> collections [ cpu ] ; its_send_mapd ( dev , 1 ) ; return dev ; }
|
<S2SV_ModStart> ; int lpi_base = 0 ; int nr_lpis = 0 <S2SV_ModEnd> ; int nr_ites
|
7,666 |
CWE-000 static inline short vmcs_field_to_offset ( unsigned long field ) { BUILD_BUG_ON ( ARRAY_SIZE ( vmcs_field_to_offset_table ) > SHRT_MAX ) ; <S2SV_StartBug> if ( field >= ARRAY_SIZE ( vmcs_field_to_offset_table ) || <S2SV_EndBug> vmcs_field_to_offset_table [ field ] == 0 ) return - ENOENT ; return vmcs_field_to_offset_table [ field ] ; }
|
<S2SV_ModStart> ( vmcs_field_to_offset_table ) ) return - ENOENT ; asm ( "lfence" ) ; if ( <S2SV_ModEnd> vmcs_field_to_offset_table [ field
|
7,667 |
CWE-000 void init_framebuffers_list ( GtkTreeView * tree ) { GtkTreeView * content = GTK_TREE_VIEW ( gtk_builder_get_object ( builder , "framebuffer0_treeview" ) ) ; GtkTreeStore * store = GTK_TREE_STORE ( gtk_tree_view_get_model ( content ) ) ; gtk_tree_store_clear ( store ) ; content = GTK_TREE_VIEW ( gtk_builder_get_object ( builder , "framebuffer_attachments" ) ) ; store = GTK_TREE_STORE ( gtk_tree_view_get_model ( content ) ) ; gtk_tree_store_clear ( store ) ; store = GTK_TREE_STORE ( gtk_tree_view_get_model ( tree ) ) ; gtk_tree_store_clear ( store ) ; GtkTreeIter row ; gtk_tree_store_append ( store , & row , NULL ) ; gtk_tree_store_set ( store , & row , 0 , "0" , - 1 ) ; <S2SV_StartBug> const trc_gl_framebuffer_rev_t * rev ; <S2SV_EndBug> for ( size_t i = 0 ; trc_iter_objects ( trace , TrcFramebuffer , & i , revision , ( const void * * ) & rev ) ; ) { char str [ 64 ] ; memset ( str , 0 , 64 ) ; snprintf ( str , 64 , "%u" , ( uint ) rev -> fake ) ; GtkTreeIter row ; <S2SV_StartBug> gtk_tree_store_append ( store , & row , NULL ) ; <S2SV_EndBug> gtk_tree_store_set ( store , & row , 0 , str , - 1 ) ; } <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> 1 ) ; create_obj_list <S2SV_ModEnd> ( store , <S2SV_ModStart> ( store , TrcFramebuffer <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null>
|
7,668 |
CWE-000 int _libssh2_pem_parse ( LIBSSH2_SESSION * session , const char * headerbegin , const char * headerend , const unsigned char * passphrase , FILE * fp , unsigned char * * data , unsigned int * datalen ) { char line [ LINE_SIZE ] ; unsigned char iv [ LINE_SIZE ] ; char * b64data = NULL ; unsigned int b64datalen = 0 ; int ret ; const LIBSSH2_CRYPT_METHOD * method = NULL ; do { * line = '\\0' ; if ( readline ( line , LINE_SIZE , fp ) ) { return - 1 ; } } while ( strcmp ( line , headerbegin ) != 0 ) ; if ( readline ( line , LINE_SIZE , fp ) ) { return - 1 ; } if ( passphrase && memcmp ( line , crypt_annotation , strlen ( crypt_annotation ) ) == 0 ) { const LIBSSH2_CRYPT_METHOD * * all_methods , * cur_method ; int i ; if ( readline ( line , LINE_SIZE , fp ) ) { ret = - 1 ; goto out ; } all_methods = libssh2_crypt_methods ( ) ; while ( ( cur_method = * all_methods ++ ) ) { if ( * cur_method -> pem_annotation && memcmp ( line , cur_method -> pem_annotation , strlen ( cur_method -> pem_annotation ) ) == 0 ) { method = cur_method ; memcpy ( iv , line + strlen ( method -> pem_annotation ) + 1 , 2 * method -> iv_len ) ; } } if ( method == NULL ) return - 1 ; for ( i = 0 ; i < method -> iv_len ; ++ i ) { iv [ i ] = hex_decode ( iv [ 2 * i ] ) << 4 ; iv [ i ] |= hex_decode ( iv [ 2 * i + 1 ] ) ; } if ( readline ( line , LINE_SIZE , fp ) ) { ret = - 1 ; goto out ; } } do { if ( * line ) { char * tmp ; size_t linelen ; linelen = strlen ( line ) ; tmp = LIBSSH2_REALLOC ( session , b64data , b64datalen + linelen ) ; if ( ! tmp ) { ret = - 1 ; goto out ; } memcpy ( tmp + b64datalen , line , linelen ) ; b64data = tmp ; b64datalen += linelen ; } * line = '\\0' ; if ( readline ( line , LINE_SIZE , fp ) ) { ret = - 1 ; goto out ; } } while ( strcmp ( line , headerend ) != 0 ) ; if ( ! b64data ) { return - 1 ; } if ( libssh2_base64_decode ( session , ( char * * ) data , datalen , b64data , b64datalen ) ) { ret = - 1 ; goto out ; } if ( method ) { int free_iv = 0 , free_secret = 0 , len_decrypted = 0 , padding = 0 ; int blocksize = method -> blocksize ; void * abstract ; unsigned char secret [ 2 * MD5_DIGEST_LENGTH ] ; libssh2_md5_ctx fingerprint_ctx ; if ( ! libssh2_md5_init ( & fingerprint_ctx ) ) { ret = - 1 ; goto out ; } libssh2_md5_update ( fingerprint_ctx , passphrase , strlen ( ( char * ) passphrase ) ) ; libssh2_md5_update ( fingerprint_ctx , iv , 8 ) ; libssh2_md5_final ( fingerprint_ctx , secret ) ; if ( method -> secret_len > MD5_DIGEST_LENGTH ) { if ( ! libssh2_md5_init ( & fingerprint_ctx ) ) { ret = - 1 ; goto out ; } libssh2_md5_update ( fingerprint_ctx , secret , MD5_DIGEST_LENGTH ) ; libssh2_md5_update ( fingerprint_ctx , passphrase , strlen ( ( char * ) passphrase ) ) ; libssh2_md5_update ( fingerprint_ctx , iv , 8 ) ; libssh2_md5_final ( fingerprint_ctx , secret + MD5_DIGEST_LENGTH ) ; } if ( method -> init ( session , method , iv , & free_iv , secret , & free_secret , 0 , & abstract ) ) { memset ( ( char * ) secret , 0 , sizeof ( secret ) ) ; LIBSSH2_FREE ( session , data ) ; ret = - 1 ; goto out ; } if ( free_secret ) { memset ( ( char * ) secret , 0 , sizeof ( secret ) ) ; } if ( ( * datalen % blocksize ) != 0 ) { memset ( ( char * ) secret , 0 , sizeof ( secret ) ) ; method -> dtor ( session , & abstract ) ; memset ( * data , 0 , * datalen ) ; LIBSSH2_FREE ( session , * data ) ; ret = - 1 ; goto out ; } <S2SV_StartBug> while ( len_decrypted <= * datalen - blocksize ) { <S2SV_EndBug> if ( method -> crypt ( session , * data + len_decrypted , blocksize , & abstract ) ) { ret = LIBSSH2_ERROR_DECRYPT ; memset ( ( char * ) secret , 0 , sizeof ( secret ) ) ; method -> dtor ( session , & abstract ) ; memset ( * data , 0 , * datalen ) ; LIBSSH2_FREE ( session , * data ) ; goto out ; } len_decrypted += blocksize ; } padding = ( * data ) [ * datalen - 1 ] ; memset ( & ( * data ) [ * datalen - padding ] , 0 , padding ) ; * datalen -= padding ; memset ( ( char * ) secret , 0 , sizeof ( secret ) ) ; method -> dtor ( session , & abstract ) ; } ret = 0 ; out : if ( b64data ) { LIBSSH2_FREE ( session , b64data ) ; } return ret ; }
|
<S2SV_ModStart> ( len_decrypted <= ( int )
|
7,669 |
CWE-000 jp2_box_t * jp2_box_get ( jas_stream_t * in ) { jp2_box_t * box ; jp2_boxinfo_t * boxinfo ; jas_stream_t * tmpstream ; uint_fast32_t len ; uint_fast64_t extlen ; bool dataflag ; box = 0 ; tmpstream = 0 ; <S2SV_StartBug> if ( ! ( box = jas_malloc ( sizeof ( jp2_box_t ) ) ) ) { <S2SV_EndBug> goto error ; } box -> ops = & jp2_boxinfo_unk . ops ; if ( jp2_getuint32 ( in , & len ) || jp2_getuint32 ( in , & box -> type ) ) { goto error ; } boxinfo = jp2_boxinfolookup ( box -> type ) ; box -> info = boxinfo ; box -> len = len ; JAS_DBGLOG ( 10 , ( <S2SV_StartBug> "preliminary<S2SV_blank>processing<S2SV_blank>of<S2SV_blank>JP2<S2SV_blank>box:<S2SV_blank>type=%c%s%c<S2SV_blank>(0x%08x);<S2SV_blank>length=%d\\n" , <S2SV_EndBug> \'"\' , boxinfo -> name , \'"\' , box -> type , box -> len ) ) ; <S2SV_StartBug> if ( box -> len == 1 ) { <S2SV_EndBug> if ( jp2_getuint64 ( in , & extlen ) ) { goto error ; } if ( extlen > 0xffffffffUL ) { jas_eprintf ( "warning:<S2SV_blank>cannot<S2SV_blank>handle<S2SV_blank>large<S2SV_blank>64-bit<S2SV_blank>box<S2SV_blank>length\\n" ) ; extlen = 0xffffffffUL ; } box -> len = extlen ; box -> datalen = extlen - JP2_BOX_HDRLEN ( true ) ; } else { box -> datalen = box -> len - JP2_BOX_HDRLEN ( false ) ; } if ( box -> len != 0 && box -> len < 8 ) { goto error ; } dataflag = ! ( box -> info -> flags & ( JP2_BOX_SUPER | JP2_BOX_NODATA ) ) ; if ( dataflag ) { if ( ! ( tmpstream = jas_stream_memopen ( 0 , 0 ) ) ) { goto error ; } if ( jas_stream_copy ( tmpstream , in , box -> datalen ) ) { jas_eprintf ( "cannot<S2SV_blank>copy<S2SV_blank>box<S2SV_blank>data\\n" ) ; goto error ; } jas_stream_rewind ( tmpstream ) ; box -> ops = & boxinfo -> ops ; if ( box -> ops -> getdata ) { if ( ( * box -> ops -> getdata ) ( box , tmpstream ) ) { jas_eprintf ( "cannot<S2SV_blank>parse<S2SV_blank>box<S2SV_blank>data\\n" ) ; goto error ; } } jas_stream_close ( tmpstream ) ; } if ( jas_getdbglevel ( ) >= 1 ) { jp2_box_dump ( box , stderr ) ; } return box ; error : if ( box ) { jp2_box_destroy ( box ) ; } if ( tmpstream ) { jas_stream_close ( tmpstream ) ; } return 0 ; }
|
<S2SV_ModStart> ( box = jp2_box_create0 ( ) ) ) { goto error ; } <S2SV_ModEnd> if ( jp2_getuint32 <S2SV_ModStart> 10 , ( "preliminary<S2SV_blank>processing<S2SV_blank>of<S2SV_blank>JP2<S2SV_blank>box:<S2SV_blank>" "type=%c%s%c<S2SV_blank>(0x%08x);<S2SV_blank>length=%" PRIuFAST32 "\\n" <S2SV_ModEnd> , \'"\' , <S2SV_ModStart> 1 ) { JAS_DBGLOG ( 10 , ( "big<S2SV_blank>length\\n" ) ) ;
|
7,670 |
CWE-000 static noinline void caching_thread ( struct btrfs_work * work ) { struct btrfs_block_group_cache * block_group ; struct btrfs_fs_info * fs_info ; struct btrfs_caching_control * caching_ctl ; <S2SV_StartBug> struct btrfs_root * extent_root ; <S2SV_EndBug> int ret ; caching_ctl = container_of ( work , struct btrfs_caching_control , work ) ; block_group = caching_ctl -> block_group ; <S2SV_StartBug> fs_info = block_group -> fs_info ; <S2SV_EndBug> extent_root = fs_info -> extent_root ; mutex_lock ( & caching_ctl -> mutex ) ; down_read ( & fs_info -> commit_root_sem ) ; if ( btrfs_fs_compat_ro ( fs_info , FREE_SPACE_TREE ) ) ret = load_free_space_tree ( caching_ctl ) ; else ret = load_extent_tree_free ( caching_ctl ) ; spin_lock ( & block_group -> lock ) ; block_group -> caching_ctl = NULL ; block_group -> cached = ret ? BTRFS_CACHE_ERROR : BTRFS_CACHE_FINISHED ; spin_unlock ( & block_group -> lock ) ; # ifdef CONFIG_BTRFS_DEBUG if ( btrfs_should_fragment_free_space ( block_group ) ) { u64 bytes_used ; spin_lock ( & block_group -> space_info -> lock ) ; spin_lock ( & block_group -> lock ) ; bytes_used = block_group -> key . offset - btrfs_block_group_used ( & block_group -> item ) ; block_group -> space_info -> bytes_used += bytes_used >> 1 ; spin_unlock ( & block_group -> lock ) ; spin_unlock ( & block_group -> space_info -> lock ) ; fragment_free_space ( block_group ) ; } # endif caching_ctl -> progress = ( u64 ) - 1 ; up_read ( & fs_info -> commit_root_sem ) ; free_excluded_extents ( fs_info , block_group ) ; mutex_unlock ( & caching_ctl -> mutex ) ; wake_up ( & caching_ctl -> wait ) ; put_caching_control ( caching_ctl ) ; btrfs_put_block_group ( block_group ) ; }
|
<S2SV_ModStart> * caching_ctl ; <S2SV_ModEnd> int ret ; <S2SV_ModStart> block_group -> fs_info <S2SV_ModEnd> ; mutex_lock (
|
7,671 |
CWE-000 void btm_sec_dev_rec_cback_event ( tBTM_SEC_DEV_REC * p_dev_rec , UINT8 res , BOOLEAN is_le_transport ) { <S2SV_StartBug> tBTM_SEC_CALLBACK * p_callback = p_dev_rec -> p_callback ; <S2SV_EndBug> if ( p_dev_rec -> p_callback ) { p_dev_rec -> p_callback = NULL ; # if BLE_INCLUDED == TRUE if ( is_le_transport ) ( * p_callback ) ( p_dev_rec -> ble . pseudo_addr , BT_TRANSPORT_LE , p_dev_rec -> p_ref_data , res ) ; else # endif ( * p_callback ) ( p_dev_rec -> bd_addr , BT_TRANSPORT_BR_EDR , p_dev_rec -> p_ref_data , res ) ; } btm_sec_check_pending_reqs ( ) ; }
|
<S2SV_ModStart> p_dev_rec -> p_callback ; BTM_TRACE_DEBUG ( "%s<S2SV_blank>" , __func__ )
|
7,672 |
CWE-000 static inline struct search * search_alloc ( struct bio * bio , struct bcache_device * d ) { struct search * s ; s = mempool_alloc ( d -> c -> search , GFP_NOIO ) ; closure_init ( & s -> cl , NULL ) ; do_bio_hook ( s , bio ) ; s -> orig_bio = bio ; <S2SV_StartBug> s -> cache_miss = NULL ; <S2SV_EndBug> s -> d = d ; s -> recoverable = 1 ; s -> write = ( bio -> bi_rw & REQ_WRITE ) != 0 ; s -> read_dirty_data = 0 ; s -> start_time = jiffies ; s -> iop . c = d -> c ; s -> iop . bio = NULL ; s -> iop . inode = d -> id ; s -> iop . write_point = hash_long ( ( unsigned long ) current , 16 ) ; s -> iop . write_prio = 0 ; s -> iop . error = 0 ; s -> iop . flags = 0 ; s -> iop . flush_journal = ( bio -> bi_rw & ( REQ_FLUSH | REQ_FUA ) ) != 0 ; s -> iop . wq = bcache_wq ; return s ; }
|
<S2SV_ModStart> cache_miss = NULL ; s -> cache_missed = 0
|
7,673 |
CWE-000 void b43_rx ( struct b43_wldev * dev , struct sk_buff * skb , const void * _rxhdr ) { struct ieee80211_rx_status status ; struct b43_plcp_hdr6 * plcp ; struct ieee80211_hdr * wlhdr ; const struct b43_rxhdr_fw4 * rxhdr = _rxhdr ; __le16 fctl ; u16 phystat0 , phystat3 ; u16 uninitialized_var ( chanstat ) , uninitialized_var ( mactime ) ; u32 uninitialized_var ( macstat ) ; u16 chanid ; u16 phytype ; int padding , rate_idx ; memset ( & status , 0 , sizeof ( status ) ) ; phystat0 = le16_to_cpu ( rxhdr -> phy_status0 ) ; phystat3 = le16_to_cpu ( rxhdr -> phy_status3 ) ; switch ( dev -> fw . hdr_format ) { case B43_FW_HDR_598 : macstat = le32_to_cpu ( rxhdr -> format_598 . mac_status ) ; mactime = le16_to_cpu ( rxhdr -> format_598 . mac_time ) ; chanstat = le16_to_cpu ( rxhdr -> format_598 . channel ) ; break ; case B43_FW_HDR_410 : case B43_FW_HDR_351 : macstat = le32_to_cpu ( rxhdr -> format_351 . mac_status ) ; mactime = le16_to_cpu ( rxhdr -> format_351 . mac_time ) ; chanstat = le16_to_cpu ( rxhdr -> format_351 . channel ) ; break ; } phytype = chanstat & B43_RX_CHAN_PHYTYPE ; if ( unlikely ( macstat & B43_RX_MAC_FCSERR ) ) { dev -> wl -> ieee_stats . dot11FCSErrorCount ++ ; status . flag |= RX_FLAG_FAILED_FCS_CRC ; } if ( unlikely ( phystat0 & ( B43_RX_PHYST0_PLCPHCF | B43_RX_PHYST0_PLCPFV ) ) ) status . flag |= RX_FLAG_FAILED_PLCP_CRC ; if ( phystat0 & B43_RX_PHYST0_SHORTPRMBL ) status . flag |= RX_FLAG_SHORTPRE ; if ( macstat & B43_RX_MAC_DECERR ) { goto drop ; } padding = ( macstat & B43_RX_MAC_PADDING ) ? 2 : 0 ; if ( unlikely ( skb -> len < ( sizeof ( struct b43_plcp_hdr6 ) + padding ) ) ) { b43dbg ( dev -> wl , "RX:<S2SV_blank>Packet<S2SV_blank>size<S2SV_blank>underrun<S2SV_blank>(1)\\n" ) ; goto drop ; } plcp = ( struct b43_plcp_hdr6 * ) ( skb -> data + padding ) ; skb_pull ( skb , sizeof ( struct b43_plcp_hdr6 ) + padding ) ; if ( unlikely ( skb -> len < ( 2 + 2 + 6 + FCS_LEN ) ) ) { b43dbg ( dev -> wl , "RX:<S2SV_blank>Packet<S2SV_blank>size<S2SV_blank>underrun<S2SV_blank>(2)\\n" ) ; goto drop ; } wlhdr = ( struct ieee80211_hdr * ) ( skb -> data ) ; fctl = wlhdr -> frame_control ; if ( macstat & B43_RX_MAC_DEC ) { unsigned int keyidx ; int wlhdr_len ; keyidx = ( ( macstat & B43_RX_MAC_KEYIDX ) >> B43_RX_MAC_KEYIDX_SHIFT ) ; keyidx = b43_kidx_to_raw ( dev , keyidx ) ; B43_WARN_ON ( keyidx >= ARRAY_SIZE ( dev -> key ) ) ; if ( dev -> key [ keyidx ] . algorithm != B43_SEC_ALGO_NONE ) { wlhdr_len = ieee80211_hdrlen ( fctl ) ; if ( unlikely ( skb -> len < ( wlhdr_len + 3 ) ) ) { b43dbg ( dev -> wl , "RX:<S2SV_blank>Packet<S2SV_blank>size<S2SV_blank>underrun<S2SV_blank>(3)\\n" ) ; goto drop ; } status . flag |= RX_FLAG_DECRYPTED ; } } switch ( chanstat & B43_RX_CHAN_PHYTYPE ) { case B43_PHYTYPE_HT : status . signal = max_t ( __s8 , max ( rxhdr -> phy_ht_power0 , rxhdr -> phy_ht_power1 ) , rxhdr -> phy_ht_power2 ) ; break ; case B43_PHYTYPE_N : if ( rxhdr -> power0 == 16 || rxhdr -> power0 == 32 ) status . signal = max ( rxhdr -> power1 , rxhdr -> power2 ) ; else status . signal = max ( rxhdr -> power0 , rxhdr -> power1 ) ; break ; case B43_PHYTYPE_A : case B43_PHYTYPE_B : case B43_PHYTYPE_G : case B43_PHYTYPE_LP : status . signal = b43_rssi_postprocess ( dev , rxhdr -> jssi , ( phystat0 & B43_RX_PHYST0_OFDM ) , ( phystat0 & B43_RX_PHYST0_GAINCTL ) , ( phystat3 & B43_RX_PHYST3_TRSTATE ) ) ; break ; } if ( phystat0 & B43_RX_PHYST0_OFDM ) rate_idx = b43_plcp_get_bitrate_idx_ofdm ( plcp , phytype == B43_PHYTYPE_A ) ; else rate_idx = b43_plcp_get_bitrate_idx_cck ( plcp ) ; if ( unlikely ( rate_idx == - 1 ) ) { if ( ! ( dev -> wl -> filter_flags & FIF_PLCPFAIL ) ) goto drop ; } status . rate_idx = rate_idx ; status . antenna = ! ! ( phystat0 & B43_RX_PHYST0_ANT ) ; if ( ieee80211_is_beacon ( fctl ) || dev -> wl -> radiotap_enabled ) { u16 low_mactime_now ; b43_tsf_read ( dev , & status . mactime ) ; low_mactime_now = status . mactime ; status . mactime = status . mactime & ~ 0xFFFFULL ; status . mactime += mactime ; if ( low_mactime_now <= mactime ) status . mactime -= 0x10000 ; status . flag |= RX_FLAG_MACTIME_START ; } chanid = ( chanstat & B43_RX_CHAN_ID ) >> B43_RX_CHAN_ID_SHIFT ; switch ( chanstat & B43_RX_CHAN_PHYTYPE ) { case B43_PHYTYPE_A : status . band = IEEE80211_BAND_5GHZ ; B43_WARN_ON ( 1 ) ; status . freq = b43_channel_to_freq_5ghz ( chanid ) ; break ; case B43_PHYTYPE_G : status . band = IEEE80211_BAND_2GHZ ; status . freq = chanid + 2400 ; break ; case B43_PHYTYPE_N : case B43_PHYTYPE_LP : case B43_PHYTYPE_HT : if ( chanstat & B43_RX_CHAN_5GHZ ) { status . band = IEEE80211_BAND_5GHZ ; <S2SV_StartBug> status . freq = b43_freq_to_channel_5ghz ( chanid ) ; <S2SV_EndBug> } else { status . band = IEEE80211_BAND_2GHZ ; <S2SV_StartBug> status . freq = b43_freq_to_channel_2ghz ( chanid ) ; <S2SV_EndBug> } break ; default : B43_WARN_ON ( 1 ) ; goto drop ; } memcpy ( IEEE80211_SKB_RXCB ( skb ) , & status , sizeof ( status ) ) ; ieee80211_rx_ni ( dev -> wl -> hw , skb ) ; # if B43_DEBUG dev -> rx_count ++ ; # endif return ; drop : dev_kfree_skb_any ( skb ) ; }
|
<S2SV_ModStart> . freq = b43_channel_to_freq_5ghz <S2SV_ModEnd> ( chanid ) <S2SV_ModStart> . freq = b43_channel_to_freq_2ghz <S2SV_ModEnd> ( chanid )
|
7,674 |
CWE-000 int gpio_change_direction ( gpio_st * g , gpio_direction_en dir ) { char buf [ 128 ] ; char * val ; int fd = - 1 ; int rc = 0 ; snprintf ( buf , sizeof ( buf ) , "/sys/class/gpio/gpio%u/direction" , g -> gs_gpio ) ; fd = open ( buf , O_WRONLY ) ; if ( fd == - 1 ) { rc = errno ; LOG_ERR ( rc , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>%s" , buf ) ; return - rc ; } val = ( dir == GPIO_DIRECTION_IN ) ? "in" : "out" ; write ( fd , val , strlen ( val ) ) ; LOG_VER ( "change<S2SV_blank>gpio=%d<S2SV_blank>direction=%s" , g -> gs_gpio , val ) ; <S2SV_StartBug> out : <S2SV_EndBug> if ( fd != - 1 ) { close ( fd ) ; } return - rc ; }
|
<S2SV_ModStart> val ) ; <S2SV_ModEnd> if ( fd
|
7,675 |
CWE-000 <S2SV_StartBug> DEFUN ( set_ipv6_nexthop_global , <S2SV_EndBug> set_ipv6_nexthop_global_cmd , "set<S2SV_blank>ipv6<S2SV_blank>next-hop<S2SV_blank>global<S2SV_blank>X:X::X:X" , SET_STR IPV6_STR "IPv6<S2SV_blank>next-hop<S2SV_blank>address\\n" <S2SV_StartBug> "IPv6<S2SV_blank>global<S2SV_blank>address\\n" <S2SV_EndBug> "IPv6<S2SV_blank>address<S2SV_blank>of<S2SV_blank>next<S2SV_blank>hop\\n" ) { int idx_ipv6 = 4 ; struct in6_addr addr ; int ret ; ret = inet_pton ( AF_INET6 , argv [ idx_ipv6 ] -> arg , & addr ) ; if ( ! ret ) { vty_out ( vty , "%%<S2SV_blank>Malformed<S2SV_blank>nexthop<S2SV_blank>address%s" , VTY_NEWLINE ) ; return CMD_WARNING ; } if ( IN6_IS_ADDR_UNSPECIFIED ( & addr ) || IN6_IS_ADDR_LOOPBACK ( & addr ) || IN6_IS_ADDR_MULTICAST ( & addr ) || IN6_IS_ADDR_LINKLOCAL ( & addr ) ) { vty_out ( vty , "%%<S2SV_blank>Invalid<S2SV_blank>global<S2SV_blank>nexthop<S2SV_blank>address%s" , VTY_NEWLINE ) ; return CMD_WARNING ; } return generic_set_add ( vty , VTY_GET_CONTEXT ( route_map_index ) , <S2SV_StartBug> "ipv6<S2SV_blank>next-hop<S2SV_blank>global" , argv [ idx_ipv6 ] -> arg ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> <S2SV_null> DEFUN ( no_set_ipv6_nexthop_prefer_global , no_set_ipv6_nexthop_prefer_global_cmd , "no<S2SV_blank>set<S2SV_blank>ipv6<S2SV_blank>next-hop<S2SV_blank>prefer-global" , NO_STR <S2SV_ModEnd> SET_STR IPV6_STR "IPv6<S2SV_blank>next-hop<S2SV_blank>address\\n" <S2SV_ModStart> SET_STR IPV6_STR "IPv6<S2SV_blank>next-hop<S2SV_blank>address\\n" "Prefer<S2SV_blank>global<S2SV_blank>over<S2SV_blank>link-local<S2SV_blank>if<S2SV_blank>both<S2SV_blank>exist\\n" ) { return generic_set_delete <S2SV_ModEnd> ( vty , <S2SV_ModStart> route_map_index ) , "ipv6<S2SV_blank>next-hop<S2SV_blank>prefer-global" , NULL <S2SV_ModEnd> ) ; }
|
7,676 |
CWE-000 <S2SV_StartBug> FILE * get_opened_file ( char * file_name , const char * in_modes ) { <S2SV_EndBug> FILE * file = NULL ; char * full_name = get_full_file_name ( file_name ) ; if ( NULL == ( file = fopen ( full_name , in_modes ) ) ) { printf ( "Can\'t<S2SV_blank>open<S2SV_blank>file<S2SV_blank>with<S2SV_blank>name<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s<S2SV_blank>mode.\\n" , full_name , in_modes ) ; return NULL ; } return file ; }
|
<S2SV_ModStart> * get_opened_file ( const
|
7,677 |
CWE-000 int main ( int argc , char * * argv ) { int num_procs , num_local ; nd total_cities = 0 ; nd * min_circuit = NULL ; nd total_threads_available = 1 ; MPI_Init ( & argc , & argv ) ; MPI_Comm_size ( MPI_COMM_WORLD , & num_procs ) ; MPI_Comm_rank ( MPI_COMM_WORLD , & num_local ) ; if ( num_local == master ) printf ( "Parallel<S2SV_blank>ranks=%d\\n" , num_procs ) ; srand ( 0 ) ; if ( num_local == master && argc < 2 ) { fprintf ( stderr , "Provide<S2SV_blank>input<S2SV_blank>file\\n" ) ; return 0 ; } if ( num_local == master ) { if ( readGraph ( argv [ 1 ] , & total_cities ) == EAGAIN ) return EINVAL ; } MPI_Bcast ( & total_cities , 1 , MPI_LONG_LONG , master , MPI_COMM_WORLD ) ; if ( num_local != master ) { G = ( double * * ) malloc ( 2 * sizeof ( double * ) ) ; for ( nd i = 0 ; i < 2 ; i ++ ) G [ i ] = ( double * ) malloc ( sizeof ( double ) * ( total_cities + 1 ) ) ; } MPI_Barrier ( MPI_COMM_WORLD ) ; MPI_Bcast ( & G [ 0 ] [ 0 ] , total_cities + 1 , MPI_DOUBLE , 0 , MPI_COMM_WORLD ) ; MPI_Bcast ( & G [ 1 ] [ 0 ] , total_cities + 1 , MPI_DOUBLE , 0 , MPI_COMM_WORLD ) ; MPI_Barrier ( MPI_COMM_WORLD ) ; if ( argc > 2 ) omp_set_num_threads ( atoi ( argv [ 2 ] ) ) ; double stime = 0 ; if ( num_local == master ) stime = omp_get_wtime ( ) ; # pragma omp parallel { total_threads_available = omp_get_num_threads ( ) ; } printf ( "%d:<S2SV_blank>Threads<S2SV_blank>spawn:<S2SV_blank>%ld\\n" , num_local , total_threads_available ) ; if ( num_local == master ) { omp_set_num_threads ( 8 ) ; min_circuit = VNN ( G , total_cities , 0 ) ; printf ( "Tour<S2SV_blank>length<S2SV_blank>after<S2SV_blank>VNN<S2SV_blank>:<S2SV_blank>%lf\\n" , find_tour_length ( G , min_circuit , total_cities ) ) ; omp_set_num_threads ( total_threads_available ) ; } else { min_circuit = ( nd * ) malloc ( sizeof ( nd ) * total_cities ) ; } char mach_name [ 100 ] ; int mach_len ; MPI_Get_processor_name ( mach_name , & mach_len ) ; printf ( "%d:%s\\n" , num_local , mach_name ) ; <S2SV_StartBug> MPI_Bcast ( min_circuit , total_cities , MPI_LONG_LONG , 0 , MPI_COMM_WORLD ) ; <S2SV_EndBug> # ifdef DEBUG if ( num_local == master ) printf ( "Broadcasted<S2SV_blank>Min_circuit<S2SV_blank>id=%d\\n" , num_local ) ; # endif MPI_Barrier ( MPI_COMM_WORLD ) ; if ( num_local != master ) { two_opt_max_swap ( G , min_circuit , total_cities , num_procs , num_local ) ; } else { nd counter = 0 ; double tour_length ; counter += two_opt_max_swap ( G , min_circuit , total_cities , num_procs , num_local ) ; tour_length = find_tour_length ( G , min_circuit , total_cities ) ; printf ( "Hills<S2SV_blank>climbed<S2SV_blank>=<S2SV_blank>%ld\\n" , counter ) ; printf ( "Min<S2SV_blank>distance<S2SV_blank>=<S2SV_blank>%lf\\n" , tour_length ) ; printf ( "Time<S2SV_blank>taken<S2SV_blank>=<S2SV_blank>%lf\\n" , omp_get_wtime ( ) - stime ) ; # ifdef DEBUG print_tour ( G , min_circuit , total_cities ) ; # endif } MPI_Finalize ( ) ; free ( min_circuit ) ; free ( G [ 0 ] ) ; free ( G [ 1 ] ) ; return 0 ; }
|
<S2SV_ModStart> min_circuit , total_cities + 1
|
7,678 |
CWE-000 void HU_Ticker ( void ) { int i , rc ; <S2SV_StartBug> char c ; <S2SV_EndBug> if ( message_counter && ! -- message_counter ) { message_on = false ; message_nottobefuckedwith = false ; } if ( showMessages || message_dontfuckwithme ) <S2SV_StartBug> { <S2SV_EndBug> if ( ( plr -> message && ! message_nottobefuckedwith ) || ( plr -> message && message_dontfuckwithme ) ) { HUlib_addMessageToSText ( & w_message , 0 , plr -> message ) ; plr -> message = 0 ; message_on = true ; message_counter = HU_MSGTIMEOUT ; message_nottobefuckedwith = message_dontfuckwithme ; message_dontfuckwithme = 0 ; } } if ( netgame ) { for ( i = 0 ; i < MAXPLAYERS ; i ++ ) { if ( ! playeringame [ i ] ) continue ; if ( i != consoleplayer && ( c = players [ i ] . cmd . chatchar ) ) { if ( c <= HU_BROADCAST ) { chat_dest [ i ] = c ; } else { rc = HUlib_keyInIText ( & w_inputbuffer [ i ] , c ) ; if ( rc && c == KEY_ENTER ) { if ( w_inputbuffer [ i ] . l . len && ( chat_dest [ i ] == consoleplayer + 1 || chat_dest [ i ] == HU_BROADCAST ) ) { HUlib_addMessageToSText ( & w_message , DEH_String ( player_names [ i ] ) , w_inputbuffer [ i ] . l . l ) ; message_nottobefuckedwith = true ; message_on = true ; message_counter = HU_MSGTIMEOUT ; if ( gamemode == commercial ) S_StartSound ( 0 , sfx_radio ) ; else S_StartSound ( 0 , sfx_tink ) ; } HUlib_resetIText ( & w_inputbuffer [ i ] ) ; } } players [ i ] . cmd . chatchar = 0 ; } } } }
|
<S2SV_ModStart> ; char c ; time_t t = time ( NULL ) ; struct tm * tm = localtime ( & t ) ; static char s [ 64 ] ; strftime ( s , sizeof ( s ) , "%H:%M" , tm ) ; if ( local_time ) plr -> message_time = ( s ) <S2SV_ModStart> message_dontfuckwithme ) { if ( plr -> message_time ) { HUlib_addMessageToSText ( & w_message_time , 0 , plr -> message_time ) ; plr -> message_time = 0 ; message_on_time = true ; }
|
7,679 |
CWE-000 <S2SV_StartBug> signed char getParamById ( unsigned char id ) { <S2SV_EndBug> if ( id < 10 ) { return paramCache [ id ] ; } return - 1 ; }
|
<S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int <S2SV_ModEnd> getParamById ( unsigned
|
7,680 |
CWE-000 Matrix multMatrix ( Matrix * m1 , Matrix * m2 ) { double * result = malloc ( m1 -> nbL * m2 -> nbC * sizeof ( double ) ) ; Matrix m3 = createMatrix ( result , m1 -> nbL , m2 -> nbC ) ; for ( int i = 0 ; i < m1 -> nbL ; i ++ ) { for ( int j = 0 ; j < m2 -> nbC ; j ++ ) { double sum = 0 ; for ( int k = 0 ; k < m1 -> nbL ; k ++ ) { <S2SV_StartBug> sum += m1 -> data [ i ] [ k ] * m2 -> data [ k ] [ j ] ; <S2SV_EndBug> } <S2SV_StartBug> m3 -> data [ i ] [ j ] = sum ; <S2SV_EndBug> } } return m3 ; }
|
<S2SV_ModStart> data [ i + <S2SV_ModEnd> k ] * <S2SV_ModStart> data [ k + <S2SV_ModEnd> j ] ; <S2SV_ModStart> ; } m3 . <S2SV_ModEnd> data [ i <S2SV_ModStart> data [ i + <S2SV_ModEnd> j ] =
|
7,681 |
CWE-000 DF2 ( jtdbunquote ) { A t , z ; B b = 0 , s ; DC d ; I i ; V * sv ; sv = VAV ( self ) ; t = sv -> f ; RZ ( d = deba ( DCCALL , a , w , self , 0L ) ) ; if ( CCOLON == sv -> id && t && NOUN & AT ( t ) ) { <S2SV_StartBug> ra ( self ) ; z = a ? dfs2 ( a , w , self ) : dfs1 ( w , self ) ; fa ( self ) ; <S2SV_EndBug> } else { i = 0 ; d -> dci = ( I ) & i ; while ( 0 == i ) { if ( s = dbstop ( d , 0L ) ) { z = 0 ; jsignal ( EVSTOP ) ; } <S2SV_StartBug> else { ra ( self ) ; z = a ? dfs2 ( a , w , self ) : dfs1 ( w , self ) ; fa ( self ) ; } <S2SV_EndBug> if ( ! z && jt -> db && ( s || DBTRY != jt -> db ) ) { d -> dcj = jt -> jerr ; z = debug ( ) ; if ( self != jt -> sitop -> dcf ) self = jt -> sitop -> dcf ; } if ( b ) { fa ( a ) ; fa ( w ) ; } if ( b = jt -> dbalpha || jt -> dbomega ) { a = jt -> dbalpha ; w = jt -> dbomega ; jt -> dbalpha = jt -> dbomega = 0 ; } ++ i ; } } if ( d -> dcss ) ssnext ( d , d -> dcss ) ; if ( jt -> dbss == SSSTEPINTOs ) jt -> dbss = 0 ; debz ( ) ; R z ; }
|
<S2SV_ModStart> ) ) { ras <S2SV_ModEnd> ( self ) <S2SV_ModStart> } else { ras <S2SV_ModEnd> ( self )
|
7,682 |
CWE-000 static void via_tmds_prepare ( struct drm_encoder * encoder ) { struct via_encoder * enc = container_of ( encoder , struct via_encoder , base ) ; struct via_device * dev_priv = encoder -> dev -> dev_private ; <S2SV_StartBug> DRM_DEBUG_KMS ( "Entered<S2SV_blank>%s." , __func__ ) ; <S2SV_EndBug> via_tmds_power ( dev_priv , false ) ; via_tmds_io_pad_setting ( dev_priv , enc -> di_port , false ) ; DRM_DEBUG_KMS ( "Exiting<S2SV_blank>%s.\\n" , __func__ ) ; }
|
<S2SV_ModStart> ; DRM_DEBUG_KMS ( "Entered<S2SV_blank>%s.\\n" <S2SV_ModEnd> , __func__ )
|
7,683 |
CWE-000 void ixl_stop_locked ( struct ixl_pf * pf ) { struct ixl_vsi * vsi = & pf -> vsi ; struct ifnet * ifp = vsi -> ifp ; INIT_DEBUGOUT ( "ixl_stop:<S2SV_blank>begin\\n" ) ; IXL_PF_LOCK_ASSERT ( pf ) ; # ifdef IXL_IW if ( ixl_enable_iwarp && pf -> iw_enabled ) ixl_iw_pf_stop ( pf ) ; # endif callout_stop ( & pf -> timer ) ; ixl_disable_rings_intr ( vsi ) ; ixl_disable_rings ( vsi ) ; <S2SV_StartBug> ifp -> if_drv_flags &= ~ ( IFF_DRV_RUNNING ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> vsi ) ; ixl_qflush ( ifp ) ;
|
7,684 |
CWE-000 static void handle_ass_fail ( struct gsm_subscriber_connection * conn , struct msgb * msg ) { struct bsc_api * api = conn -> network -> bsc_api ; uint8_t * rr_failure ; struct gsm48_hdr * gh ; if ( conn -> lchan != msg -> lchan ) { LOGP ( DMSC , LOGL_ERROR , "Assignment<S2SV_blank>failure<S2SV_blank>should<S2SV_blank>occur<S2SV_blank>on<S2SV_blank>primary<S2SV_blank>lchan.\\n" ) ; return ; } osmo_timer_del ( & conn -> T10 ) ; <S2SV_StartBug> lchan_release ( conn -> secondary_lchan , 0 , RSL_REL_LOCAL_END ) ; <S2SV_EndBug> <S2SV_StartBug> conn -> secondary_lchan = NULL ; <S2SV_EndBug> gh = msgb_l3 ( msg ) ; if ( msgb_l3len ( msg ) - sizeof ( * gh ) != 1 ) { LOGP ( DMSC , LOGL_ERROR , "assignment<S2SV_blank>failure<S2SV_blank>unhandled:<S2SV_blank>%zu\\n" , msgb_l3len ( msg ) - sizeof ( * gh ) ) ; rr_failure = NULL ; } else { rr_failure = & gh -> data [ 0 ] ; } api -> assign_fail ( conn , GSM0808_CAUSE_RADIO_INTERFACE_MESSAGE_FAILURE , rr_failure ) ; }
|
<S2SV_ModStart> T10 ) ; if ( conn -> secondary_lchan ) { <S2SV_ModStart> = NULL ; }
|
7,685 |
CWE-000 static int query_memdev ( Object * obj , void * opaque ) { MemdevList * * list = opaque ; MemdevList * m = NULL ; if ( object_dynamic_cast ( obj , TYPE_MEMORY_BACKEND ) ) { m = g_malloc0 ( sizeof ( * m ) ) ; m -> value = g_malloc0 ( sizeof ( * m -> value ) ) ; <S2SV_StartBug> m -> value -> size = object_property_get_int ( obj , "size" , <S2SV_EndBug> & error_abort ) ; m -> value -> merge = object_property_get_bool ( obj , "merge" , & error_abort ) ; m -> value -> dump = object_property_get_bool ( obj , "dump" , & error_abort ) ; m -> value -> prealloc = object_property_get_bool ( obj , "prealloc" , & error_abort ) ; m -> value -> policy = object_property_get_enum ( obj , "policy" , "HostMemPolicy" , & error_abort ) ; object_property_get_uint16List ( obj , "host-nodes" , & m -> value -> host_nodes , & error_abort ) ; m -> next = * list ; * list = m ; } return 0 ; }
|
<S2SV_ModStart> -> value -> id = object_property_get_str ( obj , "id" , NULL ) ; m -> value -> has_id = ! ! m -> value -> id ; m -> value ->
|
7,686 |
CWE-000 void updateClients ( Job_t * job ) { static int updateCount = 0 ; list_t * c ; list_for_each ( c , & clientList ) { Client_t * client = list_entry ( c , Client_t , next ) ; if ( ! client -> doAccounting ) continue ; if ( ! job || client -> job == job ) updateClntData ( client ) ; } if ( globalCollectMode ) { int forwInterval = getConfValueI ( & config , "FORWARD_INTERVAL" ) ; <S2SV_StartBug> if ( ++ updateCount >= forwInterval ) { <S2SV_EndBug> <S2SV_StartBug> forwardAggData ( ) ; <S2SV_EndBug> updateCount = 0 ; } } }
|
<S2SV_ModStart> ; if ( job ) { forwardJobData ( job , false ) ; } else if ( <S2SV_ModStart> forwInterval ) { forwardAllData <S2SV_ModEnd> ( ) ;
|
7,687 |
CWE-000 void write_char ( unsigned char letter ) { <S2SV_StartBug> RS = 1 ; <S2SV_EndBug> <S2SV_StartBug> write_byte = letter ; <S2SV_EndBug> E = 0 ; us_delay ( 1 ) ; <S2SV_StartBug> E = 1 ; <S2SV_EndBug> }
|
<S2SV_ModStart> letter ) { write_byte = letter ; <S2SV_ModStart> = 1 ; E = 1 ; us_delay ( 1 ) <S2SV_ModEnd> ; us_delay ( <S2SV_ModStart> ; E = 0 <S2SV_ModEnd> ; } <S2SV_null>
|
7,688 |
CWE-000 static void init ( void ) { long number ; struct fat16_dir_t dir ; struct fat16_dir_entry_t entry ; struct song_t * song_p ; uint32_t seconds ; fat16_read_t read ; fat16_write_t write ; void * arg_p ; sys_start ( ) ; uart_module_init ( ) ; uart_init ( & uart , & uart_device [ 0 ] , 38400 , qinbuf , sizeof ( qinbuf ) ) ; uart_start ( & uart ) ; <S2SV_StartBug> sys_set_stdout ( & uart . chout ) ; <S2SV_EndBug> std_printf ( sys_get_info ( ) ) ; fs_command_init ( & cmd_list , CSTR ( "/list" ) , cmd_list_cb , NULL ) ; fs_command_register ( & cmd_list ) ; fs_command_init ( & cmd_play , CSTR ( "/play" ) , cmd_play_cb , NULL ) ; fs_command_register ( & cmd_play ) ; fs_command_init ( & cmd_pause , CSTR ( "/pause" ) , cmd_pause_cb , NULL ) ; fs_command_register ( & cmd_pause ) ; fs_command_init ( & cmd_next , CSTR ( "/next" ) , cmd_next_cb , NULL ) ; fs_command_register ( & cmd_next ) ; fs_command_init ( & cmd_prev , CSTR ( "/prev" ) , cmd_prev_cb , NULL ) ; fs_command_register ( & cmd_prev ) ; fs_command_init ( & cmd_stop , CSTR ( "/stop" ) , cmd_stop_cb , NULL ) ; fs_command_register ( & cmd_stop ) ; fs_command_init ( & cmd_repeat , CSTR ( "/repeat" ) , cmd_repeat_cb , NULL ) ; fs_command_register ( & cmd_repeat ) ; fs_command_init ( & cmd_set_bits_per_sample , CSTR ( "/set_bits_per_sample" ) , cmd_set_bits_per_sample_cb , NULL ) ; fs_command_register ( & cmd_set_bits_per_sample ) ; if ( storage_init ( & read , & write , & arg_p ) != 0 ) { std_printf ( FSTR ( "storage<S2SV_blank>init<S2SV_blank>failed\\r\\n" ) ) ; return ; } std_printf ( FSTR ( "initializing<S2SV_blank>fat16\\r\\n" ) ) ; fat16_init ( & fs , read , write , arg_p , 0 ) ; std_printf ( FSTR ( "fat16<S2SV_blank>initialized\\r\\n" ) ) ; if ( fat16_mount ( & fs ) != 0 ) { std_printf ( FSTR ( "failed<S2SV_blank>to<S2SV_blank>mount<S2SV_blank>fat16\\r\\n" ) ) ; return ; } std_printf ( FSTR ( "fat16<S2SV_blank>mounted\\r\\n" ) ) ; event_init ( & event ) ; exti_module_init ( ) ; exti_init ( & buttons [ 0 ] , & exti_d18_dev , EXTI_TRIGGER_FALLING_EDGE , on_button_play , NULL ) ; exti_start ( & buttons [ 0 ] ) ; exti_init ( & buttons [ 1 ] , & exti_d19_dev , EXTI_TRIGGER_FALLING_EDGE , on_button_prev , NULL ) ; exti_start ( & buttons [ 1 ] ) ; exti_init ( & buttons [ 2 ] , & exti_d20_dev , EXTI_TRIGGER_FALLING_EDGE , on_button_next , NULL ) ; exti_start ( & buttons [ 2 ] ) ; exti_init ( & buttons [ 3 ] , & exti_d21_dev , EXTI_TRIGGER_FALLING_EDGE , on_button_stop , NULL ) ; exti_start ( & buttons [ 3 ] ) ; dac_init ( & dac , & dac_0_dev , & pin_dac0_dev , & pin_dac1_dev , 2 * SAMPLES_PER_SOCOND ) ; hash_map_init ( & song_map , buckets , membersof ( buckets ) , entries , membersof ( entries ) , hash_number ) ; sem_init ( & sem , 0 , 1 ) ; music_player_init ( & music_player , & fs , & dac , get_current_song_path , get_next_song_path , NULL ) ; current_song = FIRST_SONG_NUMBER ; number = FIRST_SONG_NUMBER ; fat16_dir_open ( & fs , & dir , "." , O_READ ) ; while ( fat16_dir_read ( & dir , & entry ) == 1 ) { if ( number - FIRST_SONG_NUMBER == membersof ( songs ) ) { std_printf ( "Maximum<S2SV_blank>number<S2SV_blank>of<S2SV_blank>songs<S2SV_blank>already<S2SV_blank>added.<S2SV_blank>" "Skipping<S2SV_blank>the<S2SV_blank>rest<S2SV_blank>of<S2SV_blank>the<S2SV_blank>songs.\\r\\n" ) ; break ; } if ( entry . is_dir == 1 ) { continue ; } song_p = & songs [ number - FIRST_SONG_NUMBER ] ; song_p -> number = number ; strcpy ( song_p -> name , entry . name ) ; seconds = ( entry . size / 4 / SAMPLES_PER_SOCOND ) ; song_p -> minutes = ( seconds / 60 ) ; song_p -> seconds = ( seconds % 60 ) ; std_printf ( "Adding<S2SV_blank>song<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>playlist.\\r\\n" , entry . name ) ; hash_map_add ( & song_map , number , song_p ) ; number ++ ; } fat16_dir_close ( & dir ) ; last_song_number = ( number - 1 ) ; music_player_start ( & music_player ) ; }
|
<S2SV_ModStart> & uart . base . base <S2SV_ModEnd> ) ; std_printf
|
7,689 |
CWE-000 <S2SV_StartBug> static list_node_t * get_pointer_entry ( rkmalloc_heap * heap , void * ptr ) { <S2SV_EndBug> # ifndef RKMALLOC_DISABLE_MAGIC unused ( heap ) ; rkmalloc_entry * entry = ( rkmalloc_entry * ) ( ptr - sizeof ( rkmalloc_entry ) ) ; list_node_t * node = ( list_node_t * ) ( entry - sizeof ( list_node_t ) ) ; if ( entry -> magic != rkmagic ( ( uintptr_t ) ptr ) ) { <S2SV_StartBug> return NULL ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> # else spin_lock ( heap -> lock ) ; list_node_t * node = heap -> index . head ; rkmalloc_entry * entry = NULL ; while ( node != NULL ) { entry = node -> value ; if ( entry -> ptr == ptr ) { break ; } node = node -> next ; } spin_unlock ( heap -> lock ) ; <S2SV_StartBug> # endif <S2SV_EndBug> return node ; }
|
<S2SV_ModStart> void * ptr , rkmalloc_entry * * eout <S2SV_ModStart> ) ) { * eout = NULL ; <S2SV_ModStart> NULL ; } * eout = entry ; <S2SV_ModStart> lock ) ; * eout = entry ;
|
7,690 |
CWE-000 addrs_t Malloc ( size_t size ) { struct node * pointer ; struct node * look_ahead ; <S2SV_StartBug> size = size + ( 0x8 - size % 0x8 ) % 0x8 ; <S2SV_EndBug> if ( Head == NULL ) { addrs_t baseptr ; baseptr = ( addrs_t ) malloc ( size ) Head = malloc ( sizeof ( struct node ) ) ; struct node * new ; new = malloc ( sizeof ( struct node ) ) ; init_node_types_3 ( Head , baseptr - 1 , baseptr , new ) ; init_node_type_2 ( new , baseptr , baseptr + size + 1 ) ; TOTALSIZE = size ; return new -> start ; } pointer = Head ; while ( pointer != NULL ) { look_ahead = pointer -> next ; if ( look_ahead != NULL ) { <S2SV_StartBug> if ( look_ahead -> start - pointer -> end >= size ) { <S2SV_EndBug> struct node * new = malloc ( sizeof ( struct node ) ) ; <S2SV_StartBug> init_node_types_3 ( new , pointer -> end , pointer -> end + size + 1 , pointer -> next ) ; <S2SV_EndBug> pointer -> next = new ; return new -> start ; } } else if ( TOTALSIZE + Head -> end - pointer -> end >= size ) { struct node * new = malloc ( sizeof ( struct node ) ) ; <S2SV_StartBug> init_node_types_2 ( new , pointer -> end , pointer -> end + size + 1 ) ; <S2SV_EndBug> pointer -> next = new ; return new -> start ; } pointer = look_ahead ; } printf ( "NoSpaceLeftError<S2SV_blank>:<S2SV_blank>no<S2SV_blank>space<S2SV_blank>left" ) ; return ( NULL ) ; }
|
<S2SV_ModStart> ; size = ( <S2SV_ModStart> ) % 0x8 ) ; <S2SV_ModEnd> pointer = Head <S2SV_ModStart> { if ( ( uint64_t ) ( <S2SV_ModStart> look_ahead -> start ) - ( uint64_t ) ( pointer -> end ) <S2SV_ModEnd> >= size ) <S2SV_ModStart> end + size <S2SV_ModEnd> , pointer -> <S2SV_ModStart> end + size <S2SV_ModEnd> ) ; pointer
|
7,691 |
CWE-000 bool batadv_frag_skb_buffer ( struct sk_buff * * skb , struct batadv_orig_node * orig_node_src ) { struct sk_buff * skb_out = NULL ; struct hlist_head head = HLIST_HEAD_INIT ; bool ret = false ; if ( ! batadv_frag_insert_packet ( orig_node_src , * skb , & head ) ) goto out_err ; if ( hlist_empty ( & head ) ) goto out ; skb_out = batadv_frag_merge_packets ( & head ) ; if ( ! skb_out ) goto out_err ; out : <S2SV_StartBug> * skb = skb_out ; <S2SV_EndBug> ret = true ; out_err : <S2SV_StartBug> return ret ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; out : <S2SV_ModEnd> ret = true <S2SV_ModStart> ; out_err : * skb = skb_out ;
|
7,692 |
CWE-000 int nfssvc_decode_readargs ( struct svc_rqst * rqstp , __be32 * p , struct nfsd_readargs * args ) { unsigned int len ; int v ; p = decode_fh ( p , & args -> fh ) ; if ( ! p ) return 0 ; args -> offset = ntohl ( * p ++ ) ; len = args -> count = ntohl ( * p ++ ) ; <S2SV_StartBug> p ++ ; <S2SV_EndBug> len = min_t ( unsigned int , len , NFSSVC_MAXBLKSIZE_V2 ) ; v = 0 ; while ( len > 0 ) { struct page * p = * ( rqstp -> rq_next_page ++ ) ; rqstp -> rq_vec [ v ] . iov_base = page_address ( p ) ; rqstp -> rq_vec [ v ] . iov_len = min_t ( unsigned int , len , PAGE_SIZE ) ; len -= rqstp -> rq_vec [ v ] . iov_len ; v ++ ; } args -> vlen = v ; <S2SV_StartBug> return xdr_argsize_check ( rqstp , p ) ; <S2SV_EndBug> }
|
<S2SV_ModStart> ; p ++ ; if ( ! xdr_argsize_check ( rqstp , p ) ) return 0 <S2SV_ModStart> v ; return 1 <S2SV_ModEnd> ; } <S2SV_null>
|
7,693 |
CWE-000 int mcr_message_complete_callback ( http_parser * _ ) { http_context * context = ( http_context * ) _ -> data ; mcr_route ( context ) ; <S2SV_StartBug> if ( 0 != send ( * context -> sock , context -> buffer , context -> buf_len , 0 ) ) { <S2SV_EndBug> return - 1 ; } context -> complete_flag = 1 ; return 0 ; }
|
<S2SV_ModStart> ; if ( - 1 == <S2SV_ModEnd> send ( *
|
7,694 |
CWE-000 int SetMasterBlasterDataLen ( tBRM_Control_packet * MasterBlaster , tMasterBlasterOption * Option ) { tMasterBlasterOption NewValue ; <S2SV_StartBug> int LoopCount = 4 ; <S2SV_EndBug> int MaxLen = LEMode ? MB_MAX_DATALEN_LE : MB_MAX_DATALEN ; int MinLen = LEMode ? MB_MIN_DATALEN_LE : MB_MIN_DATALEN ; UNUSED ( Option ) ; while ( -- LoopCount > 0 ) { printf ( "\\n<S2SV_blank><S2SV_blank><S2SV_blank>Enter<S2SV_blank>data<S2SV_blank>length<S2SV_blank>(%d..%d):<S2SV_blank>" , MinLen , MaxLen ) ; <S2SV_StartBug> scanf ( "%d" , & NewValue . Value ) ; <S2SV_EndBug> if ( MinMaxOption ( & MasterBlaster -> testCtrl . DataLen , & NewValue , MinLen , MaxLen ) ) { return TRUE ; } else if ( LoopCount > 1 ) { printf ( "\\n<S2SV_blank><S2SV_blank><S2SV_blank>ERROR<S2SV_blank>---><S2SV_blank>Invalid<S2SV_blank>data<S2SV_blank>length.\\n" ) ; } } return FALSE ; }
|
<S2SV_ModStart> tMasterBlasterOption NewValue ; memset ( ( void * ) & NewValue , 0 , sizeof ( tMasterBlasterOption ) ) ; <S2SV_ModStart> LoopCount = 4 ; char temp [ 5 ] = { '\\0' } <S2SV_ModStart> MaxLen ) ; fgets ( ( char * ) temp , 5 , stdin ) ; <S2SV_ModEnd> NewValue . Value <S2SV_ModStart> NewValue . Value = ( int ) strtol ( temp , NULL , 16
|
7,695 |
CWE-000 static struct filenode * file_node_address_space_init ( int mode , struct filenode * pass , int address_space_num , int node_num_to_initialize ) { size_t headersize ; headersize = sizeof ( struct filenode * ) ; switch ( mode ) { case Initialize : { struct filenode * temp , * last ; char * file_node_address_space = mem [ address_space_num ] ; size_t nodesize = ( sizeof ( struct filenode ) + 256 + sizeof ( stat ) ) ; memset ( file_node_address_space , 0 , blocksize ) ; file_node_address_space += headersize ; if ( pass ) pass -> next = ( struct filenode * ) file_node_address_space ; memcpy ( mem [ address_space_num ] , & file_node_address_space , headersize ) ; last = NULL ; for ( long i = 0 ; i < node_num_to_initialize ; i ++ ) { temp = ( struct filenode * ) ( file_node_address_space + i * nodesize ) ; if ( last ) last -> next = temp ; temp -> next = NULL ; temp -> prev = last ; last = temp ; } return last ; } case Malloc : { struct filenode * pointer_to_available ; char * file_node_address_space = mem [ FileNodeAddressSpace ] ; memcpy ( & pointer_to_available , file_node_address_space , headersize ) ; <S2SV_StartBug> memcpy ( file_node_address_space , & pointer_to_available -> next , headersize ) ; <S2SV_EndBug> return pointer_to_available ; } case Free : { <S2SV_StartBug> struct filenode * pointer_to_available , * temp = pass ; <S2SV_EndBug> char * file_node_address_space = mem [ FileNodeAddressSpace ] ; memcpy ( & pointer_to_available , file_node_address_space , headersize ) ; if ( ! pass ) break ; <S2SV_StartBug> temp = pass -> next ; <S2SV_EndBug> pass -> next = pointer_to_available ; memcpy ( file_node_address_space , & pass , headersize ) ; return temp ; } break ; default : break ; } return NULL ; }
|
<S2SV_ModStart> headersize ) ; if ( ! pointer_to_available ) exit ( 1 ) ; <S2SV_ModStart> filenode * pointer_to_available <S2SV_ModEnd> ; char * <S2SV_ModStart> ) break ; pass -> next = pointer_to_available ; memcpy ( file_node_address_space , & pass , headersize ) <S2SV_ModEnd> ; } break
|
7,696 |
CWE-000 int __wt_sweep_destroy ( WT_SESSION_IMPL * session ) { WT_CONNECTION_IMPL * conn ; WT_DECL_RET ; WT_SESSION * wt_session ; conn = S2C ( session ) ; F_CLR ( conn , WT_CONN_SERVER_SWEEP ) ; if ( conn -> sweep_tid_set ) { __wt_cond_signal ( session , conn -> sweep_cond ) ; WT_TRET ( __wt_thread_join ( session , conn -> sweep_tid ) ) ; conn -> sweep_tid_set = 0 ; } <S2SV_StartBug> WT_TRET ( __wt_cond_destroy ( session , & conn -> sweep_cond ) ) ; <S2SV_EndBug> if ( conn -> sweep_session != NULL ) { wt_session = & conn -> sweep_session -> iface ; WT_TRET ( wt_session -> close ( wt_session , NULL ) ) ; conn -> sweep_session = NULL ; } __wt_buf_free ( session , & conn -> las_sweep_key ) ; return ( ret ) ; }
|
<S2SV_ModStart> 0 ; } <S2SV_ModEnd> __wt_cond_destroy ( session <S2SV_ModStart> conn -> sweep_cond <S2SV_ModEnd> ) ; if
|
7,697 |
CWE-000 void start_server ( int port ) { char users [ MAX_NUM_OF_PLAYERS ] [ MAX_USER_NAME_LENGTH ] ; SOCKET user_sockets [ MAX_NUM_OF_PLAYERS ] ; <S2SV_StartBug> char symbols [ MAX_NUM_OF_PLAYERS ] ; <S2SV_EndBug> communication_data players_communication_data [ MAX_NUM_OF_PLAYERS ] ; <S2SV_StartBug> HANDLE players_communication_thread [ MAX_NUM_OF_PLAYERS ] ; <S2SV_EndBug> <S2SV_StartBug> int num_of_threads = 0 ; <S2SV_EndBug> symbols [ 0 ] = '@' ; symbols [ 1 ] = '#' ; symbols [ 2 ] = '%' ; symbols [ 3 ] = '*' ; if ( WaitForPlayers ( port , user_sockets , users , symbols , players_communication_data , players_communication_thread ) == FALSE ) { CloseConnections ( user_sockets ) ; return ; } WriteToLogOrderOfPlayers ( user_sockets , users , symbols ) ; if ( BroadcastPlayers ( user_sockets , users , symbols ) == FALSE ) { write_log ( "Failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>players<S2SV_blank>list<S2SV_blank>to<S2SV_blank>all<S2SV_blank>players,<S2SV_blank>Error_code:<S2SV_blank>0x%x\\n" , GetLastError ( ) ) ; CloseConnections ( user_sockets ) ; return ; } while ( players_communication_thread [ num_of_threads ] != NULL ) num_of_threads ++ ; WaitForMultipleObjects ( num_of_threads , players_communication_thread , TRUE , INFINITE ) ; CloseConnections ( user_sockets ) ; }
|
<S2SV_ModStart> [ MAX_NUM_OF_PLAYERS ] = { '@' , '#' , '%' , '*' } <S2SV_ModStart> [ MAX_NUM_OF_PLAYERS ] = { NULL } <S2SV_ModStart> num_of_threads = 0 <S2SV_ModEnd> ; if (
|
7,698 |
CWE-000 void pincode_setnew ( int fd , struct char_session_data * sd ) { char newpin [ 5 ] = "\\0\\0\\0\\0" ; nullpo_retv ( sd ) ; if ( strlen ( sd -> pincode ) == 4 ) return ; safestrncpy ( newpin , RFIFOP ( fd , 6 ) , sizeof ( newpin ) ) ; pincode -> decrypt ( sd -> pincode_seed , newpin ) ; if ( pincode -> check_blacklist && pincode -> isBlacklisted ( newpin ) ) { pincode -> makestate ( fd , sd , PINCODE_MAKE_RESTRICT_PW ) ; return ; } pincode -> update ( sd -> account_id , newpin ) ; safestrncpy ( sd -> pincode , newpin , sizeof ( sd -> pincode ) ) ; pincode -> makestate ( fd , sd , PINCODE_MAKE_SUCCESS ) ; <S2SV_StartBug> } <S2SV_EndBug>
|
<S2SV_ModStart> PINCODE_MAKE_SUCCESS ) ; pincode -> loginstate ( fd , sd , PINCODE_LOGIN_ASK ) ;
|
7,699 |
CWE-000 void logpage ( int argc , char * argv [ ] ) { int fd , nsid ; int log_page = 0 , pageflag = false ; int hexflag = false , ns_specified ; char ch , * p ; char cname [ 64 ] ; uint32_t size ; void * buf ; struct logpage_function * f ; struct nvme_controller_data cdata ; print_fn_t print_fn ; while ( ( ch = getopt ( argc , argv , "p:x" ) ) != - 1 ) { switch ( ch ) { case 'p' : log_page = strtol ( optarg , & p , 0 ) ; if ( p != NULL && * p != '\\0' ) { fprintf ( stderr , "\\"%s\\"<S2SV_blank>not<S2SV_blank>valid<S2SV_blank>log<S2SV_blank>page<S2SV_blank>id.\\n" , optarg ) ; logpage_usage ( ) ; } pageflag = true ; break ; case 'x' : hexflag = true ; break ; } } if ( ! pageflag ) { printf ( "Missing<S2SV_blank>page_id<S2SV_blank>(-p).\\n" ) ; logpage_usage ( ) ; } if ( optind >= argc ) logpage_usage ( ) ; if ( strstr ( argv [ optind ] , NVME_NS_PREFIX ) != NULL ) { ns_specified = true ; parse_ns_str ( argv [ optind ] , cname , & nsid ) ; open_dev ( cname , & fd , 1 , 1 ) ; } else { ns_specified = false ; nsid = NVME_GLOBAL_NAMESPACE_TAG ; open_dev ( argv [ optind ] , & fd , 1 , 1 ) ; } read_controller_data ( fd , & cdata ) ; if ( ns_specified ) { if ( log_page != NVME_LOG_HEALTH_INFORMATION ) errx ( 1 , "log<S2SV_blank>page<S2SV_blank>%d<S2SV_blank>valid<S2SV_blank>only<S2SV_blank>at<S2SV_blank>controller<S2SV_blank>level" , log_page ) ; if ( cdata . lpa . ns_smart == 0 ) errx ( 1 , "controller<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>per<S2SV_blank>namespace<S2SV_blank>" "smart/health<S2SV_blank>information" ) ; } print_fn = print_hex ; <S2SV_StartBug> if ( ! hexflag ) { <S2SV_EndBug> f = logfuncs ; while ( f -> log_page > 0 ) { if ( log_page == f -> log_page ) { <S2SV_StartBug> print_fn = f -> fn ; <S2SV_EndBug> break ; } f ++ ; } } <S2SV_StartBug> switch ( log_page ) { <S2SV_EndBug> case NVME_LOG_ERROR : size = sizeof ( struct nvme_error_information_entry ) ; size *= ( cdata . elpe + 1 ) ; <S2SV_StartBug> break ; <S2SV_EndBug> case NVME_LOG_HEALTH_INFORMATION : size = sizeof ( struct nvme_health_information_page ) ; break ; case NVME_LOG_FIRMWARE_SLOT : size = sizeof ( struct nvme_firmware_page ) ; break ; default : size = DEFAULT_SIZE ; break ; } buf = get_log_buffer ( size ) ; read_logpage ( fd , log_page , nsid , buf , size ) ; print_fn ( buf , size ) ; close ( fd ) ; exit ( 0 ) ; }
|
<S2SV_ModStart> = print_hex ; size = DEFAULT_SIZE ; <S2SV_ModStart> = f -> print_fn ; size = f -> size <S2SV_ModEnd> ; break ; <S2SV_ModStart> ; } } if ( log_page == NVME_LOG_ERROR ) { <S2SV_ModEnd> size = sizeof <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> } buf =
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.