use malloc attribute
[people/meteger/gpxe.git] / src / net / ipv6.c
1 #include <errno.h>
2 #include <stdint.h>
3 #include <string.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <byteswap.h>
7 #include <gpxe/in.h>
8 #include <gpxe/ip6.h>
9 #include <gpxe/ndp.h>
10 #include <gpxe/list.h>
11 #include <gpxe/icmp6.h>
12 #include <gpxe/tcpip.h>
13 #include <gpxe/socket.h>
14 #include <gpxe/iobuf.h>
15 #include <gpxe/netdevice.h>
16 #include <gpxe/if_ether.h>
17
18 struct net_protocol ipv6_protocol;
19
20 /* Unspecified IP6 address */
21 static struct in6_addr ip6_none = {
22         .in6_u.u6_addr32[0] = 0,
23         .in6_u.u6_addr32[1] = 0,
24         .in6_u.u6_addr32[2] = 0,
25         .in6_u.u6_addr32[3] = 0,
26 };
27
28 /** An IPv6 routing table entry */
29 struct ipv6_miniroute {
30         /* List of miniroutes */
31         struct list_head list;
32
33         /* Network device */
34         struct net_device *netdev;
35
36         /* Destination prefix */
37         struct in6_addr prefix;
38         /* Prefix length */
39         int prefix_len;
40         /* IPv6 address of interface */
41         struct in6_addr address;
42         /* Gateway address */
43         struct in6_addr gateway;
44 };
45
46 /** List of IPv6 miniroutes */
47 static LIST_HEAD ( miniroutes );
48
49 /**
50  * Add IPv6 minirouting table entry
51  *
52  * @v netdev            Network device
53  * @v prefix            Destination prefix
54  * @v address           Address of the interface
55  * @v gateway           Gateway address (or ::0 for no gateway)
56  * @ret miniroute       Routing table entry, or NULL
57  */
58 static struct ipv6_miniroute * __malloc 
59 add_ipv6_miniroute ( struct net_device *netdev, struct in6_addr prefix,
60                      int prefix_len, struct in6_addr address,
61                      struct in6_addr gateway ) {
62         struct ipv6_miniroute *miniroute;
63         
64         miniroute = malloc ( sizeof ( *miniroute ) );
65         if ( miniroute ) {
66                 /* Record routing information */
67                 miniroute->netdev = netdev_get ( netdev );
68                 miniroute->prefix = prefix;
69                 miniroute->prefix_len = prefix_len;
70                 miniroute->address = address;
71                 miniroute->gateway = gateway;
72                 
73                 /* Add miniroute to list of miniroutes */
74                 if ( !IP6_EQUAL ( gateway, ip6_none ) ) {
75                         list_add_tail ( &miniroute->list, &miniroutes );
76                 } else {
77                         list_add ( &miniroute->list, &miniroutes );
78                 }
79         }
80
81         return miniroute;
82 }
83
84 /**
85  * Delete IPv6 minirouting table entry
86  *
87  * @v miniroute         Routing table entry
88  */
89 static void del_ipv6_miniroute ( struct ipv6_miniroute *miniroute ) {
90         netdev_put ( miniroute->netdev );
91         list_del ( &miniroute->list );
92         free ( miniroute );
93 }
94
95 /**
96  * Add IPv6 interface
97  *
98  * @v netdev    Network device
99  * @v prefix    Destination prefix
100  * @v address   Address of the interface
101  * @v gateway   Gateway address (or ::0 for no gateway)
102  */
103 int add_ipv6_address ( struct net_device *netdev, struct in6_addr prefix,
104                        int prefix_len, struct in6_addr address,
105                        struct in6_addr gateway ) {
106         struct ipv6_miniroute *miniroute;
107
108         /* Clear any existing address for this net device */
109         del_ipv6_address ( netdev );
110
111         /* Add new miniroute */
112         miniroute = add_ipv6_miniroute ( netdev, prefix, prefix_len, address,
113                                          gateway );
114         if ( ! miniroute )
115                 return -ENOMEM;
116
117         return 0;
118 }
119
120 /**
121  * Remove IPv6 interface
122  *
123  * @v netdev    Network device
124  */
125 void del_ipv6_address ( struct net_device *netdev ) {
126         struct ipv6_miniroute *miniroute;
127
128         list_for_each_entry ( miniroute, &miniroutes, list ) {
129                 if ( miniroute->netdev == netdev ) {
130                         del_ipv6_miniroute ( miniroute );
131                         break;
132                 }
133         }
134 }
135
136 /**
137  * Calculate TCPIP checksum
138  *
139  * @v iobuf     I/O buffer
140  * @v tcpip     TCP/IP protocol
141  *
142  * This function constructs the pseudo header and completes the checksum in the
143  * upper layer header.
144  */
145 static uint16_t ipv6_tx_csum ( struct io_buffer *iobuf, uint16_t csum ) {
146         struct ip6_header *ip6hdr = iobuf->data;
147         struct ipv6_pseudo_header pshdr;
148
149         /* Calculate pseudo header */
150         memset ( &pshdr, 0, sizeof ( pshdr ) );
151         pshdr.src = ip6hdr->src;
152         pshdr.dest = ip6hdr->dest;
153         pshdr.len = htons ( iob_len ( iobuf ) - sizeof ( *ip6hdr ) );
154         pshdr.nxt_hdr = ip6hdr->nxt_hdr;
155
156         /* Update checksum value */
157         return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
158 }
159
160 /**
161  * Dump IP6 header for debugging
162  *
163  * ip6hdr       IPv6 header
164  */
165 void ipv6_dump ( struct ip6_header *ip6hdr ) {
166         DBG ( "IP6 %p src %s dest %s nxt_hdr %d len %d\n", ip6hdr,
167               inet6_ntoa ( ip6hdr->src ), inet6_ntoa ( ip6hdr->dest ),
168               ip6hdr->nxt_hdr, ntohs ( ip6hdr->payload_len ) );
169 }
170
171 /**
172  * Transmit IP6 packet
173  *
174  * iobuf                I/O buffer
175  * tcpip        TCP/IP protocol
176  * st_dest      Destination socket address
177  *
178  * This function prepends the IPv6 headers to the payload an transmits it.
179  */
180 static int ipv6_tx ( struct io_buffer *iobuf,
181                      struct tcpip_protocol *tcpip,
182                      struct sockaddr_tcpip *st_dest,
183                      struct net_device *netdev,
184                      uint16_t *trans_csum ) {
185         struct sockaddr_in6 *dest = ( struct sockaddr_in6* ) st_dest;
186         struct in6_addr next_hop;
187         struct ipv6_miniroute *miniroute;
188         uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
189         const uint8_t *ll_dest = ll_dest_buf;
190         int rc;
191
192         /* Construct the IPv6 packet */
193         struct ip6_header *ip6hdr = iob_push ( iobuf, sizeof ( *ip6hdr ) );
194         memset ( ip6hdr, 0, sizeof ( *ip6hdr) );
195         ip6hdr->ver_traffic_class_flow_label = htonl ( 0x60000000 );//IP6_VERSION;
196         ip6hdr->payload_len = htons ( iob_len ( iobuf ) - sizeof ( *ip6hdr ) );
197         ip6hdr->nxt_hdr = tcpip->tcpip_proto;
198         ip6hdr->hop_limit = IP6_HOP_LIMIT; // 255
199
200         /* Determine the next hop address and interface
201          *
202          * TODO: Implement the routing table.
203          */
204         next_hop = dest->sin6_addr;
205         list_for_each_entry ( miniroute, &miniroutes, list ) {
206                 if ( ( memcmp ( &ip6hdr->dest, &miniroute->prefix,
207                                         miniroute->prefix_len ) == 0 ) ||
208                      ( IP6_EQUAL ( miniroute->gateway, ip6_none ) ) ) {
209                         netdev = miniroute->netdev;
210                         ip6hdr->src = miniroute->address;
211                         if ( ! ( IS_UNSPECIFIED ( miniroute->gateway ) ) ) {
212                                 next_hop = miniroute->gateway;
213                         }
214                         break;
215                 }
216         }
217         /* No network interface identified */
218         if ( !netdev ) {
219                 DBG ( "No route to host %s\n", inet6_ntoa ( ip6hdr->dest ) );
220                 rc = -ENETUNREACH;
221                 goto err;
222         }
223
224         /* Complete the transport layer checksum */
225         if ( trans_csum )
226                 *trans_csum = ipv6_tx_csum ( iobuf, *trans_csum );
227
228         /* Print IPv6 header */
229         ipv6_dump ( ip6hdr );
230         
231         /* Resolve link layer address */
232         if ( next_hop.in6_u.u6_addr8[0] == 0xff ) {
233                 ll_dest_buf[0] = 0x33;
234                 ll_dest_buf[1] = 0x33;
235                 ll_dest_buf[2] = next_hop.in6_u.u6_addr8[12];
236                 ll_dest_buf[3] = next_hop.in6_u.u6_addr8[13];
237                 ll_dest_buf[4] = next_hop.in6_u.u6_addr8[14];
238                 ll_dest_buf[5] = next_hop.in6_u.u6_addr8[15];
239         } else {
240                 /* Unicast address needs to be resolved by NDP */
241                 if ( ( rc = ndp_resolve ( netdev, &next_hop, &ip6hdr->src,
242                                           ll_dest_buf ) ) != 0 ) {
243                         DBG ( "No entry for %s\n", inet6_ntoa ( next_hop ) );
244                         goto err;
245                 }
246         }
247
248         /* Transmit packet */
249         return net_tx ( iobuf, netdev, &ipv6_protocol, ll_dest );
250
251   err:
252         free_iob ( iobuf );
253         return rc;
254 }
255
256 /**
257  * Process next IP6 header
258  *
259  * @v iobuf     I/O buffer
260  * @v nxt_hdr   Next header number
261  * @v src       Source socket address
262  * @v dest      Destination socket address
263  *
264  * Refer http://www.iana.org/assignments/ipv6-parameters for the numbers
265  */
266 static int ipv6_process_nxt_hdr ( struct io_buffer *iobuf, uint8_t nxt_hdr,
267                 struct sockaddr_tcpip *src, struct sockaddr_tcpip *dest ) {
268         switch ( nxt_hdr ) {
269         case IP6_HOPBYHOP: 
270         case IP6_ROUTING: 
271         case IP6_FRAGMENT: 
272         case IP6_AUTHENTICATION: 
273         case IP6_DEST_OPTS: 
274         case IP6_ESP: 
275                 DBG ( "Function not implemented for header %d\n", nxt_hdr );
276                 return -ENOSYS;
277         case IP6_ICMP6: 
278                 break;
279         case IP6_NO_HEADER: 
280                 DBG ( "No next header\n" );
281                 return 0;
282         }
283         /* Next header is not a IPv6 extension header */
284         return tcpip_rx ( iobuf, nxt_hdr, src, dest, 0 /* fixme */ );
285 }
286
287 /**
288  * Process incoming IP6 packets
289  *
290  * @v iobuf             I/O buffer
291  * @v netdev            Network device
292  * @v ll_source         Link-layer source address
293  *
294  * This function processes a IPv6 packet
295  */
296 static int ipv6_rx ( struct io_buffer *iobuf,
297                      __unused struct net_device *netdev,
298                      __unused const void *ll_source ) {
299
300         struct ip6_header *ip6hdr = iobuf->data;
301         union {
302                 struct sockaddr_in6 sin6;
303                 struct sockaddr_tcpip st;
304         } src, dest;
305
306         /* Sanity check */
307         if ( iob_len ( iobuf ) < sizeof ( *ip6hdr ) ) {
308                 DBG ( "Packet too short (%d bytes)\n", iob_len ( iobuf ) );
309                 goto drop;
310         }
311
312         /* TODO: Verify checksum */
313
314         /* Print IP6 header for debugging */
315         ipv6_dump ( ip6hdr );
316
317         /* Check header version */
318         if ( ( ip6hdr->ver_traffic_class_flow_label & 0xf0000000 ) != 0x60000000 ) {
319                 DBG ( "Invalid protocol version\n" );
320                 goto drop;
321         }
322
323         /* Check the payload length */
324         if ( ntohs ( ip6hdr->payload_len ) > iob_len ( iobuf ) ) {
325                 DBG ( "Inconsistent packet length (%d bytes)\n",
326                         ip6hdr->payload_len );
327                 goto drop;
328         }
329
330         /* Ignore the traffic class and flow control values */
331
332         /* Construct socket address */
333         memset ( &src, 0, sizeof ( src ) );
334         src.sin6.sin_family = AF_INET6;
335         src.sin6.sin6_addr = ip6hdr->src;
336         memset ( &dest, 0, sizeof ( dest ) );
337         dest.sin6.sin_family = AF_INET6;
338         dest.sin6.sin6_addr = ip6hdr->dest;
339
340         /* Strip header */
341         iob_unput ( iobuf, iob_len ( iobuf ) - ntohs ( ip6hdr->payload_len ) -
342                                                         sizeof ( *ip6hdr ) );
343         iob_pull ( iobuf, sizeof ( *ip6hdr ) );
344
345         /* Send it to the transport layer */
346         return ipv6_process_nxt_hdr ( iobuf, ip6hdr->nxt_hdr, &src.st, &dest.st );
347
348   drop:
349         DBG ( "Packet dropped\n" );
350         free_iob ( iobuf );
351         return -1;
352 }
353
354 /**
355  * Print a IP6 address as xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx
356  */
357 char * inet6_ntoa ( struct in6_addr in6 ) {
358         static char buf[40];
359         uint16_t *bytes = ( uint16_t* ) &in6;
360         sprintf ( buf, "%x:%x:%x:%x:%x:%x:%x:%x", bytes[0], bytes[1], bytes[2],
361                         bytes[3], bytes[4], bytes[5], bytes[6], bytes[7] );
362         return buf;
363 }
364
365 static const char * ipv6_ntoa ( const void *net_addr ) {
366         return inet6_ntoa ( * ( ( struct in6_addr * ) net_addr ) );
367 }
368
369 /** IPv6 protocol */
370 struct net_protocol ipv6_protocol __net_protocol = {
371         .name = "IPv6",
372         .net_proto = htons ( ETH_P_IPV6 ),
373         .net_addr_len = sizeof ( struct in6_addr ),
374         .rx = ipv6_rx,
375         .ntoa = ipv6_ntoa,
376 };
377
378 /** IPv6 TCPIP net protocol */
379 struct tcpip_net_protocol ipv6_tcpip_protocol __tcpip_net_protocol = {
380         .name = "IPv6",
381         .sa_family = AF_INET6,
382         .tx = ipv6_tx,
383 };