}
        }
        if (ok)                         /* If found, socket gets the segment */
            txlen = tsock_rx(ts, gfp, dlen);
    }
    if (!ok)                            /* If not, send RESET */
    {
        if (statedebug)
            printf("    (?) sending reset\n");
        txlen = make_reset_resp(gfp, dlen);
    }
    if (txlen > 0)
        put_frame(gfp, txlen);
}

/* Poll all the sockets, checking for timeouts or Tx data to be sent */
void tcp_poll(TSOCK tss[], int nsocks, GENFRAME *gfp)
{
    TSOCK *ts;
    int n, txlen;

    for (n=0; n<nsocks; n++)
    {
        ts = &tss[n];
        txlen = 0;
        if (ts->state)
        {
            if (ts->state && ts->timeout && mstimeout(&ts->time, ts->timeout))
            {
                if (tcpdebug)
                    printf("    (%u) Timeout\n", ts->index);
                ts->timeout += ts->timeout;
                if (ts->retries-- >= 0)
                    txlen = remake_tsock(ts, gfp);
                else
                {
                    new_state(ts, TCP_CLOSED);
                    if (ts->state != TCP_ARPS)
                        txlen = make_sock_tcp(gfp, ts, TRST, 0);
                }
            }
            else if (ts->state)                 /* Send Tx data */
                txlen = tsock_rx(ts, gfp, 0);
        }
        if (txlen > 0)
            put_frame(gfp, txlen);
    }
}

/* Change TCP socket state; if closed/opening/closing/established, do upcall
** If upcall returns error, don't change state, and return 0 */
void new_state(TSOCK *ts, int news)
{
    if (news != ts->state)
    {
        if (statedebug)
            printf("    (%u) new state '%s'\n", ts->index, tstates[news]);
        ts->state = news;
    }
    mstimeout(&ts->time, 0);
    ts->retries = TCP_RETRIES;
    ts->timeout = TCP_TIMEOUT;
}

