Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
200 | CWE-000 int ft_fill_dist ( t_label * req , t_label * first , t_error * * error ) { t_label * decl ; int ret ; <S2SV_StartBug> ret = 1 ; <S2SV_EndBug> while ( req ) { decl = first ; while ( decl ) { if ( ! ft_strcmp ( req -> name , decl -> name ) ) { req -> dist = decl -> dist - req -> dist ; break ; } decl = decl -> next ; } if ( ! decl ) <S2SV_StartBug> ret = ft_error ( ft_strdup ( req -> line ) , <S2SV_EndBug> ft_strdup ( "Label<S2SV_blank>requested<S2SV_blank>not<S2SV_blank>declared" ) , req -> line_nb , error ) ; <S2SV_StartBug> req = req -> next ; <S2SV_EndBug> } return ( ret ) ; } | <S2SV_ModStart> ; ret = 0 <S2SV_ModEnd> ; while ( <S2SV_ModStart> decl ) ret += <S2SV_ModEnd> ft_error ( ft_strdup <S2SV_ModStart> error ) ; if ( ret > 19 ) return ( ret ) ; |
201 | CWE-000 int readc ( int h , char * c ) { unsigned short int i , j , device , newbl , end_formatted_bl ; unsigned short int rc ; unsigned int offset , file_len , next_bl ; i = get_boot_drive ( ) ; if ( i == 0xAAAA ) device = 0 ; else device = 0x80 ; if ( FCB [ 0 ] ) { if ( FCB [ 2 ] == 0 ) return - 1 ; offset = ( FCB [ 4 ] << 16 ) | FCB [ 3 ] ; file_len = ( FCB [ 7 ] << 16 ) | FCB [ 6 ] ; if ( offset >= file_len ) return - 1 ; <S2SV_StartBug> if ( ( offset % 499 ) || ( offset == 0 ) ) <S2SV_EndBug> { rc = secread ( device , FCB [ 2 ] , g_buffer512 ) ; if ( rc != 1 ) { puts0 ( "Sec<S2SV_blank>read<S2SV_blank>error!\\r\\n" ) ; return - 1 ; } <S2SV_StartBug> * c = g_buffer512 [ offset % 499 + 3 ] ; <S2SV_EndBug> offset ++ ; FCB [ 3 ] = offset ; FCB [ 4 ] = offset >> 16 ; } else { rc = secread ( device , FCB [ 2 ] , g_buffer512 ) ; if ( rc != 1 ) { puts0 ( "Sec<S2SV_blank>read<S2SV_blank>error!\\r\\n" ) ; return - 1 ; } next_bl = g_buffer512 [ 2 ] ; next_bl = next_bl << 8 | g_buffer512 [ 1 ] ; if ( next_bl == 0 ) return - 1 ; FCB [ 2 ] = next_bl ; rc = secread ( device , FCB [ 2 ] , g_buffer512 ) ; if ( rc != 1 ) { puts0 ( "Sec<S2SV_blank>read<S2SV_blank>error!\\r\\n" ) ; return - 1 ; } <S2SV_StartBug> * c = g_buffer512 [ offset % 499 + 3 ] ; <S2SV_EndBug> offset ++ ; FCB [ 3 ] = offset ; FCB [ 4 ] = offset >> 16 ; } return 0 ; } else return - 1 ; } | <S2SV_ModStart> ( offset % CARGO <S2SV_ModEnd> ) || ( <S2SV_ModStart> [ offset % CARGO <S2SV_ModEnd> + 3 ] <S2SV_ModStart> [ offset % CARGO <S2SV_ModEnd> + 3 ] |
202 | CWE-000 <S2SV_StartBug> alpha_beta alpha_beta_min ( int depth , int alpha , int beta , maze_struct * maze ) <S2SV_EndBug> { alpha_beta ret_val , temp ; pos base_position ; base_position . x = 0 ; base_position . y = 0 ; ret_val . current = base_position ; ret_val . move = base_position ; if ( depth > MAX_DEPTH ) { ret_val . heuristic = utility ( maze ) ; return ret_val ; } int i , j , k , l ; int pieces_length ; pos * pieces = NULL ; pos possible_moves [ 3 ] ; pos move ; move . x = - 999 ; move . y = - 999 ; for ( i = 0 ; i < 3 ; ++ i ) { possible_moves [ i ] = move ; } <S2SV_StartBug> ret_val . heuristic = INFINITY ; <S2SV_EndBug> if ( maze -> turn % 2 == WHITE ) { if ( depth % 2 == 0 ) { pieces = ( pos * ) maze -> white_pieces ; pieces_length = maze -> white_pieces_length ; } else { pieces = ( pos * ) maze -> black_pieces ; pieces_length = maze -> black_pieces_length ; } } else { if ( depth % 2 == 0 ) { pieces = ( pos * ) maze -> black_pieces ; pieces_length = maze -> black_pieces_length ; } else { pieces = ( pos * ) maze -> white_pieces ; pieces_length = maze -> white_pieces_length ; } } char backup [ 8 ] [ 8 ] ; for ( i = 0 ; i < pieces_length ; ++ i ) { possible_actions ( pieces [ i ] , possible_moves , maze ) ; for ( j = 0 ; j < 3 ; ++ j ) { move = possible_moves [ j ] ; if ( move . x < 0 ) { continue ; } for ( k = 0 ; k < 8 ; ++ k ) { for ( l = 0 ; l < 8 ; ++ l ) { backup [ k ] [ l ] = maze -> array [ k ] [ l ] ; } } temp = alpha_beta_max ( depth + 1 , alpha , beta , maze ) ; if ( temp . heuristic < ret_val . heuristic ) { ret_val . heuristic = temp . heuristic ; ret_val . current = pieces [ i ] ; ret_val . move = possible_moves [ j ] ; } for ( k = 0 ; k < 8 ; ++ k ) { for ( l = 0 ; l < 8 ; ++ l ) { backup [ k ] [ l ] = maze -> array [ k ] [ l ] ; } } if ( ret_val . heuristic <= alpha ) { return ret_val ; } beta = min ( beta , ret_val . heuristic ) ; } } return ret_val ; } | <S2SV_ModStart> int depth , float alpha , float <S2SV_ModEnd> beta , maze_struct <S2SV_ModStart> . heuristic = FLT_MAX <S2SV_ModEnd> ; if ( |
203 | CWE-000 static size_t rmnet_get_size ( const struct net_device * dev ) { <S2SV_StartBug> return nla_total_size ( 2 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( 2 ) + nla_total_size ( sizeof ( struct ifla_vlan_flags ) ) |
204 | CWE-000 static int acpi_add_single_object ( struct acpi_device * * child , acpi_handle handle , int type , unsigned long long sta ) { int result ; struct acpi_device * device ; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER , NULL } ; device = kzalloc ( sizeof ( struct acpi_device ) , GFP_KERNEL ) ; if ( ! device ) { printk ( KERN_ERR PREFIX "Memory<S2SV_blank>allocation<S2SV_blank>error\\n" ) ; return - ENOMEM ; } acpi_init_device_object ( device , handle , type , sta ) ; if ( type == ACPI_BUS_TYPE_DEVICE ) <S2SV_StartBug> acpi_bus_get_status ( device ) ; <S2SV_EndBug> acpi_bus_get_power_flags ( device ) ; acpi_bus_get_wakeup_device_flags ( device ) ; result = acpi_device_add ( device , acpi_device_release ) ; if ( result ) { acpi_device_release ( & device -> dev ) ; return result ; } acpi_power_add_remove_device ( device , true ) ; acpi_device_add_finalize ( device ) ; acpi_get_name ( handle , ACPI_FULL_PATHNAME , & buffer ) ; ACPI_DEBUG_PRINT ( ( ACPI_DB_INFO , "Added<S2SV_blank>%s<S2SV_blank>[%s]<S2SV_blank>parent<S2SV_blank>%s\\n" , dev_name ( & device -> dev ) , ( char * ) buffer . pointer , device -> parent ? dev_name ( & device -> parent -> dev ) : "(null)" ) ) ; kfree ( buffer . pointer ) ; * child = device ; return 0 ; } | <S2SV_ModStart> == ACPI_BUS_TYPE_DEVICE ) if ( <S2SV_ModStart> acpi_bus_get_status ( device ) < 0 ) acpi_set_device_status ( device , 0 |
205 | CWE-000 static int __wlan_hdd_cfg80211_get_key ( struct wiphy * wiphy , struct net_device * ndev , u8 key_index , bool pairwise , const u8 * mac_addr , void * cookie , void ( * callback ) ( void * cookie , struct key_params * ) ) { hdd_adapter_t * pAdapter = WLAN_HDD_GET_PRIV_PTR ( ndev ) ; hdd_wext_state_t * pWextState = WLAN_HDD_GET_WEXT_STATE_PTR ( pAdapter ) ; tCsrRoamProfile * pRoamProfile = & ( pWextState -> roamProfile ) ; struct key_params params ; ENTER ( ) ; if ( QDF_GLOBAL_FTM_MODE == hdd_get_conparam ( ) ) { hdd_err ( "Command<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>in<S2SV_blank>FTM<S2SV_blank>mode" ) ; return - EINVAL ; } <S2SV_StartBug> hdd_debug ( "Device_mode<S2SV_blank>%s(%d)" , <S2SV_EndBug> hdd_device_mode_to_string ( pAdapter -> device_mode ) , pAdapter -> device_mode ) ; memset ( & params , 0 , sizeof ( params ) ) ; if ( CSR_MAX_NUM_KEY <= key_index ) { <S2SV_StartBug> hdd_err ( "Invalid<S2SV_blank>key<S2SV_blank>index:<S2SV_blank>%d" , key_index ) ; <S2SV_EndBug> return - EINVAL ; } switch ( pRoamProfile -> EncryptionType . encryptionType [ 0 ] ) { case eCSR_ENCRYPT_TYPE_NONE : params . cipher = IW_AUTH_CIPHER_NONE ; break ; case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY : case eCSR_ENCRYPT_TYPE_WEP40 : params . cipher = WLAN_CIPHER_SUITE_WEP40 ; break ; case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY : case eCSR_ENCRYPT_TYPE_WEP104 : params . cipher = WLAN_CIPHER_SUITE_WEP104 ; break ; case eCSR_ENCRYPT_TYPE_TKIP : params . cipher = WLAN_CIPHER_SUITE_TKIP ; break ; case eCSR_ENCRYPT_TYPE_AES : params . cipher = WLAN_CIPHER_SUITE_AES_CMAC ; break ; case eCSR_ENCRYPT_TYPE_AES_GCMP : params . cipher = WLAN_CIPHER_SUITE_GCMP ; break ; case eCSR_ENCRYPT_TYPE_AES_GCMP_256 : params . cipher = WLAN_CIPHER_SUITE_GCMP_256 ; break ; default : params . cipher = IW_AUTH_CIPHER_NONE ; break ; } MTRACE ( qdf_trace ( QDF_MODULE_ID_HDD , TRACE_CODE_HDD_CFG80211_GET_KEY , pAdapter -> sessionId , params . cipher ) ) ; params . key_len = pRoamProfile -> Keys . KeyLength [ key_index ] ; params . seq_len = 0 ; params . seq = NULL ; params . key = & pRoamProfile -> Keys . KeyMaterial [ key_index ] [ 0 ] ; callback ( cookie , & params ) ; EXIT ( ) ; return 0 ; } | <S2SV_ModStart> EINVAL ; } if ( wlan_hdd_validate_session_id ( pAdapter -> sessionId ) ) { hdd_err ( "Invalid<S2SV_blank>session<S2SV_blank>id:<S2SV_blank>%d" , pAdapter -> sessionId ) ; return - EINVAL ; } <S2SV_ModStart> "Invalid<S2SV_blank>key<S2SV_blank>index:<S2SV_blank>%d" , key_index ) ; return - EINVAL ; } if ( pRoamProfile == NULL ) { hdd_err ( "Get<S2SV_blank>roam<S2SV_blank>profile<S2SV_blank>failed!" |
206 | CWE-000 void __ieee80211_subif_start_xmit ( struct sk_buff * skb , struct net_device * dev , u32 info_flags ) { struct ieee80211_sub_if_data * sdata = IEEE80211_DEV_TO_SUB_IF ( dev ) ; struct sta_info * sta ; struct sk_buff * next ; if ( unlikely ( skb -> len < ETH_HLEN ) ) { kfree_skb ( skb ) ; return ; } rcu_read_lock ( ) ; if ( ieee80211_lookup_ra_sta ( sdata , skb , & sta ) ) goto out_free ; if ( ! IS_ERR_OR_NULL ( sta ) ) { struct ieee80211_fast_tx * fast_tx ; <S2SV_StartBug> fast_tx = rcu_dereference ( sta -> fast_tx ) ; <S2SV_EndBug> if ( fast_tx && ieee80211_xmit_fast ( sdata , sta , fast_tx , skb ) ) goto out ; } if ( skb_is_gso ( skb ) ) { struct sk_buff * segs ; segs = skb_gso_segment ( skb , 0 ) ; if ( IS_ERR ( segs ) ) { goto out_free ; } else if ( segs ) { consume_skb ( skb ) ; skb = segs ; } } else { if ( skb_linearize ( skb ) ) { kfree_skb ( skb ) ; goto out ; } if ( skb -> ip_summed == CHECKSUM_PARTIAL ) { skb_set_transport_header ( skb , skb_checksum_start_offset ( skb ) ) ; if ( skb_checksum_help ( skb ) ) goto out_free ; } } next = skb ; while ( next ) { skb = next ; next = skb -> next ; skb -> prev = NULL ; skb -> next = NULL ; skb = ieee80211_build_hdr ( sdata , skb , info_flags , sta ) ; if ( IS_ERR ( skb ) ) goto out ; ieee80211_tx_stats ( dev , skb -> len ) ; ieee80211_xmit ( sdata , sta , skb ) ; } goto out ; out_free : kfree_skb ( skb ) ; out : rcu_read_unlock ( ) ; } | <S2SV_ModStart> * fast_tx ; sk_pacing_shift_update ( skb -> sk , 8 ) ; |
207 | CWE-000 static void trace_onreply_in ( struct cell * t , int type , struct tmcb_params * ps ) { static char fromip_buff [ IP_ADDR_MAX_STR_SIZE + 12 ] ; static char toip_buff [ IP_ADDR_MAX_STR_SIZE + 12 ] ; struct sip_msg * msg ; char statusbuf [ INT2STR_MAX_LEN ] ; int len ; trace_info_t info ; if ( t == NULL || t -> uas . request == 0 || ps == NULL ) { LM_DBG ( "no<S2SV_blank>uas<S2SV_blank>request,<S2SV_blank>local<S2SV_blank>transaction\\n" ) ; return ; } SET_SIPTRACE_CONTEXT ( ( trace_info_p ) ( * ps -> param ) ) ; msg = ps -> rpl ; info = * ( trace_info_p ) ( * ps -> param ) ; if ( msg -> rcv . proto != PROTO_UDP ) { info . conn_id = msg -> rcv . proto_reserved1 ; } else { info . conn_id = 0 ; } LM_DBG ( "trace<S2SV_blank>onreply<S2SV_blank>in<S2SV_blank>\\n" ) ; if ( parse_from_header ( msg ) == - 1 || msg -> from == NULL || get_from ( msg ) == NULL ) { LM_ERR ( "cannot<S2SV_blank>parse<S2SV_blank>FROM<S2SV_blank>header\\n" ) ; goto error ; } if ( parse_headers ( msg , HDR_CALLID_F | HDR_CSEQ_F , 0 ) != 0 ) { <S2SV_StartBug> LM_ERR ( "cannot<S2SV_blank>parse<S2SV_blank>call-id\\n" ) ; <S2SV_EndBug> return ; } if ( msg -> len > 0 ) { db_vals [ 0 ] . val . str_val . s = msg -> buf ; db_vals [ 0 ] . val . str_val . len = msg -> len ; } else { db_vals [ 0 ] . val . str_val . s = "No<S2SV_blank>reply<S2SV_blank>buffer" ; db_vals [ 0 ] . val . str_val . len = sizeof ( "No<S2SV_blank>reply<S2SV_blank>buffer" ) - 1 ; } if ( msg -> callid == NULL || msg -> callid -> body . s == NULL ) { <S2SV_StartBug> LM_ERR ( "cannot<S2SV_blank>find<S2SV_blank>Call-ID<S2SV_blank>header!\\n" ) ; <S2SV_EndBug> goto error ; } db_vals [ 1 ] . val . str_val = msg -> callid -> body ; db_vals [ 2 ] . val . str_val = get_cseq ( msg ) -> method ; char * str_code = int2str ( ps -> code , & len ) ; statusbuf [ INT2STR_MAX_LEN - 1 ] = 0 ; strncpy ( statusbuf , str_code , len >= INT2STR_MAX_LEN ? INT2STR_MAX_LEN - 1 : len ) ; db_vals [ 3 ] . val . str_val . s = statusbuf ; db_vals [ 3 ] . val . str_val . len = len ; set_sock_columns ( db_vals [ 4 ] , db_vals [ 5 ] , db_vals [ 6 ] , fromip_buff , & msg -> rcv . src_ip , msg -> rcv . src_port , msg -> rcv . proto ) ; if ( trace_local_ip . s && trace_local_ip . len > 0 ) { set_columns_to_trace_local_ip ( db_vals [ 7 ] , db_vals [ 8 ] , db_vals [ 9 ] ) ; } else { set_sock_columns ( db_vals [ 7 ] , db_vals [ 8 ] , db_vals [ 9 ] , toip_buff , & msg -> rcv . dst_ip , msg -> rcv . dst_port , msg -> rcv . proto ) ; } db_vals [ 10 ] . val . time_val = time ( NULL ) ; db_vals [ 11 ] . val . string_val = "in" ; db_vals [ 12 ] . val . str_val . s = get_from ( msg ) -> tag_value . s ; db_vals [ 12 ] . val . str_val . len = get_from ( msg ) -> tag_value . len ; if ( save_siptrace ( msg , db_keys , db_vals , & info ) < 0 ) { LM_ERR ( "failed<S2SV_blank>to<S2SV_blank>save<S2SV_blank>siptrace\\n" ) ; goto error ; } # ifdef STATISTICS update_stat ( siptrace_rpl , 1 ) ; # endif return ; error : return ; } | <S2SV_ModStart> { LM_ERR ( "cannot<S2SV_blank>parse<S2SV_blank>Call-ID/CSeq\\n" <S2SV_ModEnd> ) ; return <S2SV_ModStart> LM_ERR ( "cannot<S2SV_blank>find<S2SV_blank>Call-ID<S2SV_blank>header!\\n" ) ; goto error ; } if ( msg -> cseq == NULL ) { LM_ERR ( "cannot<S2SV_blank>find<S2SV_blank>CSeq<S2SV_blank>header!\\n" |
208 | CWE-000 void ctcp_output ( ctcp_state_t * state ) { uint32_t avail_buf , datalen ; datalen = state -> received_segment -> len - SEGMENT_HDR_SIZE ; avail_buf = conn_bufspace ( state -> conn ) ; if ( avail_buf == 0 ) { fprintf ( stderr , "No<S2SV_blank>available<S2SV_blank>buffer<S2SV_blank>\\n" ) ; free ( state -> received_segment ) ; return ; } if ( avail_buf >= datalen ) { <S2SV_StartBug> if ( conn_output ( state -> conn , state -> received_segment -> data , datalen ) < 0 ) <S2SV_EndBug> { fprintf ( stderr , "Cannot<S2SV_blank>output\\n" ) ; ctcp_destroy ( state ) ; return ; } state -> ackno = state -> received_segment -> seqno + datalen ; if ( _segment_send ( state , ACK , SEGMENT_HDR_SIZE , NULL ) < 0 ) { perr ( "Cannot<S2SV_blank>send<S2SV_blank>ACK<S2SV_blank>segment\\n" ) ; } _destroy_acked_segment ( state ) ; free ( state -> received_segment ) ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> { if ( datalen == 0 ) { state -> ackno = state -> received_segment -> seqno ; _destroy_acked_segment ( state ) ; free ( state -> received_segment ) ; } else { if ( <S2SV_ModStart> ; } } } |
209 | CWE-000 void handleKeyPress ( XEvent ev ) { int count = 0 ; KeySym keycode = 0 ; Status status = 0 ; char kbdbuf [ 20 ] = { 0 } ; count = Xutf8LookupString ( ic , ( XKeyPressedEvent * ) & ev , kbdbuf , 20 , & keycode , & status ) ; if ( keycode == XK_Escape && ! desktop_mode ) { cleanup ( ) ; exit ( ESCAPE ) ; } if ( keycode == XK_Return || keycode == XK_KP_Enter ) { node_t * current = entries ; node_t * selected = NULL ; node_t * selected_one = NULL ; node_t * first = NULL ; int nb = 0 ; while ( current != NULL ) { if ( ! current -> hidden ) { nb ++ ; selected_one = current ; if ( first == NULL ) first = current ; } if ( ! current -> hidden && current -> hovered ) selected = current ; current = current -> next ; } if ( nb == 1 && selected_one != NULL ) run_command ( selected_one -> cmd ) ; else if ( hoverset == KEYBOARD && selected != NULL ) run_command ( selected -> cmd ) ; else if ( ! no_prompt && ! select_only ) run_command ( commandline ) ; else if ( select_only && first != NULL ) run_command ( first -> cmd ) ; } if ( keycode == XK_Tab || keycode == XK_Up || keycode == XK_Down || keycode == XK_Left || keycode == XK_Right || keycode == XK_KP_Up || keycode == XK_KP_Down || keycode == XK_KP_Left || keycode == XK_KP_Right || keycode == XK_Page_Down || keycode == XK_Page_Up || keycode == XK_Home || keycode == XK_End ) { int i = 0 ; if ( keycode == XK_KP_Left || keycode == XK_Left ) i = - 1 ; if ( keycode == XK_Up || keycode == XK_KP_Up ) i = - columns ; if ( keycode == XK_Down || keycode == XK_KP_Down ) i = columns ; if ( keycode == XK_Tab || keycode == XK_Right || keycode == XK_KP_Right ) i = 1 ; if ( keycode == XK_Page_Up ) i = - columns * rows ; if ( keycode == XK_Page_Down ) i = columns * rows ; if ( keycode == XK_End ) i = entries_count ; if ( keycode == XK_Home ) i = - entries_count ; if ( hovered_entry == 0 ) { if ( keycode != XK_End && keycode != XK_Page_Down ) { hovered_entry = 1 - i ; } else { hovered_entry = 1 ; } } i = hovered_entry + i ; <S2SV_StartBug> hoverset = KEYBOARD ; <S2SV_EndBug> int to_row = ( i + columns - 1 ) / columns ; int display_row = ( hovered_entry - ( scrolled_past * columns ) + columns - 1 ) / columns ; if ( i > ( columns * rows ) + scrolled_past * columns || i <= scrolled_past * columns ) { set_scroll_level ( to_row - display_row ) ; } hover_entry ( i ) ; return ; } if ( keycode == XK_Delete || keycode == XK_BackSpace ) pop_key ( ) ; else if ( count > 1 || ( count == 1 && kbdbuf [ 0 ] >= 32 ) ) { if ( ! no_prompt ) push_key ( kbdbuf ) ; shortcut_t * shortcut = shortcuts ; while ( shortcut != NULL ) { for ( int i = 0 ; i < count ; i ++ ) { if ( kbdbuf [ i ] != shortcut -> key [ i ] ) { break ; } else if ( i == count - 1 ) { run_command ( shortcut -> entry -> cmd ) ; } } shortcut = shortcut -> next ; } } joincmdline ( ) ; joincmdlinetext ( ) ; filter_entries ( ) ; arrange_positions ( ) ; node_t * current = entries ; int i = 1 ; while ( current != NULL ) { set_hover ( i , current , 0 ) ; set_clicked ( current , 0 ) ; current = current -> next ; i ++ ; } updates = imlib_update_append_rect ( updates , 0 , 0 , screen_width , screen_height ) ; } | <S2SV_ModStart> + i ; <S2SV_ModEnd> hover_entry ( i |
210 | CWE-000 static int lxcContainerPivotRoot ( virDomainFSDefPtr root ) { int ret ; char * oldroot = NULL , * newroot = NULL ; ret = - 1 ; VIR_DEBUG ( "Pivot<S2SV_blank>via<S2SV_blank>%s" , root -> src -> path ) ; <S2SV_StartBug> if ( mount ( "" , "/" , NULL , MS_PRIVATE | MS_REC , NULL ) < 0 ) { <S2SV_EndBug> virReportSystemError ( errno , "%s" , _ ( "Failed<S2SV_blank>to<S2SV_blank>make<S2SV_blank>root<S2SV_blank>private" ) ) ; goto err ; } if ( virAsprintf ( & oldroot , "%s/.oldroot" , root -> src -> path ) < 0 ) goto err ; if ( virFileMakePath ( oldroot ) < 0 ) { virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>%s" ) , oldroot ) ; goto err ; } if ( mount ( "tmprootfs" , oldroot , "tmpfs" , 0 , NULL ) < 0 ) { virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>mount<S2SV_blank>empty<S2SV_blank>tmpfs<S2SV_blank>at<S2SV_blank>%s" ) , oldroot ) ; goto err ; } if ( virAsprintf ( & newroot , "%s/new" , oldroot ) < 0 ) goto err ; if ( virFileMakePath ( newroot ) < 0 ) { virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>%s" ) , newroot ) ; goto err ; } <S2SV_StartBug> if ( mount ( root -> src -> path , newroot , NULL , MS_BIND | MS_REC , NULL ) < 0 ) { <S2SV_EndBug> virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>bind<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>new<S2SV_blank>root<S2SV_blank>%s" ) , root -> src -> path , newroot ) ; goto err ; } if ( root -> readonly ) { <S2SV_StartBug> if ( mount ( root -> src -> path , newroot , NULL , MS_BIND | MS_REC | MS_RDONLY | MS_REMOUNT , NULL ) < 0 ) { <S2SV_EndBug> virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>make<S2SV_blank>new<S2SV_blank>root<S2SV_blank>%s<S2SV_blank>readonly" ) , root -> src -> path ) ; goto err ; } } if ( chdir ( newroot ) < 0 ) { virReportSystemError ( errno , _ ( "Failed<S2SV_blank>to<S2SV_blank>chdir<S2SV_blank>into<S2SV_blank>%s" ) , newroot ) ; goto err ; } if ( pivot_root ( "." , ".oldroot" ) < 0 ) { virReportSystemError ( errno , "%s" , _ ( "Failed<S2SV_blank>to<S2SV_blank>pivot<S2SV_blank>root" ) ) ; goto err ; } if ( chdir ( "/" ) < 0 ) goto err ; ret = 0 ; err : VIR_FREE ( oldroot ) ; VIR_FREE ( newroot ) ; return ret ; } | <S2SV_ModStart> , "/" , "none" <S2SV_ModEnd> , MS_PRIVATE | <S2SV_ModStart> , newroot , "none" <S2SV_ModEnd> , MS_BIND | <S2SV_ModStart> , newroot , "none" <S2SV_ModEnd> , MS_BIND | |
211 | CWE-000 void abs_setup ( pairing_t _pairing , pk_t _pk , mk_t _mk , int _l , int _d ) { <S2SV_StartBug> element_init_G1 ( _pk -> g , _pairing ) ; <S2SV_EndBug> element_init_G1 ( _pk -> g1 , _pairing ) ; element_init_G1 ( _pk -> g2 , _pairing ) ; element_init_G1 ( _pk -> u , _pairing ) ; element_init_Zr ( _mk -> x , _pairing ) ; <S2SV_StartBug> element_init_vector_G1 ( _pairing , _pk -> H , _l ) ; <S2SV_EndBug> <S2SV_StartBug> element_init_vector_G1 ( _pairing , _pk -> U , n ) ; <S2SV_EndBug> element_random ( _mk -> x ) ; element_random ( _pk -> g ) ; element_pow_zn ( _pk -> g1 , _pk -> g , _mk -> x ) ; element_random ( _pk -> g2 ) ; element_random ( _pk -> u ) ; element_random_vector ( _pk -> H ) ; element_random_vector ( _pk -> U ) ; element_pairing ( _pk -> Z , _pk -> g1 , _pk -> g2 ) ; } | <S2SV_ModStart> _d ) { int i , j ; <S2SV_ModStart> _pairing ) ; element_init_GT ( _pk -> Z , _pairing ) ; <S2SV_ModStart> U , n ) ; element_init_vector_G1 ( _pairing , US , _l ) ; element_init_vector_G1 ( _pairing , DS , _d - 1 ) ; for ( i = 0 ; i < _l ; i ++ ) element_set_si ( US -> val [ i ] , i ) ; for ( j = 0 ; j < _d - 1 ; j ++ ) element_set_si ( DS -> val [ j ] , i + j |
212 | CWE-000 void * delay_ban ( ) { <S2SV_StartBug> struct sigaction act ; <S2SV_EndBug> union sigval tsval ; act . sa_handler = show_msg ; act . sa_flags = 0 ; sigemptyset ( & act . sa_mask ) ; sigaction ( 50 , & act , NULL ) ; sleep ( 15 ) ; <S2SV_StartBug> sigqueue ( getpid ( ) , 50 , tsval ) ; <S2SV_EndBug> pthread_exit ( NULL ) ; } | <S2SV_ModStart> ( ) { <S2SV_ModEnd> sleep ( 15 <S2SV_ModStart> 15 ) ; ban = false ; printf ( "%s\\n" , start <S2SV_ModEnd> ) ; pthread_exit |
213 | CWE-000 static struct dentry * proc_sys_lookup ( struct inode * dir , struct dentry * dentry , unsigned int flags ) { struct ctl_table_header * head = grab_header ( dir ) ; struct ctl_table_header * h = NULL ; const struct qstr * name = & dentry -> d_name ; struct ctl_table * p ; struct inode * inode ; struct dentry * err = ERR_PTR ( - ENOENT ) ; struct ctl_dir * ctl_dir ; int ret ; if ( IS_ERR ( head ) ) return ERR_CAST ( head ) ; ctl_dir = container_of ( head , struct ctl_dir , header ) ; p = lookup_entry ( & h , ctl_dir , name -> name , name -> len ) ; if ( ! p ) goto out ; if ( S_ISLNK ( p -> mode ) ) { ret = sysctl_follow_link ( & h , & p ) ; err = ERR_PTR ( ret ) ; if ( ret ) goto out ; } <S2SV_StartBug> err = ERR_PTR ( - ENOMEM ) ; <S2SV_EndBug> inode = proc_sys_make_inode ( dir -> i_sb , h ? h : head , p ) ; <S2SV_StartBug> if ( ! inode ) <S2SV_EndBug> <S2SV_StartBug> goto out ; <S2SV_EndBug> d_set_d_op ( dentry , & proc_sys_dentry_operations ) ; err = d_splice_alias ( inode , dentry ) ; out : if ( h ) sysctl_head_finish ( h ) ; sysctl_head_finish ( head ) ; return err ; } | <S2SV_ModStart> out ; } <S2SV_ModEnd> inode = proc_sys_make_inode <S2SV_ModStart> ; if ( IS_ERR ( inode ) ) { err = ERR_CAST ( inode ) ; <S2SV_ModEnd> goto out ; <S2SV_ModStart> goto out ; } |
214 | CWE-000 static void shadow_delta_callback ( AWS_IoT_Client * pClient , char * topicName , uint16_t topicNameLen , IoT_Publish_Message_Params * params , void * pData ) { int32_t tokenCount ; uint32_t i = 0 ; void * pJsonHandler = NULL ; int32_t DataPosition ; uint32_t dataLength ; uint32_t tempVersionNumber = 0 ; FUNC_ENTRY ; IOT_UNUSED ( pClient ) ; IOT_UNUSED ( topicName ) ; IOT_UNUSED ( topicNameLen ) ; IOT_UNUSED ( pData ) ; <S2SV_StartBug> if ( params -> payloadLen > SHADOW_MAX_SIZE_OF_RX_BUFFER ) { <S2SV_EndBug> IOT_WARN ( "Payload<S2SV_blank>larger<S2SV_blank>than<S2SV_blank>RX<S2SV_blank>Buffer" ) ; return ; } memcpy ( shadowRxBuf , params -> payload , params -> payloadLen ) ; shadowRxBuf [ params -> payloadLen ] = '\\0' ; if ( ! isJsonValidAndParse ( shadowRxBuf , pJsonHandler , & tokenCount ) ) { IOT_WARN ( "Received<S2SV_blank>JSON<S2SV_blank>is<S2SV_blank>not<S2SV_blank>valid" ) ; return ; } if ( shadowDiscardOldDeltaFlag ) { if ( extractVersionNumber ( shadowRxBuf , pJsonHandler , tokenCount , & tempVersionNumber ) ) { if ( tempVersionNumber > shadowJsonVersionNum ) { shadowJsonVersionNum = tempVersionNumber ; } else { IOT_WARN ( "Old<S2SV_blank>Delta<S2SV_blank>Message<S2SV_blank>received<S2SV_blank>-<S2SV_blank>Ignoring<S2SV_blank>rx:<S2SV_blank>%d<S2SV_blank>local:<S2SV_blank>%d" , tempVersionNumber , shadowJsonVersionNum ) ; return ; } } } for ( i = 0 ; i < tokenTableIndex ; i ++ ) { if ( ! tokenTable [ i ] . isFree ) { if ( isJsonKeyMatchingAndUpdateValue ( shadowRxBuf , pJsonHandler , tokenCount , ( jsonStruct_t * ) tokenTable [ i ] . pStruct , & dataLength , & DataPosition ) ) { if ( tokenTable [ i ] . callback != NULL ) { tokenTable [ i ] . callback ( shadowRxBuf + DataPosition , dataLength , ( jsonStruct_t * ) tokenTable [ i ] . pStruct ) ; } } } } } | <S2SV_ModStart> params -> payloadLen >= <S2SV_ModEnd> SHADOW_MAX_SIZE_OF_RX_BUFFER ) { |
215 | CWE-000 static void <S2SV_StartBug> pmap_alloc_level ( vaddr_t kva , long * needed_ptps ) <S2SV_EndBug> { unsigned long i ; paddr_t pa ; unsigned long index , endindex ; int level ; pd_entry_t * pdep ; # ifdef XEN int s = splvm ( ) ; # endif for ( level = PTP_LEVELS ; level > 1 ; level -- ) { if ( level == PTP_LEVELS ) <S2SV_StartBug> pdep = pmap_kernel ( ) -> pm_pdir ; <S2SV_EndBug> else pdep = normal_pdes [ level - 2 ] ; index = pl_i_roundup ( kva , level ) ; endindex = index + needed_ptps [ level - 1 ] - 1 ; for ( i = index ; i <= endindex ; i ++ ) { pt_entry_t pte ; KASSERT ( ! pmap_valid_entry ( pdep [ i ] ) ) ; pa = pmap_get_physpage ( ) ; pte = pmap_pa2pte ( pa ) | PG_V | PG_RW ; pmap_pte_set ( & pdep [ i ] , pte ) ; # if defined ( XEN ) && ( defined ( PAE ) || defined ( __x86_64__ ) ) if ( level == PTP_LEVELS && i >= PDIR_SLOT_KERN ) { if ( __predict_true ( cpu_info_primary . ci_flags & CPUF_PRESENT ) ) { xen_kpm_sync ( pmap_kernel ( ) , i ) ; } else { # ifdef PAE pd_entry_t * cpu_pdep = & cpu_info_primary . ci_kpm_pdir [ l2tol2 ( i ) ] ; # endif # ifdef __x86_64__ pd_entry_t * cpu_pdep = & cpu_info_primary . ci_kpm_pdir [ i ] ; # endif pmap_pte_set ( cpu_pdep , pte ) ; } } # endif KASSERT ( level != PTP_LEVELS || nkptp [ level - 1 ] + pl_i ( VM_MIN_KERNEL_ADDRESS , level ) == i ) ; nkptp [ level - 1 ] ++ ; } pmap_pte_flush ( ) ; } # ifdef XEN splx ( s ) ; # endif } | <S2SV_ModStart> void pmap_alloc_level ( struct pmap * cpm , <S2SV_ModStart> ) pdep = cpm <S2SV_ModEnd> -> pm_pdir ; |
216 | CWE-000 static void cx_auto_reboot_notify ( struct hda_codec * codec ) { struct conexant_spec * spec = codec -> spec ; switch ( codec -> core . vendor_id ) { case 0x14f150f2 : case 0x14f150f4 : break ; default : return ; } cx_auto_turn_eapd ( codec , spec -> num_eapds , spec -> eapds , false ) ; snd_hda_codec_set_power_to_all ( codec , codec -> core . afg , AC_PWRST_D3 ) ; snd_hda_codec_write ( codec , codec -> core . afg , 0 , AC_VERB_SET_POWER_STATE , AC_PWRST_D3 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> AC_PWRST_D3 ) ; msleep ( 10 ) ; |
217 | CWE-000 static struct task * schedule_edf ( void ) { struct task * task ; struct task * future_task = NULL ; <S2SV_StartBug> uint64_t current ; <S2SV_EndBug> tracev_pipe ( "edf" ) ; current = platform_timer_get ( platform_timer ) ; task = edf_get_next ( current , NULL ) ; interrupt_clear ( PLATFORM_SCHEDULE_IRQ ) ; if ( task == NULL ) return NULL ; if ( task -> start > current ) { future_task = task ; } else { task -> start = current ; <S2SV_StartBug> task -> state = TASK_STATE_RUNNING ; <S2SV_EndBug> arch_run_task ( task ) ; } return future_task ; } | <S2SV_ModStart> ; uint64_t current ; uint32_t flags <S2SV_ModStart> = current ; wait_init ( & task -> complete ) ; spin_lock_irq ( & sch -> lock , flags ) ; <S2SV_ModStart> state = TASK_STATE_RUNNING ; list_item_del ( & task -> list ) ; spin_unlock_irq ( & sch -> lock , flags ) |
218 | CWE-000 void monetdb_unregister_progress ( void * conn ) { Client c = ( Client ) conn ; if ( ! MCvalid ( c ) ) { return ; } <S2SV_StartBug> c -> progress_callback = NULL ; <S2SV_EndBug> if ( c -> progress_data ) free ( c -> progress_data ) ; c -> progress_data = NULL ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> return ; } MT_lock_set ( & c -> progress_lock ) ; <S2SV_ModStart> = NULL ; MT_lock_unset ( & c -> progress_lock ) ; |
219 | CWE-000 static void generic_sendto ( bool is_dgram , int fd , char * data , int len , struct sockaddr * addr , socklen_t addrlen ) { if ( is_dgram ) sendto ( fd , data , len , 0 , addr , addrlen ) ; else <S2SV_StartBug> sendto ( fd , data , len , 0 , NULL , 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> ) ; else write <S2SV_ModEnd> ( fd , <S2SV_ModStart> data , len <S2SV_ModEnd> ) ; } |
220 | CWE-000 int DelagentDBInit ( ) { char CMD [ 256 ] ; int rc ; char cwd [ 2048 ] ; char * confDir = NULL ; if ( getcwd ( cwd , sizeof ( cwd ) ) != NULL ) { confDir = createTestConfDir ( cwd , "delagent" ) ; } rc = create_db_repo_sysconf ( 0 , "delagent" , confDir ) ; if ( rc != 0 ) { printf ( "Database<S2SV_blank>initialize<S2SV_blank>ERROR!\\n" ) ; DelagentClean ( ) ; return - 1 ; } DBConfFile = get_dbconf ( ) ; memset ( CMD , '\\0' , sizeof ( CMD ) ) ; <S2SV_StartBug> sprintf ( CMD , "psql<S2SV_blank>-U<S2SV_blank>%s<S2SV_blank>-d<S2SV_blank>%s<S2SV_blank><<S2SV_blank>../testdata/testdb_all.sql<S2SV_blank>>/dev/null" , getUser ( ) , get_db_name ( ) ) ; <S2SV_EndBug> rc = system ( CMD ) ; if ( WEXITSTATUS ( rc ) != 0 ) { printf ( "Database<S2SV_blank>initialize<S2SV_blank>ERROR!\\n" ) ; DelagentClean ( ) ; return - 1 ; } return 0 ; } | <S2SV_ModStart> ( CMD , "gunzip<S2SV_blank>-c<S2SV_blank>../testdata/testdb_all.gz<S2SV_blank>|<S2SV_blank>psql<S2SV_blank>-U<S2SV_blank>%s<S2SV_blank>-d<S2SV_blank>%s<S2SV_blank>>/dev/null" <S2SV_ModEnd> , getUser ( |
221 | CWE-000 static void h2_bulkfree_sync_adjust ( hammer2_bulkfree_info_t * cbinfo , hammer2_off_t data_off , hammer2_bmap_data_t * live , <S2SV_StartBug> hammer2_bmap_data_t * bmap ) <S2SV_EndBug> { int bindex ; int scount ; hammer2_off_t tmp_off ; hammer2_bitmap_t lmask ; hammer2_bitmap_t mmask ; tmp_off = data_off ; for ( bindex = 0 ; bindex < HAMMER2_BMAP_ELEMENTS ; ++ bindex ) { lmask = live -> bitmapq [ bindex ] ; mmask = bmap -> bitmapq [ bindex ] ; if ( lmask == mmask ) { tmp_off += HAMMER2_BMAP_INDEX_SIZE ; continue ; } for ( scount = 0 ; scount < HAMMER2_BMAP_BITS_PER_ELEMENT ; scount += 2 ) { if ( ( mmask & 3 ) == 0 ) { switch ( lmask & 3 ) { case 0 : break ; case 1 : kprintf ( "hammer2_bulkfree:<S2SV_blank>cannot<S2SV_blank>" "transition<S2SV_blank>m=00/l=01\\n" ) ; break ; case 2 : live -> bitmapq [ bindex ] &= ~ ( ( hammer2_bitmap_t ) 2 << scount ) ; live -> avail += HAMMER2_FREEMAP_BLOCK_SIZE ; if ( live -> avail > HAMMER2_FREEMAP_LEVEL0_SIZE ) { live -> avail = HAMMER2_FREEMAP_LEVEL0_SIZE ; } cbinfo -> adj_free += HAMMER2_FREEMAP_BLOCK_SIZE ; ++ cbinfo -> count_10_00 ; hammer2_io_dedup_assert ( cbinfo -> hmp , tmp_off | HAMMER2_FREEMAP_BLOCK_RADIX , HAMMER2_FREEMAP_BLOCK_SIZE ) ; break ; case 3 : live -> bitmapq [ bindex ] &= ~ ( ( hammer2_bitmap_t ) 1 << scount ) ; ++ cbinfo -> count_11_10 ; hammer2_io_dedup_delete ( cbinfo -> hmp , HAMMER2_BREF_TYPE_DATA , tmp_off | HAMMER2_FREEMAP_BLOCK_RADIX , HAMMER2_FREEMAP_BLOCK_SIZE ) ; break ; } } else if ( ( mmask & 3 ) == 3 ) { switch ( lmask & 3 ) { case 0 : ++ cbinfo -> count_00_11 ; cbinfo -> adj_free -= HAMMER2_FREEMAP_BLOCK_SIZE ; live -> avail -= HAMMER2_FREEMAP_BLOCK_SIZE ; if ( ( int32_t ) live -> avail < 0 ) live -> avail = 0 ; break ; case 1 : ++ cbinfo -> count_01_11 ; break ; case 2 : ++ cbinfo -> count_10_11 ; break ; case 3 : break ; } live -> bitmapq [ bindex ] |= ( ( hammer2_bitmap_t ) 3 << scount ) ; } mmask >>= 2 ; lmask >>= 2 ; tmp_off += HAMMER2_FREEMAP_BLOCK_SIZE ; } } for ( bindex = HAMMER2_BMAP_ELEMENTS - 1 ; bindex >= 0 ; -- bindex ) { if ( live -> bitmapq [ bindex ] != 0 ) break ; } if ( bindex < 0 ) { <S2SV_StartBug> live -> avail = HAMMER2_FREEMAP_LEVEL0_SIZE ; <S2SV_EndBug> live -> class = 0 ; live -> linear = 0 ; ++ cbinfo -> count_l0cleans ; } else if ( bindex < 7 ) { if ( live -> linear < bmap -> linear && ( ( live -> linear ^ bmap -> linear ) & ~ HAMMER2_FREEMAP_BLOCK_MASK ) == 0 ) { live -> linear = bmap -> linear ; ++ cbinfo -> count_linadjusts ; } else { live -> linear = ( bmap -> linear + HAMMER2_FREEMAP_BLOCK_MASK ) & ~ HAMMER2_FREEMAP_BLOCK_MASK ; ++ cbinfo -> count_linadjusts ; } } else { live -> linear = HAMMER2_SEGSIZE ; } # if 0 if ( bmap -> class ) { kprintf ( "%016jx<S2SV_blank>%04d.%04x<S2SV_blank>(avail=%7d)<S2SV_blank>" "%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x<S2SV_blank>%08x\\n" , ( intmax_t ) data_off , ( int ) ( ( data_off & HAMMER2_FREEMAP_LEVEL1_MASK ) >> HAMMER2_FREEMAP_LEVEL0_RADIX ) , bmap -> class , bmap -> avail , bmap -> bitmap [ 0 ] , bmap -> bitmap [ 1 ] , bmap -> bitmap [ 2 ] , bmap -> bitmap [ 3 ] , bmap -> bitmap [ 4 ] , bmap -> bitmap [ 5 ] , bmap -> bitmap [ 6 ] , bmap -> bitmap [ 7 ] ) ; } # endif } | <S2SV_ModStart> hammer2_bmap_data_t * bmap , hammer2_key_t alloc_base <S2SV_ModStart> 0 ) { # if 0 kprintf ( "hammer2:<S2SV_blank>cleanseg<S2SV_blank>%016jx.%04x<S2SV_blank>(%d)\\n" , alloc_base , live -> class , live -> avail ) ; # endif |
222 | CWE-000 void i2c_write_byte ( uint8_t value ) { TWDR = value ; TWCR = ( 1 << TWINT ) | ( 1 << TWEN ) ; <S2SV_StartBug> while ( ! ( TWCR & ( 1 << TWINT ) ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> TWEN ) ; timeout_timer = TIMEOUT_VALUE ; <S2SV_ModStart> TWINT ) ) && ( timeout_timer -- ) |
223 | CWE-000 int main ( ) { <S2SV_StartBug> test_subtract_second ( ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ( ) { test_2015_10_26 <S2SV_ModEnd> ( ) ; |
224 | CWE-000 static void zs_find_index_range_for_files ( struct list_head * flist , uint32_t * startidx , uint32_t * endidx ) { struct list_head * pos ; <S2SV_StartBug> * startidx = 0 ; <S2SV_EndBug> <S2SV_StartBug> * endidx = 0 ; <S2SV_EndBug> list_for_each_forward ( pos , flist ) { struct zsdb_file * f ; uint32_t sidx = 0 , eidx = 0 ; f = list_entry ( pos , struct zsdb_file , list ) ; interpret_db_filename ( f -> fname . buf , strlen ( f -> fname . buf ) , & sidx , & eidx ) ; if ( sidx != 0 && sidx < * startidx ) * startidx = sidx ; if ( eidx != 0 && eidx > * endidx ) * endidx = eidx ; } } | <S2SV_ModStart> * pos ; struct zsdb_file * first ; <S2SV_ModStart> endidx = 0 ; first = list_first ( flist , struct zsdb_file , list ) ; interpret_db_filename ( first -> fname . buf , strlen ( first -> fname . buf ) , startidx , endidx ) |
225 | CWE-000 void radioSend ( KRadioDevice * radio , uint8_t addr , uint8_t prot , size_t bytes , const void * payload ) { RadioPacket pkt ; uint8_t reg ; <S2SV_StartBug> pkt . length = bytes + sizeof ( pkt ) ; <S2SV_EndBug> pkt . src = radio -> address ; pkt . dst = addr ; pkt . prot = prot ; osalDbgAssert ( pkt . length < RADIO_FIFO_DEPTH , "Packet<S2SV_blank>is<S2SV_blank>too<S2SV_blank>large" ) ; radio -> mode = mode_transmitting ; radio_set ( radio , RADIO_OpMode , OpMode_Sequencer_On | OpMode_Listen_Off | OpMode_Transmitter ) ; radio_set ( radio , RADIO_FifoThresh , pkt . length - 1 ) ; radio_select ( radio ) ; reg = RADIO_Fifo | 0x80 ; spiSend ( radio -> driver , 1 , & reg ) ; spiSend ( radio -> driver , sizeof ( pkt ) , & pkt ) ; spiSend ( radio -> driver , bytes , payload ) ; radio_unselect ( radio ) ; <S2SV_StartBug> osalSysLock ( ) ; <S2SV_EndBug> ( void ) osalThreadSuspendS ( & radio -> thread ) ; <S2SV_StartBug> osalSysUnlock ( ) ; <S2SV_EndBug> radio -> mode = mode_receiving ; radio_set ( radio , RADIO_OpMode , OpMode_Sequencer_On | OpMode_Listen_Off | OpMode_Receiver ) ; } | <S2SV_ModStart> uint8_t reg ; uint8_t flags ; <S2SV_ModStart> radio ) ; flags = radioRead ( radioDriver , RADIO_IrqFlags2 ) ; <S2SV_ModStart> ; osalSysUnlock ( ) ; flags = radioRead ( radioDriver , RADIO_IrqFlags2 |
226 | CWE-000 int comm_upload ( char * path ) { char upload_command [ COMM_PPAYLOAD_LENGTH ] ; char filename [ MAX_FILENAME_LENGTH ] ; if ( file_get_name_from_path ( path , filename ) == - 1 ) { strcpy ( filename , path ) ; } sprintf ( upload_command , "upload<S2SV_blank>%s" , filename ) ; <S2SV_StartBug> pthread_mutex_lock ( & __command_handling_mutex ) ; <S2SV_EndBug> if ( __send_command ( & __server_sockaddr , upload_command ) == 0 ) { if ( __send_file ( & __server_sockaddr , path ) == 0 ) { log_debug ( "comm" , "\'%s\'<S2SV_blank>uploaded<S2SV_blank>into<S2SV_blank>\'%s\'" , path , filename ) ; <S2SV_StartBug> pthread_mutex_unlock ( & __command_handling_mutex ) ; <S2SV_EndBug> return 0 ; } } <S2SV_StartBug> pthread_mutex_unlock ( & __command_handling_mutex ) ; <S2SV_EndBug> return - 1 ; } | <S2SV_ModStart> filename ) ; log_debug ( "comm" , "UPLOAD<S2SV_blank>LOCK<S2SV_blank>1" ) ; <S2SV_ModStart> ( & __command_handling_mutex ) ; log_debug ( "comm" , "UPLOAD<S2SV_blank>LOCK<S2SV_blank>2" <S2SV_ModStart> filename ) ; log_debug ( "comm" , "UPLOAD<S2SV_blank>UNLOCK<S2SV_blank>1<S2SV_blank>S" ) ; <S2SV_ModStart> ( & __command_handling_mutex ) ; log_debug ( "comm" , "UPLOAD<S2SV_blank>UNLOCK<S2SV_blank>2<S2SV_blank>S" <S2SV_ModStart> ; } } log_debug ( "comm" , "UPLOAD<S2SV_blank>UNLOCK<S2SV_blank>1<S2SV_blank>E" ) ; <S2SV_ModStart> ( & __command_handling_mutex ) ; log_debug ( "comm" , "UPLOAD<S2SV_blank>UNLOCK<S2SV_blank>2<S2SV_blank>E" |
227 | CWE-000 static int decode_video ( InputStream * ist , AVPacket * pkt , int * got_output , int64_t * duration_pts , int eof , int * decode_failed ) { AVFrame * decoded_frame ; int i , ret = 0 , err = 0 ; int64_t best_effort_timestamp ; int64_t dts = AV_NOPTS_VALUE ; AVPacket avpkt ; if ( ! eof && pkt && pkt -> size == 0 ) return 0 ; if ( ! ist -> decoded_frame && ! ( ist -> decoded_frame = av_frame_alloc ( ) ) ) return AVERROR ( ENOMEM ) ; if ( ! ist -> filter_frame && ! ( ist -> filter_frame = av_frame_alloc ( ) ) ) return AVERROR ( ENOMEM ) ; decoded_frame = ist -> decoded_frame ; if ( ist -> dts != AV_NOPTS_VALUE ) dts = av_rescale_q ( ist -> dts , AV_TIME_BASE_Q , ist -> st -> time_base ) ; if ( pkt ) { avpkt = * pkt ; avpkt . dts = dts ; } if ( eof ) { void * new = av_realloc_array ( ist -> dts_buffer , ist -> nb_dts_buffer + 1 , sizeof ( ist -> dts_buffer [ 0 ] ) ) ; if ( ! new ) return AVERROR ( ENOMEM ) ; ist -> dts_buffer = new ; ist -> dts_buffer [ ist -> nb_dts_buffer ++ ] = dts ; } update_benchmark ( NULL ) ; ret = decode ( ist -> dec_ctx , decoded_frame , got_output , pkt ? & avpkt : NULL ) ; update_benchmark ( "decode_video<S2SV_blank>%d.%d" , ist -> file_index , ist -> st -> index ) ; if ( ret < 0 ) * decode_failed = 1 ; if ( ist -> st -> codecpar -> video_delay < ist -> dec_ctx -> has_b_frames ) { if ( ist -> dec_ctx -> codec_id == AV_CODEC_ID_H264 ) { ist -> st -> codecpar -> video_delay = ist -> dec_ctx -> has_b_frames ; } else av_log ( ist -> dec_ctx , AV_LOG_WARNING , "video_delay<S2SV_blank>is<S2SV_blank>larger<S2SV_blank>in<S2SV_blank>decoder<S2SV_blank>than<S2SV_blank>demuxer<S2SV_blank>%d<S2SV_blank>><S2SV_blank>%d.\\n" "If<S2SV_blank>you<S2SV_blank>want<S2SV_blank>to<S2SV_blank>help,<S2SV_blank>upload<S2SV_blank>a<S2SV_blank>sample<S2SV_blank>" "of<S2SV_blank>this<S2SV_blank>file<S2SV_blank>to<S2SV_blank>ftp://upload.ffmpeg.org/incoming/<S2SV_blank>" "and<S2SV_blank>contact<S2SV_blank>the<S2SV_blank>ffmpeg-devel<S2SV_blank>mailing<S2SV_blank>list.<S2SV_blank>(ffmpeg-devel@ffmpeg.org)\\n" , ist -> dec_ctx -> has_b_frames , ist -> st -> codecpar -> video_delay ) ; } if ( ret != AVERROR_EOF ) check_decode_result ( ist , got_output , ret ) ; if ( * got_output && ret >= 0 ) { if ( ist -> dec_ctx -> width != decoded_frame -> width || ist -> dec_ctx -> height != decoded_frame -> height || ist -> dec_ctx -> pix_fmt != decoded_frame -> format ) { av_log ( NULL , AV_LOG_DEBUG , "Frame<S2SV_blank>parameters<S2SV_blank>mismatch<S2SV_blank>context<S2SV_blank>%d,%d,%d<S2SV_blank>!=<S2SV_blank>%d,%d,%d\\n" , decoded_frame -> width , decoded_frame -> height , decoded_frame -> format , ist -> dec_ctx -> width , ist -> dec_ctx -> height , ist -> dec_ctx -> pix_fmt ) ; } } if ( ! * got_output || ret < 0 ) { if ( eof && ist -> prev_decoded_frame != NULL ) { <S2SV_StartBug> ist -> prev_decoded_frame -> pts = INT64_MAX ; <S2SV_EndBug> err = send_frame_to_filters ( ist , ist -> prev_decoded_frame ) ; <S2SV_StartBug> av_frame_unref ( ist -> prev_decoded_frame ) ; <S2SV_EndBug> ist -> prev_decoded_frame = NULL ; return err ; } return ret ; } if ( ist -> top_field_first >= 0 ) decoded_frame -> top_field_first = ist -> top_field_first ; ist -> frames_decoded ++ ; if ( ist -> hwaccel_retrieve_data && decoded_frame -> format == ist -> hwaccel_pix_fmt ) { err = ist -> hwaccel_retrieve_data ( ist -> dec_ctx , decoded_frame ) ; if ( err < 0 ) goto fail ; } ist -> hwaccel_retrieved_pix_fmt = decoded_frame -> format ; best_effort_timestamp = decoded_frame -> best_effort_timestamp ; * duration_pts = decoded_frame -> pkt_duration ; if ( ist -> framerate . num ) best_effort_timestamp = ist -> cfr_next_pts ++ ; if ( eof && best_effort_timestamp == AV_NOPTS_VALUE && ist -> nb_dts_buffer > 0 ) { best_effort_timestamp = ist -> dts_buffer [ 0 ] ; for ( i = 0 ; i < ist -> nb_dts_buffer - 1 ; i ++ ) ist -> dts_buffer [ i ] = ist -> dts_buffer [ i + 1 ] ; ist -> nb_dts_buffer -- ; } if ( best_effort_timestamp != AV_NOPTS_VALUE ) { int64_t ts = av_rescale_q ( decoded_frame -> pts = best_effort_timestamp , ist -> st -> time_base , AV_TIME_BASE_Q ) ; if ( ts != AV_NOPTS_VALUE ) ist -> next_pts = ist -> pts = ts ; } if ( eof ) <S2SV_StartBug> decoded_frame -> pts = INT64_MAX ; <S2SV_EndBug> else { if ( ! ist -> prev_decoded_frame && ! ( ist -> prev_decoded_frame = av_frame_alloc ( ) ) ) return AVERROR ( ENOMEM ) ; av_frame_unref ( ist -> prev_decoded_frame ) ; err = av_frame_ref ( ist -> prev_decoded_frame , decoded_frame ) ; if ( err ) return err ; } if ( debug_ts ) { av_log ( NULL , AV_LOG_INFO , "decoder<S2SV_blank>-><S2SV_blank>ist_index:%d<S2SV_blank>type:video<S2SV_blank>" "frame_pts:%s<S2SV_blank>frame_pts_time:%s<S2SV_blank>best_effort_ts:%" PRId64 "<S2SV_blank>best_effort_ts_time:%s<S2SV_blank>keyframe:%d<S2SV_blank>frame_type:%d<S2SV_blank>time_base:%d/%d\\n" , ist -> st -> index , av_ts2str ( decoded_frame -> pts ) , av_ts2timestr ( decoded_frame -> pts , & ist -> st -> time_base ) , best_effort_timestamp , av_ts2timestr ( best_effort_timestamp , & ist -> st -> time_base ) , decoded_frame -> key_frame , decoded_frame -> pict_type , ist -> st -> time_base . num , ist -> st -> time_base . den ) ; } if ( ist -> st -> sample_aspect_ratio . num ) decoded_frame -> sample_aspect_ratio = ist -> st -> sample_aspect_ratio ; err = send_frame_to_filters ( ist , decoded_frame ) ; fail : av_frame_unref ( ist -> filter_frame ) ; av_frame_unref ( decoded_frame ) ; return err < 0 ? err : ret ; } | <S2SV_ModStart> -> pts = ist -> st -> start_time <S2SV_ModEnd> ; err = <S2SV_ModStart> prev_decoded_frame ) ; av_frame_free ( & <S2SV_ModEnd> ist -> prev_decoded_frame <S2SV_ModStart> -> prev_decoded_frame ) <S2SV_ModEnd> ; return err <S2SV_ModStart> -> pts = ist -> st -> start_time <S2SV_ModEnd> ; else { |
228 | CWE-000 static PyObject * array_positive ( PyArrayObject * m1 ) { PyObject * value ; if ( can_elide_temp_unary ( m1 ) ) { value = PyArray_GenericInplaceUnaryFunction ( m1 , n_ops . positive ) ; } else { value = PyArray_GenericUnaryFunction ( m1 , n_ops . positive ) ; } if ( value == NULL ) { PyObject * exc , * val , * tb ; PyErr_Fetch ( & exc , & val , & tb ) ; if ( PyUFunc_HasOverride ( ( PyObject * ) m1 ) ) { PyErr_Restore ( exc , val , tb ) ; return NULL ; } <S2SV_StartBug> if ( DEPRECATE ( "Applying<S2SV_blank>\'+\'<S2SV_blank>to<S2SV_blank>a<S2SV_blank>non-numerical<S2SV_blank>array<S2SV_blank>is<S2SV_blank>" <S2SV_EndBug> "ill-defined.<S2SV_blank>Returning<S2SV_blank>a<S2SV_blank>copy,<S2SV_blank>but<S2SV_blank>in<S2SV_blank>the<S2SV_blank>future<S2SV_blank>" "this<S2SV_blank>will<S2SV_blank>error." ) < 0 ) { return NULL ; } <S2SV_StartBug> Py_XDECREF ( exc ) ; <S2SV_EndBug> Py_XDECREF ( val ) ; Py_XDECREF ( tb ) ; value = PyArray_Return ( ( PyArrayObject * ) PyArray_Copy ( m1 ) ) ; } return value ; } | <S2SV_ModStart> NULL ; } Py_XDECREF ( exc ) ; Py_XDECREF ( val ) ; Py_XDECREF ( tb ) ; <S2SV_ModStart> NULL ; } <S2SV_ModEnd> value = PyArray_Return |
229 | CWE-000 inline void rayTransform ( struct ray3D * ray_orig , struct ray3D * ray_transformed , struct object3D * obj ) { <S2SV_StartBug> ray_transformed = newRay ( ray_orig -> p0 , ray_orig -> d ) ; <S2SV_EndBug> <S2SV_StartBug> matVecMult ( obj -> Tinv , ray_transformed -> p0 ) ; <S2SV_EndBug> <S2SV_StartBug> matVecMult ( obj -> Tinv , ray_transformed -> d ) ; <S2SV_EndBug> } | <S2SV_ModStart> = newRay ( & <S2SV_ModStart> -> p0 , & <S2SV_ModStart> -> Tinv , & <S2SV_ModStart> -> Tinv , & |
230 | CWE-000 void __wt_cond_wait_signal ( WT_SESSION_IMPL * session , WT_CONDVAR * cond , uint64_t usecs , bool ( * run_func ) ( WT_SESSION_IMPL * ) , bool * signalled ) { BOOL sleepret ; DWORD milliseconds , windows_error ; bool locked ; uint64_t milliseconds64 ; locked = false ; * signalled = true ; if ( __wt_atomic_addi32 ( & cond -> waiters , 1 ) == 0 ) return ; __wt_verbose ( session , WT_VERB_MUTEX , "wait<S2SV_blank>%s" , cond -> name ) ; WT_STAT_CONN_INCR ( session , cond_wait ) ; EnterCriticalSection ( & cond -> mtx ) ; locked = true ; WT_ASSERT ( session , run_func != NULL || usecs < 5 * WT_MILLION ) ; if ( run_func != NULL && ! run_func ( session ) ) goto skipping ; if ( usecs > 0 ) { milliseconds64 = usecs / 1000 ; if ( milliseconds64 >= INFINITE ) milliseconds64 = INFINITE - 1 ; milliseconds = ( DWORD ) milliseconds64 ; if ( milliseconds == 0 ) milliseconds = 1 ; sleepret = SleepConditionVariableCS ( & cond -> cond , & cond -> mtx , milliseconds ) ; } else sleepret = SleepConditionVariableCS ( & cond -> cond , & cond -> mtx , INFINITE ) ; if ( sleepret == 0 ) { windows_error = __wt_getlasterror ( ) ; if ( windows_error == ERROR_TIMEOUT ) { <S2SV_StartBug> * signalled = false ; <S2SV_EndBug> sleepret = 1 ; } } skipping : ( void ) __wt_atomic_subi32 ( & cond -> waiters , 1 ) ; if ( locked ) LeaveCriticalSection ( & cond -> mtx ) ; if ( sleepret != 0 ) return ; __wt_errx ( session , "SleepConditionVariableCS:<S2SV_blank>%s:<S2SV_blank>%s" , cond -> name , __wt_formatmessage ( session , windows_error ) ) ; WT_PANIC_MSG ( session , __wt_map_windows_error ( windows_error ) , "SleepConditionVariableCS:<S2SV_blank>%s" , cond -> name ) ; } | <S2SV_ModStart> ERROR_TIMEOUT ) { skipping : * signalled = false ; sleepret = 1 ; } } <S2SV_ModEnd> ( void ) |
231 | CWE-000 <S2SV_StartBug> int rtas_write_config ( struct pci_bus * bus , unsigned int devfn , int offset , <S2SV_EndBug> int len , u32 val ) { struct pci_controller * hose = pci_bus_to_host ( bus ) ; unsigned long addr = ( offset & 0xff ) | ( ( devfn & 0xff ) << 8 ) | ( ( ( bus -> number - hose -> first_busno ) & 0xff ) << 16 ) | ( hose -> global_number << 24 ) ; int rval ; rval = rtas_call ( rtas_token ( "write-pci-config" ) , 3 , 1 , NULL , addr , len , val ) ; return rval ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL ; } | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> static |
232 | CWE-000 static int32_t isSizeAllowed ( struct data_ops_t * p_this , uint32_t size ) { printf ( "LS<S2SV_blank>isSizeAllowed()\\n" ) ; if ( p_this == NULL ) return - 1 ; ls_t * p_base = ( ls_t * ) p_this -> mp_base ; <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> -> mp_base ; readLock ( p_base ) ; readUnlock ( p_base ) ; |
233 | CWE-000 static void __lim_process_sme_deauth_req ( tpAniSirGlobal mac_ctx , uint32_t * msg_buf ) { uint16_t deauth_trigger , reason_code ; tLimMlmDeauthReq * mlm_deauth_req ; tSirSmeDeauthReq sme_deauth_req ; tSirResultCodes ret_code = eSIR_SME_SUCCESS ; tpPESession session_entry ; uint8_t session_id ; uint8_t sme_session_id ; uint16_t sme_transaction_id ; lim_log ( mac_ctx , LOG1 , FL ( "received<S2SV_blank>DEAUTH_REQ<S2SV_blank>message" ) ) ; qdf_mem_copy ( & sme_deauth_req , msg_buf , sizeof ( tSirSmeDeauthReq ) ) ; sme_session_id = sme_deauth_req . sessionId ; sme_transaction_id = sme_deauth_req . transactionId ; session_entry = pe_find_session_by_bssid ( mac_ctx , sme_deauth_req . bssid . bytes , & session_id ) ; if ( session_entry == NULL ) { lim_log ( mac_ctx , LOGE , FL ( "session<S2SV_blank>does<S2SV_blank>not<S2SV_blank>exist<S2SV_blank>for<S2SV_blank>given<S2SV_blank>bssId" ) ) ; ret_code = eSIR_SME_INVALID_PARAMETERS ; deauth_trigger = eLIM_HOST_DEAUTH ; goto send_deauth ; } if ( ! lim_is_sme_deauth_req_valid ( mac_ctx , & sme_deauth_req , session_entry ) ) { lim_log ( mac_ctx , LOGE , FL ( "received<S2SV_blank>invalid<S2SV_blank>SME_DEAUTH_REQ<S2SV_blank>message" ) ) ; mac_ctx -> lim . gLimRspReqd = false ; ret_code = eSIR_SME_INVALID_PARAMETERS ; deauth_trigger = eLIM_HOST_DEAUTH ; goto send_deauth ; } lim_log ( mac_ctx , LOG1 , FL ( "received<S2SV_blank>DEAUTH_REQ<S2SV_blank>sessionid<S2SV_blank>%d<S2SV_blank>Systemrole<S2SV_blank>%d<S2SV_blank>reasoncode<S2SV_blank>%u<S2SV_blank>limSmestate<S2SV_blank>%d<S2SV_blank>from<S2SV_blank>" MAC_ADDRESS_STR ) , sme_session_id , GET_LIM_SYSTEM_ROLE ( session_entry ) , sme_deauth_req . reasonCode , session_entry -> limSmeState , MAC_ADDR_ARRAY ( sme_deauth_req . peer_macaddr . bytes ) ) ; # ifdef FEATURE_WLAN_DIAG_SUPPORT_LIM lim_diag_event_report ( mac_ctx , WLAN_PE_DIAG_DEAUTH_REQ_EVENT , session_entry , 0 , sme_deauth_req . reasonCode ) ; # endif session_entry -> smeSessionId = sme_session_id ; session_entry -> transactionId = sme_transaction_id ; switch ( GET_LIM_SYSTEM_ROLE ( session_entry ) ) { case eLIM_STA_ROLE : switch ( session_entry -> limSmeState ) { case eLIM_SME_ASSOCIATED_STATE : case eLIM_SME_LINK_EST_STATE : lim_delete_tdls_peers ( mac_ctx , session_entry ) ; case eLIM_SME_WT_ASSOC_STATE : case eLIM_SME_JOIN_FAILURE_STATE : case eLIM_SME_IDLE_STATE : session_entry -> limPrevSmeState = session_entry -> limSmeState ; session_entry -> limSmeState = eLIM_SME_WT_DEAUTH_STATE ; MTRACE ( mac_trace ( mac_ctx , TRACE_CODE_SME_STATE , session_entry -> peSessionId , session_entry -> limSmeState ) ) ; break ; case eLIM_SME_WT_DEAUTH_STATE : case eLIM_SME_WT_DISASSOC_STATE : session_entry -> limSmeState = eLIM_SME_WT_DEAUTH_STATE ; lim_log ( mac_ctx , LOG1 , FL ( "Rcvd<S2SV_blank>SME_DEAUTH_REQ<S2SV_blank>while<S2SV_blank>in<S2SV_blank>SME_WT_DEAUTH_STATE" ) ) ; break ; default : lim_log ( mac_ctx , LOGE , FL ( "received<S2SV_blank>unexp<S2SV_blank>SME_DEAUTH_REQ<S2SV_blank>in<S2SV_blank>state<S2SV_blank>%X" ) , session_entry -> limSmeState ) ; lim_print_sme_state ( mac_ctx , LOGE , session_entry -> limSmeState ) ; if ( mac_ctx -> lim . gLimRspReqd ) { mac_ctx -> lim . gLimRspReqd = false ; ret_code = eSIR_SME_STA_NOT_AUTHENTICATED ; deauth_trigger = eLIM_HOST_DEAUTH ; if ( session_entry -> limSmeState == eLIM_SME_WT_DEAUTH_STATE && session_entry -> limMlmState != eLIM_MLM_IDLE_STATE && session_entry -> limMlmState != <S2SV_StartBug> eLIM_MLM_WT_DEL_STA_RSP_STATE ) <S2SV_EndBug> ret_code = eSIR_SME_DEAUTH_STATUS ; <S2SV_StartBug> goto send_deauth ; <S2SV_EndBug> } return ; } break ; case eLIM_STA_IN_IBSS_ROLE : lim_log ( mac_ctx , LOGE , FL ( "Deauth<S2SV_blank>not<S2SV_blank>allowed<S2SV_blank>in<S2SV_blank>IBSS" ) ) ; if ( mac_ctx -> lim . gLimRspReqd ) { mac_ctx -> lim . gLimRspReqd = false ; ret_code = eSIR_SME_INVALID_PARAMETERS ; deauth_trigger = eLIM_HOST_DEAUTH ; goto send_deauth ; } return ; case eLIM_AP_ROLE : break ; default : lim_log ( mac_ctx , LOGE , FL ( "received<S2SV_blank>unexpected<S2SV_blank>SME_DEAUTH_REQ<S2SV_blank>for<S2SV_blank>role<S2SV_blank>%X" ) , GET_LIM_SYSTEM_ROLE ( session_entry ) ) ; if ( mac_ctx -> lim . gLimRspReqd ) { mac_ctx -> lim . gLimRspReqd = false ; ret_code = eSIR_SME_INVALID_PARAMETERS ; deauth_trigger = eLIM_HOST_DEAUTH ; goto send_deauth ; } return ; } if ( sme_deauth_req . reasonCode == eLIM_LINK_MONITORING_DEAUTH ) { lim_log ( mac_ctx , LOG1 , FL ( "**<S2SV_blank>Lost<S2SV_blank>link<S2SV_blank>with<S2SV_blank>AP<S2SV_blank>**" ) ) ; deauth_trigger = eLIM_LINK_MONITORING_DEAUTH ; reason_code = eSIR_MAC_UNSPEC_FAILURE_REASON ; } else { deauth_trigger = eLIM_HOST_DEAUTH ; reason_code = sme_deauth_req . reasonCode ; } mlm_deauth_req = qdf_mem_malloc ( sizeof ( tLimMlmDeauthReq ) ) ; if ( NULL == mlm_deauth_req ) { lim_log ( mac_ctx , LOGP , FL ( "call<S2SV_blank>to<S2SV_blank>AllocateMemory<S2SV_blank>failed<S2SV_blank>for<S2SV_blank>mlmDeauthReq" ) ) ; if ( mac_ctx -> lim . gLimRspReqd ) { mac_ctx -> lim . gLimRspReqd = false ; ret_code = eSIR_SME_RESOURCES_UNAVAILABLE ; deauth_trigger = eLIM_HOST_DEAUTH ; goto send_deauth ; } return ; } qdf_copy_macaddr ( & mlm_deauth_req -> peer_macaddr , & sme_deauth_req . peer_macaddr ) ; mlm_deauth_req -> reasonCode = reason_code ; mlm_deauth_req -> deauthTrigger = deauth_trigger ; mlm_deauth_req -> sessionId = session_id ; lim_post_mlm_message ( mac_ctx , LIM_MLM_DEAUTH_REQ , ( uint32_t * ) mlm_deauth_req ) ; return ; send_deauth : lim_send_sme_deauth_ntf ( mac_ctx , sme_deauth_req . peer_macaddr . bytes , ret_code , deauth_trigger , 1 , sme_session_id , sme_transaction_id ) ; } | <S2SV_ModStart> != eLIM_MLM_WT_DEL_STA_RSP_STATE ) { <S2SV_ModStart> goto send_deauth ; } |
234 | CWE-000 static void cpu_ib_input_event ( struct input_handle * handle , unsigned int type , unsigned int code , int value ) { struct boost_policy * b = boost_policy_g ; struct ib_config * ib = & b -> ib ; uint32_t state ; state = get_boost_state ( b ) ; if ( ! ( state & DRIVER_ENABLED ) || ! ( state & ! state_suspended ) || ( state & WAKE_BOOST ) || ( state & INPUT_REBOOST ) ) return ; if ( state & INPUT_BOOST ) { set_boost_bit ( b , INPUT_REBOOST ) ; <S2SV_StartBug> queue_work ( system_power_efficient_wq , & ib -> reboost_work ) ; <S2SV_EndBug> return ; } set_boost_bit ( b , INPUT_BOOST ) ; <S2SV_StartBug> queue_work ( system_power_efficient_wq , & ib -> boost_work ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; queue_work ( b -> wq <S2SV_ModEnd> , & ib <S2SV_ModStart> ; queue_work ( b -> wq <S2SV_ModEnd> , & ib |
235 | CWE-000 void respond ( int cfd , int code , const char * headers , const char * body , size_t length ) { const char * phrase = reason ( code ) ; if ( phrase == NULL ) return ; if ( dprintf ( cfd , "HTTP/1.1<S2SV_blank>%i<S2SV_blank>%s\\r\\n" , code , phrase ) < 0 ) return ; <S2SV_StartBug> const char * defaultHeader = "X-Content-Type-Options:<S2SV_blank>nosniff\\r\\n\\\n<S2SV_blank>Server:<S2SV_blank>serverX/%s<S2SV_blank>(%s)\\r\\n%s\\r\\n" ; <S2SV_EndBug> int len = dprintf ( cfd , defaultHeader , serverX_VERSION , PLATFORM , headers ) ; if ( len < 0 ) return ; if ( write ( cfd , body , length ) == - 1 ) return ; if ( code == 200 ) { SUCCESS ; } else { DANGER ; } <S2SV_StartBug> printf ( "HTTP/1.1<S2SV_blank>%i<S2SV_blank>%s" , code , phrase ) ; <S2SV_EndBug> RESET ; fflush ( stdout ) ; } | <S2SV_ModStart> * defaultHeader = "X-Content-Type-Options:<S2SV_blank>nosniff\\r\\n\\\nServer:<S2SV_blank>serverX/%s<S2SV_blank>(%s)\\r\\n%s\\r\\n" <S2SV_ModEnd> ; int len <S2SV_ModStart> } printf ( "HTTP/1.1<S2SV_blank>%i<S2SV_blank>%s\\n" <S2SV_ModEnd> , code , |
236 | CWE-000 void switch_to_ring3 ( task_struct * task ) { kprintf ( "ring3" ) ; kernel_rsp = current -> kstack ; uint64_t uf = ( uint64_t ) & user_func ; <S2SV_StartBug> uint64_t rsp_cp ; <S2SV_EndBug> set_tss_rsp ( task -> kstack ) ; set_CR3 ( task -> cr3 ) ; __asm__ __volatile__ ( "movq<S2SV_blank>%%rsp,%0" : "=r" ( rsp_cp ) ) ; __asm__ __volatile__ ( "xchg<S2SV_blank>%bx,<S2SV_blank>%bx" ) ; __asm__ __volatile__ ( "cli;" "movq<S2SV_blank>%0,%%rax;" "pushq<S2SV_blank>$0x23;" "pushq<S2SV_blank>%%rax;" "pushfq;" "popq<S2SV_blank>%%rax;" "orq<S2SV_blank>$0x200,<S2SV_blank>%%rax;" "pushq<S2SV_blank>%%rax;" "pushq<S2SV_blank>$0x2B;" "pushq<S2SV_blank>%1;" : : "r" ( task -> rsp ) , "r" ( task -> rip ) ) ; __asm__ __volatile__ ( "iretq;" ) ; } | <S2SV_ModStart> ; uint64_t rsp_cp ; current = task |
237 | CWE-000 void init_MQTT ( ) { struct_size = sizeof ( long ) * 2 + sizeof ( short int ) * 3 + sizeof ( unsigned long long ) * 2 + sizeof ( time_t ) * 2 ; status = MQTT_STATUS_INIT ; connection = MQTT_CONNECT_OFF ; get_device_id ( ) ; construct_topic ( ) ; <S2SV_StartBug> MQTTClient_create ( & client , ADDRESS , id , MQTTCLIENT_PERSISTENCE_NONE , NULL ) ; <S2SV_EndBug> conn_opts . keepAliveInterval = 20 ; conn_opts . cleansession = 1 ; MQTTClient_setCallbacks ( client , NULL , connlost , msgarrvd , delivered ) ; connect_and_subscribe ( ) ; last_try = time ( NULL ) ; } | <S2SV_ModStart> & client , options . mqtt_addr <S2SV_ModEnd> , id , |
238 | CWE-000 void SDRAM_Init ( SDRAM_HandleTypeDef * hsdram ) { __IO uint32_t tmpmrd = 0 ; FMC_SDRAM_CommandTypeDef Command ; Command . CommandMode = FMC_SDRAM_CMD_CLK_ENABLE ; Command . CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1 ; Command . AutoRefreshNumber = 1 ; Command . ModeRegisterDefinition = 0 ; HAL_SDRAM_SendCommand ( hsdram , & Command , ( ( uint32_t ) 0xFFFF ) ) ; <S2SV_StartBug> HAL_Delay ( 100 ) ; <S2SV_EndBug> Command . CommandMode = FMC_SDRAM_CMD_PALL ; Command . CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1 ; Command . AutoRefreshNumber = 1 ; Command . ModeRegisterDefinition = 0 ; HAL_SDRAM_SendCommand ( hsdram , & Command , ( ( uint32_t ) 0xFFFF ) ) ; Command . CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE ; Command . CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1 ; <S2SV_StartBug> Command . AutoRefreshNumber = 8 ; <S2SV_EndBug> Command . ModeRegisterDefinition = 0 ; HAL_SDRAM_SendCommand ( hsdram , & Command , ( ( uint32_t ) 0xFFFF ) ) ; <S2SV_StartBug> tmpmrd = ( uint32_t ) SDRAM_MODEREG_BURST_LENGTH_1 | <S2SV_EndBug> SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL | SDRAM_MODEREG_CAS_LATENCY_2 | SDRAM_MODEREG_OPERATING_MODE_STANDARD | SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ; Command . CommandMode = FMC_SDRAM_CMD_LOAD_MODE ; Command . CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1 ; Command . AutoRefreshNumber = 1 ; Command . ModeRegisterDefinition = tmpmrd ; HAL_SDRAM_SendCommand ( hsdram , & Command , ( ( uint32_t ) 0xFFFF ) ) ; <S2SV_StartBug> hsdram -> Instance -> SDRTR |= ( ( uint32_t ) ( ( 1854 ) << 1 ) ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; HAL_Delay ( 1 <S2SV_ModEnd> ) ; Command <S2SV_ModStart> . AutoRefreshNumber = 4 <S2SV_ModEnd> ; Command . <S2SV_ModStart> ( uint32_t ) SDRAM_MODEREG_BURST_LENGTH_2 <S2SV_ModEnd> | SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL | <S2SV_ModStart> ) ( ( 448 <S2SV_ModEnd> ) << 1 |
239 | CWE-000 ssize_t read_textfile ( const char * filename , size_t letters ) { int file ; char * buf ; ssize_t n ; ssize_t t ; if ( ! filename || ! letters ) return ( 0 ) ; buf = malloc ( sizeof ( * buf ) * letters ) ; if ( ! buf ) return ( 0 ) ; file = open ( filename , O_RDONLY ) ; if ( file == - 1 ) { free ( buf ) ; return ( 0 ) ; } n = read ( file , buf , letters ) ; if ( n < 0 ) { free ( buf ) ; return ( 0 ) ; } t = write ( STDOUT_FILENO , buf , letters ) ; <S2SV_StartBug> t = close ( file ) ; <S2SV_EndBug> <S2SV_StartBug> if ( t < 0 || t != n ) <S2SV_EndBug> { free ( buf ) ; return ( 0 ) ; } free ( buf ) ; return ( n ) ; } | <S2SV_ModStart> letters ) ; if ( t < 0 || t != n ) { <S2SV_ModStart> file ) ; free ( buf ) ; return ( 0 ) ; } t = close ( file ) ; <S2SV_ModEnd> free ( buf |
240 | CWE-000 static int found_other ( struct asfd * asfd , struct FF_PKT * ff_pkt , struct conf * * confs , bool top_level ) { # ifdef HAVE_FREEBSD_OS if ( ( S_ISBLK ( ff_pkt -> statp . st_mode ) || S_ISCHR ( ff_pkt -> statp . st_mode ) ) && need_to_read_blockdev ( confs , ff_pkt -> fname ) ) { # else if ( S_ISBLK ( ff_pkt -> statp . st_mode ) && need_to_read_blockdev ( confs , ff_pkt -> fname ) ) { # endif ff_pkt -> type = FT_RAW ; } else if ( S_ISFIFO ( ff_pkt -> statp . st_mode ) && need_to_read_fifo ( confs , ff_pkt -> fname ) ) { ff_pkt -> type = FT_FIFO ; } else { ff_pkt -> type = FT_SPEC ; } <S2SV_StartBug> return send_file_w ( asfd , ff_pkt , top_level , confs ) ; <S2SV_EndBug> } | <S2SV_ModStart> ; } return burp_send_file_w <S2SV_ModEnd> ( asfd , |
241 | CWE-000 DEFINE_RUN_ONCE_STATIC ( do_rand_drbg_init ) { if ( ! OPENSSL_init_crypto ( 0 , NULL ) ) return 0 ; <S2SV_StartBug> drbg_master = drbg_setup ( "drbg_master" , NULL ) ; <S2SV_EndBug> <S2SV_StartBug> drbg_public = drbg_setup ( "drbg_public" , drbg_master ) ; <S2SV_EndBug> <S2SV_StartBug> drbg_private = drbg_setup ( "drbg_private" , drbg_master ) ; <S2SV_EndBug> if ( drbg_master == NULL || drbg_public == NULL || drbg_private == NULL ) return 0 ; return 1 ; } | <S2SV_ModStart> = drbg_setup ( <S2SV_ModEnd> NULL ) ; <S2SV_ModStart> = drbg_setup ( <S2SV_ModEnd> drbg_master ) ; <S2SV_ModStart> = drbg_setup ( <S2SV_ModEnd> drbg_master ) ; |
242 | CWE-000 HTTPAPI_RESULT HTTPAPI_SetOption ( HTTP_HANDLE handle , const char * optionName , const void * value ) { HTTPAPI_RESULT result ; HTTP_HANDLE_DATA * http_instance = ( HTTP_HANDLE_DATA * ) handle ; if ( ( http_instance == NULL ) || ( optionName == NULL ) || ( value == NULL ) ) { result = HTTPAPI_INVALID_ARG ; } else if ( strcmp ( "TrustedCerts" , optionName ) == 0 ) { <S2SV_StartBug> if ( http_instance -> certificate ) <S2SV_EndBug> { free ( http_instance -> certificate ) ; } <S2SV_StartBug> int len = ( int ) strlen ( ( char * ) value ) ; <S2SV_EndBug> http_instance -> certificate = ( char * ) malloc ( ( len + 1 ) * sizeof ( char ) ) ; if ( http_instance -> certificate == NULL ) { result = HTTPAPI_ALLOC_FAILED ; LogInfo ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>the<S2SV_blank>certificate<S2SV_blank>in<S2SV_blank>HTTPAPI_SetOption" ) ; } else { ( void ) strcpy ( http_instance -> certificate , ( const char * ) value ) ; result = HTTPAPI_OK ; } } else if ( strcmp ( SU_OPTION_X509_CERT , optionName ) == 0 ) { <S2SV_StartBug> if ( http_instance -> x509ClientCertificate ) <S2SV_EndBug> { free ( http_instance -> x509ClientCertificate ) ; } <S2SV_StartBug> int len = ( int ) strlen ( ( char * ) value ) ; <S2SV_EndBug> http_instance -> x509ClientCertificate = ( char * ) malloc ( ( len + 1 ) * sizeof ( char ) ) ; if ( http_instance -> x509ClientCertificate == NULL ) { result = HTTPAPI_ALLOC_FAILED ; LogInfo ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>the<S2SV_blank>client<S2SV_blank>certificate<S2SV_blank>in<S2SV_blank>HTTPAPI_SetOption" ) ; } else { ( void ) strcpy ( http_instance -> x509ClientCertificate , ( const char * ) value ) ; result = HTTPAPI_OK ; } } else if ( strcmp ( SU_OPTION_X509_PRIVATE_KEY , optionName ) == 0 ) { <S2SV_StartBug> if ( http_instance -> x509ClientPrivateKey ) <S2SV_EndBug> { free ( http_instance -> x509ClientPrivateKey ) ; } <S2SV_StartBug> int len = ( int ) strlen ( ( char * ) value ) ; <S2SV_EndBug> http_instance -> x509ClientPrivateKey = ( char * ) malloc ( ( len + 1 ) * sizeof ( char ) ) ; if ( http_instance -> x509ClientPrivateKey == NULL ) { result = HTTPAPI_ALLOC_FAILED ; LogInfo ( "unable<S2SV_blank>to<S2SV_blank>allocate<S2SV_blank>memory<S2SV_blank>for<S2SV_blank>the<S2SV_blank>client<S2SV_blank>private<S2SV_blank>key<S2SV_blank>in<S2SV_blank>HTTPAPI_SetOption" ) ; } else { ( void ) strcpy ( http_instance -> x509ClientPrivateKey , ( const char * ) value ) ; result = HTTPAPI_OK ; } } else { result = HTTPAPI_INVALID_ARG ; LogInfo ( "unknown<S2SV_blank>option<S2SV_blank>%s" , optionName ) ; } return result ; } | <S2SV_ModStart> 0 ) { int len ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> len = ( <S2SV_ModStart> 0 ) { int len ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> len = ( <S2SV_ModStart> 0 ) { int len ; <S2SV_ModStart> ) ; } <S2SV_ModEnd> len = ( |
243 | CWE-000 static ssize_t _MOCKABLE ( as_read ) ( int sock_fd , void * buf , size_t count ) { socklen_t length ; ssize_t n_rbytes = recvfrom ( sock_fd , buf , count , 0 , ( struct sockaddr * ) & ac -> serveraddr , & length ) ; if ( n_rbytes <= 0 ) { agent_printf ( "The<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>the<S2SV_blank>agent<S2SV_blank>server<S2SV_blank>is<S2SV_blank>broken<S2SV_blank>while<S2SV_blank>reading\\n" ) ; <S2SV_StartBug> agent_printf ( "%s\\n" , strerror ( errno ) ) ; <S2SV_EndBug> agent_cleanup ( ) ; } return n_rbytes ; } | <S2SV_ModStart> "The<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>the<S2SV_blank>agent<S2SV_blank>server<S2SV_blank>is<S2SV_blank>broken<S2SV_blank>while<S2SV_blank>reading\\n" ) ; <S2SV_ModEnd> agent_cleanup ( ) |
244 | CWE-000 static void vxlan_sock_release ( struct vxlan_dev * vxlan ) { struct vxlan_sock * sock4 = rtnl_dereference ( vxlan -> vn4_sock ) ; # if IS_ENABLED ( CONFIG_IPV6 ) struct vxlan_sock * sock6 = rtnl_dereference ( vxlan -> vn6_sock ) ; rcu_assign_pointer ( vxlan -> vn6_sock , NULL ) ; # endif rcu_assign_pointer ( vxlan -> vn4_sock , NULL ) ; synchronize_net ( ) ; <S2SV_StartBug> if ( __vxlan_sock_release_prep ( sock4 ) ) { <S2SV_EndBug> udp_tunnel_sock_release ( sock4 -> sock ) ; kfree ( sock4 ) ; } # if IS_ENABLED ( CONFIG_IPV6 ) if ( __vxlan_sock_release_prep ( sock6 ) ) { udp_tunnel_sock_release ( sock6 -> sock ) ; kfree ( sock6 ) ; } # endif } | <S2SV_ModStart> ( ) ; vxlan_vs_del_dev ( vxlan ) ; |
245 | CWE-000 static int wait_for_usbin_uv ( struct smbchg_chip * chip , bool high ) { <S2SV_StartBug> int rc ; <S2SV_EndBug> int tries = 3 ; struct completion * completion = & chip -> usbin_uv_lowered ; bool usbin_uv ; if ( high ) completion = & chip -> usbin_uv_raised ; while ( tries -- ) { rc = wait_for_completion_interruptible_timeout ( completion , msecs_to_jiffies ( APSD_TIMEOUT_MS ) ) ; if ( rc >= 0 ) break ; } usbin_uv = is_usbin_uv_high ( chip ) ; if ( high == usbin_uv ) return 0 ; pr_err ( "usbin<S2SV_blank>uv<S2SV_blank>didnt<S2SV_blank>go<S2SV_blank>to<S2SV_blank>a<S2SV_blank>%s<S2SV_blank>state,<S2SV_blank>still<S2SV_blank>at<S2SV_blank>%s,<S2SV_blank>tries<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>rc<S2SV_blank>=<S2SV_blank>%d\\n" , high ? "risen" : "lowered" , usbin_uv ? "high" : "low" , tries , rc ) ; return - EINVAL ; } | <S2SV_ModStart> { int rc = 0 |
246 | CWE-000 static void do_intel_finish_page_flip ( struct drm_device * dev , struct drm_crtc * crtc ) { drm_i915_private_t * dev_priv = dev -> dev_private ; struct intel_crtc * intel_crtc = to_intel_crtc ( crtc ) ; struct intel_unpin_work * work ; unsigned long flags ; if ( intel_crtc == NULL ) return ; spin_lock_irqsave ( & dev -> event_lock , flags ) ; work = intel_crtc -> unpin_work ; smp_rmb ( ) ; if ( work == NULL || atomic_read ( & work -> pending ) < INTEL_FLIP_COMPLETE ) { spin_unlock_irqrestore ( & dev -> event_lock , flags ) ; return ; } smp_rmb ( ) ; intel_crtc -> unpin_work = NULL ; if ( work -> event ) drm_send_vblank_event ( dev , intel_crtc -> pipe , work -> event ) ; drm_vblank_put ( dev , intel_crtc -> pipe ) ; spin_unlock_irqrestore ( & dev -> event_lock , flags ) ; wake_up_all ( & dev_priv -> pending_flip_queue ) ; <S2SV_StartBug> queue_work ( dev_priv -> wq , & work -> work ) ; <S2SV_EndBug> trace_i915_flip_complete ( intel_crtc -> plane , work -> pending_flip_obj ) ; } | <S2SV_ModStart> pending_flip_queue ) ; trace_i915_flip_complete ( intel_crtc -> plane , work -> pending_flip_obj ) ; <S2SV_ModStart> work -> work <S2SV_ModEnd> ) ; } |
247 | CWE-000 UBTEDU_RC_T ubtRobot_Msg_Decode_VisionDetect ( char * pcRecvBuf , char * pcValue ) { UBTEDU_RC_T ubtRet = UBTEDU_RC_FAILED ; cJSON * pJson = NULL ; cJSON * pNode = NULL ; char acCmd [ MSG_CMD_STR_MAX_LEN ] ; char type [ 32 ] ; <S2SV_StartBug> UBTEDU_RC_T ret = UBTEDU_RC_FAILED ; r <S2SV_EndBug> if ( NULL == pcRecvBuf ) { return UBTEDU_RC_WRONG_PARAM ; } acCmd [ 0 ] = '\\0' ; pJson = cJSON_Parse ( pcRecvBuf ) ; if ( pJson == NULL ) { printf ( "Parse<S2SV_blank>json<S2SV_blank>message<S2SV_blank>filed!\\r\\n" ) ; ret = UBTEDU_RC_SOCKET_DECODE_FAILED ; return ret ; } do { pNode = cJSON_GetObjectItem ( pJson , pcStr_Msg_Cmd ) ; if ( pNode != NULL ) { if ( pNode -> type == cJSON_String ) { strncpy ( acCmd , pNode -> valuestring , sizeof ( acCmd ) ) ; } } pNode = cJSON_GetObjectItem ( pJson , pcStr_Msg_Type ) ; if ( pNode != NULL ) { if ( pNode -> type == cJSON_String ) { strncpy ( type , pNode -> valuestring , sizeof ( type ) ) ; } } pNode = cJSON_GetObjectItem ( pJson , pcStr_Ret_Msg_Status ) ; if ( pNode != NULL ) { if ( pNode -> type == cJSON_String ) { if ( ! strcmp ( pNode -> valuestring , "ok" ) && ! strcmp ( acCmd , pcStr_Msg_Cmd_Vision_Ack ) ) { if ( ! strcmp ( type , pcStr_Msg_Type_Vision_Face ) ) { pNode = cJSON_GetObjectItem ( pJson , pcStr_Msg_Data ) ; if ( pNode != NULL ) { if ( pNode -> type == cJSON_String ) { strcpy ( pcValue , pNode -> valuestring ) ; DebugTrace ( "OK<S2SV_blank>faceValue<S2SV_blank>Detected!!!!!<S2SV_blank>pcValue<S2SV_blank>=<S2SV_blank>%s<S2SV_blank>\\r\\n" , pcValue ) ; if ( ! strcmp ( pcValue , "0" ) ) { ubtRet = UBTEDU_RC_FAILED ; } else { ubtRet = UBTEDU_RC_SUCCESS ; } } } } if ( ! strcmp ( type , pcStr_Msg_Type_Vision_Hand ) ) { pNode = cJSON_GetObjectItem ( pJson , pcStr_Msg_Data ) ; if ( pNode != NULL ) { if ( pNode -> type == cJSON_String ) { strcpy ( pcValue , pNode -> valuestring ) ; DebugTrace ( "OK<S2SV_blank>handValue<S2SV_blank>Detected!!!!!<S2SV_blank>pcValue<S2SV_blank>=<S2SV_blank>%s<S2SV_blank>\\r\\n" , pcValue ) ; if ( ! strcmp ( pcValue , "0" ) ) { ubtRet = UBTEDU_RC_FAILED ; } else { ubtRet = UBTEDU_RC_SUCCESS ; } } } } } ret = UBTEDU_RC_SUCCESS ; } } } while ( 0 ) ; cJSON_Delete ( pJson ) ; return ubtRet ; } | <S2SV_ModStart> = UBTEDU_RC_FAILED ; <S2SV_ModEnd> if ( NULL |
248 | CWE-000 int Instance_equals ( Instance * i1 , Instance * i2 ) { if ( i1 == NULL && i2 == NULL ) return 1 ; else if ( i1 == NULL || i2 == NULL ) return 0 ; if ( i1 -> nbJobs != i2 -> nbJobs || i1 -> nbMachine != i2 -> nbMachine ) return 0 ; unsigned int i , j ; if ( i1 -> deliveryDates != i2 -> deliveryDates ) for ( i = 0 ; i < i1 -> nbJobs ; i ++ ) if ( i1 -> deliveryDates [ i ] != i2 -> deliveryDates [ i ] ) return 0 ; if ( i1 -> times != i2 -> times ) <S2SV_StartBug> for ( i = 0 ; i < i1 -> nbMachine ; i ++ ) <S2SV_EndBug> for ( j = 0 ; j < i1 -> nbJobs ; j ++ ) if ( i1 -> times [ i ] [ j ] != i2 -> times [ i ] [ j ] ) return 0 ; if ( i1 -> distances != i2 -> distances ) for ( i = 0 ; i < i1 -> nbJobs + 1 ; i ++ ) for ( j = 0 ; j < i1 -> nbJobs + 1 ; i ++ ) if ( i1 -> distances [ i ] [ j ] != i2 -> distances [ i ] [ j ] ) return 0 ; if ( Solution_equals ( i1 -> solution , i2 -> solution ) == 0 ) return 0 ; return 1 ; } | <S2SV_ModStart> < i1 -> nbJobs ; i ++ ) for ( j = 0 ; j < i1 -> nbMachine <S2SV_ModEnd> ; j ++ |
249 | CWE-000 static pid_t mingw_spawnve_fd ( const char * cmd , const char * * argv , char * * deltaenv , const char * dir , int prepend_cmd , int fhin , int fhout , int fherr ) <S2SV_StartBug> { <S2SV_EndBug> STARTUPINFOW si ; PROCESS_INFORMATION pi ; struct strbuf args ; wchar_t wcmd [ MAX_PATH ] , wdir [ MAX_PATH ] , * wargs , * wenvblk = NULL ; unsigned flags = CREATE_UNICODE_ENVIRONMENT ; BOOL ret ; HANDLE cons ; <S2SV_StartBug> do_unset_environment_variables ( ) ; <S2SV_EndBug> cons = CreateFile ( "CONOUT$" , GENERIC_WRITE , FILE_SHARE_WRITE , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL ) ; if ( cons == INVALID_HANDLE_VALUE ) { flags |= DETACHED_PROCESS ; } else { CloseHandle ( cons ) ; } memset ( & si , 0 , sizeof ( si ) ) ; si . cb = sizeof ( si ) ; si . dwFlags = STARTF_USESTDHANDLES ; si . hStdInput = winansi_get_osfhandle ( fhin ) ; si . hStdOutput = winansi_get_osfhandle ( fhout ) ; si . hStdError = winansi_get_osfhandle ( fherr ) ; if ( * argv && ! strcmp ( cmd , * argv ) ) wcmd [ 0 ] = L'\\0' ; else if ( xutftowcs_path ( wcmd , cmd ) < 0 ) return - 1 ; if ( dir && xutftowcs_path ( wdir , dir ) < 0 ) return - 1 ; strbuf_init ( & args , 0 ) ; if ( prepend_cmd ) { char * quoted = ( char * ) quote_arg ( cmd ) ; strbuf_addstr ( & args , quoted ) ; if ( quoted != cmd ) free ( quoted ) ; } for ( ; * argv ; argv ++ ) { char * quoted = ( char * ) quote_arg ( * argv ) ; if ( * args . buf ) strbuf_addch ( & args , '<S2SV_blank>' ) ; strbuf_addstr ( & args , quoted ) ; if ( quoted != * argv ) free ( quoted ) ; } if ( getenv ( "GIT_STRACE_COMMANDS" ) ) { char * * path = get_path_split ( ) ; char * p = path_lookup ( "strace.exe" , path , 1 ) ; if ( ! p ) { free_path_split ( path ) ; return error ( "strace<S2SV_blank>not<S2SV_blank>found!" ) ; } free_path_split ( path ) ; if ( xutftowcs_path ( wcmd , p ) < 0 ) { free ( p ) ; return - 1 ; } strbuf_insert ( & args , 0 , "strace<S2SV_blank>" , 7 ) ; free ( p ) ; } ALLOC_ARRAY ( wargs , st_add ( st_mult ( 2 , args . len ) , 1 ) ) ; xutftowcs ( wargs , args . buf , 2 * args . len + 1 ) ; strbuf_release ( & args ) ; wenvblk = make_environment_block ( deltaenv ) ; memset ( & pi , 0 , sizeof ( pi ) ) ; ret = CreateProcessW ( * wcmd ? wcmd : NULL , wargs , NULL , NULL , TRUE , flags , wenvblk , dir ? wdir : NULL , & si , & pi ) ; free ( wenvblk ) ; free ( wargs ) ; if ( ! ret ) { errno = ENOENT ; return - 1 ; } CloseHandle ( pi . hThread ) ; EnterCriticalSection ( & pinfo_cs ) ; { struct pinfo_t * info = xmalloc ( sizeof ( struct pinfo_t ) ) ; info -> pid = pi . dwProcessId ; info -> proc = pi . hProcess ; info -> next = pinfo ; pinfo = info ; } LeaveCriticalSection ( & pinfo_cs ) ; return ( pid_t ) pi . dwProcessId ; } | <S2SV_ModStart> fherr ) { static int atexit_handler_initialized ; <S2SV_ModStart> HANDLE cons ; if ( ! atexit_handler_initialized ) { atexit_handler_initialized = 1 ; atexit ( kill_child_processes_on_signal ) ; } |
250 | CWE-000 static void yang_free_leaflist ( struct ly_ctx * ctx , struct lys_node_leaflist * leaflist ) { uint8_t i ; for ( i = 0 ; i < leaflist -> must_size ; i ++ ) { <S2SV_StartBug> lys_restr_free ( ctx , & leaflist -> must [ i ] ) ; <S2SV_EndBug> } free ( leaflist -> must ) ; for ( i = 0 ; i < leaflist -> dflt_size ; i ++ ) { lydict_remove ( ctx , leaflist -> dflt [ i ] ) ; } free ( leaflist -> dflt ) ; <S2SV_StartBug> lys_when_free ( ctx , leaflist -> when ) ; <S2SV_EndBug> yang_type_free ( ctx , & leaflist -> type ) ; lydict_remove ( ctx , leaflist -> units ) ; } | <S2SV_ModStart> [ i ] , NULL <S2SV_ModStart> leaflist -> when , NULL |
251 | CWE-000 static void grisbi_win_no_file_page_new ( GrisbiWin * win ) { gchar * * recent_files_array ; gint i ; gint col = 0 ; gint row = 1 ; GrisbiWinPrivate * priv ; devel_debug ( NULL ) ; priv = grisbi_win_get_instance_private ( GRISBI_WIN ( win ) ) ; gtk_container_set_border_width ( GTK_CONTAINER ( priv -> no_file_page ) , MARGIN_BOX ) ; gtk_grid_set_column_spacing ( GTK_GRID ( priv -> no_file_grid ) , MARGIN_PADDING_BOX ) ; gtk_grid_set_column_homogeneous ( GTK_GRID ( priv -> no_file_grid ) , TRUE ) ; gtk_grid_set_row_spacing ( GTK_GRID ( priv -> no_file_grid ) , MARGIN_PADDING_BOX ) ; gtk_grid_set_row_homogeneous ( GTK_GRID ( priv -> no_file_grid ) , TRUE ) ; gtk_widget_set_hexpand ( priv -> no_file_grid , TRUE ) ; gtk_widget_set_vexpand ( priv -> no_file_grid , TRUE ) ; gtk_container_add ( GTK_CONTAINER ( priv -> no_file_sw ) , priv -> no_file_grid ) ; gtk_actionable_set_action_name ( GTK_ACTIONABLE ( priv -> bouton_nouveau ) , "win.new-acc-file" ) ; gtk_actionable_set_action_name ( GTK_ACTIONABLE ( priv -> bouton_ouvrir ) , "win.open-file" ) ; priv -> bouton_importer = utils_buttons_button_new_from_stock ( "gtk-convert" , _ ( "Import" ) ) ; gtk_button_set_image_position ( GTK_BUTTON ( priv -> bouton_importer ) , GTK_POS_TOP ) ; gtk_widget_set_size_request ( priv -> bouton_importer , 150 , 150 ) ; gtk_widget_set_halign ( priv -> bouton_importer , GTK_ALIGN_CENTER ) ; gtk_widget_set_valign ( priv -> bouton_importer , GTK_ALIGN_CENTER ) ; gtk_actionable_set_action_name ( GTK_ACTIONABLE ( priv -> bouton_importer ) , "win.import-file" ) ; gtk_grid_attach ( GTK_GRID ( priv -> no_file_grid ) , priv -> bouton_importer , 2 , 0 , 1 , 1 ) ; gtk_widget_show ( priv -> bouton_importer ) ; recent_files_array = grisbi_app_get_recent_files_array ( ) ; for ( i = 0 ; i < conf . nb_derniers_fichiers_ouverts ; i ++ ) { if ( g_file_test ( recent_files_array [ i ] , G_FILE_TEST_EXISTS ) ) { GtkWidget * bouton ; gchar * tmp_str ; gchar * target_value ; if ( g_utf8_strlen ( recent_files_array [ i ] , - 1 ) > GSB_NAMEFILE_TOO_LONG ) { gchar * basename ; basename = g_path_get_basename ( recent_files_array [ i ] ) ; tmp_str = utils_str_break_filename ( basename , GSB_NBRE_CHAR ) ; g_free ( basename ) ; } else tmp_str = utils_str_break_filename ( recent_files_array [ i ] , GSB_NBRE_CHAR ) ; bouton = utils_buttons_button_new_from_stock ( "gtk-open" , tmp_str ) ; <S2SV_StartBug> gtk_button_set_image_position ( GTK_BUTTON ( bouton ) , GTK_POS_TOP ) ; <S2SV_EndBug> gtk_widget_set_size_request ( bouton , 150 , 150 ) ; gtk_widget_set_halign ( bouton , GTK_ALIGN_CENTER ) ; gtk_widget_set_valign ( bouton , GTK_ALIGN_CENTER ) ; gtk_grid_attach ( GTK_GRID ( priv -> no_file_grid ) , bouton , col , row , 1 , 1 ) ; gtk_widget_show ( bouton ) ; target_value = g_strdup_printf ( "%d" , i + 1 ) ; gtk_actionable_set_action_target_value ( GTK_ACTIONABLE ( bouton ) , g_variant_new_string ( target_value ) ) ; gtk_actionable_set_action_name ( GTK_ACTIONABLE ( bouton ) , "win.direct-open-file" ) ; g_free ( target_value ) ; col ++ ; if ( ( col % 3 ) == 0 ) { col = 0 ; row ++ ; } g_free ( tmp_str ) ; } } gtk_widget_show ( priv -> no_file_page ) ; } | <S2SV_ModStart> tmp_str ) ; gtk_widget_set_tooltip_text ( bouton , recent_files_array [ i ] ) ; |
252 | CWE-000 int scan ( char * ip , int startPort , int endPort , int threadNum ) { pthread_t * pthreads ; ScanThreadArgsPtr argsArray ; int i , pthreadNum = threadNum ; printf ( "\\nScanning<S2SV_blank>%s......\\n" , ip ) ; pthreads = ( pthread_t * ) malloc ( sizeof ( pthread_t ) * pthreadNum ) ; argsArray = ( ScanThreadArgsPtr ) malloc ( sizeof ( ScanThreadArgs ) * pthreadNum ) ; for ( i = 0 ; i < pthreadNum ; i ++ ) { memset ( & argsArray [ i ] , 0 , sizeof ( argsArray [ i ] ) ) ; argsArray [ i ] . pthreadNum = pthreadNum ; argsArray [ i ] . port = startPort + i ; argsArray [ i ] . ip = ip ; argsArray [ i ] . end = endPort ; if ( pthread_create ( & pthreads [ i ] , NULL , scanThreadFunc , ( void * ) & argsArray [ i ] ) == - 1 ) { printf ( "Can;t<S2SV_blank>create<S2SV_blank>pthread!<S2SV_blank>Please<S2SV_blank>try<S2SV_blank>again!\\n" ) ; return 0 ; } } sleep ( 1 ) ; for ( i = 0 ; i < pthreadNum ; i ++ ) { pthread_join ( pthreads [ i ] , NULL ) ; } free ( pthreads ) ; free ( argsArray ) ; <S2SV_StartBug> printf ( "Scan<S2SV_blank>down.\\n" ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> ; printf ( "Scan<S2SV_blank>down.\\n\\n" <S2SV_ModEnd> ) ; return |
253 | CWE-000 static int stackinuse ( lua_State * L ) { CallInfo * ci ; StkId lim = L -> top ; for ( ci = L -> ci ; ci != NULL ; ci = ci -> previous ) { <S2SV_StartBug> lua_assert ( ci -> top <= L -> stack_last ) ; <S2SV_EndBug> if ( lim < ci -> top ) lim = ci -> top ; } <S2SV_StartBug> return cast_int ( lim - L -> stack ) + 1 ; <S2SV_EndBug> } | <S2SV_ModStart> previous ) { <S2SV_ModEnd> if ( lim <S2SV_ModStart> top ; } lua_assert ( lim <= L -> stack_last ) ; |
254 | CWE-000 int as_free_error ( t_list_error * * list ) { t_list_error * tmp ; while ( * list ) { tmp = * list ; if ( ( * list ) -> line ) free ( ( * list ) -> line ) ; if ( ( * list ) -> message ) free ( ( * list ) -> message ) ; free ( * list ) ; * list = tmp -> next ; } <S2SV_StartBug> return ( 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> } return ( 0 <S2SV_ModEnd> ) ; } |
255 | CWE-000 UNIV_INTERN const char * dict_load_table_low ( const char * name , const rec_t * rec , dict_table_t * * table ) { const byte * field ; ulint len ; ulint space ; ulint n_cols ; ulint flags ; if ( UNIV_UNLIKELY ( rec_get_deleted_flag ( rec , 0 ) ) ) { return ( "delete-marked<S2SV_blank>record<S2SV_blank>in<S2SV_blank>SYS_TABLES" ) ; } if ( UNIV_UNLIKELY ( rec_get_n_fields_old ( rec ) != 10 ) ) { return ( "wrong<S2SV_blank>number<S2SV_blank>of<S2SV_blank>columns<S2SV_blank>in<S2SV_blank>SYS_TABLES<S2SV_blank>record" ) ; } rec_get_nth_field_offs_old ( rec , 0 , & len ) ; if ( UNIV_UNLIKELY ( len < 1 || len == UNIV_SQL_NULL ) ) { err_len : return ( "incorrect<S2SV_blank>column<S2SV_blank>length<S2SV_blank>in<S2SV_blank>SYS_TABLES" ) ; } rec_get_nth_field_offs_old ( rec , 1 , & len ) ; if ( UNIV_UNLIKELY ( len != DATA_TRX_ID_LEN && len != UNIV_SQL_NULL ) ) { goto err_len ; } rec_get_nth_field_offs_old ( rec , 2 , & len ) ; if ( UNIV_UNLIKELY ( len != DATA_ROLL_PTR_LEN && len != UNIV_SQL_NULL ) ) { goto err_len ; } rec_get_nth_field_offs_old ( rec , 3 , & len ) ; if ( UNIV_UNLIKELY ( len != 8 ) ) { goto err_len ; } field = rec_get_nth_field_old ( rec , 4 , & len ) ; if ( UNIV_UNLIKELY ( len != 4 ) ) { goto err_len ; } n_cols = mach_read_from_4 ( field ) ; rec_get_nth_field_offs_old ( rec , 5 , & len ) ; if ( UNIV_UNLIKELY ( len != 4 ) ) { goto err_len ; } rec_get_nth_field_offs_old ( rec , 6 , & len ) ; if ( UNIV_UNLIKELY ( len != 8 ) ) { goto err_len ; } rec_get_nth_field_offs_old ( rec , 7 , & len ) ; if ( UNIV_UNLIKELY ( len != 4 ) ) { goto err_len ; } rec_get_nth_field_offs_old ( rec , 8 , & len ) ; if ( UNIV_UNLIKELY ( len != UNIV_SQL_NULL ) ) { goto err_len ; } field = rec_get_nth_field_old ( rec , 9 , & len ) ; if ( UNIV_UNLIKELY ( len != 4 ) ) { goto err_len ; } space = mach_read_from_4 ( field ) ; if ( space != 0 ) { flags = dict_sys_tables_get_flags ( rec ) ; if ( UNIV_UNLIKELY ( flags == ULINT_UNDEFINED ) ) { field = rec_get_nth_field_old ( rec , 5 , & len ) ; ut_ad ( len == 4 ) ; flags = mach_read_from_4 ( field ) ; ut_print_timestamp ( stderr ) ; fputs ( "<S2SV_blank><S2SV_blank>InnoDB:<S2SV_blank>Error:<S2SV_blank>table<S2SV_blank>" , stderr ) ; ut_print_filename ( stderr , name ) ; fprintf ( stderr , "\\n" "InnoDB:<S2SV_blank>in<S2SV_blank>InnoDB<S2SV_blank>data<S2SV_blank>dictionary" "<S2SV_blank>has<S2SV_blank>unknown<S2SV_blank>type<S2SV_blank>%lx.\\n" , ( ulong ) flags ) ; return ( "incorrect<S2SV_blank>flags<S2SV_blank>in<S2SV_blank>SYS_TABLES" ) ; } } else { flags = 0 ; } if ( n_cols & 0x80000000UL ) { ulint flags2 ; flags |= DICT_TF_COMPACT ; field = rec_get_nth_field_old ( rec , 7 , & len ) ; if ( UNIV_UNLIKELY ( len != 4 ) ) { goto err_len ; } flags2 = mach_read_from_4 ( field ) ; <S2SV_StartBug> if ( flags2 & ( ~ 0 << ( DICT_TF2_BITS - DICT_TF2_SHIFT ) ) ) { <S2SV_EndBug> ut_print_timestamp ( stderr ) ; fputs ( "<S2SV_blank><S2SV_blank>InnoDB:<S2SV_blank>Warning:<S2SV_blank>table<S2SV_blank>" , stderr ) ; ut_print_filename ( stderr , name ) ; fprintf ( stderr , "\\n" "InnoDB:<S2SV_blank>in<S2SV_blank>InnoDB<S2SV_blank>data<S2SV_blank>dictionary" "<S2SV_blank>has<S2SV_blank>unknown<S2SV_blank>flags<S2SV_blank>%lx.\\n" , ( ulong ) flags2 ) ; <S2SV_StartBug> flags2 &= ~ ( ~ 0 << ( DICT_TF2_BITS - DICT_TF2_SHIFT ) ) ; <S2SV_EndBug> } flags |= flags2 << DICT_TF2_SHIFT ; } * table = dict_mem_table_create ( name , space , n_cols & ~ 0x80000000UL , flags ) ; field = rec_get_nth_field_old ( rec , 3 , & len ) ; ut_ad ( len == 8 ) ; ( * table ) -> id = mach_read_from_8 ( field ) ; ( * table ) -> ibd_file_missing = FALSE ; return ( NULL ) ; } | <S2SV_ModStart> & ( ~ 0U <S2SV_ModEnd> << ( DICT_TF2_BITS <S2SV_ModStart> ~ ( ~ 0U <S2SV_ModEnd> << ( DICT_TF2_BITS |
256 | CWE-000 EFI_STATUS DumpTable ( EFI_ACPI_DESCRIPTION_HEADER * TableEntry , CHAR8 * CheckSignature , CHAR16 * DirName , CHAR16 * FileName , CHAR16 * FileNamePrefix , UINTN * SsdtCount ) { EFI_STATUS Status ; CHAR8 Signature [ 5 ] ; CHAR8 OemTableId [ 9 ] ; BOOLEAN ReleaseFileName = FALSE ; CopyMem ( ( CHAR8 * ) & Signature , ( CHAR8 * ) & TableEntry -> Signature , 4 ) ; Signature [ 4 ] = 0 ; CopyMem ( ( CHAR8 * ) & OemTableId , ( CHAR8 * ) & TableEntry -> OemTableId , 8 ) ; OemTableId [ 8 ] = 0 ; stripTrailingSpaces ( OemTableId ) ; DBG ( "<S2SV_blank>%p:<S2SV_blank>\'%a\',<S2SV_blank>\'%a\',<S2SV_blank>Rev:<S2SV_blank>%d,<S2SV_blank>Len:<S2SV_blank>%d" , TableEntry , Signature , OemTableId , TableEntry -> Revision , TableEntry -> Length ) ; if ( CheckSignature != NULL && AsciiStrCmp ( Signature , CheckSignature ) != 0 ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>signature,<S2SV_blank>expecting<S2SV_blank>%a\\n" , CheckSignature ) ; return EFI_INVALID_PARAMETER ; } if ( TableEntry -> Signature == EFI_ACPI_2_0_EXTENDED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE ) { if ( TableEntry -> Length < sizeof ( XSDT_TABLE ) ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>length\\n" ) ; return EFI_INVALID_PARAMETER ; } } if ( TableEntry -> Signature == EFI_ACPI_1_0_ROOT_SYSTEM_DESCRIPTION_TABLE_SIGNATURE ) { if ( TableEntry -> Length < sizeof ( RSDT_TABLE ) ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>length\\n" ) ; return EFI_INVALID_PARAMETER ; } } if ( TableEntry -> Signature == EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE ) { if ( TableEntry -> Length < sizeof ( EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE ) ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>length\\n" ) ; return EFI_INVALID_PARAMETER ; } } if ( TableEntry -> Signature == EFI_ACPI_1_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE ) { if ( TableEntry -> Length < sizeof ( EFI_ACPI_DESCRIPTION_HEADER ) ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>length\\n" ) ; return EFI_INVALID_PARAMETER ; } } if ( TableEntry -> Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE ) { if ( TableEntry -> Length < sizeof ( EFI_ACPI_DESCRIPTION_HEADER ) ) { DBG ( "<S2SV_blank>-><S2SV_blank>invalid<S2SV_blank>length\\n" ) ; return EFI_INVALID_PARAMETER ; } } if ( DirName == NULL || IsTableSaved ( TableEntry ) ) { return EFI_SUCCESS ; } if ( FileNamePrefix == NULL ) { FileNamePrefix = L"" ; } if ( FileName == NULL ) { if ( TableEntry -> Signature == EFI_ACPI_1_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE && SsdtCount != NULL ) { <S2SV_StartBug> FileName = GenerateFileName ( FileNamePrefix , * SsdtCount , - 1 , OemTableId ) ; <S2SV_EndBug> DumpChildSsdt ( TableEntry , DirName , FileNamePrefix , * SsdtCount ) ; * SsdtCount += 1 ; } else { FileName = PoolPrint ( L"%s%a.aml" , FileNamePrefix , Signature ) ; } if ( FileName == NULL ) { return EFI_OUT_OF_RESOURCES ; } ReleaseFileName = TRUE ; } DBG ( "<S2SV_blank>-><S2SV_blank>%s" , FileName ) ; Status = SaveBufferToDisk ( ( VOID * ) TableEntry , TableEntry -> Length , DirName , FileName ) ; MarkTableAsSaved ( TableEntry ) ; if ( ReleaseFileName ) { FreePool ( FileName ) ; } return Status ; } | <S2SV_ModStart> * SsdtCount , ~ ( UINTN ) 0 <S2SV_ModEnd> , OemTableId ) |
257 | CWE-000 Controller * Constructor_L1Controller ( ) { <S2SV_StartBug> Controller * l1ControllerCon = malloc ( sizeof ( l1ControllerCon ) ) ; <S2SV_EndBug> Address * address = Constructor_Address ( "0000000000000000" ) ; l1ControllerCon -> controllerIsIdleUntilItReceivesThisBlock = * Constructor_Block ( * address ) ; l1ControllerCon -> writeBlockQueue = Constructor_BlockQueue ( ) ; l1ControllerCon -> cache = Constructor_Cache ( 64 ) ; l1ControllerCon -> transferer = Constructor_Transferer ( ) ; l1ControllerCon -> waiting = false ; return l1ControllerCon ; } | <S2SV_ModStart> ( l1ControllerCon ) <S2SV_ModEnd> ) ; l1ControllerCon |
258 | CWE-000 int vm_decompiler_param ( t_process * p , t_op * op , int c ) { int i ; i = 0 ; while ( i < g_op_dict [ op -> opcode ] . param_c ) { op -> params [ i ] . type = ( g_op_dict [ op -> opcode ] . is_oc ) ? ( op -> oc & ( 0xC0 >> ( i * 2 ) ) ) >> ( ( 3 - i ) * 2 ) : op -> oc ; <S2SV_StartBug> if ( ( op -> params [ i ] . type & g_op_dict [ op -> opcode ] . p_type [ i ] ) == <S2SV_EndBug> op -> params [ i ] . type || ! g_op_dict [ op -> opcode ] . is_oc ) { <S2SV_StartBug> ( op -> params [ i ] . type == T_REG ) ? op -> params [ i ] . size = 1 : 0 ; <S2SV_EndBug> <S2SV_StartBug> ( op -> params [ i ] . type == T_IND ) ? op -> params [ i ] . size = 2 : 0 ; <S2SV_EndBug> ( op -> params [ i ] . type == T_DIR ) ? op -> params [ i ] . size = g_op_dict [ op -> opcode ] . d_size : 0 ; op -> params [ i ] . value = vm_binary_toint ( & g_memory [ p -> offset + p -> pc + c + i ] , op -> params [ i ] . size ) ; op -> size += op -> params [ i ] . size ; <S2SV_StartBug> } <S2SV_EndBug> else return ( - 1 ) ; i ++ ; } return ( 0 ) ; } | <S2SV_ModStart> -> oc ; ( op -> params [ i ] . type == REG_CODE ) ? op -> params [ i ] . size = 1 : 0 ; <S2SV_ModEnd> ( op -> <S2SV_ModStart> . type == IND_CODE ) ? op -> params [ i ] . size = 2 <S2SV_ModEnd> : 0 ; <S2SV_ModStart> . type == DIR_CODE <S2SV_ModEnd> ) ? op <S2SV_ModStart> . size ; <S2SV_ModEnd> i ++ ; |
259 | CWE-000 const char * _yr_compiler_default_include_callback ( const char * include_name , const char * calling_rule_filename , const char * calling_rule_namespace , void * user_data ) <S2SV_StartBug> { <S2SV_EndBug> struct stat stbuf ; <S2SV_StartBug> # ifdef _WIN32 <S2SV_EndBug> char * b = NULL ; # endif char * s = NULL ; char * f ; char * file_buffer ; char buffer [ 1024 ] ; # ifdef _WIN32 long file_size ; # else off_t file_size ; # endif int fd = - 1 ; if ( calling_rule_filename != NULL ) strlcpy ( buffer , calling_rule_filename , sizeof ( buffer ) ) ; else buffer [ 0 ] = '\\0' ; s = strrchr ( buffer , '/' ) ; # ifdef _WIN32 b = strrchr ( buffer , '\\\\' ) ; # endif # ifdef _WIN32 if ( s != NULL || b != NULL ) # else if ( s != NULL ) # endif { # ifdef _WIN32 f = ( b > s ) ? ( b + 1 ) : ( s + 1 ) ; # else f = s + 1 ; # endif strlcpy ( f , include_name , sizeof ( buffer ) - ( f - buffer ) ) ; f = buffer ; # ifdef _WIN32 _sopen_s ( & fd , f , _O_RDONLY , _SH_DENYRW , _S_IREAD ) ; # else fd = open ( f , O_RDONLY ) ; # endif if ( fd == - 1 ) { f = ( char * ) include_name ; } } else { f = ( char * ) include_name ; } if ( fd == - 1 ) { # ifdef _WIN32 _sopen_s ( & fd , f , _O_RDONLY , _SH_DENYRW , _S_IREAD ) ; # else fd = open ( f , O_RDONLY ) ; # endif } if ( fd == - 1 ) return NULL ; # ifdef _WIN32 file_size = _filelength ( fd ) ; if ( file_size == - 1 ) { _close ( fd ) ; return NULL ; } # else if ( ( fstat ( fd , & stbuf ) != 0 ) || ( ! S_ISREG ( stbuf . st_mode ) ) ) { close ( fd ) ; return NULL ; } file_size = stbuf . st_size ; # endif file_buffer = ( char * ) yr_malloc ( file_size + 1 ) ; if ( file_buffer == NULL ) { # ifdef _WIN32 _close ( fd ) ; # else close ( fd ) ; # endif return NULL ; } if ( file_size != read ( fd , file_buffer , file_size ) ) { yr_free ( file_buffer ) ; # ifdef _WIN32 _close ( fd ) ; # else close ( fd ) ; # endif return NULL ; } else { file_buffer [ file_size ] = '\\0' ; } # ifdef _WIN32 _close ( fd ) ; # else close ( fd ) ; # endif return file_buffer ; } | <S2SV_ModStart> user_data ) { # ifndef _WIN32 <S2SV_ModStart> stbuf ; # endif # |
260 | CWE-000 int __wt_log_reset ( WT_SESSION_IMPL * session , uint32_t lognum ) { WT_CONNECTION_IMPL * conn ; WT_DECL_RET ; WT_LOG * log ; uint32_t old_lognum ; u_int i , logcount ; char * * logfiles ; conn = S2C ( session ) ; log = conn -> log ; if ( ! FLD_ISSET ( conn -> log_flags , WT_CONN_LOG_ENABLED ) || <S2SV_StartBug> log -> fileid > lognum ) { <S2SV_EndBug> __wt_verbose ( session , WT_VERB_TEMPORARY , "RESET:<S2SV_blank>log<S2SV_blank>%" PRIu32 "<S2SV_blank>in<S2SV_blank>range<S2SV_blank>of<S2SV_blank>log<S2SV_blank>fileid<S2SV_blank>%" PRIu32 , lognum , log -> fileid ) ; return ( 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> WT_ASSERT ( session , F_ISSET ( conn , WT_CONN_RECOVERING ) ) ; WT_ASSERT ( session , ! F_ISSET ( conn , WT_CONN_READONLY ) ) ; WT_RET ( __wt_close ( session , & log -> log_fh ) ) ; WT_RET ( __log_get_files ( session , WT_LOG_FILENAME , & logfiles , & logcount ) ) ; for ( i = 0 ; i < logcount ; i ++ ) { WT_ERR ( __wt_log_extract_lognum ( session , logfiles [ i ] , & old_lognum ) ) ; WT_ASSERT ( session , old_lognum < lognum ) ; <S2SV_StartBug> __wt_verbose ( session , WT_VERB_TEMPORARY , <S2SV_EndBug> "RESET:<S2SV_blank>removing<S2SV_blank>log<S2SV_blank>%" PRIu32 , old_lognum ) ; WT_ERR ( __wt_log_remove ( session , WT_LOG_FILENAME , old_lognum ) ) ; } log -> fileid = lognum ; WT_WITH_SLOT_LOCK ( session , log , ret = __log_newfile ( session , true , NULL ) ) ; <S2SV_StartBug> __wt_verbose ( session , WT_VERB_TEMPORARY , <S2SV_EndBug> "RESET:<S2SV_blank>after<S2SV_blank>newfile<S2SV_blank>alloc_lsn<S2SV_blank>%" PRIu32 "/%" PRIu32 , log -> alloc_lsn . l . file , log -> alloc_lsn . l . offset ) ; err : WT_TRET ( __wt_fs_directory_list_free ( session , & logfiles , logcount ) ) ; return ( ret ) ; } | <S2SV_ModStart> > lognum ) <S2SV_ModEnd> return ( 0 <S2SV_ModStart> 0 ) ; <S2SV_ModEnd> WT_ASSERT ( session <S2SV_ModStart> lognum ) ; <S2SV_ModEnd> WT_ERR ( __wt_log_remove <S2SV_ModStart> ) ) ; WT_ERR ( __wt_log_slot_init ( session , false ) <S2SV_ModEnd> ) ; err |
261 | CWE-000 void cut_select ( unsigned long touch ) { t_ft_sh * sh ; int len ; int tmp ; ( void ) touch ; sh = get_ft_shell ( ) ; free ( sh -> select ) ; if ( sh -> select_size < 0 ) sh -> select = ft_strsub ( sh -> buf . buf , sh -> select_start + sh -> select_size , sh -> select_size * - 1 ) ; else sh -> select = ft_strsub ( sh -> buf . buf , sh -> select_start , sh -> select_size ) ; len = ft_strlen ( sh -> select ) ; tmp = len ; while ( len -- > 0 ) <S2SV_StartBug> if ( sh -> cursor == sh -> buf . cursor ) <S2SV_EndBug> backspace_command ( T_BACKSPACE ) ; else delete_command ( T_DELETE ) ; sh -> select_start = 0 ; sh -> select_size = 0 ; } | <S2SV_ModStart> ( sh -> select_size > 0 <S2SV_ModEnd> ) backspace_command ( |
262 | CWE-000 static INT8U initQueue ( Buttons * pButtons ) { INT8U status = OS_NO_ERR ; <S2SV_StartBug> if ( pButtons ) <S2SV_EndBug> { pButtons -> pButtonPressQueue = OSQCreate ( pButtons -> pButtonPressQueueData , BUTTONS_MESSAGE_QUEUE_SIZE ) ; if ( pButtons -> pButtonPressQueue == NULL ) { status = OS_ERR_PDATA_NULL ; } } else { status = OS_ERR_PDATA_NULL ; } return status ; } | <S2SV_ModStart> if ( pButtons && ( pButtons -> pButtonPressQueueData == NULL ) |
263 | CWE-000 static int32_t msm_actuator_hvcm_init_step_table ( struct msm_actuator_ctrl_t * a_ctrl , struct msm_actuator_set_info_t * set_info ) { int16_t code_per_step = 0 ; int16_t cur_code = 0 ; <S2SV_StartBug> int16_t step_index = 0 , region_index = 0 ; <S2SV_EndBug> uint16_t step_boundary = 0 ; uint32_t max_code_size = 1 ; uint16_t data_size = set_info -> actuator_params . data_size ; CDBG ( "Enter\\n" ) ; for ( ; data_size > 0 ; data_size -- ) max_code_size *= 2 ; max_code_size = 0 ; if ( a_ctrl -> step_position_table ) { kfree ( a_ctrl -> step_position_table ) ; a_ctrl -> step_position_table = NULL ; } a_ctrl -> step_position_table = kmalloc ( sizeof ( uint16_t ) * ( set_info -> af_tuning_params . total_steps + 1 ) , GFP_KERNEL ) ; if ( a_ctrl -> step_position_table == NULL ) { pr_err ( "[%s::%d]<S2SV_blank>mem<S2SV_blank>alloc<S2SV_blank>fail<S2SV_blank>!\\n" , __func__ , __LINE__ ) ; return - ENOMEM ; } cur_code = hvca_inf_position ; a_ctrl -> step_position_table [ step_index ++ ] = cur_code ; for ( region_index = 0 ; region_index < a_ctrl -> region_size ; region_index ++ ) { code_per_step = a_ctrl -> region_params [ region_index ] . code_per_step ; step_boundary = a_ctrl -> region_params [ region_index ] . step_bound [ MOVE_NEAR ] ; <S2SV_StartBug> for ( ; step_index <= step_boundary ; <S2SV_EndBug> step_index ++ ) { cur_code -= code_per_step ; if ( cur_code > max_code_size ) a_ctrl -> step_position_table [ step_index ] = cur_code ; else { for ( ; step_index < set_info -> af_tuning_params . total_steps ; step_index ++ ) a_ctrl -> step_position_table [ step_index ] = max_code_size ; } } } for ( step_index = 0 ; step_index < set_info -> af_tuning_params . total_steps ; step_index ++ ) pr_info ( "[%s::%d]step_position_table[%d]<S2SV_blank>=<S2SV_blank>%d\\n" , __func__ , __LINE__ , step_index , a_ctrl -> step_position_table [ step_index ] ) ; CDBG ( "Exit\\n" ) ; return 0 ; } | <S2SV_ModStart> = 0 ; uint16_t <S2SV_ModEnd> step_index = 0 <S2SV_ModStart> MOVE_NEAR ] ; if ( step_boundary > set_info -> af_tuning_params . total_steps ) { pr_err ( "invalid<S2SV_blank>step_boundary<S2SV_blank>=<S2SV_blank>%d,<S2SV_blank>max_val<S2SV_blank>=<S2SV_blank>%d" , step_boundary , set_info -> af_tuning_params . total_steps ) ; kfree ( a_ctrl -> step_position_table ) ; a_ctrl -> step_position_table = NULL ; return - EINVAL ; } |
264 | CWE-000 static void PySm_enterState ( pySm_stateMachineType * stateMachine , const pySm_stateType * stateToEnter ) { pySm_stateType * statePtr = ( pySm_stateType * ) stateToEnter ; do { while ( statePtr -> superstateElementNo >= stateMachine -> firstValidStateNo ) { <S2SV_StartBug> if ( PYSM_STATE_INACTIVE == stateMachine -> states [ statePtr -> superstateElementNo ] -> stateStatus ) <S2SV_EndBug> { statePtr = ( pySm_stateType * ) stateMachine -> states [ statePtr -> superstateElementNo ] ; } } <S2SV_StartBug> if ( PYSM_STATE_INACTIVE == statePtr -> stateStatus ) <S2SV_EndBug> { statePtr -> onEntryState ( ) ; <S2SV_StartBug> statePtr -> stateStatus = PYSM_STATE_ACTIVE ; <S2SV_EndBug> } } while ( statePtr != stateToEnter ) ; if ( stateToEnter -> superstateElementNo < stateMachine -> firstValidStateNo ) { stateMachine -> actualState = stateToEnter ; } else { statePtr = ( pySm_stateType * ) stateMachine -> states [ stateToEnter -> defaultSubstateElementNo ] ; do { statePtr -> onState ( ) ; <S2SV_StartBug> statePtr -> stateStatus = PYSM_STATE_ACTIVE ; <S2SV_EndBug> stateMachine -> actualState = statePtr ; statePtr = ( pySm_stateType * ) stateMachine -> states [ statePtr -> defaultSubstateElementNo ] ; } while ( statePtr -> defaultSubstateElementNo >= stateMachine -> firstValidStateNo ) ; } } | <S2SV_ModStart> ( PYSM_STATE_INACTIVE == * ( stateMachine -> states [ statePtr -> superstateElementNo ] -> stateStatusPtr ) <S2SV_ModEnd> ) { statePtr <S2SV_ModStart> ( PYSM_STATE_INACTIVE == * ( statePtr -> stateStatusPtr ) <S2SV_ModEnd> ) { statePtr <S2SV_ModStart> ( ) ; * ( statePtr -> stateStatusPtr ) <S2SV_ModEnd> = PYSM_STATE_ACTIVE ; <S2SV_ModStart> ( ) ; * ( statePtr -> stateStatusPtr ) <S2SV_ModEnd> = PYSM_STATE_ACTIVE ; |
265 | CWE-000 void ipmapdo ( IPMap * map , void ( * thunk ) ( uint32_t key , size_t keylen , void * datum , void * arg ) , void * arg ) { <S2SV_StartBug> if ( map != NULL ) <S2SV_EndBug> <S2SV_StartBug> ipmapdorec ( map , 0 , 0 , thunk , arg ) ; <S2SV_EndBug> } | <S2SV_ModStart> arg ) { TrampArg tramparg ; memset ( & tramparg , 0 , sizeof tramparg ) ; tramparg . thunk = thunk ; tramparg . arg = arg ; ipmapdo_inorder <S2SV_ModEnd> ( map , <S2SV_ModStart> ( map , trampthunk , & tramparg <S2SV_ModEnd> ) ; } |
266 | CWE-000 POOL_STATUS ProcessFrontendResponse ( POOL_CONNECTION * frontend , POOL_CONNECTION_POOL * backend ) { char fkind ; char * bufp = NULL ; char * contents ; POOL_STATUS status ; int len = 0 ; pool_get_session_context ( false ) ; if ( pool_read_buffer_is_empty ( frontend ) && frontend -> no_forward != 0 ) return POOL_CONTINUE ; pool_read ( frontend , & fkind , 1 ) ; ereport ( DEBUG1 , ( errmsg ( "processing<S2SV_blank>frontend<S2SV_blank>response" ) , errdetail ( "received<S2SV_blank>kind<S2SV_blank>\'%c\'(%02x)<S2SV_blank>from<S2SV_blank>frontend" , fkind , fkind ) ) ) ; if ( MAJOR ( backend ) == PROTO_MAJOR_V3 ) { if ( pool_read ( frontend , & len , sizeof ( len ) ) < 0 ) ereport ( ERROR , ( errmsg ( "unable<S2SV_blank>to<S2SV_blank>process<S2SV_blank>frontend<S2SV_blank>response" ) , errdetail ( "failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>message<S2SV_blank>length<S2SV_blank>from<S2SV_blank>frontend.<S2SV_blank>frontend<S2SV_blank>abnormally<S2SV_blank>exited" ) ) ) ; len = ntohl ( len ) - 4 ; if ( len > 0 ) bufp = pool_read2 ( frontend , len ) ; else if ( len < 0 ) ereport ( ERROR , ( errmsg ( "frontend<S2SV_blank>message<S2SV_blank>length<S2SV_blank>is<S2SV_blank>less<S2SV_blank>than<S2SV_blank>4<S2SV_blank>(kind:<S2SV_blank>%c)" , fkind ) ) ) ; } else { if ( fkind != 'F' ) bufp = pool_read_string ( frontend , & len , 0 ) ; } if ( len > 0 && bufp == NULL ) ereport ( ERROR , ( errmsg ( "unable<S2SV_blank>to<S2SV_blank>process<S2SV_blank>frontend<S2SV_blank>response" ) , errdetail ( "failed<S2SV_blank>to<S2SV_blank>read<S2SV_blank>message<S2SV_blank>from<S2SV_blank>frontend.<S2SV_blank>frontend<S2SV_blank>abnormally<S2SV_blank>exited" ) ) ) ; if ( fkind != 'S' && pool_is_ignore_till_sync ( ) ) { if ( ! pool_is_query_in_progress ( ) ) pool_set_query_in_progress ( ) ; return POOL_CONTINUE ; } pool_unset_doing_extended_query_message ( ) ; if ( len > 0 ) { contents = palloc ( len ) ; memcpy ( contents , bufp , len ) ; } else { contents = palloc ( 1 ) ; memcpy ( contents , "" , 1 ) ; } switch ( fkind ) { POOL_QUERY_CONTEXT * query_context ; char * query ; Node * node ; List * parse_tree_list ; bool error ; case 'X' : if ( contents ) pfree ( contents ) ; ereport ( DEBUG1 , ( errmsg ( "Frontend<S2SV_blank>terminated" ) , errdetail ( "received<S2SV_blank>message<S2SV_blank>kind<S2SV_blank>\'X\'<S2SV_blank>from<S2SV_blank>frontend" ) ) ) ; return POOL_END ; case 'Q' : allow_close_transaction = 1 ; status = SimpleQuery ( frontend , backend , len , contents ) ; break ; case 'E' : allow_close_transaction = 1 ; pool_set_doing_extended_query_message ( ) ; if ( ! pool_is_query_in_progress ( ) && ! pool_is_ignore_till_sync ( ) ) pool_set_query_in_progress ( ) ; status = Execute ( frontend , backend , len , contents ) ; break ; case 'P' : allow_close_transaction = 0 ; pool_set_doing_extended_query_message ( ) ; status = Parse ( frontend , backend , len , contents ) ; break ; case 'B' : pool_set_doing_extended_query_message ( ) ; status = Bind ( frontend , backend , len , contents ) ; break ; case 'C' : pool_set_doing_extended_query_message ( ) ; if ( ! pool_is_query_in_progress ( ) && ! pool_is_ignore_till_sync ( ) ) pool_set_query_in_progress ( ) ; status = Close ( frontend , backend , len , contents ) ; break ; case 'D' : pool_set_doing_extended_query_message ( ) ; status = Describe ( frontend , backend , len , contents ) ; break ; case 'S' : pool_set_doing_extended_query_message ( ) ; if ( pool_is_ignore_till_sync ( ) ) pool_unset_ignore_till_sync ( ) ; if ( STREAM ) { POOL_PENDING_MESSAGE * msg ; pool_unset_query_in_progress ( ) ; msg = pool_pending_message_create ( 'S' , 0 , NULL ) ; pool_pending_message_add ( msg ) ; <S2SV_StartBug> } <S2SV_EndBug> else if ( ! pool_is_query_in_progress ( ) ) pool_set_query_in_progress ( ) ; status = SimpleForwardToBackend ( fkind , frontend , backend , len , contents ) ; break ; case 'F' : query_context = pool_init_query_context ( ) ; query = "INSERT<S2SV_blank>INTO<S2SV_blank>foo<S2SV_blank>VALUES(1)" ; MemoryContext old_context = MemoryContextSwitchTo ( query_context -> memory_context ) ; parse_tree_list = raw_parser ( query , & error ) ; node = ( Node * ) lfirst ( list_head ( parse_tree_list ) ) ; pool_start_query ( query_context , query , strlen ( query ) + 1 , node ) ; MemoryContextSwitchTo ( old_context ) ; pool_where_to_send ( query_context , query_context -> original_query , query_context -> parse_tree ) ; if ( MAJOR ( backend ) == PROTO_MAJOR_V3 ) status = FunctionCall3 ( frontend , backend , len , contents ) ; else status = FunctionCall ( frontend , backend ) ; break ; case 'c' : case 'd' : case 'f' : case 'H' : if ( MAJOR ( backend ) == PROTO_MAJOR_V3 ) { status = SimpleForwardToBackend ( fkind , frontend , backend , len , contents ) ; break ; } default : ereport ( FATAL , ( return_code ( 2 ) , errmsg ( "unable<S2SV_blank>to<S2SV_blank>process<S2SV_blank>frontend<S2SV_blank>response" ) , errdetail ( "unknown<S2SV_blank>message<S2SV_blank>type<S2SV_blank>%c(%02x)" , fkind , fkind ) ) ) ; } if ( contents ) pfree ( contents ) ; if ( status != POOL_CONTINUE ) ereport ( FATAL , ( return_code ( 2 ) , errmsg ( "unable<S2SV_blank>to<S2SV_blank>process<S2SV_blank>frontend<S2SV_blank>response" ) ) ) ; return status ; } | <S2SV_ModStart> msg ) ; pool_pending_message_free_pending_message ( msg ) ; |
267 | CWE-000 long long connectAndSend ( list * node , char * filename ) { char buf [ MAXBUFSIZE ] ; memset ( buf , 0 , MAXBUFSIZE ) ; printf ( "connecting<S2SV_blank>to<S2SV_blank>peer<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>%s\\n" , node -> ip , node -> port ) ; long long rv = client ( node -> ip , node -> port , NULL , filename , buf , 0 , 0 , ASK_AVAIL ) ; <S2SV_StartBug> printf ( "connectAndSend<S2SV_blank>rv<S2SV_blank>is:<S2SV_blank>%llu\\n" , rv ) ; <S2SV_EndBug> if ( rv >= 0 ) return rv ; else return - 1 ; } | <S2SV_ModStart> ; printf ( "connectAndSend<S2SV_blank>rv<S2SV_blank>is:<S2SV_blank>%lld\\n" <S2SV_ModEnd> , rv ) |
268 | CWE-000 <S2SV_StartBug> void schedule ( int type ) { <S2SV_EndBug> float t = expon ( mean ) ; <S2SV_StartBug> create_push_sort ( event_queue , type , current_sim_time + t ) ; <S2SV_EndBug> } | <S2SV_ModStart> ( int type , float inherit_size <S2SV_ModStart> mean ) ; if ( type == 1 || type == 0 ) <S2SV_ModStart> event_queue , type , expon ( 0.1 ) , current_sim_time + t ) ; else if ( type == 2 || type == 3 ) create_push_sort ( event_queue , type , inherit_size , current_sim_time + 50 * expon ( inherit_size ) ) ; else create_push_sort ( event_queue , type , expon ( 0.1 ) |
269 | CWE-000 int SMB2_query_info ( const unsigned int xid , struct cifs_tcon * tcon , u64 persistent_fid , u64 volatile_fid , struct smb2_file_all_info * data ) { return query_info ( xid , tcon , persistent_fid , volatile_fid , <S2SV_StartBug> FILE_ALL_INFORMATION , <S2SV_EndBug> sizeof ( struct smb2_file_all_info ) + PATH_MAX * 2 , <S2SV_StartBug> sizeof ( struct smb2_file_all_info ) , data ) ; <S2SV_EndBug> } | <S2SV_ModStart> , FILE_ALL_INFORMATION , SMB2_O_INFO_FILE , 0 , <S2SV_ModStart> smb2_file_all_info ) , ( void * * ) & data , NULL <S2SV_ModEnd> ) ; } |
270 | CWE-000 void ft_ascii_sort ( char * * arr ) { unsigned int i ; unsigned int j ; unsigned int len ; char flag ; i = 0 ; len = ft_arr_len ( arr ) ; while ( i != len - 1 ) { j = 0 ; flag = 0 ; while ( j != len ) { if ( ft_strcmp ( arr [ j ] , arr [ j + 1 ] ) > 0 ) { ft_swap ( arr , j , j + 1 ) ; flag = 1 ; } j ++ ; } <S2SV_StartBug> if ( flag == 0 ) <S2SV_EndBug> return ; i ++ ; } } | <S2SV_ModStart> } if ( ! flag <S2SV_ModEnd> ) return ; |
271 | CWE-000 int stringHasher ( string value ) { <S2SV_StartBug> return value [ 0 ] ; <S2SV_EndBug> } | <S2SV_ModStart> ) { return ( int ) |
272 | CWE-000 void mppExecutorCleanup ( QueryDesc * queryDesc ) { EState * estate ; estate = queryDesc -> estate ; if ( gp_enable_gpperfmon && Gp_role == GP_ROLE_DISPATCH && queryDesc -> gpmon_pkt && QueryCancelCleanup ) { gpmon_qlog_query_canceling ( queryDesc -> gpmon_pkt ) ; if ( gp_cancel_query_print_log ) { elog ( LOG , "canceling<S2SV_blank>query<S2SV_blank>(%d,<S2SV_blank>%d)" , queryDesc -> gpmon_pkt -> u . qlog . key . ssid , queryDesc -> gpmon_pkt -> u . qlog . key . ccnt ) ; } } if ( Gp_role == GP_ROLE_DISPATCH && QueryCancelCleanup && gp_cancel_query_delay_time > 0 ) { pg_usleep ( gp_cancel_query_delay_time * 1000 ) ; } if ( estate -> dispatcherState && estate -> dispatcherState -> primaryResults ) { if ( estate -> es_interconnect_is_setup && ! estate -> es_got_eos ) ExecSquelchNode ( queryDesc -> planstate ) ; CdbDispatchHandleError ( estate -> dispatcherState ) ; } if ( estate -> es_interconnect_is_setup ) { <S2SV_StartBug> TeardownInterconnect ( estate -> interconnect_context , estate -> motionlayer_context , true ) ; <S2SV_EndBug> estate -> es_interconnect_is_setup = false ; } if ( gp_enable_gpperfmon && Gp_role == GP_ROLE_DISPATCH && queryDesc -> gpmon_pkt ) { gpmon_qlog_query_error ( queryDesc -> gpmon_pkt ) ; pfree ( queryDesc -> gpmon_pkt ) ; queryDesc -> gpmon_pkt = NULL ; } WorkfileQueryspace_ReleaseEntry ( ) ; ReportOOMConsumption ( ) ; if ( gp_resqueue_memory_policy != RESQUEUE_MEMORY_POLICY_NONE ) { SPI_InitMemoryReservation ( ) ; } } | <S2SV_ModStart> motionlayer_context , true , true |
273 | CWE-000 int main ( ) { TSS2_SYS_CONTEXT * sapi_context ; test_data_t test_data [ TEST_MAX_SESSIONS ] = { <S2SV_StartBug> TEST_DATA_STATIC_INIT , TEST_DATA_STATIC_INIT , TEST_DATA_STATIC_INIT , <S2SV_EndBug> TEST_DATA_STATIC_INIT , TEST_DATA_STATIC_INIT } ; test_opts_t opts = TEST_OPTS_DEFAULT_INIT ; guint success_count ; get_test_opts_from_env ( & opts ) ; if ( sanity_check_test_opts ( & opts ) != 0 ) exit ( 1 ) ; create_connection_and_save_sessions ( & opts , test_data , TEST_MAX_SESSIONS ) ; sapi_context = sapi_init_from_opts ( & opts ) ; if ( sapi_context == NULL ) { g_error ( "Failed<S2SV_blank>to<S2SV_blank>create<S2SV_blank>SAPI<S2SV_blank>context." ) ; } success_count = load_sessions ( sapi_context , test_data , TEST_MAX_SESSIONS ) ; if ( success_count != TABRMD_SESSIONS_MAX_DEFAULT ) { g_critical ( "Expected<S2SV_blank>to<S2SV_blank>load<S2SV_blank>%u<S2SV_blank>sessions,<S2SV_blank>got<S2SV_blank>%u<S2SV_blank>instead" , TABRMD_SESSIONS_MAX_DEFAULT , success_count ) ; exit ( 1 ) ; } if ( test_data [ 0 ] . load_success == true ) { g_critical ( "Oldest<S2SV_blank>session<S2SV_blank>created<S2SV_blank>was<S2SV_blank>loaded<S2SV_blank>successfully." ) ; exit ( 1 ) ; } sapi_teardown_full ( sapi_context ) ; return 0 ; } | <S2SV_ModStart> ] = { TEST_DATA_ZERO_INIT , TEST_DATA_ZERO_INIT , TEST_DATA_ZERO_INIT , TEST_DATA_ZERO_INIT , TEST_DATA_ZERO_INIT <S2SV_ModEnd> } ; test_opts_t |
274 | CWE-000 void usage ( void ) { fprintf ( stderr , <S2SV_StartBug> "Usage:<S2SV_blank>arping<S2SV_blank>[-fqbDUAV]<S2SV_blank>[-c<S2SV_blank>count]<S2SV_blank>[-w<S2SV_blank>timeout]<S2SV_blank>[-I<S2SV_blank>device]<S2SV_blank>[-s<S2SV_blank>source]<S2SV_blank>destination\\n" <S2SV_EndBug> "<S2SV_blank><S2SV_blank>-f<S2SV_blank>:<S2SV_blank>quit<S2SV_blank>on<S2SV_blank>first<S2SV_blank>reply\\n" "<S2SV_blank><S2SV_blank>-q<S2SV_blank>:<S2SV_blank>be<S2SV_blank>quiet\\n" "<S2SV_blank><S2SV_blank>-b<S2SV_blank>:<S2SV_blank>keep<S2SV_blank>broadcasting,<S2SV_blank>don\'t<S2SV_blank>go<S2SV_blank>unicast\\n" "<S2SV_blank><S2SV_blank>-D<S2SV_blank>:<S2SV_blank>duplicate<S2SV_blank>address<S2SV_blank>detection<S2SV_blank>mode\\n" "<S2SV_blank><S2SV_blank>-U<S2SV_blank>:<S2SV_blank>Unsolicited<S2SV_blank>ARP<S2SV_blank>mode,<S2SV_blank>update<S2SV_blank>your<S2SV_blank>neighbours\\n" "<S2SV_blank><S2SV_blank>-A<S2SV_blank>:<S2SV_blank>ARP<S2SV_blank>answer<S2SV_blank>mode,<S2SV_blank>update<S2SV_blank>your<S2SV_blank>neighbours\\n" "<S2SV_blank><S2SV_blank>-V<S2SV_blank>:<S2SV_blank>print<S2SV_blank>version<S2SV_blank>and<S2SV_blank>exit\\n" "<S2SV_blank><S2SV_blank>-c<S2SV_blank>count<S2SV_blank>:<S2SV_blank>how<S2SV_blank>many<S2SV_blank>packets<S2SV_blank>to<S2SV_blank>send\\n" "<S2SV_blank><S2SV_blank>-w<S2SV_blank>timeout<S2SV_blank>:<S2SV_blank>how<S2SV_blank>long<S2SV_blank>to<S2SV_blank>wait<S2SV_blank>for<S2SV_blank>a<S2SV_blank>reply\\n" "<S2SV_blank><S2SV_blank>-I<S2SV_blank>device<S2SV_blank>:<S2SV_blank>which<S2SV_blank>ethernet<S2SV_blank>device<S2SV_blank>to<S2SV_blank>use" # ifdef DEFAULT_DEVICE_STR "<S2SV_blank>(" DEFAULT_DEVICE_STR ")" # endif "\\n" "<S2SV_blank><S2SV_blank>-s<S2SV_blank>source<S2SV_blank>:<S2SV_blank>source<S2SV_blank>ip<S2SV_blank>address\\n" "<S2SV_blank><S2SV_blank>destination<S2SV_blank>:<S2SV_blank>ask<S2SV_blank>for<S2SV_blank>what<S2SV_blank>ip<S2SV_blank>address\\n" ) ; exit ( 2 ) ; } | <S2SV_ModStart> ( stderr , "%s\\n" , print_usage <S2SV_ModEnd> ) ; exit |
275 | CWE-000 static int mdss_dsi_parse_panel_features ( struct device_node * np , struct mdss_dsi_ctrl_pdata * ctrl ) { struct mdss_panel_info * pinfo ; if ( ! np || ! ctrl ) { pr_err ( "%s:<S2SV_blank>Invalid<S2SV_blank>arguments\\n" , __func__ ) ; return - ENODEV ; } pinfo = & ctrl -> panel_data . panel_info ; pinfo -> cont_splash_enabled = of_property_read_bool ( np , "qcom,cont-splash-enabled" ) ; if ( pinfo -> mipi . mode == DSI_CMD_MODE ) { pinfo -> partial_update_enabled = of_property_read_bool ( np , "qcom,partial-update-enabled" ) ; pr_info ( "%s:<S2SV_blank>partial_update_enabled=%d\\n" , __func__ , pinfo -> partial_update_enabled ) ; if ( pinfo -> partial_update_enabled ) { ctrl -> set_col_page_addr = mdss_dsi_set_col_page_addr ; pinfo -> partial_update_roi_merge = of_property_read_bool ( np , "qcom,partial-update-roi-merge" ) ; } pinfo -> dcs_cmd_by_left = of_property_read_bool ( np , "qcom,dcs-cmd-by-left" ) ; } pinfo -> ulps_feature_enabled = of_property_read_bool ( np , "qcom,ulps-enabled" ) ; <S2SV_StartBug> pr_info ( "%s:<S2SV_blank>ulps<S2SV_blank>feature<S2SV_blank>%s" , __func__ , <S2SV_EndBug> ( pinfo -> ulps_feature_enabled ? "enabled" : "disabled" ) ) ; return 0 ; } | <S2SV_ModStart> ; pr_info ( "%s:<S2SV_blank>ulps<S2SV_blank>feature<S2SV_blank>%s\\n" <S2SV_ModEnd> , __func__ , |
276 | CWE-000 static errno_t cache_req_select_domains ( struct tevent_req * req , const char * domain_name ) { struct cache_req_state * state = NULL ; struct cache_req_domain * cr_domain ; bool check_next ; bool bypass_cache ; bool bypass_dp ; bool search ; <S2SV_StartBug> state = tevent_req_data ( req , struct cache_req_state ) ; <S2SV_EndBug> search = cache_req_search_schema ( state -> cr , domain_name , state -> first_iteration , & bypass_cache , & bypass_dp ) ; if ( ! search ) { return EOK ; } <S2SV_StartBug> if ( domain_name != NULL ) { <S2SV_EndBug> CACHE_REQ_DEBUG ( SSSDBG_TRACE_FUNC , state -> cr , "Performing<S2SV_blank>a<S2SV_blank>single<S2SV_blank>domain<S2SV_blank>search\\n" ) ; cr_domain = cache_req_domain_get_domain_by_name ( <S2SV_StartBug> state -> cr -> rctx -> cr_domains , domain_name ) ; <S2SV_EndBug> if ( cr_domain == NULL ) { return ERR_DOMAIN_NOT_FOUND ; } check_next = false ; } else { CACHE_REQ_DEBUG ( SSSDBG_TRACE_FUNC , state -> cr , "Performing<S2SV_blank>a<S2SV_blank>multi-domain<S2SV_blank>search\\n" ) ; <S2SV_StartBug> cr_domain = state -> cr -> rctx -> cr_domains ; <S2SV_EndBug> check_next = true ; } return cache_req_search_domains ( req , cr_domain , check_next , bypass_cache , bypass_dp ) ; } | <S2SV_ModStart> bool search ; errno_t ret ; <S2SV_ModStart> EOK ; } ret = cache_req_domain_copy_cr_domains ( state , state -> cr -> rctx -> cr_domains , & state -> cr_domains ) ; if ( ret != EOK ) { DEBUG ( SSSDBG_CRIT_FAILURE , "cache_req_copy_cr_domains()<S2SV_blank>failed\\n" ) ; return EINVAL ; } <S2SV_ModStart> ( state -> <S2SV_ModEnd> cr_domains , domain_name <S2SV_ModStart> = state -> <S2SV_ModEnd> cr_domains ; check_next |
277 | CWE-000 Graph InitializeGraph ( int n_v , int n_e ) { Heap V = InitializeHeap ( n_v ) ; <S2SV_StartBug> return ( Graph ) { V , NULL , n_v , n_e } ; <S2SV_EndBug> } | <S2SV_ModStart> , NULL , 0 , |
278 | CWE-000 <S2SV_StartBug> void memorySPIRead ( int sector , int page , uint16_t * buffer , int numBytes ) <S2SV_EndBug> <S2SV_StartBug> { <S2SV_EndBug> gpio_clr_gpio_pin ( MEMORY_CS ) ; memoryWait ( ) ; spi_write ( MEMORY_SPI , 0x03 ) ; memorySPIWriteAddress ( sector , page ) ; for ( int i = 0 ; i < numBytes ; i ++ ) { spi_write ( MEMORY_SPI , 0x00 ) ; <S2SV_StartBug> spi_read ( MEMORY_SPI , & buffer [ i ] ) ; <S2SV_EndBug> } memoryWait ( ) ; gpio_set_gpio_pin ( MEMORY_CS ) ; memoryWait ( ) ; } | <S2SV_ModStart> int page , uint8_t <S2SV_ModEnd> * buffer , <S2SV_ModStart> numBytes ) { uint8_t * _ram = buffer ; uint16_t data ; <S2SV_ModStart> MEMORY_SPI , & data ) ; * _ram ++ = data <S2SV_ModEnd> ; } memoryWait |
279 | CWE-000 int StrCache_Len ( int index ) <S2SV_StartBug> { <S2SV_EndBug> return strcache [ index ] . len ; } | <S2SV_ModStart> index ) { assert ( index >= 0 ) ; |
280 | CWE-000 t_ast * create_right_branch ( t_token * command_token , t_list * * token_list ) { t_token * token ; t_ast * right_branch ; t_ast * command_child ; right_branch = ast_create_node ( NULL , NULL , SIMPLE_COMMAND ) ; right_branch = fill_simple_command ( right_branch , token_list ) ; # ifdef PARSER_DEBUG <S2SV_StartBug> dprintf ( 2 , "\\n\\n-----------------------------------------------------------------------------\\n" ) ; <S2SV_EndBug> read_tree ( right_branch ) ; <S2SV_StartBug> dprintf ( 2 , "\\n\\n-----------------------------------------------------------------------------\\n" ) ; <S2SV_EndBug> # endif if ( right_branch && right_branch -> child ) { command_child = right_branch -> child -> data ; token = command_child -> token ; } else { dprintf ( 2 , "Parse<S2SV_blank>error<S2SV_blank>near<S2SV_blank>\'%s\'\\n" , command_token -> value ) ; return ( flush_tree ( right_branch ) ) ; } if ( ! command_child || ( token && token -> id == TK_NEWLINE ) ) { right_branch = flush_tree ( right_branch ) ; * token_list = reopen_command ( ) ; right_branch = ast_create_node ( NULL , NULL , SIMPLE_COMMAND ) ; right_branch = fill_simple_command ( right_branch , token_list ) ; } return ( right_branch ) ; } | <S2SV_ModStart> # ifdef PARSER_DEBUG # ifdef IN <S2SV_ModStart> ( 2 , "\\n\\n" RED "--------------Right<S2SV_blank>Branch<S2SV_blank>---------\\n" RESET <S2SV_ModEnd> ) ; read_tree <S2SV_ModStart> right_branch ) ; # endif <S2SV_ModEnd> # endif if |
281 | CWE-000 <S2SV_StartBug> static void wait_for_graceful_shutdown ( pid_t pid ) <S2SV_EndBug> { sigset_t mask ; sigemptyset ( & mask ) ; sigaddset ( & mask , SIGCHLD ) ; struct timespec timeout ; timeout . tv_sec = 10 ; timeout . tv_nsec = 0 ; for ( ; ; ) { debug ( "waiting<S2SV_blank>for<S2SV_blank>graceful<S2SV_blank>shutdown" ) ; int rc = sigtimedwait ( & mask , NULL , & timeout ) ; if ( rc == SIGCHLD ) { <S2SV_StartBug> return ; <S2SV_EndBug> } <S2SV_StartBug> if ( rc < 0 ) { <S2SV_EndBug> if ( errno == EINTR ) continue ; else if ( errno == EAGAIN ) { warn ( "Wait<S2SV_blank>for<S2SV_blank>Erlang<S2SV_blank>VM<S2SV_blank>to<S2SV_blank>exit<S2SV_blank>gracefully<S2SV_blank>expired.<S2SV_blank>Killing..." ) ; kill ( pid , SIGKILL ) ; return ; } } fatal ( "Unexpected<S2SV_blank>result<S2SV_blank>from<S2SV_blank>sigtimewait:<S2SV_blank>%d<S2SV_blank>%d" , rc , errno ) ; } } | <S2SV_ModStart> ( pid_t pid , int * wait_status <S2SV_ModStart> SIGCHLD ) { rc = waitpid ( pid , wait_status , WNOHANG ) ; if ( rc == pid ) { debug ( "graceful<S2SV_blank>shutdown<S2SV_blank>detected" ) ; <S2SV_ModStart> return ; } else <S2SV_ModStart> < 0 ) fatal ( "Unexpected<S2SV_blank>error<S2SV_blank>from<S2SV_blank>waitpid<S2SV_blank>%d" , errno ) ; else warn ( "Ignoring<S2SV_blank>SIGCHLD<S2SV_blank>from<S2SV_blank>pid<S2SV_blank>%d" , rc ) ; } if ( rc < 0 ) |
282 | CWE-000 void timekeeping_resume ( void ) { struct timekeeper * tk = & tk_core . timekeeper ; struct clocksource * clock = tk -> tkr_mono . clock ; unsigned long flags ; struct timespec64 ts_new , ts_delta ; cycle_t cycle_now , cycle_delta ; <S2SV_StartBug> sleeptime_injected = false ; <S2SV_EndBug> read_persistent_clock64 ( & ts_new ) ; clockevents_resume ( ) ; clocksource_resume ( ) ; raw_spin_lock_irqsave ( & timekeeper_lock , flags ) ; write_seqcount_begin ( & tk_core . seq ) ; cycle_now = tk_clock_read ( & tk -> tkr_mono ) ; if ( ( clock -> flags & CLOCK_SOURCE_SUSPEND_NONSTOP ) && cycle_now > tk -> tkr_mono . cycle_last ) { u64 num , max = ULLONG_MAX ; u32 mult = clock -> mult ; u32 shift = clock -> shift ; s64 nsec = 0 ; cycle_delta = clocksource_delta ( cycle_now , tk -> tkr_mono . cycle_last , tk -> tkr_mono . mask ) ; do_div ( max , mult ) ; if ( cycle_delta > max ) { num = div64_u64 ( cycle_delta , max ) ; nsec = ( ( ( u64 ) max * mult ) >> shift ) * num ; cycle_delta -= num * max ; } nsec += ( ( u64 ) cycle_delta * mult ) >> shift ; ts_delta = ns_to_timespec64 ( nsec ) ; <S2SV_StartBug> sleeptime_injected = true ; <S2SV_EndBug> } else if ( timespec64_compare ( & ts_new , & timekeeping_suspend_time ) > 0 ) { ts_delta = timespec64_sub ( ts_new , timekeeping_suspend_time ) ; <S2SV_StartBug> sleeptime_injected = true ; <S2SV_EndBug> } <S2SV_StartBug> if ( sleeptime_injected ) <S2SV_EndBug> <S2SV_StartBug> __timekeeping_inject_sleeptime ( tk , & ts_delta ) ; <S2SV_EndBug> tk -> tkr_mono . cycle_last = cycle_now ; tk -> tkr_raw . cycle_last = cycle_now ; tk -> ntp_error = 0 ; timekeeping_suspended = 0 ; timekeeping_update ( tk , TK_MIRROR | TK_CLOCK_WAS_SET ) ; write_seqcount_end ( & tk_core . seq ) ; raw_spin_unlock_irqrestore ( & timekeeper_lock , flags ) ; touch_softlockup_watchdog ( ) ; tick_resume ( ) ; hrtimers_resume ( ) ; } | <S2SV_ModStart> , cycle_delta ; bool inject_sleeptime <S2SV_ModEnd> = false ; <S2SV_ModStart> nsec ) ; inject_sleeptime <S2SV_ModEnd> = true ; <S2SV_ModStart> timekeeping_suspend_time ) ; inject_sleeptime <S2SV_ModEnd> = true ; <S2SV_ModStart> } if ( inject_sleeptime ) { suspend_timing_needed = false ; <S2SV_ModEnd> __timekeeping_inject_sleeptime ( tk <S2SV_ModStart> ts_delta ) ; } |
283 | CWE-000 static void _freeLocale ( void ) { if ( gLib . locale == NULL ) return ; # ifdef _WIN32 _free_locale ( gLib . locale ) ; <S2SV_StartBug> # endif <S2SV_EndBug> gLib . locale = NULL ; } | <S2SV_ModStart> ) ; # else freelocale ( gLib . locale ) ; # |
284 | CWE-000 int intel_svc_send ( struct intel_svc_chan * chan , void * msg ) { struct intel_svc_client_msg * p_msg = ( struct intel_svc_client_msg * ) msg ; struct intel_svc_data_mem * p_mem ; struct intel_svc_data * p_data ; int ret = 0 ; p_data = kmalloc ( sizeof ( * p_data ) , GFP_KERNEL ) ; if ( ! p_data ) return - ENOMEM ; if ( ! chan -> ctrl -> task ) { chan -> ctrl -> task = kthread_create_on_cpu ( svc_normal_to_secure_thread , ( void * ) chan -> ctrl , 0 , "svc_smc_hvc_thread" ) ; if ( IS_ERR ( chan -> ctrl -> task ) ) { dev_err ( chan -> ctrl -> dev , "fails<S2SV_blank>to<S2SV_blank>create<S2SV_blank>svc_smc_hvc_thread\\n" ) ; <S2SV_StartBug> return - EINVAL ; <S2SV_EndBug> } wake_up_process ( chan -> ctrl -> task ) ; } pr_debug ( "%s:<S2SV_blank>sent<S2SV_blank>P-va=%p,<S2SV_blank>P-com=%x,<S2SV_blank>P-size=%u\\n" , __func__ , p_msg -> payload , p_msg -> command , ( unsigned int ) p_msg -> payload_length ) ; <S2SV_StartBug> list_for_each_entry ( p_mem , & svc_data_mem , node ) { <S2SV_EndBug> if ( p_mem -> vaddr == p_msg -> payload ) { p_data -> paddr = p_mem -> paddr ; break ; <S2SV_StartBug> } <S2SV_EndBug> } p_data -> command = p_msg -> command ; p_data -> arg [ 0 ] = p_msg -> arg [ 0 ] ; p_data -> arg [ 1 ] = p_msg -> arg [ 1 ] ; p_data -> arg [ 2 ] = p_msg -> arg [ 2 ] ; p_data -> size = p_msg -> payload_length ; p_data -> chan = chan ; pr_debug ( "%s:<S2SV_blank>put<S2SV_blank>to<S2SV_blank>FIFO<S2SV_blank>pa=0x%016x,<S2SV_blank>cmd=%x,<S2SV_blank>size=%u\\n" , __func__ , ( unsigned int ) p_data -> paddr , p_data -> command , ( unsigned int ) p_data -> size ) ; ret = kfifo_in_spinlocked ( & chan -> ctrl -> svc_fifo , p_data , sizeof ( * p_data ) , & chan -> ctrl -> svc_fifo_lock ) ; kfree ( p_data ) ; if ( ! ret ) return - ENOBUFS ; return ret ; } | <S2SV_ModStart> "fails<S2SV_blank>to<S2SV_blank>create<S2SV_blank>svc_smc_hvc_thread\\n" ) ; kfree ( p_data ) ; <S2SV_ModStart> , node ) <S2SV_ModEnd> if ( p_mem <S2SV_ModStart> ; break ; <S2SV_ModEnd> } p_data -> |
285 | CWE-000 void bah_zbus_attach ( device_t parent , device_t self , void * aux ) { struct bah_zbus_softc * bsc = device_private ( self ) ; struct bah_softc * sc = & bsc -> sc_bah ; <S2SV_StartBug> struct zbus_args * zap = aux ; <S2SV_EndBug> sc -> sc_dev = self ; # if ( defined ( BAH_DEBUG ) && ( BAH_DEBUG > 2 ) ) printf ( "\\n%s:<S2SV_blank>attach(0x%p,<S2SV_blank>0x%p,<S2SV_blank>0x%p)\\n" , device_xname ( self ) , parent , self , aux ) ; # endif bsc -> sc_bst . base = ( bus_addr_t ) zap -> va ; bsc -> sc_bst . absm = & amiga_bus_stride_2 ; sc -> sc_bst_r = & bsc -> sc_bst ; sc -> sc_regs = bsc -> sc_bst . base + 0x4000 ; sc -> sc_bst_m = & bsc -> sc_bst ; sc -> sc_mem = bsc -> sc_bst . base + 0x8000 ; sc -> sc_reset = bah_zbus_reset ; <S2SV_StartBug> bah_attach_subr ( sc ) ; <S2SV_EndBug> bsc -> sc_isr . isr_intr = bahintr ; bsc -> sc_isr . isr_arg = sc ; bsc -> sc_isr . isr_ipl = 2 ; add_isr ( & bsc -> sc_isr ) ; } | <S2SV_ModStart> zap = aux ; int rv <S2SV_ModStart> = bah_zbus_reset ; rv = <S2SV_ModStart> sc ) ; if ( rv != 0 ) { aprint_error_dev ( self , "bah_attach_subr<S2SV_blank>failed(%d)\\n" , rv ) ; return ; } |
286 | CWE-000 static int msm_cpufreq_target ( struct cpufreq_policy * policy , unsigned int target_freq , unsigned int relation ) { int ret = 0 ; <S2SV_StartBug> int index ; <S2SV_EndBug> struct cpufreq_frequency_table * table ; mutex_lock ( & per_cpu ( suspend_data , policy -> cpu ) . suspend_mutex ) ; if ( target_freq == policy -> cur ) goto done ; if ( per_cpu ( suspend_data , policy -> cpu ) . device_suspended ) { pr_debug ( "cpufreq:<S2SV_blank>cpu%d<S2SV_blank>scheduling<S2SV_blank>frequency<S2SV_blank>change<S2SV_blank>" "in<S2SV_blank>suspend.\\n" , policy -> cpu ) ; ret = - EFAULT ; goto done ; } table = cpufreq_frequency_get_table ( policy -> cpu ) ; if ( ! table ) { pr_err ( "cpufreq:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>frequency<S2SV_blank>table<S2SV_blank>for<S2SV_blank>CPU%u\\n" , policy -> cpu ) ; ret = - ENODEV ; goto done ; } if ( cpufreq_frequency_table_target ( policy , table , target_freq , relation , & index ) ) { pr_err ( "cpufreq:<S2SV_blank>invalid<S2SV_blank>target_freq:<S2SV_blank>%d\\n" , target_freq ) ; ret = - EINVAL ; goto done ; } pr_debug ( "CPU[%d]<S2SV_blank>target<S2SV_blank>%d<S2SV_blank>relation<S2SV_blank>%d<S2SV_blank>(%d-%d)<S2SV_blank>selected<S2SV_blank>%d\\n" , policy -> cpu , target_freq , relation , policy -> min , policy -> max , table [ index ] . frequency ) ; ret = set_cpu_freq ( policy , table [ index ] . frequency , table [ index ] . driver_data ) ; done : mutex_unlock ( & per_cpu ( suspend_data , policy -> cpu ) . suspend_mutex ) ; return ret ; } | <S2SV_ModStart> ; int index = 0 |
287 | CWE-000 static void gsi_ring_in_db ( struct usb_ep * ep , struct usb_gsi_request * request ) { void __iomem * gsi_dbl_address_lsb ; void __iomem * gsi_dbl_address_msb ; dma_addr_t offset ; u64 dbl_addr = * ( ( u64 * ) request -> buf_base_addr ) ; u32 dbl_lo_addr = ( dbl_addr & 0xFFFFFFFF ) ; u32 dbl_hi_addr = ( dbl_addr >> 32 ) ; u32 num_trbs = ( request -> num_bufs * 2 + 2 ) ; struct dwc3_ep * dep = to_dwc3_ep ( ep ) ; struct dwc3 * dwc = dep -> dwc ; struct dwc3_msm * mdwc = dev_get_drvdata ( dwc -> dev -> parent ) ; gsi_dbl_address_lsb = devm_ioremap_nocache ( mdwc -> dev , dbl_lo_addr , sizeof ( u32 ) ) ; if ( ! gsi_dbl_address_lsb ) dev_dbg ( mdwc -> dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>GSI<S2SV_blank>DBL<S2SV_blank>address<S2SV_blank>LSB\\n" ) ; gsi_dbl_address_msb = devm_ioremap_nocache ( mdwc -> dev , dbl_hi_addr , sizeof ( u32 ) ) ; if ( ! gsi_dbl_address_msb ) dev_dbg ( mdwc -> dev , "Failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>GSI<S2SV_blank>DBL<S2SV_blank>address<S2SV_blank>MSB\\n" ) ; offset = dwc3_trb_dma_offset ( dep , & dep -> trb_pool [ num_trbs - 1 ] ) ; <S2SV_StartBug> dev_dbg ( mdwc -> dev , "Writing<S2SV_blank>link<S2SV_blank>TRB<S2SV_blank>addr:<S2SV_blank>%pa<S2SV_blank>to<S2SV_blank>%p<S2SV_blank>(%x)\\n" , <S2SV_EndBug> & offset , gsi_dbl_address_lsb , dbl_lo_addr ) ; writel_relaxed ( offset , gsi_dbl_address_lsb ) ; writel_relaxed ( 0 , gsi_dbl_address_msb ) ; } | <S2SV_ModStart> -> dev , "Writing<S2SV_blank>link<S2SV_blank>TRB<S2SV_blank>addr:<S2SV_blank>%pKa<S2SV_blank>to<S2SV_blank>%pK<S2SV_blank>(%x)\\n" <S2SV_ModEnd> , & offset |
288 | CWE-000 static int ArrayForLoopCallback ( ClientData data [ ] , Tcl_Interp * interp , int result ) { Interp * iPtr = ( Interp * ) interp ; ArraySearch * searchPtr = data [ 0 ] ; Tcl_Obj * keyVarObj = data [ 1 ] ; Tcl_Obj * valueVarObj = data [ 2 ] ; Tcl_Obj * scriptObj = data [ 3 ] ; Tcl_Obj * keyObj , * valueObj ; Var * varPtr ; Var * arrayPtr ; int done ; done = TCL_ERROR ; varPtr = TclObjLookupVarEx ( interp , searchPtr -> arrayNameObj , NULL , 0 , 0 , 0 , 0 , & arrayPtr ) ; if ( result == TCL_CONTINUE ) { result = TCL_OK ; } else if ( result != TCL_OK ) { if ( result == TCL_BREAK ) { Tcl_ResetResult ( interp ) ; result = TCL_OK ; } else if ( result == TCL_ERROR ) { Tcl_AppendObjToErrorInfo ( interp , Tcl_ObjPrintf ( "\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>(\\"array<S2SV_blank>for\\"<S2SV_blank>body<S2SV_blank>line<S2SV_blank>%d)" , Tcl_GetErrorLine ( interp ) ) ) ; } goto arrayfordone ; } keyObj = NULL ; valueObj = NULL ; done = ArrayObjNext ( interp , varPtr , searchPtr , & keyObj , & valueObj ) ; result = TCL_OK ; if ( done != TCL_CONTINUE ) { Tcl_ResetResult ( interp ) ; <S2SV_StartBug> if ( done == TCL_ERROR ) { <S2SV_EndBug> varPtr -> flags |= TCL_LEAVE_ERR_MSG ; <S2SV_StartBug> Tcl_AddErrorInfo ( interp , "array<S2SV_blank>changed<S2SV_blank>during<S2SV_blank>iteration" ) ; <S2SV_EndBug> result = done ; } goto arrayfordone ; } if ( Tcl_ObjSetVar2 ( interp , keyVarObj , NULL , keyObj , TCL_LEAVE_ERR_MSG ) == NULL ) { result = TCL_ERROR ; goto arrayfordone ; } if ( valueObj != NULL ) { if ( Tcl_ObjSetVar2 ( interp , valueVarObj , NULL , valueObj , TCL_LEAVE_ERR_MSG ) == NULL ) { result = TCL_ERROR ; goto arrayfordone ; } } TclNRAddCallback ( interp , ArrayForLoopCallback , searchPtr , keyVarObj , valueVarObj , scriptObj ) ; return TclNREvalObjEx ( interp , scriptObj , 0 , iPtr -> cmdFramePtr , 3 ) ; arrayfordone : if ( done != TCL_ERROR ) { ArrayDoneSearch ( iPtr , varPtr , searchPtr ) ; ckfree ( searchPtr ) ; } TclDecrRefCount ( keyVarObj ) ; TclDecrRefCount ( valueVarObj ) ; TclDecrRefCount ( scriptObj ) ; return result ; } | <S2SV_ModStart> TCL_ERROR ) { Tcl_SetObjResult ( interp , Tcl_NewStringObj ( "array<S2SV_blank>changed<S2SV_blank>during<S2SV_blank>iteration" , - 1 ) ) ; Tcl_SetErrorCode ( interp , "TCL" , "READ" , "array" , "for" , NULL ) ; <S2SV_ModStart> |= TCL_LEAVE_ERR_MSG ; <S2SV_ModEnd> result = done |
289 | CWE-000 int vp9_copy_reference_enc ( VP9_COMP * cpi , VP9_REFFRAME ref_frame_flag , YV12_BUFFER_CONFIG * sd ) { YV12_BUFFER_CONFIG * cfg = get_vp9_ref_frame_buffer ( cpi , ref_frame_flag ) ; if ( cfg ) { <S2SV_StartBug> vp8_yv12_copy_frame ( cfg , sd ) ; <S2SV_EndBug> return 0 ; } else { return - 1 ; } } | <S2SV_ModStart> cfg ) { vpx_yv12_copy_frame <S2SV_ModEnd> ( cfg , |
290 | CWE-000 static int ptlrpc_connect_set_flags ( struct obd_import * imp , struct obd_connect_data * ocd , __u64 old_connect_flags , struct obd_export * exp , int init_connect ) { static bool warned ; struct client_obd * cli = & imp -> imp_obd -> u . cli ; if ( ( imp -> imp_connect_flags_orig & OBD_CONNECT_IBITS ) && ! ( ocd -> ocd_connect_flags & OBD_CONNECT_IBITS ) ) { LCONSOLE_WARN ( "%s:<S2SV_blank>MDS<S2SV_blank>%s<S2SV_blank>does<S2SV_blank>not<S2SV_blank>support<S2SV_blank>ibits<S2SV_blank>" "lock,<S2SV_blank>either<S2SV_blank>very<S2SV_blank>old<S2SV_blank>or<S2SV_blank>invalid:<S2SV_blank>" "requested<S2SV_blank>%#llx,<S2SV_blank>replied<S2SV_blank>%#llx\\n" , imp -> imp_obd -> obd_name , imp -> imp_connection -> c_remote_uuid . uuid , imp -> imp_connect_flags_orig , ocd -> ocd_connect_flags ) ; return - EPROTO ; } spin_lock ( & imp -> imp_lock ) ; list_del ( & imp -> imp_conn_current -> oic_item ) ; list_add ( & imp -> imp_conn_current -> oic_item , & imp -> imp_conn_list ) ; imp -> imp_last_success_conn = imp -> imp_conn_current -> oic_last_attempt ; spin_unlock ( & imp -> imp_lock ) ; if ( ! warned && ( ocd -> ocd_connect_flags & OBD_CONNECT_VERSION ) && ( ocd -> ocd_version > LUSTRE_VERSION_CODE + LUSTRE_VERSION_OFFSET_WARN || ocd -> ocd_version < LUSTRE_VERSION_CODE - LUSTRE_VERSION_OFFSET_WARN ) ) { const char * older = "older<S2SV_blank>than<S2SV_blank>client.<S2SV_blank>" "Consider<S2SV_blank>upgrading<S2SV_blank>server" ; const char * newer = "newer<S2SV_blank>than<S2SV_blank>client.<S2SV_blank>" "Consider<S2SV_blank>recompiling<S2SV_blank>application" ; LCONSOLE_WARN ( "Server<S2SV_blank>%s<S2SV_blank>version<S2SV_blank>(%d.%d.%d.%d)<S2SV_blank>" "is<S2SV_blank>much<S2SV_blank>%s<S2SV_blank>(%s)\\n" , obd2cli_tgt ( imp -> imp_obd ) , OBD_OCD_VERSION_MAJOR ( ocd -> ocd_version ) , OBD_OCD_VERSION_MINOR ( ocd -> ocd_version ) , OBD_OCD_VERSION_PATCH ( ocd -> ocd_version ) , OBD_OCD_VERSION_FIX ( ocd -> ocd_version ) , ocd -> ocd_version > LUSTRE_VERSION_CODE ? newer : older , LUSTRE_VERSION_STRING ) ; warned = true ; } # if LUSTRE_VERSION_CODE < OBD_OCD_VERSION ( 3 , 0 , 53 , 0 ) if ( unlikely ( ( ocd -> ocd_connect_flags & OBD_CONNECT_VERSION ) && ! ( ocd -> ocd_connect_flags & OBD_CONNECT_MNE_SWAB ) && OBD_OCD_VERSION_MAJOR ( ocd -> ocd_version ) == 2 && OBD_OCD_VERSION_MINOR ( ocd -> ocd_version ) == 2 && OBD_OCD_VERSION_PATCH ( ocd -> ocd_version ) < 55 && strcmp ( imp -> imp_obd -> obd_type -> typ_name , LUSTRE_MGC_NAME ) == 0 ) ) imp -> imp_need_mne_swab = 1 ; else imp -> imp_need_mne_swab = 0 ; # endif if ( ocd -> ocd_connect_flags & OBD_CONNECT_CKSUM ) { if ( ( ocd -> ocd_cksum_types & cksum_types_supported_client ( ) ) == 0 ) { <S2SV_StartBug> LCONSOLE_WARN ( "The<S2SV_blank>negotiation<S2SV_blank>of<S2SV_blank>the<S2SV_blank>checksum<S2SV_blank>" <S2SV_EndBug> "alogrithm<S2SV_blank>to<S2SV_blank>use<S2SV_blank>with<S2SV_blank>server<S2SV_blank>%s<S2SV_blank>" <S2SV_StartBug> "failed<S2SV_blank>(%x/%x),<S2SV_blank>disabling<S2SV_blank>" <S2SV_EndBug> "checksums\\n" , obd2cli_tgt ( imp -> imp_obd ) , ocd -> ocd_cksum_types , cksum_types_supported_client ( ) ) ; <S2SV_StartBug> cli -> cl_checksum = 0 ; <S2SV_EndBug> cli -> cl_supp_cksum_types = OBD_CKSUM_ADLER ; } else { cli -> cl_supp_cksum_types = ocd -> ocd_cksum_types ; } } else { cli -> cl_supp_cksum_types = OBD_CKSUM_ADLER ; } cli -> cl_cksum_type = cksum_type_select ( cli -> cl_supp_cksum_types ) ; if ( ocd -> ocd_connect_flags & OBD_CONNECT_BRW_SIZE ) cli -> cl_max_pages_per_rpc = min ( ocd -> ocd_brw_size >> PAGE_SHIFT , cli -> cl_max_pages_per_rpc ) ; else if ( imp -> imp_connect_op == MDS_CONNECT || imp -> imp_connect_op == MGS_CONNECT ) cli -> cl_max_pages_per_rpc = 1 ; LASSERT ( ( cli -> cl_max_pages_per_rpc <= PTLRPC_MAX_BRW_PAGES ) && ( cli -> cl_max_pages_per_rpc > 0 ) ) ; client_adjust_max_dirty ( cli ) ; if ( ocd -> ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS ) cli -> cl_max_mod_rpcs_in_flight = min ( cli -> cl_max_mod_rpcs_in_flight , ocd -> ocd_maxmodrpcs ) ; else cli -> cl_max_mod_rpcs_in_flight = 1 ; if ( old_connect_flags != exp_connect_flags ( exp ) || init_connect ) { CDEBUG ( D_HA , "%s:<S2SV_blank>Resetting<S2SV_blank>ns_connect_flags<S2SV_blank>to<S2SV_blank>server<S2SV_blank>" "flags:<S2SV_blank>%#llx\\n" , imp -> imp_obd -> obd_name , ocd -> ocd_connect_flags ) ; imp -> imp_obd -> obd_namespace -> ns_connect_flags = ocd -> ocd_connect_flags ; imp -> imp_obd -> obd_namespace -> ns_orig_connect_flags = ocd -> ocd_connect_flags ; } if ( ocd -> ocd_connect_flags & OBD_CONNECT_AT ) imp -> imp_msghdr_flags |= MSGHDR_AT_SUPPORT ; else imp -> imp_msghdr_flags &= ~ MSGHDR_AT_SUPPORT ; imp -> imp_msghdr_flags |= MSGHDR_CKSUM_INCOMPAT18 ; return 0 ; } | <S2SV_ModStart> 0 ) { LCONSOLE_ERROR <S2SV_ModEnd> ( "The<S2SV_blank>negotiation<S2SV_blank>of<S2SV_blank>the<S2SV_blank>checksum<S2SV_blank>" "alogrithm<S2SV_blank>to<S2SV_blank>use<S2SV_blank>with<S2SV_blank>server<S2SV_blank>%s<S2SV_blank>" <S2SV_ModStart> ( "The<S2SV_blank>negotiation<S2SV_blank>of<S2SV_blank>the<S2SV_blank>checksum<S2SV_blank>" "alogrithm<S2SV_blank>to<S2SV_blank>use<S2SV_blank>with<S2SV_blank>server<S2SV_blank>%s<S2SV_blank>" "failed<S2SV_blank>(%x/%x)\\n" <S2SV_ModEnd> , obd2cli_tgt ( <S2SV_ModStart> ) ) ; return - EPROTO <S2SV_ModEnd> ; } else |
291 | CWE-000 static long vpu_service_ioctl ( struct file * filp , unsigned int cmd , unsigned long arg ) { struct vpu_subdev_data * data = container_of ( filp -> f_path . dentry -> d_inode -> i_cdev , struct vpu_subdev_data , cdev ) ; struct vpu_service_info * pservice = data -> pservice ; struct vpu_session * session = ( struct vpu_session * ) filp -> private_data ; vpu_debug_enter ( ) ; vpu_debug ( DEBUG_IOCTL , "cmd<S2SV_blank>%x,<S2SV_blank>VPU_IOC_SET_CLIENT_TYPE<S2SV_blank>%x\\n" , cmd , ( u32 ) VPU_IOC_SET_CLIENT_TYPE ) ; if ( NULL == session ) return - EINVAL ; switch ( cmd ) { case VPU_IOC_SET_CLIENT_TYPE : { int secure_mode ; secure_mode = ( arg & 0xffff0000 ) >> 16 ; session -> type = ( enum VPU_CLIENT_TYPE ) ( arg & 0xffff ) ; atomic_set ( & pservice -> secure_mode , secure_mode ) ; session -> type = ( enum VPU_CLIENT_TYPE ) arg ; vpu_debug ( DEBUG_IOCTL , "pid<S2SV_blank>%d<S2SV_blank>set<S2SV_blank>client<S2SV_blank>type<S2SV_blank>%d,<S2SV_blank>secure<S2SV_blank>mode<S2SV_blank>=<S2SV_blank>%d\\n" , session -> pid , session -> type , secure_mode ) ; } break ; case VPU_IOC_GET_HW_FUSE_STATUS : { struct vpu_request req ; vpu_debug ( DEBUG_IOCTL , "pid<S2SV_blank>%d<S2SV_blank>get<S2SV_blank>hw<S2SV_blank>status<S2SV_blank>%d\\n" , session -> pid , session -> type ) ; if ( copy_from_user ( & req , ( void __user * ) arg , sizeof ( req ) ) ) { vpu_err ( "error:<S2SV_blank>get<S2SV_blank>hw<S2SV_blank>status<S2SV_blank>copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } else { void * config = ( session -> type != VPU_ENC ) ? ( ( void * ) & pservice -> dec_config ) : ( ( void * ) & pservice -> enc_config ) ; size_t size = ( session -> type != VPU_ENC ) ? ( sizeof ( struct vpu_dec_config ) ) : ( sizeof ( struct vpu_enc_config ) ) ; if ( copy_to_user ( ( void __user * ) req . req , config , size ) ) { vpu_err ( "error:<S2SV_blank>get<S2SV_blank>hw<S2SV_blank>status<S2SV_blank>copy_to_user<S2SV_blank>failed<S2SV_blank>type<S2SV_blank>%d\\n" , session -> type ) ; return - EFAULT ; } } } break ; case VPU_IOC_SET_REG : { struct vpu_request req ; struct vpu_reg * reg ; vpu_debug ( DEBUG_IOCTL , "pid<S2SV_blank>%d<S2SV_blank>set<S2SV_blank>reg<S2SV_blank>type<S2SV_blank>%d\\n" , session -> pid , session -> type ) ; if ( atomic_read ( & pservice -> secure_mode ) == 1 ) { vpu_service_power_on ( data , pservice ) ; pservice -> wait_secure_isr = & session -> wait ; if ( ! pservice -> secure_isr && ! pservice -> secure_irq_status ) enable_irq ( data -> irq_dec ) ; break ; } if ( copy_from_user ( & req , ( void __user * ) arg , sizeof ( struct vpu_request ) ) ) { vpu_err ( "error:<S2SV_blank>set<S2SV_blank>reg<S2SV_blank>copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } reg = reg_init ( data , session , ( void __user * ) req . req , req . size ) ; if ( NULL == reg ) { return - EFAULT ; } else { queue_work ( pservice -> set_workq , & data -> set_work ) ; } } break ; case VPU_IOC_GET_REG : { struct vpu_request req ; struct vpu_reg * reg ; int ret ; vpu_debug ( DEBUG_IOCTL , "pid<S2SV_blank>%d<S2SV_blank>get<S2SV_blank>reg<S2SV_blank>type<S2SV_blank>%d\\n" , session -> pid , session -> type ) ; if ( atomic_read ( & pservice -> secure_mode ) == 1 ) { ret = wait_event_timeout ( session -> wait , pservice -> secure_isr , VPU_TIMEOUT_DELAY ) ; if ( ret < 0 ) { pr_info ( "warning:<S2SV_blank>secure<S2SV_blank>wait<S2SV_blank>timeout\\n" ) ; ret = 0 ; } pservice -> secure_isr = false ; break ; } if ( copy_from_user ( & req , ( void __user * ) arg , sizeof ( struct vpu_request ) ) ) { vpu_err ( "error:<S2SV_blank>get<S2SV_blank>reg<S2SV_blank>copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } ret = wait_event_timeout ( session -> wait , ! list_empty ( & session -> done ) , VPU_TIMEOUT_DELAY ) ; <S2SV_StartBug> if ( ! list_empty ( & session -> done ) ) { <S2SV_EndBug> if ( ret < 0 ) vpu_err ( "warning:<S2SV_blank>pid<S2SV_blank>%d<S2SV_blank>wait<S2SV_blank>task<S2SV_blank>error<S2SV_blank>ret<S2SV_blank>%d\\n" , session -> pid , ret ) ; ret = 0 ; } else { if ( unlikely ( ret < 0 ) ) { vpu_err ( "error:<S2SV_blank>pid<S2SV_blank>%d<S2SV_blank>wait<S2SV_blank>task<S2SV_blank>ret<S2SV_blank>%d\\n" , session -> pid , ret ) ; } else if ( ret == 0 ) { vpu_err ( "error:<S2SV_blank>pid<S2SV_blank>%d<S2SV_blank>wait<S2SV_blank>%d<S2SV_blank>task<S2SV_blank>done<S2SV_blank>timeout\\n" , session -> pid , atomic_read ( & session -> task_running ) ) ; ret = - ETIMEDOUT ; } } if ( ret < 0 ) { int task_running = atomic_read ( & session -> task_running ) ; mutex_lock ( & pservice -> lock ) ; if ( task_running ) { atomic_set ( & session -> task_running , 0 ) ; atomic_sub ( task_running , & pservice -> total_running ) ; dev_err ( pservice -> dev , "%d<S2SV_blank>task<S2SV_blank>is<S2SV_blank>running<S2SV_blank>but<S2SV_blank>not<S2SV_blank>return,<S2SV_blank>reset<S2SV_blank>hardware..." , task_running ) ; vpu_reset ( data ) ; dev_err ( pservice -> dev , "done\\n" ) ; } vpu_service_session_clear ( data , session ) ; mutex_unlock ( & pservice -> lock ) ; return ret ; } mutex_lock ( & pservice -> lock ) ; reg = list_entry ( session -> done . next , struct vpu_reg , session_link ) ; return_reg ( data , reg , ( u32 __user * ) req . req ) ; mutex_unlock ( & pservice -> lock ) ; } break ; case VPU_IOC_PROBE_IOMMU_STATUS : { int iommu_enable = 1 ; vpu_debug ( DEBUG_IOCTL , "VPU_IOC_PROBE_IOMMU_STATUS\\n" ) ; if ( copy_to_user ( ( void __user * ) arg , & iommu_enable , sizeof ( int ) ) ) { vpu_err ( "error:<S2SV_blank>iommu<S2SV_blank>status<S2SV_blank>copy_to_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } } break ; case VPU_IOC_SET_DRIVER_DATA : { u32 val ; if ( copy_from_user ( & val , ( void __user * ) arg , sizeof ( int ) ) ) { vpu_err ( "error:<S2SV_blank>COMPAT_VPU_IOC_SET_DRIVER_DATA<S2SV_blank>copy_from_user<S2SV_blank>failed\\n" ) ; return - EFAULT ; } if ( pservice -> grf ) regmap_write ( pservice -> grf , 0x5d8 , val ) ; } break ; default : { vpu_err ( "error:<S2SV_blank>unknow<S2SV_blank>vpu<S2SV_blank>service<S2SV_blank>ioctl<S2SV_blank>cmd<S2SV_blank>%x\\n" , cmd ) ; return - ENOIOCTLCMD ; } break ; } vpu_debug_leave ( ) ; return 0 ; } | <S2SV_ModStart> VPU_TIMEOUT_DELAY ) ; while ( atomic_read ( & pservice -> reset_request ) ) msleep ( 10 ) ; |
292 | CWE-000 int main ( ) { int net_socket ; net_socket = socket ( AF_INET , SOCK_STREAM , 0 ) ; struct sockaddr_in server_addr ; server_addr . sin_family = AF_INET ; server_addr . sin_port = htons ( 9002 ) ; server_addr . sin_addr . s_addr = htonl ( 0xC0A80009 ) ; int connection_status = connect ( net_socket , ( struct sockaddr * ) & server_addr , sizeof ( server_addr ) ) ; if ( connection_status == - 1 ) printf ( "There<S2SV_blank>was<S2SV_blank>an<S2SV_blank>error<S2SV_blank>making<S2SV_blank>a<S2SV_blank>connection<S2SV_blank>to<S2SV_blank>the<S2SV_blank>remote<S2SV_blank>socket.\\n" ) ; char connect_info [ 256 ] = "connect<S2SV_blank>to<S2SV_blank>server\\n" ; send ( net_socket , connect_info , sizeof ( connect_info ) , 0 ) ; printf ( "client<S2SV_blank>reached<S2SV_blank>the<S2SV_blank>server\\n" ) ; int count ; int term_buf [ 1 ] ; count = recv ( net_socket , term_buf , sizeof ( term_buf ) , 0 ) ; int term = term_buf [ 0 ] ; printf ( "\\n%d<S2SV_blank>devices<S2SV_blank>in<S2SV_blank>total\\n" , term ) ; int i ; pid_t * pids = malloc ( sizeof ( pid_t ) * term ) ; for ( i = 0 ; i < term ; i ++ ) { pids [ i ] = fork ( ) ; if ( pids [ i ] < 0 ) { perror ( "fork()<S2SV_blank>error!\\n" ) ; exit ( - 1 ) ; } else if ( pids [ i ] == 0 ) { double xy [ 2 ] ; int c_rev ; c_rev = recv ( net_socket , xy , sizeof ( xy ) , 0 ) ; printf ( "process<S2SV_blank>%d<S2SV_blank>received<S2SV_blank>x:<S2SV_blank>%f,<S2SV_blank>y:<S2SV_blank>%f\\n" , i , xy [ 0 ] , xy [ 1 ] ) ; printf ( "%d<S2SV_blank>bytes<S2SV_blank>in<S2SV_blank>total\\n" , c_rev ) ; sleep ( 5 ) ; <S2SV_StartBug> } <S2SV_EndBug> } pid_t child_id ; int status ; int n = term ; while ( n > 0 ) { child_id = wait ( & status ) ; printf ( "Child<S2SV_blank>with<S2SV_blank>PID<S2SV_blank>%ld<S2SV_blank>exited<S2SV_blank>with<S2SV_blank>status<S2SV_blank>0x%x.\\n" , ( long ) child_id , status ) ; n -- ; } close ( net_socket ) ; return 0 ; } | <S2SV_ModStart> 5 ) ; exit ( 0 ) ; |
293 | CWE-000 static int net_req_query_id_cmp ( const void * id1 , const void * id2 ) { <S2SV_StartBug> return ( intptr_t ) id1 - ( intptr_t ) id2 ; <S2SV_EndBug> } | <S2SV_ModStart> id2 ) { int ret = 0 ; if ( id1 != id2 ) { ret = ( <S2SV_ModEnd> ( intptr_t ) <S2SV_ModStart> intptr_t ) id1 < <S2SV_ModEnd> ( intptr_t ) <S2SV_ModStart> intptr_t ) id2 ) ? - 1 : 1 ; } return ret |
294 | CWE-000 void SS_process_ctes ( PlannerInfo * root ) { ListCell * lc ; Assert ( root -> cte_plan_ids == NIL ) ; foreach ( lc , root -> parse -> cteList ) { CommonTableExpr * cte = ( CommonTableExpr * ) lfirst ( lc ) ; CmdType cmdType = ( ( Query * ) cte -> ctequery ) -> commandType ; Query * subquery ; PlannerInfo * subroot ; RelOptInfo * final_rel ; Path * best_path ; Plan * plan ; SubPlan * splan ; int paramid ; if ( cte -> cterefcount == 0 && cmdType == CMD_SELECT ) { root -> cte_plan_ids = lappend_int ( root -> cte_plan_ids , - 1 ) ; continue ; } subquery = ( Query * ) copyObject ( cte -> ctequery ) ; Assert ( root -> plan_params == NIL ) ; subroot = subquery_planner ( root -> glob , subquery , root , cte -> cterecursive , 0.0 ) ; if ( root -> plan_params ) elog ( ERROR , "unexpected<S2SV_blank>outer<S2SV_blank>reference<S2SV_blank>in<S2SV_blank>CTE<S2SV_blank>query" ) ; final_rel = fetch_upper_rel ( subroot , UPPERREL_FINAL , NULL ) ; best_path = final_rel -> cheapest_total_path ; <S2SV_StartBug> plan = create_plan ( subroot , best_path ) ; <S2SV_EndBug> # ifdef XCP if ( subroot -> distribution ) { plan = ( Plan * ) make_remotesubplan ( subroot , plan , NULL , subroot -> distribution , subroot -> query_pathkeys ) ; plan -> extParam = bms_copy ( plan -> lefttree -> extParam ) ; plan -> allParam = bms_copy ( plan -> lefttree -> allParam ) ; } # endif splan = makeNode ( SubPlan ) ; splan -> subLinkType = CTE_SUBLINK ; splan -> testexpr = NULL ; splan -> paramIds = NIL ; get_first_col_type ( plan , & splan -> firstColType , & splan -> firstColTypmod , & splan -> firstColCollation ) ; splan -> useHashTable = false ; splan -> unknownEqFalse = false ; splan -> parallel_safe = false ; splan -> setParam = NIL ; splan -> parParam = NIL ; splan -> args = NIL ; paramid = SS_assign_special_param ( root ) ; splan -> setParam = list_make1_int ( paramid ) ; root -> glob -> subplans = lappend ( root -> glob -> subplans , plan ) ; root -> glob -> subroots = lappend ( root -> glob -> subroots , subroot ) ; splan -> plan_id = list_length ( root -> glob -> subplans ) ; root -> init_plans = lappend ( root -> init_plans , splan ) ; root -> cte_plan_ids = lappend_int ( root -> cte_plan_ids , splan -> plan_id ) ; splan -> plan_name = psprintf ( "CTE<S2SV_blank>%s" , cte -> ctename ) ; cost_subplan ( root , splan , plan ) ; } } | <S2SV_ModStart> -> cheapest_total_path ; if ( ! subroot -> distribution ) subroot -> distribution = best_path -> distribution ; |
295 | CWE-000 void shell ( char const * prompt ) { char buf [ CONFIG_LINE_MAX ] ; int argc ; char * * argv ; int exec_err ; FILE * stream ; stat_t f_stat ; stream_stack * streams , * stackp ; term_cfg_t tc ; exec_err = 0 ; stream = stdin ; streams = 0x0 ; shell_line = 0 ; strncpy ( shell_file , "stdin" , CONFIG_FILE_MAX ) ; ioctl ( 0 , IOCTL_CFGRD , & tc , sizeof ( term_cfg_t ) ) ; tc . flags &= ~ TF_ECHO ; ioctl ( 0 , IOCTL_CFGWR , & tc , sizeof ( term_cfg_t ) ) ; cmd_init ( ) ; while ( 1 ) { if ( stream == stdin ) { fputs ( prompt , stdout ) ; fputs ( STORE_POS , stdout ) ; fflush ( stdout ) ; exec_err = 0 ; } shell_line ++ ; <S2SV_StartBug> if ( exec_err || stream == 0x0 || readline ( stream , buf , CONFIG_LINE_MAX ) == 0 ) { <S2SV_EndBug> exec_err = 0 ; stackp = stack_pop ( streams ) ; if ( stackp ) { fclose ( stream ) ; stream = stackp -> stream ; strncpy ( shell_file , stackp -> file , CONFIG_FILE_MAX ) ; shell_line = stackp -> line ; free ( stackp ) ; } continue ; } if ( strsplit ( buf , & argc , & argv ) < 0 ) { SHELL_ERROR ( "error<S2SV_blank>parsing<S2SV_blank>line<S2SV_blank>\\"%s\\"\\n" , strerror ( errno ) ) ; continue ; } if ( stat ( argv [ 0 ] , & f_stat ) == 0 && f_stat . type == FT_REG ) { stackp = malloc ( sizeof ( stream_stack ) ) ; if ( stackp == 0x0 ) { SHELL_ERROR ( "out<S2SV_blank>of<S2SV_blank>memory\\n" ) ; goto iter_clean ; } stackp -> stream = stream ; strncpy ( stackp -> file , shell_file , CONFIG_FILE_MAX ) ; stackp -> line = shell_line ; stack_push ( streams , stackp ) ; stream = fopen ( argv [ 0 ] , "r" ) ; if ( stream == 0x0 ) SHELL_ERROR ( "error<S2SV_blank>opening<S2SV_blank>script<S2SV_blank>%s<S2SV_blank>\\"%s\\"\\n" , argv [ 0 ] , strerror ( errno ) ) ; strncpy ( shell_file , argv [ 0 ] , CONFIG_FILE_MAX ) ; shell_line = 0 ; } else exec_err = cmd_exec ( argc , argv ) ; iter_clean : for ( -- argc ; argc >= 0 ; argc -- ) free ( argv [ argc ] ) ; free ( argv ) ; } } | <S2SV_ModStart> ; if ( ! exec_err && stream ) { if ( stream == stdin ) exec_err = ( readline_stdin ( stream , buf , CONFIG_LINE_MAX ) == 0 ) ; else exec_err = ( readline_regfile ( stream , buf , CONFIG_LINE_MAX ) == 0 ) ; } if ( <S2SV_ModStart> stream == 0x0 <S2SV_ModEnd> ) { exec_err |
296 | CWE-000 static bool ieee80211_xmit_fast ( struct ieee80211_sub_if_data * sdata , struct sta_info * sta , struct ieee80211_fast_tx * fast_tx , struct sk_buff * skb ) { struct ieee80211_local * local = sdata -> local ; u16 ethertype = ( skb -> data [ 12 ] << 8 ) | skb -> data [ 13 ] ; int extra_head = fast_tx -> hdr_len - ( ETH_HLEN - 2 ) ; int hw_headroom = sdata -> local -> hw . extra_tx_headroom ; struct ethhdr eth ; struct ieee80211_tx_info * info = IEEE80211_SKB_CB ( skb ) ; struct ieee80211_hdr * hdr = ( void * ) fast_tx -> hdr ; struct ieee80211_tx_data tx ; ieee80211_tx_result r ; struct tid_ampdu_tx * tid_tx = NULL ; u8 tid = IEEE80211_NUM_TIDS ; if ( cpu_to_be16 ( ethertype ) == sdata -> control_port_protocol ) return false ; if ( ethertype < ETH_P_802_3_MIN ) return false ; if ( skb -> sk && skb_shinfo ( skb ) -> tx_flags & SKBTX_WIFI_STATUS ) return false ; if ( hdr -> frame_control & cpu_to_le16 ( IEEE80211_STYPE_QOS_DATA ) ) { tid = skb -> priority & IEEE80211_QOS_CTL_TAG1D_MASK ; tid_tx = rcu_dereference ( sta -> ampdu_mlme . tid_tx [ tid ] ) ; if ( tid_tx ) { if ( ! test_bit ( HT_AGG_STATE_OPERATIONAL , & tid_tx -> state ) ) return false ; if ( tid_tx -> timeout ) tid_tx -> last_tx = jiffies ; } } if ( skb_shared ( skb ) ) { struct sk_buff * tmp_skb = skb ; skb = skb_clone ( skb , GFP_ATOMIC ) ; kfree_skb ( tmp_skb ) ; if ( ! skb ) return true ; } if ( ( hdr -> frame_control & cpu_to_le16 ( IEEE80211_STYPE_QOS_DATA ) ) && ieee80211_amsdu_aggregate ( sdata , sta , fast_tx , skb ) ) return true ; if ( unlikely ( ieee80211_skb_resize ( sdata , skb , max_t ( int , extra_head + hw_headroom - skb_headroom ( skb ) , 0 ) , false ) ) ) { kfree_skb ( skb ) ; return true ; } memcpy ( & eth , skb -> data , ETH_HLEN - 2 ) ; hdr = ( void * ) skb_push ( skb , extra_head ) ; memcpy ( skb -> data , fast_tx -> hdr , fast_tx -> hdr_len ) ; memcpy ( skb -> data + fast_tx -> da_offs , eth . h_dest , ETH_ALEN ) ; memcpy ( skb -> data + fast_tx -> sa_offs , eth . h_source , ETH_ALEN ) ; memset ( info , 0 , sizeof ( * info ) ) ; info -> band = fast_tx -> band ; info -> control . vif = & sdata -> vif ; info -> flags = IEEE80211_TX_CTL_FIRST_FRAGMENT | IEEE80211_TX_CTL_DONTFRAG | ( tid_tx ? IEEE80211_TX_CTL_AMPDU : 0 ) ; info -> control . flags = IEEE80211_TX_CTRL_FAST_XMIT ; <S2SV_StartBug> __skb_queue_head_init ( & tx . skbs ) ; <S2SV_EndBug> tx . flags = IEEE80211_TX_UNICAST ; tx . local = local ; tx . sdata = sdata ; tx . sta = sta ; tx . key = fast_tx -> key ; if ( ! ieee80211_hw_check ( & local -> hw , HAS_RATE_CONTROL ) ) { tx . skb = skb ; r = ieee80211_tx_h_rate_ctrl ( & tx ) ; skb = tx . skb ; tx . skb = NULL ; if ( r != TX_CONTINUE ) { if ( r != TX_QUEUED ) kfree_skb ( skb ) ; return true ; } } if ( ieee80211_queue_skb ( local , sdata , sta , skb ) ) return true ; ieee80211_xmit_fast_finish ( sdata , sta , fast_tx -> pn_offs , fast_tx -> key , skb ) ; if ( sdata -> vif . type == NL80211_IFTYPE_AP_VLAN ) sdata = container_of ( sdata -> bss , struct ieee80211_sub_if_data , u . ap ) ; __skb_queue_tail ( & tx . skbs , skb ) ; ieee80211_tx_frags ( local , & sdata -> vif , & sta -> sta , & tx . skbs , false ) ; return true ; } | <S2SV_ModStart> = IEEE80211_TX_CTRL_FAST_XMIT ; if ( hdr -> frame_control & cpu_to_le16 ( IEEE80211_STYPE_QOS_DATA ) ) { tid = skb -> priority & IEEE80211_QOS_CTL_TAG1D_MASK ; * ieee80211_get_qos_ctl ( hdr ) = tid ; } |
297 | CWE-000 static bool endmap_handler ( void * closure , const void * hd , upb_status * s ) { map_parse_frame_t * frame = closure ; const map_handlerdata_t * mapdata = hd ; VALUE key = native_slot_get ( mapdata -> key_field_type , Qnil , & frame -> key_storage ) ; VALUE value_field_typeclass = Qnil ; VALUE value ; if ( mapdata -> value_field_type == UPB_TYPE_MESSAGE || mapdata -> value_field_type == UPB_TYPE_ENUM ) { value_field_typeclass = get_def_obj ( mapdata -> value_field_subdef ) ; } value = native_slot_get ( mapdata -> value_field_type , value_field_typeclass , & frame -> value_storage ) ; Map_index_set ( frame -> map , key , value ) ; <S2SV_StartBug> map_pop_frame ( ) ; <S2SV_EndBug> return true ; } | <S2SV_ModStart> value ) ; Map_set_frame ( frame -> map , Qnil <S2SV_ModEnd> ) ; return |
298 | CWE-000 static int mlxsw_sp_fib4_entry_type_set ( struct mlxsw_sp * mlxsw_sp , const struct fib_entry_notifier_info * fen_info , struct mlxsw_sp_fib_entry * fib_entry ) { <S2SV_StartBug> struct fib_info * fi = fen_info -> fi ; <S2SV_EndBug> switch ( fen_info -> type ) { <S2SV_StartBug> case RTN_BROADCAST : <S2SV_EndBug> case RTN_LOCAL : fib_entry -> type = MLXSW_SP_FIB_ENTRY_TYPE_TRAP ; return 0 ; case RTN_UNREACHABLE : case RTN_BLACKHOLE : case RTN_PROHIBIT : fib_entry -> type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ; return 0 ; case RTN_UNICAST : if ( mlxsw_sp_fi_is_gateway ( mlxsw_sp , fi ) ) fib_entry -> type = MLXSW_SP_FIB_ENTRY_TYPE_REMOTE ; else fib_entry -> type = MLXSW_SP_FIB_ENTRY_TYPE_LOCAL ; return 0 ; default : return - EINVAL ; } } | <S2SV_ModStart> fib_entry ) { union mlxsw_sp_l3addr dip = { . addr4 = htonl ( fen_info -> dst ) } ; struct net_device * dev = fen_info -> fi -> fib_dev ; struct mlxsw_sp_ipip_entry * ipip_entry ; <S2SV_ModStart> ) { case RTN_LOCAL : ipip_entry = mlxsw_sp_ipip_entry_find_by_decap ( mlxsw_sp , dev , MLXSW_SP_L3_PROTO_IPV4 , dip ) ; if ( ipip_entry ) { ipip_entry -> decap_fib_entry = fib_entry ; fib_entry -> ipip_entry = ipip_entry ; fib_entry -> type = MLXSW_SP_FIB_ENTRY_TYPE_IPIP_DECAP ; return 0 ; } case RTN_BROADCAST <S2SV_ModEnd> : fib_entry -> |
299 | CWE-000 int main ( int argc , char * argv [ ] ) { int auswahl ; int p ; int essidlen = 0 ; int passwordlen = 0 ; int ret = 0 ; long int hcxorgrecords = 0 ; hcxdata = NULL ; fhpot = NULL ; struct stat statpot ; struct tm * tm_info ; struct timeval tv ; char * eigenname = NULL ; char * eigenpfadname = NULL ; char * hcxinname = NULL ; char * essidname = NULL ; char * passwordname = NULL ; char * pmkname = NULL ; char * potname = NULL ; char * wordlistinname = NULL ; char zeitstring [ 26 ] ; eigenpfadname = strdupa ( argv [ 0 ] ) ; eigenname = basename ( eigenpfadname ) ; setbuf ( stdout , NULL ) ; while ( ( auswahl = getopt ( argc , argv , "i:e:p:P:w:o:hv" ) ) != - 1 ) { switch ( auswahl ) { case 'i' : hcxinname = optarg ; break ; case 'e' : essidname = optarg ; essidlen = strlen ( essidname ) ; if ( ( essidlen < 1 ) || ( essidlen > 32 ) ) { fprintf ( stderr , "error<S2SV_blank>wrong<S2SV_blank>essid<S2SV_blank>len<S2SV_blank>(allowed:<S2SV_blank>1<S2SV_blank>..<S2SV_blank>32<S2SV_blank>characters)\\n" ) ; exit ( EXIT_FAILURE ) ; } break ; case 'p' : passwordname = optarg ; passwordlen = strlen ( passwordname ) ; if ( ( passwordlen < 8 ) || ( passwordlen > 63 ) ) { fprintf ( stderr , "error<S2SV_blank>wrong<S2SV_blank>password<S2SV_blank>len<S2SV_blank>(allowed:<S2SV_blank>8<S2SV_blank>..<S2SV_blank>63<S2SV_blank>characters\\n" ) ; exit ( EXIT_FAILURE ) ; } break ; case 'P' : pmkname = optarg ; if ( strlen ( pmkname ) != 64 ) { fprintf ( stderr , "error<S2SV_blank>wrong<S2SV_blank>plainmasterkey<S2SV_blank>len<S2SV_blank>(allowed:<S2SV_blank>64<S2SV_blank>xdigits)\\n" ) ; exit ( EXIT_FAILURE ) ; } for ( p = 0 ; p < 64 ; p ++ ) { if ( ! ( isxdigit ( pmkname [ p ] ) ) ) { fprintf ( stderr , "error<S2SV_blank>wrong<S2SV_blank>plainmasterkey<S2SV_blank>len<S2SV_blank>(allowed:<S2SV_blank>64<S2SV_blank>xdigits)\\n" ) ; exit ( EXIT_FAILURE ) ; } } break ; case 'o' : potname = optarg ; if ( ( fhpot = fopen ( potname , "a" ) ) == NULL ) { fprintf ( stderr , "error<S2SV_blank>opening<S2SV_blank>%s\\n" , potname ) ; exit ( EXIT_FAILURE ) ; } break ; case 'w' : wordlistinname = optarg ; break ; case 'h' : usage ( eigenname ) ; break ; default : usage ( eigenname ) ; break ; } } if ( ( essidname == 0 ) && ( passwordname != NULL ) && ( pmkname != NULL ) && ( wordlistinname != NULL ) ) { fprintf ( stderr , "nothing<S2SV_blank>to<S2SV_blank>do\\n" ) ; return EXIT_SUCCESS ; } hcxorgrecords = readhccapx ( hcxinname ) ; if ( hcxorgrecords == 0 ) { fprintf ( stderr , "%ld<S2SV_blank>records<S2SV_blank>loaded\\n" , hcxorgrecords ) ; return EXIT_SUCCESS ; } gettimeofday ( & tv , NULL ) ; tm_info = localtime ( & tv . tv_sec ) ; strftime ( zeitstring , 26 , "%H:%M:%S" , tm_info ) ; <S2SV_StartBug> printf ( "started<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>test<S2SV_blank>%ld<S2SV_blank>records\\n" , zeitstring , hcxorgrecords ) ; <S2SV_EndBug> if ( ( essidname != NULL ) && ( passwordname != NULL ) ) hcxessidpassword ( hcxorgrecords , essidname , essidlen , passwordname , passwordlen ) ; if ( ( essidname != NULL ) && ( pmkname != NULL ) ) hcxessidpmk ( hcxorgrecords , essidname , essidlen , pmkname ) ; if ( ( passwordname != NULL ) && ( essidname == NULL ) ) hcxpassword ( hcxorgrecords , passwordname , passwordlen ) ; if ( ( pmkname != NULL ) && ( essidname == NULL ) ) hcxpmk ( hcxorgrecords , pmkname ) ; if ( ( wordlistinname != NULL ) && ( essidname != NULL ) ) hcxessidwordlist ( hcxorgrecords , essidname , essidlen , wordlistinname ) ; if ( ( wordlistinname != NULL ) && ( essidname == NULL ) ) <S2SV_StartBug> hcxwordlist ( hcxorgrecords , wordlistinname ) ; <S2SV_EndBug> if ( hcxdata != NULL ) free ( hcxdata ) ; if ( fhpot != NULL ) { fclose ( fhpot ) ; stat ( potname , & statpot ) ; if ( statpot . st_size == 0 ) ret = remove ( potname ) ; if ( ret != 0 ) fprintf ( stderr , "could<S2SV_blank>not<S2SV_blank>remove<S2SV_blank>empty<S2SV_blank>file<S2SV_blank>%s\\n" , potname ) ; } return EXIT_SUCCESS ; } | <S2SV_ModStart> ; printf ( "started<S2SV_blank>at<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>test<S2SV_blank>%ld<S2SV_blank>records\\n" <S2SV_ModEnd> , zeitstring , <S2SV_ModStart> hcxorgrecords , wordlistinname ) ; gettimeofday ( & tv , NULL ) ; tm_info = localtime ( & tv . tv_sec ) ; strftime ( zeitstring , 26 , "%H:%M:%S" , tm_info ) ; printf ( "finished<S2SV_blank>at<S2SV_blank>%s\\n" , zeitstring |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.