cnet_tcp.h

Go to the documentation of this file.

/*
 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
 *  The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by the University of
 *  California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2016-2022 Intel Corporation
 */
 
#ifndef __CNET_TCP_H
#define __CNET_TCP_H
 
#include "cnet_const.h"        // for bool_t
#include "cnet_pcb.h"          // for pcb_hd
 
#include <net/cne_tcp.h>
#include <stdint.h>        // for uint32_t, uint16_t, int32_t, int16_t, uint8_t
#include <stdio.h>         // for NULL
#include <stdbool.h>
#include <sys/queue.h>        // for TAILQ_ENTRY, TAILQ_INSERT_TAIL, TAILQ_REMOVE
 
#include "cne_log.h"           // for CNE_LOG, CNE_LOG_DEBUG
#include "cnet_const.h"        // for bool_t
#include "cnet_pcb.h"          // for pcb_entry (ptr only), pcb_hd
#include "cnet_stk.h"          // for per_thread_stk, stk_entry, this_stk
#include "cnet_tcp.h"          // for tcb_entry (ptr only)
#include "mempool.h"           // for mempool_get, mempool_put
#include "pktmbuf.h"           // for pktmbuf_t
#ifdef __cplusplus
extern "C" {
#endif
 
#define CNET_TCP_REASSEMBLE_COUNT 256
#define CNET_TCP_BACKLOG_COUNT    128
#define CNET_TCP_HALF_OPEN_COUNT  128
 
/* Basic TCP packet header
 *
 *                        TCP Header Format
 *
 *    0                   1                   2                   3
 *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |          Source Port          |       Destination Port        |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |                        Sequence Number                        |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |                    Acknowledgment Number                      |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |  Data |           |U|A|P|R|S|F|                               |
 *   | Offset| Reserved  |R|C|S|S|Y|I|            Window             |
 *   |       |           |G|K|H|T|N|N|                               |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |           Checksum            |         Urgent Pointer        |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |                    Options                    |    Padding    |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |                             data                              |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 
struct cne_tcp_hdr;
struct cne_vec;
 
typedef uint32_t seq_t; /* TCP Sequence type */
 
/* Timestamp modulo math test macros */
static inline int
tstampLT(uint32_t a, uint32_t b)
{
    return (int32_t)(a - b) < 0;
}
 
static inline int
tstampLEQ(uint32_t a, uint32_t b)
{
    return (int32_t)(a - b) <= 0;
}
 
static inline int
tstampGEQ(uint32_t a, uint32_t b)
{
    return (int32_t)(a - b) >= 0;
}
 
/* Number of milli-seconds for 24 days */
#define TCP_PAWS_IDLE (24 * 24 * 60 * 60 * 1000)
 
typedef enum {
    TCPS_FREE = 0,
    TCPS_CLOSED,      
    TCPS_LISTEN,      
    TCPS_SYN_SENT,    
    TCPS_SYN_RCVD,    
    TCPS_ESTABLISHED, 
    TCPS_CLOSE_WAIT,  
    TCPS_FIN_WAIT_1,  
    TCPS_CLOSING,     
    TCPS_LAST_ACK,    
    TCPS_FIN_WAIT_2,  
    TCPS_TIME_WAIT    
} tcb_state_t;
 
#define TCP_INPUT_STATES                                                                        \
    {                                                                                           \
        "Free", "Closed", "Listen", "SYN Sent", "SYN Rcvd", "Established", "CloseWait", "Fin1", \
            "Closing", "LastAck", "Fin2", "TimeWait", "DeleteTCB"                               \
    }
 
#define TCPS_HAVE_RCVD_SYN(s) ((s) >= TCPS_SYN_RCVD)
#define TCPS_HAVE_ESTABLISHED (s)((s) >= TCPS_ESTABLISHED)
#define TCPS_HAVE_RCVD_FIN(s) ((s) >= TCPS_TIME_WAIT)
 
/* tcp_hdr.flags TCP Header flags and seg_entry.flags */
enum {
    TCP_FIN    = 0x01,
    TCP_SYN    = 0x02,
    TCP_RST    = 0x04,
    TCP_PSH    = 0x08,
    TCP_ACK    = 0x10,
    TCP_URG    = 0x20,
    TCP_MASK   = 0x3F,
    SYN_FIN    = (TCP_SYN | TCP_FIN),
    RST_ACK    = (TCP_RST | TCP_ACK),
    FIN_ACK    = (TCP_FIN | TCP_ACK),
    SYN_ACK    = (TCP_SYN | TCP_ACK),
    SYN_RST    = (TCP_SYN | TCP_RST),
    HDR_PREDIC = (TCP_SYN | TCP_FIN | TCP_RST | TCP_URG | TCP_ACK)
};
 
/* Keep in bit order with above enums */
#define TCP_FLAGS                                \
    {                                            \
        "FIN", "SYN", "RST", "PSH", "ACK", "URG" \
    }
 
// clang-format off
/* State of the flags for all possible states in TCP */
#define TCP_OUTPUT_FLAGS                \
    {                                   \
        0,       /* TCPS_FREE        */ \
        RST_ACK, /* TCPS_CLOSED      */ \
        0,       /* TCPS_LISTEN      */ \
        TCP_SYN, /* TCPS_SYN_SENT    */ \
        SYN_ACK, /* TCPS_SYN_RCVD    */ \
        TCP_ACK, /* TCPS_ESTABLISHED */ \
        TCP_ACK, /* TCPS_CLOSE_WAIT  */ \
        FIN_ACK, /* TCPS_FIN_WAIT_1  */ \
        TCP_ACK, /* TCPS_CLOSING     */ \
        FIN_ACK, /* TCPS_LAST_ACK    */ \
        TCP_ACK, /* TCPS_FIN_WAIT_2  */ \
        TCP_ACK  /* TCPS_TIME_WAIT   */ \
    }
// clang-format on
 
/* TCP Output Events to drive the output Finite State Machine. */
enum { SEND_EVENT, PERSIST_EVENT, RETRANSMIT_EVENT, DELETE_EVENT };
 
#define TCP_OUTPUT_EVENTS                     \
    {                                         \
        "Send", "Persist", "Rexmit", "Delete" \
    }
 
/* TCP Option values */
enum {
    TCP_OPT_EOL = 0,   
    TCP_OPT_NOP,       
    TCP_OPT_MSS,       
    TCP_OPT_WSOPT,     
    TCP_OPT_SACK_OK,   
    TCP_OPT_SACK,      
    TCP_OPT_TSTAMP = 8 
};
 
/* A few option lengths */
#define TCP_OPT_SACK_LEN   2
#define TCP_OPT_MSS_LEN    4
#define TCP_OPT_WSOPT_LEN  3
#define TCP_OPT_TSTAMP_LEN 10
#define TCP_MAX_OPTIONS    32
 
/* Few default values */
#ifdef TCP_MSS
#undef TCP_MSS
#endif
#define TCP_MIN_MSS          64           
#define TCP_MSS              536          
#define TCP_NORMAL_MSS       1460         
#define TCP_MAX_MSS          (16384 - 64) 
#define TCP_MSS_OVERHEAD     52           
#define TCP_DEFAULT_HDR_SIZE 20           
#undef TCP_MAXWIN
#ifndef ETHER_MAX_MTU
#define ETHER_MAX_MTU 65535
#endif
#define TCP_MAXWIN       ETHER_MAX_MTU 
#define TCP_MAX_WINSHIFT 14            
#define TCP_INITIAL_CWND 4380          
#define TCP_VEC_SIZE     1024          
/* The following values are define in 500ms ticks slow timeout */
#define TCP_MSL_TV       60    
#define TCP_MIN_TV       2     
#define TCP_REXMTMAX_TV  128   
#define TCP_PERSMIN_TV   10    
#define TCP_PERSMAX_TV   120   
#define TCP_KEEP_INIT_TV 150   
#define TCP_KEEP_IDLE_TV 14400 
#define TCP_KEEPINTVL_TV 150   
#define TCP_KEEPCNT_TV   8
#define TCP_SRTTBASE_TV  0 
#define TCP_SRTTDFLT_TV  2 
#define TCP_KEEPCNT_TV   8 
#define TCP_RTT_SCALE    8 
#define TCP_RTT_SHIFT    3 
#define TCP_RTTVAR_SCALE 4 
#define TCP_RTTVAR_SHIFT 2 
#define TCP_ISSINCR 0x01000000 
#define TCP_SLOWHZ  2          
/* Number of ms per timeout */
#define TCP_REXMT_TIMEOUT_MS 100UL
#define TCP_FAST_TIMEOUT_MS  200UL
#define TCP_SLOW_TIMEOUT_MS  500UL
 
/*
 * The initial retransmission should happen at rtt + 4 * rttvar.
 * Because of the way we do the smoothing, srtt and rttvar
 * will each average +1/2 tick of bias.  When we compute
 * the retransmit timer, we want 1/2 tick of rounding and
 * 1 extra tick because of +-1/2 tick uncertainty in the
 * firing of the timer.  The bias will give us exactly the
 * 1.5 tick we need.  But, because the bias is
 * statistical, we have to test that we don't drop below
 * the minimum feasible timer (which is 2 ticks).
 *
 * This macro assumes that the value of TCP_RTTVAR_SCALE
 * is the same as the multiplier for rttvar.
 */
#define tcpRexmtVal(_t) ((((_t)->srtt >> TCP_RTT_SHIFT) + (_t)->rttvar) / 500)
 
#define seqLT(a, b)  ((int)((a) - (b)) < 0)
#define seqLEQ(a, b) ((int)((a) - (b)) <= 0)
#define seqGT(a, b)  ((int)((a) - (b)) > 0)
#define seqGEQ(a, b) ((int)((a) - (b)) >= 0)
#define seqEQ(a, b)  ((int)((a) - (b)) == 0)
#define seqNE(a, b)  ((int)((a) - (b)) != 0)
 
#define TCP_MAXRXTSHIFT          12 
#define TCP_RETRANSMIT_THRESHOLD 3
 
#define MAX_TCP_RCV_SIZE (128 * 1024)
#define MAX_TCP_SND_SIZE MAX_TCP_RCV_SIZE
 
/* Macro to deal with cne_mbuf pointer in TCP header */
#define reassPkt(_t) (*(pktmbuf_t **)&((_t)->tcp.src_port))
 
/* Index into the tcb.timers array */
enum {
    TCPT_REXMT = 0, 
    TCPT_PERSIST,   
    TCPT_KEEP,      
    TCPT_2MSL,      
    TCP_NTIMERS     
};
 
/* Current Segment information in host order. */
struct seg_entry {
    TAILQ_ENTRY(seg_entry) entry;
    pktmbuf_t *mbuf;               
    struct pcb_entry *pcb;         
    uint8_t flags;                 
    uint8_t offset;                
    uint16_t mss;                  
    uint16_t urp;                  
    uint16_t len;                  
    uint16_t iplen;                
    uint16_t sflags;               
    uint16_t lport;                
    uint32_t wnd;                  
    seq_t seq;                     
    seq_t ack;                     
    uint32_t ts_val;               
    uint32_t ts_ecr;               
    void *ip;                      
    uint8_t req_scale;             
    uint8_t optlen;                
    uint8_t opts[TCP_MAX_OPTIONS]; 
};
 
/* seg_entry.sflags bit definitions */
enum {
    SEG_TS_PRESENT  = 0x8000, 
    SEG_MSS_PRESENT = 0x4000, 
    SEG_WS_PRESENT  = 0x2000, 
    SEG_SACK_PERMIT = 0x1000  
};
 
enum {
    TCP_FAST_TIMER = 1, 
    TCP_SLOW_TIMER = 2, 
};
 
struct stk_s;
struct tcp_entry;
struct netif;
 
struct tcp_q {
    TAILQ_HEAD(, pcb_entry) head; 
    atomic_uint_least32_t cnt;    
};
 
/* TCP Transmission Control Block */
struct tcb_entry {
    TAILQ_ENTRY(tcb_entry) entry; 
    pktmbuf_t **reassemble;
    struct tcp_q backlog_q;   
    struct tcp_q half_open_q; 
    struct netif *netif;    
    struct tcp_entry *tcp;  
    struct pcb_entry *pcb;  
    struct pcb_entry *ppcb; 
    uint32_t tflags;   
    uint32_t persist;  
    tcb_state_t state; 
    uint16_t max_mss;  
    int16_t timers[TCP_NTIMERS] __cne_aligned(8); 
    int32_t qLimit;                               
    /* RFC1323 variables */
    uint8_t snd_scale;      
    uint8_t rcv_scale;      
    uint8_t req_recv_scale; 
    uint8_t req_send_scale; 
    uint32_t ts_recent;     
    uint32_t ts_recent_age; 
    seq_t last_ack_sent;    
    /* Send segment information */
    seq_t snd_una;         
    seq_t snd_nxt;         
    seq_t snd_up;          
    seq_t snd_wl1;         
    seq_t snd_wl2;         
    seq_t snd_iss;         
    seq_t snd_max;         
    uint32_t snd_wnd;      
    uint32_t snd_ssthresh; 
    uint32_t snd_cwnd;     
    uint32_t max_sndwnd;   
    /* Receive Segment information */
    seq_t rcv_wnd;      
    seq_t rcv_nxt;      
    seq_t rcv_irs;      
    seq_t rcv_adv;      
    int32_t rcv_bsize;  
    seq_t rcv_ssthresh; 
    uint16_t snd_urp;   
    uint16_t rcv_urp;   
    /* Retransmission timeout values */
    seq_t rttseq;        
    seq_t total_retrans; 
    int16_t rtt;         
    int16_t srtt;        
    int16_t rttvar;      
    int16_t dupacks;     
    int16_t rxtcur;      
    uint16_t rttmin;     
    int16_t rxtshift;    
    uint16_t idle;       
};
 
/* tcb_entry.tflags values */
// clang-format off
enum {
    TCBF_PASSIVE_OPEN    = 0x10000000, 
    TCBF_FORCE_TX        = 0x20000000, 
    TCBF_DELAYED_ACK     = 0x40000000, 
    TCBF_FREE_BIT_1      = 0x80000000,
 
    TCBF_RFC1122_URG     = 0x01000000, 
    TCBF_BOUND           = 0x02000000, 
    TCBF_FREE_BIT_2      = 0x04000000,
    TCBF_FREE_BIT_3      = 0x08000000,
 
    TCBF_REQ_TSTAMP      = 0x00100000, 
    TCBF_RCVD_SCALE      = 0x00200000, 
    TCBF_REQ_SCALE       = 0x00400000, 
    TCBF_SEND_URG        = 0x00800000, 
    TCBF_ACK_NOW         = 0x00010000, 
    TCBF_SENT_FIN        = 0x00020000, 
    TCBF_SACK_PERMIT     = 0x00040000, 
    TCBF_RCVD_TSTAMP     = 0x00080000, 
    TCBF_NODELAY         = 0x00001000, 
    TCBF_NAGLE_CREDIT    = 0x00002000, 
    TCBF_OUR_FIN_ACKED   = 0x00004000, 
    TCBF_FREE_BIT_4      = 0x00008000,
 
    TCBF_FREE_BIT_5      = 0x00000100,
    TCBF_NEED_FAST_REXMT = 0x00000200, 
    TCBF_NOPUSH          = 0x00000400, 
    TCBF_NOOPT           = 0x00000800, 
};
 
#define TCB_FLAGS           \
    {                       \
        "Free_1",           \
        "DELAYED_ACK",      \
        "FORCE_TX",         \
        "PASSIVE_OPEN",     \
                            \
        "Free_3",           \
        "Free_2",           \
        "BOUND",            \
        "RFC1122_URG",      \
                            \
        "SEND_URG",         \
        "REQ_SCALE",        \
        "RCVD_SCALE",       \
        "REQ_TSTAMP",       \
                            \
        "RCVD_TSTAMP",      \
        "SACK_PERMIT",      \
        "SENT_FIN",         \
        "ACK_NOW",          \
                            \
        "Free_4",           \
        "OUR_FIN_ACKED",    \
        "NAGLE_CREDIT",     \
        "NO_DELAY",         \
                            \
        "NOOPT",            \
        "NOPUSH",           \
        "NeedFastRexmt",    \
        "Free_5",           \
        NULL                \
    }
// clang-format on
 
extern const char *tcb_in_states[];
 
struct chnl;
 
struct tcp_entry {
    TAILQ_ENTRY(tcb_entry) entry;
    uint32_t rcv_size;  
    uint32_t snd_size;  
    uint32_t snd_ISS;   
    int32_t keep_intvl; 
    int32_t keep_idle;  
    int32_t keep_cnt;   
    int32_t max_idle;   
    uint16_t pad0;
    uint16_t default_MSS; 
    int32_t default_RTT;  
    struct pcb_hd tcp_hd; 
};
 
typedef struct tcp_stats {
    uint64_t S_TCPS_CLOSED; 
    uint64_t S_TCPS_LISTEN;
    uint64_t S_TCPS_SYN_SENT;
    uint64_t S_TCPS_SYN_RCVD;
    uint64_t S_TCPS_ESTABLISHED;
    uint64_t S_TCPS_CLOSE_WAIT;
    uint64_t S_TCPS_FIN_WAIT_1;
    uint64_t S_TCPS_CLOSING;
    uint64_t S_TCPS_LAST_ACK;
    uint64_t S_TCPS_FIN_WAIT_2;
    uint64_t S_TCPS_TIME_WAIT;
 
    uint64_t S_no_syn_rcvd;    
    uint64_t S_invalid_ack;    
    uint64_t S_passive_open;   
    uint64_t S_tcp_rst;        
    uint64_t S_ack_predicted;  
    uint64_t S_data_predicted; 
    uint64_t S_rx_total;       
    uint64_t S_rx_short;       
    uint64_t S_rx_badoff;      
    uint64_t S_delayed_ack;    
    uint64_t S_tcp_rexmit;     
    uint64_t S_resets_sent;    
    uint64_t S_tcp_connect;    
} tcp_stats_t;
 
#define INC_TCP_STAT(x)               \
    do {                              \
        this_stk->tcp_stats->S_##x++; \
    } while (/*CONSTCOND*/ 0)
 
static inline void
tcp_send_seq_set(struct tcb_entry *tcb, int x)
{
    struct tcp_entry *tcp = tcb->tcp;
 
    tcb->snd_iss = tcp->snd_ISS;
    tcp->snd_ISS += (TCP_ISSINCR / x);
    tcb->snd_una = tcb->snd_nxt = tcb->snd_max = tcb->snd_iss;
}
 
static inline uint16_t
tcp_range_set(int val, int tvmin, int tvmax)
{
    return (uint16_t)((val < tvmin) ? tvmin : (val > tvmax) ? tvmax : val);
}
 
static inline void
tcb_kill_timers(struct tcb_entry *tcb)
{
    uint64_t *p = (uint64_t *)(uintptr_t)tcb->timers;
 
    p[0] = 0;
}
 
static inline struct tcb_entry *
tcb_alloc(void)
{
    struct tcb_entry *tcb = NULL;
    stk_t *stk            = this_stk;
 
    if (mempool_get(stk->tcb_objs, (void *)&tcb) < 0)
        return NULL;
 
    if (stk_lock()) {
        int idx = mempool_obj_index(stk->tcb_objs, tcb);
 
        if (idx < 0) {
            mempool_put(stk->tcb_objs, (void *)tcb);
            stk_unlock();
            CNE_NULL_RET("TCB pointer is invalid\n");
        }
        bit_set(stk->tcbs, idx);
        stk_unlock();
    }
 
    return tcb;
}
 
static inline void
tcb_free(struct tcb_entry *tcb)
{
    stk_t *stk = this_stk;
 
    if (tcb) {
        if (stk_lock()) {
            int idx = mempool_obj_index(stk->tcb_objs, tcb);
 
            if (idx < 0) {
                CNE_ERR("invalid TCB pointer\n");
                return;
            }
            bit_clear(stk->tcbs, idx);
            memset(tcb, 0, sizeof(struct tcb_entry));
            stk_unlock();
        }
 
        mempool_put(stk->tcb_objs, tcb);
    }
}
 
static inline void
tcp_flags_dump(const char *msg, uint8_t flags)
{
    const char *flag_names[] = TCP_FLAGS;
 
    if (msg)
        cne_printf("[magenta]%s[]: ", msg);
    for (int i = 0; i < cne_countof(flag_names); i++) {
        if (flags & (1 << i))
            cne_printf("[orange]%s[] ", flag_names[i]);
    }
    cne_printf("\n");
}
 
#if CNET_TCP_DUMP_ENABLED
#define TCP_DUMP(tcp)                                                                 \
    do {                                                                              \
        cne_printf("[cyan]([orange]%s[cyan]:[orange]%d[cyan]) ", __func__, __LINE__); \
        cnet_tcp_dump(NULL, tcp);                                                     \
    } while (0)
#else
#define TCP_DUMP(tcp) \
    do {              \
    } while (0)
#endif
 
CNDP_API int cnet_tcp_input(struct pcb_entry *pcb, pktmbuf_t *mbuf);
 
CNDP_API void cnet_tcp_output(struct tcb_entry *tcb);
 
CNDP_API int cnet_tcp_connect(struct pcb_entry *pcb);
 
CNDP_API struct tcb_entry *cnet_tcb_new(struct pcb_entry *pcb);
 
CNDP_API void cnet_tcp_abort(struct pcb_entry *pcb);
 
CNDP_API int cnet_tcp_close(struct pcb_entry *pcb);
 
void *tcp_q_pop(struct tcp_q *tq);
 
CNDP_API void cnet_tcp_dump(const char *msg, struct cne_tcp_hdr *tcp);
 
CNDP_API void cnet_tcb_list(stk_t *stk, struct tcb_entry *tcb);
 
CNDP_API void cnet_tcb_dump(void);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CNET_TCP_H */