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