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