src/net/ipv4.c

   1 #include <string.h>
   2 #include <stdint.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <errno.h>
   6 #include <byteswap.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/iobuf.h>
  12 #include <gpxe/netdevice.h>
  13 #include <gpxe/ip.h>
  14 #include <gpxe/tcpip.h>
  15
  16 /** @file
  17  *
  18  * IPv4 protocol
  19  *
  20  */
  21
  22 /* Unique IP datagram identification number */
  23 static uint16_t next_ident = 0;
  24
  25 struct net_protocol ipv4_protocol;
  26
  27 /** List of IPv4 miniroutes */
  28 struct list_head ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes );
  29
  30 /** List of fragment reassembly buffers */
  31 static LIST_HEAD ( frag_buffers );
  32
  33 /**
  34  * Add IPv4 minirouting table entry
  35  *
  36  * @v netdev            Network device
  37  * @v address           IPv4 address
  38  * @v netmask           Subnet mask
  39  * @v gateway           Gateway address (or @c INADDR_NONE for no gateway)
  40  * @ret miniroute       Routing table entry, or NULL
  41  */
  42 static struct ipv4_miniroute * add_ipv4_miniroute ( struct net_device *netdev,
  43                                                     struct in_addr address,
  44                                                     struct in_addr netmask,
  45                                                     struct in_addr gateway ) {
  46         struct ipv4_miniroute *miniroute;
  47
  48         DBG ( "IPv4 add %s", inet_ntoa ( address ) );
  49         DBG ( "/%s ", inet_ntoa ( netmask ) );
  50         if ( gateway.s_addr != INADDR_NONE )
  51                 DBG ( "gw %s ", inet_ntoa ( gateway ) );
  52         DBG ( "via %s\n", netdev->name );
  53
  54         /* Allocate and populate miniroute structure */
  55         miniroute = malloc ( sizeof ( *miniroute ) );
  56         if ( ! miniroute ) {
  57                 DBG ( "IPv4 could not add miniroute\n" );
  58                 return NULL;
  59         }
  60
  61         /* Record routing information */
  62         miniroute->netdev = netdev_get ( netdev );
  63         miniroute->address = address;
  64         miniroute->netmask = netmask;
  65         miniroute->gateway = gateway;
  66
  67         /* Add to end of list if we have a gateway, otherwise
  68          * to start of list.
  69          */
  70         if ( gateway.s_addr != INADDR_NONE ) {
  71                 list_add_tail ( &miniroute->list, &ipv4_miniroutes );
  72         } else {
  73                 list_add ( &miniroute->list, &ipv4_miniroutes );
  74         }
  75
  76         return miniroute;
  77 }
  78
  79 /**
  80  * Delete IPv4 minirouting table entry
  81  *
  82  * @v miniroute         Routing table entry
  83  */
  84 static void del_ipv4_miniroute ( struct ipv4_miniroute *miniroute ) {
  85
  86         DBG ( "IPv4 del %s", inet_ntoa ( miniroute->address ) );
  87         DBG ( "/%s ", inet_ntoa ( miniroute->netmask ) );
  88         if ( miniroute->gateway.s_addr != INADDR_NONE )
  89                 DBG ( "gw %s ", inet_ntoa ( miniroute->gateway ) );
  90         DBG ( "via %s\n", miniroute->netdev->name );
  91
  92         netdev_put ( miniroute->netdev );
  93         list_del ( &miniroute->list );
  94         free ( miniroute );
  95 }
  96
  97 /**
  98  * Add IPv4 interface
  99  *
 100  * @v netdev    Network device
 101  * @v address   IPv4 address
 102  * @v netmask   Subnet mask
 103  * @v gateway   Gateway address (or @c INADDR_NONE for no gateway)
 104  * @ret rc      Return status code
 105  *
 106  */
 107 int add_ipv4_address ( struct net_device *netdev, struct in_addr address,
 108                        struct in_addr netmask, struct in_addr gateway ) {
 109         struct ipv4_miniroute *miniroute;
 110
 111         /* Clear any existing address for this net device */
 112         del_ipv4_address ( netdev );
 113
 114         /* Add new miniroute */
 115         miniroute = add_ipv4_miniroute ( netdev, address, netmask, gateway );
 116         if ( ! miniroute )
 117                 return -ENOMEM;
 118
 119         return 0;
 120 }
 121
 122 /**
 123  * Remove IPv4 interface
 124  *
 125  * @v netdev    Network device
 126  */
 127 void del_ipv4_address ( struct net_device *netdev ) {
 128         struct ipv4_miniroute *miniroute;
 129
 130         list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
 131                 if ( miniroute->netdev == netdev ) {
 132                         del_ipv4_miniroute ( miniroute );
 133                         break;
 134                 }
 135         }
 136 }
 137
 138 /**
 139  * Perform IPv4 routing
 140  *
 141  * @v dest              Final destination address
 142  * @ret dest            Next hop destination address
 143  * @ret miniroute       Routing table entry to use, or NULL if no route
 144  *
 145  * If the route requires use of a gateway, the next hop destination
 146  * address will be overwritten with the gateway address.
 147  */
 148 static struct ipv4_miniroute * ipv4_route ( struct in_addr *dest ) {
 149         struct ipv4_miniroute *miniroute;
 150         int local;
 151         int has_gw;
 152
 153         /* Never attempt to route the broadcast address */
 154         if ( dest->s_addr == INADDR_BROADCAST )
 155                 return NULL;
 156
 157         /* Find first usable route in routing table */
 158         list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
 159                 local = ( ( ( dest->s_addr ^ miniroute->address.s_addr )
 160                             & miniroute->netmask.s_addr ) == 0 );
 161                 has_gw = ( miniroute->gateway.s_addr != INADDR_NONE );
 162                 if ( local || has_gw ) {
 163                         if ( ! local )
 164                                 *dest = miniroute->gateway;
 165                         return miniroute;
 166                 }
 167         }
 168
 169         return NULL;
 170 }
 171
 172 /**
 173  * Fragment reassembly counter timeout
 174  *
 175  * @v timer     Retry timer
 176  * @v over      If asserted, the timer is greater than @c MAX_TIMEOUT
 177  */
 178 static void ipv4_frag_expired ( struct retry_timer *timer __unused,
 179                                 int over ) {
 180         if ( over ) {
 181                 DBG ( "Fragment reassembly timeout" );
 182                 /* Free the fragment buffer */
 183         }
 184 }
 185
 186 /**
 187  * Free fragment buffer
 188  *
 189  * @v fragbug   Fragment buffer
 190  */
 191 static void free_fragbuf ( struct frag_buffer *fragbuf ) {
 192         free ( fragbuf );
 193 }
 194
 195 /**
 196  * Fragment reassembler
 197  *
 198  * @v iobuf             I/O buffer, fragment of the datagram
 199  * @ret frag_iob        Reassembled packet, or NULL
 200  */
 201 static struct io_buffer * ipv4_reassemble ( struct io_buffer * iobuf ) {
 202         struct iphdr *iphdr = iobuf->data;
 203         struct frag_buffer *fragbuf;
 204
 205         /**
 206          * Check if the fragment belongs to any fragment series
 207          */
 208         list_for_each_entry ( fragbuf, &frag_buffers, list ) {
 209                 if ( fragbuf->ident == iphdr->ident &&
 210                      fragbuf->src.s_addr == iphdr->src.s_addr ) {
 211                         /**
 212                          * Check if the packet is the expected fragment
 213                          *
 214                          * The offset of the new packet must be equal to the
 215                          * length of the data accumulated so far (the length of
 216                          * the reassembled I/O buffer
 217                          */
 218                         if ( iob_len ( fragbuf->frag_iob ) ==
 219                               ( iphdr->frags & IP_MASK_OFFSET ) ) {
 220                                 /**
 221                                  * Append the contents of the fragment to the
 222                                  * reassembled I/O buffer
 223                                  */
 224                                 iob_pull ( iobuf, sizeof ( *iphdr ) );
 225                                 memcpy ( iob_put ( fragbuf->frag_iob,
 226                                                         iob_len ( iobuf ) ),
 227                                          iobuf->data, iob_len ( iobuf ) );
 228                                 free_iob ( iobuf );
 229
 230                                 /** Check if the fragment series is over */
 231                                 if ( !iphdr->frags & IP_MASK_MOREFRAGS ) {
 232                                         iobuf = fragbuf->frag_iob;
 233                                         free_fragbuf ( fragbuf );
 234                                         return iobuf;
 235                                 }
 236
 237                         } else {
 238                                 /* Discard the fragment series */
 239                                 free_fragbuf ( fragbuf );
 240                                 free_iob ( iobuf );
 241                         }
 242                         return NULL;
 243                 }
 244         }
 245
 246         /** Check if the fragment is the first in the fragment series */
 247         if ( iphdr->frags & IP_MASK_MOREFRAGS &&
 248                         ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
 249
 250                 /** Create a new fragment buffer */
 251                 fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
 252                 fragbuf->ident = iphdr->ident;
 253                 fragbuf->src = iphdr->src;
 254
 255                 /* Set up the reassembly I/O buffer */
 256                 fragbuf->frag_iob = alloc_iob ( IP_FRAG_IOB_SIZE );
 257                 iob_pull ( iobuf, sizeof ( *iphdr ) );
 258                 memcpy ( iob_put ( fragbuf->frag_iob, iob_len ( iobuf ) ),
 259                          iobuf->data, iob_len ( iobuf ) );
 260                 free_iob ( iobuf );
 261
 262                 /* Set the reassembly timer */
 263                 fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
 264                 fragbuf->frag_timer.expired = ipv4_frag_expired;
 265                 start_timer ( &fragbuf->frag_timer );
 266
 267                 /* Add the fragment buffer to the list of fragment buffers */
 268                 list_add ( &fragbuf->list, &frag_buffers );
 269         }
 270
 271         return NULL;
 272 }
 273
 274 /**
 275  * Add IPv4 pseudo-header checksum to existing checksum
 276  *
 277  * @v iobuf             I/O buffer
 278  * @v csum              Existing checksum
 279  * @ret csum            Updated checksum
 280  */
 281 static uint16_t ipv4_pshdr_chksum ( struct io_buffer *iobuf, uint16_t csum ) {
 282         struct ipv4_pseudo_header pshdr;
 283         struct iphdr *iphdr = iobuf->data;
 284         size_t hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
 285
 286         /* Build pseudo-header */
 287         pshdr.src = iphdr->src;
 288         pshdr.dest = iphdr->dest;
 289         pshdr.zero_padding = 0x00;
 290         pshdr.protocol = iphdr->protocol;
 291         pshdr.len = htons ( iob_len ( iobuf ) - hdrlen );
 292
 293         /* Update the checksum value */
 294         return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
 295 }
 296
 297 /**
 298  * Determine link-layer address
 299  *
 300  * @v dest              IPv4 destination address
 301  * @v src               IPv4 source address
 302  * @v netdev            Network device
 303  * @v ll_dest           Link-layer destination address buffer
 304  * @ret rc              Return status code
 305  */
 306 static int ipv4_ll_addr ( struct in_addr dest, struct in_addr src,
 307                           struct net_device *netdev, uint8_t *ll_dest ) {
 308         struct ll_protocol *ll_protocol = netdev->ll_protocol;
 309         uint8_t *dest_bytes = ( ( uint8_t * ) &dest );
 310
 311         if ( dest.s_addr == INADDR_BROADCAST ) {
 312                 /* Broadcast address */
 313                 memcpy ( ll_dest, ll_protocol->ll_broadcast,
 314                          ll_protocol->ll_addr_len );
 315                 return 0;
 316         } else if ( IN_MULTICAST ( dest.s_addr ) ) {
 317                 /* Special case: IPv4 multicast over Ethernet.  This
 318                  * code may need to be generalised once we find out
 319                  * what happens for other link layers.
 320                  */
 321                 ll_dest[0] = 0x01;
 322                 ll_dest[1] = 0x00;
 323                 ll_dest[2] = 0x5e;
 324                 ll_dest[3] = dest_bytes[1] & 0x7f;
 325                 ll_dest[4] = dest_bytes[2];
 326                 ll_dest[5] = dest_bytes[3];
 327                 return 0;
 328         } else {
 329                 /* Unicast address: resolve via ARP */
 330                 return arp_resolve ( netdev, &ipv4_protocol, &dest,
 331                                      &src, ll_dest );
 332         }
 333 }
 334
 335 /**
 336  * Transmit IP packet
 337  *
 338  * @v iobuf             I/O buffer
 339  * @v tcpip             Transport-layer protocol
 340  * @v st_dest           Destination network-layer address
 341  * @v netdev            Network device to use if no route found, or NULL
 342  * @v trans_csum        Transport-layer checksum to complete, or NULL
 343  * @ret rc              Status
 344  *
 345  * This function expects a transport-layer segment and prepends the IP header
 346  */
 347 static int ipv4_tx ( struct io_buffer *iobuf,
 348                      struct tcpip_protocol *tcpip_protocol,
 349                      struct sockaddr_tcpip *st_dest,
 350                      struct net_device *netdev,
 351                      uint16_t *trans_csum ) {
 352         struct iphdr *iphdr = iob_push ( iobuf, sizeof ( *iphdr ) );
 353         struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
 354         struct ipv4_miniroute *miniroute;
 355         struct in_addr next_hop;
 356         uint8_t ll_dest[MAX_LL_ADDR_LEN];
 357         int rc;
 358
 359         /* Fill up the IP header, except source address */
 360         memset ( iphdr, 0, sizeof ( *iphdr ) );
 361         iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
 362         iphdr->service = IP_TOS;
 363         iphdr->len = htons ( iob_len ( iobuf ) );
 364         iphdr->ident = htons ( ++next_ident );
 365         iphdr->ttl = IP_TTL;
 366         iphdr->protocol = tcpip_protocol->tcpip_proto;
 367         iphdr->dest = sin_dest->sin_addr;
 368
 369         /* Use routing table to identify next hop and transmitting netdev */
 370         next_hop = iphdr->dest;
 371         if ( ( miniroute = ipv4_route ( &next_hop ) ) ) {
 372                 iphdr->src = miniroute->address;
 373                 netdev = miniroute->netdev;
 374         }
 375         if ( ! netdev ) {
 376                 DBG ( "IPv4 has no route to %s\n", inet_ntoa ( iphdr->dest ) );
 377                 rc = -ENETUNREACH;
 378                 goto err;
 379         }
 380
 381         /* Determine link-layer destination address */
 382         if ( ( rc = ipv4_ll_addr ( next_hop, iphdr->src, netdev,
 383                                    ll_dest ) ) != 0 ) {
 384                 DBG ( "IPv4 has no link-layer address for %s: %s\n",
 385                       inet_ntoa ( next_hop ), strerror ( rc ) );
 386                 goto err;
 387         }
 388
 389         /* Fix up checksums */
 390         if ( trans_csum )
 391                 *trans_csum = ipv4_pshdr_chksum ( iobuf, *trans_csum );
 392         iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
 393
 394         /* Print IP4 header for debugging */
 395         DBG ( "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
 396         DBG ( "%s len %d proto %d id %04x csum %04x\n",
 397               inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ), iphdr->protocol,
 398               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
 399
 400         /* Hand off to link layer */
 401         if ( ( rc = net_tx ( iobuf, netdev, &ipv4_protocol, ll_dest ) ) != 0 ) {
 402                 DBG ( "IPv4 could not transmit packet via %s: %s\n",
 403                       netdev->name, strerror ( rc ) );
 404                 return rc;
 405         }
 406
 407         return 0;
 408
 409  err:
 410         free_iob ( iobuf );
 411         return rc;
 412 }
 413
 414 /**
 415  * Process incoming packets
 416  *
 417  * @v iobuf     I/O buffer
 418  * @v netdev    Network device
 419  * @v ll_source Link-layer destination source
 420  *
 421  * This function expects an IP4 network datagram. It processes the headers
 422  * and sends it to the transport layer.
 423  */
 424 static int ipv4_rx ( struct io_buffer *iobuf, struct net_device *netdev __unused,
 425                      const void *ll_source __unused ) {
 426         struct iphdr *iphdr = iobuf->data;
 427         size_t hdrlen;
 428         size_t len;
 429         union {
 430                 struct sockaddr_in sin;
 431                 struct sockaddr_tcpip st;
 432         } src, dest;
 433         uint16_t csum;
 434         uint16_t pshdr_csum;
 435         int rc;
 436
 437         /* Sanity check the IPv4 header */
 438         if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
 439                 DBG ( "IPv4 packet too short at %d bytes (min %d bytes)\n",
 440                       iob_len ( iobuf ), sizeof ( *iphdr ) );
 441                 goto err;
 442         }
 443         if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
 444                 DBG ( "IPv4 version %#02x not supported\n", iphdr->verhdrlen );
 445                 goto err;
 446         }
 447         hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
 448         if ( hdrlen < sizeof ( *iphdr ) ) {
 449                 DBG ( "IPv4 header too short at %d bytes (min %d bytes)\n",
 450                       hdrlen, sizeof ( *iphdr ) );
 451                 goto err;
 452         }
 453         if ( hdrlen > iob_len ( iobuf ) ) {
 454                 DBG ( "IPv4 header too long at %d bytes "
 455                       "(packet is %d bytes)\n", hdrlen, iob_len ( iobuf ) );
 456                 goto err;
 457         }
 458         if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
 459                 DBG ( "IPv4 checksum incorrect (is %04x including checksum "
 460                       "field, should be 0000)\n", csum );
 461                 goto err;
 462         }
 463         len = ntohs ( iphdr->len );
 464         if ( len < hdrlen ) {
 465                 DBG ( "IPv4 length too short at %d bytes "
 466                       "(header is %d bytes)\n", len, hdrlen );
 467                 goto err;
 468         }
 469         if ( len > iob_len ( iobuf ) ) {
 470                 DBG ( "IPv4 length too long at %d bytes "
 471                       "(packet is %d bytes)\n", len, iob_len ( iobuf ) );
 472                 goto err;
 473         }
 474
 475         /* Print IPv4 header for debugging */
 476         DBG ( "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
 477         DBG ( "%s len %d proto %d id %04x csum %04x\n",
 478               inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
 479               ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
 480
 481         /* Truncate packet to correct length, calculate pseudo-header
 482          * checksum and then strip off the IPv4 header.
 483          */
 484         iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
 485         pshdr_csum = ipv4_pshdr_chksum ( iobuf, TCPIP_EMPTY_CSUM );
 486         iob_pull ( iobuf, hdrlen );
 487
 488         /* Fragment reassembly */
 489         if ( ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) ) ||
 490              ( ( iphdr->frags & htons ( IP_MASK_OFFSET ) ) != 0 ) ) {
 491                 /* Pass the fragment to ipv4_reassemble() which either
 492                  * returns a fully reassembled I/O buffer or NULL.
 493                  */
 494                 iobuf = ipv4_reassemble ( iobuf );
 495                 if ( ! iobuf )
 496                         return 0;
 497         }
 498
 499         /* Construct socket addresses and hand off to transport layer */
 500         memset ( &src, 0, sizeof ( src ) );
 501         src.sin.sin_family = AF_INET;
 502         src.sin.sin_addr = iphdr->src;
 503         memset ( &dest, 0, sizeof ( dest ) );
 504         dest.sin.sin_family = AF_INET;
 505         dest.sin.sin_addr = iphdr->dest;
 506         if ( ( rc = tcpip_rx ( iobuf, iphdr->protocol, &src.st,
 507                                &dest.st, pshdr_csum ) ) != 0 ) {
 508                 DBG ( "IPv4 received packet rejected by stack: %s\n",
 509                       strerror ( rc ) );
 510                 return rc;
 511         }
 512
 513         return 0;
 514
 515  err:
 516         free_iob ( iobuf );
 517         return -EINVAL;
 518 }
 519
 520 /**
 521  * Check existence of IPv4 address for ARP
 522  *
 523  * @v netdev            Network device
 524  * @v net_addr          Network-layer address
 525  * @ret rc              Return status code
 526  */
 527 static int ipv4_arp_check ( struct net_device *netdev, const void *net_addr ) {
 528         const struct in_addr *address = net_addr;
 529         struct ipv4_miniroute *miniroute;
 530
 531         list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
 532                 if ( ( miniroute->netdev == netdev ) &&
 533                      ( miniroute->address.s_addr == address->s_addr ) ) {
 534                         /* Found matching address */
 535                         return 0;
 536                 }
 537         }
 538         return -ENOENT;
 539 }
 540
 541 /**
 542  * Convert IPv4 address to dotted-quad notation
 543  *
 544  * @v in        IP address
 545  * @ret string  IP address in dotted-quad notation
 546  */
 547 char * inet_ntoa ( struct in_addr in ) {
 548         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
 549         uint8_t *bytes = ( uint8_t * ) &in;
 550
 551         sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
 552         return buf;
 553 }
 554
 555 /**
 556  * Transcribe IP address
 557  *
 558  * @v net_addr  IP address
 559  * @ret string  IP address in dotted-quad notation
 560  *
 561  */
 562 static const char * ipv4_ntoa ( const void *net_addr ) {
 563         return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
 564 }
 565
 566 /** IPv4 protocol */
 567 struct net_protocol ipv4_protocol __net_protocol = {
 568         .name = "IP",
 569         .net_proto = htons ( ETH_P_IP ),
 570         .net_addr_len = sizeof ( struct in_addr ),
 571         .rx = ipv4_rx,
 572         .ntoa = ipv4_ntoa,
 573 };
 574
 575 /** IPv4 TCPIP net protocol */
 576 struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol = {
 577         .name = "IPv4",
 578         .sa_family = AF_INET,
 579         .tx = ipv4_tx,
 580 };
 581
 582 /** IPv4 ARP protocol */
 583 struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol = {
 584         .net_protocol = &ipv4_protocol,
 585         .check = ipv4_arp_check,
 586 };