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
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).
11 * All other source code is Copyright (C) James Yonan, 2003-2004,
12 * and is released under the GPL version 2 (see below).
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.
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.
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.,
27 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 /* NOTE: PCIBus is redefined in winddk.h */
34 #define PCIBus _PCIBus
35 #include <ddk/ntapi.h>
36 #include <ddk/winddk.h>
37 #include <ddk/ntddk.h>
44 #define TAP_CONTROL_CODE(request,method) \
45 CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
47 #define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE (1, METHOD_BUFFERED)
48 #define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE (2, METHOD_BUFFERED)
49 #define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE (3, METHOD_BUFFERED)
50 #define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE (4, METHOD_BUFFERED)
51 #define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
52 #define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE (6, METHOD_BUFFERED)
53 #define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE (7, METHOD_BUFFERED)
54 #define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE (8, METHOD_BUFFERED)
55 #define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE (9, METHOD_BUFFERED)
61 #define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
63 #define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
65 //======================
66 // Filesystem prefixes
67 //======================
69 #define USERMODEDEVICEDIR "\\\\.\\Global\\"
70 #define TAPSUFFIX ".tap"
73 //======================
74 // Compile time configuration
75 //======================
77 //#define DEBUG_TAP_WIN32 1
79 #define TUN_ASYNCHRONOUS_WRITES 1
81 #define TUN_BUFFER_SIZE 1560
82 #define TUN_MAX_BUFFER_COUNT 32
85 * The data member "buffer" must be the first element in the tun_buffer
86 * structure. See the function, tap_win32_free_buffer.
88 typedef struct tun_buffer_s
{
89 unsigned char buffer
[TUN_BUFFER_SIZE
];
90 unsigned long read_size
;
91 struct tun_buffer_s
* next
;
94 typedef struct tap_win32_overlapped
{
98 HANDLE output_queue_semaphore
;
99 HANDLE free_list_semaphore
;
100 CRITICAL_SECTION output_queue_cs
;
101 CRITICAL_SECTION free_list_cs
;
102 OVERLAPPED read_overlapped
;
103 OVERLAPPED write_overlapped
;
104 tun_buffer_t buffers
[TUN_MAX_BUFFER_COUNT
];
105 tun_buffer_t
* free_list
;
106 tun_buffer_t
* output_queue_front
;
107 tun_buffer_t
* output_queue_back
;
108 } tap_win32_overlapped_t
;
110 static tap_win32_overlapped_t tap_overlapped
;
112 static tun_buffer_t
* get_buffer_from_free_list(tap_win32_overlapped_t
* const overlapped
)
114 tun_buffer_t
* buffer
= NULL
;
115 WaitForSingleObject(overlapped
->free_list_semaphore
, INFINITE
);
116 EnterCriticalSection(&overlapped
->free_list_cs
);
117 buffer
= overlapped
->free_list
;
118 // assert(buffer != NULL);
119 overlapped
->free_list
= buffer
->next
;
120 LeaveCriticalSection(&overlapped
->free_list_cs
);
125 static void put_buffer_on_free_list(tap_win32_overlapped_t
* const overlapped
, tun_buffer_t
* const buffer
)
127 EnterCriticalSection(&overlapped
->free_list_cs
);
128 buffer
->next
= overlapped
->free_list
;
129 overlapped
->free_list
= buffer
;
130 LeaveCriticalSection(&overlapped
->free_list_cs
);
131 ReleaseSemaphore(overlapped
->free_list_semaphore
, 1, NULL
);
134 static tun_buffer_t
* get_buffer_from_output_queue(tap_win32_overlapped_t
* const overlapped
, const int block
)
136 tun_buffer_t
* buffer
= NULL
;
137 DWORD result
, timeout
= block
? INFINITE
: 0L;
140 result
= WaitForSingleObject(overlapped
->output_queue_semaphore
, timeout
);
144 // The semaphore object was signaled.
146 EnterCriticalSection(&overlapped
->output_queue_cs
);
148 buffer
= overlapped
->output_queue_front
;
149 overlapped
->output_queue_front
= buffer
->next
;
151 if(overlapped
->output_queue_front
== NULL
) {
152 overlapped
->output_queue_back
= NULL
;
155 LeaveCriticalSection(&overlapped
->output_queue_cs
);
158 // Semaphore was nonsignaled, so a time-out occurred.
160 // Cannot open another window.
167 static tun_buffer_t
* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t
* const overlapped
)
169 return get_buffer_from_output_queue(overlapped
, 0);
172 static void put_buffer_on_output_queue(tap_win32_overlapped_t
* const overlapped
, tun_buffer_t
* const buffer
)
174 EnterCriticalSection(&overlapped
->output_queue_cs
);
176 if(overlapped
->output_queue_front
== NULL
&& overlapped
->output_queue_back
== NULL
) {
177 overlapped
->output_queue_front
= overlapped
->output_queue_back
= buffer
;
180 overlapped
->output_queue_back
->next
= buffer
;
181 overlapped
->output_queue_back
= buffer
;
184 LeaveCriticalSection(&overlapped
->output_queue_cs
);
186 ReleaseSemaphore(overlapped
->output_queue_semaphore
, 1, NULL
);
190 static int is_tap_win32_dev(const char *guid
)
197 status
= RegOpenKeyEx(
204 if (status
!= ERROR_SUCCESS
) {
210 char unit_string
[256];
212 char component_id_string
[] = "ComponentId";
213 char component_id
[256];
214 char net_cfg_instance_id_string
[] = "NetCfgInstanceId";
215 char net_cfg_instance_id
[256];
218 len
= sizeof (enum_name
);
219 status
= RegEnumKeyEx(
229 if (status
== ERROR_NO_MORE_ITEMS
)
231 else if (status
!= ERROR_SUCCESS
) {
235 snprintf (unit_string
, sizeof(unit_string
), "%s\\%s",
236 ADAPTER_KEY
, enum_name
);
238 status
= RegOpenKeyEx(
245 if (status
!= ERROR_SUCCESS
) {
248 len
= sizeof (component_id
);
249 status
= RegQueryValueEx(
257 if (!(status
!= ERROR_SUCCESS
|| data_type
!= REG_SZ
)) {
258 len
= sizeof (net_cfg_instance_id
);
259 status
= RegQueryValueEx(
261 net_cfg_instance_id_string
,
267 if (status
== ERROR_SUCCESS
&& data_type
== REG_SZ
) {
268 if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
269 !strcmp (net_cfg_instance_id
, guid
)) {
270 RegCloseKey (unit_key
);
271 RegCloseKey (netcard_key
);
276 RegCloseKey (unit_key
);
281 RegCloseKey (netcard_key
);
285 static int get_device_guid(
289 int actual_name_size
)
292 HKEY control_net_key
;
297 status
= RegOpenKeyEx(
299 NETWORK_CONNECTIONS_KEY
,
304 if (status
!= ERROR_SUCCESS
) {
311 char connection_string
[256];
315 const char name_string
[] = "Name";
317 len
= sizeof (enum_name
);
318 status
= RegEnumKeyEx(
328 if (status
== ERROR_NO_MORE_ITEMS
)
330 else if (status
!= ERROR_SUCCESS
) {
334 snprintf(connection_string
,
335 sizeof(connection_string
),
336 "%s\\%s\\Connection",
337 NETWORK_CONNECTIONS_KEY
, enum_name
);
339 status
= RegOpenKeyEx(
346 if (status
== ERROR_SUCCESS
) {
347 len
= sizeof (name_data
);
348 status
= RegQueryValueEx(
356 if (status
!= ERROR_SUCCESS
|| name_type
!= REG_SZ
) {
360 if (is_tap_win32_dev(enum_name
)) {
361 snprintf(name
, name_size
, "%s", enum_name
);
363 if (strcmp(actual_name
, "") != 0) {
364 if (strcmp(name_data
, actual_name
) != 0) {
365 RegCloseKey (connection_key
);
371 snprintf(actual_name
, actual_name_size
, "%s", name_data
);
378 RegCloseKey (connection_key
);
383 RegCloseKey (control_net_key
);
391 static int tap_win32_set_status(HANDLE handle
, int status
)
393 unsigned long len
= 0;
395 return DeviceIoControl(handle
, TAP_IOCTL_SET_MEDIA_STATUS
,
396 &status
, sizeof (status
),
397 &status
, sizeof (status
), &len
, NULL
);
400 static void tap_win32_overlapped_init(tap_win32_overlapped_t
* const overlapped
, const HANDLE handle
)
402 overlapped
->handle
= handle
;
404 overlapped
->read_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
405 overlapped
->write_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
407 overlapped
->read_overlapped
.Offset
= 0;
408 overlapped
->read_overlapped
.OffsetHigh
= 0;
409 overlapped
->read_overlapped
.hEvent
= overlapped
->read_event
;
411 overlapped
->write_overlapped
.Offset
= 0;
412 overlapped
->write_overlapped
.OffsetHigh
= 0;
413 overlapped
->write_overlapped
.hEvent
= overlapped
->write_event
;
415 InitializeCriticalSection(&overlapped
->output_queue_cs
);
416 InitializeCriticalSection(&overlapped
->free_list_cs
);
418 overlapped
->output_queue_semaphore
= CreateSemaphore(
419 NULL
, // default security attributes
421 TUN_MAX_BUFFER_COUNT
, // maximum count
422 NULL
); // unnamed semaphore
424 if(!overlapped
->output_queue_semaphore
) {
425 fprintf(stderr
, "error creating output queue semaphore!\n");
428 overlapped
->free_list_semaphore
= CreateSemaphore(
429 NULL
, // default security attributes
430 TUN_MAX_BUFFER_COUNT
, // initial count
431 TUN_MAX_BUFFER_COUNT
, // maximum count
432 NULL
); // unnamed semaphore
434 if(!overlapped
->free_list_semaphore
) {
435 fprintf(stderr
, "error creating free list semaphore!\n");
438 overlapped
->free_list
= overlapped
->output_queue_front
= overlapped
->output_queue_back
= NULL
;
442 for(index
= 0; index
< TUN_MAX_BUFFER_COUNT
; index
++) {
443 tun_buffer_t
* element
= &overlapped
->buffers
[index
];
444 element
->next
= overlapped
->free_list
;
445 overlapped
->free_list
= element
;
450 static int tap_win32_write(tap_win32_overlapped_t
*overlapped
,
451 const void *buffer
, unsigned long size
)
453 unsigned long write_size
;
457 result
= GetOverlappedResult( overlapped
->handle
, &overlapped
->write_overlapped
,
460 if (!result
&& GetLastError() == ERROR_IO_INCOMPLETE
)
461 WaitForSingleObject(overlapped
->write_event
, INFINITE
);
463 result
= WriteFile(overlapped
->handle
, buffer
, size
,
464 &write_size
, &overlapped
->write_overlapped
);
467 switch (error
= GetLastError())
469 case ERROR_IO_PENDING
:
470 #ifndef TUN_ASYNCHRONOUS_WRITES
471 WaitForSingleObject(overlapped
->write_event
, INFINITE
);
482 static DWORD WINAPI
tap_win32_thread_entry(LPVOID param
)
484 tap_win32_overlapped_t
*overlapped
= (tap_win32_overlapped_t
*)param
;
485 unsigned long read_size
;
488 tun_buffer_t
* buffer
= get_buffer_from_free_list(overlapped
);
492 result
= ReadFile(overlapped
->handle
,
494 sizeof(buffer
->buffer
),
496 &overlapped
->read_overlapped
);
498 dwError
= GetLastError();
499 if (dwError
== ERROR_IO_PENDING
) {
500 WaitForSingleObject(overlapped
->read_event
, INFINITE
);
501 result
= GetOverlappedResult( overlapped
->handle
, &overlapped
->read_overlapped
,
506 dwError
= GetLastError();
507 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
508 NULL
, dwError
, MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),
509 (LPTSTR
) & lpBuffer
, 0, NULL
);
510 fprintf(stderr
, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError
, lpBuffer
);
511 LocalFree( lpBuffer
);
517 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
518 NULL
, dwError
, MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),
519 (LPTSTR
) & lpBuffer
, 0, NULL
);
520 fprintf(stderr
, "Tap-Win32: Error ReadFile %d - %s\n", dwError
, lpBuffer
);
521 LocalFree( lpBuffer
);
527 buffer
->read_size
= read_size
;
528 put_buffer_on_output_queue(overlapped
, buffer
);
529 buffer
= get_buffer_from_free_list(overlapped
);
536 static int tap_win32_read(tap_win32_overlapped_t
*overlapped
,
537 uint8_t **pbuf
, int max_size
)
541 tun_buffer_t
* buffer
= get_buffer_from_output_queue_immediate(overlapped
);
544 *pbuf
= buffer
->buffer
;
545 size
= (int)buffer
->read_size
;
546 if(size
> max_size
) {
554 static void tap_win32_free_buffer(tap_win32_overlapped_t
*overlapped
,
557 tun_buffer_t
* buffer
= (tun_buffer_t
*)pbuf
;
558 put_buffer_on_free_list(overlapped
, buffer
);
561 static int tap_win32_open(tap_win32_overlapped_t
**phandle
,
562 const char *prefered_name
)
564 char device_path
[256];
565 char device_guid
[0x100];
569 char name_buffer
[0x100] = {0, };
579 if (prefered_name
!= NULL
)
580 snprintf(name_buffer
, sizeof(name_buffer
), "%s", prefered_name
);
582 rc
= get_device_guid(device_guid
, sizeof(device_guid
), name_buffer
, sizeof(name_buffer
));
586 snprintf (device_path
, sizeof(device_path
), "%s%s%s",
591 handle
= CreateFile (
593 GENERIC_READ
| GENERIC_WRITE
,
597 FILE_ATTRIBUTE_SYSTEM
| FILE_FLAG_OVERLAPPED
,
600 if (handle
== INVALID_HANDLE_VALUE
) {
604 bret
= DeviceIoControl(handle
, TAP_IOCTL_GET_VERSION
,
605 &version
, sizeof (version
),
606 &version
, sizeof (version
), &version_len
, NULL
);
613 if (!tap_win32_set_status(handle
, TRUE
)) {
617 tap_win32_overlapped_init(&tap_overlapped
, handle
);
619 *phandle
= &tap_overlapped
;
621 hThread
= CreateThread(NULL
, 0, tap_win32_thread_entry
,
622 (LPVOID
)&tap_overlapped
, 0, &idThread
);
623 SetThreadPriority(hThread
,THREAD_PRIORITY_TIME_CRITICAL
);
628 /********************************************/
630 typedef struct TAPState
{
632 tap_win32_overlapped_t
*handle
;
635 static TAPState
*tap_win32_state
= NULL
;
637 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
639 TAPState
*s
= opaque
;
641 tap_win32_write(s
->handle
, buf
, size
);
644 /* XXX: horrible, suppress this by using proper thread signaling */
645 void tap_win32_poll(void)
647 TAPState
*s
= tap_win32_state
;
655 size
= tap_win32_read(s
->handle
, &buf
, max_size
);
657 qemu_send_packet(s
->vc
, buf
, size
);
658 tap_win32_free_buffer(s
->handle
, buf
);
662 int tap_win32_init(VLANState
*vlan
, const char *ifname
)
666 s
= qemu_mallocz(sizeof(TAPState
));
669 if (tap_win32_open(&s
->handle
, ifname
) < 0) {
670 printf("tap: Could not open '%s'\n", ifname
);
674 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
676 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
677 "tap: ifname=%s", ifname
);