Hi Sascha,
On Fri, Aug 12, 2022 at 09:04:48AM +0200, Sascha Hauer wrote:
> Hi Jules,
>
> On Tue, Aug 09, 2022 at 03:20:19PM +0200, Jules Maselbas wrote:
> > 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.
>
> I am impressed how simple TCP support can be. I never even considered
> trying to write TCP support from scratch.
> My plan for TCP support was always to integrate some existing stack like
> lwip into barebox to get a stack that has proven to work elsewhere. Also
> IPv6 support is still a pending feature which is becoming more and more
> interesting and we would get that for free with integrating an existing
> IP stack.
> Given that I am sceptical if we really want to follow the approach of
> developping TCP from scratch.
Yes... I agree that integrating a "proven" and field-tested TCP
implementation (including IPv6) is the saner solution, over rolling out
a custom implementation.
This is more a PoC and it was an excuse to take a deeper look at how TCP
works and what it requires.
> Nevertheless it's really cool to see how simple it could be ;) Nice
> stuff!
:)
> Sascha
>
>
> >
> > 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
> >
> >
> >
>
> --
> Pengutronix e.K. | |
> Steuerwalder Str. 21 | http://www.pengutronix.de/ |
> 31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
> Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |
>
>
