src/net/tcp.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <byteswap.h>
   6 #include <timer.h>
   7 #include <vsprintf.h>
   8 #include <gpxe/pkbuff.h>
   9 #include <gpxe/retry.h>
  10 #include <gpxe/tcpip.h>
  11 #include <gpxe/tcp.h>
  12
  13 /** @file
  14  *
  15  * TCP protocol
  16  *
  17  */
  18
  19 static void tcp_expired ( struct retry_timer *timer, int over );
  20 static int tcp_senddata_conn ( struct tcp_connection *conn, int force_send );
  21
  22 /**
  23  * A TCP connection
  24  *
  25  * This data structure represents the internal state of a TCP
  26  * connection.  It is kept separate from @c struct @c tcp_application
  27  * because the internal state is still required for some time after
  28  * the application closes the connection.
  29  */
  30 struct tcp_connection {
  31         /** List of TCP connections */
  32         struct list_head list;
  33         /** The associated TCP application, if any */
  34         struct tcp_application *app;
  35
  36         /** Remote socket address */
  37         struct sockaddr_tcpip peer;
  38         /** Local port, in network byte order */
  39         uint16_t local_port;
  40
  41         /** Current TCP state */
  42         unsigned int tcp_state;
  43         /** Previous TCP state
  44          *
  45          * Maintained only for debug messages
  46          */
  47         unsigned int prev_tcp_state;
  48         /** Current sequence number
  49          *
  50          * Equivalent to SND.UNA in RFC 793 terminology.
  51          */
  52         uint32_t snd_seq;
  53         /** Unacknowledged sequence count
  54          *
  55          * Equivalent to (SND.NXT-SND.UNA) in RFC 793 terminology.
  56          */
  57         uint32_t snd_sent;
  58         /** Send window
  59          *
  60          * Equivalent to SND.WND in RFC 793 terminology
  61          */
  62         uint32_t snd_win;
  63         /** Current acknowledgement number
  64          *
  65          * Equivalent to RCV.NXT in RFC 793 terminology.
  66          */
  67         uint32_t rcv_ack;
  68
  69         /** Transmit packet buffer
  70          *
  71          * This buffer is allocated prior to calling the application's
  72          * senddata() method, to provide temporary storage space.
  73          */
  74         struct pk_buff *tx_pkb;
  75         /** Retransmission timer */
  76         struct retry_timer timer;
  77 };
  78
  79 /**
  80  * List of registered TCP connections
  81  */
  82 static LIST_HEAD ( tcp_conns );
  83
  84 /**
  85  * Name TCP state
  86  *
  87  * @v state             TCP state
  88  * @ret name            Name of TCP state
  89  */
  90 static inline __attribute__ (( always_inline )) const char *
  91 tcp_state ( int state ) {
  92         switch ( state ) {
  93         case TCP_CLOSED:                return "CLOSED";
  94         case TCP_LISTEN:                return "LISTEN";
  95         case TCP_SYN_SENT:              return "SYN_SENT";
  96         case TCP_SYN_RCVD:              return "SYN_RCVD";
  97         case TCP_ESTABLISHED:           return "ESTABLISHED";
  98         case TCP_FIN_WAIT_1:            return "FIN_WAIT_1";
  99         case TCP_FIN_WAIT_2:            return "FIN_WAIT_2";
 100         case TCP_CLOSING_OR_LAST_ACK:   return "CLOSING/LAST_ACK";
 101         case TCP_TIME_WAIT:             return "TIME_WAIT";
 102         case TCP_CLOSE_WAIT:            return "CLOSE_WAIT";
 103         default:                        return "INVALID";
 104         }
 105 }
 106
 107 /**
 108  * Dump TCP state transition
 109  *
 110  * @v conn              TCP connection
 111  */
 112 static inline __attribute__ (( always_inline )) void
 113 tcp_dump_state ( struct tcp_connection *conn ) {
 114
 115         if ( conn->tcp_state != conn->prev_tcp_state ) {
 116                 DBGC ( conn, "TCP %p transitioned from %s to %s\n", conn,
 117                        tcp_state ( conn->prev_tcp_state ),
 118                        tcp_state ( conn->tcp_state ) );
 119         }
 120         conn->prev_tcp_state = conn->tcp_state;
 121 }
 122
 123 /**
 124  * Dump TCP flags
 125  *
 126  * @v flags             TCP flags
 127  */
 128 static inline __attribute__ (( always_inline )) void
 129 tcp_dump_flags ( struct tcp_connection *conn, unsigned int flags ) {
 130         if ( flags & TCP_RST )
 131                 DBGC ( conn, " RST" );
 132         if ( flags & TCP_SYN )
 133                 DBGC ( conn, " SYN" );
 134         if ( flags & TCP_PSH )
 135                 DBGC ( conn, " PSH" );
 136         if ( flags & TCP_FIN )
 137                 DBGC ( conn, " FIN" );
 138         if ( flags & TCP_ACK )
 139                 DBGC ( conn, " ACK" );
 140 }
 141
 142 /**
 143  * Allocate TCP connection
 144  *
 145  * @ret conn            TCP connection, or NULL
 146  *
 147  * Allocates TCP connection and adds it to the TCP connection list.
 148  */
 149 static struct tcp_connection * alloc_tcp ( void ) {
 150         struct tcp_connection *conn;
 151
 152         conn = calloc ( 1, sizeof ( *conn ) );
 153         if ( conn ) {
 154                 DBGC ( conn, "TCP %p allocated\n", conn );
 155                 conn->tcp_state = conn->prev_tcp_state = TCP_CLOSED;
 156                 conn->snd_seq = random();
 157                 conn->timer.expired = tcp_expired;
 158                 list_add ( &conn->list, &tcp_conns );
 159         }
 160         return conn;
 161 }
 162
 163 /**
 164  * Free TCP connection
 165  *
 166  * @v conn              TCP connection
 167  *
 168  * Removes connection from TCP connection list and frees the data
 169  * structure.
 170  */
 171 static void free_tcp ( struct tcp_connection *conn ) {
 172
 173         assert ( conn );
 174         assert ( conn->tcp_state == TCP_CLOSED );
 175         assert ( conn->app == NULL );
 176
 177         stop_timer ( &conn->timer );
 178         list_del ( &conn->list );
 179         free ( conn );
 180         DBGC ( conn, "TCP %p freed\n", conn );
 181 }
 182
 183 /**
 184  * Associate TCP connection with application
 185  *
 186  * @v conn              TCP connection
 187  * @v app               TCP application
 188  */
 189 static void tcp_associate ( struct tcp_connection *conn,
 190                             struct tcp_application *app ) {
 191         assert ( conn->app == NULL );
 192         assert ( app->conn == NULL );
 193         conn->app = app;
 194         app->conn = conn;
 195         DBGC ( conn, "TCP %p associated with application %p\n", conn, app );
 196 }
 197
 198 /**
 199  * Disassociate TCP connection from application
 200  *
 201  * @v conn              TCP connection
 202  */
 203 static void tcp_disassociate ( struct tcp_connection *conn ) {
 204         struct tcp_application *app = conn->app;
 205
 206         if ( app ) {
 207                 assert ( app->conn == conn );
 208                 conn->app = NULL;
 209                 app->conn = NULL;
 210                 DBGC ( conn, "TCP %p disassociated from application %p\n",
 211                        conn, app );
 212         }
 213 }
 214
 215 /**
 216  * Abort TCP connection
 217  *
 218  * @v conn              TCP connection
 219  * @v send_rst          Send a RST after closing
 220  * @v rc                Reason code
 221  */
 222 static void tcp_abort ( struct tcp_connection *conn, int send_rst, int rc ) {
 223         struct tcp_application *app = conn->app;
 224
 225         /* Transition to CLOSED */
 226         conn->tcp_state = TCP_CLOSED;
 227         tcp_dump_state ( conn );
 228
 229         /* Send RST if requested to do so */
 230         if ( send_rst )
 231                 tcp_senddata_conn ( conn, 1 );
 232
 233         /* Break association between application and connection */
 234         tcp_disassociate ( conn );
 235
 236         /* Free the connection */
 237         free_tcp ( conn );
 238
 239         /* Notify application */
 240         if ( app && app->tcp_op->closed )
 241                 app->tcp_op->closed ( app, rc );
 242 }
 243
 244 /**
 245  * Transmit any outstanding data
 246  *
 247  * @v conn              TCP connection
 248  * @v force_send        Force sending of packet
 249  *
 250  * Transmits any outstanding data on the connection.  If the
 251  * connection is in a connected state, the application's senddata()
 252  * method will be called to generate the data payload, if any.
 253  *
 254  * Note that even if an error is returned, the retransmission timer
 255  * will have been started if necessary, and so the stack will
 256  * eventually attempt to retransmit the failed packet.
 257  */
 258 static int tcp_senddata_conn ( struct tcp_connection *conn, int force_send ) {
 259         struct tcp_application *app = conn->app;
 260         struct pk_buff *pkb;
 261         struct tcp_header *tcphdr;
 262         struct tcp_mss_option *mssopt;
 263         void *payload;
 264         unsigned int flags;
 265         size_t len;
 266         size_t seq_len;
 267         int rc;
 268
 269         /* Allocate space to the TX buffer */
 270         pkb = alloc_pkb ( MAX_PKB_LEN );
 271         if ( ! pkb ) {
 272                 DBGC ( conn, "TCP %p could not allocate data buffer\n", conn );
 273                 /* Start the retry timer so that we attempt to
 274                  * retransmit this packet later.  (Start it
 275                  * unconditionally, since without a packet buffer we
 276                  * can't call the senddata() callback, and so may not
 277                  * be able to tell whether or not we have something
 278                  * that actually needs to be retransmitted).
 279                  */
 280                 start_timer ( &conn->timer );
 281                 return -ENOMEM;
 282         }
 283         pkb_reserve ( pkb, MAX_HDR_LEN );
 284
 285         /* If we are connected, call the senddata() method, which may
 286          * call tcp_send() to queue up a data payload.
 287          */
 288         if ( TCP_CAN_SEND_DATA ( conn->tcp_state ) &&
 289              app && app->tcp_op->senddata ) {
 290                 conn->tx_pkb = pkb;
 291                 app->tcp_op->senddata ( app, pkb->data, pkb_tailroom ( pkb ) );
 292                 conn->tx_pkb = NULL;
 293         }
 294
 295         /* Truncate payload length to fit transmit window */
 296         len = pkb_len ( pkb );
 297         if ( len > conn->snd_win )
 298                 len = conn->snd_win;
 299
 300         /* Calculate amount of sequence space that this transmission
 301          * consumes.  (SYN or FIN consume one byte, and we can never
 302          * send both at once).
 303          */
 304         seq_len = len;
 305         flags = TCP_FLAGS_SENDING ( conn->tcp_state );
 306         assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) );
 307         if ( flags & ( TCP_SYN | TCP_FIN ) )
 308                 seq_len++;
 309         conn->snd_sent = seq_len;
 310
 311         /* If we have nothing to transmit, drop the packet */
 312         if ( ( seq_len == 0 ) && ! force_send ) {
 313                 free_pkb ( pkb );
 314                 return 0;
 315         }
 316
 317         /* If we are transmitting anything that requires
 318          * acknowledgement (i.e. consumes sequence space), start the
 319          * retransmission timer.
 320          */
 321         if ( seq_len )
 322                 start_timer ( &conn->timer );
 323
 324         /* Fill up the TCP header */
 325         payload = pkb->data;
 326         if ( flags & TCP_SYN ) {
 327                 mssopt = pkb_push ( pkb, sizeof ( *mssopt ) );
 328                 mssopt->kind = TCP_OPTION_MSS;
 329                 mssopt->length = sizeof ( *mssopt );
 330                 mssopt->mss = htons ( TCP_MSS );
 331         }
 332         tcphdr = pkb_push ( pkb, sizeof ( *tcphdr ) );
 333         memset ( tcphdr, 0, sizeof ( *tcphdr ) );
 334         tcphdr->src = conn->local_port;
 335         tcphdr->dest = conn->peer.st_port;
 336         tcphdr->seq = htonl ( conn->snd_seq );
 337         tcphdr->ack = htonl ( conn->rcv_ack );
 338         tcphdr->hlen = ( ( payload - pkb->data ) << 2 );
 339         tcphdr->flags = flags;
 340         tcphdr->win = htons ( TCP_WINDOW_SIZE );
 341         tcphdr->csum = tcpip_chksum ( pkb->data, pkb_len ( pkb ) );
 342
 343         /* Dump header */
 344         DBGC ( conn, "TCP %p TX %d->%d %08lx..%08lx           %08lx %4zd",
 345                conn, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
 346                ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) + seq_len ),
 347                ntohl ( tcphdr->ack ), len );
 348         tcp_dump_flags ( conn, tcphdr->flags );
 349         DBGC ( conn, "\n" );
 350
 351         /* Transmit packet */
 352         rc = tcpip_tx ( pkb, &tcp_protocol, &conn->peer, NULL, &tcphdr->csum );
 353
 354         /* If we got -ENETUNREACH, kill the connection immediately
 355          * because there is no point retrying.  This isn't strictly
 356          * necessary (since we will eventually time out anyway), but
 357          * it avoids irritating needless delays.  Don't do this for
 358          * RST packets transmitted on connection abort, to avoid a
 359          * potential infinite loop.
 360          */
 361         if ( ( ! ( conn->tcp_state & TCP_STATE_SENT ( TCP_RST ) ) ) &&
 362              ( rc == -ENETUNREACH ) ) {
 363                 DBGC ( conn, "TCP %p aborting after TX failed: %s\n",
 364                        conn, strerror ( rc ) );
 365                 tcp_abort ( conn, 0, rc );
 366         }
 367
 368         return rc;
 369 }
 370
 371 /**
 372  * Transmit any outstanding data
 373  *
 374  * @v conn      TCP connection
 375  *
 376  * This function allocates space to the transmit buffer and invokes
 377  * the senddata() callback function, to allow the application to
 378  * transmit new data.
 379  */
 380 int tcp_senddata ( struct tcp_application *app ) {
 381         struct tcp_connection *conn = app->conn;
 382
 383         /* Check connection actually exists */
 384         if ( ! conn ) {
 385                 DBG ( "TCP app %p has no connection\n", app );
 386                 return -ENOTCONN;
 387         }
 388
 389         return tcp_senddata_conn ( conn, 0 );
 390 }
 391
 392 /**
 393  * Transmit data
 394  *
 395  * @v app               TCP application
 396  * @v data              Data to be sent
 397  * @v len               Length of the data
 398  * @ret rc              Return status code
 399  *
 400  * This function queues data to be sent via the TCP connection.  It
 401  * can be called only in the context of an application's senddata()
 402  * method.
 403  */
 404 int tcp_send ( struct tcp_application *app, const void *data, size_t len ) {
 405         struct tcp_connection *conn = app->conn;
 406         struct pk_buff *pkb;
 407
 408         /* Check connection actually exists */
 409         if ( ! conn ) {
 410                 DBG ( "TCP app %p has no connection\n", app );
 411                 return -ENOTCONN;
 412         }
 413
 414         /* Check that we have a packet buffer to fill */
 415         pkb = conn->tx_pkb;
 416         if ( ! pkb ) {
 417                 DBG ( "TCP app %p tried to send data outside of the "
 418                       "senddata() method\n", app );
 419                 return -EINVAL;
 420         }
 421
 422         /* Truncate length to fit packet buffer */
 423         if ( len > pkb_tailroom ( pkb ) )
 424                 len = pkb_tailroom ( pkb );
 425
 426         /* Copy payload */
 427         memmove ( pkb_put ( pkb, len ), data, len );
 428
 429         return 0;
 430 }
 431
 432 /**
 433  * Retransmission timer expired
 434  *
 435  * @v timer     Retry timer
 436  * @v over      Failure indicator
 437  */
 438 static void tcp_expired ( struct retry_timer *timer, int over ) {
 439         struct tcp_connection *conn =
 440                 container_of ( timer, struct tcp_connection, timer );
 441         int graceful_close = TCP_CLOSED_GRACEFULLY ( conn->tcp_state );
 442
 443         DBGC ( conn, "TCP %p timer %s in %s\n", conn,
 444                ( over ? "expired" : "fired" ), tcp_state ( conn->tcp_state ) );
 445
 446         assert ( ( conn->tcp_state == TCP_SYN_SENT ) ||
 447                  ( conn->tcp_state == TCP_SYN_RCVD ) ||
 448                  ( conn->tcp_state == TCP_ESTABLISHED ) ||
 449                  ( conn->tcp_state == TCP_FIN_WAIT_1 ) ||
 450                  ( conn->tcp_state == TCP_TIME_WAIT ) ||
 451                  ( conn->tcp_state == TCP_CLOSE_WAIT ) ||
 452                  ( conn->tcp_state == TCP_CLOSING_OR_LAST_ACK ) );
 453
 454         if ( over || graceful_close ) {
 455                 /* If we have finally timed out and given up, or if
 456                  * this is the result of a graceful close, terminate
 457                  * the connection
 458                  */
 459                 tcp_abort ( conn, 1, -ETIMEDOUT );
 460         } else {
 461                 /* Otherwise, retransmit the packet */
 462                 tcp_senddata_conn ( conn, 0 );
 463         }
 464 }
 465
 466 /**
 467  * Send RST response to incoming packet
 468  *
 469  * @v in_tcphdr         TCP header of incoming packet
 470  * @ret rc              Return status code
 471  */
 472 static int tcp_send_reset ( struct tcp_connection *conn,
 473                             struct tcp_header *in_tcphdr ) {
 474         struct pk_buff *pkb;
 475         struct tcp_header *tcphdr;
 476
 477         /* Allocate space for dataless TX buffer */
 478         pkb = alloc_pkb ( MAX_HDR_LEN );
 479         if ( ! pkb ) {
 480                 DBGC ( conn, "TCP %p could not allocate data buffer\n", conn );
 481                 return -ENOMEM;
 482         }
 483         pkb_reserve ( pkb, MAX_HDR_LEN );
 484
 485         /* Construct RST response */
 486         tcphdr = pkb_push ( pkb, sizeof ( *tcphdr ) );
 487         memset ( tcphdr, 0, sizeof ( *tcphdr ) );
 488         tcphdr->src = in_tcphdr->dest;
 489         tcphdr->dest = in_tcphdr->src;
 490         tcphdr->seq = in_tcphdr->ack;
 491         tcphdr->ack = in_tcphdr->seq;
 492         tcphdr->hlen = ( ( sizeof ( *tcphdr ) / 4 ) << 4 );
 493         tcphdr->flags = ( TCP_RST | TCP_ACK );
 494         tcphdr->win = htons ( TCP_WINDOW_SIZE );
 495         tcphdr->csum = tcpip_chksum ( pkb->data, pkb_len ( pkb ) );
 496
 497         /* Dump header */
 498         DBGC ( conn, "TCP %p TX %d->%d %08lx..%08lx           %08lx %4zd",
 499                conn, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
 500                ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) ),
 501                ntohl ( tcphdr->ack ), 0 );
 502         tcp_dump_flags ( conn, tcphdr->flags );
 503         DBGC ( conn, "\n" );
 504
 505         /* Transmit packet */
 506         return tcpip_tx ( pkb, &tcp_protocol, &conn->peer,
 507                           NULL, &tcphdr->csum );
 508 }
 509
 510 /**
 511  * Identify TCP connection by local port number
 512  *
 513  * @v local_port        Local port (in network-endian order)
 514  * @ret conn            TCP connection, or NULL
 515  */
 516 static struct tcp_connection * tcp_demux ( uint16_t local_port ) {
 517         struct tcp_connection *conn;
 518
 519         list_for_each_entry ( conn, &tcp_conns, list ) {
 520                 if ( conn->local_port == local_port )
 521                         return conn;
 522         }
 523         return NULL;
 524 }
 525
 526 /**
 527  * Handle TCP received SYN
 528  *
 529  * @v conn              TCP connection
 530  * @v seq               SEQ value (in host-endian order)
 531  * @ret rc              Return status code
 532  */
 533 static int tcp_rx_syn ( struct tcp_connection *conn, uint32_t seq ) {
 534         struct tcp_application *app = conn->app;
 535
 536         /* Synchronise sequence numbers on first SYN */
 537         if ( ! ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) )
 538                 conn->rcv_ack = seq;
 539
 540         /* Ignore duplicate SYN */
 541         if ( ( conn->rcv_ack - seq ) > 0 )
 542                 return 0;
 543
 544         /* Mark SYN as received and start sending ACKs with each packet */
 545         conn->tcp_state |= ( TCP_STATE_SENT ( TCP_ACK ) |
 546                              TCP_STATE_RCVD ( TCP_SYN ) );
 547
 548         /* Acknowledge SYN */
 549         conn->rcv_ack++;
 550
 551         /* Notify application of established connection, if applicable */
 552         if ( ( conn->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) &&
 553              app && app->tcp_op->connected )
 554                 app->tcp_op->connected ( app );
 555
 556         return 0;
 557 }
 558
 559 /**
 560  * Handle TCP received ACK
 561  *
 562  * @v conn              TCP connection
 563  * @v ack               ACK value (in host-endian order)
 564  * @v win               WIN value (in host-endian order)
 565  * @ret rc              Return status code
 566  */
 567 static int tcp_rx_ack ( struct tcp_connection *conn, uint32_t ack,
 568                         uint32_t win ) {
 569         struct tcp_application *app = conn->app;
 570         size_t ack_len = ( ack - conn->snd_seq );
 571         size_t len;
 572         unsigned int acked_flags = 0;
 573
 574         /* Ignore duplicate or out-of-range ACK */
 575         if ( ack_len > conn->snd_sent ) {
 576                 DBGC ( conn, "TCP %p received ACK for [%08lx,%08lx), "
 577                        "sent only [%08lx,%08lx)\n", conn, conn->snd_seq,
 578                        ( conn->snd_seq + ack_len ), conn->snd_seq,
 579                        ( conn->snd_seq + conn->snd_sent ) );
 580                 return -EINVAL;
 581         }
 582
 583         /* If we are sending flags and this ACK acknowledges all
 584          * outstanding sequence points, then it acknowledges the
 585          * flags.  (This works since both SYN and FIN will always be
 586          * the last outstanding sequence point.)
 587          */
 588         len = ack_len;
 589         if ( ack_len == conn->snd_sent ) {
 590                 acked_flags = ( TCP_FLAGS_SENDING ( conn->tcp_state ) &
 591                                 ( TCP_SYN | TCP_FIN ) );
 592                 if ( acked_flags )
 593                         len--;
 594         }
 595
 596         /* Update SEQ and sent counters, and window size */
 597         conn->snd_seq = ack;
 598         conn->snd_sent = 0;
 599         conn->snd_win = win;
 600
 601         /* Stop the retransmission timer */
 602         stop_timer ( &conn->timer );
 603
 604         /* Notify application of acknowledged data, if any */
 605         if ( len && app && app->tcp_op->acked )
 606                 app->tcp_op->acked ( app, len );
 607
 608         /* Mark SYN/FIN as acknowledged if applicable. */
 609         if ( acked_flags )
 610                 conn->tcp_state |= TCP_STATE_ACKED ( acked_flags );
 611
 612         /* Notify application of established connection, if applicable */
 613         if ( ( acked_flags & TCP_SYN ) &&
 614              ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) &&
 615              app && app->tcp_op->connected )
 616                 app->tcp_op->connected ( app );
 617
 618         return 0;
 619 }
 620
 621 /**
 622  * Handle TCP received data
 623  *
 624  * @v conn              TCP connection
 625  * @v seq               SEQ value (in host-endian order)
 626  * @v data              Data buffer
 627  * @v len               Length of data buffer
 628  * @ret rc              Return status code
 629  */
 630 static int tcp_rx_data ( struct tcp_connection *conn, uint32_t seq,
 631                          void *data, size_t len ) {
 632         struct tcp_application *app = conn->app;
 633         size_t already_rcvd;
 634
 635         /* Ignore duplicate data */
 636         already_rcvd = ( conn->rcv_ack - seq );
 637         if ( already_rcvd >= len )
 638                 return 0;
 639         data += already_rcvd;
 640         len -= already_rcvd;
 641
 642         /* Acknowledge new data */
 643         conn->rcv_ack += len;
 644
 645         /* Notify application */
 646         if ( app && app->tcp_op->newdata )
 647                 app->tcp_op->newdata ( app, data, len );
 648
 649         return 0;
 650 }
 651
 652 /**
 653  * Handle TCP received FIN
 654  *
 655  * @v conn              TCP connection
 656  * @v seq               SEQ value (in host-endian order)
 657  * @ret rc              Return status code
 658  */
 659 static int tcp_rx_fin ( struct tcp_connection *conn, uint32_t seq ) {
 660         struct tcp_application *app = conn->app;
 661
 662         /* Ignore duplicate FIN */
 663         if ( ( conn->rcv_ack - seq ) > 0 )
 664                 return 0;
 665
 666         /* Mark FIN as received, acknowledge it, and send our own FIN */
 667         conn->tcp_state |= ( TCP_STATE_RCVD ( TCP_FIN ) |
 668                              TCP_STATE_SENT ( TCP_FIN ) );
 669         conn->rcv_ack++;
 670
 671         /* Break association with application */
 672         tcp_disassociate ( conn );
 673
 674         /* Notify application */
 675         if ( app && app->tcp_op->closed )
 676                 app->tcp_op->closed ( app, 0 );
 677
 678         return 0;
 679 }
 680
 681 /**
 682  * Handle TCP received RST
 683  *
 684  * @v conn              TCP connection
 685  * @v seq               SEQ value (in host-endian order)
 686  * @ret rc              Return status code
 687  */
 688 static int tcp_rx_rst ( struct tcp_connection *conn, uint32_t seq ) {
 689
 690         /* Accept RST only if it falls within the window.  If we have
 691          * not yet received a SYN, then we have no window to test
 692          * against, so fall back to checking that our SYN has been
 693          * ACKed.
 694          */
 695         if ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) {
 696                 if ( ( conn->rcv_ack - seq ) > 0 )
 697                         return 0;
 698         } else {
 699                 if ( ! ( conn->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
 700                         return 0;
 701         }
 702
 703         /* Abort connection without sending a RST */
 704         tcp_abort ( conn, 0, -ECONNRESET );
 705
 706         return -ECONNRESET;
 707 }
 708
 709 /**
 710  * Process received packet
 711  *
 712  * @v pkb               Packet buffer
 713  * @v st_src            Partially-filled source address
 714  * @v st_dest           Partially-filled destination address
 715  * @v pshdr_csum        Pseudo-header checksum
 716  * @ret rc              Return status code
 717   */
 718 static int tcp_rx ( struct pk_buff *pkb,
 719                     struct sockaddr_tcpip *st_src __unused,
 720                     struct sockaddr_tcpip *st_dest __unused,
 721                     uint16_t pshdr_csum ) {
 722         struct tcp_header *tcphdr = pkb->data;
 723         struct tcp_connection *conn;
 724         unsigned int hlen;
 725         uint16_t csum;
 726         uint32_t start_seq;
 727         uint32_t seq;
 728         uint32_t ack;
 729         uint32_t win;
 730         unsigned int flags;
 731         void *data;
 732         size_t len;
 733         int rc;
 734
 735         /* Sanity check packet */
 736         if ( pkb_len ( pkb ) < sizeof ( *tcphdr ) ) {
 737                 DBG ( "TCP packet too short at %d bytes (min %d bytes)\n",
 738                       pkb_len ( pkb ), sizeof ( *tcphdr ) );
 739                 rc = -EINVAL;
 740                 goto done;
 741         }
 742         hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
 743         if ( hlen < sizeof ( *tcphdr ) ) {
 744                 DBG ( "TCP header too short at %d bytes (min %d bytes)\n",
 745                       hlen, sizeof ( *tcphdr ) );
 746                 rc = -EINVAL;
 747                 goto done;
 748         }
 749         if ( hlen > pkb_len ( pkb ) ) {
 750                 DBG ( "TCP header too long at %d bytes (max %d bytes)\n",
 751                       hlen, pkb_len ( pkb ) );
 752                 rc = -EINVAL;
 753                 goto done;
 754         }
 755         csum = tcpip_continue_chksum ( pshdr_csum, pkb->data, pkb_len ( pkb ));
 756         if ( csum != 0 ) {
 757                 DBG ( "TCP checksum incorrect (is %04x including checksum "
 758                       "field, should be 0000)\n", csum );
 759                 rc = -EINVAL;
 760                 goto done;
 761         }
 762
 763         /* Parse parameters from header and strip header */
 764         conn = tcp_demux ( tcphdr->dest );
 765         start_seq = seq = ntohl ( tcphdr->seq );
 766         ack = ntohl ( tcphdr->ack );
 767         win = ntohs ( tcphdr->win );
 768         flags = tcphdr->flags;
 769         data = pkb_pull ( pkb, hlen );
 770         len = pkb_len ( pkb );
 771
 772         /* Dump header */
 773         DBGC ( conn, "TCP %p RX %d<-%d           %08lx %08lx..%08lx %4zd",
 774                conn, ntohs ( tcphdr->dest ), ntohs ( tcphdr->src ),
 775                ntohl ( tcphdr->ack ), ntohl ( tcphdr->seq ),
 776                ( ntohl ( tcphdr->seq ) + len +
 777                  ( ( tcphdr->flags & ( TCP_SYN | TCP_FIN ) ) ? 1 : 0 ) ), len);
 778         tcp_dump_flags ( conn, tcphdr->flags );
 779         DBGC ( conn, "\n" );
 780
 781         /* If no connection was found, send RST */
 782         if ( ! conn ) {
 783                 tcp_send_reset ( conn, tcphdr );
 784                 rc = -ENOTCONN;
 785                 goto done;
 786         }
 787
 788         /* Handle ACK, if present */
 789         if ( flags & TCP_ACK ) {
 790                 if ( ( rc = tcp_rx_ack ( conn, ack, win ) ) != 0 ) {
 791                         tcp_send_reset ( conn, tcphdr );
 792                         goto done;
 793                 }
 794         }
 795
 796         /* Handle SYN, if present */
 797         if ( flags & TCP_SYN ) {
 798                 tcp_rx_syn ( conn, seq );
 799                 seq++;
 800         }
 801
 802         /* Handle RST, if present */
 803         if ( flags & TCP_RST ) {
 804                 if ( ( rc = tcp_rx_rst ( conn, seq ) ) != 0 )
 805                         goto done;
 806         }
 807
 808         /* Handle new data, if any */
 809         tcp_rx_data ( conn, seq, data, len );
 810         seq += len;
 811
 812         /* Handle FIN, if present */
 813         if ( flags & TCP_FIN ) {
 814                 tcp_rx_fin ( conn, seq );
 815                 seq++;
 816         }
 817
 818         /* Dump out any state change as a result of the received packet */
 819         tcp_dump_state ( conn );
 820
 821         /* Send out any pending data.  If peer is expecting an ACK for
 822          * this packet then force sending a reply.
 823          */
 824         tcp_senddata_conn ( conn, ( start_seq != seq ) );
 825
 826         /* If this packet was the last we expect to receive, set up
 827          * timer to expire and cause the connection to be freed.
 828          */
 829         if ( TCP_CLOSED_GRACEFULLY ( conn->tcp_state ) ) {
 830                 conn->timer.timeout = ( 2 * TCP_MSL );
 831                 start_timer ( &conn->timer );
 832         }
 833
 834         rc = 0;
 835  done:
 836         /* Free received packet */
 837         free_pkb ( pkb );
 838         return rc;
 839 }
 840
 841 /**
 842  * Bind TCP connection to local port
 843  *
 844  * @v conn              TCP connection
 845  * @v local_port        Local port (in network byte order), or 0
 846  * @ret rc              Return status code
 847  *
 848  * This function adds the connection to the list of registered TCP
 849  * connections.  If the local port is 0, the connection is assigned an
 850  * available port between 1024 and 65535.
 851  */
 852 static int tcp_bind ( struct tcp_connection *conn, uint16_t local_port ) {
 853         struct tcp_connection *existing;
 854         static uint16_t try_port = 1024;
 855
 856         /* If no port specified, find the first available port */
 857         if ( ! local_port ) {
 858                 for ( ; try_port ; try_port++ ) {
 859                         if ( try_port < 1024 )
 860                                 continue;
 861                         if ( tcp_bind ( conn, htons ( try_port ) ) == 0 )
 862                                 return 0;
 863                 }
 864                 DBGC ( conn, "TCP %p could not bind: no free ports\n", conn );
 865                 return -EADDRINUSE;
 866         }
 867
 868         /* Attempt bind to local port */
 869         list_for_each_entry ( existing, &tcp_conns, list ) {
 870                 if ( existing->local_port == local_port ) {
 871                         DBGC ( conn, "TCP %p could not bind: port %d in use\n",
 872                                conn, ntohs ( local_port ) );
 873                         return -EADDRINUSE;
 874                 }
 875         }
 876         conn->local_port = local_port;
 877
 878         DBGC ( conn, "TCP %p bound to port %d\n", conn, ntohs ( local_port ) );
 879         return 0;
 880 }
 881
 882 /**
 883  * Connect to a remote server
 884  *
 885  * @v app               TCP application
 886  * @v peer              Remote socket address
 887  * @v local_port        Local port number (in network byte order), or 0
 888  * @ret rc              Return status code
 889  *
 890  * This function initiates a TCP connection to the socket address specified in
 891  * peer. It sends a SYN packet to peer. When the connection is established, the
 892  * TCP stack calls the connected() callback function.
 893  */
 894 int tcp_connect ( struct tcp_application *app, struct sockaddr_tcpip *peer,
 895                   uint16_t local_port ) {
 896         struct tcp_connection *conn;
 897         int rc;
 898
 899         /* Application must not already have an open connection */
 900         if ( app->conn ) {
 901                 DBG ( "TCP app %p already open on %p\n", app, app->conn );
 902                 return -EISCONN;
 903         }
 904
 905         /* Allocate connection state storage and add to connection list */
 906         conn = alloc_tcp();
 907         if ( ! conn ) {
 908                 DBG ( "TCP app %p could not allocate connection\n", app );
 909                 return -ENOMEM;
 910         }
 911
 912         /* Bind to peer and to local port */
 913         memcpy ( &conn->peer, peer, sizeof ( conn->peer ) );
 914         if ( ( rc = tcp_bind ( conn, local_port ) ) != 0 ) {
 915                 free_tcp ( conn );
 916                 return rc;
 917         }
 918
 919         /* Associate with application */
 920         tcp_associate ( conn, app );
 921
 922         /* Transition to TCP_SYN_SENT and send the SYN */
 923         conn->tcp_state = TCP_SYN_SENT;
 924         tcp_dump_state ( conn );
 925         tcp_senddata_conn ( conn, 0 );
 926
 927         return 0;
 928 }
 929
 930 /**
 931  * Close the connection
 932  *
 933  * @v app               TCP application
 934  *
 935  * The association between the application and the TCP connection is
 936  * immediately severed, and the TCP application data structure can be
 937  * reused or freed immediately.  The TCP connection will persist until
 938  * the state machine has returned to the TCP_CLOSED state.
 939  */
 940 void tcp_close ( struct tcp_application *app ) {
 941         struct tcp_connection *conn = app->conn;
 942
 943         /* If no connection exists, do nothing */
 944         if ( ! conn )
 945                 return;
 946
 947         /* Break association between application and connection */
 948         tcp_disassociate ( conn );
 949
 950         /* If we have not yet received a SYN (i.e. we are in CLOSED,
 951          * LISTEN or SYN_SENT), just delete the connection
 952          */
 953         if ( ! ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
 954                 conn->tcp_state = TCP_CLOSED;
 955                 tcp_dump_state ( conn );
 956                 free_tcp ( conn );
 957                 return;
 958         }
 959
 960         /* If we have not had our SYN acknowledged (i.e. we are in
 961          * SYN_RCVD), pretend that it has been acknowledged so that we
 962          * can send a FIN without breaking things.
 963          */
 964         if ( ! ( conn->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) )
 965                 tcp_rx_ack ( conn, ( conn->snd_seq + 1 ), 0 );
 966
 967         /* Send a FIN to initiate the close */
 968         conn->tcp_state |= TCP_STATE_SENT ( TCP_FIN );
 969         tcp_dump_state ( conn );
 970         tcp_senddata_conn ( conn, 0 );
 971 }
 972
 973 /** TCP protocol */
 974 struct tcpip_protocol tcp_protocol __tcpip_protocol = {
 975         .name = "TCP",
 976         .rx = tcp_rx,
 977         .tcpip_proto = IP_TCP,
 978 };