Subversion Repositories openrisc_me

//==========================================================================

//

//      net/tcp.c

//

//      Stand-alone TCP networking support for RedBoot

//

//==========================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):    gthomas

// Contributors: gthomas

// Date:         2000-07-14

// Purpose:      

// Description:  

//              

// This code is part of RedBoot (tm).

//

//####DESCRIPTIONEND####

//

//==========================================================================

#include <net/net.h>

#define MAX_TCP_SEGMENT (ETH_MAX_PKTLEN - (sizeof(eth_header_t) + sizeof(ip_header_t)))

#define MAX_TCP_DATA    (MAX_TCP_SEGMENT - sizeof(tcp_header_t))

/* sequence number comparison macros */

#define SEQ_LT(a,b) ((int)((a)-(b)) < 0)

#define SEQ_LE(a,b) ((int)((a)-(b)) <= 0)

#define SEQ_GT(a,b) ((int)((a)-(b)) > 0)

#define SEQ_GE(a,b) ((int)((a)-(b)) >= 0)

/* Set a timer which will send an RST and abort a connection. */

static timer_t abort_timer;

static void do_retrans(void *p);

static void do_close(void *p);

#ifdef BSP_LOG

static char *

flags_to_str(octet f)

{

    static char str[7], *p;

    p = str;

    if (f & TCP_FLAG_FIN)

        *p++ = 'F';

    if (f & TCP_FLAG_SYN)

        *p++ = 'S';

    if (f & TCP_FLAG_RST)

        *p++ = 'R';

    if (f & TCP_FLAG_PSH)

        *p++ = 'P';

    if (f & TCP_FLAG_ACK)

        *p++ = 'A';

    if (f & TCP_FLAG_URG)

        *p++ = 'U';

    *p = '\0';

    return str;

}

#endif

/*

 * A major assumption is that only a very small number of sockets will

 * active, so a simple linear search of those sockets is acceptible.

 */

static tcp_socket_t *tcp_list;

/*

 * Format and send an outgoing segment.

 */

static void

tcp_send(tcp_socket_t *s, int flags, int resend)

{

    tcp_header_t *tcp;

    ip_header_t  *ip;

    pktbuf_t     *pkt = &s->pkt;

    unsigned short cksum;

    dword         tcp_magic;

    int           tcp_magic_size = sizeof(tcp_magic);

    ip = pkt->ip_hdr;

    tcp = pkt->tcp_hdr;

    if (flags & TCP_FLAG_SYN) {

        /* If SYN, assume no data and send MSS option in tcp header */

        pkt->pkt_bytes = sizeof(tcp_header_t) + 4;

        tcp->hdr_len = 6;

        tcp_magic = htonl(0x02040000 | MAX_TCP_DATA);

        memcpy((unsigned char *)(tcp+1), &tcp_magic, tcp_magic_size);

        s->data_bytes = 0;

    } else {

        pkt->pkt_bytes = s->data_bytes + sizeof(tcp_header_t);

        tcp->hdr_len = 5;

    }

    /* tcp header */

    tcp->reserved = 0;

    tcp->seqnum = htonl(s->seq);

    tcp->acknum = htonl(s->ack);

    tcp->checksum = 0;

    if (!resend) {

        tcp->src_port = htons(s->our_port);

        tcp->dest_port = htons(s->his_port);

        tcp->flags = flags;

        /* always set PUSH flag if sending data */

        if (s->data_bytes)

            tcp->flags |= TCP_FLAG_PSH;

        tcp->window = htons(MAX_TCP_DATA);

        tcp->urgent = 0;

        /* fill in some pseudo-header fields */

        memcpy(ip->source, __local_ip_addr, sizeof(ip_addr_t));

        memcpy(ip->destination, s->his_addr.ip_addr, sizeof(ip_addr_t));

        ip->protocol = IP_PROTO_TCP;

    }

    /* another pseudo-header field */

    ip->length = htons(pkt->pkt_bytes);

    /* compute tcp checksum */

    cksum = __sum((word *)tcp, pkt->pkt_bytes, __pseudo_sum(ip));

    tcp->checksum = htons(cksum);

    __ip_send(pkt, IP_PROTO_TCP, &s->his_addr);

    BSPLOG(bsp_log("tcp_send: state[%d] flags[%s] ack[%x] data[%d].\n",

                   s->state, flags_to_str(tcp->flags), s->ack, s->data_bytes));

    if (s->state == _TIME_WAIT) {

        // If 'reuse' is set on socket, close after 1 second, otherwise 2 minutes

        __timer_set(&s->timer, s->reuse ? 1000 : 120000, do_close, s);

    }

    else if ((tcp->flags & (TCP_FLAG_FIN | TCP_FLAG_SYN)) || s->data_bytes)

        __timer_set(&s->timer, 1000, do_retrans, s);

}

