Add xsltproc to Build-Depends, use git.grml.org for Vcs-Headers
[debian/uanytun.git] / src / bsd / tun.c
1 /*
2  *  uAnytun
3  *
4  *  uAnytun is a tiny implementation of SATP. Unlike Anytun which is a full
5  *  featured implementation uAnytun has no support for multiple connections
6  *  or synchronisation. It is a small single threaded implementation intended
7  *  to act as a client on small platforms.
8  *  The secure anycast tunneling protocol (satp) defines a protocol used
9  *  for communication between any combination of unicast and anycast
10  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
11  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
12  *  ethernet, ip, arp ...). satp directly includes cryptography and
13  *  message authentication based on the methodes used by SRTP.  It is
14  *  intended to deliver a generic, scaleable and secure solution for
15  *  tunneling and relaying of packets of any protocol.
16  *  
17  *
18  *  Copyright (C) 2007-2008 Christian Pointner <equinox@anytun.org>
19  *
20  *  This file is part of uAnytun.
21  *
22  *  uAnytun is free software: you can redistribute it and/or modify
23  *  it under the terms of the GNU General Public License version 3 as
24  *  published by the Free Software Foundation.
25  *
26  *  uAnytun is distributed in the hope that it will be useful,
27  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
28  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
29  *  GNU General Public License for more details.
30  *
31  *  You should have received a copy of the GNU General Public License
32  *  along with uAnytun. If not, see <http://www.gnu.org/licenses/>.
33  */
34
35 #include "datatypes.h"
36
37 #include "tun.h"
38
39 #include "tun_helper.h"
40
41 #include "log.h"
42
43 #include <fcntl.h>
44 #include <unistd.h>
45 #include <errno.h>
46 #include <sys/wait.h>
47 #include <sys/socket.h>
48 #include <net/if.h>
49 #include <net/if_tun.h>
50 #include <sys/ioctl.h>
51 #include <sys/types.h>
52 #include <sys/uio.h>
53 #include <netinet/in_systm.h>
54 #include <netinet/in.h>
55 #include <netinet/ip.h>
56 #define DEVICE_FILE_MAX 255
57
58 int tun_init(tun_device_t* dev, const char* dev_name, const char* dev_type, const char* ifcfg_addr, u_int16_t ifcfg_prefix)
59 {
60   if(!dev) 
61     return -1;
62  
63   tun_conf(dev, dev_name, dev_type, ifcfg_addr, ifcfg_prefix, 1400);
64   dev->actual_name_ = NULL;
65
66   char* device_file = NULL;
67   char* actual_name_start = NULL;
68   int dynamic = 1;
69   if(dev_name) {
70     asprintf(&device_file, "/dev/%s", dev_name);
71     dynamic = 0;
72   }
73 #if defined(__GNUC__) && defined(__OpenBSD__)
74   else if(dev->type_ == TYPE_TUN || dev->type_ == TYPE_TAP) {
75     asprintf(&device_file, "/dev/tun");
76     actual_name_start = "tun";
77   }
78 #else
79   else if(dev->type_ == TYPE_TUN) {
80     asprintf(&device_file, "/dev/tun");
81     actual_name_start = "tun";
82   }
83   else if(dev->type_ == TYPE_TAP) {
84     asprintf(&device_file, "/dev/tap");
85     actual_name_start = "tap";
86   }
87 #endif
88   else {
89     log_printf(ERROR, "unable to recognize type of device (tun or tap)");
90     tun_close(dev);
91     return -1;
92   }
93   if(!device_file) {
94     log_printf(ERROR, "can't open device file: memory error");
95     tun_close(dev);
96     return -2;
97   }
98
99   u_int32_t dev_id=0;
100   if(dynamic) {
101     for(; dev_id <= DEVICE_FILE_MAX; ++dev_id) {
102       char* device_file_tmp = NULL;
103       asprintf(&device_file_tmp, "%s%d", device_file, dev_id);
104
105       if(!device_file_tmp) {
106         log_printf(ERROR, "can't open device file: memory error");
107         free(device_file);
108         tun_close(dev);
109         return -2;
110       }
111         
112       dev->fd_ = open(device_file_tmp, O_RDWR);
113       free(device_file_tmp);
114       if(dev->fd_ >= 0)
115         break;
116     }
117   }
118   else
119     dev->fd_ = open(device_file, O_RDWR);
120   free(device_file);
121
122   if(dev->fd_ < 0) {
123     if(dynamic)
124       log_printf(ERROR, "can't open device file dynamically: no unused node left");
125     else
126       log_printf(ERROR, "can't open device file (%s): %s", device_file, strerror(errno));
127     
128     tun_close(dev);
129     return -1;
130   }
131
132   if(dynamic)
133     asprintf(&(dev->actual_name_), "%s%d", actual_name_start, dev_id);
134   else
135     dev->actual_name_ = strdup(dev_name);
136
137   if(!dev->actual_name_) {
138     log_printf(ERROR, "can't open device file: memory error");
139     tun_close(dev);
140     return -2;
141   }
142
143   int ret = tun_init_post(dev);
144   if(ret) {
145     tun_close(dev);
146     return ret;
147   }
148
149   if(ifcfg_addr)
150     tun_do_ifconfig(dev);
151
152   return 0;
153 }
154
155
156 #if defined(__GNUC__) && defined(__OpenBSD__)
157
158 int tun_init_post(tun_device_t* dev)
159 {
160   if(!dev)
161     return -1;
162
163   dev->with_pi_ = 1;
164   if(dev->type_ == TYPE_TAP)
165     dev->with_pi_ = 0;
166   
167   struct tuninfo ti;  
168
169   if(ioctl(dev->fd_, TUNGIFINFO, &ti) < 0) {
170     log_printf(ERROR, "can't enable multicast for interface: %s", strerror(errno));
171     return -1;
172   }  
173
174   ti.flags |= IFF_MULTICAST;
175   if(dev->type_ == TYPE_TUN)
176     ti.flags &= ~IFF_POINTOPOINT;
177   
178   if(ioctl(dev->fd_, TUNSIFINFO, &ti) < 0) {
179     log_printf(ERROR, "can't enable multicast for interface: %s", strerror(errno));
180     return -1;
181   }
182   return 0;
183 }
184
185 #elif defined(__GNUC__) && defined(__FreeBSD__)
186
187 int tun_init_post(tun_device_t* dev)
188 {
189   if(!dev)
190     return -1;
191
192   dev->with_pi_ = 1;
193   if(dev->type_ == TYPE_TAP)
194     dev->with_pi_ = 0;
195
196   if(dev->type_ == TYPE_TUN) {
197     int arg = 0;
198     if(ioctl(dev->fd_, TUNSLMODE, &arg) < 0) {
199       log_printf(ERROR, "can't disable link-layer mode for interface: %s", strerror(errno));
200       return -1;
201     }  
202
203     arg = 1;
204     if(ioctl(dev->fd_, TUNSIFHEAD, &arg) < 0) {
205       log_printf(ERROR, "can't enable multi-af mode for interface: %s", strerror(errno));
206       return -1;
207     }  
208
209     arg = IFF_BROADCAST;
210     arg |= IFF_MULTICAST;
211     if(ioctl(dev->fd_, TUNSIFMODE, &arg) < 0) {
212       log_printf(ERROR, "can't enable multicast for interface: %s", strerror(errno));
213       return -1;
214     }  
215   }
216
217   return 0;
218 }
219
220 #elif defined(__GNUC__) && defined(__NetBSD__)
221  #warning this device has never been tested on NetBSD and might not work
222 int tun_init_post(tun_device_t* dev)
223 {
224   if(!dev)
225     return -1;
226
227   dev->with_pi_ = 0;
228
229   int arg = IFF_POINTOPOINT|IFF_MULTICAST;
230   ioctl(dev->fd_, TUNSIFMODE, &arg);
231   arg = 0;
232   ioctl(dev->fd_, TUNSLMODE, &arg);
233
234   return 0;
235 }
236
237 #else
238  #error This Device works just for OpenBSD, FreeBSD or NetBSD
239 #endif
240
241
242
243 void tun_close(tun_device_t* dev)
244 {
245   if(!dev)
246     return;
247
248   if(dev->fd_ > 0)
249     close(dev->fd_);
250
251   if(dev->actual_name_)
252     free(dev->actual_name_);
253
254   if(dev->net_addr_)
255     free(dev->net_addr_);
256
257   if(dev->net_mask_)
258     free(dev->net_mask_);
259 }
260
261 int tun_read(tun_device_t* dev, u_int8_t* buf, u_int32_t len)
262 {
263   if(!dev || dev->fd_ < 0)
264     return -1;
265
266   if(dev->with_pi_)
267   {
268     struct iovec iov[2];
269     u_int32_t type;
270     
271     iov[0].iov_base = &type;
272     iov[0].iov_len = sizeof(type);
273     iov[1].iov_base = buf;
274     iov[1].iov_len = len;
275     return(tun_fix_return(readv(dev->fd_, iov, 2), sizeof(type)));
276   }
277   else
278     return(read(dev->fd_, buf, len));
279 }
280
281 int tun_write(tun_device_t* dev, u_int8_t* buf, u_int32_t len)
282 {
283   if(!dev || dev->fd_ < 0)
284     return -1;
285
286   if(!buf)
287     return 0;
288
289   if(dev->with_pi_)
290   {
291     struct iovec iov[2];
292     u_int32_t type;
293     struct ip *hdr = (struct ip*)buf;
294     
295     type = 0;
296     if(hdr->ip_v == 4)
297       type = htonl(AF_INET);
298     else
299       type = htonl(AF_INET6);
300     
301     iov[0].iov_base = &type;
302     iov[0].iov_len = sizeof(type);
303     iov[1].iov_base = buf;
304     iov[1].iov_len = len;
305     return(tun_fix_return(writev(dev->fd_, iov, 2), sizeof(type)));
306   }
307   else
308     return(write(dev->fd_, buf, len));
309 }
310
311 void tun_do_ifconfig(tun_device_t* dev)
312 {
313   if(!dev || !dev->actual_name_ || !dev->net_addr_ || !dev->net_mask_)
314     return;
315
316
317   char* command = NULL;
318   char* netmask;
319   char* end;
320   if(dev->type_ == TYPE_TAP) {
321 #if defined(__GNUC__) && defined(__OpenBSD__)
322     end = " link0";
323 #elif defined(__GNUC__) && defined(__FreeBSD__)
324     end = " up";
325 #elif defined(__GNUC__) && defined(__NetBSD__)
326     end = "";
327 #else
328  #error This Device works just for OpenBSD, FreeBSD or NetBSD
329 #endif
330   }
331   else
332     end = " up";
333
334   asprintf(&command, "/sbin/ifconfig %s %s netmask %s mtu %d%s", dev->actual_name_, dev->net_addr_,
335                                                                  dev->net_mask_, dev->mtu_, end);
336   if(!command) {
337     log_printf(ERROR, "Execution of ifconfig failed");
338     return;
339   }
340
341   int result = system(command);
342   if(result == -1)
343     log_printf(ERROR, "Execution of ifconfig failed");
344   else
345     log_printf(NOTICE, "ifconfig returned %d", WEXITSTATUS(result));
346
347   free(command);
348 }