##include <stdio.h>
##include <rte_eal.h>
##include <rte_mbuf.h>
##include <rte_ethdev.h>
##include <arpa/inet.h>

##define MBUF_COUNT 4096
##define BURST_SIZE 32

##define ENABLE_SEND 1

int gDpdkPortId = 0;  

static const struct rte_eth_conf port_conf_default = {
    .rxmode = { .max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};

##if ENABLE_SEND

static uint8_t src_mac[RTE_ETHER_ADDR_LEN];
static uint8_t dst_mac[RTE_ETHER_ADDR_LEN];

static uint32_t src_ip;
static uint32_t dst_ip;

static uint16_t src_port;
static uint16_t dst_port;

static int encode_udp_pkt(uint8_t *msg, uint8_t* data, uint16_t length)
{
    // ethhdr
    struct rte_ether_hdr* eth = (struct rte_ether_hdr*) msg;
    rte_memcpy(eth->s_addr.addr_bytes,src_mac,RTE_ETHER_ADDR_LEN);
    rte_memcpy(eth->d_addr.addr_bytes,dst_mac,RTE_ETHER_ADDR_LEN);
    eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);
    // iphdr
    /**
     * IPv4 Header
        struct rte_ipv4_hdr {
            uint8_t  version_ihl;		 // version and header length 
            uint8_t  type_of_service;	 // type of service 
            rte_be16_t total_length;	 // length of packet 
            rte_be16_t packet_id;		 // packet ID 
            rte_be16_t fragment_offset;	 // fragmentation offset 
            uint8_t  time_to_live;		 // time to live 
            uint8_t  next_proto_id;		 // protocol ID 
            rte_be16_t hdr_checksum;	 // header checksum 
            rte_be32_t src_addr;		 // source address 
            rte_be32_t dst_addr;		 // destination address 
        } __attribute__((__packed__));
    */
    struct rte_ipv4_hdr *iphdr = (struct rte_ipv4_hdr*)(msg + sizeof(struct rte_ether_hdr));
    // 4位版本号(ipv4==4,ipv6==6)==4   4位首部长度(20字节/4字节一组)==5 // 0x45还是0x54可以试一下
    iphdr->version_ihl = 0x45; 
    iphdr->type_of_service = 0x0; // 弃用
    iphdr->total_length = htons(length + sizeof(struct rte_udp_hdr) + sizeof(struct rte_ipv4_hdr));
    iphdr->packet_id = 0; // 还没有进行分包
    iphdr->fragment_offset = 0; // 还没有进行分片
    iphdr->time_to_live = 64; // 使用缺省值
    iphdr->next_proto_id = IPPROTO_UDP; // 单字节的
    iphdr->src_addr = src_ip; // 不需要转字节序，因为是直接从网络上copy来的
    iphdr->dst_addr = dst_ip;
    iphdr->hdr_checksum = 0; // 一定要先赋值0，不然有问题
    iphdr->hdr_checksum = rte_ipv4_cksum(iphdr);
    // udphdr
    struct rte_udp_hdr *udphdr = (struct rte_udp_hdr*)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
    udphdr->dst_port = dst_port;
    udphdr->src_port = src_port;
    udphdr->dgram_len = htons(length + sizeof(struct rte_udp_hdr));
    rte_memcpy((uint8_t*)(udphdr + 1), data, length);
    udphdr->dgram_cksum = 0;
    udphdr->dgram_cksum = rte_ipv4_udptcp_cksum(iphdr, udphdr);

    return 0;
}


static struct rte_mbuf *send_udp_pkt(struct rte_mempool *mbufpool, uint8_t* data, uint16_t length){
/*
    udp pkt
    ----------------------------------------------------------------
    |  rte_ether_hdr  |  rte_ipv4_hdr  |  rte_udp_hdr  |  payload  |
    ----------------------------------------------------------------
*/
    uint16_t total_len = sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_udp_hdr) + length;

    struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbufpool);
    if(!mbuf){
        rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc failed!");
    }
    /*
        mbuf->data_len; // 是数据总长度，包括以太网头、ip头等，不止payload
        mbuf->pkt_len; // 比data_len稍微长一点，可能有pci地址等额外数据，暂时可以写成与data_len相等
    */
    mbuf->data_len = total_len;
    mbuf->pkt_len = total_len;

    uint8_t* msg = rte_pktmbuf_mtod(mbuf, uint8_t*);
    encode_udp_pkt(msg, data, length);
    return mbuf;
}


