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