net: Fix double-free snoop bug
[akaros.git] / kern / src / net / tcp.c
index 342afa9..d544fd9 100644 (file)
@@ -1,4 +1,31 @@
-// INFERNO
+/* Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+ * Portions Copyright © 1997-1999 Vita Nuova Limited
+ * Portions Copyright © 2000-2007 Vita Nuova Holdings Limited
+ *                                (www.vitanuova.com)
+ * Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+ *
+ * Modified for the Akaros operating system:
+ * Copyright (c) 2013-2014 The Regents of the University of California
+ * Copyright (c) 2013-2015 Google Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE. */
+
 #include <vfs.h>
 #include <kfs.h>
 #include <slab.h>
@@ -80,6 +107,7 @@ enum {
        RETRAN = 4,
        ACTIVE = 8,
        SYNACK = 16,
+       TSO = 32,
 
        LOGAGAIN = 3,
        LOGDGAIN = 2,
@@ -116,8 +144,8 @@ struct Tcptimer {
        Tcptimer *prev;
        Tcptimer *readynext;
        int state;
-       int start;
-       int count;
+       uint64_t start;
+       uint64_t count;
        void (*func) (void *);
        void *arg;
 };
@@ -253,8 +281,8 @@ struct Tcpctl {
        int srtt;                                       /* Shortened round trip */
        int mdev;                                       /* Mean deviation of round trip */
        int kacounter;                          /* count down for keep alive */
-       unsigned int sndsyntime;        /* time syn sent */
-       uint32_t time;                          /* time Finwait2 or Syn_received was sent */
+       uint64_t sndsyntime;            /* time syn sent */
+       uint64_t time;                          /* time Finwait2 or Syn_received was sent */
        int nochecksum;                         /* non-zero means don't send checksums */
        int flgcnt;                                     /* number of flags in the sequence (FIN,SEQ) */
 
@@ -290,7 +318,7 @@ struct Limbo {
        uint16_t mss;                           /* mss from the other end */
        uint16_t rcvscale;                      /* how much to scale rcvd windows */
        uint16_t sndscale;                      /* how much to scale sent windows */
-       uint32_t lastsend;                      /* last time we sent a synack */
+       uint64_t lastsend;                      /* last time we sent a synack */
        uint8_t version;                        /* v4 or v6 */
        uint8_t rexmits;                        /* number of retransmissions */
 };
@@ -435,16 +463,10 @@ void tcpsetstate(struct conv *s, uint8_t newstate)
                Fsconnected(s, NULL);
 }
 
-static char *tcpconnect(struct conv *c, char **argv, int argc)
+static void tcpconnect(struct conv *c, char **argv, int argc)
 {
-       char *e;
-
-       e = Fsstdconnect(c, argv, argc);
-       if (e != NULL)
-               return e;
+       Fsstdconnect(c, argv, argc);
        tcpstart(c, TCP_CONNECT);
-
-       return NULL;
 }
 
 static int tcpstate(struct conv *c, char *state, int n)
@@ -454,7 +476,7 @@ static int tcpstate(struct conv *c, char *state, int n)
        s = (Tcpctl *) (c->ptcl);
 
        return snprintf(state, n,
-                                       "%s qin %d qout %d srtt %d mdev %d cwin %lu swin %lu>>%d rwin %lu>>%d timer.start %d timer.count %d rerecv %d katimer.start %d katimer.count %d\n",
+                                       "%s qin %d qout %d srtt %d mdev %d cwin %u swin %u>>%d rwin %u>>%d timer.start %llu timer.count %llu rerecv %d katimer.start %d katimer.count %d\n",
                                        tcpstates[s->state],
                                        c->rq ? qlen(c->rq) : 0,
                                        c->wq ? qlen(c->wq) : 0,
@@ -472,17 +494,40 @@ static int tcpinuse(struct conv *c)
        return s->state != Closed;
 }
 
-static char *tcpannounce(struct conv *c, char **argv, int argc)
+static void tcpannounce(struct conv *c, char **argv, int argc)
 {
-       char *e;
-
-       e = Fsstdannounce(c, argv, argc);
-       if (e != NULL)
-               return e;
+       Fsstdannounce(c, argv, argc);
        tcpstart(c, TCP_LISTEN);
        Fsconnected(c, NULL);
+}
+
+static void tcpbypass(struct conv *cv, char **argv, int argc)
+{
+       struct tcppriv *tpriv = cv->p->priv;
 
-       return NULL;
+       Fsstdbypass(cv, argv, argc);
+       iphtadd(&tpriv->ht, cv);
+}
+
+static void tcpshutdown(struct conv *c, int how)
+{
+       Tcpctl *tcb = (Tcpctl*)c->ptcl;
+
+       /* Do nothing for the read side */
+       if (how == SHUT_RD)
+               return;
+       /* Sends a FIN.  If we're in another state (like Listen), we'll run into
+        * issues, since we'll never send the FIN.  We'll be shutdown on our end,
+        * but we'll never tell the distant end.  Might just be an app issue. */
+       switch (tcb->state) {
+       case Syn_received:
+       case Established:
+               tcb->flgcnt++;
+               tcb->snd.nxt++;
+               tcpsetstate(c, Finwait1);
+               tcpoutput(c);
+               break;
+       }
 }
 
 /*
@@ -536,11 +581,11 @@ void tcpkick(void *x)
 
        tcb = (Tcpctl *) s->ptcl;
 
+       qlock(&s->qlock);
        if (waserror()) {
                qunlock(&s->qlock);
                nexterror();
        }
-       qlock(&s->qlock);
 
        switch (tcb->state) {
                case Syn_sent:
@@ -585,11 +630,11 @@ void tcpacktimer(void *v)
        s = v;
        tcb = (Tcpctl *) s->ptcl;
 
+       qlock(&s->qlock);
        if (waserror()) {
                qunlock(&s->qlock);
                nexterror();
        }
-       qlock(&s->qlock);
        if (tcb->state != Closed) {
                tcb->flags |= FORCE;
                tcprcvwin(s);
@@ -601,8 +646,8 @@ void tcpacktimer(void *v)
 
 static void tcpcreate(struct conv *c)
 {
-       c->rq = qopen(QMAX, Qcoalesce, tcpacktimer, c);
-       c->wq = qopen((3 * QMAX) / 2, Qkick, tcpkick, c);
+       c->rq = qopen(QMAX, Qcoalesce, 0, 0);
+       c->wq = qopen(8 * QMAX, Qkick, tcpkick, c);
 }
 
 static void timerstate(struct tcppriv *priv, Tcptimer * t, int newstate)
@@ -648,7 +693,7 @@ void tcpackproc(void *a)
        priv = tcp->priv;
 
        for (;;) {
-               udelay_sched(MSPTICK * 1000);
+               kthread_usleep(MSPTICK * 1000);
 
                qlock(&priv->tl);
                timeo = NULL;
@@ -748,7 +793,8 @@ void localclose(struct conv *s, char *reason)
 }
 
 /* mtu (- TCP + IP hdr len) of 1st hop */
-int tcpmtu(struct Proto *tcp, uint8_t * addr, int version, int *scale)
+int tcpmtu(struct Proto *tcp, uint8_t * addr, int version, int *scale,
+          uint8_t *flags)
 {
        struct Ipifc *ifc;
        int mtu;
@@ -767,6 +813,8 @@ int tcpmtu(struct Proto *tcp, uint8_t * addr, int version, int *scale)
                                mtu = ifc->maxtu - ifc->m->hsize - (TCP6_PKT + TCP6_HDRSIZE);
                        break;
        }
+       *flags &= ~TSO;
+
        if (ifc != NULL) {
                if (ifc->mbps > 100)
                        *scale = HaveWS | 3;
@@ -774,6 +822,8 @@ int tcpmtu(struct Proto *tcp, uint8_t * addr, int version, int *scale)
                        *scale = HaveWS | 1;
                else
                        *scale = HaveWS | 0;
+               if (ifc->feat & NETF_TSO)
+                       *flags |= TSO;
        } else
                *scale = HaveWS | 0;
 
@@ -857,7 +907,7 @@ void tcpstart(struct conv *s, int mode)
        Tcpctl *tcb;
        struct tcppriv *tpriv;
        /* tcpackproc needs to free this if it ever exits */
-       char *kpname = kmalloc(KNAMELEN, KMALLOC_WAIT);
+       char *kpname = kmalloc(KNAMELEN, MEM_WAIT);
 
        tpriv = s->p->priv;
 
@@ -942,7 +992,8 @@ struct block *htontcp6(Tcp * tcph, struct block *data, Tcp6hdr * ph,
                        return NULL;
        } else {
                dlen = 0;
-               data = allocb(hdrlen + TCP6_PKT + 64);  /* the 64 pad is to meet mintu's */
+               /* the 64 pad is to meet mintu's */
+               data = block_alloc(hdrlen + TCP6_PKT + 64, MEM_WAIT);
                if (data == NULL)
                        return NULL;
                data->wp += hdrlen + TCP6_PKT;
@@ -1025,7 +1076,8 @@ struct block *htontcp4(Tcp * tcph, struct block *data, Tcp4hdr * ph,
                        return NULL;
        } else {
                dlen = 0;
-               data = allocb(hdrlen + TCP4_PKT + 64);  /* the 64 pad is to meet mintu's */
+               /* the 64 pad is to meet mintu's */
+               data = block_alloc(hdrlen + TCP4_PKT + 64, MEM_WAIT);
                if (data == NULL)
                        return NULL;
                data->wp += hdrlen + TCP4_PKT;
@@ -1202,7 +1254,7 @@ int ntohtcp4(Tcp * tcph, struct block **bpp)
  */
 void tcpsndsyn(struct conv *s, Tcpctl * tcb)
 {
-       tcb->iss = (nrand(1 << 16) << 16) | nrand(1 << 16);
+       urandom_read(&tcb->iss, sizeof(tcb->iss));
        tcb->rttseq = tcb->iss;
        tcb->snd.wl2 = tcb->iss;
        tcb->snd.una = tcb->iss;
@@ -1213,7 +1265,8 @@ void tcpsndsyn(struct conv *s, Tcpctl * tcb)
        tcb->sndsyntime = NOW;
 
        /* set desired mss and scale */
-       tcb->mss = tcpmtu(s->p, s->laddr, s->ipversion, &tcb->scale);
+       tcb->mss = tcpmtu(s->p, s->laddr, s->ipversion, &tcb->scale,
+                         &tcb->flags);
 }
 
 void
@@ -1226,7 +1279,7 @@ sndrst(struct Proto *tcp, uint8_t * source, uint8_t * dest,
        Tcp4hdr ph4;
        Tcp6hdr ph6;
 
-       netlog(tcp->f, Logtcp, "sndrst: %s", reason);
+       netlog(tcp->f, Logtcp, "sndrst: %s\n", reason);
 
        tpriv = tcp->priv;
 
@@ -1303,18 +1356,14 @@ sndrst(struct Proto *tcp, uint8_t * source, uint8_t * dest,
  *  send a reset to the remote side and close the conversation
  *  called with s qlocked
  */
-char *tcphangup(struct conv *s)
+static void tcphangup(struct conv *s)
 {
-       ERRSTACK(2);
+       ERRSTACK(1);
        Tcp seg;
        Tcpctl *tcb;
        struct block *hbp;
 
        tcb = (Tcpctl *) s->ptcl;
-       if (waserror()) {
-               poperror();
-               return commonerror();
-       }
        if (ipcmp(s->raddr, IPnoaddr)) {
                /* discard error style, poperror regardless */
                if (!waserror()) {
@@ -1344,8 +1393,6 @@ char *tcphangup(struct conv *s)
                poperror();
        }
        localclose(s, NULL);
-       poperror();
-       return NULL;
 }
 
 /*
@@ -1358,6 +1405,7 @@ int sndsynack(struct Proto *tcp, Limbo * lp)
        Tcp6hdr ph6;
        Tcp seg;
        int scale;
+       uint8_t flag = 0;
 
        /* make pseudo header */
        switch (lp->version) {
@@ -1389,7 +1437,7 @@ int sndsynack(struct Proto *tcp, Limbo * lp)
        seg.ack = lp->irs + 1;
        seg.flags = SYN | ACK;
        seg.urg = 0;
-       seg.mss = tcpmtu(tcp, lp->laddr, lp->version, &scale);
+       seg.mss = tcpmtu(tcp, lp->laddr, lp->version, &scale, &flag);
        seg.wnd = QMAX;
 
        /* if the other side set scale, we should too */
@@ -1473,7 +1521,7 @@ limbo(struct conv *s, uint8_t * source, uint8_t * dest, Tcp * seg, int version)
                lp->mss = seg->mss;
                lp->rcvscale = seg->ws;
                lp->irs = seg->seq;
-               lp->iss = (nrand(1 << 16) << 16) | nrand(1 << 16);
+               urandom_read(&lp->iss, sizeof(lp->iss));
        }
 
        if (sndsynack(s->p, lp) < 0) {
@@ -1492,7 +1540,7 @@ static void limborexmit(struct Proto *tcp)
        Limbo **l, *lp;
        int h;
        int seen;
-       uint32_t now;
+       uint64_t now;
 
        tpriv = tcp->priv;
 
@@ -1596,7 +1644,7 @@ static struct conv *tcpincoming(struct conv *s, Tcp * segp, uint8_t * src,
        h = hashipa(src, segp->source);
        for (l = &tpriv->lht[h]; (lp = *l) != NULL; l = &lp->next) {
                netlog(s->p->f, Logtcp,
-                          "tcpincoming s %I,0x%x/%I,0x%x d %I,0x%x/%I,0x%x v %d/%d", src,
+                          "tcpincoming s %I!%d/%I!%d d %I!%d/%I!%d v %d/%d\n", src,
                           segp->source, lp->raddr, lp->rport, dst, segp->dest, lp->laddr,
                           lp->lport, version, lp->version);
 
@@ -1610,7 +1658,7 @@ static struct conv *tcpincoming(struct conv *s, Tcp * segp, uint8_t * src,
 
                /* we're assuming no data with the initial SYN */
                if (segp->seq != lp->irs + 1 || segp->ack != lp->iss + 1) {
-                       netlog(s->p->f, Logtcp, "tcpincoming s 0x%lx/0x%lx a 0x%lx 0x%lx",
+                       netlog(s->p->f, Logtcp, "tcpincoming s 0x%lx/0x%lx a 0x%lx 0x%lx\n",
                                   segp->seq, lp->irs + 1, segp->ack, lp->iss + 1);
                        lp = NULL;
                } else {
@@ -1738,7 +1786,7 @@ int seq_ge(uint32_t x, uint32_t y)
 void tcpsynackrtt(struct conv *s)
 {
        Tcpctl *tcb;
-       int delta;
+       uint64_t delta;
        struct tcppriv *tpriv;
 
        tcb = (Tcpctl *) s->ptcl;
@@ -1948,6 +1996,12 @@ void tcpiput(struct Proto *tcp, struct Ipifc *unused, struct block *bp)
                        return;
                }
 
+               s = iphtlook(&tpriv->ht, source, seg.source, dest, seg.dest);
+               if (s && s->state == Bypass) {
+                       bypass_or_drop(s, bp);
+                       return;
+               }
+
                /* trim the packet to the size claimed by the datagram */
                length -= hdrlen + TCP4_PKT;
                bp = trimblock(bp, hdrlen + TCP4_PKT, length);
@@ -1989,6 +2043,12 @@ void tcpiput(struct Proto *tcp, struct Ipifc *unused, struct block *bp)
                        return;
                }
 
+               s = iphtlook(&tpriv->ht, source, seg.source, dest, seg.dest);
+               if (s && s->state == Bypass) {
+                       bypass_or_drop(s, bp);
+                       return;
+               }
+
                /* trim the packet to the size claimed by the datagram */
                length -= hdrlen;
                bp = trimblock(bp, hdrlen + TCP6_PKT, length);
@@ -2000,20 +2060,19 @@ void tcpiput(struct Proto *tcp, struct Ipifc *unused, struct block *bp)
                }
        }
 
-       /* lock protocol while searching for a conversation */
-       qlock(&tcp->qlock);
-
-       /* Look for a matching conversation */
-       s = iphtlook(&tpriv->ht, source, seg.source, dest, seg.dest);
+       /* s, the conv matching the n-tuple, was set above */
        if (s == NULL) {
-               netlog(f, Logtcp, "iphtlook failed");
+               netlog(f, Logtcp, "iphtlook failed\n");
 reset:
-               qunlock(&tcp->qlock);
                sndrst(tcp, source, dest, length, &seg, version, "no conversation");
                freeblist(bp);
                return;
        }
 
+       /* lock protocol for unstate Plan 9 invariants.  funcs like limbo or
+        * incoming might rely on it. */
+       qlock(&tcp->qlock);
+
        /* if it's a listener, look for the right flags and get a new conv */
        tcb = (Tcpctl *) s->ptcl;
        if (tcb->state == Listen) {
@@ -2037,8 +2096,10 @@ reset:
                 *  return it in state Syn_received
                 */
                s = tcpincoming(s, &seg, source, dest, version);
-               if (s == NULL)
+               if (s == NULL) {
+                       qunlock(&tcp->qlock);
                        goto reset;
+               }
        }
 
        /* The rest of the input state machine is run with the control block
@@ -2074,7 +2135,7 @@ reset:
                        }
                        if (seg.flags & RST) {
                                if (seg.flags & ACK)
-                                       localclose(s, Econrefused);
+                                       localclose(s, "connection refused");
                                goto raise;
                        }
 
@@ -2179,7 +2240,7 @@ reset:
                                                 s->raddr, s->rport, s->laddr, s->lport, tcb->rcv.nxt,
                                                 seg.seq);
                        }
-                       localclose(s, Econrefused);
+                       localclose(s, "connection refused");
                        goto raise;
                }
 
@@ -2445,8 +2506,33 @@ void tcpoutput(struct conv *s)
                                   tcb->snd.wnd, tcb->cwind);
                if (usable < ssize)
                        ssize = usable;
-               if (tcb->mss < ssize)
-                       ssize = tcb->mss;
+               if (ssize > tcb->mss) {
+                       if ((tcb->flags & TSO) == 0) {
+                               ssize = tcb->mss;
+                       } else {
+                               int segs, window;
+
+                               /*  Don't send too much.  32K is arbitrary..
+                                */
+                               if (ssize > 32 * 1024)
+                                       ssize = 32 * 1024;
+
+                               /* Clamp xmit to an integral MSS to
+                                * avoid ragged tail segments causing
+                                * poor link utilization.  Also
+                                * account for each segment sent in
+                                * msg heuristic, and round up to the
+                                * next multiple of 4, to ensure we
+                                * still yeild.
+                                */
+                               segs = ssize / tcb->mss;
+                               ssize = segs * tcb->mss;
+                               msgs += segs;
+                               if (segs > 3)
+                                       msgs = (msgs + 4) & ~3;
+                       }
+               }
+
                dsize = ssize;
                seg.urg = 0;
 
@@ -2502,6 +2588,10 @@ void tcpoutput(struct conv *s)
                                seg.flags |= FIN;
                                dsize--;
                        }
+                       if (BLEN(bp) > tcb->mss) {
+                               bp->flag |= Btso;
+                               bp->mss = tcb->mss;
+                       }
                }
 
                if (sent + dsize == sndcnt)
@@ -2616,7 +2706,7 @@ void tcpsendka(struct conv *s)
        seg.mss = 0;
        seg.ws = 0;
        if (tcpporthogdefense)
-               seg.seq = tcb->snd.una - (1 << 30) - nrand(1 << 20);
+               urandom_read(&seg.seq, sizeof(seg.seq));
        else
                seg.seq = tcb->snd.una - 1;
        seg.ack = tcb->rcv.nxt;
@@ -2625,7 +2715,7 @@ void tcpsendka(struct conv *s)
        if (tcb->state == Finwait2) {
                seg.flags |= FIN;
        } else {
-               dbp = allocb(1);
+               dbp = block_alloc(1, MEM_WAIT);
                dbp->wp++;
        }
 
@@ -2672,14 +2762,14 @@ void tcpkeepalive(void *v)
 
        s = v;
        tcb = (Tcpctl *) s->ptcl;
+       qlock(&s->qlock);
        if (waserror()) {
                qunlock(&s->qlock);
                nexterror();
        }
-       qlock(&s->qlock);
        if (tcb->state != Closed) {
                if (--(tcb->kacounter) <= 0) {
-                       localclose(s, Etimedout);
+                       localclose(s, "connection timed out");
                } else {
                        tcpsendka(s);
                        tcpgo(s->p->priv, &tcb->katimer);
@@ -2692,14 +2782,14 @@ void tcpkeepalive(void *v)
 /*
  *  start keepalive timer
  */
-char *tcpstartka(struct conv *s, char **f, int n)
+static void tcpstartka(struct conv *s, char **f, int n)
 {
        Tcpctl *tcb;
        int x;
 
        tcb = (Tcpctl *) s->ptcl;
        if (tcb->state != Established)
-               return "connection must be in Establised state";
+               error(ENOTCONN, "connection must be in Establised state");
        if (n > 1) {
                x = atoi(f[1]);
                if (x >= MSPTICK)
@@ -2707,21 +2797,17 @@ char *tcpstartka(struct conv *s, char **f, int n)
        }
        tcpsetkacounter(tcb);
        tcpgo(s->p->priv, &tcb->katimer);
-
-       return NULL;
 }
 
 /*
  *  turn checksums on/off
  */
-char *tcpsetchecksum(struct conv *s, char **f, int unused)
+static void tcpsetchecksum(struct conv *s, char **f, int unused)
 {
        Tcpctl *tcb;
 
        tcb = (Tcpctl *) s->ptcl;
        tcb->nochecksum = !atoi(f[1]);
-
-       return NULL;
 }
 
 void tcprxmit(struct conv *s)
@@ -2758,11 +2844,11 @@ void tcptimeout(void *arg)
        tpriv = s->p->priv;
        tcb = (Tcpctl *) s->ptcl;
 
+       qlock(&s->qlock);
        if (waserror()) {
                qunlock(&s->qlock);
                nexterror();
        }
-       qlock(&s->qlock);
        switch (tcb->state) {
                default:
                        tcb->backoff++;
@@ -2772,10 +2858,10 @@ void tcptimeout(void *arg)
                                maxback = MAXBACKMS;
                        tcb->backedoff += tcb->timer.start * MSPTICK;
                        if (tcb->backedoff >= maxback) {
-                               localclose(s, Etimedout);
+                               localclose(s, "connection timed out");
                                break;
                        }
-                       netlog(s->p->f, Logtcprxmt, "timeout rexmit 0x%lx %d/%d\n",
+                       netlog(s->p->f, Logtcprxmt, "timeout rexmit 0x%lx %llu/%llu\n",
                                   tcb->snd.una, tcb->timer.start, NOW);
                        tcpsettimer(tcb);
                        tcprxmit(s);
@@ -2997,7 +3083,6 @@ void tcpadvise(struct Proto *tcp, struct block *bp, char *msg)
        }
 
        /* Look for a connection */
-       qlock(&tcp->qlock);
        for (p = tcp->conv; *p; p++) {
                s = *p;
                tcb = (Tcpctl *) s->ptcl;
@@ -3007,7 +3092,6 @@ void tcpadvise(struct Proto *tcp, struct block *bp, char *msg)
                                        if (ipcmp(s->raddr, dest) == 0)
                                                if (ipcmp(s->laddr, source) == 0) {
                                                        qlock(&s->qlock);
-                                                       qunlock(&tcp->qlock);
                                                        switch (tcb->state) {
                                                                case Syn_sent:
                                                                        localclose(s, msg);
@@ -3018,33 +3102,32 @@ void tcpadvise(struct Proto *tcp, struct block *bp, char *msg)
                                                        return;
                                                }
        }
-       qunlock(&tcp->qlock);
        freeblist(bp);
 }
 
-static char *tcpporthogdefensectl(char *val)
+static void tcpporthogdefensectl(char *val)
 {
        if (strcmp(val, "on") == 0)
                tcpporthogdefense = 1;
        else if (strcmp(val, "off") == 0)
                tcpporthogdefense = 0;
        else
-               return "unknown value for tcpporthogdefense";
-       return NULL;
+               error(EINVAL, "unknown value for tcpporthogdefense");
 }
 
 /* called with c qlocked */
-char *tcpctl(struct conv *c, char **f, int n)
+static void tcpctl(struct conv *c, char **f, int n)
 {
        if (n == 1 && strcmp(f[0], "hangup") == 0)
-               return tcphangup(c);
-       if (n >= 1 && strcmp(f[0], "keepalive") == 0)
-               return tcpstartka(c, f, n);
-       if (n >= 1 && strcmp(f[0], "checksum") == 0)
-               return tcpsetchecksum(c, f, n);
-       if (n >= 1 && strcmp(f[0], "tcpporthogdefense") == 0)
-               return tcpporthogdefensectl(f[1]);
-       return "unknown control request";
+               tcphangup(c);
+       else if (n >= 1 && strcmp(f[0], "keepalive") == 0)
+               tcpstartka(c, f, n);
+       else if (n >= 1 && strcmp(f[0], "checksum") == 0)
+               tcpsetchecksum(c, f, n);
+       else if (n >= 1 && strcmp(f[0], "tcpporthogdefense") == 0)
+               tcpporthogdefensectl(f[1]);
+       else
+               error(EINVAL, "unknown command to %s", __func__);
 }
 
 int tcpstats(struct Proto *tcp, char *buf, int len)
@@ -3132,17 +3215,19 @@ void tcpinit(struct Fs *fs)
        tcp->name = "tcp";
        tcp->connect = tcpconnect;
        tcp->announce = tcpannounce;
+       tcp->bypass = tcpbypass;
        tcp->ctl = tcpctl;
        tcp->state = tcpstate;
        tcp->create = tcpcreate;
        tcp->close = tcpclose;
+       tcp->shutdown = tcpshutdown;
        tcp->rcv = tcpiput;
        tcp->advise = tcpadvise;
        tcp->stats = tcpstats;
        tcp->inuse = tcpinuse;
        tcp->gc = tcpgc;
        tcp->ipproto = IP_TCPPROTO;
-       tcp->nc = scalednconv();
+       tcp->nc = 4096;
        tcp->ptclsize = sizeof(Tcpctl);
        tpriv->stats[MaxConn] = tcp->nc;