Allow an explicit network device to be specified for IP-layer
[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 netdev            Network device (or NULL to route automatically)
376  * @v trans_csum        Transport-layer checksum to complete, or NULL
377  * @ret rc              Status
378  *
379  * This function expects a transport-layer segment and prepends the IP header
380  */
381 static int ipv4_tx ( struct pk_buff *pkb,
382                      struct tcpip_protocol *tcpip_protocol,
383                      struct sockaddr_tcpip *st_dest,
384                      struct net_device *netdev,
385                      uint16_t *trans_csum ) {
386         struct iphdr *iphdr = pkb_push ( pkb, sizeof ( *iphdr ) );
387         struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
388         struct ipv4_miniroute *miniroute;
389         struct in_addr next_hop;
390         uint8_t ll_dest[MAX_LL_ADDR_LEN];
391         int rc;
392
393         /* Fill up the IP header, except source address */
394         memset ( iphdr, 0, sizeof ( *iphdr ) );
395         iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
396         iphdr->service = IP_TOS;
397         iphdr->len = htons ( pkb_len ( pkb ) ); 
398         iphdr->ident = htons ( ++next_ident );
399         iphdr->ttl = IP_TTL;
400         iphdr->protocol = tcpip_protocol->tcpip_proto;
401         iphdr->dest = sin_dest->sin_addr;
402
403         /* Use routing table to identify next hop and transmitting netdev */
404         next_hop = iphdr->dest;
405         if ( ( miniroute = ipv4_route ( &next_hop ) ) ) {
406                 iphdr->src = miniroute->address;
407                 netdev = miniroute->netdev;
408         }
409         if ( ! netdev ) {
410                 DBG ( "IPv4 has no route to %s\n", inet_ntoa ( iphdr->dest ) );
411                 rc = -EHOSTUNREACH;
412                 goto err;
413         }
414
415         /* Determine link-layer destination address */
416         if ( ( rc = ipv4_ll_addr ( next_hop, iphdr->src, netdev,
417                                    ll_dest ) ) != 0 ) {
418                 DBG ( "IPv4 has no link-layer address for %s\n",
419                       inet_ntoa ( iphdr->dest ) );
420                 goto err;
421         }
422
423         /* Fix up checksums */
424         if ( trans_csum )
425                 *trans_csum = ipv4_pshdr_chksum ( pkb, *trans_csum );
426         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
427
428         /* Print IP4 header for debugging */
429         DBG ( "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
430         DBG ( "%s len %d proto %d id %04x csum %04x\n",
431               inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ), iphdr->protocol,
432               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
433
434         /* Hand off to link layer */
435         return net_tx ( pkb, netdev, &ipv4_protocol, ll_dest );
436
437  err:
438         free_pkb ( pkb );
439         return rc;
440 }
441
442 /**
443  * Process incoming packets
444  *
445  * @v pkb       Packet buffer
446  * @v netdev    Network device
447  * @v ll_source Link-layer destination source
448  *
449  * This function expects an IP4 network datagram. It processes the headers 
450  * and sends it to the transport layer.
451  */
452 static int ipv4_rx ( struct pk_buff *pkb, struct net_device *netdev __unused,
453                      const void *ll_source __unused ) {
454         struct iphdr *iphdr = pkb->data;
455         size_t hdrlen;
456         size_t len;
457         union {
458                 struct sockaddr_in sin;
459                 struct sockaddr_tcpip st;
460         } src, dest;
461         uint16_t csum;
462         uint16_t pshdr_csum;
463
464         /* Sanity check the IPv4 header */
465         if ( pkb_len ( pkb ) < sizeof ( *iphdr ) ) {
466                 DBG ( "IPv4 packet too short at %d bytes (min %d bytes)\n",
467                       pkb_len ( pkb ), sizeof ( *iphdr ) );
468                 goto err;
469         }
470         if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
471                 DBG ( "IPv4 version %#02x not supported\n", iphdr->verhdrlen );
472                 goto err;
473         }
474         hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
475         if ( hdrlen < sizeof ( *iphdr ) ) {
476                 DBG ( "IPv4 header too short at %d bytes (min %d bytes)\n",
477                       hdrlen, sizeof ( *iphdr ) );
478                 goto err;
479         }
480         if ( hdrlen > pkb_len ( pkb ) ) {
481                 DBG ( "IPv4 header too long at %d bytes "
482                       "(packet is %d bytes)\n", hdrlen, pkb_len ( pkb ) );
483                 goto err;
484         }
485         if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
486                 DBG ( "IPv4 checksum incorrect (is %04x including checksum "
487                       "field, should be 0000)\n", csum );
488                 goto err;
489         }
490         len = ntohs ( iphdr->len );
491         if ( len < hdrlen ) {
492                 DBG ( "IPv4 length too short at %d bytes "
493                       "(header is %d bytes)\n", len, hdrlen );
494                 goto err;
495         }
496         if ( len > pkb_len ( pkb ) ) {
497                 DBG ( "IPv4 length too long at %d bytes "
498                       "(packet is %d bytes)\n", len, pkb_len ( pkb ) );
499                 goto err;
500         }
501
502         /* Print IPv4 header for debugging */
503         DBG ( "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
504         DBG ( "%s len %d proto %d id %04x csum %04x\n",
505               inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
506               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
507
508         /* Truncate packet to correct length, calculate pseudo-header
509          * checksum and then strip off the IPv4 header.
510          */
511         pkb_unput ( pkb, ( pkb_len ( pkb ) - len ) );
512         pshdr_csum = ipv4_pshdr_chksum ( pkb, TCPIP_EMPTY_CSUM );
513         pkb_pull ( pkb, hdrlen );
514
515         /* Fragment reassembly */
516         if ( ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) ) || 
517              ( ( iphdr->frags & htons ( IP_MASK_OFFSET ) ) != 0 ) ) {
518                 /* Pass the fragment to ipv4_reassemble() which either
519                  * returns a fully reassembled packet buffer or NULL.
520                  */
521                 pkb = ipv4_reassemble ( pkb );
522                 if ( ! pkb )
523                         return 0;
524         }
525
526         /* Construct socket addresses and hand off to transport layer */
527         memset ( &src, 0, sizeof ( src ) );
528         src.sin.sin_family = AF_INET;
529         src.sin.sin_addr = iphdr->src;
530         memset ( &dest, 0, sizeof ( dest ) );
531         dest.sin.sin_family = AF_INET;
532         dest.sin.sin_addr = iphdr->dest;
533         return tcpip_rx ( pkb, iphdr->protocol, &src.st, &dest.st, pshdr_csum);
534
535  err:
536         free_pkb ( pkb );
537         return -EINVAL;
538 }
539
540 /** 
541  * Check existence of IPv4 address for ARP
542  *
543  * @v netdev            Network device
544  * @v net_addr          Network-layer address
545  * @ret rc              Return status code
546  */
547 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
548         const struct in_addr *address = net_addr;
549         struct ipv4_miniroute *miniroute;
550
551         list_for_each_entry ( miniroute, &miniroutes, list ) {
552                 if ( ( miniroute->netdev == netdev ) &&
553                      ( miniroute->address.s_addr == address->s_addr ) ) {
554                         /* Found matching address */
555                         return 0;
556                 }
557         }
558         return -ENOENT;
559 }
560
561 /**
562  * Convert IPv4 address to dotted-quad notation
563  *
564  * @v in        IP address
565  * @ret string  IP address in dotted-quad notation
566  */
567 char * inet_ntoa ( struct in_addr in ) {
568         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
569         uint8_t *bytes = ( uint8_t * ) &in;
570         
571         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
572         return buf;
573 }
574
575 /**
576  * Transcribe IP address
577  *
578  * @v net_addr  IP address
579  * @ret string  IP address in dotted-quad notation
580  *
581  */
582 static const char * ipv4_ntoa ( const void *net_addr ) {
583         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
584 }
585
586 /** IPv4 protocol */
587 struct net_protocol ipv4_protocol __net_protocol = {
588         .name = "IP",
589         .net_proto = htons ( ETH_P_IP ),
590         .net_addr_len = sizeof ( struct in_addr ),
591         .rx = ipv4_rx,
592         .ntoa = ipv4_ntoa,
593 };
594
595 /** IPv4 TCPIP net protocol */
596 struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol = {
597         .name = "IPv4",
598         .sa_family = AF_INET,
599         .tx = ipv4_tx,
600 };
601
602 /** IPv4 ARP protocol */
603 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
604         .net_protocol = &ipv4_protocol,
605         .check = ipv4_arp_check,
606 };