Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
800 | CWE-000 int t4_port_init ( struct adapter * adap , int mbox , int pf , int vf , int port_id ) { u8 addr [ 6 ] ; int ret , i , j ; u16 rss_size ; struct port_info * p = adap2pinfo ( adap , port_id ) ; u32 param , val ; for ( i = 0 , j = - 1 ; i <= p -> port_id ; i ++ ) { do { j ++ ; } while ( ( adap -> params . portvec & ( 1 << j ) ) == 0 ) ; } if ( ! ( adap -> flags & IS_VF ) || adap -> params . vfres . r_caps & FW_CMD_CAP_PORT ) { t4_update_port_info ( p ) ; } ret = t4_alloc_vi ( adap , mbox , j , pf , vf , 1 , addr , & rss_size ) ; if ( ret < 0 ) return ret ; p -> vi [ 0 ] . viid = ret ; if ( chip_id ( adap ) <= CHELSIO_T5 ) p -> vi [ 0 ] . smt_idx = ( ret & 0x7f ) << 1 ; else p -> vi [ 0 ] . smt_idx = ( ret & 0x7f ) ; p -> tx_chan = j ; <S2SV_StartBug> p -> rx_chan_map = t4_get_mps_bg_map ( adap , j ) ; <S2SV_EndBug> <S2SV_StartBug> p -> lport = j ; <S2SV_EndBug> p -> vi [ 0 ] . rss_size = rss_size ; t4_os_set_hw_addr ( p , addr ) ; param = V_FW_PARAMS_MNEM ( FW_PARAMS_MNEM_DEV ) | V_FW_PARAMS_PARAM_X ( FW_PARAMS_PARAM_DEV_RSSINFO ) | V_FW_PARAMS_PARAM_YZ ( p -> vi [ 0 ] . viid ) ; ret = t4_query_params ( adap , mbox , pf , vf , 1 , & param , & val ) ; if ( ret ) p -> vi [ 0 ] . rss_base = 0xffff ; else { p -> vi [ 0 ] . rss_base = val & 0xffff ; } return 0 ; } | <S2SV_ModStart> ; p -> mps_bg_map <S2SV_ModEnd> = t4_get_mps_bg_map ( <S2SV_ModStart> ; p -> rx_e_chan_map = t4_get_rx_e_chan_map ( adap , j ) ; p -> |
801 | CWE-000 static void read_init_info ( int socket_fd , fd_set read_fds ) { unsigned char str [ 2 ] ; struct timeval timeout ; timeout . tv_sec = 1 ; timeout . tv_usec = 0 ; while ( select ( socket_fd + 1 , & read_fds , NULL , NULL , NULL ) > 0 ) { ft_bzero ( str , 2 ) ; if ( recv ( socket_fd , & str , 2 , 0 ) > 0 ) { sleep ( 1 ) ; system ( "clear" ) ; <S2SV_StartBug> printf ( "Time<S2SV_blank>to<S2SV_blank>start<S2SV_blank>the<S2SV_blank>game:<S2SV_blank>%d\\n" , str [ 0 ] ) ; <S2SV_EndBug> <S2SV_StartBug> printf ( "Number<S2SV_blank>of<S2SV_blank>connected<S2SV_blank>players:<S2SV_blank>%d\\n" , str [ 1 ] ) ; <S2SV_EndBug> if ( str [ 0 ] == 0 ) break ; } else ft_error ( "Error:<S2SV_blank>connection<S2SV_blank>interrupted" ) ; } } | <S2SV_ModStart> "clear" ) ; ft_printf <S2SV_ModEnd> ( "Time<S2SV_blank>to<S2SV_blank>start<S2SV_blank>the<S2SV_blank>game:<S2SV_blank>%d\\n" , <S2SV_ModStart> ] ) ; ft_printf <S2SV_ModEnd> ( "Number<S2SV_blank>of<S2SV_blank>connected<S2SV_blank>players:<S2SV_blank>%d\\n" , |
802 | CWE-000 static void nimf_system_keyboard_reset ( NimfEngine * engine , NimfServiceIM * target ) { g_debug ( G_STRLOC ":<S2SV_blank>%s" , G_STRFUNC ) ; <S2SV_StartBug> xkb_compose_state_reset ( NIMF_SYSTEM_KEYBOARD ( engine ) -> xkb_compose_state ) ; <S2SV_EndBug> nimf_system_keyboard_update_preedit ( engine , target , g_strdup ( "" ) ) ; } | <S2SV_ModStart> G_STRFUNC ) ; NimfSystemKeyboard * keyboard = <S2SV_ModEnd> NIMF_SYSTEM_KEYBOARD ( engine <S2SV_ModStart> ( engine ) ; if ( G_UNLIKELY ( ! keyboard -> xkb_compose_table ) ) return ; xkb_compose_state_reset ( keyboard |
803 | CWE-000 <S2SV_StartBug> static void ips_putq_wait_tail ( ips_wait_queue_t * queue , struct scsi_cmnd * item ) <S2SV_EndBug> { METHOD_TRACE ( "ips_putq_wait_tail" , 1 ) ; if ( ! item ) return ; item -> host_scribble = NULL ; if ( queue -> tail ) queue -> tail -> host_scribble = ( char * ) item ; queue -> tail = item ; if ( ! queue -> head ) queue -> head = item ; queue -> count ++ ; } | <S2SV_ModStart> void ips_putq_wait_tail ( ips_wait_queue_entry_t <S2SV_ModEnd> * queue , |
804 | CWE-000 int map_and_register_buf ( struct msm_vidc_inst * inst , struct v4l2_buffer * b ) { struct buffer_info * binfo = NULL ; struct buffer_info * temp = NULL ; int plane = 0 ; int i = 0 , rc = 0 ; struct msm_smem * same_fd_handle = NULL ; if ( ! b || ! inst ) { dprintk ( VIDC_ERR , "%s:<S2SV_blank>invalid<S2SV_blank>input\\n" , __func__ ) ; return - EINVAL ; } binfo = kzalloc ( sizeof ( * binfo ) , GFP_KERNEL ) ; if ( ! binfo ) { dprintk ( VIDC_ERR , "Out<S2SV_blank>of<S2SV_blank>memory\\n" ) ; rc = - ENOMEM ; goto exit ; } if ( b -> length > VIDEO_MAX_PLANES ) { dprintk ( VIDC_ERR , "Num<S2SV_blank>planes<S2SV_blank>exceeds<S2SV_blank>max:<S2SV_blank>%d,<S2SV_blank>%d\\n" , b -> length , VIDEO_MAX_PLANES ) ; rc = - EINVAL ; goto exit ; } dprintk ( VIDC_DBG , "[MAP]<S2SV_blank>Create<S2SV_blank>binfo<S2SV_blank>=<S2SV_blank>%pK<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>type<S2SV_blank>=<S2SV_blank>%d\\n" , binfo , b -> m . planes [ 0 ] . reserved [ 0 ] , b -> type ) ; for ( i = 0 ; i < b -> length ; ++ i ) { if ( EXTRADATA_IDX ( b -> length ) && ( i == EXTRADATA_IDX ( b -> length ) ) && ! b -> m . planes [ i ] . length ) { continue ; } mutex_lock ( & inst -> registeredbufs . lock ) ; temp = get_registered_buf ( inst , b , i , & plane ) ; if ( temp && ! is_dynamic_output_buffer_mode ( b , inst ) ) { dprintk ( VIDC_DBG , "This<S2SV_blank>memory<S2SV_blank>region<S2SV_blank>has<S2SV_blank>already<S2SV_blank>been<S2SV_blank>prepared\\n" ) ; rc = - EINVAL ; } if ( temp && is_dynamic_output_buffer_mode ( b , inst ) && ( i == 0 ) ) { dprintk ( VIDC_DBG , "[MAP]<S2SV_blank>Buffer<S2SV_blank>already<S2SV_blank>prepared\\n" ) ; rc = buf_ref_get ( inst , temp ) ; if ( rc > 0 ) { save_v4l2_buffer ( b , temp ) ; rc = - EEXIST ; } } mutex_unlock ( & inst -> registeredbufs . lock ) ; if ( rc < 0 ) goto exit ; <S2SV_StartBug> same_fd_handle = get_same_fd_buffer ( & inst -> registeredbufs , <S2SV_EndBug> b -> m . planes [ i ] . reserved [ 0 ] ) ; populate_buf_info ( binfo , b , i ) ; if ( same_fd_handle ) { binfo -> device_addr [ i ] = same_fd_handle -> device_addr + binfo -> buff_off [ i ] ; b -> m . planes [ i ] . m . userptr = binfo -> device_addr [ i ] ; binfo -> mapped [ i ] = false ; binfo -> handle [ i ] = same_fd_handle ; } else { if ( inst -> map_output_buffer ) { binfo -> handle [ i ] = map_buffer ( inst , & b -> m . planes [ i ] , get_hal_buffer_type ( inst , b ) ) ; if ( ! binfo -> handle [ i ] ) { rc = - EINVAL ; goto exit ; } binfo -> mapped [ i ] = true ; binfo -> device_addr [ i ] = binfo -> handle [ i ] -> device_addr + binfo -> buff_off [ i ] ; b -> m . planes [ i ] . m . userptr = binfo -> device_addr [ i ] ; } else { binfo -> device_addr [ i ] = b -> m . planes [ i ] . m . userptr ; } } if ( ( i == 0 ) && is_dynamic_output_buffer_mode ( b , inst ) ) { rc = buf_ref_get ( inst , binfo ) ; if ( rc < 0 ) goto exit ; } dprintk ( VIDC_DBG , "%s:<S2SV_blank>[MAP]<S2SV_blank>binfo<S2SV_blank>=<S2SV_blank>%pK,<S2SV_blank>handle[%d]<S2SV_blank>=<S2SV_blank>%pK,<S2SV_blank>device_addr<S2SV_blank>=<S2SV_blank>0x%x,<S2SV_blank>fd<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>offset<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>mapped<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , binfo , i , binfo -> handle [ i ] , binfo -> device_addr [ i ] , binfo -> fd [ i ] , binfo -> buff_off [ i ] , binfo -> mapped [ i ] ) ; } mutex_lock ( & inst -> registeredbufs . lock ) ; list_add_tail ( & binfo -> list , & inst -> registeredbufs . list ) ; mutex_unlock ( & inst -> registeredbufs . lock ) ; return 0 ; exit : kfree ( binfo ) ; return rc ; } | <S2SV_ModStart> goto exit ; if ( ! is_dynamic_output_buffer_mode ( b , inst ) ) <S2SV_ModStart> = get_same_fd_buffer ( inst , <S2SV_ModStart> & inst -> registered_bufs <S2SV_ModEnd> , b -> |
805 | CWE-000 int main ( int argc , char * argv [ ] ) { struct args args ; FILE * dst , * src ; args = parse_args ( argc , argv ) ; dst = ( args . modes & STDOUT_MODE ) ? stdout : fopen ( args . output , "w" ) ; src = fopen ( args . input , "r" ) ; if ( ! src ) { puts ( "Erreur<S2SV_blank>lors<S2SV_blank>de<S2SV_blank>la<S2SV_blank>lecture<S2SV_blank>du<S2SV_blank>fichier<S2SV_blank>source." ) ; return EXIT_FAILURE ; } if ( args . modes & ENCODE_MODE ) lzw_encode ( dst , src ) ; else lzw_decode ( dst , src ) ; clean_args ( & args ) ; <S2SV_StartBug> fclose ( dst ) ; <S2SV_EndBug> fclose ( src ) ; return EXIT_SUCCESS ; } | <S2SV_ModStart> args ) ; if ( ! ( args . modes & STDOUT_MODE ) ) |
806 | CWE-000 void * adios_mpi_amr_do_open_thread ( void * param ) { <S2SV_StartBug> ADIOST_CALLBACK_ENTER ( adiost_event_thread , NULL , __func__ ) ; <S2SV_EndBug> struct adios_MPI_thread_data_open * td = ( struct adios_MPI_thread_data_open * ) param ; int err ; unlink ( td -> md -> subfile_name ) ; if ( td -> parameters ) { adios_mpi_amr_set_striping_unit ( td -> md , td -> parameters ) ; } err = MPI_File_open ( MPI_COMM_SELF , td -> md -> subfile_name , MPI_MODE_WRONLY | MPI_MODE_CREATE , MPI_INFO_NULL , & td -> md -> fh ) ; if ( err != MPI_SUCCESS ) { char e [ MPI_MAX_ERROR_STRING ] ; int len = 0 ; memset ( e , 0 , MPI_MAX_ERROR_STRING ) ; MPI_Error_string ( err , e , & len ) ; adios_error ( err_file_open_error , "MPI_AMR<S2SV_blank>method:<S2SV_blank>MPI<S2SV_blank>open<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>%s:<S2SV_blank>\'%s\'\\n" , td -> md -> subfile_name , e ) ; } <S2SV_StartBug> ADIOST_CALLBACK_EXIT ( adiost_event_thread , NULL , __func__ ) ; <S2SV_EndBug> return NULL ; } | <S2SV_ModStart> param ) { <S2SV_ModEnd> struct adios_MPI_thread_data_open * <S2SV_ModStart> ) ; } <S2SV_ModEnd> return NULL ; |
807 | CWE-000 static int ov5640_s_frame_interval ( struct v4l2_subdev * sd , struct v4l2_subdev_frame_interval * fi ) { struct ov5640_dev * sensor = to_ov5640_dev ( sd ) ; const struct ov5640_mode_info * mode ; int frame_rate , ret = 0 ; if ( fi -> pad != 0 ) return - EINVAL ; mutex_lock ( & sensor -> lock ) ; if ( sensor -> streaming ) { ret = - EBUSY ; goto out ; } mode = sensor -> current_mode ; frame_rate = ov5640_try_frame_interval ( sensor , & fi -> interval , mode -> width , mode -> height ) ; if ( frame_rate < 0 ) frame_rate = OV5640_15_FPS ; sensor -> current_fr = frame_rate ; sensor -> frame_interval = fi -> interval ; <S2SV_StartBug> sensor -> pending_mode_change = true ; <S2SV_EndBug> out : mutex_unlock ( & sensor -> lock ) ; return ret ; } | <S2SV_ModStart> ; sensor -> current_mode = ov5640_find_mode ( sensor , frame_rate , mode -> width , mode -> height , true ) ; sensor -> |
808 | CWE-000 <S2SV_StartBug> static int magicmouse_input_configured ( struct hid_device * hdev , <S2SV_EndBug> struct hid_input * hi ) { struct magicmouse_sc * msc = hid_get_drvdata ( hdev ) ; <S2SV_StartBug> int ret = magicmouse_setup_input ( msc -> input , hdev ) ; <S2SV_EndBug> if ( ret ) { hid_err ( hdev , "magicmouse<S2SV_blank>setup<S2SV_blank>input<S2SV_blank>failed<S2SV_blank>(%d)\\n" , ret ) ; msc -> input = NULL ; } <S2SV_StartBug> return ret ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static void <S2SV_ModEnd> magicmouse_input_configured ( struct <S2SV_ModStart> ) ; int ret = 0 ; <S2SV_ModStart> NULL ; } <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
809 | CWE-000 static void burro_app_open ( GApplication * app , GFile * * files , gint n_files , const gchar * hint ) { BurroAppWindow * win ; if ( n_files != 1 ) <S2SV_StartBug> g_warning ( "Asked<S2SV_blank>to<S2SV_blank>open<S2SV_blank>%d<S2SV_blank>files,<S2SV_blank>but,<S2SV_blank>can<S2SV_blank>only<S2SV_blank>open<S2SV_blank>1" , n_files ) ; <S2SV_EndBug> win = burro_app_window_new ( BURRO_APP ( app ) ) ; burro_app_window_open ( win , files [ 0 ] ) ; gtk_window_present ( GTK_WINDOW ( win ) ) ; } | <S2SV_ModStart> != 1 ) { fprintf ( stderr , "Too<S2SV_blank>many<S2SV_blank>command-line<S2SV_blank>arguments\\n" ) ; return ; } <S2SV_ModEnd> win = burro_app_window_new |
810 | CWE-000 struct dp_packet * dp_packet_clone_with_headroom ( const struct dp_packet * buffer , size_t headroom ) { struct dp_packet * new_buffer ; new_buffer = dp_packet_clone_data_with_headroom ( dp_packet_data ( buffer ) , dp_packet_size ( buffer ) , headroom ) ; memcpy ( & new_buffer -> l2_pad_size , & buffer -> l2_pad_size , sizeof ( struct dp_packet ) - offsetof ( struct dp_packet , l2_pad_size ) ) ; # ifdef DPDK_NETDEV new_buffer -> mbuf . ol_flags = buffer -> mbuf . ol_flags ; <S2SV_StartBug> # else <S2SV_EndBug> new_buffer -> rss_hash_valid = buffer -> rss_hash_valid ; # endif <S2SV_StartBug> if ( dp_packet_rss_valid ( new_buffer ) ) { <S2SV_EndBug> <S2SV_StartBug> # ifdef DPDK_NETDEV <S2SV_EndBug> new_buffer -> mbuf . hash . rss = buffer -> mbuf . hash . rss ; # else new_buffer -> rss_hash = buffer -> rss_hash ; # endif } return new_buffer ; } | <S2SV_ModStart> ol_flags ; # <S2SV_ModEnd> endif if ( <S2SV_ModStart> ( dp_packet_rss_valid ( buffer <S2SV_ModEnd> ) ) { <S2SV_ModStart> ) ) { dp_packet_set_rss_hash ( new_buffer , dp_packet_get_rss_hash ( buffer ) ) ; <S2SV_ModEnd> } return new_buffer |
811 | CWE-000 int list_destroy ( list_t handle ) { struct list_item * curr , * next ; ASSERT_HANDLE_VALID ( handle ) ; if ( handle -> base != NULL ) { curr = handle -> base ; <S2SV_StartBug> while ( curr -> next != handle -> base ) { <S2SV_EndBug> if ( handle -> dtor != NULL ) handle -> dtor ( curr -> data ) ; next = curr -> next ; free ( curr ) ; curr = next ; <S2SV_StartBug> } <S2SV_EndBug> } free ( handle ) ; return UTILS_OK ; } | <S2SV_ModStart> -> base ; do <S2SV_ModEnd> { if ( <S2SV_ModStart> next ; } while ( curr != handle -> base ) ; |
812 | CWE-000 static void si_bind_gs_shader ( struct pipe_context * ctx , void * state ) { struct si_context * sctx = ( struct si_context * ) ctx ; struct si_shader_selector * sel = state ; bool enable_changed = ! ! sctx -> gs_shader . cso != ! ! sel ; if ( sctx -> gs_shader . cso == sel ) return ; sctx -> gs_shader . cso = sel ; sctx -> gs_shader . current = sel ? sel -> first_variant : NULL ; sctx -> ia_multi_vgt_param_key . u . uses_gs = sel != NULL ; sctx -> do_update_shaders = true ; si_mark_atom_dirty ( sctx , & sctx -> clip_regs ) ; sctx -> last_rast_prim = - 1 ; <S2SV_StartBug> if ( enable_changed ) <S2SV_EndBug> <S2SV_StartBug> si_shader_change_notify ( sctx ) ; <S2SV_EndBug> r600_update_vs_writes_viewport_index ( & sctx -> b , si_get_vs_info ( sctx ) ) ; } | <S2SV_ModStart> ( enable_changed ) { <S2SV_ModStart> sctx ) ; if ( sctx -> ia_multi_vgt_param_key . u . uses_tess ) si_update_tcs_tes_uses_prim_id ( sctx ) ; } |
813 | CWE-000 crypto_t * crypto_init ( const char * password , const char * key , const char * method ) { int i , m = - 1 ; if ( sodium_init ( ) == - 1 ) { FATAL ( "Failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>sodium" ) ; } <S2SV_StartBug> cache_create ( & nonce_cache , 1024 , NULL ) ; <S2SV_EndBug> if ( method != NULL ) { for ( i = 0 ; i < STREAM_CIPHER_NUM ; i ++ ) if ( strcmp ( method , supported_stream_ciphers [ i ] ) == 0 ) { m = i ; break ; } if ( m != - 1 ) { cipher_t * cipher = stream_init ( password , key , method ) ; if ( cipher == NULL ) return NULL ; crypto_t * crypto = ( crypto_t * ) malloc ( sizeof ( crypto_t ) ) ; crypto_t tmp = { . cipher = cipher , . encrypt_all = & stream_encrypt_all , . decrypt_all = & stream_decrypt_all , . encrypt = & stream_encrypt , . decrypt = & stream_decrypt , . ctx_init = & stream_ctx_init , . ctx_release = & stream_ctx_release , } ; memcpy ( crypto , & tmp , sizeof ( crypto_t ) ) ; return crypto ; } for ( i = 0 ; i < AEAD_CIPHER_NUM ; i ++ ) if ( strcmp ( method , supported_aead_ciphers [ i ] ) == 0 ) { m = i ; break ; } if ( m != - 1 ) { cipher_t * cipher = aead_init ( password , key , method ) ; if ( cipher == NULL ) return NULL ; crypto_t * crypto = ( crypto_t * ) ss_malloc ( sizeof ( crypto_t ) ) ; crypto_t tmp = { . cipher = cipher , . encrypt_all = & aead_encrypt_all , . decrypt_all = & aead_decrypt_all , . encrypt = & aead_encrypt , . decrypt = & aead_decrypt , . ctx_init = & aead_ctx_init , . ctx_release = & aead_ctx_release , } ; memcpy ( crypto , & tmp , sizeof ( crypto_t ) ) ; return crypto ; } } LOGE ( "invalid<S2SV_blank>cipher<S2SV_blank>name:<S2SV_blank>%s" , method ) ; return NULL ; } | <S2SV_ModStart> ) ; } # ifdef MODULE_REMOTE ppbloom_init ( 1000000 , 0.00001 ) ; # else ppbloom_init ( 100000 , 0.0000001 ) ; # endif <S2SV_ModEnd> if ( method |
814 | CWE-000 static void TranslateInputEOL ( ChannelState * statePtr , char * dstStart , const char * srcStart , int * dstLenPtr , int * srcLenPtr ) { const char * eof = NULL ; int dstLen = * dstLenPtr ; int srcLen = * srcLenPtr ; int inEofChar = statePtr -> inEofChar ; switch ( statePtr -> inputTranslation ) { case TCL_TRANSLATE_LF : case TCL_TRANSLATE_CR : if ( srcLen > dstLen ) { srcLen = dstLen ; } break ; default : if ( srcLen > 2 * dstLen ) { srcLen = 2 * dstLen ; } break ; } if ( inEofChar != '\\0' ) { if ( ( eof = memchr ( srcStart , inEofChar , srcLen ) ) ) { srcLen = eof - srcStart ; } } switch ( statePtr -> inputTranslation ) { case TCL_TRANSLATE_LF : case TCL_TRANSLATE_CR : if ( dstStart != srcStart ) { memcpy ( dstStart , srcStart , ( size_t ) srcLen ) ; } if ( statePtr -> inputTranslation == TCL_TRANSLATE_CR ) { char * dst = dstStart ; char * dstEnd = dstStart + srcLen ; while ( ( dst = memchr ( dst , '\\r' , dstEnd - dst ) ) ) { * dst ++ = '\\n' ; } } dstLen = srcLen ; break ; case TCL_TRANSLATE_CRLF : { const char * crFound , * src = srcStart ; char * dst = dstStart ; int lesser = ( dstLen < srcLen ) ? dstLen : srcLen ; while ( ( crFound = memchr ( src , '\\r' , lesser ) ) ) { int numBytes = crFound - src ; memmove ( dst , src , numBytes ) ; dst += numBytes ; src += numBytes ; dstLen -= numBytes ; srcLen -= numBytes ; if ( srcLen == 1 ) { lesser = 0 ; break ; } if ( src [ 1 ] == '\\n' ) { * dst ++ = '\\n' ; srcLen -= 2 ; src += 2 ; } else { * dst ++ = '\\r' ; srcLen -- ; src ++ ; } <S2SV_StartBug> dstLen ++ ; <S2SV_EndBug> lesser = ( dstLen < srcLen ) ? dstLen : srcLen ; } memmove ( dst , src , lesser ) ; srcLen = src + lesser - srcStart ; dstLen = dst + lesser - dstStart ; break ; } case TCL_TRANSLATE_AUTO : { const char * srcEnd = srcStart + srcLen ; const char * dstEnd = dstStart + dstLen ; const char * src = srcStart ; char * dst = dstStart ; if ( ( statePtr -> flags & INPUT_SAW_CR ) && srcLen ) { if ( * src == '\\n' ) { src ++ ; } ResetFlag ( statePtr , INPUT_SAW_CR ) ; } for ( ; dst < dstEnd && src < srcEnd ; ) { if ( * src == '\\r' ) { src ++ ; if ( src == srcEnd ) { SetFlag ( statePtr , INPUT_SAW_CR ) ; } else if ( * src == '\\n' ) { src ++ ; } * dst ++ = '\\n' ; } else { * dst ++ = * src ++ ; } } srcLen = src - srcStart ; dstLen = dst - dstStart ; break ; } default : Tcl_Panic ( "unknown<S2SV_blank>input<S2SV_blank>translation<S2SV_blank>%d" , statePtr -> inputTranslation ) ; } * dstLenPtr = dstLen ; * srcLenPtr = srcLen ; if ( srcStart + srcLen == eof ) { SetFlag ( statePtr , CHANNEL_EOF | CHANNEL_STICKY_EOF ) ; statePtr -> inputEncodingFlags |= TCL_ENCODING_END ; ResetFlag ( statePtr , INPUT_SAW_CR ) ; } } | <S2SV_ModStart> ; } dstLen -- <S2SV_ModEnd> ; lesser = |
815 | CWE-000 void trap ( struct Trapframe * tf ) { asm volatile ( "cld" : : : "cc" ) ; assert ( ! ( read_eflags ( ) & FL_IF ) ) ; cprintf ( "Incoming<S2SV_blank>TRAP<S2SV_blank>frame<S2SV_blank>at<S2SV_blank>%p\\n" , tf ) ; if ( ( tf -> tf_cs & 3 ) == 3 ) { assert ( curenv ) ; curenv -> env_tf = * tf ; tf = & curenv -> env_tf ; } last_tf = tf ; trap_dispatch ( tf ) ; if ( enable_single_step ( ) ) <S2SV_StartBug> return ; <S2SV_EndBug> assert ( curenv && curenv -> env_status == ENV_RUNNING ) ; env_run ( curenv ) ; } | <S2SV_ModStart> ( ) ) { cprintf ( "yeah!\\n" ) ; return ; } <S2SV_ModEnd> assert ( curenv |
816 | CWE-000 PHP_METHOD ( Collection , last ) { zend_fcall_info fci ; zend_fcall_info_cache fcc ; ZEND_PARSE_PARAMETERS_START ( 0 , 1 ) Z_PARAM_OPTIONAL Z_PARAM_FUNC ( fci , fcc ) ZEND_PARSE_PARAMETERS_END ( ) ; zend_array * current = COLLECTION_FETCH_EX ( ) ; if ( zend_hash_num_elements ( current ) == 0 ) RETURN_NULL ( ) ; if ( EX_NUM_ARGS ( ) == 0 ) { <S2SV_StartBug> zend_hash_internal_pointer_end ( current ) ; <S2SV_EndBug> <S2SV_StartBug> RETVAL_ZVAL ( zend_hash_get_current_data ( current ) , 1 , 0 ) ; <S2SV_EndBug> zend_hash_internal_pointer_reset ( current ) ; return ; } INIT_FCI ( ) ; ZEND_HASH_REVERSE_FOREACH_BUCKET ( current , Bucket * bucket ) CALLBACK_KEYVAL_INVOKE ( params , bucket ) ; if ( zend_is_true ( & retval ) ) RETURN_ZVAL ( & bucket -> val , 1 , 0 ) ; ZEND_HASH_FOREACH_END ( ) ; RETVAL_NULL ( ) ; } | <S2SV_ModStart> 0 ) { HashPosition pos = current -> nNumUsed ; while ( pos >= 0 && Z_ISUNDEF ( current -> arData [ pos ] . val ) ) -- pos ; RETURN_ZVAL ( & current -> arData [ pos ] . val <S2SV_ModEnd> , 1 , <S2SV_ModStart> , 0 ) <S2SV_ModEnd> ; } INIT_FCI |
817 | CWE-000 static void qede_tpa_start ( struct qede_dev * edev , struct qede_rx_queue * rxq , struct eth_fast_path_rx_tpa_start_cqe * cqe ) { struct qede_agg_info * tpa_info = & rxq -> tpa_info [ cqe -> tpa_agg_index ] ; struct eth_rx_bd * rx_bd_cons = qed_chain_consume ( & rxq -> rx_bd_ring ) ; struct eth_rx_bd * rx_bd_prod = qed_chain_produce ( & rxq -> rx_bd_ring ) ; struct sw_rx_data * replace_buf = & tpa_info -> replace_buf ; dma_addr_t mapping = tpa_info -> replace_buf_mapping ; struct sw_rx_data * sw_rx_data_cons ; struct sw_rx_data * sw_rx_data_prod ; enum pkt_hash_types rxhash_type ; u32 rxhash ; sw_rx_data_cons = & rxq -> sw_rx_ring [ rxq -> sw_rx_cons & NUM_RX_BDS_MAX ] ; sw_rx_data_prod = & rxq -> sw_rx_ring [ rxq -> sw_rx_prod & NUM_RX_BDS_MAX ] ; dma_unmap_addr_set ( sw_rx_data_prod , mapping , dma_unmap_addr ( replace_buf , mapping ) ) ; sw_rx_data_prod -> data = replace_buf -> data ; rx_bd_prod -> addr . hi = cpu_to_le32 ( upper_32_bits ( mapping ) ) ; rx_bd_prod -> addr . lo = cpu_to_le32 ( lower_32_bits ( mapping ) ) ; sw_rx_data_prod -> page_offset = replace_buf -> page_offset ; rxq -> sw_rx_prod ++ ; tpa_info -> start_buf = * sw_rx_data_cons ; mapping = HILO_U64 ( le32_to_cpu ( rx_bd_cons -> addr . hi ) , le32_to_cpu ( rx_bd_cons -> addr . lo ) ) ; tpa_info -> start_buf_mapping = mapping ; rxq -> sw_rx_cons ++ ; tpa_info -> skb = netdev_alloc_skb ( edev -> ndev , le16_to_cpu ( cqe -> len_on_first_bd ) ) ; if ( unlikely ( ! tpa_info -> skb ) ) { <S2SV_StartBug> tpa_info -> agg_state = QEDE_AGG_STATE_ERROR ; <S2SV_EndBug> <S2SV_StartBug> return ; <S2SV_EndBug> } skb_put ( tpa_info -> skb , le16_to_cpu ( cqe -> len_on_first_bd ) ) ; memcpy ( & tpa_info -> start_cqe , cqe , sizeof ( tpa_info -> start_cqe ) ) ; tpa_info -> frag_id = 0 ; tpa_info -> agg_state = QEDE_AGG_STATE_START ; rxhash = qede_get_rxhash ( edev , cqe -> bitfields , cqe -> rss_hash , & rxhash_type ) ; skb_set_hash ( tpa_info -> skb , rxhash , rxhash_type ) ; if ( ( le16_to_cpu ( cqe -> pars_flags . flags ) >> PARSING_AND_ERR_FLAGS_TAG8021QEXIST_SHIFT ) & PARSING_AND_ERR_FLAGS_TAG8021QEXIST_MASK ) tpa_info -> vlan_tag = le16_to_cpu ( cqe -> vlan_tag ) ; else tpa_info -> vlan_tag = 0 ; <S2SV_StartBug> qede_set_gro_params ( edev , tpa_info -> skb , cqe ) ; <S2SV_EndBug> if ( likely ( cqe -> ext_bd_len_list [ 0 ] ) ) qede_fill_frag_skb ( edev , rxq , cqe -> tpa_agg_index , le16_to_cpu ( cqe -> ext_bd_len_list [ 0 ] ) ) ; if ( unlikely ( cqe -> ext_bd_len_list [ 1 ] ) ) { DP_ERR ( edev , "Unlikely<S2SV_blank>-<S2SV_blank>got<S2SV_blank>a<S2SV_blank>TPA<S2SV_blank>aggregation<S2SV_blank>with<S2SV_blank>more<S2SV_blank>than<S2SV_blank>one<S2SV_blank>ext_bd_len_list<S2SV_blank>entry<S2SV_blank>in<S2SV_blank>the<S2SV_blank>TPA<S2SV_blank>start\\n" ) ; tpa_info -> agg_state = QEDE_AGG_STATE_ERROR ; } } | <S2SV_ModStart> ) ) { DP_NOTICE ( edev , "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>SKB<S2SV_blank>for<S2SV_blank>gro\\n" ) ; <S2SV_ModStart> = QEDE_AGG_STATE_ERROR ; goto cons_buf <S2SV_ModEnd> ; } skb_put <S2SV_ModStart> cqe ) ; cons_buf : |
818 | CWE-000 static int nbd_co_send_request ( BlockDriverState * bs , NBDRequest * request , QEMUIOVector * qiov ) { NBDClientSession * s = nbd_get_client_session ( bs ) ; int rc , ret , i ; qemu_co_mutex_lock ( & s -> send_mutex ) ; <S2SV_StartBug> for ( i = 0 ; i < MAX_NBD_REQUESTS ; i ++ ) { <S2SV_EndBug> if ( s -> recv_coroutine [ i ] == NULL ) { s -> recv_coroutine [ i ] = qemu_coroutine_self ( ) ; break ; } } g_assert ( qemu_in_coroutine ( ) ) ; assert ( i < MAX_NBD_REQUESTS ) ; request -> handle = INDEX_TO_HANDLE ( s , i ) ; if ( ! s -> ioc ) { qemu_co_mutex_unlock ( & s -> send_mutex ) ; return - EPIPE ; } if ( qiov ) { qio_channel_set_cork ( s -> ioc , true ) ; rc = nbd_send_request ( s -> ioc , request ) ; if ( rc >= 0 ) { ret = nbd_wr_syncv ( s -> ioc , qiov -> iov , qiov -> niov , request -> len , false , NULL ) ; if ( ret != request -> len ) { rc = - EIO ; } } qio_channel_set_cork ( s -> ioc , false ) ; } else { rc = nbd_send_request ( s -> ioc , request ) ; } qemu_co_mutex_unlock ( & s -> send_mutex ) ; return rc ; } | <S2SV_ModStart> send_mutex ) ; while ( s -> in_flight == MAX_NBD_REQUESTS ) { qemu_co_queue_wait ( & s -> free_sema , & s -> send_mutex ) ; } s -> in_flight ++ ; |
819 | CWE-000 int32_t getFifoScom ( SCOM_Trgt_t * i_target , uint64_t i_addr , uint64_t * o_data ) { uint32_t l_rc = SUCCESS ; struct fifoGetScomRequest l_fifoRequest ; struct fifoGetScomResponse l_fifoResponse ; l_fifoRequest . wordCnt = GET_SCOM_REQUEST_WORD_CNT ; l_fifoRequest . reserved = 0 ; l_fifoRequest . commandClass = SBE_FIFO_CLASS_SCOM_ACCESS ; l_fifoRequest . command = SBE_FIFO_CMD_GET_SCOM ; l_fifoRequest . address = i_addr ; l_rc = performFifoChipOp ( i_target , ( uint32_t * ) & l_fifoRequest , ( uint32_t * ) & l_fifoResponse , sizeof ( struct fifoGetScomResponse ) ) ; <S2SV_StartBug> * o_data = l_fifoResponse . data ; <S2SV_EndBug> return l_rc ; } | <S2SV_ModStart> ) ) ; if ( l_rc != SUCCESS ) { uint32_t l_data = 0xDEAD ; putfsi ( i_target , 0x2450 , l_data ) ; } |
820 | CWE-000 void ft_collect_tets ( t_tet * tet , int fd , char * line , unsigned char * index ) { int ret ; unsigned char i ; unsigned char line_tet ; i = 1 ; line_tet = 0 ; ret = 1 ; while ( ( ret = get_next_line ( fd , & line ) ) == 1 ) { if ( i ++ % 5 == 0 ) ( line && * line ) ? ft_exit ( ) : ( line_tet = 0 ) ; else if ( * index >= 26 || ! line || ft_strlen ( line ) != 4 ) ft_exit ( ) ; else ft_cp_into_tet ( tet , * index , line_tet ++ , line ) ; if ( line_tet == 4 ) { ft_justify_tet ( tet , * index ) ; ft_area ( tet , * index ) ; ( * index ) ++ ; } ft_strdel ( & line ) ; } ft_strdel ( & line ) ; <S2SV_StartBug> if ( ret == - 1 || ! * index || i % * index ) <S2SV_EndBug> ft_exit ( ) ; } | <S2SV_ModStart> % * index || i % 5 |
821 | CWE-000 CanMsg * can_rx_queue_get ( void ) { <S2SV_StartBug> if ( can_rx_count == 0 ) <S2SV_EndBug> return NULL ; return & ( can_rx_queue [ can_rx_tail ] ) ; } | <S2SV_ModStart> { if ( can_rx_head == can_rx_tail <S2SV_ModEnd> ) return NULL |
822 | CWE-000 int LUKS2_generate_hdr ( struct crypt_device * cd , struct luks2_hdr * hdr , const struct volume_key * vk , const char * cipherName , const char * cipherMode , const char * integrity , const char * uuid , unsigned int sector_size , unsigned int alignPayload , unsigned int alignOffset , int detached_metadata_device ) { struct json_object * jobj_segment , * jobj_integrity , * jobj_keyslots , * jobj_segments , * jobj_config ; char num [ 24 ] , cipher [ 128 ] ; uint64_t offset , json_size , keyslots_size ; uuid_t partitionUuid ; int digest ; hdr -> hdr_size = LUKS2_HDR_16K_LEN ; hdr -> seqid = 1 ; hdr -> version = 2 ; memset ( hdr -> label , 0 , LUKS2_LABEL_L ) ; strcpy ( hdr -> checksum_alg , "sha256" ) ; crypt_random_get ( NULL , ( char * ) hdr -> salt1 , LUKS2_SALT_L , CRYPT_RND_SALT ) ; crypt_random_get ( NULL , ( char * ) hdr -> salt2 , LUKS2_SALT_L , CRYPT_RND_SALT ) ; if ( uuid && uuid_parse ( uuid , partitionUuid ) == - 1 ) { log_err ( cd , _ ( "Wrong<S2SV_blank>LUKS<S2SV_blank>UUID<S2SV_blank>format<S2SV_blank>provided.\\n" ) ) ; return - EINVAL ; } if ( ! uuid ) uuid_generate ( partitionUuid ) ; uuid_unparse ( partitionUuid , hdr -> uuid ) ; if ( * cipherMode != '\\0' ) snprintf ( cipher , sizeof ( cipher ) , "%s-%s" , cipherName , cipherMode ) ; else snprintf ( cipher , sizeof ( cipher ) , "%s" , cipherName ) ; hdr -> jobj = json_object_new_object ( ) ; jobj_keyslots = json_object_new_object ( ) ; json_object_object_add ( hdr -> jobj , "keyslots" , jobj_keyslots ) ; json_object_object_add ( hdr -> jobj , "tokens" , json_object_new_object ( ) ) ; jobj_segments = json_object_new_object ( ) ; json_object_object_add ( hdr -> jobj , "segments" , jobj_segments ) ; json_object_object_add ( hdr -> jobj , "digests" , json_object_new_object ( ) ) ; jobj_config = json_object_new_object ( ) ; json_object_object_add ( hdr -> jobj , "config" , jobj_config ) ; digest = LUKS2_digest_create ( cd , "pbkdf2" , hdr , vk ) ; if ( digest < 0 ) { json_object_put ( hdr -> jobj ) ; hdr -> jobj = NULL ; return - EINVAL ; } <S2SV_StartBug> if ( LUKS2_digest_segment_assign ( cd , hdr , CRYPT_DEFAULT_SEGMENT , digest , 1 , 0 ) < 0 ) { <S2SV_EndBug> json_object_put ( hdr -> jobj ) ; hdr -> jobj = NULL ; return - EINVAL ; } if ( detached_metadata_device ) offset = ( uint64_t ) alignPayload * sector_size ; else { offset = size_round_up ( LUKS2_HDR_DEFAULT_LEN , ( size_t ) alignPayload * sector_size ) ; offset += alignOffset ; } jobj_segment = LUKS2_segment_create ( "crypt" , offset , 0 , NULL , cipher , sector_size , 0 ) ; if ( integrity ) { jobj_integrity = json_object_new_object ( ) ; json_object_object_add ( jobj_integrity , "type" , json_object_new_string ( integrity ) ) ; json_object_object_add ( jobj_integrity , "journal_encryption" , json_object_new_string ( "none" ) ) ; json_object_object_add ( jobj_integrity , "journal_integrity" , json_object_new_string ( "none" ) ) ; json_object_object_add ( jobj_segment , "integrity" , jobj_integrity ) ; } <S2SV_StartBug> snprintf ( num , sizeof ( num ) , "%u" , CRYPT_DEFAULT_SEGMENT ) ; <S2SV_EndBug> json_object_object_add ( jobj_segments , num , jobj_segment ) ; json_size = hdr -> hdr_size - LUKS2_HDR_BIN_LEN ; json_object_object_add ( jobj_config , "json_size" , json_object_new_uint64 ( json_size ) ) ; if ( detached_metadata_device ) keyslots_size = LUKS2_HDR_DEFAULT_LEN - get_min_offset ( hdr ) ; else keyslots_size = offset - get_min_offset ( hdr ) ; if ( keyslots_size > LUKS2_MAX_KEYSLOTS_SIZE ) keyslots_size = LUKS2_MAX_KEYSLOTS_SIZE ; keyslots_size -= ( keyslots_size % 4096 ) ; json_object_object_add ( jobj_config , "keyslots_size" , json_object_new_uint64 ( keyslots_size ) ) ; JSON_DBG ( hdr -> jobj , "Header<S2SV_blank>JSON" ) ; return 0 ; } | <S2SV_ModStart> , hdr , 0 <S2SV_ModEnd> , digest , <S2SV_ModStart> , "%u" , 0 <S2SV_ModEnd> ) ; json_object_object_add |
823 | CWE-000 static uint64_t arm_load_elf ( struct arm_boot_info * info , uint64_t * pentry , uint64_t * lowaddr , uint64_t * highaddr , int elf_machine , AddressSpace * as ) { bool elf_is64 ; union { Elf32_Ehdr h32 ; Elf64_Ehdr h64 ; } elf_header ; int data_swab = 0 ; bool big_endian ; uint64_t ret = - 1 ; Error * err = NULL ; load_elf_hdr ( info -> kernel_filename , & elf_header , & elf_is64 , & err ) ; <S2SV_StartBug> if ( err ) { <S2SV_EndBug> return ret ; } if ( elf_is64 ) { big_endian = elf_header . h64 . e_ident [ EI_DATA ] == ELFDATA2MSB ; info -> endianness = big_endian ? ARM_ENDIANNESS_BE8 : ARM_ENDIANNESS_LE ; } else { big_endian = elf_header . h32 . e_ident [ EI_DATA ] == ELFDATA2MSB ; if ( big_endian ) { if ( bswap32 ( elf_header . h32 . e_flags ) & EF_ARM_BE8 ) { info -> endianness = ARM_ENDIANNESS_BE8 ; } else { info -> endianness = ARM_ENDIANNESS_BE32 ; data_swab = 2 ; } } else { info -> endianness = ARM_ENDIANNESS_LE ; } } ret = load_elf_as ( info -> kernel_filename , NULL , NULL , pentry , lowaddr , highaddr , big_endian , elf_machine , 1 , data_swab , as ) ; if ( ret <= 0 ) { exit ( 1 ) ; } return ret ; } | <S2SV_ModStart> err ) { error_free ( err ) ; |
824 | CWE-000 static uint64_t arc_free_memory ( void ) { # ifdef _KERNEL # ifdef CONFIG_HIGHMEM struct sysinfo si ; si_meminfo ( & si ) ; return ( ptob ( si . freeram - si . freehigh ) ) ; # else <S2SV_StartBug> # ifdef ZFS_GLOBAL_NODE_PAGE_STATE <S2SV_EndBug> return ( ptob ( nr_free_pages ( ) + <S2SV_StartBug> global_node_page_state ( NR_INACTIVE_FILE ) + <S2SV_EndBug> global_node_page_state ( NR_INACTIVE_ANON ) + global_node_page_state ( NR_SLAB_RECLAIMABLE ) ) ) ; <S2SV_StartBug> # else <S2SV_EndBug> return ( ptob ( nr_free_pages ( ) + global_page_state ( NR_INACTIVE_FILE ) + global_page_state ( NR_INACTIVE_ANON ) + global_page_state ( NR_SLAB_RECLAIMABLE ) ) ) ; # endif # endif # else return ( spa_get_random ( arc_all_memory ( ) * 20 / 100 ) ) ; # endif } | <S2SV_ModStart> ; # else <S2SV_ModEnd> return ( ptob <S2SV_ModStart> ( ) + nr_inactive_file_pages ( ) + nr_inactive_anon_pages ( ) + nr_slab_reclaimable_pages ( <S2SV_ModEnd> ) ) ) <S2SV_ModStart> ) ) ; <S2SV_ModEnd> # endif # |
825 | CWE-000 static void syscall_handler ( struct intr_frame * f ) { int * sys_call_number = ( int * ) f -> esp ; switch ( * sys_call_number ) { case SYS_HALT : { printf ( "Halt!\\n" ) ; shutdown_power_off ( ) ; break ; } case SYS_EXIT : { <S2SV_StartBug> printf ( "Exit<S2SV_blank>call!\\n" ) ; <S2SV_EndBug> process_exit ( ) ; break ; } case SYS_EXEC : { break ; } case SYS_WAIT : { break ; } case SYS_CREATE : { break ; } case SYS_REMOVE : { break ; } case SYS_OPEN : { break ; } case SYS_FILESIZE : { break ; } case SYS_READ : { break ; } case SYS_WRITE : { int * fd = ( int * ) ( f -> esp + 4 ) ; char * buffer = * ( ( char * * ) ( f -> esp + 8 ) ) ; unsigned size = * ( ( unsigned * ) ( f -> esp + 12 ) ) ; int retval = 0 ; if ( * fd == 1 ) { putbuf ( buffer , size ) ; retval = size ; } f -> eax = retval ; break ; } case SYS_SEEK : { break ; } case SYS_TELL : { break ; } case SYS_CLOSE : { break ; } default : { break ; } } } | <S2SV_ModStart> SYS_EXIT : { char * thr_name = thread_name ( ) ; int * exit_code = ( int * ) ( f -> esp + 4 ) ; int retval = * exit_code ; printf ( "%s:<S2SV_blank>exit(%d)\\n" , thr_name , * exit_code ) ; f -> eax = retval <S2SV_ModEnd> ; process_exit ( |
826 | CWE-000 void mandel_key ( t_mandel * m , t_f * f ) { <S2SV_StartBug> m -> ite_max = f -> event . key . ite ; <S2SV_EndBug> f -> event . key . flag = 0 ; <S2SV_StartBug> if ( m -> ite_max == 0 ) <S2SV_EndBug> m -> ite_max = 1 ; } | <S2SV_ModStart> f ) { static double zoom = 50 ; if ( f -> event . key . ite < zoom ) <S2SV_ModStart> m -> ite_max -= f -> event . key . nb_ite ; else m -> ite_max += f -> event . key . nb_ite ; zoom <S2SV_ModStart> key . ite ; if ( m -> ite_max <= 0 ) m -> ite_max = 1 <S2SV_ModStart> = 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
827 | CWE-000 static int readCallback ( uint8_t * buffer , int length , FTDIProgressInfo * progress , void * userdata ) { if ( CONFIG_DUMP_READ ) { <S2SV_StartBug> printf ( "Read<S2SV_blank>%d" , length ) ; <S2SV_EndBug> } if ( exitRequested ) { goto out ; } <S2SV_StartBug> if ( length >= 0 && CONFIG_DUMP_READ ) { <S2SV_EndBug> size_t i = 0 ; for ( i = 0 ; i < length ; i ++ ) { char c = buffer [ i ] ; if ( c > 0x02 ) { printf ( "%c" , c ) ; } } <S2SV_StartBug> } <S2SV_EndBug> <S2SV_StartBug> CONFIG_DUMP_READ = false ; <S2SV_EndBug> if ( progress ) { <S2SV_StartBug> printf ( "\\n" ) ; <S2SV_EndBug> printf ( "Rate<S2SV_blank>%7.3f" , progress -> currentRate / ( 1024.0 * 1024.0 ) ) ; } out : return exitRequested ? 1 : 0 ; } | <S2SV_ModStart> { printf ( "Read<S2SV_blank>%d\\n" <S2SV_ModEnd> , length ) <S2SV_ModStart> if ( length > <S2SV_ModEnd> 0 && CONFIG_DUMP_READ <S2SV_ModStart> ; } } printf ( "\\n" ) ; <S2SV_ModEnd> CONFIG_DUMP_READ = false <S2SV_ModStart> = false ; } <S2SV_ModStart> progress ) { if ( ftdi_setrts ( & ftdic , 1 ) ) { printf ( "setflowctrl<S2SV_blank>error\\n" ) ; error ( ) ; } printf ( "Rate<S2SV_blank>%7.3f\\n" <S2SV_ModEnd> , progress -> |
828 | CWE-000 static int setup_ctx ( CMP_CTX * ctx , ENGINE * e ) { STACK_OF ( X509_CRL ) * all_crls = NULL ; int ret = 0 ; if ( opt_server == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>server<S2SV_blank>address[:port]\\n" ) ; goto err ; } else if ( ! ( server_port = parse_addr ( & opt_server , server_port , "server" ) ) ) { goto err ; } if ( ! CMP_CTX_set1_serverName ( ctx , opt_server ) || ! CMP_CTX_set_serverPort ( ctx , server_port ) || ! CMP_CTX_set1_serverPath ( ctx , opt_path ) ) goto oom ; if ( opt_proxy ) { if ( ! ( proxy_port = parse_addr ( & opt_proxy , proxy_port , "proxy" ) ) ) { goto err ; } if ( ! CMP_CTX_set1_proxyName ( ctx , opt_proxy ) || ! CMP_CTX_set_proxyPort ( ctx , proxy_port ) ) goto oom ; } if ( ! transform_opts ( ) ) goto err ; if ( opt_cmd == CMP_IR || opt_cmd == CMP_CR || opt_cmd == CMP_KUR ) { if ( opt_newkey == NULL && opt_key == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>-key<S2SV_blank>or<S2SV_blank>-newkey<S2SV_blank>to<S2SV_blank>be<S2SV_blank>certified\\n" ) ; goto err ; } if ( opt_certout == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>-certout<S2SV_blank>not<S2SV_blank>given,<S2SV_blank>nowhere<S2SV_blank>to<S2SV_blank>save<S2SV_blank>certificate\\n" ) ; goto err ; } } if ( opt_cmd == CMP_KUR && opt_cert == NULL && opt_oldcert == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>certificate<S2SV_blank>to<S2SV_blank>be<S2SV_blank>updated\\n" ) ; goto err ; } if ( opt_cmd == CMP_RR && opt_oldcert == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>certificate<S2SV_blank>to<S2SV_blank>be<S2SV_blank>revoked\\n" ) ; goto err ; } if ( opt_cmd == CMP_P10CR && opt_csr == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>PKCS#10<S2SV_blank>CSR<S2SV_blank>for<S2SV_blank>p10cr\\n" ) ; goto err ; } if ( opt_recipient == NULL && opt_srvcert == NULL && opt_issuer == NULL && opt_oldcert == NULL && opt_cert == NULL ) { BIO_puts ( bio_err , "warning:<S2SV_blank>missing<S2SV_blank>-recipient,<S2SV_blank>-srvcert,<S2SV_blank>-issuer,<S2SV_blank>-oldcert<S2SV_blank>or<S2SV_blank>-cert;<S2SV_blank>recipient<S2SV_blank>will<S2SV_blank>be<S2SV_blank>set<S2SV_blank>to<S2SV_blank>\\"NULL-DN\\"\\n" ) ; } if ( opt_infotype_s ) { char id_buf [ 87 ] = "id-it-" ; strncat ( id_buf , opt_infotype_s , 80 ) ; if ( ( opt_infotype = OBJ_sn2nid ( id_buf ) ) == NID_undef ) { BIO_puts ( bio_err , "error:<S2SV_blank>unknown<S2SV_blank>OID<S2SV_blank>name<S2SV_blank>in<S2SV_blank>-infotype<S2SV_blank>option\\n" ) ; goto err ; } } if ( ! setup_verification_ctx ( ctx , & all_crls ) ) goto err ; if ( opt_tls_trusted || opt_tls_host ) { opt_tls_used = 1 ; } if ( opt_tls_cert || opt_tls_key || opt_tls_keypass ) { opt_tls_used = 1 ; if ( ! opt_tls_key ) { BIO_printf ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>-tls_key<S2SV_blank>option\\n" ) ; goto err ; } else if ( ! opt_tls_cert ) { BIO_printf ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>-tls_cert<S2SV_blank>option\\n" ) ; } } if ( opt_tls_used ) { <S2SV_StartBug> BIO * sbio ; <S2SV_EndBug> X509_STORE * store ; SSL_CTX * ssl_ctx = setup_ssl_ctx ( e , CMP_CTX_get0_untrusted_certs ( ctx ) , all_crls ) ; if ( ! ssl_ctx ) goto err ; store = SSL_CTX_get_cert_store ( ssl_ctx ) ; <S2SV_StartBug> sbio = BIO_new_ssl ( ssl_ctx , 1 ) ; <S2SV_EndBug> SSL_CTX_free ( ssl_ctx ) ; if ( sbio == NULL || ( store && <S2SV_StartBug> ! X509_STORE_set_ex_data ( store , X509_STORE_EX_DATA_SBIO , sbio ) ) ) { <S2SV_EndBug> <S2SV_StartBug> BIO_printf ( bio_err , "error:<S2SV_blank>cannot<S2SV_blank>initialize<S2SV_blank>SSL<S2SV_blank>BIO" ) ; <S2SV_EndBug> goto err ; } CMP_CTX_set0_tlsBIO ( ctx , sbio ) ; } if ( ! setup_protection_ctx ( ctx , e ) ) goto err ; if ( ! setup_request_ctx ( ctx , e ) ) goto err ; if ( ! set_name ( opt_recipient , CMP_CTX_set1_recipient , ctx , "recipient" ) || ! set_name ( opt_expected_sender , CMP_CTX_set1_expected_sender , ctx , "expected<S2SV_blank>sender" ) ) goto oom ; if ( opt_geninfo ) { long value ; ASN1_OBJECT * type ; ASN1_INTEGER * aint ; ASN1_TYPE * val ; CMP_INFOTYPEANDVALUE * itav ; char * endstr ; char * valptr = strchr ( opt_geninfo , ':' ) ; if ( valptr == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>\':\'<S2SV_blank>in<S2SV_blank>-geninfo<S2SV_blank>option\\n" ) ; goto err ; } valptr [ 0 ] = '\\0' ; valptr ++ ; if ( strncmp ( valptr , "int:" , 4 ) != 0 ) { BIO_puts ( bio_err , "error:<S2SV_blank>missing<S2SV_blank>\'int:\'<S2SV_blank>in<S2SV_blank>-geninfo<S2SV_blank>option\\n" ) ; goto err ; } valptr += 4 ; value = strtol ( valptr , & endstr , 10 ) ; if ( endstr == valptr || * endstr ) { BIO_puts ( bio_err , "error:<S2SV_blank>cannot<S2SV_blank>parse<S2SV_blank>int<S2SV_blank>in<S2SV_blank>-geninfo<S2SV_blank>option\\n" ) ; goto err ; } type = OBJ_txt2obj ( opt_geninfo , 1 ) ; if ( type == NULL ) { BIO_puts ( bio_err , "error:<S2SV_blank>cannot<S2SV_blank>parse<S2SV_blank>OID<S2SV_blank>in<S2SV_blank>-geninfo<S2SV_blank>option\\n" ) ; goto err ; } aint = ASN1_INTEGER_new ( ) ; if ( aint == NULL || ! ASN1_INTEGER_set ( aint , value ) ) { goto oom ; } val = ASN1_TYPE_new ( ) ; if ( val == NULL ) { ASN1_INTEGER_free ( aint ) ; goto oom ; } ASN1_TYPE_set ( val , V_ASN1_INTEGER , aint ) ; itav = CMP_ITAV_new ( type , val ) ; if ( itav == NULL ) { ASN1_TYPE_free ( val ) ; goto oom ; } if ( ! CMP_CTX_geninfo_itav_push0 ( ctx , itav ) ) { CMP_INFOTYPEANDVALUE_free ( itav ) ; goto err ; } } if ( opt_msgtimeout >= 0 ) ( void ) CMP_CTX_set_option ( ctx , CMP_CTX_OPT_MSGTIMEOUT , opt_msgtimeout ) ; if ( opt_maxpolltime >= 0 ) ( void ) CMP_CTX_set_option ( ctx , CMP_CTX_OPT_MAXPOLLTIME , opt_maxpolltime ) ; # ifndef NDEBUG if ( opt_reqin || opt_reqout || opt_rspin || opt_rspout ) ( void ) CMP_CTX_set_transfer_cb ( ctx , read_write_req_resp ) ; # endif ret = 1 ; err : sk_X509_CRL_pop_free ( all_crls , X509_CRL_free ) ; return ret ; oom : BIO_printf ( bio_err , "Error:<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory\\n" ) ; goto err ; } | <S2SV_ModStart> opt_tls_used ) { <S2SV_ModEnd> X509_STORE * store <S2SV_ModStart> ssl_ctx ) ; if <S2SV_ModEnd> ( store && <S2SV_ModStart> ( store , X509_STORE_EX_DATA_CMP , ctx <S2SV_ModEnd> ) ) { <S2SV_ModStart> ( bio_err , "error:<S2SV_blank>cannot<S2SV_blank>set<S2SV_blank>CMP<S2SV_blank>CTX<S2SV_blank>in<S2SV_blank>SSL<S2SV_blank>store" ) ; SSL_CTX_free ( ssl_ctx ) ; goto err ; } ( void ) CMP_CTX_set_http_cb ( ctx , tls_http_cb ) ; ( void ) CMP_CTX_set_http_cb_arg ( ctx , ssl_ctx <S2SV_ModEnd> ) ; } |
829 | CWE-000 <S2SV_StartBug> static ssize_t print_bin ( char * buf , void * data , size_t size ) { <S2SV_EndBug> <S2SV_StartBug> # endif <S2SV_EndBug> uint8_t * p ; char * q ; int i ; p = data ; q = buf ; for ( i = 0 ; i < size ; ++ i ) { # ifdef POSTK_DEBUG_ARCH_DEP_38 int ret ; ret = snprintf ( q , buf_size , "%02x" , * p ) ; if ( ret < 0 ) { return ret ; } q += ret ; buf_size -= ret ; # else q += sprintf ( q , "%02x" , * p ) ; # endif ++ p ; } * q = '\\0' ; return ( q - buf ) ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> ssize_t print_bin ( <S2SV_ModStart> char * buf , size_t buf_size <S2SV_ModStart> size ) { <S2SV_ModEnd> uint8_t * p |
830 | CWE-000 int glusterd_fetchsnap_notify ( xlator_t * this ) { int ret = - 1 ; glusterd_conf_t * priv = NULL ; rpc_transport_t * trans = NULL ; priv = this -> private ; pthread_mutex_lock ( & priv -> xprt_lock ) ; { list_for_each_entry ( trans , & priv -> xprt_list , list ) { rpcsvc_callback_submit ( priv -> rpc , trans , & glusterd_cbk_prog , <S2SV_StartBug> GF_CBK_GET_SNAPS , NULL , 0 ) ; <S2SV_EndBug> } } pthread_mutex_unlock ( & priv -> xprt_lock ) ; ret = 0 ; return ret ; } | <S2SV_ModStart> NULL , 0 , NULL |
831 | CWE-000 static void cat ( FILE * in , FILE * out , int n ) { ssize_t read ; char * buff = NULL ; size_t size = 0 ; <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> while ( ( read = getline ( & buff , & size , in ) ) != - 1 ) { if ( n ) fprintf ( out , "%d<S2SV_blank>%s" , i , buff ) ; else fprintf ( out , "%s" , buff ) ; i ++ ; } free ( buff ) ; } | <S2SV_ModStart> int i = 1 <S2SV_ModEnd> ; while ( |
832 | CWE-000 static int leaf_dealloc ( struct gfs2_inode * dip , u32 index , u32 len , u64 leaf_no , struct buffer_head * leaf_bh , int last_dealloc ) { struct gfs2_sbd * sdp = GFS2_SB ( & dip -> i_inode ) ; struct gfs2_leaf * tmp_leaf ; struct gfs2_rgrp_list rlist ; struct buffer_head * bh , * dibh ; u64 blk , nblk ; unsigned int rg_blocks = 0 , l_blocks = 0 ; char * ht ; unsigned int x , size = len * sizeof ( u64 ) ; int error ; error = gfs2_rindex_update ( sdp ) ; if ( error ) return error ; memset ( & rlist , 0 , sizeof ( struct gfs2_rgrp_list ) ) ; ht = kzalloc ( size , GFP_NOFS | __GFP_NOWARN ) ; if ( ht == NULL ) ht = __vmalloc ( size , GFP_NOFS | __GFP_NOWARN | __GFP_ZERO , PAGE_KERNEL ) ; if ( ! ht ) return - ENOMEM ; error = gfs2_quota_hold ( dip , NO_UID_QUOTA_CHANGE , NO_GID_QUOTA_CHANGE ) ; if ( error ) goto out ; bh = leaf_bh ; for ( blk = leaf_no ; blk ; blk = nblk ) { if ( blk != leaf_no ) { error = get_leaf ( dip , blk , & bh ) ; if ( error ) goto out_rlist ; } tmp_leaf = ( struct gfs2_leaf * ) bh -> b_data ; nblk = be64_to_cpu ( tmp_leaf -> lf_next ) ; if ( blk != leaf_no ) brelse ( bh ) ; gfs2_rlist_add ( dip , & rlist , blk ) ; l_blocks ++ ; } <S2SV_StartBug> gfs2_rlist_alloc ( & rlist , LM_ST_EXCLUSIVE ) ; <S2SV_EndBug> for ( x = 0 ; x < rlist . rl_rgrps ; x ++ ) { struct gfs2_rgrpd * rgd = gfs2_glock2rgrp ( rlist . rl_ghs [ x ] . gh_gl ) ; rg_blocks += rgd -> rd_length ; } error = gfs2_glock_nq_m ( rlist . rl_rgrps , rlist . rl_ghs ) ; if ( error ) goto out_rlist ; error = gfs2_trans_begin ( sdp , rg_blocks + ( DIV_ROUND_UP ( size , sdp -> sd_jbsize ) + 1 ) + RES_DINODE + RES_STATFS + RES_QUOTA , l_blocks ) ; if ( error ) goto out_rg_gunlock ; bh = leaf_bh ; for ( blk = leaf_no ; blk ; blk = nblk ) { <S2SV_StartBug> if ( blk != leaf_no ) { <S2SV_EndBug> error = get_leaf ( dip , blk , & bh ) ; if ( error ) goto out_end_trans ; } tmp_leaf = ( struct gfs2_leaf * ) bh -> b_data ; nblk = be64_to_cpu ( tmp_leaf -> lf_next ) ; if ( blk != leaf_no ) brelse ( bh ) ; <S2SV_StartBug> gfs2_free_meta ( dip , blk , 1 ) ; <S2SV_EndBug> gfs2_add_inode_blocks ( & dip -> i_inode , - 1 ) ; } error = gfs2_dir_write_data ( dip , ht , index * sizeof ( u64 ) , size ) ; if ( error != size ) { if ( error >= 0 ) error = - EIO ; goto out_end_trans ; } error = gfs2_meta_inode_buffer ( dip , & dibh ) ; if ( error ) goto out_end_trans ; gfs2_trans_add_meta ( dip -> i_gl , dibh ) ; if ( last_dealloc ) dip -> i_inode . i_mode = S_IFREG ; gfs2_dinode_out ( dip , dibh -> b_data ) ; brelse ( dibh ) ; out_end_trans : gfs2_trans_end ( sdp ) ; out_rg_gunlock : gfs2_glock_dq_m ( rlist . rl_rgrps , rlist . rl_ghs ) ; out_rlist : gfs2_rlist_free ( & rlist ) ; gfs2_quota_unhold ( dip ) ; out : kvfree ( ht ) ; return error ; } | <S2SV_ModStart> ( & rlist <S2SV_ModEnd> ) ; for <S2SV_ModStart> nblk ) { struct gfs2_rgrpd * rgd ; <S2SV_ModStart> bh ) ; rgd = gfs2_blk2rgrpd ( sdp , blk , true ) ; <S2SV_ModStart> gfs2_free_meta ( dip , rgd |
833 | CWE-000 <S2SV_StartBug> static inline gboolean <S2SV_EndBug> log_msg_is_write_protected ( const LogMessage * self ) { return self -> protect_cnt > 0 ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> <S2SV_ModEnd> gboolean log_msg_is_write_protected ( |
834 | CWE-000 static int update_userspace_power ( struct sched_params __user * argp ) { int i ; int ret ; <S2SV_StartBug> int cpu = INT_MAX ; <S2SV_EndBug> struct cpu_activity_info * node ; struct cpu_static_info * sp , * clear_sp ; int cpumask , cluster , mpidr ; bool pdata_valid [ NR_CPUS ] = { 0 } ; get_user ( cpumask , & argp -> cpumask ) ; get_user ( cluster , & argp -> cluster ) ; mpidr = cluster << 8 ; pr_debug ( "%s:<S2SV_blank>cpumask<S2SV_blank>%d,<S2SV_blank>cluster:<S2SV_blank>%d\\n" , __func__ , cpumask , cluster ) ; for ( i = 0 ; i < MAX_CORES_PER_CLUSTER ; i ++ , cpumask >>= 1 ) { if ( ! ( cpumask & 0x01 ) ) continue ; mpidr |= i ; for_each_possible_cpu ( cpu ) { if ( cpu_logical_map ( cpu ) == mpidr ) break ; } } <S2SV_StartBug> if ( cpu >= num_possible_cpus ( ) ) <S2SV_EndBug> return - EINVAL ; node = & activity [ cpu ] ; sp = kzalloc ( sizeof ( * sp ) , GFP_KERNEL ) ; if ( ! sp ) return - ENOMEM ; sp -> power = allocate_2d_array_uint32_t ( node -> sp -> num_of_freqs ) ; if ( IS_ERR_OR_NULL ( sp -> power ) ) { ret = PTR_ERR ( sp -> power ) ; kfree ( sp ) ; return ret ; } sp -> num_of_freqs = node -> sp -> num_of_freqs ; sp -> voltage = node -> sp -> voltage ; sp -> table = node -> sp -> table ; for ( i = 0 ; i < TEMP_DATA_POINTS ; i ++ ) { ret = copy_from_user ( sp -> power [ i ] , & argp -> power [ i ] [ 0 ] , sizeof ( sp -> power [ i ] [ 0 ] ) * node -> sp -> num_of_freqs ) ; if ( ret ) goto failed ; } get_user ( cpumask , & argp -> cpumask ) ; spin_lock ( & update_lock ) ; for ( i = 0 ; i < MAX_CORES_PER_CLUSTER ; i ++ , cpumask >>= 1 ) { if ( ! ( cpumask & 0x01 ) ) continue ; mpidr = ( cluster << CLUSTER_OFFSET_FOR_MPIDR ) ; mpidr |= i ; for_each_possible_cpu ( cpu ) { if ( ! ( cpu_logical_map ( cpu ) == mpidr ) ) continue ; node = & activity [ cpu ] ; clear_sp = node -> sp ; node -> sp = sp ; cpumask_set_cpu ( cpu , & sp -> mask ) ; if ( clear_sp ) { cpumask_clear_cpu ( cpu , & clear_sp -> mask ) ; clear_static_power ( clear_sp ) ; } cpu_stats [ cpu ] . ptable = per_cpu ( ptable , cpu ) ; repopulate_stats ( cpu ) ; pdata_valid [ cpu ] = true ; } } spin_unlock ( & update_lock ) ; for_each_possible_cpu ( cpu ) { if ( pdata_valid [ cpu ] ) continue ; blocking_notifier_call_chain ( & msm_core_stats_notifier_list , cpu , NULL ) ; } activate_power_table = true ; return 0 ; failed : for ( i = 0 ; i < TEMP_DATA_POINTS ; i ++ ) kfree ( sp -> power [ i ] ) ; kfree ( sp -> power ) ; kfree ( sp ) ; return ret ; } | <S2SV_ModStart> int cpu = - 1 <S2SV_ModEnd> ; struct cpu_activity_info <S2SV_ModStart> } if ( ( cpu < 0 ) || ( <S2SV_ModStart> >= num_possible_cpus ( ) |
835 | CWE-000 static void xgene_xgmac_init ( struct xgene_enet_pdata * pdata ) { u32 data ; xgene_xgmac_reset ( pdata ) ; xgene_enet_rd_mac ( pdata , AXGMAC_CONFIG_1 , & data ) ; data |= HSTPPEN ; data &= ~ HSTLENCHK ; xgene_enet_wr_mac ( pdata , AXGMAC_CONFIG_1 , data ) ; xgene_xgmac_set_mac_addr ( pdata ) ; xgene_enet_rd_csr ( pdata , XG_RSIF_CONFIG_REG_ADDR , & data ) ; data |= CFG_RSIF_FPBUFF_TIMEOUT_EN ; <S2SV_StartBug> xgene_enet_wr_csr ( pdata , XG_RSIF_CONFIG_REG_ADDR , data ) ; <S2SV_EndBug> xgene_enet_rd_csr ( pdata , XG_ENET_SPARE_CFG_REG_ADDR , & data ) ; data |= BIT ( 12 ) ; xgene_enet_wr_csr ( pdata , XG_ENET_SPARE_CFG_REG_ADDR , data ) ; xgene_enet_wr_csr ( pdata , XG_ENET_SPARE_CFG_REG_1_ADDR , 0x82 ) ; xgene_enet_wr_csr ( pdata , XGENET_RX_DV_GATE_REG_0_ADDR , 0 ) ; xgene_enet_wr_csr ( pdata , XG_CFG_BYPASS_ADDR , RESUME_TX ) ; xgene_enet_rd_axg_csr ( pdata , XGENET_CSR_MULTI_DPF0_ADDR , & data ) ; data = ( DEF_QUANTA << 16 ) | ( data & 0xFFFF ) ; xgene_enet_wr_axg_csr ( pdata , XGENET_CSR_MULTI_DPF0_ADDR , data ) ; if ( pdata -> enet_id != XGENE_ENET1 ) { xgene_enet_rd_axg_csr ( pdata , XGENET_CSR_MULTI_DPF1_ADDR , & data ) ; data = ( NORM_PAUSE_OPCODE << 16 ) | ( data & 0xFFFF ) ; xgene_enet_wr_axg_csr ( pdata , XGENET_CSR_MULTI_DPF1_ADDR , data ) ; } data = ( XG_DEF_PAUSE_OFF_THRES << 16 ) | XG_DEF_PAUSE_THRES ; xgene_enet_wr_csr ( pdata , XG_RXBUF_PAUSE_THRESH , data ) ; xgene_xgmac_flowctl_tx ( pdata , pdata -> tx_pause ) ; xgene_xgmac_flowctl_rx ( pdata , pdata -> rx_pause ) ; } | <S2SV_ModStart> |= CFG_RSIF_FPBUFF_TIMEOUT_EN ; RSIF_CLE_BUFF_THRESH_SET ( & data , XG_RSIF_CLE_BUFF_THRESH ) ; <S2SV_ModStart> pdata , XG_RSIF_CONFIG_REG_ADDR , data ) ; xgene_enet_rd_csr ( pdata , XG_RSIF_CONFIG1_REG_ADDR , & data ) ; RSIF_PLC_CLE_BUFF_THRESH_SET ( & data , XG_RSIF_PLC_CLE_BUFF_THRESH ) ; xgene_enet_wr_csr ( pdata , XG_RSIF_CONFIG1_REG_ADDR |
836 | CWE-000 ssize_t read ( int fd , void * buf , size_t count ) { int ret = __syscall ( 0 , fd , ( uint64_t ) buf , count , 0 , 0 , 0 ) ; if ( ret < 0 ) { errno = - ret ; return - 1 ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> ; } return ret <S2SV_ModEnd> ; } <S2SV_null> |
837 | CWE-000 int rndset ( CSOUND * csound , RAND * p ) { p -> new = ( * p -> sel != FL ( 0.0 ) ) ; if ( * p -> iseed >= FL ( 0.0 ) ) { if ( * p -> iseed > FL ( 1.0 ) ) { uint32 seed ; seed = csound -> GetRandomSeedFromTime ( ) ; <S2SV_StartBug> csound -> Warning ( csound , Str ( "Seeding<S2SV_blank>from<S2SV_blank>current<S2SV_blank>time<S2SV_blank>%u\\n" ) , seed ) ; <S2SV_EndBug> if ( ! p -> new ) { p -> rand = ( int32 ) ( seed & 0xFFFFUL ) ; } else { p -> rand = ( int32 ) ( seed % 0x7FFFFFFEUL ) + 1L ; } } else { if ( p -> new ) { MYFLT seed = * p -> iseed ; if ( seed == FL ( 0.0 ) ) seed = FL ( 0.5 ) ; p -> rand = ( int32 ) ( seed * FL ( 2147483648.0 ) ) ; p -> rand = randint31 ( p -> rand ) ; p -> rand = randint31 ( p -> rand ) ; } else p -> rand = ( ( int16 ) ( * p -> iseed * FL ( 32768.0 ) ) ) & 0xffff ; } } p -> ampcod = IS_ASIG_ARG ( p -> xamp ) ? 1 : 0 ; return OK ; } | <S2SV_ModStart> , Str ( "Seeding<S2SV_blank>from<S2SV_blank>current<S2SV_blank>time<S2SV_blank>%" PRIu32 "\\n" <S2SV_ModEnd> ) , seed |
838 | CWE-000 BOOL manual ( char port [ 16 ] ) { BOOL active = TRUE ; HANDLE hComm ; char buffer [ 2 ] = { 0 , '\\0' } ; char bufferPrev [ 2 ] = { 0 , '\\0' } ; printf ( "Handmatige<S2SV_blank>besturing\\n" "\\n=======================================================\\n" ">1<<S2SV_blank>Gebuik<S2SV_blank>de<S2SV_blank>pijltjes<S2SV_blank>toetsen<S2SV_blank>om<S2SV_blank>te<S2SV_blank>bewegen.\\n" ">2<<S2SV_blank>Gebruik<S2SV_blank>ESC<S2SV_blank>om<S2SV_blank>het<S2SV_blank>terug<S2SV_blank>te<S2SV_blank>keren<S2SV_blank>naar<S2SV_blank>de<S2SV_blank>selector\\n" "=======================================================\\n\\n" ) ; while ( active ) { buffer [ 0 ] = keyboard ( ) ; if ( buffer [ 0 ] != bufferPrev [ 0 ] ) { <S2SV_StartBug> if ( portAlive ( port ) ) { <S2SV_EndBug> hComm = openPort ( port ) ; sendData ( buffer , hComm ) ; CloseHandle ( hComm ) ; bufferPrev [ 0 ] = buffer [ 0 ] ; } } } return TRUE ; } | <S2SV_ModStart> { if ( buffer [ 0 ] == 7 ) { break ; } if ( |
839 | CWE-000 <S2SV_StartBug> ArchiveFileNode * createArchiveNode ( const char * name , const struct stat * stat , int is_folder ) { <S2SV_EndBug> ArchiveFileNode * node = malloc ( sizeof ( ArchiveFileNode ) ) ; if ( ! node ) return NULL ; memset ( node , 0 , sizeof ( ArchiveFileNode ) ) ; node -> name = malloc ( strlen ( name ) + 1 ) ; if ( ! node -> name ) { free ( node ) ; return NULL ; } strcpy ( node -> name , name ) ; node -> child = NULL ; node -> next = NULL ; <S2SV_StartBug> if ( is_folder || stat -> st_mode & S_IFDIR ) <S2SV_EndBug> node -> is_folder = 1 ; node -> mode = node -> is_folder ? SCE_S_IFDIR : SCE_S_IFREG ; if ( stat ) { SceDateTime time ; node -> size = stat -> st_size ; sceRtcSetTime_t ( & time , stat -> st_ctime ) ; <S2SV_StartBug> convertLocalTimeToUtc ( & node -> ctime , & time ) ; <S2SV_EndBug> sceRtcSetTime_t ( & time , stat -> st_mtime ) ; convertLocalTimeToUtc ( & node -> mtime , & time ) ; sceRtcSetTime_t ( & time , stat -> st_atime ) ; convertLocalTimeToUtc ( & node -> atime , & time ) ; } return node ; } | <S2SV_ModStart> * name , SceIoStat * stat <S2SV_ModEnd> ) { ArchiveFileNode <S2SV_ModStart> = NULL ; memcpy <S2SV_ModEnd> ( & node <S2SV_ModStart> & node -> stat , stat , sizeof ( SceIoStat ) ) ; <S2SV_ModEnd> return node ; |
840 | CWE-000 TranslationBlock * tb_find_pc ( unsigned long tc_ptr ) { int m_min , m_max , m ; unsigned long v ; TranslationBlock * tb ; if ( nb_tbs <= 0 ) return NULL ; <S2SV_StartBug> if ( tc_ptr < ( unsigned long ) code_gen_buffer || <S2SV_EndBug> tc_ptr >= ( unsigned long ) code_gen_ptr ) <S2SV_StartBug> return NULL ; <S2SV_EndBug> m_min = 0 ; m_max = nb_tbs - 1 ; while ( m_min <= m_max ) { m = ( m_min + m_max ) >> 1 ; tb = & tbs [ m ] ; v = ( unsigned long ) tb -> tc_ptr ; if ( v == tc_ptr ) return tb ; else if ( tc_ptr < v ) { m_max = m - 1 ; } else { m_min = m + 1 ; } } return & tbs [ m_max ] ; } | <S2SV_ModStart> return NULL ; # if defined ( CONFIG_2nd_CCACHE ) if ( second_ccache_flag ) { if ( tc_ptr < ( unsigned long ) second_code_gen_buffer || tc_ptr >= ( unsigned long ) code_gen_ptr ) return NULL ; } else { <S2SV_ModStart> return NULL ; } # else if ( tc_ptr < ( unsigned long ) code_gen_buffer || tc_ptr >= ( unsigned long ) code_gen_ptr ) return NULL ; # endif |
841 | CWE-000 static void printnetwork ( char * networkinfo ) { int p ; char timestring [ 16 ] ; strftime ( timestring , 16 , "%H:%M:%S" , localtime ( & tv . tv_sec ) ) ; <S2SV_StartBug> fprintf ( stdout , "[%s]<S2SV_blank>" , timestring ) ; <S2SV_EndBug> for ( p = 0 ; p < 6 ; p ++ ) { fprintf ( stdout , "%02x" , networkliste -> mac_ap [ p ] ) ; } fprintf ( stdout , ":" ) ; for ( p = 0 ; p < 6 ; p ++ ) { fprintf ( stdout , "%02x" , networkliste -> mac_sta [ p ] ) ; } fprintf ( stdout , ":" ) ; fwrite ( networkliste -> essid , networkliste -> essid_len , 1 , stdout ) ; fprintf ( stdout , "<S2SV_blank>%s\\n" , networkinfo ) ; return ; } | <S2SV_ModStart> ( stdout , "\\33[2K[%s]<S2SV_blank>" <S2SV_ModEnd> , timestring ) |
842 | CWE-000 static int set_system_clock ( const struct hwclock_control * ctl , const struct timeval newtime ) { int retcode ; const struct timeval * tv_null = NULL ; struct tm * broken ; int minuteswest ; int rc = 0 ; <S2SV_StartBug> broken = localtime ( & newtime . tv_sec ) ; <S2SV_EndBug> # ifdef HAVE_TM_GMTOFF minuteswest = - broken -> tm_gmtoff / 60 ; # else minuteswest = timezone / 60 ; if ( broken -> tm_isdst ) minuteswest -= 60 ; # endif if ( ctl -> debug ) { printf ( _ ( "Calling<S2SV_blank>settimeofday:\\n" ) ) ; printf ( _ ( "\\ttv.tv_sec<S2SV_blank>=<S2SV_blank>%ld,<S2SV_blank>tv.tv_usec<S2SV_blank>=<S2SV_blank>%ld\\n" ) , newtime . tv_sec , newtime . tv_usec ) ; printf ( _ ( "\\ttz.tz_minuteswest<S2SV_blank>=<S2SV_blank>%d\\n" ) , minuteswest ) ; } if ( ctl -> testing ) { printf ( _ ( "Test<S2SV_blank>mode:<S2SV_blank>clock<S2SV_blank>was<S2SV_blank>not<S2SV_blank>changed\\n" ) ) ; retcode = 0 ; } else { const struct timezone tz = { minuteswest , 0 } ; <S2SV_StartBug> if ( ! ctl -> universal ) <S2SV_EndBug> rc = settimeofday ( tv_null , & tz ) ; <S2SV_StartBug> if ( ! rc ) <S2SV_EndBug> rc = settimeofday ( & newtime , & tz ) ; <S2SV_StartBug> if ( rc ) { <S2SV_EndBug> warn ( _ ( "settimeofday()<S2SV_blank>failed" ) ) ; retcode = 1 ; } else retcode = 0 ; } return retcode ; } | <S2SV_ModStart> = 0 ; const struct timezone tz_utc = { 0 } ; <S2SV_ModStart> ; if ( ctl -> hctosys && <S2SV_ModStart> ; if ( ctl -> systz && ctl -> universal ) rc = settimeofday ( tv_null , & tz_utc ) ; if ( ! rc && ctl -> hctosys <S2SV_ModEnd> ) rc = <S2SV_ModStart> tz ) ; else if ( ! rc ) rc = settimeofday ( NULL , & tz ) ; |
843 | CWE-000 u32 Quadramp_GetIncrementNegative ( Quadramp * InstancePtr ) { Xil_AssertNonvoid ( InstancePtr != NULL ) ; Xil_AssertNonvoid ( InstancePtr -> IsReady == XIL_COMPONENT_IS_READY ) ; <S2SV_StartBug> QUADRAMP_mReadReg ( InstancePtr -> BaseAddress , QUADRAMP_S00_AXI_SLV_REG7_OFFSET ) ; <S2SV_EndBug> } | <S2SV_ModStart> XIL_COMPONENT_IS_READY ) ; return |
844 | CWE-000 static int <S2SV_StartBug> virStorageBackendRBDBuildVol ( virConnectPtr conn , <S2SV_EndBug> virStoragePoolObjPtr pool , virStorageVolDefPtr vol , unsigned int flags ) { virStoragePoolDefPtr def = virStoragePoolObjGetDef ( pool ) ; virStorageBackendRBDStatePtr ptr = NULL ; int ret = - 1 ; int r = 0 ; VIR_DEBUG ( "Creating<S2SV_blank>RBD<S2SV_blank>image<S2SV_blank>%s/%s<S2SV_blank>with<S2SV_blank>size<S2SV_blank>%llu" , def -> source . name , vol -> name , vol -> target . capacity ) ; virCheckFlags ( 0 , - 1 ) ; if ( ! vol -> target . capacity ) { virReportError ( VIR_ERR_NO_SUPPORT , "%s" , _ ( "volume<S2SV_blank>capacity<S2SV_blank>required<S2SV_blank>for<S2SV_blank>this<S2SV_blank>storage<S2SV_blank>pool" ) ) ; goto cleanup ; } if ( vol -> target . format != VIR_STORAGE_FILE_RAW ) { virReportError ( VIR_ERR_NO_SUPPORT , "%s" , _ ( "only<S2SV_blank>RAW<S2SV_blank>volumes<S2SV_blank>are<S2SV_blank>supported<S2SV_blank>by<S2SV_blank>this<S2SV_blank>storage<S2SV_blank>pool" ) ) ; goto cleanup ; } if ( vol -> target . encryption != NULL ) { virReportError ( VIR_ERR_CONFIG_UNSUPPORTED , "%s" , _ ( "storage<S2SV_blank>pool<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>encrypted<S2SV_blank>volumes" ) ) ; goto cleanup ; } <S2SV_StartBug> if ( ! ( ptr = virStorageBackendRBDNewState ( conn , pool ) ) ) <S2SV_EndBug> goto cleanup ; if ( ( r = virStorageBackendRBDCreateImage ( ptr -> ioctx , vol -> name , vol -> target . capacity ) ) < 0 ) { virReportSystemError ( - r , _ ( "failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>volume<S2SV_blank>\'%s/%s\'" ) , def -> source . name , vol -> name ) ; goto cleanup ; } ret = 0 ; cleanup : virStorageBackendRBDFreeState ( & ptr ) ; return ret ; } | <S2SV_ModStart> ( virConnectPtr conn ATTRIBUTE_UNUSED <S2SV_ModStart> = virStorageBackendRBDNewState ( <S2SV_ModEnd> pool ) ) |
845 | CWE-000 static void _rhs_variable_step_helper ( Grid_node * g , double const * const states , double * ydot ) { int num_states_x = g -> size_x , num_states_y = g -> size_y , num_states_z = g -> size_z ; double dx = g -> dx , dy = g -> dy , dz = g -> dz ; int i , j , k , stop_i , stop_j , stop_k ; double dc_x = g -> dc_x , dc_y = g -> dc_y , dc_z = g -> dc_z ; double rate_x = dc_x / ( dx * dx ) ; double rate_y = dc_y / ( dy * dy ) ; double rate_z = dc_z / ( dz * dz ) ; int index , prev_i , prev_j , prev_k , next_i , next_j , next_k ; int xp , xm , yp , ym , zp , zm ; double div_x , div_y , div_z ; stop_i = num_states_x - 1 ; stop_j = num_states_y - 1 ; stop_k = num_states_z - 1 ; for ( i = 0 , index = 0 , prev_i = num_states_y * num_states_z , next_i = num_states_y * num_states_z ; i < num_states_x ; i ++ ) { div_x = ( i == 0 || i == stop_i ) ? 2. : 1. ; for ( j = 0 , prev_j = index + num_states_z , next_j = index + num_states_z ; j < num_states_y ; j ++ ) { div_y = ( j == 0 || j == stop_j ) ? 2. : 1. ; for ( k = 0 , prev_k = index + 1 , next_k = index + 1 ; k < num_states_z ; k ++ , index ++ , prev_i ++ , next_i ++ , prev_j ++ , next_j ++ ) { div_z = ( k == 0 || k == stop_k ) ? 2. : 1. ; <S2SV_StartBug> ydot [ index ] = rate_x * ( states [ prev_i ] - <S2SV_EndBug> 2.0 * states [ index ] + states [ next_i ] ) / div_x ; ydot [ index ] += rate_y * ( states [ prev_j ] - 2.0 * states [ index ] + states [ next_j ] ) / div_y ; ydot [ index ] += rate_z * ( states [ prev_k ] - 2.0 * states [ index ] + states [ next_k ] ) / div_z ; next_k = ( k == stop_k - 1 ) ? index : index + 2 ; prev_k = index ; } prev_j = index - num_states_z ; next_j = ( j == stop_j - 1 ) ? prev_j : index + num_states_z ; } prev_i = index - num_states_y * num_states_z ; next_i = ( i == stop_i - 1 ) ? prev_i : index + num_states_y * num_states_z ; } } | <S2SV_ModStart> [ index ] += <S2SV_ModEnd> rate_x * ( |
846 | CWE-000 void session_init ( void ) { <S2SV_StartBug> FUNC_CALL_ENTRY ; <S2SV_EndBug> clock_gettime ( CLOCK_MONOTONIC , & start_time_snapshot ) ; if ( session_exist_status != ESTABLISHED ) { set_loglevel ( ase_calc_loglevel ( ) ) ; setvbuf ( stdout , NULL , ( int ) _IONBF , ( size_t ) 0 ) ; ipc_init ( ) ; ASE_MSG ( "ASE<S2SV_blank>Session<S2SV_blank>Directory<S2SV_blank>located<S2SV_blank>at<S2SV_blank>=>\\n" ) ; ASE_MSG ( "%s\\n" , ase_workdir_path ) ; snprintf ( tstamp_filepath , ASE_FILEPATH_LEN , "%s/%s" , ase_workdir_path , TSTAMP_FILENAME ) ; ase_memset ( app_ready_lockpath , 0 , ASE_FILEPATH_LEN ) ; snprintf ( app_ready_lockpath , ASE_FILEPATH_LEN , "%s/%s" , ase_workdir_path , APP_LOCK_FILENAME ) ; if ( check_app_lock_file ( ) ) { if ( ! remove_existing_lock_file ( ) ) { ASE_MSG ( "Application<S2SV_blank>Exiting<S2SV_blank>\\n" ) ; exit ( 1 ) ; } } create_new_lock_file ( ) ; signal ( SIGTERM , send_simkill ) ; signal ( SIGINT , send_simkill ) ; signal ( SIGQUIT , send_simkill ) ; signal ( SIGHUP , send_simkill ) ; signal ( SIGSEGV , backtrace_handler ) ; signal ( SIGBUS , backtrace_handler ) ; signal ( SIGABRT , backtrace_handler ) ; signal ( SIGPIPE , SIG_IGN ) ; ASE_INFO ( "Initializing<S2SV_blank>simulation<S2SV_blank>session<S2SV_blank>...<S2SV_blank>\\n" ) ; app2sim_alloc_tx = mqueue_open ( mq_array [ 0 ] . name , mq_array [ 0 ] . perm_flag ) ; app2sim_mmioreq_tx = mqueue_open ( mq_array [ 1 ] . name , mq_array [ 1 ] . perm_flag ) ; app2sim_umsg_tx = mqueue_open ( mq_array [ 2 ] . name , mq_array [ 2 ] . perm_flag ) ; sim2app_alloc_rx = mqueue_open ( mq_array [ 3 ] . name , mq_array [ 3 ] . perm_flag ) ; sim2app_mmiorsp_rx = mqueue_open ( mq_array [ 4 ] . name , mq_array [ 4 ] . perm_flag ) ; app2sim_portctrl_req_tx = mqueue_open ( mq_array [ 5 ] . name , mq_array [ 5 ] . perm_flag ) ; app2sim_dealloc_tx = mqueue_open ( mq_array [ 6 ] . name , mq_array [ 6 ] . perm_flag ) ; sim2app_dealloc_rx = mqueue_open ( mq_array [ 7 ] . name , mq_array [ 7 ] . perm_flag ) ; sim2app_portctrl_rsp_rx = mqueue_open ( mq_array [ 8 ] . name , mq_array [ 8 ] . perm_flag ) ; sim2app_intr_request_rx = mqueue_open ( mq_array [ 9 ] . name , mq_array [ 9 ] . perm_flag ) ; send_swreset ( ) ; # ifdef ASE_DEBUG fp_pagetable_log = fopen ( "app_pagetable.log" , "w" ) ; if ( fp_pagetable_log == NULL ) { ASE_ERR ( "APP<S2SV_blank>pagetable<S2SV_blank>logger<S2SV_blank>initialization<S2SV_blank>failed<S2SV_blank>!\\n" ) ; } else { ASE_MSG ( "APP<S2SV_blank>pagetable<S2SV_blank>logger<S2SV_blank>initialized\\n" ) ; } fp_mmioaccess_log = fopen ( "app_mmioaccess.log" , "w" ) ; if ( fp_mmioaccess_log == NULL ) { ASE_ERR ( "APP<S2SV_blank>MMIO<S2SV_blank>access<S2SV_blank>logger<S2SV_blank>initialization<S2SV_blank>failed<S2SV_blank>!\\n" ) ; } else { ASE_MSG ( "APP<S2SV_blank>MMIO<S2SV_blank>access<S2SV_blank>logger<S2SV_blank>initialized\\n" ) ; } # endif io_s . glbl_mmio_tid = 0 ; int thr_err ; ASE_MSG ( "Session<S2SV_blank>started\\n" ) ; ase_portctrl ( ASE_INIT , getpid ( ) ) ; poll_for_session_id ( ) ; get_timestamp ( tstamp_string ) ; ASE_MSG ( "Creating<S2SV_blank>MMIO<S2SV_blank>...\\n" ) ; io_s . mmio_region = ( struct buffer_t * ) ase_malloc ( sizeof ( struct buffer_t ) ) ; io_s . mmio_region -> memsize = MMIO_LENGTH ; io_s . mmio_region -> is_mmiomap = 1 ; allocate_buffer ( io_s . mmio_region , NULL ) ; io_s . mmio_afu_vbase = ( uint64_t * ) ( ( uint64_t ) io_s . mmio_region -> vbase + MMIO_AFU_OFFSET ) ; ASE_MSG ( "AFU<S2SV_blank>MMIO<S2SV_blank>Virtual<S2SV_blank>Base<S2SV_blank>Address<S2SV_blank>=<S2SV_blank>%p\\n" , ( void * ) io_s . mmio_afu_vbase ) ; umas_init_flag = 0 ; ASE_MSG ( "Creating<S2SV_blank>UMAS<S2SV_blank>...<S2SV_blank>\\n" ) ; umas_s . umas_region = ( struct buffer_t * ) ase_malloc ( sizeof ( struct buffer_t ) ) ; umas_s . umas_region -> memsize = UMAS_REGION_MEMSIZE ; umas_s . umas_region -> is_umas = 1 ; allocate_buffer ( umas_s . umas_region , NULL ) ; umas_s . umsg_umas_vbase = ( uint64_t * ) ( ( uint64_t ) umas_s . umas_region -> vbase ) ; umsg_set_attribute ( 0x0 ) ; ASE_MSG ( "UMAS<S2SV_blank>Virtual<S2SV_blank>Base<S2SV_blank>address<S2SV_blank>=<S2SV_blank>%p\\n" , ( void * ) umas_s . umsg_umas_vbase ) ; ASE_MSG ( "Starting<S2SV_blank>MMIO<S2SV_blank>Read<S2SV_blank>Response<S2SV_blank>watcher<S2SV_blank>...<S2SV_blank>\\n" ) ; <S2SV_StartBug> io_s . mmio_port_lock = PTHREAD_MUTEX_INITIALIZER ; <S2SV_EndBug> thr_err = pthread_create ( & io_s . mmio_watch_tid , NULL , & mmio_response_watcher , NULL ) ; if ( thr_err != 0 ) { ASE_ERR ( "FAILED\\n" ) ; BEGIN_RED_FONTCOLOR ; perror ( "pthread_create" ) ; END_RED_FONTCOLOR ; exit ( 1 ) ; } else { ASE_MSG ( "SUCCESS\\n" ) ; } ASE_MSG ( "Starting<S2SV_blank>UMsg<S2SV_blank>watcher<S2SV_blank>...<S2SV_blank>\\n" ) ; thr_err = pthread_create ( & umas_s . umsg_watch_tid , NULL , & umsg_watcher , NULL ) ; if ( thr_err != 0 ) { ASE_ERR ( "FAILED\\n" ) ; BEGIN_RED_FONTCOLOR ; perror ( "pthread_create" ) ; END_RED_FONTCOLOR ; exit ( 1 ) ; } else { ASE_MSG ( "SUCCESS\\n" ) ; } while ( umas_init_flag != 1 ) ; int ii ; for ( ii = 0 ; ii < MMIO_MAX_OUTSTANDING ; ii = ii + 1 ) { mmio_table [ ii ] . tid = 0 ; mmio_table [ ii ] . data = 0 ; mmio_table [ ii ] . tx_flag = false ; mmio_table [ ii ] . rx_flag = false ; } session_exist_status = ESTABLISHED ; } else { # ifdef ASE_DEBUG ASE_DBG ( "Session<S2SV_blank>already<S2SV_blank>exists\\n" ) ; # endif } FUNC_CALL_EXIT ; } | <S2SV_ModStart> ) { FUNC_CALL_ENTRY ; int rc <S2SV_ModStart> "Starting<S2SV_blank>MMIO<S2SV_blank>Read<S2SV_blank>Response<S2SV_blank>watcher<S2SV_blank>...<S2SV_blank>\\n" ) ; rc = pthread_mutex_init ( & <S2SV_ModStart> io_s . mmio_port_lock , NULL ) ; assert ( rc == 0 ) <S2SV_ModEnd> ; thr_err = |
847 | CWE-000 uint32_t ata_read ( int32_t fd , void * buf , uint32_t bytes ) { if ( ! ( descriptors [ fd ] -> mode & FILE_MODE_READ ) ) <S2SV_StartBug> return - 1 ; <S2SV_EndBug> return ata_partition_read ( descriptors [ fd ] -> info , buf , bytes ) ; } | <S2SV_ModStart> ) return - EACCES <S2SV_ModEnd> ; return ata_partition_read |
848 | CWE-000 static int vrrp_dispatcher_read_timeout ( int fd ) { vrrp_t * vrrp ; int prev_state ; element e ; list l = & vrrp_data -> vrrp_index_fd [ FD_INDEX_HASH ( fd ) ] ; set_time_now ( ) ; for ( e = LIST_HEAD ( l ) ; e ; ELEMENT_NEXT ( e ) ) { vrrp = ELEMENT_DATA ( e ) ; if ( vrrp -> sockets -> fd_in != fd ) continue ; if ( timercmp ( & vrrp -> sands , & time_now , > ) ) continue ; prev_state = vrrp -> state ; if ( vrrp -> state == VRRP_STATE_BACK ) vrrp_goto_master ( vrrp ) ; else if ( vrrp -> state == VRRP_STATE_MAST ) vrrp_master ( vrrp ) ; <S2SV_StartBug> # ifdef TSM_DEBUG <S2SV_EndBug> printf ( "Send<S2SV_blank>[%s]<S2SV_blank>TSM<S2SV_blank>transtition<S2SV_blank>:<S2SV_blank>[%d,%d]<S2SV_blank>Wantstate<S2SV_blank>=<S2SV_blank>[%d]\\n" , vrrp -> iname , prev_state , vrrp -> state , vrrp -> wantstate ) ; <S2SV_StartBug> # endif <S2SV_EndBug> VRRP_TSM_HANDLE ( prev_state , vrrp ) ; vrrp_init_instance_sands ( vrrp ) ; } return fd ; } | <S2SV_ModStart> vrrp ) ; if ( __test_bit ( LOG_DETAIL_BIT , & debug ) ) log_message ( LOG_INFO , <S2SV_ModEnd> "Send<S2SV_blank>[%s]<S2SV_blank>TSM<S2SV_blank>transtition<S2SV_blank>:<S2SV_blank>[%d,%d]<S2SV_blank>Wantstate<S2SV_blank>=<S2SV_blank>[%d]\\n" , vrrp <S2SV_ModStart> wantstate ) ; <S2SV_ModEnd> VRRP_TSM_HANDLE ( prev_state |
849 | CWE-000 int testVillage ( ) { int i ; int drawn = 1 ; int discarded = 1 ; int seed = 1000 ; int numPlayers = 2 ; int thisPlayer = 0 ; int bonus = 0 ; struct gameState state , testState ; int king [ 10 ] = { smithy , tribute , sea_hag , cutpurse , mine , minion , village , embargo , gardens , adventurer } ; int handPos = 0 ; int testPassed = 1 ; initializeGame ( numPlayers , king , seed , & state ) ; int deckCounter = state . deckCount [ thisPlayer ] ; int expectedCards [ 1 ] = { state . deck [ thisPlayer ] [ ( deckCounter - 1 ) ] } ; memcpy ( & testState , & state , sizeof ( struct gameState ) ) ; printf ( "\\n\\nTESTING<S2SV_blank>VILLAGE\\n\\n" ) ; cardEffect ( village , 0 , 0 , 0 , & testState , handPos , & bonus ) ; if ( testState . handCount [ thisPlayer ] == ( state . handCount [ thisPlayer ] + drawn - discarded ) ) { printf ( "HANDCOUNT<S2SV_blank>INCREASE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "HANDCOUNT<S2SV_blank>INCREASE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } if ( testState . deckCount [ thisPlayer ] == ( state . deckCount [ thisPlayer ] - drawn ) ) { printf ( "DECKCOUNT<S2SV_blank>DECREASE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "DECKCOUNT<S2SV_blank>DECREASE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } if ( ( testState . playedCards [ ( testState . playedCardCount - 1 ) ] == state . hand [ thisPlayer ] [ handPos ] ) && ( testState . playedCardCount == state . playedCardCount + 1 ) ) { printf ( "PLAYEDCARD<S2SV_blank>HAS<S2SV_blank>PLAYED<S2SV_blank>CARD<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; printf ( "PLAYEDCARDCOUNT<S2SV_blank>INCREASE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "PLAYEDCARD<S2SV_blank>HAS<S2SV_blank>PLAYED<S2SV_blank>CARD<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; printf ( "PLAYEDCARDCOUNT<S2SV_blank>INCREASE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } if ( ( testState . hand [ thisPlayer ] [ handPos ] == expectedCards [ 0 ] ) ) { printf ( "PLAYED<S2SV_blank>CARD\'S<S2SV_blank>POSITION<S2SV_blank>OCCUPIED<S2SV_blank>BY<S2SV_blank>NEW<S2SV_blank>CARD<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "PLAYED<S2SV_blank>CARD\'S<S2SV_blank>POSITION<S2SV_blank>OCCUPIED<S2SV_blank>BY<S2SV_blank>NEW<S2SV_blank>CARD<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } if ( testState . hand [ thisPlayer ] [ ( testState . handCount [ thisPlayer ] ) ] == - 1 ) { printf ( "POSITION<S2SV_blank>FORMERLY<S2SV_blank>OCCUPIED<S2SV_blank>NOW<S2SV_blank>VALUED<S2SV_blank>AT<S2SV_blank>-1<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "POSITION<S2SV_blank>FORMERLY<S2SV_blank>OCCUPIED<S2SV_blank>NOW<S2SV_blank>VALUED<S2SV_blank>AT<S2SV_blank>-1<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } if ( ( testState . hand [ thisPlayer ] [ handPos ] == expectedCards [ 0 ] ) ) { printf ( "CARD<S2SV_blank>DRAWN<S2SV_blank>IS<S2SV_blank>FORMER<S2SV_blank>TOP<S2SV_blank>FROM<S2SV_blank>PLAYERS<S2SV_blank>DECK<S2SV_blank>AND<S2SV_blank>IN<S2SV_blank>CORRECT<S2SV_blank>POSITION<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "CARD<S2SV_blank>DRAWN<S2SV_blank>IS<S2SV_blank>FORMER<S2SV_blank>TOP<S2SV_blank>FROM<S2SV_blank>PLAYERS<S2SV_blank>DECK<S2SV_blank>AND<S2SV_blank>IN<S2SV_blank>CORRECT<S2SV_blank>POSITION<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; <S2SV_StartBug> testPassed = 1 ; <S2SV_EndBug> } if ( testState . handCount [ 1 ] == state . handCount [ 1 ] ) { printf ( "HANDCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "HANDCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; printf ( "ENDING<S2SV_blank>TEST<S2SV_blank>TO<S2SV_blank>AVOID<S2SV_blank>CRASH\\n" ) ; return 0 ; } if ( testState . deckCount [ 1 ] == state . deckCount [ 1 ] ) { printf ( "DECKCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "DECKCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; printf ( "ENDING<S2SV_blank>TEST<S2SV_blank>TO<S2SV_blank>AVOID<S2SV_blank>CRASH\\n" ) ; return 0 ; } if ( testState . discardCount [ 1 ] == state . discardCount [ 1 ] ) { printf ( "DISCARDCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "DISCARDCOUNT<S2SV_blank>OF<S2SV_blank>OTHER<S2SV_blank>PLAYER<S2SV_blank>DIDN\'T<S2SV_blank>CHANGE<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; printf ( "ENDING<S2SV_blank>TEST<S2SV_blank>TO<S2SV_blank>AVOID<S2SV_blank>CRASH\\n" ) ; return 0 ; } int changeTestPass = 1 ; for ( i = 0 ; i < testState . handCount [ 1 ] ; i ++ ) { if ( testState . hand [ 1 ] [ i ] != state . hand [ 1 ] [ i ] ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>HAND<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; changeTestPass = 0 ; } } if ( changeTestPass == 1 ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>HAND<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } changeTestPass = 1 ; for ( i = 0 ; i < testState . deckCount [ 1 ] ; i ++ ) { if ( testState . deck [ 1 ] [ i ] != state . deck [ 1 ] [ i ] ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>DECK<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; changeTestPass = 0 ; } } if ( changeTestPass == 1 ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>DECK<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } changeTestPass = 1 ; for ( i = 0 ; i < testState . discardCount [ 1 ] ; i ++ ) { if ( testState . discard [ 1 ] [ i ] != state . discard [ 1 ] [ i ] ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>DISCARD<S2SV_blank>PILE<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; changeTestPass = 0 ; } } if ( changeTestPass == 1 ) { printf ( "OTHER<S2SV_blank>PLAYER\'S<S2SV_blank>DISCARD<S2SV_blank>PILE<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } changeTestPass = 1 ; for ( i = adventurer ; i <= treasure_map ; i ++ ) { if ( testState . supplyCount [ i ] != state . supplyCount [ i ] ) { printf ( "VICTORY<S2SV_blank>AND<S2SV_blank>KINGDOM<S2SV_blank>CARDS<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; changeTestPass = 0 ; testPassed = 0 ; } } if ( changeTestPass == 1 ) { printf ( "VICTORY<S2SV_blank>AND<S2SV_blank>KINGDOM<S2SV_blank>CARDS<S2SV_blank>NOT<S2SV_blank>AFFECTED<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } if ( testState . numActions == ( state . numActions + 2 ) ) { printf ( "NUMBER<S2SV_blank>OF<S2SV_blank>ACTIONS<S2SV_blank>INCREASED<S2SV_blank>BY<S2SV_blank>TWO<S2SV_blank>TEST:<S2SV_blank>PASSED\\n" ) ; } else { printf ( "NUMBER<S2SV_blank>OF<S2SV_blank>ACTIONS<S2SV_blank>INCREASED<S2SV_blank>BY<S2SV_blank>TWO<S2SV_blank>TEST:<S2SV_blank>FAILED\\n" ) ; testPassed = 0 ; } return testPassed ; } | <S2SV_ModStart> ; testPassed = 0 <S2SV_ModEnd> ; } if |
850 | CWE-000 static int l2tp_ip_bind ( struct sock * sk , struct sockaddr * uaddr , int addr_len ) { struct inet_sock * inet = inet_sk ( sk ) ; struct sockaddr_l2tpip * addr = ( struct sockaddr_l2tpip * ) uaddr ; <S2SV_StartBug> int ret = - EINVAL ; <S2SV_EndBug> <S2SV_StartBug> int chk_addr_ret ; <S2SV_EndBug> ret = - EADDRINUSE ; read_lock_bh ( & l2tp_ip_lock ) ; if ( __l2tp_ip_bind_lookup ( & init_net , addr -> l2tp_addr . s_addr , sk -> sk_bound_dev_if , addr -> l2tp_conn_id ) ) goto out_in_use ; read_unlock_bh ( & l2tp_ip_lock ) ; lock_sock ( sk ) ; if ( sk -> sk_state != TCP_CLOSE || addr_len < sizeof ( struct sockaddr_l2tpip ) ) goto out ; chk_addr_ret = inet_addr_type ( & init_net , addr -> l2tp_addr . s_addr ) ; ret = - EADDRNOTAVAIL ; if ( addr -> l2tp_addr . s_addr && chk_addr_ret != RTN_LOCAL && chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST ) goto out ; if ( addr -> l2tp_addr . s_addr ) inet -> inet_rcv_saddr = inet -> inet_saddr = addr -> l2tp_addr . s_addr ; if ( chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST ) inet -> inet_saddr = 0 ; sk_dst_reset ( sk ) ; l2tp_ip_sk ( sk ) -> conn_id = addr -> l2tp_conn_id ; write_lock_bh ( & l2tp_ip_lock ) ; sk_add_bind_node ( sk , & l2tp_ip_bind_table ) ; sk_del_node_init ( sk ) ; write_unlock_bh ( & l2tp_ip_lock ) ; ret = 0 ; <S2SV_StartBug> out : <S2SV_EndBug> release_sock ( sk ) ; return ret ; out_in_use : read_unlock_bh ( & l2tp_ip_lock ) ; return ret ; } | <S2SV_ModStart> ; int ret ; int chk_addr_ret ; if ( ! sock_flag ( sk , SOCK_ZAPPED ) ) return <S2SV_ModEnd> - EINVAL ; <S2SV_ModStart> - EINVAL ; if ( addr_len < sizeof ( struct sockaddr_l2tpip ) ) return - EINVAL ; if ( addr -> l2tp_family != AF_INET ) return - EINVAL <S2SV_ModEnd> ; ret = <S2SV_ModStart> = 0 ; sock_reset_flag ( sk , SOCK_ZAPPED ) ; |
851 | CWE-000 static int qeth_l2_probe_device ( struct ccwgroup_device * gdev ) { struct qeth_card * card = dev_get_drvdata ( & gdev -> dev ) ; int rc ; <S2SV_StartBug> rc = qeth_l2_create_device_attributes ( & gdev -> dev ) ; <S2SV_EndBug> if ( rc ) <S2SV_StartBug> return rc ; <S2SV_EndBug> INIT_LIST_HEAD ( & card -> vid_list ) ; INIT_LIST_HEAD ( & card -> mc_list ) ; card -> options . layer2 = 1 ; card -> info . hwtrap = 0 ; return 0 ; } | <S2SV_ModStart> int rc ; if ( gdev -> dev . type == & qeth_generic_devtype ) { <S2SV_ModStart> return rc ; } |
852 | CWE-000 TEST_CASE ( "trb_bme280_read" , component ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> component ) { TEST_ASSERT_EQUAL_INT8 ( 0 , i2c_init ( ) ) ; TEST_ASSERT_EQUAL_INT8 ( 0 , trb_bme280_read ( i2c_address , BME280_CHIP_ID_ADDR , & reg_value_8 , 1 ) ) ; TEST_ASSERT_EQUAL_INT8 ( chip_id , reg_value_8 ) ; TEST_ASSERT_EQUAL_INT8 ( 0 , i2c_driver_delete ( I2C_NUM_0 ) ) ; |
853 | CWE-000 static void scroll_print ( ) { int i ; int head , tail ; int offset = ( int ) ifinfo . position - ( int ) ifinfo . offset_buffer ; if ( offset >= ifinfo . text_size || offset < 0 ) { head = 0 ; tail = 0 ; } else { tail = offset + window_width / 2 ; if ( tail > ifinfo . text_size ) tail = ifinfo . text_size ; head = tail - window_width ; if ( head < 0 ) { tail += - head ; if ( tail > ifinfo . text_size ) tail = ifinfo . text_size ; head = 0 ; } } assert ( ( offset >= head && offset < tail ) || tail == head ) ; if ( tail > head ) <S2SV_StartBug> fwrite ( & ifinfo . text_buffer [ head ] , sizeof ( char ) , tail - head , stdout ) ; <S2SV_EndBug> putchar ( '\\n' ) ; for ( i = head ; i < tail ; i ++ ) { if ( i != offset ) <S2SV_StartBug> putchar ( '<S2SV_blank>' ) ; <S2SV_EndBug> else <S2SV_StartBug> putchar ( '|' ) ; <S2SV_EndBug> } } | <S2SV_ModStart> > head ) { char c = ifinfo . text_buffer [ tail ] ; ifinfo . text_buffer [ tail ] = 0 ; printw ( "%s" , <S2SV_ModEnd> & ifinfo . <S2SV_ModStart> [ head ] ) ; ifinfo . text_buffer [ tail ] = c ; } printw ( "\\n" <S2SV_ModEnd> ) ; for <S2SV_ModStart> != offset ) printw ( "%c" , <S2SV_ModEnd> '<S2SV_blank>' ) ; <S2SV_ModStart> ) ; else printw ( "%c" , <S2SV_ModEnd> '|' ) ; |
854 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Image_Adapter , render ) { <S2SV_EndBug> zend_long quality , ZEPHIR_LAST_CALL_STATUS ; zval * ext_param = NULL , * quality_param = NULL , _0$$3 , _1$$3 , _2$$3 , _4 ; zval ext , _3$$3 ; <S2SV_StartBug> zval * this_ptr = getThis ( ) ; <S2SV_EndBug> ZVAL_UNDEF ( & ext ) ; ZVAL_UNDEF ( & _3$$3 ) ; ZVAL_UNDEF ( & _0$$3 ) ; ZVAL_UNDEF ( & _1$$3 ) ; ZVAL_UNDEF ( & _2$$3 ) ; ZVAL_UNDEF ( & _4 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 0 , 2 , & ext_param , & quality_param ) ; if ( ! ext_param ) { ZEPHIR_INIT_VAR ( & ext ) ; ZVAL_STRING ( & ext , "" ) ; } else { zephir_get_strval ( & ext , ext_param ) ; } if ( ! quality_param ) { quality = 100 ; } else { quality = zephir_get_intval ( quality_param ) ; } if ( ! ( ! ( Z_TYPE_P ( & ext ) == IS_UNDEF ) && Z_STRLEN_P ( & ext ) ) ) { zephir_read_property ( & _0$$3 , this_ptr , SL ( "_file" ) , PH_NOISY_CC | PH_READONLY ) ; ZVAL_LONG ( & _1$$3 , 4 ) ; ZEPHIR_CALL_FUNCTION ( & _2$$3 , "pathinfo" , NULL , 72 , & _0$$3 , & _1$$3 ) ; zephir_check_call_status ( ) ; zephir_get_strval ( & _3$$3 , & _2$$3 ) ; ZEPHIR_CPY_WRT ( & ext , & _3$$3 ) ; } if ( ZEPHIR_IS_EMPTY ( & ext ) ) { ZEPHIR_INIT_NVAR ( & ext ) ; ZVAL_STRING ( & ext , "png" ) ; } if ( quality < 1 ) { quality = 1 ; } else if ( quality > 100 ) { quality = 100 ; } ZVAL_LONG ( & _4 , quality ) ; ZEPHIR_RETURN_CALL_METHOD ( this_ptr , "_render" , NULL , 0 , & ext , & _4 ) ; zephir_check_call_status ( ) ; RETURN_MM ( ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Mvc_Router_Route , getHostname ) { RETURN_MEMBER ( <S2SV_ModEnd> getThis ( ) <S2SV_ModStart> getThis ( ) , "_hostname" <S2SV_ModEnd> ) ; } |
855 | CWE-000 int testQueryParser ( ) { assertValidQuery ( "hello" ) ; assertValidQuery ( "hello<S2SV_blank>wor*" ) ; assertValidQuery ( "hello<S2SV_blank>world" ) ; assertValidQuery ( "hello<S2SV_blank>(world)" ) ; assertValidQuery ( "\\"hello<S2SV_blank>world\\"" ) ; assertValidQuery ( "\\"hello\\"" ) ; assertValidQuery ( "\\"hello<S2SV_blank>world\\"<S2SV_blank>\\"foo<S2SV_blank>bar\\"" ) ; assertValidQuery ( "\\"hello<S2SV_blank>world\\"|\\"foo<S2SV_blank>bar\\"" ) ; assertValidQuery ( "\\"hello<S2SV_blank>world\\"<S2SV_blank>(\\"foo<S2SV_blank>bar\\")" ) ; assertValidQuery ( "hello<S2SV_blank>\\"foo<S2SV_blank>bar\\"<S2SV_blank>world" ) ; assertValidQuery ( "hello|hallo|yellow<S2SV_blank>world" ) ; assertValidQuery ( "(hello|world|foo)<S2SV_blank>bar<S2SV_blank>baz<S2SV_blank>123" ) ; assertValidQuery ( "(hello|world|foo)<S2SV_blank>(bar<S2SV_blank>baz)" ) ; assertValidQuery ( "@title:(barack<S2SV_blank>obama)<S2SV_blank><S2SV_blank>@body:us|president" ) ; assertValidQuery ( "@ti_tle:barack<S2SV_blank>obama<S2SV_blank><S2SV_blank>@body:us" ) ; assertValidQuery ( "@title:barack<S2SV_blank>@body:obama" ) ; assertValidQuery ( "@tit_le|bo_dy:barack<S2SV_blank>@body|title|url|something_else:obama" ) ; assertValidQuery ( "hello,world;good+bye<S2SV_blank>foo.bar" ) ; assertValidQuery ( "@BusinessName:\\"Wells<S2SV_blank>Fargo<S2SV_blank>Bank,<S2SV_blank>National<S2SV_blank>Association\\"" ) ; assertValidQuery ( "foo<S2SV_blank>-bar<S2SV_blank>-(bar<S2SV_blank>baz)" ) ; assertValidQuery ( "(hello<S2SV_blank>world)|(goodbye<S2SV_blank>moon)" ) ; assertInvalidQuery ( "@title:" ) ; assertInvalidQuery ( "@body:@title:" ) ; assertInvalidQuery ( "@body|title:@title:" ) ; assertInvalidQuery ( "@body|title" ) ; assertValidQuery ( "hello<S2SV_blank>~world<S2SV_blank>~war" ) ; assertValidQuery ( "hello<S2SV_blank>~(world<S2SV_blank>war)" ) ; assertValidQuery ( "@number:[100<S2SV_blank>200]" ) ; assertValidQuery ( "@number:[100<S2SV_blank>-200]" ) ; assertValidQuery ( "@number:[(100<S2SV_blank>(200]" ) ; assertValidQuery ( "@number:[100<S2SV_blank>inf]" ) ; assertValidQuery ( "@number:[100<S2SV_blank>-inf]" ) ; assertValidQuery ( "@number:[-inf<S2SV_blank>+inf]" ) ; assertValidQuery ( "@number:[-inf<S2SV_blank>+inf]|@number:[100<S2SV_blank>200]" ) ; assertInvalidQuery ( "@number:[100<S2SV_blank>foo]" ) ; assertInvalidQuery ( "(foo" ) ; assertInvalidQuery ( "\\"foo" ) ; assertInvalidQuery ( "" ) ; assertInvalidQuery ( "()" ) ; assertValidQuery ( "שלום<S2SV_blank>עולם" ) ; char * err = NULL ; char * qt = "(hello|world)<S2SV_blank>and<S2SV_blank>\\"another<S2SV_blank>world\\"<S2SV_blank>(foo<S2SV_blank>is<S2SV_blank>bar)<S2SV_blank>-(baz<S2SV_blank>boo*)" ; RedisSearchCtx ctx ; <S2SV_StartBug> Query * q = NewQuery ( NULL , qt , strlen ( qt ) , 0 , 1 , 0xff , 0 , "zz" , DEFAULT_STOPWORDS , NULL , - 1 , 0 , <S2SV_EndBug> NULL , ( RSPayload ) { } , NULL ) ; QueryNode * n = Query_Parse ( q , & err ) ; if ( err ) FAIL ( "Error<S2SV_blank>parsing<S2SV_blank>query:<S2SV_blank>%s" , err ) ; __queryNode_Print ( q , n , 0 ) ; ASSERT ( err == NULL ) ; ASSERT ( n != NULL ) ; ASSERT_EQUAL ( n -> type , QN_PHRASE ) ; ASSERT_EQUAL ( n -> pn . exact , 0 ) ; ASSERT_EQUAL ( n -> pn . numChildren , 4 ) ; ASSERT_EQUAL ( n -> fieldMask , RS_FIELDMASK_ALL ) ; ASSERT ( n -> pn . children [ 0 ] -> type == QN_UNION ) ; ASSERT_STRING_EQ ( "hello" , n -> pn . children [ 0 ] -> un . children [ 0 ] -> tn . str ) ; ASSERT_STRING_EQ ( "world" , n -> pn . children [ 0 ] -> un . children [ 1 ] -> tn . str ) ; QueryNode * _n = n -> pn . children [ 1 ] ; ASSERT ( _n -> type == QN_PHRASE ) ; ASSERT ( _n -> pn . exact == 1 ) ; ASSERT_EQUAL ( _n -> pn . numChildren , 2 ) ; ASSERT_STRING_EQ ( "another" , _n -> pn . children [ 0 ] -> tn . str ) ; ASSERT_STRING_EQ ( "world" , _n -> pn . children [ 1 ] -> tn . str ) ; _n = n -> pn . children [ 2 ] ; ASSERT ( _n -> type == QN_PHRASE ) ; ASSERT ( _n -> pn . exact == 0 ) ; ASSERT_EQUAL ( _n -> pn . numChildren , 2 ) ; ASSERT_STRING_EQ ( "foo" , _n -> pn . children [ 0 ] -> tn . str ) ; ASSERT_STRING_EQ ( "bar" , _n -> pn . children [ 1 ] -> tn . str ) ; _n = n -> pn . children [ 3 ] ; ASSERT ( _n -> type == QN_NOT ) ; _n = _n -> not . child ; ASSERT ( _n -> pn . exact == 0 ) ; ASSERT_EQUAL ( _n -> pn . numChildren , 2 ) ; ASSERT_STRING_EQ ( "baz" , _n -> pn . children [ 0 ] -> tn . str ) ; ASSERT_EQUAL ( _n -> pn . children [ 1 ] -> type , QN_PREFX ) ; ASSERT_STRING_EQ ( "boo" , _n -> pn . children [ 1 ] -> pfx . str ) ; Query_Free ( q ) ; return 0 ; } | <S2SV_ModStart> , "zz" , DefaultStopWordList ( ) <S2SV_ModEnd> , NULL , |
856 | CWE-000 WD_HIMAGE wdCreateImageFromHBITMAP ( HBITMAP hBmp ) { if ( d2d_enabled ( ) ) { IWICBitmap * bitmap ; IWICBitmapSource * converted_bitmap ; HRESULT hr ; if ( wic_factory == NULL ) { WD_TRACE ( "wdCreateImageFromHBITMAP:<S2SV_blank>Image<S2SV_blank>API<S2SV_blank>disabled." ) ; return NULL ; } hr = IWICImagingFactory_CreateBitmapFromHBITMAP ( wic_factory , hBmp , NULL , WICBitmapUsePremultipliedAlpha , & bitmap ) ; if ( FAILED ( hr ) ) { WD_TRACE_HR ( "wdCreateImageFromHBITMAP:<S2SV_blank>" "IWICImagingFactory::CreateBitmapFromHBITMAP()<S2SV_blank>failed." ) ; return NULL ; } converted_bitmap = wic_convert_bitmap ( ( IWICBitmapSource * ) bitmap ) ; if ( converted_bitmap == NULL ) WD_TRACE ( "wdCreateImageFromHBITMAP:<S2SV_blank>wic_convert_bitmap()<S2SV_blank>failed." ) ; IWICBitmap_Release ( bitmap ) ; return ( WD_HIMAGE ) converted_bitmap ; } else { dummy_GpBitmap * b ; int status ; <S2SV_StartBug> status = gdix_vtable -> fn_CreateBitmapFromHBITMAP ( hBmp , NULL , & b ) ; <S2SV_EndBug> if ( status != 0 ) { WD_TRACE ( "wdCreateImageFromHBITMAP:<S2SV_blank>" "GdipCreateBitmapFromHBITMAP()<S2SV_blank>failed.<S2SV_blank>[%d]" , status ) ; return NULL ; } return ( WD_HIMAGE ) b ; } } | <S2SV_ModStart> ; status = gdix_create_bitmap ( hBmp <S2SV_ModEnd> , & b |
857 | CWE-000 xmlNode * create_operation_update ( xmlNode * parent , lrmd_event_data_t * op , const char * caller_version , int target_rc , const char * node , const char * origin , int level ) { char * key = NULL ; char * magic = NULL ; char * op_id = NULL ; char * op_id_additional = NULL ; char * local_user_data = NULL ; const char * exit_reason = NULL ; xmlNode * xml_op = NULL ; const char * task = NULL ; CRM_CHECK ( op != NULL , return NULL ) ; do_crm_log ( level , "%s:<S2SV_blank>Updating<S2SV_blank>resource<S2SV_blank>%s<S2SV_blank>after<S2SV_blank>%s<S2SV_blank>op<S2SV_blank>%s<S2SV_blank>(interval=%u)" , origin , op -> rsc_id , op -> op_type , services_lrm_status_str ( op -> op_status ) , op -> interval_ms ) ; crm_trace ( "DC<S2SV_blank>version:<S2SV_blank>%s" , caller_version ) ; task = op -> op_type ; if ( crm_str_eq ( task , "reload" , TRUE ) ) { if ( op -> op_status == PCMK_LRM_OP_DONE ) { task = CRMD_ACTION_START ; } else { task = CRMD_ACTION_STATUS ; } } else if ( crm_str_eq ( task , CRMD_ACTION_MIGRATE , TRUE ) ) { if ( op -> op_status == PCMK_LRM_OP_DONE ) { task = CRMD_ACTION_STOP ; } else { task = CRMD_ACTION_STATUS ; } } else if ( ( op -> op_status == PCMK_LRM_OP_DONE ) && crm_str_eq ( task , CRMD_ACTION_MIGRATED , TRUE ) ) { task = CRMD_ACTION_START ; } key = generate_op_key ( op -> rsc_id , task , op -> interval_ms ) ; if ( crm_str_eq ( task , CRMD_ACTION_NOTIFY , TRUE ) ) { const char * n_type = crm_meta_value ( op -> params , "notify_type" ) ; const char * n_task = crm_meta_value ( op -> params , "notify_operation" ) ; CRM_LOG_ASSERT ( n_type != NULL ) ; CRM_LOG_ASSERT ( n_task != NULL ) ; op_id = generate_notify_key ( op -> rsc_id , n_type , n_task ) ; <S2SV_StartBug> op -> op_status = PCMK_LRM_OP_DONE ; <S2SV_EndBug> <S2SV_StartBug> op -> rc = 0 ; <S2SV_EndBug> } else if ( did_rsc_op_fail ( op , target_rc ) ) { op_id = generate_op_key ( op -> rsc_id , "last_failure" , 0 ) ; if ( op -> interval_ms == 0 ) { op_id_additional = generate_op_key ( op -> rsc_id , "last" , 0 ) ; } exit_reason = op -> exit_reason ; } else if ( op -> interval_ms > 0 ) { op_id = strdup ( key ) ; } else { op_id = generate_op_key ( op -> rsc_id , "last" , 0 ) ; } again : xml_op = find_entity ( parent , XML_LRM_TAG_RSC_OP , op_id ) ; if ( xml_op == NULL ) { xml_op = create_xml_node ( parent , XML_LRM_TAG_RSC_OP ) ; } if ( op -> user_data == NULL ) { crm_debug ( "Generating<S2SV_blank>fake<S2SV_blank>transition<S2SV_blank>key<S2SV_blank>for:<S2SV_blank>" CRM_OP_FMT "<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>%s" , op -> rsc_id , op -> op_type , op -> interval_ms , op -> call_id , origin ) ; local_user_data = generate_transition_key ( - 1 , op -> call_id , target_rc , FAKE_TE_ID ) ; op -> user_data = local_user_data ; } if ( magic == NULL ) { magic = generate_transition_magic ( op -> user_data , op -> op_status , op -> rc ) ; } crm_xml_add ( xml_op , XML_ATTR_ID , op_id ) ; crm_xml_add ( xml_op , XML_LRM_ATTR_TASK_KEY , key ) ; crm_xml_add ( xml_op , XML_LRM_ATTR_TASK , task ) ; crm_xml_add ( xml_op , XML_ATTR_ORIGIN , origin ) ; crm_xml_add ( xml_op , XML_ATTR_CRM_VERSION , caller_version ) ; crm_xml_add ( xml_op , XML_ATTR_TRANSITION_KEY , op -> user_data ) ; crm_xml_add ( xml_op , XML_ATTR_TRANSITION_MAGIC , magic ) ; crm_xml_add ( xml_op , XML_LRM_ATTR_EXIT_REASON , exit_reason == NULL ? "" : exit_reason ) ; crm_xml_add ( xml_op , XML_LRM_ATTR_TARGET , node ) ; crm_xml_add_int ( xml_op , XML_LRM_ATTR_CALLID , op -> call_id ) ; crm_xml_add_int ( xml_op , XML_LRM_ATTR_RC , op -> rc ) ; crm_xml_add_int ( xml_op , XML_LRM_ATTR_OPSTATUS , op -> op_status ) ; crm_xml_add_ms ( xml_op , XML_LRM_ATTR_INTERVAL_MS , op -> interval_ms ) ; if ( compare_version ( "2.1" , caller_version ) <= 0 ) { if ( op -> t_run || op -> t_rcchange || op -> exec_time || op -> queue_time ) { crm_trace ( "Timing<S2SV_blank>data<S2SV_blank>(" CRM_OP_FMT "):<S2SV_blank>last=%u<S2SV_blank>change=%u<S2SV_blank>exec=%u<S2SV_blank>queue=%u" , op -> rsc_id , op -> op_type , op -> interval_ms , op -> t_run , op -> t_rcchange , op -> exec_time , op -> queue_time ) ; if ( op -> interval_ms == 0 ) { crm_xml_add_int ( xml_op , XML_RSC_OP_LAST_RUN , op -> t_run ) ; crm_xml_add_int ( xml_op , XML_RSC_OP_LAST_CHANGE , op -> t_run ) ; } else if ( op -> t_rcchange ) { crm_xml_add_int ( xml_op , XML_RSC_OP_LAST_CHANGE , op -> t_rcchange ) ; } else { crm_xml_add_int ( xml_op , XML_RSC_OP_LAST_CHANGE , op -> t_run ) ; } crm_xml_add_int ( xml_op , XML_RSC_OP_T_EXEC , op -> exec_time ) ; crm_xml_add_int ( xml_op , XML_RSC_OP_T_QUEUE , op -> queue_time ) ; } } if ( crm_str_eq ( op -> op_type , CRMD_ACTION_MIGRATE , TRUE ) || crm_str_eq ( op -> op_type , CRMD_ACTION_MIGRATED , TRUE ) ) { const char * name = XML_LRM_ATTR_MIGRATE_SOURCE ; crm_xml_add ( xml_op , name , crm_meta_value ( op -> params , name ) ) ; name = XML_LRM_ATTR_MIGRATE_TARGET ; crm_xml_add ( xml_op , name , crm_meta_value ( op -> params , name ) ) ; } append_digest ( op , xml_op , caller_version , magic , LOG_DEBUG ) ; if ( op_id_additional ) { free ( op_id ) ; op_id = op_id_additional ; op_id_additional = NULL ; goto again ; } if ( local_user_data ) { free ( local_user_data ) ; op -> user_data = NULL ; } free ( magic ) ; free ( op_id ) ; free ( key ) ; return xml_op ; } | <S2SV_ModStart> n_task ) ; if ( <S2SV_ModStart> op -> op_status != PCMK_LRM_OP_PENDING ) { op -> op_status <S2SV_ModStart> = 0 ; } |
858 | CWE-000 void update_single_sensor ( int sensor_val , struct Cell nearby_cells [ 9 ] , int sensor_positions [ 3 ] [ 2 ] , int sensor_pos_in_eevee [ 2 ] ) { int possible_walls_size = 3 * 9 * 4 ; int currently_weighted_walls = 0 ; struct Wall * weighted_walls [ possible_walls_size ] ; if ( sensor_val < sensor_cutoff_point ) { int ray_dists [ 3 ] = { max_dist_threshold , max_dist_threshold , max_dist_threshold } ; struct Wall * ray_walls [ 3 ] ; int sensor_index , cell_index , wall_index ; for ( sensor_index = 0 ; sensor_index < 3 ; sensor_index ++ ) { for ( cell_index = 0 ; cell_index < 9 ; cell_index ++ ) { for ( wall_index = 0 ; wall_index < 4 ; wall_index ++ ) { struct Wall wall = * nearby_cells [ cell_index ] . walls [ wall_index ] ; int d = dist_to_line_segment ( sensor_positions [ sensor_index ] , wall . line [ 0 ] , wall . line [ 1 ] ) ; if ( d < ray_dists [ sensor_index ] ) { ray_dists [ sensor_index ] = d ; ray_walls [ sensor_index ] = & wall ; } } } } int min_index = 0 ; if ( ray_dists [ 1 ] < ray_dists [ 0 ] && ray_dists [ 1 ] < ray_dists [ 2 ] ) min_index = 1 ; else if ( ray_dists [ 2 ] < ray_dists [ 0 ] && ray_dists [ 2 ] < ray_dists [ 1 ] ) min_index = 2 ; struct Wall closest_dot_cell_wall = * ray_walls [ min_index ] ; int trust_val = trust_based_on_distance ( dist_to_line_segment ( sensor_pos_in_eevee , closest_dot_cell_wall . line [ 0 ] , closest_dot_cell_wall . line [ 1 ] ) ) ; weigh_wall ( & closest_dot_cell_wall , trust_val ) ; weighted_walls [ 0 ] = & closest_dot_cell_wall ; currently_weighted_walls ++ ; } int sensor_index , cell_index , wall_index ; for ( sensor_index = 0 ; sensor_index < 3 ; sensor_index ++ ) { for ( cell_index = 0 ; cell_index < 9 ; cell_index ++ ) { for ( wall_index = 0 ; wall_index < 4 ; wall_index ++ ) { struct Wall * wall = nearby_cells [ cell_index ] . walls [ wall_index ] ; int wall_not_in_weighted_walls = 1 ; int i ; for ( i = 0 ; i < currently_weighted_walls ; i ++ ) { if ( wall == weighted_walls [ i ] ) { wall_not_in_weighted_walls = 0 ; break ; } } if ( wall_not_in_weighted_walls && intersects ( wall -> line [ 0 ] , wall -> line [ 1 ] , sensor_pos_in_eevee , sensor_positions [ sensor_index ] ) ) { int dist = dist_to_line_segment ( sensor_pos_in_eevee , wall -> line [ 0 ] , wall -> line [ 1 ] ) ; <S2SV_StartBug> if ( dist < 1 ) { <S2SV_EndBug> int trust_val = trust_based_on_distance ( dist ) ; weigh_wall ( wall , - trust_val ) ; weighted_walls [ currently_weighted_walls ] = wall ; currently_weighted_walls ++ ; } } } } } } | <S2SV_ModStart> ( dist < m_p <S2SV_ModEnd> ) { int |
859 | CWE-000 void augment_type_symtab ( void ) { struct compunit_symtab * cust = buildsym_compunit -> compunit_symtab ; const struct blockvector * blockvector = COMPUNIT_BLOCKVECTOR ( cust ) ; if ( ! buildsym_compunit -> m_context_stack . empty ( ) ) complaint ( & symfile_complaints , _ ( "Context<S2SV_blank>stack<S2SV_blank>not<S2SV_blank>empty<S2SV_blank>in<S2SV_blank>augment_type_symtab" ) ) ; if ( buildsym_compunit -> m_pending_blocks != NULL ) complaint ( & symfile_complaints , _ ( "Blocks<S2SV_blank>in<S2SV_blank>a<S2SV_blank>type<S2SV_blank>symtab" ) ) ; if ( buildsym_compunit -> m_pending_macros != NULL ) complaint ( & symfile_complaints , _ ( "Macro<S2SV_blank>in<S2SV_blank>a<S2SV_blank>type<S2SV_blank>symtab" ) ) ; if ( buildsym_compunit -> m_have_line_numbers ) complaint ( & symfile_complaints , _ ( "Line<S2SV_blank>numbers<S2SV_blank>recorded<S2SV_blank>in<S2SV_blank>a<S2SV_blank>type<S2SV_blank>symtab" ) ) ; <S2SV_StartBug> if ( file_symbols != NULL ) <S2SV_EndBug> { struct block * block = BLOCKVECTOR_BLOCK ( blockvector , STATIC_BLOCK ) ; <S2SV_StartBug> set_missing_symtab ( file_symbols , cust ) ; <S2SV_EndBug> <S2SV_StartBug> dict_add_pending ( BLOCK_DICT ( block ) , file_symbols ) ; <S2SV_EndBug> } <S2SV_StartBug> if ( global_symbols != NULL ) <S2SV_EndBug> { struct block * block = BLOCKVECTOR_BLOCK ( blockvector , GLOBAL_BLOCK ) ; <S2SV_StartBug> set_missing_symtab ( global_symbols , cust ) ; <S2SV_EndBug> <S2SV_StartBug> dict_add_pending ( BLOCK_DICT ( block ) , global_symbols ) ; <S2SV_EndBug> } reset_symtab_globals ( ) ; } | <S2SV_ModStart> ; if ( * get_file_symbols ( ) <S2SV_ModEnd> != NULL ) <S2SV_ModStart> ; set_missing_symtab ( buildsym_compunit -> m_file_symbols <S2SV_ModEnd> , cust ) <S2SV_ModStart> block ) , buildsym_compunit -> m_file_symbols <S2SV_ModEnd> ) ; } <S2SV_ModStart> } if ( * get_global_symbols ( ) <S2SV_ModEnd> != NULL ) <S2SV_ModStart> ; set_missing_symtab ( buildsym_compunit -> m_global_symbols <S2SV_ModEnd> , cust ) <S2SV_ModStart> block ) , buildsym_compunit -> m_global_symbols <S2SV_ModEnd> ) ; } |
860 | CWE-000 <S2SV_StartBug> int take_device ( struct session_info_t * S , const char * path ) { <S2SV_EndBug> <S2SV_StartBug> int ret ; <S2SV_EndBug> struct stat st ; sd_bus_error error = SD_BUS_ERROR_NULL ; int fd , paused ; <S2SV_StartBug> ret = stat ( path , & st ) ; <S2SV_EndBug> if ( ret < 0 ) { fprintf ( stderr , "ERR<S2SV_blank>on<S2SV_blank>stat(%s):<S2SV_blank>%s\\n" , path , strerror ( errno ) ) ; goto end ; } ret = sd_bus_call_method ( S -> bus , "org.freedesktop.login1" , S -> object , "org.freedesktop.login1.Session" , "TakeDevice" , & error , & S -> TD_msg , "uu" , <S2SV_StartBug> major ( st . st_rdev ) , minor ( st . st_rdev ) ) ; <S2SV_EndBug> if ( ret < 0 ) { <S2SV_StartBug> fprintf ( stderr , "ERR<S2SV_blank>on<S2SV_blank>TakeDevice(%s):<S2SV_blank>%s\\n" , path , error . message ) ; <S2SV_EndBug> goto end ; } ret = sd_bus_message_read ( S -> TD_msg , "hb" , & fd , & paused ) ; if ( ret < 0 ) { <S2SV_StartBug> fprintf ( stderr , "ERR<S2SV_blank>on<S2SV_blank>message_read(%s):<S2SV_blank>%s\\n" , path , strerror ( - ret ) ) ; <S2SV_EndBug> } <S2SV_StartBug> printf ( "%s<S2SV_blank>opened,<S2SV_blank>paused:<S2SV_blank>%i\\n" , path , paused ) ; <S2SV_EndBug> end : sd_bus_error_free ( & error ) ; return ret < 0 ? EXIT_FAILURE : fd ; } | <S2SV_ModStart> * S , int major , int minor <S2SV_ModEnd> ) { int <S2SV_ModStart> { int ret <S2SV_ModEnd> ; sd_bus_error error <S2SV_ModStart> , paused ; printf ( "%i,<S2SV_blank>%i\\n" , major , minor ) ; <S2SV_ModEnd> ret = sd_bus_call_method <S2SV_ModStart> "uu" , major , minor <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( stderr , "ERR<S2SV_blank>on<S2SV_blank>TakeDevice:<S2SV_blank>%s\\n" <S2SV_ModEnd> , error . <S2SV_ModStart> ( stderr , "ERR<S2SV_blank>on<S2SV_blank>message_read:<S2SV_blank>%s\\n" <S2SV_ModEnd> , strerror ( <S2SV_ModStart> } printf ( "opened,<S2SV_blank>paused:<S2SV_blank>%i\\n" <S2SV_ModEnd> , paused ) |
861 | CWE-000 static int amdgpu_device_parse_gpu_info_fw ( struct amdgpu_device * adev ) { <S2SV_StartBug> const struct firmware * fw ; <S2SV_EndBug> const char * chip_name ; char fw_name [ 30 ] ; int err ; const struct gpu_info_firmware_header_v1_0 * hdr ; <S2SV_StartBug> switch ( adev -> asic_type ) { <S2SV_EndBug> case CHIP_TOPAZ : case CHIP_TONGA : case CHIP_FIJI : case CHIP_POLARIS11 : case CHIP_POLARIS10 : case CHIP_POLARIS12 : case CHIP_CARRIZO : case CHIP_STONEY : # ifdef CONFIG_DRM_AMDGPU_SI case CHIP_VERDE : case CHIP_TAHITI : case CHIP_PITCAIRN : case CHIP_OLAND : case CHIP_HAINAN : # endif # ifdef CONFIG_DRM_AMDGPU_CIK case CHIP_BONAIRE : case CHIP_HAWAII : case CHIP_KAVERI : case CHIP_KABINI : case CHIP_MULLINS : # endif default : return 0 ; case CHIP_VEGA10 : chip_name = "vega10" ; break ; case CHIP_RAVEN : chip_name = "raven" ; break ; } snprintf ( fw_name , sizeof ( fw_name ) , "amdgpu/%s_gpu_info.bin" , chip_name ) ; <S2SV_StartBug> err = request_firmware ( & fw , fw_name , adev -> dev ) ; <S2SV_EndBug> if ( err ) { dev_err ( adev -> dev , "Failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>gpu_info<S2SV_blank>firmware<S2SV_blank>\\"%s\\"\\n" , fw_name ) ; goto out ; } <S2SV_StartBug> err = amdgpu_ucode_validate ( fw ) ; <S2SV_EndBug> if ( err ) { dev_err ( adev -> dev , "Failed<S2SV_blank>to<S2SV_blank>validate<S2SV_blank>gpu_info<S2SV_blank>firmware<S2SV_blank>\\"%s\\"\\n" , fw_name ) ; goto out ; } <S2SV_StartBug> hdr = ( const struct gpu_info_firmware_header_v1_0 * ) fw -> data ; <S2SV_EndBug> amdgpu_ucode_print_gpu_info_hdr ( & hdr -> header ) ; switch ( hdr -> version_major ) { case 1 : { const struct gpu_info_firmware_v1_0 * gpu_info_fw = <S2SV_StartBug> ( const struct gpu_info_firmware_v1_0 * ) ( fw -> data + <S2SV_EndBug> le32_to_cpu ( hdr -> header . ucode_array_offset_bytes ) ) ; adev -> gfx . config . max_shader_engines = le32_to_cpu ( gpu_info_fw -> gc_num_se ) ; adev -> gfx . config . max_cu_per_sh = le32_to_cpu ( gpu_info_fw -> gc_num_cu_per_sh ) ; adev -> gfx . config . max_sh_per_se = le32_to_cpu ( gpu_info_fw -> gc_num_sh_per_se ) ; adev -> gfx . config . max_backends_per_se = le32_to_cpu ( gpu_info_fw -> gc_num_rb_per_se ) ; adev -> gfx . config . max_texture_channel_caches = le32_to_cpu ( gpu_info_fw -> gc_num_tccs ) ; adev -> gfx . config . max_gprs = le32_to_cpu ( gpu_info_fw -> gc_num_gprs ) ; adev -> gfx . config . max_gs_threads = le32_to_cpu ( gpu_info_fw -> gc_num_max_gs_thds ) ; adev -> gfx . config . gs_vgt_table_depth = le32_to_cpu ( gpu_info_fw -> gc_gs_table_depth ) ; adev -> gfx . config . gs_prim_buffer_depth = le32_to_cpu ( gpu_info_fw -> gc_gsprim_buff_depth ) ; adev -> gfx . config . double_offchip_lds_buf = le32_to_cpu ( gpu_info_fw -> gc_double_offchip_lds_buffer ) ; adev -> gfx . cu_info . wave_front_size = le32_to_cpu ( gpu_info_fw -> gc_wave_size ) ; adev -> gfx . cu_info . max_waves_per_simd = le32_to_cpu ( gpu_info_fw -> gc_max_waves_per_simd ) ; adev -> gfx . cu_info . max_scratch_slots_per_cu = le32_to_cpu ( gpu_info_fw -> gc_max_scratch_slots_per_cu ) ; adev -> gfx . cu_info . lds_size = le32_to_cpu ( gpu_info_fw -> gc_lds_size ) ; break ; } default : dev_err ( adev -> dev , "Unsupported<S2SV_blank>gpu_info<S2SV_blank>table<S2SV_blank>%d\\n" , hdr -> header . ucode_version ) ; err = - EINVAL ; goto out ; } out : <S2SV_StartBug> release_firmware ( fw ) ; <S2SV_EndBug> fw = NULL ; return err ; } | <S2SV_ModStart> adev ) { <S2SV_ModEnd> const char * <S2SV_ModStart> * hdr ; adev -> firmware . gpu_info_fw = NULL ; <S2SV_ModStart> request_firmware ( & adev -> firmware . gpu_info_fw <S2SV_ModEnd> , fw_name , <S2SV_ModStart> = amdgpu_ucode_validate ( adev -> firmware . gpu_info_fw <S2SV_ModEnd> ) ; if <S2SV_ModStart> gpu_info_firmware_header_v1_0 * ) adev -> firmware . gpu_info_fw <S2SV_ModEnd> -> data ; <S2SV_ModStart> * ) ( adev -> firmware . gpu_info_fw <S2SV_ModEnd> -> data + <S2SV_ModStart> } out : <S2SV_ModEnd> return err ; |
862 | CWE-000 int be_rename ( libbe_handle_t * lbh , char * old , char * new ) { char full_old [ BE_MAXPATHLEN ] ; char full_new [ BE_MAXPATHLEN ] ; zfs_handle_t * zfs_hdl ; int err ; if ( ( err = be_root_concat ( lbh , old , full_old ) ) != 0 ) return ( set_error ( lbh , err ) ) ; if ( ( err = be_root_concat ( lbh , new , full_new ) ) != 0 ) return ( set_error ( lbh , err ) ) ; <S2SV_StartBug> if ( be_validate_name ( lbh , new ) != 0 ) <S2SV_EndBug> <S2SV_StartBug> return ( BE_ERR_UNKNOWN ) ; <S2SV_EndBug> <S2SV_StartBug> if ( strcmp ( full_new , be_active_path ( lbh ) ) == 0 ) <S2SV_EndBug> <S2SV_StartBug> return ( BE_ERR_UNKNOWN ) ; <S2SV_EndBug> if ( ! zfs_dataset_exists ( lbh -> lzh , full_old , ZFS_TYPE_DATASET ) ) <S2SV_StartBug> return ( BE_ERR_UNKNOWN ) ; <S2SV_EndBug> if ( zfs_dataset_exists ( lbh -> lzh , full_new , ZFS_TYPE_DATASET ) ) <S2SV_StartBug> return ( BE_ERR_UNKNOWN ) ; <S2SV_EndBug> if ( ( zfs_hdl = zfs_open ( lbh -> lzh , full_old , ZFS_TYPE_FILESYSTEM ) ) == NULL ) <S2SV_StartBug> return ( BE_ERR_UNKNOWN ) ; <S2SV_EndBug> struct renameflags flags = { 0 , 0 , 0 } ; err = zfs_rename ( zfs_hdl , NULL , full_new , flags ) ; zfs_close ( zfs_hdl ) ; return ( set_error ( lbh , err ) ) ; } | <S2SV_ModStart> ; if ( ( err = <S2SV_ModStart> , new ) ) <S2SV_ModStart> ) return ( err <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( strcmp ( full_old <S2SV_ModEnd> , be_active_path ( <S2SV_ModStart> ) return ( set_error ( lbh , BE_ERR_MOUNTED ) <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) return ( set_error ( lbh , BE_ERR_NOENT ) <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) return ( set_error ( lbh , BE_ERR_EXISTS ) <S2SV_ModEnd> ) ; if <S2SV_ModStart> ) return ( set_error ( lbh , BE_ERR_ZFSOPEN ) <S2SV_ModEnd> ) ; struct |
863 | CWE-000 void qxl_release_unmap ( struct qxl_device * qdev , struct qxl_release * release , union qxl_release_info * info ) { struct qxl_bo_list * entry = list_first_entry ( & release -> bos , struct qxl_bo_list , tv . head ) ; struct qxl_bo * bo = to_qxl_bo ( entry -> tv . bo ) ; void * ptr ; <S2SV_StartBug> ptr = ( ( void * ) info ) - ( release -> release_offset & ~ PAGE_SIZE ) ; <S2SV_EndBug> qxl_bo_kunmap_atomic_page ( qdev , bo , ptr ) ; } | <S2SV_ModStart> release_offset & ~ PAGE_MASK <S2SV_ModEnd> ) ; qxl_bo_kunmap_atomic_page |
864 | CWE-000 static bool cp_symbol_name_matches_1 ( const char * symbol_search_name , const char * lookup_name , size_t lookup_name_len , strncmp_iw_mode mode , completion_match * match , completion_match_for_lcd * match_for_lcd ) { const char * sname = symbol_search_name ; while ( true ) { if ( strncmp_iw_with_mode ( sname , lookup_name , lookup_name_len , <S2SV_StartBug> mode ) == 0 ) <S2SV_EndBug> { if ( match != NULL ) match -> set_match ( symbol_search_name ) ; if ( match_for_lcd != NULL ) match_for_lcd -> set_match ( sname ) ; return true ; } unsigned int len = cp_find_first_component ( sname ) ; if ( sname [ len ] == '\\0' ) return false ; gdb_assert ( sname [ len ] == ':' ) ; sname += len + 2 ; } } | <S2SV_ModStart> lookup_name_len , mode , language_cplus |
865 | CWE-000 void brw_blorp_blit_miptrees ( struct brw_context * brw , struct intel_mipmap_tree * src_mt , unsigned src_level , unsigned src_layer , mesa_format src_format , int src_swizzle , struct intel_mipmap_tree * dst_mt , unsigned dst_level , unsigned dst_layer , mesa_format dst_format , float src_x0 , float src_y0 , float src_x1 , float src_y1 , float dst_x0 , float dst_y0 , float dst_x1 , float dst_y1 , GLenum gl_filter , bool mirror_x , bool mirror_y , bool decode_srgb , bool encode_srgb ) { const struct gen_device_info * devinfo = & brw -> screen -> devinfo ; DBG ( "%s<S2SV_blank>from<S2SV_blank>%dx<S2SV_blank>%s<S2SV_blank>mt<S2SV_blank>%p<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>(%f,%f)<S2SV_blank>(%f,%f)<S2SV_blank>" "to<S2SV_blank>%dx<S2SV_blank>%s<S2SV_blank>mt<S2SV_blank>%p<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>(%f,%f)<S2SV_blank>(%f,%f)<S2SV_blank>(flip<S2SV_blank>%d,%d)\\n" , __func__ , src_mt -> surf . samples , _mesa_get_format_name ( src_mt -> format ) , src_mt , src_level , src_layer , src_x0 , src_y0 , src_x1 , src_y1 , dst_mt -> surf . samples , _mesa_get_format_name ( dst_mt -> format ) , dst_mt , dst_level , dst_layer , dst_x0 , dst_y0 , dst_x1 , dst_y1 , mirror_x , mirror_y ) ; if ( ! decode_srgb && _mesa_get_format_color_encoding ( src_format ) == GL_SRGB ) src_format = _mesa_get_srgb_format_linear ( src_format ) ; if ( ! encode_srgb && _mesa_get_format_color_encoding ( dst_format ) == GL_SRGB ) dst_format = _mesa_get_srgb_format_linear ( dst_format ) ; if ( devinfo -> gen == 6 && src_mt -> surf . samples > 1 && dst_mt -> surf . samples <= 1 && src_mt -> format == dst_mt -> format && ( dst_format == MESA_FORMAT_L_FLOAT32 || dst_format == MESA_FORMAT_I_FLOAT32 ) ) { src_format = dst_format = MESA_FORMAT_R_FLOAT32 ; } enum blorp_filter blorp_filter ; if ( fabsf ( dst_x1 - dst_x0 ) == fabsf ( src_x1 - src_x0 ) && fabsf ( dst_y1 - dst_y0 ) == fabsf ( src_y1 - src_y0 ) ) { if ( src_mt -> surf . samples > 1 && dst_mt -> surf . samples <= 1 ) { GLenum base_format = _mesa_get_format_base_format ( src_mt -> format ) ; if ( base_format == GL_DEPTH_COMPONENT || base_format == GL_STENCIL_INDEX || base_format == GL_DEPTH_STENCIL || _mesa_is_format_integer ( src_mt -> format ) ) { blorp_filter = BLORP_FILTER_SAMPLE_0 ; } else { blorp_filter = BLORP_FILTER_AVERAGE ; } } else { blorp_filter = BLORP_FILTER_NONE ; } } else if ( gl_filter == GL_LINEAR || gl_filter == GL_SCALED_RESOLVE_FASTEST_EXT || gl_filter == GL_SCALED_RESOLVE_NICEST_EXT ) { blorp_filter = BLORP_FILTER_BILINEAR ; } else { blorp_filter = BLORP_FILTER_NEAREST ; } enum isl_format src_isl_format = brw_blorp_to_isl_format ( brw , src_format , false ) ; enum isl_aux_usage src_aux_usage = <S2SV_StartBug> intel_miptree_texture_aux_usage ( brw , src_mt , src_isl_format ) ; <S2SV_EndBug> if ( src_aux_usage == ISL_AUX_USAGE_HIZ ) src_aux_usage = ISL_AUX_USAGE_NONE ; const bool src_clear_supported = src_aux_usage != ISL_AUX_USAGE_NONE && src_mt -> format == src_format ; intel_miptree_prepare_access ( brw , src_mt , src_level , 1 , src_layer , 1 , src_aux_usage , src_clear_supported ) ; enum isl_format dst_isl_format = brw_blorp_to_isl_format ( brw , dst_format , true ) ; enum isl_aux_usage dst_aux_usage = intel_miptree_render_aux_usage ( brw , dst_mt , dst_isl_format , false , false ) ; const bool dst_clear_supported = dst_aux_usage != ISL_AUX_USAGE_NONE ; intel_miptree_prepare_access ( brw , dst_mt , dst_level , 1 , dst_layer , 1 , dst_aux_usage , dst_clear_supported ) ; struct isl_surf tmp_surfs [ 2 ] ; struct blorp_surf src_surf , dst_surf ; blorp_surf_for_miptree ( brw , & src_surf , src_mt , src_aux_usage , false , & src_level , src_layer , 1 , & tmp_surfs [ 0 ] ) ; blorp_surf_for_miptree ( brw , & dst_surf , dst_mt , dst_aux_usage , true , & dst_level , dst_layer , 1 , & tmp_surfs [ 1 ] ) ; struct isl_swizzle src_isl_swizzle = { . r = swizzle_to_scs ( GET_SWZ ( src_swizzle , 0 ) ) , . g = swizzle_to_scs ( GET_SWZ ( src_swizzle , 1 ) ) , . b = swizzle_to_scs ( GET_SWZ ( src_swizzle , 2 ) ) , . a = swizzle_to_scs ( GET_SWZ ( src_swizzle , 3 ) ) , } ; struct blorp_batch batch ; blorp_batch_init ( & brw -> blorp , & batch , brw , 0 ) ; blorp_blit ( & batch , & src_surf , src_level , src_layer , src_isl_format , src_isl_swizzle , & dst_surf , dst_level , dst_layer , dst_isl_format , ISL_SWIZZLE_IDENTITY , src_x0 , src_y0 , src_x1 , src_y1 , dst_x0 , dst_y0 , dst_x1 , dst_y1 , blorp_filter , mirror_x , mirror_y ) ; blorp_batch_finish ( & batch ) ; intel_miptree_finish_write ( brw , dst_mt , dst_level , dst_layer , 1 , dst_aux_usage ) ; } | <S2SV_ModStart> src_mt , src_isl_format , 0 |
866 | CWE-000 char * s_net_name ( NETLIST * netlist_head , NET * net_head , char * hierarchy_tag , int type , SCM netlist_mode ) { char * string = NULL ; NET * n_start ; NETLIST * nl_current ; CPINLIST * pl_current ; char * net_name = NULL ; int found = 0 ; char * temp ; int * unnamed_counter ; <S2SV_StartBug> char * unnamed_string = NULL ; <S2SV_EndBug> EdaConfig * cfg ; net_name = s_net_name_search ( net_head ) ; if ( net_name ) { return ( net_name ) ; } # if DEBUG printf ( "didn\'t<S2SV_blank>find<S2SV_blank>named<S2SV_blank>net\\n" ) ; # endif nl_current = netlist_head ; while ( nl_current != NULL ) { if ( nl_current -> cpins ) { pl_current = nl_current -> cpins ; while ( pl_current != NULL ) { if ( pl_current -> nets ) { n_start = pl_current -> nets ; if ( n_start -> next && net_head -> next ) { found = s_net_find ( n_start -> next , net_head -> next ) ; if ( found ) { net_name = s_net_name_search ( n_start ) ; if ( net_name ) { return ( net_name ) ; } } } } pl_current = pl_current -> next ; } } nl_current = nl_current -> next ; } # if DEBUG printf ( "didn\'t<S2SV_blank>find<S2SV_blank>previously<S2SV_blank>named\\n" ) ; # endif if ( net_head -> nid == - 1 && net_head -> prev == NULL && net_head -> next == NULL ) { string = g_strdup_printf ( "unconnected_pin-%d" , unnamed_pin_counter ++ ) ; return ( string ) ; } <S2SV_StartBug> cfg = eda_config_get_context_for_file ( NULL ) ; <S2SV_EndBug> switch ( type ) { case PIN_TYPE_NET : unnamed_counter = & unnamed_net_counter ; <S2SV_StartBug> unnamed_string = eda_config_get_string ( cfg , "gnetlist" , "default-net-name" , NULL ) ; <S2SV_EndBug> break ; case PIN_TYPE_BUS : unnamed_counter = & unnamed_bus_counter ; <S2SV_StartBug> unnamed_string = eda_config_get_string ( cfg , "gnetlist" , "default-bus-name" , NULL ) ; <S2SV_EndBug> break ; default : g_critical ( _ ( "s_net_name:<S2SV_blank>incorrect<S2SV_blank>connectivity<S2SV_blank>type<S2SV_blank>%i\\n" ) , type ) ; return NULL ; } if ( * unnamed_counter < MAX_UNNAMED_NETS ) { if ( scm_is_true ( scm_equal_p ( netlist_mode , scm_from_utf8_symbol ( "spice" ) ) ) ) { string = g_strdup_printf ( "%d" , ( * unnamed_counter ) ++ ) ; } else { temp = g_strdup_printf ( "%s%d" , unnamed_string , ( * unnamed_counter ) ++ ) ; if ( hierarchy_tag ) { string = s_hierarchy_create_netname ( temp , hierarchy_tag ) ; g_free ( temp ) ; } else { string = temp ; } } } else { fprintf ( stderr , _ ( "Increase<S2SV_blank>number<S2SV_blank>of<S2SV_blank>unnamed<S2SV_blank>nets<S2SV_blank>(s_net.c)\\n" ) ) ; exit ( - 1 ) ; } <S2SV_StartBug> g_free ( unnamed_string ) ; <S2SV_EndBug> return string ; } | <S2SV_ModStart> * unnamed_counter ; gchar <S2SV_ModEnd> * unnamed_string = <S2SV_ModStart> unnamed_string = NULL <S2SV_ModEnd> ; net_name = <S2SV_ModStart> ) ; } <S2SV_ModEnd> switch ( type <S2SV_ModStart> ; unnamed_string = default_net_name <S2SV_ModEnd> ; break ; <S2SV_ModStart> ; unnamed_string = default_bus_name <S2SV_ModEnd> ; break ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> return string ; |
867 | CWE-000 void instrumentPutI ( IRSB * sbOut , IRExpr * varOffset , Int constOffset , Int arrayBase , Int numElems , IRType elemType , IRExpr * data ) { if ( ! canBeFloat ( sbOut -> tyenv , data ) ) return ; int dest_size = exprSize ( sbOut -> tyenv , data ) ; IRExpr * dest_addrs [ 4 ] ; for ( int i = 0 ; i < ( numElems * dest_size ) ; ++ i ) { Int dest = arrayBase + i * 4 ; if ( hasStaticShadow ( data ) && tempType ( data -> Iex . RdTmp . tmp ) == Ft_Double && i % 2 == 1 && tsContext [ dest ] == Ft_NonFloat ) { continue ; } tsContext [ dest ] = Ft_Unknown ; } for ( int i = 0 ; i < dest_size ; ++ i ) { dest_addrs [ i ] = mkArrayLookupExpr ( sbOut , arrayBase , varOffset , constOffset + i , numElems , elemType ) ; IRExpr * oldVal = runGetTSValDynamic ( sbOut , dest_addrs [ i ] ) ; addSVDisown ( sbOut , oldVal ) ; } if ( ! canHaveShadow ( sbOut -> tyenv , data ) ) { for ( int i = 0 ; i < dest_size ; ++ i ) { <S2SV_StartBug> addSetTSValDynamic ( sbOut , dest_addrs [ i ] , NULL ) ; <S2SV_EndBug> } } else { int tempIdx = data -> Iex . RdTmp . tmp ; IRExpr * st = runLoadTemp ( sbOut , tempIdx ) ; if ( hasStaticShadow ( data ) ) { IRExpr * values = runArrow ( sbOut , st , ShadowTemp , values ) ; for ( int i = 0 ; i < dest_size ; ++ i ) { if ( tempType ( tempIdx ) == Ft_Double ) { if ( i % 2 == 1 ) { <S2SV_StartBug> addSetTSValDynamic ( sbOut , dest_addrs [ i ] , NULL ) ; <S2SV_EndBug> } else { IRExpr * value = runIndex ( sbOut , values , ShadowValue * , i / 2 ) ; addSetTSValDynamic ( sbOut , dest_addrs [ i ] , value ) ; } } else { IRExpr * value = runIndex ( sbOut , values , ShadowValue * , i ) ; addSetTSValDynamic ( sbOut , dest_addrs [ i ] , value ) ; } } } else { IRExpr * stExists = runNonZeroCheck64 ( sbOut , st ) ; if ( dest_size == 1 ) { IRExpr * values = runArrowG ( sbOut , stExists , st , ShadowTemp , values ) ; IRExpr * value = runLoadG64 ( sbOut , values , stExists ) ; addSVOwnNonNullG ( sbOut , stExists , value ) ; addSetTSValDynamic ( sbOut , dest_addrs [ 0 ] , value ) ; } else { IRDirty * putDirty = unsafeIRDirty_0_N ( 2 , "dynamicPut" , VG_ ( fnptr_to_fnentry ) ( dynamicPut ) , mkIRExprVec_2 ( dest_addrs [ 0 ] , st ) ) ; putDirty -> guard = stExists ; putDirty -> mFx = Ifx_Modify ; putDirty -> mAddr = mkU64 ( ( uintptr_t ) & ( shadowThreadState [ VG_ ( get_running_tid ) ( ) ] [ arrayBase ] ) ) ; putDirty -> mSize = numElems * sizeofIRType ( elemType ) ; addStmtToIRSB ( sbOut , IRStmt_Dirty ( putDirty ) ) ; } } } } | <S2SV_ModStart> i ] , mkU64 ( 0 ) <S2SV_ModEnd> ) ; } <S2SV_ModStart> i ] , mkU64 ( 0 ) <S2SV_ModEnd> ) ; } |
868 | CWE-000 static void write_image ( const char * filename , int width , int height ) { int buffer_stride = width * 4 ; void * data = calloc ( 1 , buffer_stride * height ) ; if ( ! data ) { return ; } struct screenshooter_output * output , * next ; wl_list_for_each_safe ( output , next , & output_list , link ) { int output_stride = output -> width * 4 ; uint32_t * src = ( uint32_t * ) output -> data ; uint32_t * dst = ( uint32_t * ) ( data + ( output -> offset_y - min_y ) * buffer_stride + ( output -> offset_x - min_x ) * 4 ) ; switch ( output -> transform ) { case WL_OUTPUT_TRANSFORM_NORMAL : for ( int i = 0 ; i < output -> height ; i ++ ) { memcpy ( dst , src , output_stride ) ; dst += width ; src += output -> width ; } break ; case WL_OUTPUT_TRANSFORM_FLIPPED : for ( int i = 0 ; i < output -> height ; ++ i ) { for ( int j = 0 ; j < output -> width ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ i * output -> width + output -> width - j ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_90 : for ( int i = 0 ; i < output -> width ; ++ i ) { for ( int j = 0 ; j < output -> height ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ j * output -> width + output -> width - i ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_FLIPPED_90 : for ( int i = 0 ; i < output -> width ; ++ i ) { for ( int j = 0 ; j < output -> height ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ ( output -> height - j ) * output -> width + output -> width - i ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_180 : for ( int i = 0 ; i < output -> height ; ++ i ) { for ( int j = 0 ; j < output -> width ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ ( output -> height - i ) * output -> width + output -> width - j ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_FLIPPED_180 : for ( int i = 0 ; i < output -> height ; ++ i ) { for ( int j = 0 ; j < output -> width ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ ( output -> height - i ) * output -> width + j ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_270 : for ( int i = 0 ; i < output -> width ; ++ i ) { for ( int j = 0 ; j < output -> height ; ++ j ) { dst [ i * width + j ] = <S2SV_StartBug> src [ ( output -> height - j ) * output -> width + i ] ; <S2SV_EndBug> } } break ; case WL_OUTPUT_TRANSFORM_FLIPPED_270 : for ( int i = 0 ; i < output -> width ; ++ i ) { for ( int j = 0 ; j < output -> height ; ++ j ) { dst [ i * width + j ] = src [ j * output -> width + i ] ; } } break ; } free ( output ) ; } char size [ 10 + 1 + 10 + 2 + 1 ] ; sprintf ( size , "%dx%d+0" , width , height ) ; int fd [ 2 ] ; if ( pipe ( fd ) != 0 ) { fprintf ( stderr , "cannot<S2SV_blank>create<S2SV_blank>pipe:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } pid_t child = fork ( ) ; if ( child < 0 ) { fprintf ( stderr , "fork()<S2SV_blank>failed\\n" ) ; exit ( EXIT_FAILURE ) ; } else if ( child != 0 ) { close ( fd [ 0 ] ) ; if ( write ( fd [ 1 ] , data , buffer_stride * height ) < 0 ) { fprintf ( stderr , "write()<S2SV_blank>failed:<S2SV_blank>%s\\n" , strerror ( errno ) ) ; exit ( EXIT_FAILURE ) ; } close ( fd [ 1 ] ) ; free ( data ) ; waitpid ( child , NULL , 0 ) ; } else { close ( fd [ 1 ] ) ; if ( dup2 ( fd [ 0 ] , 0 ) != 0 ) { fprintf ( stderr , "cannot<S2SV_blank>dup<S2SV_blank>the<S2SV_blank>pipe\\n" ) ; exit ( EXIT_FAILURE ) ; } close ( fd [ 0 ] ) ; execlp ( "convert" , "convert" , "-depth" , "8" , "-size" , size , "bgra:-" , "-alpha" , "opaque" , filename , NULL ) ; fprintf ( stderr , "cannot<S2SV_blank>execute<S2SV_blank>convert\\n" ) ; exit ( EXIT_FAILURE ) ; } } | <S2SV_ModStart> -> width - 1 - <S2SV_ModStart> -> width - 1 - <S2SV_ModStart> -> height - 1 - j ) * output -> width + output -> width - 1 <S2SV_ModEnd> - i ] <S2SV_ModStart> -> height - 1 - i ) * output -> width + output -> width - 1 <S2SV_ModEnd> - j ] <S2SV_ModStart> -> height - 1 - <S2SV_ModStart> -> height - 1 - |
869 | CWE-000 void br_forward ( const struct net_bridge_port * to , struct sk_buff * skb , bool local_rcv , bool local_orig ) { <S2SV_StartBug> if ( to && should_deliver ( to , skb ) ) { <S2SV_EndBug> if ( local_rcv ) deliver_clone ( to , skb , local_orig ) ; else __br_forward ( to , skb , local_orig ) ; return ; } <S2SV_StartBug> if ( ! local_rcv ) <S2SV_EndBug> kfree_skb ( skb ) ; } | <S2SV_ModStart> { if ( unlikely ( ! to ) ) goto out ; if ( rcu_access_pointer ( to -> backup_port ) && ! netif_carrier_ok ( to -> dev ) ) { struct net_bridge_port * backup_port ; backup_port = rcu_dereference ( to -> backup_port ) ; if ( unlikely ( ! backup_port ) ) goto out ; to = backup_port ; } if ( <S2SV_ModEnd> should_deliver ( to <S2SV_ModStart> return ; } out : |
870 | CWE-000 blklarge * find_owning_block ( void * ptr ) { <S2SV_StartBug> blklarge * bl = * blist -> blockp ; <S2SV_EndBug> <S2SV_StartBug> for ( int i = 0 ; i < blist -> numb ; i ++ ) { <S2SV_EndBug> <S2SV_StartBug> if ( ptr >= bl -> base && ptr < ( bl -> base + bl -> size ) ) { <S2SV_EndBug> return bl ; } bl ++ ; } return NULL ; } | <S2SV_ModStart> * blist -> b_blockp <S2SV_ModEnd> ; for ( <S2SV_ModStart> < blist -> b_numb <S2SV_ModEnd> ; i ++ <S2SV_ModStart> >= bl -> bl_base <S2SV_ModEnd> && ptr < <S2SV_ModStart> ( bl -> bl_base <S2SV_ModEnd> + bl -> <S2SV_ModStart> + bl -> bl_size <S2SV_ModEnd> ) ) { |
871 | CWE-000 cf_read_status_t cf_read ( capture_file * cf , gboolean reloading ) { int err = 0 ; gchar * err_info = NULL ; gchar * name_ptr ; progdlg_t * volatile progbar = NULL ; GTimer * prog_timer = g_timer_new ( ) ; GTimeVal start_time ; epan_dissect_t edt ; dfilter_t * dfcode ; volatile gboolean create_proto_tree ; guint tap_flags ; <S2SV_StartBug> gboolean compiled ; <S2SV_EndBug> compiled = dfilter_compile ( cf -> dfilter , & dfcode , NULL ) ; g_assert ( ! cf -> dfilter || ( compiled && dfcode ) ) ; tap_flags = union_of_tap_listener_flags ( ) ; create_proto_tree = ( dfcode != NULL || have_filtering_tap_listeners ( ) || ( tap_flags & TL_REQUIRES_PROTO_TREE ) || postdissectors_want_hfids ( ) ) ; reset_tap_listeners ( ) ; name_ptr = g_filename_display_basename ( cf -> filename ) ; if ( reloading ) cf_callback_invoke ( cf_cb_file_reload_started , cf ) ; else cf_callback_invoke ( cf_cb_file_read_started , cf ) ; cf -> iscompressed = wtap_iscompressed ( cf -> wth ) ; packet_list_freeze ( ) ; cf -> stop_flag = FALSE ; g_get_current_time ( & start_time ) ; epan_dissect_init ( & edt , cf -> epan , create_proto_tree , FALSE ) ; TRY { int count = 0 ; gint64 size ; gint64 file_pos ; gint64 data_offset ; float progbar_val ; gchar status_str [ 100 ] ; column_info * cinfo ; cinfo = ( tap_flags & TL_REQUIRES_COLUMNS ) ? & cf -> cinfo : NULL ; size = wtap_file_size ( cf -> wth , NULL ) ; g_timer_start ( prog_timer ) ; while ( ( wtap_read ( cf -> wth , & err , & err_info , & data_offset ) ) ) { if ( size >= 0 ) { count ++ ; file_pos = wtap_read_so_far ( cf -> wth ) ; if ( progress_is_slow ( progbar , prog_timer , size , file_pos ) ) { progbar_val = calc_progbar_val ( cf , size , file_pos , status_str , sizeof ( status_str ) ) ; if ( reloading ) progbar = delayed_create_progress_dlg ( cf -> window , "Reloading" , name_ptr , TRUE , & cf -> stop_flag , & start_time , progbar_val ) ; else progbar = delayed_create_progress_dlg ( cf -> window , "Loading" , name_ptr , TRUE , & cf -> stop_flag , & start_time , progbar_val ) ; } if ( progbar && g_timer_elapsed ( prog_timer , NULL ) > PROGBAR_UPDATE_INTERVAL ) { progbar_val = calc_progbar_val ( cf , size , file_pos , status_str , sizeof ( status_str ) ) ; update_progress_dlg ( progbar , progbar_val , status_str ) ; packets_bar_update ( ) ; g_timer_start ( prog_timer ) ; } } <S2SV_StartBug> if ( cf -> stop_flag ) { <S2SV_EndBug> break ; } read_packet ( cf , dfcode , & edt , cinfo , data_offset ) ; } } CATCH ( OutOfMemoryError ) { simple_message_box ( ESD_TYPE_ERROR , NULL , "More<S2SV_blank>information<S2SV_blank>and<S2SV_blank>workarounds<S2SV_blank>can<S2SV_blank>be<S2SV_blank>found<S2SV_blank>at\\n" "https://wiki.wireshark.org/KnownBugs/OutOfMemory" , "Sorry,<S2SV_blank>but<S2SV_blank>Wireshark<S2SV_blank>has<S2SV_blank>run<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>and<S2SV_blank>has<S2SV_blank>to<S2SV_blank>terminate<S2SV_blank>now." ) ; # if 0 # else exit ( 1 ) ; # endif } ENDTRY ; g_free ( name_ptr ) ; if ( dfcode != NULL ) { dfilter_free ( dfcode ) ; } epan_dissect_cleanup ( & edt ) ; if ( progbar != NULL ) destroy_progress_dlg ( progbar ) ; g_timer_destroy ( prog_timer ) ; cf -> state = FILE_READ_DONE ; wtap_sequential_close ( cf -> wth ) ; postseq_cleanup_all_protocols ( ) ; compute_elapsed ( cf , & start_time ) ; cf -> lnk_t = wtap_file_encap ( cf -> wth ) ; cf -> current_frame = frame_data_sequence_find ( cf -> frames , cf -> first_displayed ) ; cf -> current_row = 0 ; packet_list_thaw ( ) ; if ( reloading ) cf_callback_invoke ( cf_cb_file_reload_finished , cf ) ; else cf_callback_invoke ( cf_cb_file_read_finished , cf ) ; if ( cf -> first_displayed != 0 ) { packet_list_select_first_row ( ) ; } <S2SV_StartBug> if ( cf -> stop_flag ) { <S2SV_EndBug> simple_message_box ( ESD_TYPE_WARN , NULL , "The<S2SV_blank>remaining<S2SV_blank>packets<S2SV_blank>in<S2SV_blank>the<S2SV_blank>file<S2SV_blank>were<S2SV_blank>discarded.\\n" "\\n" "As<S2SV_blank>a<S2SV_blank>lot<S2SV_blank>of<S2SV_blank>packets<S2SV_blank>from<S2SV_blank>the<S2SV_blank>original<S2SV_blank>file<S2SV_blank>will<S2SV_blank>be<S2SV_blank>missing,\\n" "remember<S2SV_blank>to<S2SV_blank>be<S2SV_blank>careful<S2SV_blank>when<S2SV_blank>saving<S2SV_blank>the<S2SV_blank>current<S2SV_blank>content<S2SV_blank>to<S2SV_blank>a<S2SV_blank>file.\\n" , "File<S2SV_blank>loading<S2SV_blank>was<S2SV_blank>cancelled." ) ; return CF_READ_ERROR ; } if ( err != 0 ) { cfile_read_failure_alert_box ( NULL , err , err_info ) ; return CF_READ_ERROR ; } else return CF_READ_OK ; } | <S2SV_ModStart> ; gboolean compiled ; volatile gboolean is_read_aborted = FALSE <S2SV_ModStart> ( cf -> state == FILE_READ_ABORTED ) { is_read_aborted = TRUE ; break ; } if ( cf -> <S2SV_ModStart> } if ( is_read_aborted ) { cf_close ( cf ) ; return CF_READ_ABORTED ; } if ( |
872 | CWE-000 int parseCommandQuit ( ftpDataType * data , int socketId ) { int returnCode ; <S2SV_StartBug> char * theResponse = "221<S2SV_blank>Logout.\\r\\n" ; <S2SV_EndBug> <S2SV_StartBug> returnCode = write ( data -> clients [ socketId ] . socketDescriptor , theResponse , strlen ( theResponse ) ) ; <S2SV_EndBug> if ( returnCode <= 0 ) return FTP_COMMAND_PROCESSED_WRITE_ERROR ; data -> clients [ socketId ] . closeTheClient = 1 ; return 1 ; } | <S2SV_ModStart> int returnCode ; returnCode = dprintf <S2SV_ModEnd> ( data -> <S2SV_ModStart> . socketDescriptor , "221<S2SV_blank>Logout.\\r\\n" <S2SV_ModEnd> ) ; if |
873 | CWE-000 static void handle_module_import ( void ) { const char * const PATHS [ ] = { "$/lib" , "#/cell_modules" , "#/runtime" , } ; const char * caller_id = NULL ; path_t * path ; char * source ; size_t source_len ; const char * specifier ; int i ; specifier = jsal_require_string ( 0 ) ; if ( ! jsal_is_null ( 1 ) ) caller_id = jsal_require_string ( 1 ) ; if ( caller_id == NULL && ( strncmp ( specifier , "./" , 2 ) == 0 || strncmp ( specifier , "../" , 3 ) == 0 ) ) jsal_error ( JS_URI_ERROR , "relative<S2SV_blank>import()<S2SV_blank>outside<S2SV_blank>of<S2SV_blank>an<S2SV_blank>mJS<S2SV_blank>module" ) ; for ( i = 0 ; i < sizeof PATHS / sizeof PATHS [ 0 ] ; ++ i ) { if ( path = find_module_file ( s_build -> fs , specifier , caller_id , PATHS [ i ] ) ) break ; } if ( path == NULL ) jsal_error ( JS_URI_ERROR , "couldn\'t<S2SV_blank>find<S2SV_blank>module<S2SV_blank>\'%s\'" , specifier ) ; if ( path_has_extension ( path , ".mjs" ) ) { source = fs_fslurp ( s_build -> fs , path_cstr ( path ) , & source_len ) ; jsal_push_string ( path_cstr ( path ) ) ; <S2SV_StartBug> jsal_push_lstring ( source , source_len ) ; <S2SV_EndBug> free ( source ) ; } else { jsal_push_sprintf ( "%%/moduleShim-%d.mjs" , s_next_module_id ++ ) ; <S2SV_StartBug> jsal_push_sprintf ( "export<S2SV_blank>default<S2SV_blank>require(\\"%s\\");" , path_cstr ( path ) ) ; <S2SV_EndBug> } } | <S2SV_ModStart> ) ) ; jsal_dup ( - 1 ) ; <S2SV_ModStart> ++ ) ; jsal_dup ( - 1 ) ; |
874 | CWE-000 static unsigned int cbn_egress_hook ( void * priv , struct sk_buff * skb , const struct nf_hook_state * state ) { struct iphdr * iph = ip_hdr ( skb ) ; if ( ! skb -> mark ) goto out ; if ( ( iph -> protocol == IPPROTO_TCP ) ) { struct tcphdr * tcphdr = ( struct tcphdr * ) skb_transport_header ( skb ) ; if ( unlikely ( ( ntohs ( tcphdr -> source ) == CBP_PROBE_PORT ) ) ) { struct addresses * addresses = build_addresses ( skb ) ; if ( ! addresses ) { pr_err ( "Faield<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>mem<S2SV_blank>%s\\n" , __FUNCTION__ ) ; goto drop ; } addresses -> src . sin_port = tcphdr -> window ; if ( is_out_gue ( skb ) ) { if ( set_cbn_probe ( skb , addresses ) ) goto drop ; } else { kthread_pool_run ( & cbn_pool , start_new_connection_syn , addresses ) ; goto drop ; } } goto out ; } if ( ( iph -> protocol == IPPROTO_UDP ) & is_cbn_probe ( skb ) ) { struct addresses * addresses = get_cbn_probe ( skb ) ; if ( addresses ) { <S2SV_StartBug> addresses -> sin_addr . s_addr = iph -> daddr ; <S2SV_EndBug> kthread_pool_run ( & cbn_pool , start_new_pre_connection_syn , addresses ) ; } goto drop ; } out : return NF_ACCEPT ; drop : return NF_DROP ; } | <S2SV_ModStart> addresses ) { TRACE_PRINT ( "Next<S2SV_blank>hop<S2SV_blank>is<S2SV_blank>" IP4 "=>" IP4 "\\n" , IP4N ( & iph -> saddr ) , IP4N ( & iph -> daddr ) ) ; |
875 | CWE-000 void hdd_select_cbmode ( hdd_adapter_t * pAdapter , v_U8_t operationChannel , uint16_t * vht_channel_width ) { v_U8_t iniDot11Mode = ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> cfg_ini -> dot11Mode ; eHddDot11Mode hddDot11Mode = iniDot11Mode ; <S2SV_StartBug> hdd_station_ctx_t * station_ctx = WLAN_HDD_GET_STATION_CTX_PTR ( pAdapter ) ; <S2SV_EndBug> uint32_t cb_mode ; struct hdd_mon_set_ch_info * ch_info = & station_ctx -> ch_info ; hddLog ( LOG1 , FL ( "Channel<S2SV_blank>Bonding<S2SV_blank>Mode<S2SV_blank>Selected<S2SV_blank>is<S2SV_blank>%u" ) , iniDot11Mode ) ; <S2SV_StartBug> if ( VOS_MONITOR_MODE != hdd_get_conparam ( ) ) <S2SV_EndBug> * vht_channel_width = ( WLAN_HDD_GET_CTX ( pAdapter ) ) -> cfg_ini -> vhtChannelWidth ; if ( ( WLAN_HDD_IBSS == pAdapter -> device_mode ) && ( SIR_11B_CHANNEL_END >= operationChannel ) ) * vht_channel_width = eHT_CHANNEL_WIDTH_20MHZ ; switch ( iniDot11Mode ) { case eHDD_DOT11_MODE_AUTO : case eHDD_DOT11_MODE_11ac : case eHDD_DOT11_MODE_11ac_ONLY : # ifdef WLAN_FEATURE_11AC if ( sme_IsFeatureSupportedByFW ( DOT11AC ) ) hddDot11Mode = eHDD_DOT11_MODE_11ac ; else hddDot11Mode = eHDD_DOT11_MODE_11n ; # else hddDot11Mode = eHDD_DOT11_MODE_11n ; # endif break ; case eHDD_DOT11_MODE_11n : case eHDD_DOT11_MODE_11n_ONLY : hddDot11Mode = eHDD_DOT11_MODE_11n ; break ; default : hddDot11Mode = iniDot11Mode ; break ; } <S2SV_StartBug> cb_mode = sme_SelectCBMode ( ( WLAN_HDD_GET_CTX ( pAdapter ) -> hHal ) , <S2SV_EndBug> hdd_cfg_xlate_to_csr_phy_mode ( hddDot11Mode ) , operationChannel , 0 , vht_channel_width , * vht_channel_width ) ; <S2SV_StartBug> if ( VOS_MONITOR_MODE == hdd_get_conparam ( ) ) { <S2SV_EndBug> ch_info -> channel_width = * vht_channel_width ; ch_info -> phy_mode = hdd_cfg_xlate_to_csr_phy_mode ( hddDot11Mode ) ; ch_info -> channel = operationChannel ; ch_info -> cb_mode = cb_mode ; hddLog ( LOG1 , FL ( "ch_info<S2SV_blank>width<S2SV_blank>%d,<S2SV_blank>phymode<S2SV_blank>%d<S2SV_blank>channel<S2SV_blank>%d" ) , ch_info -> channel_width , ch_info -> phy_mode , ch_info -> channel ) ; } } | <S2SV_ModStart> = iniDot11Mode ; <S2SV_ModEnd> hddLog ( LOG1 <S2SV_ModStart> iniDot11Mode ) ; <S2SV_ModEnd> * vht_channel_width = <S2SV_ModStart> break ; } <S2SV_ModEnd> sme_SelectCBMode ( ( <S2SV_ModStart> vht_channel_width ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
876 | CWE-000 static void column_decompress_load ( sqlite3_stmt * statement , size_t index , flex_trit_t * flex_trits , size_t num_bytes ) { char const * buffer ; size_t column_size ; buffer = sqlite3_column_blob ( statement , index ) ; <S2SV_StartBug> column_size = sqlite3_column_bytes ( statement , index ) ; <S2SV_EndBug> memcpy ( flex_trits , buffer , column_size ) ; memset ( flex_trits + column_size , FLEX_TRIT_NULL_VALUE , num_bytes - column_size ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> index ) ; if ( buffer ) { <S2SV_ModStart> ) ; } else { memset ( flex_trits , FLEX_TRIT_NULL_VALUE , num_bytes ) ; } } |
877 | CWE-000 <S2SV_StartBug> void destroy_bitree ( pbitree_t p_root ) <S2SV_EndBug> { <S2SV_StartBug> clear_bitree ( p_root ) ; <S2SV_EndBug> } | <S2SV_ModStart> destroy_bitree ( pbitree_t * pp_root <S2SV_ModEnd> ) { clear_bitree <S2SV_ModStart> { clear_bitree ( pp_root <S2SV_ModEnd> ) ; } |
878 | CWE-000 GtkWidget * new_username_widget ( void ) { elmprintf ( LOGINFO , "Displaying<S2SV_blank>username<S2SV_blank>entry." ) ; static GtkWidget * Username = NULL ; Username = gtk_entry_new ( ) ; <S2SV_StartBug> set_entry_buffer ( Username , "Username" ) ; <S2SV_EndBug> <S2SV_StartBug> set_default_user ( Username ) ; <S2SV_EndBug> set_entry_icon ( Username , "Username" ) ; <S2SV_StartBug> gtk_widget_set_can_focus ( Username , TRUE ) ; <S2SV_EndBug> gtk_entry_set_activates_default ( GTK_ENTRY ( Username ) , TRUE ) ; elm_gtk_conf_set_widget_size ( & Username , "Credentials" , "Width" , "Height" ) ; <S2SV_StartBug> elm_gtk_set_widget_style ( & Username , "Username" , Style ) ; <S2SV_EndBug> gtk_widget_show ( Username ) ; return Username ; } | <S2SV_ModStart> ( ) ; elm_app_set_entry_buffer <S2SV_ModEnd> ( Username , <S2SV_ModStart> "Username" ) ; elm_app_set_entry_icon <S2SV_ModEnd> ( Username , <S2SV_ModStart> "Username" ) ; elm_app_set_default_user ( Username ) ; elm_gtk_set_widget_size_from_conf <S2SV_ModEnd> ( & Username <S2SV_ModStart> "Height" ) ; elm_gtk_add_css_from_file <S2SV_ModEnd> ( & Username <S2SV_ModStart> & Username , NULL , Style ) ; gtk_entry_set_activates_default ( GTK_ENTRY ( Username ) , TRUE <S2SV_ModEnd> ) ; gtk_widget_show |
879 | CWE-000 static void _clear_history ( void ) { EINA_SAFETY_ON_NULL_RETURN ( clip_inst ) ; if ( clip_inst -> items ) E_FREE_LIST ( clip_inst -> items , free_clip_data ) ; <S2SV_StartBug> clip_save ( clip_inst -> items ) ; <S2SV_EndBug> } | <S2SV_ModStart> free_clip_data ) ; elm_object_cnp_selection_clear ( e_comp -> evas , ELM_SEL_TYPE_CLIPBOARD ) ; |
880 | CWE-000 <S2SV_StartBug> tank_data controlling ( Tank * tankName , tank_data myTank ) { <S2SV_EndBug> controlVector command ; if ( myTank . danger . missile ) { <S2SV_StartBug> command = dwaMissileAvoid ( myTank ) ; <S2SV_EndBug> } else { command . acceleration = 1.5 ; command . steer = 0.0 ; } myTank . control . acceleration = command . acceleration ; myTank . control . steer = command . steer ; set_steering ( tankName , myTank . control . steer ) ; accelerate ( tankName , myTank . control . acceleration ) ; return myTank ; } | <S2SV_ModStart> , tank_data myTank , bool reverseInd <S2SV_ModStart> dwaMissileAvoid ( myTank ) ; } else if ( myTank . danger . tankHits ) { command = avoidTankHits ( myTank , reverseInd |
881 | CWE-000 int main ( void ) { int starty , startx ; int input ; initscr ( ) ; raw ( ) ; noecho ( ) ; keypad ( stdscr , TRUE ) ; curs_set ( 0 ) ; srand ( time ( NULL ) ) ; start_color ( ) ; init_pair ( 1 , COLOR_WHITE , COLOR_BLACK ) ; init_pair ( 2 , COLOR_YELLOW , COLOR_BLACK ) ; init_pair ( 3 , COLOR_BLUE , COLOR_BLUE ) ; init_pair ( 4 , COLOR_MAGENTA , COLOR_BLACK ) ; init_pair ( 5 , COLOR_RED , COLOR_BLACK ) ; load_maze ( ) ; starty = ( LINES - sizey ) / 2 ; startx = ( COLS - sizex ) / 2 ; printw ( "\'w\',<S2SV_blank>\'a\',<S2SV_blank>\'s\',<S2SV_blank>\'d\'<S2SV_blank>to<S2SV_blank>move.<S2SV_blank>\'x\'<S2SV_blank>to<S2SV_blank>Exit" ) ; refresh ( ) ; win = newwin ( sizey , sizex , starty , startx ) ; timeout ( 0 ) ; player . y = 5 ; player . x = 10 ; ghost . y = 1 ; ghost . x = 10 ; blinky . y = 1 ; blinky . x = 11 ; int ticks = 0 ; int gameState = 0 ; drawMaze ( ) ; do { input = getch ( ) ; if ( input != 255 ) { setDirectionFromInput ( input , & player ) ; } if ( ( ticks % 16 ) == 0 ) { setDirectionRandom ( & ghost ) ; moveFigure ( & ghost ) ; setDirectionRandom ( & blinky ) ; moveFigure ( & blinky ) ; moveFigure ( & player ) ; eatCookie ( & player ) ; setNewDirection ( & player ) ; printPoints ( ) ; drawMaze ( ) ; } if ( ( ticks % 100 ) == 0 ) { points = points - 5 ; printPoints ( ) ; } gameState = checkIfGameOver ( input ) ; usleep ( 10000 ) ; ticks ++ ; } while ( ! gameState ) ; if ( gameState == 1 ) { <S2SV_StartBug> mvprintw ( 2 , 2 , "CONGRATS<S2SV_blank>-<S2SV_blank>YOU<S2SV_blank>WON!" ) ; <S2SV_EndBug> } else if ( gameState == 6 ) { mvprintw ( 2 , 2 , "YOU<S2SV_blank>LOST<S2SV_blank>ALL<S2SV_blank><S2SV_blank>POINTS" ) ; } else if ( gameState == 7 ) { mvprintw ( 2 , 2 , "YOU<S2SV_blank>LOST<S2SV_blank>-<S2SV_blank>GAME<S2SV_blank>OVER" ) ; } else if ( gameState == 10 ) { mvprintw ( 2 , 2 , "QUIT:<S2SV_blank>GAME<S2SV_blank>TERMINATED" ) ; } refresh ( ) ; sleep ( 1 ) ; delwin ( win ) ; <S2SV_StartBug> sleep ( 1 ) ; <S2SV_EndBug> endwin ( ) ; return 0 ; } | <S2SV_ModStart> { mvprintw ( 5 , 29 , "CONGRATS<S2SV_blank>-<S2SV_blank>YOU<S2SV_blank>WON!" ) ; } else if ( gameState == 6 ) { mvprintw ( 5 , 29 , "YOU<S2SV_blank>LOST<S2SV_blank>ALL<S2SV_blank><S2SV_blank>POINTS" ) ; } else if ( gameState == 7 ) { mvprintw ( 5 , 29 , "YOU<S2SV_blank>LOST<S2SV_blank>-<S2SV_blank>GAME<S2SV_blank>OVER" ) ; } else if ( gameState == 10 ) { mvprintw ( 5 , 29 , "QUIT:<S2SV_blank>GAME<S2SV_blank>TERMINATED" ) ; } refresh ( ) ; sleep ( 2 <S2SV_ModEnd> ) ; delwin <S2SV_ModStart> win ) ; <S2SV_ModEnd> endwin ( ) |
882 | CWE-000 void avcServer_UpdateHandler ( le_avc_Status_t updateStatus , le_avc_UpdateType_t updateType , int32_t totalNumBytes , int32_t dloadProgress , le_avc_ErrorCode_t errorCode ) { LE_INFO ( "Update<S2SV_blank>state:<S2SV_blank>%s" , AvcSessionStateToStr ( updateStatus ) ) ; switch ( updateStatus ) { case LE_AVC_DOWNLOAD_PENDING : CurrentState = AVC_DOWNLOAD_PENDING ; CurrentDownloadProgress = dloadProgress ; CurrentTotalNumBytes = totalNumBytes ; LE_DEBUG ( "Update<S2SV_blank>type<S2SV_blank>for<S2SV_blank>DOWNLOAD<S2SV_blank>is<S2SV_blank>%d" , updateType ) ; CurrentUpdateType = updateType ; break ; case LE_AVC_INSTALL_PENDING : CurrentState = AVC_INSTALL_PENDING ; LE_DEBUG ( "Update<S2SV_blank>type<S2SV_blank>for<S2SV_blank>INSTALL<S2SV_blank>is<S2SV_blank>%d" , updateType ) ; CurrentUpdateType = updateType ; break ; case LE_AVC_DOWNLOAD_IN_PROGRESS : LE_DEBUG ( "Update<S2SV_blank>type<S2SV_blank>for<S2SV_blank>DOWNLOAD<S2SV_blank>is<S2SV_blank>%d" , updateType ) ; CurrentTotalNumBytes = totalNumBytes ; CurrentDownloadProgress = dloadProgress ; CurrentUpdateType = updateType ; if ( LE_AVC_APPLICATION_UPDATE == updateType ) { avcApp_SetSwUpdateBytesDownloaded ( ) ; } break ; case LE_AVC_DOWNLOAD_COMPLETE : LE_DEBUG ( "Update<S2SV_blank>type<S2SV_blank>for<S2SV_blank>DOWNLOAD<S2SV_blank>is<S2SV_blank>%d" , updateType ) ; DownloadAgreement = false ; <S2SV_StartBug> CurrentTotalNumBytes = totalNumBytes ; <S2SV_EndBug> <S2SV_StartBug> CurrentDownloadProgress = dloadProgress ; <S2SV_EndBug> CurrentUpdateType = updateType ; if ( LE_AVC_APPLICATION_UPDATE == updateType ) { avcApp_SetSwUpdateBytesDownloaded ( ) ; avcApp_EndDownload ( ) ; } break ; case LE_AVC_UNINSTALL_PENDING : case LE_AVC_UNINSTALL_IN_PROGRESS : case LE_AVC_UNINSTALL_FAILED : case LE_AVC_UNINSTALL_COMPLETE : LE_ERROR ( "Received<S2SV_blank>unexpected<S2SV_blank>update<S2SV_blank>status." ) ; break ; case LE_AVC_NO_UPDATE : case LE_AVC_INSTALL_COMPLETE : CurrentState = AVC_IDLE ; break ; case LE_AVC_DOWNLOAD_FAILED : case LE_AVC_INSTALL_FAILED : AvcErrorCode = errorCode ; CurrentState = AVC_IDLE ; if ( LE_AVC_APPLICATION_UPDATE == updateType ) { avcApp_DeletePackage ( ) ; } break ; case LE_AVC_SESSION_STARTED : avcApp_NotifyObj9List ( ) ; avData_ReportSessionState ( LE_AVDATA_SESSION_STARTED ) ; break ; case LE_AVC_INSTALL_IN_PROGRESS : case LE_AVC_SESSION_STOPPED : avData_ReportSessionState ( LE_AVDATA_SESSION_STOPPED ) ; break ; default : LE_DEBUG ( "Unsupported<S2SV_blank>updateStatus<S2SV_blank>%d" , updateStatus ) ; break ; } if ( StatusHandlerRef != NULL ) { LE_DEBUG ( "Reporting<S2SV_blank>status<S2SV_blank>%d" , updateStatus ) ; LE_DEBUG ( "Total<S2SV_blank>number<S2SV_blank>of<S2SV_blank>Bytes<S2SV_blank>to<S2SV_blank>download<S2SV_blank>=<S2SV_blank>%d" , totalNumBytes ) ; LE_DEBUG ( "Download<S2SV_blank>progress<S2SV_blank>=<S2SV_blank>%d%%" , dloadProgress ) ; StatusHandlerRef ( updateStatus , totalNumBytes , dloadProgress , StatusHandlerContextPtr ) ; ResendPendingNotification ( updateStatus ) ; } else if ( IsControlAppInstalled ) { if ( updateStatus == LE_AVC_DOWNLOAD_PENDING ) { LE_INFO ( "Automatically<S2SV_blank>deferring<S2SV_blank>download,<S2SV_blank>while<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>control<S2SV_blank>app<S2SV_blank>to<S2SV_blank>register" ) ; DeferDownload ( BLOCKED_DEFER_TIME ) ; } else if ( updateStatus == LE_AVC_INSTALL_PENDING ) { LE_INFO ( "Automatically<S2SV_blank>deferring<S2SV_blank>install,<S2SV_blank>while<S2SV_blank>waiting<S2SV_blank>for<S2SV_blank>control<S2SV_blank>app<S2SV_blank>to<S2SV_blank>register" ) ; DeferInstall ( BLOCKED_DEFER_TIME ) ; } else { LE_DEBUG ( "No<S2SV_blank>handler<S2SV_blank>registered<S2SV_blank>to<S2SV_blank>receive<S2SV_blank>status<S2SV_blank>%i" , updateStatus ) ; } } else { if ( updateStatus == LE_AVC_DOWNLOAD_PENDING ) { LE_INFO ( "Automatically<S2SV_blank>accepting<S2SV_blank>download" ) ; AcceptDownloadPackage ( ) ; CurrentState = AVC_DOWNLOAD_IN_PROGRESS ; } else if ( updateStatus == LE_AVC_INSTALL_PENDING ) { if ( 0 == BlockRefCount ) { LE_INFO ( "Automatically<S2SV_blank>accepting<S2SV_blank>install" ) ; AcceptInstallPackage ( ) ; StopInstallDeferTimer ( ) ; CurrentState = AVC_INSTALL_IN_PROGRESS ; } else { LE_INFO ( "Automatically<S2SV_blank>deferring<S2SV_blank>install" ) ; DeferInstall ( BLOCKED_DEFER_TIME ) ; } } else { LE_DEBUG ( "No<S2SV_blank>handler<S2SV_blank>registered<S2SV_blank>to<S2SV_blank>receive<S2SV_blank>status<S2SV_blank>%i" , updateStatus ) ; } } } | <S2SV_ModStart> = false ; if ( totalNumBytes > 0 ) { <S2SV_ModStart> = totalNumBytes ; } else { totalNumBytes = CurrentTotalNumBytes ; } if ( dloadProgress > 0 ) { <S2SV_ModStart> = dloadProgress ; } else { dloadProgress = CurrentDownloadProgress ; } |
883 | CWE-000 static void loadControllerType ( BackgroundState * e , MugenDefScriptGroup * tGroup ) { char * text = getAllocatedMugenDefStringOrDefaultAsGroup ( tGroup , "type" , "null" ) ; turnStringLowercase ( text ) ; if ( ! strcmp ( "null" , text ) ) { loadNullController ( e ) ; } else if ( ! strcmp ( "visible" , text ) ) { loadSingleValueController ( e , BACKGROUND_STATE_CONTROLLER_VISIBLE , tGroup ) ; } else if ( ! strcmp ( "enabled" , text ) ) { loadSingleValueController ( e , BACKGROUND_STATE_CONTROLLER_ENABLED , tGroup ) ; } else if ( ! strcmp ( "velset" , text ) ) { loadPhysicsController ( e , BACKGROUND_STATE_CONTROLLER_VEL_SET , tGroup ) ; } else if ( ! strcmp ( "veladd" , text ) ) { loadPhysicsController ( e , BACKGROUND_STATE_CONTROLLER_VEL_ADD , tGroup ) ; } else if ( ! strcmp ( "posset" , text ) ) { loadPhysicsController ( e , BACKGROUND_STATE_CONTROLLER_POS_SET , tGroup ) ; } else if ( ! strcmp ( "posadd" , text ) ) { loadPhysicsController ( e , BACKGROUND_STATE_CONTROLLER_POS_ADD , tGroup ) ; } else if ( ! strcmp ( "anim" , text ) ) { loadSingleValueController ( e , BACKGROUND_STATE_CONTROLLER_ANIM , tGroup ) ; } else if ( ! strcmp ( "sinx" , text ) ) { loadSingleValueController ( e , BACKGROUND_STATE_CONTROLLER_SIN_X , tGroup ) ; } else if ( ! strcmp ( "siny" , text ) ) { loadSingleValueController ( e , BACKGROUND_STATE_CONTROLLER_SIN_Y , tGroup ) ; } else { <S2SV_StartBug> logErrorFormat ( "Unrecognized<S2SV_blank>state<S2SV_blank>controller<S2SV_blank>%s.<S2SV_blank>Defaulting<S2SV_blank>to<S2SV_blank>null." ) ; <S2SV_EndBug> loadNullController ( e ) ; } freeMemory ( text ) ; } | <S2SV_ModStart> logErrorFormat ( "Unrecognized<S2SV_blank>state<S2SV_blank>controller<S2SV_blank>%s.<S2SV_blank>Defaulting<S2SV_blank>to<S2SV_blank>null." , text |
884 | CWE-000 char * _ui_get_key ( atomic_int * isEnd ) { char * c = malloc ( sizeof ( char ) ) ; for ( ; ; ) { if ( * isEnd == 1 ) { free ( c ) ; c = 0 ; break ; } pthread_mutex_lock ( & block_input ) ; * c = getch ( ) ; pthread_mutex_unlock ( & block_input ) ; if ( * c > 0 ) { break ; } <S2SV_StartBug> SLEEP ( 5 ) ; <S2SV_EndBug> } return c ; } | <S2SV_ModStart> break ; } <S2SV_ModEnd> } return c |
885 | CWE-000 static const char * droste_filter_name ( void * unused ) { UNUSED_PARAMETER ( unused ) ; <S2SV_StartBug> return obs_module_text ( "Droste.Effect" ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; return OMT <S2SV_ModEnd> ( "Droste.Effect" ) |
886 | CWE-000 static void php_zmq_sendmsg_impl ( INTERNAL_FUNCTION_PARAMETERS ) { php_zmq_socket_object * intern ; zend_string * message_param ; <S2SV_StartBug> long flags = 0 ; <S2SV_EndBug> zend_bool ret ; if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) , "S|l" , & message_param , & flags ) == FAILURE ) { return ; } intern = PHP_ZMQ_SOCKET_OBJECT ; ret = php_zmq_send ( intern , message_param , flags ) ; if ( ret ) { ZMQ_RETURN_THIS ; } else { RETURN_FALSE ; } } | <S2SV_ModStart> * message_param ; zend_long <S2SV_ModEnd> flags = 0 |
887 | CWE-000 static void blkcg_iolatency_throttle ( struct rq_qos * rqos , struct bio * bio ) { struct blk_iolatency * blkiolat = BLKIOLATENCY ( rqos ) ; struct blkcg * blkcg ; struct blkcg_gq * blkg ; struct request_queue * q = rqos -> q ; bool issue_as_root = bio_issue_as_root_blkg ( bio ) ; if ( ! blk_iolatency_enabled ( blkiolat ) ) return ; rcu_read_lock ( ) ; <S2SV_StartBug> blkcg = bio_blkcg ( bio ) ; <S2SV_EndBug> bio_associate_blkcg ( bio , & blkcg -> css ) ; blkg = blkg_lookup ( blkcg , q ) ; if ( unlikely ( ! blkg ) ) { spin_lock_irq ( & q -> queue_lock ) ; blkg = blkg_lookup_create ( blkcg , q ) ; if ( IS_ERR ( blkg ) ) blkg = NULL ; spin_unlock_irq ( & q -> queue_lock ) ; } if ( ! blkg ) goto out ; bio_issue_init ( & bio -> bi_issue , bio_sectors ( bio ) ) ; bio_associate_blkg ( bio , blkg ) ; out : rcu_read_unlock ( ) ; while ( blkg && blkg -> parent ) { struct iolatency_grp * iolat = blkg_to_lat ( blkg ) ; if ( ! iolat ) { blkg = blkg -> parent ; continue ; } check_scale_change ( iolat ) ; __blkcg_iolatency_throttle ( rqos , iolat , issue_as_root , ( bio -> bi_opf & REQ_SWAP ) == REQ_SWAP ) ; blkg = blkg -> parent ; } if ( ! timer_pending ( & blkiolat -> timer ) ) mod_timer ( & blkiolat -> timer , jiffies + HZ ) ; } | <S2SV_ModStart> ( ) ; bio_associate_blkcg ( bio , NULL ) ; <S2SV_ModStart> bio_blkcg ( bio <S2SV_ModEnd> ) ; blkg |
888 | CWE-000 int sfs_fread ( int fileID , char * buf , int length ) { if ( length < 0 ) { printf ( "Length<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>negative\\n" ) ; return - 1 ; } file_descriptor * myFd ; myFd = & fd [ fileID ] ; if ( ( * myFd ) . inodeIndex == - 1 ) { printf ( "File<S2SV_blank>is<S2SV_blank>not<S2SV_blank>open\\n" ) ; return - 1 ; } inode_t * myINode ; myINode = ( * myFd ) . inode ; int rwptr = ( * myFd ) . rwptr ; int startBlockIndex = rwptr / BLOCK_SIZE ; int startIndexInBlock = rwptr % BLOCK_SIZE ; int endRwptr ; if ( rwptr + length > ( * myINode ) . size ) { endRwptr = ( * myINode ) . size ; } else { endRwptr = rwptr + length ; } int endBlockIndex = endRwptr / BLOCK_SIZE ; int endIndexInBlock = endRwptr % BLOCK_SIZE ; int bytesRead = 0 ; buffer = ( void * ) malloc ( BLOCK_SIZE ) ; int addresses [ NUM_ADDRESSES_INDIRECT ] ; <S2SV_StartBug> int indirectBlockIndex ; <S2SV_EndBug> int i ; for ( i = startBlockIndex ; i <= endBlockIndex ; i ++ ) { int tmp = calculateByteIndex ( i , 0 ) ; if ( tmp >= ( * myINode ) . size ) { printf ( "File<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>read<S2SV_blank>past<S2SV_blank>its<S2SV_blank>size\\n" ) ; printf ( "SOMETHING<S2SV_blank>WRONG<S2SV_blank>-<S2SV_blank>i:<S2SV_blank>%d<S2SV_blank>myINode.size<S2SV_blank>%d\\n" , i , ( * myINode ) . size ) ; break ; } memset ( buffer , 0 , BLOCK_SIZE ) ; if ( i > 11 ) { <S2SV_StartBug> if ( i == 12 ) { <S2SV_EndBug> read_blocks ( ( * myINode ) . indirectPointer , 1 , buffer ) ; memcpy ( addresses , buffer , BLOCK_SIZE ) ; <S2SV_StartBug> memset ( buffer , 0 , BLOCK_SIZE ) ; <S2SV_EndBug> } indirectBlockIndex = i - 11 - 1 ; if ( addresses [ indirectBlockIndex ] == - 1 ) { printf ( "Address<S2SV_blank>of<S2SV_blank>block<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>found.<S2SV_blank>Investigate\\n" ) ; break ; } read_blocks ( addresses [ indirectBlockIndex ] , 1 , buffer ) ; if ( i == startBlockIndex ) { if ( startBlockIndex == endBlockIndex ) { memcpy ( buf , buffer + startIndexInBlock , endIndexInBlock - startIndexInBlock ) ; bytesRead += endIndexInBlock - startIndexInBlock ; } else { memcpy ( buf , buffer + startIndexInBlock , BLOCK_SIZE - startIndexInBlock ) ; bytesRead += BLOCK_SIZE - startIndexInBlock ; } } else if ( i == endBlockIndex ) { if ( calculateByteIndex ( i , endIndexInBlock ) > ( * myINode ) . size ) printf ( "SOMETHING<S2SV_blank>WRONG<S2SV_blank>-<S2SV_blank>i:<S2SV_blank>%d<S2SV_blank>endIndexInBlock:<S2SV_blank>%d<S2SV_blank>myINode.size<S2SV_blank>%d\\n" , i , endIndexInBlock , ( * myINode ) . size ) ; memcpy ( buf + bytesRead , buffer , endIndexInBlock ) ; if ( length - bytesRead != endIndexInBlock ) printf ( "Investigate<S2SV_blank>endIndexInBlock<S2SV_blank>in<S2SV_blank>indirect<S2SV_blank>pointers\\n" ) ; bytesRead += endIndexInBlock ; } else { memcpy ( buf + bytesRead , buffer , BLOCK_SIZE ) ; bytesRead += BLOCK_SIZE ; } } else { if ( ( * myINode ) . data_ptrs [ i ] == - 1 ) { printf ( "Address<S2SV_blank>of<S2SV_blank>block<S2SV_blank>has<S2SV_blank>not<S2SV_blank>been<S2SV_blank>found.<S2SV_blank>Investigate\\n" ) ; break ; } read_blocks ( ( * myINode ) . data_ptrs [ i ] , 1 , buffer ) ; if ( i == startBlockIndex ) { if ( startBlockIndex == endBlockIndex ) { memcpy ( buf , buffer + startIndexInBlock , endIndexInBlock - startIndexInBlock ) ; bytesRead += endIndexInBlock - startIndexInBlock ; } else { memcpy ( buf , buffer + startIndexInBlock , BLOCK_SIZE - startIndexInBlock ) ; bytesRead += BLOCK_SIZE - startIndexInBlock ; } } else if ( i == endBlockIndex ) { if ( calculateByteIndex ( i , endIndexInBlock ) > ( * myINode ) . size ) printf ( "SOMETHING<S2SV_blank>WRONG<S2SV_blank>-<S2SV_blank>i:<S2SV_blank>%d<S2SV_blank>endIndexInBlock:<S2SV_blank>%d<S2SV_blank>myINode.size<S2SV_blank>%d\\n" , i , endIndexInBlock , ( * myINode ) . size ) ; memcpy ( buf + bytesRead , buffer , endIndexInBlock ) ; if ( length - bytesRead != endIndexInBlock ) printf ( "Investigate<S2SV_blank>endIndexInBlock<S2SV_blank>in<S2SV_blank>direct<S2SV_blank>pointers\\n" ) ; bytesRead += endIndexInBlock ; } else { memcpy ( buf + bytesRead , buffer , BLOCK_SIZE ) ; bytesRead += BLOCK_SIZE ; } } } ( * myFd ) . rwptr += bytesRead ; free ( buffer ) ; return bytesRead ; } | <S2SV_ModStart> ] ; int addressesInitialized = 0 ; int <S2SV_ModStart> { if ( ! addressesInitialized <S2SV_ModEnd> ) { read_blocks <S2SV_ModStart> , BLOCK_SIZE ) ; addressesInitialized = 1 |
889 | CWE-000 static int nvm_create_tgt ( struct nvm_dev * dev , struct nvm_ioctl_create * create ) { struct nvm_ioctl_create_simple * s = & create -> conf . s ; struct request_queue * tqueue ; struct gendisk * tdisk ; struct nvm_tgt_type * tt ; struct nvm_target * t ; struct nvm_tgt_dev * tgt_dev ; void * targetdata ; tt = nvm_find_target_type ( create -> tgttype , 1 ) ; if ( ! tt ) { pr_err ( "nvm:<S2SV_blank>target<S2SV_blank>type<S2SV_blank>%s<S2SV_blank>not<S2SV_blank>found\\n" , create -> tgttype ) ; return - EINVAL ; } mutex_lock ( & dev -> mlock ) ; t = nvm_find_target ( dev , create -> tgtname ) ; if ( t ) { pr_err ( "nvm:<S2SV_blank>target<S2SV_blank>name<S2SV_blank>already<S2SV_blank>exists.\\n" ) ; mutex_unlock ( & dev -> mlock ) ; return - EINVAL ; } mutex_unlock ( & dev -> mlock ) ; if ( nvm_reserve_luns ( dev , s -> lun_begin , s -> lun_end ) ) return - ENOMEM ; t = kmalloc ( sizeof ( struct nvm_target ) , GFP_KERNEL ) ; if ( ! t ) goto err_reserve ; tgt_dev = nvm_create_tgt_dev ( dev , s -> lun_begin , s -> lun_end ) ; if ( ! tgt_dev ) { pr_err ( "nvm:<S2SV_blank>could<S2SV_blank>not<S2SV_blank>create<S2SV_blank>target<S2SV_blank>device\\n" ) ; goto err_t ; } <S2SV_StartBug> tqueue = blk_alloc_queue_node ( GFP_KERNEL , dev -> q -> node ) ; <S2SV_EndBug> <S2SV_StartBug> if ( ! tqueue ) <S2SV_EndBug> goto err_dev ; <S2SV_StartBug> blk_queue_make_request ( tqueue , tt -> make_rq ) ; <S2SV_EndBug> tdisk = alloc_disk ( 0 ) ; if ( ! tdisk ) goto err_queue ; sprintf ( tdisk -> disk_name , "%s" , create -> tgtname ) ; tdisk -> flags = GENHD_FL_EXT_DEVT ; tdisk -> major = 0 ; tdisk -> first_minor = 0 ; tdisk -> fops = & nvm_fops ; tdisk -> queue = tqueue ; targetdata = tt -> init ( tgt_dev , tdisk ) ; if ( IS_ERR ( targetdata ) ) goto err_init ; tdisk -> private_data = targetdata ; tqueue -> queuedata = targetdata ; blk_queue_max_hw_sectors ( tqueue , 8 * dev -> ops -> max_phys_sect ) ; set_capacity ( tdisk , tt -> capacity ( targetdata ) ) ; add_disk ( tdisk ) ; if ( tt -> sysfs_init && tt -> sysfs_init ( tdisk ) ) goto err_sysfs ; t -> type = tt ; t -> disk = tdisk ; t -> dev = tgt_dev ; mutex_lock ( & dev -> mlock ) ; list_add_tail ( & t -> list , & dev -> targets ) ; mutex_unlock ( & dev -> mlock ) ; return 0 ; err_sysfs : if ( tt -> exit ) tt -> exit ( targetdata ) ; err_init : <S2SV_StartBug> put_disk ( tdisk ) ; <S2SV_EndBug> err_queue : blk_cleanup_queue ( tqueue ) ; err_dev : nvm_remove_tgt_dev ( tgt_dev , 0 ) ; err_t : kfree ( t ) ; err_reserve : nvm_release_luns_err ( dev , s -> lun_begin , s -> lun_end ) ; return - ENOMEM ; } | <S2SV_ModStart> err_t ; } tdisk = alloc_disk ( 0 <S2SV_ModEnd> ) ; if <S2SV_ModStart> if ( ! tdisk <S2SV_ModEnd> ) goto err_dev <S2SV_ModStart> goto err_dev ; tqueue = blk_alloc_queue_node ( GFP_KERNEL , dev -> q -> node ) ; if ( ! tqueue ) goto err_disk ; <S2SV_ModStart> -> make_rq ) <S2SV_ModEnd> ; sprintf ( <S2SV_ModStart> ; err_init : blk_cleanup_queue ( tqueue ) ; err_disk : <S2SV_ModStart> put_disk ( tdisk <S2SV_ModEnd> ) ; err_dev |
890 | CWE-000 static void print_active_wakeup_sources ( void ) { struct wakeup_source * ws ; int active = 0 ; <S2SV_StartBug> struct wakeup_source * last_activity_ws = NULL ; <S2SV_EndBug> if ( is_display_on ( ) ) return ; rcu_read_lock ( ) ; list_for_each_entry_rcu ( ws , & wakeup_sources , entry ) { if ( ws -> active ) { pr_info ( "active<S2SV_blank>wakeup<S2SV_blank>source:<S2SV_blank>%s\\n" , ws -> name ) ; active = 1 ; } else if ( ! active && ( ! last_activity_ws || ktime_to_ns ( ws -> last_time ) > ktime_to_ns ( last_activity_ws -> last_time ) ) ) { last_activity_ws = ws ; } } if ( ! active && last_activity_ws ) pr_info ( "last<S2SV_blank>active<S2SV_blank>wakeup<S2SV_blank>source:<S2SV_blank>%s\\n" , last_activity_ws -> name ) ; rcu_read_unlock ( ) ; } | <S2SV_ModStart> last_activity_ws = NULL <S2SV_ModEnd> ; rcu_read_lock ( |
891 | CWE-000 void * memcpy ( void * dest , const void * src , size_t count ) { char * tmp = dest ; const char * s = src ; <S2SV_StartBug> while ( count -- ) <S2SV_EndBug> * tmp ++ = * s ++ ; return dest ; } | <S2SV_ModStart> ( count -- AENOC |
892 | CWE-000 Lval callfunc ( const char * name , Lval * in , size_t numasts ) { size_t j ; <S2SV_StartBug> for ( size_t i = 0 ; i < sizeof ( builtins ) ; i ++ ) { <S2SV_EndBug> if ( ! strcmp ( name , builtins [ i ] . name ) ) { for ( j = 0 ; j < numasts ; j ++ ) { <S2SV_StartBug> if ( ! isin ( in [ j ] . type , builtins [ i ] . validtypes , SIZE ( builtins [ i ] . validtypes ) ) ) { <S2SV_EndBug> goto postfor ; } } return builtins [ i ] . func ( in , numasts ) ; } <S2SV_StartBug> continue ; <S2SV_EndBug> postfor : error ( "Unexpected<S2SV_blank>type<S2SV_blank>%d,<S2SV_blank>for<S2SV_blank>function<S2SV_blank>%s." , in [ j ] . type , name ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> ; i < SIZE <S2SV_ModEnd> ( builtins ) <S2SV_ModStart> . type , ( int * ) <S2SV_ModStart> ) ; } } error ( "Unknown<S2SV_blank>function<S2SV_blank>%s" , name ) <S2SV_ModEnd> ; postfor : <S2SV_ModStart> ) ; } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
893 | CWE-000 void handle_arpreq ( struct sr_instance * sr , struct sr_arpreq * arpreq ) { if ( difftime ( time ( 0 ) , arpreq -> sent ) >= 1 ) { <S2SV_StartBug> if ( arpreq -> times_sent < 5 ) { <S2SV_EndBug> struct sr_if * dest_intface = sr_get_interface ( sr , arpreq -> packets -> iface ) ; uint8_t * arp_packet = malloc ( sizeof ( sr_ethernet_hdr_t ) + sizeof ( sr_arp_hdr_t ) ) ; sr_ethernet_hdr_t * arp_ether_header = ( sr_ethernet_hdr_t * ) arp_packet ; arp_ether_header -> ether_type = htons ( ethertype_arp ) ; memset ( arp_ether_header -> ether_dhost , 255 , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; memcpy ( arp_ether_header -> ether_shost , dest_intface -> addr , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; sr_arp_hdr_t * arp_header = ( sr_arp_hdr_t * ) ( arp_packet + sizeof ( sr_ethernet_hdr_t ) ) ; arp_header -> ar_tip = arpreq -> ip ; arp_header -> ar_sip = dest_intface -> ip ; arp_header -> ar_op = htons ( arp_op_request ) ; arp_header -> ar_pro = htons ( ethertype_ip ) ; arp_header -> ar_hrd = htons ( arp_hrd_ethernet ) ; arp_header -> ar_pln = sizeof ( uint32_t ) ; arp_header -> ar_hln = ETHER_ADDR_LEN ; memset ( arp_header -> ar_tha , 255 , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; memcpy ( arp_header -> ar_sha , dest_intface -> addr , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; sr_send_packet ( sr , arp_packet , sizeof ( sr_ethernet_hdr_t ) + sizeof ( sr_arp_hdr_t ) , dest_intface -> name ) ; free ( arp_packet ) ; arpreq -> sent = time ( NULL ) ; arpreq -> times_sent ++ ; } else { while ( arpreq -> packets ) { uint8_t * arp_buf = arpreq -> packets -> buf ; char * arp_intface = arpreq -> packets -> iface ; uint8_t * arp_packet = malloc ( sizeof ( sr_ethernet_hdr_t ) + sizeof ( sr_ip_hdr_t ) + sizeof ( sr_icmp_t3_hdr_t ) ) ; create_send ( 3 , 1 , sr_get_interface ( sr , arp_intface ) -> ip , arp_packet , sr , arp_buf , arp_intface ) ; sr_ip_hdr_t * arp_ip_header = ( sr_ip_hdr_t * ) ( arp_packet + sizeof ( sr_ethernet_hdr_t ) ) ; struct sr_rt * source_match = prematch ( sr , arp_ip_header -> ip_src ) ; if ( source_match ) { struct sr_arpentry * arp_ent = sr_arpcache_lookup ( & sr -> cache , source_match -> gw . s_addr ) ; if ( ! arp_ent ) { struct sr_arpreq * arp_req = sr_arpcache_queuereq ( & sr -> cache , source_match -> gw . s_addr , arp_packet , sizeof ( sr_ethernet_hdr_t ) + sizeof ( sr_ip_hdr_t ) + sizeof ( sr_icmp_t3_hdr_t ) , source_match -> interface ) ; handle_arpreq ( sr , arp_req ) ; } else { struct sr_if * cache_intface = sr_get_interface ( sr , source_match -> interface ) ; sr_ethernet_hdr_t * cache_ether_header = ( sr_ethernet_hdr_t * ) arp_packet ; memcpy ( cache_ether_header -> ether_dhost , arp_ent -> mac , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; memcpy ( cache_ether_header -> ether_shost , cache_intface -> addr , sizeof ( uint8_t ) * ETHER_ADDR_LEN ) ; sr_ip_hdr_t * cache_ip_header = ( sr_ip_hdr_t * ) ( arp_packet + sizeof ( sr_ethernet_hdr_t ) ) ; cache_ip_header -> ip_src = sr_get_interface ( sr , arp_intface ) -> ip ; cache_ip_header -> ip_sum = 0 ; cache_ip_header -> ip_sum = cksum ( cache_ip_header , sizeof ( sr_ip_hdr_t ) ) ; sr_send_packet ( sr , arp_packet , sizeof ( sr_ethernet_hdr_t ) + sizeof ( sr_ip_hdr_t ) + sizeof ( sr_icmp_t3_hdr_t ) , cache_intface -> name ) ; free ( arp_ent ) ; } free ( arp_packet ) ; } arpreq -> packets = arpreq -> packets -> next ; } sr_arpreq_destroy ( & sr -> cache , arpreq ) ; } } } | <S2SV_ModStart> -> times_sent < 15 <S2SV_ModEnd> ) { struct |
894 | CWE-000 <S2SV_StartBug> size_t log_err ( const char * format , ... ) <S2SV_EndBug> { <S2SV_StartBug> size_t ret ; <S2SV_EndBug> int len ; char * buffer ; va_list args ; va_start ( args , format ) ; len = vasprintf ( & buffer , format , args ) ; va_end ( args ) ; if ( len < 0 ) return len ; if ( is_backend ) { ret = fio_server_text_output ( FIO_LOG_ERR , buffer , len ) ; if ( ret != - 1 ) goto done ; } if ( log_syslog ) { syslog ( LOG_INFO , "%s" , buffer ) ; ret = len ; } else { if ( f_err != stderr ) ret = fwrite ( buffer , len , 1 , stderr ) ; ret = fwrite ( buffer , len , 1 , f_err ) ; } done : free ( buffer ) ; return ret ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> ssize_t <S2SV_ModEnd> log_err ( const <S2SV_ModStart> ... ) { ssize_t <S2SV_ModEnd> ret ; int |
895 | CWE-000 void initLEDs ( void ) { # ifdef LED_SHIELD_PRESENT TRISAbits . TRISA2 = OUTPUT ; TRISCbits . TRISC4 = OUTPUT ; TRISDbits . TRISD4 = OUTPUT ; TRISDbits . TRISD3 = OUTPUT ; TRISDbits . TRISD12 = OUTPUT ; TRISGbits . TRISG1 = OUTPUT ; TRISGbits . TRISG0 = INPUT ; <S2SV_StartBug> RED2 = OFF , YELLOW1 = OFF , YELLOW2 = OFF ; <S2SV_EndBug> <S2SV_StartBug> GREEN1 = OFF , GREEN2 = OFF , BUTTONPWR = ON ; <S2SV_EndBug> # endif TRISAbits . TRISA3 = OUTPUT ; TRISCbits . TRISC1 = OUTPUT ; <S2SV_StartBug> BOARD_LED1 = OFF , BOARD_LED2 = OFF ; <S2SV_EndBug> } | <S2SV_ModStart> ; RED2 = 0 <S2SV_ModEnd> , YELLOW1 = <S2SV_ModStart> , YELLOW1 = 0 <S2SV_ModEnd> , YELLOW2 = <S2SV_ModStart> , YELLOW2 = 0 <S2SV_ModEnd> ; GREEN1 = <S2SV_ModStart> ; GREEN1 = 0 <S2SV_ModEnd> , GREEN2 = <S2SV_ModStart> , GREEN2 = 0 <S2SV_ModEnd> , BUTTONPWR = <S2SV_ModStart> , BUTTONPWR = 1 <S2SV_ModEnd> ; # endif <S2SV_ModStart> ; BOARD_LED1 = 0 <S2SV_ModEnd> , BOARD_LED2 = <S2SV_ModStart> , BOARD_LED2 = 0 <S2SV_ModEnd> ; } <S2SV_null> |
896 | CWE-000 void virNetServerClose ( virNetServerPtr srv ) { size_t i ; if ( ! srv ) return ; virObjectLock ( srv ) ; for ( i = 0 ; i < srv -> nservices ; i ++ ) virNetServerServiceClose ( srv -> services [ i ] ) ; <S2SV_StartBug> virObjectUnlock ( srv ) ; <S2SV_EndBug> } | <S2SV_ModStart> ] ) ; for ( i = 0 ; i < srv -> nclients ; i ++ ) virNetServerClientClose ( srv -> clients [ i ] ) ; |
897 | CWE-000 static void add_to_size_group ( EAPMethod * parent , GtkSizeGroup * group ) { EAPMethodPEAP * method = ( EAPMethodPEAP * ) parent ; GtkWidget * widget ; GtkTreeModel * model ; GtkTreeIter iter ; EAPMethod * eap ; if ( method -> size_group ) g_object_unref ( method -> size_group ) ; method -> size_group = g_object_ref ( group ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_ca_cert_not_required_checkbox" ) ) ; g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_anon_identity_label" ) ) ; g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; <S2SV_StartBug> widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_ca_cert_label" ) ) ; <S2SV_EndBug> g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_version_label" ) ) ; g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_inner_auth_label" ) ) ; g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; widget = GTK_WIDGET ( gtk_builder_get_object ( parent -> builder , "eap_peap_inner_auth_combo" ) ) ; g_assert ( widget ) ; model = gtk_combo_box_get_model ( GTK_COMBO_BOX ( widget ) ) ; gtk_combo_box_get_active_iter ( GTK_COMBO_BOX ( widget ) , & iter ) ; gtk_tree_model_get ( model , & iter , I_METHOD_COLUMN , & eap , - 1 ) ; g_assert ( eap ) ; eap_method_add_to_size_group ( eap , group ) ; eap_method_unref ( eap ) ; } | <S2SV_ModStart> -> builder , "eap_peap_domain_label" ) ) ; g_assert ( widget ) ; gtk_size_group_add_widget ( group , widget ) ; nma_cert_chooser_add_to_size_group ( NMA_CERT_CHOOSER ( method -> ca_cert_chooser ) , group <S2SV_ModEnd> ) ; widget |
898 | CWE-000 Datum isLocalValue ( PG_FUNCTION_ARGS ) { char * relname = TextDatumGetCString ( PG_GETARG_DATUM ( 0 ) ) ; fr_options_t frOpts ; int destnode ; void * data ; if ( nfrRelations == 0 ) load_description_frag ( ) ; if ( nfrRelations == 0 ) PG_RETURN_BOOL ( true ) ; frOpts = getRelFrag ( relname ) ; if ( frOpts . funcId == FR_FUNC_HASH ) { Oid atttypid ; Oid opclass ; Oid funcid ; FmgrInfo * hashfunction = palloc0 ( sizeof ( FmgrInfo ) ) ; Oid relid ; Relation rel ; Oid opcfamily , opcintype ; relid = get_relname_relid ( relname , get_pargres_schema ( ) ) ; rel = heap_open ( relid , AccessShareLock ) ; <S2SV_StartBug> atttypid = TupleDescAttr ( rel -> rd_att , frOpts . attno ) -> atttypid ; <S2SV_EndBug> heap_close ( rel , AccessShareLock ) ; opclass = GetDefaultOpClass ( atttypid , HASH_AM_OID ) ; opcfamily = get_opclass_family ( opclass ) ; opcintype = get_opclass_input_type ( opclass ) ; funcid = get_opfamily_proc ( opcfamily , opcintype , opcintype , HASHEXTENDED_PROC ) ; fmgr_info ( funcid , hashfunction ) ; data = hashfunction ; } else data = NULL ; destnode = get_tuple_node ( frOpts . funcId , PG_GETARG_DATUM ( 1 ) , node_number , nodes_at_cluster , data ) ; PG_RETURN_BOOL ( destnode == node_number ) ; } | <S2SV_ModStart> frOpts . attno - 1 |
899 | CWE-000 static void mdss_mdp_overlay_pan_display ( struct msm_fb_data_type * mfd ) { struct mdss_mdp_data * buf ; struct mdss_mdp_pipe * pipe ; struct fb_info * fbi ; struct mdss_overlay_private * mdp5_data ; struct mdss_data_type * mdata ; u32 offset ; int bpp , ret ; if ( ! mfd || ! mfd -> mdp . private1 ) return ; mdata = mfd_to_mdata ( mfd ) ; fbi = mfd -> fbi ; mdp5_data = mfd_to_mdp5_data ( mfd ) ; if ( ! mdp5_data || ! mdp5_data -> ctl ) return ; if ( ! fbi -> fix . smem_start || fbi -> fix . smem_len == 0 || mdp5_data -> borderfill_enable ) { mfd -> mdp . kickoff_fnc ( mfd , NULL ) ; return ; } if ( mutex_lock_interruptible ( & mdp5_data -> ov_lock ) ) return ; if ( ( mdss_fb_is_power_off ( mfd ) ) && ! ( ( mfd -> dcm_state == DCM_ENTER ) && ( mfd -> panel . type == MIPI_CMD_PANEL ) ) ) { mutex_unlock ( & mdp5_data -> ov_lock ) ; return ; } mdss_mdp_clk_ctrl ( MDP_BLOCK_POWER_ON ) ; bpp = fbi -> var . bits_per_pixel / 8 ; offset = fbi -> var . xoffset * bpp + fbi -> var . yoffset * fbi -> fix . line_length ; if ( offset > fbi -> fix . smem_len ) { pr_err ( "invalid<S2SV_blank>fb<S2SV_blank>offset=%u<S2SV_blank>total<S2SV_blank>length=%u\\n" , offset , fbi -> fix . smem_len ) ; goto pan_display_error ; } <S2SV_StartBug> # ifdef CONFIG_MACH_WT86518 <S2SV_EndBug> ret = mdss_mdp_overlay_get_fb_pipe ( mfd , & pipe , MDSS_MDP_MIXER_MUX_LEFT ) ; if ( ret ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } if ( mdss_mdp_pipe_map ( pipe ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>map<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } ret = mdss_mdp_overlay_start ( mfd ) ; if ( ret ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>start<S2SV_blank>overlay<S2SV_blank>%d<S2SV_blank>(%d)\\n" , mfd -> index , ret ) ; goto pan_display_error ; } ret = mdss_iommu_ctrl ( 1 ) ; if ( IS_ERR_VALUE ( ret ) ) { pr_err ( "IOMMU<S2SV_blank>attach<S2SV_blank>failed\\n" ) ; goto pan_display_error ; } # else ret = mdss_mdp_overlay_get_fb_pipe ( mfd , & pipe , MDSS_MDP_MIXER_MUX_LEFT ) ; if ( ret ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } if ( mdss_mdp_pipe_map ( pipe ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>map<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } ret = mdss_mdp_overlay_start ( mfd ) ; if ( ret ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>start<S2SV_blank>overlay<S2SV_blank>%d<S2SV_blank>(%d)\\n" , mfd -> index , ret ) ; goto pan_display_error ; } ret = mdss_iommu_ctrl ( 1 ) ; if ( IS_ERR_VALUE ( ret ) ) { pr_err ( "IOMMU<S2SV_blank>attach<S2SV_blank>failed\\n" ) ; goto pan_display_error ; } # endif buf = & pipe -> back_buf ; if ( mdata -> mdss_util -> iommu_attached ( ) ) { if ( ! mfd -> iova ) { pr_err ( "mfd<S2SV_blank>iova<S2SV_blank>is<S2SV_blank>zero\\n" ) ; mdss_mdp_pipe_unmap ( pipe ) ; goto pan_display_error ; } buf -> p [ 0 ] . addr = mfd -> iova ; } else { buf -> p [ 0 ] . addr = fbi -> fix . smem_start ; } buf -> p [ 0 ] . addr += offset ; buf -> p [ 0 ] . len = fbi -> fix . smem_len - offset ; buf -> num_planes = 1 ; mdss_mdp_pipe_unmap ( pipe ) ; if ( fbi -> var . xres > mdata -> max_mixer_width || is_split_lm ( mfd ) ) { ret = mdss_mdp_overlay_get_fb_pipe ( mfd , & pipe , MDSS_MDP_MIXER_MUX_RIGHT ) ; if ( ret ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>right<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } if ( mdss_mdp_pipe_map ( pipe ) ) { pr_err ( "unable<S2SV_blank>to<S2SV_blank>map<S2SV_blank>right<S2SV_blank>base<S2SV_blank>pipe\\n" ) ; goto pan_display_error ; } pipe -> back_buf = * buf ; mdss_mdp_pipe_unmap ( pipe ) ; } mutex_unlock ( & mdp5_data -> ov_lock ) ; if ( ( fbi -> var . activate & FB_ACTIVATE_VBL ) || ( fbi -> var . activate & FB_ACTIVATE_FORCE ) ) mfd -> mdp . kickoff_fnc ( mfd , NULL ) ; mdss_iommu_ctrl ( 0 ) ; mdss_mdp_clk_ctrl ( MDP_BLOCK_POWER_OFF ) ; return ; pan_display_error : mdss_iommu_ctrl ( 0 ) ; mdss_mdp_clk_ctrl ( MDP_BLOCK_POWER_OFF ) ; mutex_unlock ( & mdp5_data -> ov_lock ) ; } | <S2SV_ModStart> } # ifdef CNFIG_MACH_LENOVO_MSM8916 <S2SV_ModEnd> ret = mdss_mdp_overlay_get_fb_pipe |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.