1: /*
2: * Tunnel Interface Functions.
3: * Copyright (C) 2002, 2003, 2004 Mondru AB.
4: * Copyright (c) 2006-2007 David Bird <david@coova.com>
5: *
6: * The contents of this file may be used under the terms of the GNU
7: * General Public License Version 2, provided that the above copyright
8: * notice and this permission notice is included in all copies or
9: * substantial portions of the software.
10: *
11: */
12:
13: /*
14: * A tunnel is the back-haul link which chilli sends traffic. Typically,
15: * this is a single tun/tap interface allowing chilli to simply pass on
16: * packets to the kernel for processing (iptables) and routing. Without the
17: * tun/tap interface, chilli must decide for itself how to route traffic,
18: * maintaining a socket into each back-haul interface. One or more tunnels
19: * are required.
20: *
21: */
22:
23: #include "system.h"
24: #include "tun.h"
25: #include "ippool.h"
26: #include "radius.h"
27: #include "radius_wispr.h"
28: #include "radius_chillispot.h"
29: #include "redir.h"
30: #include "syserr.h"
31: #include "dhcp.h"
32: #include "cmdline.h"
33: #include "chilli.h"
34: #include "options.h"
35: #include "net.h"
36:
37: #define inaddr(x) (((struct sockaddr_in *)&ifr->x)->sin_addr)
38: #define inaddr2(p,x) (((struct sockaddr_in *)&(p)->x)->sin_addr)
39:
40: int tun_discover(struct tun_t *this) {
41: net_interface netif;
42: struct ifconf ic;
43: int fd, len, i;
44:
45: if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
46: log_err(errno, "socket() failed");
47: return -1;
48: }
49:
50: ic.ifc_buf=0;
51: ic.ifc_len=0;
52:
53: if (ioctl(fd, SIOCGIFCONF, &ic) < 0) {
54: log_err(errno, "ioctl(SIOCGIFCONF)");
55: close(fd);
56: return -1;
57: }
58:
59: ic.ifc_buf = calloc((size_t)ic.ifc_len, 1);
60: if (ioctl(fd, SIOCGIFCONF, &ic) < 0) {
61: log_err(errno, "ioctl(SIOCGIFCONF)");
62: close(fd);
63: return -1;
64: }
65:
66: len = (ic.ifc_len/sizeof(struct ifreq));
67:
68: for (i=0; i<len; ++i) {
69: struct ifreq *ifr = (struct ifreq *)&ic.ifc_req[i];
70: memset(&netif, 0, sizeof(netif));
71:
72:
73: /* device name and address */
74: strncpy(netif.devname, ifr->ifr_name, sizeof(netif.devname));
75: netif.address = inaddr(ifr_addr);
76:
77: log_dbg("Interface: %s", ifr->ifr_name);
78: log_dbg("\tIP Address:\t%s", inet_ntoa(inaddr(ifr_addr)));
79:
80:
81: /* netmask */
82: if (-1 < ioctl(fd, SIOCGIFNETMASK, (caddr_t)ifr)) {
83:
84: netif.netmask = inaddr(ifr_addr);
85: log_dbg("\tNetmask:\t%s", inet_ntoa(inaddr(ifr_addr)));
86:
87: } else log_err(errno, "ioctl(SIOCGIFNETMASK)");
88:
89:
90: /* hardware address */
91: #ifdef SIOCGIFHWADDR
92: if (-1 < ioctl(fd, SIOCGIFHWADDR, (caddr_t)ifr)) {
93: switch (ifr->ifr_hwaddr.sa_family) {
94: case ARPHRD_NETROM:
95: case ARPHRD_ETHER:
96: case ARPHRD_PPP:
97: case ARPHRD_EETHER:
98: case ARPHRD_IEEE802:
99: {
100: unsigned char *u = (unsigned char *)&ifr->ifr_addr.sa_data;
101:
102: memcpy(netif.hwaddr, u, 6);
103:
104: log_dbg("\tHW Address:\t%2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2x",
105: u[0], u[1], u[2], u[3], u[4], u[5]);
106: }
107: break;
108: }
109: } else log_err(errno, "ioctl(SIOCGIFHWADDR)");
110: #else
111: #ifdef SIOCGENADDR
112: if (-1 < ioctl(fd, SIOCGENADDR, (caddr_t)ifr)) {
113: unsigned char *u = (unsigned char *)&ifr->ifr_enaddr;
114:
115: memcpy(netif.hwaddr, u, 6);
116:
117: log_dbg("\tHW Address:\t%2.2X-%2.2X-%2.2X-%2.2X-%2.2X-%2.2x",
118: u[0], u[1], u[2], u[3], u[4], u[5]);
119: } else log_err(errno, "ioctl(SIOCGENADDR)");
120: #else
121: #warning Do not know how to find interface hardware address
122: #endif /* SIOCGENADDR */
123: #endif /* SIOCGIFHWADDR */
124:
125:
126: /* flags */
127: if (-1 < ioctl(fd, SIOCGIFFLAGS, (caddr_t)ifr)) {
128:
129: netif.devflags = ifr->ifr_flags;
130:
131: } else log_err(errno, "ioctl(SIOCGIFFLAGS)");
132:
133:
134: /* point-to-point gateway */
135: if (netif.devflags & IFF_POINTOPOINT) {
136: if (-1 < ioctl(fd, SIOCGIFDSTADDR, (caddr_t)ifr)) {
137:
138: netif.gateway = inaddr(ifr_addr);
139: log_dbg("\tPoint-to-Point:\t%s", inet_ntoa(inaddr(ifr_dstaddr)));
140:
141: } else log_err(errno, "ioctl(SIOCGIFDSTADDR)");
142: }
143:
144:
145: /* broadcast address */
146: if (netif.devflags & IFF_BROADCAST) {
147: if (-1 < ioctl(fd, SIOCGIFBRDADDR, (caddr_t)ifr)) {
148:
149: netif.broadcast = inaddr(ifr_addr);
150: log_dbg("\tBroadcast:\t%s", inet_ntoa(inaddr(ifr_addr)));
151:
152: } else log_err(errno, "ioctl(SIOCGIFBRDADDR)");
153: }
154:
155:
156: /* mtu */
157: if (-1 < ioctl(fd, SIOCGIFMTU, (caddr_t)ifr)) {
158:
159: netif.mtu = ifr->ifr_mtu;
160: log_dbg("\tMTU: \t%u", ifr->ifr_mtu);
161:
162: } else log_err(errno, "ioctl(SIOCGIFMTU)");
163:
164:
165: /* if (0 == ioctl(fd, SIOCGIFMETRIC, ifr)) */
166:
167: if (netif.address.s_addr == htonl(INADDR_LOOPBACK) ||
168: netif.address.s_addr == INADDR_ANY ||
169: netif.address.s_addr == INADDR_NONE)
170: continue;
171:
172: else {
173: net_interface *newif = tun_nextif(tun);
174: if (newif) {
175: memcpy(newif, &netif, sizeof(netif));
176: net_open(newif);
177:
178: if (!strcmp(options.routeif, netif.devname))
179: tun->routeidx = newif->idx;
180: } else {
181: log_dbg("no room for interface %s", netif.devname);
182: }
183: }
184: }
185:
186: close(fd);
187: return 0;
188: }
189:
190: net_interface * tun_nextif(struct tun_t *tun) {
191: net_interface *netif;
192:
193: if (tun->_interface_count == TUN_MAX_INTERFACES)
194: return 0;
195:
196: netif = &tun->_interfaces[tun->_interface_count];
197: netif->idx = tun->_interface_count;
198:
199: tun->_interface_count++;
200:
201: return netif;
202: }
203:
204: int tun_name2idx(struct tun_t *tun, char *name) {
205: int i;
206:
207: for (i=0; i<tun->_interface_count; i++)
208: if (!strcmp(name, tun->_interfaces[i].devname))
209: return i;
210:
211: return 0; /* tun/tap index */
212: }
213:
214: #if defined(__linux__)
215:
216: int tun_nlattr(struct nlmsghdr *n, int nsize, int type, void *d, size_t dlen) {
217: size_t len = RTA_LENGTH(dlen);
218: size_t alen = NLMSG_ALIGN(n->nlmsg_len);
219: struct rtattr *rta = (struct rtattr*) (((void*)n) + alen);
220: if (alen + len > nsize)
221: return -1;
222: rta->rta_len = len;
223: rta->rta_type = type;
224: memcpy(RTA_DATA(rta), d, dlen);
225: n->nlmsg_len = alen + len;
226: return 0;
227: }
228:
229: int tun_gifindex(struct tun_t *this, int *index) {
230: struct ifreq ifr;
231: int fd;
232:
233: memset (&ifr, '\0', sizeof (ifr));
234: ifr.ifr_addr.sa_family = AF_INET;
235: ifr.ifr_dstaddr.sa_family = AF_INET;
236: ifr.ifr_netmask.sa_family = AF_INET;
237: strncpy(ifr.ifr_name, tuntap(this).devname, IFNAMSIZ);
238: ifr.ifr_name[IFNAMSIZ-1] = 0; /* Make sure to terminate */
239: if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
240: log_err(errno, "socket() failed");
241: }
242: if (ioctl(fd, SIOCGIFINDEX, &ifr)) {
243: log_err(errno,"ioctl() failed");
244: close(fd);
245: return -1;
246: }
247: close(fd);
248: *index = ifr.ifr_ifindex;
249: return 0;
250: }
251: #endif
252:
253: int tun_addaddr(struct tun_t *this, struct in_addr *addr,
254: struct in_addr *dstaddr, struct in_addr *netmask) {
255:
256: #if defined(__linux__)
257: struct {
258: struct nlmsghdr n;
259: struct ifaddrmsg i;
260: char buf[TUN_NLBUFSIZE];
261: } req;
262:
263: struct sockaddr_nl local;
264: size_t addr_len;
265: int fd;
266: int status;
267:
268: struct sockaddr_nl nladdr;
269: struct iovec iov;
270: struct msghdr msg;
271:
272: if (!this->addrs) /* Use ioctl for first addr to make ping work */
273: return tun_setaddr(this, addr, dstaddr, netmask);
274:
275: memset(&req, 0, sizeof(req));
276: req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
277: req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
278: req.n.nlmsg_type = RTM_NEWADDR;
279: req.i.ifa_family = AF_INET;
280: req.i.ifa_prefixlen = 32; /* 32 FOR IPv4 */
281: req.i.ifa_flags = 0;
282: req.i.ifa_scope = RT_SCOPE_HOST; /* TODO or 0 */
283:
284: if (tun_gifindex(this, &req.i.ifa_index)) {
285: log_err(errno,"tun_gifindex() failed");
286: return -1;
287: }
288:
289: tun_nlattr(&req.n, sizeof(req), IFA_ADDRESS, addr, sizeof(addr));
290: tun_nlattr(&req.n, sizeof(req), IFA_LOCAL, dstaddr, sizeof(dstaddr));
291:
292: if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0) {
293: log_err(errno,"socket() failed");
294: return -1;
295: }
296:
297: memset(&local, 0, sizeof(local));
298: local.nl_family = AF_NETLINK;
299: local.nl_groups = 0;
300:
301: if (bind(fd, (struct sockaddr*)&local, sizeof(local)) < 0) {
302: log_err(errno, "bind() failed");
303: close(fd);
304: return -1;
305: }
306:
307: addr_len = sizeof(local);
308: if (getsockname(fd, (struct sockaddr*)&local, (socklen_t *) &addr_len) < 0) {
309: log_err(errno, "getsockname() failed");
310: close(fd);
311: return -1;
312: }
313:
314: if (addr_len != sizeof(local)) {
315: log_err(0, "Wrong address length %d", addr_len);
316: close(fd);
317: return -1;
318: }
319:
320: if (local.nl_family != AF_NETLINK) {
321: log_err(0, "Wrong address family %d", local.nl_family);
322: close(fd);
323: return -1;
324: }
325:
326: iov.iov_base = (void*)&req.n;
327: iov.iov_len = req.n.nlmsg_len;
328:
329: msg.msg_name = (void*)&nladdr;
330: msg.msg_namelen = sizeof(nladdr),
331: msg.msg_iov = &iov;
332: msg.msg_iovlen = 1;
333: msg.msg_control = NULL;
334: msg.msg_controllen = 0;
335: msg.msg_flags = 0;
336:
337: memset(&nladdr, 0, sizeof(nladdr));
338: nladdr.nl_family = AF_NETLINK;
339: nladdr.nl_pid = 0;
340: nladdr.nl_groups = 0;
341:
342: req.n.nlmsg_seq = 0;
343: req.n.nlmsg_flags |= NLM_F_ACK;
344:
345: status = sendmsg(fd, &msg, 0);
346:
347: dev_set_flags(tuntap(this).devname, IFF_UP | IFF_RUNNING);
348:
349: close(fd);
350: this->addrs++;
351:
352: return 0;
353:
354: #elif defined (__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
355:
356: int fd;
357: struct ifaliasreq areq;
358:
359: /* TODO: Is this needed on FreeBSD? */
360: if (!this->addrs) /* Use ioctl for first addr to make ping work */
361: return tun_setaddr(this, addr, dstaddr, netmask); /* TODO dstaddr */
362:
363: memset(&areq, 0, sizeof(areq));
364:
365: /* Set up interface name */
366: strncpy(areq.ifra_name, tuntap(this).devname, IFNAMSIZ);
367: areq.ifra_name[IFNAMSIZ-1] = 0; /* Make sure to terminate */
368:
369: ((struct sockaddr_in*) &areq.ifra_addr)->sin_family = AF_INET;
370: ((struct sockaddr_in*) &areq.ifra_addr)->sin_len = sizeof(areq.ifra_addr);
371: ((struct sockaddr_in*) &areq.ifra_addr)->sin_addr.s_addr = addr->s_addr;
372:
373: ((struct sockaddr_in*) &areq.ifra_mask)->sin_family = AF_INET;
374: ((struct sockaddr_in*) &areq.ifra_mask)->sin_len = sizeof(areq.ifra_mask);
375: ((struct sockaddr_in*) &areq.ifra_mask)->sin_addr.s_addr = netmask->s_addr;
376:
377: /* For some reason FreeBSD uses ifra_broadcast for specifying dstaddr */
378: ((struct sockaddr_in*) &areq.ifra_broadaddr)->sin_family = AF_INET;
379: ((struct sockaddr_in*) &areq.ifra_broadaddr)->sin_len = sizeof(areq.ifra_broadaddr);
380: ((struct sockaddr_in*) &areq.ifra_broadaddr)->sin_addr.s_addr = dstaddr->s_addr;
381:
382: /* Create a channel to the NET kernel. */
383: if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
384: log_err(errno,
385: "socket() failed");
386: return -1;
387: }
388:
389: if (ioctl(fd, SIOCAIFADDR, (void *) &areq) < 0) {
390: log_err(errno,
391: "ioctl(SIOCAIFADDR) failed");
392: close(fd);
393: return -1;
394: }
395:
396: close(fd);
397: this->addrs++;
398: return 0;
399:
400: #elif defined (__sun__)
401:
402: if (!this->addrs) /* Use ioctl for first addr to make ping work */
403: return tun_setaddr(this, addr, dstaddr, netmask);
404:
405: log_err(errno, "Setting multiple addresses not possible on Solaris");
406: return -1;
407:
408: #else
409: #error "Unknown platform!"
410: #endif
411:
412: }
413:
414:
415: int tun_setaddr(struct tun_t *this, struct in_addr *addr, struct in_addr *dstaddr, struct in_addr *netmask) {
416: net_set_address(&tuntap(this), addr, dstaddr, netmask);
417:
418: #if defined(__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
419: net_add_route(dstaddr, addr, netmask);
420: this->routes = 1;
421: #endif
422:
423: return 0;
424: }
425:
426: static int tuntap_interface(struct _net_interface *netif) {
427: #if defined(__linux__)
428: struct ifreq ifr;
429:
430: #elif defined(__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
431: char devname[IFNAMSIZ+5]; /* "/dev/" + ifname */
432: int devnum;
433: struct ifaliasreq areq;
434: int fd;
435:
436: #elif defined(__sun__)
437: int if_fd, ppa = -1;
438: static int ip_fd = 0;
439: int muxid;
440: struct ifreq ifr;
441:
442: #else
443: #error "Unknown platform!"
444: #endif
445:
446:
447: #if defined(__linux__)
448: /* Open the actual tun device */
449: if ((netif->fd = open("/dev/net/tun", O_RDWR)) < 0) {
450: log_err(errno, "open() failed");
451: return -1;
452: }
453:
454: /* Set device flags. For some weird reason this is also the method
455: used to obtain the network interface name */
456: memset(&ifr, 0, sizeof(ifr));
457: ifr.ifr_flags = (options.usetap ? IFF_TAP : IFF_TUN) | IFF_NO_PI; /* Tun device, no packet info */
458: #if defined(IFF_ONE_QUEUE) && defined(SIOCSIFTXQLEN)
459: ifr.ifr_flags |= IFF_ONE_QUEUE;
460: #endif
461:
462: if (options.tundev && *options.tundev &&
463: strcmp(options.tundev, "tap") && strcmp(options.tundev, "tun"))
464: strncpy(ifr.ifr_name, options.tundev, IFNAMSIZ);
465:
466: if (ioctl(netif->fd, TUNSETIFF, (void *) &ifr) < 0) {
467: log_err(errno, "ioctl() failed");
468: close(netif->fd);
469: return -1;
470: }
471:
472: #if defined(IFF_ONE_QUEUE) && defined(SIOCSIFTXQLEN)
473: {
474: struct ifreq nifr;
475: int nfd;
476: memset(&nifr, 0, sizeof(nifr));
477: if ((nfd = socket (AF_INET, SOCK_DGRAM, 0)) >= 0) {
478: strncpy(nifr.ifr_name, ifr.ifr_name, IFNAMSIZ);
479: nifr.ifr_qlen = options.txqlen;
480:
481: if (ioctl(nfd, SIOCSIFTXQLEN, (void *) &nifr) >= 0)
482: log_info("TX queue length set to %d", options.txqlen);
483: else
484: log_err(errno, "Cannot set tx queue length on %s", ifr.ifr_name);
485:
486: close (nfd);
487: } else {
488: log_err(errno, "Cannot open socket on %s", ifr.ifr_name);
489: }
490: }
491: #endif
492:
493: strncpy(netif->devname, ifr.ifr_name, IFNAMSIZ);
494: netif->devname[IFNAMSIZ-1] = 0;
495:
496: ioctl(netif->fd, TUNSETNOCSUM, 1); /* Disable checksums */
497:
498: /* Get the MAC address of our tap interface */
499: if (options.usetap) {
500: int fd;
501: netif->flags |= NET_ETHHDR;
502: if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) >= 0) {
503: memset(&ifr, 0, sizeof(ifr));
504: strncpy(ifr.ifr_name, netif->devname, IFNAMSIZ);
505: if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
506: log_err(errno, "ioctl(d=%d, request=%d) failed", fd, SIOCGIFHWADDR);
507: }
508: memcpy(netif->hwaddr, ifr.ifr_hwaddr.sa_data, PKT_ETH_ALEN);
509: log_dbg("tap-mac: %s %.2X-%.2X-%.2X-%.2X-%.2X-%.2X", ifr.ifr_name,
510: netif->hwaddr[0],netif->hwaddr[1],netif->hwaddr[2],
511: netif->hwaddr[3],netif->hwaddr[4],netif->hwaddr[5]);
512: close(fd);
513: }
514: }
515:
516: return 0;
517:
518: #elif defined(__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
519:
520: /* Find suitable device */
521: for (devnum = 0; devnum < 255; devnum++) { /* TODO 255 */
522: snprintf(devname, sizeof(devname), "/dev/tun%d", devnum);
523: devname[sizeof(devname)] = 0;
524: if ((netif->fd = open(devname, O_RDWR)) >= 0) break;
525: if (errno != EBUSY) break;
526: }
527: if (netif->fd < 0) {
528: log_err(errno, "Can't find tunnel device");
529: return -1;
530: }
531:
532: snprintf(netif->devname, sizeof(netif->devname), "tun%d", devnum);
533: netif->devname[sizeof(netif->devname)-1] = 0;
534:
535: /* The tun device we found might have "old" IP addresses allocated */
536: /* We need to delete those. This problem is not present on Linux */
537:
538: memset(&areq, 0, sizeof(areq));
539:
540: /* Set up interface name */
541: strncpy(areq.ifra_name, netif->devname, IFNAMSIZ);
542: areq.ifra_name[IFNAMSIZ-1] = 0; /* Make sure to terminate */
543:
544: /* Create a channel to the NET kernel. */
545: if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
546: log_err(errno,
547: "socket() failed");
548: return -1;
549: }
550:
551: /* Delete any IP addresses until SIOCDIFADDR fails */
552: while (ioctl(fd, SIOCDIFADDR, (void *) &areq) != -1);
553:
554: close(fd);
555: return 0;
556:
557: #elif defined(__sun__)
558:
559: if( (ip_fd = open("/dev/udp", O_RDWR, 0)) < 0){
560: log_err(errno, "Can't open /dev/udp");
561: return -1;
562: }
563:
564: if( (netif->fd = open("/dev/tun", O_RDWR, 0)) < 0){
565: log_err(errno, "Can't open /dev/tun");
566: return -1;
567: }
568:
569: /* Assign a new PPA and get its unit number. */
570: if( (ppa = ioctl(netif->fd, TUNNEWPPA, -1)) < 0){
571: log_err(errno, "Can't assign new interface");
572: return -1;
573: }
574:
575: if( (if_fd = open("/dev/tun", O_RDWR, 0)) < 0){
576: log_err(errno, "Can't open /dev/tun (2)");
577: return -1;
578: }
579: if(ioctl(if_fd, I_PUSH, "ip") < 0){
580: log_err(errno, "Can't push IP module");
581: return -1;
582: }
583:
584: /* Assign ppa according to the unit number returned by tun device */
585: if(ioctl(if_fd, IF_UNITSEL, (char *)&ppa) < 0){
586: log_err(errno, "Can't set PPA %d", ppa);
587: return -1;
588: }
589:
590: /* Link the two streams */
591: if ((muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0) {
592: log_err(errno, "Can't link TUN device to IP");
593: return -1;
594: }
595:
596: close (if_fd);
597:
598: snprintf(netif->devname, sizeof(netif->devname), "tun%d", ppa);
599: netif->devname[sizeof(netif->devname)-1] = 0;
600:
601: memset(&ifr, 0, sizeof(ifr));
602: strcpy(ifr.ifr_name, netif->devname);
603: ifr.ifr_ip_muxid = muxid;
604:
605: if (ioctl(ip_fd, SIOCSIFMUXID, &ifr) < 0) {
606: ioctl(ip_fd, I_PUNLINK, muxid);
607: log_err(errno, "Can't set multiplexor id");
608: return -1;
609: }
610:
611: /* if (fcntl (fd, F_SETFL, O_NONBLOCK) < 0)
612: msg (M_ERR, "Set file descriptor to non-blocking failed"); */
613:
614: return 0;
615:
616: #else
617: #error "Unknown platform!"
618: #endif
619:
620: }
621:
622: int tun_new(struct tun_t **ptun) {
623: struct tun_t *tun;
624:
625: if (!(tun = *ptun = calloc(1, sizeof(struct tun_t)))) {
626: log_err(errno, "calloc() failed");
627: return EOF;
628: }
629:
630: tuntap_interface(tun_nextif(tun));
631:
632: if (options.routeif) {
633: tun_discover(tun);
634: }
635:
636: return 0;
637: }
638:
639: int tun_free(struct tun_t *tun) {
640:
641: if (tun->routes) {
642: #warning fix this
643: /*XXX: todo! net_delete_route(&tuntap(tun)); */
644: }
645:
646: tun_close(tun);
647:
648: /* TODO: For solaris we need to unlink streams */
649:
650: free(tun);
651: return 0;
652: }
653:
654: int tun_set_cb_ind(struct tun_t *this,
655: int (*cb_ind) (struct tun_t *tun, void *pack, size_t len, int idx)) {
656: this->cb_ind = cb_ind;
657: return 0;
658: }
659:
660: int tun_decaps(struct tun_t *this, int idx) {
661:
662: #if defined(__linux__) || defined (__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
663: unsigned char buffer[PACKET_MAX];
664: ssize_t status;
665:
666: if ((status = net_read(&tun(this, idx), buffer, sizeof(buffer))) <= 0) {
667: log_err(errno, "read() failed");
668: return -1;
669: }
670:
671: if (this->debug)
672: log_dbg("tun_decaps(%d) %s",status,tun(tun,idx).devname);
673:
674: if (0) { /* if we wanted to do nat'ing, it would could be done here */
675: struct in_addr a;
676: struct pkt_iphdr_t *iph = (struct pkt_iphdr_t *)buffer;
677: inet_aton("10.1.0.1", &a);
678: iph->daddr = a.s_addr;
679: chksum(iph);
680: }
681:
682: if (this->cb_ind)
683: #if defined (__OpenBSD__)
684: /* tun interface adds 4 bytes to front of packet under OpenBSD */
685: return this->cb_ind(this, buffer+4, status, idx);
686: #else
687: return this->cb_ind(this, buffer, status, idx);
688: #endif
689:
690: return 0;
691:
692: #elif defined (__sun__)
693: unsigned char buffer[PACKET_MAX];
694: struct strbuf sbuf;
695: int f = 0;
696:
697: sbuf.maxlen = PACKET_MAX;
698: sbuf.buf = buffer;
699: if (getmsg(tun(this, idx).fd, NULL, &sbuf, &f) < 0) {
700: log_err(errno, "getmsg() failed");
701: return -1;
702: }
703:
704: if (this->cb_ind)
705: return this->cb_ind(this, &packet, sbuf.len);
706:
707: return 0;
708:
709: #endif
710: }
711:
712: static uint32_t dnatip[1024];
713: static uint16_t dnatport[1024];
714:
715: int tun_encaps(struct tun_t *tun, void *pack, size_t len, int idx) {
716:
717: if (tun(tun, idx).flags & NET_ETHHDR) {
718:
719: struct pkt_ethhdr_t *ethh = (struct pkt_ethhdr_t *)pack;
720: /*memcpy(ethh->src, tun->tap_hwaddr, PKT_ETH_ALEN); */
721:
722: /** XXX **/
723: if (1) {
724: ethh->src[0]=0x00;
725: ethh->src[1]=0x17;
726: ethh->src[2]=0x3f;
727: ethh->src[3]=0x99;
728: ethh->src[4]=0xf4;
729: ethh->src[5]=0x46;
730:
731: ethh->dst[0]=0x00;
732: ethh->dst[1]=0x14;
733: ethh->dst[2]=0xBF;
734: ethh->dst[3]=0xE2;
735: ethh->dst[4]=0xC1;
736: ethh->dst[5]=0x75;
737: }
738:
739: log_dbg("writing to tun/tap src=%.2x:%.2x:%.2x:%.2x:%.2x:%.2x dst=%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
740: ethh->src[0],ethh->src[1],ethh->src[2],ethh->src[3],ethh->src[4],ethh->src[5],
741: ethh->dst[0],ethh->dst[1],ethh->dst[2],ethh->dst[3],ethh->dst[4],ethh->dst[5]);
742: } else {
743: pack += PKT_ETH_HLEN;
744: len -= PKT_ETH_HLEN;
745: }
746:
747: if (tun->debug)
748: log_dbg("tun_encaps(%d) %s",len,tun(tun,idx).devname);
749:
750: #if defined (__OpenBSD__)
751:
752: unsigned char buffer[PACKET_MAX+4];
753:
754: /* Can we user writev here to be more efficient??? */
755: *((uint32_t *)(&buffer))=htonl(AF_INET);
756: memcpy(&buffer[4], pack, PACKET_MAX);
757:
758: return net_write(&tun(tun, idx), buffer, len+4);
759:
760: #elif defined(__linux__) || defined (__FreeBSD__) || defined (__APPLE__) || defined (__NetBSD__)
761:
762: if (0) { /* if we wanted to do nat'ing we could do it here */
763: struct in_addr a;
764: struct pkt_iphdr_t *iph = (struct pkt_iphdr_t *)pack;
765: inet_aton("172.30.97.2", &a);
766: iph->saddr = a.s_addr;
767: chksum(iph);
768: }
769:
770: return net_write(&tun(tun, idx), pack, len);
771:
772: #elif defined (__sun__)
773:
774: struct strbuf sbuf;
775: sbuf.len = len;
776: sbuf.buf = pack;
777: return putmsg(tun(tun, idx).fd, NULL, &sbuf, 0);
778:
779: #endif
780: }
781:
782: int tun_runscript(struct tun_t *tun, char* script) {
783: char saddr[TUN_ADDRSIZE];
784: char smask[TUN_ADDRSIZE];
785: char b[TUN_ADDRSIZE];
786: struct in_addr net;
787: int status;
788:
789: net.s_addr = tuntap(tun).address.s_addr & tuntap(tun).netmask.s_addr;
790:
791: if ((status = fork()) < 0) {
792: log_err(errno, "fork() returned -1!");
793: return 0;
794: }
795:
796: if (status > 0) { /* Parent */
797: return 0;
798: }
799:
800: /*
801: #ifdef HAVE_CLEARENV
802: if (clearenv() != 0) {
803: log_err(errno,
804: "clearenv() did not return 0!");
805: exit(0);
806: }
807: #endif
808: */
809:
810: if (setenv("DEV", tuntap(tun).devname, 1) != 0) {
811: log_err(errno, "setenv() did not return 0!");
812: exit(0);
813: }
814:
815: strncpy(saddr, inet_ntoa(tuntap(tun).address), sizeof(saddr));
816: saddr[sizeof(saddr)-1] = 0;
817: if (setenv("ADDR", saddr, 1 ) != 0) {
818: log_err(errno, "setenv() did not return 0!");
819: exit(0);
820: }
821:
822: strncpy(smask, inet_ntoa(tuntap(tun).netmask), sizeof(smask));
823: smask[sizeof(smask)-1] = 0;
824: if (setenv("MASK", smask, 1) != 0) {
825: log_err(errno, "setenv() did not return 0!");
826: exit(0);
827: }
828:
829: strncpy(b, inet_ntoa(net), sizeof(b));
830: b[sizeof(b)-1] = 0;
831: if (setenv("NET", b, 1 ) != 0) {
832: log_err(errno, "setenv() did not return 0!");
833: exit(0);
834: }
835:
836: snprintf(b, sizeof(b), "%d", options.uamport);
837: if (setenv("UAMPORT", b, 1 ) != 0) {
838: log_err(errno, "setenv() did not return 0!");
839: exit(0);
840: }
841:
842: snprintf(b, sizeof(b), "%d", options.uamuiport);
843: if (setenv("UAMUIPORT", b, 1 ) != 0) {
844: log_err(errno, "setenv() did not return 0!");
845: exit(0);
846: }
847:
848: if (setenv("DHCPIF", options.dhcpif ? options.dhcpif : "", 1 ) != 0) {
849: log_err(errno, "setenv() did not return 0!");
850: exit(0);
851: }
852:
853: if (execl(script, script, tuntap(tun).devname, saddr, smask, (char *) 0) != 0) {
854: log_err(errno, "execl() did not return 0!");
855: exit(0);
856: }
857:
858: exit(0);
859: }
860:
861:
862: /* Currently unused
863: int tun_addroute2(struct tun_t *this,
864: struct in_addr *dst,
865: struct in_addr *gateway,
866: struct in_addr *mask) {
867:
868: struct {
869: struct nlmsghdr n;
870: struct rtmsg r;
871: char buf[TUN_NLBUFSIZE];
872: } req;
873:
874: struct sockaddr_nl local;
875: int addr_len;
876: int fd;
877: int status;
878: struct sockaddr_nl nladdr;
879: struct iovec iov;
880: struct msghdr msg;
881:
882: memset(&req, 0, sizeof(req));
883: req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
884: req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
885: req.n.nlmsg_type = RTM_NEWROUTE;
886: req.r.rtm_family = AF_INET;
887: req.r.rtm_table = RT_TABLE_MAIN;
888: req.r.rtm_protocol = RTPROT_BOOT;
889: req.r.rtm_scope = RT_SCOPE_UNIVERSE;
890: req.r.rtm_type = RTN_UNICAST;
891: tun_nlattr(&req.n, sizeof(req), RTA_DST, dst, 4);
892: tun_nlattr(&req.n, sizeof(req), RTA_GATEWAY, gateway, 4);
893:
894: if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0) {
895: sys_err(LOG_ERR, __FILE__, __LINE__, errno,
896: "socket() failed");
897: return -1;
898: }
899:
900: memset(&local, 0, sizeof(local));
901: local.nl_family = AF_NETLINK;
902: local.nl_groups = 0;
903:
904: if (bind(fd, (struct sockaddr*)&local, sizeof(local)) < 0) {
905: sys_err(LOG_ERR, __FILE__, __LINE__, errno,
906: "bind() failed");
907: close(fd);
908: return -1;
909: }
910:
911: addr_len = sizeof(local);
912: if (getsockname(fd, (struct sockaddr*)&local, &addr_len) < 0) {
913: sys_err(LOG_ERR, __FILE__, __LINE__, errno,
914: "getsockname() failed");
915: close(fd);
916: return -1;
917: }
918:
919: if (addr_len != sizeof(local)) {
920: sys_err(LOG_ERR, __FILE__, __LINE__, 0,
921: "Wrong address length %d", addr_len);
922: close(fd);
923: return -1;
924: }
925:
926: if (local.nl_family != AF_NETLINK) {
927: sys_err(LOG_ERR, __FILE__, __LINE__, 0,
928: "Wrong address family %d", local.nl_family);
929: close(fd);
930: return -1;
931: }
932:
933: iov.iov_base = (void*)&req.n;
934: iov.iov_len = req.n.nlmsg_len;
935:
936: msg.msg_name = (void*)&nladdr;
937: msg.msg_namelen = sizeof(nladdr),
938: msg.msg_iov = &iov;
939: msg.msg_iovlen = 1;
940: msg.msg_control = NULL;
941: msg.msg_controllen = 0;
942: msg.msg_flags = 0;
943:
944: memset(&nladdr, 0, sizeof(nladdr));
945: nladdr.nl_family = AF_NETLINK;
946: nladdr.nl_pid = 0;
947: nladdr.nl_groups = 0;
948:
949: req.n.nlmsg_seq = 0;
950: req.n.nlmsg_flags |= NLM_F_ACK;
951:
952: status = sendmsg(fd, &msg, 0); * TODO: Error check *
953: close(fd);
954: return 0;
955: }
956: */
957:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tun.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / coova-chilli / src