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