Return to tcpif.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/tcpif.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "../port/lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "../port/error.h"
        !             7: #include       "arp.h"
        !             8: #include       "../port/ipdat.h"
        !             9: 
        !            10: extern int tcpdbg;
        !            11: #define DPRINT if(tcpdbg) print
        !            12: 
        !            13: void
        !            14: tcpxstate(Ipconv *s, char oldstate, char newstate)
        !            15: {
        !            16:        int len;
        !            17:        Block *bp;
        !            18:        Tcpctl *tcb;
        !            19: 
        !            20:        if(oldstate == newstate)
        !            21:                return;
        !            22: 
        !            23:        tcb = &s->tcpctl;
        !            24:        switch(newstate) {
        !            25:        case Closed:
        !            26:                s->psrc = 0;            /* This connection is toast */
        !            27:                s->pdst = 0;
        !            28:                s->dst = 0;
        !            29:                /* fall through */
        !            30: 
        !            31:        case Close_wait:                /* Remote closes */
        !            32:                if(s->err) {
        !            33:                        len = strlen(s->err);
        !            34:                        bp = allocb(len);
        !            35:                        strcpy((char *)bp->wptr, s->err);
        !            36:                        bp->wptr += len;
        !            37:                }
        !            38:                else
        !            39:                        bp = allocb(0);
        !            40: 
        !            41:                bp->flags |= S_DELIM;
        !            42:                bp->type = M_HANGUP;
        !            43:                qlock(s);
        !            44:                if(waserror()) {
        !            45:                        qunlock(s);
        !            46:                        nexterror();
        !            47:                }
        !            48:                if(s->readq == 0) {
        !            49:                        if(newstate == Close_wait)
        !            50:                                putb(&tcb->rcvq, bp);
        !            51:                        else
        !            52:                                freeb(bp);
        !            53:                } else
        !            54:                        PUTNEXT(s->readq, bp);
        !            55:                if(tcb){
        !            56:                        tcb->sndfull = 0;
        !            57:                        wakeup(&tcb->sndr);
        !            58:                }
        !            59:                poperror();
        !            60:                qunlock(s);
        !            61:                break;
        !            62:        }
        !            63: 
        !            64:        if(oldstate == Syn_sent)
        !            65:                wakeup(&tcb->syner);
        !            66: }
        !            67: 
        !            68: static int
        !            69: notsyner(void *ic)
        !            70: {
        !            71:        return ((Tcpctl*)ic)->state != Syn_sent;
        !            72: }
        !            73: 
        !            74: void
        !            75: tcpstart(Ipconv *s, int mode, ushort window, char tos)
        !            76: {
        !            77:        Tcpctl *tcb;
        !            78: 
        !            79:        tcb = &s->tcpctl;
        !            80:        if(tcb->state != Closed || tcb->sndq != 0){
        !            81:                print("tcpstart: %lux %d sndq %lux dest %d.%d.%d.%d %d to %d\n",
        !            82:                        s, tcb->state, tcb->sndq, fmtaddr(s->dst), s->pdst, s->psrc);
        !            83:                error(Einuse);
        !            84:        }
        !            85: 
        !            86:        init_tcpctl(s);
        !            87: 
        !            88:        tcb->window = window;
        !            89:        tcb->rcv.wnd = window;
        !            90:        tcb->tos = tos;
        !            91: 
        !            92:        switch(mode){
        !            93:        case TCP_PASSIVE:
        !            94:                tcb->flags |= CLONE;
        !            95:                tcpsetstate(s, Listen);
        !            96:                break;
        !            97: 
        !            98:        case TCP_ACTIVE:
        !            99:                /* Send SYN, go into SYN_SENT state */
        !           100:                tcb->flags |= ACTIVE;
        !           101:                qlock(tcb);
        !           102:                if(waserror()) {
        !           103:                        qunlock(tcb);
        !           104:                        nexterror();
        !           105:                }
        !           106:                tcpsndsyn(tcb);
        !           107:                tcpsetstate(s, Syn_sent);
        !           108:                tcpoutput(s);
        !           109:                poperror();
        !           110:                qunlock(tcb);
        !           111:                tsleep(&tcb->syner, notsyner, tcb, 120*1000);
        !           112:                if(tcb->state != Established && tcb->state != Syn_received){
        !           113:                        if(s->err)
        !           114:                                error(s->err);
        !           115:                        error(Etimedout);
        !           116:                }
        !           117:                break;
        !           118:        }
        !           119: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.