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