##endif

int main(int argc, char *argv[])
{
    if(rte_eal_init(argc, argv) < 0){
        rte_exit(EXIT_FAILURE, "Failed to init EAL\n");
    }
    struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("mbufpool", MBUF_COUNT, 0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
    struct rte_eth_conf port_conf = port_conf_default;
    int num_rx_queues = 1; // 需要小于多队列网卡最多的rx队列数，1代表只用1个，表示只活动一个rx用于收数据
    int num_tx_queues = 1; // 需要小于多队列网卡最多的tx队列数，0代表都不用，表示不写数据
    rte_eth_dev_configure(gDpdkPortId, num_rx_queues, num_tx_queues, &port_conf );

    rte_eth_rx_queue_setup(gDpdkPortId, 0, 128, rte_eth_dev_socket_id(gDpdkPortId), NULL, mbuf_pool);
    rte_eth_tx_queue_setup(gDpdkPortId, 0, 512, rte_eth_dev_socket_id(gDpdkPortId), NULL);
    
    rte_eth_dev_start(gDpdkPortId);

    while(1)
    {
        struct rte_mbuf *mbufs[BURST_SIZE];
        unsigned num_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
        if(num_recvd > BURST_SIZE){
            rte_exit(EXIT_FAILURE, "Failed to rte_eth_rx_burst\n");
        }
        unsigned i = 0;
        for(i = 0; i < num_recvd ; i++){
            struct rte_ether_hdr *ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr *); // mbufs就是一个完整的数据包
            if(ehdr->ether_type == htons(RTE_ETHER_TYPE_IPV4)) 
            {
                struct rte_ipv4_hdr *iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr *, sizeof(struct rte_ether_hdr));
                if(iphdr->next_proto_id == IPPROTO_UDP) 
                {
                    struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);
                    uint16_t length = ntohs(udphdr->dgram_len);
                    *((char*)udphdr + length) = '\0';

                    printf("data : %s\n", (char*)(udphdr + 1));
##if ENABLE_SEND

                    rte_memcpy(dst_mac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
                    rte_memcpy(src_mac, ehdr->d_addr.addr_bytes, RTE_ETHER_ADDR_LEN);

                    rte_memcpy(&src_ip, &iphdr->dst_addr, sizeof(uint32_t));
                    rte_memcpy(&dst_ip, &iphdr->src_addr, sizeof(uint32_t));

                    rte_memcpy(&src_port, &udphdr->dst_port, sizeof(uint16_t));
                    rte_memcpy(&dst_port, &udphdr->src_port, sizeof(uint16_t));

                    struct rte_mbuf *tx_buf = send_udp_pkt(mbuf_pool, (uint8_t*)(udphdr + 1), length - sizeof(struct rte_udp_hdr));     
                    rte_eth_tx_burst(gDpdkPortId, 0, &tx_buf, 1);
##endif
                }
            }
        }
    }
}

##include <stdio.h>
##include <rte_eal.h>
##include <rte_mbuf.h>
##include <rte_ethdev.h>
##include <arpa/inet.h>
##include <string.h>
##include <rte_malloc.h>

##define MBUF_COUNT 4096
##define BURST_SIZE 32

##define ENABLE_SEND 1

##define ENABLE_TCP 1

int gDpdkPortId = 0;  
static uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];

static const struct rte_eth_conf port_conf_default = {
    .rxmode = { .max_rx_pkt_len = RTE_ETHER_MAX_LEN }
};


##if ENABLE_TCP

##define TCP_OPTION_LENGTH	10
##define RING_SIZE	1024
##define TCP_MAX_SEQ		4294967295
##define TCP_INITIAL_WINDOW  14600


static uint8_t src_mac[RTE_ETHER_ADDR_LEN];
static uint8_t dst_mac[RTE_ETHER_ADDR_LEN];

static uint32_t src_ip;
static uint32_t dst_ip;

static uint16_t src_port;
static uint16_t dst_port;