static pktbuf_t ack_pkt;

static word     ack_buf[ETH_MIN_PKTLEN/sizeof(word)];

/*

 * Send an ack.

 */

static void

send_ack(tcp_socket_t *s)

{

    tcp_header_t *tcp;

    ip_header_t  *ip;

    unsigned short cksum;

    ack_pkt.buf = ack_buf;

    ack_pkt.bufsize = sizeof(ack_buf);

    ack_pkt.ip_hdr = ip = (ip_header_t *)ack_buf;

    ack_pkt.tcp_hdr = tcp = (tcp_header_t *)(ip + 1);

    ack_pkt.pkt_bytes = sizeof(tcp_header_t);

    /* tcp header */

    tcp->hdr_len = 5;

    tcp->reserved = 0;

    tcp->seqnum = htonl(s->seq);

    tcp->acknum = htonl(s->ack);

    tcp->checksum = 0;

    tcp->src_port = htons(s->our_port);

    tcp->dest_port = htons(s->his_port);

    tcp->flags = TCP_FLAG_ACK;

    tcp->window = htons(MAX_TCP_DATA);

    tcp->urgent = 0;

    /* fill in some pseudo-header fields */

    memcpy(ip->source, __local_ip_addr, sizeof(ip_addr_t));

    memcpy(ip->destination, s->his_addr.ip_addr, sizeof(ip_addr_t));

    ip->protocol = IP_PROTO_TCP;

    /* another pseudo-header field */

    ip->length = htons(sizeof(tcp_header_t));

    /* compute tcp checksum */

    cksum = __sum((word *)tcp, sizeof(*tcp), __pseudo_sum(ip));

    tcp->checksum = htons(cksum);

    __ip_send(&ack_pkt, IP_PROTO_TCP, &s->his_addr);

}

/*

 * Send a reset for a bogus incoming segment.

 */

static void

send_reset(pktbuf_t *pkt, ip_route_t *r)

{

    ip_header_t   *ip = pkt->ip_hdr;

    tcp_header_t  *tcp = pkt->tcp_hdr;

    dword         seq, ack;

    word          src, dest;

    word          cksum;

    seq = ntohl(tcp->acknum);

    ack = ntohl(tcp->seqnum);

    src = ntohs(tcp->dest_port);

    dest = ntohs(tcp->src_port);

    tcp = (tcp_header_t *)(ip + 1);

    pkt->pkt_bytes = sizeof(tcp_header_t);

    /* tcp header */

    tcp->hdr_len = 5;

    tcp->reserved = 0;

    tcp->seqnum = htonl(seq);

    tcp->acknum = htonl(ack);

    tcp->window = htons(1024);

    tcp->urgent = 0;

    tcp->checksum = 0;

    tcp->src_port = htons(src);

    tcp->dest_port = htons(dest);

    tcp->flags = TCP_FLAG_RST | TCP_FLAG_ACK;

    /* fill in some pseudo-header fields */

    memcpy(ip->source, __local_ip_addr, sizeof(ip_addr_t));

    memcpy(ip->destination, r->ip_addr, sizeof(ip_addr_t));

    ip->protocol = IP_PROTO_TCP;

    ip->length = htons(pkt->pkt_bytes);

    /* compute tcp checksum */

    cksum = __sum((word *)tcp, pkt->pkt_bytes, __pseudo_sum(ip));

    tcp->checksum = htons(cksum);

    __ip_send(pkt, IP_PROTO_TCP, r);

}

/*

 * Remove given socket from socket list.

 */

static void

unlink_socket(tcp_socket_t *s)

