Don't send a second FIN if we receive a FIN while in FIN_WAIT_2
[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                 DBG ( "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 ( unsigned int flags ) {
129         if ( flags & TCP_RST )
130                 DBG ( " RST" );
131         if ( flags & TCP_SYN )
132                 DBG ( " SYN" );
133         if ( flags & TCP_PSH )
134                 DBG ( " PSH" );
135         if ( flags & TCP_FIN )
136                 DBG ( " FIN" );
137         if ( flags & TCP_ACK )
138                 DBG ( " 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                 DBG ( "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         DBG ( "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         DBG ( "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                 DBG ( "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         size_t len;
233         size_t seq_len;
234
235         /* Allocate space to the TX buffer */
236         pkb = alloc_pkb ( MAX_PKB_LEN );
237         if ( ! pkb ) {
238                 DBG ( "TCP %p could not allocate senddata buffer\n", conn );
239                 /* Start the retry timer so that we attempt to
240                  * retransmit this packet later.  (Start it
241                  * unconditionally, since without a packet buffer we
242                  * can't can the senddata() callback, and so may not
243                  * be able to tell whether or not we have something
244                  * that actually needs to be retransmitted).
245                  */
246                 start_timer ( &conn->timer );
247                 return -ENOMEM;
248         }
249         pkb_reserve ( pkb, MAX_HDR_LEN );
250
251         /* If we are connected, call the senddata() method, which may
252          * call tcp_send() to queue up a data payload.
253          */
254         if ( TCP_CAN_SEND_DATA ( conn->tcp_state ) &&
255              app && app->tcp_op->senddata ) {
256                 conn->tx_pkb = pkb;
257                 app->tcp_op->senddata ( app, pkb->data, pkb_available ( pkb ));
258                 conn->tx_pkb = NULL;
259         }
260
261         /* Calculate amount of sequence space that this transmission
262          * consumes.  (SYN or FIN consume one byte, and we can never
263          * send both at once).
264          */
265         len = pkb_len ( pkb );
266         seq_len = len;
267         assert ( ! ( ( conn->tcp_state & TCP_STATE_SENDING ( TCP_SYN ) ) &&
268                      ( conn->tcp_state & TCP_STATE_SENDING ( TCP_FIN ) ) ) );
269         if ( conn->tcp_state & TCP_STATE_SENDING ( TCP_SYN | TCP_FIN ) )
270                 seq_len++;
271         conn->snd_sent = seq_len;
272
273         /* If we have nothing to transmit, drop the packet */
274         if ( ( seq_len == 0 ) && ! force_send ) {
275                 free_pkb ( pkb );
276                 return 0;
277         }
278
279         /* If we are transmitting anything that requires
280          * acknowledgement (i.e. consumes sequence space), start the
281          * retransmission timer.
282          */
283         if ( seq_len )
284                 start_timer ( &conn->timer );
285
286         /* Fill up the TCP header */
287         tcphdr = pkb_push ( pkb, sizeof ( *tcphdr ) );
288         memset ( tcphdr, 0, sizeof ( *tcphdr ) );
289         tcphdr->src = conn->local_port;
290         tcphdr->dest = conn->peer.st_port;
291         tcphdr->seq = htonl ( conn->snd_seq );
292         tcphdr->ack = htonl ( conn->rcv_ack );
293         tcphdr->hlen = ( ( sizeof ( *tcphdr ) / 4 ) << 4 );
294         tcphdr->flags = TCP_FLAGS_SENDING ( conn->tcp_state );
295         tcphdr->win = htons ( TCP_WINDOW_SIZE );
296         tcphdr->csum = tcpip_chksum ( pkb->data, pkb_len ( pkb ) );
297
298         /* Dump header */
299         DBG ( "TCP %p TX %d->%d %08lx..%08lx           %08lx %4zd", conn,
300               ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ),
301               ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) + seq_len ),
302               ntohl ( tcphdr->ack ), len );
303         tcp_dump_flags ( tcphdr->flags );
304         DBG ( "\n" );
305
306         /* Transmit packet */
307         return tcpip_tx ( pkb, &tcp_protocol, &conn->peer );
308 }
309
310 /**
311  * Transmit any outstanding data
312  *
313  * @v conn      TCP connection
314  * 
315  * This function allocates space to the transmit buffer and invokes
316  * the senddata() callback function, to allow the application to
317  * transmit new data.
318  */
319 int tcp_senddata ( struct tcp_application *app ) {
320         struct tcp_connection *conn = app->conn;
321
322         /* Check connection actually exists */
323         if ( ! conn ) {
324                 DBG ( "TCP app %p has no connection\n", app );
325                 return -ENOTCONN;
326         }
327
328         return tcp_senddata_conn ( conn, 0 );
329 }
330
331 /**
332  * Transmit data
333  *
334  * @v app               TCP application
335  * @v data              Data to be sent
336  * @v len               Length of the data
337  * @ret rc              Return status code
338  *
339  * This function queues data to be sent via the TCP connection.  It
340  * can be called only in the context of an application's senddata()
341  * method.
342  */
343 int tcp_send ( struct tcp_application *app, const void *data, size_t len ) {
344         struct tcp_connection *conn = app->conn;
345         struct pk_buff *pkb;
346
347         /* Check connection actually exists */
348         if ( ! conn ) {
349                 DBG ( "TCP app %p has no connection\n", app );
350                 return -ENOTCONN;
351         }
352
353         /* Check that we have a packet buffer to fill */
354         pkb = conn->tx_pkb;
355         if ( ! pkb ) {
356                 DBG ( "TCP app %p tried to send data outside of the "
357                       "senddata() method\n", app );
358                 return -EINVAL;
359         }
360
361         /* Truncate length to fit transmit window */
362         if ( len > conn->snd_win )
363                 len = conn->snd_win;
364
365         /* Truncate length to fit packet buffer */
366         if ( len > pkb_available ( pkb ) )
367                 len = pkb_available ( pkb );
368
369         /* Copy payload */
370         memmove ( pkb_put ( pkb, len ), data, len );
371
372         return 0;
373 }
374
375 /**
376  * Retransmission timer expired
377  *
378  * @v timer     Retry timer
379  * @v over      Failure indicator
380  */
381 static void tcp_expired ( struct retry_timer *timer, int over ) {
382         struct tcp_connection *conn =
383                 container_of ( timer, struct tcp_connection, timer );
384         struct tcp_application *app = conn->app;
385         int graceful_close = TCP_CLOSED_GRACEFULLY ( conn->tcp_state );
386
387         DBG ( "TCP %p timer %s in %s\n", conn,
388               ( over ? "expired" : "fired" ), tcp_state ( conn->tcp_state ) );
389
390         assert ( ( conn->tcp_state == TCP_SYN_SENT ) ||
391                  ( conn->tcp_state == TCP_SYN_RCVD ) ||
392                  ( conn->tcp_state == TCP_ESTABLISHED ) ||
393                  ( conn->tcp_state == TCP_FIN_WAIT_1 ) ||
394                  ( conn->tcp_state == TCP_TIME_WAIT ) ||
395                  ( conn->tcp_state == TCP_CLOSE_WAIT ) ||
396                  ( conn->tcp_state == TCP_CLOSING_OR_LAST_ACK ) );
397
398         /* If we have finally timed out and given up, or if this is
399          * the result of a graceful close, terminate the connection
400          */
401         if ( over || graceful_close ) {
402
403                 /* Transition to CLOSED */
404                 conn->tcp_state = TCP_CLOSED;
405                 tcp_dump_state ( conn );
406
407                 /* If we haven't closed gracefully, send a RST */
408                 if ( ! graceful_close )
409                         tcp_senddata_conn ( conn, 1 );
410
411                 /* Break association between application and connection */
412                 tcp_disassociate ( conn );
413
414                 /* Free the connection */
415                 free_tcp ( conn );
416
417                 /* Notify application */
418                 if ( app && app->tcp_op->closed )
419                         app->tcp_op->closed ( app, -ETIMEDOUT );
420
421         } else {
422                 /* Otherwise, retransmit the packet */
423                 tcp_senddata_conn ( conn, 0 );
424         }
425 }
426
427 /**
428  * Identify TCP connection by local port number
429  *
430  * @v local_port        Local port (in network-endian order)
431  * @ret conn            TCP connection, or NULL
432  */
433 static struct tcp_connection * tcp_demux ( uint16_t local_port ) {
434         struct tcp_connection *conn;
435
436         list_for_each_entry ( conn, &tcp_conns, list ) {
437                 if ( conn->local_port == local_port )
438                         return conn;
439         }
440         return NULL;
441 }
442
443 /**
444  * Handle TCP received SYN
445  *
446  * @v conn              TCP connection
447  * @v seq               SEQ value (in host-endian order)
448  * @ret rc              Return status code
449  */
450 static int tcp_rx_syn ( struct tcp_connection *conn, uint32_t seq ) {
451
452         /* Synchronise sequence numbers on first SYN */
453         if ( ! ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) )
454                 conn->rcv_ack = seq;
455
456         /* Ignore duplicate SYN */
457         if ( ( conn->rcv_ack - seq ) > 0 )
458                 return 0;
459
460         /* Mark SYN as received and start sending ACKs with each packet */
461         conn->tcp_state |= ( TCP_STATE_SENDING ( TCP_ACK ) |
462                              TCP_STATE_RCVD ( TCP_SYN ) );
463
464         /* Acknowledge SYN */
465         conn->rcv_ack++;
466
467         return 0;
468 }
469
470 /**
471  * Handle TCP received ACK
472  *
473  * @v conn              TCP connection
474  * @v ack               ACK value (in host-endian order)
475  * @v win               WIN value (in host-endian order)
476  * @ret rc              Return status code
477  */
478 static int tcp_rx_ack ( struct tcp_connection *conn, uint32_t ack,
479                         uint32_t win ) {
480         struct tcp_application *app = conn->app;
481         size_t ack_len = ( ack - conn->snd_seq );
482         size_t len;
483         unsigned int acked_flags = 0;
484
485         /* Ignore duplicate or out-of-range ACK */
486         if ( ack_len > conn->snd_sent ) {
487                 DBG ( "TCP %p received ACK for [%08lx,%08lx), sent only "
488                       "[%08lx,%08lx)\n", conn, conn->snd_seq,
489                       ( conn->snd_seq + ack_len ), conn->snd_seq,
490                       ( conn->snd_seq + conn->snd_sent ) );
491                 return -EINVAL;
492         }
493
494         /* If we are sending flags and this ACK acknowledges all
495          * outstanding sequence points, then it acknowledges the
496          * flags.  (This works since both SYN and FIN will always be
497          * the last outstanding sequence point.)
498          */
499         len = ack_len;
500         if ( ack_len == conn->snd_sent ) {
501                 acked_flags = ( TCP_FLAGS_SENDING ( conn->tcp_state ) &
502                                 ( TCP_SYN | TCP_FIN ) );
503                 if ( acked_flags )
504                         len--;
505         }
506
507         /* Update SEQ and sent counters, and window size */
508         conn->snd_seq = ack;
509         conn->snd_sent = 0;
510         conn->snd_win = win;
511
512         /* Stop the retransmission timer */
513         stop_timer ( &conn->timer );
514
515         /* Notify application of acknowledged data, if any */
516         if ( len && app && app->tcp_op->acked )
517                 app->tcp_op->acked ( app, len );
518
519         /* Mark SYN/FIN as acknowledged if applicable. */
520         if ( acked_flags ) {
521                 conn->tcp_state &= ~TCP_STATE_SENDING ( TCP_SYN | TCP_FIN );
522                 conn->tcp_state |= TCP_STATE_ACKED ( acked_flags );
523         }
524
525         /* Notify application of established connection, if applicable */
526         if ( ( acked_flags & TCP_SYN ) && app && app->tcp_op->connected )
527                 app->tcp_op->connected ( app );
528
529         return 0;
530 }
531
532 /**
533  * Handle TCP received data
534  *
535  * @v conn              TCP connection
536  * @v seq               SEQ value (in host-endian order)
537  * @v data              Data buffer
538  * @v len               Length of data buffer
539  * @ret rc              Return status code
540  */
541 static int tcp_rx_data ( struct tcp_connection *conn, uint32_t seq,
542                          void *data, size_t len ) {
543         struct tcp_application *app = conn->app;
544         size_t already_rcvd;
545
546         /* Ignore duplicate data */
547         already_rcvd = ( conn->rcv_ack - seq );
548         if ( already_rcvd >= len )
549                 return 0;
550         data += already_rcvd;
551         len -= already_rcvd;
552
553         /* Acknowledge new data */
554         conn->rcv_ack += len;
555
556         /* Notify application */
557         if ( app && app->tcp_op->newdata )
558                 app->tcp_op->newdata ( app, data, len );
559
560         return 0;
561 }
562
563 /** Handle TCP received FIN
564  *
565  * @v conn              TCP connection
566  * @v seq               SEQ value (in host-endian order)
567  * @ret rc              Return status code
568  */
569 static int tcp_rx_fin ( struct tcp_connection *conn, uint32_t seq ) {
570         struct tcp_application *app = conn->app;
571
572         /* Ignore duplicate FIN */
573         if ( ( conn->rcv_ack - seq ) > 0 )
574                 return 0;
575
576         /* Mark FIN as received and acknowledge it */
577         conn->tcp_state |= TCP_STATE_RCVD ( TCP_FIN );
578         conn->rcv_ack++;
579
580         /* If we haven't already sent our FIN, send a FIN */
581         if ( ! ( conn->tcp_state & TCP_STATE_ACKED ( TCP_FIN ) ) )
582                 conn->tcp_state |= TCP_STATE_SENDING ( TCP_FIN );
583
584         /* Break association with application */
585         tcp_disassociate ( conn );
586
587         /* Notify application */
588         if ( app && app->tcp_op->closed )
589                 app->tcp_op->closed ( app, 0 );
590
591         return 0;
592 }
593
594 /**
595  * Process received packet
596  *
597  * @v pkb               Packet buffer
598  * @v partial           Partial checksum
599  */
600 static int tcp_rx ( struct pk_buff *pkb,
601                     struct sockaddr_tcpip *st_src __unused,
602                     struct sockaddr_tcpip *st_dest __unused ) {
603         struct tcp_header *tcphdr;
604         struct tcp_connection *conn;
605         unsigned int hlen;
606         uint32_t start_seq;
607         uint32_t seq;
608         uint32_t ack;
609         uint32_t win;
610         unsigned int flags;
611         void *data;
612         size_t len;
613         int rc = 0;
614
615         /* Sanity check packet and strip TCP header */
616         if ( pkb_len ( pkb ) < sizeof ( *tcphdr ) ) {
617                 DBG ( "TCP packet too short at %d bytes (min %d bytes)\n",
618                       pkb_len ( pkb ), sizeof ( *tcphdr ) );
619                 rc = -EINVAL;
620                 goto err;
621         }
622         tcphdr = pkb->data;
623         hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4;
624         if ( hlen < sizeof ( *tcphdr ) ) {
625                 DBG ( "TCP header too short at %d bytes (min %d bytes)\n",
626                       hlen, sizeof ( *tcphdr ) );
627                 rc = -EINVAL;
628                 goto err;
629         }
630         if ( hlen > pkb_len ( pkb ) ) {
631                 DBG ( "TCP header too long at %d bytes (max %d bytes)\n",
632                       hlen, pkb_len ( pkb ) );
633                 rc = -EINVAL;
634                 goto err;
635         }
636
637         /* TODO: Verify checksum */
638 #warning "Verify checksum"
639         
640         /* Parse parameters from header and strip header */
641         conn = tcp_demux ( tcphdr->dest );
642         start_seq = seq = ntohl ( tcphdr->seq );
643         ack = ntohl ( tcphdr->ack );
644         win = ntohs ( tcphdr->win );
645         flags = tcphdr->flags;
646         data = pkb_pull ( pkb, hlen );
647         len = pkb_len ( pkb );
648
649         /* Dump header */
650         DBG ( "TCP %p RX %d<-%d %08lx           %08lx..%08lx %4zd", conn,
651               ntohs ( tcphdr->dest ), ntohs ( tcphdr->src ),
652               ntohl ( tcphdr->ack ), ntohl ( tcphdr->seq ),
653               ( ntohl ( tcphdr->seq ) + len +
654                 ( ( tcphdr->flags & ( TCP_SYN | TCP_FIN ) ) ? 1 : 0 ) ), len );
655         tcp_dump_flags ( tcphdr->flags );
656         DBG ( "\n" );
657
658         /* If no connection was found, create dummy connection for
659          * sending RST
660          */
661 #warning "Handle non-matched connections"
662         if ( ! conn )
663                 goto err;
664
665         /* Handle RST, if present */
666 #warning "Handle RST"
667         if ( flags & TCP_RST )
668                 goto err;
669
670         /* Handle ACK, if present */
671         if ( flags & TCP_ACK )
672                 tcp_rx_ack ( conn, ack, win );
673
674         /* Handle SYN, if present */
675         if ( flags & TCP_SYN ) {
676                 tcp_rx_syn ( conn, seq );
677                 seq++;
678         }
679
680         /* Handle new data, if any */
681         tcp_rx_data ( conn, seq, data, len );
682         seq += len;
683
684         /* Handle FIN, if present */
685         if ( flags & TCP_FIN ) {
686                 tcp_rx_fin ( conn, seq );
687                 seq++;
688         }
689
690         /* Dump out any state change as a result of SYN, FIN or ACK */
691         tcp_dump_state ( conn );
692
693         /* Send out any pending data.  If peer is expecting an ACK for
694          * this packet then force sending a reply.
695          */
696         tcp_senddata_conn ( conn, ( start_seq != seq ) );
697
698         /* If this packet was the last we expect to receive, set up
699          * timer to expire and cause the connection to be freed.
700          */
701         if ( TCP_CLOSED_GRACEFULLY ( conn->tcp_state ) ) {
702                 conn->timer.timeout = ( 2 * TCP_MSL );
703                 start_timer ( &conn->timer );
704         }
705
706  err:
707         /* Free received packet */
708         free_pkb ( pkb );
709         return rc;
710 }
711
712 /**
713  * Bind TCP connection to local port
714  *
715  * @v conn              TCP connection
716  * @v local_port        Local port (in network byte order), or 0
717  * @ret rc              Return status code
718  *
719  * This function adds the connection to the list of registered TCP
720  * connections.  If the local port is 0, the connection is assigned an
721  * available port between 1024 and 65535.
722  */
723 static int tcp_bind ( struct tcp_connection *conn, uint16_t local_port ) {
724         struct tcp_connection *existing;
725         static uint16_t try_port = 1024;
726
727 #warning "Fix the port re-use bug"
728         try_port = random();
729
730         /* If no port specified, find the first available port */
731         if ( ! local_port ) {
732                 for ( ; try_port ; try_port++ ) {
733                         if ( try_port < 1024 )
734                                 continue;
735                         if ( tcp_bind ( conn, htons ( try_port ) ) == 0 )
736                                 return 0;
737                 }
738                 DBG ( "TCP %p could not bind: no free ports remaining\n",
739                       conn );
740                 return -EADDRINUSE;
741         }
742
743         /* Attempt bind to local port */
744         list_for_each_entry ( existing, &tcp_conns, list ) {
745                 if ( existing->local_port == local_port ) {
746                         DBG ( "TCP %p could not bind: port %d in use\n",
747                               conn, ntohs ( local_port ) );
748                         return -EADDRINUSE;
749                 }
750         }
751         conn->local_port = local_port;
752
753         DBG ( "TCP %p bound to port %d\n", conn, ntohs ( local_port ) );
754         return 0;
755 }
756
757 /**
758  * Connect to a remote server
759  *
760  * @v app               TCP application
761  * @v peer              Remote socket address
762  * @v local_port        Local port number (in network byte order), or 0
763  * @ret rc              Return status code
764  *
765  * This function initiates a TCP connection to the socket address specified in
766  * peer. It sends a SYN packet to peer. When the connection is established, the
767  * TCP stack calls the connected() callback function.
768  */
769 int tcp_connect ( struct tcp_application *app, struct sockaddr_tcpip *peer,
770                   uint16_t local_port ) {
771         struct tcp_connection *conn;
772         int rc;
773
774         /* Application must not already have an open connection */
775         if ( app->conn ) {
776                 DBG ( "TCP app %p already open on %p\n", app, app->conn );
777                 return -EISCONN;
778         }
779
780         /* Allocate connection state storage and add to connection list */
781         conn = alloc_tcp();
782         if ( ! conn ) {
783                 DBG ( "TCP app %p could not allocate connection\n", app );
784                 return -ENOMEM;
785         }
786
787         /* Bind to peer and to local port */
788         memcpy ( &conn->peer, peer, sizeof ( conn->peer ) );
789         if ( ( rc = tcp_bind ( conn, local_port ) ) != 0 ) {
790                 free_tcp ( conn );
791                 return rc;
792         }
793
794         /* Associate with application */
795         tcp_associate ( conn, app );
796
797         /* Transition to TCP_SYN_SENT and send the SYN */
798         conn->tcp_state = TCP_SYN_SENT;
799         tcp_dump_state ( conn );
800         tcp_senddata_conn ( conn, 0 );
801
802         return 0;
803 }
804
805 /**
806  * Close the connection
807  *
808  * @v app               TCP application
809  *
810  * The association between the application and the TCP connection is
811  * immediately severed, and the TCP application data structure can be
812  * reused or freed immediately.  The TCP connection will persist until
813  * the state machine has returned to the TCP_CLOSED state.
814  */
815 void tcp_close ( struct tcp_application *app ) {
816         struct tcp_connection *conn = app->conn;
817
818         /* If no connection exists, do nothing */
819         if ( ! conn )
820                 return;
821
822         /* Break association between application and connection */
823         tcp_disassociate ( conn );
824
825         /* If we have not yet received a SYN (i.e. we are in CLOSED,
826          * LISTEN or SYN_SENT), just delete the connection
827          */
828         if ( ! ( conn->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) {
829                 conn->tcp_state = TCP_CLOSED;
830                 tcp_dump_state ( conn );
831                 free_tcp ( conn );
832                 return;
833         }
834
835         /* If we have sent a SYN but not had it acknowledged (i.e. we
836          * are in SYN_RCVD), pretend that it has been acknowledged so
837          * that we can send a FIN without breaking things.
838          */
839         if ( conn->tcp_state & TCP_STATE_SENDING ( TCP_SYN ) )
840                 tcp_rx_ack ( conn, ( conn->snd_seq + 1 ), 0 );
841
842         /* Send a FIN to initiate the close */
843         conn->tcp_state |= TCP_STATE_SENDING ( TCP_FIN );
844         tcp_dump_state ( conn );
845         tcp_senddata_conn ( conn, 0 );
846 }
847
848 /** TCP protocol */
849 struct tcpip_protocol tcp_protocol __tcpip_protocol = {
850         .name = "TCP",
851         .rx = tcp_rx,
852         .tcpip_proto = IP_TCP,
853         .csum_offset = 16,
854 };