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