Minor changes to the network layer rx() functions
[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         DBG ( "IP4 header at %p+%#zx\n", iphdr, sizeof ( *iphdr ) );
111         DBG ( "\tVersion = %d\n", ( iphdr->verhdrlen & IP_MASK_VER ) / 16 );
112         DBG ( "\tHeader length = %d\n", iphdr->verhdrlen & IP_MASK_HLEN );
113         DBG ( "\tService = %d\n", iphdr->service );
114         DBG ( "\tTotal length = %d\n", ntohs ( iphdr->len ) );
115         DBG ( "\tIdent = %d\n", ntohs ( iphdr->ident ) );
116         DBG ( "\tFrags/Offset = %d\n", ntohs ( iphdr->frags ) );
117         DBG ( "\tIP TTL = %d\n", iphdr->ttl );
118         DBG ( "\tProtocol = %d\n", iphdr->protocol );
119         DBG ( "\tHeader Checksum (at %p) = %x\n", &iphdr->chksum, 
120                                 ntohs ( iphdr->chksum ) );
121         DBG ( "\tSource = %s\n", inet_ntoa ( iphdr->src ) );
122         DBG ( "\tDestination = %s\n", inet_ntoa ( iphdr->dest ) );
123 }
124
125 /**
126  * Fragment reassembly counter timeout
127  *
128  * @v timer     Retry timer
129  * @v over      If asserted, the timer is greater than @c MAX_TIMEOUT 
130  */
131 void ipv4_frag_expired ( struct retry_timer *timer __unused , int over ) {
132         if ( over ) {
133                 DBG ( "Fragment reassembly timeout" );
134                 /* Free the fragment buffer */
135         }
136 }
137
138 /**
139  * Free fragment buffer
140  *
141  * @v fragbug   Fragment buffer
142  */
143 void free_fragbuf ( struct frag_buffer *fragbuf ) {
144         if ( fragbuf ) {
145                 free_dma ( fragbuf, sizeof ( *fragbuf ) );
146         }
147 }
148
149 /**
150  * Fragment reassembler
151  *
152  * @v pkb               Packet buffer, fragment of the datagram
153  * @ret frag_pkb        Reassembled packet, or NULL
154  */
155 struct pk_buff * ipv4_reassemble ( struct pk_buff * pkb ) {
156         struct iphdr *iphdr = pkb->data;
157         struct frag_buffer *fragbuf;
158         
159         /**
160          * Check if the fragment belongs to any fragment series
161          */
162         list_for_each_entry ( fragbuf, &frag_buffers, list ) {
163                 if ( fragbuf->ident == iphdr->ident &&
164                      fragbuf->src.s_addr == iphdr->src.s_addr ) {
165                         /**
166                          * Check if the packet is the expected fragment
167                          * 
168                          * The offset of the new packet must be equal to the
169                          * length of the data accumulated so far (the length of
170                          * the reassembled packet buffer
171                          */
172                         if ( pkb_len ( fragbuf->frag_pkb ) == 
173                               ( iphdr->frags & IP_MASK_OFFSET ) ) {
174                                 /**
175                                  * Append the contents of the fragment to the
176                                  * reassembled packet buffer
177                                  */
178                                 pkb_pull ( pkb, sizeof ( *iphdr ) );
179                                 memcpy ( pkb_put ( fragbuf->frag_pkb,
180                                                         pkb_len ( pkb ) ),
181                                          pkb->data, pkb_len ( pkb ) );
182                                 free_pkb ( pkb );
183
184                                 /** Check if the fragment series is over */
185                                 if ( !iphdr->frags & IP_MASK_MOREFRAGS ) {
186                                         pkb = fragbuf->frag_pkb;
187                                         free_fragbuf ( fragbuf );
188                                         return pkb;
189                                 }
190
191                         } else {
192                                 /* Discard the fragment series */
193                                 free_fragbuf ( fragbuf );
194                                 free_pkb ( pkb );
195                         }
196                         return NULL;
197                 }
198         }
199         
200         /** Check if the fragment is the first in the fragment series */
201         if ( iphdr->frags & IP_MASK_MOREFRAGS &&
202                         ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
203         
204                 /** Create a new fragment buffer */
205                 fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
206                 fragbuf->ident = iphdr->ident;
207                 fragbuf->src = iphdr->src;
208
209                 /* Set up the reassembly packet buffer */
210                 fragbuf->frag_pkb = alloc_pkb ( IP_FRAG_PKB_SIZE );
211                 pkb_pull ( pkb, sizeof ( *iphdr ) );
212                 memcpy ( pkb_put ( fragbuf->frag_pkb, pkb_len ( pkb ) ),
213                          pkb->data, pkb_len ( pkb ) );
214                 free_pkb ( pkb );
215
216                 /* Set the reassembly timer */
217                 fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
218                 fragbuf->frag_timer.expired = ipv4_frag_expired;
219                 start_timer ( &fragbuf->frag_timer );
220
221                 /* Add the fragment buffer to the list of fragment buffers */
222                 list_add ( &fragbuf->list, &frag_buffers );
223         }
224         
225         return NULL;
226 }
227
228
229 /**
230  * Complete the transport-layer checksum
231  *
232  * @v pkb       Packet buffer
233  * @v tcpip     Transport-layer protocol
234  *
235  * This function calculates the tcpip 
236  */
237 void ipv4_tx_csum ( struct pk_buff *pkb, struct tcpip_protocol *tcpip ) {
238
239         struct iphdr *iphdr = pkb->data;
240         struct ipv4_pseudo_header pshdr;
241         uint16_t *csum = ( ( ( void * ) iphdr ) + sizeof ( *iphdr )
242                            + tcpip->csum_offset );
243
244         /* Calculate pseudo header */
245         pshdr.src = iphdr->src;
246         pshdr.dest = iphdr->dest;
247         pshdr.zero_padding = 0x00;
248         pshdr.protocol = iphdr->protocol;
249         pshdr.len = htons ( pkb_len ( pkb ) - sizeof ( *iphdr ) );
250
251         /* Update the checksum value */
252         *csum = tcpip_continue_chksum ( *csum, &pshdr, sizeof ( pshdr ) );
253 }
254
255 /**
256  * Calculate the transport-layer checksum while processing packets
257  */
258 uint16_t ipv4_rx_csum ( struct pk_buff *pkb __unused,
259                         uint8_t trans_proto __unused ) {
260         /** 
261          * This function needs to be implemented. Until then, it will return
262          * 0xffffffff every time
263          */
264         return 0xffff;
265 }
266
267 /**
268  * Transmit packet constructed by uIP
269  *
270  * @v pkb               Packet buffer
271  * @ret rc              Return status code
272  *
273  */
274 int ipv4_uip_tx ( struct pk_buff *pkb ) {
275         struct iphdr *iphdr = pkb->data;
276         struct ipv4_miniroute *miniroute;
277         struct net_device *netdev = NULL;
278         struct in_addr next_hop;
279         struct in_addr source;
280         uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
281         const uint8_t *ll_dest = ll_dest_buf;
282         int rc;
283
284         /* Use routing table to identify next hop and transmitting netdev */
285         next_hop = iphdr->dest;
286         list_for_each_entry ( miniroute, &miniroutes, list ) {
287                 if ( ( ( ( iphdr->dest.s_addr ^ miniroute->address.s_addr ) &
288                          miniroute->netmask.s_addr ) == 0 ) ||
289                      ( miniroute->gateway.s_addr != INADDR_NONE ) ) {
290                         netdev = miniroute->netdev;
291                         source = miniroute->address;
292                         if ( miniroute->gateway.s_addr != INADDR_NONE )
293                                 next_hop = miniroute->gateway;
294                         break;
295                 }
296         }
297
298         /* Abort if no network device identified */
299         if ( ! netdev ) {
300                 DBG ( "No route to %s\n", inet_ntoa ( iphdr->dest ) );
301                 rc = -EHOSTUNREACH;
302                 goto err;
303         }
304
305         /* Determine link-layer destination address */
306         if ( next_hop.s_addr == INADDR_BROADCAST ) {
307                 /* Broadcast address */
308                 ll_dest = netdev->ll_protocol->ll_broadcast;
309         } else if ( IN_MULTICAST ( next_hop.s_addr ) ) {
310                 /* Special case: IPv4 multicast over Ethernet.  This
311                  * code may need to be generalised once we find out
312                  * what happens for other link layers.
313                  */
314                 uint8_t *next_hop_bytes = ( uint8_t * ) &next_hop;
315                 ll_dest_buf[0] = 0x01;
316                 ll_dest_buf[0] = 0x00;
317                 ll_dest_buf[0] = 0x5e;
318                 ll_dest_buf[3] = next_hop_bytes[1] & 0x7f;
319                 ll_dest_buf[4] = next_hop_bytes[2];
320                 ll_dest_buf[5] = next_hop_bytes[3];
321         } else {
322                 /* Unicast address: resolve via ARP */
323                 if ( ( rc = arp_resolve ( netdev, &ipv4_protocol, &next_hop,
324                                           &source, ll_dest_buf ) ) != 0 ) {
325                         DBG ( "No ARP entry for %s\n",
326                               inet_ntoa ( iphdr->dest ) );
327                         goto err;
328                 }
329         }
330         
331         /* Hand off to link layer */
332         return net_tx ( pkb, netdev, &ipv4_protocol, ll_dest );
333
334  err:
335         free_pkb ( pkb );
336         return rc;
337 }
338
339 /**
340  * Transmit IP packet (without uIP)
341  *
342  * @v pkb               Packet buffer
343  * @v tcpip             Transport-layer protocol
344  * @v dest              Destination network-layer address
345  * @ret rc              Status
346  *
347  * This function expects a transport-layer segment and prepends the IP header
348  */
349 int ipv4_tx ( struct pk_buff *pkb, struct tcpip_protocol *tcpip,
350               struct sockaddr* sock ) {
351         struct in_addr *dest = &sock->sin.sin_addr;
352         struct iphdr *iphdr = pkb_push ( pkb, sizeof ( *iphdr ) );
353         struct ipv4_miniroute *miniroute;
354         struct net_device *netdev = NULL;
355         struct in_addr next_hop;
356         uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
357         const uint8_t *ll_dest = ll_dest_buf;
358         int rc;
359
360         /* Fill up the IP header, except source address */
361         iphdr->verhdrlen = ( IP_VER << 4 ) | ( sizeof ( *iphdr ) / 4 );
362         iphdr->service = IP_TOS;
363         iphdr->len = htons ( pkb_len ( pkb ) ); 
364         iphdr->ident = htons ( next_ident++ );
365         iphdr->frags = 0;
366         iphdr->ttl = IP_TTL;
367         iphdr->protocol = tcpip->trans_proto;
368
369         /* Copy destination address */
370         iphdr->dest = *dest;
371
372         /**
373          * All fields in the IP header filled in except the source network
374          * address (which requires routing) and the header checksum (which
375          * requires the source network address). As the pseudo header requires
376          * the source address as well and the transport-layer checksum is
377          * updated after routing.
378          *
379          * Continue processing as in ipv4_uip_tx()
380          */
381
382         /* Use routing table to identify next hop and transmitting netdev */
383         next_hop = iphdr->dest;
384         list_for_each_entry ( miniroute, &miniroutes, list ) {
385                 if ( ( ( ( iphdr->dest.s_addr ^ miniroute->address.s_addr ) &
386                          miniroute->netmask.s_addr ) == 0 ) ||
387                      ( miniroute->gateway.s_addr != INADDR_NONE ) ) {
388                         netdev = miniroute->netdev;
389                         iphdr->src = miniroute->address;
390                         if ( miniroute->gateway.s_addr != INADDR_NONE )
391                                 next_hop = miniroute->gateway;
392                         break;
393                 }
394         }
395         /* Abort if no network device identified */
396         if ( ! netdev ) {
397                 DBG ( "No route to %s\n", inet_ntoa ( iphdr->dest ) );
398                 rc = -EHOSTUNREACH;
399                 goto err;
400         }
401
402         /* Calculate the transport layer checksum */
403         if ( tcpip->csum_offset > 0 ) {
404                 ipv4_tx_csum ( pkb, tcpip );
405         }
406
407         /* Calculate header checksum, in network byte order */
408         iphdr->chksum = 0;
409         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
410
411         /* Print IP4 header for debugging */
412         ipv4_dump ( iphdr );
413
414         /* Determine link-layer destination address */
415         if ( next_hop.s_addr == INADDR_BROADCAST ) {
416                 /* Broadcast address */
417                 ll_dest = netdev->ll_protocol->ll_broadcast;
418         } else if ( IN_MULTICAST ( next_hop.s_addr ) ) {
419                 /* Special case: IPv4 multicast over Ethernet.  This
420                  * code may need to be generalised once we find out
421                  * what happens for other link layers.
422                  */
423                 uint8_t *next_hop_bytes = ( uint8_t * ) &next_hop;
424                 ll_dest_buf[0] = 0x01;
425                 ll_dest_buf[0] = 0x00;
426                 ll_dest_buf[0] = 0x5e;
427                 ll_dest_buf[3] = next_hop_bytes[1] & 0x7f;
428                 ll_dest_buf[4] = next_hop_bytes[2];
429                 ll_dest_buf[5] = next_hop_bytes[3];
430         } else {
431                 /* Unicast address: resolve via ARP */
432                 if ( ( rc = arp_resolve ( netdev, &ipv4_protocol, &next_hop,
433                                           &iphdr->src, ll_dest_buf ) ) != 0 ) {
434                         DBG ( "No ARP entry for %s\n",
435                               inet_ntoa ( iphdr->dest ) );
436                         goto err;
437                 }
438         }
439
440         /* Hand off to link layer */
441         return net_tx ( pkb, netdev, &ipv4_protocol, ll_dest );
442
443  err:
444         free_pkb ( pkb );
445         return rc;
446 }
447
448 /**
449  * Process incoming IP packets
450  *
451  * @v pkb               Packet buffer
452  * @v netdev            Network device
453  * @v ll_source         Link-layer source address
454  * @ret rc              Return status code
455  *
456  * This handles IP packets by handing them off to the uIP protocol
457  * stack.
458  */
459 static int ipv4_uip_rx ( struct pk_buff *pkb,
460                          struct net_device *netdev __unused,
461                          const void *ll_source __unused ) {
462
463         /* Transfer to uIP buffer.  Horrendously space-inefficient,
464          * but will do as a proof-of-concept for now.
465          */
466         uip_len = pkb_len ( pkb );
467         memcpy ( uip_buf, pkb->data, uip_len );
468         free_pkb ( pkb );
469
470         /* Hand to uIP for processing */
471         uip_input ();
472         if ( uip_len > 0 ) {
473                 pkb = alloc_pkb ( MAX_LL_HEADER_LEN + uip_len );
474                 if ( ! pkb )
475                         return -ENOMEM;
476                 pkb_reserve ( pkb, MAX_LL_HEADER_LEN );
477                 memcpy ( pkb_put ( pkb, uip_len ), uip_buf, uip_len );
478                 ipv4_uip_tx ( pkb );
479         }
480         return 0;
481 }
482
483 /**
484  * Process incoming packets (without uIP)
485  *
486  * @v pkb       Packet buffer
487  * @v netdev    Network device
488  * @v ll_source Link-layer destination source
489  *
490  * This function expects an IP4 network datagram. It processes the headers 
491  * and sends it to the transport layer.
492  */
493 void ipv4_rx ( struct pk_buff *pkb, struct net_device *netdev __unused,
494                         const void *ll_source __unused ) {
495         struct iphdr *iphdr = pkb->data;
496         struct in_addr *src = &iphdr->src;
497         struct in_addr *dest = &iphdr->dest;
498         uint16_t chksum;
499
500         /* Sanity check */
501         if ( pkb_len ( pkb ) < sizeof ( *iphdr ) ) {
502                 DBG ( "IP datagram too short (%d bytes)\n",
503                         pkb_len ( pkb ) );
504                 return;
505         }
506
507         /* Print IP4 header for debugging */
508         ipv4_dump ( iphdr );
509
510         /* Validate version and header length */
511         if ( iphdr->verhdrlen != 0x45 ) {
512                 DBG ( "Bad version and header length %x\n", iphdr->verhdrlen );
513                 return;
514         }
515
516         /* Validate length of IP packet */
517         if ( ntohs ( iphdr->len ) != pkb_len ( pkb ) ) {
518                 DBG ( "Inconsistent packet length %d\n",
519                                         ntohs ( iphdr->len ) );
520                 return;
521         }
522
523         /* Verify the checksum */
524         if ( ( chksum = ipv4_rx_csum ( pkb, iphdr->protocol ) ) != 0xffff ) {
525                 DBG ( "Bad checksum %x\n", chksum );
526         }
527         /* Fragment reassembly */
528         if ( iphdr->frags & IP_MASK_MOREFRAGS || 
529                 ( !iphdr->frags & IP_MASK_MOREFRAGS &&
530                         iphdr->frags & IP_MASK_OFFSET != 0 ) ) {
531                 /* Pass the fragment to the reassembler ipv4_ressable() which
532                  * either returns a fully reassembled packet buffer or NULL.
533                  */
534                 pkb = ipv4_reassemble ( pkb );
535                 if ( !pkb ) {
536                         return;
537                 }
538         }
539
540         /* To reduce code size, the following functions are not implemented:
541          * 1. Check the destination address
542          * 2. Check the TTL field
543          * 3. Check the service field
544          */
545
546         /* Strip header */
547         pkb_pull ( pkb, sizeof ( *iphdr ) );
548
549         /* Send it to the transport layer */
550         tcpip_rx ( pkb, iphdr->protocol, src, dest );
551 }
552
553 /** 
554  * Check existence of IPv4 address for ARP
555  *
556  * @v netdev            Network device
557  * @v net_addr          Network-layer address
558  * @ret rc              Return status code
559  */
560 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
561         const struct in_addr *address = net_addr;
562         struct ipv4_miniroute *miniroute;
563
564         list_for_each_entry ( miniroute, &miniroutes, list ) {
565                 if ( ( miniroute->netdev == netdev ) &&
566                      ( miniroute->address.s_addr == address->s_addr ) ) {
567                         /* Found matching address */
568                         return 0;
569                 }
570         }
571         return -ENOENT;
572 }
573
574 /**
575  * Convert IPv4 address to dotted-quad notation
576  *
577  * @v in        IP address
578  * @ret string  IP address in dotted-quad notation
579  */
580 char * inet_ntoa ( struct in_addr in ) {
581         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
582         uint8_t *bytes = ( uint8_t * ) &in;
583         
584         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
585         return buf;
586 }
587
588 /**
589  * Transcribe IP address
590  *
591  * @v net_addr  IP address
592  * @ret string  IP address in dotted-quad notation
593  *
594  */
595 static const char * ipv4_ntoa ( const void *net_addr ) {
596         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
597 }
598
599 /** IPv4 protocol */
600 struct net_protocol ipv4_protocol = {
601         .name = "IP",
602         .net_proto = htons ( ETH_P_IP ),
603         .net_addr_len = sizeof ( struct in_addr ),
604 #if USE_UIP
605         .rx = ipv4_uip_rx,
606 #else
607         .rx = ipv4_rx,
608 #endif
609         .ntoa = ipv4_ntoa,
610 };
611
612 NET_PROTOCOL ( ipv4_protocol );
613
614 /** IPv4 TCPIP net protocol */
615 struct tcpip_net_protocol ipv4_tcpip_protocol = {
616         .net_protocol = &ipv4_protocol,
617         .sa_family = AF_INET,
618         .tx = ipv4_tx,
619         .tx_csum = ipv4_tx_csum,
620 };
621
622 TCPIP_NET_PROTOCOL ( ipv4_tcpip_protocol );
623
624 /** IPv4 ARP protocol */
625 struct arp_net_protocol ipv4_arp_protocol = {
626         .net_protocol = &ipv4_protocol,
627         .check = ipv4_arp_check,
628 };
629
630 ARP_NET_PROTOCOL ( ipv4_arp_protocol );