// tcp 状态
typedef enum _TCP_STATUS{
    TCP_STATUS_CLOSED = 0,
	TCP_STATUS_LISTEN,
	TCP_STATUS_SYN_RCVD,
	TCP_STATUS_SYN_SENT,
	TCP_STATUS_ESTABLISHED,

	TCP_STATUS_FIN_WAIT_1,
	TCP_STATUS_FIN_WAIT_2,
	TCP_STATUS_CLOSING,
	TCP_STATUS_TIME_WAIT,

	TCP_STATUS_CLOSE_WAIT,
	TCP_STATUS_LAST_ACK
} TCP_STATUS;

// tcb -- tcp控制块
struct tcp_control_block{
    int fd;

    uint32_t dip;
    uint8_t localmac[RTE_ETHER_ADDR_LEN];
    uint32_t dport;

    uint8_t protocol;

    uint32_t sport;
    uint32_t sip;
    
    uint32_t snd_nxt; // seqnum
    uint32_t rcv_nxt; // acknum
    TCP_STATUS status;

    // struct rte_ring *sndbuf;
    // struct rte_ring *rcvbuf;

    struct tcp_control_block* prev;
    struct tcp_control_block* next;

    pthread_cond_t cond;
    pthread_mutex_t mutex;
};

// tcb表
struct tcp_table{
    int count;
    struct tcp_control_block *tcb_set;
};

// tcp 包
struct tcp_fragment{
    uint16_t sport;
    uint16_t dport;
    uint32_t seqnum;
    uint32_t acknum;
    uint8_t hdrlen_off;
    uint8_t tcp_flags;
    uint16_t windows;
    uint16_t cksum;
    uint16_t tcp_urp;

    int optlen;
    uint32_t option[TCP_OPTION_LENGTH];
    unsigned char *data;
    uint32_t length;
};

// 单例，保证唯一
struct tcp_table *tInst = NULL;
static struct tcp_table* tcpInstance(void){
    if(tInst == NULL){
        tInst = rte_malloc("tcp_table", sizeof(struct tcp_table), 0);
        memset(tInst, 0, sizeof(struct tcp_table));
    }
    return tInst;
}

// 根据五元组找对应的tcb
static struct tcp_control_block* tcp_block_search(uint32_t sip, uint32_t dip, uint16_t sport, uint16_t dport)
{
    struct tcp_table* table = tcpInstance();
    struct tcp_control_block *iter;
    for(iter = table->tcb_set; iter!=NULL;iter = iter->next){
        if(iter->sip == sip && iter->dip == dip && iter->sport == sport 
        && iter->dport == dport )
            return iter;
    }
    
    for(iter = table->tcb_set; iter!=NULL;iter = iter->next){
        if(iter->dport == dport && iter->status == TCP_STATUS_LISTEN)
            return iter;
    }

    return NULL;
}

// 创建一个新的tcb
static struct tcp_control_block* tcp_control_block_create(uint32_t sip, uint32_t dip, uint16_t sport, uint16_t dport){
    struct tcp_control_block* stream = rte_malloc("tcp_control_block", sizeof(struct tcp_control_block), 0);
    if(stream == NULL) return stream;
    stream->sip = sip;
    stream->dip = dip;
    stream->sport = sport;
    stream->dport = dport;
    stream->protocol = IPPROTO_TCP;
    stream->fd = -1;

    stream->status = TCP_STATUS_LISTEN;

    // seq num
    uint32_t next_seed = time(NULL);
    stream->snd_nxt = rand_r(&next_seed) % TCP_MAX_SEQ;

    return stream;
}

