c - Linux TUN/TAP : Unable to read data back from TAP devices

Question

问题是关于要使用 Tun/Tap 模块的 Linux 主机的正确配置。

我的目标:

利用现有的路由软件(下文中的 APP1 和 APP2)，但拦截和修改它发送和接收的所有消息(由 Mediator 完成)。

我的场景:

              Ubuntu 10.04 Machine
+---------------------------------------------+
|                                             |
|APP1 --- tap1 --- Mediator --- tap2 --- APP2 |
|                                             |
+---------------------------------------------+

• tap1 和 tap2:分别使用 IFF_TAP 标志和 IP 10.0.0.1/24 和 10.0.0.2/24 设置的 tap 设备。创 build 备的代码如下:

  #include <stdlib.h>
  #include <stdio.h>
  #include <sys/socket.h>
  #include <sys/ioctl.h>
  #include <fcntl.h>
  #include <linux/if.h>
  #include <linux/if_tun.h>
  #include <string.h>
  #include <errno.h>
  #include <sys/resource.h>
  
  void createTun(char *, char *, short);
  
  int main(void)
  {
      const short FLAGS = IFF_TAP;
      char *tunName;
      char *tunIP;
  
      // Create tap1
      tunName = "tap1\0";
      tunIP = "10.0.0.1/24\0";
      createTun(tunName, tunIP, FLAGS);
      printf("Created %s with IP %s\n", tunName, tunIP);
  
      // Create tap2
      tunName = "tap2\0";
      tunIP = "10.0.0.2/24\0";
      createTun(tunName, tunIP, FLAGS);
      printf("Created %s with IP %s\n", tunName, tunIP);
  
      return 0;
  }
  
  void createTun(char *tunName, char *tunIP, short FLAGS)
  {
      char *cmd;
      char *cloneDev = "/dev/net/tun";
      char *cmdIPLinkUpTemplate = "ip link set %s up";
      char *cmdIPAddrAddTemplate = "ip addr add %s dev %s";
      int cmdIPLinkUpRawLength = strlen(cmdIPLinkUpTemplate) - 2;
      int cmdIPAddrAddRawLength = strlen(cmdIPAddrAddTemplate) - 4;
      FILE *fp;
      int fd, err, owner, group;
      struct ifreq ifr;
  
      owner = geteuid();
      group = getegid();
  
      // open the clone device
      if((fd = open(cloneDev, O_RDWR)) < 0)
      {
          perror("OPEN CLONEDEV failed.");
          exit(EXIT_FAILURE);
      }
  
      memset(&ifr, 0, sizeof(struct ifreq));
      ifr.ifr_flags = FLAGS;
      strncpy(ifr.ifr_name, tunName, strlen(tunName));
  
      // create the device
      if(ioctl(fd, TUNSETIFF, (void *) &ifr) < 0)
      {
          perror("IOCTL SETIFF denied.");
          close(fd);
          exit(EXIT_FAILURE);
      }
  
      // set dev owner
      if(owner != -1)
      {
      if(ioctl(fd, TUNSETOWNER, owner) < 0)
      {
          perror("IOCTL SETOWNER denied.");
          close(fd);
          exit(EXIT_FAILURE);
      }
      }
  
      // set dev group
      if(group != -1)
      {
      if(ioctl(fd, TUNSETGROUP, group) < 0)
      {
          perror("IOCTL SETGROUP denied.");
          close(fd);
          exit(EXIT_FAILURE);
      }
      }
  
      // set dev persistent
      if(ioctl(fd, TUNSETPERSIST, 1) < 0)
      {
          perror("IOCTL SETPERSIST denied.");
          close(fd);
          exit(EXIT_FAILURE);
      }
  
      // Set dev up
      cmd = malloc(cmdIPLinkUpRawLength + strlen(tunName) + 1);
      sprintf(cmd, cmdIPLinkUpTemplate, ifr.ifr_name);
      fp = popen(cmd, "r");
      if(fp == NULL)
      {
          perror("POPEN failed.");
          close(fd);
          free(cmd);
          exit(EXIT_FAILURE);
      }
      pclose(fp);
      free(cmd);
  
      // Assign IP
      cmd = malloc(cmdIPAddrAddRawLength + strlen(tunIP) + strlen(tunName) + 1);
      sprintf(cmd, cmdIPAddrAddTemplate, tunIP, tunName);
      fp = popen(cmd, "r");
      if(fp == NULL)
      {
          perror("POPEN failed.");
          close(fd);
          free(cmd);
          exit(EXIT_FAILURE);
      }
  
      pclose(fp);
      free(cmd);
  
      return;
  }
  

