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 };