static int encode_tcp_pkt(uint8_t *msg, uint32_t sip, uint32_t dip,
	uint8_t *srcmac, uint8_t *dstmac, struct tcp_fragment *fragment)
{
    const unsigned total_len = fragment->length + sizeof(struct rte_ether_hdr) +
							sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_tcp_hdr) + 
							fragment->optlen * sizeof(uint32_t);
    struct rte_ether_hdr* eth = (struct rte_ether_hdr*)msg;
    rte_memcpy(eth->s_addr.addr_bytes, srcmac, RTE_ETHER_ADDR_LEN);
	rte_memcpy(eth->d_addr.addr_bytes, dstmac, RTE_ETHER_ADDR_LEN);
    eth->ether_type = htons(RTE_ETHER_TYPE_IPV4);

    struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(msg + sizeof(struct rte_ether_hdr));
	ip->version_ihl = 0x45;
	ip->type_of_service = 0;
	ip->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
	ip->packet_id = 0;
	ip->fragment_offset = 0;
	ip->time_to_live = 64; // ttl = 64
	ip->next_proto_id = IPPROTO_TCP;
	ip->src_addr = sip;
	ip->dst_addr = dip;
	
	ip->hdr_checksum = 0;
	ip->hdr_checksum = rte_ipv4_cksum(ip);

    struct rte_tcp_hdr *tcp = (struct rte_tcp_hdr *)(msg + sizeof(struct rte_ether_hdr) + sizeof(struct rte_ipv4_hdr));
	tcp->src_port = fragment->sport;
	tcp->dst_port = fragment->dport;
	tcp->sent_seq = htonl(fragment->seqnum);
	tcp->recv_ack = htonl(fragment->acknum);

	tcp->data_off = fragment->hdrlen_off;
	tcp->rx_win = fragment->windows;
	tcp->tcp_urp = fragment->tcp_urp;
	tcp->tcp_flags = fragment->tcp_flags;

	if (fragment->data != NULL) {
		uint8_t *payload = (uint8_t*)(tcp+1) + fragment->optlen * sizeof(uint32_t);
		rte_memcpy(payload, fragment->data, fragment->length);
	}

	tcp->cksum = 0;
	tcp->cksum = rte_ipv4_udptcp_cksum(ip, tcp);

	return 0;

}

// 由fragment组成一个rte_mbuf准备brust发送
static struct rte_mbuf* conduct_tcp_pkt(struct rte_mempool *mbuf_pool, uint32_t sip, uint32_t dip,
	uint8_t *srcmac, uint8_t *dstmac, struct tcp_fragment *fragment)
{
    const unsigned total_len = fragment->length + sizeof(struct rte_ether_hdr) +
							sizeof(struct rte_ipv4_hdr) + sizeof(struct rte_tcp_hdr) + 
							fragment->optlen * sizeof(uint32_t);
    struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
	if (!mbuf) {
		rte_exit(EXIT_FAILURE, "tcp_pkt rte_pktmbuf_alloc\n");
	}
	mbuf->pkt_len = total_len;
	mbuf->data_len = total_len;
    uint8_t *pktdata = rte_pktmbuf_mtod(mbuf, uint8_t*);
    encode_tcp_pkt(pktdata, sip, dip, srcmac, dstmac, fragment);

	return mbuf;
}


static struct tcp_fragment * tcp_send_ackpkt(struct tcp_control_block* stream, struct rte_tcp_hdr *tcphdr)
{
    struct tcp_fragment *ackfrag = rte_malloc("tcp_fragment", sizeof(struct tcp_fragment), 0);
	if (ackfrag == NULL) return NULL;
	memset(ackfrag, 0, sizeof(struct tcp_fragment));
    ackfrag->dport = tcphdr->src_port;
	ackfrag->sport = tcphdr->dst_port;
    printf("tcp_send_ackpkt: %d, %d\n", stream->rcv_nxt, ntohs(tcphdr->sent_seq));
    ackfrag->acknum = stream->rcv_nxt;
    ackfrag->seqnum = stream->snd_nxt;
    ackfrag->tcp_flags = RTE_TCP_ACK_FLAG;
    ackfrag->windows = TCP_INITIAL_WINDOW;
	ackfrag->hdrlen_off = 0x50;
	ackfrag->data = NULL;
	ackfrag->length = 0;

    return ackfrag;
}