• 中介者:自行编写的小型代码，用于简单地在 tap1 和 tap2 之间中继数据。基本结构如下:

  #include <unistd.h>
  #include <stdio.h>
  #include <sys/socket.h>
  #include <netinet/ip.h>
  #include <sys/ioctl.h>
  #include <sys/resource.h>
  #include <sys/epoll.h>
  #include <errno.h>
  #include <fcntl.h>
  #include <stdlib.h>
  #include <string.h>
  #include <linux/if.h>
  #include <linux/if_tun.h>
  
  int main(int argc, char *argv[])
  {
      const int NOF_FD = 2;
      const char *TUN1 = "tap1";
      const char *TUN2 = "tap2";
      const char *CLONEDEV = "/dev/net/tun";
      int fd_tun1, fd_tun2, fd_epoll;
      struct ifreq ifr_tun1, ifr_tun2;
      struct epoll_event ev;
      const int MAX_EVENTS = 1;
      int ready, s, t;
      const int MAX_BUF = 2000;
      char buf[MAX_BUF];
      struct sockaddr_in to;
      const short FLAGS = IFF_TAP;
  
      // Open tap1
      if((fd_tun1 = open(CLONEDEV, O_RDWR)) < 0)
      {
          perror("OPEN CLONEDEV for tun1 failed");
          exit(EXIT_FAILURE);
      }
  
      memset(&ifr_tun1, 0, sizeof(struct ifreq));
      ifr_tun1.ifr_flags = FLAGS;
      strcpy(ifr_tun1.ifr_name, TUN1);
      if(ioctl(fd_tun1, TUNSETIFF, (void *) &ifr_tun1) < 0)
      {
          perror("IOCTL SETIFF for tap1 failed");
          close(fd_tun1);
          exit(EXIT_FAILURE);
      }
  
      // Open tap2
      if((fd_tun2 = open(CLONEDEV, O_RDWR)) < 0)
      {
          perror("OPEN CLONEDEV for tap2 failed");
          exit(EXIT_FAILURE);
      }
  
      memset(&ifr_tun2, 0, sizeof(struct ifreq));
      ifr_tun2.ifr_flags = FLAGS;
      strcpy(ifr_tun2.ifr_name, TUN2);
      if(ioctl(fd_tun2, TUNSETIFF, (void *) &ifr_tun2) < 0)
      {
          perror("IOCTL SETIFF for tun2 failed");
          close(fd_tun1);
          close(fd_tun2);
          exit(EXIT_FAILURE);
      }
  
      // Prepare EPOLL
      if((fd_epoll = epoll_create(NOF_FD)) < 0)
      {
          perror("EPOLL CREATE failed");
          close(fd_tun1);
          close(fd_tun2);
          exit(EXIT_FAILURE);
      }
  
      memset(&ev, 0, sizeof(ev));
      ev.events = EPOLLIN;
      ev.data.fd = fd_tun1;
      if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, fd_tun1, &ev) < 0)
      {
          perror("EPOLL CTL ADD fd_tun1 failed");
          close(fd_tun1);
          close(fd_tun2);
          close(fd_epoll);
          exit(EXIT_FAILURE);
      }
  
      memset(&ev, 0, sizeof(ev));
      ev.events = EPOLLIN;
      ev.data.fd = fd_tun2;
      if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, fd_tun2, &ev) < 0)
      {
          perror("EPOLL CTL ADD fd_tun2 failed");
          close(fd_tun1);
          close(fd_tun2);
          close(fd_epoll);
          exit(EXIT_FAILURE);
      }
  
      // Do relay
      while(1)
      {
          if((ready = epoll_wait(fd_epoll, &ev, MAX_EVENTS, -1)) < 0)
          {
              if(errno == EINTR)
                  continue;
              else
              {
                  perror("EPOLL WAIT failed");
                  close(fd_tun1);
                  close(fd_tun2);
                  close(fd_epoll);
                  exit(EXIT_FAILURE);
              }
          }
  
          //printf("EPOLL WAIT SIGNALED\n");
  
          if(ev.events & EPOLLIN)
          {
              if((s = read(ev.data.fd, buf, MAX_BUF)) < 0)
              {
                  perror("READ failed");
                  close(fd_tun1);
                  close(fd_tun2);
                  close(fd_epoll);
                  exit(EXIT_FAILURE);
              }
  
              printf("Read from %s. Bytes: %d\nData:\n", (ev.data.fd == fd_tun1 ? "tun1" : "tun2"), s);
              int k;
              for(k = 0; k < s; k++)
              {
                  printf("%c", buf[k]);
              }
              printf("\n");
  
              t = (ev.data.fd == fd_tun1) ? fd_tun2 : fd_tun1;
  
              if((s = write(t, buf, s)) < 0)
              {
                  perror("WRITE failed");
                  close(fd_tun1);
                  close(fd_tun2);
                  close(fd_epoll);
                  exit(EXIT_FAILURE);
              }
  
              printf("Written to %s. Bytes: %d\n", (t == fd_tun1 ? "tun1" : "tun2"), s);
  
              if(epoll_ctl(fd_epoll, EPOLL_CTL_DEL, ev.data.fd, NULL) < 0)
              {
                  perror("EPOLL CTL DEL failed");
                  close(fd_tun1);
                  close(fd_tun2);
                  close(fd_epoll);
                  exit(EXIT_FAILURE);
              }
  
              if(epoll_ctl(fd_epoll, EPOLL_CTL_ADD, ev.data.fd, &ev) < 0)
              {
                  perror("EPOLL CTL ADD failed");
                  close(fd_tun1);
                  close(fd_tun2);
                  close(fd_epoll);
                  exit(EXIT_FAILURE);
              }
          }
  
          printf("\n\n");
      }
  }
  

