4c07c2c911ad15f4d33cb80018aaf7a3c1812d98
[people/xl0/gpxe.git] / src / net / ipv4.c
1 #include <string.h>
2 #include <stdint.h>
3 #include <errno.h>
4 #include <byteswap.h>
5 #include <malloc.h>
6 #include <vsprintf.h>
7 #include <gpxe/list.h>
8 #include <gpxe/in.h>
9 #include <gpxe/arp.h>
10 #include <gpxe/if_ether.h>
11 #include <gpxe/pkbuff.h>
12 #include <gpxe/netdevice.h>
13 #include "uip/uip.h"
14 #include <gpxe/ip.h>
15 #include <gpxe/tcpip.h>
16
17 /** @file
18  *
19  * IPv4 protocol
20  *
21  * The gPXE IP 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  */
27
28 /* Unique IP datagram identification number */
29 static uint16_t next_ident = 0;
30
31 struct net_protocol ipv4_protocol;
32
33 /** An IPv4 address/routing table entry */
34 struct ipv4_miniroute {
35         /** List of miniroutes */
36         struct list_head list;
37         /** Network device */
38         struct net_device *netdev;
39         /** IPv4 address */
40         struct in_addr address;
41         /** Subnet mask */
42         struct in_addr netmask;
43         /** Gateway address */
44         struct in_addr gateway;
45 };
46
47 /** List of IPv4 miniroutes */
48 static LIST_HEAD ( miniroutes );
49
50 /** List of fragment reassembly buffers */
51 static LIST_HEAD ( frag_buffers );
52
53 /**
54  * Add IPv4 interface
55  *
56  * @v netdev    Network device
57  * @v address   IPv4 address
58  * @v netmask   Subnet mask
59  * @v gateway   Gateway address (or @c INADDR_NONE for no gateway)
60  * @ret rc      Return status code
61  *
62  */
63 int add_ipv4_address ( struct net_device *netdev, struct in_addr address,
64                        struct in_addr netmask, struct in_addr gateway ) {
65         struct ipv4_miniroute *miniroute;
66
67         /* Allocate and populate miniroute structure */
68         miniroute = malloc ( sizeof ( *miniroute ) );
69         if ( ! miniroute )
70                 return -ENOMEM;
71         miniroute->netdev = netdev;
72         miniroute->address = address;
73         miniroute->netmask = netmask;
74         miniroute->gateway = gateway;
75         
76         /* Add to end of list if we have a gateway, otherwise to start
77          * of list.
78          */
79         if ( gateway.s_addr != INADDR_NONE ) {
80                 list_add_tail ( &miniroute->list, &miniroutes );
81         } else {
82                 list_add ( &miniroute->list, &miniroutes );
83         }
84         return 0;
85 }
86
87 /**
88  * Remove IPv4 interface
89  *
90  * @v netdev    Network device
91  */
92 void del_ipv4_address ( struct net_device *netdev ) {
93         struct ipv4_miniroute *miniroute;
94
95         list_for_each_entry ( miniroute, &miniroutes, list ) {
96                 if ( miniroute->netdev == netdev ) {
97                         list_del ( &miniroute->list );
98                         break;
99                 }
100         }
101 }
102
103 /**
104  * Dump IPv4 packet header
105  *
106  * @v iphdr     IPv4 header
107  */
108 static void ipv4_dump ( struct iphdr *iphdr __unused ) {
109
110 /*
111         DBG ( "IP4 header at %p+%#zx\n", iphdr, sizeof ( *iphdr ) );
112         DBG ( "\tVersion = %d\n", ( iphdr->verhdrlen & IP_MASK_VER ) / 16 );
113         DBG ( "\tHeader length = %d\n", iphdr->verhdrlen & IP_MASK_HLEN );
114         DBG ( "\tService = %d\n", iphdr->service );
115         DBG ( "\tTotal length = %d\n", ntohs ( iphdr->len ) );
116         DBG ( "\tIdent = %d\n", ntohs ( iphdr->ident ) );
117         DBG ( "\tFrags/Offset = %d\n", ntohs ( iphdr->frags ) );
118         DBG ( "\tIP TTL = %d\n", iphdr->ttl );
119         DBG ( "\tProtocol = %d\n", iphdr->protocol );
120         DBG ( "\tHeader Checksum (at %p) = %x\n", &iphdr->chksum, 
121                                 ntohs ( iphdr->chksum ) );
122         DBG ( "\tSource = %s\n", inet_ntoa ( iphdr->src ) );
123         DBG ( "\tDestination = %s\n", inet_ntoa ( iphdr->dest ) );
124 */
125         DBG ( "IP4 %p transmitting %p+%d ident %d protocol %d header-csum %x\n",
126                 &ipv4_protocol, iphdr, ntohs ( iphdr->len ), ntohs ( iphdr->ident ),
127                 iphdr->protocol, ntohs ( iphdr->chksum ) );
128         DBG ( "src %s, dest %s\n", inet_ntoa ( iphdr->src ), inet_ntoa ( iphdr->dest ) );
129 }
130
131 /**
132  * Fragment reassembly counter timeout
133  *
134  * @v timer     Retry timer
135  * @v over      If asserted, the timer is greater than @c MAX_TIMEOUT 
136  */
137 static void ipv4_frag_expired ( struct retry_timer *timer __unused,
138                                 int over ) {
139         if ( over ) {
140                 DBG ( "Fragment reassembly timeout" );
141                 /* Free the fragment buffer */
142         }
143 }
144
145 /**
146  * Free fragment buffer
147  *
148  * @v fragbug   Fragment buffer
149  */
150 static void free_fragbuf ( struct frag_buffer *fragbuf ) {
151         if ( fragbuf ) {
152                 free_dma ( fragbuf, sizeof ( *fragbuf ) );
153         }
154 }
155
156 /**
157  * Fragment reassembler
158  *
159  * @v pkb               Packet buffer, fragment of the datagram
160  * @ret frag_pkb        Reassembled packet, or NULL
161  */
162 static struct pk_buff * ipv4_reassemble ( struct pk_buff * pkb ) {
163         struct iphdr *iphdr = pkb->data;
164         struct frag_buffer *fragbuf;
165         
166         /**
167          * Check if the fragment belongs to any fragment series
168          */
169         list_for_each_entry ( fragbuf, &frag_buffers, list ) {
170                 if ( fragbuf->ident == iphdr->ident &&
171                      fragbuf->src.s_addr == iphdr->src.s_addr ) {
172                         /**
173                          * Check if the packet is the expected fragment
174                          * 
175                          * The offset of the new packet must be equal to the
176                          * length of the data accumulated so far (the length of
177                          * the reassembled packet buffer
178                          */
179                         if ( pkb_len ( fragbuf->frag_pkb ) == 
180                               ( iphdr->frags & IP_MASK_OFFSET ) ) {
181                                 /**
182                                  * Append the contents of the fragment to the
183                                  * reassembled packet buffer
184                                  */
185                                 pkb_pull ( pkb, sizeof ( *iphdr ) );
186                                 memcpy ( pkb_put ( fragbuf->frag_pkb,
187                                                         pkb_len ( pkb ) ),
188                                          pkb->data, pkb_len ( pkb ) );
189                                 free_pkb ( pkb );
190
191                                 /** Check if the fragment series is over */
192                                 if ( !iphdr->frags & IP_MASK_MOREFRAGS ) {
193                                         pkb = fragbuf->frag_pkb;
194                                         free_fragbuf ( fragbuf );
195                                         return pkb;
196                                 }
197
198                         } else {
199                                 /* Discard the fragment series */
200                                 free_fragbuf ( fragbuf );
201                                 free_pkb ( pkb );
202                         }
203                         return NULL;
204                 }
205         }
206         
207         /** Check if the fragment is the first in the fragment series */
208         if ( iphdr->frags & IP_MASK_MOREFRAGS &&
209                         ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
210         
211                 /** Create a new fragment buffer */
212                 fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
213                 fragbuf->ident = iphdr->ident;
214                 fragbuf->src = iphdr->src;
215
216                 /* Set up the reassembly packet buffer */
217                 fragbuf->frag_pkb = alloc_pkb ( IP_FRAG_PKB_SIZE );
218                 pkb_pull ( pkb, sizeof ( *iphdr ) );
219                 memcpy ( pkb_put ( fragbuf->frag_pkb, pkb_len ( pkb ) ),
220                          pkb->data, pkb_len ( pkb ) );
221                 free_pkb ( pkb );
222
223                 /* Set the reassembly timer */
224                 fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
225                 fragbuf->frag_timer.expired = ipv4_frag_expired;
226                 start_timer ( &fragbuf->frag_timer );
227
228                 /* Add the fragment buffer to the list of fragment buffers */
229                 list_add ( &fragbuf->list, &frag_buffers );
230         }
231         
232         return NULL;
233 }
234
235
236 /**
237  * Complete the transport-layer checksum
238  *
239  * @v pkb       Packet buffer
240  * @v tcpip     Transport-layer protocol
241  *
242  * This function calculates the tcpip 
243  */
244 static void ipv4_tx_csum ( struct pk_buff *pkb,
245                            struct tcpip_protocol *tcpip ) {
246         struct iphdr *iphdr = pkb->data;
247         struct ipv4_pseudo_header pshdr;
248         uint16_t *csum = ( ( ( void * ) iphdr ) + sizeof ( *iphdr )
249                            + tcpip->csum_offset );
250
251         /* Calculate pseudo header */
252         pshdr.src = iphdr->src;
253         pshdr.dest = iphdr->dest;
254         pshdr.zero_padding = 0x00;
255         pshdr.protocol = iphdr->protocol;
256         /* This is only valid when IPv4 does not have options */
257         pshdr.len = htons ( pkb_len ( pkb ) - sizeof ( *iphdr ) );
258
259         /* Update the checksum value */
260         *csum = tcpip_continue_chksum ( *csum, &pshdr, sizeof ( pshdr ) );
261 }
262
263 /**
264  * Calculate the transport-layer checksum while processing packets
265  */
266 static uint16_t ipv4_rx_csum ( struct pk_buff *pkb __unused,
267                                uint8_t trans_proto __unused ) {
268         /** 
269          * This function needs to be implemented. Until then, it will return
270          * 0xffffffff every time
271          */
272         return 0xffff;
273 }
274
275 /**
276  * Transmit IP packet
277  *
278  * @v pkb               Packet buffer
279  * @v tcpip             Transport-layer protocol
280  * @v st_dest           Destination network-layer address
281  * @ret rc              Status
282  *
283  * This function expects a transport-layer segment and prepends the IP header
284  */
285 static int ipv4_tx ( struct pk_buff *pkb,
286                      struct tcpip_protocol *tcpip_protocol,
287                      struct sockaddr_tcpip *st_dest ) {
288         struct iphdr *iphdr = pkb_push ( pkb, sizeof ( *iphdr ) );
289         struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
290         struct ipv4_miniroute *miniroute;
291         struct net_device *netdev = NULL;
292         struct in_addr next_hop;
293         uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
294         const uint8_t *ll_dest = ll_dest_buf;
295         int rc;
296
297         /* Fill up the IP header, except source address */
298         iphdr->verhdrlen = ( IP_VER << 4 ) | ( sizeof ( *iphdr ) / 4 );
299         iphdr->service = IP_TOS;
300         iphdr->len = htons ( pkb_len ( pkb ) ); 
301         iphdr->ident = htons ( next_ident++ );
302         iphdr->frags = 0;
303         iphdr->ttl = IP_TTL;
304         iphdr->protocol = tcpip_protocol->tcpip_proto;
305
306         /* Copy destination address */
307         iphdr->dest = sin_dest->sin_addr;
308
309         /**
310          * All fields in the IP header filled in except the source network
311          * address (which requires routing) and the header checksum (which
312          * requires the source network address). As the pseudo header requires
313          * the source address as well and the transport-layer checksum is
314          * updated after routing.
315          */
316
317         /* Use routing table to identify next hop and transmitting netdev */
318         next_hop = iphdr->dest;
319         list_for_each_entry ( miniroute, &miniroutes, list ) {
320                 int local, has_gw;
321
322                 local = ( ( ( iphdr->dest.s_addr ^ miniroute->address.s_addr )
323                             & miniroute->netmask.s_addr ) == 0 );
324                 has_gw = ( miniroute->gateway.s_addr != INADDR_NONE );
325                 if ( local || has_gw ) {
326                         netdev = miniroute->netdev;
327                         iphdr->src = miniroute->address;
328                         if ( ! local )
329                                 next_hop = miniroute->gateway;
330                         break;
331                 }
332         }
333         /* Abort if no network device identified */
334         if ( ! netdev ) {
335                 DBG ( "No route to %s\n", inet_ntoa ( iphdr->dest ) );
336                 rc = -EHOSTUNREACH;
337                 goto err;
338         }
339
340         /* Calculate the transport layer checksum */
341         if ( tcpip_protocol->csum_offset > 0 ) {
342                 ipv4_tx_csum ( pkb, tcpip_protocol );
343         }
344
345         /* Calculate header checksum, in network byte order */
346         iphdr->chksum = 0;
347         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
348
349         /* Print IP4 header for debugging */
350         ipv4_dump ( iphdr );
351
352         /* Determine link-layer destination address */
353         if ( next_hop.s_addr == INADDR_BROADCAST ) {
354                 /* Broadcast address */
355                 ll_dest = netdev->ll_protocol->ll_broadcast;
356         } else if ( IN_MULTICAST ( next_hop.s_addr ) ) {
357                 /* Special case: IPv4 multicast over Ethernet.  This
358                  * code may need to be generalised once we find out
359                  * what happens for other link layers.
360                  */
361                 uint8_t *next_hop_bytes = ( uint8_t * ) &next_hop;
362                 ll_dest_buf[0] = 0x01;
363                 ll_dest_buf[0] = 0x00;
364                 ll_dest_buf[0] = 0x5e;
365                 ll_dest_buf[3] = next_hop_bytes[1] & 0x7f;
366                 ll_dest_buf[4] = next_hop_bytes[2];
367                 ll_dest_buf[5] = next_hop_bytes[3];
368         } else {
369                 /* Unicast address: resolve via ARP */
370                 if ( ( rc = arp_resolve ( netdev, &ipv4_protocol, &next_hop,
371                                           &iphdr->src, ll_dest_buf ) ) != 0 ) {
372                         DBG ( "No ARP entry for %s\n",
373                               inet_ntoa ( iphdr->dest ) );
374                         goto err;
375                 }
376         }
377
378         /* Hand off to link layer */
379         return net_tx ( pkb, netdev, &ipv4_protocol, ll_dest );
380
381  err:
382         free_pkb ( pkb );
383         return rc;
384 }
385
386 /**
387  * Process incoming packets
388  *
389  * @v pkb       Packet buffer
390  * @v netdev    Network device
391  * @v ll_source Link-layer destination source
392  *
393  * This function expects an IP4 network datagram. It processes the headers 
394  * and sends it to the transport layer.
395  */
396 static int ipv4_rx ( struct pk_buff *pkb, struct net_device *netdev __unused,
397                      const void *ll_source __unused ) {
398         struct iphdr *iphdr = pkb->data;
399         union {
400                 struct sockaddr_in sin;
401                 struct sockaddr_tcpip st;
402         } src, dest;
403         uint16_t chksum;
404
405         /* Sanity check */
406         if ( pkb_len ( pkb ) < sizeof ( *iphdr ) ) {
407                 DBG ( "IP datagram too short (%d bytes)\n",
408                         pkb_len ( pkb ) );
409                 return -EINVAL;
410         }
411
412         /* Print IP4 header for debugging */
413         ipv4_dump ( iphdr );
414
415         /* Validate version and header length */
416         if ( iphdr->verhdrlen != 0x45 ) {
417                 DBG ( "Bad version and header length %x\n", iphdr->verhdrlen );
418                 return -EINVAL;
419         }
420
421         /* Validate length of IP packet */
422         if ( ntohs ( iphdr->len ) > pkb_len ( pkb ) ) {
423                 DBG ( "Inconsistent packet length %d\n",
424                       ntohs ( iphdr->len ) );
425                 return -EINVAL;
426         }
427
428         /* Verify the checksum */
429         if ( ( chksum = ipv4_rx_csum ( pkb, iphdr->protocol ) ) != 0xffff ) {
430                 DBG ( "Bad checksum %x\n", chksum );
431         }
432         /* Fragment reassembly */
433         if ( iphdr->frags & IP_MASK_MOREFRAGS || 
434                 ( !iphdr->frags & IP_MASK_MOREFRAGS &&
435                         iphdr->frags & IP_MASK_OFFSET != 0 ) ) {
436                 /* Pass the fragment to the reassembler ipv4_ressable() which
437                  * either returns a fully reassembled packet buffer or NULL.
438                  */
439                 pkb = ipv4_reassemble ( pkb );
440                 if ( !pkb ) {
441                         return 0;
442                 }
443         }
444
445         /* To reduce code size, the following functions are not implemented:
446          * 1. Check the destination address
447          * 2. Check the TTL field
448          * 3. Check the service field
449          */
450
451         /* Construct socket addresses */
452         memset ( &src, 0, sizeof ( src ) );
453         src.sin.sin_family = AF_INET;
454         src.sin.sin_addr = iphdr->src;
455         memset ( &dest, 0, sizeof ( dest ) );
456         dest.sin.sin_family = AF_INET;
457         dest.sin.sin_addr = iphdr->dest;
458
459         /* Strip header */
460         pkb_pull ( pkb, sizeof ( *iphdr ) );
461
462         /* Send it to the transport layer */
463         return tcpip_rx ( pkb, iphdr->protocol, &src.st, &dest.st );
464 }
465
466 /** 
467  * Check existence of IPv4 address for ARP
468  *
469  * @v netdev            Network device
470  * @v net_addr          Network-layer address
471  * @ret rc              Return status code
472  */
473 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
474         const struct in_addr *address = net_addr;
475         struct ipv4_miniroute *miniroute;
476
477         list_for_each_entry ( miniroute, &miniroutes, list ) {
478                 if ( ( miniroute->netdev == netdev ) &&
479                      ( miniroute->address.s_addr == address->s_addr ) ) {
480                         /* Found matching address */
481                         return 0;
482                 }
483         }
484         return -ENOENT;
485 }
486
487 /**
488  * Convert IPv4 address to dotted-quad notation
489  *
490  * @v in        IP address
491  * @ret string  IP address in dotted-quad notation
492  */
493 char * inet_ntoa ( struct in_addr in ) {
494         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
495         uint8_t *bytes = ( uint8_t * ) &in;
496         
497         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
498         return buf;
499 }
500
501 /**
502  * Transcribe IP address
503  *
504  * @v net_addr  IP address
505  * @ret string  IP address in dotted-quad notation
506  *
507  */
508 static const char * ipv4_ntoa ( const void *net_addr ) {
509         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
510 }
511
512 /** IPv4 protocol */
513 struct net_protocol ipv4_protocol = {
514         .name = "IP",
515         .net_proto = htons ( ETH_P_IP ),
516         .net_addr_len = sizeof ( struct in_addr ),
517         .rx = ipv4_rx,
518         .ntoa = ipv4_ntoa,
519 };
520
521 NET_PROTOCOL ( ipv4_protocol );
522
523 /** IPv4 TCPIP net protocol */
524 struct tcpip_net_protocol ipv4_tcpip_protocol = {
525         .name = "IPv4",
526         .sa_family = AF_INET,
527         .tx = ipv4_tx,
528 };
529
530 TCPIP_NET_PROTOCOL ( ipv4_tcpip_protocol );
531
532 /** IPv4 ARP protocol */
533 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
534         .net_protocol = &ipv4_protocol,
535         .check = ipv4_arp_check,
536 };