{

    tcp_socket_t *prev, *tp;

    for (prev = NULL, tp = tcp_list; tp; prev = tp, tp = tp->next)

        if (tp == s) {

            BSPLOG(bsp_log("unlink tcp socket.\n"));

            if (prev)

                prev->next = s->next;

            else

                tcp_list = s->next;

        }

}

/*

 * Retransmit last packet.

 */

static void

do_retrans(void *p)

{

    BSPLOG(bsp_log("tcp do_retrans.\n"));

    tcp_send((tcp_socket_t *)p, 0, 1);

}

static void

do_close(void *p)

{

    BSPLOG(bsp_log("tcp do_close.\n"));

    /* close connection */

    ((tcp_socket_t *)p)->state = _CLOSED;

    unlink_socket(p);

}

static void

free_rxlist(tcp_socket_t *s)

{

    pktbuf_t *p;

    BSPLOG(bsp_log("tcp free_rxlist.\n"));

    while ((p = s->rxlist) != NULL) {

        s->rxlist = p->next;

        __pktbuf_free(p);

    }

}

/*

 * Handle a conection reset.

 */

static void

do_reset(tcp_socket_t *s)

{

    /* close connection */

    s->state = _CLOSED;

    __timer_cancel(&s->timer);

    free_rxlist(s);

    unlink_socket(s);

}

/*

 * Extract data from incoming tcp segment.

 * Returns true if packet is queued on rxlist, false otherwise.

 */

static int

handle_data(tcp_socket_t *s, pktbuf_t *pkt)

{

    tcp_header_t  *tcp = pkt->tcp_hdr;

    unsigned int  diff, seq;

    int           data_len;

    char          *data_ptr;

    pktbuf_t      *p;

    data_len = pkt->pkt_bytes - (tcp->hdr_len << 2);

    data_ptr = ((char *)tcp)  + (tcp->hdr_len << 2);

    seq = ntohl(tcp->seqnum);

    BSPLOG(bsp_log("tcp data: seq[%x] len[%d].\n", seq, data_len));

    if (SEQ_LE(seq, s->ack)) {

        /*

         * Figure difference between which byte we're expecting and which byte

         * is sent first. Adjust data length and data pointer accordingly.

         */

        diff = s->ack - seq;

        data_len -= diff;

        data_ptr += diff;

        if (data_len > 0) {

            /* queue the new data */

            s->ack += data_len;

            pkt->next = NULL;

            if ((p = s->rxlist) != NULL) {

                while (p->next)

                    p = p->next;

                p->next = pkt;

                BSPLOG(bsp_log("tcp data: Add pkt[%x] len[%d].\n",

                               pkt, data_len));

            } else {

                s->rxlist = pkt;

                s->rxcnt = data_len;

                s->rxptr = data_ptr;

                BSPLOG(bsp_log("tcp data: pkt[%x] len[%d].\n",

                               pkt, data_len));

            }

            return 1;

        }

    }

    return 0;

}

static void

handle_ack(tcp_socket_t *s, pktbuf_t *pkt)

{

    tcp_header_t *tcp = pkt->tcp_hdr;

    dword        ack;

    int          advance;

    char         *dp;

    /* process ack value in packet */

    ack = ntohl(tcp->acknum);

    BSPLOG(bsp_log("Rcvd tcp ACK %x\n", ack));

    if (SEQ_GT(ack, s->seq)) {

        __timer_cancel(&s->timer);

        advance = ack - s->seq;

        if (advance > s->data_bytes)

            advance = s->data_bytes;

        BSPLOG(bsp_log("seq advance %d", advance));

        if (advance > 0) {

            s->seq += advance;

            s->data_bytes -= advance;

            if (s->data_bytes) {

                /* other end ack'd only part of the pkt */

                BSPLOG(bsp_log(" %d bytes left", s->data_bytes));

                dp = (char *)(s->pkt.tcp_hdr + 1);

                memcpy(dp, dp + advance, s->data_bytes);

            }

        }

    }

    BSPLOG(bsp_log("\n"));

}

/*

 * Handle incoming TCP packets.

 */

void

__tcp_handler(pktbuf_t *pkt, ip_route_t *r)

