Some device.c files weren't synchronised.
[tinc] / src / linux / device.c
1 /*
2     device.c -- Interaction with Linux ethertap and tun/tap device
3     Copyright (C) 2001-2003 Ivo Timmermans <ivo@o2w.nl>,
4                   2001-2003 Guus Sliepen <guus@sliepen.eu.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
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: device.c,v 1.4 2003/08/27 13:47:48 guus Exp $
21 */
22
23 #include "system.h"
24
25 #ifdef HAVE_TUNTAP
26 #ifdef LINUX_IF_TUN_H
27 #include LINUX_IF_TUN_H
28 #else
29 #include <linux/if_tun.h>
30 #endif
31 #define DEFAULT_DEVICE "/dev/net/tun"
32 #else
33 #define DEFAULT_DEVICE "/dev/tap0"
34 #endif
35
36 #include "conf.h"
37 #include "logger.h"
38 #include "net.h"
39 #include "route.h"
40 #include "utils.h"
41
42 typedef enum device_type_t {
43         DEVICE_TYPE_ETHERTAP,
44         DEVICE_TYPE_TUN,
45         DEVICE_TYPE_TAP,
46 } device_type_t;
47
48 int device_fd = -1;
49 device_type_t device_type;
50 char *device;
51 char *iface;
52 char ifrname[IFNAMSIZ];
53 char *device_info;
54
55 int device_total_in = 0;
56 int device_total_out = 0;
57
58 bool setup_device(void)
59 {
60         struct ifreq ifr;
61
62         cp();
63
64         if(!get_config_string(lookup_config(config_tree, "Device"), &device))
65                 device = DEFAULT_DEVICE;
66
67         if(!get_config_string(lookup_config(config_tree, "Interface"), &iface))
68 #ifdef HAVE_TUNTAP
69                 iface = netname;
70 #else
71                 iface = rindex(device, '/') ? rindex(device, '/') + 1 : device;
72 #endif
73         device_fd = open(device, O_RDWR | O_NONBLOCK);
74
75         if(device_fd < 0) {
76                 logger(LOG_ERR, _("Could not open %s: %s"), device, strerror(errno));
77                 return false;
78         }
79
80 #ifdef HAVE_TUNTAP
81         /* Ok now check if this is an old ethertap or a new tun/tap thingie */
82
83         memset(&ifr, 0, sizeof(ifr));
84         if(routing_mode == RMODE_ROUTER) {
85                 ifr.ifr_flags = IFF_TUN;
86                 device_type = DEVICE_TYPE_TUN;
87                 device_info = _("Linux tun/tap device (tun mode)");
88         } else {
89                 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
90                 device_type = DEVICE_TYPE_TAP;
91                 device_info = _("Linux tun/tap device (tap mode)");
92         }
93
94         if(iface)
95                 strncpy(ifr.ifr_name, iface, IFNAMSIZ);
96
97         if(!ioctl(device_fd, TUNSETIFF, (void *) &ifr)) {
98                 strncpy(ifrname, ifr.ifr_name, IFNAMSIZ);
99                 iface = ifrname;
100         } else if(!ioctl(device_fd, (('T' << 8) | 202), (void *) &ifr)) {
101                 logger(LOG_WARNING, _("Old ioctl() request was needed for %s"), device);
102                 strncpy(ifrname, ifr.ifr_name, IFNAMSIZ);
103                 iface = ifrname;
104         } else
105 #endif
106         {
107                 if(routing_mode == RMODE_ROUTER)
108                         overwrite_mac = true;
109                 device_info = _("Linux ethertap device");
110                 device_type = DEVICE_TYPE_ETHERTAP;
111                 iface = rindex(device, '/') ? rindex(device, '/') + 1 : device;
112         }
113
114         logger(LOG_INFO, _("%s is a %s"), device, device_info);
115
116         return true;
117 }
118
119 void close_device(void)
120 {
121         cp();
122         
123         close(device_fd);
124 }
125
126 bool read_packet(vpn_packet_t *packet)
127 {
128         int lenin;
129         
130         cp();
131
132         switch(device_type) {
133                 case DEVICE_TYPE_TUN:
134                         lenin = read(device_fd, packet->data + 10, MTU - 10);
135
136                         if(lenin <= 0) {
137                                 logger(LOG_ERR, _("Error while reading from %s %s: %s"),
138                                            device_info, device, strerror(errno));
139                                 return false;
140                         }
141
142                         packet->len = lenin + 10;
143                         break;
144                 case DEVICE_TYPE_TAP:
145                         lenin = read(device_fd, packet->data, MTU);
146
147                         if(lenin <= 0) {
148                                 logger(LOG_ERR, _("Error while reading from %s %s: %s"),
149                                            device_info, device, strerror(errno));
150                                 return false;
151                         }
152
153                         packet->len = lenin;
154                         break;
155                 case DEVICE_TYPE_ETHERTAP:
156                         lenin = read(device_fd, packet->data - 2, MTU + 2);
157
158                         if(lenin <= 0) {
159                                 logger(LOG_ERR, _("Error while reading from %s %s: %s"),
160                                            device_info, device, strerror(errno));
161                                 return false;
162                         }
163
164                         packet->len = lenin - 2;
165                         break;
166         }
167
168         device_total_in += packet->len;
169
170         ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Read packet of %d bytes from %s"), packet->len,
171                            device_info);
172
173         return true;
174 }
175
176 bool write_packet(vpn_packet_t *packet)
177 {
178         cp();
179
180         ifdebug(TRAFFIC) logger(LOG_DEBUG, _("Writing packet of %d bytes to %s"),
181                            packet->len, device_info);
182
183         switch(device_type) {
184                 case DEVICE_TYPE_TUN:
185                         packet->data[10] = packet->data[11] = 0;
186                         if(write(device_fd, packet->data + 10, packet->len - 10) < 0) {
187                                 logger(LOG_ERR, _("Can't write to %s %s: %s"), device_info, device,
188                                            strerror(errno));
189                                 return false;
190                         }
191                         break;
192                 case DEVICE_TYPE_TAP:
193                         if(write(device_fd, packet->data, packet->len) < 0) {
194                                 logger(LOG_ERR, _("Can't write to %s %s: %s"), device_info, device,
195                                            strerror(errno));
196                                 return false;
197                         }
198                         break;
199                 case DEVICE_TYPE_ETHERTAP:
200                         *(short int *)(packet->data - 2) = packet->len;
201
202                         if(write(device_fd, packet->data - 2, packet->len + 2) < 0) {
203                                 logger(LOG_ERR, _("Can't write to %s %s: %s"), device_info, device,
204                                            strerror(errno));
205                                 return false;
206                         }
207                         break;
208         }
209
210         device_total_out += packet->len;
211
212         return true;
213 }
214
215 void dump_device_stats(void)
216 {
217         cp();
218
219         logger(LOG_DEBUG, _("Statistics for %s %s:"), device_info, device);
220         logger(LOG_DEBUG, _(" total bytes in:  %10d"), device_total_in);
221         logger(LOG_DEBUG, _(" total bytes out: %10d"), device_total_out);
222 }