blob: ba93355a741b59928712d0d5c293242aedb81468 [file] [log] [blame]
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -08001/*
2 * TAP-Win32 -- A kernel driver to provide virtual tap device functionality
3 * on Windows. Originally derived from the CIPE-Win32
4 * project by Damion K. Wilson, with extensive modifications by
5 * James Yonan.
6 *
7 * All source code which derives from the CIPE-Win32 project is
8 * Copyright (C) Damion K. Wilson, 2003, and is released under the
9 * GPL version 2 (see below).
10 *
11 * All other source code is Copyright (C) James Yonan, 2003-2004,
12 * and is released under the GPL version 2 (see below).
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program (see the file COPYING included with this
26 * distribution); if not, write to the Free Software Foundation, Inc.,
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -070027 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080028 */
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -070029#include "qemu-common.h"
30#include "net.h"
31#include "sysemu.h"
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080032#include <stdio.h>
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080033#include <windows.h>
34
35/* NOTE: PCIBus is redefined in winddk.h */
36#define PCIBus _PCIBus
37#include <ddk/ntapi.h>
38#include <ddk/winddk.h>
39#include <ddk/ntddk.h>
40#undef PCIBus
41
42//=============
43// TAP IOCTLs
44//=============
45
46#define TAP_CONTROL_CODE(request,method) \
47 CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
48
49#define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE (1, METHOD_BUFFERED)
50#define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE (2, METHOD_BUFFERED)
51#define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE (3, METHOD_BUFFERED)
52#define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE (4, METHOD_BUFFERED)
53#define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
54#define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE (6, METHOD_BUFFERED)
55#define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE (7, METHOD_BUFFERED)
56#define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE (8, METHOD_BUFFERED)
57#define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE (9, METHOD_BUFFERED)
58
59//=================
60// Registry keys
61//=================
62
63#define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
64
65#define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
66
67//======================
68// Filesystem prefixes
69//======================
70
71#define USERMODEDEVICEDIR "\\\\.\\Global\\"
72#define TAPSUFFIX ".tap"
73
74
75//======================
76// Compile time configuration
77//======================
78
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -070079//#define DEBUG_TAP_WIN32
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -080080
81#define TUN_ASYNCHRONOUS_WRITES 1
82
83#define TUN_BUFFER_SIZE 1560
84#define TUN_MAX_BUFFER_COUNT 32
85
86/*
87 * The data member "buffer" must be the first element in the tun_buffer
88 * structure. See the function, tap_win32_free_buffer.
89 */
90typedef struct tun_buffer_s {
91 unsigned char buffer [TUN_BUFFER_SIZE];
92 unsigned long read_size;
93 struct tun_buffer_s* next;
94} tun_buffer_t;
95
96typedef struct tap_win32_overlapped {
97 HANDLE handle;
98 HANDLE read_event;
99 HANDLE write_event;
100 HANDLE output_queue_semaphore;
101 HANDLE free_list_semaphore;
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700102 HANDLE tap_semaphore;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800103 CRITICAL_SECTION output_queue_cs;
104 CRITICAL_SECTION free_list_cs;
105 OVERLAPPED read_overlapped;
106 OVERLAPPED write_overlapped;
107 tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
108 tun_buffer_t* free_list;
109 tun_buffer_t* output_queue_front;
110 tun_buffer_t* output_queue_back;
111} tap_win32_overlapped_t;
112
113static tap_win32_overlapped_t tap_overlapped;
114
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700115static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800116{
117 tun_buffer_t* buffer = NULL;
118 WaitForSingleObject(overlapped->free_list_semaphore, INFINITE);
119 EnterCriticalSection(&overlapped->free_list_cs);
120 buffer = overlapped->free_list;
121// assert(buffer != NULL);
122 overlapped->free_list = buffer->next;
123 LeaveCriticalSection(&overlapped->free_list_cs);
124 buffer->next = NULL;
125 return buffer;
126}
127
128static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
129{
130 EnterCriticalSection(&overlapped->free_list_cs);
131 buffer->next = overlapped->free_list;
132 overlapped->free_list = buffer;
133 LeaveCriticalSection(&overlapped->free_list_cs);
134 ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL);
135}
136
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700137static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800138{
139 tun_buffer_t* buffer = NULL;
140 DWORD result, timeout = block ? INFINITE : 0L;
141
142 // Non-blocking call
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700143 result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800144
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700145 switch (result)
146 {
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800147 // The semaphore object was signaled.
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700148 case WAIT_OBJECT_0:
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800149 EnterCriticalSection(&overlapped->output_queue_cs);
150
151 buffer = overlapped->output_queue_front;
152 overlapped->output_queue_front = buffer->next;
153
154 if(overlapped->output_queue_front == NULL) {
155 overlapped->output_queue_back = NULL;
156 }
157
158 LeaveCriticalSection(&overlapped->output_queue_cs);
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700159 break;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800160
161 // Semaphore was nonsignaled, so a time-out occurred.
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700162 case WAIT_TIMEOUT:
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800163 // Cannot open another window.
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700164 break;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800165 }
166
167 return buffer;
168}
169
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700170static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800171{
172 return get_buffer_from_output_queue(overlapped, 0);
173}
174
175static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
176{
177 EnterCriticalSection(&overlapped->output_queue_cs);
178
179 if(overlapped->output_queue_front == NULL && overlapped->output_queue_back == NULL) {
180 overlapped->output_queue_front = overlapped->output_queue_back = buffer;
181 } else {
182 buffer->next = NULL;
183 overlapped->output_queue_back->next = buffer;
184 overlapped->output_queue_back = buffer;
185 }
186
187 LeaveCriticalSection(&overlapped->output_queue_cs);
188
189 ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
190}
191
192
193static int is_tap_win32_dev(const char *guid)
194{
195 HKEY netcard_key;
196 LONG status;
197 DWORD len;
198 int i = 0;
199
200 status = RegOpenKeyEx(
201 HKEY_LOCAL_MACHINE,
202 ADAPTER_KEY,
203 0,
204 KEY_READ,
205 &netcard_key);
206
207 if (status != ERROR_SUCCESS) {
208 return FALSE;
209 }
210
211 for (;;) {
212 char enum_name[256];
213 char unit_string[256];
214 HKEY unit_key;
215 char component_id_string[] = "ComponentId";
216 char component_id[256];
217 char net_cfg_instance_id_string[] = "NetCfgInstanceId";
218 char net_cfg_instance_id[256];
219 DWORD data_type;
220
221 len = sizeof (enum_name);
222 status = RegEnumKeyEx(
223 netcard_key,
224 i,
225 enum_name,
226 &len,
227 NULL,
228 NULL,
229 NULL,
230 NULL);
231
232 if (status == ERROR_NO_MORE_ITEMS)
233 break;
234 else if (status != ERROR_SUCCESS) {
235 return FALSE;
236 }
237
238 snprintf (unit_string, sizeof(unit_string), "%s\\%s",
239 ADAPTER_KEY, enum_name);
240
241 status = RegOpenKeyEx(
242 HKEY_LOCAL_MACHINE,
243 unit_string,
244 0,
245 KEY_READ,
246 &unit_key);
247
248 if (status != ERROR_SUCCESS) {
249 return FALSE;
250 } else {
251 len = sizeof (component_id);
252 status = RegQueryValueEx(
253 unit_key,
254 component_id_string,
255 NULL,
256 &data_type,
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700257 (LPBYTE)component_id,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800258 &len);
259
260 if (!(status != ERROR_SUCCESS || data_type != REG_SZ)) {
261 len = sizeof (net_cfg_instance_id);
262 status = RegQueryValueEx(
263 unit_key,
264 net_cfg_instance_id_string,
265 NULL,
266 &data_type,
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700267 (LPBYTE)net_cfg_instance_id,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800268 &len);
269
270 if (status == ERROR_SUCCESS && data_type == REG_SZ) {
271 if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
272 !strcmp (net_cfg_instance_id, guid)) {
273 RegCloseKey (unit_key);
274 RegCloseKey (netcard_key);
275 return TRUE;
276 }
277 }
278 }
279 RegCloseKey (unit_key);
280 }
281 ++i;
282 }
283
284 RegCloseKey (netcard_key);
285 return FALSE;
286}
287
288static int get_device_guid(
289 char *name,
290 int name_size,
291 char *actual_name,
292 int actual_name_size)
293{
294 LONG status;
295 HKEY control_net_key;
296 DWORD len;
297 int i = 0;
298 int stop = 0;
299
300 status = RegOpenKeyEx(
301 HKEY_LOCAL_MACHINE,
302 NETWORK_CONNECTIONS_KEY,
303 0,
304 KEY_READ,
305 &control_net_key);
306
307 if (status != ERROR_SUCCESS) {
308 return -1;
309 }
310
311 while (!stop)
312 {
313 char enum_name[256];
314 char connection_string[256];
315 HKEY connection_key;
316 char name_data[256];
317 DWORD name_type;
318 const char name_string[] = "Name";
319
320 len = sizeof (enum_name);
321 status = RegEnumKeyEx(
322 control_net_key,
323 i,
324 enum_name,
325 &len,
326 NULL,
327 NULL,
328 NULL,
329 NULL);
330
331 if (status == ERROR_NO_MORE_ITEMS)
332 break;
333 else if (status != ERROR_SUCCESS) {
334 return -1;
335 }
336
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700337 snprintf(connection_string,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800338 sizeof(connection_string),
339 "%s\\%s\\Connection",
340 NETWORK_CONNECTIONS_KEY, enum_name);
341
342 status = RegOpenKeyEx(
343 HKEY_LOCAL_MACHINE,
344 connection_string,
345 0,
346 KEY_READ,
347 &connection_key);
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700348
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800349 if (status == ERROR_SUCCESS) {
350 len = sizeof (name_data);
351 status = RegQueryValueEx(
352 connection_key,
353 name_string,
354 NULL,
355 &name_type,
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700356 (LPBYTE)name_data,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800357 &len);
358
359 if (status != ERROR_SUCCESS || name_type != REG_SZ) {
360 return -1;
361 }
362 else {
363 if (is_tap_win32_dev(enum_name)) {
364 snprintf(name, name_size, "%s", enum_name);
365 if (actual_name) {
366 if (strcmp(actual_name, "") != 0) {
367 if (strcmp(name_data, actual_name) != 0) {
368 RegCloseKey (connection_key);
369 ++i;
370 continue;
371 }
372 }
373 else {
374 snprintf(actual_name, actual_name_size, "%s", name_data);
375 }
376 }
377 stop = 1;
378 }
379 }
380
381 RegCloseKey (connection_key);
382 }
383 ++i;
384 }
385
386 RegCloseKey (control_net_key);
387
388 if (stop == 0)
389 return -1;
390
391 return 0;
392}
393
394static int tap_win32_set_status(HANDLE handle, int status)
395{
396 unsigned long len = 0;
397
398 return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
399 &status, sizeof (status),
400 &status, sizeof (status), &len, NULL);
401}
402
403static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
404{
405 overlapped->handle = handle;
406
407 overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
408 overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);
409
410 overlapped->read_overlapped.Offset = 0;
411 overlapped->read_overlapped.OffsetHigh = 0;
412 overlapped->read_overlapped.hEvent = overlapped->read_event;
413
414 overlapped->write_overlapped.Offset = 0;
415 overlapped->write_overlapped.OffsetHigh = 0;
416 overlapped->write_overlapped.hEvent = overlapped->write_event;
417
418 InitializeCriticalSection(&overlapped->output_queue_cs);
419 InitializeCriticalSection(&overlapped->free_list_cs);
420
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700421 overlapped->output_queue_semaphore = CreateSemaphore(
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800422 NULL, // default security attributes
423 0, // initial count
424 TUN_MAX_BUFFER_COUNT, // maximum count
425 NULL); // unnamed semaphore
426
427 if(!overlapped->output_queue_semaphore) {
428 fprintf(stderr, "error creating output queue semaphore!\n");
429 }
430
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700431 overlapped->free_list_semaphore = CreateSemaphore(
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800432 NULL, // default security attributes
433 TUN_MAX_BUFFER_COUNT, // initial count
434 TUN_MAX_BUFFER_COUNT, // maximum count
435 NULL); // unnamed semaphore
436
437 if(!overlapped->free_list_semaphore) {
438 fprintf(stderr, "error creating free list semaphore!\n");
439 }
440
441 overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;
442
443 {
444 unsigned index;
445 for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
446 tun_buffer_t* element = &overlapped->buffers[index];
447 element->next = overlapped->free_list;
448 overlapped->free_list = element;
449 }
450 }
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700451 /* To count buffers, initially no-signal. */
452 overlapped->tap_semaphore = CreateSemaphore(NULL, 0, TUN_MAX_BUFFER_COUNT, NULL);
453 if(!overlapped->tap_semaphore)
454 fprintf(stderr, "error creating tap_semaphore.\n");
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800455}
456
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700457static int tap_win32_write(tap_win32_overlapped_t *overlapped,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800458 const void *buffer, unsigned long size)
459{
460 unsigned long write_size;
461 BOOL result;
462 DWORD error;
463
464 result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
465 &write_size, FALSE);
466
467 if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
468 WaitForSingleObject(overlapped->write_event, INFINITE);
469
470 result = WriteFile(overlapped->handle, buffer, size,
471 &write_size, &overlapped->write_overlapped);
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700472
473 if (!result) {
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800474 switch (error = GetLastError())
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700475 {
476 case ERROR_IO_PENDING:
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800477#ifndef TUN_ASYNCHRONOUS_WRITES
478 WaitForSingleObject(overlapped->write_event, INFINITE);
479#endif
480 break;
481 default:
482 return -1;
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700483 }
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800484 }
485
486 return 0;
487}
488
489static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
490{
491 tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
492 unsigned long read_size;
493 BOOL result;
494 DWORD dwError;
495 tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);
496
497
498 for (;;) {
499 result = ReadFile(overlapped->handle,
500 buffer->buffer,
501 sizeof(buffer->buffer),
502 &read_size,
503 &overlapped->read_overlapped);
504 if (!result) {
505 dwError = GetLastError();
506 if (dwError == ERROR_IO_PENDING) {
507 WaitForSingleObject(overlapped->read_event, INFINITE);
508 result = GetOverlappedResult( overlapped->handle, &overlapped->read_overlapped,
509 &read_size, FALSE);
510 if (!result) {
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700511#ifdef DEBUG_TAP_WIN32
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800512 LPVOID lpBuffer;
513 dwError = GetLastError();
514 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
515 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
516 (LPTSTR) & lpBuffer, 0, NULL );
517 fprintf(stderr, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError, lpBuffer);
518 LocalFree( lpBuffer );
519#endif
520 }
521 } else {
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700522#ifdef DEBUG_TAP_WIN32
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800523 LPVOID lpBuffer;
524 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
525 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
526 (LPTSTR) & lpBuffer, 0, NULL );
527 fprintf(stderr, "Tap-Win32: Error ReadFile %d - %s\n", dwError, lpBuffer);
528 LocalFree( lpBuffer );
529#endif
530 }
531 }
532
533 if(read_size > 0) {
534 buffer->read_size = read_size;
535 put_buffer_on_output_queue(overlapped, buffer);
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700536 ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800537 buffer = get_buffer_from_free_list(overlapped);
538 }
539 }
540
541 return 0;
542}
543
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700544static int tap_win32_read(tap_win32_overlapped_t *overlapped,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800545 uint8_t **pbuf, int max_size)
546{
547 int size = 0;
548
549 tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
550
551 if(buffer != NULL) {
552 *pbuf = buffer->buffer;
553 size = (int)buffer->read_size;
554 if(size > max_size) {
555 size = max_size;
556 }
557 }
558
559 return size;
560}
561
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700562static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
563 uint8_t *pbuf)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800564{
565 tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
566 put_buffer_on_free_list(overlapped, buffer);
567}
568
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700569static int tap_win32_open(tap_win32_overlapped_t **phandle,
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800570 const char *prefered_name)
571{
572 char device_path[256];
573 char device_guid[0x100];
574 int rc;
575 HANDLE handle;
576 BOOL bret;
577 char name_buffer[0x100] = {0, };
578 struct {
579 unsigned long major;
580 unsigned long minor;
581 unsigned long debug;
582 } version;
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700583 DWORD version_len;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800584 DWORD idThread;
585 HANDLE hThread;
586
587 if (prefered_name != NULL)
588 snprintf(name_buffer, sizeof(name_buffer), "%s", prefered_name);
589
590 rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
591 if (rc)
592 return -1;
593
594 snprintf (device_path, sizeof(device_path), "%s%s%s",
595 USERMODEDEVICEDIR,
596 device_guid,
597 TAPSUFFIX);
598
599 handle = CreateFile (
600 device_path,
601 GENERIC_READ | GENERIC_WRITE,
602 0,
603 0,
604 OPEN_EXISTING,
605 FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
606 0 );
607
608 if (handle == INVALID_HANDLE_VALUE) {
609 return -1;
610 }
611
612 bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
613 &version, sizeof (version),
614 &version, sizeof (version), &version_len, NULL);
615
616 if (bret == FALSE) {
617 CloseHandle(handle);
618 return -1;
619 }
620
621 if (!tap_win32_set_status(handle, TRUE)) {
622 return -1;
623 }
624
625 tap_win32_overlapped_init(&tap_overlapped, handle);
626
627 *phandle = &tap_overlapped;
628
629 hThread = CreateThread(NULL, 0, tap_win32_thread_entry,
630 (LPVOID)&tap_overlapped, 0, &idThread);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800631 return 0;
632}
633
634/********************************************/
635
636 typedef struct TAPState {
637 VLANClientState *vc;
638 tap_win32_overlapped_t *handle;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800639 } TAPState;
640
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700641static void tap_cleanup(VLANClientState *vc)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800642{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700643 TAPState *s = vc->opaque;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800644
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700645 qemu_del_wait_object(s->handle->tap_semaphore, NULL, NULL);
646
647 /* FIXME: need to kill thread and close file handle:
648 tap_win32_close(s);
649 */
650 qemu_free(s);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800651}
652
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700653static ssize_t tap_receive(VLANClientState *vc, const uint8_t *buf, size_t size)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800654{
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700655 TAPState *s = vc->opaque;
656
657 return tap_win32_write(s->handle, buf, size);
658}
659
660static void tap_win32_send(void *opaque)
661{
662 TAPState *s = opaque;
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800663 uint8_t *buf;
664 int max_size = 4096;
665 int size;
666
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800667 size = tap_win32_read(s->handle, &buf, max_size);
668 if (size > 0) {
669 qemu_send_packet(s->vc, buf, size);
670 tap_win32_free_buffer(s->handle, buf);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800671 }
672}
673
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700674int tap_win32_init(VLANState *vlan, const char *model,
675 const char *name, const char *ifname)
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800676{
677 TAPState *s;
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700678
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800679 s = qemu_mallocz(sizeof(TAPState));
680 if (!s)
681 return -1;
682 if (tap_win32_open(&s->handle, ifname) < 0) {
683 printf("tap: Could not open '%s'\n", ifname);
684 return -1;
685 }
686
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700687 s->vc = qemu_new_vlan_client(vlan, model, name, NULL, tap_receive,
688 NULL, tap_cleanup, s);
689
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800690 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
691 "tap: ifname=%s", ifname);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800692
David 'Digit' Turner5d8f37a2009-09-14 14:32:27 -0700693 qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
The Android Open Source Project8b23a6c2009-03-03 19:30:32 -0800694 return 0;
695}