{

    tcp_header_t *tcp = pkt->tcp_hdr;

    ip_header_t  *ip = pkt->ip_hdr;

    tcp_socket_t *prev,*s;

    dword        ack;

    int          queued = 0;

    /* set length for pseudo sum calculation */

    ip->length = htons(pkt->pkt_bytes);

    if (__sum((word *)tcp, pkt->pkt_bytes, __pseudo_sum(ip)) == 0) {

        for (prev = NULL, s = tcp_list; s; prev = s, s = s->next) {

            if (s->our_port == ntohs(tcp->dest_port)) {

                if (s->his_port == 0)

                    break;

                if (s->his_port == ntohs(tcp->src_port) &&

                    !memcmp(r->ip_addr, s->his_addr.ip_addr, sizeof(ip_addr_t)))

                    break;

            }

        }

        if (s) {

            /* found the socket this packet belongs to */

            /* refresh his ethernet address */

            memcpy(s->his_addr.enet_addr, r->enet_addr, sizeof(enet_addr_t));

            if (s->state != _SYN_RCVD && tcp->flags & TCP_FLAG_RST) {

                BSPLOG(bsp_log("TCP_FLAG_RST rcvd\n"));

                do_reset(s);

                __pktbuf_free(pkt);

                return;

            }

            switch (s->state) {

              case _SYN_SENT:

                /* active open not supported */

                  if (tcp->flags != (TCP_FLAG_SYN | TCP_FLAG_ACK)) {

                      do_reset(s);

                      __pktbuf_free(pkt);

                      return;

                  }

                  s->state = _ESTABLISHED;

                  s->ack = ntohl(tcp->seqnum) + 1;

                  s->seq = ntohl(tcp->acknum);

                  send_ack(s);

                break;

              case _LISTEN:

                if (tcp->flags & TCP_FLAG_SYN) {

                    s->state = _SYN_RCVD;

                    s->ack = ntohl(tcp->seqnum) + 1;

                    s->his_port = ntohs(tcp->src_port);

                    memcpy(s->his_addr.ip_addr, r->ip_addr, sizeof(ip_addr_t));

                    s->data_bytes = 0;

                    BSPLOG(bsp_log("SYN from %d.%d.%d.%d:%d (seq %x)\n",

                               s->his_addr.ip_addr[0],s->his_addr.ip_addr[1],

                               s->his_addr.ip_addr[2],s->his_addr.ip_addr[3],

                               s->his_port, ntohl(tcp->seqnum)));

                    tcp_send(s, TCP_FLAG_SYN | TCP_FLAG_ACK, 0);

                }

                else

                    send_reset(pkt, r);

                break;

              case _SYN_RCVD:

                BSPLOG(bsp_log("_SYN_RCVD timer cancel.\n"));

                __timer_cancel(&s->timer);

                /* go back to _LISTEN state if reset */

                if (tcp->flags & TCP_FLAG_RST) {

                    s->state = _LISTEN;

                    BSPLOG(bsp_log("_SYN_RCVD --> _LISTEN\n"));

                } else if (tcp->flags & TCP_FLAG_SYN) {

                    /* apparently our SYN/ACK was lost? */

                    tcp_send(s, 0, 1);

                    BSPLOG(bsp_log("retransmitting SYN/ACK\n"));

                } else if ((tcp->flags & TCP_FLAG_ACK) &&

                           ntohl(tcp->acknum) == (s->seq + 1)) {

                    /* we've established the connection */

                    s->state = _ESTABLISHED;

                    s->seq++;

                    BSPLOG(bsp_log("ACK received - connection established\n"));

                }

                break;

              case _ESTABLISHED:

              case _CLOSE_WAIT:

                ack = s->ack;  /* save original ack */

                if (tcp->flags & TCP_FLAG_ACK)

                    handle_ack(s, pkt);

                queued = handle_data(s, pkt);

                if ((tcp->flags & TCP_FLAG_FIN) &&

                    ntohl(tcp->seqnum) == s->ack) {

                    BSPLOG(bsp_log("FIN received - going to _CLOSE_WAIT\n"));

                    s->ack++;

                    s->state = _CLOSE_WAIT;

                }

                /*

                 * Send an ack if neccessary.

                 */

                if (s->ack != ack || pkt->pkt_bytes > (tcp->hdr_len << 2))

                    send_ack(s);

                break;

              case _LAST_ACK:

                if (tcp->flags & TCP_FLAG_ACK) {

                    handle_ack(s, pkt);

                    if (ntohl(tcp->acknum) == (s->seq + 1)) {

                        BSPLOG(bsp_log("_LAST_ACK --> _CLOSED\n"));

                        s->state = _CLOSED;

                        unlink_socket(s);

                    }

                }

                break;

              case _FIN_WAIT_1:

                if (tcp->flags & TCP_FLAG_ACK) {

                    handle_ack(s, pkt);

                    if (ntohl(tcp->acknum) == (s->seq + 1)) {

                        /* got ACK for FIN packet */

                        s->seq++;

                        if (tcp->flags & TCP_FLAG_FIN) {

                            BSPLOG(bsp_log("_FIN_WAIT_1 --> _TIME_WAIT\n"));

                            s->ack++;

                            s->state = _TIME_WAIT;

                            send_ack(s);

                        } else {

                            s->state = _FIN_WAIT_2;

                            BSPLOG(bsp_log("_FIN_WAIT_1 --> _FIN_WAIT_2\n"));

                        }

                        break; /* All done for now */

                    }

                }

                /* At this point, no ACK for FIN has been seen, so check for

                   simultaneous close */

                if (tcp->flags & TCP_FLAG_FIN) {

                    BSPLOG(bsp_log("_FIN_WAIT_1 --> _CLOSING\n"));

                    __timer_cancel(&s->timer);

                    s->ack++;

                    s->state = _CLOSING;

                    /* FIN is resent so the timeout and retry for this packet

                       will also take care of timeout and resend of the

                       previously sent FIN (which got us to FIN_WAIT_1). While

                       not technically correct, resending FIN only causes a

                       duplicate FIN (same sequence number) which should be

                       ignored by the other end. */

                    tcp_send(s, TCP_FLAG_FIN | TCP_FLAG_ACK, 0);

                }

                break;

              case _FIN_WAIT_2:

                queued = handle_data(s, pkt);

                if (tcp->flags & TCP_FLAG_FIN) {

                    BSPLOG(bsp_log("_FIN_WAIT_2 --> _TIME_WAIT\n"));

                    s->ack++;

                    s->state = _TIME_WAIT;

                    send_ack(s);

                }

                break;

              case _CLOSING:

                if (tcp->flags & TCP_FLAG_ACK) {

                    handle_ack(s, pkt);

                    if (ntohl(tcp->acknum) == (s->seq + 1)) {

                        /* got ACK for FIN packet */

                        BSPLOG(bsp_log("_CLOSING --> _TIME_WAIT\n"));

                        __timer_cancel(&s->timer);

                        s->state = _TIME_WAIT;

                    }

                }

                break;

              case _TIME_WAIT:

                BSPLOG(bsp_log("_TIME_WAIT resend.\n"));

                if (tcp->flags & TCP_FLAG_FIN)

                    tcp_send(s, 0, 1); /* just resend ack */

                break;

            }

        } else {

            BSPLOG(bsp_log("Unexpected segment from: %d.%d.%d.%d:%d\n",

                           r->ip_addr[0], r->ip_addr[1], r->ip_addr[3],

                           r->ip_addr[4], ntohs(tcp->src_port)));

            send_reset(pkt, r);

        }

    }

    if (!queued)

        __pktbuf_free(pkt);

}

void

__tcp_poll(void)

{

    __enet_poll();

    MS_TICKS_DELAY();

    __timer_poll();

}

int

__tcp_listen(tcp_socket_t *s, word port)

{

    BSPLOG(bsp_log("tcp_listen: s[%p] port[%x]\n", s, port));

    memset(s, 0, sizeof(tcp_socket_t));

    s->state    = _LISTEN;

    s->our_port = port;

    s->pkt.buf = (word *)s->pktbuf;

    s->pkt.bufsize = ETH_MAX_PKTLEN;

    s->pkt.ip_hdr  = (ip_header_t *)s->pkt.buf;

    s->pkt.tcp_hdr = (tcp_header_t *)(s->pkt.ip_hdr + 1);