Use CFB mode for meta-connections to improve security.
[tinc] / src / linux / device.c
1 /*
2     device.c -- Interaction with Linux ethertap and tun/tap device
3     Copyright (C) 2001-2005 Ivo Timmermans,
4                   2001-2014 Guus Sliepen <guus@tinc-vpn.org>
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License along
17     with this program; if not, write to the Free Software Foundation, Inc.,
18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "../system.h"
22
23 #ifdef HAVE_LINUX_IF_TUN_H
24 #include <linux/if_tun.h>
25 #define DEFAULT_DEVICE "/dev/net/tun"
26 #else
27 #define DEFAULT_DEVICE "/dev/tap0"
28 #endif
29
30 #include "../conf.h"
31 #include "../device.h"
32 #include "../logger.h"
33 #include "../net.h"
34 #include "../route.h"
35 #include "../utils.h"
36 #include "../xalloc.h"
37
38 typedef enum device_type_t {
39         DEVICE_TYPE_ETHERTAP,
40         DEVICE_TYPE_TUN,
41         DEVICE_TYPE_TAP,
42 } device_type_t;
43
44 int device_fd = -1;
45 static device_type_t device_type;
46 char *device = NULL;
47 char *iface = NULL;
48 static char *type = NULL;
49 static char ifrname[IFNAMSIZ];
50 static char *device_info;
51
52 static uint64_t device_total_in = 0;
53 static uint64_t device_total_out = 0;
54
55 static bool setup_device(void) {
56         struct ifreq ifr;
57         bool t1q = false;
58
59         if(!get_config_string(lookup_config(config_tree, "Device"), &device))
60                 device = xstrdup(DEFAULT_DEVICE);
61
62         if(!get_config_string(lookup_config(config_tree, "Interface"), &iface))
63 #ifdef HAVE_LINUX_IF_TUN_H
64                 if (netname != NULL)
65                         iface = xstrdup(netname);
66 #else
67                 iface = xstrdup(strrchr(device, '/') ? strrchr(device, '/') + 1 : device);
68 #endif
69         device_fd = open(device, O_RDWR | O_NONBLOCK);
70
71         if(device_fd < 0) {
72                 logger(LOG_ERR, "Could not open %s: %s", device, strerror(errno));
73                 return false;
74         }
75
76 #ifdef FD_CLOEXEC
77         fcntl(device_fd, F_SETFD, FD_CLOEXEC);
78 #endif
79
80 #ifdef HAVE_LINUX_IF_TUN_H
81         /* Ok now check if this is an old ethertap or a new tun/tap thingie */
82
83         memset(&ifr, 0, sizeof(ifr));
84
85         get_config_string(lookup_config(config_tree, "DeviceType"), &type);
86
87         if(type && strcasecmp(type, "tun") && strcasecmp(type, "tap")) {
88                 logger(LOG_ERR, "Unknown device type %s!", type);
89                 return false;
90         }
91
92         if((type && !strcasecmp(type, "tun")) || (!type && routing_mode == RMODE_ROUTER)) {
93                 ifr.ifr_flags = IFF_TUN;
94                 device_type = DEVICE_TYPE_TUN;
95                 device_info = "Linux tun/tap device (tun mode)";
96         } else {
97                 if (routing_mode == RMODE_ROUTER)
98                         overwrite_mac = true;
99                 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
100                 device_type = DEVICE_TYPE_TAP;
101                 device_info = "Linux tun/tap device (tap mode)";
102         }
103
104 #ifdef IFF_ONE_QUEUE
105         /* Set IFF_ONE_QUEUE flag... */
106         if(get_config_bool(lookup_config(config_tree, "IffOneQueue"), &t1q) && t1q)
107                 ifr.ifr_flags |= IFF_ONE_QUEUE;
108 #endif
109
110         if(iface) {
111                 strncpy(ifr.ifr_name, iface, IFNAMSIZ);
112                 ifr.ifr_name[IFNAMSIZ - 1] = 0;
113         }
114
115         if(!ioctl(device_fd, TUNSETIFF, &ifr)) {
116                 strncpy(ifrname, ifr.ifr_name, IFNAMSIZ);
117                 ifrname[IFNAMSIZ - 1] = 0;
118                 free(iface);
119                 iface = xstrdup(ifrname);
120         } else if(!ioctl(device_fd, (('T' << 8) | 202), &ifr)) {
121                 logger(LOG_WARNING, "Old ioctl() request was needed for %s", device);
122                 strncpy(ifrname, ifr.ifr_name, IFNAMSIZ);
123                 ifrname[IFNAMSIZ - 1] = 0;
124                 free(iface);
125                 iface = xstrdup(ifrname);
126         } else
127 #endif
128         {
129                 if(routing_mode == RMODE_ROUTER)
130                         overwrite_mac = true;
131                 device_info = "Linux ethertap device";
132                 device_type = DEVICE_TYPE_ETHERTAP;
133                 free(iface);
134                 iface = xstrdup(strrchr(device, '/') ? strrchr(device, '/') + 1 : device);
135         }
136
137         if(overwrite_mac && !ioctl(device_fd, SIOCGIFHWADDR, &ifr))
138                 memcpy(mymac.x, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
139
140         logger(LOG_INFO, "%s is a %s", device, device_info);
141
142         return true;
143 }
144
145 static void close_device(void) {
146         close(device_fd);
147
148         free(type);
149         free(device);
150         free(iface);
151 }
152
153 static bool read_packet(vpn_packet_t *packet) {
154         int lenin;
155         
156         switch(device_type) {
157                 case DEVICE_TYPE_TUN:
158                         lenin = read(device_fd, packet->data + 10, MTU - 10);
159
160                         if(lenin <= 0) {
161                                 logger(LOG_ERR, "Error while reading from %s %s: %s",
162                                            device_info, device, strerror(errno));
163                                 return false;
164                         }
165
166                         memset(packet->data, 0, 12);
167                         packet->len = lenin + 10;
168                         break;
169                 case DEVICE_TYPE_TAP:
170                         lenin = read(device_fd, packet->data, MTU);
171
172                         if(lenin <= 0) {
173                                 logger(LOG_ERR, "Error while reading from %s %s: %s",
174                                            device_info, device, strerror(errno));
175                                 return false;
176                         }
177
178                         packet->len = lenin;
179                         break;
180                 case DEVICE_TYPE_ETHERTAP:
181                         lenin = read(device_fd, packet->data - 2, MTU + 2);
182
183                         if(lenin <= 0) {
184                                 logger(LOG_ERR, "Error while reading from %s %s: %s",
185                                            device_info, device, strerror(errno));
186                                 return false;
187                         }
188
189                         packet->len = lenin - 2;
190                         break;
191         }
192
193         device_total_in += packet->len;
194
195         ifdebug(TRAFFIC) logger(LOG_DEBUG, "Read packet of %d bytes from %s", packet->len,
196                            device_info);
197
198         return true;
199 }
200
201 static bool write_packet(vpn_packet_t *packet) {
202         ifdebug(TRAFFIC) logger(LOG_DEBUG, "Writing packet of %d bytes to %s",
203                            packet->len, device_info);
204
205         switch(device_type) {
206                 case DEVICE_TYPE_TUN:
207                         packet->data[10] = packet->data[11] = 0;
208                         if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
209                                 logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
210                                            strerror(errno));
211                                 return false;
212                         }
213                         break;
214                 case DEVICE_TYPE_TAP:
215                         if(write(device_fd, packet->data, packet->len) < 0) {
216                                 logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
217                                            strerror(errno));
218                                 return false;
219                         }
220                         break;
221                 case DEVICE_TYPE_ETHERTAP:
222                         memcpy(packet->data - 2, &packet->len, 2);
223
224                         if(write(device_fd, packet->data - 2, packet->len + 2) < 0) {
225                                 logger(LOG_ERR, "Can't write to %s %s: %s", device_info, device,
226                                            strerror(errno));
227                                 return false;
228                         }
229                         break;
230         }
231
232         device_total_out += packet->len;
233
234         return true;
235 }
236
237 static void dump_device_stats(void) {
238         logger(LOG_DEBUG, "Statistics for %s %s:", device_info, device);
239         logger(LOG_DEBUG, " total bytes in:  %10"PRIu64, device_total_in);
240         logger(LOG_DEBUG, " total bytes out: %10"PRIu64, device_total_out);
241 }
242
243 const devops_t os_devops = {
244         .setup = setup_device,
245         .close = close_device,
246         .read = read_packet,
247         .write = write_packet,
248         .dump_stats = dump_device_stats,
249 };