static int tcp_enqueue_recvbuffer(struct tcp_control_block* stream, struct rte_tcp_hdr* tcphdr, int tcplen)
{
    struct tcp_fragment *rfragment = rte_malloc("tcp_fragment", sizeof(struct tcp_fragment), 0);
    if(rfragment == NULL) return -1;
    memset(rfragment, 0, sizeof(struct tcp_fragment));
    rfragment->dport = ntohs(tcphdr->dst_port);
    rfragment->sport = ntohs(tcphdr->src_port);

    uint8_t hdrlen = tcphdr->data_off >> 4;
    int payloadlen = tcplen - hdrlen * 4;
    if(payloadlen > 0){
        uint8_t* payload = (uint8_t*)tcphdr + hdrlen * 4;
        rfragment->data = rte_malloc("unsigned char*", payloadlen + 1, 0);
        if(rfragment->data == NULL){
            rte_free(rfragment);return -1;
        }
        memset(rfragment->data, 0 , payloadlen + 1);
        rte_memcpy(rfragment->data, 0, payloadlen + 1);
        rfragment->length = payloadlen;
    } else if (payloadlen == 0) {
        rfragment->length = 0;
        rfragment->data = NULL;
    }
    printf("tcp recv : %s\n", rfragment->data);

    return 0;
}

// 从listen状态进入syn_recv状态，收到syn，回syn与ack
static struct tcp_fragment * tcp_handle_listen(struct tcp_control_block *stream, struct rte_tcp_hdr *tcphdr, struct rte_ipv4_hdr *iphdr)
{
    if(tcphdr->tcp_flags & RTE_TCP_SYN_FLAG){
        if(stream->status == TCP_STATUS_LISTEN){
            struct tcp_table* table = tcpInstance();
            struct tcp_control_block* syn = tcp_control_block_create(iphdr->src_addr, iphdr->dst_addr, tcphdr->src_port, tcphdr->dst_port);
            do{ // 插入表
                syn->prev = NULL;
                syn->next = table->tcb_set;
                if(table->tcb_set != NULL){
                    table->tcb_set->prev = syn;
                }
                table->tcb_set = syn;
            } while(0);
            struct tcp_fragment *fragment = rte_malloc("tcp_fragment",  sizeof(struct tcp_fragment), 0);
            if(fragment == NULL) return NULL;
            memset(fragment, 0, sizeof(struct tcp_fragment));

            fragment->sport = tcphdr->dst_port; 
            fragment->dport = tcphdr->src_port;
            // -----------------------debug----------------------------------
            struct in_addr addr;
			addr.s_addr = syn->sip;
			printf("tcp ---> src: %s:%d ", inet_ntoa(addr), ntohs(tcphdr->src_port));
			addr.s_addr = syn->dip;
			printf("  ---> dst: %s:%d \n", inet_ntoa(addr), ntohs(tcphdr->dst_port));
            // -----------------------debug----------------------------------
            
            fragment->seqnum = syn->snd_nxt;
            fragment->acknum = ntohl(tcphdr->sent_seq) + 1;
            syn->rcv_nxt = fragment->acknum;

            fragment->tcp_flags = (RTE_TCP_SYN_FLAG | RTE_TCP_ACK_FLAG);
            fragment->windows = TCP_INITIAL_WINDOW;
            fragment->hdrlen_off = 0x50;

            fragment->data = NULL;
            fragment->length = 0;

            // rte_ring_mp_enqueue(syn->sndbuf, fragment);

            syn->status = TCP_STATUS_SYN_RCVD;
            return fragment;
        }
    }
    return NULL;
}

// 从syn_recv状态进入established状态，收到ack
static int tcp_handle_syn_rcvd(struct tcp_control_block* stream, struct rte_tcp_hdr* tcphdr)
{
    if(tcphdr->tcp_flags & RTE_TCP_ACK_FLAG){
        if(stream->status == TCP_STATUS_SYN_RCVD){
            uint32_t acknum = ntohl(tcphdr->recv_ack);
            if(acknum == stream -> snd_nxt + 1){

            }
            stream->status = TCP_STATUS_ESTABLISHED;
        }
    }
    return 0;
}

// 从established状态收到消息
static struct tcp_fragment * tcp_handle_established(struct tcp_control_block* stream, struct rte_tcp_hdr* tcphdr, int tcplen)
{
    struct tcp_fragment * fragment = NULL;
    if(tcphdr->tcp_flags & RTE_TCP_SYN_FLAG){}
    if(tcphdr->tcp_flags & RTE_TCP_PSH_FLAG){
        tcp_enqueue_recvbuffer(stream, tcphdr, tcplen);
        uint8_t hdrlen = tcphdr->data_off >> 4;
        int payloadlen = tcplen - hdrlen * 4;
        stream->rcv_nxt = stream->rcv_nxt + payloadlen;
        stream->snd_nxt = ntohl(tcphdr->recv_ack);
        fragment = tcp_send_ackpkt(stream, tcphdr);
    }
    if(tcphdr->tcp_flags & RTE_TCP_ACK_FLAG){}
    if(tcphdr->tcp_flags & RTE_TCP_FIN_FLAG){
        stream->status = TCP_STATUS_CLOSE_WAIT;
        tcp_enqueue_recvbuffer(stream, tcphdr, tcphdr->data_off >> 4);
        stream->rcv_nxt =  stream->rcv_nxt + 1;
        stream->snd_nxt = ntohl(tcphdr->recv_ack);
        fragment = tcp_send_ackpkt(stream, tcphdr);
    }
    return fragment;
}

