Unnamed: 0
int64
0
535k
source
stringlengths
50
89.8k
target
stringlengths
23
37.7k
7,700
CWE-000 static void sun4i_lvds_encoder_enable ( struct drm_encoder * encoder ) { struct sun4i_lvds * lvds = drm_encoder_to_sun4i_lvds ( encoder ) ; struct sun4i_tcon * tcon = lvds -> tcon ; DRM_DEBUG_DRIVER ( "Enabling<S2SV_blank>LVDS<S2SV_blank>output\\n" ) ; <S2SV_StartBug> if ( ! IS_ERR ( tcon -> panel ) ) { <S2SV_EndBug> drm_panel_prepare ( tcon -> panel ) ; drm_panel_enable ( tcon -> panel ) ; } }
<S2SV_ModStart> ; if ( <S2SV_ModEnd> tcon -> panel <S2SV_ModStart> tcon -> panel <S2SV_ModEnd> ) { drm_panel_prepare
7,701
CWE-000 static enum status parse_world ( struct memfile * mf , struct base_file * file , int not_a_world ) { struct zip_archive * zp = zip_open_mem_read ( mf -> start , mf -> end - mf -> start ) ; char * buffer ; size_t actual_size ; struct memfile buf_file ; unsigned int file_id ; <S2SV_StartBug> int ret = ZIP_SUCCESS ; <S2SV_EndBug> if ( ZIP_SUCCESS != zip_read_directory ( zp ) ) { ret = CORRUPT_WORLD ; goto err_close ; } assign_fprops ( zp , not_a_world ) ; while ( ZIP_SUCCESS == zip_get_next_prop ( zp , & file_id , NULL , NULL ) ) { switch ( file_id ) { case FPROP_BOARD_INFO : case FPROP_ROBOT : <S2SV_StartBug> { <S2SV_EndBug> zip_get_next_uncompressed_size ( zp , & actual_size ) ; buffer = malloc ( actual_size ) ; zip_read_file ( zp , buffer , actual_size , & actual_size ) ; mfopen_static ( buffer , actual_size , & buf_file ) ; if ( file_id == FPROP_BOARD_INFO ) ret = parse_board_info ( & buf_file , file ) ; else if ( file_id == FPROP_ROBOT ) <S2SV_StartBug> ret = parse_robot_info ( & buf_file , file ) ; <S2SV_EndBug> free ( buffer ) ; break ; } default : { zip_skip_file ( zp ) ; break ; } } if ( ret != SUCCESS ) goto err_close ; } err_close : zip_close ( zp , NULL ) ; return ret ; }
<S2SV_ModStart> int file_id ; enum status ret = SUCCESS <S2SV_ModEnd> ; if ( <S2SV_ModStart> case FPROP_ROBOT : case FPROP_WORLD_SFX : <S2SV_ModStart> ret = parse_robot_info ( & buf_file , file ) ; else if ( file_id == FPROP_WORLD_SFX ) ret = parse_sfx_file
7,702
CWE-000 static parser_state_t scanError ( REnv * re , FEnv * fe , int inp_stream ) { CACHE_REGS fe -> t = 0 ; if ( LOCAL_Error_TYPE == RESOURCE_ERROR_TRAIL ) { LOCAL_Error_TYPE = YAP_NO_ERROR ; if ( ! Yap_growtrail ( sizeof ( CELL ) * K16 , FALSE ) ) { return YAP_PARSING_FINISHED ; } } else if ( LOCAL_Error_TYPE == RESOURCE_ERROR_AUXILIARY_STACK ) { LOCAL_Error_TYPE = YAP_NO_ERROR ; if ( ! Yap_ExpandPreAllocCodeSpace ( 0 , NULL , TRUE ) ) { return YAP_PARSING_FINISHED ; } } else if ( LOCAL_Error_TYPE == RESOURCE_ERROR_HEAP ) { LOCAL_Error_TYPE = YAP_NO_ERROR ; if ( ! Yap_growheap ( FALSE , 0 , NULL ) ) { return YAP_PARSING_FINISHED ; } } else if ( LOCAL_Error_TYPE == RESOURCE_ERROR_STACK ) { LOCAL_Error_TYPE = YAP_NO_ERROR ; if ( ! Yap_gcl ( LOCAL_Error_Size , fe -> nargs , ENV , CP ) ) { return YAP_PARSING_FINISHED ; } } <S2SV_StartBug> if ( re -> seekable ) { <S2SV_EndBug> if ( GLOBAL_Stream [ inp_stream ] . status & InMemory_Stream_f ) { GLOBAL_Stream [ inp_stream ] . u . mem_string . pos = re -> cpos ; } else if ( GLOBAL_Stream [ inp_stream ] . status ) { # if HAVE_FTELLO fseeko ( GLOBAL_Stream [ inp_stream ] . file , re -> cpos , 0L ) ; # else fseek ( GLOBAL_Stream [ inp_stream ] . file , re -> cpos , 0L ) ; # endif } } return YAP_SCANNING ; }
<S2SV_ModStart> } if ( LOCAL_Error_TYPE == SYNTAX_ERROR ) { return YAP_PARSING_ERROR ; } if (
7,703
CWE-000 uint32_t FAudioVoice_SetOutputMatrix ( FAudioVoice * voice , FAudioVoice * pDestinationVoice , uint32_t SourceChannels , uint32_t DestinationChannels , const float * pLevelMatrix , uint32_t OperationSet ) { uint32_t i ; FAudio_assert ( OperationSet == FAUDIO_COMMIT_NOW ) ; if ( pDestinationVoice == NULL && voice -> sends . SendCount == 1 ) { pDestinationVoice = voice -> audio -> master ; } for ( i = 0 ; i < voice -> sends . SendCount ; i += 1 ) { if ( pDestinationVoice == voice -> sends . pSends [ i ] . pOutputVoice ) { break ; } } FAudio_assert ( i < voice -> sends . SendCount ) ; if ( voice -> type == FAUDIO_VOICE_SOURCE ) { FAudio_assert ( SourceChannels == voice -> src . format . nChannels ) ; } else { FAudio_assert ( SourceChannels == voice -> mix . inputChannels ) ; } if ( pDestinationVoice -> type == FAUDIO_VOICE_MASTER ) { FAudio_assert ( DestinationChannels == pDestinationVoice -> master . inputChannels ) ; } else { <S2SV_StartBug> FAudio_assert ( DestinationChannels == voice -> mix . inputChannels ) ; <S2SV_EndBug> } FAudio_memcpy ( voice -> sendCoefficients [ i ] , pLevelMatrix , sizeof ( float ) * SourceChannels * DestinationChannels ) ; return 0 ; }
<S2SV_ModStart> ( DestinationChannels == pDestinationVoice <S2SV_ModEnd> -> mix .
7,704
CWE-000 int atoi ( char * str ) { int ret ; int i ; ret = 0 ; i = 0 ; do { <S2SV_StartBug> ret = ( ret * 10 + str [ i ] - '\\0' ) ; <S2SV_EndBug> } while ( i ++ && str [ i ] ) ; return ret ; }
<S2SV_ModStart> ; do { if ( str [ i ] > '9' && str [ i ] < '0' ) { break ; } <S2SV_ModStart> i ] - '0' <S2SV_ModEnd> ) ; }
7,705
CWE-000 int DriverRegPlayback ( SurviveContext * ctx ) { <S2SV_StartBug> install_recording ( ctx ) ; <S2SV_EndBug> <S2SV_StartBug> const char * playback_file = survive_configs ( ctx , "playbackfile" , SC_SETCONFIG , "" ) ; <S2SV_EndBug> if ( strlen ( playback_file ) == 0 ) { return 0 ; } SurvivePlaybackData * sp = calloc ( 1 , sizeof ( SurvivePlaybackData ) ) ; sp -> ctx = ctx ; sp -> playback_dir = playback_file ; <S2SV_StartBug> sp -> time_factor = survive_configf ( ctx , "playbackfactor" , SC_SETCONFIG , 1.f ) ; <S2SV_EndBug> printf ( "%s\\n" , playback_file ) ; sp -> playback_file = fopen ( playback_file , "r" ) ; if ( sp -> playback_file == 0 ) { fprintf ( stderr , "Could<S2SV_blank>not<S2SV_blank>open<S2SV_blank>playback<S2SV_blank>events<S2SV_blank>file<S2SV_blank>%s" , playback_file ) ; return - 1 ; } <S2SV_StartBug> SV_INFO ( "Using<S2SV_blank>playback<S2SV_blank>file<S2SV_blank>\'%s\'" , playback_file ) ; <S2SV_EndBug> SurviveObject * hmd = survive_create_hmd ( ctx , "Playback" , sp ) ; SurviveObject * wm0 = survive_create_wm0 ( ctx , "Playback" , sp , 0 ) ; SurviveObject * wm1 = survive_create_wm1 ( ctx , "Playback" , sp , 0 ) ; SurviveObject * tr0 = survive_create_tr0 ( ctx , "Playback" , sp ) ; SurviveObject * ww0 = survive_create_ww0 ( ctx , "Playback" , sp ) ; SurviveObject * objs [ ] = { hmd , wm0 , wm1 , tr0 , ww0 , 0 } ; FLT time ; while ( ! feof ( sp -> playback_file ) && ! ferror ( sp -> playback_file ) ) { char * line = 0 ; size_t n ; ssize_t r = getline ( & line , & n , sp -> playback_file ) ; if ( r <= 0 ) continue ; char dev [ 10 ] ; char command [ 10 ] ; if ( sscanf ( line , "%lf<S2SV_blank>%s<S2SV_blank>%s" , & time , dev , command ) != 3 ) { break ; } if ( strcmp ( command , "CONFIG" ) == 0 ) { char * configStart = line ; for ( int i = 0 ; i < 3 ; i ++ ) { while ( * ( ++ configStart ) != '<S2SV_blank>' ) ; } size_t len = strlen ( configStart ) ; for ( SurviveObject * * obj = objs ; * obj ; obj ++ ) { if ( * obj && strcmp ( dev , ( * obj ) -> codename ) == 0 && ctx -> configfunction ( * obj , configStart , len ) == 0 ) { SV_INFO ( "Found<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>playback<S2SV_blank>file..." , dev ) ; survive_add_object ( ctx , * obj ) ; * obj = 0 ; } } } } for ( SurviveObject * * obj = objs ; * obj ; obj ++ ) { if ( * obj ) { free ( * obj ) ; } } fseek ( sp -> playback_file , 0 , SEEK_SET ) ; survive_add_driver ( ctx , sp , playback_poll , playback_close , 0 ) ; return 0 ; }
<S2SV_ModStart> ctx ) { <S2SV_ModEnd> const char * <S2SV_ModStart> ( ctx , "playback" <S2SV_ModEnd> , SC_SETCONFIG , <S2SV_ModStart> ( ctx , "playback-factor" <S2SV_ModEnd> , SC_SETCONFIG , <S2SV_ModStart> } SV_INFO ( "Using<S2SV_blank>playback<S2SV_blank>file<S2SV_blank>\'%s\'<S2SV_blank>with<S2SV_blank>timefactor<S2SV_blank>of<S2SV_blank>%f" , playback_file , sp -> time_factor <S2SV_ModEnd> ) ; SurviveObject
7,706
CWE-000 int ext4_ind_map_blocks ( handle_t * handle , struct inode * inode , struct ext4_map_blocks * map , int flags ) { struct ext4_allocation_request ar ; int err = - EIO ; ext4_lblk_t offsets [ 4 ] ; Indirect chain [ 4 ] ; Indirect * partial ; int indirect_blks ; int blocks_to_boundary = 0 ; int depth ; int count = 0 ; ext4_fsblk_t first_block = 0 ; trace_ext4_ind_map_blocks_enter ( inode , map -> m_lblk , map -> m_len , flags ) ; J_ASSERT ( ! ( ext4_test_inode_flag ( inode , EXT4_INODE_EXTENTS ) ) ) ; J_ASSERT ( handle != NULL || ( flags & EXT4_GET_BLOCKS_CREATE ) == 0 ) ; depth = ext4_block_to_path ( inode , map -> m_lblk , offsets , & blocks_to_boundary ) ; if ( depth == 0 ) goto out ; partial = ext4_get_branch ( inode , depth , offsets , chain , & err ) ; if ( ! partial ) { first_block = le32_to_cpu ( chain [ depth - 1 ] . key ) ; count ++ ; while ( count < map -> m_len && count <= blocks_to_boundary ) { ext4_fsblk_t blk ; blk = le32_to_cpu ( * ( chain [ depth - 1 ] . p + count ) ) ; if ( blk == first_block + count ) count ++ ; else break ; } goto got_it ; } if ( ( flags & EXT4_GET_BLOCKS_CREATE ) == 0 || err == - EIO ) goto cleanup ; if ( EXT4_HAS_RO_COMPAT_FEATURE ( inode -> i_sb , EXT4_FEATURE_RO_COMPAT_BIGALLOC ) ) { EXT4_ERROR_INODE ( inode , "Can\'t<S2SV_blank>allocate<S2SV_blank>blocks<S2SV_blank>for<S2SV_blank>" "non-extent<S2SV_blank>mapped<S2SV_blank>inodes<S2SV_blank>with<S2SV_blank>bigalloc" ) ; return - ENOSPC ; } memset ( & ar , 0 , sizeof ( ar ) ) ; ar . inode = inode ; ar . logical = map -> m_lblk ; if ( S_ISREG ( inode -> i_mode ) ) ar . flags = EXT4_MB_HINT_DATA ; if ( flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ) ar . flags |= EXT4_MB_DELALLOC_RESERVED ; <S2SV_StartBug> ar . goal = ext4_find_goal ( inode , map -> m_lblk , partial ) ; <S2SV_EndBug> indirect_blks = ( chain + depth ) - partial - 1 ; ar . len = ext4_blks_to_allocate ( partial , indirect_blks , map -> m_len , blocks_to_boundary ) ; err = ext4_alloc_branch ( handle , & ar , indirect_blks , offsets + ( partial - chain ) , partial ) ; if ( ! err ) err = ext4_splice_branch ( handle , & ar , partial , indirect_blks ) ; if ( err ) goto cleanup ; map -> m_flags |= EXT4_MAP_NEW ; ext4_update_inode_fsync_trans ( handle , inode , 1 ) ; count = ar . len ; got_it : map -> m_flags |= EXT4_MAP_MAPPED ; map -> m_pblk = le32_to_cpu ( chain [ depth - 1 ] . key ) ; map -> m_len = count ; if ( count > blocks_to_boundary ) map -> m_flags |= EXT4_MAP_BOUNDARY ; err = count ; partial = chain + depth - 1 ; cleanup : while ( partial > chain ) { BUFFER_TRACE ( partial -> bh , "call<S2SV_blank>brelse" ) ; brelse ( partial -> bh ) ; partial -- ; } out : trace_ext4_ind_map_blocks_exit ( inode , flags , map , err ) ; return err ; }
<S2SV_ModStart> |= EXT4_MB_DELALLOC_RESERVED ; if ( flags & EXT4_GET_BLOCKS_METADATA_NOFAIL ) ar . flags |= EXT4_MB_USE_RESERVED ;
7,707
CWE-000 static void init ( void ) { char line [ 256 ] = { 0 } ; uint32_t flow_id = 0 ; uint32_t src_ip_segment1 = 0 , src_ip_segment2 = 0 , src_ip_segment3 = 0 , src_ip_segment4 = 0 ; uint32_t dst_ip_segment1 = 0 , dst_ip_segment2 = 0 , dst_ip_segment3 = 0 , dst_ip_segment4 = 0 ; uint16_t udp_src_port = 0 , udp_dst_port = 0 ; uint32_t flow_size = 0 ; double start_time ; FILE * fd = fopen ( flow_filename , "r" ) ; if ( ! fd ) printf ( "%s:<S2SV_blank>no<S2SV_blank>such<S2SV_blank>file\\n" , flow_filename ) ; while ( fgets ( line , sizeof ( line ) , fd ) != NULL ) { remove_newline ( line ) ; sscanf ( line , "%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%u<S2SV_blank>%hu<S2SV_blank>%hu<S2SV_blank>%u<S2SV_blank>%lf" , & flow_id , & src_ip_segment1 , & src_ip_segment2 , & src_ip_segment3 , & src_ip_segment4 , & dst_ip_segment1 , & dst_ip_segment2 , & dst_ip_segment3 , & dst_ip_segment4 , & udp_src_port , & udp_dst_port , & flow_size , & start_time ) ; sender_flows [ flow_id ] . src_ip = IPv4 ( src_ip_segment1 , src_ip_segment2 , src_ip_segment3 , src_ip_segment4 ) ; sender_flows [ flow_id ] . dst_ip = IPv4 ( dst_ip_segment1 , dst_ip_segment2 , dst_ip_segment3 , dst_ip_segment4 ) ; sender_flows [ flow_id ] . src_port = udp_src_port ; sender_flows [ flow_id ] . dst_port = udp_dst_port ; sender_flows [ flow_id ] . flow_size = flow_size ; sender_flows [ flow_id ] . remain_size = flow_size ; sender_flows [ flow_id ] . data_seqnum = 1 ; sender_flows [ flow_id ] . start_time = start_time ; <S2SV_StartBug> sender_flows [ flow_id ] . first_request_access_time = rte_rdtsc ( ) / ( double ) hz ; <S2SV_EndBug> sender_flows [ flow_id ] . last_grant_sent_time = 0 ; sender_flows [ flow_id ] . flow_state = HOMA_SEND_UNSTARTED ; sender_flows [ flow_id ] . first_grant_access_time = - 1.0 ; sender_flows [ flow_id ] . wait_close_start_time = - 1.0 ; receiver_flows [ flow_id ] . flow_state = HOMA_RECV_UNSTARTED ; if ( get_src_server_id ( flow_id , sender_flows ) == this_server_id ) sender_total_flow_num ++ ; if ( verbose > 0 ) { printf ( "Flow<S2SV_blank>info:<S2SV_blank>flow_id=%u,<S2SV_blank>src_ip=%u,<S2SV_blank>dst_ip=%u,<S2SV_blank>" "src_port=%hu,<S2SV_blank>dst_port=%hu,<S2SV_blank>flow_size=%u,<S2SV_blank>start_time=%lf\\n" , flow_id , sender_flows [ flow_id ] . src_ip , sender_flows [ flow_id ] . dst_ip , sender_flows [ flow_id ] . src_port , sender_flows [ flow_id ] . dst_port , sender_flows [ flow_id ] . flow_size , sender_flows [ flow_id ] . start_time ) ; } if ( flow_id == ( uint32_t ) total_flow_num - 2 ) break ; } sender_next_unstart_flow_id = - 1 ; sender_next_unstart_flow_id = find_next_unstart_flow_id ( ) ; fclose ( fd ) ; for ( int i = 0 ; i < MAX_CONCURRENT_FLOW ; i ++ ) { sender_request_sent_flow_array [ i ] = - 1 ; sender_active_flow_array [ i ] = - 1 ; receiver_active_flow_array [ i ] = - 1 ; } if ( verbose > 0 ) printf ( "Flow<S2SV_blank>info<S2SV_blank>summary:<S2SV_blank>total_flow_num<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>sender_total_flow_num<S2SV_blank>=<S2SV_blank>%d\\n" , total_flow_num , sender_total_flow_num ) ; }
<S2SV_ModStart> . first_request_access_time = - 1.0 <S2SV_ModEnd> ; sender_flows [
7,708
CWE-000 int exchanger_start_metadata_transfer ( exchanger_t * ex , void * * send_arrays , void * * receive_arrays , int stride , int tag , MPI_Datatype type , exchanger_metadata_dir direction ) { # if POLYMEC_HAVE_MPI START_FUNCTION_TIMER ( ) ; mpi_message_t * msg = mpi_message_new ( type , stride , tag ) ; int num_sends = exchanger_num_sends ( ex ) ; int * dest_procs = polymec_malloc ( sizeof ( int ) * num_sends ) ; int * send_buffer_sizes = polymec_malloc ( sizeof ( int ) * num_sends ) ; int pos = 0 , proc , * indices , num_indices , i = 0 ; while ( exchanger_next_send ( ex , & pos , & proc , & indices , & num_indices ) ) { dest_procs [ i ] = proc ; send_buffer_sizes [ i ++ ] = num_indices ; } int num_receives = exchanger_num_receives ( ex ) ; int * source_procs = polymec_malloc ( sizeof ( int ) * num_receives ) ; int * receive_buffer_sizes = polymec_malloc ( sizeof ( int ) * num_receives ) ; <S2SV_StartBug> pos = 0 , i = 0 ; <S2SV_EndBug> while ( exchanger_next_receive ( ex , & pos , & proc , & indices , & num_indices ) ) { source_procs [ i ] = proc ; receive_buffer_sizes [ i ++ ] = num_indices ; } if ( direction == EX_METADATA_FORWARD ) { msg -> num_sends = num_sends ; msg -> dest_procs = dest_procs ; msg -> send_buffer_sizes = send_buffer_sizes ; msg -> send_buffers = send_arrays ; msg -> source_procs = source_procs ; msg -> receive_buffer_sizes = receive_buffer_sizes ; msg -> receive_buffers = receive_arrays ; } else { msg -> num_sends = num_receives ; msg -> dest_procs = source_procs ; msg -> send_buffer_sizes = receive_buffer_sizes ; msg -> send_buffers = receive_arrays ; msg -> source_procs = dest_procs ; msg -> receive_buffer_sizes = send_buffer_sizes ; msg -> receive_buffers = send_arrays ; } msg -> requests = polymec_malloc ( ( msg -> num_sends + msg -> num_receives ) * sizeof ( MPI_Request ) ) ; int token = exchanger_send_message ( ex , NULL , msg ) ; STOP_FUNCTION_TIMER ( ) ; return token ; # else return 0 ; # endif }
<S2SV_ModStart> pos = 0 ; <S2SV_ModEnd> i = 0
7,709
CWE-000 static UCS_CLASS_CLEANUP_FUNC ( uct_rc_ep_t ) { uct_rc_iface_t * iface = ucs_derived_of ( self -> super . super . iface , uct_rc_iface_t ) ; ucs_debug ( "destroy<S2SV_blank>rc<S2SV_blank>ep<S2SV_blank>%p" , self ) ; ucs_list_del ( & self -> list ) ; uct_rc_iface_remove_qp ( iface , self -> txqp . qp -> qp_num ) ; uct_rc_ep_tag_qp_destroy ( self ) ; uct_rc_ep_pending_purge ( & self -> super . super , NULL , NULL ) ; uct_rc_fc_cleanup ( & self -> fc ) ; <S2SV_StartBug> uct_rc_txqp_cleanup ( & self -> txqp ) ; <S2SV_EndBug> }
<S2SV_ModStart> ; uct_rc_txqp_cleanup ( iface ,
7,710
CWE-000 static void ubus_msg_dequeue ( struct ubus_client * cl ) { struct ubus_msg_buf * ub = ubus_msg_head ( cl ) ; if ( ! ub ) return ; <S2SV_StartBug> ubus_msg_free ( ub ) ; <S2SV_EndBug> cl -> txq_ofs = 0 ; <S2SV_StartBug> cl -> tx_queue [ cl -> txq_cur ] = NULL ; <S2SV_EndBug> cl -> txq_cur = ( cl -> txq_cur + 1 ) % ARRAY_SIZE ( cl -> tx_queue ) ; }
<S2SV_ModStart> ) return ; list_del ( & ub -> list ) ; <S2SV_ModStart> = 0 ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
7,711
CWE-000 STATIC int connection_ap_process_http_connect ( entry_connection_t * conn ) { if ( BUG ( ENTRY_TO_CONN ( conn ) -> state != AP_CONN_STATE_HTTP_CONNECT_WAIT ) ) return - 1 ; char * headers = NULL , * body = NULL ; char * command = NULL , * addrport = NULL ; char * addr = NULL ; size_t bodylen = 0 ; const char * errmsg = NULL ; int rv = 0 ; const int http_status = fetch_from_buf_http ( ENTRY_TO_CONN ( conn ) -> inbuf , & headers , 8192 , & body , & bodylen , 1024 , 0 ) ; if ( http_status < 0 ) { errmsg = "HTTP/1.0<S2SV_blank>400<S2SV_blank>Bad<S2SV_blank>Request\\r\\n\\r\\n" ; goto err ; } else if ( http_status == 0 ) { goto done ; } const int cmd_status = parse_http_command ( headers , & command , & addrport ) ; if ( cmd_status < 0 ) { errmsg = "HTTP/1.0<S2SV_blank>400<S2SV_blank>Bad<S2SV_blank>Request\\r\\n\\r\\n" ; goto err ; } tor_assert ( command ) ; tor_assert ( addrport ) ; if ( strcasecmp ( command , "connect" ) ) { errmsg = "HTTP/1.0<S2SV_blank>405<S2SV_blank>Method<S2SV_blank>Not<S2SV_blank>Allowed\\r\\n\\r\\n" ; goto err ; } tor_assert ( conn -> socks_request ) ; socks_request_t * socks = conn -> socks_request ; uint16_t port ; if ( tor_addr_port_split ( LOG_WARN , addrport , & addr , & port ) < 0 ) { errmsg = "HTTP/1.0<S2SV_blank>400<S2SV_blank>Bad<S2SV_blank>Request\\r\\n\\r\\n" ; goto err ; } if ( strlen ( addr ) >= MAX_SOCKS_ADDR_LEN ) { errmsg = "HTTP/1.0<S2SV_blank>414<S2SV_blank>Request-URI<S2SV_blank>Too<S2SV_blank>Long\\r\\n\\r\\n" ; goto err ; } { char * authorization = http_get_header ( headers , "Proxy-Authorization:<S2SV_blank>" ) ; if ( authorization ) { socks -> username = authorization ; socks -> usernamelen = strlen ( authorization ) ; } char * isolation = http_get_header ( headers , "X-Tor-Stream-Isolation:<S2SV_blank>" ) ; if ( isolation ) { socks -> password = isolation ; socks -> passwordlen = strlen ( isolation ) ; } } socks -> command = SOCKS_COMMAND_CONNECT ; socks -> listener_type = CONN_TYPE_AP_HTTP_CONNECT_LISTENER ; strlcpy ( socks -> address , addr , sizeof ( socks -> address ) ) ; socks -> port = port ; control_event_stream_status ( conn , STREAM_EVENT_NEW , 0 ) ; rv = connection_ap_rewrite_and_attach_if_allowed ( conn , NULL , NULL ) ; goto done ; err : if ( BUG ( errmsg == NULL ) ) errmsg = "HTTP/1.0<S2SV_blank>400<S2SV_blank>Bad<S2SV_blank>Request\\r\\n\\r\\n" ; <S2SV_StartBug> log_warn ( LD_EDGE , "Saying<S2SV_blank>%s" , escaped ( errmsg ) ) ; <S2SV_EndBug> <S2SV_StartBug> connection_buf_add ( errmsg , strlen ( errmsg ) , ENTRY_TO_CONN ( conn ) ) ; <S2SV_EndBug> connection_mark_unattached_ap ( conn , END_STREAM_REASON_HTTPPROTOCOL | END_STREAM_REASON_FLAG_ALREADY_SOCKS_REPLIED ) ; done : tor_free ( headers ) ; tor_free ( body ) ; tor_free ( command ) ; tor_free ( addrport ) ; tor_free ( addr ) ; return rv ; }
<S2SV_ModStart> = "HTTP/1.0<S2SV_blank>400<S2SV_blank>Bad<S2SV_blank>Request\\r\\n\\r\\n" ; log_info <S2SV_ModEnd> ( LD_EDGE , <S2SV_ModStart> ( LD_EDGE , "HTTP<S2SV_blank>tunnel<S2SV_blank>error:<S2SV_blank>saying<S2SV_blank>%s" <S2SV_ModEnd> , escaped ( <S2SV_ModStart> conn ) ) ; conn -> socks_request -> has_finished = 1
7,712
CWE-000 int SendArg ( int id , unsigned char idx , char dtype , unsigned char nargs , unsigned short length , char ndims , int * dims , char * bytes ) { <S2SV_StartBug> int status ; <S2SV_EndBug> int msglen ; int i ; int nbytes = length ; Message * m ; int msgid = ( idx == 0 || nargs == 0 ) ? IncrementConnectionMessageId ( id ) : GetConnectionMessageId ( id ) ; if ( msgid < 1 ) <S2SV_StartBug> return 0 ; <S2SV_EndBug> if ( idx > nargs ) { nbytes = dims [ 0 ] ; } else { for ( i = 0 ; i < ndims ; i ++ ) nbytes *= dims [ i ] ; } msglen = sizeof ( MsgHdr ) + nbytes ; m = memset ( malloc ( msglen ) , 0 , msglen ) ; m -> h . client_type = 0 ; m -> h . msglen = msglen ; m -> h . message_id = msgid ; m -> h . descriptor_idx = idx ; m -> h . dtype = dtype ; m -> h . nargs = nargs ; m -> h . length = length ; m -> h . ndims = ndims ; # ifdef __CRAY for ( i = 0 ; i < 4 ; i ++ ) m -> h . dims [ i ] = ( ( ndims > i * 2 ) ? ( dims [ i * 2 ] << 32 ) : 0 ) | ( ( ndims > ( i * 2 + 1 ) ) ? ( dims [ i * 2 + 1 ] ) : 0 ) ; # else for ( i = 0 ; i < MAX_DIMS ; i ++ ) m -> h . dims [ i ] = i < ndims ? dims [ i ] : 0 ; # endif memcpy ( m -> bytes , bytes , nbytes ) ; status = SendMdsMsg ( id , m , 0 ) ; free ( m ) ; return status ; }
<S2SV_ModStart> bytes ) { INIT_STATUS_AS MDSplusERROR <S2SV_ModEnd> ; int msglen <S2SV_ModStart> 1 ) return status <S2SV_ModEnd> ; if (
7,713
CWE-000 static PHP_METHOD ( Phalcon_Escaper , escapeHtmlAttr ) { zend_long ZEPHIR_LAST_CALL_STATUS ; <S2SV_StartBug> zval * attribute_param = NULL , _0 , _1 , _2 ; <S2SV_EndBug> <S2SV_StartBug> zval attribute ; <S2SV_EndBug> zval * this_ptr = getThis ( ) ; ZVAL_UNDEF ( & attribute ) ; ZVAL_UNDEF ( & _0 ) ; ZVAL_UNDEF ( & _1 ) ; ZVAL_UNDEF ( & _2 ) ; ZEPHIR_MM_GROW ( ) ; zephir_fetch_params ( 1 , 1 , 0 , & attribute_param ) ; <S2SV_StartBug> zephir_get_strval ( & attribute , attribute_param ) ; <S2SV_EndBug> <S2SV_StartBug> zephir_read_property ( & _0 , this_ptr , SL ( "_encoding" ) , PH_NOISY_CC | PH_READONLY ) ; <S2SV_EndBug> <S2SV_StartBug> zephir_read_property ( & _1 , this_ptr , SL ( "_doubleEncode" ) , PH_NOISY_CC | PH_READONLY ) ; <S2SV_EndBug> ZVAL_LONG ( & _2 , 3 ) ; <S2SV_StartBug> ZEPHIR_RETURN_CALL_FUNCTION ( "htmlspecialchars" , NULL , 182 , & attribute , & _2 , & _0 , & _1 ) ; <S2SV_EndBug> zephir_check_call_status ( ) ; RETURN_MM ( ) ; }
<S2SV_ModStart> = NULL , * _0 , * <S2SV_ModEnd> _1 , _2 <S2SV_ModStart> _2 ; zval * attribute = NULL <S2SV_ModEnd> ; ZEPHIR_MM_GROW ( <S2SV_ModStart> ; zephir_get_strval ( <S2SV_ModEnd> attribute , attribute_param <S2SV_ModStart> attribute_param ) ; _0 = zephir_fetch_nproperty_this ( <S2SV_ModEnd> this_ptr , SL <S2SV_ModStart> ) , PH_NOISY_CC ) ; _1 = zephir_fetch_nproperty_this ( <S2SV_ModEnd> this_ptr , SL <S2SV_ModStart> ) , PH_NOISY_CC ) ; ZEPHIR_SINIT_VAR ( _2 <S2SV_ModEnd> ) ; ZVAL_LONG <S2SV_ModStart> , NULL , 194 , <S2SV_ModEnd> attribute , & <S2SV_ModStart> & _2 , _0 , <S2SV_ModEnd> _1 ) ;
7,714
CWE-000 static void __init_pthread_catalog ( ) { # ifdef __PTCATALOG_LOCK_MUTEX __ptcatalog_mutex = NULL ; # else __ptcatalog_sem = NULL ; # endif __ptcatalog = NULL ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> = NULL ; __register_thread ( ) ;
7,715
CWE-000 int _printf ( const char * format , ... ) { <S2SV_StartBug> int i = 0 ; <S2SV_EndBug> int count = 0 ; va_list args ; va_start ( args , format ) ; while ( * format != '\\0' ) { if ( * format != '%' ) { _putchar ( * format ) ; count ++ ; format ++ ; continue ; } format ++ ; count += ( * get_sel ( * format ) ) ( args ) ; <S2SV_StartBug> i ++ ; <S2SV_EndBug> } return ( count ) ; }
<S2SV_ModStart> ... ) { <S2SV_ModEnd> int count = <S2SV_ModStart> args ) ; format <S2SV_ModEnd> ++ ; }
7,716
CWE-000 int init ( int p , int c , int max ) { <S2SV_StartBug> return ( p % max ) ; <S2SV_EndBug> }
<S2SV_ModStart> max ) { p = abs ( p ) ;
7,717
CWE-000 void start_timer_loop ( ) { <S2SV_StartBug> calculate_time ( NULL , 1 ) ; <S2SV_EndBug> uv_timer_init ( server . loop , & server . time_timer ) ; uv_timer_start ( & server . time_timer , calculate_time , 500 , 500 ) ; }
<S2SV_ModStart> calculate_time ( NULL <S2SV_ModEnd> ) ; uv_timer_init
7,718
CWE-000 void loop ( void ) { HAL_GPIO_TogglePin ( LED_2_GPIO_Port , LED_2_Pin ) ; <S2SV_StartBug> HAL_Delay ( 500 ) ; <S2SV_EndBug> }
<S2SV_ModStart> LED_2_Pin ) ; vl_range_once ( ) ; HAL_Delay ( 10 ) ; HAL_GPIO_TogglePin ( LED_2_GPIO_Port , LED_2_Pin ) ; HAL_Delay ( 190 <S2SV_ModEnd> ) ; }
7,719
CWE-000 static Datum test_factory ( ConnectionType type , int status , char * host , int port ) { Connection * conn ; HttpRequest * req ; HttpResponseState * rsp = NULL ; HttpError err ; Datum json ; conn = connection_create ( type ) ; if ( conn == NULL ) return CStringGetTextDatum ( "could<S2SV_blank>not<S2SV_blank>initialize<S2SV_blank>a<S2SV_blank>connection" ) ; if ( connection_connect ( conn , host , NULL , port ) < 0 ) { <S2SV_StartBug> connection_destroy ( conn ) ; <S2SV_EndBug> <S2SV_StartBug> elog ( ERROR , "connection<S2SV_blank>error:<S2SV_blank>%s" , connection_get_and_clear_error ( conn ) ) ; <S2SV_EndBug> } # ifdef TS_DEBUG if ( type == CONNECTION_MOCK ) connection_mock_set_recv_buf ( conn , test_string , strlen ( test_string ) ) ; # endif req = build_request ( status ) ; rsp = http_response_state_create ( ) ; err = http_send_and_recv ( conn , req , rsp ) ; http_request_destroy ( req ) ; connection_destroy ( conn ) ; if ( err != HTTP_ERROR_NONE ) elog ( ERROR , "%s" , http_strerror ( err ) ) ; if ( ! http_response_state_valid_status ( rsp ) ) elog ( ERROR , "endpoint<S2SV_blank>sent<S2SV_blank>back<S2SV_blank>unexpected<S2SV_blank>HTTP<S2SV_blank>status:<S2SV_blank>%d" , http_response_state_status_code ( rsp ) ) ; json = DirectFunctionCall1 ( jsonb_in , CStringGetDatum ( http_response_state_body_start ( rsp ) ) ) ; http_response_state_destroy ( rsp ) ; return json ; }
<S2SV_ModStart> 0 ) { const char * err_msg = connection_get_and_clear_error ( conn ) ; <S2SV_ModStart> , "connection<S2SV_blank>error:<S2SV_blank>%s" , err_msg <S2SV_ModEnd> ) ; }
7,720
CWE-000 struct yabi_string * yabi_get_string ( struct yabi_type * element ) { <S2SV_StartBug> return element -> string ; <S2SV_EndBug> }
<S2SV_ModStart> element ) { assert ( element -> type == YABI_STRING ) ;
7,721
CWE-000 void zconfig_set_name ( zconfig_t * self , const char * name ) { assert ( self ) ; <S2SV_StartBug> free ( self -> name ) ; <S2SV_EndBug> self -> name = name ? strdup ( name ) : NULL ; }
<S2SV_ModStart> self ) ; FREE_AND_NULL <S2SV_ModEnd> ( self ->
7,722
CWE-000 static rnp_result_t encrypted_add_recipient ( pgp_write_handler_t * handler , pgp_dest_t * dst , const char * userid , const uint8_t * key , const unsigned keylen ) { pgp_key_request_ctx_t keyctx = { 0 } ; pgp_key_t * userkey ; pgp_pubkey_t * pubkey ; uint8_t enckey [ PGP_MAX_KEY_SIZE + 3 ] ; unsigned checksum = 0 ; pgp_pk_sesskey_pkt_t pkey = { 0 } ; pgp_dest_encrypted_param_t * param = dst -> param ; rnp_result_t ret = RNP_ERROR_GENERIC ; if ( ! handler -> key_provider ) { RNP_LOG ( "no<S2SV_blank>key<S2SV_blank>provider" ) ; return RNP_ERROR_BAD_PARAMETERS ; } keyctx . op = PGP_OP_ENCRYPT_SYM ; keyctx . secret = false ; keyctx . stype = PGP_KEY_SEARCH_USERID ; keyctx . search . userid = userid ; if ( ! pgp_request_key ( handler -> key_provider , & keyctx , & userkey ) ) { RNP_LOG ( "key<S2SV_blank>for<S2SV_blank>recipient<S2SV_blank>\'%s\'<S2SV_blank>not<S2SV_blank>found" , userid ) ; return RNP_ERROR_BAD_PARAMETERS ; } userkey = find_suitable_key ( PGP_OP_ENCRYPT_SYM , userkey , handler -> key_provider , PGP_KF_ENCRYPT ) ; if ( ! userkey ) { return RNP_ERROR_NO_SUITABLE_KEY ; } pubkey = & userkey -> key . pubkey ; pkey . version = PGP_PKSK_V3 ; pkey . alg = pubkey -> alg ; if ( ! pgp_keyid ( pkey . key_id , PGP_KEY_ID_SIZE , pubkey ) ) { RNP_LOG ( "key<S2SV_blank>id<S2SV_blank>calculation<S2SV_blank>failed" ) ; return RNP_ERROR_BAD_PARAMETERS ; } enckey [ 0 ] = param -> ctx -> ealg ; memcpy ( & enckey [ 1 ] , key , keylen ) ; for ( unsigned i = 1 ; i <= keylen ; i ++ ) { checksum += enckey [ i ] ; } enckey [ keylen + 1 ] = ( checksum >> 8 ) & 0xff ; enckey [ keylen + 2 ] = checksum & 0xff ; switch ( pubkey -> alg ) { case PGP_PKA_RSA : case PGP_PKA_RSA_ENCRYPT_ONLY : pkey . params . rsa . mlen = pgp_rsa_encrypt_pkcs1 ( rnp_ctx_rng_handle ( handler -> ctx ) , pkey . params . rsa . m , sizeof ( pkey . params . rsa . m ) , enckey , keylen + 3 , & pubkey -> key . rsa ) ; if ( pkey . params . rsa . mlen <= 0 ) { RNP_LOG ( "pgp_rsa_encrypt_pkcs1<S2SV_blank>failed" ) ; ret = RNP_ERROR_GENERIC ; goto finish ; } break ; case PGP_PKA_SM2 : { size_t outlen = sizeof ( pkey . params . sm2 . m ) ; ret = pgp_sm2_encrypt ( rnp_ctx_rng_handle ( handler -> ctx ) , pkey . params . sm2 . m , & outlen , enckey , keylen + 3 , PGP_HASH_SM3 , & pubkey -> key . ecc ) ; if ( ret != RNP_SUCCESS ) { RNP_LOG ( "pgp_sm2_encrypt<S2SV_blank>failed" ) ; goto finish ; } pkey . params . sm2 . mlen = outlen ; } break ; case PGP_PKA_ECDH : { pgp_fingerprint_t fingerprint ; size_t outlen = sizeof ( pkey . params . ecdh . m ) ; bignum_t * p ; if ( ! pgp_fingerprint ( & fingerprint , pubkey ) ) { RNP_LOG ( "ECDH<S2SV_blank>fingerprint<S2SV_blank>calculation<S2SV_blank>failed" ) ; ret = RNP_ERROR_GENERIC ; goto finish ; } if ( ! ( p = bn_new ( ) ) ) { RNP_LOG ( "allocation<S2SV_blank>failed" ) ; ret = RNP_ERROR_OUT_OF_MEMORY ; goto finish ; } ret = pgp_ecdh_encrypt_pkcs5 ( rnp_ctx_rng_handle ( handler -> ctx ) , enckey , keylen + 3 , pkey . params . ecdh . m , & outlen , p , & pubkey -> key . ecdh , & fingerprint ) ; if ( ret != RNP_SUCCESS ) { RNP_LOG ( "ECDH<S2SV_blank>encryption<S2SV_blank>failed<S2SV_blank>%d" , ret ) ; bn_free ( p ) ; goto finish ; } pkey . params . ecdh . mlen = outlen ; ( void ) bn_num_bytes ( p , ( size_t * ) & pkey . params . ecdh . plen ) ; ( void ) bn_bn2bin ( p , pkey . params . ecdh . p ) ; bn_free ( p ) ; } break ; case PGP_PKA_ELGAMAL : <S2SV_StartBug> case PGP_PKA_ELGAMAL_ENCRYPT_OR_SIGN : { <S2SV_EndBug> int outlen ; outlen = pgp_elgamal_public_encrypt_pkcs1 ( rnp_ctx_rng_handle ( handler -> ctx ) , pkey . params . eg . g , pkey . params . eg . m , enckey , keylen + 3 , & pubkey -> key . elgamal ) ; if ( outlen <= 0 ) { ret = RNP_ERROR_GENERIC ; RNP_LOG ( "pgp_elgamal_public_encrypt<S2SV_blank>failed" ) ; goto finish ; } pkey . params . eg . glen = outlen / 2 ; pkey . params . eg . mlen = outlen / 2 ; } break ; default : RNP_LOG ( "unsupported<S2SV_blank>alg:<S2SV_blank>%d" , pubkey -> alg ) ; goto finish ; } if ( ! stream_write_pk_sesskey ( & pkey , param -> pkt . origdst ) ) { ret = RNP_ERROR_WRITE ; goto finish ; } ret = RNP_SUCCESS ; finish : pgp_forget ( enckey , sizeof ( enckey ) ) ; pgp_forget ( & checksum , sizeof ( checksum ) ) ; return ret ; }
<S2SV_ModStart> case PGP_PKA_ELGAMAL : <S2SV_ModEnd> { int outlen
7,723
CWE-000 static struct boost_policy * alloc_boost_policy ( void ) { struct boost_policy * b ; b = kzalloc ( sizeof ( * b ) , GFP_KERNEL ) ; if ( ! b ) return NULL ; <S2SV_StartBug> b -> ib . boost_info = alloc_percpu ( typeof ( * b -> ib . boost_info ) ) ; <S2SV_EndBug> if ( ! b -> ib . boost_info ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>percpu<S2SV_blank>definition\\n" ) ; <S2SV_StartBug> goto free_b ; <S2SV_EndBug> } <S2SV_StartBug> return b ; <S2SV_EndBug> free_b : kfree ( b ) ; return NULL ; }
<S2SV_ModStart> ; b -> wq = alloc_workqueue ( "cpu_ib_wq" , WQ_HIGHPRI , 0 ) ; if ( ! b -> wq ) { pr_err ( "Failed<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>workqueue\\n" ) ; goto free_b ; } b -> <S2SV_ModStart> ) ; goto destroy_wq <S2SV_ModEnd> ; } return <S2SV_ModStart> } return b ; destroy_wq : destroy_workqueue ( b -> wq )
7,724
CWE-000 t_vec4 ft_vec4_by_mat4 ( t_vec4 * v , t_mat4 * m ) { t_vec4 victor ; victor . x = ft_vec4_scalprod ( v , & m -> x ) ; victor . y = ft_vec4_scalprod ( v , & m -> y ) ; <S2SV_StartBug> victor . z = ft_vec4_scalprod ( v , & m -> z ) ; ; <S2SV_EndBug> <S2SV_StartBug> victor . w = ft_vec4_scalprod ( v , & m -> w ) ; ; <S2SV_EndBug> return ( victor ) ; }
<S2SV_ModStart> z ) ; <S2SV_ModEnd> victor . w <S2SV_ModStart> w ) ; <S2SV_ModEnd> return ( victor
7,725
CWE-000 gboolean ev_annotation_set_color ( EvAnnotation * annot , const GdkColor * color ) { GdkColor annot_color ; GdkRGBA rgba ; g_return_val_if_fail ( EV_IS_ANNOTATION ( annot ) , FALSE ) ; ev_annotation_get_color ( annot , & annot_color ) ; if ( color == NULL || gdk_color_equal ( color , & annot_color ) ) return FALSE ; rgba . red = color -> red / 65535. ; rgba . green = color -> green / 65535. ; rgba . blue = color -> blue / 65535. ; rgba . alpha = 1. ; ev_annotation_set_rgba ( annot , & rgba ) ; <S2SV_StartBug> g_object_notify ( G_OBJECT ( annot ) , "color" ) ; <S2SV_EndBug> return TRUE ; }
<S2SV_ModStart> rgba ) ; <S2SV_ModEnd> return TRUE ;
7,726
CWE-000 void mptcp_cleanup_rbuf ( struct sock * meta_sk , int copied ) { struct tcp_sock * meta_tp = tcp_sk ( meta_sk ) ; struct sock * sk ; <S2SV_StartBug> __u32 rcv_window_now = 0 ; <S2SV_EndBug> if ( copied > 0 && ! ( meta_sk -> sk_shutdown & RCV_SHUTDOWN ) ) { rcv_window_now = tcp_receive_window ( meta_tp ) ; <S2SV_StartBug> if ( 2 * rcv_window_now > meta_tp -> window_clamp ) <S2SV_EndBug> <S2SV_StartBug> rcv_window_now = 0 ; <S2SV_EndBug> } mptcp_for_each_sk ( meta_tp -> mpcb , sk ) { struct tcp_sock * tp = tcp_sk ( sk ) ; const struct inet_connection_sock * icsk = inet_csk ( sk ) ; if ( ! mptcp_sk_can_send_ack ( sk ) ) continue ; if ( ! inet_csk_ack_scheduled ( sk ) ) goto second_part ; if ( icsk -> icsk_ack . blocked || tp -> rcv_nxt - tp -> rcv_wup > icsk -> icsk_ack . rcv_mss || ( copied > 0 && ( ( icsk -> icsk_ack . pending & ICSK_ACK_PUSHED2 ) || ( ( icsk -> icsk_ack . pending & ICSK_ACK_PUSHED ) && ! icsk -> icsk_ack . pingpong ) ) && ! atomic_read ( & meta_sk -> sk_rmem_alloc ) ) ) { tcp_send_ack ( sk ) ; continue ; } second_part : <S2SV_StartBug> if ( rcv_window_now ) { <S2SV_EndBug> __u32 new_window = tp -> ops -> __select_window ( sk ) ; if ( new_window && new_window >= 2 * rcv_window_now ) tcp_send_ack ( sk ) ; } } }
<S2SV_ModStart> * sk ; bool recheck_rcv_window = false ; <S2SV_ModStart> 2 * rcv_window_now <= <S2SV_ModEnd> meta_tp -> window_clamp <S2SV_ModStart> -> window_clamp ) recheck_rcv_window = true <S2SV_ModEnd> ; } mptcp_for_each_sk <S2SV_ModStart> : if ( recheck_rcv_window <S2SV_ModEnd> ) { __u32
7,727
CWE-000 <S2SV_StartBug> void monitor_trap_pd ( vmi_instance_t vmi , addr_t pd , GHashTable * table , vmi_pid_t pid ) { <S2SV_EndBug> unsigned index ; addr_t entry_addr ; uint64_t entry_val ; addr_t next_addr ; <S2SV_StartBug> monitor_set_trap ( vmi , pd , VMI_MEMACCESS_W , pid , table , PAGE_CAT_PD ) ; <S2SV_EndBug> for ( index = 0 ; index < PAGING_INTEL_64_MAX_ENTRIES ; index ++ ) { entry_addr = pd + PAGING_INTEL_64_GET_ENTRY_OFFSET ( index ) ; vmi_read_64_pa ( vmi , entry_addr , & entry_val ) ; if ( ! PAGING_INTEL_64_IS_PRESENT ( entry_val ) ) continue ; if ( PAGING_INTEL_64_IS_FRAME_PTR ( entry_val ) && PAGING_INTEL_64_IS_WRITABLE ( entry_val ) && PAGING_INTEL_64_IS_USERMODE ( entry_val ) ) { next_addr = PAGING_INTEL_64_GET_2MB_FRAME_PADDR ( entry_val ) ; if ( next_addr <= max_paddr ) <S2SV_StartBug> monitor_set_trap ( vmi , next_addr , VMI_MEMACCESS_X , pid , table , PAGE_CAT_2MB_FRAME ) ; <S2SV_EndBug> continue ; } if ( ! PAGING_INTEL_64_IS_FRAME_PTR ( entry_val ) ) { next_addr = PAGING_INTEL_64_GET_PT_PADDR ( entry_val ) ; if ( next_addr <= max_paddr ) <S2SV_StartBug> monitor_trap_pt ( vmi , next_addr , table , pid ) ; <S2SV_EndBug> continue ; } } }
<S2SV_ModStart> , addr_t pd <S2SV_ModEnd> , vmi_pid_t pid <S2SV_ModStart> VMI_MEMACCESS_W , pid <S2SV_ModEnd> , PAGE_CAT_PD ) <S2SV_ModStart> , pid , <S2SV_ModEnd> PAGE_CAT_2MB_FRAME ) ; <S2SV_ModStart> , next_addr , <S2SV_ModEnd> pid ) ;
7,728
CWE-000 int output_variable_value_ ( VariableVA * variable ) { if ( variable -> value == NULL ) return 0 ; switch ( variable -> type ) { case NarrativeVariable : output_narrative_variable ( ( Registry * ) variable -> value ) ; break ; case EntityVariable : output_entity_variable ( ( listItem * ) variable -> value , NULL ) ; break ; case ExpressionVariable : <S2SV_StartBug> output_expression ( ExpressionAll , ( ( listItem * ) variable -> value ) -> ptr , - 1 , - 1 ) ; <S2SV_EndBug> break ; case LiteralVariable : output_literal_variable ( ( listItem * ) variable -> value , NULL ) ; break ; case StringVariable : output_string_variable ( ( listItem * ) variable -> value ) ; break ; } return 1 ; }
<S2SV_ModStart> ) -> ptr <S2SV_ModEnd> ) ; break
7,729
CWE-000 void test_AvrOperatorTable_given_brbc_5_61 ( void ) { <S2SV_StartBug> uint32_t k ; <S2SV_EndBug> uint8_t codeMemory [ ] = { 0xed , 0xf5 , } ; uint8_t * progCounter = codeMemory ; flash = codeMemory ; sreg -> H = 0 ; <S2SV_StartBug> k = simulateOneInstruction ( progCounter ) ; <S2SV_EndBug> <S2SV_StartBug> TEST_ASSERT_EQUAL_INT32 ( 124 , k ) ; <S2SV_EndBug> }
<S2SV_ModStart> void ) { uint8_t pc <S2SV_ModEnd> ; uint8_t codeMemory <S2SV_ModStart> = 0 ; pc <S2SV_ModEnd> = simulateOneInstruction ( <S2SV_ModStart> ( 124 , pc <S2SV_ModEnd> ) ; }
7,730
CWE-000 static int ptrace_traceme ( void ) { int ret = - EPERM ; write_lock_irq ( & tasklist_lock ) ; if ( ! current -> ptrace ) { ret = security_ptrace_traceme ( current -> parent ) ; if ( ! ret && ! ( current -> real_parent -> flags & PF_EXITING ) ) { current -> ptrace = PT_PTRACED ; <S2SV_StartBug> __ptrace_link ( current , current -> real_parent ) ; <S2SV_EndBug> } } write_unlock_irq ( & tasklist_lock ) ; return ret ; }
<S2SV_ModStart> = PT_PTRACED ; ptrace_link <S2SV_ModEnd> ( current ,
7,731
CWE-000 PRIVATE void ParseExpression ( void ) { <S2SV_StartBug> printf ( "here<S2SV_blank>0!\\n" ) ; <S2SV_EndBug> ParseCompoundTerm ( ) ; <S2SV_StartBug> printf ( "here<S2SV_blank>1!\\n" ) ; <S2SV_EndBug> while ( ( CurrentToken . code == ADD ) || ( CurrentToken . code == SUBTRACT ) ) { printf ( "here<S2SV_blank>2!\\n" ) ; Accept ( CurrentToken . code ) ; ParseCompoundTerm ( ) ; } }
<S2SV_ModStart> { printf ( "here<S2SV_blank>ParseCompound<S2SV_blank>term<S2SV_blank><S2SV_blank>start!\\n" <S2SV_ModEnd> ) ; ParseCompoundTerm <S2SV_ModStart> ; printf ( "here<S2SV_blank>ParseCompoundTermEnd!\\n" <S2SV_ModEnd> ) ; while
7,732
CWE-000 int main ( int argc , char * argv [ ] ) { Bool detach = False ; int replace = 0 ; char * pstr ; ARGBEGIN { case 'c' : closelastclient = True ; fillagain = False ; break ; case 'd' : detach = True ; break ; case 'f' : fillagain = True ; break ; case 'g' : geometry = EARGF ( usage ( ) ) ; break ; case 'n' : wmname = EARGF ( usage ( ) ) ; break ; case 'O' : normfgcolor = EARGF ( usage ( ) ) ; break ; case 'o' : normbgcolor = EARGF ( usage ( ) ) ; break ; case 'p' : pstr = EARGF ( usage ( ) ) ; if ( pstr [ 0 ] == 's' ) { npisrelative = True ; newposition = atoi ( & pstr [ 1 ] ) ; } else { newposition = atoi ( pstr ) ; } break ; case 'r' : replace = atoi ( EARGF ( usage ( ) ) ) ; break ; case 's' : doinitspawn = False ; break ; case 'T' : selfgcolor = EARGF ( usage ( ) ) ; break ; case 't' : selbgcolor = EARGF ( usage ( ) ) ; break ; case 'U' : urgfgcolor = EARGF ( usage ( ) ) ; break ; case 'u' : urgbgcolor = EARGF ( usage ( ) ) ; break ; case 'v' : <S2SV_StartBug> die ( "tabbed-" VERSION ",<S2SV_blank>©<S2SV_blank>2009-2016" <S2SV_EndBug> "<S2SV_blank>tabbed<S2SV_blank>engineers,<S2SV_blank>see<S2SV_blank>LICENSE" "<S2SV_blank>for<S2SV_blank>details.\\n" ) ; break ; default : case 'h' : usage ( ) ; } ARGEND ; if ( argc < 1 ) { doinitspawn = False ; fillagain = False ; } setcmd ( argc , argv , replace ) ; if ( ! setlocale ( LC_CTYPE , "" ) || ! XSupportsLocale ( ) ) fprintf ( stderr , "%s:<S2SV_blank>no<S2SV_blank>locale<S2SV_blank>support\\n" , argv0 ) ; if ( ! ( dpy = XOpenDisplay ( NULL ) ) ) die ( "%s:<S2SV_blank>cannot<S2SV_blank>open<S2SV_blank>display\\n" , argv0 ) ; setup ( ) ; printf ( "0x%lx\\n" , win ) ; fflush ( NULL ) ; if ( detach ) { if ( fork ( ) == 0 ) { fclose ( stdout ) ; } else { if ( dpy ) close ( ConnectionNumber ( dpy ) ) ; return EXIT_SUCCESS ; } } run ( ) ; cleanup ( ) ; XCloseDisplay ( dpy ) ; return EXIT_SUCCESS ; }
<S2SV_ModStart> ( "tabbed-" VERSION ",<S2SV_blank>©<S2SV_blank>2009-2016<S2SV_blank>tabbed<S2SV_blank>engineers,<S2SV_blank>" "see<S2SV_blank>LICENSE<S2SV_blank>for<S2SV_blank>details.\\n" <S2SV_ModEnd> ) ; break
7,733
CWE-000 int env_init ( void ) { struct env_driver * drv = env_driver_lookup_default ( ) ; int ret = - ENOENT ; if ( ! drv ) return - ENODEV ; if ( drv -> init ) ret = drv -> init ( ) ; if ( ret == - ENOENT ) { gd -> env_addr = ( ulong ) & default_environment [ 0 ] ; <S2SV_StartBug> gd -> env_valid = 0 ; <S2SV_EndBug> return 0 ; } else if ( ret ) { debug ( "%s:<S2SV_blank>Environment<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>(err=%d)\\n" , __func__ , ret ) ; return ret ; } return 0 ; }
<S2SV_ModStart> -> env_valid = ENV_VALID <S2SV_ModEnd> ; return 0
7,734
CWE-000 int __ieee80211_suspend ( struct ieee80211_hw * hw , struct cfg80211_wowlan * wowlan ) { struct ieee80211_local * local = hw_to_local ( hw ) ; struct ieee80211_sub_if_data * sdata ; struct sta_info * sta ; if ( ! local -> open_count ) goto suspend ; ieee80211_scan_cancel ( local ) ; ieee80211_dfs_cac_cancel ( local ) ; ieee80211_roc_purge ( local , NULL ) ; ieee80211_del_virtual_monitor ( local ) ; if ( ieee80211_hw_check ( hw , AMPDU_AGGREGATION ) && ! ( wowlan && wowlan -> any ) ) { mutex_lock ( & local -> sta_mtx ) ; list_for_each_entry ( sta , & local -> sta_list , list ) { set_sta_flag ( sta , WLAN_STA_BLOCK_BA ) ; ieee80211_sta_tear_down_BA_sessions ( sta , AGG_STOP_LOCAL_REQUEST ) ; } mutex_unlock ( & local -> sta_mtx ) ; } if ( ! ( wowlan && wowlan -> any ) ) ieee80211_sched_scan_cancel ( local ) ; ieee80211_stop_queues_by_reason ( hw , IEEE80211_MAX_QUEUE_MAP , IEEE80211_QUEUE_STOP_REASON_SUSPEND , false ) ; synchronize_net ( ) ; ieee80211_flush_queues ( local , NULL , true ) ; local -> quiescing = true ; mb ( ) ; flush_workqueue ( local -> workqueue ) ; del_timer_sync ( & local -> sta_cleanup ) ; cancel_work_sync ( & local -> dynamic_ps_enable_work ) ; del_timer_sync ( & local -> dynamic_ps_timer ) ; local -> wowlan = wowlan ; if ( local -> wowlan ) { int err ; list_for_each_entry ( sdata , & local -> interfaces , list ) { if ( ! ieee80211_sdata_running ( sdata ) ) continue ; if ( sdata -> vif . type != NL80211_IFTYPE_STATION ) continue ; ieee80211_mgd_quiesce ( sdata ) ; if ( sdata -> u . mgd . associated && sdata -> u . mgd . powersave && ! ( local -> hw . conf . flags & IEEE80211_CONF_PS ) ) { local -> hw . conf . flags |= IEEE80211_CONF_PS ; ieee80211_hw_config ( local , IEEE80211_CONF_CHANGE_PS ) ; } } err = drv_suspend ( local , wowlan ) ; if ( err < 0 ) { local -> quiescing = false ; local -> wowlan = false ; if ( ieee80211_hw_check ( hw , AMPDU_AGGREGATION ) ) { mutex_lock ( & local -> sta_mtx ) ; list_for_each_entry ( sta , & local -> sta_list , list ) { clear_sta_flag ( sta , WLAN_STA_BLOCK_BA ) ; } mutex_unlock ( & local -> sta_mtx ) ; } ieee80211_wake_queues_by_reason ( hw , IEEE80211_MAX_QUEUE_MAP , IEEE80211_QUEUE_STOP_REASON_SUSPEND , false ) ; return err ; } else if ( err > 0 ) { WARN_ON ( err != 1 ) ; ieee80211_wake_queues_by_reason ( hw , IEEE80211_MAX_QUEUE_MAP , IEEE80211_QUEUE_STOP_REASON_SUSPEND , false ) ; return err ; } else { goto suspend ; } } list_for_each_entry ( sdata , & local -> interfaces , list ) { if ( ! ieee80211_sdata_running ( sdata ) ) continue ; switch ( sdata -> vif . type ) { case NL80211_IFTYPE_AP_VLAN : case NL80211_IFTYPE_MONITOR : continue ; case NL80211_IFTYPE_STATION : ieee80211_mgd_quiesce ( sdata ) ; break ; case NL80211_IFTYPE_WDS : mutex_lock ( & local -> sta_mtx ) ; sta = sdata -> u . wds . sta ; if ( sta && sta -> uploaded ) { enum ieee80211_sta_state state ; state = sta -> sta_state ; for ( ; state > IEEE80211_STA_NOTEXIST ; state -- ) WARN_ON ( drv_sta_state ( local , sta -> sdata , sta , state , state - 1 ) ) ; } mutex_unlock ( & local -> sta_mtx ) ; break ; default : break ; } <S2SV_StartBug> drv_remove_interface ( local , sdata ) ; <S2SV_EndBug> } WARN_ON ( ! list_empty ( & local -> chanctx_list ) ) ; if ( local -> open_count ) ieee80211_stop_device ( local ) ; suspend : local -> suspended = true ; barrier ( ) ; local -> quiescing = false ; return 0 ; }
<S2SV_ModStart> break ; } flush_delayed_work ( & sdata -> dec_tailroom_needed_wk ) ;
7,735
CWE-000 static int process_aes_ccm_param ( odp_crypto_generic_session_t * session , const EVP_CIPHER * cipher ) { if ( ( uint32_t ) EVP_CIPHER_key_length ( cipher ) != <S2SV_StartBug> session -> p . cipher_key . length ) <S2SV_EndBug> return - 1 ; memcpy ( session -> cipher . key_data , session -> p . cipher_key . data , session -> p . cipher_key . length ) ; session -> cipher . evp_cipher = cipher ; if ( ODP_CRYPTO_OP_ENCODE == session -> p . op ) { session -> cipher . func = aes_ccm_encrypt ; session -> cipher . init = aes_ccm_encrypt_init ; } else { session -> cipher . func = aes_ccm_decrypt ; session -> cipher . init = aes_ccm_decrypt_init ; } return 0 ; }
<S2SV_ModStart> p . cipher_key . length ) return - 1 ; if ( 11 != session -> p . cipher_iv . length && 13 != session -> p . cipher_iv
7,736
CWE-000 bool ce_layout_split ( CeLayout_t * layout , bool vertical ) { <S2SV_StartBug> assert ( layout -> type = CE_LAYOUT_TYPE_TAB ) ; <S2SV_EndBug> CeLayout_t * parent_of_current = ce_layout_find_parent ( layout , layout -> tab . current ) ; if ( parent_of_current ) { CeBuffer_t * buffer = ce_layout_find_buffer ( layout -> tab . current ) ; assert ( buffer ) ; switch ( parent_of_current -> type ) { default : break ; case CE_LAYOUT_TYPE_LIST : if ( parent_of_current -> list . vertical == vertical ) { CeLayout_t * new_layout = ce_layout_view_init ( buffer ) ; if ( ! new_layout ) return false ; int64_t new_layout_count = parent_of_current -> list . layout_count + 1 ; parent_of_current -> list . layouts = realloc ( parent_of_current -> list . layouts , new_layout_count * sizeof ( * parent_of_current -> list . layouts ) ) ; if ( parent_of_current -> list . layouts ) parent_of_current -> list . layout_count = new_layout_count ; else return false ; parent_of_current -> list . layouts [ new_layout_count - 1 ] = new_layout ; } else { CeLayout_t * new_list_layout = calloc ( 1 , sizeof ( * new_list_layout ) ) ; if ( ! new_list_layout ) return false ; new_list_layout -> type = CE_LAYOUT_TYPE_LIST ; new_list_layout -> list . layouts = malloc ( sizeof ( * new_list_layout -> list . layouts ) ) ; if ( ! new_list_layout -> list . layouts ) return false ; new_list_layout -> list . layout_count = 1 ; new_list_layout -> list . vertical = vertical ; new_list_layout -> list . layouts [ 0 ] = layout -> tab . current ; for ( int64_t i = 0 ; i < parent_of_current -> list . layout_count ; i ++ ) { if ( parent_of_current -> list . layouts [ i ] == layout -> tab . current ) { parent_of_current -> list . layouts [ i ] = new_list_layout ; break ; } } return ce_layout_split ( layout , vertical ) ; } break ; case CE_LAYOUT_TYPE_TAB : { CeLayout_t * list_layout = calloc ( 1 , sizeof ( * list_layout ) ) ; list_layout -> type = CE_LAYOUT_TYPE_LIST ; list_layout -> list . layout_count = 1 ; list_layout -> list . layouts = calloc ( list_layout -> list . layout_count , sizeof ( * list_layout -> list . layouts ) ) ; list_layout -> list . layouts [ 0 ] = layout -> tab . current ; list_layout -> list . vertical = vertical ; parent_of_current -> tab . root = list_layout ; return ce_layout_split ( layout , vertical ) ; } break ; case CE_LAYOUT_TYPE_TAB_LIST : if ( layout -> tab_list . current ) return ce_layout_split ( layout -> tab_list . current , vertical ) ; break ; } return true ; } return false ; }
<S2SV_ModStart> layout -> type == <S2SV_ModEnd> CE_LAYOUT_TYPE_TAB ) ;
7,737
CWE-000 void stop_file_management ( struct file_management_info * finfo ) { finfo -> is_managed = 0 ; if ( finfo -> management_thread ) { pthread_join ( * ( finfo -> management_thread ) , NULL ) ; } <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> ) ; } if ( finfo -> scrubbing_thread ) { pthread_join ( * ( finfo -> scrubbing_thread ) , NULL ) ; }
7,738
CWE-000 extern List as_mysql_get_assocs ( mysql_conn_t * mysql_conn , uid_t uid , slurmdb_assoc_cond_t * assoc_cond ) { char * extra = NULL ; char * tmp = NULL ; List assoc_list = NULL ; ListIterator itr = NULL ; int i = 0 , is_admin = 1 ; uint16_t private_data = 0 ; slurmdb_user_rec_t user ; char * prefix = "t1" ; List use_cluster_list = as_mysql_cluster_list ; char * cluster_name = NULL ; if ( ! assoc_cond ) { xstrcat ( extra , "<S2SV_blank>where<S2SV_blank>deleted=0" ) ; goto empty ; } if ( check_connection ( mysql_conn ) != SLURM_SUCCESS ) return NULL ; memset ( & user , 0 , sizeof ( slurmdb_user_rec_t ) ) ; user . uid = uid ; private_data = slurm_get_private_data ( ) ; if ( private_data & PRIVATE_DATA_USERS ) { if ( ! ( is_admin = is_user_min_admin_level ( mysql_conn , uid , SLURMDB_ADMIN_OPERATOR ) ) ) { assoc_mgr_fill_in_user ( <S2SV_StartBug> mysql_conn , & user , 1 , NULL ) ; <S2SV_EndBug> } if ( ! is_admin && ! user . name ) { debug ( "User<S2SV_blank>%u<S2SV_blank>has<S2SV_blank>no<S2SV_blank>associations,<S2SV_blank>and<S2SV_blank>is<S2SV_blank>not<S2SV_blank>admin,<S2SV_blank>" "so<S2SV_blank>not<S2SV_blank>returning<S2SV_blank>any." , user . uid ) ; return NULL ; } } if ( ( assoc_cond -> qos_list && list_count ( assoc_cond -> qos_list ) ) || assoc_cond -> with_sub_accts ) prefix = "t2" ; ( void ) _setup_assoc_cond_limits ( assoc_cond , prefix , & extra ) ; if ( assoc_cond -> cluster_list && list_count ( assoc_cond -> cluster_list ) ) use_cluster_list = assoc_cond -> cluster_list ; empty : xfree ( tmp ) ; xstrfmtcat ( tmp , "t1.%s" , assoc_req_inx [ i ] ) ; for ( i = 1 ; i < ASSOC_REQ_COUNT ; i ++ ) { xstrfmtcat ( tmp , ",<S2SV_blank>t1.%s" , assoc_req_inx [ i ] ) ; } assoc_list = list_create ( slurmdb_destroy_assoc_rec ) ; if ( use_cluster_list == as_mysql_cluster_list ) slurm_mutex_lock ( & as_mysql_cluster_list_lock ) ; itr = list_iterator_create ( use_cluster_list ) ; while ( ( cluster_name = list_next ( itr ) ) ) { int rc ; if ( ( rc = _cluster_get_assocs ( mysql_conn , & user , assoc_cond , cluster_name , tmp , extra , is_admin , assoc_list ) ) != SLURM_SUCCESS ) { FREE_NULL_LIST ( assoc_list ) ; assoc_list = NULL ; break ; } } list_iterator_destroy ( itr ) ; if ( use_cluster_list == as_mysql_cluster_list ) slurm_mutex_unlock ( & as_mysql_cluster_list_lock ) ; xfree ( tmp ) ; xfree ( extra ) ; return assoc_list ; }
<S2SV_ModStart> 1 , NULL , false
7,739
CWE-000 mapper_signal mapper_database_add_or_update_signal ( mapper_database db , const char * name , const char * device_name , <S2SV_StartBug> mapper_message_t * props ) <S2SV_EndBug> { mapper_signal sig = 0 ; int sig_rc = 0 , dev_rc = 0 , updated = 0 ; mapper_device dev = mapper_database_device_by_name ( db , device_name ) ; if ( dev ) { sig = mapper_device_signal_by_name ( dev , name ) ; if ( sig && sig -> local ) return sig ; } else { dev = mapper_database_add_or_update_device ( db , device_name , 0 ) ; dev_rc = 1 ; } if ( ! sig ) { sig = ( mapper_signal ) mapper_list_add_item ( ( void * * ) & db -> signals , sizeof ( mapper_signal_t ) ) ; sig -> device = dev ; mapper_signal_init ( sig , 0 , 0 , name , 0 , 0 , 0 , 0 , 0 , 0 , 0 ) ; sig_rc = 1 ; } if ( sig ) { <S2SV_StartBug> updated = mapper_signal_set_from_message ( sig , props ) ; <S2SV_EndBug> if ( sig_rc ) { if ( sig -> direction == MAPPER_DIR_INCOMING ) ++ dev -> num_inputs ; else if ( sig -> direction == MAPPER_DIR_OUTGOING ) ++ dev -> num_outputs ; } if ( sig_rc || updated ) { fptr_list cb = db -> signal_callbacks , temp ; while ( cb ) { temp = cb -> next ; mapper_database_signal_handler * h = cb -> f ; h ( db , sig , sig_rc ? MAPPER_ADDED : MAPPER_MODIFIED , cb -> context ) ; cb = temp ; } } } return sig ; }
<S2SV_ModStart> * device_name , mapper_message msg <S2SV_ModEnd> ) { mapper_signal <S2SV_ModStart> ( sig , msg <S2SV_ModEnd> ) ; if
7,740
CWE-000 void slide_builder_slide_reply ( struct slide_builder_context * * context , char * reply , char * scene ) { struct dialog * dialog = make_dialog ( NULL , reply ) ; if ( ( * context ) -> root == ( * context ) -> current ) { ( * context ) -> root = ( * context ) -> current = slide_add_dialog ( ( * context ) -> current , dialog ) ; } else { ( * context ) -> current = slide_add_dialog ( ( * context ) -> current , dialog ) ; } size_t i = ( * context ) -> current -> dialogs_count - 1 ; * context = realloc ( * context , sizeof * * context + <S2SV_StartBug> ( i + 2 ) * sizeof * ( * context ) -> current_fills ) ; <S2SV_EndBug> ( * context ) -> current_fills [ i ] = scene ; <S2SV_StartBug> ( * context ) -> current_fills [ i + 1 ] = EOS ; <S2SV_EndBug> }
<S2SV_ModStart> context + ( ( * context ) -> fill_start + <S2SV_ModStart> context ) -> fills ) ; ( * context ) -> fills [ ( * context ) -> fill_start + <S2SV_ModEnd> i ] = <S2SV_ModStart> context ) -> fills [ ( * context ) -> fill_start + <S2SV_ModEnd> i + 1
7,741
CWE-000 static int bpf_offload_notification ( struct notifier_block * notifier , ulong event , void * ptr ) { struct net_device * netdev = netdev_notifier_info_to_dev ( ptr ) ; struct bpf_dev_offload * offload , * tmp ; ASSERT_RTNL ( ) ; switch ( event ) { case NETDEV_UNREGISTER : <S2SV_StartBug> list_for_each_entry_safe ( offload , tmp , & bpf_prog_offload_devs , <S2SV_EndBug> offloads ) { if ( offload -> netdev == netdev ) __bpf_prog_offload_destroy ( offload -> prog ) ; } break ; default : break ; } return NOTIFY_OK ; }
<S2SV_ModStart> case NETDEV_UNREGISTER : if ( netdev -> reg_state != NETREG_UNREGISTERING ) break ;
7,742
CWE-000 static void wait_if_pipe ( t_sh * shell , int * ret , int * fd , t_tree * node ) { if ( shell -> fd_pipe ) close ( shell -> fd_pipe ) ; if ( ( shell -> fd_pipe = fd [ 0 ] ) == fd [ 0 ] && shell -> right_side ) { <S2SV_StartBug> waitpid ( g_father , ret , 0 ) ; <S2SV_EndBug> close ( fd [ 0 ] ) ; <S2SV_StartBug> shell -> fd_pipe = - 1 ; <S2SV_EndBug> } else if ( node && node -> token && node -> TYPE != DCHEVB ) waitpid ( g_father , ret , WNOHANG ) ; else waitpid ( g_father , ret , 0 ) ; }
<S2SV_ModStart> right_side ) { <S2SV_ModEnd> close ( fd <S2SV_ModStart> = - 1 ; waitpid ( - 1 , ret , 0 ) ; usleep ( 3000 )
7,743
CWE-000 static void _parse_logging ( xmlDocPtr doc , xmlNodePtr node , ice_config_t * configuration ) { char * tmp ; do { if ( node == NULL ) break ; if ( xmlIsBlankNode ( node ) ) continue ; if ( xmlStrcmp ( node -> name , XMLSTR ( "accesslog" ) ) == 0 ) { if ( ! ( tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ) ) { ICECAST_LOG_WARN ( "<accesslog><S2SV_blank>setting<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>empty." ) ; continue ; } if ( configuration -> access_log ) xmlFree ( configuration -> access_log ) ; configuration -> access_log = tmp ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "errorlog" ) ) == 0 ) { if ( ! ( tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ) ) { ICECAST_LOG_WARN ( "<errorlog><S2SV_blank>setting<S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>empty." ) ; continue ; } if ( configuration -> error_log ) xmlFree ( configuration -> error_log ) ; configuration -> error_log = tmp ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "playlistlog" ) ) == 0 ) { if ( configuration -> playlist_log ) xmlFree ( configuration -> playlist_log ) ; configuration -> playlist_log = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "logsize" ) ) == 0 ) { <S2SV_StartBug> char * tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> configuration -> logsize = atoi ( tmp ) ; <S2SV_EndBug> if ( tmp ) xmlFree ( tmp ) ; <S2SV_StartBug> } else if ( xmlStrcmp ( node -> name , XMLSTR ( "loglevel" ) ) == 0 ) { <S2SV_EndBug> char * tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; configuration -> loglevel = util_str_to_loglevel ( tmp ) ; if ( tmp ) xmlFree ( tmp ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "logarchive" ) ) == 0 ) { <S2SV_StartBug> char * tmp = ( char * ) xmlNodeListGetString ( doc , node -> xmlChildrenNode , 1 ) ; <S2SV_EndBug> <S2SV_StartBug> configuration -> logarchive = atoi ( tmp ) ; <S2SV_EndBug> if ( tmp ) xmlFree ( tmp ) ; } } while ( ( node = node -> next ) ) ; }
<S2SV_ModStart> 0 ) { __read_int ( doc , node , & configuration -> logsize , "<logsize><S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>empty." ) ; } else if ( xmlStrcmp ( node -> name , XMLSTR ( "loglevel" ) ) == 0 ) { <S2SV_ModStart> ; configuration -> loglevel = util_str_to_loglevel <S2SV_ModEnd> ( tmp ) <S2SV_ModStart> , XMLSTR ( <S2SV_ModEnd> "logarchive" ) ) <S2SV_ModStart> 0 ) { __read_int ( doc , node , & <S2SV_ModEnd> configuration -> logarchive <S2SV_ModStart> configuration -> logarchive , "<logarchive><S2SV_blank>must<S2SV_blank>not<S2SV_blank>be<S2SV_blank>empty." <S2SV_ModEnd> ) ; }
7,744
CWE-000 void free_Stmt_Func_Ptr ( Func_Ptr * a ) { if ( a -> args ) free_Arg_List ( a -> args ) ; <S2SV_StartBug> if ( a -> value && ! a -> value -> is_member ) { <S2SV_EndBug> rem_ref ( a -> value -> m_type -> obj , a -> value -> m_type ) ; rem_ref ( a -> value -> obj , a -> value ) ; } free ( a ) ; }
<S2SV_ModStart> is_member ) { if ( ! a -> func ) free_Type_Decl ( a -> type ) ;
7,745
CWE-000 END_TEST <S2SV_StartBug> START_TEST ( test_ns_reserved_attributes_2 ) <S2SV_EndBug> { const char * text1 = <S2SV_StartBug> "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'" <S2SV_EndBug> "<S2SV_blank><S2SV_blank>xmlns:xml=\'http://example.org/\'<S2SV_blank>/>" ; const char * text2 = <S2SV_StartBug> "<foo:e<S2SV_blank>xmlns:foo=\'http://www.w3.org/XML/1998/namespace\'<S2SV_blank>/>" ; <S2SV_EndBug> const char * text3 = "<foo:e<S2SV_blank>xmlns:foo=\'http://www.w3.org/2000/xmlns/\'<S2SV_blank>/>" ; <S2SV_StartBug> expect_failure ( text1 , XML_ERROR_RESERVED_PREFIX_XML , <S2SV_EndBug> "xml<S2SV_blank>not<S2SV_blank>rejected<S2SV_blank>as<S2SV_blank>an<S2SV_blank>attribute" ) ; XML_ParserReset ( parser , NULL ) ; <S2SV_StartBug> expect_failure ( text2 , XML_ERROR_RESERVED_NAMESPACE_URI , <S2SV_EndBug> "Use<S2SV_blank>of<S2SV_blank>w3.org<S2SV_blank>URL<S2SV_blank>not<S2SV_blank>faulted" ) ; <S2SV_StartBug> XML_ParserReset ( parser , NULL ) ; <S2SV_EndBug> expect_failure ( text3 , XML_ERROR_RESERVED_NAMESPACE_URI , "Use<S2SV_blank>of<S2SV_blank>w3.org<S2SV_blank>xmlns<S2SV_blank>URL<S2SV_blank>not<S2SV_blank>faulted" ) ; }
<S2SV_ModStart> END_TEST START_TEST ( test_ns_reserved_attributes <S2SV_ModEnd> ) { const <S2SV_ModStart> * text1 = "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'<S2SV_blank>xmlns:xmlns=\'12\'<S2SV_blank>/>" <S2SV_ModEnd> ; const char <S2SV_ModStart> * text2 = "<foo:e<S2SV_blank>xmlns:foo=\'http://example.org/\'<S2SV_blank>foo:xmlns=\'12\'<S2SV_blank>/>" <S2SV_ModEnd> ; expect_failure ( <S2SV_ModStart> ( text1 , XML_ERROR_RESERVED_PREFIX_XMLNS , "xmlns<S2SV_blank>not<S2SV_blank>rejected<S2SV_blank>as<S2SV_blank>an<S2SV_blank>attribute" <S2SV_ModEnd> ) ; XML_ParserReset <S2SV_ModStart> NULL ) ; if ( _XML_Parse_SINGLE_BYTES <S2SV_ModEnd> ( parser , <S2SV_ModStart> ( parser , text2 , strlen ( text2 ) , XML_TRUE ) == XML_STATUS_ERROR ) xml_failure ( parser <S2SV_ModEnd> ) ; }
7,746
CWE-000 int hostif_data_request ( struct ks_wlan_private * priv , struct sk_buff * skb ) { unsigned int skb_len = 0 ; unsigned char * buffer = NULL ; unsigned int length = 0 ; struct hostif_data_request_t * pp ; unsigned char * p ; int result = 0 ; unsigned short eth_proto ; struct ether_hdr * eth_hdr ; struct michael_mic_t michael_mic ; unsigned short keyinfo = 0 ; struct ieee802_1x_hdr * aa1x_hdr ; struct wpa_eapol_key * eap_key ; struct ethhdr * eth ; size_t size ; int ret ; skb_len = skb -> len ; if ( skb_len > ETH_FRAME_LEN ) { DPRINTK ( 1 , "bad<S2SV_blank>length<S2SV_blank>skb_len=%d\\n" , skb_len ) ; ret = - EOVERFLOW ; goto err_kfree_skb ; } if ( ( ( priv -> connect_status & CONNECT_STATUS_MASK ) == DISCONNECT_STATUS ) || ( priv -> connect_status & FORCE_DISCONNECT ) || priv -> wpa . mic_failure . stop ) { DPRINTK ( 3 , "<S2SV_blank>DISCONNECT\\n" ) ; if ( netif_queue_stopped ( priv -> net_dev ) ) netif_wake_queue ( priv -> net_dev ) ; if ( skb ) dev_kfree_skb ( skb ) ; return 0 ; } if ( atomic_read ( & priv -> psstatus . status ) == PS_SNOOZE ) { if ( ! netif_queue_stopped ( priv -> net_dev ) ) netif_stop_queue ( priv -> net_dev ) ; } <S2SV_StartBug> DPRINTK ( 4 , "skb_buff<S2SV_blank>length=%d\\n" , skb_len ) ; <S2SV_EndBug> <S2SV_StartBug> pp = kmalloc ( hif_align_size ( sizeof ( * pp ) + 6 + skb_len + 8 ) , <S2SV_EndBug> KS_WLAN_MEM_FLAG ) ; if ( ! pp ) { <S2SV_StartBug> DPRINTK ( 3 , "allocate<S2SV_blank>memory<S2SV_blank>failed..\\n" ) ; <S2SV_EndBug> ret = - ENOMEM ; goto err_kfree_skb ; } p = ( unsigned char * ) pp -> data ; buffer = skb -> data ; length = skb -> len ; eth = ( struct ethhdr * ) skb -> data ; if ( memcmp ( & priv -> eth_addr [ 0 ] , eth -> h_source , ETH_ALEN ) != 0 ) { DPRINTK ( 1 , "invalid<S2SV_blank>mac<S2SV_blank>address<S2SV_blank>!!\\n" ) ; DPRINTK ( 1 , "ethernet->h_source=%pM\\n" , eth -> h_source ) ; ret = - ENXIO ; goto err_kfree ; } size = ETH_ALEN * 2 ; memcpy ( p , buffer , size ) ; p += size ; buffer += size ; length -= size ; if ( * ( buffer + 1 ) + ( * buffer << 8 ) > 1500 ) { * p ++ = 0xAA ; * p ++ = 0xAA ; * p ++ = 0x03 ; * p ++ = 0x00 ; * p ++ = 0x00 ; * p ++ = 0x00 ; skb_len += 6 ; } else { DPRINTK ( 4 , "DIX\\n" ) ; buffer += 2 ; length -= 2 ; skb_len -= 2 ; } memcpy ( p , buffer , length ) ; p += length ; eth_hdr = ( struct ether_hdr * ) & pp -> data [ 0 ] ; eth_proto = ntohs ( eth_hdr -> h_proto ) ; if ( eth_proto == ETHER_PROTOCOL_TYPE_EAP && priv -> wpa . mic_failure . failure > 0 ) { aa1x_hdr = ( struct ieee802_1x_hdr * ) ( eth_hdr + 1 ) ; if ( aa1x_hdr -> type == IEEE802_1X_TYPE_EAPOL_KEY ) { eap_key = ( struct wpa_eapol_key * ) ( aa1x_hdr + 1 ) ; keyinfo = ntohs ( eap_key -> key_info ) ; } } if ( priv -> wpa . rsn_enabled && priv -> wpa . key [ 0 ] . key_len ) { if ( eth_proto == ETHER_PROTOCOL_TYPE_EAP && priv -> wpa . key [ 1 ] . key_len == 0 && priv -> wpa . key [ 2 ] . key_len == 0 && priv -> wpa . key [ 3 ] . key_len == 0 ) { pp -> auth_type = cpu_to_le16 ( ( uint16_t ) TYPE_AUTH ) ; } else { if ( priv -> wpa . pairwise_suite == IW_AUTH_CIPHER_TKIP ) { MichaelMICFunction ( & michael_mic , ( uint8_t * ) priv -> wpa . key [ 0 ] . tx_mic_key , ( uint8_t * ) & pp -> data [ 0 ] , ( int ) skb_len , ( uint8_t ) 0 , ( uint8_t * ) michael_mic . Result ) ; memcpy ( p , michael_mic . Result , 8 ) ; length += 8 ; skb_len += 8 ; p += 8 ; pp -> auth_type = cpu_to_le16 ( ( uint16_t ) TYPE_DATA ) ; } else if ( priv -> wpa . pairwise_suite == IW_AUTH_CIPHER_CCMP ) { pp -> auth_type = cpu_to_le16 ( ( uint16_t ) TYPE_DATA ) ; } } } else { if ( eth_proto == ETHER_PROTOCOL_TYPE_EAP ) pp -> auth_type = cpu_to_le16 ( ( uint16_t ) TYPE_AUTH ) ; else pp -> auth_type = cpu_to_le16 ( ( uint16_t ) TYPE_DATA ) ; } pp -> header . size = cpu_to_le16 ( ( uint16_t ) ( sizeof ( * pp ) - sizeof ( pp -> header . size ) + skb_len ) ) ; pp -> header . event = cpu_to_le16 ( ( uint16_t ) HIF_DATA_REQ ) ; result = ks_wlan_hw_tx ( priv , pp , hif_align_size ( sizeof ( * pp ) + skb_len ) , send_packet_complete , skb ) ; if ( eth_proto == ETHER_PROTOCOL_TYPE_EAP && priv -> wpa . mic_failure . failure > 0 ) { if ( keyinfo & WPA_KEY_INFO_ERROR && keyinfo & WPA_KEY_INFO_REQUEST ) { DPRINTK ( 3 , "<S2SV_blank>MIC<S2SV_blank>ERROR<S2SV_blank>Report<S2SV_blank>SET<S2SV_blank>:<S2SV_blank>%04X\\n" , keyinfo ) ; hostif_sme_enqueue ( priv , SME_MIC_FAILURE_REQUEST ) ; } if ( priv -> wpa . mic_failure . failure == 2 ) priv -> wpa . mic_failure . stop = 1 ; } return result ; err_kfree : kfree ( pp ) ; err_kfree_skb : dev_kfree_skb ( skb ) ; return ret ; }
<S2SV_ModStart> ) ; } size = <S2SV_ModEnd> sizeof ( * <S2SV_ModStart> skb_len + 8 ; pp = kmalloc ( hif_align_size ( size ) , <S2SV_ModEnd> KS_WLAN_MEM_FLAG ) ; <S2SV_ModStart> pp ) { <S2SV_ModEnd> ret = -
7,747
CWE-000 int FTI_Protect ( int id , void * ptr , long count , FTIT_type type ) { if ( FTI_Exec . initSCES == 0 ) { FTI_Print ( "FTI<S2SV_blank>is<S2SV_blank>not<S2SV_blank>initialized." , FTI_WARN ) ; return FTI_NSCS ; } char str [ FTI_BUFS ] ; int i ; for ( i = 0 ; i < FTI_BUFS ; i ++ ) { if ( id == FTI_Data [ i ] . id ) { long prevSize = FTI_Data [ i ] . size ; FTI_Data [ i ] . ptr = ptr ; FTI_Data [ i ] . count = count ; FTI_Data [ i ] . type = FTI_Exec . FTI_Type [ type . id ] ; FTI_Data [ i ] . eleSize = type . size ; FTI_Data [ i ] . size = type . size * count ; FTI_Data [ i ] . dimLength [ 0 ] = count ; FTI_Exec . ckptSize = FTI_Exec . ckptSize + ( ( type . size * count ) - prevSize ) ; sprintf ( str , "Variable<S2SV_blank>ID<S2SV_blank>%d<S2SV_blank>reseted.<S2SV_blank>Current<S2SV_blank>ckpt.<S2SV_blank>size<S2SV_blank>per<S2SV_blank>rank<S2SV_blank>is<S2SV_blank>%.2fMB." , id , ( float ) FTI_Exec . ckptSize / ( 1024.0 * 1024.0 ) ) ; FTI_Print ( str , FTI_DBUG ) ; return FTI_SCES ; } } if ( FTI_Exec . nbVar >= FTI_BUFS ) { FTI_Print ( "Unable<S2SV_blank>to<S2SV_blank>register<S2SV_blank>variable.<S2SV_blank>Too<S2SV_blank>many<S2SV_blank>variables<S2SV_blank>already<S2SV_blank>registered." , FTI_WARN ) ; return FTI_NSCS ; } FTI_Data [ FTI_Exec . nbVar ] . id = id ; FTI_Data [ FTI_Exec . nbVar ] . ptr = ptr ; FTI_Data [ FTI_Exec . nbVar ] . count = count ; FTI_Data [ FTI_Exec . nbVar ] . type = FTI_Exec . FTI_Type [ type . id ] ; FTI_Data [ FTI_Exec . nbVar ] . eleSize = type . size ; FTI_Data [ FTI_Exec . nbVar ] . size = type . size * count ; FTI_Data [ FTI_Exec . nbVar ] . rank = 1 ; FTI_Data [ FTI_Exec . nbVar ] . dimLength [ 0 ] = FTI_Data [ FTI_Exec . nbVar ] . count ; <S2SV_StartBug> FTI_Data [ FTI_Exec . nbVar ] . h5group = & FTI_Exec . H5RootGroup ; <S2SV_EndBug> sprintf ( FTI_Data [ FTI_Exec . nbVar ] . name , "Dataset_%d" , id ) ; FTI_Exec . nbVar = FTI_Exec . nbVar + 1 ; FTI_Exec . ckptSize = FTI_Exec . ckptSize + ( type . size * count ) ; sprintf ( str , "Variable<S2SV_blank>ID<S2SV_blank>%d<S2SV_blank>to<S2SV_blank>protect.<S2SV_blank>Current<S2SV_blank>ckpt.<S2SV_blank>size<S2SV_blank>per<S2SV_blank>rank<S2SV_blank>is<S2SV_blank>%.2fMB." , id , ( float ) FTI_Exec . ckptSize / ( 1024.0 * 1024.0 ) ) ; FTI_Print ( str , FTI_INFO ) ; return FTI_SCES ; }
<S2SV_ModStart> . h5group = FTI_Exec . H5groups [ 0 ] <S2SV_ModEnd> ; sprintf (
7,748
CWE-000 static void dhd_set_multicast_list ( struct net_device * dev ) { dhd_info_t * dhd = DHD_DEV_INFO ( dev ) ; int ifidx ; ifidx = dhd_net2idx ( dhd , dev ) ; if ( ifidx == DHD_BAD_IF ) return ; dhd -> iflist [ ifidx ] -> set_multicast = TRUE ; dhd_deferred_schedule_work ( dhd -> dhd_deferred_wq , ( void * ) dhd -> iflist [ ifidx ] , <S2SV_StartBug> DHD_WQ_WORK_SET_MCAST_LIST , dhd_set_mcast_list_handler , DHD_WORK_PRIORITY_LOW ) ; <S2SV_EndBug> }
<S2SV_ModStart> , dhd_set_mcast_list_handler , DHD_WQ_WORK_PRIORITY_LOW <S2SV_ModEnd> ) ; }
7,749
CWE-000 static void x_platformobject_update ( X_GameObject * obj , x_fp16x16 deltaTime ) { X_PlatformObject * platform = ( X_PlatformObject * ) obj ; X_Time time = x_enginecontext_get_time ( obj -> engineContext ) ; if ( platform -> state == X_PLATFORMOBJECT_DOWN || platform -> state == X_PLATFORMOBJECT_UP ) { if ( time >= platform -> nextTransition ) { platform -> state = ( platform -> state + 1 ) % 4 ; platform -> transitionStart = time ; } return ; } x_fp16x16 pos ; x_fp16x16 offset = x_fp16x16_from_int ( x_fp16x16_mul ( time - platform -> transitionStart , platform -> speed ) / 1000 ) ; if ( platform -> state == X_PLATFORMOBJECT_LOWERING ) <S2SV_StartBug> pos = platform -> raiseHeight - offset ; <S2SV_EndBug> <S2SV_StartBug> else <S2SV_EndBug> pos = offset ; if ( pos < 0 || pos >= platform -> raiseHeight ) { pos = x_fp16x16_clamp ( pos , 0 , platform -> raiseHeight ) ; platform -> state = ( platform -> state + 1 ) % 4 ; platform -> nextTransition = time + platform -> waitTime ; } <S2SV_StartBug> platform -> model -> origin . y = - pos ; <S2SV_EndBug> }
<S2SV_ModStart> ) pos = offset ; else pos = <S2SV_ModStart> - offset ; <S2SV_ModEnd> if ( pos <S2SV_ModStart> . y = <S2SV_ModEnd> pos ; }
7,750
CWE-000 void ts_show_pebble ( void ) { <S2SV_StartBug> listTitle = "Pebble" ; <S2SV_EndBug> window_stack_push ( wndTasks , true ) ; if ( ts_count < 0 ) <S2SV_StartBug> comm_query_tasks ( id ) ; <S2SV_EndBug> }
<S2SV_ModStart> listTitle = "Pebble" ; LOG ( "ts<S2SV_blank>show<S2SV_blank>called" ) <S2SV_ModStart> < 0 ) comm_query_list ( ) ; LOG ( "ts<S2SV_blank>show<S2SV_blank>returned" <S2SV_ModEnd> ) ; }
7,751
CWE-000 static irqreturn_t tsens_irq_thread ( int irq , void * data ) { struct tsens_tm_device * tm = data ; unsigned int i , status , threshold ; void __iomem * sensor_status_addr ; void __iomem * sensor_status_ctrl_addr ; int sensor_sw_id = - EINVAL , rc = 0 ; uint32_t idx = 0 ; if ( tmdev -> tsens_type == TSENS_TYPE2 ) sensor_status_addr = TSENS2_SN_STATUS_ADDR ( tmdev -> tsens_addr ) ; else sensor_status_addr = TSENS_S0_STATUS_ADDR ( tmdev -> tsens_addr ) ; sensor_status_ctrl_addr = TSENS_S0_UPPER_LOWER_STATUS_CTRL_ADDR ( tmdev -> tsens_addr ) ; for ( i = 0 ; i < tm -> tsens_num_sensor ; i ++ ) { bool upper_thr = false , lower_thr = false ; uint32_t addr_offset ; addr_offset = tm -> sensor [ i ] . sensor_hw_num * TSENS_SN_ADDR_OFFSET ; status = readl_relaxed ( sensor_status_addr + addr_offset ) ; threshold = readl_relaxed ( sensor_status_ctrl_addr + addr_offset ) ; if ( status & TSENS_SN_STATUS_UPPER_STATUS ) { writel_relaxed ( threshold | TSENS_UPPER_STATUS_CLR , TSENS_S0_UPPER_LOWER_STATUS_CTRL_ADDR ( tmdev -> tsens_addr + addr_offset ) ) ; upper_thr = true ; } if ( status & TSENS_SN_STATUS_LOWER_STATUS ) { writel_relaxed ( threshold | TSENS_LOWER_STATUS_CLR , TSENS_S0_UPPER_LOWER_STATUS_CTRL_ADDR ( tmdev -> tsens_addr + addr_offset ) ) ; lower_thr = true ; } if ( upper_thr || lower_thr ) { <S2SV_StartBug> unsigned long temp ; <S2SV_EndBug> enum thermal_trip_type trip = THERMAL_TRIP_CONFIGURABLE_LOW ; if ( upper_thr ) trip = THERMAL_TRIP_CONFIGURABLE_HI ; tsens_tz_get_temp ( tm -> sensor [ i ] . tz_dev , & temp ) ; thermal_sensor_trip ( tm -> sensor [ i ] . tz_dev , trip , temp ) ; rc = tsens_get_sw_id_mapping ( tm -> sensor [ i ] . sensor_hw_num , & sensor_sw_id ) ; if ( rc < 0 ) pr_err ( "tsens<S2SV_blank>mapping<S2SV_blank>index<S2SV_blank>not<S2SV_blank>found\\n" ) ; pr_debug ( "sensor:%d<S2SV_blank>trigger<S2SV_blank>temp<S2SV_blank>(%d<S2SV_blank>degC)\\n" , tm -> sensor [ i ] . sensor_hw_num , tsens_tz_code_to_degc ( ( status & TSENS_SN_STATUS_TEMP_MASK ) , sensor_sw_id ) ) ; if ( upper_thr ) trace_tsens_threshold_hit ( tsens_tz_code_to_degc ( ( threshold & TSENS_UPPER_THRESHOLD_MASK ) >> TSENS_UPPER_THRESHOLD_SHIFT , sensor_sw_id ) , tm -> sensor [ i ] . sensor_hw_num ) ; else trace_tsens_threshold_clear ( tsens_tz_code_to_degc ( ( threshold & TSENS_LOWER_THRESHOLD_MASK ) , sensor_sw_id ) , tm -> sensor [ i ] . sensor_hw_num ) ; } } idx = tmdev -> tsens_thread_iq_dbg . idx ; tmdev -> tsens_thread_iq_dbg . dbg_count [ idx % 10 ] ++ ; tmdev -> tsens_thread_iq_dbg . time_stmp [ idx % 10 ] = sched_clock ( ) ; tmdev -> tsens_thread_iq_dbg . idx ++ ; mb ( ) ; return IRQ_HANDLED ; }
<S2SV_ModStart> unsigned long temp = 0
7,752
CWE-000 void get_history ( ) { char command [ 513 ] ; <S2SV_StartBug> char * h = concat2 ( getenv ( "HOME" ) , "MyHistory" ) ; <S2SV_EndBug> FILE * history = fopen ( h , "r" ) ; if ( history == NULL ) printf ( "%s\\n" , "No<S2SV_blank>History" ) ; else { while ( fgets ( command , 513 , history ) ) printf ( "%s" , command ) ; fclose ( history ) ; } }
<S2SV_ModStart> = concat2 ( getcwd ( cwd , sizeof ( cwd ) <S2SV_ModEnd> ) , "MyHistory"
7,753
CWE-000 static void btnMinusDown ( void ) { int16_t idx ; int16_t up ; if ( btnLastState != UNDEF ) { up = ( ( int ) btnLastState & 1 ) ; idx = ( ( int ) btnLastState >> 1 ) ; if ( up ) { servo [ idx ] . minPos += SERVO_ADJUST ; if ( servo [ idx ] . minPos > servo [ idx ] . maxPos ) { servo [ idx ] . minPos = servo [ idx ] . maxPos ; } servo [ idx ] . targetPos = servo [ idx ] . minPos ; } else { servo [ idx ] . maxPos -= SERVO_ADJUST ; <S2SV_StartBug> if ( servo [ idx ] . maxPos > servo [ idx ] . minPos ) { <S2SV_EndBug> servo [ idx ] . maxPos = servo [ idx ] . minPos ; } servo [ idx ] . targetPos = servo [ idx ] . maxPos ; } } }
<S2SV_ModStart> ] . maxPos < <S2SV_ModEnd> servo [ idx
7,754
CWE-000 static void run_external_diff ( const char * pgm , const char * name , const char * other , struct diff_filespec * one , struct diff_filespec * two , const char * xfrm_msg , int complete_rewrite , struct diff_options * o ) { struct argv_array argv = ARGV_ARRAY_INIT ; struct argv_array env = ARGV_ARRAY_INIT ; struct diff_queue_struct * q = & diff_queued_diff ; argv_array_push ( & argv , pgm ) ; argv_array_push ( & argv , name ) ; if ( one && two ) { add_external_diff_name ( o -> repo , & argv , name , one ) ; if ( ! other ) add_external_diff_name ( o -> repo , & argv , name , two ) ; else { add_external_diff_name ( o -> repo , & argv , other , two ) ; argv_array_push ( & argv , other ) ; argv_array_push ( & argv , xfrm_msg ) ; } } argv_array_pushf ( & env , "GIT_DIFF_PATH_COUNTER=%d" , ++ o -> diff_path_counter ) ; argv_array_pushf ( & env , "GIT_DIFF_PATH_TOTAL=%d" , q -> nr ) ; <S2SV_StartBug> if ( run_command_v_opt_cd_env ( argv . argv , RUN_USING_SHELL , NULL , env . argv ) ) <S2SV_EndBug> die ( _ ( "external<S2SV_blank>diff<S2SV_blank>died,<S2SV_blank>stopping<S2SV_blank>at<S2SV_blank>%s" ) , name ) ; remove_tempfile ( ) ; argv_array_clear ( & argv ) ; argv_array_clear ( & env ) ; }
<S2SV_ModStart> ; if ( one && one -> should_munmap ) diff_free_filespec_data ( one ) ; if ( two && two -> should_munmap ) diff_free_filespec_data ( two ) ; if (
7,755
CWE-000 uint8_t i2c_read ( ) { <S2SV_StartBug> uint8_t byte = 0x00 , bit ; <S2SV_EndBug> for ( bit = 0 ; bit < 8 ; bit ++ ) { <S2SV_StartBug> i2c_set_sda ( 1 ) ; <S2SV_EndBug> i2c_set_scl ( 0 ) ; _delay_us ( 2 ) ; i2c_set_scl ( 1 ) ; _delay_us ( 2 ) ; byte <<= 1 ; <S2SV_StartBug> if ( PINA & _BV ( I2C_SDA ) ) byte |= 1 ; <S2SV_EndBug> _delay_us ( 1 ) ; i2c_set_scl ( 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> return byte ; }
<S2SV_ModStart> 0x00 , bit ; i2c_set_sda ( 1 ) <S2SV_ModStart> ++ ) { <S2SV_ModEnd> i2c_set_scl ( 0 <S2SV_ModStart> |= 1 ; } <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> return byte ;
7,756
CWE-000 static void sigma_gfx200 ( sigma_t * sigma ) { int x ; unsigned char * vram = & sigma -> vram [ ( ( sigma -> ma << 1 ) & 0x1FFF ) + ( sigma -> sc & 2 ) * 0x1000 ] ; uint8_t plane [ 4 ] ; uint8_t mask , col , c ; for ( x = 0 ; x < ( sigma -> crtc [ 1 ] << 1 ) ; x ++ ) { plane [ 0 ] = vram [ x ] ; plane [ 1 ] = vram [ 0x8000 + x ] ; plane [ 2 ] = vram [ 0x10000 + x ] ; plane [ 3 ] = vram [ 0x18000 + x ] ; for ( c = 0 , mask = 0x80 ; c < 8 ; c ++ , mask >>= 1 ) { col = ( ( plane [ 3 ] & mask ) ? 8 : 0 ) | ( ( plane [ 2 ] & mask ) ? 4 : 0 ) | ( ( plane [ 1 ] & mask ) ? 2 : 0 ) | ( ( plane [ 0 ] & mask ) ? 1 : 0 ) ; <S2SV_StartBug> buffer -> line [ sigma -> displine ] [ ( x << 3 ) + c + 8 ] = col ; <S2SV_EndBug> } if ( x & 1 ) ++ sigma -> ma ; } }
<S2SV_ModStart> 0 ) ; col |= 16 ;
7,757
CWE-000 static void write_to_emlog ( struct emlog_info * einfo , char * buf , size_t length ) { int bytes_copied = 0 ; int overflow = 0 ; int n ; <S2SV_StartBug> if ( length + EMLOG_QLEN ( einfo ) >= ( einfo -> size - 1 ) ) { <S2SV_EndBug> overflow = 1 ; einfo -> offset = einfo -> offset + EMLOG_QLEN ( einfo ) + length - einfo -> size + 1 ; } while ( length ) { n = min ( length , einfo -> size - einfo -> write_point ) ; memcpy ( einfo -> data + einfo -> write_point , buf + bytes_copied , n ) ; bytes_copied += n ; length -= n ; einfo -> write_point = ( einfo -> write_point + n ) % einfo -> size ; } if ( overflow ) einfo -> read_point = ( einfo -> write_point + 1 ) % einfo -> size ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> int n ; write_lock ( & einfo -> rwlock ) ; if ( emlog_debug ) pr_debug ( "\\nLength:<S2SV_blank>%zu\\nEMLOG_QLEN:<S2SV_blank>%zu\\neinfo->size:<S2SV_blank>%zu\\neinfo->offset:<S2SV_blank>%lld\\neinfo->read_point:<S2SV_blank>%zu\\neinfo->write_point:<S2SV_blank>%zu\\n" , length , EMLOG_QLEN ( einfo ) , einfo -> size , einfo -> offset , einfo -> read_point , einfo -> write_point ) ; <S2SV_ModStart> -> size ; write_unlock ( & einfo -> rwlock ) ;
7,758
CWE-000 static PyObject * gc_unfreeze_impl ( PyObject * module ) <S2SV_StartBug> { <S2SV_EndBug> gc_list_merge ( & _PyRuntime . gc . permanent_generation . head , GEN_HEAD ( NUM_GENERATIONS - 1 ) ) ; Py_RETURN_NONE ; }
<S2SV_ModStart> module ) { RAISE_EXCEPTION_IF_LOCKDOWN_IS_ENABLED ;
7,759
CWE-000 int pat_ref_append ( struct pat_ref * ref , char * pattern , char * sample , int line ) { struct pat_ref_elt * elt ; elt = malloc ( sizeof ( * elt ) ) ; if ( ! elt ) return 0 ; elt -> line = line ; elt -> pattern = strdup ( pattern ) ; if ( ! elt -> pattern ) { free ( elt ) ; return 0 ; } if ( sample ) { elt -> sample = strdup ( sample ) ; if ( ! elt -> sample ) { free ( elt -> pattern ) ; free ( elt ) ; return 0 ; } } else elt -> sample = NULL ; <S2SV_StartBug> LIST_ADDQ ( & ref -> head , & elt -> list ) ; <S2SV_EndBug> return 1 ; }
<S2SV_ModStart> = NULL ; LIST_INIT ( & elt -> back_refs ) ;
7,760
CWE-000 bool stream_seek ( stream_t * stream , double position ) { <S2SV_StartBug> bool result ; <S2SV_EndBug> int64_t seek_pos ; seek_pos = ( position + stream -> track -> start ) / av_q2d ( stream -> src_ctx -> streams [ 0 ] -> time_base ) ; result = av_seek_frame ( stream -> src_ctx , 0 , seek_pos , 0 ) ; stream -> pts = position * AV_TIME_BASE ; return result >= 0 ? true : false ; }
<S2SV_ModStart> position ) { int <S2SV_ModEnd> result ; int64_t
7,761
CWE-000 static void message_complete ( SoupSession * sesison , SoupMessage * msg , gpointer user_data ) { MessageData * message_data = ( MessageData * ) user_data ; static gint delay = 2 ; if ( SOUP_STATUS_IS_SUCCESSFUL ( message_data -> msg -> status_code ) || SOUP_STATUS_IS_CLIENT_ERROR ( message_data -> msg -> status_code ) ) { delay = 2 ; if ( message_data -> finish_callback ) { message_data -> finish_callback ( message_data -> session , message_data -> msg , message_data -> user_data ) ; } g_slice_free ( MessageData , message_data ) ; g_idle_add_full ( G_PRIORITY_DEFAULT_IDLE , message_handler , NULL , NULL ) ; } else { delay = ( gint ) ( delay * 1.5 ) ; if ( delay > 625 ) { delay = 625 ; } gchar * uri = soup_uri_to_string ( soup_message_get_uri ( message_data -> msg ) , TRUE ) ; g_warning ( "%s:<S2SV_blank>Unable<S2SV_blank>to<S2SV_blank>send<S2SV_blank>%s,<S2SV_blank>delaying<S2SV_blank>%d<S2SV_blank>seconds.." , message_data -> msg -> reason_phrase , uri , delay ) ; g_free ( uri ) ; <S2SV_StartBug> g_object_ref ( message_data -> msg ) ; <S2SV_EndBug> g_queue_push_head ( message_queue , message_data ) ; g_timeout_add_seconds_full ( G_PRIORITY_DEFAULT_IDLE , delay , message_handler , NULL , NULL ) ; } }
<S2SV_ModStart> uri ) ; ( void )
7,762
CWE-000 int main ( int argc , char * * argv ) { char * arstream [ ] = { "ar-stream" , NULL } ; char * tarstream [ ] = { "tar-stream" , NULL , NULL } ; char * xz [ ] = { "xz" , NULL } ; char * debdir ; if ( argc != 3 ) { fprintf ( stderr , "Usage:<S2SV_blank>%s<S2SV_blank>[directory]<S2SV_blank>[target.deb]\\n" , argv [ 0 ] ) ; return 1 ; } for ( size_t i = 0 ; i < PIPES_MAX ; ++ i ) { fd ( i ) = - 1 ; } check_dir ( argv [ 1 ] ) ; load_rules ( ) ; debdir = calloc ( strlen ( argv [ 1 ] ) + 10 , sizeof ( char ) ) ; <S2SV_StartBug> sprintf ( debdir , "%s/DEBIAN" , argv [ 1 ] ) ; <S2SV_EndBug> create_file ( argv [ 2 ] , pipe ( DEB_OUTPUT ) ) ; create_fifo ( pipe ( AR_INPUT_R ) ) ; pipe_fork_exec ( arstream , pipe ( AR_INPUT_R ) , pipe ( DEB_OUTPUT ) ) ; ar_header ( "debian-binary" ) ; write ( fd ( AR_INPUT_W ) , "2.0\\n" , 4 ) ; ar_footer ( ) ; ar_header ( "control.tar.xz" ) ; create_pipes ( pipe ( TARSTREAM_INPUT_R ) ) ; create_pipes ( pipe ( XZIP_INPUT_R ) ) ; tarstream [ 1 ] = debdir ; pipe_fork_exec ( tarstream , pipe ( TARSTREAM_INPUT_R ) , pipe ( XZIP_INPUT_W ) ) ; pipe_fork_exec ( xz , pipe ( XZIP_INPUT_R ) , pipe ( AR_INPUT_W ) ) ; process_control ( ) ; ar_footer ( ) ; ar_header ( "data.tar.xz" ) ; create_pipes ( pipe ( TARSTREAM_INPUT_R ) ) ; create_pipes ( pipe ( XZIP_INPUT_R ) ) ; tarstream [ 1 ] = argv [ 1 ] ; pipe_fork_exec ( tarstream , pipe ( TARSTREAM_INPUT_R ) , pipe ( XZIP_INPUT_W ) ) ; pipe_fork_exec ( xz , pipe ( XZIP_INPUT_R ) , pipe ( AR_INPUT_W ) ) ; process_data ( ) ; ar_footer ( ) ; ar_header ( "" ) ; ar_footer ( ) ; free ( debdir ) ; c_exit ( 0 ) ; }
<S2SV_ModStart> ( debdir , "%s/debian" <S2SV_ModEnd> , argv [
7,763
CWE-000 void jwork_process_device ( jamstate_t * js ) { nvoid_t * nv = queue_deq ( js -> deviceinq ) ; if ( nv == NULL ) return ; command_t * rcmd = ( command_t * ) nv -> data ; free ( nv ) ; # ifdef DEBUG_LVL1 <S2SV_StartBug> printf ( "\\n\\nIMPORTANT<S2SV_blank>%s,<S2SV_blank>opt:<S2SV_blank>%s<S2SV_blank>actarg:<S2SV_blank>%s<S2SV_blank>actid:<S2SV_blank>%s\\n\\n\\n" , rcmd -> cmd , rcmd -> opt , rcmd -> actarg , rcmd -> actid ) ; <S2SV_EndBug> # endif if ( rcmd != NULL ) { if ( strcmp ( rcmd -> cmd , "KILL" ) == 0 ) { printf ( "ERROR!<S2SV_blank>Kill<S2SV_blank>message<S2SV_blank>received<S2SV_blank>from<S2SV_blank>the<S2SV_blank>J<S2SV_blank>node.\\n" ) ; printf ( "Exiting.\\n" ) ; exit ( 1 ) ; } else if ( strcmp ( rcmd -> cmd , "REGISTER-ACK" ) == 0 ) { command_t * scmd = command_new ( "GET-CF-INFO" , "-" , "-" , 0 , "-" , "-" , js -> cstate -> device_id , "" ) ; mqtt_publish ( js -> cstate -> mqttserv [ 0 ] , "/admin/request/all" , scmd ) ; thread_signal ( js -> bgsem ) ; } else if ( strcmp ( rcmd -> cmd , "PING" ) == 0 ) { if ( js -> cstate -> cf_pending ) { command_t * scmd = command_new ( "REF-CF-INFO" , "-" , "-" , 0 , "-" , "-" , js -> cstate -> device_id , "" ) ; mqtt_publish ( js -> cstate -> mqttserv [ 0 ] , "/admin/request/all" , scmd ) ; } } else if ( strcmp ( rcmd -> cmd , "PUT-CF-INFO" ) == 0 ) { if ( ( strcmp ( rcmd -> actarg , "fog" ) == 0 ) && ( strcmp ( rcmd -> opt , "ADD" ) == 0 ) ) { core_createserver ( js -> cstate , 1 , rcmd -> args [ 0 ] . val . sval ) ; comboptr_t * ctx = create_combo3i_ptr ( js , js -> foginq , NULL , 1 ) ; core_setcallbacks ( js -> cstate , ctx , jwork_connect_lost , jwork_msg_arrived , NULL ) ; core_connect ( js -> cstate , 1 , on_fog_connect ) ; } else if ( ( strcmp ( rcmd -> actarg , "cloud" ) == 0 ) && ( strcmp ( rcmd -> opt , "ADD" ) == 0 ) ) { core_createserver ( js -> cstate , 2 , rcmd -> args [ 0 ] . val . sval ) ; comboptr_t * ctx = create_combo3i_ptr ( js , js -> cloudinq , NULL , 2 ) ; core_setcallbacks ( js -> cstate , ctx , jwork_connect_lost , jwork_msg_arrived , NULL ) ; core_connect ( js -> cstate , 2 , on_cloud_connect ) ; } command_free ( rcmd ) ; core_check_pending ( js -> cstate ) ; } else if ( ( strcmp ( rcmd -> cmd , "REXEC-ASY" ) == 0 ) || ( strcmp ( rcmd -> cmd , "REXEC-SYN" ) == 0 ) ) { if ( find_list_item ( cache , rcmd -> actid ) ) { command_free ( rcmd ) ; return ; } else { put_list_tail ( cache , strdup ( rcmd -> actid ) , strlen ( rcmd -> actid ) ) ; if ( list_length ( cache ) > cachesize ) del_list_tail ( cache ) ; } if ( jwork_evaluate_cond ( rcmd -> cond ) ) p2queue_enq_low ( js -> atable -> globalinq , rcmd , sizeof ( command_t ) ) ; else jwork_send_nak ( js , rcmd , "CONDITION<S2SV_blank>FALSE" ) ; } else if ( strcmp ( rcmd -> cmd , "REXEC-ASY-CBK" ) == 0 ) { if ( runtable_find ( js -> rtable , rcmd -> actarg ) != NULL ) { if ( jwork_evaluate_cond ( rcmd -> cond ) ) p2queue_enq_low ( js -> atable -> globalinq , rcmd , sizeof ( command_t ) ) ; else jwork_send_nak ( js -> cstate -> mqttserv [ 0 ] , rcmd , "CONDITION<S2SV_blank>FALSE" ) ; } } else if ( ( strcmp ( rcmd -> cmd , "REXEC-ACK" ) == 0 ) || ( strcmp ( rcmd -> cmd , "REXEC-NAK" ) == 0 ) || ( strcmp ( rcmd -> cmd , "REXEC-RES" ) == 0 ) ) { int aindx = activity_id2indx ( js -> atable , rcmd -> actid ) ; if ( aindx >= 0 ) { activity_thread_t * athr = js -> atable -> athreads [ aindx ] ; pqueue_enq ( athr -> inq , rcmd , sizeof ( command_t ) ) ; } } else if ( strcmp ( rcmd -> cmd , "GOGOGO" ) == 0 ) { p2queue_enq_high ( js -> atable -> globalinq , rcmd , sizeof ( command_t ) ) ; } else { printf ( "Command<S2SV_blank>%s<S2SV_blank>freed...............\\n" , rcmd -> cmd ) ; command_free ( rcmd ) ; } } }
<S2SV_ModStart> DEBUG_LVL1 printf ( "\\n\\nCommand<S2SV_blank>from<S2SV_blank>Device<S2SV_blank>cmd:<S2SV_blank>%s,<S2SV_blank>opt:<S2SV_blank>%s<S2SV_blank>actarg:<S2SV_blank>%s<S2SV_blank>actid:<S2SV_blank>%s\\n\\n\\n" <S2SV_ModEnd> , rcmd ->
7,764
CWE-000 dlistint_t * insert_dnodeint_at_index ( dlistint_t * * h , unsigned int idx , int n ) { dlistint_t * temp ; dlistint_t * new ; unsigned int count = 0 ; new = malloc ( sizeof ( dlistint_t ) ) ; if ( ! new ) return ( NULL ) ; new -> n = n ; temp = * h ; if ( idx == 0 ) <S2SV_StartBug> { <S2SV_EndBug> new -> next = temp ; new -> prev = NULL ; temp = new ; return ( new ) ; } while ( count != idx ) { count ++ ; <S2SV_StartBug> temp = temp -> next ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> new -> next = temp -> next ; new -> prev = temp ; <S2SV_StartBug> temp -> next = new ; <S2SV_EndBug> return ( new ) ; }
<S2SV_ModStart> == 0 ) return ( add_nodeint ( h , n ) ) ; <S2SV_ModEnd> while ( count <S2SV_ModStart> count ++ ; if ( temp ) <S2SV_ModStart> next ; } if ( temp == NULL ) return ( NULL ) ; <S2SV_ModStart> = temp ; if ( temp -> next ) temp -> next -> prev = new ;
7,765
CWE-000 void lv_task_del ( lv_task_t * lv_task_p ) { lv_ll_rem ( & lv_task_ll , lv_task_p ) ; lv_mem_free ( lv_task_p ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> lv_task_p ) ; if ( task_act == lv_task_p ) task_deleted = true ;
7,766
CWE-000 static int iwl_fill_data_tbs ( struct iwl_trans * trans , struct sk_buff * skb , struct iwl_txq * txq , u8 hdr_len , struct iwl_cmd_meta * out_meta , struct iwl_device_cmd * dev_cmd , u16 tb1_len ) { struct iwl_trans_pcie * trans_pcie = IWL_TRANS_GET_PCIE_TRANS ( trans ) ; u16 tb2_len ; int i ; tb2_len = skb_headlen ( skb ) - hdr_len ; if ( tb2_len > 0 ) { dma_addr_t tb2_phys = dma_map_single ( trans -> dev , skb -> data + hdr_len , tb2_len , DMA_TO_DEVICE ) ; if ( unlikely ( dma_mapping_error ( trans -> dev , tb2_phys ) ) ) { iwl_pcie_tfd_unmap ( trans , out_meta , txq , txq -> write_ptr ) ; return - EINVAL ; } iwl_pcie_txq_build_tfd ( trans , txq , tb2_phys , tb2_len , false ) ; } for ( i = 0 ; i < skb_shinfo ( skb ) -> nr_frags ; i ++ ) { const skb_frag_t * frag = & skb_shinfo ( skb ) -> frags [ i ] ; dma_addr_t tb_phys ; int tb_idx ; if ( ! skb_frag_size ( frag ) ) continue ; tb_phys = skb_frag_dma_map ( trans -> dev , frag , 0 , skb_frag_size ( frag ) , DMA_TO_DEVICE ) ; if ( unlikely ( dma_mapping_error ( trans -> dev , tb_phys ) ) ) { iwl_pcie_tfd_unmap ( trans , out_meta , txq , txq -> write_ptr ) ; return - EINVAL ; } tb_idx = iwl_pcie_txq_build_tfd ( trans , txq , tb_phys , skb_frag_size ( frag ) , false ) ; out_meta -> tbs |= BIT ( tb_idx ) ; } trace_iwlwifi_dev_tx ( trans -> dev , skb , <S2SV_StartBug> iwl_pcie_get_tfd ( trans_pcie , txq , txq -> write_ptr ) , <S2SV_EndBug> trans_pcie -> tfd_size , & dev_cmd -> hdr , IWL_FIRST_TB_SIZE + tb1_len , hdr_len ) ; trace_iwlwifi_dev_tx_data ( trans -> dev , skb , hdr_len ) ; return 0 ; }
<S2SV_ModStart> , iwl_pcie_get_tfd ( trans <S2SV_ModEnd> , txq ,
7,767
CWE-000 zx_status_t aml_gpio_init ( aml_bus_t * bus ) { <S2SV_StartBug> zx_status_t status = pbus_device_add ( & bus -> pbus , & gpio_dev , PDEV_ADD_PBUS_DEVHOST ) ; <S2SV_EndBug> if ( status != ZX_OK ) { <S2SV_StartBug> zxlogf ( ERROR , "aml_gpio_init:<S2SV_blank>pbus_device_add<S2SV_blank>failed:<S2SV_blank>%d\\n" , status ) ; <S2SV_EndBug> return status ; } status = pbus_wait_protocol ( & bus -> pbus , ZX_PROTOCOL_GPIO ) ; if ( status != ZX_OK ) { zxlogf ( ERROR , "aml_gpio_init:<S2SV_blank>pbus_wait_protocol<S2SV_blank>failed:<S2SV_blank>%d\\n" , status ) ; return status ; } status = device_get_protocol ( bus -> parent , ZX_PROTOCOL_GPIO , & bus -> gpio ) ; if ( status != ZX_OK ) { zxlogf ( ERROR , "aml_gpio_init:<S2SV_blank>device_get_protocol<S2SV_blank>failed:<S2SV_blank>%d\\n" , status ) ; return status ; } # if GPIO_TEST const pbus_gpio_t gpio_test_gpios [ ] = { { . gpio = S905D2_GPIOAO ( 11 ) , } , { . gpio = S905D2_GPIOAO ( 6 ) , } } ; const pbus_dev_t gpio_test_dev = { . name = "aml-gpio-test" , . vid = PDEV_VID_GENERIC , . pid = PDEV_PID_GENERIC , . did = PDEV_DID_GPIO_TEST , . gpios = gpio_test_gpios , . gpio_count = countof ( gpio_test_gpios ) , } ; if ( ( status = pbus_device_add ( & bus -> pbus , & gpio_test_dev , 0 ) ) != ZX_OK ) { zxlogf ( ERROR , "aml_gpio_init<S2SV_blank>could<S2SV_blank>not<S2SV_blank>add<S2SV_blank>gpio_test_dev:<S2SV_blank>%d\\n" , status ) ; return status ; } # endif return ZX_OK ; }
<S2SV_ModStart> zx_status_t status = pbus_protocol_device_add <S2SV_ModEnd> ( & bus <S2SV_ModStart> -> pbus , ZX_PROTOCOL_GPIO , & gpio_dev <S2SV_ModEnd> ) ; if <S2SV_ModStart> ( ERROR , "aml_gpio_init:<S2SV_blank>pbus_protocol_device_add<S2SV_blank>failed:<S2SV_blank>%d\\n" <S2SV_ModEnd> , status )
7,768
CWE-000 void check_for_unresolved ( Ast * ast , Type * t ) { switch ( t -> comp ) { case FUNC : for ( int i = 0 ; i < array_len ( t -> fn . args ) ; i ++ ) { check_for_unresolved ( ast , t -> fn . args [ i ] ) ; } if ( t -> fn . ret != NULL ) { check_for_unresolved ( ast , t -> fn . ret ) ; } break ; case STRUCT : { for ( int i = 0 ; i < array_len ( t -> st . member_types ) ; i ++ ) { check_for_unresolved ( ast , t -> st . member_types [ i ] ) ; } break ; } case ALIAS : <S2SV_StartBug> if ( resolve_alias ( t ) == NULL ) { <S2SV_EndBug> error ( ast -> line , ast -> file , "Unknown<S2SV_blank>type<S2SV_blank>\'%s\'." , t -> name ) ; } break ; case REF : check_for_unresolved ( ast , t -> ref . inner ) ; break ; case ARRAY : case STATIC_ARRAY : check_for_unresolved ( ast , t -> array . inner ) ; break ; case BASIC : case POLYDEF : case PARAMS : case EXTERNAL : case ENUM : break ; } }
<S2SV_ModStart> : if ( ! <S2SV_ModStart> ( t ) <S2SV_ModEnd> ) { error
7,769
CWE-000 PetscErrorCode DMProjectFieldLocal ( DM dm , PetscReal time , Vec localU , void ( * * funcs ) ( PetscInt , PetscInt , PetscInt , const PetscInt [ ] , const PetscInt [ ] , const PetscScalar [ ] , const PetscScalar [ ] , const PetscScalar [ ] , const PetscInt [ ] , const PetscInt [ ] , const PetscScalar [ ] , const PetscScalar [ ] , const PetscScalar [ ] , PetscReal , const PetscReal [ ] , PetscInt , const PetscScalar [ ] , PetscScalar [ ] ) , InsertMode mode , Vec localX ) { PetscErrorCode ierr ; PetscFunctionBegin ; PetscValidHeaderSpecific ( dm , DM_CLASSID , 1 ) ; PetscValidHeaderSpecific ( localU , VEC_CLASSID , 3 ) ; PetscValidHeaderSpecific ( localX , VEC_CLASSID , 6 ) ; <S2SV_StartBug> if ( ! dm -> ops -> projectfieldlocal ) SETERRQ1 ( PetscObjectComm ( ( PetscObject ) dm ) , PETSC_ERR_SUP , "DM<S2SV_blank>type<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>implemnt<S2SV_blank>DMProjectFieldLocal" , ( ( PetscObject ) dm ) -> type_name ) ; <S2SV_EndBug> ierr = ( dm -> ops -> projectfieldlocal ) ( dm , time , localU , funcs , mode , localX ) ; CHKERRQ ( ierr ) ; PetscFunctionReturn ( 0 ) ; }
<S2SV_ModStart> , PETSC_ERR_SUP , "DM<S2SV_blank>type<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>implement<S2SV_blank>DMProjectFieldLocal" <S2SV_ModEnd> , ( (
7,770
CWE-000 gpio_hal_pin_cfg_t gpio_hal_arch_pin_cfg_get ( gpio_hal_pin_t pin ) { gpio_hal_pin_cfg_t cfg ; uint32_t tmp ; uint32_t config ; cfg = 0 ; <S2SV_StartBug> config = ti_lib_rom_ioc_port_configure_get ( pin ) ; <S2SV_EndBug> tmp = config & IOC_IOPULL_M ; if ( tmp == IOC_IOPULL_UP ) { cfg |= GPIO_HAL_PIN_CFG_PULL_UP ; } else if ( tmp == IOC_IOPULL_DOWN ) { cfg |= GPIO_HAL_PIN_CFG_PULL_DOWN ; } else if ( tmp == IOC_NO_IOPULL ) { cfg |= GPIO_HAL_PIN_CFG_PULL_NONE ; } tmp = config & IOC_INT_ENABLE ; if ( tmp == IOC_INT_DISABLE ) { cfg |= GPIO_HAL_PIN_CFG_INT_DISABLE ; } else if ( tmp == IOC_INT_ENABLE ) { cfg |= GPIO_HAL_PIN_CFG_INT_ENABLE ; } tmp = config & IOC_BOTH_EDGES ; if ( tmp == IOC_NO_EDGE ) { cfg |= GPIO_HAL_PIN_CFG_EDGE_NONE ; } else if ( tmp == IOC_FALLING_EDGE ) { cfg |= GPIO_HAL_PIN_CFG_EDGE_FALLING ; } else if ( tmp == IOC_RISING_EDGE ) { cfg |= GPIO_HAL_PIN_CFG_EDGE_RISING ; } else if ( tmp == IOC_BOTH_EDGES ) { cfg |= GPIO_HAL_PIN_CFG_EDGE_BOTH ; } return cfg ; }
<S2SV_ModStart> = 0 ; # ifdef ThisLibraryIsFor_CC26x0R2_HaltIfViolated config = ti_lib_ioc_port_configure_get ( pin ) ; # else <S2SV_ModStart> pin ) ; # endif
7,771
CWE-000 static UI_CONTROLLER_EVENT handleEventPieceDrag ( WindowController * controller ) { GameWindowControllerData * data = getGameWindowControllerData ( controller ) ; ChessPiecePosition sourcePos = gameWindowGetData ( controller -> window ) -> sourcePos ; ChessPiecePosition targetPos = gameWindowGetData ( controller -> window ) -> targetPos ; ChessGame * game = data -> gameSettings -> chessGame ; CHESS_GAME_MESSAGE msg = chessGameSetMove ( game , sourcePos , targetPos ) ; if ( msg == CHESS_GAME_SUCCESS ) { <S2SV_StartBug> msg = chessGameStatePopup ( game ) ; <S2SV_EndBug> if ( msg == CHESS_GAME_NONE || msg == CHESS_GAME_CHECK ) { if ( data -> gameSettings -> gameMode == ONE_PLAYER ) { <S2SV_StartBug> } <S2SV_EndBug> setUnsavedChanges ( controller , true ) ; } } bool res = gameWindowRefreshWidgets ( controller -> window ) ; return res ? UI_CONTROLLER_EVENT_INVOKE_DRAW : UI_CONTROLLER_EVENT_ERROR ; }
<S2SV_ModStart> CHESS_GAME_SUCCESS ) { setUnsavedChanges ( controller , true ) ; <S2SV_ModStart> ONE_PLAYER ) { TreeNode * root = chessGameMinimax ( data -> gameSettings ) ; if ( root == NULL ) return UI_CONTROLLER_EVENT_ERROR ; ChessMove move = root -> bestMove ; chessGameSetMove ( game , move . previousPosition , move . currentPosition ) ; msg = chessGameStatePopup ( game ) ; } <S2SV_ModEnd> } } bool
7,772
CWE-000 static int smb2_close_pipe ( struct cifsd_work * work ) { struct cifsd_pipe * pipe_desc ; uint64_t id ; int rc = 0 ; struct smb2_close_req * req = ( struct smb2_close_req * ) REQUEST_BUF ( work ) ; struct smb2_close_rsp * rsp = ( struct smb2_close_rsp * ) RESPONSE_BUF ( work ) ; id = le64_to_cpu ( req -> VolatileFileId ) ; pipe_desc = get_pipe_desc ( work -> sess , id ) ; if ( ! pipe_desc ) { cifsd_debug ( "Pipe<S2SV_blank>not<S2SV_blank>opened<S2SV_blank>or<S2SV_blank>invalid<S2SV_blank>in<S2SV_blank>Pipe<S2SV_blank>id\\n" ) ; <S2SV_StartBug> rsp -> hdr . Status = NT_STATUS_INVALID_HANDLE ; <S2SV_EndBug> smb2_set_err_rsp ( work ) ; return 0 ; } rsp -> StructureSize = cpu_to_le16 ( 60 ) ; rsp -> Flags = 0 ; rsp -> Reserved = 0 ; rsp -> CreationTime = 0 ; rsp -> LastAccessTime = 0 ; rsp -> LastWriteTime = 0 ; rsp -> ChangeTime = 0 ; rsp -> AllocationSize = 0 ; rsp -> EndOfFile = 0 ; rsp -> Attributes = 0 ; inc_rfc1001_len ( rsp , 60 ) ; if ( ! rc ) { rc = cifsd_sendmsg ( work -> sess , CIFSD_KEVENT_DESTROY_PIPE , pipe_desc -> pipe_type , 0 , NULL , 0 ) ; if ( rc ) cifsd_err ( "failed<S2SV_blank>to<S2SV_blank>send<S2SV_blank>event,<S2SV_blank>err<S2SV_blank>%d\\n" , rc ) ; } rc = close_pipe_id ( work -> sess , pipe_desc -> pipe_type ) ; if ( rc < 0 ) { <S2SV_StartBug> rsp -> hdr . Status = NT_STATUS_INVALID_HANDLE ; <S2SV_EndBug> smb2_set_err_rsp ( work ) ; } return 0 ; }
<S2SV_ModStart> . Status = NT_STATUS_FILE_CLOSED <S2SV_ModEnd> ; smb2_set_err_rsp ( <S2SV_ModStart> . Status = NT_STATUS_FILE_CLOSED <S2SV_ModEnd> ; smb2_set_err_rsp (
7,773
CWE-000 void _hash_pageinit ( Page page , Size size ) { <S2SV_StartBug> PageInit ( page , size , sizeof ( HashPageOpaqueData ) , 0 , PD_DEFAULT_INIT_TRANS ) ; <S2SV_EndBug> }
<S2SV_ModStart> HashPageOpaqueData ) , BLKTYPE_INDEX <S2SV_ModEnd> , PD_DEFAULT_INIT_TRANS )
7,774
CWE-000 static int get_page_list ( uint32_t kernel , struct smq_invoke_ctx * ctx , int cid ) { struct fastrpc_apps * me = & gfa ; struct smq_phy_page * pgstart , * pages ; struct smq_invoke_buf * list ; struct fastrpc_buf * ibuf = & ctx -> dev -> buf ; struct fastrpc_buf * obuf = & ctx -> obuf ; remote_arg_t * pra = ctx -> pra ; uint32_t sc = ctx -> sc ; int i , rlen , err = 0 ; int inbufs = REMOTE_SCALARS_INBUFS ( sc ) ; int outbufs = REMOTE_SCALARS_OUTBUFS ( sc ) ; LOCK_MMAP ( kernel ) ; * obuf = * ibuf ; retry : list = smq_invoke_buf_start ( ( remote_arg_t * ) obuf -> virt , sc ) ; pgstart = smq_phy_page_start ( sc , list ) ; pages = pgstart + 1 ; rlen = obuf -> size - ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) ; if ( rlen < 0 ) { rlen = ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) - obuf -> size ; obuf -> size += buf_page_size ( rlen ) ; VERIFY ( err , 0 == alloc_mem ( obuf , cid ) ) ; if ( err ) goto bail ; goto retry ; } pgstart -> addr = obuf -> phys ; pgstart -> size = obuf -> size ; for ( i = 0 ; i < inbufs + outbufs ; ++ i ) { void * buf ; <S2SV_StartBug> int len , num ; <S2SV_EndBug> list [ i ] . num = 0 ; list [ i ] . pgidx = 0 ; len = pra [ i ] . buf . len ; VERIFY ( err , len >= 0 ) ; if ( err ) goto bail ; if ( ! len ) continue ; buf = pra [ i ] . buf . pv ; num = buf_num_pages ( buf , len ) ; if ( ! kernel ) { if ( me -> channel [ cid ] . smmu . enabled ) { VERIFY ( err , 0 != access_ok ( i >= inbufs ? VERIFY_WRITE : VERIFY_READ , ( void __user * ) buf , len ) ) ; if ( err ) goto bail ; if ( ctx -> fds && ( ctx -> fds [ i ] >= 0 ) ) list [ i ] . num = 1 ; } else { list [ i ] . num = buf_get_pages ( buf , len , num , i >= inbufs , pages , rlen / sizeof ( * pages ) ) ; } } VERIFY ( err , list [ i ] . num >= 0 ) ; if ( err ) goto bail ; if ( list [ i ] . num ) { list [ i ] . pgidx = pages - pgstart ; pages = pages + list [ i ] . num ; } else if ( rlen > sizeof ( * pages ) ) { list [ i ] . pgidx = pages - pgstart ; pages = pages + 1 ; } else { if ( obuf -> handle != ibuf -> handle ) free_mem ( obuf , cid ) ; obuf -> size += buf_page_size ( sizeof ( * pages ) ) ; VERIFY ( err , 0 == alloc_mem ( obuf , cid ) ) ; if ( err ) goto bail ; goto retry ; } rlen = obuf -> size - ( ( uint32_t ) pages - ( uint32_t ) obuf -> virt ) ; } obuf -> used = obuf -> size - rlen ; bail : if ( err && ( obuf -> handle != ibuf -> handle ) ) free_mem ( obuf , cid ) ; UNLOCK_MMAP ( kernel ) ; return err ; }
<S2SV_ModStart> buf ; int num ; ssize_t len <S2SV_ModEnd> ; list [
7,775
CWE-000 static inline int64_t toFixedPoint ( const float f ) { binary32 b ; b . f = f ; int32_t e = ( ( b . ui32 << 1 ) >> 24 ) - 127 ; int64_t mantisse = ( ( b . ui32 << 9 ) >> 9 ) ; int sign = b . ui32 >> 31 ; int64_t val = ( mantisse << 32 ) + ( ( int64_t ) 0b1 << 55 ) ; if ( e > 0 ) { val = val << e ; } else { <S2SV_StartBug> val = val >> ( - e ) ; <S2SV_EndBug> } if ( sign > 0 ) { val = - val ; } return val ; }
<S2SV_ModStart> } else { if ( e < - 63 ) e = - 63 ;
7,776
CWE-000 g2int g2_unpack4 ( unsigned char * cgrib , g2int cgrib_length , g2int * iofst , g2int * ipdsnum , g2int * * ipdstmpl , g2int * mappdslen , g2float * * coordlist , g2int * numcoord ) { g2int ierr , needext , i , j , nbits , isecnum ; g2int lensec , isign , newlen ; g2int * coordieee ; g2int * lipdstmpl = 0 ; g2float * lcoordlist ; gtemplate * mappds ; ierr = 0 ; * ipdstmpl = 0 ; * coordlist = 0 ; gbit2 ( cgrib , cgrib_length , & lensec , * iofst , 32 ) ; * iofst = * iofst + 32 ; gbit2 ( cgrib , cgrib_length , & isecnum , * iofst , 8 ) ; * iofst = * iofst + 8 ; if ( isecnum != 4 ) { ierr = 2 ; * numcoord = 0 ; * mappdslen = 0 ; return ( ierr ) ; } gbit2 ( cgrib , cgrib_length , numcoord , * iofst , 16 ) ; * iofst = * iofst + 16 ; gbit2 ( cgrib , cgrib_length , ipdsnum , * iofst , 16 ) ; * iofst = * iofst + 16 ; mappds = getpdstemplate ( * ipdsnum ) ; if ( mappds == 0 ) { ierr = 5 ; * mappdslen = 0 ; return ( ierr ) ; } * mappdslen = mappds -> maplen ; needext = mappds -> needext ; if ( * mappdslen > 0 ) lipdstmpl = ( g2int * ) calloc ( * mappdslen , sizeof ( g2int ) ) ; if ( lipdstmpl == 0 ) { ierr = 6 ; * mappdslen = 0 ; * ipdstmpl = 0 ; free ( mappds ) ; return ( ierr ) ; } else { * ipdstmpl = lipdstmpl ; } for ( i = 0 ; i < mappds -> maplen ; i ++ ) { nbits = abs ( mappds -> map [ i ] ) * 8 ; if ( mappds -> map [ i ] >= 0 ) { gbit2 ( cgrib , cgrib_length , lipdstmpl + i , * iofst , nbits ) ; } else { gbit2 ( cgrib , cgrib_length , & isign , * iofst , 1 ) ; gbit2 ( cgrib , cgrib_length , lipdstmpl + i , * iofst + 1 , nbits - 1 ) ; if ( isign == 1 ) lipdstmpl [ i ] = - 1 * lipdstmpl [ i ] ; } * iofst = * iofst + nbits ; } if ( needext == 1 ) { free ( mappds ) ; mappds = extpdstemplate ( * ipdsnum , lipdstmpl ) ; newlen = mappds -> maplen + mappds -> extlen ; lipdstmpl = ( g2int * ) realloc ( lipdstmpl , newlen * sizeof ( g2int ) ) ; * ipdstmpl = lipdstmpl ; j = 0 ; for ( i = * mappdslen ; i < newlen ; i ++ ) { # ifdef notneeded if ( mappds -> ext [ j ] < INT_MIN / 8 || mappds -> ext [ j ] > INT_MAX / 8 ) { ierr = 6 ; * numcoord = 0 ; * mappdslen = 0 ; * coordlist = 0 ; * ipdstmpl = 0 ; free ( mappds -> ext ) ; free ( mappds ) ; free ( lipdstmpl ) ; return ( ierr ) ; } # endif nbits = abs ( mappds -> ext [ j ] ) * 8 ; <S2SV_StartBug> if ( mappds -> ext [ j ] >= 0 ) { <S2SV_EndBug> gbit2 ( cgrib , cgrib_length , lipdstmpl + i , * iofst , nbits ) ; } else { gbit2 ( cgrib , cgrib_length , & isign , * iofst , 1 ) ; gbit2 ( cgrib , cgrib_length , lipdstmpl + i , * iofst + 1 , nbits - 1 ) ; if ( isign == 1 ) lipdstmpl [ i ] = - 1 * lipdstmpl [ i ] ; } * iofst = * iofst + nbits ; j ++ ; } * mappdslen = newlen ; } free ( mappds -> ext ) ; free ( mappds ) ; * coordlist = 0 ; if ( * numcoord != 0 ) { coordieee = ( g2int * ) calloc ( * numcoord , sizeof ( g2int ) ) ; lcoordlist = ( g2float * ) calloc ( * numcoord , sizeof ( g2float ) ) ; if ( coordieee == 0 || lcoordlist == 0 ) { ierr = 6 ; * numcoord = 0 ; * coordlist = 0 ; if ( coordieee != 0 ) free ( coordieee ) ; if ( lcoordlist != 0 ) free ( lcoordlist ) ; return ( ierr ) ; } else { * coordlist = lcoordlist ; } gbits ( cgrib , cgrib_length , coordieee , * iofst , 32 , 0 , * numcoord ) ; rdieee ( coordieee , * coordlist , * numcoord ) ; free ( coordieee ) ; * iofst = * iofst + ( 32 * ( * numcoord ) ) ; } return ( ierr ) ; }
<S2SV_ModStart> * 8 ; lipdstmpl [ i ] = 0 ;
7,777
CWE-000 int free_token ( struct server * sv , struct user * usr ) { hashmap_remove ( sv -> tokens_map , usr -> token ) ; <S2SV_StartBug> user_put ( sv , usr ) ; <S2SV_EndBug> return 0 ; }
<S2SV_ModStart> token ) ; mlog ( "free<S2SV_blank>token:%s\\n" , usr -> username ) ;
7,778
CWE-000 void rw_destroy ( rwlock_t * rw ) { <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> rw ) { ( void ) rw ;
7,779
CWE-000 static ngx_int_t ngx_http_auth_basic_set_realm ( ngx_http_request_t * r , ngx_str_t * realm ) { size_t len ; u_char * basic , * p ; r -> headers_out . www_authenticate = ngx_list_push ( & r -> headers_out . headers ) ; if ( r -> headers_out . www_authenticate == NULL ) { return NGX_HTTP_INTERNAL_SERVER_ERROR ; } len = sizeof ( "Basic<S2SV_blank>realm=\\"\\"" ) - 1 + realm -> len ; basic = ngx_pnalloc ( r -> pool , len ) ; if ( basic == NULL ) { <S2SV_StartBug> return NGX_HTTP_INTERNAL_SERVER_ERROR ; <S2SV_EndBug> } p = ngx_cpymem ( basic , "Basic<S2SV_blank>realm=\\"" , sizeof ( "Basic<S2SV_blank>realm=\\"" ) - 1 ) ; p = ngx_cpymem ( p , realm -> data , realm -> len ) ; * p = \'"\' ; r -> headers_out . www_authenticate -> hash = 1 ; ngx_str_set ( & r -> headers_out . www_authenticate -> key , "WWW-Authenticate" ) ; r -> headers_out . www_authenticate -> value . data = basic ; r -> headers_out . www_authenticate -> value . len = len ; return NGX_HTTP_UNAUTHORIZED ; }
<S2SV_ModStart> NULL ) { r -> headers_out . www_authenticate -> hash = 0 ; r -> headers_out . www_authenticate = NULL ;
7,780
CWE-000 static void ixgbevf_tx_map ( struct ixgbevf_ring * tx_ring , struct ixgbevf_tx_buffer * first , const u8 hdr_len ) { struct sk_buff * skb = first -> skb ; struct ixgbevf_tx_buffer * tx_buffer ; union ixgbe_adv_tx_desc * tx_desc ; struct skb_frag_struct * frag ; dma_addr_t dma ; unsigned int data_len , size ; u32 tx_flags = first -> tx_flags ; __le32 cmd_type = ixgbevf_tx_cmd_type ( tx_flags ) ; u16 i = tx_ring -> next_to_use ; tx_desc = IXGBEVF_TX_DESC ( tx_ring , i ) ; ixgbevf_tx_olinfo_status ( tx_desc , tx_flags , skb -> len - hdr_len ) ; size = skb_headlen ( skb ) ; data_len = skb -> data_len ; dma = dma_map_single ( tx_ring -> dev , skb -> data , size , DMA_TO_DEVICE ) ; tx_buffer = first ; for ( frag = & skb_shinfo ( skb ) -> frags [ 0 ] ; ; frag ++ ) { if ( dma_mapping_error ( tx_ring -> dev , dma ) ) goto dma_error ; dma_unmap_len_set ( tx_buffer , len , size ) ; dma_unmap_addr_set ( tx_buffer , dma , dma ) ; tx_desc -> read . buffer_addr = cpu_to_le64 ( dma ) ; while ( unlikely ( size > IXGBE_MAX_DATA_PER_TXD ) ) { tx_desc -> read . cmd_type_len = cmd_type | cpu_to_le32 ( IXGBE_MAX_DATA_PER_TXD ) ; i ++ ; tx_desc ++ ; if ( i == tx_ring -> count ) { tx_desc = IXGBEVF_TX_DESC ( tx_ring , 0 ) ; i = 0 ; } tx_desc -> read . olinfo_status = 0 ; dma += IXGBE_MAX_DATA_PER_TXD ; size -= IXGBE_MAX_DATA_PER_TXD ; tx_desc -> read . buffer_addr = cpu_to_le64 ( dma ) ; } if ( likely ( ! data_len ) ) break ; tx_desc -> read . cmd_type_len = cmd_type | cpu_to_le32 ( size ) ; i ++ ; tx_desc ++ ; if ( i == tx_ring -> count ) { tx_desc = IXGBEVF_TX_DESC ( tx_ring , 0 ) ; i = 0 ; } tx_desc -> read . olinfo_status = 0 ; size = skb_frag_size ( frag ) ; data_len -= size ; dma = skb_frag_dma_map ( tx_ring -> dev , frag , 0 , size , DMA_TO_DEVICE ) ; tx_buffer = & tx_ring -> tx_buffer_info [ i ] ; } cmd_type |= cpu_to_le32 ( size ) | cpu_to_le32 ( IXGBE_TXD_CMD ) ; tx_desc -> read . cmd_type_len = cmd_type ; first -> time_stamp = jiffies ; <S2SV_StartBug> wmb ( ) ; <S2SV_EndBug> first -> next_to_watch = tx_desc ; i ++ ; if ( i == tx_ring -> count ) i = 0 ; tx_ring -> next_to_use = i ; ixgbevf_write_tail ( tx_ring , i ) ; return ; dma_error : dev_err ( tx_ring -> dev , "TX<S2SV_blank>DMA<S2SV_blank>map<S2SV_blank>failed\\n" ) ; tx_buffer = & tx_ring -> tx_buffer_info [ i ] ; while ( tx_buffer != first ) { if ( dma_unmap_len ( tx_buffer , len ) ) dma_unmap_page ( tx_ring -> dev , dma_unmap_addr ( tx_buffer , dma ) , dma_unmap_len ( tx_buffer , len ) , DMA_TO_DEVICE ) ; dma_unmap_len_set ( tx_buffer , len , 0 ) ; if ( i -- == 0 ) i += tx_ring -> count ; tx_buffer = & tx_ring -> tx_buffer_info [ i ] ; } if ( dma_unmap_len ( tx_buffer , len ) ) dma_unmap_single ( tx_ring -> dev , dma_unmap_addr ( tx_buffer , dma ) , dma_unmap_len ( tx_buffer , len ) , DMA_TO_DEVICE ) ; dma_unmap_len_set ( tx_buffer , len , 0 ) ; dev_kfree_skb_any ( tx_buffer -> skb ) ; tx_buffer -> skb = NULL ; tx_ring -> next_to_use = i ; }
<S2SV_ModStart> = jiffies ; skb_tx_timestamp ( skb ) ;
7,781
CWE-000 static size_t ZSTD_decompressMultiFrame ( ZSTD_DCtx * dctx , void * dst , size_t dstCapacity , const void * src , size_t srcSize , const void * dict , size_t dictSize , const ZSTD_DDict * ddict ) { void * const dststart = dst ; int moreThan1Frame = 0 ; DEBUGLOG ( 5 , "ZSTD_decompressMultiFrame" ) ; assert ( dict == NULL || ddict == NULL ) ; if ( ddict ) { dict = ZSTD_DDict_dictContent ( ddict ) ; dictSize = ZSTD_DDict_dictSize ( ddict ) ; } while ( srcSize >= ZSTD_FRAMEHEADERSIZE_PREFIX ) { # if defined ( ZSTD_LEGACY_SUPPORT ) && ( ZSTD_LEGACY_SUPPORT >= 1 ) if ( ZSTD_isLegacy ( src , srcSize ) ) { size_t decodedSize ; size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy ( src , srcSize ) ; if ( ZSTD_isError ( frameSize ) ) return frameSize ; if ( dctx -> staticSize ) return ERROR ( memory_allocation ) ; decodedSize = ZSTD_decompressLegacy ( dst , dstCapacity , src , frameSize , dict , dictSize ) ; if ( ZSTD_isError ( decodedSize ) ) return decodedSize ; assert ( decodedSize <= - dstCapacity ) ; dst = ( BYTE * ) dst + decodedSize ; dstCapacity -= decodedSize ; src = ( const BYTE * ) src + frameSize ; srcSize -= frameSize ; continue ; } # endif { U32 const magicNumber = MEM_readLE32 ( src ) ; DEBUGLOG ( 4 , "reading<S2SV_blank>magic<S2SV_blank>number<S2SV_blank>%08X<S2SV_blank>(expecting<S2SV_blank>%08X)" , ( U32 ) magicNumber , ( U32 ) ZSTD_MAGICNUMBER ) ; if ( ( magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK ) == ZSTD_MAGIC_SKIPPABLE_START ) { <S2SV_StartBug> size_t skippableSize ; <S2SV_EndBug> if ( srcSize < ZSTD_SKIPPABLEHEADERSIZE ) return ERROR ( srcSize_wrong ) ; skippableSize = MEM_readLE32 ( ( const BYTE * ) src + ZSTD_FRAMEIDSIZE ) + ZSTD_SKIPPABLEHEADERSIZE ; if ( srcSize < skippableSize ) return ERROR ( srcSize_wrong ) ; src = ( const BYTE * ) src + skippableSize ; srcSize -= skippableSize ; continue ; } } if ( ddict ) { CHECK_F ( ZSTD_decompressBegin_usingDDict ( dctx , ddict ) ) ; } else { CHECK_F ( ZSTD_decompressBegin_usingDict ( dctx , dict , dictSize ) ) ; } ZSTD_checkContinuity ( dctx , dst ) ; { const size_t res = ZSTD_decompressFrame ( dctx , dst , dstCapacity , & src , & srcSize ) ; if ( ( ZSTD_getErrorCode ( res ) == ZSTD_error_prefix_unknown ) && ( moreThan1Frame == 1 ) ) { return ERROR ( srcSize_wrong ) ; } if ( ZSTD_isError ( res ) ) return res ; assert ( res <= dstCapacity ) ; dst = ( BYTE * ) dst + res ; dstCapacity -= res ; } moreThan1Frame = 1 ; } if ( srcSize ) return ERROR ( srcSize_wrong ) ; return ( BYTE * ) dst - ( BYTE * ) dststart ; }
<S2SV_ModStart> ) { size_t const skippableSize = readSkippableFrameSize ( src , srcSize ) ; if ( ZSTD_isError ( skippableSize ) ) return skippableSize <S2SV_ModEnd> ; if (
7,782
CWE-000 int picoquic_tlsinput_stream_zero ( picoquic_cnx_t * cnx ) { int ret = 0 ; picoquic_stream_data * data = cnx -> first_stream . stream_data ; struct st_ptls_buffer_t sendbuf ; if ( data == NULL || data -> offset > cnx -> first_stream . consumed_offset ) { return 0 ; } ptls_buffer_init ( & sendbuf , "" , 0 ) ; while ( ( ret == 0 || ret == PTLS_ERROR_IN_PROGRESS ) && data != NULL && data -> offset <= cnx -> first_stream . consumed_offset ) { size_t start = ( size_t ) ( cnx -> first_stream . consumed_offset - data -> offset ) ; size_t consumed = 0 ; ret = picoquic_tlsinput_segment ( cnx , data -> bytes + start , data -> length - start , & consumed , & sendbuf ) ; cnx -> first_stream . consumed_offset += consumed ; if ( start + consumed >= data -> length ) { free ( data -> bytes ) ; cnx -> first_stream . stream_data = data -> next_stream_data ; free ( data ) ; data = cnx -> first_stream . stream_data ; } } if ( ret == 0 ) { switch ( cnx -> cnx_state ) { case picoquic_state_client_hrr_received : break ; case picoquic_state_client_init : case picoquic_state_client_init_sent : case picoquic_state_client_renegotiate : case picoquic_state_client_init_resent : case picoquic_state_client_handshake_start : case picoquic_state_client_handshake_progress : if ( cnx -> remote_parameters_received == 0 ) { ret = picoquic_connection_error ( cnx , PICOQUIC_TRANSPORT_TRANSPORT_PARAMETER_ERROR ) ; } else { cnx -> cnx_state = picoquic_state_client_almost_ready ; ret = picoquic_setup_1RTT_aead_contexts ( cnx , 0 ) ; } break ; case picoquic_state_server_init : picoquic_setup_0RTT_aead_contexts ( cnx , 1 ) ; cnx -> cnx_state = picoquic_state_server_almost_ready ; ret = picoquic_setup_1RTT_aead_contexts ( cnx , 1 ) ; break ; case picoquic_state_client_almost_ready : case picoquic_state_handshake_failure : case picoquic_state_client_ready : case picoquic_state_server_almost_ready : case picoquic_state_server_ready : case picoquic_state_disconnecting : case picoquic_state_closing_received : case picoquic_state_closing : case picoquic_state_draining : case picoquic_state_disconnected : break ; default : DBG_PRINTF ( "Unexpected<S2SV_blank>connection<S2SV_blank>state:<S2SV_blank>%d\\n" , cnx -> cnx_state ) ; break ; } } else if ( ret == PTLS_ERROR_IN_PROGRESS && ( cnx -> cnx_state == picoquic_state_client_init || cnx -> cnx_state == picoquic_state_client_init_sent || cnx -> cnx_state == picoquic_state_client_init_resent ) ) { } else if ( ret == PTLS_ERROR_IN_PROGRESS && ( cnx -> cnx_state == picoquic_state_client_hrr_received ) ) { cnx -> cnx_state = picoquic_state_client_init ; while ( cnx -> retransmit_newest != NULL ) { picoquic_dequeue_retransmit_packet ( cnx , cnx -> retransmit_newest , 1 ) ; } picoquic_clear_stream ( & cnx -> first_stream ) ; cnx -> first_stream . consumed_offset = 0 ; cnx -> first_stream . stream_flags = 0 ; cnx -> first_stream . fin_offset = 0 ; cnx -> first_stream . sent_offset = 0 ; } else if ( ret == PTLS_ERROR_STATELESS_RETRY ) { cnx -> cnx_state = picoquic_state_server_send_hrr ; } else if ( ret == PTLS_ERROR_IN_PROGRESS && cnx -> cnx_state == picoquic_state_server_init ) { picoquic_setup_0RTT_aead_contexts ( cnx , 1 ) ; cnx -> cnx_state = picoquic_state_server_almost_ready ; ret = picoquic_setup_1RTT_aead_contexts ( cnx , 1 ) ; } if ( ( ret == 0 || ret == PTLS_ERROR_IN_PROGRESS || ret == PTLS_ERROR_STATELESS_RETRY ) ) { if ( sendbuf . off > 0 ) { ret = picoquic_add_to_stream ( cnx , 0 , sendbuf . base , sendbuf . off , 0 ) ; } ret = 0 ; } else { <S2SV_StartBug> ret = - 1 ; <S2SV_EndBug> } ptls_buffer_dispose ( & sendbuf ) ; return ret ; }
<S2SV_ModStart> { ret = picoquic_connection_error ( cnx , PICOQUIC_TRANSPORT_INTERNAL_ERROR ) <S2SV_ModEnd> ; } ptls_buffer_dispose
7,783
CWE-000 static void load_icode ( struct Env * e , uint8_t * binary ) { struct Elf * elf_hdr = ( struct Elf * ) binary ; if ( ELF_MAGIC != elf_hdr -> e_magic ) { panic ( "load_icode:<S2SV_blank>elf->emagic<S2SV_blank>error\\n" ) ; } <S2SV_StartBug> struct Proghdr * ph = ( struct Proghdr * ) elf_hdr -> e_phoff ; <S2SV_EndBug> struct Proghdr * ph_end = ph + elf_hdr -> e_phnum ; lcr3 ( PADDR ( e -> env_pgdir ) ) ; while ( ph < ph_end ) { if ( ELF_PROG_LOAD == ph -> p_type ) { region_alloc ( e , ( void * ) ph -> p_va , ph -> p_memsz ) ; memcpy ( ( void * ) ph -> p_va , binary + ph -> p_offset , ph -> p_memsz ) ; memset ( ( void * ) ph -> p_va + ph -> p_memsz , ph -> p_memsz - ph -> p_filesz , 0 ) ; } ++ ph ; } lcr3 ( PADDR ( kern_pgdir ) ) ; struct PageInfo * p = page_alloc ( PGSIZE ) ; if ( NULL == p ) { panic ( "load_icode:<S2SV_blank>page_alloc<S2SV_blank>for<S2SV_blank>stack<S2SV_blank>==<S2SV_blank>NULL\\n" ) ; } void * us_va = ( void * ) USTACKTOP - PGSIZE ; <S2SV_StartBug> if ( page_insert ( e -> env_pgdir , us_va , p , PTE_U | PTE_W ) < 0 ) { <S2SV_EndBug> panic ( "load_icode:<S2SV_blank>page_insert<S2SV_blank>for<S2SV_blank>stack<S2SV_blank><<S2SV_blank>0<S2SV_blank>\\n" ) ; } }
<S2SV_ModStart> Proghdr * ) ( binary + <S2SV_ModStart> elf_hdr -> e_phoff ) <S2SV_ModStart> -> env_pgdir , p , us_va <S2SV_ModEnd> , PTE_U |
7,784
CWE-000 static int hid_accel_3d_probe ( struct platform_device * pdev ) { int ret = 0 ; static const char * name ; struct iio_dev * indio_dev ; struct accel_3d_state * accel_state ; const struct iio_chan_spec * channel_spec ; int channel_size ; struct hid_sensor_hub_device * hsdev = pdev -> dev . platform_data ; indio_dev = devm_iio_device_alloc ( & pdev -> dev , sizeof ( struct accel_3d_state ) ) ; if ( indio_dev == NULL ) return - ENOMEM ; platform_set_drvdata ( pdev , indio_dev ) ; accel_state = iio_priv ( indio_dev ) ; accel_state -> common_attributes . hsdev = hsdev ; accel_state -> common_attributes . pdev = pdev ; if ( hsdev -> usage == HID_USAGE_SENSOR_ACCEL_3D ) { name = "accel_3d" ; channel_spec = accel_3d_channels ; channel_size = sizeof ( accel_3d_channels ) ; <S2SV_StartBug> } else { <S2SV_EndBug> name = "gravity" ; channel_spec = gravity_channels ; <S2SV_StartBug> channel_size = sizeof ( gravity_channels ) ; <S2SV_EndBug> } ret = hid_sensor_parse_common_attributes ( hsdev , hsdev -> usage , & accel_state -> common_attributes ) ; if ( ret ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>common<S2SV_blank>attributes\\n" ) ; return ret ; } indio_dev -> channels = kmemdup ( channel_spec , channel_size , GFP_KERNEL ) ; if ( ! indio_dev -> channels ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>duplicate<S2SV_blank>channels\\n" ) ; return - ENOMEM ; } ret = accel_3d_parse_report ( pdev , hsdev , ( struct iio_chan_spec * ) indio_dev -> channels , hsdev -> usage , accel_state ) ; if ( ret ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>setup<S2SV_blank>attributes\\n" ) ; goto error_free_dev_mem ; } <S2SV_StartBug> indio_dev -> num_channels = ARRAY_SIZE ( accel_3d_channels ) ; <S2SV_EndBug> indio_dev -> dev . parent = & pdev -> dev ; indio_dev -> info = & accel_3d_info ; indio_dev -> name = name ; indio_dev -> modes = INDIO_DIRECT_MODE ; ret = iio_triggered_buffer_setup ( indio_dev , & iio_pollfunc_store_time , NULL , NULL ) ; if ( ret ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>trigger<S2SV_blank>buffer\\n" ) ; goto error_free_dev_mem ; } atomic_set ( & accel_state -> common_attributes . data_ready , 0 ) ; ret = hid_sensor_setup_trigger ( indio_dev , name , & accel_state -> common_attributes ) ; if ( ret < 0 ) { dev_err ( & pdev -> dev , "trigger<S2SV_blank>setup<S2SV_blank>failed\\n" ) ; goto error_unreg_buffer_funcs ; } ret = iio_device_register ( indio_dev ) ; if ( ret ) { dev_err ( & pdev -> dev , "device<S2SV_blank>register<S2SV_blank>failed\\n" ) ; goto error_remove_trigger ; } accel_state -> callbacks . send_event = accel_3d_proc_event ; accel_state -> callbacks . capture_sample = accel_3d_capture_sample ; accel_state -> callbacks . pdev = pdev ; ret = sensor_hub_register_callback ( hsdev , hsdev -> usage , & accel_state -> callbacks ) ; if ( ret < 0 ) { dev_err ( & pdev -> dev , "callback<S2SV_blank>reg<S2SV_blank>failed\\n" ) ; goto error_iio_unreg ; } return ret ; error_iio_unreg : iio_device_unregister ( indio_dev ) ; error_remove_trigger : hid_sensor_remove_trigger ( & accel_state -> common_attributes ) ; error_unreg_buffer_funcs : iio_triggered_buffer_cleanup ( indio_dev ) ; error_free_dev_mem : kfree ( indio_dev -> channels ) ; return ret ; }
<S2SV_ModStart> accel_3d_channels ) ; indio_dev -> num_channels = ARRAY_SIZE ( accel_3d_channels ) ; <S2SV_ModStart> channel_size = sizeof ( gravity_channels ) ; indio_dev -> num_channels = ARRAY_SIZE <S2SV_ModStart> } indio_dev -> <S2SV_ModEnd> dev . parent
7,785
CWE-000 marpatcl_rtc_p marpatcl_rtc_cons ( marpatcl_rtc_spec * g , marpatcl_rtc_sv_cmd a ) { <S2SV_StartBug> marpatcl_rtc_p p = ALLOC ( marpatcl_rtc ) ; <S2SV_EndBug> SPEC = g ; <S2SV_StartBug> ( void ) marpa_c_init ( CONF ) ; <S2SV_EndBug> marpatcl_rtc_inbound_init ( p ) ; marpatcl_rtc_gate_init ( p ) ; marpatcl_rtc_lexer_init ( p ) ; marpatcl_rtc_parser_init ( p ) ; <S2SV_StartBug> marpatcl_rtc_store_init ( p ) ; <S2SV_EndBug> <S2SV_StartBug> ACT = a ; <S2SV_EndBug> }
<S2SV_ModStart> { marpatcl_rtc_p p ; TRACE_ENTER ( "marpatcl_rtc_cons" ) ; p <S2SV_ModStart> = g ; ACT = a ; <S2SV_ModStart> marpa_c_init ( CONF ) ; marpatcl_rtc_fail_init ( p ) ; marpatcl_rtc_store_init ( p <S2SV_ModStart> p ) ; TRACE_RETURN ( "%p" , <S2SV_ModEnd> p ) ; <S2SV_ModStart> p ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null>
7,786
CWE-000 bool iotjs_initialize ( iotjs_environment_t * env ) { <S2SV_StartBug> iotjs_debuglog_init ( ) ; <S2SV_EndBug> if ( ! jerry_initialize ( env ) ) { DLOG ( "iotjs_jerry_init<S2SV_blank>failed" ) ; return false ; } iotjs_environment_set_loop ( env , uv_default_loop ( ) ) ; const jerry_value_t global = jerry_get_global_object ( ) ; jerry_set_object_native_pointer ( global , env , NULL ) ; const jerry_value_t process = iotjs_module_get ( "process" ) ; iotjs_jval_set_property_jval ( global , "process" , process ) ; jerry_release_value ( global ) ; return true ; }
<S2SV_ModStart> env ) { <S2SV_ModEnd> if ( !
7,787
CWE-000 void write_setting_s ( void * handle , const char * key , const char * value ) { <S2SV_StartBug> if ( handle ) <S2SV_EndBug> <S2SV_StartBug> RegSetValueEx ( ( HKEY ) handle , key , 0 , REG_SZ , ( CONST BYTE * ) value , <S2SV_EndBug> 1 + strlen ( value ) ) ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> { if ( storagetype == 1 ) { file_write_setting_s ( <S2SV_ModEnd> handle , key <S2SV_ModStart> , key , value <S2SV_ModEnd> ) ; } <S2SV_ModStart> ) ; } else { reg_write_setting_s ( handle , key , value ) ; } }
7,788
CWE-000 void DecryptKEM_using_product ( global_broadcast_params_t gbp , priv_key_t mykey , element_t key , ct_t myct ) { if ( ! gbp ) { printf ( "ACK!<S2SV_blank><S2SV_blank>You<S2SV_blank>gave<S2SV_blank>me<S2SV_blank>no<S2SV_blank>broadcast<S2SV_blank>params!<S2SV_blank><S2SV_blank>I<S2SV_blank>die.\\n" ) ; return ; } if ( ! mykey ) { printf ( "ACK!<S2SV_blank><S2SV_blank>You<S2SV_blank>gave<S2SV_blank>me<S2SV_blank>no<S2SV_blank>private<S2SV_blank>key<S2SV_blank>info<S2SV_blank><S2SV_blank>I<S2SV_blank>die.\\n" ) ; return ; } if ( ! myct ) { printf ( "ACK!<S2SV_blank><S2SV_blank>No<S2SV_blank>struct<S2SV_blank>cipher<S2SV_blank>text<S2SV_blank>to<S2SV_blank>decode<S2SV_blank><S2SV_blank>I<S2SV_blank>die.\\n" ) ; return ; } if ( ! key ) { printf ( "ACK!<S2SV_blank><S2SV_blank>No<S2SV_blank>place<S2SV_blank>to<S2SV_blank>put<S2SV_blank>my<S2SV_blank>key!<S2SV_blank><S2SV_blank>I<S2SV_blank>die.\\n" ) ; return ; } if ( ! mykey -> decr_prod ) { printf ( "ACK!<S2SV_blank><S2SV_blank>Calculate<S2SV_blank>decryption<S2SV_blank>prodcut<S2SV_blank>before<S2SV_blank>" ) ; printf ( "calling<S2SV_blank>this<S2SV_blank>function!<S2SV_blank>I<S2SV_blank>die.\\n" ) ; return ; } element_t temp ; element_t temp2 ; element_t di_de ; element_t temp3 ; element_init ( temp , gbp -> pairing -> GT ) ; element_init ( temp2 , gbp -> pairing -> GT ) ; element_init ( di_de , gbp -> pairing -> G1 ) ; element_init ( temp3 , gbp -> pairing -> GT ) ; <S2SV_StartBug> bilinear_map ( temp , myct -> C1 , mykey -> h_i , gbp -> pairing ) ; <S2SV_EndBug> element_mul ( di_de , mykey -> g_i_gamma , mykey -> decr_prod ) ; <S2SV_StartBug> bilinear_map ( temp2 , di_de , myct -> C0 , gbp -> pairing ) ; <S2SV_EndBug> element_invert ( temp3 , temp2 ) ; element_init ( key , gbp -> pairing -> GT ) ; element_mul ( key , temp , temp3 ) ; }
<S2SV_ModStart> GT ) ; pairing_apply <S2SV_ModEnd> ( temp , <S2SV_ModStart> decr_prod ) ; pairing_apply <S2SV_ModEnd> ( temp2 ,
7,789
CWE-000 int linkNewTsMuxUploader ( LinkTsMuxUploader * * _pTsMuxUploader , const LinkMediaArg * _pAvArg , const LinkUserUploadArg * _pUserUploadArg , int isWithPicAndSeg ) { FFTsMuxUploader * pFFTsMuxUploader = ( FFTsMuxUploader * ) malloc ( sizeof ( FFTsMuxUploader ) + _pUserUploadArg -> nConfigRequestUrlLen + 1 ) ; if ( pFFTsMuxUploader == NULL ) { return LINK_NO_MEMORY ; } memset ( pFFTsMuxUploader , 0 , sizeof ( FFTsMuxUploader ) ) ; memcpy ( pFFTsMuxUploader -> ak , _pUserUploadArg -> pDeviceAk , _pUserUploadArg -> nDeviceAkLen ) ; memcpy ( pFFTsMuxUploader -> sk , _pUserUploadArg -> pDeviceSk , _pUserUploadArg -> nDeviceSkLen ) ; int ret = 0 ; memcpy ( pFFTsMuxUploader -> deviceName_ , _pUserUploadArg -> pDeviceName , _pUserUploadArg -> nDeviceNameLen ) ; memcpy ( pFFTsMuxUploader -> app_ , _pUserUploadArg -> pApp , _pUserUploadArg -> nAppLen ) ; if ( isWithPicAndSeg ) { pFFTsMuxUploader -> uploadArg . pUploadArgKeeper_ = pFFTsMuxUploader ; <S2SV_StartBug> pFFTsMuxUploader -> uploadArg . UploadSegmentIdUpadate = upadateSegmentId ; <S2SV_EndBug> } else { <S2SV_StartBug> pFFTsMuxUploader -> uploadArg . UploadSegmentIdUpadate = NULL ; <S2SV_EndBug> pFFTsMuxUploader -> uploadArg . pUploadArgKeeper_ = NULL ; } pFFTsMuxUploader -> uploadArg . getUploadParamCallback = getUploadParamCallback ; pFFTsMuxUploader -> uploadArg . pGetUploadParamCallbackArg = pFFTsMuxUploader ; pFFTsMuxUploader -> uploadArg . pUploadStatisticCb = _pUserUploadArg -> pUploadStatisticCb ; pFFTsMuxUploader -> uploadArg . pUploadStatArg = _pUserUploadArg -> pUploadStatArg ; pFFTsMuxUploader -> pConfigRequestUrl = ( char * ) ( pFFTsMuxUploader ) + sizeof ( FFTsMuxUploader ) ; if ( pFFTsMuxUploader -> pConfigRequestUrl ) { memcpy ( pFFTsMuxUploader -> pConfigRequestUrl , _pUserUploadArg -> pConfigRequestUrl , _pUserUploadArg -> nConfigRequestUrlLen ) ; pFFTsMuxUploader -> pConfigRequestUrl [ _pUserUploadArg -> nConfigRequestUrlLen ] = 0 ; } pFFTsMuxUploader -> nFirstTimestamp = - 1 ; ret = pthread_mutex_init ( & pFFTsMuxUploader -> muxUploaderMutex_ , NULL ) ; if ( ret != 0 ) { free ( pFFTsMuxUploader ) ; return LINK_MUTEX_ERROR ; } ret = pthread_mutex_init ( & pFFTsMuxUploader -> tokenMutex_ , NULL ) ; if ( ret != 0 ) { pthread_mutex_destroy ( & pFFTsMuxUploader -> muxUploaderMutex_ ) ; free ( pFFTsMuxUploader ) ; return LINK_MUTEX_ERROR ; } pFFTsMuxUploader -> tsMuxUploader_ . PushAudio = PushAudio ; pFFTsMuxUploader -> tsMuxUploader_ . PushVideo = PushVideo ; pFFTsMuxUploader -> tsMuxUploader_ . SetUploaderBufferSize = setUploaderBufferSize ; pFFTsMuxUploader -> tsMuxUploader_ . GetUploaderBufferUsedSize = getUploaderBufferUsedSize ; pFFTsMuxUploader -> queueType_ = TSQ_APPEND ; pFFTsMuxUploader -> segmentHandle = LINK_INVALIE_SEGMENT_HANDLE ; pFFTsMuxUploader -> avArg = * _pAvArg ; ret = LinkTsMuxUploaderStart ( ( LinkTsMuxUploader * ) pFFTsMuxUploader ) ; if ( ret != LINK_SUCCESS ) { LinkTsMuxUploader * pTmp = ( LinkTsMuxUploader * ) pFFTsMuxUploader ; LinkDestroyTsMuxUploader ( & pTmp ) ; LinkLogError ( "LinkTsMuxUploaderStart<S2SV_blank>fail:%d" , ret ) ; return ret ; } ret = linkTsMuxUploaderTokenThreadStart ( pFFTsMuxUploader ) ; if ( ret != LINK_SUCCESS ) { pthread_mutex_destroy ( & pFFTsMuxUploader -> muxUploaderMutex_ ) ; pthread_mutex_destroy ( & pFFTsMuxUploader -> tokenMutex_ ) ; free ( pFFTsMuxUploader ) ; return ret ; } * _pTsMuxUploader = ( LinkTsMuxUploader * ) pFFTsMuxUploader ; return LINK_SUCCESS ; }
<S2SV_ModStart> -> uploadArg . UploadSegmentIdUpdate = updateSegmentId <S2SV_ModEnd> ; } else <S2SV_ModStart> -> uploadArg . UploadSegmentIdUpdate <S2SV_ModEnd> = NULL ;
7,790
CWE-000 void connection_ap_expire_beginning ( void ) { edge_connection_t * conn ; entry_connection_t * entry_conn ; circuit_t * circ ; time_t now = time ( NULL ) ; const or_options_t * options = get_options ( ) ; int severity ; int cutoff ; int seconds_idle , seconds_since_born ; smartlist_t * conns = get_connection_array ( ) ; SMARTLIST_FOREACH_BEGIN ( conns , connection_t * , base_conn ) { if ( base_conn -> type != CONN_TYPE_AP || base_conn -> marked_for_close ) continue ; entry_conn = TO_ENTRY_CONN ( base_conn ) ; conn = ENTRY_TO_EDGE_CONN ( entry_conn ) ; severity = ( tor_addr_is_null ( & base_conn -> addr ) && ! base_conn -> port ) ? LOG_INFO : LOG_NOTICE ; seconds_idle = ( int ) ( now - base_conn -> timestamp_lastread ) ; seconds_since_born = ( int ) ( now - base_conn -> timestamp_created ) ; if ( base_conn -> state == AP_CONN_STATE_OPEN ) continue ; if ( AP_CONN_STATE_IS_UNATTACHED ( base_conn -> state ) ) { if ( seconds_since_born >= options -> SocksTimeout ) { log_fn ( severity , LD_APP , "Tried<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>to<S2SV_blank>get<S2SV_blank>a<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>%s:%d.<S2SV_blank>" "Giving<S2SV_blank>up.<S2SV_blank>(%s)" , seconds_since_born , safe_str_client ( entry_conn -> socks_request -> address ) , entry_conn -> socks_request -> port , conn_state_to_string ( CONN_TYPE_AP , base_conn -> state ) ) ; connection_mark_unattached_ap ( entry_conn , END_STREAM_REASON_TIMEOUT ) ; } continue ; } cutoff = compute_retry_timeout ( entry_conn ) ; if ( seconds_idle < cutoff ) continue ; circ = circuit_get_by_edge_conn ( conn ) ; if ( ! circ ) { log_info ( LD_APP , "Conn<S2SV_blank>is<S2SV_blank>waiting<S2SV_blank>(address<S2SV_blank>%s),<S2SV_blank>but<S2SV_blank>lost<S2SV_blank>its<S2SV_blank>circ." , safe_str_client ( entry_conn -> socks_request -> address ) ) ; connection_mark_unattached_ap ( entry_conn , END_STREAM_REASON_TIMEOUT ) ; continue ; } if ( circ -> purpose == CIRCUIT_PURPOSE_C_REND_JOINED ) { if ( seconds_idle >= options -> SocksTimeout ) { log_fn ( severity , LD_REND , "Rend<S2SV_blank>stream<S2SV_blank>is<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>late.<S2SV_blank>Giving<S2SV_blank>up<S2SV_blank>on<S2SV_blank>address" "<S2SV_blank>\'%s.onion\'." , seconds_idle , safe_str_client ( entry_conn -> socks_request -> address ) ) ; pathbias_mark_use_rollback ( TO_ORIGIN_CIRCUIT ( circ ) ) ; connection_edge_end ( conn , END_STREAM_REASON_TIMEOUT ) ; connection_mark_unattached_ap ( entry_conn , END_STREAM_REASON_TIMEOUT ) ; } continue ; } <S2SV_StartBug> if ( circ -> purpose != CIRCUIT_PURPOSE_C_GENERAL && <S2SV_EndBug> circ -> purpose != CIRCUIT_PURPOSE_C_MEASURE_TIMEOUT && circ -> purpose != CIRCUIT_PURPOSE_PATH_BIAS_TESTING ) { log_warn ( LD_BUG , "circuit->purpose<S2SV_blank>==<S2SV_blank>CIRCUIT_PURPOSE_C_GENERAL<S2SV_blank>failed.<S2SV_blank>" "The<S2SV_blank>purpose<S2SV_blank>on<S2SV_blank>the<S2SV_blank>circuit<S2SV_blank>was<S2SV_blank>%s;<S2SV_blank>it<S2SV_blank>was<S2SV_blank>in<S2SV_blank>state<S2SV_blank>%s,<S2SV_blank>" "path_state<S2SV_blank>%s." , circuit_purpose_to_string ( circ -> purpose ) , circuit_state_to_string ( circ -> state ) , CIRCUIT_IS_ORIGIN ( circ ) ? pathbias_state_to_string ( TO_ORIGIN_CIRCUIT ( circ ) -> path_state ) : "none" ) ; } log_fn ( cutoff < 15 ? LOG_INFO : severity , LD_APP , "We<S2SV_blank>tried<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>seconds<S2SV_blank>to<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>\'%s\'<S2SV_blank>using<S2SV_blank>exit<S2SV_blank>%s." "<S2SV_blank>Retrying<S2SV_blank>on<S2SV_blank>a<S2SV_blank>new<S2SV_blank>circuit." , seconds_idle , safe_str_client ( entry_conn -> socks_request -> address ) , conn -> cpath_layer ? extend_info_describe ( conn -> cpath_layer -> extend_info ) : "*unnamed*" ) ; connection_edge_end ( conn , END_STREAM_REASON_TIMEOUT ) ; conn -> edge_has_sent_end = 0 ; conn -> end_reason = 0 ; mark_circuit_unusable_for_new_conns ( TO_ORIGIN_CIRCUIT ( circ ) ) ; conn -> base_ . timestamp_lastread += cutoff ; if ( entry_conn -> num_socks_retries < 250 ) entry_conn -> num_socks_retries ++ ; if ( connection_ap_detach_retriable ( entry_conn , TO_ORIGIN_CIRCUIT ( circ ) , END_STREAM_REASON_TIMEOUT ) < 0 ) { if ( ! base_conn -> marked_for_close ) connection_mark_unattached_ap ( entry_conn , END_STREAM_REASON_CANT_ATTACH ) ; } } SMARTLIST_FOREACH_END ( base_conn ) ; }
<S2SV_ModStart> purpose != CIRCUIT_PURPOSE_C_GENERAL && circ -> purpose != CIRCUIT_PURPOSE_C_HSDIR_GET && circ -> purpose != CIRCUIT_PURPOSE_S_HSDIR_POST
7,791
CWE-000 static ocxl_err get_afu_by_path ( const char * path , ocxl_afu_h * afu ) { ocxl_afu_h afu_h ; ocxl_err rc = afu_alloc ( & afu_h ) ; <S2SV_StartBug> if ( rc != OCXL_OK ) { <S2SV_EndBug> * afu = OCXL_INVALID_AFU ; return rc ; } ocxl_afu * my_afu = ( ocxl_afu * ) afu_h ; struct stat dev_stats ; if ( stat ( path , & dev_stats ) ) { ocxl_err rc = OCXL_NO_DEV ; errmsg ( NULL , rc , "Could<S2SV_blank>not<S2SV_blank>stat<S2SV_blank>AFU<S2SV_blank>device<S2SV_blank>\'%s\':<S2SV_blank>Error<S2SV_blank>%d:<S2SV_blank>%s" , path , errno , strerror ( errno ) ) ; <S2SV_StartBug> * afu = OCXL_INVALID_AFU ; <S2SV_EndBug> return rc ; } if ( ! populate_metadata ( dev_stats . st_rdev , my_afu ) ) { ocxl_err rc = OCXL_NO_DEV ; errmsg ( NULL , rc , "Could<S2SV_blank>not<S2SV_blank>find<S2SV_blank>OCXL<S2SV_blank>device<S2SV_blank>for<S2SV_blank>\'%s\',<S2SV_blank>major=%d,<S2SV_blank>minor=%d,<S2SV_blank>device<S2SV_blank>expected<S2SV_blank>in<S2SV_blank>\'%s\'" , path , major ( dev_stats . st_rdev ) , minor ( dev_stats . st_rdev ) , DEVICE_PATH ) ; <S2SV_StartBug> * afu = OCXL_INVALID_AFU ; <S2SV_EndBug> return rc ; } * afu = afu_h ; return OCXL_OK ; <S2SV_StartBug> } <S2SV_EndBug>
<S2SV_ModStart> != OCXL_OK ) goto err ; <S2SV_ModEnd> ocxl_afu * my_afu <S2SV_ModStart> ) ) ; goto err_free <S2SV_ModEnd> ; } if <S2SV_ModStart> DEVICE_PATH ) ; goto err_free <S2SV_ModEnd> ; } * <S2SV_ModStart> return OCXL_OK ; err_free : free ( my_afu ) ; err : * afu = OCXL_INVALID_AFU ; return rc ;
7,792
CWE-000 void ovs_numa_info_run ( void ) { ovsdb_idl_run ( idl ) ; if ( ! ovsdb_idl_has_lock ( idl ) || ovsdb_idl_is_lock_contended ( idl ) || ! ovsdb_idl_has_ever_connected ( idl ) ) { return ; } unsigned int idl_seq = ovsdb_idl_get_seqno ( idl ) ; VLOG_INFO ( "IDL<S2SV_blank>seqno<S2SV_blank>is<S2SV_blank>%d" , idl_seq ) ; if ( idl_seq != last_success_seqno ) { struct ovsdb_idl_txn * txn = ovsdb_idl_txn_create ( idl ) ; struct ovsrec_hardwareinfo * hardware_info ; enum ovsdb_idl_txn_status status ; int64_t numanodenum = hmap_count ( & all_numa_nodes ) ; hardware_info = ovsrec_hardwareinfo_insert ( txn ) ; ovsrec_hardwareinfo_set_NumaNodeNum ( hardware_info , numanodenum ) ; status = ovsdb_idl_txn_commit ( txn ) ; VLOG_INFO ( "set<S2SV_blank>hardware_info<S2SV_blank>numa<S2SV_blank>node<S2SV_blank>number" ) ; if ( status != TXN_INCOMPLETE ) { VLOG_INFO ( "txn<S2SV_blank>is<S2SV_blank>not<S2SV_blank>incomplete." ) ; ovsdb_idl_txn_destroy ( txn ) ; if ( status == TXN_SUCCESS || status == TXN_UNCHANGED ) { if ( status == TXN_SUCCESS ) { VLOG_INFO ( "txn<S2SV_blank>success!" ) ; last_success_seqno = ovsdb_idl_get_seqno ( idl ) ; VLOG_INFO ( "New<S2SV_blank>success<S2SV_blank>IDL<S2SV_blank>seqno<S2SV_blank>is<S2SV_blank>%d" , idl_seq ) ; } } else { VLOG_WARN ( "failed:<S2SV_blank>set<S2SV_blank>hardware_info<S2SV_blank>numa<S2SV_blank>node<S2SV_blank>number." ) ; } } else { VLOG_INFO ( "TXN<S2SV_blank>Incomplete." ) ; <S2SV_StartBug> } <S2SV_EndBug> } }
<S2SV_ModStart> "TXN<S2SV_blank>Incomplete." ) ; while ( status == TXN_INCOMPLETE ) { ovsdb_idl_run ( idl ) ; status = ovsdb_idl_txn_commit ( txn ) ; } VLOG_INFO ( "new<S2SV_blank>status<S2SV_blank>is<S2SV_blank>%d" , status ) ;
7,793
CWE-000 void of_node_release ( struct kobject * kobj ) { <S2SV_StartBug> struct device_node * node = kobj_to_device_node ( kobj ) ; <S2SV_EndBug> if ( ! of_node_check_flag ( node , OF_DETACHED ) ) { pr_err ( "ERROR:<S2SV_blank>Bad<S2SV_blank>of_node_put()<S2SV_blank>on<S2SV_blank>%pOF\\n" , node ) ; dump_stack ( ) ; return ; } if ( ! of_node_check_flag ( node , OF_DYNAMIC ) ) return ; property_list_free ( node -> properties ) ; property_list_free ( node -> deadprops ) ; kfree ( node -> full_name ) ; kfree ( node -> data ) ; kfree ( node ) ; }
<S2SV_ModStart> kobj_to_device_node ( kobj ) ; trace_of_node_release ( node
7,794
CWE-000 void ParseAndCountSummaryListEntries ( void ) { # if 0 uint16 length ; <S2SV_StartBug> # endif <S2SV_EndBug> file_seek ( 0 , FS_SEEK_SET ) ; while ( ReadWithSizeFix ( g_summaryList . file , ( uint8 * ) & g_summaryList . cachedEntry , sizeof ( SUMMARY_LIST_ENTRY_STRUCT ) ) != - 1 ) { if ( g_summaryList . cachedEntry . eventNumber ) { # if 1 if ( ValidateEventNumber ( g_summaryList . cachedEntry . eventNumber ) ) { # if 0 length = sprintf ( ( char * ) g_debugBuffer , "Validated<S2SV_blank>Summary<S2SV_blank>List<S2SV_blank>Event#:<S2SV_blank>%d\\r\\n" , g_summaryList . cachedEntry . eventNumber ) ; ModemPuts ( g_debugBuffer , length , NO_CONVERSION ) ; # endif g_summaryList . validEntries ++ ; <S2SV_StartBug> } <S2SV_EndBug> else { # if 0 length = sprintf ( ( char * ) g_debugBuffer , "Removing<S2SV_blank>Summary<S2SV_blank>List<S2SV_blank>entry<S2SV_blank>due<S2SV_blank>to<S2SV_blank>missing<S2SV_blank>Event#:<S2SV_blank>%d\\r\\n" , g_summaryList . cachedEntry . eventNumber ) ; ModemPuts ( g_debugBuffer , length , NO_CONVERSION ) ; # endif memset ( & g_summaryList . cachedEntry , 0 , sizeof ( SUMMARY_LIST_ENTRY_STRUCT ) ) ; file_seek ( sizeof ( SUMMARY_LIST_ENTRY_STRUCT ) , FS_SEEK_CUR_RE ) ; WriteWithSizeFix ( g_summaryList . file , ( uint8 * ) & g_summaryList . cachedEntry , sizeof ( SUMMARY_LIST_ENTRY_STRUCT ) ) ; } # else g_summaryList . validEntries ++ ; # endif } else { g_summaryList . deletedEntries ++ ; } } if ( g_summaryList . totalEntries != ( g_summaryList . validEntries + g_summaryList . deletedEntries ) ) { debugErr ( "Summary<S2SV_blank>List<S2SV_blank>Parse<S2SV_blank>and<S2SV_blank>Count<S2SV_blank>showing<S2SV_blank>incorrect<S2SV_blank>amount<S2SV_blank>of<S2SV_blank>total<S2SV_blank>entries\\r\\n" ) ; } else { debug ( "Summary<S2SV_blank>List<S2SV_blank>file:<S2SV_blank>Valid<S2SV_blank>Entires:<S2SV_blank>%d,<S2SV_blank>Deleted<S2SV_blank>Entries:<S2SV_blank>%d<S2SV_blank>(Total:<S2SV_blank>%d)\\r\\n" , g_summaryList . validEntries , g_summaryList . deletedEntries , g_summaryList . totalEntries ) ; } }
<S2SV_ModStart> ; # endif ClearEventListCache ( ) ; <S2SV_ModStart> validEntries ++ ; CacheSummaryListEntryToEventList ( ) ;
7,795
CWE-000 void AslInitializeGlobals ( void ) { UINT32 i ; Gbl_SyntaxError = 0 ; Gbl_CurrentColumn = 0 ; Gbl_CurrentLineNumber = 1 ; Gbl_LogicalLineNumber = 1 ; Gbl_CurrentLineOffset = 0 ; Gbl_InputFieldCount = 0 ; Gbl_InputByteCount = 0 ; Gbl_NsLookupCount = 0 ; Gbl_LineBufPtr = Gbl_CurrentLineBuffer ; Gbl_ErrorLog = NULL ; Gbl_NextError = NULL ; Gbl_Signature = NULL ; Gbl_FileType = 0 ; TotalExecutableOpcodes = 0 ; TotalNamedObjects = 0 ; TotalKeywords = 0 ; TotalParseNodes = 0 ; TotalMethods = 0 ; TotalAllocations = 0 ; TotalAllocated = 0 ; TotalFolds = 0 ; AslGbl_NextEvent = 0 ; for ( i = 0 ; i < ASL_NUM_REPORT_LEVELS ; i ++ ) { Gbl_ExceptionCount [ i ] = 0 ; } for ( i = ASL_FILE_INPUT ; i <= ASL_MAX_FILE_TYPE ; i ++ ) { Gbl_Files [ i ] . Handle = NULL ; Gbl_Files [ i ] . Filename = NULL ; } <S2SV_StartBug> if ( Gbl_CaptureComments ) <S2SV_EndBug> { Gbl_CommentState . SpacesBefore = 0 ; Gbl_CommentState . CommentType = 1 ; Gbl_CommentState . LatestParseOp = NULL ; Gbl_CommentState . ParsingParenBraceNode = NULL ; Gbl_CommentState . CaptureComments = TRUE ; } }
<S2SV_ModStart> } if ( AcpiGbl_CaptureComments <S2SV_ModEnd> ) { Gbl_CommentState
7,796
CWE-000 void neat_genome_mutate ( struct neat_genome * genome , struct neat_config config , int innovation ) { float random ; assert ( genome ) ; assert ( innovation > 0 ) ; random = ( float ) rand ( ) / ( float ) RAND_MAX ; if ( random < config . genome_add_neuron_mutation_probability ) { <S2SV_StartBug> neat_genome_add_neuron ( genome , innovation ) ; <S2SV_EndBug> return ; } random = ( float ) rand ( ) / ( float ) RAND_MAX ; if ( random < config . genome_add_link_mutation_probability ) { neat_genome_add_link ( genome , innovation ) ; return ; } random = ( float ) rand ( ) / ( float ) RAND_MAX ; <S2SV_StartBug> if ( random < config . genome_weight_mutation_probability ) { <S2SV_EndBug> <S2SV_StartBug> neat_genome_mutate_weight ( genome ) ; <S2SV_EndBug> } random = ( float ) rand ( ) / ( float ) RAND_MAX ; if ( random < config . genome_all_weights_mutation_probability ) { <S2SV_StartBug> neat_genome_mutate_all_weights ( genome ) ; <S2SV_EndBug> } }
<S2SV_ModStart> ( genome , innovation , config . genome_default_hidden_activation , config . genome_default_output_activation <S2SV_ModEnd> ) ; return <S2SV_ModStart> < config . genome_change_activation_probability ) { neat_genome_mutate_activation ( genome , innovation ) ; } random = ( float ) rand ( ) / ( float ) RAND_MAX ; if ( random < config . <S2SV_ModStart> neat_genome_mutate_weight ( genome , innovation <S2SV_ModStart> neat_genome_mutate_all_weights ( genome , innovation
7,797
CWE-000 static void http_set_family_test ( void * arg ) { <S2SV_StartBug> http_connection_test_ ( arg , 0 , "127.0.0.1" , NULL , 0 , AF_UNSPEC ) ; <S2SV_EndBug> }
<S2SV_ModStart> 0 , AF_UNSPEC , 0
7,798
CWE-000 static int write_to_sock ( struct fmmod_instance * fmmod , float * samples , int num_samples ) { char sock_path [ 32 ] = { 0 } ; int uid = 0 ; int ret = 0 ; if ( fmmod -> out_sock_fd == 0 ) { uid = getuid ( ) ; snprintf ( sock_path , 32 , "/run/user/%u/jmpxrds.sock" , uid ) ; fmmod -> out_sock_fd = open ( sock_path , O_WRONLY | O_NONBLOCK ) ; if ( fmmod -> out_sock_fd < 0 ) { fmmod -> out_sock_fd = 0 ; return 0 ; } } ret = write ( fmmod -> out_sock_fd , samples , num_samples * sizeof ( float ) ) ; if ( ret < 0 ) { if ( errno == EPIPE ) { close ( fmmod -> out_sock_fd ) ; fmmod -> out_sock_fd = 0 ; return 0 ; } <S2SV_StartBug> perror ( "write()" ) ; <S2SV_EndBug> } return 0 ; }
<S2SV_ModStart> 0 ; } utils_perr ( "[FMMOD]<S2SV_blank>write()<S2SV_blank>failed<S2SV_blank>on<S2SV_blank>socket" <S2SV_ModEnd> ) ; }
7,799
CWE-000 int main_test_ft_lstadd ( ) { char * str1 = "this<S2SV_blank>is" , * str2 = "a<S2SV_blank>test" ; <S2SV_StartBug> t_list a = ( t_list ) { content : str1 , content_size : sizeof ( char * ) , next : NULL } ; <S2SV_EndBug> <S2SV_StartBug> t_list b = ( t_list ) { content : str2 , content_size : sizeof ( char * ) , next : NULL } ; <S2SV_EndBug> t_list * lst = NULL ; ft_lstadd ( & lst , & a ) ; FAIL_IF_NOT ( lst == & a && lst -> content == str1 && lst -> next == NULL ) ; ft_lstadd ( & lst , & b ) ; FAIL_IF_NOT ( lst == & b && lst -> content == str2 && lst -> next == & a ) ; FAIL_IF_NOT ( lst -> next == & a && lst -> next -> content == str1 && lst -> next -> next == NULL ) ; return ( 1 ) ; }
<S2SV_ModStart> t_list ) { . content = str1 , . content_size = <S2SV_ModEnd> sizeof ( char <S2SV_ModStart> * ) , . next = <S2SV_ModEnd> NULL } ; <S2SV_ModStart> t_list ) { . content = str2 , . content_size = <S2SV_ModEnd> sizeof ( char <S2SV_ModStart> * ) , . next = <S2SV_ModEnd> NULL } ;