vnet/vnet/unix/tuntap.c

   1 /*
   2  *------------------------------------------------------------------
   3  * tuntap.c - kernel stack (reverse) punt/inject path
   4  *
   5  * Copyright (c) 2009 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19 /**
  20  * @file
  21  * @brief  TunTap Kernel stack (reverse) punt/inject path.
  22  *
  23  * This driver runs in one of two distinct modes:
  24  * - "punt/inject" mode, where we send pkts not otherwise processed
  25  * by the forwarding to the Linux kernel stack, and
  26  *
  27  * - "normal interface" mode, where we treat the Linux kernel stack
  28  * as a peer.
  29  *
  30  * By default, we select punt/inject mode.
  31  */
  32
  33 #include <fcntl.h>              /* for open */
  34 #include <sys/ioctl.h>
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/uio.h>            /* for iovec */
  39 #include <netinet/in.h>
  40
  41 #include <linux/if_arp.h>
  42 #include <linux/if_tun.h>
  43
  44 #include <vlib/vlib.h>
  45 #include <vlib/unix/unix.h>
  46
  47 #include <vnet/ip/ip.h>
  48
  49 #include <vnet/ethernet/ethernet.h>
  50 #include <vnet/devices/devices.h>
  51 #include <vnet/feature/feature.h>
  52
  53 #if DPDK == 1
  54 #include <vnet/devices/dpdk/dpdk.h>
  55 #endif
  56
  57 static vnet_device_class_t tuntap_dev_class;
  58 static vnet_hw_interface_class_t tuntap_interface_class;
  59
  60 static void tuntap_punt_frame (vlib_main_t * vm,
  61                                vlib_node_runtime_t * node,
  62                                vlib_frame_t * frame);
  63 static void tuntap_nopunt_frame (vlib_main_t * vm,
  64                                  vlib_node_runtime_t * node,
  65                                  vlib_frame_t * frame);
  66
  67 typedef struct {
  68   u32 sw_if_index;
  69   u8 is_v6;
  70   u8 addr[16];
  71 } subif_address_t;
  72
  73 /**
  74  * @brief TUNTAP node main state
  75  */
  76 typedef struct {
  77   /** Vector of iovecs for readv/writev calls. */
  78   struct iovec * iovecs;
  79
  80   /** Vector of VLIB rx buffers to use.  We allocate them in blocks
  81      of VLIB_FRAME_SIZE (256). */
  82   u32 * rx_buffers;
  83
  84   /** File descriptors for /dev/net/tun and provisioning socket. */
  85   int dev_net_tun_fd, dev_tap_fd;
  86
  87   /** Create a "tap" [ethernet] encaps device */
  88   int is_ether;
  89
  90   /** 1 if a "normal" routed intfc, 0 if a punt/inject interface */
  91
  92   int have_normal_interface;
  93
  94   /** tap device destination MAC address. Required, or Linux drops pkts */
  95   u8 ether_dst_mac[6];
  96
  97   /** Interface MTU in bytes and # of default sized buffers. */
  98   u32 mtu_bytes, mtu_buffers;
  99
 100   /** Linux interface name for tun device. */
 101   char * tun_name;
 102
 103   /** Pool of subinterface addresses */
 104   subif_address_t *subifs;
 105
 106   /** Hash for subif addresses */
 107   mhash_t subif_mhash;
 108
 109   /** Unix file index */
 110   u32 unix_file_index;
 111
 112   /** For the "normal" interface, if configured */
 113   u32 hw_if_index, sw_if_index;
 114
 115 } tuntap_main_t;
 116
 117 static tuntap_main_t tuntap_main = {
 118   .tun_name = "vnet",
 119
 120   /** Suitable defaults for an Ethernet-like tun/tap device */
 121   .mtu_bytes = 4096 + 256,
 122 };
 123
 124 /**
 125  * @brief tuntap_tx
 126  * @node tuntap-tx
 127  *
 128  * Output node, writes the buffers comprising the incoming frame
 129  * to the tun/tap device, aka hands them to the Linux kernel stack.
 130  *
 131  * @param *vm - vlib_main_t
 132  * @param *node - vlib_node_runtime_t
 133  * @param *frame - vlib_frame_t
 134  *
 135  * @return rc - uword
 136  *
 137  */
 138 static uword
 139 tuntap_tx (vlib_main_t * vm,
 140            vlib_node_runtime_t * node,
 141            vlib_frame_t * frame)
 142 {
 143   u32 * buffers = vlib_frame_args (frame);
 144   uword n_packets = frame->n_vectors;
 145   tuntap_main_t * tm = &tuntap_main;
 146   vnet_main_t *vnm = vnet_get_main ();
 147   vnet_interface_main_t *im = &vnm->interface_main;
 148   u32 n_bytes = 0;
 149   int i;
 150
 151   for (i = 0; i < n_packets; i++)
 152     {
 153       struct iovec * iov;
 154       vlib_buffer_t * b;
 155       uword l;
 156
 157       b = vlib_get_buffer (vm, buffers[i]);
 158
 159       if (tm->is_ether && (!tm->have_normal_interface))
 160         {
 161           vlib_buffer_reset(b);
 162           clib_memcpy (vlib_buffer_get_current (b), tm->ether_dst_mac, 6);
 163         }
 164
 165       /* Re-set iovecs if present. */
 166       if (tm->iovecs)
 167         _vec_len (tm->iovecs) = 0;
 168
 169       /** VLIB buffer chain -> Unix iovec(s). */
 170       vec_add2 (tm->iovecs, iov, 1);
 171       iov->iov_base = b->data + b->current_data;
 172       iov->iov_len = l = b->current_length;
 173
 174       if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
 175         {
 176           do {
 177             b = vlib_get_buffer (vm, b->next_buffer);
 178
 179             vec_add2 (tm->iovecs, iov, 1);
 180
 181             iov->iov_base = b->data + b->current_data;
 182             iov->iov_len = b->current_length;
 183             l += b->current_length;
 184           } while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
 185         }
 186
 187       if (writev (tm->dev_net_tun_fd, tm->iovecs, vec_len (tm->iovecs)) < l)
 188         clib_unix_warning ("writev");
 189
 190       n_bytes += l;
 191     }
 192
 193   /* Update tuntap interface output stats. */
 194   vlib_increment_combined_counter (im->combined_sw_if_counters
 195                                    + VNET_INTERFACE_COUNTER_TX,
 196                                    vm->cpu_index,
 197                                    tm->sw_if_index, n_packets, n_bytes);
 198
 199
 200   /** The normal interface path flattens the buffer chain */
 201   if (tm->have_normal_interface)
 202     vlib_buffer_free_no_next (vm, buffers, n_packets);
 203   else
 204     vlib_buffer_free (vm, buffers, n_packets);
 205
 206   return n_packets;
 207 }
 208
 209 VLIB_REGISTER_NODE (tuntap_tx_node,static) = {
 210   .function = tuntap_tx,
 211   .name = "tuntap-tx",
 212   .type = VLIB_NODE_TYPE_INTERNAL,
 213   .vector_size = 4,
 214 };
 215
 216 /**
 217  * @brief TUNTAP receive node
 218  * @node tuntap-rx
 219  *
 220  * @param *vm - vlib_main_t
 221  * @param *node - vlib_node_runtime_t
 222  * @param *frame - vlib_frame_t
 223  *
 224  * @return rc - uword
 225  *
 226  */
 227 static uword
 228 tuntap_rx (vlib_main_t * vm,
 229            vlib_node_runtime_t * node,
 230            vlib_frame_t * frame)
 231 {
 232   tuntap_main_t * tm = &tuntap_main;
 233   vlib_buffer_t * b;
 234   u32 bi;
 235   const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
 236 #if DPDK == 0
 237   u32 free_list_index = VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX;
 238 #else
 239   dpdk_main_t * dm = &dpdk_main;
 240   u32 free_list_index = dm->vlib_buffer_free_list_index;
 241   struct rte_mbuf *first_mb = NULL, *prev_mb = NULL;
 242 #endif
 243
 244   /** Make sure we have some RX buffers. */
 245   {
 246     uword n_left = vec_len (tm->rx_buffers);
 247     uword n_alloc;
 248
 249     if (n_left < VLIB_FRAME_SIZE / 2)
 250       {
 251         if (! tm->rx_buffers)
 252           vec_alloc (tm->rx_buffers, VLIB_FRAME_SIZE);
 253
 254         n_alloc = vlib_buffer_alloc_from_free_list
 255             (vm, tm->rx_buffers + n_left, VLIB_FRAME_SIZE - n_left,
 256              free_list_index);
 257         _vec_len (tm->rx_buffers) = n_left + n_alloc;
 258       }
 259   }
 260
 261   /** Allocate RX buffers from end of rx_buffers.
 262      Turn them into iovecs to pass to readv. */
 263   {
 264     uword i_rx = vec_len (tm->rx_buffers) - 1;
 265     vlib_buffer_t * b;
 266     word i, n_bytes_left, n_bytes_in_packet;
 267
 268     /** We should have enough buffers left for an MTU sized packet. */
 269     ASSERT (vec_len (tm->rx_buffers) >= tm->mtu_buffers);
 270
 271     vec_validate (tm->iovecs, tm->mtu_buffers - 1);
 272     for (i = 0; i < tm->mtu_buffers; i++)
 273       {
 274         b = vlib_get_buffer (vm, tm->rx_buffers[i_rx - i]);
 275         tm->iovecs[i].iov_base = b->data;
 276         tm->iovecs[i].iov_len = buffer_size;
 277       }
 278
 279     n_bytes_left = readv (tm->dev_net_tun_fd, tm->iovecs, tm->mtu_buffers);
 280     n_bytes_in_packet = n_bytes_left;
 281     if (n_bytes_left <= 0)
 282       {
 283         if (errno != EAGAIN)
 284           clib_unix_warning ("readv %d", n_bytes_left);
 285         return 0;
 286       }
 287
 288     bi = tm->rx_buffers[i_rx];
 289
 290     while (1)
 291       {
 292 #if DPDK == 1
 293         struct rte_mbuf * mb;
 294 #endif
 295         b = vlib_get_buffer (vm, tm->rx_buffers[i_rx]);
 296 #if DPDK == 1
 297         mb = rte_mbuf_from_vlib_buffer(b);
 298
 299         if (first_mb == NULL)
 300             first_mb = mb;
 301
 302         if (prev_mb != NULL)
 303           {
 304             prev_mb->next = mb;
 305             first_mb->nb_segs++;
 306           }
 307 #endif
 308         b->flags = 0;
 309         b->current_data = 0;
 310         b->current_length = n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
 311
 312         n_bytes_left -= buffer_size;
 313 #if DPDK == 1
 314         rte_pktmbuf_data_len (mb) = b->current_length;
 315         mb->data_off = RTE_PKTMBUF_HEADROOM + b->current_data;
 316 #endif
 317
 318         if (n_bytes_left <= 0)
 319           {
 320 #if DPDK == 1
 321             rte_pktmbuf_pkt_len (first_mb) = n_bytes_in_packet;
 322 #endif
 323             break;
 324           }
 325
 326         i_rx--;
 327         b->flags |= VLIB_BUFFER_NEXT_PRESENT;
 328         b->next_buffer = tm->rx_buffers[i_rx];
 329 #if DPDK == 1
 330         prev_mb = mb;
 331 #endif
 332       }
 333
 334     /** Interface counters for tuntap interface. */
 335     vlib_increment_combined_counter
 336         (vnet_main.interface_main.combined_sw_if_counters
 337          + VNET_INTERFACE_COUNTER_RX,
 338          os_get_cpu_number(),
 339          tm->sw_if_index,
 340          1, n_bytes_in_packet);
 341
 342     _vec_len (tm->rx_buffers) = i_rx;
 343   }
 344
 345   b = vlib_get_buffer (vm, bi);
 346
 347   {
 348     u32 next_index;
 349     uword n_trace = vlib_get_trace_count (vm, node);
 350
 351     vnet_buffer (b)->sw_if_index[VLIB_RX] = tm->sw_if_index;
 352     vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32)~0;
 353
 354     /*
 355      * Turn this on if you run into
 356      * "bad monkey" contexts, and you want to know exactly
 357      * which nodes they've visited...
 358      */
 359     if (VLIB_BUFFER_TRACE_TRAJECTORY)
 360         b->pre_data[0] = 0;
 361
 362     b->error = node->errors[0];
 363
 364     if (tm->is_ether)
 365       {
 366         next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
 367       }
 368     else
 369       switch (b->data[0] & 0xf0)
 370         {
 371         case 0x40:
 372           next_index = VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
 373           break;
 374         case 0x60:
 375           next_index = VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
 376           break;
 377         default:
 378           next_index = VNET_DEVICE_INPUT_NEXT_DROP;
 379           break;
 380         }
 381
 382     /* The linux kernel couldn't care less if our interface is up */
 383     if (tm->have_normal_interface)
 384       {
 385         vnet_main_t *vnm = vnet_get_main();
 386         vnet_sw_interface_t * si;
 387         si = vnet_get_sw_interface (vnm, tm->sw_if_index);
 388         if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 389           next_index = VNET_DEVICE_INPUT_NEXT_DROP;
 390       }
 391
 392     vnet_feature_start_device_input_x1 (tm->sw_if_index, &next_index, b, 0);
 393
 394     vlib_set_next_frame_buffer (vm, node, next_index, bi);
 395
 396     if (n_trace > 0)
 397       {
 398         vlib_trace_buffer (vm, node, next_index,
 399                            b, /* follow_chain */ 1);
 400         vlib_set_trace_count (vm, node, n_trace - 1);
 401       }
 402   }
 403
 404   return 1;
 405 }
 406
 407 /**
 408  * @brief TUNTAP_RX error strings
 409  */
 410 static char * tuntap_rx_error_strings[] = {
 411   "unknown packet type",
 412 };
 413
 414 VLIB_REGISTER_NODE (tuntap_rx_node,static) = {
 415   .function = tuntap_rx,
 416   .name = "tuntap-rx",
 417   .sibling_of = "device-input",
 418   .type = VLIB_NODE_TYPE_INPUT,
 419   .state = VLIB_NODE_STATE_INTERRUPT,
 420   .vector_size = 4,
 421   .n_errors = 1,
 422   .error_strings = tuntap_rx_error_strings,
 423 };
 424
 425 /**
 426  * @brief Gets called when file descriptor is ready from epoll.
 427  *
 428  * @param *uf - unix_file_t
 429  *
 430  * @return error - clib_error_t
 431  */
 432 static clib_error_t * tuntap_read_ready (unix_file_t * uf)
 433 {
 434   vlib_main_t * vm = vlib_get_main();
 435   vlib_node_set_interrupt_pending (vm, tuntap_rx_node.index);
 436   return 0;
 437 }
 438
 439 /**
 440  * @brief Clean up the tun/tap device
 441  *
 442  * @param *vm - vlib_main_t
 443  *
 444  * @return error - clib_error_t
 445  *
 446  */
 447 static clib_error_t *
 448 tuntap_exit (vlib_main_t * vm)
 449 {
 450   tuntap_main_t *tm = &tuntap_main;
 451   struct ifreq ifr;
 452   int sfd;
 453
 454   /* Not present. */
 455   if (! tm->dev_net_tun_fd || tm->dev_net_tun_fd < 0)
 456     return 0;
 457
 458   sfd = socket (AF_INET, SOCK_STREAM, 0);
 459   if (sfd < 0)
 460     clib_unix_warning("provisioning socket");
 461
 462   memset(&ifr, 0, sizeof (ifr));
 463   strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name)-1);
 464
 465   /* get flags, modify to bring down interface... */
 466   if (ioctl (sfd, SIOCGIFFLAGS, &ifr) < 0)
 467     clib_unix_warning ("SIOCGIFFLAGS");
 468
 469   ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
 470
 471   if (ioctl (sfd, SIOCSIFFLAGS, &ifr) < 0)
 472     clib_unix_warning ("SIOCSIFFLAGS");
 473
 474   /* Turn off persistence */
 475   if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 0) < 0)
 476     clib_unix_warning ("TUNSETPERSIST");
 477   close(tm->dev_tap_fd);
 478   if (tm->dev_net_tun_fd >= 0)
 479     close(tm->dev_net_tun_fd);
 480   if (sfd >= 0)
 481     close (sfd);
 482
 483   return 0;
 484 }
 485
 486 VLIB_MAIN_LOOP_EXIT_FUNCTION (tuntap_exit);
 487
 488 /**
 489  * @brief CLI function for tun/tap config
 490  *
 491  * @param *vm - vlib_main_t
 492  * @param *input - unformat_input_t
 493  *
 494  * @return error - clib_error_t
 495  *
 496  */
 497 static clib_error_t *
 498 tuntap_config (vlib_main_t * vm, unformat_input_t * input)
 499 {
 500   tuntap_main_t *tm = &tuntap_main;
 501   clib_error_t * error = 0;
 502   struct ifreq ifr;
 503   u8 * name;
 504   int flags = IFF_TUN | IFF_NO_PI;
 505   int is_enabled = 0, is_ether = 0, have_normal_interface = 0;
 506   const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
 507
 508   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 509     {
 510       if (unformat (input, "mtu %d", &tm->mtu_bytes))
 511         ;
 512       else if (unformat (input, "enable"))
 513         is_enabled = 1;
 514       else if (unformat (input, "disable"))
 515         is_enabled = 0;
 516       else if (unformat (input, "ethernet") ||
 517                unformat (input, "ether"))
 518         is_ether = 1;
 519       else if (unformat (input, "have-normal-interface") ||
 520                unformat (input, "have-normal"))
 521         have_normal_interface = 1;
 522       else if (unformat (input, "name %s", &name))
 523         tm->tun_name = (char *) name;
 524       else
 525         return clib_error_return (0, "unknown input `%U'",
 526                                   format_unformat_error, input);
 527     }
 528
 529   tm->dev_net_tun_fd = -1;
 530   tm->dev_tap_fd = -1;
 531
 532   if (is_enabled == 0)
 533     return 0;
 534
 535   if (geteuid())
 536     {
 537       clib_warning ("tuntap disabled: must be superuser");
 538       return 0;
 539     }
 540
 541   tm->is_ether = is_ether;
 542   tm->have_normal_interface = have_normal_interface;
 543
 544   if (is_ether)
 545     flags = IFF_TAP | IFF_NO_PI;
 546
 547   if ((tm->dev_net_tun_fd = open ("/dev/net/tun", O_RDWR)) < 0)
 548     {
 549       error = clib_error_return_unix (0, "open /dev/net/tun");
 550       goto done;
 551     }
 552
 553   memset (&ifr, 0, sizeof (ifr));
 554   strncpy(ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
 555   ifr.ifr_flags = flags;
 556   if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *)&ifr) < 0)
 557     {
 558       error = clib_error_return_unix (0, "ioctl TUNSETIFF");
 559       goto done;
 560     }
 561
 562   /* Make it persistent, at least until we split. */
 563   if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 1) < 0)
 564     {
 565       error = clib_error_return_unix (0, "TUNSETPERSIST");
 566       goto done;
 567     }
 568
 569   /* Open a provisioning socket */
 570   if ((tm->dev_tap_fd = socket(PF_PACKET, SOCK_RAW,
 571                                htons(ETH_P_ALL))) < 0 )
 572     {
 573       error = clib_error_return_unix (0, "socket");
 574       goto done;
 575     }
 576
 577   /* Find the interface index. */
 578   {
 579     struct ifreq ifr;
 580     struct sockaddr_ll sll;
 581
 582     memset (&ifr, 0, sizeof(ifr));
 583     strncpy (ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
 584     if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0 )
 585       {
 586         error = clib_error_return_unix (0, "ioctl SIOCGIFINDEX");
 587         goto done;
 588       }
 589
 590     /* Bind the provisioning socket to the interface. */
 591     memset(&sll, 0, sizeof(sll));
 592     sll.sll_family   = AF_PACKET;
 593     sll.sll_ifindex  = ifr.ifr_ifindex;
 594     sll.sll_protocol = htons(ETH_P_ALL);
 595
 596     if (bind(tm->dev_tap_fd, (struct sockaddr*) &sll, sizeof(sll)) < 0)
 597       {
 598         error = clib_error_return_unix (0, "bind");
 599         goto done;
 600       }
 601   }
 602
 603   /* non-blocking I/O on /dev/tapX */
 604   {
 605     int one = 1;
 606     if (ioctl (tm->dev_net_tun_fd, FIONBIO, &one) < 0)
 607       {
 608         error = clib_error_return_unix (0, "ioctl FIONBIO");
 609         goto done;
 610       }
 611   }
 612
 613   tm->mtu_buffers = (tm->mtu_bytes + (buffer_size - 1)) / buffer_size;
 614
 615   ifr.ifr_mtu = tm->mtu_bytes;
 616   if (ioctl (tm->dev_tap_fd, SIOCSIFMTU, &ifr) < 0)
 617     {
 618       error = clib_error_return_unix (0, "ioctl SIOCSIFMTU");
 619       goto done;
 620     }
 621
 622   /* get flags, modify to bring up interface... */
 623   if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
 624     {
 625       error = clib_error_return_unix (0, "ioctl SIOCGIFFLAGS");
 626       goto done;
 627     }
 628
 629   ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
 630
 631   if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
 632     {
 633       error = clib_error_return_unix (0, "ioctl SIOCSIFFLAGS");
 634       goto done;
 635     }
 636
 637   if (is_ether)
 638     {
 639       if (ioctl (tm->dev_tap_fd, SIOCGIFHWADDR, &ifr) < 0)
 640         {
 641           error = clib_error_return_unix (0, "ioctl SIOCGIFHWADDR");
 642           goto done;
 643         }
 644       else
 645         clib_memcpy (tm->ether_dst_mac, ifr.ifr_hwaddr.sa_data, 6);
 646     }
 647
 648   if (have_normal_interface)
 649     {
 650       vnet_main_t *vnm = vnet_get_main();
 651       error = ethernet_register_interface
 652         (vnm,
 653          tuntap_dev_class.index,
 654          0 /* device instance */,
 655          tm->ether_dst_mac /* ethernet address */,
 656          &tm->hw_if_index,
 657          0 /* flag change */);
 658       if (error)
 659         clib_error_report (error);
 660       tm->sw_if_index = tm->hw_if_index;
 661       vm->os_punt_frame = tuntap_nopunt_frame;
 662     }
 663   else
 664     {
 665       vnet_main_t *vnm = vnet_get_main();
 666       vnet_hw_interface_t * hi;
 667
 668       vm->os_punt_frame = tuntap_punt_frame;
 669
 670       tm->hw_if_index = vnet_register_interface
 671         (vnm,
 672          tuntap_dev_class.index, 0 /* device instance */,
 673          tuntap_interface_class.index, 0);
 674       hi = vnet_get_hw_interface (vnm, tm->hw_if_index);
 675       tm->sw_if_index = hi->sw_if_index;
 676
 677       /* Interface is always up. */
 678       vnet_hw_interface_set_flags (vnm, tm->hw_if_index,
 679                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 680       vnet_sw_interface_set_flags (vnm, tm->sw_if_index,
 681                                    VNET_SW_INTERFACE_FLAG_ADMIN_UP);
 682     }
 683
 684   {
 685     unix_file_t template = {0};
 686     template.read_function = tuntap_read_ready;
 687     template.file_descriptor = tm->dev_net_tun_fd;
 688     tm->unix_file_index = unix_file_add (&unix_main, &template);
 689   }
 690
 691  done:
 692   if (error)
 693     {
 694       if (tm->dev_net_tun_fd >= 0)
 695         close (tm->dev_net_tun_fd);
 696       if (tm->dev_tap_fd >= 0)
 697         close (tm->dev_tap_fd);
 698     }
 699
 700   return error;
 701 }
 702
 703 VLIB_CONFIG_FUNCTION (tuntap_config, "tuntap");
 704
 705 /**
 706  * @brief Add or Del IP4 address to tun/tap interface
 707  *
 708  * @param *im - ip4_main_t
 709  * @param opaque - uword
 710  * @param sw_if_index - u32
 711  * @param *address - ip4_address_t
 712  * @param is_delete - u32
 713  *
 714  */
 715 void
 716 tuntap_ip4_add_del_interface_address (ip4_main_t * im,
 717                                       uword opaque,
 718                                       u32 sw_if_index,
 719                                       ip4_address_t * address,
 720                                       u32 address_length,
 721                                       u32 if_address_index,
 722                                       u32 is_delete)
 723 {
 724   tuntap_main_t * tm = &tuntap_main;
 725   struct ifreq ifr;
 726   subif_address_t subif_addr, * ap;
 727   uword * p;
 728
 729   /** Tuntap disabled, or using a "normal" interface. */
 730   if (tm->have_normal_interface ||  tm->dev_tap_fd < 0)
 731     return;
 732
 733   /** See if we already know about this subif */
 734   memset (&subif_addr, 0, sizeof (subif_addr));
 735   subif_addr.sw_if_index = sw_if_index;
 736   clib_memcpy (&subif_addr.addr, address, sizeof (*address));
 737
 738   p = mhash_get (&tm->subif_mhash, &subif_addr);
 739
 740   if (p)
 741     ap = pool_elt_at_index (tm->subifs, p[0]);
 742   else
 743     {
 744       pool_get (tm->subifs, ap);
 745       *ap = subif_addr;
 746       mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
 747     }
 748
 749   /* Use subif pool index to select alias device. */
 750   memset (&ifr, 0, sizeof (ifr));
 751   snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
 752             "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
 753
 754   /* the tuntap punt/inject is enabled for IPv4 RX so long as
 755    * any vpp interface has an IPv4 address.
 756    * this is also ref counted.
 757    */
 758   ip4_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
 759
 760   if (! is_delete)
 761     {
 762       struct sockaddr_in * sin;
 763
 764       sin = (struct sockaddr_in *)&ifr.ifr_addr;
 765
 766       /* Set ipv4 address, netmask. */
 767       sin->sin_family = AF_INET;
 768       clib_memcpy (&sin->sin_addr.s_addr, address, 4);
 769       if (ioctl (tm->dev_tap_fd, SIOCSIFADDR, &ifr) < 0)
 770         clib_unix_warning ("ioctl SIOCSIFADDR");
 771
 772       sin->sin_addr.s_addr = im->fib_masks[address_length];
 773       if (ioctl (tm->dev_tap_fd, SIOCSIFNETMASK, &ifr) < 0)
 774         clib_unix_warning ("ioctl SIOCSIFNETMASK");
 775     }
 776   else
 777     {
 778       mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
 779       pool_put (tm->subifs, ap);
 780     }
 781
 782   /* get flags, modify to bring up interface... */
 783   if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
 784     clib_unix_warning ("ioctl SIOCGIFFLAGS");
 785
 786   if (is_delete)
 787     ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
 788   else
 789     ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
 790
 791   if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
 792     clib_unix_warning ("ioctl SIOCSIFFLAGS");
 793 }
 794
 795 /**
 796  * @brief workaround for a known include file bug.
 797  * including @c <linux/ipv6.h> causes multiple definitions if
 798  * @c <netinet/in.h is also included.
 799  */
 800 struct in6_ifreq {
 801         struct in6_addr ifr6_addr;
 802         u32             ifr6_prefixlen;
 803         int             ifr6_ifindex;
 804 };
 805
 806 /**
 807  * @brief Add or Del tun/tap interface address.
 808  *
 809  * Both the v6 interface address API and the way ifconfig
 810  * displays subinterfaces differ from their v4 couterparts.
 811  * The code given here seems to work but YMMV.
 812  *
 813  * @param *im - ip6_main_t
 814  * @param opaque - uword
 815  * @param sw_if_index - u32
 816  * @param *address - ip6_address_t
 817  * @param address_length - u32
 818  * @param if_address_index - u32
 819  * @param is_delete - u32
 820  */
 821 void
 822 tuntap_ip6_add_del_interface_address (ip6_main_t * im,
 823                                       uword opaque,
 824                                       u32 sw_if_index,
 825                                       ip6_address_t * address,
 826                                       u32 address_length,
 827                                       u32 if_address_index,
 828                                       u32 is_delete)
 829 {
 830   tuntap_main_t * tm = &tuntap_main;
 831   struct ifreq ifr;
 832   struct in6_ifreq ifr6;
 833   subif_address_t subif_addr, * ap;
 834   uword * p;
 835
 836   /* Tuntap disabled, or using a "normal" interface. */
 837   if (tm->have_normal_interface ||  tm->dev_tap_fd < 0)
 838     return;
 839
 840   /* See if we already know about this subif */
 841   memset (&subif_addr, 0, sizeof (subif_addr));
 842   subif_addr.sw_if_index = sw_if_index;
 843   subif_addr.is_v6 = 1;
 844   clib_memcpy (&subif_addr.addr, address, sizeof (*address));
 845
 846   p = mhash_get (&tm->subif_mhash, &subif_addr);
 847
 848   if (p)
 849     ap = pool_elt_at_index (tm->subifs, p[0]);
 850   else
 851     {
 852       pool_get (tm->subifs, ap);
 853       *ap = subif_addr;
 854       mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
 855     }
 856
 857   /* Use subif pool index to select alias device. */
 858   memset (&ifr, 0, sizeof (ifr));
 859   memset (&ifr6, 0, sizeof (ifr6));
 860   snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
 861             "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
 862
 863   /* the tuntap punt/inject is enabled for IPv6 RX so long as
 864    * any vpp interface has an IPv6 address.
 865    * this is also ref counted.
 866    */
 867   ip6_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
 868
 869   if (! is_delete)
 870     {
 871       int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
 872       if (sockfd < 0)
 873         clib_unix_warning ("get ifindex socket");
 874
 875       if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
 876         clib_unix_warning ("get ifindex");
 877
 878       ifr6.ifr6_ifindex = ifr.ifr_ifindex;
 879       ifr6.ifr6_prefixlen = address_length;
 880       clib_memcpy (&ifr6.ifr6_addr, address, 16);
 881
 882       if (ioctl (sockfd, SIOCSIFADDR, &ifr6) < 0)
 883         clib_unix_warning ("set address");
 884
 885       if (sockfd >= 0)
 886         close (sockfd);
 887     }
 888   else
 889     {
 890       int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
 891       if (sockfd < 0)
 892         clib_unix_warning ("get ifindex socket");
 893
 894       if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
 895         clib_unix_warning ("get ifindex");
 896
 897       ifr6.ifr6_ifindex = ifr.ifr_ifindex;
 898       ifr6.ifr6_prefixlen = address_length;
 899       clib_memcpy (&ifr6.ifr6_addr, address, 16);
 900
 901       if (ioctl (sockfd, SIOCDIFADDR, &ifr6) < 0)
 902         clib_unix_warning ("del address");
 903
 904       if (sockfd >= 0)
 905         close (sockfd);
 906
 907       mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
 908       pool_put (tm->subifs, ap);
 909     }
 910 }
 911
 912 /**
 913  * @brief TX the tun/tap frame
 914  *
 915  * @param *vm - vlib_main_t
 916  * @param *node - vlib_node_runtime_t
 917  * @param *frame - vlib_frame_t
 918  *
 919  */
 920 static void
 921 tuntap_punt_frame (vlib_main_t * vm,
 922                    vlib_node_runtime_t * node,
 923                    vlib_frame_t * frame)
 924 {
 925   tuntap_tx (vm, node, frame);
 926   vlib_frame_free (vm, node, frame);
 927 }
 928
 929 /**
 930  * @brief Free the tun/tap frame
 931  *
 932  * @param *vm - vlib_main_t
 933  * @param *node - vlib_node_runtime_t
 934  * @param *frame - vlib_frame_t
 935  *
 936  */
 937 static void
 938 tuntap_nopunt_frame (vlib_main_t * vm,
 939                    vlib_node_runtime_t * node,
 940                    vlib_frame_t * frame)
 941 {
 942   u32 * buffers = vlib_frame_args (frame);
 943   uword n_packets = frame->n_vectors;
 944   vlib_buffer_free (vm, buffers, n_packets);
 945   vlib_frame_free (vm, node, frame);
 946 }
 947
 948 VNET_HW_INTERFACE_CLASS (tuntap_interface_class,static) = {
 949   .name = "tuntap",
 950   .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
 951 };
 952
 953 /**
 954  * @brief Format tun/tap interface name
 955  *
 956  * @param *s - u8 - formatter string
 957  * @param *args - va_list
 958  *
 959  * @return *s - u8 - formatted string
 960  *
 961  */
 962 static u8 * format_tuntap_interface_name (u8 * s, va_list * args)
 963 {
 964   u32 i = va_arg (*args, u32);
 965
 966   s = format (s, "tuntap-%d", i);
 967   return s;
 968 }
 969
 970 /**
 971  * @brief TX packet out tun/tap
 972  *
 973  * @param *vm - vlib_main_t
 974  * @param *node - vlib_node_runtime_t
 975  * @param *frame - vlib_frame_t
 976  *
 977  * @return n_buffers - uword - Packets transmitted
 978  *
 979  */
 980 static uword
 981 tuntap_intfc_tx (vlib_main_t * vm,
 982                  vlib_node_runtime_t * node,
 983                  vlib_frame_t * frame)
 984 {
 985   tuntap_main_t * tm = &tuntap_main;
 986   u32 * buffers = vlib_frame_args (frame);
 987   uword n_buffers = frame->n_vectors;
 988
 989   /* Normal interface transmit happens only on the normal interface... */
 990   if (tm->have_normal_interface)
 991     return tuntap_tx (vm, node, frame);
 992
 993   vlib_buffer_free (vm, buffers, n_buffers);
 994   return n_buffers;
 995 }
 996
 997 VNET_DEVICE_CLASS (tuntap_dev_class,static) = {
 998   .name = "tuntap",
 999   .tx_function = tuntap_intfc_tx,
1000   .format_device_name = format_tuntap_interface_name,
1001 };
1002
1003 /**
1004  * @brief tun/tap node init
1005  *
1006  * @param *vm - vlib_main_t
1007  *
1008  * @return error - clib_error_t
1009  *
1010  */
1011 static clib_error_t *
1012 tuntap_init (vlib_main_t * vm)
1013 {
1014   clib_error_t * error;
1015   ip4_main_t * im4 = &ip4_main;
1016   ip6_main_t * im6 = &ip6_main;
1017   ip4_add_del_interface_address_callback_t cb4;
1018   ip6_add_del_interface_address_callback_t cb6;
1019   tuntap_main_t * tm = &tuntap_main;
1020
1021   error = vlib_call_init_function (vm, ip4_init);
1022   if (error)
1023     return error;
1024
1025   mhash_init (&tm->subif_mhash, sizeof (u32), sizeof(subif_address_t));
1026
1027   cb4.function = tuntap_ip4_add_del_interface_address;
1028   cb4.function_opaque = 0;
1029   vec_add1 (im4->add_del_interface_address_callbacks, cb4);
1030
1031   cb6.function = tuntap_ip6_add_del_interface_address;
1032   cb6.function_opaque = 0;
1033   vec_add1 (im6->add_del_interface_address_callbacks, cb6);
1034
1035   return 0;
1036 }
1037
1038 VLIB_INIT_FUNCTION (tuntap_init);