/* Receive an incoming TCP seg into a socket, given data length (-1 if no data)
** Also called with length=0 to send out Tx data when connected.
** Returns transmit length, 0 if nothing to transmit */
int tsock_rx(TSOCK *ts, GENFRAME *gfp, int dlen)
{
    BYTE rflags=0;
    TCPKT *tcp;
    int txlen=0, tx=0;
    static WORD eport=MINEPORT;
    int (*upcall)(TSOCK *ts, CONN_STATE conn);

    tcp = getframe_datap(gfp);
    upcall = ts->server ? server_upcall : client_upcall;
    if (dlen>0 || dlen==DLEN_NODATA)
    {
        rflags = tcp->t.flags & (TFIN+TSYN+TRST+TACK);
        ts->rxseq = tcp->t.seq;
        ts->rxack = tcp->t.ack;
        ts->txwin = tcp->t.window;
        if (rflags & TRST)
            new_state(ts, TCP_RSTR);
        else if (rflags&TACK &&
                 in_limits(ts->rxack, ts->txb.out, ts->txb.trial))
            ts->txb.out = ts->rxack;
    }
    switch (ts->state)
    {
    /* Passive (remote) open a connection */
    case TCP_CLOSED:
        if (rflags == TSYN)                     /* If closed & SYN received.. */
        {
            buff_setall(&ts->rxb, ++ts->rxseq); /* Load my ACK value */
            buff_setall(&ts->txb, mstime()*0x100L); /* ..and my SEQ */
            ts->rxwin = TCP_RXWIN;              /* Default Rx window */
            ts->connflags = 0;                  /* No special flags */
            if (server_upcall && !server_upcall(ts, TCP_OPEN)) /* Upcall err? */
                txlen = make_reset_resp(gfp, dlen); /* ..don't accept SYN */
            else
            {
                new_state(ts, TCP_SYNR);        /* If OK, send SYN+ACK */
                txlen = make_sock_tcp(gfp, ts, TSYN+TACK, 0);
                ts->server = 1;                 /* Identify as server socket */
            }
        }
        else                                    /* If not SYN.. */
            txlen = make_reset_resp(gfp, dlen); /* ..send reset */
        break;

    case TCP_SYNR:                              /* SYN+ACK sent, if ACK Rx.. */
        tsock_estab_rx(ts, gfp, dlen);          /* Fetch Rx data */
        if (rflags==TACK && ts->rxseq==ts->rxb.in && ts->rxack==ts->txb.out)
        {
            if (upcall && !upcall(ts, TCP_CONN))/* If upcall not OK.. */
                new_state(ts, TCP_ACLOSE);      /* ..close after sending data */
            else                                /* If OK.. */
                new_state(ts, TCP_EST);         /* ..go established */
        }
        else if (dlen && ts->rxseq==ts->rxb.in-1)   /* If repeat SYN.. */
            txlen = make_sock_tcp(gfp, ts, TSYN+TACK, 0);
        break;                                      /* ..repeat SYN+ACK */

    /* Connection established */
    case TCP_EST:
        if (rflags)                                 /* Refresh timer if Rx */
            new_state(ts, ts->state);
        if (rflags&TFIN && ts->rxseq==ts->rxb.in)   /* If remote close.. */
        {
            tx = tsock_estab_rx(ts, gfp, dlen);     /* Fetch Rx data */
            if (!upcall || upcall(ts, TCP_CLOSE))
            {
                new_state(ts, TCP_LASTACK);         /* ..FIN+ACK if OK */
                txlen = make_sock_tcp(gfp, ts, TFIN+TACK, 0);
            }
            else
            {
                new_state(ts, TCP_CLWAIT);          /* ..or send data if not */
                txlen = tsock_estab_tx(ts, gfp, 1);
            }
        }
        else
        {
            tx = tsock_estab_rx(ts, gfp, dlen);     /* Fetch Rx data */
            if (upcall && !upcall(ts, dlen>0 ? TCP_DATA : TCP_NODATA))
            {
                new_state(ts, TCP_ACLOSE);      /* If upcall 0, start close */
                tx = 1;
            }
            else if (dlen > 0)                  /* If Rx data, send ack */
                tx = 1;
            txlen = tsock_estab_tx(ts, gfp, tx);/* Send packet, maybe Tx data */
        }
        break;

    /* Passive (remote) close a connection */
    case TCP_CLWAIT:                            /* Do upcall to application */
        if (!upcall || upcall(ts, TCP_CLOSE))   /* If OK, send FIN */
        {
            new_state(ts, TCP_LASTACK);
            txlen = make_sock_tcp(gfp, ts, TFIN+TACK, 0);
        }
        else                                    /* If not, keep open */
            txlen = tsock_estab_tx(ts, gfp, 0);
        break;

    case TCP_LASTACK:                           /* If ACK of my FIN.. */
        if (rflags==TACK && ts->rxseq==ts->rxb.in+1)
            new_state(ts, TCP_CLOSED);          /* ..connection closed */
        break;

    /* Active (local) open a connection */
    case TCP_AOPEN:
        ts->server = 0;                         /* Identify as client socket */
        if (gfp->g.dtype & DTYPE_SLIP)
            new_state(ts, TCP_ARPR);            /* If SLIP, don't ARP */
        else
        {                                       /* If Ether, do ARP */
            memcpy(ts->rem.mac, bcast, MACLEN); /* Set broadcast addr */
            new_state(ts, TCP_ARPS);            /* Send ARP */
            txlen = make_arp(gfp, &ts->loc, &ts->rem, ARPREQ);
        }
        break;

    case TCP_ARPS:                              /* Idle until ARP response */
        break;                                  /* (see ARP_receive function) */

    case TCP_ARPR:
        buff_setall(&ts->txb, mstime()*100L);   /* ARPed: set my SEQ value */
        ts->rxwin = TCP_RXWIN;                  /* Default window size */
        ts->connflags = 0;                      /* No special flags */
        ts->loc.port = ++eport>=MAXEPORT ? MINEPORT : eport;/* New port num */
        if (upcall)                             /* Do upcall */
            upcall(ts, TCP_OPEN);
        new_state(ts, TCP_SYNS);
        txlen = make_sock_tcp(gfp, ts, TSYN, 0);
        break;

    case TCP_SYNS:                              /* Sent SYN, if SYN+ACK Rx */
        if (rflags==TSYN+TACK && ts->rxack==ts->txb.out)
        {
            buff_setall(&ts->rxb, ts->rxseq+1); /* Set my ACK value */
            if (upcall)                         /* Do upcall */
                upcall(ts, TCP_CONN);
            new_state(ts, TCP_EST);             /* ..send ACK, go established */
            txlen = make_sock_tcp(gfp, ts, TACK, 0);
        }
        else if (rflags)                        /* If anything else.. */
            txlen = make_reset_resp(gfp, dlen); /* ..send reset */
        break;

    /* Active (local) close a connection */
    case TCP_ACLOSE:
        tsock_estab_rx(ts, gfp, dlen);          /* Fetch Rx data */
        if (buff_dlen(&ts->txb))                /* If any Tx data left.. */
            txlen = tsock_estab_tx(ts, gfp, 0); /* If unsent, send it */
        else                                    /* All data sent: close conn */
        {
            if (upcall)                         /* Do upcall */
                upcall(ts, TCP_CLOSE);
            new_state(ts, TCP_FINWT1);
            txlen = make_sock_tcp(gfp, ts, TFIN+TACK, 0);
        }
        break;

    case TCP_FINWT1:
        tsock_estab_rx(ts, gfp, dlen);          /* Fetch Rx data */
        if (rflags&TFIN && ts->rxseq==ts->rxb.in)
        {
            if (rflags&TACK && ts->rxack==ts->txb.trial+1)
                new_state(ts, TCP_TWAIT);       /* If ACK+FIN, close */
            else if (!(rflags&TACK) || ts->rxack==ts->txb.trial)
                new_state(ts, TCP_CLING);       /* If FIN, wait for ACK */
            txlen = make_sock_tcp(gfp, ts, TACK, 0);
        }
        else if (rflags&TACK && ts->rxack==ts->txb.trial+1)
            new_state(ts, TCP_FINWT2);          /* If just ACK, half-close */
        break;

    case TCP_FINWT2:                            /* Half-closed: awaiting FIN */
        tsock_estab_rx(ts, gfp, dlen);          /* Fetch Rx data */
        if (rflags&TFIN && ts->rxseq==ts->rxb.in)
        {
            new_state(ts, TCP_TWAIT);           /* Got FIN, close */
            txlen = make_sock_tcp(gfp, ts, TACK, 0);
        }
        break;

    case TCP_CLING:                             /* Closing: need final ACK */
        if (rflags==TACK && ts->rxseq==ts->rxb.in+1)
            new_state(ts, TCP_CLOSED);
        break;

    case TCP_TWAIT:                             /* Timed wait: just close! */
    default:
        new_state(ts, TCP_CLOSED);
        break;
    }
    return(txlen);
}

