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