• APP1 和 APP2:OSPF 路由守护进程分别通过 tap1 和 tap2 进行通信。守护进程的 strace 显示基本上涉及以下系统调用:

  socket(PF_INET, SOCK_RAW, 0X59 /*IPPROTO_??? */) = 8 // Opening a socket for OSPF and tap1
  fcntl64(8, F_SETFL, 0_RDONLY | 0_NONBLOCK) = 0
  setsockopt(8, SOL_IP, IP_TOS, [192], 4) = 0
  setsockopt(8, SOL_SOCKET, SO_PRIORITY, [7], 4) = 0
  setsockopt(8, SOL_IP, IP_PKTINFO, [1], 4) = 0
  setsockopt(8, SOL_IP, IP_MTU_DISCOVER, [0], 4) = 0
  setsockopt(8, SOL_IP, IP_MULTICAST_LOOP, [0], 4) = 0
  setsockopt(8, SOL_IP, IP_MULTICAST_TTL, [1], 4) = 0
  setsockopt(8, SOL_IP, IP_MUTLICAST_IF, "\0\0\0\0\n\0\0\1\223\0\0\0", 12) = 0
  setsockopt(8, SOL_SOCKET, SO_BINDTODEVICE, "tap1\0\0\0\0\0\0\0\0\0\0\0\0\0\315\375\307\250\352\t\t8\207\t\10\0\0\0\0", 32) = 0
  setsockopt(8, SOL_IP, IP_ADD_MEMBERSHIP, "340\0\0\5\n\0\0\1\223\0\0\0", 12) = 0
  
  // Then it gets in a cycle like:
  select(9, [3, 7, 8], [], NULL, {1, 0}) = 0 (Timeout)
  clock_gettime(CLOCK_MONOTONIC, {120893, 360452769}) = 0
  time(NULL)
  clock_gettime(CLOCK_MONOTONIC, {120893, 360504525}) = 0
  select(9, [3, 7, 8], [], NULL, {1, 0}) = 0 (Timeout)
  clock_gettime(CLOCK_MONOTONIC, {120894, 363022746}) = 0
  time(NULL)
  ...
  

我的用法:

• 将 wireshark 附加到 tap1。 (还没有看到流量)。
• 启动 APP1。 (wireshark 看到源为 10.0.0.1 (tap1) 的 IGMP 和 OSPF 消息)
• 启动 APP2。 (wireshark 仍然只能看到源为 10.0.0.1 (tap1) 的 IGMP 和 OSPF 消息，因为 Mediator 尚未运行)
• 启动调解器。 (wireshark 现在可以看到源为 tap1 和 tap2 的 IGMP 和 OSPF 消息)。

我的问题:

即使连接到 tap1 的 wireshark 看到来自 tap1 和 tap2 的消息，APP2 也没有收到 APP1 发送的消息，APP2 也没有收到来自 APP1 的消息。在上面显示的 strace 提取中，select() 调用永远不会返回文件描述符 8，它实际上是连接到 tap1 的套接字。

我的问题:

为什么 APP1 没有收到 APP2 发送的消息，即使这些消息是由 APP2 发送、由 Mediator 中继并被连接到 tap1 的 wireshark 看到的？

我是否必须在我的 Linux 主机上添加任何类型/种类的额外路由？

我是否在设置 tun/tap 设备时犯了错误？

我的 Mediator 代码是否无法正常工作？

Answer 1

我没有尝试过你的代码(你能够从用户空间而不是 using a multiqueue flag 打开 TAP 设备两次有点奇怪，但我们假设这是正确的)，但是你在处理方式上有一个概念错误TAP 设备。

TUN/TAP 本质上只是一个管道，这个管道的一侧在内核(tapX 接口(interface))中，另一侧在一些用户空间应用程序中。这个应用程序写入管道的任何内容都会作为传入流量到达内核接口(interface)(您可以使用 wireshark 看到它)。无论内核发送到该管道(传出到 tapX)，最终都会进入应用程序(您可以在应用程序中读取的数据)。

您的代码当前正在做的是打开同一管道的另一个用户空间部分，而这不是您想要的。你想在管道的另一边获得流量。从技术上讲，您当前正在做的事情可以通过一个简单的桥接接口(interface)来完成，将两个分路器作为端口添加到其中。当然，如果您不仅要桥接，而且要以某种方式修改流量，事情会变得有点复杂。

解决这个问题的一种方法是添加另一对 TAP 接口(interface)。您将 tap1 与 tap3 和 tap2 与 tap4 桥接(如在内核桥中)，现在您在“中介”中打开 tap3 和 tap4 以及它们之间的代理帧。这是非常低效的，但可能是您问题的解决方案。