2 *------------------------------------------------------------------
3 * tuntap.c - kernel stack (reverse) punt/inject path
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:
10 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
21 * @brief TunTap Kernel stack (reverse) punt/inject path.
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
27 * - "normal interface" mode, where we treat the Linux kernel stack
30 * By default, we select punt/inject mode.
33 #include <fcntl.h> /* for open */
34 #include <sys/ioctl.h>
35 #include <sys/socket.h>
37 #include <sys/types.h>
38 #include <sys/uio.h> /* for iovec */
39 #include <netinet/in.h>
41 #include <linux/if_arp.h>
42 #include <linux/if_tun.h>
44 #include <vlib/vlib.h>
45 #include <vlib/unix/unix.h>
47 #include <vnet/ip/ip.h>
48 #include <vnet/fib/fib_table.h>
50 #include <vnet/ethernet/ethernet.h>
51 #include <vnet/devices/devices.h>
52 #include <vnet/feature/feature.h>
54 static vnet_device_class_t tuntap_dev_class;
55 static vnet_hw_interface_class_t tuntap_interface_class;
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);
71 * @brief TUNTAP node main state
74 /** Vector of iovecs for readv calls. */
75 struct iovec * rd_iovecs;
77 /** Vector of iovecs for writev calls. */
78 struct iovec * wr_iovecs;
80 /** Vector of VLIB rx buffers to use. We allocate them in blocks
81 of VLIB_FRAME_SIZE (256). */
84 /** File descriptors for /dev/net/tun and provisioning socket. */
85 int dev_net_tun_fd, dev_tap_fd;
87 /** Create a "tap" [ethernet] encaps device */
90 /** 1 if a "normal" routed intfc, 0 if a punt/inject interface */
92 int have_normal_interface;
94 /** tap device destination MAC address. Required, or Linux drops pkts */
97 /** Interface MTU in bytes and # of default sized buffers. */
98 u32 mtu_bytes, mtu_buffers;
100 /** Linux interface name for tun device. */
103 /** Pool of subinterface addresses */
104 subif_address_t *subifs;
106 /** Hash for subif addresses */
109 /** Unix file index */
112 /** For the "normal" interface, if configured */
113 u32 hw_if_index, sw_if_index;
117 static tuntap_main_t tuntap_main = {
120 /** Suitable defaults for an Ethernet-like tun/tap device */
121 .mtu_bytes = 4096 + 256,
128 * Output node, writes the buffers comprising the incoming frame
129 * to the tun/tap device, aka hands them to the Linux kernel stack.
131 * @param *vm - vlib_main_t
132 * @param *node - vlib_node_runtime_t
133 * @param *frame - vlib_frame_t
139 tuntap_tx (vlib_main_t * vm,
140 vlib_node_runtime_t * node,
141 vlib_frame_t * frame)
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;
151 for (i = 0; i < n_packets; i++)
157 b = vlib_get_buffer (vm, buffers[i]);
159 if (tm->is_ether && (!tm->have_normal_interface))
161 vlib_buffer_reset(b);
162 clib_memcpy (vlib_buffer_get_current (b), tm->ether_dst_mac, 6);
165 /* Re-set iovecs if present. */
167 _vec_len (tm->wr_iovecs) = 0;
169 /** VLIB buffer chain -> Unix iovec(s). */
170 vec_add2 (tm->wr_iovecs, iov, 1);
171 iov->iov_base = b->data + b->current_data;
172 iov->iov_len = l = b->current_length;
174 if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
177 b = vlib_get_buffer (vm, b->next_buffer);
179 vec_add2 (tm->wr_iovecs, iov, 1);
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);
187 if (writev (tm->dev_net_tun_fd, tm->wr_iovecs,
188 vec_len (tm->wr_iovecs)) < l)
189 clib_unix_warning ("writev");
194 /* Update tuntap interface output stats. */
195 vlib_increment_combined_counter (im->combined_sw_if_counters
196 + VNET_INTERFACE_COUNTER_TX,
198 tm->sw_if_index, n_packets, n_bytes);
201 /** The normal interface path flattens the buffer chain */
202 if (tm->have_normal_interface)
203 vlib_buffer_free_no_next (vm, buffers, n_packets);
205 vlib_buffer_free (vm, buffers, n_packets);
210 VLIB_REGISTER_NODE (tuntap_tx_node,static) = {
211 .function = tuntap_tx,
213 .type = VLIB_NODE_TYPE_INTERNAL,
218 * @brief TUNTAP receive node
221 * @param *vm - vlib_main_t
222 * @param *node - vlib_node_runtime_t
223 * @param *frame - vlib_frame_t
229 tuntap_rx (vlib_main_t * vm,
230 vlib_node_runtime_t * node,
231 vlib_frame_t * frame)
233 tuntap_main_t * tm = &tuntap_main;
236 const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
238 /** Make sure we have some RX buffers. */
240 uword n_left = vec_len (tm->rx_buffers);
243 if (n_left < VLIB_FRAME_SIZE / 2)
245 if (! tm->rx_buffers)
246 vec_alloc (tm->rx_buffers, VLIB_FRAME_SIZE);
248 n_alloc = vlib_buffer_alloc (vm, tm->rx_buffers + n_left, VLIB_FRAME_SIZE - n_left);
249 _vec_len (tm->rx_buffers) = n_left + n_alloc;
253 /** Allocate RX buffers from end of rx_buffers.
254 Turn them into iovecs to pass to readv. */
256 uword i_rx = vec_len (tm->rx_buffers) - 1;
258 word i, n_bytes_left, n_bytes_in_packet;
260 /** We should have enough buffers left for an MTU sized packet. */
261 ASSERT (vec_len (tm->rx_buffers) >= tm->mtu_buffers);
263 vec_validate (tm->rd_iovecs, tm->mtu_buffers - 1);
264 for (i = 0; i < tm->mtu_buffers; i++)
266 b = vlib_get_buffer (vm, tm->rx_buffers[i_rx - i]);
267 tm->rd_iovecs[i].iov_base = b->data;
268 tm->rd_iovecs[i].iov_len = buffer_size;
271 n_bytes_left = readv (tm->dev_net_tun_fd, tm->rd_iovecs, tm->mtu_buffers);
272 n_bytes_in_packet = n_bytes_left;
273 if (n_bytes_left <= 0)
276 clib_unix_warning ("readv %d", n_bytes_left);
280 bi = tm->rx_buffers[i_rx];
284 b = vlib_get_buffer (vm, tm->rx_buffers[i_rx]);
287 b->current_length = n_bytes_left < buffer_size ? n_bytes_left : buffer_size;
289 n_bytes_left -= buffer_size;
291 if (n_bytes_left <= 0)
297 b->flags |= VLIB_BUFFER_NEXT_PRESENT;
298 b->next_buffer = tm->rx_buffers[i_rx];
301 /** Interface counters for tuntap interface. */
302 vlib_increment_combined_counter
303 (vnet_main.interface_main.combined_sw_if_counters
304 + VNET_INTERFACE_COUNTER_RX,
305 vlib_get_thread_index(),
307 1, n_bytes_in_packet);
309 _vec_len (tm->rx_buffers) = i_rx;
312 b = vlib_get_buffer (vm, bi);
316 uword n_trace = vlib_get_trace_count (vm, node);
318 vnet_buffer (b)->sw_if_index[VLIB_RX] = tm->sw_if_index;
319 vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32)~0;
322 * Turn this on if you run into
323 * "bad monkey" contexts, and you want to know exactly
324 * which nodes they've visited...
326 if (VLIB_BUFFER_TRACE_TRAJECTORY)
329 b->error = node->errors[0];
333 next_index = VNET_DEVICE_INPUT_NEXT_ETHERNET_INPUT;
336 switch (b->data[0] & 0xf0)
339 next_index = VNET_DEVICE_INPUT_NEXT_IP4_INPUT;
342 next_index = VNET_DEVICE_INPUT_NEXT_IP6_INPUT;
345 next_index = VNET_DEVICE_INPUT_NEXT_DROP;
349 /* The linux kernel couldn't care less if our interface is up */
350 if (tm->have_normal_interface)
352 vnet_main_t *vnm = vnet_get_main();
353 vnet_sw_interface_t * si;
354 si = vnet_get_sw_interface (vnm, tm->sw_if_index);
355 if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
356 next_index = VNET_DEVICE_INPUT_NEXT_DROP;
359 vnet_feature_start_device_input_x1 (tm->sw_if_index, &next_index, b);
361 vlib_set_next_frame_buffer (vm, node, next_index, bi);
365 vlib_trace_buffer (vm, node, next_index,
366 b, /* follow_chain */ 1);
367 vlib_set_trace_count (vm, node, n_trace - 1);
375 * @brief TUNTAP_RX error strings
377 static char * tuntap_rx_error_strings[] = {
378 "unknown packet type",
381 VLIB_REGISTER_NODE (tuntap_rx_node,static) = {
382 .function = tuntap_rx,
384 .sibling_of = "device-input",
385 .type = VLIB_NODE_TYPE_INPUT,
386 .state = VLIB_NODE_STATE_INTERRUPT,
389 .error_strings = tuntap_rx_error_strings,
393 * @brief Gets called when file descriptor is ready from epoll.
395 * @param *uf - clib_file_t
397 * @return error - clib_error_t
399 static clib_error_t * tuntap_read_ready (clib_file_t * uf)
401 vlib_main_t * vm = vlib_get_main();
402 vlib_node_set_interrupt_pending (vm, tuntap_rx_node.index);
407 * @brief Clean up the tun/tap device
409 * @param *vm - vlib_main_t
411 * @return error - clib_error_t
414 static clib_error_t *
415 tuntap_exit (vlib_main_t * vm)
417 tuntap_main_t *tm = &tuntap_main;
422 if (! tm->dev_net_tun_fd || tm->dev_net_tun_fd < 0)
425 sfd = socket (AF_INET, SOCK_STREAM, 0);
427 clib_unix_warning("provisioning socket");
429 memset(&ifr, 0, sizeof (ifr));
430 strncpy (ifr.ifr_name, tm->tun_name, sizeof (ifr.ifr_name)-1);
432 /* get flags, modify to bring down interface... */
433 if (ioctl (sfd, SIOCGIFFLAGS, &ifr) < 0)
434 clib_unix_warning ("SIOCGIFFLAGS");
436 ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
438 if (ioctl (sfd, SIOCSIFFLAGS, &ifr) < 0)
439 clib_unix_warning ("SIOCSIFFLAGS");
441 /* Turn off persistence */
442 if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 0) < 0)
443 clib_unix_warning ("TUNSETPERSIST");
444 close(tm->dev_tap_fd);
445 if (tm->dev_net_tun_fd >= 0)
446 close(tm->dev_net_tun_fd);
453 VLIB_MAIN_LOOP_EXIT_FUNCTION (tuntap_exit);
456 * @brief CLI function for tun/tap config
458 * @param *vm - vlib_main_t
459 * @param *input - unformat_input_t
461 * @return error - clib_error_t
464 static clib_error_t *
465 tuntap_config (vlib_main_t * vm, unformat_input_t * input)
467 tuntap_main_t *tm = &tuntap_main;
468 clib_error_t * error = 0;
471 int flags = IFF_TUN | IFF_NO_PI;
472 int is_enabled = 0, is_ether = 0, have_normal_interface = 0;
473 const uword buffer_size = VLIB_BUFFER_DATA_SIZE;
475 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
477 if (unformat (input, "mtu %d", &tm->mtu_bytes))
479 else if (unformat (input, "enable"))
481 else if (unformat (input, "disable"))
483 else if (unformat (input, "ethernet") ||
484 unformat (input, "ether"))
486 else if (unformat (input, "have-normal-interface") ||
487 unformat (input, "have-normal"))
488 have_normal_interface = 1;
489 else if (unformat (input, "name %s", &name))
490 tm->tun_name = (char *) name;
492 return clib_error_return (0, "unknown input `%U'",
493 format_unformat_error, input);
496 tm->dev_net_tun_fd = -1;
504 clib_warning ("tuntap disabled: must be superuser");
508 tm->is_ether = is_ether;
509 tm->have_normal_interface = have_normal_interface;
512 flags = IFF_TAP | IFF_NO_PI;
514 if ((tm->dev_net_tun_fd = open ("/dev/net/tun", O_RDWR)) < 0)
516 error = clib_error_return_unix (0, "open /dev/net/tun");
520 memset (&ifr, 0, sizeof (ifr));
521 strncpy(ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
522 ifr.ifr_flags = flags;
523 if (ioctl (tm->dev_net_tun_fd, TUNSETIFF, (void *)&ifr) < 0)
525 error = clib_error_return_unix (0, "ioctl TUNSETIFF");
529 /* Make it persistent, at least until we split. */
530 if (ioctl (tm->dev_net_tun_fd, TUNSETPERSIST, 1) < 0)
532 error = clib_error_return_unix (0, "TUNSETPERSIST");
536 /* Open a provisioning socket */
537 if ((tm->dev_tap_fd = socket(PF_PACKET, SOCK_RAW,
538 htons(ETH_P_ALL))) < 0 )
540 error = clib_error_return_unix (0, "socket");
544 /* Find the interface index. */
547 struct sockaddr_ll sll;
549 memset (&ifr, 0, sizeof(ifr));
550 strncpy (ifr.ifr_name, tm->tun_name, sizeof(ifr.ifr_name)-1);
551 if (ioctl (tm->dev_tap_fd, SIOCGIFINDEX, &ifr) < 0 )
553 error = clib_error_return_unix (0, "ioctl SIOCGIFINDEX");
557 /* Bind the provisioning socket to the interface. */
558 memset(&sll, 0, sizeof(sll));
559 sll.sll_family = AF_PACKET;
560 sll.sll_ifindex = ifr.ifr_ifindex;
561 sll.sll_protocol = htons(ETH_P_ALL);
563 if (bind(tm->dev_tap_fd, (struct sockaddr*) &sll, sizeof(sll)) < 0)
565 error = clib_error_return_unix (0, "bind");
570 /* non-blocking I/O on /dev/tapX */
573 if (ioctl (tm->dev_net_tun_fd, FIONBIO, &one) < 0)
575 error = clib_error_return_unix (0, "ioctl FIONBIO");
580 tm->mtu_buffers = (tm->mtu_bytes + (buffer_size - 1)) / buffer_size;
582 ifr.ifr_mtu = tm->mtu_bytes;
583 if (ioctl (tm->dev_tap_fd, SIOCSIFMTU, &ifr) < 0)
585 error = clib_error_return_unix (0, "ioctl SIOCSIFMTU");
589 /* get flags, modify to bring up interface... */
590 if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
592 error = clib_error_return_unix (0, "ioctl SIOCGIFFLAGS");
596 ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
598 if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
600 error = clib_error_return_unix (0, "ioctl SIOCSIFFLAGS");
606 if (ioctl (tm->dev_tap_fd, SIOCGIFHWADDR, &ifr) < 0)
608 error = clib_error_return_unix (0, "ioctl SIOCGIFHWADDR");
612 clib_memcpy (tm->ether_dst_mac, ifr.ifr_hwaddr.sa_data, 6);
615 if (have_normal_interface)
617 vnet_main_t *vnm = vnet_get_main();
618 error = ethernet_register_interface
620 tuntap_dev_class.index,
621 0 /* device instance */,
622 tm->ether_dst_mac /* ethernet address */,
624 0 /* flag change */);
626 clib_error_report (error);
627 tm->sw_if_index = tm->hw_if_index;
628 vm->os_punt_frame = tuntap_nopunt_frame;
632 vnet_main_t *vnm = vnet_get_main();
633 vnet_hw_interface_t * hi;
635 vm->os_punt_frame = tuntap_punt_frame;
637 tm->hw_if_index = vnet_register_interface
639 tuntap_dev_class.index, 0 /* device instance */,
640 tuntap_interface_class.index, 0);
641 hi = vnet_get_hw_interface (vnm, tm->hw_if_index);
642 tm->sw_if_index = hi->sw_if_index;
644 /* Interface is always up. */
645 vnet_hw_interface_set_flags (vnm, tm->hw_if_index,
646 VNET_HW_INTERFACE_FLAG_LINK_UP);
647 vnet_sw_interface_set_flags (vnm, tm->sw_if_index,
648 VNET_SW_INTERFACE_FLAG_ADMIN_UP);
652 clib_file_t template = {0};
653 template.read_function = tuntap_read_ready;
654 template.file_descriptor = tm->dev_net_tun_fd;
655 tm->clib_file_index = clib_file_add (&file_main, &template);
661 if (tm->dev_net_tun_fd >= 0)
662 close (tm->dev_net_tun_fd);
663 if (tm->dev_tap_fd >= 0)
664 close (tm->dev_tap_fd);
670 VLIB_CONFIG_FUNCTION (tuntap_config, "tuntap");
673 * @brief Add or Del IP4 address to tun/tap interface
675 * @param *im - ip4_main_t
676 * @param opaque - uword
677 * @param sw_if_index - u32
678 * @param *address - ip4_address_t
679 * @param is_delete - u32
683 tuntap_ip4_add_del_interface_address (ip4_main_t * im,
686 ip4_address_t * address,
688 u32 if_address_index,
691 tuntap_main_t * tm = &tuntap_main;
693 subif_address_t subif_addr, * ap;
696 /** Tuntap disabled, or using a "normal" interface. */
697 if (tm->have_normal_interface || tm->dev_tap_fd < 0)
700 /* if the address is being applied to an interface that is not in
701 * the same table/VRF as this tap, then ignore it.
702 * If we don't do this overlapping address spaces in the diferent tables
703 * breaks the linux host's routing tables */
704 if (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
706 fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
710 /** See if we already know about this subif */
711 memset (&subif_addr, 0, sizeof (subif_addr));
712 subif_addr.sw_if_index = sw_if_index;
713 clib_memcpy (&subif_addr.addr, address, sizeof (*address));
715 p = mhash_get (&tm->subif_mhash, &subif_addr);
718 ap = pool_elt_at_index (tm->subifs, p[0]);
721 pool_get (tm->subifs, ap);
723 mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
726 /* Use subif pool index to select alias device. */
727 memset (&ifr, 0, sizeof (ifr));
728 snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
729 "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
731 /* the tuntap punt/inject is enabled for IPv4 RX so long as
732 * any vpp interface has an IPv4 address.
733 * this is also ref counted.
735 ip4_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
739 struct sockaddr_in * sin;
741 sin = (struct sockaddr_in *)&ifr.ifr_addr;
743 /* Set ipv4 address, netmask. */
744 sin->sin_family = AF_INET;
745 clib_memcpy (&sin->sin_addr.s_addr, address, 4);
746 if (ioctl (tm->dev_tap_fd, SIOCSIFADDR, &ifr) < 0)
747 clib_unix_warning ("ioctl SIOCSIFADDR");
749 sin->sin_addr.s_addr = im->fib_masks[address_length];
750 if (ioctl (tm->dev_tap_fd, SIOCSIFNETMASK, &ifr) < 0)
751 clib_unix_warning ("ioctl SIOCSIFNETMASK");
755 mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
756 pool_put (tm->subifs, ap);
759 /* get flags, modify to bring up interface... */
760 if (ioctl (tm->dev_tap_fd, SIOCGIFFLAGS, &ifr) < 0)
761 clib_unix_warning ("ioctl SIOCGIFFLAGS");
764 ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
766 ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
768 if (ioctl (tm->dev_tap_fd, SIOCSIFFLAGS, &ifr) < 0)
769 clib_unix_warning ("ioctl SIOCSIFFLAGS");
773 * @brief workaround for a known include file bug.
774 * including @c <linux/ipv6.h> causes multiple definitions if
775 * @c <netinet/in.h is also included.
778 struct in6_addr ifr6_addr;
784 * @brief Add or Del tun/tap interface address.
786 * Both the v6 interface address API and the way ifconfig
787 * displays subinterfaces differ from their v4 couterparts.
788 * The code given here seems to work but YMMV.
790 * @param *im - ip6_main_t
791 * @param opaque - uword
792 * @param sw_if_index - u32
793 * @param *address - ip6_address_t
794 * @param address_length - u32
795 * @param if_address_index - u32
796 * @param is_delete - u32
799 tuntap_ip6_add_del_interface_address (ip6_main_t * im,
802 ip6_address_t * address,
804 u32 if_address_index,
807 tuntap_main_t * tm = &tuntap_main;
809 struct in6_ifreq ifr6;
810 subif_address_t subif_addr, * ap;
813 /* Tuntap disabled, or using a "normal" interface. */
814 if (tm->have_normal_interface || tm->dev_tap_fd < 0)
817 /* if the address is being applied to an interface that is not in
818 * the same table/VRF as this tap, then ignore it.
819 * If we don't do this overlapping address spaces in the diferent tables
820 * breaks the linux host's routing tables */
821 if (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP6,
823 fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP6,
827 /* See if we already know about this subif */
828 memset (&subif_addr, 0, sizeof (subif_addr));
829 subif_addr.sw_if_index = sw_if_index;
830 subif_addr.is_v6 = 1;
831 clib_memcpy (&subif_addr.addr, address, sizeof (*address));
833 p = mhash_get (&tm->subif_mhash, &subif_addr);
836 ap = pool_elt_at_index (tm->subifs, p[0]);
839 pool_get (tm->subifs, ap);
841 mhash_set (&tm->subif_mhash, ap, ap - tm->subifs, 0);
844 /* Use subif pool index to select alias device. */
845 memset (&ifr, 0, sizeof (ifr));
846 memset (&ifr6, 0, sizeof (ifr6));
847 snprintf (ifr.ifr_name, sizeof(ifr.ifr_name),
848 "%s:%d", tm->tun_name, (int)(ap - tm->subifs));
850 /* the tuntap punt/inject is enabled for IPv6 RX so long as
851 * any vpp interface has an IPv6 address.
852 * this is also ref counted.
854 ip6_sw_interface_enable_disable (tm->sw_if_index, !is_delete);
858 int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
860 clib_unix_warning ("get ifindex socket");
862 if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
863 clib_unix_warning ("get ifindex");
865 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
866 ifr6.ifr6_prefixlen = address_length;
867 clib_memcpy (&ifr6.ifr6_addr, address, 16);
869 if (ioctl (sockfd, SIOCSIFADDR, &ifr6) < 0)
870 clib_unix_warning ("set address");
877 int sockfd = socket (AF_INET6, SOCK_STREAM, 0);
879 clib_unix_warning ("get ifindex socket");
881 if (ioctl (sockfd, SIOGIFINDEX, &ifr) < 0)
882 clib_unix_warning ("get ifindex");
884 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
885 ifr6.ifr6_prefixlen = address_length;
886 clib_memcpy (&ifr6.ifr6_addr, address, 16);
888 if (ioctl (sockfd, SIOCDIFADDR, &ifr6) < 0)
889 clib_unix_warning ("del address");
894 mhash_unset (&tm->subif_mhash, &subif_addr, 0 /* old value ptr */);
895 pool_put (tm->subifs, ap);
900 * @brief TX the tun/tap frame
902 * @param *vm - vlib_main_t
903 * @param *node - vlib_node_runtime_t
904 * @param *frame - vlib_frame_t
908 tuntap_punt_frame (vlib_main_t * vm,
909 vlib_node_runtime_t * node,
910 vlib_frame_t * frame)
912 tuntap_tx (vm, node, frame);
913 vlib_frame_free (vm, node, frame);
917 * @brief Free the tun/tap frame
919 * @param *vm - vlib_main_t
920 * @param *node - vlib_node_runtime_t
921 * @param *frame - vlib_frame_t
925 tuntap_nopunt_frame (vlib_main_t * vm,
926 vlib_node_runtime_t * node,
927 vlib_frame_t * frame)
929 u32 * buffers = vlib_frame_args (frame);
930 uword n_packets = frame->n_vectors;
931 vlib_buffer_free (vm, buffers, n_packets);
932 vlib_frame_free (vm, node, frame);
935 VNET_HW_INTERFACE_CLASS (tuntap_interface_class,static) = {
937 .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
941 * @brief Format tun/tap interface name
943 * @param *s - u8 - formatter string
944 * @param *args - va_list
946 * @return *s - u8 - formatted string
949 static u8 * format_tuntap_interface_name (u8 * s, va_list * args)
951 u32 i = va_arg (*args, u32);
953 s = format (s, "tuntap-%d", i);
958 * @brief TX packet out tun/tap
960 * @param *vm - vlib_main_t
961 * @param *node - vlib_node_runtime_t
962 * @param *frame - vlib_frame_t
964 * @return n_buffers - uword - Packets transmitted
968 tuntap_intfc_tx (vlib_main_t * vm,
969 vlib_node_runtime_t * node,
970 vlib_frame_t * frame)
972 tuntap_main_t * tm = &tuntap_main;
973 u32 * buffers = vlib_frame_args (frame);
974 uword n_buffers = frame->n_vectors;
976 /* Normal interface transmit happens only on the normal interface... */
977 if (tm->have_normal_interface)
978 return tuntap_tx (vm, node, frame);
980 vlib_buffer_free (vm, buffers, n_buffers);
984 VNET_DEVICE_CLASS (tuntap_dev_class,static) = {
986 .tx_function = tuntap_intfc_tx,
987 .format_device_name = format_tuntap_interface_name,
991 * @brief tun/tap node init
993 * @param *vm - vlib_main_t
995 * @return error - clib_error_t
998 static clib_error_t *
999 tuntap_init (vlib_main_t * vm)
1001 clib_error_t * error;
1002 ip4_main_t * im4 = &ip4_main;
1003 ip6_main_t * im6 = &ip6_main;
1004 ip4_add_del_interface_address_callback_t cb4;
1005 ip6_add_del_interface_address_callback_t cb6;
1006 tuntap_main_t * tm = &tuntap_main;
1008 error = vlib_call_init_function (vm, ip4_init);
1012 mhash_init (&tm->subif_mhash, sizeof (u32), sizeof(subif_address_t));
1014 cb4.function = tuntap_ip4_add_del_interface_address;
1015 cb4.function_opaque = 0;
1016 vec_add1 (im4->add_del_interface_address_callbacks, cb4);
1018 cb6.function = tuntap_ip6_add_del_interface_address;
1019 cb6.function_opaque = 0;
1020 vec_add1 (im6->add_del_interface_address_callbacks, cb6);
1025 VLIB_INIT_FUNCTION (tuntap_init);