Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
4,400 | CWE-000 int usb_hcd_submit_urb ( struct urb * urb , gfp_t mem_flags ) { int status ; struct usb_hcd * hcd = bus_to_hcd ( urb -> dev -> bus ) ; usb_get_urb ( urb ) ; atomic_inc ( & urb -> use_count ) ; atomic_inc ( & urb -> dev -> urbnum ) ; usbmon_urb_submit ( & hcd -> self , urb ) ; <S2SV_StartBug> if ( hcd -> driver -> log_urb ) <S2SV_EndBug> hcd -> driver -> log_urb ( urb , "S" , urb -> status ) ; if ( is_root_hub ( urb -> dev ) ) { status = rh_urb_enqueue ( hcd , urb ) ; } else { status = map_urb_for_dma ( hcd , urb , mem_flags ) ; if ( likely ( status == 0 ) ) { status = hcd -> driver -> urb_enqueue ( hcd , urb , mem_flags ) ; if ( unlikely ( status ) ) unmap_urb_for_dma ( hcd , urb ) ; } } if ( unlikely ( status ) ) { usbmon_urb_submit_error ( & hcd -> self , urb , status ) ; <S2SV_StartBug> if ( hcd -> driver -> log_urb ) <S2SV_EndBug> hcd -> driver -> log_urb ( urb , "E" , status ) ; urb -> hcpriv = NULL ; INIT_LIST_HEAD ( & urb -> urb_list ) ; atomic_dec ( & urb -> use_count ) ; atomic_dec ( & urb -> dev -> urbnum ) ; if ( atomic_read ( & urb -> reject ) ) wake_up ( & usb_kill_urb_queue ) ; usb_put_urb ( urb ) ; } return status ; } | <S2SV_ModStart> ; if ( <S2SV_ModEnd> is_root_hub ( urb <S2SV_ModStart> status ) ; <S2SV_ModEnd> urb -> hcpriv |
4,401 | CWE-000 static int bnxt_init_msix ( struct bnxt * bp ) { int i , total_vecs , rc = 0 , min = 1 ; struct msix_entry * msix_ent ; total_vecs = bnxt_get_max_func_irqs ( bp ) ; msix_ent = kcalloc ( total_vecs , sizeof ( struct msix_entry ) , GFP_KERNEL ) ; if ( ! msix_ent ) return - ENOMEM ; for ( i = 0 ; i < total_vecs ; i ++ ) { msix_ent [ i ] . entry = i ; msix_ent [ i ] . vector = 0 ; } if ( ! ( bp -> flags & BNXT_FLAG_SHARED_RINGS ) ) min = 2 ; total_vecs = pci_enable_msix_range ( bp -> pdev , msix_ent , min , total_vecs ) ; if ( total_vecs < 0 ) { rc = - ENODEV ; goto msix_setup_exit ; } bp -> irq_tbl = kcalloc ( total_vecs , sizeof ( struct bnxt_irq ) , GFP_KERNEL ) ; if ( bp -> irq_tbl ) { for ( i = 0 ; i < total_vecs ; i ++ ) bp -> irq_tbl [ i ] . vector = msix_ent [ i ] . vector ; bp -> total_irqs = total_vecs ; rc = bnxt_trim_rings ( bp , & bp -> rx_nr_rings , & bp -> tx_nr_rings , total_vecs , min == 1 ) ; if ( rc ) goto msix_setup_exit ; <S2SV_StartBug> bp -> tx_nr_rings_per_tc = bp -> tx_nr_rings ; <S2SV_EndBug> bp -> cp_nr_rings = ( min == 1 ) ? max_t ( int , bp -> tx_nr_rings , bp -> rx_nr_rings ) : bp -> tx_nr_rings + bp -> rx_nr_rings ; } else { rc = - ENOMEM ; goto msix_setup_exit ; } bp -> flags |= BNXT_FLAG_USING_MSIX ; kfree ( msix_ent ) ; return 0 ; msix_setup_exit : netdev_err ( bp -> dev , "bnxt_init_msix<S2SV_blank>err:<S2SV_blank>%x\\n" , rc ) ; kfree ( bp -> irq_tbl ) ; bp -> irq_tbl = NULL ; pci_disable_msix ( bp -> pdev ) ; kfree ( msix_ent ) ; return rc ; } | <S2SV_ModStart> ; bp -> <S2SV_ModEnd> cp_nr_rings = ( |
4,402 | CWE-000 int int1e_a01gp_spinor ( double complex * out , int * dims , int * shls , int * atm , int natm , int * bas , int nbas , double * env , CINTOpt * opt , double * cache ) { int ng [ ] = { 1 , 2 , 0 , 0 , 3 , 1 , 0 , 9 } ; CINTEnvVars envs ; CINTinit_int1e_EnvVars ( & envs , ng , shls , atm , natm , bas , nbas , env ) ; envs . f_gout = & CINTgout1e_int1e_a01gp ; envs . common_factor *= 0.5 ; int i , nout ; int counts [ 4 ] ; <S2SV_StartBug> if ( envs . shls [ 0 ] == envs . shls [ 1 ] ) { <S2SV_EndBug> counts [ 0 ] = CINTcgto_spinor ( envs . shls [ 0 ] , envs . bas ) ; counts [ 1 ] = CINTcgto_spinor ( envs . shls [ 1 ] , envs . bas ) ; counts [ 2 ] = 1 ; counts [ 3 ] = 1 ; if ( dims == NULL ) { dims = counts ; } nout = dims [ 0 ] * dims [ 1 ] ; for ( i = 0 ; i < envs . ncomp_tensor ; i ++ ) { c2s_zset0 ( out + nout * i , dims , counts ) ; } return 0 ; } return CINT1e_spinor_drv ( out , dims , & envs , opt , cache , & c2s_sf_1e ) ; } | <S2SV_ModStart> ; if ( out != NULL && |
4,403 | CWE-000 static uint32_t friends_list_save ( const Messenger * m , uint8_t * data ) { uint32_t i ; uint32_t num = 0 ; uint8_t * cur_data = data ; for ( i = 0 ; i < m -> numfriends ; ++ i ) { if ( m -> friendlist [ i ] . status > 0 ) { struct Saved_Friend temp = { 0 } ; temp . status = m -> friendlist [ i ] . status ; memcpy ( temp . real_pk , m -> friendlist [ i ] . real_pk , CRYPTO_PUBLIC_KEY_SIZE ) ; if ( temp . status < 3 ) { const size_t friendrequest_length = <S2SV_StartBug> MIN ( m -> friendlist [ i ] . info_size , <S2SV_EndBug> <S2SV_StartBug> MIN ( SAVED_FRIEND_REQUEST_SIZE , MAX_FRIEND_REQUEST_DATA_SIZE ) ) ; <S2SV_EndBug> memcpy ( temp . info , m -> friendlist [ i ] . info , friendrequest_length ) ; temp . info_size = net_htons ( m -> friendlist [ i ] . info_size ) ; temp . friendrequest_nospam = m -> friendlist [ i ] . friendrequest_nospam ; } else { memcpy ( temp . name , m -> friendlist [ i ] . name , m -> friendlist [ i ] . name_length ) ; temp . name_length = net_htons ( m -> friendlist [ i ] . name_length ) ; memcpy ( temp . statusmessage , m -> friendlist [ i ] . statusmessage , m -> friendlist [ i ] . statusmessage_length ) ; temp . statusmessage_length = net_htons ( m -> friendlist [ i ] . statusmessage_length ) ; temp . userstatus = m -> friendlist [ i ] . userstatus ; uint8_t last_seen_time [ sizeof ( uint64_t ) ] ; memcpy ( last_seen_time , & m -> friendlist [ i ] . last_seen_time , sizeof ( uint64_t ) ) ; host_to_net ( last_seen_time , sizeof ( uint64_t ) ) ; memcpy ( & temp . last_seen_time , last_seen_time , sizeof ( uint64_t ) ) ; } uint8_t * next_data = friend_save ( & temp , cur_data ) ; assert ( next_data - cur_data == friend_size ( ) ) ; # ifdef __LP64__ assert ( memcmp ( cur_data , & temp , friend_size ( ) ) == 0 ) ; # endif cur_data = next_data ; ++ num ; } } assert ( cur_data - data == num * friend_size ( ) ) ; return cur_data - data ; } | <S2SV_ModStart> size_t friendrequest_length = min_u32 <S2SV_ModEnd> ( m -> <S2SV_ModStart> . info_size , min_u32 <S2SV_ModEnd> ( SAVED_FRIEND_REQUEST_SIZE , |
4,404 | CWE-000 void * MIDIInput ( ) { int err ; int i ; char buffer [ 1 ] ; int status ; const char * device_in ; char key [ ] = "My<S2SV_blank>Unique<S2SV_blank>Registry<S2SV_blank>Key<S2SV_blank>(no,<S2SV_blank>really!)" ; pthread_mutex_lock ( & myMutex ) ; lua_pushstring ( L , key ) ; MIDIstack = lua_newthread ( L ) ; lua_settable ( L , LUA_REGISTRYINDEX ) ; lua_getglobal ( MIDIstack , "AlsaMIDIDeviceID" ) ; device_in = luaL_checkstring ( MIDIstack , - 1 ) ; lua_pop ( MIDIstack , 1 ) ; lua_getglobal ( MIDIstack , "LinuxOpenSynth" ) ; lua_call ( MIDIstack , 0 , 0 ) ; pthread_mutex_unlock ( & myMutex ) ; err = snd_rawmidi_open ( & handle_in , NULL , device_in , 0 ) ; if ( err ) { printf ( "snd_rawmidi_open<S2SV_blank>%s<S2SV_blank>failed:<S2SV_blank>%d\\n" , device_in , err ) ; printf ( "Error<S2SV_blank>%i<S2SV_blank>(%s)\\n" , err , snd_strerror ( err ) ) ; return NULL ; } else { } err = snd_rawmidi_open ( NULL , & handle_out , "virtual" , SND_RAWMIDI_SYNC ) ; if ( err ) { printf ( "snd_rawmidi_open<S2SV_blank>virtual<S2SV_blank>failed:<S2SV_blank>%d\\n" , err ) ; printf ( "Error<S2SV_blank>%i<S2SV_blank>(%s)\\n" , err , snd_strerror ( err ) ) ; return NULL ; } else { } <S2SV_StartBug> for ( i = 1 ; i < 10 ; i ++ ) { <S2SV_EndBug> usleep ( 500000 ) ; pthread_mutex_lock ( & myMutex ) ; lua_getglobal ( MIDIstack , "LinuxAconnect" ) ; lua_call ( MIDIstack , 0 , 1 ) ; if ( lua_toboolean ( MIDIstack , - 1 ) ) { lua_pop ( MIDIstack , 1 ) ; pthread_mutex_unlock ( & myMutex ) ; break ; } lua_pop ( MIDIstack , 1 ) ; pthread_mutex_unlock ( & myMutex ) ; } status = 0 ; while ( ( status != EAGAIN ) && stillGoing ) { status = snd_rawmidi_read ( handle_in , buffer , 1 ) ; if ( ( status < 0 ) && ( status != - EBUSY ) && ( status != - EAGAIN ) ) { printf ( "Problem<S2SV_blank>reading<S2SV_blank>MIDI<S2SV_blank>input." ) ; } else if ( status >= 0 ) { addToBuffer ( ( unsigned char ) buffer [ 0 ] ) ; } } printf ( "Finishing<S2SV_blank>MIDI<S2SV_blank>thread.\\n" ) ; pthread_exit ( NULL ) ; return NULL ; } | <S2SV_ModStart> 1 ; i <= <S2SV_ModEnd> 10 ; i |
4,405 | CWE-000 table_type sound_to_table ( sound_type s ) { long len = snd_length ( s , max_table_len ) ; long tx = 0 ; long blocklen ; register double scale_factor = s -> scale ; sound_type original_s = s ; table_type table ; long table_bytes ; if ( s -> table ) { s -> table -> refcount ++ ; return s -> table ; } if ( len >= max_table_len ) { char emsg [ 100 ] ; <S2SV_StartBug> sprintf ( emsg , "maximum<S2SV_blank>table<S2SV_blank>size<S2SV_blank>(%d)<S2SV_blank>exceeded" , max_table_len ) ; <S2SV_EndBug> xlcerror ( "use<S2SV_blank>truncated<S2SV_blank>sound<S2SV_blank>for<S2SV_blank>table" , emsg , NIL ) ; } else if ( len == 0 ) { xlabort ( "table<S2SV_blank>size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>greater<S2SV_blank>than<S2SV_blank>0" ) ; } len ++ ; s = sound_copy ( s ) ; table_bytes = table_size_in_bytes ( len ) ; table = ( table_type ) malloc ( table_bytes ) ; if ( ! table ) xlfail ( "osc_init<S2SV_blank>couldn\'t<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>table" ) ; table_memory += table_bytes ; table -> length = ( double ) ( len - 1 ) ; while ( len > 1 ) { sample_block_type sampblock = sound_get_next ( s , & blocklen ) ; long togo = MIN ( blocklen , len ) ; long i ; sample_block_values_type sbufp = sampblock -> samples ; for ( i = 0 ; i < togo ; i ++ ) { table -> samples [ tx ++ ] = ( float ) ( * sbufp ++ * scale_factor ) ; } len -= togo ; } table -> samples [ tx ] = table -> samples [ 0 ] ; table -> refcount = 2 ; sound_unref ( s ) ; s = NULL ; original_s -> table = table ; return table ; } | <S2SV_ModStart> "maximum<S2SV_blank>table<S2SV_blank>size<S2SV_blank>(%d)<S2SV_blank>exceeded" , max_table_len - 1 |
4,406 | CWE-000 <S2SV_StartBug> RPC_OMX_ERRORTYPE RPC_SKEL_GetHandle ( uint32_t size , uint32_t * data ) <S2SV_EndBug> { return RPC_OMX_ErrorNone ; } | <S2SV_ModStart> RPC_OMX_ERRORTYPE RPC_SKEL_GetHandle ( __unused <S2SV_ModStart> uint32_t size , __unused |
4,407 | CWE-000 static bool batadv_frag_insert_packet ( struct batadv_orig_node * orig_node , struct sk_buff * skb , struct hlist_head * chain_out ) { struct batadv_frag_table_entry * chain ; <S2SV_StartBug> struct batadv_frag_list_entry * frag_entry_new = NULL , * frag_entry_curr ; <S2SV_EndBug> struct batadv_frag_packet * frag_packet ; uint8_t bucket ; uint16_t seqno , hdr_size = sizeof ( struct batadv_frag_packet ) ; bool ret = false ; if ( skb_linearize ( skb ) < 0 ) goto err ; frag_packet = ( struct batadv_frag_packet * ) skb -> data ; seqno = ntohs ( frag_packet -> seqno ) ; bucket = seqno % BATADV_FRAG_BUFFER_COUNT ; frag_entry_new = kmalloc ( sizeof ( * frag_entry_new ) , GFP_ATOMIC ) ; if ( ! frag_entry_new ) goto err ; frag_entry_new -> skb = skb ; frag_entry_new -> no = frag_packet -> no ; chain = & orig_node -> fragments [ bucket ] ; spin_lock_bh ( & chain -> lock ) ; if ( batadv_frag_init_chain ( chain , seqno ) ) { hlist_add_head ( & frag_entry_new -> list , & chain -> head ) ; chain -> size = skb -> len - hdr_size ; chain -> timestamp = jiffies ; ret = true ; goto out ; } hlist_for_each_entry ( frag_entry_curr , & chain -> head , list ) { if ( frag_entry_curr -> no == frag_entry_new -> no ) goto err_unlock ; if ( frag_entry_curr -> no < frag_entry_new -> no ) { hlist_add_before ( & frag_entry_new -> list , & frag_entry_curr -> list ) ; chain -> size += skb -> len - hdr_size ; chain -> timestamp = jiffies ; ret = true ; goto out ; } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> if ( likely ( frag_entry_curr ) ) { <S2SV_EndBug> <S2SV_StartBug> hlist_add_after ( & frag_entry_curr -> list , & frag_entry_new -> list ) ; <S2SV_EndBug> chain -> size += skb -> len - hdr_size ; chain -> timestamp = jiffies ; ret = true ; } out : if ( chain -> size > batadv_frag_size_limit ( ) || ntohs ( frag_packet -> total_size ) > batadv_frag_size_limit ( ) ) { batadv_frag_clear_chain ( & chain -> head ) ; chain -> size = 0 ; } else if ( ntohs ( frag_packet -> total_size ) == chain -> size ) { hlist_move_list ( & chain -> head , chain_out ) ; chain -> size = 0 ; } err_unlock : spin_unlock_bh ( & chain -> lock ) ; err : if ( ! ret ) kfree ( frag_entry_new ) ; return ret ; } | <S2SV_ModStart> , * frag_entry_curr ; struct batadv_frag_list_entry * frag_entry_last = NULL <S2SV_ModStart> out ; } frag_entry_last = frag_entry_curr ; <S2SV_ModStart> ( likely ( frag_entry_last <S2SV_ModEnd> ) ) { <S2SV_ModStart> hlist_add_after ( & frag_entry_last <S2SV_ModEnd> -> list , |
4,408 | CWE-000 int gnupg_digest_is_allowed ( enum gnupg_compliance_mode compliance , int producer , digest_algo_t digest ) <S2SV_StartBug> { <S2SV_EndBug> switch ( compliance ) { case CO_DE_VS : switch ( digest ) { case DIGEST_ALGO_SHA256 : case DIGEST_ALGO_SHA384 : case DIGEST_ALGO_SHA512 : return 1 ; case DIGEST_ALGO_SHA1 : case DIGEST_ALGO_SHA224 : case DIGEST_ALGO_RMD160 : return ! producer ; case DIGEST_ALGO_MD5 : return ! producer && module == GNUPG_MODULE_NAME_GPGSM ; default : return 0 ; } log_assert ( ! "reached" ) ; default : return 1 ; } log_assert ( ! "reached" ) ; } | <S2SV_ModStart> digest ) { if ( ! initialized ) return 1 ; |
4,409 | CWE-000 void ceph_file_layout_from_legacy ( struct ceph_file_layout * fl , struct ceph_file_layout_legacy * legacy ) { fl -> stripe_unit = le32_to_cpu ( legacy -> fl_stripe_unit ) ; fl -> stripe_count = le32_to_cpu ( legacy -> fl_stripe_count ) ; fl -> object_size = le32_to_cpu ( legacy -> fl_object_size ) ; fl -> pool_id = le32_to_cpu ( legacy -> fl_pg_pool ) ; <S2SV_StartBug> if ( fl -> pool_id == 0 ) <S2SV_EndBug> fl -> pool_id = - 1 ; } | <S2SV_ModStart> pool_id == 0 && fl -> stripe_unit == 0 && fl -> stripe_count == 0 && fl -> object_size == 0 |
4,410 | CWE-000 Expr * canonicalize_qual ( Expr * qual ) { <S2SV_StartBug> Expr * newqual ; <S2SV_EndBug> if ( qual == NULL ) return NULL ; newqual = find_duplicate_ors ( qual ) ; return newqual ; } | <S2SV_ModStart> qual ) { return canonicalize_qual_ext ( qual , false ) <S2SV_ModEnd> ; } <S2SV_null> |
4,411 | CWE-000 static int create_fixed_stream_quirk ( struct snd_usb_audio * chip , struct usb_interface * iface , struct usb_driver * driver , const struct snd_usb_audio_quirk * quirk ) { struct audioformat * fp ; struct usb_host_interface * alts ; int stream , err ; unsigned * rate_table = NULL ; fp = kmemdup ( quirk -> data , sizeof ( * fp ) , GFP_KERNEL ) ; if ( ! fp ) { snd_printk ( KERN_ERR "cannot<S2SV_blank>memdup\\n" ) ; return - ENOMEM ; } INIT_LIST_HEAD ( & fp -> list ) ; if ( fp -> nr_rates > MAX_NR_RATES ) { kfree ( fp ) ; return - EINVAL ; } if ( fp -> nr_rates > 0 ) { rate_table = kmemdup ( fp -> rate_table , sizeof ( int ) * fp -> nr_rates , GFP_KERNEL ) ; if ( ! rate_table ) { kfree ( fp ) ; return - ENOMEM ; } fp -> rate_table = rate_table ; } stream = ( fp -> endpoint & USB_DIR_IN ) ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK ; err = snd_usb_add_audio_stream ( chip , stream , fp ) ; if ( err < 0 ) goto error ; if ( fp -> iface != get_iface_desc ( & iface -> altsetting [ 0 ] ) -> bInterfaceNumber || fp -> altset_idx >= iface -> num_altsetting ) { err = - EINVAL ; goto error ; } alts = & iface -> altsetting [ fp -> altset_idx ] ; <S2SV_StartBug> if ( altsd -> bNumEndpoints < 1 ) { <S2SV_EndBug> <S2SV_StartBug> kfree ( fp ) ; <S2SV_EndBug> kfree ( rate_table ) ; return - EINVAL ; <S2SV_StartBug> } <S2SV_EndBug> if ( fp -> datainterval == 0 ) fp -> datainterval = snd_usb_parse_datainterval ( chip , alts ) ; if ( fp -> maxpacksize == 0 ) fp -> maxpacksize = le16_to_cpu ( get_endpoint ( alts , 0 ) -> wMaxPacketSize ) ; usb_set_interface ( chip -> dev , fp -> iface , 0 ) ; snd_usb_init_pitch ( chip , fp -> iface , alts , fp ) ; snd_usb_init_sample_rate ( chip , fp -> iface , alts , fp , fp -> rate_max ) ; return 0 ; error : list_del ( & fp -> list ) ; kfree ( fp ) ; kfree ( rate_table ) ; return err ; } | <S2SV_ModStart> ; if ( get_iface_desc ( alts ) <S2SV_ModEnd> -> bNumEndpoints < <S2SV_ModStart> 1 ) { err = <S2SV_ModEnd> - EINVAL ; <S2SV_ModStart> - EINVAL ; goto error ; |
4,412 | CWE-000 void test_multiple_alarms_instance ( const char * dev_name ) { struct device * dev ; int err ; u32_t ticks ; dev = device_get_binding ( dev_name ) ; ticks = counter_us_to_ticks ( dev , WRAP_PERIOD_US ) ; alarm_cfg . channel_id = 0 ; alarm_cfg . absolute = true ; alarm_cfg . ticks = counter_us_to_ticks ( dev , 2000 ) ; alarm_cfg . handler = alarm_handler2 ; alarm_cfg2 . channel_id = 1 ; alarm_cfg2 . absolute = false ; alarm_cfg2 . ticks = counter_us_to_ticks ( dev , 2000 ) ; alarm_cfg2 . handler = alarm_handler2 ; alarm_cnt = 0 ; err = counter_start ( dev ) ; zassert_equal ( 0 , err , "Counter<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>start\\n" ) ; err = counter_set_wrap ( dev , ticks , wrap_handler , exp_user_data ) ; zassert_equal ( 0 , err , "Counter<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>set<S2SV_blank>wrap\\n" ) ; k_busy_wait ( 1.2 * counter_ticks_to_us ( dev , alarm_cfg . ticks ) ) ; <S2SV_StartBug> err = counter_set_alarm ( dev , & alarm_cfg ) ; <S2SV_EndBug> zassert_equal ( 0 , err , "Counter<S2SV_blank>set<S2SV_blank>alarm<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> err = counter_set_alarm ( dev , & alarm_cfg2 ) ; <S2SV_EndBug> zassert_equal ( 0 , err , "Counter<S2SV_blank>set<S2SV_blank>alarm<S2SV_blank>failed\\n" ) ; k_busy_wait ( 1.2 * counter_ticks_to_us ( dev , 2 * ticks ) ) ; zassert_equal ( 2 , alarm_cnt , "Counter<S2SV_blank>set<S2SV_blank>alarm<S2SV_blank>failed\\n" ) ; zassert_equal ( & alarm_cfg2 , clbks [ 0 ] , "Expected<S2SV_blank>different<S2SV_blank>order<S2SV_blank>or<S2SV_blank>callbacks\\n" ) ; zassert_equal ( & alarm_cfg , clbks [ 1 ] , "Expected<S2SV_blank>different<S2SV_blank>order<S2SV_blank>or<S2SV_blank>callbacks\\n" ) ; <S2SV_StartBug> err = counter_disable_alarm ( dev , & alarm_cfg ) ; <S2SV_EndBug> zassert_equal ( 0 , err , "Counter<S2SV_blank>disabling<S2SV_blank>alarm<S2SV_blank>failed\\n" ) ; <S2SV_StartBug> err = counter_disable_alarm ( dev , & alarm_cfg2 ) ; <S2SV_EndBug> zassert_equal ( 0 , err , "Counter<S2SV_blank>disabling<S2SV_blank>alarm<S2SV_blank>failed\\n" ) ; } | <S2SV_ModStart> ; err = counter_set_ch_alarm <S2SV_ModEnd> ( dev , <S2SV_ModStart> ; err = counter_set_ch_alarm <S2SV_ModEnd> ( dev , <S2SV_ModStart> ; err = counter_disable_ch_alarm <S2SV_ModEnd> ( dev , <S2SV_ModStart> ; err = counter_disable_ch_alarm <S2SV_ModEnd> ( dev , |
4,413 | CWE-000 static void RemoveModifiedBuffer ( Buffer buffer , OffsetNumber xactnum ) <S2SV_StartBug> { <S2SV_EndBug> BufferXactTag * tag ; RelFileNode rnode ; ForkNumber forkNum ; BlockNumber blockNum ; <S2SV_StartBug> tag = ( BufferXactTag * ) linitial ( xact_modified_blocks ) ; <S2SV_EndBug> xact_modified_blocks = list_delete_first ( xact_modified_blocks ) ; BufferGetTag ( buffer , & rnode , & forkNum , & blockNum ) ; tag -> xactNum = xactnum ; Assert ( RelFileNodeEquals ( tag -> rnode , rnode ) ) ; Assert ( tag -> forkNum == forkNum ) ; Assert ( tag -> blockNum == blockNum ) ; Assert ( tag -> xactNum == xactnum ) ; pfree ( tag ) ; } | <S2SV_ModStart> xactnum ) { ListCell * cell ; List * list ; <S2SV_ModStart> BlockNumber blockNum ; list = xact_modified_blocks ; Assert ( list -> length > 0 ) ; cell = list_head ( list ) ; <S2SV_ModStart> BufferXactTag * ) lfirst ( cell ) ; list -> length -- ; list -> head = cell -> next ; if ( list -> tail == cell ) list -> tail = NULL ; pfree ( cell <S2SV_ModEnd> ) ; BufferGetTag |
4,414 | CWE-000 static void emit_discard ( struct ac_nir_context * ctx , const nir_intrinsic_instr * instr ) { LLVMValueRef cond ; if ( instr -> intrinsic == nir_intrinsic_discard_if ) { cond = LLVMBuildICmp ( ctx -> ac . builder , LLVMIntEQ , get_src ( ctx , instr -> src [ 0 ] ) , ctx -> ac . i32_0 , "" ) ; } else { assert ( instr -> intrinsic == nir_intrinsic_discard ) ; cond = LLVMConstInt ( ctx -> ac . i1 , false , 0 ) ; } <S2SV_StartBug> ac_build_kill_if_false ( & ctx -> ac , cond ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; } ctx -> abi -> emit_kill ( ctx -> abi <S2SV_ModEnd> , cond ) |
4,415 | CWE-000 START_TEST ( test_limits ) { ck_assert ( libevdev_event_type_get_name ( EV_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_ABS , ABS_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_REL , REL_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_KEY , KEY_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_LED , LED_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_SW , SW_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_MSC , MSC_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_SND , SND_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_REP , REP_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_FF , FF_MAX + 1 ) == NULL ) ; ck_assert ( libevdev_event_code_get_name ( EV_MAX + 1 , 0 ) == NULL ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> NULL ) ; ck_assert ( libevdev_event_value_get_name ( EV_ABS , ABS_MT_TOOL_TYPE , MT_TOOL_MAX + 1 ) == NULL ) ; |
4,416 | CWE-000 void mc_line ( float * target , plan_line_data_t * pl_data ) { if ( bit_istrue ( settings . flags , BITFLAG_SOFT_LIMIT_ENABLE ) ) { if ( sys . state != STATE_JOG ) { limits_soft_check ( target ) ; } } if ( sys . state == STATE_CHECK_MODE ) { return ; } do { protocol_execute_realtime ( ) ; if ( sys . abort ) { return ; } if ( plan_check_full_buffer ( ) ) { protocol_auto_cycle_start ( ) ; } else { break ; } } while ( 1 ) ; <S2SV_StartBug> plan_buffer_line ( target , pl_data ) ; <S2SV_EndBug> } | <S2SV_ModStart> 1 ) ; if ( <S2SV_ModStart> , pl_data ) == PLAN_EMPTY_BLOCK ) { if ( bit_istrue ( settings . flags , BITFLAG_LASER_MODE ) ) { spindle_sync ( ( pl_data -> condition & ( PL_COND_FLAG_SPINDLE_CW | PL_COND_FLAG_SPINDLE_CCW ) ) , pl_data -> spindle_speed ) ; } } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
4,417 | CWE-000 int vu_vufuse_chmod ( const char * pathname , mode_t mode , int fd , void * fdprivate ) { int rv ; struct fuse_context fc , * ofc ; ofc = fuse_push_context ( & fc ) ; <S2SV_StartBug> if ( fc . fuse -> flags & MS_RDONLY ) { <S2SV_EndBug> fuse_pop_context ( ofc ) ; errno = EROFS ; return - 1 ; } pthread_mutex_lock ( & ( fc . fuse -> mutex ) ) ; rv = fc . fuse -> fops . chmod ( pathname , mode ) ; fuse_pop_context ( ofc ) ; pthread_mutex_unlock ( & ( fc . fuse -> mutex ) ) ; printkdebug ( F , "CHMOD<S2SV_blank>path:%s<S2SV_blank>status:%s<S2SV_blank>retvalue:%d" , pathname , rv ? "ERROR" : "SUCCESS" , ( rv < 0 ) ? - rv : 0 ) ; if ( rv < 0 ) { errno = - rv ; return - 1 ; } else return rv ; } | <S2SV_ModStart> . fuse -> mountflags <S2SV_ModEnd> & MS_RDONLY ) |
4,418 | CWE-000 static void backspace ( KeyboardHandles * p ) { GConsoleObject * cons ; uint8_t w ; uint8_t h ; h = gdispGetFontMetric ( p -> font , fontHeight ) ; w = gdispGetFontMetric ( p -> font , fontMaxWidth ) ; cons = ( GConsoleObject * ) p -> ghConsole ; if ( cons -> cx == 0 ) { cons -> cy -= h ; cons -> cx = gdispGetWidth ( ) - ( w * 2 ) ; } else cons -> cx -= w ; <S2SV_StartBug> p -> ghConsole -> display -> clipx0 = 0 ; <S2SV_EndBug> <S2SV_StartBug> p -> ghConsole -> display -> clipy0 = 0 ; <S2SV_EndBug> gdispGFillArea ( p -> ghConsole -> display , cons -> cx , cons -> cy , w , h , cons -> g . bgcolor ) ; return ; } | <S2SV_ModStart> -= w ; _gwinDrawStart ( p -> ghConsole ) ; <S2SV_ModStart> clipy0 = 0 ; p -> ghConsole -> display -> clipx1 = gdispGetWidth ( ) ; p -> ghConsole -> display -> clipy1 = gdispGetHeight ( ) ; _gwinDrawEnd ( p -> ghConsole ) |
4,419 | CWE-000 <S2SV_StartBug> int64 os_getfilesize ( char * path ) <S2SV_EndBug> { OS_FD fd = CreateFile ( path , GENERIC_READ , FILE_SHARE_READ , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL ) ; long len_high ; long ret ; if ( fd != INVALID_HANDLE_VALUE ) { ret = GetFileSize ( fd , & len_high ) ; CloseHandle ( fd ) ; <S2SV_StartBug> return ( ( int64 ) len_high << 32 | ret ) ; <S2SV_EndBug> } else { long err = GetLastError ( ) ; if ( err != NO_ERROR ) { win32_maperr ( err ) ; uerror ( "os_getfilesize" , Nothing ) ; } return 0 ; } } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> int64_t <S2SV_ModEnd> os_getfilesize ( char <S2SV_ModStart> return ( ( int64_t <S2SV_ModEnd> ) len_high << |
4,420 | CWE-000 static int sock_test_connect_test_sockets ( uint32_t num_test_sockets ) { sock_client_main_t * scm = & sock_client_main ; sock_test_socket_t * ctrl = & scm -> ctrl_socket ; sock_test_socket_t * tsock ; int i , rv , errno_val ; if ( num_test_sockets < 1 ) { errno = EINVAL ; return - 1 ; } if ( num_test_sockets < scm -> num_test_sockets ) { for ( i = scm -> num_test_sockets - 1 ; i >= num_test_sockets ; i -- ) { tsock = & scm -> test_socket [ i ] ; # ifdef VCL_TEST vppcom_session_close ( tsock -> fd ) ; # else close ( tsock -> fd ) ; # endif free ( tsock -> txbuf ) ; free ( tsock -> rxbuf ) ; } } else if ( num_test_sockets > scm -> num_test_sockets ) { tsock = realloc ( scm -> test_socket , sizeof ( sock_test_socket_t ) * num_test_sockets ) ; if ( ! tsock ) { errno_val = errno ; perror ( "ERROR<S2SV_blank>in<S2SV_blank>sock_test_connect_test_sockets()" ) ; fprintf ( stderr , "ERROR:<S2SV_blank>socket<S2SV_blank>failed<S2SV_blank>(errno<S2SV_blank>=<S2SV_blank>%d)!\\n" , errno_val ) ; return - 1 ; } <S2SV_StartBug> scm -> test_socket = tsock ; <S2SV_EndBug> for ( i = scm -> num_test_sockets ; i < num_test_sockets ; i ++ ) { tsock = & scm -> test_socket [ i ] ; # ifdef VCL_TEST tsock -> fd = vppcom_session_create ( VPPCOM_VRF_DEFAULT , VPPCOM_PROTO_TCP , 0 ) ; if ( tsock -> fd < 0 ) { errno = - tsock -> fd ; tsock -> fd = - 1 ; } # else tsock -> fd = socket ( AF_INET , SOCK_STREAM , 0 ) ; # endif if ( tsock -> fd < 0 ) { errno_val = errno ; perror ( "ERROR<S2SV_blank>in<S2SV_blank>sock_test_connect_test_sockets()" ) ; fprintf ( stderr , "ERROR:<S2SV_blank>socket<S2SV_blank>failed<S2SV_blank>(errno<S2SV_blank>=<S2SV_blank>%d)!\\n" , errno_val ) ; return tsock -> fd ; } # ifdef VCL_TEST rv = vppcom_session_connect ( tsock -> fd , & scm -> server_endpt ) ; # else rv = connect ( tsock -> fd , ( struct sockaddr * ) & scm -> server_addr , sizeof ( scm -> server_addr ) ) ; # endif if ( rv < 0 ) { errno_val = errno ; perror ( "ERROR<S2SV_blank>in<S2SV_blank>main()" ) ; fprintf ( stderr , "ERROR:<S2SV_blank>connect<S2SV_blank>failed<S2SV_blank>(errno<S2SV_blank>=<S2SV_blank>%d)!\\n" , errno_val ) ; } tsock -> cfg = ctrl -> cfg ; sock_test_socket_buf_alloc ( tsock ) ; sock_test_cfg_sync ( tsock ) ; printf ( "CLIENT<S2SV_blank>(fd<S2SV_blank>%d):<S2SV_blank>Test<S2SV_blank>socket<S2SV_blank>%d<S2SV_blank>connected.\\n" , tsock -> fd , i ) ; } } scm -> num_test_sockets = num_test_sockets ; printf ( "CLIENT:<S2SV_blank>All<S2SV_blank>sockets<S2SV_blank>(%d)<S2SV_blank>connected!\\n" , scm -> num_test_sockets + 1 ) ; return 0 ; } | <S2SV_ModStart> 1 ; } if ( ! scm -> test_socket ) memset ( tsock , 0 , sizeof ( * tsock ) ) ; |
4,421 | CWE-000 void fbp_system_config ( ) { <S2SV_StartBug> init_control_framework ( & g_controller_mtoc ) ; <S2SV_EndBug> <S2SV_StartBug> init_control_framework ( & g_controller_ctom ) ; <S2SV_EndBug> ipc_init_parameters ( ) ; bsmp_init_server ( ) ; adcp_channel_config ( ) ; } | <S2SV_ModStart> init_control_framework ( & g_controller_ctom <S2SV_ModEnd> ) ; init_control_framework <S2SV_ModStart> init_control_framework ( & g_controller_mtoc <S2SV_ModEnd> ) ; ipc_init_parameters |
4,422 | CWE-000 void creeArbreDepuisFichier ( Arbre * a , char * nomFichier ) { FILE * in = fopen ( nomFichier , "r" ) ; <S2SV_StartBug> fclose ( in ) ; <S2SV_EndBug> } | <S2SV_ModStart> "r" ) ; creeArbre ( a , in ) ; |
4,423 | CWE-000 audio_manager_result_t set_audio_stream_out ( uint8_t channels , uint32_t sample_rate , uint8_t format ) { int card_id = - 1 ; struct pcm_config config ; <S2SV_StartBug> if ( ( channels <= 0 ) || ( sample_rate <= 0 ) || ( format < 0 ) ) { <S2SV_EndBug> return AUDIO_MANAGER_INVALID_PARAM ; } if ( ( g_audio_out_card_num == 0 ) && ( find_output_audio_card ( ) != AUDIO_MANAGER_SUCCESS ) ) { meddbg ( "Found<S2SV_blank>no<S2SV_blank>active<S2SV_blank>output<S2SV_blank>audio<S2SV_blank>card\\n" ) ; return AUDIO_MANAGER_CARD_NOT_FOUND ; } medvdbg ( "Print<S2SV_blank>the<S2SV_blank>current<S2SV_blank>card<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%d\\n" , card_id ) ; card_id = get_avail_audio_out_card_id ( ) ; if ( card_id < 0 ) { meddbg ( "Found<S2SV_blank>no<S2SV_blank>available<S2SV_blank>card\\n" ) ; return AUDIO_MANAGER_NO_AVAIL_CARD ; } if ( channels > AUDIO_STREAM_CHANNEL_MONO ) { channels = AUDIO_STREAM_CHANNEL_STEREO ; } memset ( & config , 0 , sizeof ( struct pcm_config ) ) ; config . channels = channels ; config . rate = get_closest_samprate ( sample_rate ) ; config . format = format ; config . period_size = AUDIO_STREAM_VOIP_PERIOD_SIZE ; config . period_count = AUDIO_STREAM_VOIP_PERIOD_COUNT ; medvdbg ( "[OUT]<S2SV_blank>Device<S2SV_blank>samplerate:<S2SV_blank>%u,<S2SV_blank>User<S2SV_blank>requested:<S2SV_blank>%u,<S2SV_blank>channels:<S2SV_blank>%u\\n" , config . rate , sample_rate , channels ) ; medvdbg ( "Print<S2SV_blank>the<S2SV_blank>found<S2SV_blank>card<S2SV_blank>id<S2SV_blank>=<S2SV_blank>%d\\n" , card_id ) ; g_audio_out_cards [ card_id ] . pcm = pcm_open ( card_id , 0 , PCM_OUT , & config ) ; if ( ! pcm_is_ready ( g_audio_out_cards [ card_id ] . pcm ) ) { pcm_close ( g_audio_out_cards [ card_id ] . pcm ) ; meddbg ( "fail<S2SV_blank>to<S2SV_blank>pcm_is_ready()\\n" ) ; return AUDIO_MANAGER_CARD_NOT_READY ; } g_actual_audio_out_card_id = card_id ; g_audio_out_cards [ card_id ] . status = AUDIO_CARD_RUNNING ; if ( sample_rate == config . rate ) { g_audio_out_cards [ card_id ] . resample . necessary = false ; } else { g_audio_out_cards [ card_id ] . resample . necessary = true ; g_audio_out_cards [ card_id ] . resample . from = sample_rate ; g_audio_out_cards [ card_id ] . resample . to = config . rate ; g_audio_out_cards [ card_id ] . resample . ratio = ( float ) config . rate / ( float ) sample_rate ; g_audio_out_cards [ card_id ] . resample . handle = src_init ( CONFIG_AUDIO_RESAMPLER_BUFSIZE ) ; } return AUDIO_MANAGER_SUCCESS ; } | <S2SV_ModStart> ( ( channels == <S2SV_ModEnd> 0 ) || <S2SV_ModStart> || ( sample_rate == <S2SV_ModEnd> 0 ) ) |
4,424 | CWE-000 static void random_get_uint64_success_test ( void * * state ) { test_data_t * data = * state ; uint64_t dest = 0 ; dest = random_get_uint64 ( data -> random ) ; <S2SV_StartBug> assert_true ( dest >= 0 && dest <= UINT64_MAX ) ; <S2SV_EndBug> } | <S2SV_ModStart> assert_true ( dest != <S2SV_ModEnd> 0 && dest <S2SV_ModStart> 0 && dest != <S2SV_ModEnd> UINT64_MAX ) ; |
4,425 | CWE-000 int snd_pcm_poll_descriptors ( snd_pcm_t * pcm , struct pollfd * pfds , unsigned int space ) { <S2SV_StartBug> if ( space > ( unsigned int ) sio_nfds ( pcm -> hdl ) ) <S2SV_EndBug> <S2SV_StartBug> return - 1 ; <S2SV_EndBug> return sio_pollfd ( pcm -> hdl , pfds , ( pcm -> hw . stream == SND_PCM_STREAM_PLAYBACK ? POLLOUT : POLLIN ) ) ; } | <S2SV_ModStart> if ( space < <S2SV_ModEnd> ( unsigned int <S2SV_ModStart> hdl ) ) { WARNX ( "not<S2SV_blank>enough<S2SV_blank>space:<S2SV_blank>%u<S2SV_blank><<S2SV_blank>%d" , space , sio_nfds ( pcm -> hdl ) ) ; <S2SV_ModStart> - 1 ; } |
4,426 | CWE-000 void ADC1_COMP_IRQHandler ( ) { ADCChannel current_channel = s_adc_status . current_channel ; uint32_t select = ADC1 -> CHSELR ; uint16_t reading ; if ( select & ( 1 << current_channel ) ) { reading = ADC_GetConversionValue ( ADC1 ) ; <S2SV_StartBug> if ( s_adc_interrupts [ current_channel ] . callback != NULL ) { <S2SV_EndBug> s_adc_interrupts [ current_channel ] . callback ( current_channel , reading , s_adc_interrupts [ current_channel ] . context ) ; } <S2SV_StartBug> } <S2SV_EndBug> current_channel = prv_get_ffs ( select , current_channel ) ; s_adc_status . current_channel = current_channel ; } | <S2SV_ModStart> ADC1 ) ; switch ( current_channel ) { case ADC_CHANNEL_TEMP : reading = prv_get_temp ( reading ) ; break ; case ADC_CHANNEL_REF : reading = prv_get_vdd ( reading ) ; break ; case ADC_CHANNEL_BAT : reading *= 2 ; break ; default : break ; } <S2SV_ModStart> ) ; } s_adc_interrupts [ current_channel ] . reading = reading ; |
4,427 | CWE-000 void domain_shutdown ( struct domain * d , u8 reason ) { <S2SV_StartBug> struct vcpu * v ; <S2SV_EndBug> spin_lock ( & d -> shutdown_lock ) ; if ( d -> shutdown_code == SHUTDOWN_CODE_INVALID ) d -> shutdown_code = reason ; reason = d -> shutdown_code ; if ( is_hardware_domain ( d ) ) hwdom_shutdown ( reason ) ; if ( d -> is_shutting_down ) { spin_unlock ( & d -> shutdown_lock ) ; return ; } d -> is_shutting_down = 1 ; smp_mb ( ) ; for_each_vcpu ( d , v ) { if ( reason == SHUTDOWN_crash ) v -> defer_shutdown = 0 ; else if ( v -> defer_shutdown ) continue ; vcpu_pause_nosync ( v ) ; v -> paused_for_shutdown = 1 ; } arch_domain_shutdown ( d ) ; __domain_finalise_shutdown ( d ) ; spin_unlock ( & d -> shutdown_lock ) ; } | <S2SV_ModStart> * v ; # ifdef CONFIG_X86 if ( pv_shim ) { pv_shim_shutdown ( reason ) ; return ; } # endif |
4,428 | CWE-000 static int packet_notifier ( struct notifier_block * this , unsigned long msg , void * data ) { struct sock * sk ; struct net_device * dev = data ; struct net * net = dev_net ( dev ) ; rcu_read_lock ( ) ; sk_for_each_rcu ( sk , & net -> packet . sklist ) { struct packet_sock * po = pkt_sk ( sk ) ; switch ( msg ) { case NETDEV_UNREGISTER : if ( po -> mclist ) packet_dev_mclist ( dev , po -> mclist , - 1 ) ; case NETDEV_DOWN : if ( dev -> ifindex == po -> ifindex ) { spin_lock ( & po -> bind_lock ) ; if ( po -> running ) { __unregister_prot_hook ( sk , false ) ; sk -> sk_err = ENETDOWN ; if ( ! sock_flag ( sk , SOCK_DEAD ) ) sk -> sk_error_report ( sk ) ; } if ( msg == NETDEV_UNREGISTER ) { packet_cached_dev_reset ( po ) ; <S2SV_StartBug> po -> ifindex = - 1 ; <S2SV_EndBug> if ( po -> prot_hook . dev ) dev_put ( po -> prot_hook . dev ) ; po -> prot_hook . dev = NULL ; } spin_unlock ( & po -> bind_lock ) ; } break ; case NETDEV_UP : if ( dev -> ifindex == po -> ifindex ) { spin_lock ( & po -> bind_lock ) ; if ( po -> num ) register_prot_hook ( sk ) ; spin_unlock ( & po -> bind_lock ) ; } break ; } } rcu_read_unlock ( ) ; return NOTIFY_DONE ; } | <S2SV_ModStart> po ) ; fanout_release ( sk ) ; |
4,429 | CWE-000 static int cr50_i2c_init ( struct i2c_client * client ) { struct device * dev = & client -> dev ; struct tpm_chip * chip ; struct priv_data * priv ; u8 buf [ 4 ] ; u32 vendor ; int rc ; chip = tpmm_chip_alloc ( dev , & cr50_i2c ) ; if ( IS_ERR ( chip ) ) return PTR_ERR ( chip ) ; priv = devm_kzalloc ( dev , sizeof ( struct priv_data ) , GFP_KERNEL ) ; if ( ! priv ) return - ENOMEM ; chip -> flags |= TPM_CHIP_FLAG_TPM2 ; chip -> timeout_a = msecs_to_jiffies ( TIS_SHORT_TIMEOUT ) ; chip -> timeout_b = msecs_to_jiffies ( TIS_LONG_TIMEOUT ) ; chip -> timeout_c = msecs_to_jiffies ( TIS_SHORT_TIMEOUT ) ; chip -> timeout_d = msecs_to_jiffies ( TIS_SHORT_TIMEOUT ) ; dev_set_drvdata ( & chip -> dev , priv ) ; init_completion ( & priv -> tpm_ready ) ; if ( client -> irq > 0 ) { rc = devm_request_irq ( dev , client -> irq , cr50_i2c_int_handler , IRQF_TRIGGER_FALLING | IRQF_ONESHOT , dev -> driver -> name , chip ) ; if ( rc < 0 ) { dev_err ( dev , "Failed<S2SV_blank>to<S2SV_blank>probe<S2SV_blank>IRQ<S2SV_blank>%d\\n" , client -> irq ) ; return rc ; } disable_irq ( client -> irq ) ; priv -> irq = client -> irq ; } else { dev_warn ( dev , "No<S2SV_blank>IRQ,<S2SV_blank>will<S2SV_blank>use<S2SV_blank>%ums<S2SV_blank>delay<S2SV_blank>for<S2SV_blank>TPM<S2SV_blank>ready\\n" , CR50_TIMEOUT_NOIRQ_MS ) ; } rc = request_locality ( chip , 0 ) ; if ( rc < 0 ) { dev_err ( dev , "Could<S2SV_blank>not<S2SV_blank>request<S2SV_blank>locality\\n" ) ; return rc ; } rc = cr50_i2c_read ( chip , TPM_DID_VID ( 0 ) , buf , sizeof ( buf ) ) ; if ( rc < 0 ) { dev_err ( dev , "Could<S2SV_blank>not<S2SV_blank>read<S2SV_blank>vendor<S2SV_blank>id\\n" ) ; release_locality ( chip , 1 ) ; return rc ; } vendor = le32_to_cpup ( ( __le32 * ) buf ) ; if ( vendor != CR50_I2C_DID_VID ) { dev_err ( dev , "Vendor<S2SV_blank>ID<S2SV_blank>did<S2SV_blank>not<S2SV_blank>match!<S2SV_blank>ID<S2SV_blank>was<S2SV_blank>%08x\\n" , vendor ) ; release_locality ( chip , 1 ) ; return - ENODEV ; } <S2SV_StartBug> dev_info ( dev , "cr50<S2SV_blank>TPM<S2SV_blank>2.0<S2SV_blank>(i2c<S2SV_blank>0x%02x<S2SV_blank>irq<S2SV_blank>%d<S2SV_blank>id<S2SV_blank>0x%x)\\n" , <S2SV_EndBug> client -> addr , client -> irq , vendor >> 16 ) ; return tpm_chip_register ( chip ) ; } | <S2SV_ModStart> ( dev , "cr50<S2SV_blank>TPM<S2SV_blank>2.0<S2SV_blank>(i2c<S2SV_blank>0x%02x<S2SV_blank>irq<S2SV_blank>%d<S2SV_blank>id<S2SV_blank>0x%x)<S2SV_blank>[gentle<S2SV_blank>shutdown]\\n" <S2SV_ModEnd> , client -> |
4,430 | CWE-000 void do_el1h_sync ( struct thread * td , struct trapframe * frame ) { struct trapframe * oframe ; uint32_t exception ; uint64_t esr , far ; esr = frame -> tf_esr ; exception = ESR_ELx_EXCEPTION ( esr ) ; # ifdef KDTRACE_HOOKS if ( dtrace_trap_func != NULL && ( * dtrace_trap_func ) ( frame , exception ) ) return ; # endif CTR4 ( KTR_TRAP , "do_el1_sync:<S2SV_blank>curthread:<S2SV_blank>%p,<S2SV_blank>esr<S2SV_blank>%lx,<S2SV_blank>elr:<S2SV_blank>%lx,<S2SV_blank>frame:<S2SV_blank>%p" , td , esr , frame -> tf_elr , frame ) ; oframe = td -> td_frame ; switch ( exception ) { case EXCP_BRK : case EXCP_WATCHPT_EL1 : case EXCP_SOFTSTP_EL1 : break ; default : td -> td_frame = frame ; break ; } switch ( exception ) { case EXCP_FP_SIMD : case EXCP_TRAP_FP : # ifdef VFP if ( ( td -> td_pcb -> pcb_fpflags & PCB_FP_KERN ) != 0 ) { vfp_restore_state ( ) ; } else # endif { print_registers ( frame ) ; printf ( "<S2SV_blank>esr:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%.8lx\\n" , esr ) ; panic ( "VFP<S2SV_blank>exception<S2SV_blank>in<S2SV_blank>the<S2SV_blank>kernel" ) ; } break ; case EXCP_INSN_ABORT : case EXCP_DATA_ABORT : far = READ_SPECIALREG ( far_el1 ) ; intr_enable ( ) ; data_abort ( td , frame , esr , far , 0 ) ; break ; case EXCP_BRK : # ifdef KDTRACE_HOOKS if ( ( esr & ESR_ELx_ISS_MASK ) == 0x40d && dtrace_invop_jump_addr != 0 ) { dtrace_invop_jump_addr ( frame ) ; break ; } # endif <S2SV_StartBug> case EXCP_WATCHPT_EL1 : <S2SV_EndBug> case EXCP_SOFTSTP_EL1 : # ifdef KDB kdb_trap ( exception , 0 , ( td -> td_frame != NULL ) ? td -> td_frame : frame ) ; # else panic ( "No<S2SV_blank>debugger<S2SV_blank>in<S2SV_blank>kernel.\\n" ) ; # endif break ; case EXCP_UNKNOWN : if ( undef_insn ( 1 , frame ) ) break ; default : print_registers ( frame ) ; panic ( "Unknown<S2SV_blank>kernel<S2SV_blank>exception<S2SV_blank>%x<S2SV_blank>esr_el1<S2SV_blank>%lx\\n" , exception , esr ) ; } td -> td_frame = oframe ; } | <S2SV_ModStart> } # endif kdb_trap ( exception , 0 , ( td -> td_frame != NULL ) ? td -> td_frame : frame ) ; frame -> tf_elr += 4 ; break ; |
4,431 | CWE-000 void gpio_af_init ( GPIO_TypeDef * port , GPIO_Pin pin , GPIO_Speed speed , GPIO_OutputType ot , GPIO_AlternateFunction af ) { init_gpio_clock ( port ) ; uint8_t pos = pin_number ( pin ) ; <S2SV_StartBug> set_mode ( port , pos , GPIO_AF ) ; <S2SV_EndBug> set_speed ( port , pos , speed ) ; set_output_type ( port , pos , ot ) ; <S2SV_StartBug> set_af ( port , pos , af ) ; <S2SV_EndBug> } | <S2SV_ModStart> pin ) ; set_af <S2SV_ModEnd> ( port , <S2SV_ModStart> , pos , af <S2SV_ModEnd> ) ; set_speed <S2SV_ModStart> ot ) ; set_pull <S2SV_ModEnd> ( port , <S2SV_ModStart> , pos , GPIO_NO_PULL ) ; set_mode ( port , pos , GPIO_AF <S2SV_ModEnd> ) ; } |
4,432 | CWE-000 int checkOrientation ( int * values , int total_nodes ) { int oriented = 0 ; <S2SV_StartBug> for ( int j = 0 ; j < total_nodes ; j ++ ) { <S2SV_EndBug> if ( values [ j ] ) { oriented = 1 ; break ; } } if ( oriented ) { printf ( "orientado\\n" ) ; } else { printf ( "nao<S2SV_blank>orientado\\n" ) ; } return oriented ; } | <S2SV_ModStart> = 0 ; int j ; for ( <S2SV_ModEnd> j = 0 |
4,433 | CWE-000 int init_iommu ( void ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> ret = register_hrhd_units ( ) ; if ( ret != 0 ) { return ret ; <S2SV_StartBug> } <S2SV_EndBug> do_action_for_iommus ( dmar_prepare ) ; <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> { int ret <S2SV_ModEnd> ; ret = <S2SV_ModStart> ret ; } else { <S2SV_ModStart> dmar_prepare ) ; ret = 0 ; } |
4,434 | CWE-000 PyObject * recpy_bt_goto ( PyObject * self , PyObject * args ) { const recpy_record_object * const record = ( recpy_record_object * ) self ; thread_info * const tinfo = record -> thread ; <S2SV_StartBug> const recpy_element_object * obj ; <S2SV_EndBug> if ( tinfo == NULL || btrace_is_empty ( tinfo ) ) return PyErr_Format ( gdbpy_gdb_error , _ ( "Empty<S2SV_blank>branch<S2SV_blank>trace." ) ) ; <S2SV_StartBug> if ( ! PyArg_ParseTuple ( args , "O" , & obj ) ) <S2SV_EndBug> return NULL ; <S2SV_StartBug> if ( Py_TYPE ( obj ) != & recpy_insn_type ) <S2SV_EndBug> <S2SV_StartBug> return PyErr_Format ( PyExc_TypeError , _ ( "Argument<S2SV_blank>must<S2SV_blank>be<S2SV_blank>instruction." ) ) ; <S2SV_EndBug> TRY { struct btrace_insn_iterator iter ; btrace_insn_end ( & iter , & tinfo -> btrace ) ; if ( btrace_insn_number ( & iter ) == obj -> number ) target_goto_record_end ( ) ; else target_goto_record ( obj -> number ) ; } CATCH ( except , RETURN_MASK_ALL ) { GDB_PY_HANDLE_EXCEPTION ( except ) ; } END_CATCH Py_RETURN_NONE ; } | <S2SV_ModStart> recpy_element_object * obj ; PyObject * parse_obj <S2SV_ModStart> "O" , & parse_obj <S2SV_ModEnd> ) ) return <S2SV_ModStart> ( Py_TYPE ( parse_obj <S2SV_ModEnd> ) != & <S2SV_ModStart> "Argument<S2SV_blank>must<S2SV_blank>be<S2SV_blank>instruction." ) ) ; obj = ( const recpy_element_object * ) parse_obj |
4,435 | CWE-000 int ext2_get_free_inode ( superblock_t * fs ) { ext2_superblock_t * sb = devices [ fs -> id ] . sb ; storage_driver * disk = devices [ fs -> id ] . disk ; ext2_block_group_descriptor_t group_descriptor ; int block_size = 1024 << sb -> log_block_size ; for ( int i = 0 ; i < sb -> total_block_count ; i ++ ) { group_descriptor = ext2_get_block_group_descriptor ( fs , i ) ; if ( group_descriptor . unallocated_inode_count > 0 ) { uint8_t * bitmap = malloc ( block_size ) ; disk -> read ( group_descriptor . inode_usage_bitmap_addr * block_size , bitmap , block_size ) ; int found = - 1 ; for ( int b = 0 ; b < block_size && found == - 1 ; b ++ ) { if ( bitmap [ b ] != 0xFF ) { for ( int bit = 0 ; bit < 8 ; bit ++ ) { if ( ! ( bitmap [ b ] & ( 1 << bit ) ) ) { found = b * 8 + bit ; } } } } free ( bitmap ) ; <S2SV_StartBug> return 1 + found + sb -> inodes_per_group * i ; <S2SV_EndBug> } } kernel_printf ( "[INFO][EXT2]<S2SV_blank>ext2_get_free_inode:<S2SV_blank>error.<S2SV_blank>No<S2SV_blank>available<S2SV_blank>inode." ) ; return 0 ; } | <S2SV_ModStart> bitmap ) ; int free_inode = 1 + found + sb -> inodes_per_group * i ; kdebug ( D_EXT2 , 1 , "ext2_get_free_inode:<S2SV_blank>here<S2SV_blank>you<S2SV_blank>go:<S2SV_blank>%d\\n" , free_inode ) ; return free_inode ; } } kdebug ( D_EXT2 , 2 , "ext2_get_free_inode:<S2SV_blank>error.<S2SV_blank>No<S2SV_blank>available<S2SV_blank>inode.\\n" <S2SV_ModEnd> ) ; return |
4,436 | CWE-000 void core_get_point_for_mag ( double mag , double * radius , double * luminance ) { double l ; double r ; <S2SV_StartBug> double r_min = 0.05 * DD2R ; <S2SV_EndBug> r = get_radius_for_mag ( mag ) ; if ( r == 0 ) { * radius = 0 ; if ( luminance ) * luminance = 0 ; return ; } l = 1.0 ; if ( r > 0 && r < r_min ) { l *= r / r_min ; r = r_min ; } r /= ( 60 * DD2R / core -> fov ) ; * radius = r ; if ( luminance ) * luminance = l ; } | <S2SV_ModStart> double r_min = core -> r_min <S2SV_ModEnd> ; r = |
4,437 | CWE-000 int rt_Set ( struct bundle * bundle , int cmd , const struct ncprange * dst , const struct ncpaddr * gw , int bang , int quiet ) { struct rtmsg rtmes ; int s , nb , wb ; char * cp ; const char * cmdstr ; struct sockaddr_storage sadst , samask , sagw ; int result = 1 ; if ( bang ) cmdstr = ( cmd == RTM_ADD ? "Add!" : "Delete!" ) ; else cmdstr = ( cmd == RTM_ADD ? "Add" : "Delete" ) ; s = ID0socket ( PF_ROUTE , SOCK_RAW , 0 ) ; if ( s < 0 ) { log_Printf ( LogERROR , "rt_Set:<S2SV_blank>socket():<S2SV_blank>%s\\n" , strerror ( errno ) ) ; return result ; } memset ( & rtmes , '\\0' , sizeof rtmes ) ; rtmes . m_rtm . rtm_version = RTM_VERSION ; rtmes . m_rtm . rtm_type = cmd ; rtmes . m_rtm . rtm_addrs = RTA_DST ; rtmes . m_rtm . rtm_seq = ++ bundle -> routing_seq ; rtmes . m_rtm . rtm_pid = getpid ( ) ; rtmes . m_rtm . rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC ; if ( cmd == RTM_ADD ) { if ( bundle -> ncp . cfg . sendpipe > 0 ) { rtmes . m_rtm . rtm_rmx . rmx_sendpipe = bundle -> ncp . cfg . sendpipe ; rtmes . m_rtm . rtm_inits |= RTV_SPIPE ; } if ( bundle -> ncp . cfg . recvpipe > 0 ) { rtmes . m_rtm . rtm_rmx . rmx_recvpipe = bundle -> ncp . cfg . recvpipe ; rtmes . m_rtm . rtm_inits |= RTV_RPIPE ; } } ncprange_getsa ( dst , & sadst , & samask ) ; # if defined ( __KAME__ ) && ! defined ( NOINET6 ) add_scope ( ( struct sockaddr * ) & sadst , bundle -> iface -> index ) ; # endif cp = rtmes . m_space ; cp += memcpy_roundup ( cp , & sadst , sadst . ss_len ) ; if ( cmd == RTM_ADD ) { if ( gw == NULL ) { log_Printf ( LogERROR , "rt_Set:<S2SV_blank>Program<S2SV_blank>error\\n" ) ; close ( s ) ; return result ; } ncpaddr_getsa ( gw , & sagw ) ; # if defined ( __KAME__ ) && ! defined ( NOINET6 ) add_scope ( ( struct sockaddr * ) & sagw , bundle -> iface -> index ) ; # endif if ( ncpaddr_isdefault ( gw ) ) { if ( ! quiet ) log_Printf ( LogERROR , "rt_Set:<S2SV_blank>Cannot<S2SV_blank>add<S2SV_blank>a<S2SV_blank>route<S2SV_blank>with" "<S2SV_blank>gateway<S2SV_blank>0.0.0.0\\n" ) ; close ( s ) ; return result ; } else { cp += memcpy_roundup ( cp , & sagw , sagw . ss_len ) ; rtmes . m_rtm . rtm_addrs |= RTA_GATEWAY ; } } if ( ! ncprange_ishost ( dst ) ) { cp += memcpy_roundup ( cp , & samask , samask . ss_len ) ; rtmes . m_rtm . rtm_addrs |= RTA_NETMASK ; <S2SV_StartBug> } <S2SV_EndBug> nb = cp - ( char * ) & rtmes ; rtmes . m_rtm . rtm_msglen = nb ; wb = ID0write ( s , & rtmes , nb ) ; if ( wb < 0 ) { log_Printf ( LogTCPIP , "rt_Set<S2SV_blank>failure:\\n" ) ; log_Printf ( LogTCPIP , "rt_Set:<S2SV_blank><S2SV_blank>Cmd<S2SV_blank>=<S2SV_blank>%s\\n" , cmdstr ) ; log_Printf ( LogTCPIP , "rt_Set:<S2SV_blank><S2SV_blank>Dst<S2SV_blank>=<S2SV_blank>%s\\n" , ncprange_ntoa ( dst ) ) ; if ( gw != NULL ) log_Printf ( LogTCPIP , "rt_Set:<S2SV_blank><S2SV_blank>Gateway<S2SV_blank>=<S2SV_blank>%s\\n" , ncpaddr_ntoa ( gw ) ) ; failed : if ( cmd == RTM_ADD && ( rtmes . m_rtm . rtm_errno == EEXIST || ( rtmes . m_rtm . rtm_errno == 0 && errno == EEXIST ) ) ) { if ( ! bang ) { log_Printf ( LogWARN , "Add<S2SV_blank>route<S2SV_blank>failed:<S2SV_blank>%s<S2SV_blank>already<S2SV_blank>exists\\n" , ncprange_ntoa ( dst ) ) ; result = 0 ; } else { rtmes . m_rtm . rtm_type = cmd = RTM_CHANGE ; if ( ( wb = ID0write ( s , & rtmes , nb ) ) < 0 ) goto failed ; } } else if ( cmd == RTM_DELETE && ( rtmes . m_rtm . rtm_errno == ESRCH || ( rtmes . m_rtm . rtm_errno == 0 && errno == ESRCH ) ) ) { if ( ! bang ) log_Printf ( LogWARN , "Del<S2SV_blank>route<S2SV_blank>failed:<S2SV_blank>%s:<S2SV_blank>Non-existent\\n" , ncprange_ntoa ( dst ) ) ; } else if ( rtmes . m_rtm . rtm_errno == 0 ) { if ( ! quiet || errno != ENETUNREACH ) log_Printf ( LogWARN , "%s<S2SV_blank>route<S2SV_blank>failed:<S2SV_blank>%s:<S2SV_blank>errno:<S2SV_blank>%s\\n" , cmdstr , ncprange_ntoa ( dst ) , strerror ( errno ) ) ; } else log_Printf ( LogWARN , "%s<S2SV_blank>route<S2SV_blank>failed:<S2SV_blank>%s:<S2SV_blank>%s\\n" , cmdstr , ncprange_ntoa ( dst ) , strerror ( rtmes . m_rtm . rtm_errno ) ) ; } if ( log_IsKept ( LogDEBUG ) ) { char gwstr [ 40 ] ; if ( gw ) snprintf ( gwstr , sizeof gwstr , "%s" , ncpaddr_ntoa ( gw ) ) ; else snprintf ( gwstr , sizeof gwstr , "<none>" ) ; log_Printf ( LogDEBUG , "wrote<S2SV_blank>%d:<S2SV_blank>cmd<S2SV_blank>=<S2SV_blank>%s,<S2SV_blank>dst<S2SV_blank>=<S2SV_blank>%s,<S2SV_blank>gateway<S2SV_blank>=<S2SV_blank>%s\\n" , wb , cmdstr , ncprange_ntoa ( dst ) , gwstr ) ; } close ( s ) ; return result ; } | <S2SV_ModStart> RTA_NETMASK ; } else rtmes . m_rtm . rtm_flags |= RTF_HOST ; |
4,438 | CWE-000 static void quantize_tr_residual ( encoder_state_t * const state , const color_t color , const int32_t x , const int32_t y , const uint8_t depth , cu_info_t * cur_pu , lcu_t * lcu ) { const kvz_config * cfg = & state -> encoder_control -> cfg ; const int32_t shift = color == COLOR_Y ? 0 : 1 ; const vector2d_t lcu_px = { SUB_SCU ( x ) >> shift , SUB_SCU ( y ) >> shift } ; bool handled_elsewhere = color != COLOR_Y && depth > MAX_DEPTH && ( lcu_px . x % 4 != 0 || lcu_px . y % 4 != 0 ) ; if ( handled_elsewhere ) { return ; } cbf_clear ( & cur_pu -> cbf , depth , color ) ; int32_t tr_width ; if ( color == COLOR_Y ) { tr_width = LCU_WIDTH >> depth ; } else { const int chroma_depth = ( depth == MAX_PU_DEPTH ? depth - 1 : depth ) ; tr_width = LCU_WIDTH_C >> chroma_depth ; } const int32_t lcu_width = LCU_WIDTH >> shift ; const int8_t mode = ( color == COLOR_Y ) ? cur_pu -> intra . mode : cur_pu -> intra . mode_chroma ; const coeff_scan_order_t scan_idx = kvz_get_scan_order ( cur_pu -> type , mode , depth ) ; const int offset = lcu_px . x + lcu_px . y * lcu_width ; const int z_index = xy_to_zorder ( lcu_width , lcu_px . x , lcu_px . y ) ; kvz_pixel * pred = NULL ; const kvz_pixel * ref = NULL ; coeff_t * coeff = NULL ; switch ( color ) { case COLOR_Y : pred = & lcu -> rec . y [ offset ] ; ref = & lcu -> ref . y [ offset ] ; coeff = & lcu -> coeff . y [ z_index ] ; break ; case COLOR_U : pred = & lcu -> rec . u [ offset ] ; ref = & lcu -> ref . u [ offset ] ; coeff = & lcu -> coeff . u [ z_index ] ; break ; case COLOR_V : pred = & lcu -> rec . v [ offset ] ; ref = & lcu -> ref . v [ offset ] ; coeff = & lcu -> coeff . v [ z_index ] ; break ; } const bool can_use_trskip = tr_width == 4 && color == COLOR_Y && cfg -> trskip_enable ; bool has_coeffs ; if ( cfg -> lossless ) { has_coeffs = bypass_transquant ( tr_width , lcu_width , lcu_width , ref , pred , pred , coeff ) ; if ( cfg -> implicit_rdpcm && cur_pu -> type == CU_INTRA ) { if ( mode == 10 ) { rdpcm ( tr_width , RDPCM_HOR , coeff ) ; } else if ( mode == 26 ) { rdpcm ( tr_width , RDPCM_VER , coeff ) ; } } } else if ( can_use_trskip ) { <S2SV_StartBug> has_coeffs = kvz_quantize_residual_trskip ( state , <S2SV_EndBug> cur_pu , tr_width , color , scan_idx , <S2SV_StartBug> & cur_pu -> intra . tr_skip , <S2SV_EndBug> lcu_width , lcu_width , ref , pred , pred , coeff ) ; <S2SV_StartBug> } else { <S2SV_EndBug> has_coeffs = kvz_quantize_residual ( state , cur_pu , tr_width , color , scan_idx , false , lcu_width , lcu_width , ref , pred , pred , coeff ) ; } if ( has_coeffs ) { cbf_set ( & cur_pu -> cbf , depth , color ) ; } } | <S2SV_ModStart> can_use_trskip ) { int8_t tr_skip = 0 ; <S2SV_ModStart> scan_idx , & <S2SV_ModEnd> tr_skip , lcu_width <S2SV_ModStart> coeff ) ; cur_pu -> tr_skip = tr_skip ; |
4,439 | CWE-000 static void msm_comm_clean_notify_client ( struct msm_vidc_core * core ) { <S2SV_StartBug> int rc = 0 ; <S2SV_EndBug> struct msm_vidc_inst * inst = NULL ; <S2SV_StartBug> struct hfi_device * hdev = NULL ; <S2SV_EndBug> <S2SV_StartBug> if ( ! core || ! core -> device ) { <S2SV_EndBug> dprintk ( VIDC_ERR , "%s:<S2SV_blank>Invalid<S2SV_blank>params\\n" , __func__ ) ; return ; } dprintk ( VIDC_WARN , "%s:<S2SV_blank>Core<S2SV_blank>%p\\n" , __func__ , core ) ; mutex_lock ( & core -> lock ) ; core -> state = VIDC_CORE_INVALID ; list_for_each_entry ( inst , & core -> instances , list ) { mutex_lock ( & inst -> lock ) ; inst -> state = MSM_VIDC_CORE_INVALID ; <S2SV_StartBug> hdev = inst -> core -> device ; <S2SV_EndBug> if ( hdev && inst -> session ) { dprintk ( VIDC_DBG , "cleaning<S2SV_blank>up<S2SV_blank>inst:<S2SV_blank>0x%p\\n" , inst ) ; rc = call_hfi_op ( hdev , session_clean , ( void * ) inst -> session ) ; if ( rc ) dprintk ( VIDC_ERR , "Sess<S2SV_blank>clean<S2SV_blank>failed<S2SV_blank>:%p\\n" , inst ) ; } inst -> session = NULL ; mutex_unlock ( & inst -> lock ) ; dprintk ( VIDC_WARN , "%s<S2SV_blank>Send<S2SV_blank>sys<S2SV_blank>error<S2SV_blank>for<S2SV_blank>inst<S2SV_blank>%p\\n" , __func__ , inst ) ; msm_vidc_queue_v4l2_event ( inst , V4L2_EVENT_MSM_VIDC_SYS_ERROR ) ; } mutex_unlock ( & core -> lock ) ; } | <S2SV_ModStart> core ) { <S2SV_ModEnd> struct msm_vidc_inst * <S2SV_ModStart> = NULL ; <S2SV_ModEnd> if ( ! <S2SV_ModStart> ( ! core <S2SV_ModEnd> ) { dprintk <S2SV_ModStart> = MSM_VIDC_CORE_INVALID ; <S2SV_ModEnd> mutex_unlock ( & |
4,440 | CWE-000 static enum nfp_repr_type nfp_flower_repr_get_type_and_port ( struct nfp_app * app , u32 port_id , u8 * port ) { switch ( FIELD_GET ( NFP_FLOWER_CMSG_PORT_TYPE , port_id ) ) { case NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT : * port = FIELD_GET ( NFP_FLOWER_CMSG_PORT_PHYS_PORT_NUM , port_id ) ; return NFP_REPR_TYPE_PHYS_PORT ; case NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT : * port = FIELD_GET ( NFP_FLOWER_CMSG_PORT_VNIC , port_id ) ; if ( FIELD_GET ( NFP_FLOWER_CMSG_PORT_VNIC_TYPE , port_id ) == NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF ) return NFP_REPR_TYPE_PF ; else return NFP_REPR_TYPE_VF ; } <S2SV_StartBug> return NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC ; <S2SV_EndBug> } | <S2SV_ModStart> ; } return __NFP_REPR_TYPE_MAX <S2SV_ModEnd> ; } <S2SV_null> |
4,441 | CWE-000 <S2SV_StartBug> RESULT <S2SV_EndBug> <S2SV_StartBug> test_array_index ( ) <S2SV_EndBug> { GArray * array = g_array_new ( FALSE , FALSE , sizeof ( int ) ) ; int v ; v = 27 ; g_array_append_val ( array , v ) ; if ( 27 != g_array_index ( array , int , 0 ) ) return FAILED ( "" ) ; g_array_free ( array , TRUE ) ; return NULL ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static <S2SV_ModStart> RESULT test_array_index ( void |
4,442 | CWE-000 <S2SV_StartBug> int ls_aho_addpattern ( ls_aho_t * pThis , const char * pattern , size_t size ) <S2SV_EndBug> { ls_aho_state_t * pState , * ptr = NULL ; size_t j = 0 ; int ret ; unsigned char ch ; pState = pThis -> zero_state ; while ( j != size ) { ch = * ( pattern + j ) ; if ( pThis -> case_sensitive == 0 ) ch = tolower ( ch ) ; ptr = ls_aho_getgoto ( pState , ch , 0 ) ; if ( ptr == NULL ) break ; if ( ptr -> output > 0 ) { # ifdef LS_AHO_DEBUG <S2SV_StartBug> printf ( "-----pattern=%s,<S2SV_blank>this<S2SV_blank>pattern<S2SV_blank>can<S2SV_blank>be<S2SV_blank>safely<S2SV_blank>ignored\\\n<S2SV_blank><S2SV_blank>-<S2SV_blank>its<S2SV_blank>prefix<S2SV_blank>is<S2SV_blank>a<S2SV_blank>pattern\\n" , pattern ) ; <S2SV_EndBug> # endif return 1 ; } pState = ptr ; ++ j ; } if ( j == size ) { if ( ptr -> output == 0 ) { ptr -> output = j ; ls_aho_freegoto ( ptr -> first ) ; ptr -> first = NULL ; ptr -> goto_size = 0 ; # ifdef LS_AHO_DEBUG <S2SV_StartBug> printf ( "-----pattern=%s,<S2SV_blank>this<S2SV_blank>pattern<S2SV_blank>discards<S2SV_blank>previous<S2SV_blank>patterns\\\n<S2SV_blank><S2SV_blank>-<S2SV_blank>it\'s<S2SV_blank>a<S2SV_blank>prefix<S2SV_blank>of<S2SV_blank>previous<S2SV_blank>ones\\n" , pattern ) ; <S2SV_EndBug> # endif return 1 ; } else if ( ptr -> output == j ) { # ifdef LS_AHO_DEBUG printf ( "info:same<S2SV_blank>pattern<S2SV_blank>already<S2SV_blank>exists\\n" ) ; # endif return 1 ; } # ifdef LS_AHO_DEBUG else { printf ( "warning:<S2SV_blank>impossible,<S2SV_blank>logic<S2SV_blank>error<S2SV_blank>somewhere\\n" ) ; return 0 ; } # endif } while ( j != size ) { if ( ( ptr = ls_aho_initstate ( ) ) == NULL ) return ( 0 ) ; ptr -> id = pThis -> next_state ++ ; ch = * ( pattern + j ) ; if ( pThis -> case_sensitive == 0 ) ch = tolower ( ch ) ; if ( ( ret = ls_aho_setgoto ( pState , ch , ptr ) ) == 0 ) { ls_pfree ( ptr ) ; return 0 ; } pState = ptr ; ++ j ; } <S2SV_StartBug> ptr -> output = size ; <S2SV_EndBug> return 1 ; } | <S2SV_ModStart> , size_t size , void * pattern_ctx <S2SV_ModStart> LS_AHO_DEBUG printf ( "-----pattern=%s,<S2SV_blank>this<S2SV_blank>pattern<S2SV_blank>can<S2SV_blank>be<S2SV_blank>safely<S2SV_blank>ignored\\\n<S2SV_blank>-<S2SV_blank>its<S2SV_blank>prefix<S2SV_blank>is<S2SV_blank>a<S2SV_blank>pattern\\n" <S2SV_ModEnd> , pattern ) <S2SV_ModStart> LS_AHO_DEBUG printf ( "-----pattern=%s,<S2SV_blank>this<S2SV_blank>pattern<S2SV_blank>discards<S2SV_blank>previous<S2SV_blank>patterns\\\n<S2SV_blank>-<S2SV_blank>it\'s<S2SV_blank>a<S2SV_blank>prefix<S2SV_blank>of<S2SV_blank>previous<S2SV_blank>ones\\n" <S2SV_ModEnd> , pattern ) <S2SV_ModStart> } ptr -> ctx = pattern_ctx ; ptr -> |
4,443 | CWE-000 int zpool_shrink ( struct zpool * zpool , unsigned int pages , unsigned int * reclaimed ) { <S2SV_StartBug> return zpool -> driver -> shrink ( zpool -> pool , pages , reclaimed ) ; <S2SV_EndBug> } | <S2SV_ModStart> driver -> shrink ? zpool -> driver -> shrink <S2SV_ModStart> , reclaimed ) : - EINVAL |
4,444 | CWE-000 static int rkss_verify_ptable ( struct rk_secure_storage * rkss ) { void * vp = ( void * ) rkss -> data ; char * cp = ( char * ) vp ; if ( rkss -> index > RKSS_PARTITION_TABLE_COUNT ) { printf ( "cannot<S2SV_blank>support<S2SV_blank>verifing<S2SV_blank>other<S2SV_blank>section." ) ; return 0 ; } cp = ( char * ) ( cp + RKSS_DATA_LEN - sizeof ( struct rkss_file_verification ) ) ; struct rkss_file_verification * verify = ( struct rkss_file_verification * ) ( void * ) cp ; if ( verify -> version != RKSS_VERSION || verify -> checkstr != RKSS_CHECK_STR ) { debug ( "verify<S2SV_blank>[%lu]<S2SV_blank>fail,<S2SV_blank>cleanning<S2SV_blank>...." , rkss -> index ) ; <S2SV_StartBug> memset ( rkss -> data , 0 , sizeof ( RKSS_DATA_LEN ) ) ; <S2SV_EndBug> verify -> checkstr = RKSS_CHECK_STR ; verify -> version = RKSS_VERSION ; int ret = rkss_write_section ( rkss ) ; if ( ret < 0 ) { printf ( "cleanning<S2SV_blank>ptable<S2SV_blank>fail<S2SV_blank>!<S2SV_blank>ret:<S2SV_blank>%d." , ret ) ; return - 1 ; } return 0 ; } return 0 ; } | <S2SV_ModStart> , 0 , RKSS_DATA_LEN <S2SV_ModEnd> ) ; verify |
4,445 | CWE-000 void nnAdd ( nnBuckets * nn , nodeBac * bacterium , errorCode * error ) { cInt coords [ LIMITS_DIM ] ; bucketBac bucket , * bucket_ptr ; nnBucketCoords ( nn , bacterium , coords , error ) ; if ( * error == INCONSISTENT ) { return ; } cInt idx = nnCoords2Idx ( coords ) ; bucket_ptr = mapLookupBucket ( & nn -> bucketTable , idx ) ; if ( bucket_ptr ) { setAdd ( bucket_ptr , bacterium , error ) ; <S2SV_StartBug> } <S2SV_EndBug> else { setInit ( & bucket , 1 , error ) ; if ( * error == MEM ) { return ; } setAdd ( & bucket , bacterium , error ) ; mapAddBucket ( & nn -> bucketTable , idx , & bucket , error ) ; if ( * error == MEM ) { setFree ( & bucket ) ; } } * error = SUCCESS ; } | <S2SV_ModStart> error ) ; if ( * error == MEM ) { return ; } |
4,446 | CWE-000 static void anv_physical_device_init_disk_cache ( struct anv_physical_device * device ) { # ifdef ENABLE_SHADER_CACHE char renderer [ 10 ] ; MAYBE_UNUSED int len = snprintf ( renderer , sizeof ( renderer ) , "anv_%04x" , device -> chipset_id ) ; assert ( len == sizeof ( renderer ) - 2 ) ; char timestamp [ 41 ] ; _mesa_sha1_format ( timestamp , device -> driver_build_sha1 ) ; <S2SV_StartBug> const uint64_t driver_flags = INTEL_DEBUG & DEBUG_DISK_CACHE_MASK ; <S2SV_EndBug> device -> disk_cache = disk_cache_create ( renderer , timestamp , driver_flags ) ; # else device -> disk_cache = NULL ; # endif } | <S2SV_ModStart> uint64_t driver_flags = brw_get_compiler_config_value ( device -> compiler ) <S2SV_ModEnd> ; device -> |
4,447 | CWE-000 const char * driver_get_err_msg_by_exception ( int exception ) { const driver_t * driver ; driver_message_t * msg ; driver = driver_get_by_exception_base ( exception & 0b11111111000000000000000000000000 ) ; if ( driver ) { <S2SV_StartBug> msg = driver -> error ; <S2SV_EndBug> while ( msg -> message ) { if ( msg -> exception == exception ) { return msg -> message ; } msg ++ ; } } return NULL ; } | <S2SV_ModStart> { msg = ( driver_message_t * ) |
4,448 | CWE-000 static int get_segment_name ( quo_xpm_t * xpm , char * * sname ) { <S2SV_StartBug> int qrc = QUO_SUCCESS ; <S2SV_EndBug> if ( QUO_SUCCESS != ( qrc = quo_mpi_xchange_uniq_path ( xpm -> qc -> mpi , <S2SV_StartBug> "xpm" , sname ) ) ) { <S2SV_EndBug> QUO_ERR_MSGRC ( "quo_mpi_xchange_uniq_path" , qrc ) ; goto out ; } out : return qrc ; } | <S2SV_ModStart> int qrc = <S2SV_ModEnd> quo_mpi_xchange_uniq_path ( xpm <S2SV_ModStart> , sname ) ; if ( QUO_SUCCESS != qrc <S2SV_ModEnd> ) { QUO_ERR_MSGRC |
4,449 | CWE-000 int iscsi_target_start_negotiation ( struct iscsi_login * login , struct iscsi_conn * conn ) { int ret ; if ( conn -> sock ) { struct sock * sk = conn -> sock -> sk ; write_lock_bh ( & sk -> sk_callback_lock ) ; set_bit ( LOGIN_FLAGS_READY , & conn -> login_flags ) ; set_bit ( LOGIN_FLAGS_INITIAL_PDU , & conn -> login_flags ) ; write_unlock_bh ( & sk -> sk_callback_lock ) ; } ret = iscsi_target_do_login ( conn , login ) ; if ( ! ret && iscsi_target_sk_check_and_clear ( conn , LOGIN_FLAGS_INITIAL_PDU ) ) ret = - 1 ; if ( ret < 0 ) { <S2SV_StartBug> cancel_delayed_work_sync ( & conn -> login_work ) ; <S2SV_EndBug> cancel_delayed_work_sync ( & conn -> login_cleanup_work ) ; iscsi_target_restore_sock_callbacks ( conn ) ; iscsi_remove_failed_auth_entry ( conn ) ; } if ( ret != 0 ) iscsi_target_nego_release ( conn ) ; return ret ; } | <S2SV_ModStart> 0 ) { write_lock_bh ( & sk -> sk_callback_lock ) ; set_bit ( LOGIN_FLAGS_READY , & conn -> login_flags ) ; write_unlock_bh ( & sk -> sk_callback_lock ) ; } ret = iscsi_target_do_login ( conn , login ) ; if ( ret < 0 ) { |
4,450 | CWE-000 static void bta_dm_disable_timer_cback ( TIMER_LIST_ENT * p_tle ) { UNUSED ( p_tle ) ; UINT8 i ; tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR ; BOOLEAN trigger_disc = FALSE ; APPL_TRACE_EVENT ( "<S2SV_blank>bta_dm_disable_timer_cback<S2SV_blank>trial<S2SV_blank>%d<S2SV_blank>" , p_tle -> param ) ; if ( BTM_GetNumAclLinks ( ) && p_tle -> param == 0 ) { for ( i = 0 ; i < bta_dm_cb . device_list . count ; i ++ ) { # if ( BLE_INCLUDED == TRUE ) transport = bta_dm_cb . device_list . peer_device [ i ] . transport ; # endif btm_remove_acl ( bta_dm_cb . device_list . peer_device [ i ] . peer_bdaddr , transport ) ; trigger_disc = TRUE ; } if ( trigger_disc ) { bta_dm_cb . disable_timer . p_cback = ( TIMER_CBACK * ) & bta_dm_disable_timer_cback ; bta_dm_cb . disable_timer . param = 1 ; bta_sys_start_timer ( & bta_dm_cb . disable_timer , 0 , 1500 ) ; } } else { bta_dm_cb . disabling = FALSE ; bta_sys_remove_uuid ( UUID_SERVCLASS_PNP_INFORMATION ) ; <S2SV_StartBug> bta_dm_cb . p_sec_cback ( BTA_DM_DISABLE_EVT , NULL ) ; <S2SV_EndBug> } } | <S2SV_ModStart> UUID_SERVCLASS_PNP_INFORMATION ) ; bta_dm_disable_conn_down_timer_cback ( <S2SV_ModEnd> NULL ) ; |
4,451 | CWE-000 static void on_mousemove ( void * user , void * event ) { vec3_t ray_origin = rc_unproject_mouse_coords ( ) ; vec3_t ray_dir ; vec3_t cam_pos = Camera_GetPos ( s_ctx . cam ) ; PFM_Vec3_Sub ( & ray_origin , & cam_pos , & ray_dir ) ; PFM_Vec3_Normal ( & ray_dir , & ray_dir ) ; s_ctx . active_tile = false ; struct tile_desc cts [ MAX_CANDIDATE_TILES ] ; int len = candidate_tiles_sorted ( s_ctx . map , ray_origin , ray_dir , cts ) ; for ( int i = 0 ; i < len ; i ++ ) { struct aabb tile_aabb = aabb_for_tile ( cts [ i ] , s_ctx . map ) ; float t ; if ( C_RayIntersectsAABB ( ray_origin , ray_dir , tile_aabb , & t ) ) { vec3_t tile_mesh [ 36 ] ; mat4x4_t model ; const struct pfchunk * chunk = & s_ctx . map -> chunks [ cts [ i ] . chunk_r * s_ctx . map -> width + cts [ i ] . chunk_c ] ; M_ModelMatrixForChunk ( s_ctx . map , ( struct chunkpos ) { cts [ i ] . chunk_r , cts [ i ] . chunk_c } , & model ) ; int num_verts = R_GL_TriMeshForTile ( & cts [ i ] , chunk -> render_private , & model , TILES_PER_CHUNK_WIDTH , tile_mesh ) ; <S2SV_StartBug> if ( C_RayIntersectsTriMesh ( ray_origin , ray_dir , tile_mesh , num_verts ) ) { <S2SV_EndBug> s_ctx . hovered = cts [ i ] ; s_ctx . active_tile = true ; break ; } } } } | <S2SV_ModStart> tile_mesh ) ; assert ( num_verts == sizeof ( tile_mesh ) / sizeof ( vec3_t ) ) ; |
4,452 | CWE-000 int main ( int argc , char * * argv ) { int play , num_players , i , row ; char piece , col ; board_t * board ; player_t * player1 , * player2 ; player1 = ( player_t * ) malloc ( sizeof ( player_t ) ) ; player2 = ( player_t * ) malloc ( sizeof ( player_t ) ) ; board = create_board ( ) ; <S2SV_StartBug> if ( argc == 1 ) { <S2SV_EndBug> draw ( board ) ; printf ( "Enter<S2SV_blank>number<S2SV_blank>of<S2SV_blank>(human)<S2SV_blank>players<S2SV_blank>(0-2):<S2SV_blank>" ) ; scanf ( "%d" , & num_players ) ; if ( num_players == 0 ) { player1 -> is_human = FALSE ; player1 -> piece_type = WHITE ; player2 -> is_human = FALSE ; player2 -> piece_type = BLACK ; } else if ( num_players == 1 ) { player1 -> is_human = TRUE ; player1 -> piece_type = WHITE ; player2 -> is_human = FALSE ; player2 -> piece_type = BLACK ; } else { player1 -> is_human = TRUE ; player1 -> piece_type = WHITE ; player2 -> is_human = TRUE ; player2 -> piece_type = BLACK ; } <S2SV_StartBug> } else if ( argc == 2 ) { <S2SV_EndBug> if ( strcmp ( argv [ 1 ] , "-p" ) == 0 ) { for ( i = 0 ; i < 16 ; i ++ ) { board -> white [ i ] . taken = TRUE ; board -> black [ i ] . taken = TRUE ; } draw ( board ) ; printf ( "Add<S2SV_blank>pieces,<S2SV_blank>format<S2SV_blank>=<S2SV_blank><piece><S2SV_blank>at<S2SV_blank><cell>\\n" ) ; <S2SV_StartBug> i = 1 ; <S2SV_EndBug> while ( i ) { printf ( "Add<S2SV_blank>piece:<S2SV_blank>" ) ; <S2SV_StartBug> scanf ( "<S2SV_blank>%c<S2SV_blank>at<S2SV_blank>%c%d" , & piece , & col , & row ) ; <S2SV_EndBug> if ( piece == 'f' ) { i = 0 ; } else { <S2SV_StartBug> if ( col > 96 ) { <S2SV_EndBug> <S2SV_StartBug> i = place_piece ( board , piece , 8 - row , col - 96 ) ; <S2SV_EndBug> } else { i = place_piece ( board , piece , 8 - row , col - 65 ) ; } if ( ! i ) { i = 1 ; printf ( "Error<S2SV_blank>placing<S2SV_blank>piece\\n" ) ; } draw ( board ) ; } } } else { printf ( "Error:<S2SV_blank>usage\\n" ) ; return 0 ; } } else { } play = 1 ; <S2SV_StartBug> while ( play ) { <S2SV_EndBug> draw ( board ) ; play = move ( player1 , board ) ; if ( play ) { play = move ( player2 , board ) ; } } return 0 ; } | <S2SV_ModStart> ( ) ; <S2SV_ModEnd> draw ( board <S2SV_ModStart> BLACK ; } if ( argc == 1 ) { <S2SV_ModStart> "Add<S2SV_blank>pieces,<S2SV_blank>format<S2SV_blank>=<S2SV_blank><piece><S2SV_blank>at<S2SV_blank><cell>\\n" ) ; printf ( "Type<S2SV_blank>\\"Done\\"<S2SV_blank>to<S2SV_blank>finish\\n" ) ; <S2SV_ModStart> "Add<S2SV_blank>piece:<S2SV_blank>" ) ; if ( <S2SV_ModStart> & row ) == 1 <S2SV_ModEnd> ) { i <S2SV_ModStart> if ( col >= 'a' <S2SV_ModEnd> ) { i <S2SV_ModStart> , col - 97 <S2SV_ModEnd> ) ; } <S2SV_ModStart> = 1 ; printf ( "Beginning<S2SV_blank>game\\n" ) ; |
4,453 | CWE-000 static void mlx5e_redirect_rqts_to_channels ( struct mlx5e_priv * priv , struct mlx5e_channels * chs ) { struct mlx5e_redirect_rqt_param rrp = { . is_rss = true , <S2SV_StartBug> . rss . channels = chs , <S2SV_EndBug> <S2SV_StartBug> . rss . hfunc = chs -> params . rss_hfunc <S2SV_EndBug> } ; mlx5e_redirect_rqts ( priv , rrp ) ; } | <S2SV_ModStart> = true , { . rss = { <S2SV_ModEnd> . channels = <S2SV_ModStart> = chs , <S2SV_ModEnd> . hfunc = <S2SV_ModStart> params . rss_hfunc , } } , |
4,454 | CWE-000 static void _arch_exit_critical ( ) { <S2SV_StartBug> s_arch_port . critical_nesting -- ; <S2SV_EndBug> if ( s_arch_port . critical_nesting < 0 ) { s_arch_port . critical_nesting = 0 ; } if ( s_arch_port . critical_nesting == 0 ) { asm_open_irq ( ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { if ( g_pt -> <S2SV_ModEnd> critical_nesting == 0 <S2SV_ModStart> ) ; } g_pt -> critical_nesting -- ; |
4,455 | CWE-000 static void msm_hotplug_work ( struct work_struct * work ) { unsigned int i , target = 0 , online_little ; if ( ! msm_enabled ) return ; if ( hotplug . suspended ) { dprintk ( "%s:<S2SV_blank>suspended.\\n" , MSM_HOTPLUG ) ; return ; } if ( prevent_big_off ) { <S2SV_StartBug> if ( ! cpu_online ( stats . total_cpus ) ) <S2SV_EndBug> # ifdef CONFIG_THERMAL_MONITOR if ( ! msm_thermal_deny_cpu_up ( stats . total_cpus ) ) { # endif cpu_up ( stats . total_cpus ) ; <S2SV_StartBug> # ifdef CONFIG_THERMAL_MONITOR <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> # endif } if ( timeout_enabled ) { if ( ktime_to_ms ( ktime_get ( ) ) - pre_time > HOTPLUG_TIMEOUT ) { if ( msm_hotplug_scr_suspended ) { msm_hotplug_suspend ( ) ; return ; } timeout_enabled = false ; msm_hotplug_fingerprint_called = false ; } goto reschedule ; } update_load_stats ( ) ; online_little = num_online_little_cpus ( ) ; if ( stats . cur_max_load >= ( hotplug . fast_lane_load * online_little ) && hotplug . fast_lane_load != 0 ) { online_cpu ( hotplug . max_cpus_online ) ; big_updown ( 1 ) ; goto reschedule ; } big_updown ( 0 ) ; if ( hotplug . min_cpus_online == stats . total_cpus ) { if ( stats . online_cpus != hotplug . min_cpus_online ) online_cpu ( hotplug . min_cpus_online ) ; goto reschedule ; } else if ( hotplug . max_cpus_online == stats . min_cpus ) { if ( stats . online_cpus != hotplug . max_cpus_online ) offline_cpu ( hotplug . max_cpus_online ) ; goto reschedule ; } for ( i = stats . min_cpus ; loads [ i ] . up_threshold ; i ++ ) { if ( stats . cur_avg_load <= loads [ i ] . up_threshold && stats . cur_avg_load > loads [ i ] . down_threshold ) { target = i ; break ; } } if ( target > hotplug . max_cpus_online ) target = hotplug . max_cpus_online ; else if ( target < hotplug . min_cpus_online ) target = hotplug . min_cpus_online ; if ( stats . online_cpus != target ) { if ( target > stats . online_cpus ) online_cpu ( target ) ; else if ( target < stats . online_cpus ) offline_cpu ( target ) ; } reschedule : dprintk ( "%s:<S2SV_blank>cur_avg_load:<S2SV_blank>%3u<S2SV_blank>online_cpus:<S2SV_blank>%u<S2SV_blank>target:<S2SV_blank>%u\\n" , MSM_HOTPLUG , stats . cur_avg_load , stats . online_cpus , target ) ; reschedule_hotplug_work ( ) ; } | <S2SV_ModStart> total_cpus ) ) { <S2SV_ModStart> total_cpus ) ; if ( unlikely ( debug_dmesg ) ) { pr_info ( "[msm_hotplug]<S2SV_blank>brought<S2SV_blank>up<S2SV_blank>cpu%d\\n" , stats . total_cpus ) ; } <S2SV_ModStart> ifdef CONFIG_THERMAL_MONITOR } else { if ( unlikely ( debug_dmesg ) ) { pr_info ( "[msm_hotplug]<S2SV_blank>bringup<S2SV_blank>of<S2SV_blank>cpu%d<S2SV_blank>denied<S2SV_blank>by<S2SV_blank>msm_thermal\\n" , stats . total_cpus ) ; } } # endif } <S2SV_ModEnd> } if ( |
4,456 | CWE-000 size_t BRAddressScriptPubKey ( uint8_t * script , size_t scriptLen , const char * addr ) { <S2SV_StartBug> static uint8_t pubkeyAddress = BITCOIN_PUBKEY_ADDRESS , scriptAddress = BITCOIN_SCRIPT_ADDRESS ; <S2SV_EndBug> <S2SV_StartBug> uint8_t data [ 21 ] ; <S2SV_EndBug> size_t r = 0 ; assert ( addr != NULL ) ; # if BITCOIN_TESTNET pubkeyAddress = BITCOIN_PUBKEY_ADDRESS_TEST ; scriptAddress = BITCOIN_SCRIPT_ADDRESS_TEST ; # endif if ( BRBase58CheckDecode ( data , sizeof ( data ) , addr ) == 21 ) { if ( data [ 0 ] == pubkeyAddress ) { if ( script && 25 <= scriptLen ) { script [ 0 ] = OP_DUP ; script [ 1 ] = OP_HASH160 ; script [ 2 ] = 20 ; memcpy ( & script [ 3 ] , & data [ 1 ] , 20 ) ; script [ 23 ] = OP_EQUALVERIFY ; script [ 24 ] = OP_CHECKSIG ; } r = ( ! script || 25 <= scriptLen ) ? 25 : 0 ; } else if ( data [ 0 ] == scriptAddress ) { if ( script && 23 <= scriptLen ) { script [ 0 ] = OP_HASH160 ; script [ 1 ] = 20 ; memcpy ( & script [ 2 ] , & data [ 1 ] , 20 ) ; script [ 22 ] = OP_EQUAL ; } r = ( ! script || 23 <= scriptLen ) ? 23 : 0 ; } } return r ; } | <S2SV_ModStart> uint8_t pubkeyAddress = BITCOIN_PUBKEY_ADDRESS_0 <S2SV_ModEnd> , scriptAddress = <S2SV_ModStart> , scriptAddress = BITCOIN_SCRIPT_ADDRESS_0 <S2SV_ModEnd> ; uint8_t data <S2SV_ModStart> uint8_t data [ 22 <S2SV_ModEnd> ] ; size_t |
4,457 | CWE-000 void convert ( ) { Image image ; image . h = getHeight ( filename ) ; image . w = getWidth ( filename ) ; unsigned char final_array [ image . h * image . w ] ; image . data = final_array ; if ( parse_bmp ( final_array , filename ) == 1 ) { printf ( "File<S2SV_blank>not<S2SV_blank>found<S2SV_blank>!\\n<S2SV_blank>filename=%s\\n" , filename ) ; } char text [ ] = "Lorem<S2SV_blank>ipsum<S2SV_blank>elit.<S2SV_blank>Utvenenatis," ; <S2SV_StartBug> Image cutted = cut ( filename , text ) ; <S2SV_EndBug> char n [ ] = "converted.bmp" ; array_to_bmp ( cutted . data , cutted . w , cutted . h , filename , n ) ; gtk_image_set_from_file ( GTK_IMAGE ( image_glo ) , n ) ; } | <S2SV_ModStart> ( filename , NULL <S2SV_ModEnd> ) ; char |
4,458 | CWE-000 int setpriv_main ( int argc UNUSED_PARAM , char * * argv ) { static const char setpriv_longopts [ ] ALIGN1 = "nnp\\0" No_argument "\\xff" "no-new-privs\\0" No_argument "\\xff" ; int opts ; opt_complementary = "-1" ; applet_long_options = setpriv_longopts ; <S2SV_StartBug> opts = getopt32 ( argv , "" ) ; <S2SV_EndBug> if ( opts ) { if ( prctl ( PR_SET_NO_NEW_PRIVS , 1 , 0 , 0 , 0 ) ) bb_simple_perror_msg_and_die ( "prctl:<S2SV_blank>NO_NEW_PRIVS" ) ; } argv += optind ; BB_EXECVP_or_die ( argv ) ; } | <S2SV_ModStart> ( argv , "+" <S2SV_ModEnd> ) ; if |
4,459 | CWE-000 static rsRetVal OnFileOpen ( void * pT , uchar * fn , void * pGF ) { lmsig_ksi_ls12_t * pThis = ( lmsig_ksi_ls12_t * ) pT ; ksifile * pgf = ( ksifile * ) pGF ; DEFiRet ; <S2SV_StartBug> DBGPRINTF ( "lmsig_ksi-ls12:<S2SV_blank>onFileOpen:<S2SV_blank>%s\\n" , fn ) ; <S2SV_EndBug> * pgf = rsksiCtxOpenFile ( pThis -> ctx , fn ) ; sigblkInitKSI ( * pgf ) ; RETiRet ; } | <S2SV_ModStart> ; DEFiRet ; <S2SV_ModEnd> * pgf = |
4,460 | CWE-000 void vmbus_disconnect ( void ) { <S2SV_StartBug> vmbus_initiate_unload ( false ) ; <S2SV_EndBug> if ( vmbus_connection . work_queue ) { drain_workqueue ( vmbus_connection . work_queue ) ; destroy_workqueue ( vmbus_connection . work_queue ) ; } if ( vmbus_connection . int_page ) { free_pages ( ( unsigned long ) vmbus_connection . int_page , 0 ) ; vmbus_connection . int_page = NULL ; } free_pages ( ( unsigned long ) vmbus_connection . monitor_pages [ 0 ] , 0 ) ; free_pages ( ( unsigned long ) vmbus_connection . monitor_pages [ 1 ] , 0 ) ; vmbus_connection . monitor_pages [ 0 ] = NULL ; vmbus_connection . monitor_pages [ 1 ] = NULL ; } | <S2SV_ModStart> false ) ; if ( vmbus_connection . work_queue_rescind ) { drain_workqueue ( vmbus_connection . work_queue_rescind ) ; destroy_workqueue ( vmbus_connection . work_queue_rescind ) ; } |
4,461 | CWE-000 int tcp_v4_connect ( struct sock * sk , struct sockaddr * uaddr , int addr_len ) { struct sockaddr_in * usin = ( struct sockaddr_in * ) uaddr ; struct inet_sock * inet = inet_sk ( sk ) ; struct tcp_sock * tp = tcp_sk ( sk ) ; __be16 orig_sport , orig_dport ; __be32 daddr , nexthop ; struct flowi4 * fl4 ; struct rtable * rt ; int err ; struct ip_options_rcu * inet_opt ; if ( addr_len < sizeof ( struct sockaddr_in ) ) return - EINVAL ; if ( usin -> sin_family != AF_INET ) return - EAFNOSUPPORT ; nexthop = daddr = usin -> sin_addr . s_addr ; inet_opt = rcu_dereference_protected ( inet -> inet_opt , sock_owned_by_user ( sk ) ) ; if ( inet_opt && inet_opt -> opt . srr ) { if ( ! daddr ) return - EINVAL ; nexthop = inet_opt -> opt . faddr ; } orig_sport = inet -> inet_sport ; orig_dport = usin -> sin_port ; fl4 = & inet -> cork . fl . u . ip4 ; rt = ip_route_connect ( fl4 , nexthop , inet -> inet_saddr , RT_CONN_FLAGS ( sk ) , sk -> sk_bound_dev_if , IPPROTO_TCP , orig_sport , orig_dport , sk , true ) ; if ( IS_ERR ( rt ) ) { err = PTR_ERR ( rt ) ; if ( err == - ENETUNREACH ) IP_INC_STATS ( sock_net ( sk ) , IPSTATS_MIB_OUTNOROUTES ) ; return err ; } if ( rt -> rt_flags & ( RTCF_MULTICAST | RTCF_BROADCAST ) ) { ip_rt_put ( rt ) ; return - ENETUNREACH ; } if ( ! inet_opt || ! inet_opt -> opt . srr ) daddr = fl4 -> daddr ; if ( ! inet -> inet_saddr ) inet -> inet_saddr = fl4 -> saddr ; inet -> inet_rcv_saddr = inet -> inet_saddr ; if ( tp -> rx_opt . ts_recent_stamp && inet -> inet_daddr != daddr ) { tp -> rx_opt . ts_recent = 0 ; tp -> rx_opt . ts_recent_stamp = 0 ; <S2SV_StartBug> tp -> write_seq = 0 ; <S2SV_EndBug> } if ( tcp_death_row . sysctl_tw_recycle && ! tp -> rx_opt . ts_recent_stamp && fl4 -> daddr == daddr ) { struct inet_peer * peer = rt_get_peer ( rt , fl4 -> daddr ) ; if ( peer ) { inet_peer_refcheck ( peer ) ; if ( ( u32 ) get_seconds ( ) - peer -> tcp_ts_stamp <= TCP_PAWS_MSL ) { tp -> rx_opt . ts_recent_stamp = peer -> tcp_ts_stamp ; tp -> rx_opt . ts_recent = peer -> tcp_ts ; } } } inet -> inet_dport = usin -> sin_port ; inet -> inet_daddr = daddr ; inet_csk ( sk ) -> icsk_ext_hdr_len = 0 ; if ( inet_opt ) inet_csk ( sk ) -> icsk_ext_hdr_len = inet_opt -> opt . optlen ; tp -> rx_opt . mss_clamp = TCP_MSS_DEFAULT ; tcp_set_state ( sk , TCP_SYN_SENT ) ; err = inet_hash_connect ( & tcp_death_row , sk ) ; if ( err ) goto failure ; rt = ip_route_newports ( fl4 , rt , orig_sport , orig_dport , inet -> inet_sport , inet -> inet_dport , sk ) ; if ( IS_ERR ( rt ) ) { err = PTR_ERR ( rt ) ; rt = NULL ; goto failure ; } sk -> sk_gso_type = SKB_GSO_TCPV4 ; sk_setup_caps ( sk , & rt -> dst ) ; <S2SV_StartBug> if ( ! tp -> write_seq ) <S2SV_EndBug> tp -> write_seq = secure_tcp_sequence_number ( inet -> inet_saddr , inet -> inet_daddr , inet -> inet_sport , usin -> sin_port ) ; inet -> inet_id = tp -> write_seq ^ jiffies ; <S2SV_StartBug> err = tcp_connect ( sk ) ; <S2SV_EndBug> rt = NULL ; if ( err ) goto failure ; return 0 ; failure : tcp_set_state ( sk , TCP_CLOSE ) ; ip_rt_put ( rt ) ; sk -> sk_route_caps = 0 ; inet -> inet_dport = 0 ; return err ; } | <S2SV_ModStart> = 0 ; if ( likely ( ! tp -> repair ) ) <S2SV_ModStart> tp -> write_seq && likely ( ! tp -> repair ) <S2SV_ModStart> ^ jiffies ; if ( likely ( ! tp -> repair ) ) <S2SV_ModStart> err = tcp_connect ( sk ) ; else err = tcp_repair_connect |
4,462 | CWE-000 int stream_blob_to_fd ( int fd , const struct object_id * oid , struct stream_filter * filter , int can_seek ) { struct git_istream * st ; enum object_type type ; unsigned long sz ; ssize_t kept = 0 ; int result = - 1 ; st = open_istream ( oid -> hash , & type , & sz , filter ) ; if ( ! st ) { if ( filter ) free_stream_filter ( filter ) ; return result ; } if ( type != OBJ_BLOB ) goto close_and_exit ; for ( ; ; ) { char buf [ 1024 * 16 ] ; ssize_t wrote , holeto ; ssize_t readlen = read_istream ( st , buf , sizeof ( buf ) ) ; if ( readlen < 0 ) goto close_and_exit ; if ( ! readlen ) break ; if ( can_seek && sizeof ( buf ) == readlen ) { for ( holeto = 0 ; holeto < readlen ; holeto ++ ) if ( buf [ holeto ] ) break ; if ( readlen == holeto ) { kept += holeto ; continue ; } } if ( kept && lseek ( fd , kept , SEEK_CUR ) == ( off_t ) - 1 ) goto close_and_exit ; else kept = 0 ; wrote = write_in_full ( fd , buf , readlen ) ; <S2SV_StartBug> if ( wrote != readlen ) <S2SV_EndBug> goto close_and_exit ; } if ( kept && ( lseek ( fd , kept - 1 , SEEK_CUR ) == ( off_t ) - 1 || xwrite ( fd , "" , 1 ) != 1 ) ) goto close_and_exit ; result = 0 ; close_and_exit : close_istream ( st ) ; return result ; } | <S2SV_ModStart> if ( wrote < 0 <S2SV_ModEnd> ) goto close_and_exit |
4,463 | CWE-000 static void extended_remote_attach ( struct target_ops * target , const char * args , int from_tty ) { struct remote_state * rs = get_remote_state ( ) ; int pid ; char * wait_status = NULL ; pid = parse_pid_to_attach ( args ) ; if ( packet_support ( PACKET_vAttach ) == PACKET_DISABLE ) error ( _ ( "This<S2SV_blank>target<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>attaching<S2SV_blank>to<S2SV_blank>a<S2SV_blank>process" ) ) ; if ( from_tty ) { char * exec_file = get_exec_file ( 0 ) ; if ( exec_file ) printf_unfiltered ( _ ( "Attaching<S2SV_blank>to<S2SV_blank>program:<S2SV_blank>%s,<S2SV_blank>%s\\n" ) , exec_file , target_pid_to_str ( pid_to_ptid ( pid ) ) ) ; else printf_unfiltered ( _ ( "Attaching<S2SV_blank>to<S2SV_blank>%s\\n" ) , target_pid_to_str ( pid_to_ptid ( pid ) ) ) ; gdb_flush ( gdb_stdout ) ; } xsnprintf ( rs -> buf , get_remote_packet_size ( ) , "vAttach;%x" , pid ) ; putpkt ( rs -> buf ) ; getpkt ( & rs -> buf , & rs -> buf_size , 0 ) ; switch ( packet_ok ( rs -> buf , & remote_protocol_packets [ PACKET_vAttach ] ) ) { case PACKET_OK : if ( ! target_is_non_stop_p ( ) ) { wait_status = ( char * ) alloca ( strlen ( rs -> buf ) + 1 ) ; strcpy ( wait_status , rs -> buf ) ; } else if ( strcmp ( rs -> buf , "OK" ) != 0 ) error ( _ ( "Attaching<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>failed<S2SV_blank>with:<S2SV_blank>%s" ) , target_pid_to_str ( pid_to_ptid ( pid ) ) , rs -> buf ) ; break ; case PACKET_UNKNOWN : error ( _ ( "This<S2SV_blank>target<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>attaching<S2SV_blank>to<S2SV_blank>a<S2SV_blank>process" ) ) ; default : error ( _ ( "Attaching<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>failed" ) , target_pid_to_str ( pid_to_ptid ( pid ) ) ) ; } set_current_inferior ( remote_add_inferior ( 0 , pid , 1 , 0 ) ) ; inferior_ptid = pid_to_ptid ( pid ) ; if ( target_is_non_stop_p ( ) ) { struct thread_info * thread ; remote_update_thread_list ( target ) ; thread = first_thread_of_process ( pid ) ; if ( thread ) inferior_ptid = thread -> ptid ; else inferior_ptid = pid_to_ptid ( pid ) ; record_currthread ( rs , minus_one_ptid ) ; } else { inferior_ptid = remote_current_thread ( inferior_ptid ) ; <S2SV_StartBug> add_thread_silent ( inferior_ptid ) ; <S2SV_EndBug> } target_find_description ( ) ; if ( ! target_is_non_stop_p ( ) ) { gdb_assert ( wait_status != NULL ) ; if ( target_can_async_p ( ) ) { struct notif_event * reply = remote_notif_parse ( & notif_client_stop , wait_status ) ; push_stop_reply ( ( struct stop_reply * ) reply ) ; target_async ( 1 ) ; } else { gdb_assert ( wait_status != NULL ) ; strcpy ( rs -> buf , wait_status ) ; rs -> cached_wait_status = 1 ; } } else gdb_assert ( wait_status == NULL ) ; } | <S2SV_ModStart> inferior_ptid ) ; thread_info * thr = <S2SV_ModStart> add_thread_silent ( inferior_ptid ) ; set_executing ( thr -> ptid , true |
4,464 | CWE-000 int draw_icon ( Layer * * layer , short y , short x , char iconLayer ) { <S2SV_StartBug> Layer * lyr = layer [ iconLayer - 1 ] ; <S2SV_EndBug> int result = position_test ( layer , y , x , iconLayer ) ; <S2SV_StartBug> if ( result >= 0 ) return result ; <S2SV_EndBug> Sprite * sprite = lyr -> sprite [ y - lyr -> yOffset ] + x - lyr -> xOffset ; if ( sprite -> iconDepth == 0 ) return 1 ; mvprintw ( y , 2 * x , sprite -> icon [ sprite -> iconDepth - 1 ] ) ; lyr -> draw = false ; return 0 ; } | <S2SV_ModStart> iconLayer ) { <S2SV_ModEnd> int result = <S2SV_ModStart> ) return result ; Layer * lyr = layer [ iconLayer - 1 ] |
4,465 | CWE-000 int Tcl_ListObjAppendList ( Tcl_Interp * interp , register Tcl_Obj * listPtr , Tcl_Obj * elemListPtr ) { int listLen , objc , result ; Tcl_Obj * * objv ; if ( Tcl_IsShared ( listPtr ) ) { Tcl_Panic ( "%s<S2SV_blank>called<S2SV_blank>with<S2SV_blank>shared<S2SV_blank>object" , "Tcl_ListObjAppendList" ) ; } <S2SV_StartBug> result = TclListObjLength ( interp , listPtr , & listLen ) ; <S2SV_EndBug> if ( result != TCL_OK ) { return result ; } result = TclListObjGetElements ( interp , elemListPtr , & objc , & objv ) ; if ( result != TCL_OK ) { return result ; } <S2SV_StartBug> return Tcl_ListObjReplace ( interp , listPtr , listLen , 0 , objc , objv ) ; <S2SV_EndBug> } | <S2SV_ModStart> } result = <S2SV_ModEnd> TclListObjGetElements ( interp <S2SV_ModStart> , listPtr , LIST_MAX <S2SV_ModEnd> , 0 , |
4,466 | CWE-000 int RAND_DRBG_reseed ( RAND_DRBG * drbg , const unsigned char * adin , size_t adinlen , int prediction_resistance ) { unsigned char * entropy = NULL ; size_t entropylen = 0 ; if ( drbg -> state == DRBG_ERROR ) { RANDerr ( RAND_F_RAND_DRBG_RESEED , RAND_R_IN_ERROR_STATE ) ; return 0 ; } if ( drbg -> state == DRBG_UNINITIALISED ) { RANDerr ( RAND_F_RAND_DRBG_RESEED , RAND_R_NOT_INSTANTIATED ) ; return 0 ; } if ( adin == NULL ) { adinlen = 0 ; } else if ( adinlen > drbg -> max_adinlen ) { RANDerr ( RAND_F_RAND_DRBG_RESEED , RAND_R_ADDITIONAL_INPUT_TOO_LONG ) ; return 0 ; } drbg -> state = DRBG_ERROR ; if ( drbg -> get_entropy != NULL ) entropylen = drbg -> get_entropy ( drbg , & entropy , drbg -> strength , drbg -> min_entropylen , drbg -> max_entropylen , prediction_resistance ) ; if ( entropylen < drbg -> min_entropylen || entropylen > drbg -> max_entropylen ) { RANDerr ( RAND_F_RAND_DRBG_RESEED , RAND_R_ERROR_RETRIEVING_ENTROPY ) ; goto end ; } if ( ! drbg -> meth -> reseed ( drbg , entropy , entropylen , adin , adinlen ) ) goto end ; drbg -> state = DRBG_READY ; <S2SV_StartBug> drbg -> generate_counter = 0 ; <S2SV_EndBug> drbg -> reseed_time = time ( NULL ) ; <S2SV_StartBug> if ( drbg -> reseed_counter > 0 ) { <S2SV_EndBug> if ( drbg -> parent == NULL ) <S2SV_StartBug> drbg -> reseed_counter ++ ; <S2SV_EndBug> else <S2SV_StartBug> drbg -> reseed_counter = drbg -> parent -> reseed_counter ; <S2SV_EndBug> } end : if ( entropy != NULL && drbg -> cleanup_entropy != NULL ) drbg -> cleanup_entropy ( drbg , entropy , entropylen ) ; if ( drbg -> state == DRBG_READY ) return 1 ; return 0 ; } | <S2SV_ModStart> ; drbg -> reseed_gen_counter <S2SV_ModEnd> = 0 ; <S2SV_ModStart> ( drbg -> reseed_prop_counter <S2SV_ModEnd> > 0 ) <S2SV_ModStart> ) drbg -> reseed_prop_counter <S2SV_ModEnd> ++ ; else <S2SV_ModStart> else drbg -> reseed_prop_counter <S2SV_ModEnd> = drbg -> <S2SV_ModStart> -> parent -> reseed_prop_counter <S2SV_ModEnd> ; } end |
4,467 | CWE-000 void print_shit ( t_assembler * st ) { int i ; int y ; i = 0 ; y = 5 ; print_header ( st , & y ) ; while ( st -> arr [ i ] ) { ft_printf ( "%02x" , st -> arr [ i ] -> op ) ; print_sp_nl ( & y ) ; if ( st -> arr [ i ] -> acb ) { ft_printf ( "%02x" , st -> arr [ i ] -> acb ) ; print_sp_nl ( & y ) ; } print_parameters ( st , i , & y ) ; i ++ ; } <S2SV_StartBug> ft_printf ( "0a\\n" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ++ ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
4,468 | CWE-000 static void stmmac_mac_config_rx_queues_routing ( struct stmmac_priv * priv ) { u32 rx_queues_count = priv -> plat -> rx_queues_to_use ; u32 queue ; u8 packet ; for ( queue = 0 ; queue < rx_queues_count ; queue ++ ) { if ( priv -> plat -> rx_queues_cfg [ queue ] . pkt_route == 0x0 ) continue ; packet = priv -> plat -> rx_queues_cfg [ queue ] . pkt_route ; <S2SV_StartBug> priv -> hw -> mac -> rx_queue_prio ( priv -> hw , packet , queue ) ; <S2SV_EndBug> } } | <S2SV_ModStart> -> mac -> rx_queue_routing <S2SV_ModEnd> ( priv -> |
4,469 | CWE-000 static int loopback_notify_put ( struct snd_kcontrol * kcontrol , struct snd_ctl_elem_value * ucontrol ) { struct loopback * loopback = snd_kcontrol_chip ( kcontrol ) ; unsigned int val ; int change = 0 ; <S2SV_StartBug> val = ucontrol -> value . integer . value [ 0 ] ? 1 : 0 ; <S2SV_EndBug> if ( val != loopback -> setup [ kcontrol -> id . subdevice ] [ kcontrol -> id . device ] . notify ) { loopback -> setup [ kcontrol -> id . subdevice ] [ kcontrol -> id . device ] . notify = val ; change = 1 ; } <S2SV_StartBug> return change ; <S2SV_EndBug> } | <S2SV_ModStart> 1 : 0 ; mutex_lock ( & loopback -> cable_lock ) <S2SV_ModStart> 1 ; } mutex_unlock ( & loopback -> cable_lock ) ; |
4,470 | CWE-000 <S2SV_StartBug> static int _umount_all ( char * mntinfo ) <S2SV_EndBug> { int umount_fail_cnt ; <S2SV_StartBug> char * p , * next ; <S2SV_EndBug> umount_fail_cnt = 0 ; <S2SV_StartBug> next = mntinfo ; <S2SV_EndBug> while ( ( p = readline ( next , & next ) ) != 0 ) { if ( ueld_umount ( p ) < 0 ) umount_fail_cnt ++ ; } <S2SV_StartBug> return umount_fail_cnt ; <S2SV_EndBug> } | <S2SV_ModStart> char * mntinfo , size_t length <S2SV_ModStart> ; char * mnts , * <S2SV_ModStart> , * next ; if ( ( mnts = malloc ( length ) ) == NULL ) return - 1 ; memcpy ( mnts , mntinfo , length ) <S2SV_ModStart> ; next = mnts <S2SV_ModEnd> ; while ( <S2SV_ModStart> ++ ; } free ( mnts ) ; |
4,471 | CWE-000 GameManager * new_game_manager ( ) { GameManager * manager = ( GameManager * ) calloc ( 1 , sizeof ( GameManager ) ) ; if ( ! manager ) { printf ( "Not<S2SV_blank>enough<S2SV_blank>memory!\\n" ) ; exit ( - 1 ) ; } manager -> game = new_game ( ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) ; return manager ; |
4,472 | CWE-000 <S2SV_StartBug> static unsigned short treat_input ( t_input * input , char * line , int i ) <S2SV_EndBug> { char const * s = ft_strtrim ( line ) ; char const * * array = ( char const * * ) ft_strsplit ( s , '<S2SV_blank>' ) ; input -> arg = NULL ; if ( line ) <S2SV_StartBug> my_free ( 13 , line ) ; <S2SV_EndBug> if ( ! array ) return ( 0 ) ; if ( ft_array_length ( array ) > 1 ) input -> arg = ( char * ) array [ 1 ] ; else input -> arg = ft_strdup ( "" ) ; if ( ft_strlen ( array [ 0 ] ) > PATH_MAX || ( input -> arg && ft_strlen ( input -> arg ) > PATH_MAX ) ) return ( 0 ) ; input -> cmd = get_type ( array [ 0 ] , input -> arg ) ; while ( array [ i ] ) { if ( i != 1 ) <S2SV_StartBug> my_free ( 16 , ( void * ) array [ i ] ) ; <S2SV_EndBug> i ++ ; } <S2SV_StartBug> sub_free ( ( void * ) array , ( void * ) s ) ; <S2SV_EndBug> return ( input -> cmd ) ; } | <S2SV_ModStart> short treat_input ( t_config * config , <S2SV_ModStart> 13 , line , config -> options <S2SV_ModStart> [ i ] , config -> options <S2SV_ModStart> } sub_free ( config , |
4,473 | CWE-000 int32_t do_chmod ( int32_t perm [ 3 ] , char * path , uint32_t * length , char * * cmd_msg ) { <S2SV_StartBug> int32_t ret_val = 0 ; <S2SV_EndBug> char * err_msg = NULL ; MSG_CHMOD * msg = NULL ; char * ls_result = NULL ; MSG_COMN * comn_msg = NULL ; msg = ( MSG_CHMOD * ) malloc ( sizeof ( MSG_CHMOD ) + strlen ( path ) ) ; if ( ! msg ) { LOG_EXCEPTION ( "Error<S2SV_blank>allocating<S2SV_blank>buffers." , 0 , NEQ , 0 , FALSE ) ; ret_val = - 1 ; goto EXIT_LABEL ; } memset ( msg , 0 , sizeof ( MSG_CHMOD ) + strlen ( path ) ) ; msg -> hdr . cmd = CHMOD ; msg -> hdr . is_request = TRUE ; msg -> hdr . response = 0 ; msg -> hdr . length = sizeof ( MSG_CHMOD ) + strlen ( path ) ; msg -> perms [ 0 ] = ( uint8_t ) perm [ 0 ] ; msg -> perms [ 1 ] = ( uint8_t ) perm [ 1 ] ; msg -> perms [ 2 ] = ( uint8_t ) perm [ 2 ] ; strncpy ( msg -> comn . data , path , strlen ( path ) ) ; ret_val = send_data ( sock_fd , msg -> hdr . length , ( char * ) msg ) ; if ( ret_val != msg -> hdr . length ) { LOG_EXCEPTION ( "Error<S2SV_blank>sending<S2SV_blank>data<S2SV_blank>to<S2SV_blank>server." , ret_val , EQ , msg -> hdr . length , FALSE ) ; goto EXIT_LABEL ; } memset ( msg , 0 , sizeof ( MSG_CD ) ) ; ret_val = receive_data ( sock_fd , sizeof ( MSG_HDR ) , ( char * ) msg ) ; if ( ret_val != sizeof ( MSG_HDR ) ) { LOG_EXCEPTION ( "Error<S2SV_blank>receiving<S2SV_blank>response" , ret_val , EQ , sizeof ( MSG_HDR ) , FALSE ) ; goto EXIT_LABEL ; } ls_result = ( char * ) malloc ( msg -> hdr . length - sizeof ( MSG_HDR ) ) ; if ( ! ls_result ) { LOG_EXCEPTION ( "Error<S2SV_blank>allocating<S2SV_blank>buffers." , 0 , NEQ , 0 , FALSE ) ; ret_val = - 1 ; goto EXIT_LABEL ; } ret_val = receive_data ( sock_fd , msg -> hdr . length - sizeof ( MSG_HDR ) , ( char * ) ls_result ) ; if ( ret_val != msg -> hdr . length - sizeof ( MSG_HDR ) ) { LOG_EXCEPTION ( "Error<S2SV_blank>receiving<S2SV_blank>response" , ret_val , EQ , msg -> hdr . length - sizeof ( MSG_HDR ) , FALSE ) ; goto EXIT_LABEL ; } comn_msg = ( MSG_COMN * ) ( ( unsigned char * ) ls_result + ( sizeof ( uint8_t ) * 3 ) ) ; if ( ! ( msg -> hdr . is_request ) && ! ( msg -> hdr . response == 1 ) ) { if ( ! msg -> hdr . is_request ) { LOG_EXCEPTION ( "Malformed<S2SV_blank>reply!" , 0 , EQ , 1 , FALSE ) ; ret_val = - 1 ; goto EXIT_LABEL ; } fprintf ( stdout , "%s\\n" , ( char * ) comn_msg ) ; } EXIT_LABEL : if ( msg != NULL ) { free ( msg ) ; msg = NULL ; } if ( ls_result != NULL ) { free ( ls_result ) ; ls_result = NULL ; } <S2SV_StartBug> return ( ret_val ) ; <S2SV_EndBug> } | <S2SV_ModStart> cmd_msg ) { ENTRY ( ) ; <S2SV_ModStart> NULL ; } EXIT ( ) ; |
4,474 | CWE-000 void flash_icon ( int sound ) { # ifdef _WIN32 FLASHWINFO fi ; <S2SV_StartBug> if ( GetActiveWindow ( ) == hw ) <S2SV_EndBug> return 0 ; fi . hwnd = hw ; fi . cbSize = sizeof ( FLASHWINFO ) ; fi . dwFlags = FLASHW_ALL | FLASHW_TIMERNOFG ; fi . uCount = 0 ; fi . dwTimeout = 0 ; FlashWindowEx ( & fi ) ; if ( sound ) { PlaySound ( TEXT ( "notification.wav" ) , NULL , SND_FILENAME ) ; } # endif } | <S2SV_ModStart> ) == hw ) if ( sound != SOUND_ALWAYS |
4,475 | CWE-000 <S2SV_StartBug> static int __parse_config_parse_value ( ) <S2SV_EndBug> { return 0 ; } | <S2SV_ModStart> int __parse_config_parse_value ( void |
4,476 | CWE-000 char * cap_string ( char * str ) { int i , j ; char n [ 13 ] = { '<S2SV_blank>' , '\\n' , '\\t' , ',' , ';' , '.' , '!' , '?' , \'"\' , '(' , ')' , '{' , '}' } ; char * hey ; hey = n ; i = 1 ; j = 0 ; while ( str [ i ] != '\\0' ) { while ( j < 13 ) { if ( * ( ( str + i ) - 1 ) == hey [ j ] && * ( str + i ) >= 97 && * ( str + i ) <= 122 ) { * ( str + i ) = * ( str + i ) - 32 ; } <S2SV_StartBug> j ++ ; <S2SV_EndBug> } i ++ ; j = 0 ; } return ( str ) ; } | <S2SV_ModStart> 32 ; } else if ( str [ i ] == 0 ) { * ( str + i ) = * ( str + i ) - 32 ; } |
4,477 | CWE-000 static ssize_t chars_in_buffer ( struct tty_struct * tty ) { struct n_tty_data * ldata = tty -> disc_data ; ssize_t n = 0 ; if ( ! ldata -> icanon ) <S2SV_StartBug> n = read_cnt ( ldata ) ; <S2SV_EndBug> else n = ldata -> canon_head - ldata -> read_tail ; return n ; } | <S2SV_ModStart> ) n = ldata -> commit_head - ldata -> read_tail <S2SV_ModEnd> ; else n |
4,478 | CWE-000 <S2SV_StartBug> float * HarmonicProductSpectrum ( double * * AudioData , int size , int dftBlocksize , int hpsOvr , int samplerate ) <S2SV_EndBug> { int i , j , limit , numBlocks , loudestIndex ; double loudestOfBlock ; assert ( size % dftBlocksize == 0 ) ; numBlocks = size / dftBlocksize ; float * loudestFreq = malloc ( sizeof ( float ) * numBlocks ) ; double * AudioDataCopy = malloc ( sizeof ( double ) * dftBlocksize ) ; printf ( "size:<S2SV_blank>%d\\n" , size ) ; printf ( "dftblocksize:<S2SV_blank>%d\\n" , dftBlocksize ) ; for ( int blockstart = 0 ; blockstart < size ; blockstart += dftBlocksize ) { for ( i = 0 ; i < dftBlocksize ; ++ i ) { AudioDataCopy [ i ] = ( * AudioData ) [ blockstart + i ] ; } for ( i = 2 ; i <= hpsOvr ; i ++ ) { limit = dftBlocksize / i ; for ( j = 0 ; j <= limit ; j ++ ) { ( * AudioData ) [ blockstart + j ] *= AudioDataCopy [ j * i ] ; } } loudestOfBlock = 0.0 ; for ( i = 0 ; i < dftBlocksize ; ++ i ) { if ( ( * AudioData ) [ blockstart + i ] > loudestOfBlock ) { loudestOfBlock = ( * AudioData ) [ blockstart + i ] ; loudestIndex = i ; } } <S2SV_StartBug> loudestFreq [ blockstart / dftBlocksize ] = BinToFreq ( loudestIndex , dftBlocksize , samplerate ) ; <S2SV_EndBug> } free ( AudioDataCopy ) ; return loudestFreq ; } | <S2SV_ModStart> , int hpsOvr , int fftSize <S2SV_ModStart> ( loudestIndex , fftSize <S2SV_ModEnd> , samplerate ) |
4,479 | CWE-000 void osql_checkboard_for_each ( void * arg , int ( * func ) ( void * , void * ) ) { <S2SV_StartBug> int rc ; <S2SV_EndBug> if ( ! checkboard ) return ; Pthread_rwlock_rdlock ( & checkboard -> rwlock ) ; hash_for ( checkboard -> rqs , func , arg ) ; hash_for ( checkboard -> rqsuuid , func , arg ) ; Pthread_rwlock_unlock ( & checkboard -> rwlock ) ; } | <S2SV_ModStart> ) ) { <S2SV_ModEnd> if ( ! |
4,480 | CWE-000 static void gfs2_metapath_ra ( struct gfs2_glock * gl , const struct buffer_head * bh , const __be64 * pos ) { struct buffer_head * rabh ; const __be64 * endp = ( const __be64 * ) ( bh -> b_data + bh -> b_size ) ; const __be64 * t ; for ( t = pos ; t < endp ; t ++ ) { if ( ! * t ) continue ; rabh = gfs2_getbuf ( gl , be64_to_cpu ( * t ) , CREATE ) ; if ( trylock_buffer ( rabh ) ) { if ( ! buffer_uptodate ( rabh ) ) { rabh -> b_end_io = end_buffer_read_sync ; <S2SV_StartBug> submit_bh ( REQ_OP_READ , REQ_RAHEAD | REQ_META , <S2SV_EndBug> rabh ) ; continue ; } unlock_buffer ( rabh ) ; } brelse ( rabh ) ; } } | <S2SV_ModStart> REQ_RAHEAD | REQ_META | REQ_PRIO |
4,481 | CWE-000 int rviValidateCredential ( TRviHandle handle , const char * cred , X509 * cert ) { if ( ! handle || ! cred ) { return EINVAL ; } int ret ; TRviContext * ctx = ( TRviContext * ) handle ; char * key ; jwt_t * jwt ; long length ; time_t rawtime ; BIO * bio = { 0 } ; X509 * dcert = { 0 } ; const char certHead [ ] = "-----BEGIN<S2SV_blank>CERTIFICATE-----\\n" ; const char certFoot [ ] = "\\n-----END<S2SV_blank>CERTIFICATE-----" ; <S2SV_StartBug> ret = RVI_OK ; <S2SV_EndBug> key = rviGetPubkeyFile ( ctx -> cafile ) ; if ( ! key ) { ret = - 1 ; goto exit ; } length = strlen ( key ) + 1 ; ret = jwt_decode ( & jwt , cred , ( unsigned char * ) key , length ) ; if ( ret ) { goto exit ; } if ( jwt_get_alg ( jwt ) != JWT_ALG_RS256 ) { ret = 1 ; goto exit ; } time ( & rawtime ) ; json_t * validity = rviGetJsonGrant ( jwt , "validity" ) ; int start = json_integer_value ( json_object_get ( validity , "start" ) ) ; int stop = json_integer_value ( json_object_get ( validity , "stop" ) ) ; if ( ( start > rawtime ) || ( stop < rawtime ) ) { ret = - 1 ; goto exit ; } const char * deviceCert = jwt_get_grant ( jwt , "device_cert" ) ; <S2SV_StartBug> char * tmp = malloc ( strlen ( deviceCert ) + strlen ( certHead ) <S2SV_EndBug> + strlen ( certFoot ) + 1 ) ; if ( ! tmp ) { ret = ENOMEM ; goto exit ; } sprintf ( tmp , "%s%s%s" , certHead , deviceCert , certFoot ) ; bio = BIO_new ( BIO_s_mem ( ) ) ; BIO_puts ( bio , ( const char * ) tmp ) ; dcert = PEM_read_bio_X509 ( bio , NULL , 0 , NULL ) ; if ( ! dcert ) { ret = RVI_ERR_OPENSSL ; goto exit ; } ret = X509_cmp ( dcert , cert ) ; exit : jwt_free ( jwt ) ; if ( key ) free ( key ) ; if ( validity ) json_decref ( validity ) ; if ( tmp ) free ( tmp ) ; BIO_free_all ( bio ) ; X509_free ( dcert ) ; return ret ; } | <S2SV_ModStart> = "\\n-----END<S2SV_blank>CERTIFICATE-----" ; char * tmp = NULL ; <S2SV_ModStart> "device_cert" ) ; <S2SV_ModEnd> tmp = malloc |
4,482 | CWE-000 void gsp_app_create ( const char * name , const char * comment , <S2SV_StartBug> const char * exec ) <S2SV_EndBug> { GspAppManager * manager ; GspAppPrivate * priv ; GspApp * app ; char * basename ; char * * argv ; int argc ; g_return_if_fail ( ! gsm_util_text_is_blank ( exec ) ) ; if ( ! g_shell_parse_argv ( exec , & argc , & argv , NULL ) ) { return ; } basename = _gsp_find_free_basename ( argv [ 0 ] ) ; g_strfreev ( argv ) ; if ( basename == NULL ) { return ; } app = g_object_new ( GSP_TYPE_APP , NULL ) ; priv = gsp_app_get_instance_private ( app ) ; priv -> basename = basename ; priv -> path = g_build_filename ( g_get_user_config_dir ( ) , "autostart" , priv -> basename , NULL ) ; priv -> hidden = FALSE ; priv -> enabled = TRUE ; if ( ! gsm_util_text_is_blank ( name ) ) { priv -> name = g_strdup ( name ) ; } else { priv -> name = g_strdup ( exec ) ; } priv -> exec = g_strdup ( exec ) ; priv -> comment = g_strdup ( comment ) ; <S2SV_StartBug> priv -> icon = NULL ; <S2SV_EndBug> priv -> gicon = NULL ; _gsp_app_update_description ( app ) ; priv -> xdg_position = 0 ; priv -> xdg_system_position = G_MAXUINT ; priv -> save_timeout = 0 ; priv -> save_mask |= GSP_ASP_SAVE_MASK_ALL ; priv -> old_system_path = NULL ; priv -> skip_next_monitor_event = FALSE ; _gsp_app_queue_save ( app ) ; manager = gsp_app_manager_get ( ) ; gsp_app_manager_add ( manager , app ) ; g_object_unref ( app ) ; g_object_unref ( manager ) ; } | <S2SV_ModStart> char * exec , guint delay <S2SV_ModStart> ; priv -> delay = delay ; priv -> |
4,483 | CWE-000 static <S2SV_StartBug> void broker_handle_req ( RemoteDSLink * link , json_t * req ) { <S2SV_EndBug> json_t * jRid = json_object_get ( req , "rid" ) ; if ( ! jRid ) { <S2SV_StartBug> return ; <S2SV_EndBug> } const char * method = json_string_value ( json_object_get ( req , "method" ) ) ; uint32_t r = ( uint32_t ) json_integer_value ( jRid ) ; ref_t * ref = dslink_map_get ( & link -> requester_streams , & r ) ; if ( ref && ! method ) { BrokerInvokeStream * stream = ref -> data ; if ( stream -> continuous_invoke ) { json_t * params = json_object_get ( req , "params" ) ; stream -> continuous_invoke ( link , params ) ; } <S2SV_StartBug> return ; <S2SV_EndBug> } if ( ! method ) { <S2SV_StartBug> return ; <S2SV_EndBug> } if ( strcmp ( method , "list" ) == 0 ) { if ( broker_msg_handle_list ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>list<S2SV_blank>request\\n" ) ; } } else if ( strcmp ( method , "invoke" ) == 0 ) { if ( broker_msg_handle_invoke ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>handle<S2SV_blank>invocation<S2SV_blank>request\\n" ) ; } } else if ( strcmp ( method , "subscribe" ) == 0 ) { if ( broker_msg_handle_subscribe ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>subscribe<S2SV_blank>request\\n" ) ; } } else if ( strcmp ( method , "unsubscribe" ) == 0 ) { if ( broker_msg_handle_unsubscribe ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>unsubscribe<S2SV_blank>request\\n" ) ; } } else if ( strcmp ( method , "set" ) == 0 ) { if ( broker_msg_handle_set ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>set<S2SV_blank>request" ) ; } } else if ( strcmp ( method , "remove" ) == 0 ) { if ( broker_msg_handle_remove ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>remove<S2SV_blank>request" ) ; } } else if ( strcmp ( method , "close" ) == 0 ) { if ( broker_msg_handle_close ( link , req ) != 0 ) { log_err ( "Failed<S2SV_blank>to<S2SV_blank>handle<S2SV_blank>close<S2SV_blank>request\\n" ) ; } } else { log_err ( "Method<S2SV_blank>unhandled:<S2SV_blank>%s\\n" , method ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> broker_handle_req ( RemoteDSLink <S2SV_ModStart> ) { return 1 <S2SV_ModStart> ; } return 1 <S2SV_ModStart> ) { return 1 <S2SV_ModStart> ) ; } return 1 ; |
4,484 | CWE-000 void solartimer_loop ( ) { if ( timer_value_target == TIMER_INACTIVE ) { if ( refresh_needed ) { refresh_needed = false ; senddigits ( adc_val ( ) ) ; } if ( check_action_button_status ( ) ) { <S2SV_StartBug> start_timer ( ) ; <S2SV_EndBug> timer_value_target = adc_val ( ) ; } } else if ( timer_value_target == TIMER_FINISHED ) { if ( refresh_needed ) { refresh_needed = false ; senddigits ( timer_elapsed_secs ) ; } if ( check_action_button_status ( ) ) { timer_value_target = TIMER_INACTIVE ; } } else { update_timer ( ) ; if ( refresh_needed ) { refresh_needed = false ; if ( drop_condition_reached ) { senddigits ( timer_elapsed_secs ) ; } else { senddashes ( ) ; } } } } | <S2SV_ModStart> ) { start_timer <S2SV_ModEnd> ( ) ; |
4,485 | CWE-000 static void applyMask ( const uint8_t functionModules [ ] , uint8_t qrcode [ ] , enum qrcodegen_Mask mask ) { assert ( 0 <= ( int ) mask && ( int ) mask <= 7 ) ; int qrsize = qrcodegen_getSize ( qrcode ) ; for ( int y = 0 ; y < qrsize ; y ++ ) { for ( int x = 0 ; x < qrsize ; x ++ ) { if ( getModule ( functionModules , x , y ) ) continue ; <S2SV_StartBug> bool invert ; <S2SV_EndBug> switch ( ( int ) mask ) { case 0 : invert = ( x + y ) % 2 == 0 ; break ; case 1 : invert = y % 2 == 0 ; break ; case 2 : invert = x % 3 == 0 ; break ; case 3 : invert = ( x + y ) % 3 == 0 ; break ; case 4 : invert = ( x / 3 + y / 2 ) % 2 == 0 ; break ; case 5 : invert = x * y % 2 + x * y % 3 == 0 ; break ; case 6 : invert = ( x * y % 2 + x * y % 3 ) % 2 == 0 ; break ; case 7 : invert = ( ( x + y ) % 2 + x * y % 3 ) % 2 == 0 ; break ; default : assert ( false ) ; } bool val = getModule ( qrcode , x , y ) ; setModule ( qrcode , x , y , val ^ invert ) ; } } } | <S2SV_ModStart> ; bool invert = false |
4,486 | CWE-000 ts_event_t * ts_poll ( ts_t * server ) { if ( server == NULL ) return ( NULL ) ; <S2SV_StartBug> if ( ll_empty ( server -> events ) <= 0 ) <S2SV_EndBug> return ( NULL ) ; return ( ll_pop ( server -> events ) ) ; } | <S2SV_ModStart> NULL ) ; <S2SV_ModEnd> return ( ll_pop |
4,487 | CWE-000 int pw_verify_be_dn ( Slapi_PBlock * pb , Slapi_Entry * * referral ) { <S2SV_StartBug> int rc = 0 ; <S2SV_EndBug> Slapi_Backend * be = NULL ; if ( slapi_mapping_tree_select ( pb , & be , referral , NULL , 0 ) != LDAP_SUCCESS ) { return SLAPI_BIND_NO_BACKEND ; } if ( * referral ) { slapi_be_Unlock ( be ) ; return SLAPI_BIND_REFERRAL ; } slapi_pblock_set ( pb , SLAPI_BACKEND , be ) ; if ( be -> be_bind == NULL ) { slapi_be_Unlock ( be ) ; return LDAP_OPERATIONS_ERROR ; } slapi_pblock_set ( pb , SLAPI_PLUGIN , be -> be_database ) ; set_db_default_result_handlers ( pb ) ; rc = ( * be -> be_bind ) ( pb ) ; slapi_be_Unlock ( be ) ; return rc ; } | <S2SV_ModStart> int rc = SLAPI_BIND_SUCCESS <S2SV_ModEnd> ; Slapi_Backend * |
4,488 | CWE-000 void print_shape ( struct shape s ) { if ( s . num_e ) { print_edges ( s ) ; <S2SV_StartBug> } else { <S2SV_EndBug> print_vertices ( s ) ; } } | <S2SV_ModStart> ) ; } if ( s . print_vertices ) <S2SV_ModEnd> { print_vertices ( |
4,489 | CWE-000 int OpenMV_Main ( uint32_t first_soft_reset ) { int ret = 0 ; PRINTF ( "Enter<S2SV_blank>OpenMV<S2SV_blank>main\\r\\n" ) ; led_state ( LED_IR , 0 ) ; led_state ( LED_RED , 1 ) ; led_state ( LED_GREEN , 1 ) ; led_state ( LED_BLUE , 1 ) ; OverlaySwitch ( OVLY_YUV_TAB ) ; fb_alloc_init0 ( ) ; file_buffer_init0 ( ) ; MainLoop : if ( first_soft_reset ) { first_soft_reset = 0 ; exec_boot_script ( "/sd/selftest.py" , true , false ) ; apply_settings ( "/sd/openmv.config" ) ; usbdbg_set_irq_enabled ( true ) ; mp_import_stat_t stat = mp_import_stat ( "main.py" ) ; if ( stat == MP_IMPORT_STAT_FILE ) { nlr_buf_t nlr ; if ( nlr_push ( & nlr ) == 0 ) { int ret = pyexec_file ( "main.py" ) ; if ( ret & PYEXEC_FORCED_EXIT ) { ret = 1 ; } if ( ! ret ) { flash_error ( 3 ) ; } nlr_pop ( ) ; } } } while ( ! usbdbg_script_ready ( ) ) { nlr_buf_t nlr ; if ( nlr_push ( & nlr ) == 0 ) { usbdbg_set_irq_enabled ( true ) ; if ( pyexec_mode_kind == PYEXEC_MODE_RAW_REPL ) { if ( pyexec_raw_repl ( ) != 0 ) { break ; } } else { if ( pyexec_friendly_repl ( ) != 0 ) { ret = 1 ; break ; } } nlr_pop ( ) ; } } if ( usbdbg_script_ready ( ) ) { nlr_buf_t nlr ; PRINTF ( "script<S2SV_blank>ready!\\r\\n" ) ; if ( nlr_push ( & nlr ) == 0 ) { <S2SV_StartBug> # if 1 <S2SV_EndBug> vstr_t * buf = usbdbg_get_script ( ) ; mp_obj_t code = pyexec_compile_str ( buf ) ; usbdbg_set_irq_enabled ( true ) ; pyexec_exec_code ( code ) ; # else <S2SV_StartBug> pyexec_str ( usbdbg_get_script ( ) ) ; <S2SV_EndBug> # endif nlr_pop ( ) ; } else { mp_obj_print_exception ( & mp_plat_print , ( mp_obj_t ) nlr . ret_val ) ; } } usbdbg_set_irq_enabled ( true ) ; return ret ; } | <S2SV_ModStart> { # if 0 <S2SV_ModEnd> vstr_t * buf <S2SV_ModStart> ; # else usbdbg_set_irq_enabled ( true ) ; |
4,490 | CWE-000 static void prune_non_exact ( struct robot_specs * specs ) { struct path_info * newpaths ; int i , j , cnt ; cnt = 0 ; for ( i = 0 ; i < specs -> count ; i ++ ) if ( specs -> paths [ i ] . user_agent_exact_p ) ++ cnt ; newpaths = xnew_array ( struct path_info , cnt ) ; for ( i = 0 , j = 0 ; i < specs -> count ; i ++ ) if ( specs -> paths [ i ] . user_agent_exact_p ) newpaths [ j ++ ] = specs -> paths [ i ] ; <S2SV_StartBug> assert ( j == cnt ) ; <S2SV_EndBug> xfree ( specs -> paths ) ; specs -> paths = newpaths ; specs -> count = cnt ; specs -> size = cnt ; } | <S2SV_ModStart> i ] ; else xfree ( specs -> paths [ i ] . path ) ; |
4,491 | CWE-000 int ft_datas_init ( t_datas * datas , char * buff ) { datas -> result = NULL ; if ( ! ( datas -> tmp_args = ft_get_argslist ( datas , buff ) ) ) return ( - 1 ) ; datas -> args = datas -> tmp_args ; datas -> flags = NULL ; datas -> len = 0 ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> = 0 ; datas -> cplen = 0 ; |
4,492 | CWE-000 mlt_properties mlt_properties_parse_yaml ( const char * filename ) { mlt_properties self = mlt_properties_new ( ) ; if ( self ) { <S2SV_StartBug> mlt_properties_set ( self , "_mlt_properties_parse_yaml" , filename ) ; <S2SV_EndBug> mlt_properties_from_utf8 ( self , "_mlt_properties_parse_yaml" , "__mlt_properties_parse_yaml" ) ; filename = mlt_properties_get ( self , "__mlt_properties_parse_yaml" ) ; <S2SV_StartBug> FILE * file = fopen ( filename , "r" ) ; <S2SV_EndBug> if ( file ) { char temp [ 1024 ] ; char * ptemp = & temp [ 0 ] ; mlt_properties_set_lcnumeric ( self , "C" ) ; yaml_parser context = calloc ( 1 , sizeof ( struct yaml_parser_context ) ) ; context -> stack = mlt_deque_init ( ) ; context -> index_stack = mlt_deque_init ( ) ; mlt_deque_push_back ( context -> stack , self ) ; mlt_deque_push_back_int ( context -> index_stack , 0 ) ; while ( fgets ( temp , 1024 , file ) ) { if ( strncmp ( ptemp , "..." , 3 ) == 0 ) break ; temp [ strlen ( temp ) - 1 ] = '\\0' ; if ( strcmp ( ptemp , "" ) && ptemp [ 0 ] != '#' && strncmp ( ptemp , "---" , 3 ) && strncmp ( ptemp , "%YAML" , 5 ) && strncmp ( ptemp , "%<S2SV_blank>YAML" , 6 ) ) parse_yaml ( context , temp ) ; } fclose ( file ) ; mlt_deque_close ( context -> stack ) ; mlt_deque_close ( context -> index_stack ) ; free ( context -> block_name ) ; free ( context ) ; } } return self ; } | <S2SV_ModStart> self ) { <S2SV_ModEnd> FILE * file <S2SV_ModStart> * file = mlt_fopen <S2SV_ModEnd> ( filename , |
4,493 | CWE-000 void pushMemoryStack ( ) { <S2SV_StartBug> pushMemoryStackInternal ( & gData . mMemoryStack ) ; <S2SV_EndBug> } | <S2SV_ModStart> pushMemoryStackInternal ( & gMemoryHandler <S2SV_ModEnd> . mMemoryStack ) |
4,494 | CWE-000 void envPrint ( env_t * e ) { <S2SV_StartBug> printf ( "<S2SV_blank>Env=<S2SV_blank>Count(%lu){" , e -> count ) ; <S2SV_EndBug> for ( size_t i = 0 ; i < e -> count ; ++ i ) { printf ( "[%s," , e -> syms [ i ] ) ; valPrint ( e -> vars [ i ] ) ; <S2SV_StartBug> printf ( "]" ) ; <S2SV_EndBug> } printf ( "}" ) ; } | <S2SV_ModStart> { printf ( "Env[%lu]={<S2SV_blank>" <S2SV_ModEnd> , e -> <S2SV_ModStart> ; printf ( "]<S2SV_blank>" <S2SV_ModEnd> ) ; } |
4,495 | CWE-000 static lv_res_t lv_img_built_in_decoder_line_alpha ( lv_coord_t x , lv_coord_t y , lv_coord_t len , uint8_t * buf ) { const lv_opa_t alpha1_opa_table [ 2 ] = { 0 , 255 } ; const lv_opa_t alpha2_opa_table [ 4 ] = { 0 , 85 , 170 , 255 } ; const lv_opa_t alpha4_opa_table [ 16 ] = { 0 , 17 , 34 , 51 , 68 , 85 , 102 , 119 , 136 , 153 , 170 , 187 , 204 , 221 , 238 , 255 } ; lv_color_t bg_color = decoder_style -> image . color ; lv_coord_t i ; for ( i = 0 ; i < len ; i ++ ) { # if LV_COLOR_DEPTH == 8 buf [ i * LV_IMG_PX_SIZE_ALPHA_BYTE ] = bg_color . full ; # elif LV_COLOR_DEPTH == 16 buf [ i * LV_IMG_PX_SIZE_ALPHA_BYTE ] = bg_color . full & 0xFF ; buf [ i * LV_IMG_PX_SIZE_ALPHA_BYTE + 1 ] = ( bg_color . full >> 8 ) & 0xFF ; # elif LV_COLOR_DEPTH == 24 * ( ( uint32_t * ) & buf [ i * LV_IMG_PX_SIZE_ALPHA_BYTE ] ) = bg_color . full ; # endif } const lv_img_dsc_t * img_dsc = decoder_src ; const uint8_t * data_tmp = img_dsc -> data ; const lv_opa_t * opa_table = NULL ; <S2SV_StartBug> uint8_t px_size = lv_img_color_format_get_px_size ( img_dsc -> header . color_format ) ; <S2SV_EndBug> uint16_t mask = ( 1 << px_size ) - 1 ; lv_coord_t w = 0 ; int8_t pos = 0 ; <S2SV_StartBug> switch ( img_dsc -> header . color_format ) { <S2SV_EndBug> case LV_IMG_FORMAT_ALPHA_1BIT : w = ( img_dsc -> header . w >> 3 ) ; if ( img_dsc -> header . w & 0x7 ) w ++ ; data_tmp += w * y + ( x >> 3 ) ; pos = 7 - ( x & 0x7 ) ; opa_table = alpha1_opa_table ; break ; case LV_IMG_FORMAT_ALPHA_2BIT : w = ( img_dsc -> header . w >> 2 ) ; if ( img_dsc -> header . w & 0x3 ) w ++ ; data_tmp += w * y + ( x >> 2 ) ; pos = 6 - ( ( x & 0x3 ) * 2 ) ; opa_table = alpha2_opa_table ; break ; case LV_IMG_FORMAT_ALPHA_4BIT : w = ( img_dsc -> header . w >> 1 ) ; if ( img_dsc -> header . w & 0x1 ) w ++ ; data_tmp += w * y + ( x >> 1 ) ; pos = 4 - ( ( x & 0x1 ) * 4 ) ; opa_table = alpha4_opa_table ; break ; case LV_IMG_FORMAT_ALPHA_8BIT : w = img_dsc -> header . w ; data_tmp += w * y + x ; pos = 0 ; break ; } uint8_t byte_act = 0 ; uint8_t val_act ; for ( i = 0 ; i < len ; i ++ ) { val_act = ( data_tmp [ byte_act ] & ( mask << pos ) ) >> pos ; buf [ i * LV_IMG_PX_SIZE_ALPHA_BYTE + LV_IMG_PX_SIZE_ALPHA_BYTE - 1 ] = <S2SV_StartBug> img_dsc -> header . color_format == LV_IMG_FORMAT_ALPHA_8BIT ? val_act : opa_table [ val_act ] ; <S2SV_EndBug> pos -= px_size ; if ( pos < 0 ) { pos = 8 - px_size ; data_tmp ++ ; } } return LV_RES_OK ; } | <S2SV_ModStart> -> header . cf <S2SV_ModEnd> ) ; uint16_t <S2SV_ModStart> -> header . cf <S2SV_ModEnd> ) { case <S2SV_ModStart> -> header . cf <S2SV_ModEnd> == LV_IMG_FORMAT_ALPHA_8BIT ? |
4,496 | CWE-000 int selectCardAndPeformActions ( int card , int choice1 , int choice2 , int choice3 , struct gameState * state , int handPos , int * bonus , int cardDrawn , int * temphand , int z2 , int i2 ) { <S2SV_StartBug> int result ; <S2SV_EndBug> result = - 1 ; if ( card == adventurer ) { <S2SV_StartBug> result = peformAdventurerActions ( card , choice1 , choice2 , choice3 , state , handPos , bonus , cardDrawn , * temphand , z2 , i2 ) ; <S2SV_EndBug> } else if ( card == smithy ) { <S2SV_StartBug> result = peformsmithyActions ( card , choice1 , choice2 , choice3 , state , handPos , bonus , cardDrawn , * temphand , z2 , i2 ) ; <S2SV_EndBug> } else if ( card == baron ) { <S2SV_StartBug> result = peformBaronActions ( card , choice1 , choice2 , choice3 , state , handPos , bonus , cardDrawn , * temphand , z2 , i2 ) ; <S2SV_EndBug> } else if ( card == salvager ) { <S2SV_StartBug> result = peformSalvagerActions ( card , choice1 , choice2 , choice3 , state , handPos , bonus , cardDrawn , * temphand , z2 , i2 ) ; <S2SV_EndBug> } else if ( card == sea_hag ) { <S2SV_StartBug> result = peformSeaHagctions ( card , choice1 , choice2 , choice3 , state , handPos , bonus , cardDrawn , * temphand , z2 , i2 ) ; <S2SV_EndBug> } return result ; } | <S2SV_ModStart> ) { int currentPlayer = whoseTurn ( state ) ; int <S2SV_ModStart> , handPos , currentPlayer <S2SV_ModEnd> , cardDrawn , <S2SV_ModStart> , handPos , currentPlayer <S2SV_ModEnd> , cardDrawn , <S2SV_ModStart> , handPos , currentPlayer <S2SV_ModEnd> , cardDrawn , <S2SV_ModStart> , handPos , currentPlayer <S2SV_ModEnd> , cardDrawn , <S2SV_ModStart> , handPos , currentPlayer <S2SV_ModEnd> , cardDrawn , |
4,497 | CWE-000 int main ( int argc , char * argv [ ] ) { int sockfd , numbytes ; char buf [ MAXDATASIZE ] ; struct addrinfo hints , * servinfo , * p ; int rv ; char s [ INET6_ADDRSTRLEN ] ; char cmd = 't' ; if ( argc != 2 ) { fprintf ( stderr , "usage:<S2SV_blank>client<S2SV_blank>hostname\\n" ) ; exit ( 1 ) ; } memset ( & hints , 0 , sizeof hints ) ; hints . ai_family = AF_UNSPEC ; hints . ai_socktype = SOCK_STREAM ; if ( ( rv = getaddrinfo ( argv [ 1 ] , PORT , & hints , & servinfo ) ) != 0 ) { fprintf ( stderr , "getaddrinfo:<S2SV_blank>%s\\n" , gai_strerror ( rv ) ) ; return 1 ; } for ( p = servinfo ; p != NULL ; p = p -> ai_next ) { if ( ( sockfd = socket ( p -> ai_family , p -> ai_socktype , p -> ai_protocol ) ) == - 1 ) { perror ( "client:<S2SV_blank>socket" ) ; continue ; } if ( connect ( sockfd , p -> ai_addr , p -> ai_addrlen ) == - 1 ) { close ( sockfd ) ; perror ( "client:<S2SV_blank>connect" ) ; continue ; } break ; } if ( p == NULL ) { fprintf ( stderr , "client:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>connect\\n" ) ; return 2 ; } inet_ntop ( p -> ai_family , get_in_addr ( ( struct sockaddr * ) p -> ai_addr ) , s , sizeof s ) ; printf ( "client:<S2SV_blank>connecting<S2SV_blank>to<S2SV_blank>%s\\n" , s ) ; char filename [ MAXDATASIZE ] ; freeaddrinfo ( servinfo ) ; while ( cmd != 'q' ) { printf ( "............Welcome<S2SV_blank>to<S2SV_blank>the<S2SV_blank>MC<S2SV_blank>Command<S2SV_blank>Hub.............\\n" ) ; printf ( "Please<S2SV_blank>input<S2SV_blank>your<S2SV_blank>command........\'input:<S2SV_blank>h<S2SV_blank>for<S2SV_blank>help\'..\\n" ) ; scanf ( "%c" , & cmd ) ; while ( getchar ( ) != '\\n' ) continue ; if ( cmd == 'h' ) { printf ( "Please<S2SV_blank>make<S2SV_blank>your<S2SV_blank>selection<S2SV_blank>from<S2SV_blank>the<S2SV_blank>following<S2SV_blank>commands\\n" ) ; printf ( "\'l\'<S2SV_blank>=<S2SV_blank>List<S2SV_blank>contents<S2SV_blank>of<S2SV_blank>server.....ex(l)...............\\n" ) ; printf ( "\'c\'<S2SV_blank>=<S2SV_blank>Check<S2SV_blank>for<S2SV_blank>a<S2SV_blank>file<S2SV_blank>name.......ex(c<S2SV_blank><filename>)....\\n" ) ; printf ( "\'d\'<S2SV_blank>=<S2SV_blank>Download<S2SV_blank>file<S2SV_blank>name..........ex(d<S2SV_blank><filename>)....\\n" ) ; printf ( "\'p\'<S2SV_blank>=<S2SV_blank>Display<S2SV_blank>file<S2SV_blank>name...........ex(p<S2SV_blank><filename>)....\\n" ) ; printf ( "\'q\'<S2SV_blank>=<S2SV_blank>Quit............................................\\n" ) ; } if ( cmd == 'l' ) { <S2SV_StartBug> char bigBuffer [ 10000000 ] ; <S2SV_EndBug> int bigCount = 0 ; send ( sockfd , "list" , 4 , 0 ) ; do { if ( ( numbytes = recv ( sockfd , buf , MAXDATASIZE - 1 , 0 ) ) == - 1 ) { perror ( "recv" ) ; exit ( 1 ) ; } bigCount += numbytes ; strcat ( bigBuffer , buf ) ; } while ( buf [ numbytes - 1 ] != 0 ) ; bigBuffer [ bigCount ] = '\\0' ; printf ( "%s\\n" , bigBuffer ) ; } if ( cmd == 'c' ) { char ans [ 3 ] ; int numb ; send ( sockfd , "chek" , 4 , 0 ) ; printf ( "Which<S2SV_blank>file<S2SV_blank>do<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>check<S2SV_blank>for?:\\n" ) ; scanf ( "%s" , & filename ) ; while ( getchar ( ) != '\\n' ) continue ; send ( sockfd , filename , MAXDATASIZE , 0 ) ; numb = recv ( sockfd , buf , MAXDATASIZE - 1 , 0 ) ; buf [ numb ] = '\\0' ; if ( ! strcmp ( buf , "yes" ) ) printf ( "File<S2SV_blank>was<S2SV_blank>found\\n" ) ; else printf ( "File<S2SV_blank>was<S2SV_blank>not<S2SV_blank>found\\n" ) ; } if ( cmd == 'p' ) { send ( sockfd , "disp" , 50 , 0 ) ; printf ( "enter<S2SV_blank>file<S2SV_blank>name:<S2SV_blank>\\n" ) ; scanf ( "%s" , & filename ) ; int filesize ; char sizeofFile [ 20 ] = { 0 } ; send ( sockfd , filename , 100 , 0 ) ; numbytes = recv ( sockfd , sizeofFile , 20 , 0 ) ; filesize = ( int ) strtol ( sizeofFile , ( char * * ) NULL , 10 ) ; printf ( "Size<S2SV_blank>file:<S2SV_blank>%d<S2SV_blank>\\n" , filesize ) ; if ( filesize == 0 ) { printf ( "File<S2SV_blank>not<S2SV_blank>found" ) ; continue ; } else { char * filebuff = calloc ( filesize + 1 , sizeof ( char ) ) ; sleep ( 1 ) ; numbytes = recv ( sockfd , filebuff , filesize , 0 ) ; printf ( "Save<S2SV_blank>as:<S2SV_blank>" ) ; scanf ( "%s" , & filename ) ; FILE * fp ; fp = fopen ( filename , "r" ) ; if ( fp != NULL ) { char choice [ 5 ] ; printf ( "File<S2SV_blank>%s<S2SV_blank>exist.<S2SV_blank>Do<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>override?<S2SV_blank>(y/n):<S2SV_blank>" , filename ) ; scanf ( "%4s" , & choice ) ; if ( tolower ( choice [ 0 ] ) == 'n' ) { fclose ( fp ) ; free ( filebuff ) ; continue ; } } fp = fopen ( filename , "w" ) ; if ( NULL == fp ) { printf ( "error<S2SV_blank>opening<S2SV_blank>file" ) ; return 1 ; } fwrite ( filebuff , 1 , filesize , fp ) ; fclose ( fp ) ; free ( filebuff ) ; } close ( sockfd ) ; } if ( cmd == 'q' ) { break ; } } close ( sockfd ) ; return 0 ; } | <S2SV_ModStart> char bigBuffer [ INT_MAX <S2SV_ModEnd> ] ; int |
4,498 | CWE-000 int init_graph ( t_graph * * ptr , int room_type , char * line , t_super * hold ) { * ptr = malloc ( sizeof ( t_graph ) ) ; <S2SV_StartBug> if ( hold -> graph == NULL ) <S2SV_EndBug> hold -> graph = * ptr ; ( * ptr ) -> links = NULL ; ( * ptr ) -> next_room = NULL ; ( * ptr ) -> room_name = NULL ; <S2SV_StartBug> decide_roomtype ( * ptr , room_type ) ; <S2SV_EndBug> return ( set_roomname ( * ptr , line , hold ) ) ; } | <S2SV_ModStart> ) ) ; <S2SV_ModEnd> hold -> graph <S2SV_ModStart> = NULL ; ( * ptr ) -> x = - 1 ; ( * ptr ) -> y = - 1 ; |
4,499 | CWE-000 <S2SV_StartBug> void raftServer ( ) { <S2SV_EndBug> struct sockaddr_in me ; int sfd , recv_len ; struct ip_mreq mreq ; char buf [ BUFLEN ] ; Message m ; int yes = 1 ; if ( ( sfd = socket ( AF_INET , SOCK_DGRAM , IPPROTO_UDP ) ) < 0 ) { perror ( "socket<S2SV_blank>-<S2SV_blank>raftServer" ) ; exit ( 1 ) ; } if ( setsockopt ( sfd , SOL_SOCKET , SO_REUSEADDR , & yes , sizeof ( yes ) ) < 0 ) { perror ( "Reusing<S2SV_blank>ADDR<S2SV_blank>failed" ) ; exit ( 1 ) ; } memset ( & me , 0 , sizeof ( me ) ) ; me . sin_family = AF_INET ; me . sin_addr . s_addr = htonl ( INADDR_ANY ) ; me . sin_port = htons ( GROUP_PORT ) ; if ( bind ( sfd , ( struct sockaddr * ) & me , sizeof ( me ) ) < 0 ) { perror ( "bind<S2SV_blank>-<S2SV_blank>raftServer" ) ; close ( sfd ) ; exit ( 1 ) ; } mreq . imr_multiaddr . s_addr = inet_addr ( GROUP ) ; mreq . imr_interface . s_addr = htonl ( INADDR_ANY ) ; if ( setsockopt ( sfd , IPPROTO_IP , IP_ADD_MEMBERSHIP , & mreq , sizeof ( mreq ) ) < 0 ) { perror ( "setsockopt<S2SV_blank>-<S2SV_blank>raftServer" ) ; exit ( 1 ) ; } while ( 1 ) { if ( ( recv_len = recv ( sfd , buf , BUFLEN , 0 ) ) < 0 ) { perror ( "recv<S2SV_blank>-<S2SV_blank>raftServer" ) ; close ( sfd ) ; exit ( 1 ) ; } deserializeMessage ( & m , buf ) ; enqueue ( sq , & m ) ; } } | <S2SV_ModStart> ( ) { char * s ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.