// last_wait状态收到ack进入closed状态
static int tcp_handle_last_ack(struct tcp_control_block* stream, struct rte_tcp_hdr* tcphdr)
{
    if(tcphdr->tcp_flags & RTE_TCP_ACK_FLAG)
    {
        if(stream->status == TCP_STATUS_LAST_ACK){
            stream->status = TCP_STATUS_CLOSED;
            printf("tcp_handle_last_ack\n");
            struct tcp_table* table = tcpInstance();
            do{
                if(stream->prev != NULL)
                    stream->prev->next = stream->next;
                if(stream->next != NULL)
                    stream->next->prev = stream->prev;
                if(table->tcb_set == stream)
                    table->tcb_set = stream->next;
                stream->prev = stream->next = NULL;
            }while(0);
            
            rte_free(stream);
        }
    }
    return 0;
}

struct tcp_fragment *tcp_pkt_process(struct rte_mbuf* tcpmbuf)
{
    struct rte_ipv4_hdr *iphdr = rte_pktmbuf_mtod_offset(tcpmbuf, struct rte_ipv4_hdr*, sizeof(struct rte_ether_hdr));
    struct rte_tcp_hdr *tcphdr = (struct rte_tcp_hdr *)(iphdr + 1);
    // checksum 校验
    uint16_t tcpcksum = tcphdr->cksum;
    tcphdr->cksum = 0;
    uint16_t cksum = rte_ipv4_udptcp_cksum(iphdr, tcphdr);
    if(cksum != tcpcksum) return NULL; // 丢弃

    // 搜索五元，有的话返回该tcp
    struct tcp_control_block* stream = tcp_block_search(iphdr->src_addr, iphdr->dst_addr, 
		tcphdr->src_port, tcphdr->dst_port);
    if(stream == NULL){
        rte_pktmbuf_free(tcpmbuf);
        return NULL;
    }

    struct tcp_fragment * fragment = NULL;

    rte_memcpy(&src_ip, &iphdr->dst_addr, sizeof(uint32_t));
    rte_memcpy(&dst_ip, &iphdr->src_addr, sizeof(uint32_t));

    rte_memcpy(&src_port, &tcphdr->dst_port, sizeof(uint16_t));
    rte_memcpy(&dst_port, &tcphdr->src_port, sizeof(uint16_t));

    // 判断tcb状态，处理不同状态（状态机模式）
    switch (stream->status)
    {
    case  TCP_STATUS_CLOSED :
        break;
	case TCP_STATUS_LISTEN : 
        fragment = tcp_handle_listen(stream, tcphdr, iphdr);
        break;
	case TCP_STATUS_SYN_RCVD: 
        tcp_handle_syn_rcvd(stream, tcphdr);
        break;
	case TCP_STATUS_SYN_SENT: 
        break;
	case TCP_STATUS_ESTABLISHED: {
        int tcplen = ntohs(iphdr->total_length) - sizeof(struct rte_ipv4_hdr);
        fragment = tcp_handle_established(stream, tcphdr, tcplen);
    }
        break;
	case TCP_STATUS_FIN_WAIT_1: 
        break;
	case TCP_STATUS_FIN_WAIT_2: 
        break;
	case TCP_STATUS_CLOSING: 
        break;
	case TCP_STATUS_TIME_WAIT: 
        break;

	case TCP_STATUS_CLOSE_WAIT: 
        break;
	case TCP_STATUS_LAST_ACK: 
        tcp_handle_last_ack(stream, tcphdr);
        break;    
    default:
        break;
    }

