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