e663ec32b94ad50b927e19edc075e5e03756b728
[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
38         /** Network device */
39         struct net_device *netdev;
40         /** Reference to network device */
41         struct reference netdev_ref;
42
43         /** IPv4 address */
44         struct in_addr address;
45         /** Subnet mask */
46         struct in_addr netmask;
47         /** Gateway address */
48         struct in_addr gateway;
49 };
50
51 /** List of IPv4 miniroutes */
52 static LIST_HEAD ( miniroutes );
53
54 /** List of fragment reassembly buffers */
55 static LIST_HEAD ( frag_buffers );
56
57 static void ipv4_forget_netdev ( struct reference *ref );
58
59 /**
60  * Add IPv4 minirouting table entry
61  *
62  * @v netdev            Network device
63  * @v address           IPv4 address
64  * @v netmask           Subnet mask
65  * @v gateway           Gateway address (or @c INADDR_NONE for no gateway)
66  * @ret miniroute       Routing table entry, or NULL
67  */
68 static struct ipv4_miniroute * add_ipv4_miniroute ( struct net_device *netdev,
69                                                     struct in_addr address,
70                                                     struct in_addr netmask,
71                                                     struct in_addr gateway ) {
72         struct ipv4_miniroute *miniroute;
73
74         /* Allocate and populate miniroute structure */
75         miniroute = malloc ( sizeof ( *miniroute ) );
76         if ( miniroute ) {
77
78                 DBG ( "IPv4 add %s", inet_ntoa ( address ) );
79                 DBG ( "/%s ", inet_ntoa ( netmask ) );
80                 if ( gateway.s_addr != INADDR_NONE )
81                         DBG ( "gw %s ", inet_ntoa ( gateway ) );
82                 DBG ( "via %s\n", netdev->name );
83
84                 /* Record routing information */
85                 miniroute->netdev = netdev;
86                 miniroute->address = address;
87                 miniroute->netmask = netmask;
88                 miniroute->gateway = gateway;
89                 
90                 /* Add to end of list if we have a gateway, otherwise
91                  * to start of list.
92                  */
93                 if ( gateway.s_addr != INADDR_NONE ) {
94                         list_add_tail ( &miniroute->list, &miniroutes );
95                 } else {
96                         list_add ( &miniroute->list, &miniroutes );
97                 }
98
99                 /* Record reference to net_device */
100                 miniroute->netdev_ref.forget = ipv4_forget_netdev;
101                 ref_add ( &miniroute->netdev_ref, &netdev->references );
102         }
103
104         return miniroute;
105 }
106
107 /**
108  * Delete IPv4 minirouting table entry
109  *
110  * @v miniroute         Routing table entry
111  */
112 static void del_ipv4_miniroute ( struct ipv4_miniroute *miniroute ) {
113
114         DBG ( "IPv4 del %s", inet_ntoa ( miniroute->address ) );
115         DBG ( "/%s ", inet_ntoa ( miniroute->netmask ) );
116         if ( miniroute->gateway.s_addr != INADDR_NONE )
117                 DBG ( "gw %s ", inet_ntoa ( miniroute->gateway ) );
118         DBG ( "via %s\n", miniroute->netdev->name );
119
120         ref_del ( &miniroute->netdev_ref );
121         list_del ( &miniroute->list );
122         free ( miniroute );
123 }
124
125 /**
126  * Forget reference to net_device
127  *
128  * @v ref               Persistent reference
129  */
130 static void ipv4_forget_netdev ( struct reference *ref ) {
131         struct ipv4_miniroute *miniroute
132                 = container_of ( ref, struct ipv4_miniroute, netdev_ref );
133
134         del_ipv4_miniroute ( miniroute );
135 }
136
137 /**
138  * Add IPv4 interface
139  *
140  * @v netdev    Network device
141  * @v address   IPv4 address
142  * @v netmask   Subnet mask
143  * @v gateway   Gateway address (or @c INADDR_NONE for no gateway)
144  * @ret rc      Return status code
145  *
146  */
147 int add_ipv4_address ( struct net_device *netdev, struct in_addr address,
148                        struct in_addr netmask, struct in_addr gateway ) {
149         struct ipv4_miniroute *miniroute;
150
151         /* Clear any existing address for this net device */
152         del_ipv4_address ( netdev );
153
154         /* Add new miniroute */
155         miniroute = add_ipv4_miniroute ( netdev, address, netmask, gateway );
156         if ( ! miniroute )
157                 return -ENOMEM;
158
159         return 0;
160 }
161
162 /**
163  * Remove IPv4 interface
164  *
165  * @v netdev    Network device
166  */
167 void del_ipv4_address ( struct net_device *netdev ) {
168         struct ipv4_miniroute *miniroute;
169
170         list_for_each_entry ( miniroute, &miniroutes, list ) {
171                 if ( miniroute->netdev == netdev ) {
172                         del_ipv4_miniroute ( miniroute );
173                         break;
174                 }
175         }
176 }
177
178 /**
179  * Perform IPv4 routing
180  *
181  * @v dest              Final destination address
182  * @ret dest            Next hop destination address
183  * @ret miniroute       Routing table entry to use, or NULL if no route
184  */
185 static struct ipv4_miniroute * ipv4_route ( struct in_addr *dest ) {
186         struct ipv4_miniroute *miniroute;
187         int local;
188         int has_gw;
189
190         list_for_each_entry ( miniroute, &miniroutes, list ) {
191                 local = ( ( ( dest->s_addr ^ miniroute->address.s_addr )
192                             & miniroute->netmask.s_addr ) == 0 );
193                 has_gw = ( miniroute->gateway.s_addr != INADDR_NONE );
194                 if ( local || has_gw ) {
195                         if ( ! local )
196                                 *dest = miniroute->gateway;
197                         return miniroute;
198                 }
199         }
200
201         return NULL;
202 }
203
204 /**
205  * Fragment reassembly counter timeout
206  *
207  * @v timer     Retry timer
208  * @v over      If asserted, the timer is greater than @c MAX_TIMEOUT 
209  */
210 static void ipv4_frag_expired ( struct retry_timer *timer __unused,
211                                 int over ) {
212         if ( over ) {
213                 DBG ( "Fragment reassembly timeout" );
214                 /* Free the fragment buffer */
215         }
216 }
217
218 /**
219  * Free fragment buffer
220  *
221  * @v fragbug   Fragment buffer
222  */
223 static void free_fragbuf ( struct frag_buffer *fragbuf ) {
224         if ( fragbuf ) {
225                 free_dma ( fragbuf, sizeof ( *fragbuf ) );
226         }
227 }
228
229 /**
230  * Fragment reassembler
231  *
232  * @v pkb               Packet buffer, fragment of the datagram
233  * @ret frag_pkb        Reassembled packet, or NULL
234  */
235 static struct pk_buff * ipv4_reassemble ( struct pk_buff * pkb ) {
236         struct iphdr *iphdr = pkb->data;
237         struct frag_buffer *fragbuf;
238         
239         /**
240          * Check if the fragment belongs to any fragment series
241          */
242         list_for_each_entry ( fragbuf, &frag_buffers, list ) {
243                 if ( fragbuf->ident == iphdr->ident &&
244                      fragbuf->src.s_addr == iphdr->src.s_addr ) {
245                         /**
246                          * Check if the packet is the expected fragment
247                          * 
248                          * The offset of the new packet must be equal to the
249                          * length of the data accumulated so far (the length of
250                          * the reassembled packet buffer
251                          */
252                         if ( pkb_len ( fragbuf->frag_pkb ) == 
253                               ( iphdr->frags & IP_MASK_OFFSET ) ) {
254                                 /**
255                                  * Append the contents of the fragment to the
256                                  * reassembled packet buffer
257                                  */
258                                 pkb_pull ( pkb, sizeof ( *iphdr ) );
259                                 memcpy ( pkb_put ( fragbuf->frag_pkb,
260                                                         pkb_len ( pkb ) ),
261                                          pkb->data, pkb_len ( pkb ) );
262                                 free_pkb ( pkb );
263
264                                 /** Check if the fragment series is over */
265                                 if ( !iphdr->frags & IP_MASK_MOREFRAGS ) {
266                                         pkb = fragbuf->frag_pkb;
267                                         free_fragbuf ( fragbuf );
268                                         return pkb;
269                                 }
270
271                         } else {
272                                 /* Discard the fragment series */
273                                 free_fragbuf ( fragbuf );
274                                 free_pkb ( pkb );
275                         }
276                         return NULL;
277                 }
278         }
279         
280         /** Check if the fragment is the first in the fragment series */
281         if ( iphdr->frags & IP_MASK_MOREFRAGS &&
282                         ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
283         
284                 /** Create a new fragment buffer */
285                 fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
286                 fragbuf->ident = iphdr->ident;
287                 fragbuf->src = iphdr->src;
288
289                 /* Set up the reassembly packet buffer */
290                 fragbuf->frag_pkb = alloc_pkb ( IP_FRAG_PKB_SIZE );
291                 pkb_pull ( pkb, sizeof ( *iphdr ) );
292                 memcpy ( pkb_put ( fragbuf->frag_pkb, pkb_len ( pkb ) ),
293                          pkb->data, pkb_len ( pkb ) );
294                 free_pkb ( pkb );
295
296                 /* Set the reassembly timer */
297                 fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
298                 fragbuf->frag_timer.expired = ipv4_frag_expired;
299                 start_timer ( &fragbuf->frag_timer );
300
301                 /* Add the fragment buffer to the list of fragment buffers */
302                 list_add ( &fragbuf->list, &frag_buffers );
303         }
304         
305         return NULL;
306 }
307
308 /**
309  * Add IPv4 pseudo-header checksum to existing checksum
310  *
311  * @v pkb               Packet buffer
312  * @v csum              Existing checksum
313  * @ret csum            Updated checksum
314  */
315 static uint16_t ipv4_pshdr_chksum ( struct pk_buff *pkb, uint16_t csum ) {
316         struct ipv4_pseudo_header pshdr;
317         struct iphdr *iphdr = pkb->data;
318         size_t hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
319
320         /* Build pseudo-header */
321         pshdr.src = iphdr->src;
322         pshdr.dest = iphdr->dest;
323         pshdr.zero_padding = 0x00;
324         pshdr.protocol = iphdr->protocol;
325         pshdr.len = htons ( pkb_len ( pkb ) - hdrlen );
326
327         /* Update the checksum value */
328         return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
329 }
330
331 /**
332  * Determine link-layer address
333  *
334  * @v dest              IPv4 destination address
335  * @v src               IPv4 source address
336  * @v netdev            Network device
337  * @v ll_dest           Link-layer destination address buffer
338  * @ret rc              Return status code
339  */
340 static int ipv4_ll_addr ( struct in_addr dest, struct in_addr src,
341                           struct net_device *netdev, uint8_t *ll_dest ) {
342         struct ll_protocol *ll_protocol = netdev->ll_protocol;
343         uint8_t *dest_bytes = ( ( uint8_t * ) &dest );
344
345         if ( dest.s_addr == INADDR_BROADCAST ) {
346                 /* Broadcast address */
347                 memcpy ( ll_dest, ll_protocol->ll_broadcast,
348                          ll_protocol->ll_addr_len );
349                 return 0;
350         } else if ( IN_MULTICAST ( dest.s_addr ) ) {
351                 /* Special case: IPv4 multicast over Ethernet.  This
352                  * code may need to be generalised once we find out
353                  * what happens for other link layers.
354                  */
355                 ll_dest[0] = 0x01;
356                 ll_dest[1] = 0x00;
357                 ll_dest[2] = 0x5e;
358                 ll_dest[3] = dest_bytes[1] & 0x7f;
359                 ll_dest[4] = dest_bytes[2];
360                 ll_dest[5] = dest_bytes[3];
361                 return 0;
362         } else {
363                 /* Unicast address: resolve via ARP */
364                 return arp_resolve ( netdev, &ipv4_protocol, &dest,
365                                      &src, ll_dest );
366         }
367 }
368
369 /**
370  * Transmit IP packet
371  *
372  * @v pkb               Packet buffer
373  * @v tcpip             Transport-layer protocol
374  * @v st_dest           Destination network-layer address
375  * @v trans_csum        Transport-layer checksum to complete, or NULL
376  * @ret rc              Status
377  *
378  * This function expects a transport-layer segment and prepends the IP header
379  */
380 static int ipv4_tx ( struct pk_buff *pkb,
381                      struct tcpip_protocol *tcpip_protocol,
382                      struct sockaddr_tcpip *st_dest, uint16_t *trans_csum ) {
383         struct iphdr *iphdr = pkb_push ( pkb, sizeof ( *iphdr ) );
384         struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
385         struct ipv4_miniroute *miniroute;
386         struct in_addr next_hop;
387         uint8_t ll_dest[MAX_LL_ADDR_LEN];
388         int rc;
389
390         /* Fill up the IP header, except source address */
391         iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
392         iphdr->service = IP_TOS;
393         iphdr->len = htons ( pkb_len ( pkb ) ); 
394         iphdr->ident = htons ( ++next_ident );
395         iphdr->frags = 0;
396         iphdr->ttl = IP_TTL;
397         iphdr->protocol = tcpip_protocol->tcpip_proto;
398         iphdr->chksum = 0;
399         iphdr->dest = sin_dest->sin_addr;
400
401         /* Use routing table to identify next hop and transmitting netdev */
402         next_hop = iphdr->dest;
403         miniroute = ipv4_route ( &next_hop );
404         if ( ! miniroute ) {
405                 DBG ( "IPv4 has no route to %s\n", inet_ntoa ( iphdr->dest ) );
406                 rc = -EHOSTUNREACH;
407                 goto err;
408         }
409         iphdr->src = miniroute->address;
410
411         /* Determine link-layer destination address */
412         if ( ( rc = ipv4_ll_addr ( next_hop, iphdr->src, miniroute->netdev,
413                                    ll_dest ) ) != 0 ) {
414                 DBG ( "IPv4 has no link-layer address for %s\n",
415                       inet_ntoa ( iphdr->dest ) );
416                 goto err;
417         }
418
419         /* Fix up checksums */
420         if ( trans_csum )
421                 *trans_csum = ipv4_pshdr_chksum ( pkb, *trans_csum );
422         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
423
424         /* Print IP4 header for debugging */
425         DBG ( "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
426         DBG ( "%s len %d proto %d id %04x csum %04x\n",
427               inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ), iphdr->protocol,
428               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
429
430         /* Hand off to link layer */
431         return net_tx ( pkb, miniroute->netdev, &ipv4_protocol, ll_dest );
432
433  err:
434         free_pkb ( pkb );
435         return rc;
436 }
437
438 /**
439  * Process incoming packets
440  *
441  * @v pkb       Packet buffer
442  * @v netdev    Network device
443  * @v ll_source Link-layer destination source
444  *
445  * This function expects an IP4 network datagram. It processes the headers 
446  * and sends it to the transport layer.
447  */
448 static int ipv4_rx ( struct pk_buff *pkb, struct net_device *netdev __unused,
449                      const void *ll_source __unused ) {
450         struct iphdr *iphdr = pkb->data;
451         size_t hdrlen;
452         size_t len;
453         union {
454                 struct sockaddr_in sin;
455                 struct sockaddr_tcpip st;
456         } src, dest;
457         uint16_t csum;
458         uint16_t pshdr_csum;
459
460         /* Sanity check the IPv4 header */
461         if ( pkb_len ( pkb ) < sizeof ( *iphdr ) ) {
462                 DBG ( "IPv4 packet too short at %d bytes (min %d bytes)\n",
463                       pkb_len ( pkb ), sizeof ( *iphdr ) );
464                 goto err;
465         }
466         if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
467                 DBG ( "IPv4 version %#02x not supported\n", iphdr->verhdrlen );
468                 goto err;
469         }
470         hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
471         if ( hdrlen < sizeof ( *iphdr ) ) {
472                 DBG ( "IPv4 header too short at %d bytes (min %d bytes)\n",
473                       hdrlen, sizeof ( *iphdr ) );
474                 goto err;
475         }
476         if ( hdrlen > pkb_len ( pkb ) ) {
477                 DBG ( "IPv4 header too long at %d bytes "
478                       "(packet is %d bytes)\n", hdrlen, pkb_len ( pkb ) );
479                 goto err;
480         }
481         if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
482                 DBG ( "IPv4 checksum incorrect (is %04x including checksum "
483                       "field, should be 0000)\n", csum );
484                 goto err;
485         }
486         len = ntohs ( iphdr->len );
487         if ( len < hdrlen ) {
488                 DBG ( "IPv4 length too short at %d bytes "
489                       "(header is %d bytes)\n", len, hdrlen );
490                 goto err;
491         }
492         if ( len > pkb_len ( pkb ) ) {
493                 DBG ( "IPv4 length too long at %d bytes "
494                       "(packet is %d bytes)\n", len, pkb_len ( pkb ) );
495                 goto err;
496         }
497
498         /* Print IPv4 header for debugging */
499         DBG ( "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
500         DBG ( "%s len %d proto %d id %04x csum %04x\n",
501               inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
502               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
503
504         /* Truncate packet to correct length, calculate pseudo-header
505          * checksum and then strip off the IPv4 header.
506          */
507         pkb_unput ( pkb, ( pkb_len ( pkb ) - len ) );
508         pshdr_csum = ipv4_pshdr_chksum ( pkb, TCPIP_EMPTY_CSUM );
509         pkb_pull ( pkb, hdrlen );
510
511         /* Fragment reassembly */
512         if ( ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) ) || 
513              ( ( iphdr->frags & htons ( IP_MASK_OFFSET ) ) != 0 ) ) {
514                 /* Pass the fragment to ipv4_reassemble() which either
515                  * returns a fully reassembled packet buffer or NULL.
516                  */
517                 pkb = ipv4_reassemble ( pkb );
518                 if ( ! pkb )
519                         return 0;
520         }
521
522         /* Construct socket addresses and hand off to transport layer */
523         memset ( &src, 0, sizeof ( src ) );
524         src.sin.sin_family = AF_INET;
525         src.sin.sin_addr = iphdr->src;
526         memset ( &dest, 0, sizeof ( dest ) );
527         dest.sin.sin_family = AF_INET;
528         dest.sin.sin_addr = iphdr->dest;
529         return tcpip_rx ( pkb, iphdr->protocol, &src.st, &dest.st, pshdr_csum);
530
531  err:
532         free_pkb ( pkb );
533         return -EINVAL;
534 }
535
536 /** 
537  * Check existence of IPv4 address for ARP
538  *
539  * @v netdev            Network device
540  * @v net_addr          Network-layer address
541  * @ret rc              Return status code
542  */
543 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
544         const struct in_addr *address = net_addr;
545         struct ipv4_miniroute *miniroute;
546
547         list_for_each_entry ( miniroute, &miniroutes, list ) {
548                 if ( ( miniroute->netdev == netdev ) &&
549                      ( miniroute->address.s_addr == address->s_addr ) ) {
550                         /* Found matching address */
551                         return 0;
552                 }
553         }
554         return -ENOENT;
555 }
556
557 /**
558  * Convert IPv4 address to dotted-quad notation
559  *
560  * @v in        IP address
561  * @ret string  IP address in dotted-quad notation
562  */
563 char * inet_ntoa ( struct in_addr in ) {
564         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
565         uint8_t *bytes = ( uint8_t * ) &in;
566         
567         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
568         return buf;
569 }
570
571 /**
572  * Transcribe IP address
573  *
574  * @v net_addr  IP address
575  * @ret string  IP address in dotted-quad notation
576  *
577  */
578 static const char * ipv4_ntoa ( const void *net_addr ) {
579         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
580 }
581
582 /** IPv4 protocol */
583 struct net_protocol ipv4_protocol __net_protocol = {
584         .name = "IP",
585         .net_proto = htons ( ETH_P_IP ),
586         .net_addr_len = sizeof ( struct in_addr ),
587         .rx = ipv4_rx,
588         .ntoa = ipv4_ntoa,
589 };
590
591 /** IPv4 TCPIP net protocol */
592 struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol = {
593         .name = "IPv4",
594         .sa_family = AF_INET,
595         .tx = ipv4_tx,
596 };
597
598 /** IPv4 ARP protocol */
599 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
600         .net_protocol = &ipv4_protocol,
601         .check = ipv4_arp_check,
602 };