ia64/xen-unstable

view tools/ioemu/tap-win32.c @ 15841:c5f735271e22

[IA64] Foreign p2m: Fix vti domain builder.

It should set arch_domain::convmem_end.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Alex Williamson <alex.williamson@hp.com>
date Thu Sep 06 13:48:43 2007 -0600 (2007-09-06)
parents 00618037d37d
children
line source
1 /*
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.,
27 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 */
29 #include "vl.h"
30 #include <stdio.h>
31 #include <windows.h>
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>
38 #undef PCIBus
40 //=============
41 // TAP IOCTLs
42 //=============
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)
57 //=================
58 // Registry keys
59 //=================
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
84 /*
85 * The data member "buffer" must be the first element in the tun_buffer
86 * structure. See the function, tap_win32_free_buffer.
87 */
88 typedef struct tun_buffer_s {
89 unsigned char buffer [TUN_BUFFER_SIZE];
90 unsigned long read_size;
91 struct tun_buffer_s* next;
92 } tun_buffer_t;
94 typedef struct tap_win32_overlapped {
95 HANDLE handle;
96 HANDLE read_event;
97 HANDLE write_event;
98 HANDLE output_queue_semaphore;
99 HANDLE free_list_semaphore;
100 HANDLE tap_semaphore;
101 CRITICAL_SECTION output_queue_cs;
102 CRITICAL_SECTION free_list_cs;
103 OVERLAPPED read_overlapped;
104 OVERLAPPED write_overlapped;
105 tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
106 tun_buffer_t* free_list;
107 tun_buffer_t* output_queue_front;
108 tun_buffer_t* output_queue_back;
109 } tap_win32_overlapped_t;
111 static tap_win32_overlapped_t tap_overlapped;
113 static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
114 {
115 tun_buffer_t* buffer = NULL;
116 WaitForSingleObject(overlapped->free_list_semaphore, INFINITE);
117 EnterCriticalSection(&overlapped->free_list_cs);
118 buffer = overlapped->free_list;
119 // assert(buffer != NULL);
120 overlapped->free_list = buffer->next;
121 LeaveCriticalSection(&overlapped->free_list_cs);
122 buffer->next = NULL;
123 return buffer;
124 }
126 static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
127 {
128 EnterCriticalSection(&overlapped->free_list_cs);
129 buffer->next = overlapped->free_list;
130 overlapped->free_list = buffer;
131 LeaveCriticalSection(&overlapped->free_list_cs);
132 ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL);
133 }
135 static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
136 {
137 tun_buffer_t* buffer = NULL;
138 DWORD result, timeout = block ? INFINITE : 0L;
140 // Non-blocking call
141 result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);
143 switch (result)
144 {
145 // The semaphore object was signaled.
146 case WAIT_OBJECT_0:
147 EnterCriticalSection(&overlapped->output_queue_cs);
149 buffer = overlapped->output_queue_front;
150 overlapped->output_queue_front = buffer->next;
152 if(overlapped->output_queue_front == NULL) {
153 overlapped->output_queue_back = NULL;
154 }
156 LeaveCriticalSection(&overlapped->output_queue_cs);
157 break;
159 // Semaphore was nonsignaled, so a time-out occurred.
160 case WAIT_TIMEOUT:
161 // Cannot open another window.
162 break;
163 }
165 return buffer;
166 }
168 static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
169 {
170 return get_buffer_from_output_queue(overlapped, 0);
171 }
173 static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
174 {
175 EnterCriticalSection(&overlapped->output_queue_cs);
177 if(overlapped->output_queue_front == NULL && overlapped->output_queue_back == NULL) {
178 overlapped->output_queue_front = overlapped->output_queue_back = buffer;
179 } else {
180 buffer->next = NULL;
181 overlapped->output_queue_back->next = buffer;
182 overlapped->output_queue_back = buffer;
183 }
185 LeaveCriticalSection(&overlapped->output_queue_cs);
187 ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
188 }
191 static int is_tap_win32_dev(const char *guid)
192 {
193 HKEY netcard_key;
194 LONG status;
195 DWORD len;
196 int i = 0;
198 status = RegOpenKeyEx(
199 HKEY_LOCAL_MACHINE,
200 ADAPTER_KEY,
201 0,
202 KEY_READ,
203 &netcard_key);
205 if (status != ERROR_SUCCESS) {
206 return FALSE;
207 }
209 for (;;) {
210 char enum_name[256];
211 char unit_string[256];
212 HKEY unit_key;
213 char component_id_string[] = "ComponentId";
214 char component_id[256];
215 char net_cfg_instance_id_string[] = "NetCfgInstanceId";
216 char net_cfg_instance_id[256];
217 DWORD data_type;
219 len = sizeof (enum_name);
220 status = RegEnumKeyEx(
221 netcard_key,
222 i,
223 enum_name,
224 &len,
225 NULL,
226 NULL,
227 NULL,
228 NULL);
230 if (status == ERROR_NO_MORE_ITEMS)
231 break;
232 else if (status != ERROR_SUCCESS) {
233 return FALSE;
234 }
236 snprintf (unit_string, sizeof(unit_string), "%s\\%s",
237 ADAPTER_KEY, enum_name);
239 status = RegOpenKeyEx(
240 HKEY_LOCAL_MACHINE,
241 unit_string,
242 0,
243 KEY_READ,
244 &unit_key);
246 if (status != ERROR_SUCCESS) {
247 return FALSE;
248 } else {
249 len = sizeof (component_id);
250 status = RegQueryValueEx(
251 unit_key,
252 component_id_string,
253 NULL,
254 &data_type,
255 component_id,
256 &len);
258 if (!(status != ERROR_SUCCESS || data_type != REG_SZ)) {
259 len = sizeof (net_cfg_instance_id);
260 status = RegQueryValueEx(
261 unit_key,
262 net_cfg_instance_id_string,
263 NULL,
264 &data_type,
265 net_cfg_instance_id,
266 &len);
268 if (status == ERROR_SUCCESS && data_type == REG_SZ) {
269 if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
270 !strcmp (net_cfg_instance_id, guid)) {
271 RegCloseKey (unit_key);
272 RegCloseKey (netcard_key);
273 return TRUE;
274 }
275 }
276 }
277 RegCloseKey (unit_key);
278 }
279 ++i;
280 }
282 RegCloseKey (netcard_key);
283 return FALSE;
284 }
286 static int get_device_guid(
287 char *name,
288 int name_size,
289 char *actual_name,
290 int actual_name_size)
291 {
292 LONG status;
293 HKEY control_net_key;
294 DWORD len;
295 int i = 0;
296 int stop = 0;
298 status = RegOpenKeyEx(
299 HKEY_LOCAL_MACHINE,
300 NETWORK_CONNECTIONS_KEY,
301 0,
302 KEY_READ,
303 &control_net_key);
305 if (status != ERROR_SUCCESS) {
306 return -1;
307 }
309 while (!stop)
310 {
311 char enum_name[256];
312 char connection_string[256];
313 HKEY connection_key;
314 char name_data[256];
315 DWORD name_type;
316 const char name_string[] = "Name";
318 len = sizeof (enum_name);
319 status = RegEnumKeyEx(
320 control_net_key,
321 i,
322 enum_name,
323 &len,
324 NULL,
325 NULL,
326 NULL,
327 NULL);
329 if (status == ERROR_NO_MORE_ITEMS)
330 break;
331 else if (status != ERROR_SUCCESS) {
332 return -1;
333 }
335 snprintf(connection_string,
336 sizeof(connection_string),
337 "%s\\%s\\Connection",
338 NETWORK_CONNECTIONS_KEY, enum_name);
340 status = RegOpenKeyEx(
341 HKEY_LOCAL_MACHINE,
342 connection_string,
343 0,
344 KEY_READ,
345 &connection_key);
347 if (status == ERROR_SUCCESS) {
348 len = sizeof (name_data);
349 status = RegQueryValueEx(
350 connection_key,
351 name_string,
352 NULL,
353 &name_type,
354 name_data,
355 &len);
357 if (status != ERROR_SUCCESS || name_type != REG_SZ) {
358 return -1;
359 }
360 else {
361 if (is_tap_win32_dev(enum_name)) {
362 snprintf(name, name_size, "%s", enum_name);
363 if (actual_name) {
364 if (strcmp(actual_name, "") != 0) {
365 if (strcmp(name_data, actual_name) != 0) {
366 RegCloseKey (connection_key);
367 ++i;
368 continue;
369 }
370 }
371 else {
372 snprintf(actual_name, actual_name_size, "%s", name_data);
373 }
374 }
375 stop = 1;
376 }
377 }
379 RegCloseKey (connection_key);
380 }
381 ++i;
382 }
384 RegCloseKey (control_net_key);
386 if (stop == 0)
387 return -1;
389 return 0;
390 }
392 static int tap_win32_set_status(HANDLE handle, int status)
393 {
394 unsigned long len = 0;
396 return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
397 &status, sizeof (status),
398 &status, sizeof (status), &len, NULL);
399 }
401 static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
402 {
403 overlapped->handle = handle;
405 overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
406 overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);
408 overlapped->read_overlapped.Offset = 0;
409 overlapped->read_overlapped.OffsetHigh = 0;
410 overlapped->read_overlapped.hEvent = overlapped->read_event;
412 overlapped->write_overlapped.Offset = 0;
413 overlapped->write_overlapped.OffsetHigh = 0;
414 overlapped->write_overlapped.hEvent = overlapped->write_event;
416 InitializeCriticalSection(&overlapped->output_queue_cs);
417 InitializeCriticalSection(&overlapped->free_list_cs);
419 overlapped->output_queue_semaphore = CreateSemaphore(
420 NULL, // default security attributes
421 0, // initial count
422 TUN_MAX_BUFFER_COUNT, // maximum count
423 NULL); // unnamed semaphore
425 if(!overlapped->output_queue_semaphore) {
426 fprintf(stderr, "error creating output queue semaphore!\n");
427 }
429 overlapped->free_list_semaphore = CreateSemaphore(
430 NULL, // default security attributes
431 TUN_MAX_BUFFER_COUNT, // initial count
432 TUN_MAX_BUFFER_COUNT, // maximum count
433 NULL); // unnamed semaphore
435 if(!overlapped->free_list_semaphore) {
436 fprintf(stderr, "error creating free list semaphore!\n");
437 }
439 overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;
441 {
442 unsigned index;
443 for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
444 tun_buffer_t* element = &overlapped->buffers[index];
445 element->next = overlapped->free_list;
446 overlapped->free_list = element;
447 }
448 }
449 /* To count buffers, initially no-signal. */
450 overlapped->tap_semaphore = CreateSemaphore(NULL, 0, TUN_MAX_BUFFER_COUNT, NULL);
451 if(!overlapped->tap_semaphore)
452 fprintf(stderr, "error creating tap_semaphore.\n");
453 }
455 static int tap_win32_write(tap_win32_overlapped_t *overlapped,
456 const void *buffer, unsigned long size)
457 {
458 unsigned long write_size;
459 BOOL result;
460 DWORD error;
462 result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
463 &write_size, FALSE);
465 if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
466 WaitForSingleObject(overlapped->write_event, INFINITE);
468 result = WriteFile(overlapped->handle, buffer, size,
469 &write_size, &overlapped->write_overlapped);
471 if (!result) {
472 switch (error = GetLastError())
473 {
474 case ERROR_IO_PENDING:
475 #ifndef TUN_ASYNCHRONOUS_WRITES
476 WaitForSingleObject(overlapped->write_event, INFINITE);
477 #endif
478 break;
479 default:
480 return -1;
481 }
482 }
484 return 0;
485 }
487 static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
488 {
489 tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
490 unsigned long read_size;
491 BOOL result;
492 DWORD dwError;
493 tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);
496 for (;;) {
497 result = ReadFile(overlapped->handle,
498 buffer->buffer,
499 sizeof(buffer->buffer),
500 &read_size,
501 &overlapped->read_overlapped);
502 if (!result) {
503 dwError = GetLastError();
504 if (dwError == ERROR_IO_PENDING) {
505 WaitForSingleObject(overlapped->read_event, INFINITE);
506 result = GetOverlappedResult( overlapped->handle, &overlapped->read_overlapped,
507 &read_size, FALSE);
508 if (!result) {
509 #if DEBUG_TAP_WIN32
510 LPVOID lpBuffer;
511 dwError = GetLastError();
512 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
513 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
514 (LPTSTR) & lpBuffer, 0, NULL );
515 fprintf(stderr, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError, lpBuffer);
516 LocalFree( lpBuffer );
517 #endif
518 }
519 } else {
520 #if DEBUG_TAP_WIN32
521 LPVOID lpBuffer;
522 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
523 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
524 (LPTSTR) & lpBuffer, 0, NULL );
525 fprintf(stderr, "Tap-Win32: Error ReadFile %d - %s\n", dwError, lpBuffer);
526 LocalFree( lpBuffer );
527 #endif
528 }
529 }
531 if(read_size > 0) {
532 buffer->read_size = read_size;
533 put_buffer_on_output_queue(overlapped, buffer);
534 ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
535 buffer = get_buffer_from_free_list(overlapped);
536 }
537 }
539 return 0;
540 }
542 static int tap_win32_read(tap_win32_overlapped_t *overlapped,
543 uint8_t **pbuf, int max_size)
544 {
545 int size = 0;
547 tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
549 if(buffer != NULL) {
550 *pbuf = buffer->buffer;
551 size = (int)buffer->read_size;
552 if(size > max_size) {
553 size = max_size;
554 }
555 }
557 return size;
558 }
560 static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
561 char* pbuf)
562 {
563 tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
564 put_buffer_on_free_list(overlapped, buffer);
565 }
567 static int tap_win32_open(tap_win32_overlapped_t **phandle,
568 const char *prefered_name)
569 {
570 char device_path[256];
571 char device_guid[0x100];
572 int rc;
573 HANDLE handle;
574 BOOL bret;
575 char name_buffer[0x100] = {0, };
576 struct {
577 unsigned long major;
578 unsigned long minor;
579 unsigned long debug;
580 } version;
581 LONG version_len;
582 DWORD idThread;
583 HANDLE hThread;
585 if (prefered_name != NULL)
586 snprintf(name_buffer, sizeof(name_buffer), "%s", prefered_name);
588 rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
589 if (rc)
590 return -1;
592 snprintf (device_path, sizeof(device_path), "%s%s%s",
593 USERMODEDEVICEDIR,
594 device_guid,
595 TAPSUFFIX);
597 handle = CreateFile (
598 device_path,
599 GENERIC_READ | GENERIC_WRITE,
600 0,
601 0,
602 OPEN_EXISTING,
603 FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
604 0 );
606 if (handle == INVALID_HANDLE_VALUE) {
607 return -1;
608 }
610 bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
611 &version, sizeof (version),
612 &version, sizeof (version), &version_len, NULL);
614 if (bret == FALSE) {
615 CloseHandle(handle);
616 return -1;
617 }
619 if (!tap_win32_set_status(handle, TRUE)) {
620 return -1;
621 }
623 tap_win32_overlapped_init(&tap_overlapped, handle);
625 *phandle = &tap_overlapped;
627 hThread = CreateThread(NULL, 0, tap_win32_thread_entry,
628 (LPVOID)&tap_overlapped, 0, &idThread);
629 return 0;
630 }
632 /********************************************/
634 typedef struct TAPState {
635 VLANClientState *vc;
636 tap_win32_overlapped_t *handle;
637 } TAPState;
639 static void tap_receive(void *opaque, const uint8_t *buf, int size)
640 {
641 TAPState *s = opaque;
643 tap_win32_write(s->handle, buf, size);
644 }
646 static void tap_win32_send(void *opaque)
647 {
648 TAPState *s = opaque;
649 uint8_t *buf;
650 int max_size = 4096;
651 int size;
653 size = tap_win32_read(s->handle, &buf, max_size);
654 if (size > 0) {
655 qemu_send_packet(s->vc, buf, size);
656 tap_win32_free_buffer(s->handle, buf);
657 }
658 }
660 int tap_win32_init(VLANState *vlan, const char *ifname)
661 {
662 TAPState *s;
664 s = qemu_mallocz(sizeof(TAPState));
665 if (!s)
666 return -1;
667 if (tap_win32_open(&s->handle, ifname) < 0) {
668 printf("tap: Could not open '%s'\n", ifname);
669 return -1;
670 }
672 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
674 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
675 "tap: ifname=%s", ifname);
677 qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
678 return 0;
679 }