    rte_pktmbuf_free(tcpmbuf);
    return fragment;
}


##endif


int main(int argc, char *argv[])
{
    if(rte_eal_init(argc, argv) < 0){
        rte_exit(EXIT_FAILURE, "Failed to init EAL\n");
    }
    struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create("mbufpool", MBUF_COUNT, 0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
    struct rte_eth_conf port_conf = port_conf_default;
    int num_rx_queues = 1; // 需要小于多队列网卡最多的rx队列数，1代表只用1个，表示只活动一个rx用于收数据
    int num_tx_queues = 1; // 需要小于多队列网卡最多的tx队列数，0代表都不用，表示不写数据
    rte_eth_dev_configure(gDpdkPortId, num_rx_queues, num_tx_queues, &port_conf );

    rte_eth_rx_queue_setup(gDpdkPortId, 0, 128, rte_eth_dev_socket_id(gDpdkPortId), NULL, mbuf_pool);
    rte_eth_tx_queue_setup(gDpdkPortId, 0, 512, rte_eth_dev_socket_id(gDpdkPortId), NULL);
    
    rte_eth_dev_start(gDpdkPortId);

    rte_eth_macaddr_get(gDpdkPortId, (struct rte_ether_addr *)gSrcMac);

##if ENABLE_TCP
    // socket
    struct tcp_control_block *stream = rte_malloc("tcp_control_block", sizeof(struct tcp_control_block), 0);
    if (stream == NULL) {
        return -1;
    }
    memset(stream, 0, sizeof(struct tcp_control_block));
    stream->fd = rand();
    stream->protocol = IPPROTO_TCP;
    stream->next = stream->prev = NULL;
    struct tcp_table *table = tcpInstance();
    do{ // 插入表
        stream->prev = NULL;
        stream->next = table->tcb_set;
        if(table->tcb_set != NULL){
            table->tcb_set->prev = stream;
        }
        table->tcb_set = stream;
    } while(0);
    // bind
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);
    const struct sockaddr_in *laddr = &servaddr;
    stream->dport = laddr->sin_port;
    rte_memcpy(&stream->dip, &laddr->sin_addr.s_addr, sizeof(uint32_t));
    rte_memcpy(stream->localmac, gSrcMac, RTE_ETHER_ADDR_LEN);
    stream->status = TCP_STATUS_CLOSED;
    // listen
    stream->status = TCP_STATUS_LISTEN;
    // 未实现accept，未做fd的管理，所以暂时不能正常收数据
##endif
    while(1)
    {
        struct rte_mbuf *mbufs[BURST_SIZE];
        unsigned num_recvd = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_SIZE);
        if(num_recvd > BURST_SIZE){
            rte_exit(EXIT_FAILURE, "Failed to rte_eth_rx_burst\n");
        }
        unsigned i = 0;
        for(i = 0; i < num_recvd ; i++){
            struct rte_ether_hdr *ehdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr *); // mbufs就是一个完整的数据包
            if(ehdr->ether_type == htons(RTE_ETHER_TYPE_IPV4)) 
            {
                struct rte_ipv4_hdr *iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr *, sizeof(struct rte_ether_hdr));
                
                if(iphdr->next_proto_id == IPPROTO_UDP) 
                {
                    struct rte_udp_hdr *udphdr = (struct rte_udp_hdr *)(iphdr + 1);
                    uint16_t length = ntohs(udphdr->dgram_len);
                    *((char*)udphdr + length) = '\0';

                    printf("data : %s\n", (char*)(udphdr + 1));
                }
##if ENABLE_TCP
                else if(iphdr->next_proto_id == IPPROTO_TCP)
                {
                    rte_memcpy(dst_mac, ehdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
                    rte_memcpy(src_mac, ehdr->d_addr.addr_bytes, RTE_ETHER_ADDR_LEN);

                    struct tcp_fragment *fragment = tcp_pkt_process(mbufs[i]);
                    if(fragment != NULL){
                        struct rte_mbuf *tx_buf = conduct_tcp_pkt(mbuf_pool, src_ip, dst_ip, src_mac, dst_mac, fragment);
                        rte_eth_tx_burst(gDpdkPortId, 0, &tx_buf, 1);
                    }
                }
##endif
            }
        }
    }
}