ip/iptuntap.c

   1 /*
   2  * iptunnel.c          "ip tuntap"
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     David Woodhouse <David.Woodhouse@intel.com>
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <sys/types.h>
  18 #include <sys/socket.h>
  19 #include <arpa/inet.h>
  20 #include <sys/ioctl.h>
  21 #include <linux/if.h>
  22 #include <linux/if_tun.h>
  23 #include <pwd.h>
  24 #include <grp.h>
  25 #include <fcntl.h>
  26 #include <dirent.h>
  27 #include <errno.h>
  28 #include <glob.h>
  29
  30 #include "rt_names.h"
  31 #include "utils.h"
  32 #include "ip_common.h"
  33
  34 #define TUNDEV "/dev/net/tun"
  35
  36 static void usage(void) __attribute__((noreturn));
  37
  38 static void usage(void)
  39 {
  40         fprintf(stderr, "Usage: ip tuntap { add | del | show | list | lst | help } [ dev PHYS_DEV ]\n");
  41         fprintf(stderr, "          [ mode { tun | tap } ] [ user USER ] [ group GROUP ]\n");
  42         fprintf(stderr, "          [ one_queue ] [ pi ] [ vnet_hdr ] [ multi_queue ]\n");
  43         fprintf(stderr, "\n");
  44         fprintf(stderr, "Where: USER  := { STRING | NUMBER }\n");
  45         fprintf(stderr, "       GROUP := { STRING | NUMBER }\n");
  46         exit(-1);
  47 }
  48
  49 static int tap_add_ioctl(struct ifreq *ifr, uid_t uid, gid_t gid)
  50 {
  51         int fd;
  52         int ret = -1;
  53
  54 #ifdef IFF_TUN_EXCL
  55         ifr->ifr_flags |= IFF_TUN_EXCL;
  56 #endif
  57
  58         fd = open(TUNDEV, O_RDWR);
  59         if (fd < 0) {
  60                 perror("open");
  61                 return -1;
  62         }
  63         if (ioctl(fd, TUNSETIFF, ifr)) {
  64                 perror("ioctl(TUNSETIFF)");
  65                 goto out;
  66         }
  67         if (uid != -1 && ioctl(fd, TUNSETOWNER, uid)) {
  68                 perror("ioctl(TUNSETOWNER)");
  69                 goto out;
  70         }
  71         if (gid != -1 && ioctl(fd, TUNSETGROUP, gid)) {
  72                 perror("ioctl(TUNSETGROUP)");
  73                 goto out;
  74         }
  75         if (ioctl(fd, TUNSETPERSIST, 1)) {
  76                 perror("ioctl(TUNSETPERSIST)");
  77                 goto out;
  78         }
  79         ret = 0;
  80  out:
  81         close(fd);
  82         return ret;
  83 }
  84
  85 static int tap_del_ioctl(struct ifreq *ifr)
  86 {
  87         int fd = open(TUNDEV, O_RDWR);
  88         int ret = -1;
  89
  90         if (fd < 0) {
  91                 perror("open");
  92                 return -1;
  93         }
  94         if (ioctl(fd, TUNSETIFF, ifr)) {
  95                 perror("ioctl(TUNSETIFF)");
  96                 goto out;
  97         }
  98         if (ioctl(fd, TUNSETPERSIST, 0)) {
  99                 perror("ioctl(TUNSETPERSIST)");
 100                 goto out;
 101         }
 102         ret = 0;
 103  out:
 104         close(fd);
 105         return ret;
 106
 107 }
 108 static int parse_args(int argc, char **argv, struct ifreq *ifr, uid_t *uid, gid_t *gid)
 109 {
 110         int count = 0;
 111
 112         memset(ifr, 0, sizeof(*ifr));
 113
 114         ifr->ifr_flags |= IFF_NO_PI;
 115
 116         while (argc > 0) {
 117                 if (matches(*argv, "mode") == 0) {
 118                         NEXT_ARG();
 119                         if (matches(*argv, "tun") == 0) {
 120                                 if (ifr->ifr_flags & IFF_TAP) {
 121                                         fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
 122                                         exit(-1);
 123                                 }
 124                                 ifr->ifr_flags |= IFF_TUN;
 125                         } else if (matches(*argv, "tap") == 0) {
 126                                 if (ifr->ifr_flags & IFF_TUN) {
 127                                         fprintf(stderr, "You managed to ask for more than one tunnel mode.\n");
 128                                         exit(-1);
 129                                 }
 130                                 ifr->ifr_flags |= IFF_TAP;
 131                         } else {
 132                                 fprintf(stderr, "Unknown tunnel mode \"%s\"\n", *argv);
 133                                 exit(-1);
 134                         }
 135                 } else if (uid && matches(*argv, "user") == 0) {
 136                         char *end;
 137                         unsigned long user;
 138
 139                         NEXT_ARG();
 140                         if (**argv && ((user = strtol(*argv, &end, 10)), !*end))
 141                                 *uid = user;
 142                         else {
 143                                 struct passwd *pw = getpwnam(*argv);
 144
 145                                 if (!pw) {
 146                                         fprintf(stderr, "invalid user \"%s\"\n", *argv);
 147                                         exit(-1);
 148                                 }
 149                                 *uid = pw->pw_uid;
 150                         }
 151                 } else if (gid && matches(*argv, "group") == 0) {
 152                         char *end;
 153                         unsigned long group;
 154
 155                         NEXT_ARG();
 156
 157                         if (**argv && ((group = strtol(*argv, &end, 10)), !*end))
 158                                 *gid = group;
 159                         else {
 160                                 struct group *gr = getgrnam(*argv);
 161
 162                                 if (!gr) {
 163                                         fprintf(stderr, "invalid group \"%s\"\n", *argv);
 164                                         exit(-1);
 165                                 }
 166                                 *gid = gr->gr_gid;
 167                         }
 168                 } else if (matches(*argv, "pi") == 0) {
 169                         ifr->ifr_flags &= ~IFF_NO_PI;
 170                 } else if (matches(*argv, "one_queue") == 0) {
 171                         ifr->ifr_flags |= IFF_ONE_QUEUE;
 172                 } else if (matches(*argv, "vnet_hdr") == 0) {
 173                         ifr->ifr_flags |= IFF_VNET_HDR;
 174                 } else if (matches(*argv, "multi_queue") == 0) {
 175                         ifr->ifr_flags |= IFF_MULTI_QUEUE;
 176                 } else if (matches(*argv, "dev") == 0) {
 177                         NEXT_ARG();
 178                         strncpy(ifr->ifr_name, *argv, IFNAMSIZ-1);
 179                 } else {
 180                         if (matches(*argv, "name") == 0) {
 181                                 NEXT_ARG();
 182                         } else if (matches(*argv, "help") == 0)
 183                                 usage();
 184                         if (ifr->ifr_name[0])
 185                                 duparg2("name", *argv);
 186                         strncpy(ifr->ifr_name, *argv, IFNAMSIZ);
 187                 }
 188                 count++;
 189                 argc--; argv++;
 190         }
 191
 192         if (!(ifr->ifr_flags & TUN_TYPE_MASK)) {
 193                 fprintf(stderr, "You failed to specify a tunnel mode\n");
 194                 return -1;
 195         }
 196
 197         return 0;
 198 }
 199
 200
 201 static int do_add(int argc, char **argv)
 202 {
 203         struct ifreq ifr;
 204         uid_t uid = -1;
 205         gid_t gid = -1;
 206
 207         if (parse_args(argc, argv, &ifr, &uid, &gid) < 0)
 208                 return -1;
 209
 210         return tap_add_ioctl(&ifr, uid, gid);
 211 }
 212
 213 static int do_del(int argc, char **argv)
 214 {
 215         struct ifreq ifr;
 216
 217         if (parse_args(argc, argv, &ifr, NULL, NULL) < 0)
 218                 return -1;
 219
 220         return tap_del_ioctl(&ifr);
 221 }
 222
 223 static int read_prop(char *dev, char *prop, long *value)
 224 {
 225         char fname[IFNAMSIZ+25], buf[80], *endp;
 226         ssize_t len;
 227         int fd;
 228         long result;
 229
 230         sprintf(fname, "/sys/class/net/%s/%s", dev, prop);
 231         fd = open(fname, O_RDONLY);
 232         if (fd < 0) {
 233                 if (strcmp(prop, "tun_flags"))
 234                         fprintf(stderr, "open %s: %s\n", fname,
 235                                 strerror(errno));
 236                 return -1;
 237         }
 238         len = read(fd, buf, sizeof(buf)-1);
 239         close(fd);
 240         if (len < 0) {
 241                 fprintf(stderr, "read %s: %s", fname, strerror(errno));
 242                 return -1;
 243         }
 244
 245         buf[len] = 0;
 246         result = strtol(buf, &endp, 0);
 247         if (*endp != '\n') {
 248                 fprintf(stderr, "Failed to parse %s\n", fname);
 249                 return -1;
 250         }
 251         *value = result;
 252         return 0;
 253 }
 254
 255 static void print_flags(long flags)
 256 {
 257         if (flags & IFF_TUN)
 258                 printf(" tun");
 259
 260         if (flags & IFF_TAP)
 261                 printf(" tap");
 262
 263         if (!(flags & IFF_NO_PI))
 264                 printf(" pi");
 265
 266         if (flags & IFF_ONE_QUEUE)
 267                 printf(" one_queue");
 268
 269         if (flags & IFF_VNET_HDR)
 270                 printf(" vnet_hdr");
 271
 272         flags &= ~(IFF_TUN|IFF_TAP|IFF_NO_PI|IFF_ONE_QUEUE|IFF_VNET_HDR);
 273         if (flags)
 274                 printf(" UNKNOWN_FLAGS:%lx", flags);
 275 }
 276
 277 static char *pid_name(pid_t pid)
 278 {
 279         char *comm;
 280         FILE *f;
 281         int err;
 282
 283         err = asprintf(&comm, "/proc/%d/comm", pid);
 284         if (err < 0)
 285                 return NULL;
 286
 287         f = fopen(comm, "r");
 288         free(comm);
 289         if (!f) {
 290                 perror("fopen");
 291                 return NULL;
 292         }
 293
 294         if (fscanf(f, "%ms\n", &comm) != 1) {
 295                 perror("fscanf");
 296                 comm = NULL;
 297         }
 298
 299
 300         if (fclose(f))
 301                 perror("fclose");
 302
 303         return comm;
 304 }
 305
 306 static void show_processes(const char *name)
 307 {
 308         glob_t globbuf = { };
 309         char **fd_path;
 310         int err;
 311
 312         err = glob("/proc/[0-9]*/fd/[0-9]*", GLOB_NOSORT,
 313                    NULL, &globbuf);
 314         if (err)
 315                 return;
 316
 317         fd_path = globbuf.gl_pathv;
 318         while (*fd_path) {
 319                 const char *dev_net_tun = "/dev/net/tun";
 320                 const size_t linkbuf_len = strlen(dev_net_tun) + 2;
 321                 char linkbuf[linkbuf_len], *fdinfo;
 322                 int pid, fd;
 323                 FILE *f;
 324
 325                 if (sscanf(*fd_path, "/proc/%d/fd/%d", &pid, &fd) != 2)
 326                         goto next;
 327
 328                 if (pid == getpid())
 329                         goto next;
 330
 331                 err = readlink(*fd_path, linkbuf, linkbuf_len - 1);
 332                 if (err < 0) {
 333                         perror("readlink");
 334                         goto next;
 335                 }
 336                 linkbuf[err] = '\0';
 337                 if (strcmp(dev_net_tun, linkbuf))
 338                         goto next;
 339
 340                 if (asprintf(&fdinfo, "/proc/%d/fdinfo/%d", pid, fd) < 0)
 341                         goto next;
 342
 343                 f = fopen(fdinfo, "r");
 344                 free(fdinfo);
 345                 if (!f) {
 346                         perror("fopen");
 347                         goto next;
 348                 }
 349
 350                 while (!feof(f)) {
 351                         char *key = NULL, *value = NULL;
 352
 353                         err = fscanf(f, "%m[^:]: %ms\n", &key, &value);
 354                         if (err == EOF) {
 355                                 if (ferror(f))
 356                                         perror("fscanf");
 357                                 break;
 358                         } else if (err == 2 &&
 359                                    !strcmp("iff", key) && !strcmp(name, value)) {
 360                                 char *pname = pid_name(pid);
 361                                 printf(" %s(%d)", pname ? pname : "<NULL>", pid);
 362                                 free(pname);
 363                         }
 364
 365                         free(key);
 366                         free(value);
 367                 }
 368                 if (fclose(f))
 369                         perror("fclose");
 370
 371 next:
 372                 ++fd_path;
 373         }
 374
 375         globfree(&globbuf);
 376         return;
 377 }
 378
 379
 380 static int do_show(int argc, char **argv)
 381 {
 382         DIR *dir;
 383         struct dirent *d;
 384         long flags, owner = -1, group = -1;
 385
 386         dir = opendir("/sys/class/net");
 387         if (!dir) {
 388                 perror("opendir");
 389                 return -1;
 390         }
 391         while ((d = readdir(dir))) {
 392                 if (d->d_name[0] == '.' &&
 393                     (d->d_name[1] == 0 || d->d_name[1] == '.'))
 394                         continue;
 395
 396                 if (read_prop(d->d_name, "tun_flags", &flags))
 397                         continue;
 398
 399                 read_prop(d->d_name, "owner", &owner);
 400                 read_prop(d->d_name, "group", &group);
 401
 402                 printf("%s:", d->d_name);
 403                 print_flags(flags);
 404                 if (owner != -1)
 405                         printf(" user %ld", owner);
 406                 if (group != -1)
 407                         printf(" group %ld", group);
 408                 printf("\n");
 409                 if (show_details) {
 410                         printf("\tAttached to processes:");
 411                         show_processes(d->d_name);
 412                         printf("\n");
 413                 }
 414         }
 415         closedir(dir);
 416         return 0;
 417 }
 418
 419 int do_iptuntap(int argc, char **argv)
 420 {
 421         if (argc > 0) {
 422                 if (matches(*argv, "add") == 0)
 423                         return do_add(argc-1, argv+1);
 424                 if (matches(*argv, "delete") == 0)
 425                         return do_del(argc-1, argv+1);
 426                 if (matches(*argv, "show") == 0 ||
 427                     matches(*argv, "lst") == 0 ||
 428                     matches(*argv, "list") == 0)
 429                         return do_show(argc-1, argv+1);
 430                 if (matches(*argv, "help") == 0)
 431                         usage();
 432         } else
 433                 return do_show(0, NULL);
 434
 435         fprintf(stderr, "Command \"%s\" is unknown, try \"ip tuntap help\".\n",
 436                 *argv);
 437         exit(-1);
 438 }