tinc-vpn.org Git - tinc/blob - src/mingw/device.c

   1 /*
   2     device.c -- Interaction with Windows tap driver in a MinGW environment
   3     Copyright (C) 2002-2005 Ivo Timmermans,
   4                   2002-2018 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 #include <windows.h>
  24 #include <winioctl.h>
  25
  26 #include "../conf.h"
  27 #include "../device.h"
  28 #include "../logger.h"
  29 #include "../names.h"
  30 #include "../net.h"
  31 #include "../route.h"
  32 #include "../utils.h"
  33 #include "../xalloc.h"
  34
  35 #include "common.h"
  36
  37 int device_fd = -1;
  38 static HANDLE device_handle = INVALID_HANDLE_VALUE;
  39 static io_t device_read_io;
  40 static OVERLAPPED device_read_overlapped;
  41 static OVERLAPPED device_write_overlapped;
  42 static vpn_packet_t device_read_packet;
  43 static vpn_packet_t device_write_packet;
  44 char *device = NULL;
  45 char *iface = NULL;
  46 static const char *device_info = "Windows tap device";
  47
  48 extern char *myport;
  49
  50 static void device_issue_read() {
  51         int status;
  52
  53         for(;;) {
  54                 ResetEvent(device_read_overlapped.hEvent);
  55
  56                 DWORD len;
  57                 status = ReadFile(device_handle, (void *)device_read_packet.data, MTU, &len, &device_read_overlapped);
  58
  59                 if(!status) {
  60                         if(GetLastError() != ERROR_IO_PENDING)
  61                                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while reading from %s %s: %s", device_info,
  62                                        device, strerror(errno));
  63
  64                         break;
  65                 }
  66
  67                 device_read_packet.len = len;
  68                 device_read_packet.priority = 0;
  69                 route(myself, &device_read_packet);
  70         }
  71 }
  72
  73 static void device_handle_read(void *data, int flags) {
  74         (void)data;
  75         (void)flags;
  76
  77         DWORD len;
  78
  79         if(!GetOverlappedResult(device_handle, &device_read_overlapped, &len, FALSE)) {
  80                 logger(DEBUG_ALWAYS, LOG_ERR, "Error getting read result from %s %s: %s", device_info,
  81                        device, strerror(errno));
  82
  83                 if(GetLastError() != ERROR_IO_INCOMPLETE) {
  84                         /* Must reset event or it will keep firing. */
  85                         ResetEvent(device_read_overlapped.hEvent);
  86                 }
  87
  88                 return;
  89         }
  90
  91         device_read_packet.len = len;
  92         device_read_packet.priority = 0;
  93         route(myself, &device_read_packet);
  94         device_issue_read();
  95 }
  96
  97 static bool setup_device(void) {
  98         HKEY key, key2;
  99         int i;
 100
 101         char regpath[1024];
 102         char adapterid[1024];
 103         char adaptername[1024];
 104         char tapname[1024];
 105         DWORD len;
 106
 107         bool found = false;
 108
 109         int err;
 110
 111         get_config_string(lookup_config(config_tree, "Device"), &device);
 112         get_config_string(lookup_config(config_tree, "Interface"), &iface);
 113
 114         if(device && iface) {
 115                 logger(DEBUG_ALWAYS, LOG_WARNING, "Warning: both Device and Interface specified, results may not be as expected");
 116         }
 117
 118         /* Open registry and look for network adapters */
 119
 120         if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, NETWORK_CONNECTIONS_KEY, 0, KEY_READ, &key)) {
 121                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to read registry: %s", winerror(GetLastError()));
 122                 return false;
 123         }
 124
 125         for(i = 0; ; i++) {
 126                 len = sizeof(adapterid);
 127
 128                 if(RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL)) {
 129                         break;
 130                 }
 131
 132                 /* Find out more about this adapter */
 133
 134                 snprintf(regpath, sizeof(regpath), "%s\\%s\\Connection", NETWORK_CONNECTIONS_KEY, adapterid);
 135
 136                 if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regpath, 0, KEY_READ, &key2)) {
 137                         continue;
 138                 }
 139
 140                 len = sizeof(adaptername);
 141                 err = RegQueryValueEx(key2, "Name", 0, 0, (LPBYTE)adaptername, &len);
 142
 143                 RegCloseKey(key2);
 144
 145                 if(err) {
 146                         continue;
 147                 }
 148
 149                 if(device) {
 150                         if(!strcmp(device, adapterid)) {
 151                                 found = true;
 152                                 break;
 153                         } else {
 154                                 continue;
 155                         }
 156                 }
 157
 158                 if(iface) {
 159                         if(!strcmp(iface, adaptername)) {
 160                                 found = true;
 161                                 break;
 162                         } else {
 163                                 continue;
 164                         }
 165                 }
 166
 167                 snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, adapterid);
 168                 device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
 169
 170                 if(device_handle != INVALID_HANDLE_VALUE) {
 171                         found = true;
 172                         break;
 173                 }
 174         }
 175
 176         RegCloseKey(key);
 177
 178         if(!found) {
 179                 logger(DEBUG_ALWAYS, LOG_ERR, "No Windows tap device found!");
 180                 return false;
 181         }
 182
 183         if(!device) {
 184                 device = xstrdup(adapterid);
 185         }
 186
 187         if(!iface) {
 188                 iface = xstrdup(adaptername);
 189         }
 190
 191         /* Try to open the corresponding tap device */
 192
 193         if(device_handle == INVALID_HANDLE_VALUE) {
 194                 snprintf(tapname, sizeof(tapname), USERMODEDEVICEDIR "%s" TAPSUFFIX, device);
 195                 device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
 196         }
 197
 198         if(device_handle == INVALID_HANDLE_VALUE) {
 199                 logger(DEBUG_ALWAYS, LOG_ERR, "%s (%s) is not a usable Windows tap device: %s", device, iface, winerror(GetLastError()));
 200                 return false;
 201         }
 202
 203         /* Get version information from tap device */
 204
 205         {
 206                 ULONG info[3] = {0};
 207                 DWORD len;
 208
 209                 if(!DeviceIoControl(device_handle, TAP_IOCTL_GET_VERSION, &info, sizeof(info), &info, sizeof(info), &len, NULL)) {
 210                         logger(DEBUG_ALWAYS, LOG_WARNING, "Could not get version information from Windows tap device %s (%s): %s", device, iface, winerror(GetLastError()));
 211                 } else {
 212                         logger(DEBUG_ALWAYS, LOG_INFO, "TAP-Windows driver version: %lu.%lu%s", info[0], info[1], info[2] ? " (DEBUG)" : "");
 213
 214                         /* Warn if using >=9.21. This is because starting from 9.21, TAP-Win32 seems to use a different, less efficient write path. */
 215                         if(info[0] == 9 && info[1] >= 21)
 216                                 logger(DEBUG_ALWAYS, LOG_WARNING,
 217                                        "You are using the newer (>= 9.0.0.21, NDIS6) series of TAP-Win32 drivers. "
 218                                        "Using these drivers with tinc is not recommended as it can result in poor performance. "
 219                                        "You might want to revert back to 9.0.0.9 instead.");
 220                 }
 221         }
 222
 223         /* Get MAC address from tap device */
 224
 225         if(!DeviceIoControl(device_handle, TAP_IOCTL_GET_MAC, mymac.x, sizeof(mymac.x), mymac.x, sizeof(mymac.x), &len, 0)) {
 226                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not get MAC address from Windows tap device %s (%s): %s", device, iface, winerror(GetLastError()));
 227                 return false;
 228         }
 229
 230         if(routing_mode == RMODE_ROUTER) {
 231                 overwrite_mac = 1;
 232         }
 233
 234         device_info = "Windows tap device";
 235
 236         logger(DEBUG_ALWAYS, LOG_INFO, "%s (%s) is a %s", device, iface, device_info);
 237
 238         device_read_overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 239         device_write_overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 240
 241         return true;
 242 }
 243
 244 static void enable_device(void) {
 245         logger(DEBUG_ALWAYS, LOG_INFO, "Enabling %s", device_info);
 246
 247         ULONG status = 1;
 248         DWORD len;
 249         DeviceIoControl(device_handle, TAP_IOCTL_SET_MEDIA_STATUS, &status, sizeof(status), &status, sizeof(status), &len, NULL);
 250
 251         /* We don't use the write event directly, but GetOverlappedResult() does, internally. */
 252
 253         io_add_event(&device_read_io, device_handle_read, NULL, device_read_overlapped.hEvent);
 254         device_issue_read();
 255 }
 256
 257 static void disable_device(void) {
 258         logger(DEBUG_ALWAYS, LOG_INFO, "Disabling %s", device_info);
 259
 260         io_del(&device_read_io);
 261
 262         ULONG status = 0;
 263         DWORD len;
 264         DeviceIoControl(device_handle, TAP_IOCTL_SET_MEDIA_STATUS, &status, sizeof(status), &status, sizeof(status), &len, NULL);
 265
 266         /* Note that we don't try to cancel ongoing I/O here - we just stop listening.
 267            This is because some TAP-Win32 drivers don't seem to handle cancellation very well,
 268            especially when combined with other events such as the computer going to sleep - cases
 269            were observed where the GetOverlappedResult() would just block indefinitely and never
 270            return in that case. */
 271 }
 272
 273 static void close_device(void) {
 274         CancelIo(device_handle);
 275
 276         /* According to MSDN, CancelIo() does not necessarily wait for the operation to complete.
 277            To prevent race conditions, make sure the operation is complete
 278            before we close the event it's referencing. */
 279
 280         DWORD len;
 281
 282         if(!GetOverlappedResult(device_handle, &device_read_overlapped, &len, TRUE) && GetLastError() != ERROR_OPERATION_ABORTED) {
 283                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not wait for %s %s read to cancel: %s", device_info, device, winerror(GetLastError()));
 284         }
 285
 286         if(device_write_packet.len > 0 && !GetOverlappedResult(device_handle, &device_write_overlapped, &len, TRUE) && GetLastError() != ERROR_OPERATION_ABORTED) {
 287                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not wait for %s %s write to cancel: %s", device_info, device, winerror(GetLastError()));
 288         }
 289
 290         device_write_packet.len = 0;
 291
 292         CloseHandle(device_read_overlapped.hEvent);
 293         CloseHandle(device_write_overlapped.hEvent);
 294
 295         CloseHandle(device_handle);
 296         device_handle = INVALID_HANDLE_VALUE;
 297
 298         free(device);
 299         device = NULL;
 300         free(iface);
 301         iface = NULL;
 302         device_info = NULL;
 303 }
 304
 305 static bool read_packet(vpn_packet_t *packet) {
 306         (void)packet;
 307         return false;
 308 }
 309
 310 static bool write_packet(vpn_packet_t *packet) {
 311         DWORD outlen;
 312
 313         logger(DEBUG_TRAFFIC, LOG_DEBUG, "Writing packet of %d bytes to %s",
 314                packet->len, device_info);
 315
 316         if(device_write_packet.len > 0) {
 317                 /* Make sure the previous write operation is finished before we start the next one;
 318                    otherwise we end up with multiple write ops referencing the same OVERLAPPED structure,
 319                    which according to MSDN is a no-no. */
 320
 321                 if(!GetOverlappedResult(device_handle, &device_write_overlapped, &outlen, FALSE)) {
 322                         if(GetLastError() != ERROR_IO_INCOMPLETE) {
 323                                 logger(DEBUG_ALWAYS, LOG_ERR, "Error completing previously queued write to %s %s: %s", device_info, device, winerror(GetLastError()));
 324                         } else {
 325                                 logger(DEBUG_TRAFFIC, LOG_ERR, "Previous overlapped write to %s %s still in progress", device_info, device);
 326                                 // drop this packet
 327                                 return true;
 328                         }
 329                 }
 330         }
 331
 332         /* Copy the packet, since the write operation might still be ongoing after we return. */
 333
 334         memcpy(&device_write_packet, packet, sizeof(*packet));
 335
 336         ResetEvent(device_write_overlapped.hEvent);
 337
 338         if(WriteFile(device_handle, DATA(&device_write_packet), device_write_packet.len, &outlen, &device_write_overlapped)) {
 339                 // Write was completed immediately.
 340                 device_write_packet.len = 0;
 341         } else if(GetLastError() != ERROR_IO_PENDING) {
 342                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while writing to %s %s: %s", device_info, device, winerror(GetLastError()));
 343                 device_write_packet.len = 0;
 344                 return false;
 345         }
 346
 347         return true;
 348 }
 349
 350 const devops_t os_devops = {
 351         .setup = setup_device,
 352         .close = close_device,
 353         .read = read_packet,
 354         .write = write_packet,
 355         .enable = enable_device,
 356         .disable = disable_device,
 357 };