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