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