/* Put Rx data into an established socket, return non-zero if Tx ACK required */
int tsock_estab_rx(TSOCK *ts, GENFRAME *gfp, int dlen)
{
    TCPKT *tcp;
    int oset=0, oldlen, tx=0;
    WORD rdlen=0;
    long rxdiff;

    if (dlen > 0)                               /* If any data received.. */
    {
        tcp = getframe_datap(gfp);
        oset = gettcp_opt(tcp, 0);
        rxdiff = ts->rxseq - ts->rxb.in;        /* Find posn w.r.t. last data */
        if (rxdiff == 0)                        /* If next block, accept it */
            rdlen = (WORD)dlen;
        else if (rxdiff < 0)                    /* If part or all is a repeat */
        {
            oldlen = -(int)rxdiff;              /* ..read in new part */
            if (oldlen<=ts->rxwin && dlen>oldlen)
            {
                rdlen = dlen - oldlen;
                oset += (int)oldlen;
            }
        }
        if (rdlen)                               /* Read the data in */
        {
            if (statedebug)
                printf("    (%u) Rx data %u bytes\n", ts->index, rdlen);
            buff_in(&ts->rxb, &tcp->data[oset], rdlen);
        }                                        /* Tx if repeat or half full */
        tx = tcp->t.flags&TPUSH || rxdiff<0 || buff_dlen(&ts->rxb)>ts->rxwin/2;
    }
    return(tx);
}

/* Prepare Tx frame containing outgoing data for connection, return frame len
** If 'force' is non-zero, make frame even if there is no data */
int tsock_estab_tx(TSOCK *ts, GENFRAME *gfp, int force)
{
    int tdlen, txlen=0;

    tdlen = mini(buff_untriedlen(&ts->txb), tcp_maxdata(gfp));
    tdlen = mini(tdlen, ts->txwin-buff_trylen(&ts->txb));
    if (tdlen>0 && !force)
        force = buff_trylen(&ts->txb)==0 || tdlen<tcp_maxdata(gfp)/2;
    if (force)
    {
        if (tdlen>0 && statedebug)
            printf("    (%u) Tx data %u bytes\n", ts->index, tdlen);
        txlen = make_sock_tcp(gfp, ts, (BYTE)(TACK+ts->connflags), (WORD)tdlen);
    }
    return(txlen);
}

/* Remake the last transmission (TCP or ARP), return frame length */
int remake_tsock(TSOCK *ts, GENFRAME *gfp)
{
    int txlen=0;

    if (ts->state == TCP_ARPS)
        txlen = make_arp(gfp, &ts->loc, &ts->rem, ARPREQ);
    else if (ts->state==TCP_EST||ts->state==TCP_CLWAIT||ts->state==TCP_ACLOSE)
    {
        ts->txb.trial = ts->txb.out;
        txlen = tsock_estab_tx(ts, gfp, 1);
    }
    else if (ts->state)
        txlen = make_sock_tcp(gfp, ts, ts->txflags, 0);
    return(txlen);
}

/* EOF */