This is a very simple TCP implementation that only support connecting
to servers (passive open and listen are not supported).
This also doesn't handle multiples segments and the TCP window size is
smaller than the MTU, this will hopefully make the sender only send one
segment at a time.
Signed-off-by: Jules Maselbas <jmaselbas@xxxxxxxxx>
---
common/misc.c | 12 +-
include/net.h | 118 +++++++++++++++
net/net.c | 406 ++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 531 insertions(+), 5 deletions(-)
diff --git a/common/misc.c b/common/misc.c
index 0f6de3e9e5..30e94f5a8b 100644
--- a/common/misc.c
+++ b/common/misc.c
@@ -57,6 +57,13 @@ const char *strerror(int errnum)
case EPROBE_DEFER : str = "Requested probe deferral"; break;
case ELOOP : str = "Too many symbolic links encountered"; break;
case ENODATA : str = "No data available"; break;
+#ifdef CONFIG_NET
+ case ENETRESET : str = "Network dropped connection because of reset"; break;
+ case ECONNABORTED : str = "Software caused connection abort"; break;
+ case ECONNRESET : str = "Connection reset by peer"; break;
+ case ENOBUFS : str = "No buffer space available"; break;
+ case ECONNREFUSED : str = "Connection refused"; break;
+#endif
#if 0 /* These are probably not needed */
case ENOTBLK : str = "Block device required"; break;
case EFBIG : str = "File too large"; break;
@@ -79,11 +86,6 @@ const char *strerror(int errnum)
case EAFNOSUPPORT : str = "Address family not supported by protocol"; break;
case EADDRINUSE : str = "Address already in use"; break;
case EADDRNOTAVAIL : str = "Cannot assign requested address"; break;
- case ENETRESET : str = "Network dropped connection because of reset"; break;
- case ECONNABORTED : str = "Software caused connection abort"; break;
- case ECONNRESET : str = "Connection reset by peer"; break;
- case ENOBUFS : str = "No buffer space available"; break;
- case ECONNREFUSED : str = "Connection refused"; break;
case EHOSTDOWN : str = "Host is down"; break;
case EALREADY : str = "Operation already in progress"; break;
case EINPROGRESS : str = "Operation now in progress"; break;
diff --git a/include/net.h b/include/net.h
index b50b6e76c8..76b64ccb21 100644
--- a/include/net.h
+++ b/include/net.h
@@ -143,6 +143,7 @@ struct ethernet {
#define PROT_VLAN 0x8100 /* IEEE 802.1q protocol */
#define IPPROTO_ICMP 1 /* Internet Control Message Protocol */
+#define IPPROTO_TCP 6 /* Transmission Control Protocol */
#define IPPROTO_UDP 17 /* User Datagram Protocol */
#define IP_BROADCAST 0xffffffff /* Broadcast IP aka 255.255.255.255 */
@@ -171,6 +172,67 @@ struct udphdr {
uint16_t uh_sum; /* udp checksum */
} __attribute__ ((packed));
+/* pseudo header for checksum */
+struct psdhdr {
+ uint32_t saddr;
+ uint32_t daddr;
+ uint16_t proto;
+ uint16_t ttlen;
+} __attribute__ ((packed));
+
+struct tcphdr {
+ uint16_t src; /* source port */
+ uint16_t dst; /* destination port */
+ uint32_t seq; /* sequence number */
+ uint32_t ack; /* acknowledge number */
+ uint16_t doff_flag; /* data offset and flags */
+#define TCP_DOFF_MASK 0xf
+#define TCP_DOFF_SHIFT 12
+#define TCP_FLAG_FIN BIT(0)
+#define TCP_FLAG_SYN BIT(1)
+#define TCP_FLAG_RST BIT(2)
+#define TCP_FLAG_PSH BIT(3)
+#define TCP_FLAG_ACK BIT(4)
+#define TCP_FLAG_URG BIT(5)
+#define TCP_FLAG_ECE BIT(6)
+#define TCP_FLAG_CWR BIT(7)
+#define TCP_FLAG_NS BIT(8)
+#define TCP_FLAG_MASK 0x1ff
+ uint16_t wnd; /* window size */
+ uint16_t sum; /* header and data checksum */
+ uint16_t urp; /* urgent pointer (if URG is set) */
+ /* The options start here. */
+} __attribute__ ((packed));
+
+enum tcp_state {
+ TCP_CLOSED = 0,
+ TCP_LISTEN,
+ TCP_SYN_SENT,
+ TCP_SYN_RECV,
+ TCP_ESTABLISHED,
+ TCP_FIN_WAIT1,
+ TCP_FIN_WAIT2,
+ TCP_TIME_WAIT,
+ TCP_CLOSE_WAIT,
+ TCP_LAST_ACK,
+ TCP_CLOSING,
+};
+
+/* Transmission Control Block */
+struct tcb {
+ uint32_t snd_una;
+ uint32_t snd_nxt;
+ uint32_t snd_wnd;
+ uint16_t snd_urp;
+ uint32_t snd_wl1;
+ uint32_t snd_wl2;
+ uint32_t rcv_nxt;
+ uint32_t rcv_wnd;
+ uint16_t rcv_urp;
+ uint32_t iss;
+ uint32_t irs;
+};
+
/*
* Address Resolution Protocol (ARP) header.
*/
@@ -264,6 +326,13 @@ struct eth_device *net_route(IPaddr_t ip);
/* Do the work */
void net_poll(void);
+static inline size_t net_tcp_data_offset(struct tcphdr *tcp)
+{
+ uint16_t doff;
+ doff = ntohs(tcp->doff_flag) >> TCP_DOFF_SHIFT;
+ return doff * sizeof(uint32_t);
+}
+
static inline struct iphdr *net_eth_to_iphdr(char *pkt)
{
return (struct iphdr *)(pkt + ETHER_HDR_SIZE);
@@ -274,6 +343,11 @@ static inline struct udphdr *net_eth_to_udphdr(char *pkt)
return (struct udphdr *)(net_eth_to_iphdr(pkt) + 1);
}
+static inline struct tcphdr *net_eth_to_tcphdr(char *pkt)
+{
+ return (struct tcphdr *)(net_eth_to_iphdr(pkt) + 1);
+}
+
static inline struct icmphdr *net_eth_to_icmphdr(char *pkt)
{
return (struct icmphdr *)(net_eth_to_iphdr(pkt) + 1);
@@ -295,8 +369,28 @@ static inline int net_eth_to_udplen(char *pkt)
return ntohs(udp->uh_ulen) - 8;
}
+static inline char *net_eth_to_tcp_payload(char *pkt)
+{
+ struct tcphdr *tcp = net_eth_to_tcphdr(pkt);
+ return ((char *)tcp) + net_tcp_data_offset(tcp);
+}
+
+static inline int net_eth_to_iplen(char *pkt)
+{
+ struct iphdr *ip = net_eth_to_iphdr(pkt);
+ return ntohs(ip->tot_len) - sizeof(struct iphdr);
+}
+
+static inline int net_eth_to_tcplen(char *pkt)
+{
+ struct tcphdr *tcp = net_eth_to_tcphdr(pkt);
+ return net_eth_to_iplen(pkt) - net_tcp_data_offset(tcp);
+}
+
int net_checksum_ok(unsigned char *, int); /* Return true if cksum OK */
uint16_t net_checksum(unsigned char *, int); /* Calculate the checksum */
+int tcp_checksum_ok(struct iphdr *ip, struct tcphdr *tcp, int len);
+uint16_t tcp_checksum(struct iphdr *ip, struct tcphdr *tcp, int len);
/*
* The following functions are a bit ugly, but necessary to deal with
@@ -459,12 +553,18 @@ struct net_connection {
struct ethernet *et;
struct iphdr *ip;
struct udphdr *udp;
+ struct tcphdr *tcp;
struct eth_device *edev;
struct icmphdr *icmp;
unsigned char *packet;
struct list_head list;
rx_handler_f *handler;
int proto;
+ int state;
+ int ret;
+ union {
+ struct tcb tcb;
+ };
void *priv;
};
@@ -480,6 +580,13 @@ struct net_connection *net_udp_eth_new(struct eth_device *edev, IPaddr_t dest,
uint16_t dport, rx_handler_f *handler,
void *ctx);
+struct net_connection *net_tcp_new(IPaddr_t dest, uint16_t dport,
+ rx_handler_f *handler, void *ctx);
+
+struct net_connection *net_tcp_eth_new(struct eth_device *edev, IPaddr_t dest,
+ uint16_t dport, rx_handler_f *handler,
+ void *ctx);
+
struct net_connection *net_icmp_new(IPaddr_t dest, rx_handler_f *handler,
void *ctx);
@@ -497,6 +604,17 @@ static inline void *net_udp_get_payload(struct net_connection *con)
sizeof(struct udphdr);
}
+static inline void *net_tcp_get_payload(struct net_connection *con)
+{
+ return con->packet + sizeof(struct ethernet) + sizeof(struct iphdr) +
+ net_tcp_data_offset(con->tcp);
+}
+
+int net_tcp_listen(struct net_connection *con);
+int net_tcp_open(struct net_connection *con);
+int net_tcp_send(struct net_connection *con, int len);
+int net_tcp_close(struct net_connection *con);
+
int net_udp_send(struct net_connection *con, int len);
int net_icmp_send(struct net_connection *con, int len);
diff --git a/net/net.c b/net/net.c
index 9f799f252d..855bb8e4c2 100644
--- a/net/net.c
+++ b/net/net.c
@@ -47,6 +47,8 @@ static struct net_connection *net_ip_get_con(int proto, uint16_t port)
continue;
if (con->proto == IPPROTO_UDP && ntohs(con->udp->uh_sport) == port)
return con;
+ if (con->proto == IPPROTO_TCP && ntohs(con->tcp->src) == port)
+ return con;
}
return NULL;
@@ -99,6 +101,31 @@ uint16_t net_checksum(unsigned char *ptr, int len)
return xsum & 0xffff;
}
+uint16_t tcp_checksum(struct iphdr *ip, struct tcphdr *tcp, int len)
+{
+ uint32_t xsum;
+ struct psdhdr pseudo;
+ size_t hdrsize = net_tcp_data_offset(tcp);
+
+ pseudo.saddr = ip->saddr;
+ pseudo.daddr = ip->daddr;
+ pseudo.proto = htons(ip->protocol);
+ pseudo.ttlen = htons(hdrsize + len);
+
+ xsum = net_checksum((void *)&pseudo, sizeof(struct psdhdr));
+ xsum += net_checksum((void *)tcp, hdrsize + len);
+
+ while (xsum > 0xffff)
+ xsum = (xsum & 0xffff) + (xsum >> 16);
+
+ return xsum;
+}
+
+int tcp_checksum_ok(struct iphdr *ip, struct tcphdr *tcp, int len)
+{
+ return tcp_checksum(ip, tcp, len) == 0xffff;
+}
+
IPaddr_t getenv_ip(const char *name)
{
IPaddr_t ip;
@@ -335,6 +362,11 @@ static uint16_t net_udp_new_localport(void)
return net_new_localport(IPPROTO_UDP);
}
+static uint16_t net_tcp_new_localport(void)
+{
+ return net_new_localport(IPPROTO_TCP);
+}
+
IPaddr_t net_get_serverip(void)
{
IPaddr_t ip;
@@ -422,6 +454,7 @@ static struct net_connection *net_new(struct eth_device *edev, IPaddr_t dest,
con->et = (struct ethernet *)con->packet;
con->ip = (struct iphdr *)(con->packet + ETHER_HDR_SIZE);
con->udp = (struct udphdr *)(con->packet + ETHER_HDR_SIZE + sizeof(struct iphdr));
+ con->tcp = (struct tcphdr *)(con->packet + ETHER_HDR_SIZE + sizeof(struct iphdr));
con->icmp = (struct icmphdr *)(con->packet + ETHER_HDR_SIZE + sizeof(struct iphdr));
con->handler = handler;
@@ -452,6 +485,30 @@ out:
return ERR_PTR(ret);
}
+struct net_connection *net_tcp_eth_new(struct eth_device *edev, IPaddr_t dest,
+ uint16_t dport, rx_handler_f *handler,
+ void *ctx)
+{
+ struct net_connection *con = net_new(edev, dest, handler, ctx);
+ uint16_t doff;
+
+ if (IS_ERR(con))
+ return con;
+
+ con->proto = IPPROTO_TCP;
+ con->state = TCP_CLOSED;
+ con->tcp->src = htons(net_tcp_new_localport());
+ con->tcp->dst = htons(dport);
+ con->tcp->seq = 0;
+ con->tcp->ack = 0;
+ doff = sizeof(struct tcphdr) / sizeof(uint32_t);
+ con->tcp->doff_flag = htons(doff << TCP_DOFF_SHIFT);
+ con->tcp->urp = 0;
+ con->ip->protocol = IPPROTO_TCP;
+
+ return con;
+}
+
struct net_connection *net_udp_eth_new(struct eth_device *edev, IPaddr_t dest,
uint16_t dport, rx_handler_f *handler,
void *ctx)
@@ -475,6 +532,12 @@ struct net_connection *net_udp_new(IPaddr_t dest, uint16_t dport,
return net_udp_eth_new(NULL, dest, dport, handler, ctx);
}
+struct net_connection *net_tcp_new(IPaddr_t dest, uint16_t dport,
+ rx_handler_f *handler, void *ctx)
+{
+ return net_tcp_eth_new(NULL, dest, dport, handler, ctx);
+}
+
struct net_connection *net_icmp_new(IPaddr_t dest, rx_handler_f *handler,
void *ctx)
{
@@ -514,6 +577,167 @@ int net_udp_send(struct net_connection *con, int len)
return net_ip_send(con, sizeof(struct udphdr) + len);
}
+static int tcp_send(struct net_connection *con, int len, uint16_t flags)
+{
+ size_t hdr_size = net_tcp_data_offset(con->tcp);
+
+ con->tcp->doff_flag &= ~htons(TCP_FLAG_MASK);
+ con->tcp->doff_flag |= htons(flags);
+ con->tcp->sum = 0;
+ con->tcp->sum = ~tcp_checksum(con->ip, con->tcp, len);
+
+ return net_ip_send(con, hdr_size + len);
+}
+
+int net_tcp_send(struct net_connection *con, int len)
+{
+ struct tcb *tcb = &con->tcb;
+ uint16_t flag = 0;
+
+ if (con->proto != IPPROTO_TCP)
+ return -EPROTOTYPE;
+ switch (con->state) {
+ case TCP_CLOSED:
+ return -ENOTCONN;
+ case TCP_LISTEN:
+ /* TODO: proceed as open */
+ break;
+ case TCP_SYN_SENT:
+ case TCP_SYN_RECV:
+ /* queue request or "error: insufficient resources". */
+ break;
+ case TCP_ESTABLISHED:
+ case TCP_CLOSE_WAIT:
+ /* proceed */
+ break;
+ case TCP_FIN_WAIT1:
+ case TCP_FIN_WAIT2:
+ case TCP_TIME_WAIT:
+ case TCP_LAST_ACK:
+ case TCP_CLOSING:
+ return -ESHUTDOWN;
+ }
+
+ con->tcp->seq = htonl(tcb->snd_nxt);
+ tcb->snd_nxt += len;
+ flag |= TCP_FLAG_PSH;
+ if (1 || ntohl(con->tcp->ack) < con->tcb.rcv_nxt) {
+ flag |= TCP_FLAG_ACK;
+ con->tcp->ack = htonl(con->tcb.rcv_nxt);
+ } else {
+ con->tcp->ack = 0;
+ }
+
+ return tcp_send(con, len, flag);
+}
+
+int net_tcp_listen(struct net_connection *con)
+{
+ if (con->proto != IPPROTO_TCP)
+ return -EPROTOTYPE;
+
+ con->state = TCP_LISTEN;
+ return -1;
+}
+
+int net_tcp_open(struct net_connection *con)
+{
+ struct tcphdr *tcp = net_eth_to_tcphdr(con->packet);
+ struct tcb *tcb = &con->tcb;
+ int ret;
+
+ if (con->proto != IPPROTO_TCP)
+ return -EPROTOTYPE;
+ switch (con->state) {
+ case TCP_CLOSED:
+ case TCP_LISTEN:
+ break;
+ case TCP_SYN_SENT:
+ case TCP_SYN_RECV:
+ case TCP_ESTABLISHED:
+ case TCP_FIN_WAIT1:
+ case TCP_FIN_WAIT2:
+ case TCP_TIME_WAIT:
+ case TCP_CLOSE_WAIT:
+ case TCP_LAST_ACK:
+ case TCP_CLOSING:
+ return -EISCONN;
+ }
+
+ /* use a window smaller than the MTU, as only one tcp segment packet
+ * can be received at time */
+ tcb->rcv_wnd = 1024;
+ tcb->snd_wnd = 0;
+ tcb->iss = random32() + (get_time_ns() >> 10);
+ con->state = TCP_SYN_SENT;
+
+ tcp->wnd = htons(tcb->rcv_wnd);
+ tcp->seq = htonl(tcb->iss);
+ tcb->snd_una = tcb->iss;
+ tcb->snd_nxt = tcb->iss + 1;
+ ret = tcp_send(con, 0, TCP_FLAG_SYN);
+ if (ret)
+ return ret;
+
+ ret = wait_on_timeout(6000 * MSECOND, con->state == TCP_ESTABLISHED);
+ if (ret)
+ return -ETIMEDOUT;
+
+ return con->ret; // TODO: return 0 ?
+}
+
+int net_tcp_close(struct net_connection *con)
+{
+ struct tcphdr *tcp = net_eth_to_tcphdr(con->packet);
+ struct tcb *tcb = &con->tcb;
+ int ret;
+
+ if (con->proto != IPPROTO_TCP)
+ return -EPROTOTYPE;
+ switch (con->state) {
+ case TCP_CLOSED:
+ return -ENOTCONN;
+ case TCP_LISTEN:
+ case TCP_SYN_SENT:
+ con->state = TCP_CLOSED;
+ return 0;
+ break;
+ case TCP_SYN_RECV:
+ case TCP_ESTABLISHED:
+ /* wait for pending send */
+ con->state = TCP_FIN_WAIT1;
+ break;
+ case TCP_FIN_WAIT1:
+ case TCP_FIN_WAIT2:
+ /* error: connection closing */
+ return -1;
+ case TCP_TIME_WAIT:
+ case TCP_LAST_ACK:
+ case TCP_CLOSING:
+ /* error: connection closing */
+ return -1;
+ case TCP_CLOSE_WAIT:
+ /* queue close request after pending sends */
+ con->state = TCP_LAST_ACK;
+ break;
+ }
+
+ tcp->seq = htonl(tcb->snd_nxt);
+ tcp->ack = htonl(tcb->rcv_nxt);
+ tcb->snd_nxt += 1;
+ ret = tcp_send(con, 0, TCP_FLAG_FIN | TCP_FLAG_ACK);
+ if (ret)
+ return ret;
+
+ ret = wait_on_timeout(1000 * MSECOND, con->state == TCP_CLOSED);
+ if (ret)
+ return -ETIMEDOUT;
+
+ net_unregister(con);
+
+ return con->ret; // TODO: return 0 ?
+}
+
int net_icmp_send(struct net_connection *con, int len)
{
con->icmp->checksum = ~net_checksum((unsigned char *)con->icmp,
@@ -624,6 +848,186 @@ static int net_handle_udp(unsigned char *pkt, int len)
return -EINVAL;
}
+static int net_handle_tcp(unsigned char *pkt, int len)
+{
+ size_t min_size = ETHER_HDR_SIZE + sizeof(struct iphdr);
+ struct net_connection *con;
+ struct iphdr *ip = net_eth_to_iphdr(pkt);
+ struct tcphdr *tcp = net_eth_to_tcphdr(pkt);
+ struct tcb *tcb;
+ uint16_t flag;
+ uint16_t doff;
+ uint32_t tcp_len;
+ uint32_t seg_len;
+ uint32_t seg_ack;
+ uint32_t seg_seq;
+ uint32_t seg_last;
+ uint32_t rcv_wnd;
+ uint32_t rcv_nxt;
+ int seg_accept = 0;
+
+ if (len < (min_size + sizeof(struct tcphdr)))
+ goto bad;
+ flag = ntohs(tcp->doff_flag) & TCP_FLAG_MASK;
+ doff = net_tcp_data_offset(tcp);
+ if (doff < sizeof(struct tcphdr))
+ goto bad;
+ if (len < (min_size + doff))
+ goto bad;
+
+ seg_ack = ntohl(tcp->ack);
+ seg_seq = ntohl(tcp->seq);
+ tcp_len = net_eth_to_tcplen(pkt);
+ seg_len = tcp_len;
+ seg_len += !!(flag & TCP_FLAG_FIN);
+ seg_len += !!(flag & TCP_FLAG_SYN);
+
+ if (!tcp_checksum_ok(ip, tcp, tcp_len))
+ goto bad;
+
+ con = net_ip_get_con(IPPROTO_TCP, ntohs(tcp->dst));
+ if (con == NULL)
+ goto bad;
+ tcb = &con->tcb;
+
+ /* segment arrives */
+ seg_last = seg_seq + seg_len - 1;
+ rcv_wnd = tcb->rcv_wnd;
+ rcv_nxt = tcb->rcv_nxt;
+
+ if (seg_len == 0 && rcv_wnd == 0)
+ seg_accept = seg_seq == rcv_nxt;
+ if (seg_len == 0 && rcv_wnd > 0)
+ seg_accept = rcv_nxt <= seg_seq && seg_seq < (rcv_nxt + rcv_wnd);
+ if (seg_len > 0 && rcv_wnd == 0)
+ seg_accept = 0; /* not acceptable */
+ if (seg_len > 0 && rcv_wnd > 0)
+ seg_accept = (rcv_nxt <= seg_seq && seg_seq < (rcv_nxt + rcv_wnd))
+ || (rcv_nxt <= seg_last && seg_last < (rcv_nxt + rcv_wnd));
+
+ switch (con->state) {
+ case TCP_CLOSED:
+ if (flag & TCP_FLAG_RST) {
+ goto drop;
+ }
+ if (flag & TCP_FLAG_ACK) {
+ con->tcp->seq = 0;
+ con->tcp->ack = htonl(seg_seq + seg_len);
+ con->ret = tcp_send(con, 0, TCP_FLAG_RST | TCP_FLAG_ACK);
+ } else {
+ con->tcp->seq = htonl(seg_ack);
+ con->ret = tcp_send(con, 0, TCP_FLAG_RST);
+ }
+ break;
+ case TCP_LISTEN:
+ /* TODO */
+ break;
+ case TCP_SYN_SENT:
+ if (flag & TCP_FLAG_ACK) {
+ if (seg_ack <= tcb->iss || seg_ack > tcb->snd_nxt) {
+ if (flag & TCP_FLAG_RST)
+ goto drop;
+ con->tcp->seq = htonl(seg_ack);
+ return tcp_send(con, 0, TCP_FLAG_RST);
+ }
+ if (tcb->snd_una > seg_ack || seg_ack > tcb->snd_nxt)
+ goto drop; /* unacceptable */
+ }
+ if (flag & TCP_FLAG_RST) {
+ con->state = TCP_CLOSED;
+ con->ret = -ENETRESET;
+ break;
+ }
+ if ((flag & TCP_FLAG_SYN) && !(flag & TCP_FLAG_RST)) {
+ tcb->irs = seg_seq;
+ tcb->rcv_nxt = seg_seq + 1;
+ if (flag & TCP_FLAG_ACK)
+ tcb->snd_una = seg_ack;
+ if (tcb->snd_una > tcb->iss) {
+ con->state = TCP_ESTABLISHED;
+ con->tcp->seq = htonl(tcb->snd_nxt);
+ con->tcp->ack = htonl(tcb->rcv_nxt);
+ con->ret = tcp_send(con, 0, TCP_FLAG_ACK);
+ } else {
+ con->state = TCP_SYN_RECV;
+ tcb->snd_nxt = tcb->iss + 1;
+ con->tcp->seq = htonl(tcb->iss);
+ con->tcp->ack = htonl(tcb->rcv_nxt);
+ con->ret = tcp_send(con, 0, TCP_FLAG_SYN | TCP_FLAG_ACK);
+ }
+ }
+ break;
+ case TCP_SYN_RECV:
+ case TCP_ESTABLISHED:
+ if (flag & TCP_FLAG_RST) {
+ /* TODO: if passive open then return to LISTEN */
+ con->state = TCP_CLOSED;
+ con->ret = -ECONNREFUSED;
+ break;
+ }
+ if (!seg_accept) {
+ /* segment is not acceptable, send an ack unless RST bit
+ * is set (done above) */
+ con->tcp->seq = htonl(tcb->snd_nxt);
+ con->tcp->ack = htonl(tcb->rcv_nxt);
+ con->ret = tcp_send(con, 0, TCP_FLAG_ACK);
+ goto drop;
+ }
+ if (flag & TCP_FLAG_FIN && flag & TCP_FLAG_ACK)
+ con->state = TCP_CLOSE_WAIT;
+
+ if (flag & TCP_FLAG_ACK)
+ tcb->snd_una = seg_ack;
+
+ tcb->rcv_nxt += seg_len;
+ con->tcp->seq = htonl(tcb->snd_nxt);
+ if (seg_len) {
+ con->tcp->ack = htonl(tcb->rcv_nxt);
+ con->ret = tcp_send(con, 0, TCP_FLAG_ACK |
+ /* send FIN+ACK if FIN is set */
+ (flag & TCP_FLAG_FIN));
+ }
+ con->handler(con->priv, pkt, len);
+ break;
+ case TCP_FIN_WAIT1:
+ if (flag & TCP_FLAG_FIN)
+ con->state = TCP_CLOSING;
+ if (flag & TCP_FLAG_ACK)
+ tcb->snd_una = seg_ack;
+ /* fall-through */
+ case TCP_FIN_WAIT2:
+ tcb->rcv_nxt += seg_len;
+ con->tcp->seq = htonl(tcb->snd_nxt);
+ if (seg_len) {
+ con->tcp->ack = htonl(tcb->rcv_nxt);
+ con->ret = tcp_send(con, 0, TCP_FLAG_ACK);
+ }
+ case TCP_CLOSE_WAIT:
+ /* all segment queues should be flushed */
+ if (flag & TCP_FLAG_RST) {
+ con->state = TCP_CLOSED;
+ con->ret = -ENETRESET;
+ break;
+ }
+ break;
+ case TCP_CLOSING:
+ con->state = TCP_TIME_WAIT;
+ case TCP_LAST_ACK:
+ case TCP_TIME_WAIT:
+ if (flag & TCP_FLAG_RST) {
+ con->state = TCP_CLOSED;
+ con->ret = 0;
+ }
+ break;
+ }
+ return con->ret;
+drop:
+ return 0;
+bad:
+ net_bad_packet(pkt, len);
+ return 0;
+}
+
static int ping_reply(struct eth_device *edev, unsigned char *pkt, int len)
{
struct ethernet *et = (struct ethernet *)pkt;
@@ -711,6 +1115,8 @@ static int net_handle_ip(struct eth_device *edev, unsigned char *pkt, int len)
return net_handle_icmp(edev, pkt, len);
case IPPROTO_UDP:
return net_handle_udp(pkt, len);
+ case IPPROTO_TCP:
+ return net_handle_tcp(pkt, len);
}
return 0;
--
2.17.1
