src/net/tcp.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <assert.h>
   4 #include <byteswap.h>
   5 #include <latch.h>
   6 #include <errno.h>
   7 #include <gpxe/process.h>
   8 #include <gpxe/init.h>
   9 #include <gpxe/netdevice.h>
  10 #include <gpxe/pkbuff.h>
  11 #include <gpxe/ip.h>
  12 #include <gpxe/tcp.h>
  13 #include <gpxe/tcpip.h>
  14 #include <gpxe/retry.h>
  15 #include "uip/uip.h"
  16
  17 /** @file
  18  *
  19  * TCP protocol
  20  *
  21  * The gPXE TCP stack is currently implemented on top of the uIP
  22  * protocol stack.  This file provides wrappers around uIP so that
  23  * higher-level protocol implementations do not need to talk directly
  24  * to uIP (which has a somewhat baroque API).
  25  *
  26  * Basic operation is to create a #tcp_connection structure, call
  27  * tcp_connect() and then call run_tcpip() in a loop until the
  28  * operation has completed.  The TCP stack will call the various
  29  * methods defined in the #tcp_operations structure in order to send
  30  * and receive data.
  31  *
  32  * See hello.c for a trivial example of a TCP protocol using this
  33  * API.
  34  *
  35  */
  36
  37 #if USE_UIP
  38
  39 /**
  40  * TCP transmit buffer
  41  *
  42  * When a tcp_operations::senddata() method is called, it is
  43  * guaranteed to be able to use this buffer as temporary space for
  44  * constructing the data to be sent.  For example, code such as
  45  *
  46  * @code
  47  *
  48  *     static void my_senddata ( struct tcp_connection *conn, void *buf,
  49  *                               size_t len ) {
  50  *         len = snprintf ( buf, len, "FETCH %s\r\n", filename );
  51  *         tcp_send ( conn, buf + already_sent, len - already_sent );
  52  *     }
  53  *
  54  * @endcode
  55  *
  56  * is allowed, and is probably the best way to deal with
  57  * variably-sized data.
  58  *
  59  * Note that you cannot use this simple mechanism if you want to be
  60  * able to construct single data blocks of more than #len bytes.
  61  */
  62 static void *tcp_buffer = uip_buf + ( 40 + UIP_LLH_LEN );
  63
  64 /** Size of #tcp_buffer */
  65 static size_t tcp_buflen = UIP_BUFSIZE - ( 40 + UIP_LLH_LEN );
  66
  67 /**
  68  * Open a TCP connection
  69  *
  70  * @v conn      TCP connection
  71  *
  72  * This sets up a new TCP connection to the remote host specified in
  73  * tcp_connection::sin.
  74  */
  75 void tcp_connect ( struct tcp_connection *conn ) {
  76         struct uip_conn *uip_conn;
  77         u16_t ipaddr[2];
  78
  79         assert ( conn->sin.sin_addr.s_addr != 0 );
  80         assert ( conn->sin.sin_port != 0 );
  81         assert ( conn->tcp_op != NULL );
  82         assert ( sizeof ( uip_conn->appstate ) == sizeof ( conn ) );
  83
  84         * ( ( uint32_t * ) ipaddr ) = conn->sin.sin_addr.s_addr;
  85         uip_conn = uip_connect ( ipaddr, conn->sin.sin_port );
  86 #warning "Use linked lists so that uip_connect() cannot fail"
  87         assert ( uip_conn != NULL );
  88         *( ( void ** ) uip_conn->appstate ) = conn;
  89 }
  90
  91 /**
  92  * Send data via a TCP connection
  93  *
  94  * @v conn      TCP connection
  95  * @v data      Data to send
  96  * @v len       Length of data
  97  *
  98  * Data will be automatically limited to the current TCP window size.
  99  *
 100  * If retransmission is required, the connection's
 101  * tcp_operations::senddata() method will be called again in order to
 102  * regenerate the data.
 103  */
 104 void tcp_send ( struct tcp_connection *conn __unused,
 105                 const void *data, size_t len ) {
 106
 107         assert ( conn = *( ( void ** ) uip_conn->appstate ) );
 108
 109         if ( len > tcp_buflen )
 110                 len = tcp_buflen;
 111         memmove ( tcp_buffer, data, len );
 112
 113         uip_send ( tcp_buffer, len );
 114 }
 115
 116 /**
 117  * Close a TCP connection
 118  *
 119  * @v conn      TCP connection
 120  */
 121 void tcp_close ( struct tcp_connection *conn __unused ) {
 122         assert ( conn = *( ( void ** ) uip_conn->appstate ) );
 123         uip_close();
 124 }
 125
 126 /**
 127  * uIP TCP application call interface
 128  *
 129  * This is the entry point of gPXE from the point of view of the uIP
 130  * protocol stack.  This function calls the appropriate methods from
 131  * the connection's @tcp_operations table in order to process received
 132  * data, transmit new data etc.
 133  */
 134 void uip_tcp_appcall ( void ) {
 135         struct tcp_connection *conn = *( ( void ** ) uip_conn->appstate );
 136         struct tcp_operations *op = conn->tcp_op;
 137
 138         if ( op->closed ) {
 139                 if ( uip_aborted() )
 140                         op->closed ( conn, -ECONNABORTED );
 141                 if ( uip_timedout() )
 142                         op->closed ( conn, -ETIMEDOUT );
 143                 if ( uip_closed() )
 144                         op->closed ( conn, 0 );
 145         }
 146         if ( uip_connected() && op->connected )
 147                 op->connected ( conn );
 148         if ( uip_acked() && op->acked )
 149                 op->acked ( conn, uip_conn->len );
 150         if ( uip_newdata() && op->newdata )
 151                 op->newdata ( conn, ( void * ) uip_appdata, uip_len );
 152         if ( ( uip_rexmit() || uip_newdata() || uip_acked() ||
 153                uip_connected() || uip_poll() ) && op->senddata )
 154                 op->senddata ( conn, tcp_buffer, tcp_buflen );
 155 }
 156
 157 /* Present here to allow everything to link.  Will go into separate
 158  * udp.c file
 159  */
 160 void uip_udp_appcall ( void ) {
 161 }
 162
 163 /**
 164  * Perform periodic processing of all TCP connections
 165  *
 166  * This allows TCP connections to retransmit data if necessary.
 167  */
 168 static void tcp_periodic ( void ) {
 169         struct pk_buff *pkb;
 170         int i;
 171
 172         for ( i = 0 ; i < UIP_CONNS ; i++ ) {
 173                 uip_periodic ( i );
 174                 if ( uip_len > 0 ) {
 175                         pkb = alloc_pkb ( uip_len + MAX_LL_HEADER_LEN);
 176                         if ( ! pkb )
 177                                 continue;
 178
 179                         pkb_reserve ( pkb, MAX_LL_HEADER_LEN );
 180                         pkb_put ( pkb, uip_len );
 181                         memcpy ( pkb->data, uip_buf, uip_len );
 182
 183                         ipv4_uip_tx ( pkb );
 184                 }
 185         }
 186 }
 187
 188 /**
 189  * Kick a connection into life
 190  *
 191  * @v conn      TCP connection
 192  *
 193  * Call this function when you have new data to send and are not
 194  * already being called as part of TCP processing.
 195  */
 196 void tcp_kick ( struct tcp_connection *conn __unused ) {
 197         /* Just kick all the connections; this will work for now */
 198         tcp_periodic();
 199 }
 200
 201 /**
 202  * Single-step the TCP stack
 203  *
 204  * @v process   TCP process
 205  *
 206  * This calls tcp_periodic() at regular intervals.
 207  */
 208 static void tcp_step ( struct process *process ) {
 209         static unsigned long timeout = 0;
 210
 211         if ( currticks() > timeout ) {
 212                 timeout = currticks() + ( TICKS_PER_SEC / 10 );
 213                 tcp_periodic ();
 214         }
 215
 216         schedule ( process );
 217 }
 218
 219 /** TCP stack process */
 220 static struct process tcp_process = {
 221         .step = tcp_step,
 222 };
 223
 224 /** Initialise the TCP stack */
 225 static void init_tcp ( void ) {
 226         schedule ( &tcp_process );
 227 }
 228
 229 INIT_FN ( INIT_PROCESS, init_tcp, NULL, NULL );
 230
 231 #else
 232
 233 /**
 234  * List of registered TCP connections
 235  */
 236 static LIST_HEAD ( tcp_conns );
 237
 238 /**
 239  * List of TCP states
 240  */
 241 static const char *tcp_states[] = {
 242         "CLOSED",
 243         "LISTEN",
 244         "SYN_SENT",
 245         "SYN_RCVD",
 246         "ESTABLISHED",
 247         "FIN_WAIT_1",
 248         "FIN_WAIT_2",
 249         "CLOSING",
 250         "TIME_WAIT",
 251         "CLOSE_WAIT",
 252         "LAST_ACK",
 253         "INVALID" };
 254
 255 /**
 256  * TCP state transition function
 257  *
 258  * @v conn      TCP connection
 259  * @v nxt_state Next TCP state
 260  */
 261 void tcp_set_flags ( struct tcp_connection *conn ) {
 262
 263         /* Set the TCP flags */
 264         switch ( conn->tcp_state ) {
 265         case TCP_CLOSED:
 266                 if ( conn->tcp_lstate == TCP_SYN_RCVD ) {
 267                         conn->tcp_flags |= TCP_RST;
 268                 }
 269                 break;
 270         case TCP_LISTEN:
 271                 break;
 272         case TCP_SYN_SENT:
 273                 if ( conn->tcp_lstate == TCP_LISTEN ||
 274                      conn->tcp_lstate == TCP_CLOSED ) {
 275                         conn->tcp_flags |= TCP_SYN;
 276                 }
 277                 break;
 278         case TCP_SYN_RCVD:
 279                 if ( conn->tcp_lstate == TCP_LISTEN ||
 280                      conn->tcp_lstate == TCP_SYN_SENT ) {
 281                         conn->tcp_flags |= ( TCP_SYN | TCP_ACK );
 282                 }
 283                 break;
 284         case TCP_ESTABLISHED:
 285                 if ( conn->tcp_lstate == TCP_SYN_SENT ) {
 286                         conn->tcp_flags |= TCP_ACK;
 287                 }
 288                 break;
 289         case TCP_FIN_WAIT_1:
 290                 if ( conn->tcp_lstate == TCP_SYN_RCVD ||
 291                      conn->tcp_lstate == TCP_ESTABLISHED ) {
 292                         conn->tcp_flags |= TCP_FIN;
 293                 }
 294                 break;
 295         case TCP_FIN_WAIT_2:
 296                 break;
 297         case TCP_CLOSING:
 298                 if ( conn->tcp_lstate == TCP_FIN_WAIT_1 ) {
 299                         conn->tcp_flags |= TCP_ACK;
 300                 }
 301                 break;
 302         case TCP_TIME_WAIT:
 303                 if ( conn->tcp_lstate == TCP_FIN_WAIT_1 ||
 304                      conn->tcp_lstate == TCP_FIN_WAIT_2 ) {
 305                         conn->tcp_flags |= TCP_ACK;
 306                 }
 307                 break;
 308         case TCP_CLOSE_WAIT:
 309                 if ( conn->tcp_lstate == TCP_ESTABLISHED ) {
 310                         conn->tcp_flags |= TCP_ACK;
 311                 }
 312                 break;
 313         case TCP_LAST_ACK:
 314                 if ( conn->tcp_lstate == TCP_CLOSE_WAIT ) {
 315                         conn->tcp_flags |= TCP_FIN;
 316                 }
 317                 if ( conn->tcp_lstate == TCP_ESTABLISHED ) {
 318                         conn->tcp_flags |= ( TCP_FIN | TCP_ACK );
 319                 }
 320                 break;
 321         default:
 322                 DBG ( "TCP_INVALID state %d\n", conn->tcp_state );
 323                 return;
 324         }
 325 }
 326
 327 void tcp_trans ( struct tcp_connection *conn, int nxt_state ) {
 328         /* Remember the last state */
 329         conn->tcp_lstate = conn->tcp_state;
 330         conn->tcp_state = nxt_state;
 331
 332         DBG ( "Transition from %s to %s\n", tcp_states[conn->tcp_lstate], tcp_states[conn->tcp_state] );
 333
 334         /* TODO: Check if this check is required */
 335         if ( conn->tcp_lstate == conn->tcp_state ||
 336              conn->tcp_state == TCP_INVALID ) {
 337                 conn->tcp_flags = 0;
 338                 return;
 339         }
 340         tcp_set_flags ( conn );
 341 }
 342
 343 /**
 344  * Dump TCP header
 345  *
 346  * @v tcphdr    TCP header
 347  */
 348 void tcp_dump ( struct tcp_header *tcphdr ) {
 349         DBG ( "TCP %p src:%d dest:%d seq:%lx ack:%lx hlen:%hd flags:%#hx\n",
 350                 tcphdr, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ), ntohl ( tcphdr->seq ),
 351                 ntohl ( tcphdr->ack ), ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ), ( tcphdr->flags & TCP_MASK_FLAGS ) );
 352 }
 353
 354 /**
 355  * Initialize a TCP connection
 356  *
 357  * @v conn      TCP connection
 358  *
 359  * This function assigns initial values to some fields in the connection
 360  * structure. The application should call tcp_init_conn after creating a new
 361  * connection before calling any other "tcp_*" function.
 362  *
 363  * struct tcp_connection my_conn;
 364  * tcp_init_conn ( &my_conn );
 365  * ...
 366  */
 367 void tcp_init_conn ( struct tcp_connection *conn ) {
 368         conn->local_port = 0;
 369         conn->tcp_state = TCP_CLOSED;
 370         conn->tcp_lstate = TCP_INVALID;
 371         conn->tx_pkb = NULL;
 372         conn->tcp_op = NULL;
 373 }
 374
 375 /** Retry timer
 376  *
 377  * @v timer     Retry timer
 378  * @v over      Failure indicator
 379  */
 380 void tcp_expired ( struct retry_timer *timer, int over ) {
 381         struct tcp_connection *conn;
 382         conn = ( struct tcp_connection * ) container_of ( timer,
 383                                         struct tcp_connection, timer );
 384         DBG ( "Timer expired in %s\n", tcp_states[conn->tcp_state] );
 385         switch ( conn->tcp_state ) {
 386         case TCP_SYN_SENT:
 387                 if ( over ) {
 388                         tcp_trans ( conn, TCP_CLOSED );
 389                         DBG ( "Timeout! Connection closed\n" );
 390                         return;
 391                 }
 392                 goto send_tcp_nomsg;
 393         case TCP_SYN_RCVD:
 394                 if ( over ) {
 395                         tcp_trans ( conn, TCP_CLOSED );
 396                         goto send_tcp_nomsg;
 397                 }
 398                 goto send_tcp_nomsg;
 399         case TCP_ESTABLISHED:
 400                 if ( conn->tcp_lstate == TCP_SYN_SENT ) {
 401                         goto send_tcp_nomsg;
 402                 }
 403                 break;
 404         case TCP_CLOSE_WAIT:
 405                 if ( conn->tcp_lstate == TCP_ESTABLISHED ) {
 406                         goto send_tcp_nomsg;
 407                 }
 408                 break;
 409         case TCP_FIN_WAIT_1:
 410         case TCP_FIN_WAIT_2:
 411                 goto send_tcp_nomsg;
 412         case TCP_CLOSING:
 413         case TCP_LAST_ACK:
 414                 if ( conn->tcp_lstate == TCP_CLOSE_WAIT ) {
 415                         goto send_tcp_nomsg;
 416                 }
 417                 return;
 418         case TCP_TIME_WAIT:
 419                 tcp_trans ( conn, TCP_CLOSED );
 420                 return;
 421         }
 422         /* Retransmit the data */
 423         tcp_set_flags ( conn );
 424         tcp_senddata ( conn );
 425         return;
 426
 427   send_tcp_nomsg:
 428         free_pkb ( conn->tx_pkb );
 429         conn->tx_pkb = alloc_pkb ( MIN_PKB_LEN );
 430         pkb_reserve ( conn->tx_pkb, MAX_HDR_LEN );
 431         tcp_set_flags ( conn );
 432         int rc;
 433         if ( ( rc = tcp_send ( conn, TCP_NOMSG, TCP_NOMSG_LEN ) ) != 0 ) {
 434                 DBG ( "Error sending TCP message (rc = %d)\n", rc );
 435         }
 436         return;
 437 }
 438
 439 /**
 440  * Connect to a remote server
 441  *
 442  * @v conn      TCP connection
 443  * @v peer      Remote socket address
 444  *
 445  * This function initiates a TCP connection to the socket address specified in
 446  * peer. It sends a SYN packet to peer. When the connection is established, the
 447  * TCP stack calls the connected() callback function.
 448  */
 449 int tcp_connectto ( struct tcp_connection *conn,
 450                     struct sockaddr_tcpip *peer ) {
 451         int rc;
 452
 453         /* A connection can only be established from the CLOSED state */
 454         if ( conn->tcp_state != TCP_CLOSED ) {
 455                 DBG ( "Error opening connection: Invalid state %s\n",
 456                                 tcp_states[conn->tcp_state] );
 457                 return -EISCONN;
 458         }
 459
 460         /* Add the connection to the set of listening connections */
 461         if ( ( rc = tcp_listen ( conn, conn->local_port ) ) != 0 ) {
 462                 return rc;
 463         }
 464         memcpy ( &conn->peer, peer, sizeof ( conn->peer ) );
 465
 466         /* Initialize the TCP timer */
 467         conn->timer.expired = tcp_expired;
 468
 469         /* Send a SYN packet and transition to TCP_SYN_SENT */
 470         conn->snd_una = random();
 471         tcp_trans ( conn, TCP_SYN_SENT );
 472         /* Allocate space for the packet */
 473         free_pkb ( conn->tx_pkb );
 474         conn->tx_pkb = alloc_pkb ( MIN_PKB_LEN );
 475         pkb_reserve ( conn->tx_pkb, MAX_HDR_LEN );
 476         conn->rcv_win = MAX_PKB_LEN - MAX_HDR_LEN; /* TODO: Is this OK? */
 477         return tcp_send ( conn, TCP_NOMSG, TCP_NOMSG_LEN );
 478 }
 479
 480 int tcp_connect ( struct tcp_connection *conn ) {
 481         return tcp_connectto ( conn, &conn->peer );
 482 }
 483
 484 /**
 485  * Close the connection
 486  *
 487  * @v conn
 488  *
 489  * This function sends a FIN packet to the remote end of the connection. When
 490  * the remote end of the connection ACKs the FIN (FIN consumes one byte on the
 491  * snd stream), the stack invokes the closed() callback function.
 492  */
 493 int tcp_close ( struct tcp_connection *conn ) {
 494         /* A connection can only be closed if it is a connected state */
 495         switch ( conn->tcp_state ) {
 496         case TCP_SYN_RCVD:
 497         case TCP_ESTABLISHED:
 498                 tcp_trans ( conn, TCP_FIN_WAIT_1 );
 499                 if ( conn->tcp_op->closed )
 500                         conn->tcp_op->closed ( conn, CONN_SNDCLOSE ); /* TODO: Check! */
 501                 /* FIN consumes one byte on the snd stream */
 502 //              conn->snd_una++;
 503                 goto send_tcp_nomsg;
 504         case TCP_SYN_SENT:
 505         case TCP_LISTEN:
 506                 /**
 507                  * Since the connection does not expect any packets from the
 508                  * remote end, it can be removed from the set of listening
 509                  * connections.
 510                  */
 511                 list_del ( &conn->list );
 512                 tcp_trans ( conn, TCP_CLOSED );
 513                 if ( conn->tcp_op->closed )
 514                         conn->tcp_op->closed ( conn, CONN_SNDCLOSE );
 515                 return 0;
 516         case TCP_CLOSE_WAIT:
 517                 tcp_trans ( conn, TCP_LAST_ACK );
 518                 if ( conn->tcp_op->closed )
 519                         conn->tcp_op->closed ( conn, CONN_SNDCLOSE ); /* TODO: Check! */
 520                 /* FIN consumes one byte on the snd stream */
 521 //              conn->snd_una++;
 522                 goto send_tcp_nomsg;
 523         default:
 524                 DBG ( "tcp_close(): Invalid state %s\n",
 525                                         tcp_states[conn->tcp_state] );
 526                 return -EPROTO;
 527         }
 528
 529   send_tcp_nomsg:
 530         free_pkb ( conn->tx_pkb );
 531         conn->tx_pkb = alloc_pkb ( MIN_PKB_LEN );
 532         conn->tcp_flags = TCP_FIN;
 533         pkb_reserve ( conn->tx_pkb, MAX_HDR_LEN );
 534         return tcp_send ( conn, TCP_NOMSG, TCP_NOMSG_LEN );
 535 }
 536
 537 /**
 538  * Bind TCP connection to local port
 539  *
 540  * @v conn              TCP connection
 541  * @v local_port        Local port, in network byte order
 542  * @ret rc              Return status code
 543  */
 544 int tcp_bind ( struct tcp_connection *conn, uint16_t local_port ) {
 545         struct tcp_connection *existing;
 546
 547         list_for_each_entry ( existing, &tcp_conns, list ) {
 548                 if ( existing->local_port == local_port )
 549                         return -EADDRINUSE;
 550         }
 551         conn->local_port = local_port;
 552         return 0;
 553 }
 554
 555
 556 /**
 557  * Listen for a packet
 558  *
 559  * @v conn              TCP connection
 560  * @v local_port        Local port, in network byte order
 561  *
 562  * This function adds the connection to a list of registered tcp
 563  * connections. If the local port is 0, the connection is assigned an
 564  * available port between MIN_TCP_PORT and 65535.
 565  */
 566 int tcp_listen ( struct tcp_connection *conn, uint16_t local_port ) {
 567         static uint16_t try_port = 1024;
 568         int rc;
 569
 570 #warning "Fix the port re-use bug"
 571         /* If we re-use the same port, the connection should be reset
 572          * and a new connection set up.  This doesn't happen yet, so
 573          * randomise the port to avoid hitting the problem.
 574          */
 575         try_port = random();
 576
 577         /* If no port specified, find the first available port */
 578         if ( ! local_port ) {
 579                 for ( ; try_port ; try_port++ ) {
 580                         if ( try_port < 1024 )
 581                                 continue;
 582                         if ( tcp_listen ( conn, htons ( try_port ) ) == 0 )
 583                                 return 0;
 584                 }
 585                 return -EADDRINUSE;
 586         }
 587
 588         /* Attempt bind to local port */
 589         if ( ( rc = tcp_bind ( conn, local_port ) ) != 0 )
 590                 return rc;
 591
 592         /* Add to TCP connection list */
 593         list_add ( &conn->list, &tcp_conns );
 594         DBG ( "TCP opened %p on port %d\n", conn, ntohs ( local_port ) );
 595
 596         return 0;
 597 }
 598
 599 /**
 600  * Send data
 601  *
 602  * @v conn      TCP connection
 603  *
 604  * This function allocates space to the transmit buffer and invokes the
 605  * senddata() callback function. It passes the allocated buffer to senddata().
 606  * The applicaion may use this space to write it's data.
 607  */
 608 int tcp_senddata ( struct tcp_connection *conn ) {
 609         /* The connection must be in a state in which the user can send data */
 610         switch ( conn->tcp_state ) {
 611         case TCP_LISTEN:
 612                 tcp_trans ( conn, TCP_SYN_SENT );
 613                 conn->snd_una = random();
 614                 break;
 615         case TCP_ESTABLISHED:
 616         case TCP_CLOSE_WAIT:
 617                 break;
 618         default:
 619                 DBG ( "tcp_senddata: Invalid state %s\n",
 620                                 tcp_states[conn->tcp_state] );
 621                 return -EPROTO;
 622         }
 623
 624         /* Allocate space to the TX buffer */
 625         free_pkb ( conn->tx_pkb );
 626         conn->tx_pkb = alloc_pkb ( MAX_PKB_LEN );
 627         if ( !conn->tx_pkb ) {
 628                 DBG ( "Insufficient memory\n" );
 629                 return -ENOMEM;
 630         }
 631         pkb_reserve ( conn->tx_pkb, MAX_HDR_LEN );
 632         /* Set the advertised window */
 633         conn->rcv_win = pkb_available ( conn->tx_pkb );
 634         /* Call the senddata() call back function */
 635         if ( conn->tcp_op->senddata )
 636                 conn->tcp_op->senddata ( conn, conn->tx_pkb->data,
 637                                          pkb_available ( conn->tx_pkb ) );
 638         /* Send pure ACK if senddata() didn't call tcp_send() */
 639         if ( conn->tx_pkb ) {
 640                 tcp_send ( conn, TCP_NOMSG, TCP_NOMSG_LEN );
 641         }
 642         return 0;
 643 }
 644
 645 /**
 646  * Transmit data
 647  *
 648  * @v conn      TCP connection
 649  * @v data      Data to be sent
 650  * @v len       Length of the data
 651  *
 652  * This function sends data to the peer socket address
 653  */
 654 int tcp_send ( struct tcp_connection *conn, const void *data, size_t len ) {
 655         struct sockaddr_tcpip *peer = &conn->peer;
 656         struct pk_buff *pkb;
 657         int slen;
 658
 659         /* Take ownership of the TX buffer from the connection */
 660         pkb = conn->tx_pkb;
 661         conn->tx_pkb = NULL;
 662
 663         /* Determine the amount of data to be sent */
 664         slen = len < conn->snd_win ? len : conn->snd_win;
 665         /* Copy payload */
 666         memmove ( pkb_put ( pkb, slen ), data, slen );
 667
 668         /* Fill up the TCP header */
 669         struct tcp_header *tcphdr = pkb_push ( pkb, sizeof ( *tcphdr ) );
 670
 671         /* Source port, assumed to be in network byte order in conn */
 672         tcphdr->src = conn->local_port;
 673         /* Destination port, assumed to be in network byte order in peer */
 674         tcphdr->dest = peer->st_port;
 675         tcphdr->seq = htonl ( conn->snd_una );
 676         tcphdr->ack = htonl ( conn->rcv_nxt );
 677         /* Header length, = 0x50 (without TCP options) */
 678         tcphdr->hlen = ( uint8_t ) ( ( sizeof ( *tcphdr ) / 4 ) << 4 );
 679         /* Copy TCP flags, and then reset the variable */
 680         tcphdr->flags = conn->tcp_flags;
 681         conn->tcp_flags = 0;
 682         /* Advertised window, in network byte order */
 683         tcphdr->win = htons ( conn->rcv_win );
 684         /* Set urgent pointer to 0 */
 685         tcphdr->urg = 0;
 686         /* Calculate and store partial checksum, in host byte order */
 687         tcphdr->csum = 0;
 688         tcphdr->csum = tcpip_chksum ( pkb->data, pkb_len ( pkb ) );
 689
 690         /* Dump the TCP header */
 691         tcp_dump ( tcphdr );
 692
 693         /* Start the timer */
 694         if ( ( conn->tcp_state == TCP_ESTABLISHED && conn->tcp_lstate == TCP_SYN_SENT ) ||
 695              ( conn->tcp_state == TCP_LISTEN && conn->tcp_lstate == TCP_SYN_RCVD ) ||
 696              ( conn->tcp_state == TCP_CLOSED && conn->tcp_lstate == TCP_SYN_RCVD ) ||
 697              ( conn->tcp_state == TCP_ESTABLISHED && ( len == 0 ) ) ) {
 698                 // Don't start the timer
 699         } else {
 700                 start_timer ( &conn->timer );
 701         }
 702
 703         /* Transmit packet */
 704         return tcpip_tx ( pkb, &tcp_protocol, peer );
 705 }
 706
 707 /**
 708  * Process received packet
 709  *
 710  * @v pkb       Packet buffer
 711  * @v partial   Partial checksum
 712  */
 713 static int tcp_rx ( struct pk_buff *pkb,
 714                     struct sockaddr_tcpip *st_src __unused,
 715                     struct sockaddr_tcpip *st_dest __unused ) {
 716         struct tcp_connection *conn;
 717         struct tcp_header *tcphdr;
 718         uint32_t acked, toack;
 719         int hlen;
 720         int rc;
 721
 722         /* Sanity check */
 723         if ( pkb_len ( pkb ) < sizeof ( *tcphdr ) ) {
 724                 DBG ( "Packet too short (%d bytes)\n", pkb_len ( pkb ) );
 725                 rc = -EINVAL;
 726                 goto done;
 727         }
 728
 729         /* Process TCP header */
 730         tcphdr = pkb->data;
 731         tcp_dump ( tcphdr );
 732
 733         /* Verify header length */
 734         hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
 735         if ( hlen < sizeof ( *tcphdr ) ) {
 736                 DBG ( "Bad header length (%d bytes)\n", hlen );
 737                 rc = -EINVAL;
 738                 goto done;
 739         }
 740         /* TODO: Parse TCP options */
 741         if ( hlen != sizeof ( *tcphdr ) ) {
 742                 DBG ( "Ignoring TCP options\n" );
 743         }
 744
 745         /* TODO: Verify checksum */
 746
 747         /* Demux TCP connection */
 748         list_for_each_entry ( conn, &tcp_conns, list ) {
 749                 if ( tcphdr->dest == conn->local_port ) {
 750                         goto found_conn;
 751                 }
 752         }
 753
 754         DBG ( "No connection found on port %d\n", ntohs ( tcphdr->dest ) );
 755         rc = 0;
 756         goto done;
 757
 758   found_conn:
 759         /* Stop the timer */
 760         stop_timer ( &conn->timer );
 761
 762         /* Set the advertised window */
 763         conn->snd_win = tcphdr->win;
 764
 765         /* TCP State Machine */
 766         conn->tcp_lstate = conn->tcp_state;
 767         switch ( conn->tcp_state ) {
 768         case TCP_CLOSED:
 769                 DBG ( "tcp_rx(): Invalid state %s\n",
 770                                 tcp_states[conn->tcp_state] );
 771                 rc = -EINVAL;
 772                 goto done;
 773         case TCP_LISTEN:
 774                 if ( tcphdr->flags & TCP_SYN ) {
 775                         tcp_trans ( conn, TCP_SYN_RCVD );
 776                         /* Synchronize the sequence numbers */
 777                         conn->rcv_nxt = ntohl ( tcphdr->seq ) + 1;
 778                         conn->tcp_flags |= TCP_ACK;
 779
 780                         /* Set the sequence number for the snd stream */
 781                         conn->snd_una = random();
 782                         conn->tcp_flags |= TCP_SYN;
 783
 784                         /* Send a SYN,ACK packet */
 785                         goto send_tcp_nomsg;
 786                 }
 787                 /* Unexpected packet */
 788                 goto unexpected;
 789         case TCP_SYN_SENT:
 790                 if ( tcphdr->flags & TCP_SYN ) {
 791                         /* Synchronize the sequence number in rcv stream */
 792                         conn->rcv_nxt = ntohl ( tcphdr->seq ) + 1;
 793                         conn->tcp_flags |= TCP_ACK;
 794
 795                         if ( tcphdr->flags & TCP_ACK ) {
 796                                 tcp_trans ( conn, TCP_ESTABLISHED );
 797                                 /**
 798                                  * Process ACK of SYN. This does not invoke the
 799                                  * acked() callback function.
 800                                  */
 801                                 conn->snd_una = ntohl ( tcphdr->ack );
 802                                 if ( conn->tcp_op->connected )
 803                                         conn->tcp_op->connected ( conn );
 804                                 conn->tcp_flags |= TCP_ACK;
 805                                 tcp_senddata ( conn );
 806                                 rc = 0;
 807                                 goto done;
 808                         } else {
 809                                 tcp_trans ( conn, TCP_SYN_RCVD );
 810                                 conn->tcp_flags |= TCP_SYN;
 811                                 goto send_tcp_nomsg;
 812                         }
 813                 }
 814                 /* Unexpected packet */
 815                 goto unexpected;
 816         case TCP_SYN_RCVD:
 817                 if ( tcphdr->flags & TCP_RST ) {
 818                         tcp_trans ( conn, TCP_LISTEN );
 819                         if ( conn->tcp_op->closed )
 820                                 conn->tcp_op->closed ( conn, CONN_RESTART );
 821                         rc = 0;
 822                         goto done;
 823                 }
 824                 if ( tcphdr->flags & TCP_ACK ) {
 825                         tcp_trans ( conn, TCP_ESTABLISHED );
 826                         /**
 827                          * Process ACK of SYN. It neither invokes the callback
 828                          * function nor does it send an ACK.
 829                          */
 830                         conn->snd_una = tcphdr->ack - 1;
 831                         if ( conn->tcp_op->connected )
 832                                 conn->tcp_op->connected ( conn );
 833                         rc = 0;
 834                         goto done;
 835                 }
 836                 /* Unexpected packet */
 837                 goto unexpected;
 838         case TCP_ESTABLISHED:
 839                 if ( tcphdr->flags & TCP_FIN ) {
 840                         if ( tcphdr->flags & TCP_ACK ) {
 841                                 tcp_trans ( conn, TCP_LAST_ACK );
 842                                 conn->tcp_flags |= TCP_FIN;
 843                         } else {
 844                                 tcp_trans ( conn, TCP_CLOSE_WAIT );
 845                         }
 846                         /* FIN consumes one byte */
 847                         conn->rcv_nxt++;
 848                         conn->tcp_flags |= TCP_ACK;
 849                         /* Send the packet */
 850                         goto send_tcp_nomsg;
 851                 }
 852                 /* Packet might contain data */
 853                 break;
 854         case TCP_FIN_WAIT_1:
 855                 if ( tcphdr->flags & TCP_FIN ) {
 856                         conn->rcv_nxt++;
 857                         conn->tcp_flags |= TCP_ACK;
 858                         if ( conn->tcp_op->closed )
 859                                 conn->tcp_op->closed ( conn, CONN_SNDCLOSE );
 860
 861                         if ( tcphdr->flags & TCP_ACK ) {
 862                                 tcp_trans ( conn, TCP_TIME_WAIT );
 863                         } else {
 864                                 tcp_trans ( conn, TCP_CLOSING );
 865                         }
 866                         /* Send an acknowledgement */
 867                         goto send_tcp_nomsg;
 868                 }
 869                 if ( tcphdr->flags & TCP_ACK ) {
 870                         tcp_trans ( conn, TCP_FIN_WAIT_2 );
 871                 }
 872                 /* Packet might contain data */
 873                 break;
 874         case TCP_FIN_WAIT_2:
 875                 if ( tcphdr->flags & TCP_FIN ) {
 876                         tcp_trans ( conn, TCP_TIME_WAIT );
 877                         /* FIN consumes one byte */
 878                         conn->rcv_nxt++;
 879                         conn->tcp_flags |= TCP_ACK;
 880                         goto send_tcp_nomsg;
 881                 }
 882                 /* Packet might contain data */
 883                 break;
 884         case TCP_CLOSING:
 885                 if ( tcphdr->flags & TCP_ACK ) {
 886                         tcp_trans ( conn, TCP_TIME_WAIT );
 887                         start_timer ( &conn->timer );
 888                         rc = 0;
 889                         goto done;
 890                 }
 891                 /* Unexpected packet */
 892                 goto unexpected;
 893         case TCP_TIME_WAIT:
 894                 /* Unexpected packet */
 895                 goto unexpected;
 896         case TCP_CLOSE_WAIT:
 897                 /* Packet could acknowledge data */
 898                 break;
 899         case TCP_LAST_ACK:
 900                 if ( tcphdr->flags & TCP_ACK ) {
 901                         tcp_trans ( conn, TCP_CLOSED );
 902                         rc = 0;
 903                         goto done;
 904                 }
 905                 /* Unexpected packet */
 906                 goto unexpected;
 907         }
 908
 909         /**
 910          * Any packet reaching this point either contains new data or
 911          * acknowledges previously transmitted data.
 912          */
 913         assert ( ( tcphdr->flags & TCP_ACK ) ||
 914                  pkb_len ( pkb ) > sizeof ( *tcphdr ) );
 915
 916         /**
 917          * Check if the received packet ACKs sent data
 918          */
 919         if ( tcphdr->flags & TCP_ACK ) {
 920                 acked = ntohl ( tcphdr->ack ) - conn->snd_una;
 921                 if ( acked < 0 ) {
 922                         /* Packet ACKs previously ACKed data */
 923                         DBG ( "Previously ACKed data %lx\n",
 924                                                 ntohl ( tcphdr->ack ) );
 925                         rc = 0;
 926                         goto done;
 927                 }
 928                 /* Invoke the acked() callback */
 929                 conn->snd_una += acked;
 930                 if ( conn->tcp_op->acked )
 931                         conn->tcp_op->acked ( conn, acked );
 932         }
 933
 934         /**
 935          * Check if packet contains new data
 936          */
 937         toack = pkb_len ( pkb ) - hlen;
 938         if ( toack >= 0 ) {
 939                 /* Check the sequence number */
 940                 if ( conn->rcv_nxt == ntohl ( tcphdr->seq ) ) {
 941                         conn->rcv_nxt += toack;
 942                         if ( conn->tcp_op->newdata )
 943                                 conn->tcp_op->newdata ( conn, pkb->data + hlen,
 944                                                         toack );
 945                 } else {
 946                         DBG ( "Unexpected sequence number %lx (wanted %lx)\n",
 947                                 ntohl ( tcphdr->ack ), conn->rcv_nxt );
 948                 }
 949                 conn->tcp_flags |= TCP_ACK;
 950         }
 951
 952         /**
 953          * Send data
 954          */
 955         tcp_senddata ( conn );
 956         return 0;
 957
 958   send_tcp_nomsg:
 959         free_pkb ( conn->tx_pkb );
 960         conn->tx_pkb = alloc_pkb ( MIN_PKB_LEN );
 961         pkb_reserve ( conn->tx_pkb, MAX_HDR_LEN );
 962         if ( ( rc = tcp_send ( conn, TCP_NOMSG, TCP_NOMSG_LEN ) ) != 0 ) {
 963                 DBG ( "Error sending TCP message (rc = %d)\n", rc );
 964         }
 965         goto done;
 966
 967   unexpected:
 968         DBG ( "Unexpected packet received in %s with flags = %#hx\n",
 969                         tcp_states[conn->tcp_state], tcphdr->flags & TCP_MASK_FLAGS );
 970         tcp_close ( conn );
 971         free_pkb ( conn->tx_pkb );
 972         conn->tx_pkb = NULL;
 973         rc = -EINVAL;
 974         goto done;
 975
 976  done:
 977         free_pkb ( pkb );
 978         return rc;
 979 }
 980
 981 /** TCP protocol */
 982 struct tcpip_protocol tcp_protocol __tcpip_protocol = {
 983         .name = "TCP",
 984         .rx = tcp_rx,
 985         .tcpip_proto = IP_TCP,
 986         .csum_offset = 16,
 987 };
 988
 989 #endif /* USE_UIP */