1: /*
2: * Copyright (C) 2012 Tobias Brunner
3: * Copyright (C) 2012 Giuliano Grassi
4: * Copyright (C) 2012 Ralf Sager
5: * HSR Hochschule fuer Technik Rapperswil
6: * Copyright (C) 2012 Martin Willi
7: *
8: * This program is free software; you can redistribute it and/or modify it
9: * under the terms of the GNU General Public License as published by the
10: * Free Software Foundation; either version 2 of the License, or (at your
11: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
12: *
13: * This program is distributed in the hope that it will be useful, but
14: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16: * for more details.
17: */
18:
19: #include "tun_device.h"
20:
21: #include <utils/debug.h>
22: #include <threading/thread.h>
23:
24: #if defined(__APPLE__)
25: #include "TargetConditionals.h"
26: #if !TARGET_OS_OSX
27: #define TUN_DEVICE_NOT_SUPPORTED
28: #endif
29: #elif !defined(__linux__) && !defined(HAVE_NET_IF_TUN_H)
30: #define TUN_DEVICE_NOT_SUPPORTED
31: #endif
32:
33: #ifdef TUN_DEVICE_NOT_SUPPORTED
34:
35: tun_device_t *tun_device_create(const char *name_tmpl)
36: {
37: DBG1(DBG_LIB, "TUN devices are not supported");
38: return NULL;
39: }
40:
41: #else /* TUN devices supported */
42:
43: #include <errno.h>
44: #include <fcntl.h>
45: #include <netinet/in.h>
46: #include <string.h>
47: #include <sys/ioctl.h>
48: #include <sys/types.h>
49: #include <sys/socket.h>
50: #include <sys/stat.h>
51: #include <unistd.h>
52: #include <net/if.h>
53:
54: #ifdef __APPLE__
55: #include <net/if_utun.h>
56: #include <netinet/in_var.h>
57: #include <sys/kern_control.h>
58: #elif defined(__linux__)
59: #include <linux/types.h>
60: #include <linux/if_tun.h>
61: #elif __FreeBSD__ >= 10
62: #include <net/if_tun.h>
63: #include <net/if_var.h>
64: #include <netinet/in_var.h>
65: #else
66: #include <net/if_tun.h>
67: #endif
68:
69: #define TUN_DEFAULT_MTU 1500
70:
71: typedef struct private_tun_device_t private_tun_device_t;
72:
73: struct private_tun_device_t {
74:
75: /**
76: * Public interface
77: */
78: tun_device_t public;
79:
80: /**
81: * The TUN device's file descriptor
82: */
83: int tunfd;
84:
85: /**
86: * Name of the TUN device
87: */
88: char if_name[IFNAMSIZ];
89:
90: /**
91: * Socket used for ioctl() to set interface addr, ...
92: */
93: int sock;
94:
95: /**
96: * The current MTU
97: */
98: int mtu;
99:
100: /**
101: * Associated address
102: */
103: host_t *address;
104:
105: /**
106: * Netmask for address
107: */
108: uint8_t netmask;
109: };
110:
111: /**
112: * FreeBSD 10 deprecated the SIOCSIFADDR etc. commands.
113: */
114: #if __FreeBSD__ >= 10
115:
116: static bool set_address_and_mask(struct in_aliasreq *ifra, host_t *addr,
117: uint8_t netmask)
118: {
119: host_t *mask;
120:
121: memcpy(&ifra->ifra_addr, addr->get_sockaddr(addr),
122: *addr->get_sockaddr_len(addr));
123: /* set the same address as destination address */
124: memcpy(&ifra->ifra_dstaddr, addr->get_sockaddr(addr),
125: *addr->get_sockaddr_len(addr));
126:
127: mask = host_create_netmask(addr->get_family(addr), netmask);
128: if (!mask)
129: {
130: DBG1(DBG_LIB, "invalid netmask: %d", netmask);
131: return FALSE;
132: }
133: memcpy(&ifra->ifra_mask, mask->get_sockaddr(mask),
134: *mask->get_sockaddr_len(mask));
135: mask->destroy(mask);
136: return TRUE;
137: }
138:
139: /**
140: * Set the address using the more flexible SIOCAIFADDR/SIOCDIFADDR commands
141: * on FreeBSD 10 an newer.
142: */
143: static bool set_address_impl(private_tun_device_t *this, host_t *addr,
144: uint8_t netmask)
145: {
146: struct in_aliasreq ifra;
147:
148: memset(&ifra, 0, sizeof(ifra));
149: strncpy(ifra.ifra_name, this->if_name, IFNAMSIZ);
150:
151: if (this->address)
152: { /* remove the existing address first */
153: if (!set_address_and_mask(&ifra, this->address, this->netmask))
154: {
155: return FALSE;
156: }
157: if (ioctl(this->sock, SIOCDIFADDR, &ifra) < 0)
158: {
159: DBG1(DBG_LIB, "failed to remove existing address on %s: %s",
160: this->if_name, strerror(errno));
161: return FALSE;
162: }
163: }
164: if (!set_address_and_mask(&ifra, addr, netmask))
165: {
166: return FALSE;
167: }
168: if (ioctl(this->sock, SIOCAIFADDR, &ifra) < 0)
169: {
170: DBG1(DBG_LIB, "failed to add address on %s: %s",
171: this->if_name, strerror(errno));
172: return FALSE;
173: }
174: return TRUE;
175: }
176:
177: #else /* __FreeBSD__ */
178:
179: /**
180: * Set the address using the classic SIOCSIFADDR etc. commands on other systems.
181: */
182: static bool set_address_impl(private_tun_device_t *this, host_t *addr,
183: uint8_t netmask)
184: {
185: struct ifreq ifr;
186: host_t *mask;
187:
188: memset(&ifr, 0, sizeof(ifr));
189: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
190: memcpy(&ifr.ifr_addr, addr->get_sockaddr(addr),
191: *addr->get_sockaddr_len(addr));
192:
193: if (ioctl(this->sock, SIOCSIFADDR, &ifr) < 0)
194: {
195: DBG1(DBG_LIB, "failed to set address on %s: %s",
196: this->if_name, strerror(errno));
197: return FALSE;
198: }
199: #ifdef __APPLE__
200: if (ioctl(this->sock, SIOCSIFDSTADDR, &ifr) < 0)
201: {
202: DBG1(DBG_LIB, "failed to set dest address on %s: %s",
203: this->if_name, strerror(errno));
204: return FALSE;
205: }
206: #endif /* __APPLE__ */
207:
208: mask = host_create_netmask(addr->get_family(addr), netmask);
209: if (!mask)
210: {
211: DBG1(DBG_LIB, "invalid netmask: %d", netmask);
212: return FALSE;
213: }
214: memcpy(&ifr.ifr_addr, mask->get_sockaddr(mask),
215: *mask->get_sockaddr_len(mask));
216: mask->destroy(mask);
217:
218: if (ioctl(this->sock, SIOCSIFNETMASK, &ifr) < 0)
219: {
220: DBG1(DBG_LIB, "failed to set netmask on %s: %s",
221: this->if_name, strerror(errno));
222: return FALSE;
223: }
224: return TRUE;
225: }
226:
227: #endif /* __FreeBSD__ */
228:
229: METHOD(tun_device_t, set_address, bool,
230: private_tun_device_t *this, host_t *addr, uint8_t netmask)
231: {
232: if (!set_address_impl(this, addr, netmask))
233: {
234: return FALSE;
235: }
236: DESTROY_IF(this->address);
237: this->address = addr->clone(addr);
238: this->netmask = netmask;
239: return TRUE;
240: }
241:
242: METHOD(tun_device_t, get_address, host_t*,
243: private_tun_device_t *this, uint8_t *netmask)
244: {
245: if (netmask && this->address)
246: {
247: *netmask = this->netmask;
248: }
249: return this->address;
250: }
251:
252: METHOD(tun_device_t, up, bool,
253: private_tun_device_t *this)
254: {
255: struct ifreq ifr;
256:
257: memset(&ifr, 0, sizeof(ifr));
258: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
259:
260: if (ioctl(this->sock, SIOCGIFFLAGS, &ifr) < 0)
261: {
262: DBG1(DBG_LIB, "failed to get interface flags for %s: %s", this->if_name,
263: strerror(errno));
264: return FALSE;
265: }
266:
267: ifr.ifr_flags |= IFF_RUNNING | IFF_UP;
268:
269: if (ioctl(this->sock, SIOCSIFFLAGS, &ifr) < 0)
270: {
271: DBG1(DBG_LIB, "failed to set interface flags on %s: %s", this->if_name,
272: strerror(errno));
273: return FALSE;
274: }
275: return TRUE;
276: }
277:
278: METHOD(tun_device_t, set_mtu, bool,
279: private_tun_device_t *this, int mtu)
280: {
281: struct ifreq ifr;
282:
283: memset(&ifr, 0, sizeof(ifr));
284: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
285: ifr.ifr_mtu = mtu;
286:
287: if (ioctl(this->sock, SIOCSIFMTU, &ifr) < 0)
288: {
289: DBG1(DBG_LIB, "failed to set MTU on %s: %s", this->if_name,
290: strerror(errno));
291: return FALSE;
292: }
293: this->mtu = mtu;
294: return TRUE;
295: }
296:
297: METHOD(tun_device_t, get_mtu, int,
298: private_tun_device_t *this)
299: {
300: struct ifreq ifr;
301:
302: if (this->mtu > 0)
303: {
304: return this->mtu;
305: }
306:
307: memset(&ifr, 0, sizeof(ifr));
308: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
309: this->mtu = TUN_DEFAULT_MTU;
310:
311: if (ioctl(this->sock, SIOCGIFMTU, &ifr) == 0)
312: {
313: this->mtu = ifr.ifr_mtu;
314: }
315: return this->mtu;
316: }
317:
318: METHOD(tun_device_t, get_name, char*,
319: private_tun_device_t *this)
320: {
321: return this->if_name;
322: }
323:
324: METHOD(tun_device_t, get_fd, int,
325: private_tun_device_t *this)
326: {
327: return this->tunfd;
328: }
329:
330: METHOD(tun_device_t, write_packet, bool,
331: private_tun_device_t *this, chunk_t packet)
332: {
333: ssize_t s;
334:
335: #ifdef __APPLE__
336: /* UTUN's expect the packets to be prepended by a 32-bit protocol number
337: * instead of parsing the packet again, we assume IPv4 for now */
338: uint32_t proto = htonl(AF_INET);
339: packet = chunk_cata("cc", chunk_from_thing(proto), packet);
340: #endif
341: s = write(this->tunfd, packet.ptr, packet.len);
342: if (s < 0)
343: {
344: DBG1(DBG_LIB, "failed to write packet to TUN device %s: %s",
345: this->if_name, strerror(errno));
346: return FALSE;
347: }
348: else if (s != packet.len)
349: {
350: return FALSE;
351: }
352: return TRUE;
353: }
354:
355: METHOD(tun_device_t, read_packet, bool,
356: private_tun_device_t *this, chunk_t *packet)
357: {
358: chunk_t data;
359: ssize_t len;
360: bool old;
361:
362: data = chunk_alloca(get_mtu(this));
363:
364: old = thread_cancelability(TRUE);
365: len = read(this->tunfd, data.ptr, data.len);
366: thread_cancelability(old);
367: if (len < 0)
368: {
369: DBG1(DBG_LIB, "reading from TUN device %s failed: %s", this->if_name,
370: strerror(errno));
371: return FALSE;
372: }
373: data.len = len;
374: #ifdef __APPLE__
375: /* UTUN's prepend packets with a 32-bit protocol number */
376: data = chunk_skip(data, sizeof(uint32_t));
377: #endif
378: *packet = chunk_clone(data);
379: return TRUE;
380: }
381:
382: METHOD(tun_device_t, destroy, void,
383: private_tun_device_t *this)
384: {
385: if (this->tunfd > 0)
386: {
387: close(this->tunfd);
388: #ifdef __FreeBSD__
389: /* tun(4) says the following: "These network interfaces persist until
390: * the if_tun.ko module is unloaded, or until removed with the
391: * ifconfig(8) command." So simply closing the FD is not enough. */
392: struct ifreq ifr;
393:
394: memset(&ifr, 0, sizeof(ifr));
395: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
396: if (ioctl(this->sock, SIOCIFDESTROY, &ifr) < 0)
397: {
398: DBG1(DBG_LIB, "failed to destroy %s: %s", this->if_name,
399: strerror(errno));
400: }
401: #endif /* __FreeBSD__ */
402: }
403: if (this->sock > 0)
404: {
405: close(this->sock);
406: }
407: DESTROY_IF(this->address);
408: free(this);
409: }
410:
411: /**
412: * Initialize the tun device
413: */
414: static bool init_tun(private_tun_device_t *this, const char *name_tmpl)
415: {
416: #ifdef __APPLE__
417:
418: struct ctl_info info;
419: struct sockaddr_ctl addr;
420: socklen_t size = IFNAMSIZ;
421:
422: memset(&info, 0, sizeof(info));
423: memset(&addr, 0, sizeof(addr));
424:
425: this->tunfd = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
426: if (this->tunfd < 0)
427: {
428: DBG1(DBG_LIB, "failed to open tundevice PF_SYSTEM socket: %s",
429: strerror(errno));
430: return FALSE;
431: }
432:
433: /* get a control identifier for the utun kernel extension */
434: strncpy(info.ctl_name, UTUN_CONTROL_NAME, strlen(UTUN_CONTROL_NAME));
435: if (ioctl(this->tunfd, CTLIOCGINFO, &info) < 0)
436: {
437: DBG1(DBG_LIB, "failed to ioctl tundevice: %s", strerror(errno));
438: close(this->tunfd);
439: return FALSE;
440: }
441:
442: addr.sc_id = info.ctl_id;
443: addr.sc_len = sizeof(addr);
444: addr.sc_family = AF_SYSTEM;
445: addr.ss_sysaddr = AF_SYS_CONTROL;
446: /* allocate identifier dynamically */
447: addr.sc_unit = 0;
448:
449: if (connect(this->tunfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
450: {
451: DBG1(DBG_LIB, "failed to connect tundevice: %s", strerror(errno));
452: close(this->tunfd);
453: return FALSE;
454: }
455: if (getsockopt(this->tunfd, SYSPROTO_CONTROL, UTUN_OPT_IFNAME,
456: this->if_name, &size) < 0)
457: {
458: DBG1(DBG_LIB, "getting tundevice name failed: %s", strerror(errno));
459: close(this->tunfd);
460: return FALSE;
461: }
462: return TRUE;
463:
464: #elif defined(IFF_TUN)
465:
466: struct ifreq ifr;
467:
468: strncpy(this->if_name, name_tmpl ?: "tun%d", IFNAMSIZ);
469: this->if_name[IFNAMSIZ-1] = '\0';
470:
471: this->tunfd = open("/dev/net/tun", O_RDWR);
472: if (this->tunfd < 0)
473: {
474: DBG1(DBG_LIB, "failed to open /dev/net/tun: %s", strerror(errno));
475: return FALSE;
476: }
477:
478: memset(&ifr, 0, sizeof(ifr));
479:
480: /* TUN device, no packet info */
481: ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
482:
483: strncpy(ifr.ifr_name, this->if_name, IFNAMSIZ);
484: if (ioctl(this->tunfd, TUNSETIFF, (void*)&ifr) < 0)
485: {
486: DBG1(DBG_LIB, "failed to configure TUN device: %s", strerror(errno));
487: close(this->tunfd);
488: return FALSE;
489: }
490: strncpy(this->if_name, ifr.ifr_name, IFNAMSIZ);
491: return TRUE;
492:
493: #elif defined(__FreeBSD__)
494:
495: if (name_tmpl)
496: {
497: DBG1(DBG_LIB, "arbitrary naming of TUN devices is not supported");
498: }
499:
500: this->tunfd = open("/dev/tun", O_RDWR);
501: if (this->tunfd < 0)
502: {
503: DBG1(DBG_LIB, "failed to open /dev/tun: %s", strerror(errno));
504: return FALSE;
505: }
506: fdevname_r(this->tunfd, this->if_name, IFNAMSIZ);
507: return TRUE;
508:
509: #else /* !__FreeBSD__ */
510:
511: /* this might work on Linux with older TUN driver versions (no IFF_TUN) */
512: char devname[IFNAMSIZ];
513: /* the same process is allowed to open a device again, but that's not what
514: * we want (unless we previously closed a device, which we don't know at
515: * this point). therefore, this counter is static so we don't accidentally
516: * open a device twice */
517: static int i = -1;
518:
519: if (name_tmpl)
520: {
521: DBG1(DBG_LIB, "arbitrary naming of TUN devices is not supported");
522: }
523:
524: for (; ++i < 256; )
525: {
526: snprintf(devname, IFNAMSIZ, "/dev/tun%d", i);
527: this->tunfd = open(devname, O_RDWR);
528: if (this->tunfd > 0)
529: { /* for ioctl(2) calls only the interface name is used */
530: snprintf(this->if_name, IFNAMSIZ, "tun%d", i);
531: break;
532: }
533: DBG1(DBG_LIB, "failed to open %s: %s", this->if_name, strerror(errno));
534: }
535: return this->tunfd > 0;
536:
537: #endif /* !__APPLE__ */
538: }
539:
540: /*
541: * Described in header
542: */
543: tun_device_t *tun_device_create(const char *name_tmpl)
544: {
545: private_tun_device_t *this;
546:
547: INIT(this,
548: .public = {
549: .read_packet = _read_packet,
550: .write_packet = _write_packet,
551: .get_mtu = _get_mtu,
552: .set_mtu = _set_mtu,
553: .get_name = _get_name,
554: .get_fd = _get_fd,
555: .set_address = _set_address,
556: .get_address = _get_address,
557: .up = _up,
558: .destroy = _destroy,
559: },
560: .tunfd = -1,
561: .sock = -1,
562: );
563:
564: if (!init_tun(this, name_tmpl))
565: {
566: free(this);
567: return NULL;
568: }
569: DBG1(DBG_LIB, "created TUN device: %s", this->if_name);
570:
571: this->sock = socket(AF_INET, SOCK_DGRAM, 0);
572: if (this->sock < 0)
573: {
574: DBG1(DBG_LIB, "failed to open socket to configure TUN device");
575: destroy(this);
576: return NULL;
577: }
578: return &this->public;
579: }
580:
581: #endif /* TUN devices supported */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tun_device.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / networking