|
@@ -0,0 +1,446 @@
|
|
|
|
|
+/* Minimal TCP client: see tcp.h. */
|
|
|
|
|
+
|
|
|
|
|
+#include "io.h"
|
|
|
|
|
+#include "timer.h"
|
|
|
|
|
+#include "netdev.h"
|
|
|
|
|
+#include "net.h"
|
|
|
|
|
+#include "tcp.h"
|
|
|
|
|
+
|
|
|
|
|
+/* TCP flags. */
|
|
|
|
|
+#define TCP_FIN 0x01
|
|
|
|
|
+#define TCP_SYN 0x02
|
|
|
|
|
+#define TCP_RST 0x04
|
|
|
|
|
+#define TCP_PSH 0x08
|
|
|
|
|
+#define TCP_ACK 0x10
|
|
|
|
|
+
|
|
|
|
|
+#define TCP_MSS_OURS 1460
|
|
|
|
|
+#define TCP_WINDOW 4096
|
|
|
|
|
+#define TCP_RETRY_MS 1000
|
|
|
|
|
+#define TCP_RETRIES 3
|
|
|
|
|
+
|
|
|
|
|
+/* Frame buffers are file scope: a 4 KB process stack cannot hold them. The
|
|
|
|
|
+ * receive side uses the shared frame scratch (netdev_rx_scratch()). */
|
|
|
|
|
+static unsigned char tx_frame[14 + 20 + 20 + TCP_MSS_OURS];
|
|
|
|
|
+
|
|
|
|
|
+/* Payload of a segment larger than the caller's buffer is held here, so no
|
|
|
|
|
+ * bytes are lost; at most one segment can be outstanding. */
|
|
|
|
|
+static unsigned char hold_buf[TCP_MSS_OURS];
|
|
|
|
|
+static unsigned int hold_len;
|
|
|
|
|
+static unsigned int hold_pos;
|
|
|
|
|
+
|
|
|
|
|
+static unsigned int rd16(const unsigned char *p)
|
|
|
|
|
+{
|
|
|
|
|
+ return ((unsigned int)p[0] << 8) | p[1];
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+static void wr16(unsigned char *p, unsigned int v)
|
|
|
|
|
+{
|
|
|
|
|
+ p[0] = (unsigned char)(v >> 8);
|
|
|
|
|
+ p[1] = (unsigned char)v;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+static unsigned int rd32(const unsigned char *p)
|
|
|
|
|
+{
|
|
|
|
|
+ return ((unsigned int)p[0] << 24) | ((unsigned int)p[1] << 16) |
|
|
|
|
|
+ ((unsigned int)p[2] << 8) | p[3];
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+static void wr32(unsigned char *p, unsigned int v)
|
|
|
|
|
+{
|
|
|
|
|
+ p[0] = (unsigned char)(v >> 24);
|
|
|
|
|
+ p[1] = (unsigned char)(v >> 16);
|
|
|
|
|
+ p[2] = (unsigned char)(v >> 8);
|
|
|
|
|
+ p[3] = (unsigned char)v;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+/* Build and transmit one segment. `seq` is the sequence of the first byte
|
|
|
|
|
+ * (for SYN/FIN that is the flag's own sequence). Returns 0 / -1 (tx). */
|
|
|
|
|
+static int tcp_send_segment(struct tcp_conn *c, unsigned char flags,
|
|
|
|
|
+ unsigned int seq, unsigned int ack,
|
|
|
|
|
+ const unsigned char *payload, unsigned int len,
|
|
|
|
|
+ int with_mss)
|
|
|
|
|
+{
|
|
|
|
|
+ const struct netdev *nd = netdev_active();
|
|
|
|
|
+ unsigned char my_mac[6], my_ip[4];
|
|
|
|
|
+ unsigned char *ip = tx_frame + 14;
|
|
|
|
|
+ unsigned char *tcp = ip + 20;
|
|
|
|
|
+ unsigned short cs;
|
|
|
|
|
+ unsigned int total, optlen = 0, i;
|
|
|
|
|
+
|
|
|
|
|
+ if (!nd)
|
|
|
|
|
+ return -1;
|
|
|
|
|
+ nd->get_mac(my_mac);
|
|
|
|
|
+ net_get_ip(my_ip);
|
|
|
|
|
+
|
|
|
|
|
+ /* Ethernet. */
|
|
|
|
|
+ for (i = 0; i < 6; i++)
|
|
|
|
|
+ tx_frame[i] = c->dst_mac[i];
|
|
|
|
|
+ for (i = 0; i < 6; i++)
|
|
|
|
|
+ tx_frame[6 + i] = my_mac[i];
|
|
|
|
|
+ tx_frame[12] = 0x08;
|
|
|
|
|
+ tx_frame[13] = 0x00;
|
|
|
|
|
+
|
|
|
|
|
+ /* IPv4 header (IHL 5, no options). */
|
|
|
|
|
+ total = 20 + 20 + (with_mss ? 4 : 0) + len;
|
|
|
|
|
+ for (i = 0; i < 20; i++)
|
|
|
|
|
+ ip[i] = 0;
|
|
|
|
|
+ ip[0] = 0x45;
|
|
|
|
|
+ wr16(ip + 2, total);
|
|
|
|
|
+ ip[8] = 64; /* TTL */
|
|
|
|
|
+ ip[9] = IPPROTO_TCP;
|
|
|
|
|
+ for (i = 0; i < 4; i++)
|
|
|
|
|
+ ip[12 + i] = my_ip[i];
|
|
|
|
|
+ for (i = 0; i < 4; i++)
|
|
|
|
|
+ ip[16 + i] = c->dst_ip[i];
|
|
|
|
|
+ cs = net_checksum(ip, 20);
|
|
|
|
|
+ wr16(ip + 10, cs);
|
|
|
|
|
+
|
|
|
|
|
+ /* TCP header (+ MSS option on SYN). */
|
|
|
|
|
+ if (with_mss) {
|
|
|
|
|
+ tcp[20] = 2; /* kind: MSS */
|
|
|
|
|
+ tcp[21] = 4; /* length */
|
|
|
|
|
+ wr16(tcp + 22, TCP_MSS_OURS);
|
|
|
|
|
+ optlen = 4;
|
|
|
|
|
+ }
|
|
|
|
|
+ wr16(tcp + 0, c->sport);
|
|
|
|
|
+ wr16(tcp + 2, c->dport);
|
|
|
|
|
+ wr32(tcp + 4, seq);
|
|
|
|
|
+ wr32(tcp + 8, ack);
|
|
|
|
|
+ tcp[12] = (unsigned char)((5 + optlen / 4) << 4);
|
|
|
|
|
+ tcp[13] = flags;
|
|
|
|
|
+ wr16(tcp + 14, TCP_WINDOW);
|
|
|
|
|
+ wr16(tcp + 16, 0); /* checksum */
|
|
|
|
|
+ wr16(tcp + 18, 0); /* urgent pointer */
|
|
|
|
|
+ for (i = 0; i < len; i++)
|
|
|
|
|
+ tcp[20 + optlen + i] = payload[i];
|
|
|
|
|
+
|
|
|
|
|
+ cs = net_checksum_tcp(my_ip, c->dst_ip, tcp, 20 + optlen + len);
|
|
|
|
|
+ wr16(tcp + 16, cs);
|
|
|
|
|
+
|
|
|
|
|
+ return nd->tx(tx_frame, 14 + total);
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+/* One received segment. */
|
|
|
|
|
+struct tcp_seg {
|
|
|
|
|
+ unsigned int seq, ack;
|
|
|
|
|
+ unsigned char flags;
|
|
|
|
|
+ const unsigned char *data;
|
|
|
|
|
+ unsigned int len;
|
|
|
|
|
+ const unsigned char *tcp; /* for option parsing */
|
|
|
|
|
+ unsigned int doff;
|
|
|
|
|
+};
|
|
|
|
|
+
|
|
|
|
|
+/* Parse one frame as a TCP segment from the peer. Returns 1 on match.
|
|
|
|
|
+ * Incoming checksums are not validated (same as the UDP path). */
|
|
|
|
|
+static int tcp_parse(const unsigned char *f, unsigned int flen,
|
|
|
|
|
+ const unsigned char *peer_ip,
|
|
|
|
|
+ unsigned int peer_port, unsigned int local_port,
|
|
|
|
|
+ struct tcp_seg *s)
|
|
|
|
|
+{
|
|
|
|
|
+ const unsigned char *ip = f + 14;
|
|
|
|
|
+ const unsigned char *tcp;
|
|
|
|
|
+ unsigned char my_ip[4];
|
|
|
|
|
+ unsigned int i, ihl, ip_len, doff;
|
|
|
|
|
+
|
|
|
|
|
+ if (flen < 14 + 20)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if ((((unsigned int)f[12] << 8) | f[13]) != ET_IPV4)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if ((ip[0] >> 4) != 4)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ ihl = (unsigned int)(ip[0] & 0x0F) * 4;
|
|
|
|
|
+ if (ihl < 20 || ip[9] != IPPROTO_TCP)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ /* Fragments are not reassembled: MF or a nonzero offset. */
|
|
|
|
|
+ if ((ip[6] & 0x3F) != 0 || ip[7] != 0)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ ip_len = rd16(ip + 2);
|
|
|
|
|
+ if (ip_len < ihl + 20 || ip_len > flen - 14)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+
|
|
|
|
|
+ net_get_ip(my_ip);
|
|
|
|
|
+ for (i = 0; i < 4; i++) {
|
|
|
|
|
+ if (ip[12 + i] != peer_ip[i])
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if (ip[16 + i] != my_ip[i])
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ }
|
|
|
|
|
+
|
|
|
|
|
+ tcp = ip + ihl;
|
|
|
|
|
+ if (rd16(tcp + 0) != peer_port || rd16(tcp + 2) != local_port)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ doff = (unsigned int)(tcp[12] >> 4) * 4;
|
|
|
|
|
+ if (doff < 20 || ihl + doff > ip_len)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+
|
|
|
|
|
+ s->seq = rd32(tcp + 4);
|
|
|
|
|
+ s->ack = rd32(tcp + 8);
|
|
|
|
|
+ s->flags = tcp[13];
|
|
|
|
|
+ s->data = tcp + doff;
|
|
|
|
|
+ s->len = ip_len - ihl - doff;
|
|
|
|
|
+ s->tcp = tcp;
|
|
|
|
|
+ s->doff = doff;
|
|
|
|
|
+ return 1;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+/* Parse the peer's MSS option (default stays when absent); 1 if present. */
|
|
|
|
|
+static int tcp_parse_mss(const unsigned char *tcp, unsigned int doff,
|
|
|
|
|
+ unsigned int *mss)
|
|
|
|
|
+{
|
|
|
|
|
+ unsigned int o = 20;
|
|
|
|
|
+
|
|
|
|
|
+ while (o < doff) {
|
|
|
|
|
+ unsigned char kind = tcp[o];
|
|
|
|
|
+
|
|
|
|
|
+ if (kind == 0) /* end of options */
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if (kind == 1) { /* NOP */
|
|
|
|
|
+ o++;
|
|
|
|
|
+ continue;
|
|
|
|
|
+ }
|
|
|
|
|
+ if (o + 1 >= doff)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if (tcp[o + 1] < 2 || o + tcp[o + 1] > doff)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ if (kind == 2 && tcp[o + 1] == 4) {
|
|
|
|
|
+ *mss = rd16(tcp + o + 2);
|
|
|
|
|
+ return 1;
|
|
|
|
|
+ }
|
|
|
|
|
+ o += tcp[o + 1];
|
|
|
|
|
+ }
|
|
|
|
|
+ return 0;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+int tcp_connect(const unsigned char *dst_mac, const unsigned char *dst_ip,
|
|
|
|
|
+ unsigned int dport, struct tcp_conn *c)
|
|
|
|
|
+{
|
|
|
|
|
+ const struct netdev *nd = netdev_active();
|
|
|
|
|
+ unsigned char *rxbuf = netdev_rx_scratch();
|
|
|
|
|
+ unsigned int tries, i;
|
|
|
|
|
+
|
|
|
|
|
+ if (!nd || !net_is_configured())
|
|
|
|
|
+ return -3;
|
|
|
|
|
+
|
|
|
|
|
+ for (i = 0; i < 6; i++)
|
|
|
|
|
+ c->dst_mac[i] = dst_mac[i];
|
|
|
|
|
+ for (i = 0; i < 4; i++)
|
|
|
|
|
+ c->dst_ip[i] = dst_ip[i];
|
|
|
|
|
+ c->dport = dport;
|
|
|
|
|
+ c->sport = 0xC000u | (get_ticks_ms() & 0x3FFFu);
|
|
|
|
|
+ c->snd_una = c->snd_nxt = (get_ticks_ms() << 16) ^ 0x5EED0000u;
|
|
|
|
|
+ c->rcv_nxt = 0;
|
|
|
|
|
+ c->peer_mss = 536;
|
|
|
|
|
+ c->peer_fin = 0;
|
|
|
|
|
+ hold_len = hold_pos = 0;
|
|
|
|
|
+
|
|
|
|
|
+ for (tries = 0; tries < TCP_RETRIES; tries++) {
|
|
|
|
|
+ unsigned int deadline = get_ticks_ms() + TCP_RETRY_MS;
|
|
|
|
|
+
|
|
|
|
|
+ if (tcp_send_segment(c, TCP_SYN, c->snd_nxt, 0, 0, 0, 1) != 0)
|
|
|
|
|
+ return -3;
|
|
|
|
|
+
|
|
|
|
|
+ while ((int)(get_ticks_ms() - deadline) < 0) {
|
|
|
|
|
+ struct tcp_seg s;
|
|
|
|
|
+ int len = nd->rx(rxbuf, NETDEV_FRAME_MAX);
|
|
|
|
|
+
|
|
|
|
|
+ if (len < 0)
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (!tcp_parse(rxbuf, (unsigned int)len, c->dst_ip,
|
|
|
|
|
+ c->dport, c->sport, &s))
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (s.flags & TCP_RST)
|
|
|
|
|
+ return -2;
|
|
|
|
|
+ if ((s.flags & (TCP_SYN | TCP_ACK)) ==
|
|
|
|
|
+ (TCP_SYN | TCP_ACK) && s.ack == c->snd_nxt + 1) {
|
|
|
|
|
+ unsigned int mss;
|
|
|
|
|
+
|
|
|
|
|
+ c->rcv_nxt = s.seq + 1;
|
|
|
|
|
+ c->snd_nxt++;
|
|
|
|
|
+ c->snd_una = c->snd_nxt;
|
|
|
|
|
+ if (tcp_parse_mss(s.tcp, s.doff, &mss) &&
|
|
|
|
|
+ mss >= 64 && mss <= TCP_MSS_OURS)
|
|
|
|
|
+ c->peer_mss = mss;
|
|
|
|
|
+ if (tcp_send_segment(c, TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0) != 0)
|
|
|
|
|
+ return -3;
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ return -1;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+int tcp_send(struct tcp_conn *c, const void *data, unsigned int len)
|
|
|
|
|
+{
|
|
|
|
|
+ const struct netdev *nd = netdev_active();
|
|
|
|
|
+ unsigned char *rxbuf = netdev_rx_scratch();
|
|
|
|
|
+ unsigned int tries;
|
|
|
|
|
+
|
|
|
|
|
+ if (!nd || len > c->peer_mss)
|
|
|
|
|
+ return -3;
|
|
|
|
|
+
|
|
|
|
|
+ for (tries = 0; tries < TCP_RETRIES; tries++) {
|
|
|
|
|
+ unsigned int deadline = get_ticks_ms() + TCP_RETRY_MS;
|
|
|
|
|
+
|
|
|
|
|
+ if (tcp_send_segment(c, TCP_PSH | TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, (const unsigned char *)data,
|
|
|
|
|
+ len, 0) != 0)
|
|
|
|
|
+ return -3;
|
|
|
|
|
+
|
|
|
|
|
+ while ((int)(get_ticks_ms() - deadline) < 0) {
|
|
|
|
|
+ struct tcp_seg s;
|
|
|
|
|
+ int rlen = nd->rx(rxbuf, NETDEV_FRAME_MAX);
|
|
|
|
|
+
|
|
|
|
|
+ if (rlen < 0)
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (!tcp_parse(rxbuf, (unsigned int)rlen, c->dst_ip,
|
|
|
|
|
+ c->dport, c->sport, &s))
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (s.flags & TCP_RST)
|
|
|
|
|
+ return -2;
|
|
|
|
|
+ if (s.ack == c->snd_nxt + len) {
|
|
|
|
|
+ c->snd_una = s.ack;
|
|
|
|
|
+ c->snd_nxt = s.ack;
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ }
|
|
|
|
|
+ /* Data before the request is fully acked: ACK it and
|
|
|
|
|
+ * drop it; the peer retransmits if it cares. */
|
|
|
|
|
+ if (s.len) {
|
|
|
|
|
+ if (s.seq == c->rcv_nxt)
|
|
|
|
|
+ c->rcv_nxt += s.len;
|
|
|
|
|
+ tcp_send_segment(c, TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0);
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ return -1;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+int tcp_recv(struct tcp_conn *c, unsigned char *out, unsigned int maxlen,
|
|
|
|
|
+ unsigned int deadline_ms)
|
|
|
|
|
+{
|
|
|
|
|
+ const struct netdev *nd = netdev_active();
|
|
|
|
|
+ unsigned char *rxbuf = netdev_rx_scratch();
|
|
|
|
|
+
|
|
|
|
|
+ if (!nd)
|
|
|
|
|
+ return -2;
|
|
|
|
|
+
|
|
|
|
|
+ /* Drain a partially consumed segment first. */
|
|
|
|
|
+ if (hold_pos < hold_len) {
|
|
|
|
|
+ unsigned int n = hold_len - hold_pos;
|
|
|
|
|
+ unsigned int i;
|
|
|
|
|
+
|
|
|
|
|
+ if (n > maxlen)
|
|
|
|
|
+ n = maxlen;
|
|
|
|
|
+ for (i = 0; i < n; i++)
|
|
|
|
|
+ out[i] = hold_buf[hold_pos + i];
|
|
|
|
|
+ hold_pos += n;
|
|
|
|
|
+ return (int)n;
|
|
|
|
|
+ }
|
|
|
|
|
+ if (c->peer_fin)
|
|
|
|
|
+ return 0;
|
|
|
|
|
+
|
|
|
|
|
+ while ((int)(get_ticks_ms() - deadline_ms) < 0) {
|
|
|
|
|
+ struct tcp_seg s;
|
|
|
|
|
+ int len = nd->rx(rxbuf, NETDEV_FRAME_MAX);
|
|
|
|
|
+
|
|
|
|
|
+ if (len < 0)
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (!tcp_parse(rxbuf, (unsigned int)len, c->dst_ip,
|
|
|
|
|
+ c->dport, c->sport, &s))
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (s.flags & TCP_RST)
|
|
|
|
|
+ return -2;
|
|
|
|
|
+
|
|
|
|
|
+ /* Track our send window (nothing pending here, but keeps
|
|
|
|
|
+ * snd_una meaningful for the ACKs we emit). */
|
|
|
|
|
+ if ((unsigned)(s.ack - c->snd_una) <=
|
|
|
|
|
+ (unsigned)(c->snd_nxt - c->snd_una))
|
|
|
|
|
+ c->snd_una = s.ack;
|
|
|
|
|
+
|
|
|
|
|
+ if (s.len) {
|
|
|
|
|
+ if (s.len > sizeof(hold_buf)) /* not ours to store */
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (s.seq == c->rcv_nxt) {
|
|
|
|
|
+ unsigned int take = s.len < maxlen ? s.len : maxlen;
|
|
|
|
|
+ unsigned int i;
|
|
|
|
|
+
|
|
|
|
|
+ for (i = 0; i < take; i++)
|
|
|
|
|
+ out[i] = s.data[i];
|
|
|
|
|
+ c->rcv_nxt += s.len;
|
|
|
|
|
+ if (s.len > take) { /* hold the rest */
|
|
|
|
|
+ for (i = take; i < s.len; i++)
|
|
|
|
|
+ hold_buf[i - take] = s.data[i];
|
|
|
|
|
+ hold_len = s.len - take;
|
|
|
|
|
+ hold_pos = 0;
|
|
|
|
|
+ }
|
|
|
|
|
+ /* A FIN riding on the data consumes the next
|
|
|
|
|
+ * sequence number after the payload. */
|
|
|
|
|
+ if ((s.flags & TCP_FIN) && !c->peer_fin) {
|
|
|
|
|
+ c->peer_fin = 1;
|
|
|
|
|
+ c->rcv_nxt++;
|
|
|
|
|
+ }
|
|
|
|
|
+ tcp_send_segment(c, TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0);
|
|
|
|
|
+ return (int)take;
|
|
|
|
|
+ }
|
|
|
|
|
+ /* Duplicate or out-of-order data: re-ACK to resync. */
|
|
|
|
|
+ tcp_send_segment(c, TCP_ACK, c->snd_nxt, c->rcv_nxt,
|
|
|
|
|
+ 0, 0, 0);
|
|
|
|
|
+ continue;
|
|
|
|
|
+ }
|
|
|
|
|
+ if (s.flags & TCP_FIN) {
|
|
|
|
|
+ if (s.seq == c->rcv_nxt) {
|
|
|
|
|
+ c->rcv_nxt++;
|
|
|
|
|
+ c->peer_fin = 1;
|
|
|
|
|
+ tcp_send_segment(c, TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0);
|
|
|
|
|
+ return 0;
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+ return -1;
|
|
|
|
|
+}
|
|
|
|
|
+
|
|
|
|
|
+void tcp_close(struct tcp_conn *c)
|
|
|
|
|
+{
|
|
|
|
|
+ const struct netdev *nd = netdev_active();
|
|
|
|
|
+ unsigned char *rxbuf = netdev_rx_scratch();
|
|
|
|
|
+ unsigned int fin_seq = c->snd_nxt;
|
|
|
|
|
+ unsigned int tries;
|
|
|
|
|
+
|
|
|
|
|
+ if (!nd)
|
|
|
|
|
+ return;
|
|
|
|
|
+
|
|
|
|
|
+ for (tries = 0; tries < 2; tries++) {
|
|
|
|
|
+ unsigned int deadline = get_ticks_ms() + 500;
|
|
|
|
|
+ struct tcp_seg s;
|
|
|
|
|
+
|
|
|
|
|
+ if (tcp_send_segment(c, TCP_FIN | TCP_ACK, fin_seq,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0) != 0)
|
|
|
|
|
+ return;
|
|
|
|
|
+ c->snd_nxt = fin_seq + 1;
|
|
|
|
|
+
|
|
|
|
|
+ while ((int)(get_ticks_ms() - deadline) < 0) {
|
|
|
|
|
+ int len = nd->rx(rxbuf, NETDEV_FRAME_MAX);
|
|
|
|
|
+
|
|
|
|
|
+ if (len < 0)
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (!tcp_parse(rxbuf, (unsigned int)len, c->dst_ip,
|
|
|
|
|
+ c->dport, c->sport, &s))
|
|
|
|
|
+ continue;
|
|
|
|
|
+ if (s.flags & TCP_RST)
|
|
|
|
|
+ return;
|
|
|
|
|
+ /* Our FIN acked (or their FIN first). */
|
|
|
|
|
+ if ((s.flags & TCP_FIN) && s.seq == c->rcv_nxt) {
|
|
|
|
|
+ c->rcv_nxt++;
|
|
|
|
|
+ c->peer_fin = 1;
|
|
|
|
|
+ tcp_send_segment(c, TCP_ACK, c->snd_nxt,
|
|
|
|
|
+ c->rcv_nxt, 0, 0, 0);
|
|
|
|
|
+ return;
|
|
|
|
|
+ }
|
|
|
|
|
+ if (s.ack == c->snd_nxt)
|
|
|
|
|
+ return;
|
|
|
|
|
+ }
|
|
|
|
|
+ }
|
|
|
|
|
+}
|