mdw@git.distorted.org.uk Git - secnet/blob - tun.c

   1 #include "secnet.h"
   2 #include "util.h"
   3 #include "netlink.h"
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <errno.h>
   7 #include <unistd.h>
   8 #include <fcntl.h>
   9 #include <sys/ioctl.h>
  10 #include <sys/utsname.h>
  11 #include <sys/socket.h>
  12
  13 #ifdef HAVE_NET_IF_H
  14 #include <net/if.h>
  15 #ifdef HAVE_LINUX_IF_H
  16 #include <linux/if_tun.h>
  17 #define LINUX_TUN_SUPPORTED
  18 #endif
  19 #endif
  20
  21 #ifdef HAVE_NET_ROUTE_H
  22 #include <net/route.h>
  23 #endif
  24
  25 #if defined(HAVE_STROPTS_H) && defined(HAVE_SYS_SOCKIO_H) && \
  26 defined(HAVE_NET_IF_TUN_H)
  27 #define HAVE_TUN_STREAMS
  28 #endif
  29
  30 #ifdef HAVE_TUN_STREAMS
  31 #include <stropts.h>
  32 #include <sys/sockio.h>
  33 #include <net/if_tun.h>
  34 #endif
  35
  36 #define TUN_FLAVOUR_GUESS   0
  37 #define TUN_FLAVOUR_BSD     1
  38 #define TUN_FLAVOUR_LINUX   2
  39 #define TUN_FLAVOUR_STREAMS 3
  40
  41 static struct flagstr flavours[]={
  42     {"guess", TUN_FLAVOUR_GUESS},
  43     {"bsd", TUN_FLAVOUR_BSD},
  44     {"BSD", TUN_FLAVOUR_BSD},
  45     {"linux", TUN_FLAVOUR_LINUX},
  46     {"streams", TUN_FLAVOUR_STREAMS},
  47     {"STREAMS", TUN_FLAVOUR_STREAMS},
  48     {NULL, 0}
  49 };
  50
  51 #define TUN_CONFIG_GUESS      0
  52 #define TUN_CONFIG_IOCTL      1
  53 #define TUN_CONFIG_BSD        2
  54 #define TUN_CONFIG_LINUX      3
  55 #define TUN_CONFIG_SOLARIS25  4
  56
  57 static struct flagstr config_types[]={
  58     {"guess", TUN_CONFIG_GUESS},
  59     {"ioctl", TUN_CONFIG_IOCTL},
  60     {"bsd", TUN_CONFIG_BSD},
  61     {"BSD", TUN_CONFIG_BSD},
  62     {"linux", TUN_CONFIG_LINUX},
  63     {"solaris-2.5", TUN_CONFIG_SOLARIS25},
  64     {NULL, 0}
  65 };
  66
  67 /* Connection to the kernel through the universal TUN/TAP driver */
  68
  69 struct tun {
  70     struct netlink nl;
  71     int fd;
  72     cstring_t device_path;
  73     cstring_t ip_path;
  74     string_t interface_name;
  75     cstring_t ifconfig_path;
  76     uint32_t ifconfig_type;
  77     cstring_t route_path;
  78     uint32_t route_type;
  79     uint32_t tun_flavour;
  80     bool_t search_for_if; /* Applies to tun-BSD only */
  81     struct buffer_if *buff; /* We receive packets into here
  82                                and send them to the netlink code. */
  83     netlink_deliver_fn *netlink_to_tunnel;
  84     uint32_t local_address; /* host interface address */
  85 };
  86
  87 static cstring_t tun_flavour_str(uint32_t flavour)
  88 {
  89     switch (flavour) {
  90     case TUN_FLAVOUR_GUESS: return "guess";
  91     case TUN_FLAVOUR_BSD: return "BSD";
  92     case TUN_FLAVOUR_LINUX: return "linux";
  93     case TUN_FLAVOUR_STREAMS: return "STREAMS";
  94     default: return "unknown";
  95     }
  96 }
  97
  98 static int tun_beforepoll(void *sst, struct pollfd *fds, int *nfds_io,
  99                           int *timeout_io)
 100 {
 101     struct tun *st=sst;
 102     *nfds_io=1;
 103     fds[0].fd=st->fd;
 104     fds[0].events=POLLIN;
 105     return 0;
 106 }
 107
 108 static void tun_afterpoll(void *sst, struct pollfd *fds, int nfds)
 109 {
 110     struct tun *st=sst;
 111     int l;
 112
 113     if (nfds==0) return;
 114     if (fds[0].revents&POLLERR) {
 115         printf("tun_afterpoll: hup!\n");
 116     }
 117     if (fds[0].revents&POLLIN) {
 118         BUF_ALLOC(st->buff,"tun_afterpoll");
 119         buffer_init(st->buff,st->nl.max_start_pad);
 120         l=read(st->fd,st->buff->start,st->buff->len-st->nl.max_start_pad);
 121         if (l<0) {
 122             fatal_perror("tun_afterpoll: read()");
 123         }
 124         if (l==0) {
 125             fatal("tun_afterpoll: read()=0; device gone away?");
 126         }
 127         if (l>0) {
 128             st->buff->size=l;
 129             st->netlink_to_tunnel(&st->nl,st->buff);
 130             BUF_ASSERT_FREE(st->buff);
 131         }
 132     }
 133 }
 134
 135 static void tun_deliver_to_kernel(void *sst, struct buffer_if *buf)
 136 {
 137     struct tun *st=sst;
 138     ssize_t rc;
 139
 140     BUF_ASSERT_USED(buf);
 141
 142     /* Log errors, so we can tell what's going on, but only once a
 143        minute, so we don't flood the logs.  Short writes count as
 144        errors. */
 145     rc = write(st->fd,buf->start,buf->size);
 146     if(rc != buf->size) {
 147         static struct timeval last_report;
 148         if(tv_now_global.tv_sec >= last_report.tv_sec + 60) {
 149             if(rc < 0)
 150                 Message(M_WARNING,
 151                         "failed to deliver packet to tun device: %s\n",
 152                         strerror(errno));
 153             else
 154                 Message(M_WARNING,
 155                         "truncated packet delivered to tun device\n");
 156             last_report = tv_now_global;
 157         }
 158     }
 159     BUF_FREE(buf);
 160 }
 161
 162 static bool_t tun_set_route(void *sst, struct netlink_client *routes)
 163 {
 164     struct tun *st=sst;
 165     string_t network, mask, secnetaddr;
 166     struct subnet_list *nets;
 167     int32_t i;
 168     int fd=-1;
 169     bool_t up;
 170
 171     if (routes->options & OPT_SOFTROUTE)
 172         up = routes->up;
 173     else
 174         up = routes->link_quality > LINK_QUALITY_UNUSED;
 175
 176     if (up == routes->kup) return False;
 177     if (st->route_type==TUN_CONFIG_IOCTL) {
 178         if (st->tun_flavour==TUN_FLAVOUR_STREAMS) {
 179             fd=open(st->ip_path,O_RDWR);
 180             if (fd<0) {
 181                 fatal_perror("tun_set_route: can't open %s",st->ip_path);
 182             }
 183         } else {
 184             fd=socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 185             if (fd<0) {
 186                 fatal_perror("tun_set_route: socket()");
 187             }
 188         }
 189     }
 190     nets=routes->subnets;
 191     secnetaddr=ipaddr_to_string(st->nl.secnet_address);
 192     for (i=0; i<nets->entries; i++) {
 193         network=ipaddr_to_string(nets->list[i].prefix);
 194         mask=ipaddr_to_string(nets->list[i].mask);
 195         Message(M_INFO,"%s: %s route %s/%d %s kernel routing table\n",
 196                 st->nl.name,up?"adding":"deleting",network,
 197                 nets->list[i].len,up?"to":"from");
 198         switch (st->route_type) {
 199         case TUN_CONFIG_LINUX:
 200             sys_cmd(st->route_path,"route",up?"add":"del",
 201                     "-net",network,"netmask",mask,
 202                     "gw",secnetaddr,(char *)0);
 203             break;
 204         case TUN_CONFIG_BSD:
 205             sys_cmd(st->route_path,"route",up?"add":"del",
 206                     "-net",network,secnetaddr,mask,(char *)0);
 207             break;
 208         case TUN_CONFIG_SOLARIS25:
 209             sys_cmd(st->route_path,"route",up?"add":"del",
 210                     network,secnetaddr,(char *)0);
 211             break;
 212         case TUN_CONFIG_IOCTL:
 213         {
 214           /* darwin rtentry has a different format, use /sbin/route instead */
 215 #if HAVE_NET_ROUTE_H && ! __APPLE__
 216             struct rtentry rt;
 217             struct sockaddr_in *sa;
 218             int action;
 219
 220             FILLZERO(rt);
 221             sa=(struct sockaddr_in *)&rt.rt_dst;
 222             sa->sin_family=AF_INET;
 223             sa->sin_addr.s_addr=htonl(nets->list[i].prefix);
 224             sa=(struct sockaddr_in *)&rt.rt_genmask;
 225             sa->sin_family=AF_INET;
 226             sa->sin_addr.s_addr=htonl(nets->list[i].mask);
 227             sa=(struct sockaddr_in *)&rt.rt_gateway;
 228             sa->sin_family=AF_INET;
 229             sa->sin_addr.s_addr=htonl(st->nl.secnet_address);
 230             rt.rt_flags=RTF_UP|RTF_GATEWAY;
 231             action=up?SIOCADDRT:SIOCDELRT;
 232             if (ioctl(fd,action,&rt)<0) {
 233                 fatal_perror("tun_set_route: ioctl()");
 234             }
 235 #else
 236             fatal("tun_set_route: ioctl method not supported");
 237 #endif
 238         }
 239         break;
 240         default:
 241             fatal("tun_set_route: unsupported route command type");
 242             break;
 243         }
 244         free(network); free(mask);
 245     }
 246     free(secnetaddr);
 247     if (st->route_type==TUN_CONFIG_IOCTL) {
 248         close(fd);
 249     }
 250     routes->kup=up;
 251     return True;
 252 }
 253
 254 static void tun_phase_hook(void *sst, uint32_t newphase)
 255 {
 256     struct tun *st=sst;
 257     string_t hostaddr,secnetaddr;
 258     char mtu[6];
 259     struct netlink_client *r;
 260
 261     if (st->tun_flavour==TUN_FLAVOUR_BSD) {
 262         if (st->search_for_if) {
 263             string_t dname;
 264             int i;
 265
 266             dname=safe_malloc(strlen(st->device_path)+4,"tun_old_apply");
 267             st->interface_name=safe_malloc(8,"tun_phase_hook");
 268
 269             for (i=0; i<255; i++) {
 270                 sprintf(dname,"%s%d",st->device_path,i);
 271                 if ((st->fd=open(dname,O_RDWR))>0) {
 272                     sprintf(st->interface_name,"tun%d",i);
 273                     Message(M_INFO,"%s: allocated network interface %s "
 274                             "through %s\n",st->nl.name,st->interface_name,
 275                             dname);
 276                     break;
 277                 }
 278             }
 279             if (st->fd==-1) {
 280                 fatal("%s: unable to open any TUN device (%s...)",
 281                       st->nl.name,st->device_path);
 282             }
 283         } else {
 284             st->fd=open(st->device_path,O_RDWR);
 285             if (st->fd==-1) {
 286                 fatal_perror("%s: unable to open TUN device file %s",
 287                              st->nl.name,st->device_path);
 288             }
 289         }
 290     } else if (st->tun_flavour==TUN_FLAVOUR_LINUX) {
 291 #ifdef LINUX_TUN_SUPPORTED
 292         struct ifreq ifr;
 293
 294         /* New TUN interface: open the device, then do ioctl TUNSETIFF
 295            to set or find out the network interface name. */
 296         st->fd=open(st->device_path,O_RDWR);
 297         if (st->fd==-1) {
 298             fatal_perror("%s: can't open device file %s",st->nl.name,
 299                          st->device_path);
 300         }
 301         FILLZERO(ifr);
 302         ifr.ifr_flags = IFF_TUN | IFF_NO_PI; /* Just send/receive IP packets,
 303                                                 no extra headers */
 304         if (st->interface_name)
 305             strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 306         if (ioctl(st->fd,TUNSETIFF,&ifr)<0) {
 307             fatal_perror("%s: ioctl(TUNSETIFF)",st->nl.name);
 308         }
 309         if (!st->interface_name) {
 310             st->interface_name=safe_malloc(strlen(ifr.ifr_name)+1,"tun_apply");
 311             strcpy(st->interface_name,ifr.ifr_name);
 312             Message(M_INFO,"%s: allocated network interface %s\n",st->nl.name,
 313                     st->interface_name);
 314         }
 315 #else
 316         fatal("tun_phase_hook: TUN_FLAVOUR_LINUX unexpected");
 317 #endif /* LINUX_TUN_SUPPORTED */
 318     } else if (st->tun_flavour==TUN_FLAVOUR_STREAMS) {
 319 #ifdef HAVE_TUN_STREAMS
 320         int tun_fd, if_fd, ppa=-1, ip_fd;
 321
 322         if ((ip_fd=open(st->ip_path, O_RDWR)) < 0) {
 323             fatal_perror("%s: can't open %s",st->nl.name,st->ip_path);
 324         }
 325         if ((tun_fd=open(st->device_path,O_RDWR)) < 0) {
 326             fatal_perror("%s: can't open %s",st->nl.name,st->device_path);
 327         }
 328         if ((ppa=ioctl(tun_fd,TUNNEWPPA,ppa)) < 0) {
 329             fatal_perror("%s: can't assign new interface");
 330         }
 331         if ((if_fd=open(st->device_path,O_RDWR)) < 0) {
 332             fatal_perror("%s: can't open %s (2)",st->nl.name,st->device_path);
 333         }
 334         if (ioctl(if_fd,I_PUSH,"ip") < 0) {
 335             fatal_perror("%s: can't push IP module",st->nl.name);
 336         }
 337         if (ioctl(if_fd,IF_UNITSEL,(char *)&ppa) < 0) {
 338             fatal_perror("%s: can't set ppa %d",st->nl.name,ppa);
 339         }
 340         if (ioctl(ip_fd, I_LINK, if_fd) < 0) {
 341             fatal_perror("%s: can't link TUN device to IP",st->nl.name);
 342         }
 343         st->interface_name=safe_malloc(10,"tun_apply");
 344         sprintf(st->interface_name,"tun%d",ppa);
 345         st->fd=tun_fd;
 346 #else
 347         fatal("tun_phase_hook: TUN_FLAVOUR_STREAMS unexpected");
 348 #endif /* HAVE_TUN_STREAMS */
 349     } else {
 350         fatal("tun_phase_hook: unknown flavour of TUN");
 351     }
 352     /* All the networks we'll be using have been registered. Invoke ifconfig
 353        to set the TUN device's address, and route to add routes to all
 354        our networks. */
 355
 356     hostaddr=ipaddr_to_string(st->local_address);
 357     secnetaddr=ipaddr_to_string(st->nl.secnet_address);
 358     snprintf(mtu,sizeof(mtu),"%d",st->nl.mtu);
 359     mtu[5]=0;
 360
 361     switch (st->ifconfig_type) {
 362     case TUN_CONFIG_LINUX:
 363         sys_cmd(st->ifconfig_path,"ifconfig",st->interface_name,
 364                 hostaddr,"netmask","255.255.255.255","-broadcast",
 365                 "-multicast",
 366                 "pointopoint",secnetaddr,"mtu",mtu,"up",(char *)0);
 367         break;
 368     case TUN_CONFIG_BSD:
 369         sys_cmd(st->ifconfig_path,"ifconfig",st->interface_name,
 370                 hostaddr,"netmask","255.255.255.255",
 371                 secnetaddr,"mtu",mtu,"up",(char *)0);
 372         break;
 373     case TUN_CONFIG_SOLARIS25:
 374         sys_cmd(st->ifconfig_path,"ifconfig",st->interface_name,
 375                 hostaddr,secnetaddr,"mtu",mtu,"up",(char *)0);
 376         break;
 377     case TUN_CONFIG_IOCTL:
 378 #if HAVE_NET_IF_H && ! __APPLE__
 379     {
 380         int fd;
 381         struct ifreq ifr;
 382         struct sockaddr_in *sa;
 383         fd=socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 384
 385         /* Interface address */
 386         strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 387         sa=(struct sockaddr_in *)&ifr.ifr_addr;
 388         FILLZERO(*sa);
 389         sa->sin_family=AF_INET;
 390         sa->sin_addr.s_addr=htonl(st->local_address);
 391         if (ioctl(fd,SIOCSIFADDR, &ifr)!=0) {
 392             fatal_perror("tun_apply: SIOCSIFADDR");
 393         }
 394 #ifdef SIOCSIFNETMASK
 395         /* Netmask */
 396         strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 397         sa=(struct sockaddr_in *)&ifr.ifr_netmask;
 398         FILLZERO(*sa);
 399         sa->sin_family=AF_INET;
 400         sa->sin_addr.s_addr=htonl(0xffffffff);
 401         if (ioctl(fd,SIOCSIFNETMASK, &ifr)!=0) {
 402             fatal_perror("tun_apply: SIOCSIFNETMASK");
 403         }
 404 #endif
 405         /* Destination address (point-to-point) */
 406         strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 407         sa=(struct sockaddr_in *)&ifr.ifr_dstaddr;
 408         FILLZERO(*sa);
 409         sa->sin_family=AF_INET;
 410         sa->sin_addr.s_addr=htonl(st->nl.secnet_address);
 411         if (ioctl(fd,SIOCSIFDSTADDR, &ifr)!=0) {
 412             fatal_perror("tun_apply: SIOCSIFDSTADDR");
 413         }
 414         /* MTU */
 415         strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 416         ifr.ifr_mtu=st->nl.mtu;
 417         if (ioctl(fd,SIOCSIFMTU, &ifr)!=0) {
 418             fatal_perror("tun_apply: SIOCSIFMTU");
 419         }
 420         /* Flags */
 421         strncpy(ifr.ifr_name,st->interface_name,IFNAMSIZ);
 422         ifr.ifr_flags=IFF_UP|IFF_POINTOPOINT|IFF_RUNNING|IFF_NOARP;
 423         if (ioctl(fd,SIOCSIFFLAGS, &ifr)!=0) {
 424             fatal_perror("tun_apply: SIOCSIFFLAGS");
 425         }
 426
 427         close(fd);
 428     }
 429 #else
 430     fatal("tun_apply: ifconfig by ioctl() not supported");
 431 #endif /* HAVE_NET_IF_H */
 432     break;
 433     default:
 434         fatal("tun_apply: unsupported ifconfig method");
 435         break;
 436     }
 437
 438     for (r=st->nl.clients; r; r=r->next) {
 439         tun_set_route(st,r);
 440     }
 441
 442     /* Register for poll() */
 443     register_for_poll(st, tun_beforepoll, tun_afterpoll, 1, st->nl.name);
 444 }
 445
 446 static list_t *tun_create(closure_t *self, struct cloc loc, dict_t *context,
 447                           list_t *args,uint32_t default_flavour)
 448 {
 449     struct tun *st;
 450     item_t *item;
 451     dict_t *dict;
 452     string_t flavour,type;
 453
 454     st=safe_malloc(sizeof(*st),"tun_apply");
 455
 456     /* First parameter must be a dict */
 457     item=list_elem(args,0);
 458     if (!item || item->type!=t_dict)
 459         cfgfatal(loc,"tun","parameter must be a dictionary\n");
 460
 461     dict=item->data.dict;
 462
 463     st->netlink_to_tunnel=
 464         netlink_init(&st->nl,st,loc,dict,
 465                      "netlink-tun",tun_set_route,tun_deliver_to_kernel);
 466
 467     flavour=dict_read_string(dict,"flavour",False,"tun-netlink",loc);
 468     if (flavour)
 469         st->tun_flavour=string_to_word(flavour,loc,flavours,"tun-flavour");
 470     else
 471         st->tun_flavour=default_flavour;
 472
 473     st->device_path=dict_read_string(dict,"device",False,"tun-netlink",loc);
 474     st->ip_path=dict_read_string(dict,"ip-path",False,"tun-netlink",loc);
 475     st->interface_name=dict_read_string(dict,"interface",False,
 476                                         "tun-netlink",loc);
 477     st->search_for_if=dict_read_bool(dict,"interface-search",False,
 478                                      "tun-netlink",loc,st->device_path==NULL);
 479
 480     type=dict_read_string(dict,"ifconfig-type",False,"tun-netlink",loc);
 481     if (type) st->ifconfig_type=string_to_word(type,loc,config_types,
 482                                                "ifconfig-type");
 483     else st->ifconfig_type=TUN_CONFIG_GUESS;
 484     st->ifconfig_path=dict_read_string(dict,"ifconfig-path",False,
 485                                        "tun-netlink",loc);
 486
 487     type=dict_read_string(dict,"route-type",False,"tun-netlink",loc);
 488     if (type) st->route_type=string_to_word(type,loc,config_types,
 489                                             "route-type");
 490     else st->route_type=TUN_CONFIG_GUESS;
 491     st->route_path=dict_read_string(dict,"route-path",False,"tun-netlink",loc);
 492
 493     st->buff=find_cl_if(dict,"buffer",CL_BUFFER,True,"tun-netlink",loc);
 494     st->local_address=string_item_to_ipaddr(
 495         dict_find_item(dict,"local-address", True, "netlink", loc),"netlink");
 496
 497     if (st->tun_flavour==TUN_FLAVOUR_GUESS) {
 498         /* If we haven't been told what type of TUN we're using, take
 499            a guess based on the system details. */
 500         struct utsname u;
 501         if (uname(&u)<0) {
 502             fatal_perror("tun_create: uname");
 503         }
 504         if (strcmp(u.sysname,"Linux")==0) {
 505             st->tun_flavour=TUN_FLAVOUR_LINUX;
 506         } else if (strcmp(u.sysname,"SunOS")==0) {
 507             st->tun_flavour=TUN_FLAVOUR_STREAMS;
 508         } else if (strcmp(u.sysname,"FreeBSD")==0
 509                    || strcmp(u.sysname,"Darwin")==0) {
 510             st->tun_flavour=TUN_FLAVOUR_BSD;
 511         }
 512     }
 513     if (st->tun_flavour==TUN_FLAVOUR_GUESS) {
 514         cfgfatal(loc,"tun","cannot guess which type of TUN is in use; "
 515                  "specify the flavour explicitly\n");
 516     }
 517
 518     if (st->ifconfig_type==TUN_CONFIG_GUESS) {
 519         switch (st->tun_flavour) {
 520         case TUN_FLAVOUR_LINUX:
 521             st->ifconfig_type=TUN_CONFIG_IOCTL;
 522             break;
 523         case TUN_FLAVOUR_BSD:
 524 #if __linux__
 525             /* XXX on Linux we still want TUN_CONFIG_IOCTL.  Perhaps we can
 526                use this on BSD too. */
 527             st->ifconfig_type=TUN_CONFIG_IOCTL;
 528 #else
 529             st->ifconfig_type=TUN_CONFIG_BSD;
 530 #endif
 531             break;
 532         case TUN_FLAVOUR_STREAMS:
 533             st->ifconfig_type=TUN_CONFIG_BSD;
 534             break;
 535         }
 536     }
 537     if (st->route_type==TUN_CONFIG_GUESS)
 538         st->route_type=st->ifconfig_type;
 539
 540     if (st->ifconfig_type==TUN_CONFIG_GUESS) {
 541         cfgfatal(loc,"tun","cannot guess which ifconfig method to use\n");
 542     }
 543     if (st->route_type==TUN_CONFIG_GUESS) {
 544         cfgfatal(loc,"tun","cannot guess which route method to use\n");
 545     }
 546
 547     if (st->ifconfig_type==TUN_CONFIG_IOCTL && st->ifconfig_path) {
 548         cfgfatal(loc,"tun","ifconfig-type \"ioctl\" is incompatible with "
 549                  "ifconfig-path\n");
 550     }
 551     if (st->route_type==TUN_CONFIG_IOCTL && st->route_path) {
 552         cfgfatal(loc,"tun","route-type \"ioctl\" is incompatible with "
 553                  "route-path\n");
 554     }
 555
 556     Message(M_DEBUG_CONFIG,"%s: tun flavour %s\n",st->nl.name,
 557             tun_flavour_str(st->tun_flavour));
 558     switch (st->tun_flavour) {
 559     case TUN_FLAVOUR_BSD:
 560         if (!st->device_path) st->device_path="/dev/tun";
 561         break;
 562     case TUN_FLAVOUR_LINUX:
 563         if (!st->device_path) st->device_path="/dev/net/tun";
 564         break;
 565     case TUN_FLAVOUR_STREAMS:
 566         if (!st->device_path) st->device_path="/dev/tun";
 567         if (st->interface_name) cfgfatal(loc,"tun","interface name cannot "
 568                                          "be specified with STREAMS TUN\n");
 569         break;
 570     }
 571
 572     if (!st->ip_path) st->ip_path="/dev/ip";
 573     if (!st->ifconfig_path) st->ifconfig_path="ifconfig";
 574     if (!st->route_path) st->route_path="route";
 575
 576 #ifndef HAVE_TUN_STREAMS
 577     if (st->tun_flavour==TUN_FLAVOUR_STREAMS) {
 578         cfgfatal(loc,"tun","TUN flavour STREAMS unsupported in this build "
 579                  "of secnet\n");
 580     }
 581 #endif
 582 #ifndef LINUX_TUN_SUPPORTED
 583     if (st->tun_flavour==TUN_FLAVOUR_LINUX) {
 584         cfgfatal(loc,"tun","TUN flavour LINUX unsupported in this build "
 585                  "of secnet\n");
 586     }
 587 #endif
 588
 589     /* Old TUN interface: the network interface name depends on which
 590        /dev/tunX file we open. If 'interface-search' is set to true, treat
 591        'device' as the prefix and try numbers from 0--255. If it's set
 592        to false, treat 'device' as the whole name, and require than an
 593        appropriate interface name be specified. */
 594     if (st->tun_flavour==TUN_FLAVOUR_BSD) {
 595         if (st->search_for_if && st->interface_name) {
 596             cfgfatal(loc,"tun","you may not specify an interface name "
 597                      "in interface-search mode\n");
 598         }
 599         if (!st->search_for_if && !st->interface_name) {
 600             cfgfatal(loc,"tun","you must specify an interface name "
 601                      "when you explicitly specify a TUN device file\n");
 602         }
 603     }
 604
 605     add_hook(PHASE_GETRESOURCES,tun_phase_hook,st);
 606
 607     return new_closure(&st->nl.cl);
 608 }
 609
 610 static list_t *tun_apply(closure_t *self, struct cloc loc, dict_t *context,
 611                          list_t *args)
 612 {
 613     return tun_create(self,loc,context,args,TUN_FLAVOUR_GUESS);
 614 }
 615
 616 static list_t *tun_bsd_apply(closure_t *self, struct cloc loc, dict_t *context,
 617                              list_t *args)
 618 {
 619     Message(M_WARNING,"(%s,%d): obsolete use of tun-old; replace with tun "
 620             "and specify flavour \"bsd\".\n",loc.file,loc.line);
 621     return tun_create(self,loc,context,args,TUN_FLAVOUR_BSD);
 622 }
 623
 624 void tun_module(dict_t *dict)
 625 {
 626     add_closure(dict,"tun",tun_apply);
 627     add_closure(dict,"tun-old",tun_bsd_apply);
 628 }