Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
5,100 | CWE-000 static u8 vmx_msr_bitmap_mode ( struct kvm_vcpu * vcpu ) { u8 mode = 0 ; if ( cpu_has_secondary_exec_ctrls ( ) && ( vmcs_read32 ( SECONDARY_VM_EXEC_CONTROL ) & SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE ) ) { mode |= MSR_BITMAP_MODE_X2APIC ; if ( enable_apicv && kvm_vcpu_apicv_active ( vcpu ) ) mode |= MSR_BITMAP_MODE_X2APIC_APICV ; } <S2SV_StartBug> if ( is_long_mode ( vcpu ) ) <S2SV_EndBug> mode |= MSR_BITMAP_MODE_LM ; return mode ; } | <S2SV_ModStart> MSR_BITMAP_MODE_X2APIC_APICV ; } <S2SV_ModEnd> return mode ; |
5,101 | CWE-000 static int unescape_string_utf8 ( char * in_buf , int sz , char * out_buf ) { <S2SV_StartBug> u_int32_t ch ; <S2SV_EndBug> char temp [ 4 ] ; char * next ; int count_out = 0 ; int count_in = 0 ; int esc_in = 0 ; int esc_out = 0 ; while ( * in_buf && count_in < sz ) { next = in_buf + 1 ; if ( * in_buf == '\\\\' && ! is_json_escape ( next ) ) { <S2SV_StartBug> esc_in = u8_read_escape_sequence ( ( in_buf + 1 ) , & ch ) + 1 ; <S2SV_EndBug> } else { <S2SV_StartBug> ch = ( u_int32_t ) * in_buf ; <S2SV_EndBug> esc_in = 1 ; } in_buf += esc_in ; <S2SV_StartBug> count_in += esc_in ; <S2SV_EndBug> esc_out = u8_wc_toutf8 ( temp , ch ) ; if ( esc_out > sz - count_out ) { flb_error ( "Crossing<S2SV_blank>over<S2SV_blank>string<S2SV_blank>boundary" ) ; break ; } memcpy ( & out_buf [ count_out ] , temp , esc_out ) ; count_out += esc_out ; } if ( count_in < sz ) { flb_error ( "Not<S2SV_blank>at<S2SV_blank>boundary<S2SV_blank>but<S2SV_blank>still<S2SV_blank>NULL<S2SV_blank>terminating<S2SV_blank>:<S2SV_blank>%d<S2SV_blank>-<S2SV_blank>\'%s\'" , sz , in_buf ) ; } out_buf [ count_in - 1 ] = '\\0' ; return count_out ; } | <S2SV_ModStart> out_buf ) { <S2SV_ModEnd> char temp [ <S2SV_ModStart> { esc_in = flb_utils_read_escape_sequence_as_utf8 ( in_buf , sz - count_in , temp , & esc_out ) <S2SV_ModEnd> ; } else <S2SV_ModStart> } else { temp [ 0 ] = * in_buf ; esc_in = 1 ; esc_out <S2SV_ModEnd> = 1 ; <S2SV_ModStart> count_in += esc_in <S2SV_ModEnd> ; if ( |
5,102 | CWE-000 static int ocfs2_trim_extent ( struct super_block * sb , struct ocfs2_group_desc * gd , <S2SV_StartBug> u32 start , u32 count ) <S2SV_EndBug> { u64 discard , bcount ; <S2SV_StartBug> bcount = ocfs2_clusters_to_blocks ( sb , count ) ; <S2SV_EndBug> <S2SV_StartBug> discard = le64_to_cpu ( gd -> bg_blkno ) + <S2SV_EndBug> ocfs2_clusters_to_blocks ( sb , start ) ; trace_ocfs2_trim_extent ( sb , ( unsigned long long ) discard , bcount ) ; return sb_issue_discard ( sb , discard , bcount , GFP_NOFS , 0 ) ; } | <S2SV_ModStart> * gd , u64 group , <S2SV_ModStart> , bcount ; struct ocfs2_super * osb = OCFS2_SB ( sb ) ; <S2SV_ModStart> ; discard = ocfs2_clusters_to_blocks ( sb , start ) ; if ( group != osb -> first_cluster_group_blkno ) discard += <S2SV_ModStart> gd -> bg_blkno <S2SV_ModEnd> ) ; trace_ocfs2_trim_extent |
5,103 | CWE-000 int riichi_claim_phase ( struct riichi_engine * engine , int player_index , struct action_input * input ) { ASSERT_BACKTRACE ( engine ) ; ASSERT_BACKTRACE ( input ) ; engine -> phase = PHASE_CLAIM ; struct player * player = & engine -> players [ player_index ] ; struct net_server * server = & engine -> server ; pk_update update_packet = { packet_type : PACKET_UPDATE , player_pos : player -> player_pos , input : * input , victory : 0 } ; send_to_all_clients ( engine , & update_packet , sizeof ( pk_update ) , player_index ) ; struct action_input claim_input = { tile : input -> tile } ; int player_claim = - 1 ; for ( int c = 0 ; c < NB_PLAYERS ; ++ c ) { if ( c == player_index ) continue ; struct player * other_player = & engine -> players [ c ] ; if ( other_player -> player_type != PLAYER_AI ) continue ; if ( other_player -> player_type == PLAYER_CLIENT ) { pk_input packet ; if ( ! receive_data_from_client ( server , player -> net_id , & packet , sizeof ( pk_input ) ) ) continue ; if ( packet . input . action == ACTION_PASS ) continue ; if ( packet . input . tile != input -> tile ) continue ; if ( ! is_claim_action ( packet . input . action ) ) continue ; claim_input . action = packet . input . action ; } else { continue ; } if ( claim_input . action == ACTION_CHII && ! is_at_left_of ( other_player -> player_pos , player -> player_pos ) ) continue ; if ( ! verify_action ( engine , other_player , & claim_input ) ) continue ; apply_action ( other_player , & claim_input ) ; pop_last_discard ( & player -> hand . discardlist ) ; player_claim = c ; break ; } if ( player_claim == - 1 ) { for ( int iother = 0 ; iother < NB_PLAYERS ; ++ iother ) { if ( player_index == iother ) continue ; struct player * other_player = & engine -> players [ iother ] ; if ( other_player -> player_type != PLAYER_AI ) continue ; enum action claims [ 4 ] = { ACTION_CHII , ACTION_PON , ACTION_KAN , ACTION_RON } ; for ( int iclaim = 0 ; iclaim < 4 ; ++ iclaim ) { claim_input . action = claims [ iclaim ] ; if ( ! verify_action ( engine , other_player , & claim_input ) ) { continue ; } apply_action ( other_player , & claim_input ) ; pop_last_discard ( & player -> hand . discardlist ) ; player_claim = iother ; break ; } if ( player_claim != - 1 ) break ; } } if ( player_claim != - 1 ) { engine -> players [ player_claim ] . hand . has_claimed = 1 ; char * str ; switch ( claim_input . action ) { case ACTION_CHII : str = "CHII" ; break ; case ACTION_PON : str = "PON" ; break ; case ACTION_KAN : str = "KAN" ; break ; case ACTION_RON : str = "RON" ; break ; default : str = "ERR" ; break ; } char * pos [ ] = { "EAST" , "SOUTH" , "WEST" , "NORTH" } ; <S2SV_StartBug> fprintf ( stderr , "%s<S2SV_blank>claim<S2SV_blank>from<S2SV_blank>player<S2SV_blank>%s!\\n" , str , pos [ player_claim ] ) ; <S2SV_EndBug> if ( is_valid_hand ( & player -> hand , & engine -> grouplist ) ) { riichi_tsumo_phase ( engine , player_index , & claim_input ) ; return player_index ; } pk_update packet = { packet_type : PACKET_UPDATE , player_pos : ( enum table_pos ) player_claim , input : claim_input , victory : 0 } ; send_to_all_clients ( engine , & packet , sizeof ( pk_update ) , - 1 ) ; } return - 1 ; } | <S2SV_ModStart> "NORTH" } ; char f , n ; index_to_char ( input -> tile , & f , & n ) ; <S2SV_ModStart> ( stderr , "%s<S2SV_blank>claim<S2SV_blank>of<S2SV_blank>%c%c<S2SV_blank>from<S2SV_blank>player<S2SV_blank>%s!\\n" , str , n , f <S2SV_ModEnd> , pos [ |
5,104 | CWE-000 int isSemAvailable ( ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ( ) { return - 1 ; |
5,105 | CWE-000 void * SendChat ( void * arg ) { char buf [ SBUFLEN ] ; while ( connected ) { fgets ( buf , SBUFLEN , stdin ) ; if ( strcmp ( buf , "q\\n" ) == 0 ) { printf ( "Disconnected.\\n" ) ; connected = 0 ; break ; } <S2SV_StartBug> fprintf ( fp , "%s\\n" , buf ) ; <S2SV_EndBug> send ( clientSocket , buf , SBUFLEN , 0 ) ; } close ( clientSocket ) ; <S2SV_StartBug> fclose ( fp ) ; <S2SV_EndBug> <S2SV_StartBug> exit ( 0 ) ; <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> break ; } if ( fp ) { <S2SV_ModStart> buf ) ; } <S2SV_ModStart> clientSocket ) ; if ( fp ) { <S2SV_ModStart> fp ) ; } exit ( EXIT_SUCCESS <S2SV_ModEnd> ) ; return |
5,106 | CWE-000 mame_file * mame_fopen ( const char * gamename , const char * filename , int filetype , int openforwrite ) { switch ( filetype ) { case FILETYPE_ROM : # ifndef MESS case FILETYPE_IMAGE : # endif case FILETYPE_SAMPLE : case FILETYPE_HIGHSCORE_DB : case FILETYPE_ARTWORK : case FILETYPE_HISTORY : case FILETYPE_LANGUAGE : <S2SV_StartBug> # ifndef MESS <S2SV_EndBug> case FILETYPE_INI : # endif if ( openforwrite ) { logerror ( "mame_fopen:<S2SV_blank>type<S2SV_blank>%02x<S2SV_blank>write<S2SV_blank>not<S2SV_blank>supported\\n" , filetype ) ; return NULL ; } break ; case FILETYPE_SCREENSHOT : if ( ! openforwrite ) { logerror ( "mame_fopen:<S2SV_blank>type<S2SV_blank>%02x<S2SV_blank>read<S2SV_blank>not<S2SV_blank>supported\\n" , filetype ) ; return NULL ; } break ; } switch ( filetype ) { case FILETYPE_ROM : return generic_fopen ( filetype , gamename , filename , 0 , FILEFLAG_OPENREAD | FILEFLAG_HASH ) ; case FILETYPE_IMAGE : # ifndef MESS return generic_fopen ( filetype , gamename , filename , 0 , FILEFLAG_OPENREAD | FILEFLAG_NOZIP ) ; # else { int flags = FILEFLAG_ALLOW_ABSOLUTE ; switch ( openforwrite ) { case OSD_FOPEN_READ : flags |= FILEFLAG_OPENREAD | FILEFLAG_ZIP_PATHS ; break ; case OSD_FOPEN_WRITE : flags |= FILEFLAG_OPENWRITE ; break ; case OSD_FOPEN_RW : flags |= FILEFLAG_OPENREAD | FILEFLAG_OPENWRITE | FILEFLAG_MUST_EXIST ; break ; case OSD_FOPEN_RW_CREATE : flags |= FILEFLAG_OPENREAD | FILEFLAG_OPENWRITE ; break ; } return generic_fopen ( filetype , gamename , filename , 0 , flags ) ; } # endif case FILETYPE_IMAGE_DIFF : return generic_fopen ( filetype , gamename , filename , 0 , FILEFLAG_OPENREAD | FILEFLAG_OPENWRITE ) ; case FILETYPE_SAMPLE : return generic_fopen ( filetype , gamename , filename , 0 , FILEFLAG_OPENREAD ) ; case FILETYPE_ARTWORK : return generic_fopen ( filetype , gamename , filename , 0 , FILEFLAG_OPENREAD ) ; case FILETYPE_NVRAM : # ifdef MESS if ( filename ) return generic_fopen ( filetype , gamename , filename , 0 , openforwrite ? FILEFLAG_OPENWRITE | FILEFLAG_CREATE_GAMEDIR : FILEFLAG_OPENREAD ) ; # endif return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; case FILETYPE_HIGHSCORE : if ( ! mame_highscore_enabled ( ) ) return NULL ; return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; case FILETYPE_HIGHSCORE_DB : return generic_fopen ( filetype , NULL , filename , 0 , FILEFLAG_OPENREAD ) ; case FILETYPE_CONFIG : return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; case FILETYPE_INPUTLOG : return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; case FILETYPE_MEMCARD : return generic_fopen ( filetype , NULL , filename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; case FILETYPE_SCREENSHOT : return generic_fopen ( filetype , NULL , filename , 0 , FILEFLAG_OPENWRITE ) ; case FILETYPE_HISTORY : return generic_fopen ( filetype , NULL , filename , 0 , FILEFLAG_OPENREAD ) ; case FILETYPE_CHEAT : return generic_fopen ( filetype , NULL , filename , 0 , FILEFLAG_OPENREAD | ( openforwrite ? FILEFLAG_OPENWRITE : 0 ) ) ; case FILETYPE_LANGUAGE : return generic_fopen ( filetype , NULL , filename , 0 , FILEFLAG_OPENREAD ) ; case FILETYPE_CTRLR : return generic_fopen ( filetype , gamename , filename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; <S2SV_StartBug> case FILETYPE_INI : <S2SV_EndBug> # ifndef MESS return generic_fopen ( filetype , NULL , gamename , 0 , FILEFLAG_OPENREAD ) ; # else return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; # endif # ifdef MESS case FILETYPE_CRC : return generic_fopen ( filetype , NULL , gamename , 0 , openforwrite ? FILEFLAG_OPENWRITE : FILEFLAG_OPENREAD ) ; # endif default : logerror ( "mame_fopen():<S2SV_blank>unknown<S2SV_blank>filetype<S2SV_blank>%02x\\n" , filetype ) ; return NULL ; } return NULL ; } | <S2SV_ModStart> case FILETYPE_LANGUAGE : <S2SV_ModEnd> if ( openforwrite <S2SV_ModStart> FILEFLAG_OPENREAD ) ; <S2SV_ModEnd> # ifdef MESS |
5,107 | CWE-000 PyObject * UnicodeStringToPythonL ( const unsigned char * src , const Py_ssize_t len ) { Py_UNICODE * val ; PyObject * res ; <S2SV_StartBug> val = strGammuToPythonL ( src , len ) ; <S2SV_EndBug> if ( val == NULL ) return NULL ; <S2SV_StartBug> res = PyUnicode_FromUnicode ( val , len ) ; <S2SV_EndBug> free ( val ) ; return res ; } | <S2SV_ModStart> * res ; size_t out_len = 0 ; <S2SV_ModStart> src , len , & out_len <S2SV_ModStart> ( val , out_len <S2SV_ModEnd> ) ; free |
5,108 | CWE-000 static int macsec_drv_delete_transmit_sc ( void * priv , struct transmit_sc * sc ) { struct macsec_drv_data * drv = priv ; int err ; <S2SV_StartBug> wpa_printf ( MSG_DEBUG , "%s" , __func__ ) ; <S2SV_EndBug> if ( ! drv -> created_link ) { rtnl_link_put ( drv -> link ) ; drv -> link = NULL ; wpa_printf ( MSG_DEBUG , DRV_PREFIX "we<S2SV_blank>didn\'t<S2SV_blank>create<S2SV_blank>the<S2SV_blank>link,<S2SV_blank>leave<S2SV_blank>it<S2SV_blank>alone" ) ; return 0 ; } err = rtnl_link_delete ( drv -> sk , drv -> link ) ; if ( err < 0 ) wpa_printf ( MSG_ERROR , DRV_PREFIX "couldn\'t<S2SV_blank>delete<S2SV_blank>link" ) ; rtnl_link_put ( drv -> link ) ; drv -> link = NULL ; return err ; } | <S2SV_ModStart> , __func__ ) ; if ( ! drv -> sk ) return 0 |
5,109 | CWE-000 <S2SV_StartBug> static gboolean <S2SV_EndBug> meta_wayland_buffer_realize ( MetaWaylandBuffer * buffer ) { EGLint format ; MetaBackend * backend = meta_get_backend ( ) ; MetaEgl * egl = meta_backend_get_egl ( backend ) ; ClutterBackend * clutter_backend = meta_backend_get_clutter_backend ( backend ) ; CoglContext * cogl_context = clutter_backend_get_cogl_context ( clutter_backend ) ; EGLDisplay egl_display = cogl_egl_context_get_egl_display ( cogl_context ) ; MetaWaylandEglStream * stream ; MetaWaylandDmaBufBuffer * dma_buf ; if ( wl_shm_buffer_get ( buffer -> resource ) != NULL ) { buffer -> type = META_WAYLAND_BUFFER_TYPE_SHM ; return TRUE ; } if ( meta_egl_query_wayland_buffer ( egl , egl_display , buffer -> resource , EGL_TEXTURE_FORMAT , & format , NULL ) ) { buffer -> type = META_WAYLAND_BUFFER_TYPE_EGL_IMAGE ; return TRUE ; } stream = meta_wayland_egl_stream_new ( buffer , NULL ) ; if ( stream ) { CoglTexture2D * texture ; <S2SV_StartBug> buffer -> egl_stream . stream = stream ; <S2SV_EndBug> buffer -> type = META_WAYLAND_BUFFER_TYPE_EGL_STREAM ; <S2SV_StartBug> texture = meta_wayland_egl_stream_create_texture ( stream , NULL ) ; <S2SV_EndBug> if ( ! texture ) return FALSE ; <S2SV_StartBug> buffer -> texture = COGL_TEXTURE ( texture ) ; <S2SV_EndBug> buffer -> is_y_inverted = meta_wayland_egl_stream_is_y_inverted ( stream ) ; return TRUE ; } dma_buf = meta_wayland_dma_buf_from_buffer ( buffer ) ; if ( dma_buf ) { buffer -> dma_buf . dma_buf = dma_buf ; buffer -> type = META_WAYLAND_BUFFER_TYPE_DMA_BUF ; return TRUE ; } return FALSE ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> gboolean meta_wayland_buffer_realize ( <S2SV_ModStart> * texture ; texture = meta_wayland_egl_stream_create_texture ( stream , NULL ) ; if ( ! texture ) return FALSE ; <S2SV_ModStart> = META_WAYLAND_BUFFER_TYPE_EGL_STREAM ; buffer -> texture = COGL_TEXTURE ( texture ) ; buffer -> is_y_inverted = meta_wayland_egl_stream_is_y_inverted ( stream ) ; return TRUE ; } dma_buf = meta_wayland_dma_buf_from_buffer ( buffer ) ; if ( dma_buf ) { buffer -> dma_buf . dma_buf = dma_buf ; buffer -> type = META_WAYLAND_BUFFER_TYPE_DMA_BUF ; return TRUE ; } <S2SV_ModEnd> return FALSE ; <S2SV_ModStart> return FALSE ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,110 | CWE-000 static void on_gc_dispose_error_stream ( mrb_state * mrb , void * _error_stream ) { h2o_mruby_error_stream_t * error_stream = _error_stream ; if ( error_stream == NULL ) return ; <S2SV_StartBug> if ( error_stream -> generator != NULL ) <S2SV_EndBug> error_stream -> generator -> refs . error_stream = mrb_nil_value ( ) ; <S2SV_StartBug> free ( error_stream ) ; <S2SV_EndBug> } | <S2SV_ModStart> != NULL ) { error_stream -> generator -> error_stream = NULL ; <S2SV_ModStart> ( ) ; } |
5,111 | CWE-000 int util_poolset_create_set ( struct pool_set * * setp , const char * path , size_t poolsize , size_t minsize ) { LOG ( 3 , "setp<S2SV_blank>%p<S2SV_blank>path<S2SV_blank>%s<S2SV_blank>poolsize<S2SV_blank>%zu<S2SV_blank>minsize<S2SV_blank>%zu" , setp , path , poolsize , minsize ) ; int oerrno ; int ret = 0 ; int fd ; size_t size = 0 ; int is_dev_dax = util_file_is_device_dax ( path ) ; if ( poolsize != 0 ) { if ( is_dev_dax ) { ERR ( "size<S2SV_blank>must<S2SV_blank>be<S2SV_blank>zero<S2SV_blank>for<S2SV_blank>device<S2SV_blank>dax" ) ; return - 1 ; } * setp = util_poolset_single ( path , poolsize , 1 ) ; if ( * setp == NULL ) return - 1 ; return 0 ; } if ( ( fd = util_file_open ( path , & size , 0 , O_RDONLY ) ) == - 1 ) return - 1 ; char signature [ POOLSET_HDR_SIG_LEN ] ; if ( ! is_dev_dax ) { ret = ( int ) read ( fd , signature , POOLSET_HDR_SIG_LEN ) ; if ( ret < 0 ) { ERR ( "!read<S2SV_blank>%d" , fd ) ; goto err ; } } if ( is_dev_dax || ret < POOLSET_HDR_SIG_LEN || strncmp ( signature , POOLSET_HDR_SIG , POOLSET_HDR_SIG_LEN ) ) { LOG ( 4 , "not<S2SV_blank>a<S2SV_blank>pool<S2SV_blank>set<S2SV_blank>header" ) ; ( void ) os_close ( fd ) ; if ( size < minsize ) { <S2SV_StartBug> ERR ( "size<S2SV_blank>%zu<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>%zu" , size , minsize ) ; <S2SV_EndBug> errno = EINVAL ; return - 1 ; } * setp = util_poolset_single ( path , size , 0 ) ; if ( * setp == NULL ) return - 1 ; return 0 ; } ret = util_poolset_parse ( setp , path , fd ) ; # ifdef _WIN32 if ( ret ) goto err ; if ( ( * setp ) -> remote ) { util_poolset_free ( * setp ) ; ERR ( "remote<S2SV_blank>replication<S2SV_blank>is<S2SV_blank>not<S2SV_blank>supported<S2SV_blank>on<S2SV_blank>Windows" ) ; errno = ENOTSUP ; ret = - 1 ; goto err ; } # endif err : oerrno = errno ; ( void ) os_close ( fd ) ; errno = oerrno ; return ret ; } | <S2SV_ModStart> { ERR ( "file<S2SV_blank>is<S2SV_blank>not<S2SV_blank>a<S2SV_blank>poolset<S2SV_blank>file<S2SV_blank>and<S2SV_blank>its<S2SV_blank>size<S2SV_blank>(%zu)" "<S2SV_blank>is<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>%zu" <S2SV_ModEnd> , size , |
5,112 | CWE-000 static int create_pktio ( const char * dev , int idx , int num_rx , int num_tx , odp_pool_t pool , odp_schedule_group_t group ) { odp_pktio_t pktio ; odp_pktio_param_t pktio_param ; odp_schedule_sync_t sync_mode ; odp_pktio_capability_t pktio_capa ; odp_pktio_config_t config ; odp_pktin_queue_param_t pktin_param ; odp_pktout_queue_param_t pktout_param ; odp_pktio_op_mode_t mode_rx ; odp_pktio_op_mode_t mode_tx ; pktin_mode_t in_mode = gbl_args -> appl . in_mode ; odp_pktio_info_t info ; odp_pktio_param_init ( & pktio_param ) ; if ( in_mode == PLAIN_QUEUE ) pktio_param . in_mode = ODP_PKTIN_MODE_QUEUE ; else if ( in_mode != DIRECT_RECV ) pktio_param . in_mode = ODP_PKTIN_MODE_SCHED ; if ( gbl_args -> appl . out_mode != PKTOUT_DIRECT ) pktio_param . out_mode = ODP_PKTOUT_MODE_QUEUE ; pktio = odp_pktio_open ( dev , pool , & pktio_param ) ; if ( pktio == ODP_PKTIO_INVALID ) { LOG_ERR ( "Error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } if ( odp_pktio_info ( pktio , & info ) ) { LOG_ERR ( "Error:<S2SV_blank>pktio<S2SV_blank>info<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } printf ( "created<S2SV_blank>pktio<S2SV_blank>%" PRIu64 ",<S2SV_blank>dev:<S2SV_blank>%s,<S2SV_blank>drv:<S2SV_blank>%s\\n" , odp_pktio_to_u64 ( pktio ) , dev , info . drv_name ) ; if ( gbl_args -> appl . verbose ) odp_pktio_print ( pktio ) ; if ( odp_pktio_capability ( pktio , & pktio_capa ) ) { LOG_ERR ( "Error:<S2SV_blank>pktio<S2SV_blank>capability<S2SV_blank>query<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } odp_pktio_config_init ( & config ) ; config . parser . layer = gbl_args -> appl . extra_check ? ODP_PROTO_LAYER_ALL : ODP_PROTO_LAYER_NONE ; if ( gbl_args -> appl . chksum ) { printf ( "Checksum<S2SV_blank>offload<S2SV_blank>enabled\\n" ) ; config . pktout . bit . ipv4_chksum_ena = 1 ; config . pktout . bit . udp_chksum_ena = 1 ; config . pktout . bit . tcp_chksum_ena = 1 ; } odp_pktio_config ( pktio , & config ) ; odp_pktin_queue_param_init ( & pktin_param ) ; odp_pktout_queue_param_init ( & pktout_param ) ; mode_rx = ODP_PKTIO_OP_MT_UNSAFE ; mode_tx = ODP_PKTIO_OP_MT_UNSAFE ; if ( gbl_args -> appl . sched_mode ) { if ( gbl_args -> appl . in_mode == SCHED_ATOMIC ) sync_mode = ODP_SCHED_SYNC_ATOMIC ; else if ( gbl_args -> appl . in_mode == SCHED_ORDERED ) sync_mode = ODP_SCHED_SYNC_ORDERED ; else sync_mode = ODP_SCHED_SYNC_PARALLEL ; pktin_param . queue_param . sched . prio = ODP_SCHED_PRIO_DEFAULT ; pktin_param . queue_param . sched . sync = sync_mode ; pktin_param . queue_param . sched . group = group ; } if ( num_rx > ( int ) pktio_capa . max_input_queues ) { printf ( "Sharing<S2SV_blank>%i<S2SV_blank>input<S2SV_blank>queues<S2SV_blank>between<S2SV_blank>%i<S2SV_blank>workers\\n" , pktio_capa . max_input_queues , num_rx ) ; num_rx = pktio_capa . max_input_queues ; mode_rx = ODP_PKTIO_OP_MT ; } if ( num_tx > ( int ) pktio_capa . max_output_queues ) { printf ( "Sharing<S2SV_blank>%i<S2SV_blank>output<S2SV_blank>queues<S2SV_blank>between<S2SV_blank>%i<S2SV_blank>workers\\n" , pktio_capa . max_output_queues , num_tx ) ; num_tx = pktio_capa . max_output_queues ; mode_tx = ODP_PKTIO_OP_MT ; <S2SV_StartBug> } <S2SV_EndBug> pktin_param . hash_enable = 1 ; pktin_param . hash_proto . proto . ipv4_udp = 1 ; pktin_param . num_queues = num_rx ; pktin_param . op_mode = mode_rx ; pktout_param . op_mode = mode_tx ; pktout_param . num_queues = num_tx ; if ( odp_pktin_queue_config ( pktio , & pktin_param ) ) { LOG_ERR ( "Error:<S2SV_blank>input<S2SV_blank>queue<S2SV_blank>config<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } if ( odp_pktout_queue_config ( pktio , & pktout_param ) ) { LOG_ERR ( "Error:<S2SV_blank>output<S2SV_blank>queue<S2SV_blank>config<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } if ( gbl_args -> appl . in_mode == DIRECT_RECV ) { if ( odp_pktin_queue ( pktio , gbl_args -> pktios [ idx ] . pktin , num_rx ) != num_rx ) { LOG_ERR ( "Error:<S2SV_blank>pktin<S2SV_blank>queue<S2SV_blank>query<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } } else { if ( odp_pktin_event_queue ( pktio , gbl_args -> pktios [ idx ] . rx_q , num_rx ) != num_rx ) { LOG_ERR ( "Error:<S2SV_blank>pktin<S2SV_blank>event<S2SV_blank>queue<S2SV_blank>query<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } } if ( gbl_args -> appl . out_mode == PKTOUT_DIRECT ) { if ( odp_pktout_queue ( pktio , gbl_args -> pktios [ idx ] . pktout , num_tx ) != num_tx ) { LOG_ERR ( "Error:<S2SV_blank>pktout<S2SV_blank>queue<S2SV_blank>query<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } } else { if ( odp_pktout_event_queue ( pktio , gbl_args -> pktios [ idx ] . tx_q , num_tx ) != num_tx ) { LOG_ERR ( "Error:<S2SV_blank>event<S2SV_blank>queue<S2SV_blank>query<S2SV_blank>failed<S2SV_blank>%s\\n" , dev ) ; return - 1 ; } } printf ( "created<S2SV_blank>%i<S2SV_blank>input<S2SV_blank>and<S2SV_blank>%i<S2SV_blank>output<S2SV_blank>queues<S2SV_blank>on<S2SV_blank>(%s)\\n" , num_rx , num_tx , dev ) ; gbl_args -> pktios [ idx ] . num_rx_queue = num_rx ; gbl_args -> pktios [ idx ] . num_tx_queue = num_tx ; gbl_args -> pktios [ idx ] . pktio = pktio ; return 0 ; } | <S2SV_ModStart> ODP_PKTIO_OP_MT ; } else if ( gbl_args -> appl . in_mode == SCHED_ORDERED && gbl_args -> appl . num_workers != 1 ) mode_tx = ODP_PKTIO_OP_MT ; |
5,113 | CWE-000 void HT_Add ( BFhash_entry * * table , BFpage * page ) { BFhash_entry * entry , * prev ; const unsigned int index = HT_Index ( page -> fd , page -> pagenum ) ; entry = table [ index ] ; prev = NULL ; while ( entry ) { prev = entry ; entry = entry -> nextentry ; } entry = malloc ( sizeof ( BFhash_entry ) ) ; initialize_entry ( entry , page ) ; <S2SV_StartBug> entry -> preventry = prev ; <S2SV_EndBug> if ( table [ index ] == NULL ) { table [ index ] = entry ; } } | <S2SV_ModStart> page ) ; if ( prev ) { prev -> nextentry = entry ; <S2SV_ModStart> = prev ; } |
5,114 | CWE-000 int range ( struct dataset * set ) { <S2SV_StartBug> assert ( set -> number_count > 0 ) ; <S2SV_EndBug> double max = set -> numbers [ 0 ] ; double min = set -> numbers [ 0 ] ; for ( int i = 0 ; i < set -> number_count ; i ++ ) { if ( set -> numbers [ i ] > max ) max = set -> numbers [ i ] ; else if ( set -> numbers [ i ] < min ) min = set -> numbers [ i ] ; } set -> range = fabs ( max - min ) ; <S2SV_StartBug> return 1 ; <S2SV_EndBug> } | <S2SV_ModStart> set ) { <S2SV_ModEnd> double max = <S2SV_ModStart> ) ; return 0 <S2SV_ModEnd> ; } <S2SV_null> |
5,115 | CWE-000 int main ( int argc , char * * argv ) { int inlen , i , j ; ALIGN char * msgstr [ 2 ] ; ALIGN uint8_t * md [ 2 ] ; ALIGN uint8_t * md1 [ 64 ] ; if ( argc != 2 ) { printf ( "ERROR!,<S2SV_blank>You<S2SV_blank>need<S2SV_blank>to<S2SV_blank>pass<S2SV_blank>the<S2SV_blank>message<S2SV_blank>size\\n\\n" ) ; exit ( 1 ) ; } inlen = atoi ( argv [ 1 ] ) ; for ( i = 0 ; i < 2 ; i ++ ) { msgstr [ i ] = ( char * ) _mm_malloc ( inlen * sizeof ( char ) , 32 ) ; md [ i ] = ( uint8_t * ) _mm_malloc ( 64 * sizeof ( uint8_t ) , 32 ) ; md1 [ i ] = ( uint8_t * ) _mm_malloc ( 64 * sizeof ( uint8_t ) , 32 ) ; } for ( i = 0 ; i < inlen ; i ++ ) { msgstr [ 0 ] [ i ] = ( char ) ( rand ( ) % 256 ) ; <S2SV_StartBug> } <S2SV_EndBug> printf ( "\\n<S2SV_blank>2-way<S2SV_blank>implementation<S2SV_blank>using<S2SV_blank>128-bit<S2SV_blank>registers.\\n\\n" ) ; printf ( "<------------------------------------------------------>\\n" ) ; printf ( "Keccak_256<S2SV_blank>4<S2SV_blank>way<S2SV_blank>\\t\\t\\t" ) ; keccak ( msgstr , inlen , md , 136 ) ; keccak_std ( msgstr [ 0 ] , inlen , md1 [ 0 ] , 32 ) ; keccak_std ( msgstr [ 1 ] , inlen , md1 [ 1 ] , 32 ) ; <S2SV_StartBug> if ( ( memcmp ( md [ 0 ] , md1 [ 0 ] , 32 ) && memcmp ( md [ 1 ] , md1 [ 1 ] , 32 ) != 0 ) ) { <S2SV_EndBug> printf ( "Error!!\\n" ) ; exit ( 1 ) ; } printf ( "Ok!!\\n" ) ; printf ( "Keccak_384<S2SV_blank>4<S2SV_blank>way<S2SV_blank>\\t\\t\\t" ) ; keccak ( msgstr , inlen , md , 104 ) ; keccak_std ( msgstr [ 0 ] , inlen , md1 [ 0 ] , 48 ) ; keccak_std ( msgstr [ 1 ] , inlen , md1 [ 1 ] , 48 ) ; <S2SV_StartBug> if ( ( memcmp ( md [ 0 ] , md1 [ 0 ] , 48 ) && memcmp ( md [ 1 ] , md1 [ 1 ] , 48 ) != 0 ) ) { <S2SV_EndBug> printf ( "Error!!\\n" ) ; exit ( 1 ) ; } printf ( "Ok!!\\n" ) ; printf ( "Keccak_512<S2SV_blank>4<S2SV_blank>way<S2SV_blank>\\t\\t\\t" ) ; keccak ( msgstr , inlen , md , 72 ) ; keccak_std ( msgstr [ 0 ] , inlen , md1 [ 0 ] , 64 ) ; keccak_std ( msgstr [ 1 ] , inlen , md1 [ 1 ] , 64 ) ; <S2SV_StartBug> if ( ( memcmp ( md [ 0 ] , md1 [ 0 ] , 64 ) && memcmp ( md [ 1 ] , md1 [ 1 ] , 64 ) != 0 ) ) { <S2SV_EndBug> printf ( "Error!!\\n" ) ; exit ( 1 ) ; } printf ( "Ok!!\\n" ) ; printf ( "<------------------------------------------------------>\\n" ) ; for ( i = 0 ; i < 2 ; i ++ ) { _mm_free ( msgstr [ i ] ) ; _mm_free ( md [ i ] ) ; _mm_free ( md1 [ i ] ) ; } return 0 ; } | <S2SV_ModStart> 256 ) ; msgstr [ 1 ] [ i ] = ( char ) ( rand ( ) % 256 ) ; <S2SV_ModStart> , 32 ) != 0 || <S2SV_ModEnd> memcmp ( md <S2SV_ModStart> , 48 ) != 0 || <S2SV_ModEnd> memcmp ( md <S2SV_ModStart> , 64 ) != 0 || <S2SV_ModEnd> memcmp ( md |
5,116 | CWE-000 void gigimport ( giant g , unsigned char * buff , int len ) { <S2SV_StartBug> int count ; <S2SV_EndBug> memcpy ( g -> n , buff , len ) ; <S2SV_StartBug> g -> sign = len / 2 ; <S2SV_EndBug> for ( count = g -> sign ; count != 0 ; count -- ) { if ( g -> n [ count ] != 0x00 ) { count = count + 1 ; break ; } } g -> sign = count ; <S2SV_StartBug> if ( g -> sign == 0 ) g -> sign = 1 ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> len ) { <S2SV_ModEnd> memcpy ( g <S2SV_ModStart> len ) ; if ( len & 1 ) { * ( ( unsigned char * ) ( g -> n ) + len ) = 0x00 ; len ++ ; } <S2SV_ModStart> len / 2 <S2SV_ModEnd> ; if ( <S2SV_ModStart> == 0 ) { <S2SV_ModStart> = 1 ; * ( ( unsigned char * ) ( g -> n ) ) = 0x00 ; } |
5,117 | CWE-000 static ecma_value_t ecma_builtin_global_object_unescape ( ecma_value_t this_arg , ecma_value_t arg ) { JERRY_UNUSED ( this_arg ) ; ecma_value_t ret_value = ecma_make_simple_value ( ECMA_SIMPLE_VALUE_EMPTY ) ; ECMA_TRY_CATCH ( string , ecma_op_to_string ( arg ) , ret_value ) ; ecma_string_t * input_string_p = ecma_get_string_from_value ( string ) ; lit_utf8_size_t input_size = ecma_string_get_size ( input_string_p ) ; JMEM_DEFINE_LOCAL_ARRAY ( input_start_p , input_size , lit_utf8_byte_t ) ; ecma_string_to_utf8_bytes ( input_string_p , input_start_p , input_size ) ; const lit_utf8_byte_t * input_curr_p = input_start_p ; const lit_utf8_byte_t * input_end_p = input_start_p + input_size ; lit_utf8_byte_t * output_char_p = input_start_p ; uint8_t status = 0 ; ecma_char_t hex_digits = 0 ; while ( input_curr_p < input_end_p ) { ecma_char_t chr = lit_utf8_read_next ( & input_curr_p ) ; if ( status == 0 && chr == LIT_CHAR_PERCENT ) { status = 1 ; } else if ( status == 1 && chr == LIT_CHAR_LOWERCASE_U ) { status = 4 ; } else if ( status > 0 && lit_char_is_hex_digit ( chr ) ) { hex_digits = ( ecma_char_t ) ( hex_digits * 16 + ( ecma_char_t ) lit_char_hex_to_int ( chr ) ) ; <S2SV_StartBug> status ++ ; <S2SV_EndBug> } if ( status == 8 || status == 3 ) { output_char_p -= ( status == 3 ) ? 2 : 5 ; status = 0 ; chr = hex_digits ; hex_digits = 0 ; } lit_utf8_size_t lit_size = lit_code_unit_to_utf8 ( chr , output_char_p ) ; output_char_p += lit_size ; JERRY_ASSERT ( output_char_p <= input_curr_p ) ; } lit_utf8_size_t output_length = ( lit_utf8_size_t ) ( output_char_p - input_start_p ) ; ecma_string_t * output_string_p = ecma_new_ecma_string_from_utf8 ( input_start_p , output_length ) ; ret_value = ecma_make_string_value ( output_string_p ) ; JMEM_FINALIZE_LOCAL_ARRAY ( input_start_p ) ; ECMA_FINALIZE ( string ) ; return ret_value ; } | <S2SV_ModStart> ; status ++ ; } else { status = 0 |
5,118 | CWE-000 static PetscErrorCode DMInitialize_Plex ( DM dm ) { PetscErrorCode ierr ; PetscFunctionBegin ; dm -> ops -> view = DMView_Plex ; dm -> ops -> load = DMLoad_Plex ; dm -> ops -> setfromoptions = DMSetFromOptions_Plex ; dm -> ops -> clone = DMClone_Plex ; dm -> ops -> setup = DMSetUp_Plex ; dm -> ops -> createdefaultsection = DMCreateDefaultSection_Plex ; dm -> ops -> createdefaultconstraints = DMCreateDefaultConstraints_Plex ; dm -> ops -> createglobalvector = DMCreateGlobalVector_Plex ; dm -> ops -> createlocalvector = DMCreateLocalVector_Plex ; dm -> ops -> getlocaltoglobalmapping = NULL ; dm -> ops -> createfieldis = NULL ; dm -> ops -> createcoordinatedm = DMCreateCoordinateDM_Plex ; dm -> ops -> getcoloring = NULL ; dm -> ops -> creatematrix = DMCreateMatrix_Plex ; dm -> ops -> createinterpolation = DMCreateInterpolation_Plex ; dm -> ops -> createmassmatrix = DMCreateMassMatrix_Plex ; dm -> ops -> getaggregates = NULL ; dm -> ops -> getinjection = DMCreateInjection_Plex ; dm -> ops -> refine = DMRefine_Plex ; dm -> ops -> coarsen = DMCoarsen_Plex ; dm -> ops -> refinehierarchy = DMRefineHierarchy_Plex ; dm -> ops -> coarsenhierarchy = DMCoarsenHierarchy_Plex ; dm -> ops -> adaptlabel = DMAdaptLabel_Plex ; dm -> ops -> adaptmetric = DMAdaptMetric_Plex ; dm -> ops -> globaltolocalbegin = NULL ; dm -> ops -> globaltolocalend = NULL ; dm -> ops -> localtoglobalbegin = NULL ; dm -> ops -> localtoglobalend = NULL ; dm -> ops -> destroy = DMDestroy_Plex ; <S2SV_StartBug> dm -> ops -> createsubdm = DMCreateSubDM_Plex ; <S2SV_EndBug> dm -> ops -> getdimpoints = DMGetDimPoints_Plex ; dm -> ops -> locatepoints = DMLocatePoints_Plex ; dm -> ops -> projectfunctionlocal = DMProjectFunctionLocal_Plex ; dm -> ops -> projectfunctionlabellocal = DMProjectFunctionLabelLocal_Plex ; dm -> ops -> projectfieldlocal = DMProjectFieldLocal_Plex ; dm -> ops -> projectfieldlabellocal = DMProjectFieldLabelLocal_Plex ; dm -> ops -> computel2diff = DMComputeL2Diff_Plex ; dm -> ops -> computel2gradientdiff = DMComputeL2GradientDiff_Plex ; dm -> ops -> computel2fielddiff = DMComputeL2FieldDiff_Plex ; dm -> ops -> getneighbors = DMGetNeighors_Plex ; ierr = PetscObjectComposeFunction ( ( PetscObject ) dm , "DMPlexInsertBoundaryValues_C" , DMPlexInsertBoundaryValues_Plex ) ; CHKERRQ ( ierr ) ; ierr = PetscObjectComposeFunction ( ( PetscObject ) dm , "DMSetUpGLVisViewer_C" , DMSetUpGLVisViewer_Plex ) ; CHKERRQ ( ierr ) ; PetscFunctionReturn ( 0 ) ; } | <S2SV_ModStart> createsubdm = DMCreateSubDM_Plex ; dm -> ops -> createsuperdm = DMCreateSuperDM_Plex |
5,119 | CWE-000 __attribute__ ( ( leaf , nonnull ( 1 ) , nothrow , warn_unused_result ) ) int trim_cap_darr ( darr_t * restrict darr , size_t n ) { void * restrict new_data ; if ( n >= darr -> maxn ) return 0 ; # ifndef NDEBUG printf ( "DARRSZN<S2SV_blank>(darr,<S2SV_blank>%d):<S2SV_blank>%d\\n" , ( int ) n , ( int ) DARRSZN ( darr , n ) ) ; fflush ( stdout ) ; # endif new_data = realloc ( darr -> data , DARRSZN ( darr , max ( n , 1 ) ) ) ; error_check ( new_data == NULL ) return - 1 ; darr -> data = new_data ; darr -> maxn = max ( n , 1 ) ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> 1 ) ; darr -> n = min ( darr -> n , darr -> maxn ) ; |
5,120 | CWE-000 void * __memcpy_chk ( void * dest , const void * src , size_t len , size_t destlen ) { <S2SV_StartBug> assert ( len <= destlen ) ; <S2SV_EndBug> return memcpy ( dest , src , len ) ; } | <S2SV_ModStart> destlen ) { __assert <S2SV_ModEnd> ( len <= |
5,121 | CWE-000 int ec_shd_selfheal ( struct subvol_healer * healer , int child , loc_t * loc ) { <S2SV_StartBug> return syncop_getxattr ( healer -> this , loc , NULL , EC_XATTR_HEAL , NULL , <S2SV_EndBug> NULL ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> loc ) { int32_t ret ; ret = <S2SV_ModEnd> syncop_getxattr ( healer <S2SV_ModStart> NULL ) ; if ( ( ret >= 0 ) && ( loc -> inode -> ia_type == IA_IFDIR ) ) { healer -> rerun = _gf_true ; } return ret ; |
5,122 | CWE-000 static pj_bool_t authenticate ( pjsip_rx_data * rdata ) { RAII_VAR ( struct ast_sip_endpoint * , endpoint , ast_pjsip_rdata_get_endpoint ( rdata ) , ao2_cleanup ) ; int is_ack = rdata -> msg_info . msg -> line . req . method . id == PJSIP_ACK_METHOD ; ast_assert ( endpoint != NULL ) ; if ( endpoint != artificial_endpoint ) { if ( apply_endpoint_acl ( rdata , endpoint ) || apply_endpoint_contact_acl ( rdata , endpoint ) ) { if ( ! is_ack ) { pjsip_endpt_respond_stateless ( ast_sip_get_pjsip_endpoint ( ) , rdata , 403 , NULL , NULL , NULL ) ; } return PJ_TRUE ; } } if ( ! is_ack && ast_sip_requires_authentication ( endpoint , rdata ) ) { pjsip_tx_data * tdata ; struct unidentified_request * unid ; pjsip_endpt_create_response ( ast_sip_get_pjsip_endpoint ( ) , rdata , 401 , NULL , & tdata ) ; switch ( ast_sip_check_authentication ( endpoint , rdata , tdata ) ) { case AST_SIP_AUTHENTICATION_CHALLENGE : ast_sip_report_auth_challenge_sent ( endpoint , rdata , tdata ) ; <S2SV_StartBug> pjsip_endpt_send_response2 ( ast_sip_get_pjsip_endpoint ( ) , rdata , tdata , NULL , NULL ) ; <S2SV_EndBug> return PJ_TRUE ; case AST_SIP_AUTHENTICATION_SUCCESS : if ( ( unid = ao2_find ( unidentified_requests , rdata -> pkt_info . src_name , OBJ_SEARCH_KEY ) ) ) { ao2_unlink ( unidentified_requests , unid ) ; ao2_ref ( unid , - 1 ) ; } ast_sip_report_auth_success ( endpoint , rdata ) ; break ; case AST_SIP_AUTHENTICATION_FAILED : log_failed_request ( rdata , "Failed<S2SV_blank>to<S2SV_blank>authenticate" , 0 , 0 ) ; ast_sip_report_auth_failed_challenge_response ( endpoint , rdata ) ; <S2SV_StartBug> pjsip_endpt_send_response2 ( ast_sip_get_pjsip_endpoint ( ) , rdata , tdata , NULL , NULL ) ; <S2SV_EndBug> return PJ_TRUE ; case AST_SIP_AUTHENTICATION_ERROR : log_failed_request ( rdata , "Error<S2SV_blank>to<S2SV_blank>authenticate" , 0 , 0 ) ; ast_sip_report_auth_failed_challenge_response ( endpoint , rdata ) ; pjsip_tx_data_dec_ref ( tdata ) ; pjsip_endpt_respond_stateless ( ast_sip_get_pjsip_endpoint ( ) , rdata , 500 , NULL , NULL , NULL ) ; return PJ_TRUE ; } pjsip_tx_data_dec_ref ( tdata ) ; } return PJ_FALSE ; } | <S2SV_ModStart> tdata ) ; if ( <S2SV_ModStart> , NULL ) != PJ_SUCCESS ) { pjsip_tx_data_dec_ref ( tdata ) ; } <S2SV_ModEnd> return PJ_TRUE ; <S2SV_ModStart> rdata ) ; if ( <S2SV_ModStart> , NULL ) != PJ_SUCCESS ) { pjsip_tx_data_dec_ref ( tdata ) ; } <S2SV_ModEnd> return PJ_TRUE ; |
5,123 | CWE-000 void insert_msg ( msg_channel * mc , msg_t * msg ) { spin_lock ( & mc -> write_lock ) ; if ( mc -> buffers [ M_WRITE ] -> written == mc -> buffers [ M_WRITE ] -> size ) { spin_lock ( & mc -> read_lock ) ; mc -> buffers [ M_WRITE ] -> size *= 2 ; <S2SV_StartBug> mc -> buffers [ M_WRITE ] -> buffer = rsrealloc ( ( void * ) mc -> buffers [ M_WRITE ] -> buffer , mc -> buffers [ M_WRITE ] -> size ) ; <S2SV_EndBug> if ( mc -> buffers [ M_WRITE ] -> buffer == NULL ) rootsim_error ( true , "%s:%d:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>reallocate<S2SV_blank>message<S2SV_blank>channel\\n" , __FILE__ , __LINE__ ) ; spin_unlock ( & mc -> read_lock ) ; } # ifndef NDEBUG validate_msg ( msg ) ; # endif int index = mc -> buffers [ M_WRITE ] -> written ++ ; mc -> buffers [ M_WRITE ] -> buffer [ index ] = msg ; spin_unlock ( & mc -> write_lock ) ; } | <S2SV_ModStart> ] -> size * sizeof ( msg_t * ) |
5,124 | CWE-000 static struct Body * decrypt_part ( struct Body * a , struct State * s , FILE * fpout , int is_smime , int * r_is_signed ) { if ( ! a || ! s || ! fpout ) return NULL ; struct stat info ; struct Body * tattach = NULL ; int err = 0 ; gpgme_ctx_t ctx ; gpgme_data_t ciphertext , plaintext ; bool maybe_signed = false ; bool anywarn = false ; int sig_stat = 0 ; if ( r_is_signed ) * r_is_signed = 0 ; ctx = create_gpgme_context ( is_smime ) ; restart : ciphertext = file_to_data_object ( s -> fpin , a -> offset , a -> length ) ; if ( ! ciphertext ) return NULL ; plaintext = create_gpgme_data ( ) ; if ( ( ! is_smime ) || maybe_signed ) { if ( ! is_smime ) err = gpgme_op_decrypt_verify ( ctx , ciphertext , plaintext ) ; else if ( maybe_signed ) err = gpgme_op_verify ( ctx , ciphertext , NULL , plaintext ) ; if ( err == GPG_ERR_NO_ERROR ) { gpgme_verify_result_t verify_result = gpgme_op_verify_result ( ctx ) ; if ( verify_result -> signatures ) sig_stat = 1 ; } } else err = gpgme_op_decrypt ( ctx , ciphertext , plaintext ) ; gpgme_data_release ( ciphertext ) ; if ( err ) { if ( is_smime && ! maybe_signed && gpg_err_code ( err ) == GPG_ERR_NO_DATA ) { gpgme_decrypt_result_t result ; result = gpgme_op_decrypt_result ( ctx ) ; if ( ! result -> unsupported_algorithm ) { maybe_signed = true ; <S2SV_StartBug> gpgme_data_release ( plaintext ) ; <S2SV_EndBug> goto restart ; } } redraw_if_needed ( ctx ) ; if ( ( s -> flags & MUTT_DISPLAY ) ) { char buf [ 200 ] ; snprintf ( buf , sizeof ( buf ) - 1 , _ ( "[--<S2SV_blank>Error:<S2SV_blank>decryption<S2SV_blank>failed:<S2SV_blank>%s<S2SV_blank>--]\\n\\n" ) , gpgme_strerror ( err ) ) ; state_attach_puts ( buf , s ) ; } gpgme_data_release ( plaintext ) ; gpgme_release ( ctx ) ; return NULL ; } redraw_if_needed ( ctx ) ; if ( data_object_to_stream ( plaintext , fpout ) ) { gpgme_data_release ( plaintext ) ; gpgme_release ( ctx ) ; return NULL ; } gpgme_data_release ( plaintext ) ; a -> is_signed_data = false ; if ( sig_stat ) { int res , idx ; int anybad = 0 ; if ( maybe_signed ) a -> is_signed_data = true ; if ( r_is_signed ) * r_is_signed = - 1 ; if ( ( s -> flags & MUTT_DISPLAY ) ) state_attach_puts ( _ ( "[--<S2SV_blank>Begin<S2SV_blank>signature<S2SV_blank>" "information<S2SV_blank>--]\\n" ) , s ) ; for ( idx = 0 ; ( res = show_one_sig_status ( ctx , idx , s ) ) != - 1 ; idx ++ ) { if ( res == 1 ) anybad = 1 ; else if ( res == 2 ) anywarn = true ; } if ( ! anybad && idx && r_is_signed && * r_is_signed ) * r_is_signed = anywarn ? 2 : 1 ; if ( ( s -> flags & MUTT_DISPLAY ) ) state_attach_puts ( _ ( "[--<S2SV_blank>End<S2SV_blank>signature<S2SV_blank>" "information<S2SV_blank>--]\\n\\n" ) , s ) ; } gpgme_release ( ctx ) ; ctx = NULL ; fflush ( fpout ) ; rewind ( fpout ) ; tattach = mutt_read_mime_header ( fpout , 0 ) ; if ( tattach ) { fstat ( fileno ( fpout ) , & info ) ; tattach -> length = info . st_size - tattach -> offset ; tattach -> warnsig = anywarn ; mutt_parse_part ( fpout , tattach ) ; } return tattach ; } | <S2SV_ModStart> gpgme_data_release ( plaintext ) ; gpgme_release ( ctx ) ; ctx = create_gpgme_context ( is_smime |
5,125 | CWE-000 static void readFromTAPSocket ( n2n_edge_t * eee ) { uint8_t eth_pkt [ N2N_PKT_BUF_SIZE ] ; macstr_t mac_buf ; ssize_t len ; <S2SV_StartBug> len = tuntap_read ( & ( eee -> device ) , eth_pkt , N2N_PKT_BUF_SIZE ) ; <S2SV_EndBug> if ( ( len <= 0 ) || ( len > N2N_PKT_BUF_SIZE ) ) { # ifdef _WIN32 DWORD err = GetLastError ( ) ; W32_ERROR ( err , error ) ; traceEvent ( TRACE_WARNING , "read()=%d<S2SV_blank>[%d/%ls]" , ( signed int ) len , err , error ) ; <S2SV_StartBug> W32_ERROR_FREE ( error ) ; <S2SV_EndBug> # else traceEvent ( TRACE_WARNING , "read()=%d<S2SV_blank>[%d/%s]" , ( signed int ) len , errno , strerror ( errno ) ) ; # endif } else { const uint8_t * mac = eth_pkt ; traceEvent ( TRACE_INFO , "###<S2SV_blank>Rx<S2SV_blank>TAP<S2SV_blank>packet<S2SV_blank>(%4d)<S2SV_blank>for<S2SV_blank>%s" , ( signed int ) len , macaddr_str ( mac_buf , mac ) ) ; if ( eee -> drop_multicast && ( is_ethMulticast ( eth_pkt , len ) ) ) { traceEvent ( TRACE_DEBUG , "Dropping<S2SV_blank>multicast" ) ; } else { send_packet2net ( eee , eth_pkt , len ) ; } } } | <S2SV_ModStart> ssize_t len ; retry : <S2SV_ModStart> error ) ; if ( ERROR_OPERATION_ABORTED == err ) { retry2 : traceEvent ( TRACE_NORMAL , "Restart<S2SV_blank>TAP<S2SV_blank>device" ) ; if ( tuntap_restart ( & eee -> device ) < 0 ) { Sleep ( 2000 ) ; goto retry2 ; } goto retry ; } |
5,126 | CWE-000 GFX_STATUS __attribute__ ( ( weak ) ) GFX_TextCharDraw ( GFX_XCHAR ch ) { typedef enum { TC_IDLE , TC_GET_INFO , TC_CHECK_RENDER_STATUS , TC_RENDER_CHAR , TC_RENDER_CHAR_DRIVER , TC_RENDER_STATUS_CHECK , TC_RENDER_NEWLINE_CHAR , } TEXTCHAR_RENDER_STATES ; static TEXTCHAR_RENDER_STATES state = TC_IDLE , renderState ; static GFX_FONT_OUTCHAR OutCharParam ; static GFX_STATUS status ; static GFX_STATUS_BIT statusBit ; static GFX_RESOURCE_HDR * pFont ; while ( 1 ) { switch ( state ) { case TC_IDLE : <S2SV_StartBug> status = GFX_STATUS_SUCCESS_BIT ; <S2SV_EndBug> pFont = GFX_FontGet ( ) ; if ( ch == ( GFX_UXCHAR ) 0x0A ) { state = TC_RENDER_NEWLINE_CHAR ; break ; } if ( ( GFX_UXCHAR ) ch < ( GFX_UXCHAR ) pFont -> resource . font . header . firstChar ) statusBit = GFX_STATUS_ERROR_BIT ; else if ( ( GFX_UXCHAR ) ch > ( GFX_UXCHAR ) pFont -> resource . font . header . lastChar ) statusBit = GFX_STATUS_ERROR_BIT ; # ifdef GFX_CONFIG_FONT_ANTIALIASED_DISABLE else if ( pFont -> resource . font . header . bpp > 1 ) statusBit = GFX_STATUS_ERROR_BIT ; # endif if ( statusBit == GFX_STATUS_ERROR_BIT ) return GFX_STATUS_SUCCESS ; else state = TC_GET_INFO ; case TC_GET_INFO : # ifndef GFX_CONFIG_FONT_EXTERNAL_DISABLE OutCharParam . pChImage = NULL ; # endif OutCharParam . xAdjust = 0 ; OutCharParam . yAdjust = 0 ; OutCharParam . xWidthAdjust = 0 ; OutCharParam . heightOvershoot = 0 ; state = TC_CHECK_RENDER_STATUS ; case TC_CHECK_RENDER_STATUS : if ( GFX_RenderStatusCheck ( ) == GFX_STATUS_BUSY_BIT ) { state = TC_IDLE ; return ( GFX_STATUS_FAILURE ) ; } switch ( pFont -> type ) { case GFX_RESOURCE_FONT_FLASH_NONE : GFX_TextCharInfoFlashGet ( ch , & OutCharParam ) ; state = TC_RENDER_CHAR ; renderState = TC_RENDER_CHAR ; break ; case GFX_RESOURCE_FONT_EXTERNAL_NONE : GFX_TextCharInfoExternalGet ( ch , & OutCharParam ) ; state = TC_RENDER_CHAR ; renderState = TC_RENDER_CHAR ; break ; case GFX_RESOURCE_FONT_EDS_NONE : state = TC_RENDER_CHAR_DRIVER ; renderState = TC_RENDER_CHAR_DRIVER ; break ; default : state = TC_IDLE ; return ( GFX_STATUS_SUCCESS ) ; } break ; case TC_RENDER_CHAR_DRIVER : status = GFX_DRV_TextCharRender ( ch ) ; state = TC_RENDER_STATUS_CHECK ; break ; case TC_RENDER_CHAR : status = GFX_TextCharRender ( ch , & OutCharParam ) ; state = TC_RENDER_STATUS_CHECK ; case TC_RENDER_STATUS_CHECK : if ( status == GFX_STATUS_SUCCESS ) { state = TC_IDLE ; } else { state = renderState ; } return ( status ) ; case TC_RENDER_NEWLINE_CHAR : GFX_TextCursorPositionSet ( GFX_TextCursorPositionXGet ( ) , ( GFX_TextCursorPositionYGet ( ) + pFont -> resource . font . header . height ) ) ; status = GFX_STATUS_SUCCESS ; state = TC_IDLE ; return ( status ) ; default : state = TC_IDLE ; return GFX_STATUS_FAILURE ; } } } | <S2SV_ModStart> case TC_IDLE : statusBit <S2SV_ModEnd> = GFX_STATUS_SUCCESS_BIT ; |
5,127 | CWE-000 int pthread_detach ( pthread_t thread ) { FAR struct tcb_s * rtcb = ( FAR struct tcb_s * ) g_readytorun . head ; FAR struct task_group_s * group = rtcb -> group ; FAR struct join_s * pjoin ; int ret ; trace_begin ( TTRACE_TAG_TASK , "pthread_detach" ) ; svdbg ( "Thread=%d<S2SV_blank>group=%p\\n" , thread , group ) ; DEBUGASSERT ( group ) ; <S2SV_StartBug> ( void ) pthread_takesemaphore ( & group -> tg_joinsem , false ) ; <S2SV_EndBug> pjoin = pthread_findjoininfo ( group , ( pid_t ) thread ) ; if ( ! pjoin ) { sdbg ( "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>thread<S2SV_blank>entry\\n" ) ; ret = EINVAL ; } else { if ( pjoin -> terminated ) { pthread_destroyjoin ( group , pjoin ) ; } else { pjoin -> detached = true ; } ret = OK ; } <S2SV_StartBug> ( void ) pthread_givesemaphore ( & group -> tg_joinsem ) ; <S2SV_EndBug> svdbg ( "Returning<S2SV_blank>%d\\n" , ret ) ; trace_end ( TTRACE_TAG_TASK ) ; return ret ; } | <S2SV_ModStart> ( void ) pthread_sem_take <S2SV_ModEnd> ( & group <S2SV_ModStart> ( void ) pthread_sem_give <S2SV_ModEnd> ( & group |
5,128 | CWE-000 static void dump_user_probe ( char * msg ) { int i = 0 ; <S2SV_StartBug> char * tmp_key = get_key_ptr ( ) ; <S2SV_EndBug> <S2SV_StartBug> char * tmp_salt = get_salt_ptr ( ) ; <S2SV_EndBug> char * tmp_iv = get_iv_ptr ( ) ; printf ( "%s:\\n" , msg ) ; printf ( "key:\\n" ) ; for ( i = 0 ; i < SYM_KEY_BYTES ; i ++ ) { printf ( "%x" , * ( tmp_key + i ) ) ; } <S2SV_StartBug> printk ( "\\nsalt:\\n" ) ; <S2SV_EndBug> for ( i = 0 ; i < SALT_BYTES ; i ++ ) { printf ( "%x" , * ( tmp_salt + i ) ) ; } <S2SV_StartBug> printk ( "\\niv:\\n" ) ; <S2SV_EndBug> for ( i = 0 ; i < AES_BLOCK_SIZE ; i ++ ) { printf ( "%x" , * ( tmp_iv + i ) ) ; } printf ( "\\n" ) ; } | <S2SV_ModStart> * tmp_key = final_key <S2SV_ModEnd> ; char * <S2SV_ModStart> * tmp_salt = final_salt <S2SV_ModEnd> ; printf ( <S2SV_ModStart> ) ; } printf <S2SV_ModEnd> ( "\\nsalt:\\n" ) <S2SV_ModStart> ) ; } <S2SV_ModEnd> printf ( "\\n" |
5,129 | CWE-000 <S2SV_StartBug> static int count_files ( const char * fn ) <S2SV_EndBug> { struct archive * a ; struct archive_entry * entry ; int r , r2 ; int total = 0 ; a = archive_read_new ( ) ; archive_read_support_filter_all ( a ) ; archive_read_support_format_all ( a ) ; <S2SV_StartBug> r = archive_read_open_filename ( a , fn , 10240 ) ; <S2SV_EndBug> if ( r == ARCHIVE_OK ) { while ( 1 ) { r2 = archive_read_next_header ( a , & entry ) ; if ( r2 == ARCHIVE_OK ) { total ++ ; archive_entry_pathname ( entry ) ; } else { break ; } } archive_read_free ( a ) ; } return total ; } | <S2SV_ModStart> int count_files ( void * data ) { ARCHIVE_HANDLER_DATA * archive_data = ( ARCHIVE_HANDLER_DATA * ) data ; <S2SV_ModEnd> struct archive * <S2SV_ModStart> ( a , archive_data -> filename <S2SV_ModEnd> , 10240 ) |
5,130 | CWE-000 struct resource_tree_node * pcr_create_rsrc_tree_node ( pcr_error_code * err ) { struct resource_tree_node * node ; size_t node_size = sizeof ( struct resource_tree_node ) ; node = ( struct resource_tree_node * ) pcr_malloc ( node_size , err ) ; <S2SV_StartBug> memset ( node , 0 , node_size ) ; <S2SV_EndBug> return node ; } | <S2SV_ModStart> err ) ; if ( PCR_FAILURE ( * err ) ) return NULL ; |
5,131 | CWE-000 static int iwl_request_firmware ( struct iwl_drv * drv , bool first ) { const struct iwl_cfg * cfg = drv -> trans -> cfg ; char tag [ 8 ] ; const char * fw_pre_name ; if ( drv -> trans -> cfg -> device_family == IWL_DEVICE_FAMILY_9000 && <S2SV_StartBug> CSR_HW_REV_STEP ( drv -> trans -> hw_rev ) == SILICON_B_STEP ) <S2SV_EndBug> fw_pre_name = cfg -> fw_name_pre_next_step ; else if ( drv -> trans -> cfg -> integrated && CSR_HW_RFID_STEP ( drv -> trans -> hw_rf_id ) == SILICON_B_STEP && cfg -> fw_name_pre_rf_next_step ) fw_pre_name = cfg -> fw_name_pre_rf_next_step ; else fw_pre_name = cfg -> fw_name_pre ; if ( first ) { drv -> fw_index = cfg -> ucode_api_max ; sprintf ( tag , "%d" , drv -> fw_index ) ; } else { drv -> fw_index -- ; sprintf ( tag , "%d" , drv -> fw_index ) ; } if ( drv -> fw_index < cfg -> ucode_api_min ) { IWL_ERR ( drv , "no<S2SV_blank>suitable<S2SV_blank>firmware<S2SV_blank>found!\\n" ) ; if ( cfg -> ucode_api_min == cfg -> ucode_api_max ) { IWL_ERR ( drv , "%s%d<S2SV_blank>is<S2SV_blank>required\\n" , fw_pre_name , cfg -> ucode_api_max ) ; } else { IWL_ERR ( drv , "minimum<S2SV_blank>version<S2SV_blank>required:<S2SV_blank>%s%d\\n" , fw_pre_name , cfg -> ucode_api_min ) ; IWL_ERR ( drv , "maximum<S2SV_blank>version<S2SV_blank>supported:<S2SV_blank>%s%d\\n" , fw_pre_name , cfg -> ucode_api_max ) ; } IWL_ERR ( drv , "check<S2SV_blank>git://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git\\n" ) ; return - ENOENT ; } snprintf ( drv -> firmware_name , sizeof ( drv -> firmware_name ) , "%s%s.ucode" , fw_pre_name , tag ) ; IWL_DEBUG_INFO ( drv , "attempting<S2SV_blank>to<S2SV_blank>load<S2SV_blank>firmware<S2SV_blank>\'%s\'\\n" , drv -> firmware_name ) ; return request_firmware_nowait ( THIS_MODULE , 1 , drv -> firmware_name , drv -> trans -> dev , GFP_KERNEL , drv , iwl_req_fw_callback ) ; } | <S2SV_ModStart> == IWL_DEVICE_FAMILY_9000 && ( <S2SV_ModStart> ) == SILICON_B_STEP || CSR_HW_REV_STEP ( drv -> trans -> hw_rev ) == SILICON_C_STEP ) ) fw_pre_name = cfg -> fw_name_pre_b_or_c_step <S2SV_ModEnd> ; else if |
5,132 | CWE-000 <S2SV_StartBug> static char * plc_datum_as_int2 ( Datum input , plcTypeInfo * type UNUSED ) { <S2SV_EndBug> char * out = ( char * ) pmalloc ( 2 ) ; * ( ( int16 * ) out ) = DatumGetInt16 ( input ) ; return out ; } | <S2SV_ModStart> Datum input , pg_attribute_unused ( ) <S2SV_ModStart> plcTypeInfo * type <S2SV_ModEnd> ) { char |
5,133 | CWE-000 void exec_opt ( t_vm * vm , t_process * process ) { <S2SV_StartBug> static void ( * f [ ] ) ( ) = { NULL , & live , & ld , & st , & add , & sub <S2SV_EndBug> } ; unsigned char byte_code ; unsigned int octal_skip ; if ( ! ( octal_skip = check_octal ( vm , process ) ) ) { <S2SV_StartBug> printf ( "byte_code:<S2SV_blank>%u\\n" , process -> op_code ) ; <S2SV_EndBug> f [ process -> op_code ] ( vm , process ) ; } <S2SV_StartBug> else <S2SV_EndBug> <S2SV_StartBug> process -> pc += octal_skip ; <S2SV_EndBug> process -> op_code = 0 ; process -> exec_cycle = 0 ; byte_code = vm -> map [ PTR ( process -> pc ) ] ; if ( byte_code > 0 && byte_code <= 16 ) { process -> exec_cycle = g_op_tab [ byte_code ] . cycles + vm -> cycle ; process -> op_code = g_op_tab [ byte_code ] . opcode ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> , & sub , & and , & or , & xor , & zjmp <S2SV_ModStart> ) ) { f [ <S2SV_ModEnd> process -> op_code <S2SV_ModStart> process -> op_code <S2SV_ModEnd> ] ( vm <S2SV_ModStart> ; } else { <S2SV_ModStart> += octal_skip ; } <S2SV_ModStart> opcode ; } else { if ( ++ process -> pc > MEM_SIZE ) process -> pc = process -> pc % MEM_SIZE ; } |
5,134 | CWE-000 void GetStickCtrlChassisPositionProgram ( void ) { float targetX = 1100 , targetY = 1100 , targetZ = 1100 ; chassisPositionTarget . x = MAP ( targetX , CH_MIN , CH_MAX , - INPUT_CHASSIS_POSITION_MAX , INPUT_CHASSIS_POSITION_MAX ) ; chassisPositionTarget . y = MAP ( targetY , CH_MIN , CH_MAX , - INPUT_CHASSIS_POSITION_MAX , INPUT_CHASSIS_POSITION_MAX ) ; chassisPositionTarget . z = MAP ( targetZ , CH_MIN , CH_MAX , - INPUT_GIMBALS_POSITION_MAX , INPUT_GIMBALS_POSITION_MAX ) ; <S2SV_StartBug> RAMP_CALC_Mecanum ( & chassisPositionTarget , INPUT_MODE_RC ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( & chassisPositionTarget <S2SV_ModEnd> ) ; } |
5,135 | CWE-000 static UINT16 GetDigestSize ( TPM_ALG_ID authHash ) { <S2SV_StartBug> INT8 i ; <S2SV_EndBug> for ( i = 0 ; i < ( sizeof ( hashSizes ) / sizeof ( HASH_SIZE_INFO ) ) ; i ++ ) { if ( hashSizes [ i ] . algId == authHash ) return hashSizes [ i ] . size ; } return ( 0 ) ; } | <S2SV_ModStart> authHash ) { UINT32 <S2SV_ModEnd> i ; for |
5,136 | CWE-000 int device_init_wakeup ( struct device * dev , bool enable ) { <S2SV_StartBug> int ret = 0 ; <S2SV_EndBug> if ( enable ) { device_set_wakeup_capable ( dev , true ) ; ret = device_wakeup_enable ( dev ) ; } else { <S2SV_StartBug> device_set_wakeup_capable ( dev , false ) ; <S2SV_EndBug> } return ret ; } | <S2SV_ModStart> ret = 0 ; if ( ! dev ) return - EINVAL <S2SV_ModStart> } else { if ( dev -> power . can_wakeup ) device_wakeup_disable ( dev ) ; |
5,137 | CWE-000 uint64_t pdbg_target_address ( struct pdbg_target * target , uint64_t * out_size ) { const struct dt_property * p ; u32 na = dt_n_address_cells ( target ) ; u32 ns = dt_n_size_cells ( target ) ; <S2SV_StartBug> u32 pos , n ; <S2SV_EndBug> p = dt_require_property ( target , "reg" , - 1 ) ; n = ( na + ns ) * sizeof ( u32 ) ; <S2SV_StartBug> pos = n ; <S2SV_EndBug> assert ( ( pos + n ) <= p -> len ) ; if ( out_size ) <S2SV_StartBug> * out_size = dt_get_number ( p -> prop + pos + na * sizeof ( u32 ) , ns ) ; <S2SV_EndBug> <S2SV_StartBug> return dt_get_number ( p -> prop + pos , na ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; u32 <S2SV_ModEnd> n ; p <S2SV_ModStart> u32 ) ; assert ( n <S2SV_ModEnd> <= p -> <S2SV_ModStart> -> prop + <S2SV_ModEnd> na * sizeof <S2SV_ModStart> p -> prop <S2SV_ModEnd> , na ) |
5,138 | CWE-000 void write_command ( int fd , const char * cmd ) { ssize_t written ; written = write ( fd , cmd , strlen ( cmd ) ) ; <S2SV_StartBug> printf ( "Wrote<S2SV_blank>command:<S2SV_blank>\'%s\';<S2SV_blank>%zi<S2SV_blank>of<S2SV_blank>%zi<S2SV_blank>bytes<S2SV_blank>written.\\n" , cmd , written , strlen ( cmd ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ) ; char cmd_output [ 100 ] ; strncpy ( cmd_output , cmd , 100 ) ; cmd_output [ strlen ( cmd_output ) - 1 ] = 0 ; <S2SV_ModStart> ( "Wrote<S2SV_blank>command:<S2SV_blank>\'%s\';<S2SV_blank>%zi<S2SV_blank>of<S2SV_blank>%zi<S2SV_blank>bytes<S2SV_blank>written.\\n" , cmd_output <S2SV_ModEnd> , written , |
5,139 | CWE-000 __print_funct_t stub_print_filesystem_stats ( struct activity * a , int curr , int dispavg ) { int i , j ; struct stats_filesystem * sfc , * sfm ; int unit = NO_UNIT ; if ( DISPLAY_UNIT ( flags ) ) { unit = UNIT_BYTE ; } if ( dis ) { print_hdr_line ( ( dispavg ? _ ( "Summary:" ) : timestamp [ ! curr ] ) , a , FIRST + DISPLAY_MOUNT ( a -> opt_flags ) , - 1 , 9 ) ; } for ( i = 0 ; i < a -> nr [ curr ] ; i ++ ) { sfc = ( struct stats_filesystem * ) ( ( char * ) a -> buf [ curr ] + i * a -> msize ) ; printf ( "%-11s" , ( dispavg ? _ ( "Summary:" ) : timestamp [ curr ] ) ) ; cprintf_f ( unit , 2 , 9 , 0 , unit < 0 ? ( double ) sfc -> f_bfree / 1024 / 1024 : ( double ) sfc -> f_bfree , unit < 0 ? ( double ) ( sfc -> f_blocks - sfc -> f_bfree ) / 1024 / 1024 : ( double ) ( sfc -> f_blocks - sfc -> f_bfree ) ) ; cprintf_pc ( DISPLAY_UNIT ( flags ) , 2 , 9 , 2 , sfc -> f_blocks ? SP_VALUE ( sfc -> f_bfree , sfc -> f_blocks , sfc -> f_blocks ) : 0.0 , sfc -> f_blocks ? SP_VALUE ( sfc -> f_bavail , sfc -> f_blocks , sfc -> f_blocks ) : 0.0 ) ; cprintf_u64 ( NO_UNIT , 2 , 9 , ( unsigned long long ) sfc -> f_ffree , ( unsigned long long ) ( sfc -> f_files - sfc -> f_ffree ) ) ; cprintf_pc ( DISPLAY_UNIT ( flags ) , 1 , 9 , 2 , sfc -> f_files ? SP_VALUE ( sfc -> f_ffree , sfc -> f_files , sfc -> f_files ) : 0.0 ) ; cprintf_in ( IS_STR , "<S2SV_blank>%s\\n" , DISPLAY_MOUNT ( a -> opt_flags ) ? sfc -> mountp : sfc -> fs_name , 0 ) ; if ( ! dispavg ) { for ( j = 0 ; j < a -> nr_allocated ; j ++ ) { sfm = ( struct stats_filesystem * ) ( ( char * ) a -> buf [ 2 ] + j * a -> msize ) ; if ( ! strcmp ( sfm -> fs_name , sfc -> fs_name ) || ! sfm -> f_blocks ) { * sfm = * sfc ; <S2SV_StartBug> break ; <S2SV_EndBug> } } if ( j == a -> nr_allocated ) { reallocate_all_buffers ( a ) ; sfm = ( struct stats_filesystem * ) ( ( char * ) a -> buf [ 2 ] + j * a -> msize ) ; * sfm = * sfc ; <S2SV_StartBug> } <S2SV_EndBug> } } } | <S2SV_ModStart> * sfc ; if ( j >= a -> nr [ 2 ] ) { a -> nr [ 2 ] = j + 1 ; } <S2SV_ModStart> * sfc ; a -> nr [ 2 ] = j + 1 ; |
5,140 | CWE-000 static int get_one_number ( struct dmr_C * C , int c , int next , struct stream_t * stream ) { struct token * token ; char * buffer = C -> T -> number_buffer ; <S2SV_StartBug> char * p = buffer , * buf , * buffer_end = buffer + sizeof ( buffer ) ; <S2SV_EndBug> size_t len ; * p ++ = c ; for ( ; ; ) { long kclass = C -> T -> cclass [ next + 1 ] ; if ( ! ( kclass & ( Dot | Digit | Letter ) ) ) break ; if ( p != buffer_end ) * p ++ = next ; next = nextchar ( C , stream ) ; if ( kclass & Exp ) { if ( next == '-' || next == '+' ) { if ( p != buffer_end ) * p ++ = next ; next = nextchar ( C , stream ) ; } } } if ( p == buffer_end ) { sparse_error ( C , stream_pos ( stream ) , "number<S2SV_blank>token<S2SV_blank>exceeds<S2SV_blank>%td<S2SV_blank>characters" , buffer_end - buffer ) ; buffer [ 0 ] = '1' ; p = buffer + 1 ; } * p ++ = 0 ; len = p - buffer ; buf = ( char * ) allocator_allocate ( & C -> byte_allocator , len ) ; memcpy ( buf , buffer , len ) ; token = stream -> token ; token_type ( token ) = TOKEN_NUMBER ; token -> number = buf ; add_token ( stream ) ; return next ; } | <S2SV_ModStart> buffer + sizeof C -> T -> number_buffer <S2SV_ModEnd> ; size_t len |
5,141 | CWE-000 static void qpic_nand_add_wr_page_cws_cmd_desc ( struct cfg_params * cfg , uint32_t status [ ] , enum nand_cfg_value cfg_mode ) { struct cmd_element * cmd_list_ptr = ce_array ; struct cmd_element * cmd_list_read_ptr = ce_read_array ; struct cmd_element * cmd_list_ptr_start = ce_array ; struct cmd_element * cmd_list_read_ptr_start = ce_read_array ; uint32_t ecc ; int num_desc = 0 ; int int_flag = 0 ; if ( cfg_mode == NAND_CFG ) ecc = ecc_bch_cfg ; else ecc = ecc_bch_cfg | 0x1 ; bam_add_cmd_element ( cmd_list_ptr , NAND_DEV0_ECC_CFG , ( uint32_t ) ecc , CE_WRITE_TYPE ) ; cmd_list_ptr ++ ; cmd_list_ptr = qpic_nand_add_addr_n_cfg_ce ( cfg , cmd_list_ptr ) ; bam_add_cmd_element ( cmd_list_ptr , NAND_FLASH_CMD , ( uint32_t ) cfg -> cmd , CE_WRITE_TYPE ) ; cmd_list_ptr ++ ; bam_add_one_desc ( & bam , CMD_PIPE_INDEX , ( unsigned char * ) PA ( ( addr_t ) cmd_list_ptr_start ) , PA ( ( uint32_t ) cmd_list_ptr - ( uint32_t ) cmd_list_ptr_start ) , BAM_DESC_CMD_FLAG | BAM_DESC_LOCK_FLAG ) ; num_desc ++ ; for ( unsigned i = 0 ; i < flash . cws_per_page ; i ++ ) { cmd_list_ptr_start = cmd_list_ptr ; int_flag = BAM_DESC_INT_FLAG ; bam_add_cmd_element ( cmd_list_ptr , NAND_EXEC_CMD , ( uint32_t ) cfg -> exec , CE_WRITE_TYPE ) ; cmd_list_ptr ++ ; bam_add_one_desc ( & bam , CMD_PIPE_INDEX , ( unsigned char * ) PA ( ( addr_t ) cmd_list_ptr_start ) , PA ( ( uint32_t ) cmd_list_ptr - ( uint32_t ) cmd_list_ptr_start ) , BAM_DESC_NWD_FLAG | BAM_DESC_CMD_FLAG ) ; num_desc ++ ; cmd_list_ptr_start = cmd_list_ptr ; cmd_list_read_ptr_start = cmd_list_read_ptr ; cmd_list_read_ptr = qpic_nand_add_read_ce ( cmd_list_read_ptr_start , & status [ i ] ) ; bam_add_one_desc ( & bam , CMD_PIPE_INDEX , ( unsigned char * ) PA ( ( addr_t ) cmd_list_read_ptr_start ) , PA ( ( uint32_t ) cmd_list_read_ptr - ( uint32_t ) cmd_list_read_ptr_start ) , BAM_DESC_CMD_FLAG ) ; if ( i == flash . cws_per_page - 1 ) cmd_list_ptr = qpic_nand_reset_status_ce ( cmd_list_ptr , 1 ) ; else cmd_list_ptr = qpic_nand_reset_status_ce ( cmd_list_ptr , 0 ) ; bam_add_one_desc ( & bam , CMD_PIPE_INDEX , ( unsigned char * ) PA ( ( addr_t ) cmd_list_ptr_start ) , PA ( ( uint32_t ) cmd_list_ptr - ( uint32_t ) cmd_list_ptr_start ) , int_flag | BAM_DESC_CMD_FLAG ) ; num_desc += 2 ; <S2SV_StartBug> qpic_nand_wait_for_cmd_exec ( num_desc ) ; <S2SV_EndBug> <S2SV_StartBug> status [ i ] = qpic_nand_check_status ( status [ i ] ) ; <S2SV_EndBug> num_desc = 0 ; } return ; } | <S2SV_ModStart> += 2 ; # ifdef SIERRA arch_clean_invalidate_cache_range ( ( addr_t ) & <S2SV_ModEnd> status [ i <S2SV_ModStart> [ i ] , sizeof ( uint32_t ) ) ; qpic_nand_wait_for_cmd_exec ( num_desc ) ; arch_clean_invalidate_cache_range ( ( addr_t ) & <S2SV_ModEnd> status [ i <S2SV_ModStart> [ i ] , sizeof ( uint32_t ) ) ; # else qpic_nand_wait_for_cmd_exec ( num_desc ) ; # endif status [ i ] = qpic_nand_check_status ( status [ i ] |
5,142 | CWE-000 void bdb_set_key ( bdb_state_type * bdb_state ) { <S2SV_StartBug> int rc ; <S2SV_EndBug> if ( gbl_bdb_state ) return ; if ( bdb_state -> parent ) bdb_state = bdb_state -> parent ; gbl_bdb_state = bdb_state ; <S2SV_StartBug> rc = pthread_setspecific ( bdb_key , bdb_state ) ; <S2SV_EndBug> <S2SV_StartBug> if ( rc != 0 ) { <S2SV_EndBug> logmsg ( LOGMSG_ERROR , "pthread_setspecific<S2SV_blank>failed\\n" ) ; } } | <S2SV_ModStart> bdb_state ) { <S2SV_ModEnd> if ( gbl_bdb_state <S2SV_ModStart> = bdb_state ; Pthread_setspecific <S2SV_ModEnd> ( bdb_key , <S2SV_ModStart> bdb_state ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
5,143 | CWE-000 SOCKET_LISTENER_HANDLE socketlistener_create ( int port ) { SOCKET_LISTENER_INSTANCE * result = ( SOCKET_LISTENER_INSTANCE * ) malloc ( sizeof ( SOCKET_LISTENER_INSTANCE ) ) ; <S2SV_StartBug> if ( result != NULL ) <S2SV_EndBug> { result -> port = port ; result -> on_socket_accepted = NULL ; result -> callback_context = NULL ; } return ( SOCKET_LISTENER_HANDLE ) result ; } | <S2SV_ModStart> if ( result == NULL ) { LogError ( "Cannot<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>socket<S2SV_blank>listener" ) ; } else <S2SV_ModEnd> { result -> |
5,144 | CWE-000 static void process_client_msg ( XClientMessageEvent * ev ) { int cmd = ev -> data . b [ 0 ] ; int monitor ; int edge ; char * plugin_type ; char * command ; switch ( cmd ) { # ifndef DISABLE_MENU case LXPANEL_CMD_SYS_MENU : { GSList * l ; for ( l = all_panels ; l ; l = l -> next ) { LXPanel * p = ( LXPanel * ) l -> data ; GList * plugins , * pl ; if ( p -> priv -> box == NULL ) continue ; plugins = gtk_container_get_children ( GTK_CONTAINER ( p -> priv -> box ) ) ; for ( pl = plugins ; pl ; pl = pl -> next ) { const LXPanelPluginInit * init = PLUGIN_CLASS ( pl -> data ) ; if ( init -> show_system_menu ) init -> show_system_menu ( pl -> data ) ; } g_list_free ( plugins ) ; } break ; } # endif case LXPANEL_CMD_RUN : gtk_run ( ) ; break ; case LXPANEL_CMD_CONFIG : { LXPanel * p = ( ( all_panels != NULL ) ? all_panels -> data : NULL ) ; if ( p != NULL ) panel_configure ( p , 0 ) ; } break ; case LXPANEL_CMD_RESTART : restart ( ) ; break ; case LXPANEL_CMD_EXIT : gtk_main_quit ( ) ; break ; case LXPANEL_CMD_REFRESH : { LXPanel * p = ( ( all_panels != NULL ) ? all_panels -> data : NULL ) ; if ( p != NULL ) { char linebuf [ 256 ] , posbuf [ 16 ] ; int val ; FILE * fp = fopen ( _user_config_file_name ( "panels" , p -> priv -> name ) , "rb" ) ; <S2SV_StartBug> while ( ! feof ( fp ) ) <S2SV_EndBug> { if ( fgets ( linebuf , 256 , fp ) ) { if ( sscanf ( linebuf , "%*[<S2SV_blank>\\t]iconsize=%d" , & val ) == 1 ) { p -> priv -> icon_size = val ; p -> priv -> height = val ; panel_set_panel_configuration_changed ( p -> priv ) ; } if ( sscanf ( linebuf , "%*[<S2SV_blank>\\t]edge=%s" , posbuf ) == 1 ) { if ( ! strcmp ( posbuf , "bottom" ) ) { if ( p -> priv -> edge != EDGE_BOTTOM ) { p -> priv -> edge = EDGE_BOTTOM ; gtk_widget_queue_resize ( GTK_WIDGET ( p ) ) ; } } else { if ( p -> priv -> edge != EDGE_TOP ) { p -> priv -> edge = EDGE_TOP ; gtk_widget_queue_resize ( GTK_WIDGET ( p ) ) ; } } } if ( sscanf ( linebuf , "%*[<S2SV_blank>\\t]MaxTaskWidth=%d" , & val ) == 1 ) { GList * plugins , * pl ; const LXPanelPluginInit * init ; char buf [ 10 ] ; init = g_hash_table_lookup ( lxpanel_get_all_types ( ) , "taskbar" ) ; if ( init && init -> control ) { plugins = gtk_container_get_children ( GTK_CONTAINER ( p -> priv -> box ) ) ; for ( pl = plugins ; pl ; pl = pl -> next ) { if ( init == PLUGIN_CLASS ( pl -> data ) ) { sprintf ( buf , "mtw%d\\n" , val ) ; init -> control ( pl -> data , buf ) ; break ; } } g_list_free ( plugins ) ; } } } <S2SV_StartBug> } <S2SV_EndBug> } } break ; case LXPANEL_CMD_COMMAND : monitor = ( ev -> data . b [ 1 ] & 0xf ) - 1 ; edge = ( ev -> data . b [ 1 ] >> 4 ) & 0x7 ; if ( ( ev -> data . b [ 1 ] & 0x80 ) != 0 ) break ; plugin_type = g_strndup ( & ev -> data . b [ 2 ] , 18 ) ; command = strchr ( plugin_type , '\\t' ) ; if ( command ) do { LXPanel * p ; GSList * l ; GList * plugins , * pl ; const LXPanelPluginInit * init ; GtkWidget * plugin = NULL ; * command ++ = '\\0' ; for ( l = all_panels ; l ; l = l -> next ) { p = ( LXPanel * ) l -> data ; if ( p -> priv -> box == NULL ) continue ; if ( monitor >= 0 && p -> priv -> monitor != monitor ) continue ; if ( edge == EDGE_NONE || p -> priv -> edge == edge ) break ; } if ( l == NULL ) break ; init = g_hash_table_lookup ( lxpanel_get_all_types ( ) , plugin_type ) ; if ( init == NULL ) break ; plugins = gtk_container_get_children ( GTK_CONTAINER ( p -> priv -> box ) ) ; for ( pl = plugins ; pl ; pl = pl -> next ) { if ( init == PLUGIN_CLASS ( pl -> data ) ) { plugin = pl -> data ; break ; } } g_list_free ( plugins ) ; if ( strcmp ( command , "ADD" ) == 0 ) { if ( plugin == NULL ) { config_setting_t * cfg ; cfg = config_group_add_subgroup ( config_root_setting ( p -> priv -> config ) , "Plugin" ) ; config_group_set_string ( cfg , "type" , plugin_type ) ; plugin = lxpanel_add_plugin ( p , plugin_type , cfg , - 1 ) ; if ( plugin == NULL ) config_setting_destroy ( cfg ) ; } } else if ( strcmp ( command , "DEL" ) == 0 ) { if ( plugin != NULL ) lxpanel_remove_plugin ( p , plugin ) ; } else if ( plugin && init -> control ) init -> control ( plugin , command ) ; } while ( 0 ) ; g_free ( plugin_type ) ; break ; } } | <S2SV_ModStart> ; while ( fp && <S2SV_ModStart> } } } if ( fp ) fclose ( fp ) ; |
5,145 | CWE-000 NecroAST_LocalPtr parse_expression ( NecroLexToken * * tokens , NecroAST * ast ) { # ifdef PARSE_DEBUG_PRINT <S2SV_StartBug> printf ( "<S2SV_blank>parse_expression<S2SV_blank>{<S2SV_blank>tokens**:<S2SV_blank>%p,<S2SV_blank>tokens*:<S2SV_blank>%p,<S2SV_blank>token:<S2SV_blank>%i<S2SV_blank>,<S2SV_blank>ast:<S2SV_blank>%p<S2SV_blank>}\\n" , tokens , * tokens , ( * tokens ) -> token , ast ) ; <S2SV_EndBug> # endif if ( ( * tokens ) -> token == NECRO_LEX_END_OF_STREAM ) return null_local_ptr ; NecroLexToken * original_tokens = * tokens ; size_t original_ast_size = ast -> arena . size ; NecroAST_LocalPtr local_ptr = null_local_ptr ; if ( local_ptr == null_local_ptr ) { local_ptr = parse_constant ( tokens , ast ) ; } if ( local_ptr == null_local_ptr ) { local_ptr = parse_function_composition ( tokens , ast ) ; } if ( local_ptr == null_local_ptr ) { local_ptr = parse_binary_operation ( tokens , ast ) ; } if ( local_ptr == null_local_ptr ) { local_ptr = parse_unary_operation ( tokens , ast ) ; } if ( local_ptr != null_local_ptr ) { return local_ptr ; } * tokens = original_tokens ; ast -> arena . size = original_ast_size ; return null_local_ptr ; } | <S2SV_ModStart> PARSE_DEBUG_PRINT printf ( "<S2SV_blank>parse_expression<S2SV_blank>{<S2SV_blank>tokens**:<S2SV_blank>%p,<S2SV_blank>tokens*:<S2SV_blank>%p,<S2SV_blank>token:<S2SV_blank>%s<S2SV_blank>,<S2SV_blank>ast:<S2SV_blank>%p<S2SV_blank>}\\n" , tokens , * tokens , necro_lex_token_type_string ( <S2SV_ModEnd> ( * tokens <S2SV_ModStart> ) -> token ) , <S2SV_ModEnd> ast ) ; |
5,146 | CWE-000 void draw_graphical_x ( int window_height , int bars_count , int bar_width , int bar_spacing , int rest , int gradient , int f [ 200 ] , int flastd [ 200 ] , double foreground_opacity ) { if ( GLXmode ) { # ifdef GLX glClearColor ( xbgcol . red / 65535.0 , xbgcol . green / 65535.0 , xbgcol . blue / 65535.0 , ( ! transparentFlag ) * 1.0 ) ; glClear ( GL_COLOR_BUFFER_BIT ) ; # endif } else { if ( gradient && ! gradientBox && transparentFlag ) render_gradient_x ( window_height , bar_width , foreground_opacity ) ; } if ( GLXmode ) { # ifdef GLX float glColors [ 11 ] = { gradient ? xgrad [ 0 ] . red / 65535.0 : xcol . red / 65535.0 , gradient ? xgrad [ 0 ] . green / 65535.0 : xcol . green / 65535.0 , gradient ? xgrad [ 0 ] . blue / 65535.0 : xcol . blue / 65535.0 , xgrad [ 1 ] . red / 65535.0 , xgrad [ 1 ] . green / 65535.0 , xgrad [ 1 ] . blue / 65535.0 , foreground_opacity , ( ( unsigned int ) shadow_color >> 24 ) % 256 / 255.0 , ( ( unsigned int ) shadow_color >> 16 ) % 256 / 255.0 , ( ( unsigned int ) shadow_color >> 8 ) % 256 / 255.0 , ( unsigned int ) shadow_color % 256 / 255.0 } ; <S2SV_StartBug> if ( drawGLBars ( cavaGLVertex , rest , bar_width , bar_spacing , bars_count , window_height , shadow , gradient , glColors , f ) ) exit ( EXIT_FAILURE ) ; <S2SV_EndBug> # endif } else { for ( int i = 0 ; i < bars_count ; i ++ ) { if ( f [ i ] > window_height ) f [ i ] = window_height ; if ( f [ i ] > flastd [ i ] ) { if ( gradient && transparentFlag ) XCopyArea ( cavaXDisplay , gradientBox , cavaXWindow , cavaXGraphics , 0 , window_height - f [ i ] , bar_width , f [ i ] - flastd [ i ] , rest + i * ( bar_spacing + bar_width ) , window_height - f [ i ] ) ; else { XSetForeground ( cavaXDisplay , cavaXGraphics , xcol . pixel ) ; XFillRectangle ( cavaXDisplay , cavaXWindow , cavaXGraphics , rest + i * ( bar_spacing + bar_width ) , window_height - f [ i ] , bar_width , f [ i ] - flastd [ i ] ) ; } } else if ( f [ i ] < flastd [ i ] ) XClearArea ( cavaXDisplay , cavaXWindow , rest + i * ( bar_spacing + bar_width ) , window_height - flastd [ i ] , bar_width , flastd [ i ] - f [ i ] , FALSE ) ; } } # ifdef GLX if ( GLXmode ) { <S2SV_StartBug> glDrawArrays ( GL_QUADS , 0 , bars_count * ( shadow ? 20 : 4 ) ) ; <S2SV_EndBug> glXSwapBuffers ( cavaXDisplay , cavaXWindow ) ; glXWaitGL ( ) ; } # endif XSync ( cavaXDisplay , 0 ) ; return ; } | <S2SV_ModStart> ( drawGLBars ( <S2SV_ModEnd> rest , bar_width <S2SV_ModStart> GLXmode ) { <S2SV_ModEnd> glXSwapBuffers ( cavaXDisplay |
5,147 | CWE-000 int solve_diffusion ( int print , struct Point points [ ] , int n_x , int n_y , double total_time , double initial_temp , int i_bc , int j_bc , double source_val , double diff_1 , double diff_2 , int i_1 , int i_2 , int j_1 , int j_2 ) { double res = 10.0 ; int iter = 0 , length = n_x * n_y ; double d_x , d_y ; double delta_space , timestep , side_size , max_diff ; max_diff = diff_1 > diff_2 ? diff_1 : diff_2 ; side_size = sqrt ( 2 * max_diff * total_time ) ; if ( print ) printf ( "Side<S2SV_blank>size<S2SV_blank>=<S2SV_blank>%.10e\\n" , side_size ) ; d_x = side_size / ( n_x - 1 ) ; d_y = side_size / ( n_y - 1 ) ; delta_space = d_x < d_y ? d_x : d_y ; timestep = 0.25 * delta_space * delta_space / max_diff ; timestep *= 0.98 ; if ( print ) printf ( "Delta<S2SV_blank>time<S2SV_blank>=<S2SV_blank>%.10e\\n" , timestep ) ; compute_mesh ( points , n_x , n_y , side_size , side_size , d_x , d_y ) ; set_diffusivities ( points , n_x , n_y , diff_1 , diff_2 , i_1 , i_2 , j_1 , j_2 ) ; init_temperatures ( points , length , initial_temp ) ; points [ i_bc + j_bc * n_x ] . source = source_val ; while ( iter < ( total_time / timestep ) ) { iter ++ ; res = compute_step ( points , n_x , n_y , side_size , side_size , timestep , d_x , d_y ) ; if ( print && ( iter % 1000 == 0 ) ) printf ( "Residual<S2SV_blank>=<S2SV_blank>%.10e,<S2SV_blank>Number<S2SV_blank>of<S2SV_blank>iterations<S2SV_blank>=<S2SV_blank>%d\\n" , res , iter ) ; <S2SV_StartBug> if ( iter % 10000 == 0 ) { <S2SV_EndBug> write_vtk ( points , n_x , n_y , iter / 10000 ) ; write_res_vtk ( points , n_x , n_y , iter / 10000 ) ; } } if ( print ) printf ( "Residual<S2SV_blank>=<S2SV_blank>%.10e,<S2SV_blank>Number<S2SV_blank>of<S2SV_blank>iterations<S2SV_blank>=<S2SV_blank>%d\\n" , res , iter ) ; write_vtk ( points , n_x , n_y , 0 ) ; write_res_vtk ( points , n_x , n_y , 0 ) ; return iter ; } | <S2SV_ModStart> iter ) ; <S2SV_ModEnd> } if ( |
5,148 | CWE-000 int test_arithmetic ( void ) { struct chip8_options opts = chip8_options_testing ( ) ; struct chip8 * chip = chip8_new ( opts ) ; <S2SV_StartBug> chip8_execute_opcode ( chip , 0x6066 ) ; <S2SV_EndBug> chip8_execute_opcode ( chip , 0x700A ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x70 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 0 ) ; chip8_execute_opcode ( chip , 0x70FF ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x6F ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 1 ) ; chip8_execute_opcode ( chip , 0x6110 ) ; chip8_execute_opcode ( chip , 0x8011 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x7F ) ; chip8_execute_opcode ( chip , 0x62F0 ) ; chip8_execute_opcode ( chip , 0x8022 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x70 ) ; chip8_execute_opcode ( chip , 0x8023 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x80 ) ; chip8_execute_opcode ( chip , 0x8024 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x70 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 1 ) ; chip8_execute_opcode ( chip , 0x6170 ) ; chip8_execute_opcode ( chip , 0x8014 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0xE0 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 0 ) ; chip8_execute_opcode ( chip , 0x8015 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x70 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 1 ) ; chip8_execute_opcode ( chip , 0x8025 ) ; ASSERT_EQ ( chip -> regs [ REG_V0 ] , 0x80 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 0 ) ; chip8_execute_opcode ( chip , 0x6307 ) ; chip8_execute_opcode ( chip , 0x8306 ) ; ASSERT_EQ ( chip -> regs [ REG_V3 ] , 0x03 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 1 ) ; chip8_execute_opcode ( chip , 0x830E ) ; ASSERT_EQ ( chip -> regs [ REG_V3 ] , 0x06 ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 0 ) ; chip8_execute_opcode ( chip , 0x8307 ) ; ASSERT_EQ ( chip -> regs [ REG_V3 ] , 0x7A ) ; ASSERT_EQ ( chip -> regs [ REG_VF ] , 1 ) ; chip8_destroy ( chip ) ; return 0 ; } | <S2SV_ModStart> opts ) ; ASSERT ( chip != NULL ) ; |
5,149 | CWE-000 static void iterator_get_visible_state ( const Iterator * self , Tree * * tree , TSSymbol * alias_symbol , uint32_t * start_byte ) { uint32_t i = self -> path . size - 1 ; if ( self -> in_padding ) { <S2SV_StartBug> while ( self -> path . contents [ i ] . child_index == 0 ) i -- ; <S2SV_EndBug> } for ( ; i + 1 > 0 ; i -- ) { TreePathEntry entry = self -> path . contents [ i ] ; if ( i > 0 ) { Tree * parent = self -> path . contents [ i - 1 ] . tree ; const TSSymbol * alias_sequence = ts_language_alias_sequence ( self -> language , parent -> alias_sequence_id ) ; if ( alias_sequence ) { * alias_symbol = alias_sequence [ entry . structural_child_index ] ; } } if ( entry . tree -> visible || * alias_symbol ) { * tree = entry . tree ; * start_byte = entry . position . bytes ; break ; } } } | <S2SV_ModStart> in_padding ) { if ( i <S2SV_ModEnd> == 0 ) <S2SV_ModStart> == 0 ) return ; |
5,150 | CWE-000 uint8_t msb_16 ( uint16_t v ) { <S2SV_StartBug> return ( sizeof ( unsigned int ) * 8 ) - __builtin_clz ( v ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( v ) - 1 |
5,151 | CWE-000 void mat_cutoff ( mat_t * mat , real_t cutoff ) { size_t i ; ST_CHECK_PARAM_VOID ( mat == NULL || cutoff < 0 ) ; <S2SV_StartBug> for ( i = 0 ; i < mat -> num_rows * mat -> num_cols ; i ++ ) { <S2SV_EndBug> if ( mat -> vals [ i ] > cutoff ) { mat -> vals [ i ] = cutoff ; } else if ( mat -> vals [ i ] < - cutoff ) { mat -> vals [ i ] = - cutoff ; } } } | <S2SV_ModStart> * mat -> stride <S2SV_ModEnd> ; i ++ |
5,152 | CWE-000 char * save_file_popup ( int h , int w ) { WINDOW * win ; char * fname = ( char * ) malloc ( sizeof ( char ) * FNAME_MAX_SIZE ) ; <S2SV_StartBug> char ch ; <S2SV_EndBug> int i ; int win_height = 3 ; int win_width = 42 ; echo ( ) ; <S2SV_StartBug> win = newpad ( win_height , win_width ) ; <S2SV_EndBug> wbkgd ( win , COLOR_PAIR ( 3 ) ) ; box ( win , ACS_VLINE , ACS_HLINE ) ; mvwaddstr ( win , 1 , 1 , "<S2SV_blank>Enter<S2SV_blank>file<S2SV_blank>name:<S2SV_blank>" ) ; <S2SV_StartBug> prefresh ( win , 0 , 0 , h / 2 - win_height / 2 , w / 2 - win_width / 2 , <S2SV_EndBug> h / 2 + win_height / 2 , w / 2 + win_width / 2 ) ; for ( i = 0 ; ( ch = wgetch ( win ) ) != '\\n' && i != FNAME_MAX_SIZE ; ++ i ) { fname [ i ] = ch ; prefresh ( win , 0 , 0 , h / 2 - win_height / 2 , w / 2 - win_width / 2 , h / 2 + win_height / 2 , w / 2 + win_width / 2 ) ; } fname [ i ] = '\\0' ; noecho ( ) ; <S2SV_StartBug> wclear ( win ) ; <S2SV_EndBug> return fname ; } | <S2SV_ModStart> FNAME_MAX_SIZE ) ; <S2SV_ModEnd> int win_height = <S2SV_ModStart> ; win = newwin <S2SV_ModEnd> ( win_height , <S2SV_ModStart> win_height , win_width , h / 2 - win_height / 2 , w / 2 - win_width / 2 <S2SV_ModStart> "<S2SV_blank>Enter<S2SV_blank>file<S2SV_blank>name:<S2SV_blank>" ) ; wrefresh ( win ) ; mvwgetstr <S2SV_ModEnd> ( win , <S2SV_ModStart> ( win , 1 , 19 , fname ) <S2SV_ModEnd> ; noecho ( <S2SV_ModStart> ( ) ; delwin <S2SV_ModEnd> ( win ) |
5,153 | CWE-000 void gf_proc_dump_info ( int signum , glusterfs_ctx_t * ctx ) { int i = 0 ; int ret = - 1 ; glusterfs_graph_t * trav = NULL ; char brick_name [ PATH_MAX ] = { 0 , } ; char timestr [ 256 ] = { 0 , } ; char sign_string [ 512 ] = { 0 , } ; char tmp_dump_name [ PATH_MAX ] = { 0 , } ; char path [ PATH_MAX ] = { 0 , } ; struct timeval tv = { 0 , } ; gf_boolean_t is_brick_mux = _gf_false ; xlator_t * top = NULL ; xlator_list_t * * trav_p = NULL ; int brick_count = 0 ; int len = 0 ; gf_proc_dump_lock ( ) ; if ( ! ctx ) goto out ; <S2SV_StartBug> if ( ctx ) { <S2SV_EndBug> top = ctx -> active -> first ; for ( trav_p = & top -> children ; * trav_p ; trav_p = & ( * trav_p ) -> next ) { brick_count ++ ; } if ( brick_count > 1 ) is_brick_mux = _gf_true ; } if ( ctx -> cmd_args . brick_name ) { GF_REMOVE_SLASH_FROM_PATH ( ctx -> cmd_args . brick_name , brick_name ) ; } else snprintf ( brick_name , sizeof ( brick_name ) , "glusterdump" ) ; ret = gf_proc_dump_options_init ( ) ; if ( ret < 0 ) goto out ; ret = snprintf ( path , sizeof ( path ) , "%s/%s.%d.dump.%" PRIu64 , ( ( dump_options . dump_path != NULL ) ? dump_options . dump_path : ( ( ctx -> statedump_path != NULL ) ? ctx -> statedump_path : DEFAULT_VAR_RUN_DIRECTORY ) ) , brick_name , getpid ( ) , ( uint64_t ) time ( NULL ) ) ; if ( ( ret < 0 ) || ( ret >= sizeof ( path ) ) ) { goto out ; } snprintf ( tmp_dump_name , PATH_MAX , "%s/dumpXXXXXX" , ( ( dump_options . dump_path != NULL ) ? dump_options . dump_path : ( ( ctx -> statedump_path != NULL ) ? ctx -> statedump_path : DEFAULT_VAR_RUN_DIRECTORY ) ) ) ; ret = gf_proc_dump_open ( tmp_dump_name ) ; if ( ret < 0 ) goto out ; ret = gettimeofday ( & tv , NULL ) ; if ( 0 == ret ) { gf_time_fmt ( timestr , sizeof timestr , tv . tv_sec , gf_timefmt_FT ) ; len = strlen ( timestr ) ; snprintf ( timestr + len , sizeof timestr - len , ".%" GF_PRI_SUSECONDS , tv . tv_usec ) ; } len = snprintf ( sign_string , sizeof ( sign_string ) , "DUMP-START-TIME:<S2SV_blank>%s\\n" , timestr ) ; ret = sys_write ( gf_dump_fd , sign_string , len ) ; memset ( timestr , 0 , sizeof ( timestr ) ) ; if ( GF_PROC_DUMP_IS_OPTION_ENABLED ( mem ) ) { gf_proc_dump_mem_info ( ) ; gf_proc_dump_mempool_info ( ctx ) ; } if ( GF_PROC_DUMP_IS_OPTION_ENABLED ( iobuf ) ) iobuf_stats_dump ( ctx -> iobuf_pool ) ; if ( GF_PROC_DUMP_IS_OPTION_ENABLED ( callpool ) ) gf_proc_dump_pending_frames ( ctx -> pool ) ; gf_proc_dump_add_section ( "dict" ) ; gf_proc_dump_dict_info ( ctx ) ; if ( ctx -> master ) { gf_proc_dump_add_section ( "fuse" ) ; gf_proc_dump_single_xlator_info ( ctx -> master ) ; } if ( ctx -> active ) { gf_proc_dump_add_section ( "active<S2SV_blank>graph<S2SV_blank>-<S2SV_blank>%d" , ctx -> graph_id ) ; gf_proc_dump_xlator_info ( ctx -> active -> top , is_brick_mux ) ; } i = 0 ; list_for_each_entry ( trav , & ctx -> graphs , list ) { if ( trav == ctx -> active ) continue ; gf_proc_dump_add_section ( "oldgraph[%d]" , i ) ; gf_proc_dump_oldgraph_xlator_info ( trav -> top ) ; i ++ ; } ret = gettimeofday ( & tv , NULL ) ; if ( 0 == ret ) { gf_time_fmt ( timestr , sizeof timestr , tv . tv_sec , gf_timefmt_FT ) ; len = strlen ( timestr ) ; snprintf ( timestr + len , sizeof timestr - len , ".%" GF_PRI_SUSECONDS , tv . tv_usec ) ; } len = snprintf ( sign_string , sizeof ( sign_string ) , "\\nDUMP-END-TIME:<S2SV_blank>%s" , timestr ) ; ret = sys_write ( gf_dump_fd , sign_string , len ) ; if ( gf_dump_fd != - 1 ) gf_proc_dump_close ( ) ; sys_rename ( tmp_dump_name , path ) ; out : GF_FREE ( dump_options . dump_path ) ; dump_options . dump_path = NULL ; gf_proc_dump_unlock ( ) ; return ; } | <S2SV_ModStart> if ( ctx && ctx -> active |
5,154 | CWE-000 int Pcap_run ( void ) { int i , err ; extern uint64_t statistics_interval ; for ( i = 0 ; i < n_interfaces ; i ++ ) interfaces [ i ] . pkts_captured = 0 ; if ( n_pcap_offline > 0 ) { if ( finish_ts . tv_sec > 0 ) { start_ts . tv_sec = finish_ts . tv_sec ; finish_ts . tv_sec += statistics_interval ; } else { if ( ( err = pcap_thread_next_reset ( & pcap_thread ) ) ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>reset<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>next:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } for ( i = 0 ; i < n_pcap_offline ; i ++ ) { if ( ( err = pcap_thread_next ( & pcap_thread ) ) ) { if ( err != PCAP_THREAD_EPCAP ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>do<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>next:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } continue ; } if ( ! start_ts . tv_sec || last_ts . tv_sec < start_ts . tv_sec || ( last_ts . tv_sec == start_ts . tv_sec && last_ts . tv_usec < start_ts . tv_usec ) ) { start_ts = last_ts ; } } if ( ! start_ts . tv_sec ) { return 0 ; } finish_ts . tv_sec = ( ( start_ts . tv_sec / statistics_interval ) + 1 ) * statistics_interval ; finish_ts . tv_usec = 0 ; } i = 0 ; do { err = pcap_thread_next ( & pcap_thread ) ; if ( err == PCAP_THREAD_EPCAP ) { i ++ ; } else if ( err ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>do<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>next:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } else { i = 0 ; } if ( i == n_pcap_offline || sig_while_processing ) { finish_ts = last_ts ; return 0 ; } } while ( last_ts . tv_sec < finish_ts . tv_sec ) ; } else { gettimeofday ( & start_ts , NULL ) ; gettimeofday ( & last_ts , NULL ) ; finish_ts . tv_sec = ( ( start_ts . tv_sec / statistics_interval ) + 1 ) * statistics_interval ; finish_ts . tv_usec = 0 ; if ( ( err = pcap_thread_set_timedrun_to ( & pcap_thread , finish_ts ) ) ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>set<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>timed<S2SV_blank>run:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } dsyslogf ( LOG_INFO , "Timed<S2SV_blank>run<S2SV_blank>set<S2SV_blank>to<S2SV_blank>%lu.%lu,<S2SV_blank>now<S2SV_blank>%lu.%lu" , finish_ts . tv_sec , finish_ts . tv_usec , start_ts . tv_sec , start_ts . tv_usec ) ; if ( ( err = pcap_thread_run ( & pcap_thread ) ) ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>run:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; if ( err == PCAP_THREAD_EPCAP ) { dsyslogf ( LOG_ERR , "libpcap<S2SV_blank>error<S2SV_blank>[%d]:<S2SV_blank>%s<S2SV_blank>(%s)" , pcap_thread_status ( & pcap_thread ) , pcap_statustostr ( pcap_thread_status ( & pcap_thread ) ) , pcap_thread_errbuf ( & pcap_thread ) ) ; } else if ( err == PCAP_THREAD_ERRNO ) { char errbuf [ 512 ] ; dsyslogf ( LOG_ERR , "system<S2SV_blank>error<S2SV_blank>[%d]:<S2SV_blank>%s<S2SV_blank>(%s)\\n" , errno , dsc_strerror ( errno , errbuf , sizeof ( errbuf ) ) , pcap_thread_errbuf ( & pcap_thread ) ) ; } <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } { struct timeval now = { 0 , 0 } ; gettimeofday ( & now , 0 ) ; dsyslogf ( LOG_INFO , "Ran<S2SV_blank>to<S2SV_blank>%lu.%lu" , now . tv_sec , now . tv_usec ) ; } if ( ( err = pcap_thread_stats ( & pcap_thread , _stats , 0 ) ) ) { dsyslogf ( LOG_ERR , "unable<S2SV_blank>to<S2SV_blank>get<S2SV_blank>pcap<S2SV_blank>thread<S2SV_blank>stats:<S2SV_blank>%s" , pcap_thread_strerr ( err ) ) ; if ( err == PCAP_THREAD_EPCAP ) { dsyslogf ( LOG_ERR , "libpcap<S2SV_blank>error<S2SV_blank>[%d]:<S2SV_blank>%s<S2SV_blank>(%s)" , pcap_thread_status ( & pcap_thread ) , pcap_statustostr ( pcap_thread_status ( & pcap_thread ) ) , pcap_thread_errbuf ( & pcap_thread ) ) ; } <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } if ( sig_while_processing ) finish_ts = last_ts ; } tcpList_remove_older_than ( last_ts . tv_sec - MAX_TCP_IDLE ) ; return 1 ; } | <S2SV_ModStart> ) ) ; return 0 <S2SV_ModEnd> ; } for <S2SV_ModStart> ) ) ; return 0 <S2SV_ModEnd> ; } continue <S2SV_ModStart> ) ) ; return 0 <S2SV_ModEnd> ; } else <S2SV_ModStart> ) ) ; return 0 <S2SV_ModEnd> ; } dsyslogf <S2SV_ModStart> ) ; } return 0 <S2SV_ModEnd> ; } { <S2SV_ModStart> ) ; } return 0 <S2SV_ModEnd> ; } if |
5,155 | CWE-000 BOOL read_config ( char * filename ) { FILE * fp = NULL ; char buffer [ 256 ] ; char * bufp = NULL ; char * opt = NULL ; char * optdata = NULL ; if ( ( fp = fopen ( filename , "r" ) ) != NULL ) { while ( ! feof ( fp ) ) { if ( fgets ( buffer , 256 , fp ) ) { bufp = trim ( buffer ) ; if ( bufp [ 0 ] == '#' || bufp [ 0 ] == ';' || bufp [ 0 ] == '[' ) continue ; opt = strtok ( bufp , "=" ) ; if ( opt ) { opt = trim ( opt ) ; optdata = strtok ( NULL , "=" ) ; if ( optdata ) { optdata = trim ( optdata ) ; if ( ! strcmp ( opt , "daemonize" ) ) { option_daemonize = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "port" ) ) { listen_port = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "device" ) ) { serial_device_name = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "bind_ip" ) ) { option_bind_ip = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "baudrate" ) ) { option_baud_rate = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "raw_device_mode" ) ) { option_raw_device_mode = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "send_terminal_init" ) ) { option_send_terminal_init = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "preserve_connections" ) ) { option_keep_connection = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "device_open_delay" ) ) { option_open_serial_delay = atoi ( optdata ) ; } <S2SV_StartBug> # ifdef HAVE_LIBSSL <S2SV_EndBug> else if ( ! strcmp ( opt , "encrypted" ) ) { option_ssl = atoi ( optdata ) ; } else if ( ! strcmp ( opt , "ca_certificate" ) ) { option_ca_certificate = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "ssl_certificate" ) ) { option_ssl_certificate = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "ssl_key" ) ) { option_ssl_key = strdup ( optdata ) ; } else if ( ! strcmp ( opt , "ssl_crl" ) ) { option_ssl_crl = strdup ( optdata ) ; } # endif } } } } fclose ( fp ) ; return TRUE ; } return FALSE ; } | <S2SV_ModStart> ) ; } else if ( ! strcmp ( opt , "pid_file" ) ) { option_pid_file = strdup ( optdata ) ; } |
5,156 | CWE-000 void delay ( char * string ) { register int i ; if ( typing_delay == FALSE ) { <S2SV_StartBug> fprintf ( stdout , string ) ; <S2SV_EndBug> return ; } for ( i = 0 ; i < ( int ) strlen ( string ) - 1 ; ++ i ) typein ( string [ i ] ) ; usleep ( ( D_THINK + rnd ( V_THINK ) - rnd ( V_THINK ) ) / 2 ) ; typein ( string [ i ] ) ; } | <S2SV_ModStart> fprintf ( stdout , "%s" |
5,157 | CWE-000 static int igt_shrink_thp ( void * arg ) { <S2SV_StartBug> struct drm_i915_private * i915 = arg ; <S2SV_EndBug> struct i915_gem_context * ctx = i915 -> kernel_context ; struct i915_address_space * vm = ctx -> ppgtt ? & ctx -> ppgtt -> base : & i915 -> ggtt . base ; struct drm_i915_gem_object * obj ; struct i915_vma * vma ; unsigned int flags = PIN_USER ; int err ; if ( ! igt_can_allocate_thp ( i915 ) ) { pr_info ( "missing<S2SV_blank>THP<S2SV_blank>support,<S2SV_blank>skipping\\n" ) ; return 0 ; } obj = i915_gem_object_create ( i915 , SZ_2M ) ; if ( IS_ERR ( obj ) ) return PTR_ERR ( obj ) ; vma = i915_vma_instance ( obj , vm , NULL ) ; if ( IS_ERR ( vma ) ) { err = PTR_ERR ( vma ) ; goto out_put ; } err = i915_vma_pin ( vma , 0 , 0 , flags ) ; if ( err ) goto out_close ; if ( obj -> mm . page_sizes . phys < I915_GTT_PAGE_SIZE_2M ) { pr_info ( "failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>THP,<S2SV_blank>finishing<S2SV_blank>test<S2SV_blank>early\\n" ) ; goto out_unpin ; } err = igt_check_page_sizes ( vma ) ; if ( err ) goto out_unpin ; <S2SV_StartBug> err = gpu_write ( vma , i915 -> kernel_context , i915 -> engine [ RCS ] , 0 , <S2SV_EndBug> 0xdeadbeaf ) ; if ( err ) goto out_unpin ; i915_vma_unpin ( vma ) ; i915_gem_shrink_all ( i915 ) ; if ( ! IS_ERR_OR_NULL ( obj -> mm . pages ) ) { pr_err ( "shrink-all<S2SV_blank>didn\'t<S2SV_blank>truncate<S2SV_blank>the<S2SV_blank>pages\\n" ) ; err = - EINVAL ; goto out_close ; } if ( obj -> mm . page_sizes . sg || obj -> mm . page_sizes . phys ) { pr_err ( "residual<S2SV_blank>page-size<S2SV_blank>bits<S2SV_blank>left\\n" ) ; err = - EINVAL ; goto out_close ; } err = i915_vma_pin ( vma , 0 , 0 , flags ) ; if ( err ) goto out_close ; err = cpu_check ( obj , 0 , 0xdeadbeaf ) ; out_unpin : i915_vma_unpin ( vma ) ; out_close : i915_vma_close ( vma ) ; out_put : i915_gem_object_put ( obj ) ; return err ; } | <S2SV_ModStart> ) { struct i915_gem_context * ctx = arg ; struct <S2SV_ModStart> * i915 = ctx -> i915 <S2SV_ModEnd> ; struct i915_address_space <S2SV_ModStart> ( vma , ctx <S2SV_ModEnd> , i915 -> |
5,158 | CWE-000 static int maxim_thermocouple_read ( struct maxim_thermocouple_data * data , struct iio_chan_spec const * chan , int * val ) { unsigned int storage_bytes = data -> chip -> read_size ; unsigned int shift = chan -> scan_type . shift + ( chan -> address * 8 ) ; <S2SV_StartBug> unsigned int buf ; <S2SV_EndBug> <S2SV_StartBug> int ret ; <S2SV_EndBug> <S2SV_StartBug> ret = spi_read ( data -> spi , ( void * ) & buf , storage_bytes ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ret ) <S2SV_EndBug> return ret ; switch ( storage_bytes ) { case 2 : <S2SV_StartBug> * val = be16_to_cpu ( buf ) ; <S2SV_EndBug> break ; case 4 : <S2SV_StartBug> * val = be32_to_cpu ( buf ) ; <S2SV_EndBug> break ; <S2SV_StartBug> } <S2SV_EndBug> if ( * val & data -> chip -> status_bit ) return - EINVAL ; * val = sign_extend32 ( * val >> shift , chan -> scan_type . realbits - 1 ) ; return 0 ; } | <S2SV_ModStart> 8 ) ; __be16 buf16 ; __be32 buf32 <S2SV_ModEnd> ; int ret <S2SV_ModStart> int ret ; switch ( storage_bytes ) { case 2 : <S2SV_ModStart> * ) & buf16 <S2SV_ModEnd> , storage_bytes ) <S2SV_ModStart> storage_bytes ) ; <S2SV_ModEnd> * val = <S2SV_ModStart> = be16_to_cpu ( buf16 <S2SV_ModEnd> ) ; break <S2SV_ModStart> case 4 : ret = spi_read ( data -> spi , ( void * ) & buf32 , storage_bytes ) ; <S2SV_ModStart> = be32_to_cpu ( buf32 <S2SV_ModEnd> ) ; break <S2SV_ModStart> break ; } if ( ret ) return ret ; |
5,159 | CWE-000 static void parse_elp_list ( cfg_t * cfg , shash_t * ht ) { elp_node_t * enode ; elp_t * elp ; lisp_addr_t * laddr ; char * name ; int i , j ; uint8_t good_elp ; for ( i = 0 ; i < cfg_size ( cfg , "explicit-locator-path" ) ; i ++ ) { cfg_t * selp = cfg_getnsec ( cfg , "explicit-locator-path" , i ) ; name = cfg_getstr ( selp , "elp-name" ) ; if ( name == NULL ) { OOR_LOG ( LWRN , "Configuration<S2SV_blank>file:<S2SV_blank>explicit-locator-path<S2SV_blank>requires<S2SV_blank>an<S2SV_blank>elp-name.<S2SV_blank>Discarding<S2SV_blank>ELP" ) ; continue ; } if ( cfg_size ( selp , "elp-node" ) == 0 ) { OOR_LOG ( LWRN , "Configuration<S2SV_blank>file:<S2SV_blank>explicit-locator-path<S2SV_blank>needs<S2SV_blank>at<S2SV_blank>least<S2SV_blank>one<S2SV_blank>elp<S2SV_blank>node.<S2SV_blank>Discarding<S2SV_blank>ELP" ) ; continue ; } elp = elp_type_new ( ) ; good_elp = TRUE ; for ( j = 0 ; j < cfg_size ( selp , "elp-node" ) ; j ++ ) { cfg_t * senode = cfg_getnsec ( selp , "elp-node" , j ) ; if ( cfg_getstr ( senode , "address" ) == NULL ) { good_elp = FALSE ; OOR_LOG ( LWRN , "Configuration<S2SV_blank>file:<S2SV_blank>elp-node<S2SV_blank>needs<S2SV_blank>at<S2SV_blank>least<S2SV_blank>the<S2SV_blank>address<S2SV_blank>field.<S2SV_blank>Discarding<S2SV_blank>ELP" ) ; break ; } enode = xzalloc ( sizeof ( elp_node_t ) ) ; enode -> addr = lisp_addr_new ( ) ; if ( lisp_addr_ip_from_char ( cfg_getstr ( senode , "address" ) , enode -> addr ) != GOOD ) { elp_node_del ( enode ) ; <S2SV_StartBug> OOR_LOG ( LDBG_1 , "parse_elp_list:<S2SV_blank>Couldn\'t<S2SV_blank>parse<S2SV_blank>ELP<S2SV_blank>node<S2SV_blank>%s" , <S2SV_EndBug> cfg_getstr ( senode , "address" ) ) ; continue ; } enode -> L = cfg_getbool ( senode , "lookup" ) ? 1 : 0 ; enode -> P = cfg_getbool ( senode , "probe" ) ? 1 : 0 ; enode -> S = cfg_getbool ( senode , "strict" ) ? 1 : 0 ; glist_add_tail ( enode , elp -> nodes ) ; } if ( good_elp == FALSE ) { elp_type_del ( elp ) ; continue ; } laddr = lisp_addr_new_lafi ( LM_AFI_LCAF ) ; lisp_addr_lcaf_set_type ( laddr , LCAF_EXPL_LOC_PATH ) ; lisp_addr_lcaf_set_addr ( laddr , elp ) ; OOR_LOG ( LDBG_1 , "Configuration<S2SV_blank>file:<S2SV_blank>parsed<S2SV_blank>explicit-locator-path:<S2SV_blank>%s" , lisp_addr_to_char ( laddr ) ) ; shash_insert ( ht , strdup ( name ) , laddr ) ; } } | <S2SV_ModStart> ; OOR_LOG ( LWRN , "Configuration<S2SV_blank>file:<S2SV_blank>Couldn\'t<S2SV_blank>parse<S2SV_blank>ELP<S2SV_blank>node<S2SV_blank>%s" <S2SV_ModEnd> , cfg_getstr ( |
5,160 | CWE-000 int main ( int argc , char * * argv ) { int c , option_index ; int log_mask = LOG_ERR ; const char default_dsp_config [ ] = CRAS_CONFIG_FILE_DIR "/dsp.ini" ; const char * dsp_config = default_dsp_config ; const char * device_config_dir = CRAS_CONFIG_FILE_DIR ; <S2SV_StartBug> unsigned int profile_disable_mask = 0 ; <S2SV_EndBug> set_signals ( ) ; while ( 1 ) { c = getopt_long ( argc , argv , "" , long_options , & option_index ) ; if ( c == - 1 ) break ; switch ( c ) { case 'l' : log_mask = atoi ( optarg ) ; break ; case 'c' : device_config_dir = optarg ; break ; case 'd' : dsp_config = optarg ; break ; case 'D' : while ( ( optarg != NULL ) && ( * optarg != 0 ) ) { if ( strncmp ( optarg , "hfp" , 3 ) == 0 ) { profile_disable_mask |= CRAS_SERVER_PROFILE_MASK_HFP ; } if ( strncmp ( optarg , "hsp" , 3 ) == 0 ) { profile_disable_mask |= CRAS_SERVER_PROFILE_MASK_HSP ; } if ( strncmp ( optarg , "a2dp" , 4 ) == 0 ) { profile_disable_mask |= CRAS_SERVER_PROFILE_MASK_A2DP ; } optarg = strchr ( optarg , ',' ) ; if ( optarg != NULL ) { optarg ++ ; } } break ; <S2SV_StartBug> default : <S2SV_EndBug> break ; } } switch ( log_mask ) { case LOG_EMERG : case LOG_ALERT : case LOG_CRIT : case LOG_ERR : case LOG_WARNING : case LOG_NOTICE : case LOG_INFO : case LOG_DEBUG : break ; default : fprintf ( stderr , "Unsupported<S2SV_blank>syslog<S2SV_blank>priority<S2SV_blank>value:<S2SV_blank>%d;<S2SV_blank>using<S2SV_blank>LOG_ERR=%d\\n" , log_mask , LOG_ERR ) ; log_mask = LOG_ERR ; break ; } setlogmask ( LOG_UPTO ( log_mask ) ) ; cras_server_init ( ) ; <S2SV_StartBug> cras_system_state_init ( device_config_dir ) ; <S2SV_EndBug> cras_dsp_init ( dsp_config ) ; cras_iodev_list_init ( ) ; return cras_server_run ( profile_disable_mask ) ; } | <S2SV_ModStart> = CRAS_CONFIG_FILE_DIR ; const char * internal_ucm_suffix = NULL ; <S2SV_ModStart> } break ; case 'u' : internal_ucm_suffix = optarg ; break ; <S2SV_ModStart> cras_system_state_init ( device_config_dir ) ; if ( internal_ucm_suffix ) cras_system_state_set_internal_ucm_suffix ( internal_ucm_suffix |
5,161 | CWE-000 size_t pack ( struct message * req_msg , unsigned char * * ret_buf ) { int endian_check = 1 ; msg_size_t data_len_bigend ; if ( * ( char * ) & endian_check == 1 ) data_len_bigend = msg_hton ( req_msg -> data_len ) ; else data_len_bigend = req_msg -> data_len ; size_t buf_len = TYPE_LEN + sizeof ( data_len_bigend ) + req_msg -> data_len ; <S2SV_StartBug> * ret_buf = calloc ( buf_len , 1 ) ; <S2SV_EndBug> if ( * ret_buf == NULL ) { return 0 ; } * ( * ret_buf + MSG_TYPE_I ) = req_msg -> type ; * ( msg_size_t * ) ( * ret_buf + MSG_LEN_I ) = data_len_bigend ; <S2SV_StartBug> snprintf ( ( char * ) * ret_buf + TYPE_LEN + sizeof ( data_len_bigend ) , <S2SV_EndBug> <S2SV_StartBug> req_msg -> data_len + 1 , <S2SV_EndBug> "%s" , req_msg -> data_p ) ; return buf_len ; } | <S2SV_ModStart> = calloc ( 1 , buf_len <S2SV_ModEnd> ) ; if <S2SV_ModStart> = data_len_bigend ; memcpy <S2SV_ModEnd> ( ( char <S2SV_ModStart> data_len_bigend ) , req_msg -> data_p , <S2SV_ModStart> req_msg -> data_len <S2SV_ModEnd> ) ; return |
5,162 | CWE-000 static int siglent_sds_trigger_wait ( const struct sr_dev_inst * sdi ) { struct dev_context * devc ; long s ; if ( ! ( devc = sdi -> priv ) ) return SR_ERR ; if ( devc -> timebase < 0.0299 ) { if ( devc -> timebase > 0.99e-6 ) { s = ( devc -> timebase * devc -> model -> series -> num_horizontal_divs * 85e6 ) / 100L ; sr_spew ( "Sleeping<S2SV_blank>for<S2SV_blank>%ld<S2SV_blank>usecs<S2SV_blank>instead<S2SV_blank>of<S2SV_blank>trigger-wait" , s ) ; g_usleep ( s ) ; <S2SV_StartBug> } <S2SV_EndBug> siglent_sds_set_wait_event ( devc , WAIT_NONE ) ; return SR_OK ; } else { return siglent_sds_event_wait ( sdi ) ; } } | <S2SV_ModStart> s ) ; return SR_OK ; |
5,163 | CWE-000 <S2SV_StartBug> static int vobsub_set_lang ( const char * line ) <S2SV_EndBug> { if ( vobsub_id == - 1 ) vobsub_id = atoi ( line + 8 ) ; return 0 ; } | <S2SV_ModStart> vobsub_set_lang ( const unsigned |
5,164 | CWE-000 static void dmix_sub_c ( int32_t * dst , const int32_t * src , int coeff , ptrdiff_t len ) { int i ; for ( i = 0 ; i < len ; i ++ ) <S2SV_StartBug> dst [ i ] -= mul15 ( src [ i ] , coeff ) ; <S2SV_EndBug> } | <S2SV_ModStart> i ] -= ( unsigned ) |
5,165 | CWE-000 void _ws_print_r ( Ws * ws , Ws * ( * recurse ) ( W * ) , int depth ) { if ( ! ws || ! ws -> head ) return ; for ( W * w = ws -> head ; w ; w = w -> next ) { <S2SV_StartBug> for ( int i = 0 ; i < depth ; i ++ ) { printf ( "<S2SV_blank><S2SV_blank>" ) ; } <S2SV_EndBug> <S2SV_StartBug> printf ( "%s\\n" , w_str ( w ) ) ; <S2SV_EndBug> Ws * rs = recurse ( w ) ; if ( ! rs ) continue ; for ( W * r = rs -> head ; r ; r = r -> next ) { _ws_print_r ( g_ws ( r ) , recurse , depth + 1 ) ; } } } | <S2SV_ModStart> ++ ) { fprintf ( stderr , <S2SV_ModEnd> "<S2SV_blank><S2SV_blank>" ) ; <S2SV_ModStart> ) ; } fprintf ( stderr , <S2SV_ModEnd> "%s\\n" , w_str |
5,166 | CWE-000 bool fi_conflict_group_has ( struct FiConfGroup * self , struct FiFileInfo * file ) { <S2SV_StartBug> if ( ! self || ! file ) <S2SV_EndBug> return false ; <S2SV_StartBug> struct FiList * c = NULL ; <S2SV_EndBug> <S2SV_StartBug> for ( c = self -> files ; c -> prev ; c = c -> prev ) ; <S2SV_EndBug> for ( ; c ; c = c -> next ) { <S2SV_StartBug> if ( ( struct FiFileInfo * ) fi_list_data_ptr ( c , struct FiFileInfo ) == file ) <S2SV_EndBug> return true ; } return false ; } | <S2SV_ModStart> file ) { for ( <S2SV_ModEnd> struct FiList * <S2SV_ModStart> * c = fi_list_head ( <S2SV_ModEnd> self -> files <S2SV_ModStart> self -> files ) <S2SV_ModEnd> ; c ; <S2SV_ModStart> c , struct FiList <S2SV_ModEnd> ) == file |
5,167 | CWE-000 struct dentry * new_d_splice_alias ( struct dentry * dentry , struct new_entry * new_entry ) { <S2SV_StartBug> dentry -> bucket_num = new_entry -> bucket_num ; <S2SV_EndBug> <S2SV_StartBug> dentry -> dentry_type = new_entry -> entry_type ; <S2SV_EndBug> if ( dentry -> dentry_type == FILE_ENTRY ) { struct inode * inode ; <S2SV_StartBug> inode = new_entry -> inode ; <S2SV_EndBug> return d_splice_alias ( inode , dentry ) ; } if ( dentry -> dentry_type == DIR_ENTRY ) { return d_splice_alias ( NULL , dentry ) ; } } | <S2SV_ModStart> { dentry -> bucket_info . <S2SV_ModStart> ; dentry -> bucket_info . <S2SV_ModStart> = new_entry -> inode_num <S2SV_ModEnd> ; return d_splice_alias |
5,168 | CWE-000 char * ft_re_match_capture ( const char * pattern , const char * group , const char * text ) { int len ; int start ; char * str ; char * temp ; if ( ft_re_match ( pattern , text ) == - 1 ) return NULL ; start = ft_re_match ( group , text ) ; text = text + start ; len = ft_strlen ( text ) ; temp = ft_memalloc ( ft_strlen ( group ) + 2 ) ; ft_memcpy ( temp , group , ft_strlen ( group ) ) ; temp [ ft_strlen ( group ) ] = '$' ; temp [ ft_strlen ( group ) + 1 ] = '\\0' ; <S2SV_StartBug> while ( ft_re_matchn ( temp , text , len ) != 0 ) <S2SV_EndBug> len -- ; free ( temp ) ; str = ft_memalloc ( len + 1 ) ; ft_memcpy ( str , text , len ) ; str [ len ] = '\\0' ; return ( str ) ; } | <S2SV_ModStart> ; while ( len > 0 && |
5,169 | CWE-000 static void NodeList_append ( NodeList * l , TreeNode * n ) { if ( l -> len >= l -> cap ) { l -> nodes = realloc ( l -> nodes , 2 * l -> cap * sizeof ( TreeNode * ) ) ; <S2SV_StartBug> } <S2SV_EndBug> l -> nodes [ l -> len ] = n ; l -> len ++ ; } | <S2SV_ModStart> ) ) ; l -> cap *= 2 ; |
5,170 | CWE-000 bool initTty ( unsigned int tty , char * name , size_t nameSize , algorithm_t * algorithm ) { struct cgpu_info * cgpu = & ttys [ tty ] ; int * dev = & cgpu -> tty_dev ; struct termios options ; * dev = open ( TTYDEVICE , O_RDWR | O_NOCTTY | O_NDELAY ) ; if ( * dev == - 1 ) { applog ( LOG_ERR , "Failed<S2SV_blank>to<S2SV_blank>open<S2SV_blank>tty<S2SV_blank>device" ) ; return false ; } fcntl ( * dev , F_SETFL , 0 ) ; tcgetattr ( * dev , & options ) ; cfsetispeed ( & options , BAUDRATE ) ; cfsetospeed ( & options , BAUDRATE ) ; options . c_cflag |= ( CLOCAL | CREAD ) ; options . c_cflag &= ~ PARENB ; options . c_cflag &= ~ CSTOPB ; options . c_cflag &= ~ CSIZE ; options . c_cflag |= CS8 ; options . c_iflag &= ~ ( BRKINT | ICRNL | IMAXBEL ) ; options . c_oflag &= ~ ( OPOST | ONLCR ) ; options . c_lflag &= ~ ( ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOKE ) ; options . c_cc [ VMIN ] = 0 ; options . c_cc [ VTIME ] = 10 ; tcsetattr ( * dev , TCSANOW , & options ) ; <S2SV_StartBug> return true ; <S2SV_EndBug> } | <S2SV_ModStart> options ) ; strcpy ( name , TTYDEVICE ) ; |
5,171 | CWE-000 void partition_to_basic_blocks ( MemoryArena * stmt_arena , AstNode * proc ) { if ( proc -> proc . ir_stmt_count > 0 ) { List * leaders = new_list ( arena , eList_ir_leader_stmt ) ; IrStmt * stmt_array = proc -> proc . ir_stmt_array ; int stmt_count = proc -> proc . ir_stmt_count ; IrStmt * stmt = & stmt_array [ 0 ] ; normalize_jump_target_labels ( stmt ) ; append_list_elem ( leaders , new_leader_stmt ( leaders -> arena , 0 , stmt ) , eList_ir_leader_stmt ) ; for ( int i = 1 ; i < proc -> proc . ir_stmt_count ; i ++ ) { stmt = & stmt_array [ i ] ; if ( stmt -> kind == eIrStmt_cond_goto || stmt -> kind == eIrStmt_goto ) { start_new_basic_block ( leaders , i + 1 , stmt_array , stmt_count ) ; IrLabel * target_label = normalize_jump_target_labels ( stmt ) ; start_new_basic_block ( leaders , target_label -> stmt_nr , stmt_array , stmt_count ) ; } else if ( stmt -> kind == eIrStmt_call || stmt -> kind == eIrStmt_return ) { start_new_basic_block ( leaders , i + 1 , stmt_array , stmt_count ) ; } } List * basic_blocks = proc -> proc . basic_blocks = new_list ( stmt_arena , eList_basic_block ) ; for ( ListItem * li = leaders -> first ; li ; li = li -> next ) { int next_stmt_nr = proc -> proc . ir_stmt_count ; if ( li -> next ) { IrLeaderStmt * leader_next = KIND ( li -> next , eList_ir_leader_stmt ) -> ir_leader_stmt ; next_stmt_nr = leader_next -> stmt_nr ; } IrLeaderStmt * leader = KIND ( li , eList_ir_leader_stmt ) -> ir_leader_stmt ; BasicBlock * block = mem_push_struct ( stmt_arena , BasicBlock ) ; append_list_elem ( basic_blocks , block , eList_basic_block ) ; init_list ( & block -> pred_list , stmt_arena , eList_basic_block ) ; init_list ( & block -> succ_list , stmt_arena , eList_basic_block ) ; leader -> block = block ; block -> stmt_array = mem_push_array ( stmt_arena , IrStmt * , next_stmt_nr - leader -> stmt_nr ) ; block -> stmt_count = 0 ; block -> label = leader -> label ; for ( int i = leader -> stmt_nr ; i < next_stmt_nr ; i ++ ) { block -> stmt_array [ block -> stmt_count ++ ] = & proc -> proc . ir_stmt_array [ i ] ; } assert ( block -> stmt_count > 0 ) ; } for ( ListItem * li = basic_blocks -> first ; li ; li = li -> next ) { BasicBlock * bb_next = 0 ; if ( li -> next ) { bb_next = KIND ( li -> next , eList_basic_block ) -> basic_block ; } BasicBlock * bb = KIND ( li , eList_basic_block ) -> basic_block ; IrStmt * last_stmt = bb -> stmt_array [ bb -> stmt_count - 1 ] ; if ( last_stmt -> kind == eIrStmt_goto || last_stmt -> kind == eIrStmt_cond_goto ) { IrLabel * goto_label = 0 ; if ( last_stmt -> kind == eIrStmt_cond_goto ) { goto_label = last_stmt -> cond_goto . label ; } else if ( last_stmt -> kind == eIrStmt_goto ) { goto_label = last_stmt -> goto_label ; } else assert ( 0 ) ; int stmt_nr = goto_label -> stmt_nr ; IrLeaderStmt * leader = get_leader_stmt ( leaders , stmt_nr ) ; <S2SV_StartBug> append_list_elem ( & bb -> succ_list , leader -> block , eList_basic_block ) ; <S2SV_EndBug> append_list_elem ( & leader -> block -> pred_list , bb , eList_basic_block ) ; if ( last_stmt -> kind != eIrStmt_goto ) { append_list_elem ( & bb -> succ_list , bb_next , eList_basic_block ) ; <S2SV_StartBug> append_list_elem ( & bb_next -> pred_list , bb , eList_basic_block ) ; <S2SV_EndBug> } } else if ( bb_next ) { append_list_elem ( & bb -> succ_list , bb_next , eList_basic_block ) ; append_list_elem ( & bb_next -> pred_list , bb , eList_basic_block ) ; } for ( int i = bb -> stmt_count - 1 ; i >= 0 ; i -- ) { IrStmt * stmt = bb -> stmt_array [ i ] ; if ( stmt -> kind == eIrStmt_assign ) { IrArg * result = stmt -> assign . result ; IrArg * arg1 = stmt -> assign . arg1 ; IrArg * arg2 = stmt -> assign . arg2 ; result -> is_live = result -> object -> is_live ; result -> next_use = result -> object -> next_use ; arg1 -> is_live = arg1 -> object -> is_live ; arg1 -> next_use = arg1 -> object -> next_use ; if ( arg2 ) { arg2 -> is_live = arg2 -> object -> is_live ; arg2 -> next_use = arg2 -> object -> next_use ; } if ( stmt -> assign . op == eIrOp_index_dest || stmt -> assign . op == eIrOp_deref_dest ) { result -> object -> is_live = true ; result -> object -> next_use = i ; } else { result -> object -> is_live = result -> object -> is_temp ? false : true ; result -> object -> next_use = NextUse_None ; } arg1 -> object -> is_live = true ; arg1 -> object -> next_use = i ; if ( arg2 ) { arg2 -> object -> is_live = true ; arg2 -> object -> next_use = i ; } } } } } } | <S2SV_ModStart> stmt_nr ) ; if ( leader ) { <S2SV_ModStart> bb , eList_basic_block ) ; } } else { compile_error ( 0 , "leader<S2SV_blank>is<S2SV_blank>null" |
5,172 | CWE-000 int main ( void ) { <S2SV_StartBug> tests_start_mpfr ( ) ; <S2SV_EndBug> special ( ) ; test_generic ( MPFR_PREC_MIN , 100 , 2 ) ; tests_end_mpfr ( ) ; return 0 ; } | <S2SV_ModStart> ) { tests_start_mpfr ( ) ; bug20171220 ( ) ; bug20171220a |
5,173 | CWE-000 void discoverDataDirectory ( DSLink * link , DSNode * node , char * doRef , IedConnection con , FunctionalConstraint inFC ) { IedClientError error ; LinkedList dataAttributesFC ; if ( inFC == IEC61850_FC_NONE ) dataAttributesFC = IedConnection_getDataDirectoryFC ( con , & error , doRef ) ; else dataAttributesFC = IedConnection_getDataDirectoryByFC ( con , & error , doRef , inFC ) ; if ( dataAttributesFC != NULL ) { LinkedList dataAttributeFC = LinkedList_getNext ( dataAttributesFC ) ; if ( dataAttributeFC == NULL ) { ref_t * tempRef ; DSNode * currFcNode ; DSNode * currRefNode ; <S2SV_StartBug> if ( tempRef = dslink_map_get ( node -> children , "FC" ) ) <S2SV_EndBug> { currFcNode = ( DSNode * ) ( tempRef -> data ) ; } else { log_warn ( "Error<S2SV_blank>while<S2SV_blank>getting<S2SV_blank>FC<S2SV_blank>node\\n" ) ; return ; } <S2SV_StartBug> if ( tempRef = dslink_map_get ( node -> children , DA_OBJECT_REF_NODE_KEY ) ) <S2SV_EndBug> { currRefNode = ( DSNode * ) ( tempRef -> data ) ; } else { log_warn ( "Error<S2SV_blank>while<S2SV_blank>getting<S2SV_blank>Object<S2SV_blank>node\\n" ) ; return ; } FunctionalConstraint currFc = FunctionalConstraint_fromString ( json_string_value ( currFcNode -> value ) ) ; const char * currObjRef = json_string_value ( currRefNode -> value ) ; if ( currFc != IEC61850_FC_NONE ) { MmsVariableSpecification * mmsVarSpec = IedConnection_getVariableSpecification ( con , & error , currObjRef , currFc ) ; if ( mmsVarSpec ) { createValueNode ( link , node , currObjRef , con , currFc , mmsVarSpec -> type ) ; } else { log_warn ( "Error<S2SV_blank>getting<S2SV_blank>MMS<S2SV_blank>Variable<S2SV_blank>Specification:<S2SV_blank>%d\\n" , error ) ; } } # ifdef DEVEL_DEBUG log_info ( "Functional<S2SV_blank>Constraint:<S2SV_blank>%s\\nObj.Ref.:<S2SV_blank>%s\\n" , FunctionalConstraint_toString ( currFc ) , currObjRef ) ; # endif } while ( dataAttributeFC != NULL ) { char * daName = copyString ( ( const char * ) dataAttributeFC -> data ) ; char * tempPtr = strchr ( daName , '[' ) ; if ( tempPtr ) * tempPtr = '\\0' ; char daRef [ 129 ] ; sprintf ( daRef , "%s.%s" , doRef , daName ) ; DSNode * newDANode = NULL ; FunctionalConstraint fc ; char fcStr [ 3 ] ; fc = getFunctionalConstraint ( ( char * ) dataAttributeFC -> data , fcStr ) ; # ifdef DEVEL_DEBUG log_info ( "New<S2SV_blank>Data<S2SV_blank>Attribute:<S2SV_blank>%s<S2SV_blank>-<S2SV_blank>%s\\n" , daRef , fcStr ) ; # endif if ( fc != IEC61850_FC_NONE ) { MmsVariableSpecification * mmsVarSpec = IedConnection_getVariableSpecification ( con , & error , daRef , fc ) ; newDANode = createDANode ( link , node , daRef , daName , ( char * ) dataAttributeFC -> data , fcStr , fc , getMmsTypeString ( mmsVarSpec -> type ) ) ; } else { log_warn ( "FC<S2SV_blank>couldn\'t<S2SV_blank>be<S2SV_blank>resolved,<S2SV_blank>DA<S2SV_blank><S2SV_blank>Node<S2SV_blank>couldn\'t<S2SV_blank>be<S2SV_blank>created!\\n" ) ; newDANode = createDONode ( link , node , daRef , daName ) ; } if ( newDANode ) { if ( strcmp ( "Oper" , daName ) == 0 ) handleControllableNode ( link , node , con , doRef ) ; } dataAttributeFC = LinkedList_getNext ( dataAttributeFC ) ; if ( newDANode ) { discoverDataDirectory ( link , newDANode , daRef , con , fc ) ; } } } } | <S2SV_ModStart> ; if ( ( <S2SV_ModStart> "FC" ) ) != NULL ) <S2SV_ModStart> } if ( ( <S2SV_ModStart> , DA_OBJECT_REF_NODE_KEY ) ) != NULL |
5,174 | CWE-000 void menu_check_buttons ( void ) { if ( menu_editmode . enabled ) { editmode_handler ( ) ; } else if ( menumode . enabled ) { menumode_handler ( ) ; } else { <S2SV_StartBug> if ( ports_button_pressed ( PORTS_BTN_LSTAR , 1 ) ) { <S2SV_EndBug> if ( menumode . item -> lstar_btn_fn ) menumode . item -> lstar_btn_fn ( ) ; <S2SV_StartBug> } else if ( ports_button_pressed ( PORTS_BTN_STAR , ! ! ( menumode . item -> lstar_btn_fn ) ) ) { <S2SV_EndBug> menumode_enable ( ) ; } else if ( ports_button_pressed ( PORTS_BTN_LNUM , 1 ) ) { if ( menumode . item -> lnum_btn_fn ) menumode . item -> lnum_btn_fn ( ) ; } else if ( ports_button_pressed ( PORTS_BTN_NUM , ! ! ( menumode . item -> lnum_btn_fn ) ) ) { if ( menumode . item -> num_btn_fn ) menumode . item -> num_btn_fn ( ) ; } else if ( ports_button_pressed ( PORTS_BTN_UP | PORTS_BTN_DOWN , 0 ) ) { if ( menumode . item -> updown_btn_fn ) menumode . item -> updown_btn_fn ( ) ; } else if ( ports_button_pressed ( PORTS_BTN_UP , 0 ) ) { if ( menumode . item -> up_btn_fn ) menumode . item -> up_btn_fn ( ) ; } else if ( ports_button_pressed ( PORTS_BTN_DOWN , 0 ) ) { if ( menumode . item -> down_btn_fn ) menumode . item -> down_btn_fn ( ) ; } } ports_buttons_clear ( ) ; } | <S2SV_ModStart> } else { menuitem_handler <S2SV_ModEnd> ( ) ; <S2SV_ModStart> ( ) ; <S2SV_ModEnd> } ports_buttons_clear ( |
5,175 | CWE-000 void cdate_daytag ( t_cdate * cdate ) { int today ; int i ; char * * daytags ; printf ( normal ) ; daytags = ( char * * ) daytag_en ; putchar ( '\\n' ) ; today = cdate -> tm -> tm_wday - 1 ; today < 0 ? today = 6 : ( 0 ) ; i = 0 ; while ( * daytags != NULL ) { printf ( darken ) ; if ( i == today ) printf ( active ) ; printf ( "%4s" , * daytags ) ; <S2SV_StartBug> printf ( normal ) ; <S2SV_EndBug> ++ daytags ; ++ i ; } <S2SV_StartBug> putchar ( '\\n' ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; printf ( RESET <S2SV_ModEnd> ) ; ++ <S2SV_ModStart> i ; } printf ( RESET ) ; |
5,176 | CWE-000 int repl_load_servers ( ) { FILE * f ; int idx = 0 ; f = fopen ( "known_servers.txt" , "r" ) ; if ( f == NULL ) { log_error ( "repl" , "Could<S2SV_blank>not<S2SV_blank>fin<S2SV_blank>the<S2SV_blank>known<S2SV_blank>replication<S2SV_blank>servers<S2SV_blank>file" ) ; return - 1 ; } while ( ! feof ( f ) && idx < REPL_MAX_SERVER ) { int id = - 1 , port = - 1 , type = - 1 ; char host [ 50 ] ; fscanf ( f , "%d<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>%d" , & id , host , & port , & type ) ; log_info ( "repl" , "Known<S2SV_blank>server:<S2SV_blank>%d<S2SV_blank>%s<S2SV_blank>%d<S2SV_blank>%d" , id , host , port , type ) ; servers [ idx ] . id = id ; servers [ idx ] . primary = type == 1 ; servers [ idx ] . down = 0 ; <S2SV_StartBug> servers [ idx ] . entity . idx_buffer = - 1 ; <S2SV_EndBug> servers [ idx ] . entity . socket_instance = utils_create_socket ( ) ; utils_init_sockaddr_to_host ( & ( servers [ idx ] . entity . sockaddr ) , port , host ) ; idx ++ ; } fclose ( f ) ; return 0 ; } | <S2SV_ModStart> = 0 ; strcpy ( servers [ idx ] . host , host ) ; |
5,177 | CWE-000 static ssize_t <S2SV_StartBug> nrf24_write ( struct file * filp , const char * buf , size_t size , loff_t * f_pos ) <S2SV_EndBug> { struct nrf24_device * device ; struct nrf24_pipe * p ; ssize_t n ; ssize_t copied ; p = filp -> private_data ; device = to_nrf24_device ( p -> dev -> parent ) ; dev_dbg ( p -> dev , "write<S2SV_blank>(%d)" , size ) ; mutex_lock ( & device -> tx_fifo_mutex ) ; n = kfifo_in ( & device -> tx_fifo , & p , sizeof ( p ) ) ; if ( n != sizeof ( p ) ) goto error ; n = kfifo_in ( & device -> tx_fifo , & size , sizeof ( size ) ) ; if ( n != sizeof ( size ) ) goto error ; n = kfifo_from_user ( & device -> tx_fifo , buf , size , & copied ) ; if ( n || size != copied ) goto error ; mutex_unlock ( & device -> tx_fifo_mutex ) ; wake_up_interruptible ( & device -> tx_fifo_wait_queue ) ; return copied ; error : kfifo_reset ( & device -> tx_fifo ) ; mutex_unlock ( & device -> tx_fifo_mutex ) ; return - EAGAIN ; } | <S2SV_ModStart> , const char __user |
5,178 | CWE-000 static uint32_t out_get_latency ( const struct audio_stream_out * stream ) { <S2SV_StartBug> return ( pcm_config_out . period_size * pcm_config_out . period_count * 1000 ) / <S2SV_EndBug> pcm_config_out . rate ; } | <S2SV_ModStart> stream ) { struct stream_out * out = ( struct stream_out * ) stream ; struct audio_device * adev = out -> dev ; size_t period_count ; pthread_mutex_lock ( & adev -> lock ) ; if ( adev -> screen_off && ! adev -> active_in && ! ( adev -> devices & AUDIO_DEVICE_OUT_ALL_SCO ) ) period_count = OUT_LONG_PERIOD_COUNT ; else period_count = OUT_SHORT_PERIOD_COUNT ; pthread_mutex_unlock ( & adev -> lock ) ; <S2SV_ModStart> . period_size * <S2SV_ModEnd> period_count * 1000 |
5,179 | CWE-000 static __inline void vmx_exit_trace ( struct vmx * vmx , int vcpu , uint64_t rip , uint32_t exit_reason , int handled ) { # ifdef KTR VCPU_CTR3 ( vmx -> vm , vcpu , "%s<S2SV_blank>%s<S2SV_blank>vmexit<S2SV_blank>at<S2SV_blank>0x%0lx" , handled ? "handled" : "unhandled" , exit_reason_to_str ( exit_reason ) , rip ) ; # endif <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; # endif DTRACE_PROBE3 ( vmm__vexit , int , vcpu , uint64_t , rip , uint32_t , exit_reason ) ; |
5,180 | CWE-000 static struct ratbagd * ratbagd_free ( struct ratbagd * ctx ) { <S2SV_StartBug> struct ratbagd_device * device ; <S2SV_EndBug> if ( ! ctx ) return NULL ; <S2SV_StartBug> RATBAGD_DEVICE_FOREACH ( device , ctx ) <S2SV_EndBug> ratbagd_device_unlink ( device ) ; ctx -> bus = sd_bus_flush_close_unref ( ctx -> bus ) ; ctx -> monitor_source = sd_event_source_unref ( ctx -> monitor_source ) ; ctx -> monitor = udev_monitor_unref ( ctx -> monitor ) ; ctx -> lib_ctx = ratbag_unref ( ctx -> lib_ctx ) ; ctx -> event = sd_event_unref ( ctx -> event ) ; assert ( ! ctx -> device_map . root ) ; assert ( ! ctx -> lib_ctx ) ; return mfree ( ctx ) ; } | <S2SV_ModStart> ratbagd_device * device , * tmp <S2SV_ModStart> return NULL ; RATBAGD_DEVICE_FOREACH_SAFE ( device , tmp <S2SV_ModEnd> , ctx ) |
5,181 | CWE-000 static int ndef_prefix ( BIO * b , unsigned char * * pbuf , int * plen , void * parg ) { NDEF_SUPPORT * ndef_aux ; unsigned char * p ; int derlen ; if ( ! parg ) return 0 ; ndef_aux = * ( NDEF_SUPPORT * * ) parg ; derlen = ASN1_item_ndef_i2d ( ndef_aux -> val , NULL , ndef_aux -> it ) ; p = OPENSSL_malloc ( derlen ) ; if ( p == NULL ) return 0 ; ndef_aux -> derbuf = p ; * pbuf = p ; derlen = ASN1_item_ndef_i2d ( ndef_aux -> val , & p , ndef_aux -> it ) ; if ( ! * ndef_aux -> boundary ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> * plen = * ndef_aux -> boundary - * pbuf ; return 1 ; } | <S2SV_ModStart> -> boundary ) OPENSSL_free ( p ) ; |
5,182 | CWE-000 int main ( int argc , char * * argv ) { double T = 1.5 ; double step = 0.01 ; int M = 10 ; int N = 50 ; int steps = 100 ; int flags , opt ; int nsecs , tfnd ; while ( ( opt = getopt ( argc , argv , "M:N:T:S:s:" ) ) != - 1 ) { switch ( opt ) { case 'M' : M = atoi ( optarg ) ; break ; case 'N' : N = atoi ( optarg ) ; break ; case 'T' : T = atof ( optarg ) ; break ; case 'S' : step = atof ( optarg ) ; break ; case 's' : steps = atoi ( optarg ) ; break ; default : fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[-M<S2SV_blank>xsize]<S2SV_blank>[-N<S2SV_blank>ysize]<S2SV_blank>[-T<S2SV_blank>temperature]<S2SV_blank>[-S<S2SV_blank>temperature<S2SV_blank>step]<S2SV_blank>[-s<S2SV_blank>number<S2SV_blank>of<S2SV_blank>steps]\\n" , argv [ 0 ] ) ; exit ( EXIT_FAILURE ) ; } } double * lnZ , * lnZbar ; int twotoM ; long double Z ; twotoM = 1 << M ; lnZ = ( double * ) malloc ( twotoM * sizeof ( double ) ) ; <S2SV_StartBug> int i , j , k , l ; <S2SV_EndBug> for ( i = 0 ; i < steps ; i ++ ) { for ( j = 0 ; j < twotoM ; j ++ ) { lnZ [ j ] = 0 ; for ( l = 0 ; l < M - 1 ; l ++ ) { lnZ [ j ] += 2.0 / T * ( double ) ( ( ( j >> l ) % 2 ) ^ ( ( ( ~ j ) >> ( l + 1 ) ) % 2 ) ) ; } lnZ [ j ] += 2.0 / T * ( double ) ( ( ( j >> ( M - 1 ) ) % 2 ) ^ ( ( ~ j ) & 1 ) ) - ( double ) M / T ; } for ( k = 0 ; k < N ; k ++ ) { for ( l = 0 ; l < M ; l ++ ) { lnZbar = ( double * ) malloc ( twotoM * sizeof ( double ) ) ; for ( j = 0 ; j < twotoM ; j ++ ) { lnZbar [ j ] = 1 / T + lnZ [ j ] + log ( 1 + exp ( - 2 / T + lnZ [ j ^ ( 1 << l ) ] - lnZ [ j ] ) ) ; } free ( lnZ ) ; lnZ = lnZbar ; } for ( j = 0 ; j < twotoM ; j ++ ) { for ( l = 0 ; l < M - 1 ; l ++ ) { lnZ [ j ] += 2.0 / T * ( double ) ( ( ( j >> l ) % 2 ) ^ ( ( ( ~ j ) >> ( l + 1 ) ) % 2 ) ) ; } lnZ [ j ] += 2.0 / T * ( double ) ( ( ( j >> ( M - 1 ) ) % 2 ) ^ ( ( ~ j ) & 1 ) ) - ( double ) M / T ; } } Z = 0.0 ; for ( j = 0 ; j < twotoM ; j ++ ) { Z += expl ( lnZ [ j ] ) ; } printf ( "%d<S2SV_blank>%lf<S2SV_blank>%lf\\n" , M , T , - ( double ) ( logl ( Z ) * T / ( double ) ( M * N ) ) ) ; T = T + step ; } return 0 ; } | <S2SV_ModStart> ) ) ; unsigned |
5,183 | CWE-000 <S2SV_StartBug> int count_Dolmen ( char * * * board , int max_x , int max_y , char color ) <S2SV_EndBug> { <S2SV_StartBug> int result = 0 ; <S2SV_EndBug> int y = 0 ; int x = 0 ; int labeled_board [ max_y ] [ max_x ] ; for ( y = 0 ; y < max_y ; y ++ ) for ( x = 0 ; x < max_x ; x ++ ) labeled_board [ y ] [ x ] = 0 ; int equival_relationship [ 20 ] [ 2 ] ; for ( y = 0 ; y < 20 ; y ++ ) { equival_relationship [ y ] [ 0 ] = y ; equival_relationship [ y ] [ 1 ] = 0 ; } int dolmen_sizes [ 20 ] [ 2 ] ; for ( y = 0 ; y < 20 ; y ++ ) { dolmen_sizes [ y ] [ 0 ] = y ; dolmen_sizes [ y ] [ 1 ] = 0 ; } int curr_label = 0 ; for ( y = 0 ; y < max_y ; y ++ ) { for ( x = 0 ; x < max_x ; x ++ ) { if ( * ( * ( * ( board + y ) + x ) ) == color ) { if ( ( x > 0 && y > 0 ) && ( * ( * ( * ( board + y ) + x - 1 ) ) == color ) && ( * ( * ( * ( board + y - 1 ) + x ) ) == color ) && ( labeled_board [ y ] [ x - 1 ] != labeled_board [ y - 1 ] [ x ] ) ) { if ( labeled_board [ y ] [ x - 1 ] < labeled_board [ y - 1 ] [ x ] ) { labeled_board [ y ] [ x ] = labeled_board [ y ] [ x - 1 ] ; equival_relationship [ labeled_board [ y - 1 ] [ x ] ] [ 1 ] = labeled_board [ y ] [ x - 1 ] ; } else { labeled_board [ y ] [ x ] = labeled_board [ y - 1 ] [ x ] ; equival_relationship [ labeled_board [ y ] [ x - 1 ] ] [ 1 ] = labeled_board [ y - 1 ] [ x ] ; } continue ; } if ( x > 0 && * ( * ( * ( board + y ) + x - 1 ) ) == color ) { labeled_board [ y ] [ x ] = labeled_board [ y ] [ x - 1 ] ; continue ; } <S2SV_StartBug> if ( x > 0 && y > 0 && * ( * ( * ( board + y - 1 ) + x ) ) == color ) <S2SV_EndBug> { labeled_board [ y ] [ x ] = labeled_board [ y - 1 ] [ x ] ; continue ; } labeled_board [ y ] [ x ] = ++ curr_label ; equival_relationship [ curr_label ] [ 1 ] = curr_label ; } } } for ( y = 0 ; y < max_y ; y ++ ) { for ( x = 0 ; x < max_x ; x ++ ) { labeled_board [ y ] [ x ] = equival_relationship [ labeled_board [ y ] [ x ] ] [ 1 ] ; } } for ( y = 0 ; y < max_y ; y ++ ) for ( x = 0 ; x < max_x ; x ++ ) dolmen_sizes [ labeled_board [ y ] [ x ] ] [ 1 ] ++ ; <S2SV_StartBug> for ( y = 1 ; y < 20 ; y ++ ) <S2SV_EndBug> if ( dolmen_sizes [ y ] [ 1 ] > 2 ) <S2SV_StartBug> { <S2SV_EndBug> result ++ ; } for ( y = 0 ; y < max_y ; y ++ ) { for ( x = 0 ; x < max_x ; x ++ ) g_printf ( "%d<S2SV_blank>" , labeled_board [ y ] [ x ] ) ; g_printf ( "%s" , "\\n" ) ; } for ( y = 0 ; y < 20 ; y ++ ) { for ( x = 0 ; x < 2 ; x ++ ) <S2SV_StartBug> g_printf ( "%d<S2SV_blank>" , equival_relationship [ y ] [ x ] ) ; <S2SV_EndBug> g_printf ( "%s" , "\\n" ) ; } return result ; } | <S2SV_ModStart> , char color , char type_count <S2SV_ModStart> { int result = 0 ; int mayor <S2SV_ModStart> } if ( <S2SV_ModEnd> y > 0 <S2SV_ModStart> ] ++ ; switch ( type_count ) { case 'R' : <S2SV_ModStart> > 2 ) result ++ ; return result ; case 'D' : for ( y = 1 ; y < 20 ; y ++ ) if ( dolmen_sizes [ y ] [ 1 ] > mayor ) mayor = dolmen_sizes [ y ] [ 1 ] ; return mayor <S2SV_ModEnd> ; } for <S2SV_ModStart> ( "%d<S2SV_blank>" , dolmen_sizes <S2SV_ModEnd> [ y ] |
5,184 | CWE-000 int xsp_set_eid ( struct xsp_addr * eid , void * arg , int eid_type ) { switch ( eid_type ) { case XSP_EID_IPv4 : break ; case XSP_EID_IPv6 : break ; case XSP_EID_URN : break ; case XSP_EID_HOPID : <S2SV_StartBug> memcpy ( eid -> x_addrc , ( char * ) arg , XSP_HOPID_LEN ) ; <S2SV_EndBug> break ; default : break ; } eid -> type = eid_type ; return 0 ; } | <S2SV_ModStart> case XSP_EID_HOPID : strncpy <S2SV_ModEnd> ( eid -> |
5,185 | CWE-000 static void parserInit ( XML_Parser parser , const XML_Char * encodingName ) { processor = prologInitProcessor ; XmlPrologStateInit ( & prologState ) ; if ( encodingName != NULL ) { protocolEncodingName = copyString ( encodingName , & ( parser -> m_mem ) ) ; } curBase = NULL ; XmlInitEncoding ( & initEncoding , & encoding , 0 ) ; parser -> m_userData = NULL ; parser -> m_handlerArg = NULL ; parser -> m_startElementHandler = NULL ; parser -> m_endElementHandler = NULL ; parser -> m_characterDataHandler = NULL ; processingInstructionHandler = NULL ; parser -> m_commentHandler = NULL ; startCdataSectionHandler = NULL ; parser -> m_endCdataSectionHandler = NULL ; parser -> m_defaultHandler = NULL ; parser -> m_startDoctypeDeclHandler = NULL ; parser -> m_endDoctypeDeclHandler = NULL ; unparsedEntityDeclHandler = NULL ; parser -> m_notationDeclHandler = NULL ; startNamespaceDeclHandler = NULL ; parser -> m_endNamespaceDeclHandler = NULL ; <S2SV_StartBug> notStandaloneHandler = NULL ; <S2SV_EndBug> externalEntityRefHandler = NULL ; externalEntityRefHandlerArg = parser ; skippedEntityHandler = NULL ; elementDeclHandler = NULL ; attlistDeclHandler = NULL ; entityDeclHandler = NULL ; xmlDeclHandler = NULL ; bufferPtr = buffer ; bufferEnd = buffer ; parseEndByteIndex = 0 ; parseEndPtr = NULL ; declElementType = NULL ; declAttributeId = NULL ; declEntity = NULL ; doctypeName = NULL ; doctypeSysid = NULL ; doctypePubid = NULL ; declAttributeType = NULL ; declNotationName = NULL ; declNotationPublicId = NULL ; declAttributeIsCdata = XML_FALSE ; declAttributeIsId = XML_FALSE ; memset ( & position , 0 , sizeof ( POSITION ) ) ; errorCode = XML_ERROR_NONE ; eventPtr = NULL ; eventEndPtr = NULL ; positionPtr = NULL ; openInternalEntities = NULL ; defaultExpandInternalEntities = XML_TRUE ; tagLevel = 0 ; tagStack = NULL ; inheritedBindings = NULL ; nSpecifiedAtts = 0 ; unknownEncodingMem = NULL ; unknownEncodingRelease = NULL ; unknownEncodingData = NULL ; parentParser = NULL ; ps_parsing = XML_INITIALIZED ; # ifdef XML_DTD isParamEntity = XML_FALSE ; useForeignDTD = XML_FALSE ; paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER ; # endif hash_secret_salt = 0 ; } | <S2SV_ModStart> = NULL ; parser -> m_notStandaloneHandler <S2SV_ModEnd> = NULL ; |
5,186 | CWE-000 void aubio_fft_rdo_complex ( aubio_fft_t * s , const fvec_t * compspec , fvec_t * output ) { uint_t i ; # ifdef HAVE_FFTW3 const smpl_t renorm = 1. / ( smpl_t ) s -> winsize ; # ifdef HAVE_COMPLEX_H s -> specdata [ 0 ] = compspec -> data [ 0 ] ; for ( i = 1 ; i < s -> fft_size - 1 ; i ++ ) { s -> specdata [ i ] = compspec -> data [ i ] + I * compspec -> data [ compspec -> length - i ] ; } s -> specdata [ s -> fft_size - 1 ] = compspec -> data [ s -> fft_size - 1 ] ; # else for ( i = 0 ; i < s -> fft_size ; i ++ ) { s -> specdata [ i ] = compspec -> data [ i ] ; } # endif fftw_execute ( s -> pbw ) ; for ( i = 0 ; i < output -> length ; i ++ ) { output -> data [ i ] = s -> out [ i ] * renorm ; } # elif defined HAVE_ACCELERATE s -> out [ 0 ] = compspec -> data [ 0 ] ; s -> out [ 1 ] = compspec -> data [ s -> winsize / 2 ] ; for ( i = 1 ; i < s -> fft_size / 2 ; i ++ ) { s -> out [ 2 * i ] = compspec -> data [ i ] ; s -> out [ 2 * i + 1 ] = compspec -> data [ s -> winsize - i ] ; } aubio_vDSP_ctoz ( ( aubio_DSPComplex * ) s -> out , 2 , & s -> spec , 1 , s -> fft_size / 2 ) ; aubio_vDSP_fft_zrip ( s -> fftSetup , & s -> spec , 1 , s -> log2fftsize , FFT_INVERSE ) ; aubio_vDSP_ztoc ( & s -> spec , 1 , ( aubio_DSPComplex * ) output -> data , 2 , s -> fft_size / 2 ) ; smpl_t scale = 1.0 / s -> winsize ; aubio_vDSP_vsmul ( output -> data , 1 , & scale , output -> data , 1 , s -> fft_size ) ; # elif defined HAVE_INTEL_IPP s -> complexOut [ 0 ] . re = compspec -> data [ 0 ] ; s -> complexOut [ 0 ] . im = 0 ; s -> complexOut [ s -> fft_size / 2 ] . re = compspec -> data [ s -> fft_size / 2 ] ; s -> complexOut [ s -> fft_size / 2 ] . im = 0.0 ; for ( i = 1 ; i < s -> fft_size / 2 ; i ++ ) { s -> complexOut [ i ] . re = compspec -> data [ i ] ; s -> complexOut [ i ] . im = compspec -> data [ s -> fft_size - i ] ; } # if HAVE_AUBIO_DOUBLE <S2SV_StartBug> ippsFFTInv_CCSToR_64f ( s -> complexOut , output -> data , s -> fftSpec , s -> memBuffer ) ; <S2SV_EndBug> <S2SV_StartBug> ippsMulC_64f ( ( const Ip642f * ) output -> data , 1.0 / s -> winsize , output -> data , s -> fft_size ) ; <S2SV_EndBug> # else ippsFFTInv_CCSToR_32f ( ( const Ipp32f * ) s -> complexOut , output -> data , s -> fftSpec , s -> memBuffer ) ; ippsMulC_32f ( output -> data , 1.0f / s -> winsize , output -> data , s -> fft_size ) ; # endif # else smpl_t scale = 1.0 / s -> winsize ; s -> out [ 0 ] = compspec -> data [ 0 ] ; s -> out [ 1 ] = compspec -> data [ s -> winsize / 2 ] ; for ( i = 1 ; i < s -> fft_size - 1 ; i ++ ) { s -> out [ 2 * i ] = compspec -> data [ i ] ; s -> out [ 2 * i + 1 ] = - compspec -> data [ s -> winsize - i ] ; } aubio_ooura_rdft ( s -> winsize , - 1 , s -> out , s -> ip , s -> w ) ; for ( i = 0 ; i < s -> winsize ; i ++ ) { output -> data [ i ] = s -> out [ i ] * scale ; } # endif } | <S2SV_ModStart> HAVE_AUBIO_DOUBLE ippsFFTInv_CCSToR_64f ( ( const Ipp64f * ) <S2SV_ModStart> ; ippsMulC_64f ( <S2SV_ModEnd> output -> data |
5,187 | CWE-000 static int restore_r2 ( u32 * instruction , struct module * me ) { <S2SV_StartBug> if ( is_early_mcount_callsite ( instruction - 1 ) ) <S2SV_EndBug> return 1 ; if ( * instruction != PPC_INST_NOP ) { pr_err ( "%s:<S2SV_blank>Expect<S2SV_blank>noop<S2SV_blank>after<S2SV_blank>relocate,<S2SV_blank>got<S2SV_blank>%08x\\n" , me -> name , * instruction ) ; return 0 ; } * instruction = PPC_INST_LD_TOC ; return 1 ; } | <S2SV_ModStart> me ) { u32 * prev_insn = instruction - 1 ; <S2SV_ModStart> ( is_early_mcount_callsite ( prev_insn ) ) return 1 ; if ( ! instr_is_relative_link_branch ( * prev_insn <S2SV_ModEnd> ) ) return |
5,188 | CWE-000 void * malloc ( size_t size ) { <S2SV_StartBug> return gc_alloc ( size , false ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> size ) { void * p = <S2SV_ModEnd> gc_alloc ( size <S2SV_ModStart> false ) ; if ( p == NULL ) { errno = ENOMEM ; } return p ; |
5,189 | CWE-000 void crash_enter_zone ( enum CrashZone zone ) { crash_zone |= zone ; <S2SV_StartBug> persist_write_int ( STORAGE_CRASH_DETECTOR_ZONE , crash_zone ) ; <S2SV_EndBug> } | <S2SV_ModStart> |= zone ; check_write_status ( <S2SV_ModStart> , crash_zone ) , STORAGE_CRASH_DETECTOR_ZONE ) |
5,190 | CWE-000 int read_task_ustack ( struct ftrace_file_handle * handle , struct ftrace_task_handle * task ) { if ( task -> valid ) return 0 ; if ( task -> done || task -> fp == NULL ) return - 1 ; if ( __read_task_ustack ( task ) < 0 ) { task -> done = true ; <S2SV_StartBug> fclose ( task -> fp ) ; <S2SV_EndBug> task -> fp = NULL ; return - 1 ; } if ( task -> lost_seen ) { int i ; for ( i = 0 ; i <= task -> ustack . depth ; i ++ ) task -> func_stack [ i ] . valid = false ; pr_dbg ( "lost<S2SV_blank>seen:<S2SV_blank>invalidating<S2SV_blank>existing<S2SV_blank>stack..\\n" ) ; task -> lost_seen = false ; task -> display_depth_set = false ; } if ( task -> ustack . more ) { if ( ! ( handle -> hdr . feat_mask & ( ARGUMENT | RETVAL ) ) || handle -> info . argspec == NULL ) pr_err_ns ( "invalid<S2SV_blank>data<S2SV_blank>(more<S2SV_blank>bit<S2SV_blank>set<S2SV_blank>w/o<S2SV_blank>args)" ) ; if ( task -> ustack . type == FTRACE_ENTRY ) read_task_args ( task , & task -> ustack , false ) ; else if ( task -> ustack . type == FTRACE_EXIT ) read_task_args ( task , & task -> ustack , true ) ; else abort ( ) ; } task -> valid = true ; return 0 ; } | <S2SV_ModStart> = true ; <S2SV_ModEnd> return - 1 |
5,191 | CWE-000 static void histogram_sweep_calculations ( struct histogram_config * conf , noit_check_t * check ) { mtev_hash_iter iter = MTEV_HASH_ITER_ZERO ; const char * metric_name ; int klen ; void * data ; mtev_hash_table * metrics ; stats_t * c ; double * out_q ; c = noit_check_get_stats_current ( check ) ; if ( ! conf -> mean && conf -> n_quantiles < 1 ) return ; metrics = noit_check_get_module_metadata ( check , histogram_module_id ) ; if ( ! metrics ) return ; out_q = alloca ( sizeof ( double * ) * conf -> n_quantiles ) ; u_int64_t s = time ( NULL ) ; while ( mtev_hash_next ( metrics , & iter , & metric_name , & klen , & data ) ) { char mname [ 1024 ] ; histotier * ht = data ; if ( ht -> last_aggr == NULL ) continue ; if ( conf -> mean ) { double mean_value ; snprintf ( mname , sizeof ( mname ) , "%s:mean" , metric_name ) ; mean_value = hist_approx_mean ( ht -> last_aggr ) ; <S2SV_StartBug> noit_stats_set_metric ( check , metric_name , METRIC_DOUBLE , & mean_value ) ; <S2SV_EndBug> } if ( conf -> n_quantiles ) { if ( hist_approx_quantile ( ht -> last_aggr , conf -> quantiles , conf -> n_quantiles , out_q ) == 0 ) { int i ; for ( i = 0 ; i < conf -> n_quantiles ; i ++ ) { snprintf ( mname , sizeof ( mname ) , "%s:q(%0.5f)" , metric_name , conf -> quantiles [ i ] ) ; <S2SV_StartBug> noit_stats_set_metric ( check , metric_name , METRIC_DOUBLE , & out_q [ i ] ) ; <S2SV_EndBug> } } } } } | <S2SV_ModStart> ( check , mname <S2SV_ModEnd> , METRIC_DOUBLE , <S2SV_ModStart> ( check , mname <S2SV_ModEnd> , METRIC_DOUBLE , |
5,192 | CWE-000 struct page * init_inode_metadata ( struct inode * inode , struct inode * dir , const struct qstr * name , struct page * dpage ) { struct page * page ; int err ; if ( is_inode_flag_set ( F2FS_I ( inode ) , FI_NEW_INODE ) ) { page = new_inode_page ( inode ) ; if ( IS_ERR ( page ) ) return page ; if ( S_ISDIR ( inode -> i_mode ) ) { err = make_empty_dir ( inode , dir , page ) ; if ( err ) goto error ; } err = f2fs_init_acl ( inode , dir , page , dpage ) ; if ( err ) goto put_error ; err = f2fs_init_security ( inode , dir , name , page ) ; if ( err ) goto put_error ; if ( f2fs_encrypted_inode ( dir ) && f2fs_may_encrypt ( inode ) ) { err = f2fs_inherit_context ( dir , inode , page ) ; if ( err ) goto put_error ; } } else { page = get_node_page ( F2FS_I_SB ( dir ) , inode -> i_ino ) ; if ( IS_ERR ( page ) ) return page ; set_cold_node ( inode , page ) ; } if ( name ) init_dent_inode ( name , page ) ; if ( is_inode_flag_set ( F2FS_I ( inode ) , FI_INC_LINK ) ) { file_lost_pino ( inode ) ; if ( inode -> i_nlink == 0 ) remove_orphan_inode ( F2FS_I_SB ( dir ) , inode -> i_ino ) ; inc_nlink ( inode ) ; } return page ; put_error : f2fs_put_page ( page , 1 ) ; error : truncate_inode_pages ( & inode -> i_data , 0 ) ; truncate_blocks ( inode , 0 , false ) ; <S2SV_StartBug> remove_dirty_dir_inode ( inode ) ; <S2SV_EndBug> remove_inode_page ( inode ) ; return ERR_PTR ( err ) ; } | <S2SV_ModStart> false ) ; remove_dirty_inode <S2SV_ModEnd> ( inode ) |
5,193 | CWE-000 int main ( int argc , char * argv [ ] ) { odph_odpthread_params_t thr_params ; odph_odpthread_t thread_tbl [ NUMBER_WORKERS ] ; odp_cpumask_t cpu_mask ; int num_workers ; int cpu , affinity ; int ret ; char cpumaskstr [ ODP_CPUMASK_STR_SIZE ] ; odph_parse_options ( argc , argv , NULL , NULL ) ; if ( odp_init_global ( & odp_instance , NULL , NULL ) ) { ODPH_ERR ( "Error:<S2SV_blank>ODP<S2SV_blank>global<S2SV_blank>init<S2SV_blank>failed.\\n" ) ; exit ( EXIT_FAILURE ) ; } if ( odp_init_local ( odp_instance , ODP_THREAD_CONTROL ) ) { ODPH_ERR ( "Error:<S2SV_blank>ODP<S2SV_blank>local<S2SV_blank>init<S2SV_blank>failed.\\n" ) ; exit ( EXIT_FAILURE ) ; } atexit ( main_exit ) ; odp_cpumask_zero ( & cpu_mask ) ; if ( odp_cpumask_default_control ( & cpu_mask , 1 ) != 1 ) { ODPH_ERR ( "Allocate<S2SV_blank>main<S2SV_blank>process<S2SV_blank>CPU<S2SV_blank>core<S2SV_blank>failed.\\n" ) ; exit ( EXIT_FAILURE ) ; } cpu = odp_cpumask_first ( & cpu_mask ) ; if ( odph_odpthread_setaffinity ( cpu ) != 0 ) { ODPH_ERR ( "Set<S2SV_blank>main<S2SV_blank>process<S2SV_blank>affinify<S2SV_blank>to<S2SV_blank>" "cpu(%d)<S2SV_blank>failed.\\n" , cpu ) ; exit ( EXIT_FAILURE ) ; } affinity = odph_odpthread_getaffinity ( ) ; if ( ( affinity < 0 ) || ( cpu != affinity ) ) { ODPH_ERR ( "Verify<S2SV_blank>main<S2SV_blank>process<S2SV_blank>affinity<S2SV_blank>failed:<S2SV_blank>" "set(%d)<S2SV_blank>read(%d).\\n" , cpu , affinity ) ; exit ( EXIT_FAILURE ) ; } cpu = 0 ; affinity = 0 ; odp_cpumask_zero ( & cpu_mask ) ; num_workers = odp_cpumask_default_worker ( & cpu_mask , NUMBER_WORKERS ) ; if ( num_workers < NUMBER_WORKERS ) { printf ( "System<S2SV_blank>can<S2SV_blank>only<S2SV_blank>support<S2SV_blank>%d<S2SV_blank>threads<S2SV_blank>and<S2SV_blank>not<S2SV_blank>the<S2SV_blank>%d<S2SV_blank>requested\\n" , num_workers , NUMBER_WORKERS ) ; } ( void ) odp_cpumask_to_str ( & cpu_mask , cpumaskstr , sizeof ( cpumaskstr ) ) ; printf ( "default<S2SV_blank>cpu<S2SV_blank>mask:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , cpumaskstr ) ; printf ( "default<S2SV_blank>num<S2SV_blank>worker<S2SV_blank>threads:<S2SV_blank>%i\\n" , num_workers ) ; cpu = odp_cpumask_first ( & cpu_mask ) ; printf ( "the<S2SV_blank>first<S2SV_blank>CPU:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%i\\n" , cpu ) ; <S2SV_StartBug> odp_cpumask_clr ( & cpu_mask , 0 ) ; <S2SV_EndBug> num_workers = odp_cpumask_count ( & cpu_mask ) ; ( void ) odp_cpumask_to_str ( & cpu_mask , cpumaskstr , sizeof ( cpumaskstr ) ) ; printf ( "new<S2SV_blank>cpu<S2SV_blank>mask:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%s\\n" , cpumaskstr ) ; printf ( "new<S2SV_blank>num<S2SV_blank>worker<S2SV_blank>threads:<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>%i\\n\\n" , num_workers ) ; memset ( & thr_params , 0 , sizeof ( thr_params ) ) ; thr_params . start = worker_fn ; thr_params . arg = NULL ; thr_params . thr_type = ODP_THREAD_WORKER ; thr_params . instance = odp_instance ; odph_odpthreads_create ( & thread_tbl [ 0 ] , & cpu_mask , & thr_params ) ; ret = odph_odpthreads_join ( thread_tbl ) ; if ( ret < 0 ) exit ( EXIT_FAILURE ) ; return 0 ; } | <S2SV_ModStart> cpu ) ; if ( num_workers > 1 ) |
5,194 | CWE-000 <S2SV_StartBug> ZEPHIR_INIT_CLASS ( Phalcon_Assets_Resource_Css ) { <S2SV_EndBug> <S2SV_StartBug> ZEPHIR_REGISTER_CLASS_EX ( Phalcon \\ \\ Assets \\ \\ Resource , Css , phalcon , assets_resource_css , phalcon_assets_resource_ce , phalcon_assets_resource_css_method_entry , 0 ) ; <S2SV_EndBug> return SUCCESS ; } | <S2SV_ModStart> <S2SV_null> ZEPHIR_INIT_CLASS ( Phalcon_Cli_Console <S2SV_ModEnd> ) { ZEPHIR_REGISTER_CLASS_EX <S2SV_ModStart> Phalcon \\ \\ Cli , Console <S2SV_ModEnd> , phalcon , <S2SV_ModStart> , phalcon , cli_console , phalcon_application_ce , phalcon_cli_console_method_entry <S2SV_ModEnd> , 0 ) <S2SV_ModStart> , 0 ) ; zend_declare_property_null ( phalcon_cli_console_ce , SL ( "_arguments" ) , ZEND_ACC_PROTECTED TSRMLS_CC ) ; zend_declare_property_null ( phalcon_cli_console_ce , SL ( "_options" ) , ZEND_ACC_PROTECTED TSRMLS_CC ) ; phalcon_cli_console_ce -> create_object = zephir_init_properties_Phalcon_Cli_Console |
5,195 | CWE-000 NORM_FUNC ( SRAV ) { uint8_t rt = GET_RT ( opdata ) ; uint8_t rs = GET_RS ( opdata ) ; CHECK_ZR ( rt | rs ) ; cpu -> R [ GET_RD ( opdata ) ] = <S2SV_StartBug> BYTE_CONV ( BYTE_CONV ( cpu -> R [ rt ] , int32_t ) ; >> ( cpu -> R [ rt ] & 0x1F ) , uint32_t ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> , int32_t ) <S2SV_ModEnd> >> ( cpu |
5,196 | CWE-000 static int TransferFloat ( float * fld , sInt4 ngrdpts , sInt4 ibitmap , sInt4 * bmap , char f_ignoreScan , sInt4 * scan , sInt4 nx , sInt4 ny , sInt4 iclean , float xmissp , float * ain , sInt4 nd2x3 , sInt4 * ib ) { int i ; sInt4 x , y ; uInt4 curIndex ; <S2SV_StartBug> if ( nd2x3 < ngrdpts ) { <S2SV_EndBug> # ifdef DEBUG printf ( "nd2x3(%d)<S2SV_blank>is<S2SV_blank><<S2SV_blank>ngrdpts(%d)\\n" , nd2x3 , ngrdpts ) ; # endif return 1 ; } if ( f_ignoreScan || ( ( * scan & 0xf0 ) == 64 ) ) { if ( ibitmap ) { for ( i = 0 ; i < ngrdpts ; i ++ ) { ib [ i ] = bmap [ i ] ; if ( ( iclean != 0 ) && ( ib [ i ] == 0 ) ) { ain [ i ] = xmissp ; } else { ain [ i ] = fld [ i ] ; } } } else { for ( i = 0 ; i < ngrdpts ; i ++ ) { ain [ i ] = fld [ i ] ; } } } else { if ( nx == 0 || ny != ngrdpts / nx ) { # ifdef DEBUG printf ( "nx(%d)<S2SV_blank>*<S2SV_blank>ny(%d)<S2SV_blank>!=<S2SV_blank>ngrdpts(%d)\\n" , nx , ny , ngrdpts ) ; # endif return 2 ; } if ( ibitmap ) { for ( i = 0 ; i < ngrdpts ; i ++ ) { ScanIndex2XY ( i , & x , & y , * scan , nx , ny ) ; curIndex = ( uInt4 ) ( x - 1 ) + ( uInt4 ) ( y - 1 ) * ( uInt4 ) nx ; if ( curIndex >= ( uInt4 ) nd2x3 ) return 1 ; ib [ curIndex ] = bmap [ i ] ; if ( ( iclean != 0 ) && ( ib [ curIndex ] == 0 ) ) { ain [ i ] = xmissp ; } else { ain [ curIndex ] = fld [ i ] ; } } } else { for ( i = 0 ; i < ngrdpts ; i ++ ) { ScanIndex2XY ( i , & x , & y , * scan , nx , ny ) ; curIndex = ( uInt4 ) ( x - 1 ) + ( uInt4 ) ( y - 1 ) * ( uInt4 ) nx ; if ( curIndex >= ( uInt4 ) nd2x3 ) return 1 ; ain [ curIndex ] = fld [ i ] ; } } * scan = 64 + ( * scan & 0x0f ) ; } return 0 ; } | <S2SV_ModStart> ; if ( nx == 0 || ny == 0 ) { return 1 ; } if ( |
5,197 | CWE-000 <S2SV_StartBug> long zephir_mt_rand ( long min , long max ) <S2SV_EndBug> { long number ; if ( max < min ) { <S2SV_StartBug> php_error_docref ( NULL , E_WARNING , "max(%ld)<S2SV_blank>is<S2SV_blank>smaller<S2SV_blank>than<S2SV_blank>min(%ld)" , max , min ) ; <S2SV_EndBug> return 0 ; } if ( ! BG ( mt_rand_is_seeded ) ) { <S2SV_StartBug> php_mt_srand ( GENERATE_SEED ( ) ) ; <S2SV_EndBug> } <S2SV_StartBug> number = ( long ) ( php_mt_rand ( ) >> 1 ) ; <S2SV_EndBug> RAND_RANGE ( number , min , max , PHP_MT_RAND_MAX ) ; return number ; } | <S2SV_ModStart> , long max TSRMLS_DC <S2SV_ModStart> php_error_docref ( NULL TSRMLS_CC <S2SV_ModStart> GENERATE_SEED ( ) TSRMLS_CC <S2SV_ModStart> ( php_mt_rand ( TSRMLS_C |
5,198 | CWE-000 struct shared_basic * loadCodeOntoMicroblaze ( struct interpreterconfiguration * configuration ) { if ( parseConfiguration ( OVERLAY_TCL_FILE ) == - 1 ) { fprintf ( stderr , "Error<S2SV_blank>opening<S2SV_blank>overlay<S2SV_blank>TCL<S2SV_blank>file<S2SV_blank>%s\\n" , OVERLAY_TCL_FILE ) ; exit ( EXIT_FAILURE ) ; } allocateSharedBuffer ( ) ; struct shared_basic * basicCode = ( void * ) shared_buffer ; <S2SV_StartBug> int codeOnCore = 0 ; <S2SV_EndBug> basicCode -> length = getMemoryFilledSize ( ) ; <S2SV_StartBug> if ( configuration -> forceCodeOnCore ) { <S2SV_EndBug> codeOnCore = 1 ; <S2SV_StartBug> } else if ( configuration -> forceCodeOnShared ) { <S2SV_EndBug> <S2SV_StartBug> codeOnCore = 0 ; <S2SV_EndBug> } else { <S2SV_StartBug> codeOnCore = basicCode -> length <= CORE_CODE_MAX_SIZE ; <S2SV_EndBug> if ( ! codeOnCore ) { printf ( "Warning:<S2SV_blank>Your<S2SV_blank>code<S2SV_blank>size<S2SV_blank>of<S2SV_blank>%d<S2SV_blank>bytes<S2SV_blank>exceeds<S2SV_blank>the<S2SV_blank>%d<S2SV_blank>byte<S2SV_blank>limit<S2SV_blank>for<S2SV_blank>placement<S2SV_blank>on<S2SV_blank>cores<S2SV_blank>so<S2SV_blank>storing<S2SV_blank>in<S2SV_blank>shared<S2SV_blank>memory\\n" , basicCode -> length , CORE_CODE_MAX_SIZE ) ; } } basicCode -> symbol_size = getNumberEntriesInSymbolTable ( ) ; basicCode -> allInSharedMemory = configuration -> forceDataOnShared ; basicCode -> interactive = configuration -> interactive ; <S2SV_StartBug> basicCode -> codeOnCores = basicCode -> interactive == 0 && codeOnCore == 1 ; <S2SV_EndBug> basicCode -> num_procs = configuration -> coreProcs + configuration -> hostProcs ; basicCode -> baseHostPid = configuration -> coreProcs ; reset_pins = ( struct gpio_state * * ) malloc ( sizeof ( struct gpio_state * ) * configuration -> coreProcs ) ; interupt_pins = ( struct gpio_state * * ) malloc ( sizeof ( struct gpio_state * ) * configuration -> coreProcs ) ; microblaze_memories = ( struct mmio_state * * ) malloc ( sizeof ( struct mmio_state * ) * configuration -> coreProcs ) ; num_initialised_microblazes = configuration -> coreProcs ; <S2SV_StartBug> initialiseCores ( basicCode , codeOnCore , configuration ) ; <S2SV_EndBug> <S2SV_StartBug> placeByteCode ( basicCode , codeOnCore ) ; <S2SV_EndBug> int i ; for ( i = 0 ; i < configuration -> coreProcs ; i ++ ) { initialiseMicroblaze ( i ) ; } cleanConfigurationRecords ( ) ; startApplicableCores ( basicCode , configuration ) ; pb = ( unsigned int * ) malloc ( sizeof ( unsigned int ) * TOTAL_CORES ) ; for ( i = 0 ; i < TOTAL_CORES ; i ++ ) { pb [ i ] = 1 ; } return basicCode ; } | <S2SV_ModStart> ) shared_buffer ; basicCode -> codeOnCores <S2SV_ModEnd> = 0 ; <S2SV_ModStart> ( configuration -> interactive ) { basicCode -> codeOnCores = 0 <S2SV_ModEnd> ; } else <S2SV_ModStart> ( configuration -> forceCodeOnCore ) { basicCode -> codeOnCores = 1 ; } else if ( configuration -> <S2SV_ModStart> forceCodeOnShared ) { basicCode -> codeOnCores <S2SV_ModEnd> = 0 ; <S2SV_ModStart> } else { basicCode -> codeOnCores <S2SV_ModEnd> = basicCode -> <S2SV_ModStart> ; basicCode -> <S2SV_ModEnd> num_procs = configuration <S2SV_ModStart> ( basicCode , basicCode -> codeOnCores <S2SV_ModEnd> , configuration ) <S2SV_ModStart> ( basicCode , basicCode -> codeOnCores <S2SV_ModEnd> ) ; int |
5,199 | CWE-000 int __wt_thread_create ( WT_SESSION_IMPL * session , wt_thread_t * tidret , WT_THREAD_CALLBACK ( * func ) ( void * ) , void * arg ) { WT_DECL_RET ; WT_FULL_BARRIER ( ) ; <S2SV_StartBug> WT_SYSCALL_RETRY ( pthread_create ( tidret , NULL , func , arg ) , ret ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ret == 0 ) <S2SV_EndBug> <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> WT_RET_MSG ( session , ret , "pthread_create" ) ; } | <S2SV_ModStart> ( pthread_create ( & tidret -> id <S2SV_ModEnd> , NULL , <S2SV_ModStart> == 0 ) { tidret -> created = true ; <S2SV_ModStart> 0 ) ; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.