tests: virtio-9p: rename PCI configuration test
[qemu.git] / net / tap-win32.c
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, see <http://www.gnu.org/licenses/>.
27 */
28
29 #include "qemu/osdep.h"
30 #include "tap_int.h"
31
32 #include "qemu-common.h"
33 #include "clients.h" /* net_init_tap */
34 #include "net/net.h"
35 #include "net/tap.h" /* tap_has_ufo, ... */
36 #include "sysemu/sysemu.h"
37 #include "qemu/error-report.h"
38 #include <windows.h>
39 #include <winioctl.h>
40
41 //=============
42 // TAP IOCTLs
43 //=============
44
45 #define TAP_CONTROL_CODE(request,method) \
46 CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
47
48 #define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE (1, METHOD_BUFFERED)
49 #define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE (2, METHOD_BUFFERED)
50 #define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE (3, METHOD_BUFFERED)
51 #define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE (4, METHOD_BUFFERED)
52 #define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
53 #define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE (6, METHOD_BUFFERED)
54 #define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE (7, METHOD_BUFFERED)
55 #define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE (8, METHOD_BUFFERED)
56 #define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE (9, METHOD_BUFFERED)
57
58 //=================
59 // Registry keys
60 //=================
61
62 #define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
63
64 #define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
65
66 //======================
67 // Filesystem prefixes
68 //======================
69
70 #define USERMODEDEVICEDIR "\\\\.\\Global\\"
71 #define TAPSUFFIX ".tap"
72
73
74 //======================
75 // Compile time configuration
76 //======================
77
78 //#define DEBUG_TAP_WIN32
79
80 /* FIXME: The asynch write path appears to be broken at
81 * present. WriteFile() ignores the lpNumberOfBytesWritten parameter
82 * for overlapped writes, with the result we return zero bytes sent,
83 * and after handling a single packet, receive is disabled for this
84 * interface. */
85 /* #define TUN_ASYNCHRONOUS_WRITES 1 */
86
87 #define TUN_BUFFER_SIZE 1560
88 #define TUN_MAX_BUFFER_COUNT 32
89
90 /*
91 * The data member "buffer" must be the first element in the tun_buffer
92 * structure. See the function, tap_win32_free_buffer.
93 */
94 typedef struct tun_buffer_s {
95 unsigned char buffer [TUN_BUFFER_SIZE];
96 unsigned long read_size;
97 struct tun_buffer_s* next;
98 } tun_buffer_t;
99
100 typedef struct tap_win32_overlapped {
101 HANDLE handle;
102 HANDLE read_event;
103 HANDLE write_event;
104 HANDLE output_queue_semaphore;
105 HANDLE free_list_semaphore;
106 HANDLE tap_semaphore;
107 CRITICAL_SECTION output_queue_cs;
108 CRITICAL_SECTION free_list_cs;
109 OVERLAPPED read_overlapped;
110 OVERLAPPED write_overlapped;
111 tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
112 tun_buffer_t* free_list;
113 tun_buffer_t* output_queue_front;
114 tun_buffer_t* output_queue_back;
115 } tap_win32_overlapped_t;
116
117 static tap_win32_overlapped_t tap_overlapped;
118
119 static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
120 {
121 tun_buffer_t* buffer = NULL;
122 WaitForSingleObject(overlapped->free_list_semaphore, INFINITE);
123 EnterCriticalSection(&overlapped->free_list_cs);
124 buffer = overlapped->free_list;
125 // assert(buffer != NULL);
126 overlapped->free_list = buffer->next;
127 LeaveCriticalSection(&overlapped->free_list_cs);
128 buffer->next = NULL;
129 return buffer;
130 }
131
132 static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
133 {
134 EnterCriticalSection(&overlapped->free_list_cs);
135 buffer->next = overlapped->free_list;
136 overlapped->free_list = buffer;
137 LeaveCriticalSection(&overlapped->free_list_cs);
138 ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL);
139 }
140
141 static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
142 {
143 tun_buffer_t* buffer = NULL;
144 DWORD result, timeout = block ? INFINITE : 0L;
145
146 // Non-blocking call
147 result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);
148
149 switch (result)
150 {
151 // The semaphore object was signaled.
152 case WAIT_OBJECT_0:
153 EnterCriticalSection(&overlapped->output_queue_cs);
154
155 buffer = overlapped->output_queue_front;
156 overlapped->output_queue_front = buffer->next;
157
158 if(overlapped->output_queue_front == NULL) {
159 overlapped->output_queue_back = NULL;
160 }
161
162 LeaveCriticalSection(&overlapped->output_queue_cs);
163 break;
164
165 // Semaphore was nonsignaled, so a time-out occurred.
166 case WAIT_TIMEOUT:
167 // Cannot open another window.
168 break;
169 }
170
171 return buffer;
172 }
173
174 static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
175 {
176 return get_buffer_from_output_queue(overlapped, 0);
177 }
178
179 static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
180 {
181 EnterCriticalSection(&overlapped->output_queue_cs);
182
183 if(overlapped->output_queue_front == NULL && overlapped->output_queue_back == NULL) {
184 overlapped->output_queue_front = overlapped->output_queue_back = buffer;
185 } else {
186 buffer->next = NULL;
187 overlapped->output_queue_back->next = buffer;
188 overlapped->output_queue_back = buffer;
189 }
190
191 LeaveCriticalSection(&overlapped->output_queue_cs);
192
193 ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
194 }
195
196
197 static int is_tap_win32_dev(const char *guid)
198 {
199 HKEY netcard_key;
200 LONG status;
201 DWORD len;
202 int i = 0;
203
204 status = RegOpenKeyEx(
205 HKEY_LOCAL_MACHINE,
206 ADAPTER_KEY,
207 0,
208 KEY_READ,
209 &netcard_key);
210
211 if (status != ERROR_SUCCESS) {
212 return FALSE;
213 }
214
215 for (;;) {
216 char enum_name[256];
217 char unit_string[256];
218 HKEY unit_key;
219 char component_id_string[] = "ComponentId";
220 char component_id[256];
221 char net_cfg_instance_id_string[] = "NetCfgInstanceId";
222 char net_cfg_instance_id[256];
223 DWORD data_type;
224
225 len = sizeof (enum_name);
226 status = RegEnumKeyEx(
227 netcard_key,
228 i,
229 enum_name,
230 &len,
231 NULL,
232 NULL,
233 NULL,
234 NULL);
235
236 if (status == ERROR_NO_MORE_ITEMS)
237 break;
238 else if (status != ERROR_SUCCESS) {
239 return FALSE;
240 }
241
242 snprintf (unit_string, sizeof(unit_string), "%s\\%s",
243 ADAPTER_KEY, enum_name);
244
245 status = RegOpenKeyEx(
246 HKEY_LOCAL_MACHINE,
247 unit_string,
248 0,
249 KEY_READ,
250 &unit_key);
251
252 if (status != ERROR_SUCCESS) {
253 return FALSE;
254 } else {
255 len = sizeof (component_id);
256 status = RegQueryValueEx(
257 unit_key,
258 component_id_string,
259 NULL,
260 &data_type,
261 (LPBYTE)component_id,
262 &len);
263
264 if (!(status != ERROR_SUCCESS || data_type != REG_SZ)) {
265 len = sizeof (net_cfg_instance_id);
266 status = RegQueryValueEx(
267 unit_key,
268 net_cfg_instance_id_string,
269 NULL,
270 &data_type,
271 (LPBYTE)net_cfg_instance_id,
272 &len);
273
274 if (status == ERROR_SUCCESS && data_type == REG_SZ) {
275 if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
276 !strcmp (net_cfg_instance_id, guid)) {
277 RegCloseKey (unit_key);
278 RegCloseKey (netcard_key);
279 return TRUE;
280 }
281 }
282 }
283 RegCloseKey (unit_key);
284 }
285 ++i;
286 }
287
288 RegCloseKey (netcard_key);
289 return FALSE;
290 }
291
292 static int get_device_guid(
293 char *name,
294 int name_size,
295 char *actual_name,
296 int actual_name_size)
297 {
298 LONG status;
299 HKEY control_net_key;
300 DWORD len;
301 int i = 0;
302 int stop = 0;
303
304 status = RegOpenKeyEx(
305 HKEY_LOCAL_MACHINE,
306 NETWORK_CONNECTIONS_KEY,
307 0,
308 KEY_READ,
309 &control_net_key);
310
311 if (status != ERROR_SUCCESS) {
312 return -1;
313 }
314
315 while (!stop)
316 {
317 char enum_name[256];
318 char connection_string[256];
319 HKEY connection_key;
320 char name_data[256];
321 DWORD name_type;
322 const char name_string[] = "Name";
323
324 len = sizeof (enum_name);
325 status = RegEnumKeyEx(
326 control_net_key,
327 i,
328 enum_name,
329 &len,
330 NULL,
331 NULL,
332 NULL,
333 NULL);
334
335 if (status == ERROR_NO_MORE_ITEMS)
336 break;
337 else if (status != ERROR_SUCCESS) {
338 return -1;
339 }
340
341 snprintf(connection_string,
342 sizeof(connection_string),
343 "%s\\%s\\Connection",
344 NETWORK_CONNECTIONS_KEY, enum_name);
345
346 status = RegOpenKeyEx(
347 HKEY_LOCAL_MACHINE,
348 connection_string,
349 0,
350 KEY_READ,
351 &connection_key);
352
353 if (status == ERROR_SUCCESS) {
354 len = sizeof (name_data);
355 status = RegQueryValueEx(
356 connection_key,
357 name_string,
358 NULL,
359 &name_type,
360 (LPBYTE)name_data,
361 &len);
362
363 if (status != ERROR_SUCCESS || name_type != REG_SZ) {
364 ++i;
365 continue;
366 }
367 else {
368 if (is_tap_win32_dev(enum_name)) {
369 snprintf(name, name_size, "%s", enum_name);
370 if (actual_name) {
371 if (strcmp(actual_name, "") != 0) {
372 if (strcmp(name_data, actual_name) != 0) {
373 RegCloseKey (connection_key);
374 ++i;
375 continue;
376 }
377 }
378 else {
379 snprintf(actual_name, actual_name_size, "%s", name_data);
380 }
381 }
382 stop = 1;
383 }
384 }
385
386 RegCloseKey (connection_key);
387 }
388 ++i;
389 }
390
391 RegCloseKey (control_net_key);
392
393 if (stop == 0)
394 return -1;
395
396 return 0;
397 }
398
399 static int tap_win32_set_status(HANDLE handle, int status)
400 {
401 unsigned long len = 0;
402
403 return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
404 &status, sizeof (status),
405 &status, sizeof (status), &len, NULL);
406 }
407
408 static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
409 {
410 overlapped->handle = handle;
411
412 overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
413 overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);
414
415 overlapped->read_overlapped.Offset = 0;
416 overlapped->read_overlapped.OffsetHigh = 0;
417 overlapped->read_overlapped.hEvent = overlapped->read_event;
418
419 overlapped->write_overlapped.Offset = 0;
420 overlapped->write_overlapped.OffsetHigh = 0;
421 overlapped->write_overlapped.hEvent = overlapped->write_event;
422
423 InitializeCriticalSection(&overlapped->output_queue_cs);
424 InitializeCriticalSection(&overlapped->free_list_cs);
425
426 overlapped->output_queue_semaphore = CreateSemaphore(
427 NULL, // default security attributes
428 0, // initial count
429 TUN_MAX_BUFFER_COUNT, // maximum count
430 NULL); // unnamed semaphore
431
432 if(!overlapped->output_queue_semaphore) {
433 fprintf(stderr, "error creating output queue semaphore!\n");
434 }
435
436 overlapped->free_list_semaphore = CreateSemaphore(
437 NULL, // default security attributes
438 TUN_MAX_BUFFER_COUNT, // initial count
439 TUN_MAX_BUFFER_COUNT, // maximum count
440 NULL); // unnamed semaphore
441
442 if(!overlapped->free_list_semaphore) {
443 fprintf(stderr, "error creating free list semaphore!\n");
444 }
445
446 overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;
447
448 {
449 unsigned index;
450 for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
451 tun_buffer_t* element = &overlapped->buffers[index];
452 element->next = overlapped->free_list;
453 overlapped->free_list = element;
454 }
455 }
456 /* To count buffers, initially no-signal. */
457 overlapped->tap_semaphore = CreateSemaphore(NULL, 0, TUN_MAX_BUFFER_COUNT, NULL);
458 if(!overlapped->tap_semaphore)
459 fprintf(stderr, "error creating tap_semaphore.\n");
460 }
461
462 static int tap_win32_write(tap_win32_overlapped_t *overlapped,
463 const void *buffer, unsigned long size)
464 {
465 unsigned long write_size;
466 BOOL result;
467 DWORD error;
468
469 #ifdef TUN_ASYNCHRONOUS_WRITES
470 result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
471 &write_size, FALSE);
472
473 if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
474 WaitForSingleObject(overlapped->write_event, INFINITE);
475 #endif
476
477 result = WriteFile(overlapped->handle, buffer, size,
478 &write_size, &overlapped->write_overlapped);
479
480 #ifdef TUN_ASYNCHRONOUS_WRITES
481 /* FIXME: we can't sensibly set write_size here, without waiting
482 * for the IO to complete! Moreover, we can't return zero,
483 * because that will disable receive on this interface, and we
484 * also can't assume it will succeed and return the full size,
485 * because that will result in the buffer being reclaimed while
486 * the IO is in progress. */
487 #error Async writes are broken. Please disable TUN_ASYNCHRONOUS_WRITES.
488 #else /* !TUN_ASYNCHRONOUS_WRITES */
489 if (!result) {
490 error = GetLastError();
491 if (error == ERROR_IO_PENDING) {
492 result = GetOverlappedResult(overlapped->handle,
493 &overlapped->write_overlapped,
494 &write_size, TRUE);
495 }
496 }
497 #endif
498
499 if (!result) {
500 #ifdef DEBUG_TAP_WIN32
501 LPTSTR msgbuf;
502 error = GetLastError();
503 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
504 NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
505 &msgbuf, 0, NULL);
506 fprintf(stderr, "Tap-Win32: Error WriteFile %d - %s\n", error, msgbuf);
507 LocalFree(msgbuf);
508 #endif
509 return 0;
510 }
511
512 return write_size;
513 }
514
515 static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
516 {
517 tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
518 unsigned long read_size;
519 BOOL result;
520 DWORD dwError;
521 tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);
522
523
524 for (;;) {
525 result = ReadFile(overlapped->handle,
526 buffer->buffer,
527 sizeof(buffer->buffer),
528 &read_size,
529 &overlapped->read_overlapped);
530 if (!result) {
531 dwError = GetLastError();
532 if (dwError == ERROR_IO_PENDING) {
533 WaitForSingleObject(overlapped->read_event, INFINITE);
534 result = GetOverlappedResult( overlapped->handle, &overlapped->read_overlapped,
535 &read_size, FALSE);
536 if (!result) {
537 #ifdef DEBUG_TAP_WIN32
538 LPVOID lpBuffer;
539 dwError = GetLastError();
540 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
541 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
542 (LPTSTR) & lpBuffer, 0, NULL );
543 fprintf(stderr, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError, lpBuffer);
544 LocalFree( lpBuffer );
545 #endif
546 }
547 } else {
548 #ifdef DEBUG_TAP_WIN32
549 LPVOID lpBuffer;
550 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
551 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
552 (LPTSTR) & lpBuffer, 0, NULL );
553 fprintf(stderr, "Tap-Win32: Error ReadFile %d - %s\n", dwError, lpBuffer);
554 LocalFree( lpBuffer );
555 #endif
556 }
557 }
558
559 if(read_size > 0) {
560 buffer->read_size = read_size;
561 put_buffer_on_output_queue(overlapped, buffer);
562 ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
563 buffer = get_buffer_from_free_list(overlapped);
564 }
565 }
566
567 return 0;
568 }
569
570 static int tap_win32_read(tap_win32_overlapped_t *overlapped,
571 uint8_t **pbuf, int max_size)
572 {
573 int size = 0;
574
575 tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
576
577 if(buffer != NULL) {
578 *pbuf = buffer->buffer;
579 size = (int)buffer->read_size;
580 if(size > max_size) {
581 size = max_size;
582 }
583 }
584
585 return size;
586 }
587
588 static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
589 uint8_t *pbuf)
590 {
591 tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
592 put_buffer_on_free_list(overlapped, buffer);
593 }
594
595 static int tap_win32_open(tap_win32_overlapped_t **phandle,
596 const char *preferred_name)
597 {
598 char device_path[256];
599 char device_guid[0x100];
600 int rc;
601 HANDLE handle;
602 BOOL bret;
603 char name_buffer[0x100] = {0, };
604 struct {
605 unsigned long major;
606 unsigned long minor;
607 unsigned long debug;
608 } version;
609 DWORD version_len;
610 DWORD idThread;
611
612 if (preferred_name != NULL) {
613 snprintf(name_buffer, sizeof(name_buffer), "%s", preferred_name);
614 }
615
616 rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
617 if (rc)
618 return -1;
619
620 snprintf (device_path, sizeof(device_path), "%s%s%s",
621 USERMODEDEVICEDIR,
622 device_guid,
623 TAPSUFFIX);
624
625 handle = CreateFile (
626 device_path,
627 GENERIC_READ | GENERIC_WRITE,
628 0,
629 0,
630 OPEN_EXISTING,
631 FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
632 0 );
633
634 if (handle == INVALID_HANDLE_VALUE) {
635 return -1;
636 }
637
638 bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
639 &version, sizeof (version),
640 &version, sizeof (version), &version_len, NULL);
641
642 if (bret == FALSE) {
643 CloseHandle(handle);
644 return -1;
645 }
646
647 if (!tap_win32_set_status(handle, TRUE)) {
648 return -1;
649 }
650
651 tap_win32_overlapped_init(&tap_overlapped, handle);
652
653 *phandle = &tap_overlapped;
654
655 CreateThread(NULL, 0, tap_win32_thread_entry,
656 (LPVOID)&tap_overlapped, 0, &idThread);
657 return 0;
658 }
659
660 /********************************************/
661
662 typedef struct TAPState {
663 NetClientState nc;
664 tap_win32_overlapped_t *handle;
665 } TAPState;
666
667 static void tap_cleanup(NetClientState *nc)
668 {
669 TAPState *s = DO_UPCAST(TAPState, nc, nc);
670
671 qemu_del_wait_object(s->handle->tap_semaphore, NULL, NULL);
672
673 /* FIXME: need to kill thread and close file handle:
674 tap_win32_close(s);
675 */
676 }
677
678 static ssize_t tap_receive(NetClientState *nc, const uint8_t *buf, size_t size)
679 {
680 TAPState *s = DO_UPCAST(TAPState, nc, nc);
681
682 return tap_win32_write(s->handle, buf, size);
683 }
684
685 static void tap_win32_send(void *opaque)
686 {
687 TAPState *s = opaque;
688 uint8_t *buf;
689 int max_size = 4096;
690 int size;
691
692 size = tap_win32_read(s->handle, &buf, max_size);
693 if (size > 0) {
694 qemu_send_packet(&s->nc, buf, size);
695 tap_win32_free_buffer(s->handle, buf);
696 }
697 }
698
699 static bool tap_has_ufo(NetClientState *nc)
700 {
701 return false;
702 }
703
704 static bool tap_has_vnet_hdr(NetClientState *nc)
705 {
706 return false;
707 }
708
709 int tap_probe_vnet_hdr_len(int fd, int len)
710 {
711 return 0;
712 }
713
714 void tap_fd_set_vnet_hdr_len(int fd, int len)
715 {
716 }
717
718 int tap_fd_set_vnet_le(int fd, int is_le)
719 {
720 return -EINVAL;
721 }
722
723 int tap_fd_set_vnet_be(int fd, int is_be)
724 {
725 return -EINVAL;
726 }
727
728 static void tap_using_vnet_hdr(NetClientState *nc, bool using_vnet_hdr)
729 {
730 }
731
732 static void tap_set_offload(NetClientState *nc, int csum, int tso4,
733 int tso6, int ecn, int ufo)
734 {
735 }
736
737 struct vhost_net *tap_get_vhost_net(NetClientState *nc)
738 {
739 return NULL;
740 }
741
742 static bool tap_has_vnet_hdr_len(NetClientState *nc, int len)
743 {
744 return false;
745 }
746
747 static void tap_set_vnet_hdr_len(NetClientState *nc, int len)
748 {
749 abort();
750 }
751
752 static NetClientInfo net_tap_win32_info = {
753 .type = NET_CLIENT_DRIVER_TAP,
754 .size = sizeof(TAPState),
755 .receive = tap_receive,
756 .cleanup = tap_cleanup,
757 .has_ufo = tap_has_ufo,
758 .has_vnet_hdr = tap_has_vnet_hdr,
759 .has_vnet_hdr_len = tap_has_vnet_hdr_len,
760 .using_vnet_hdr = tap_using_vnet_hdr,
761 .set_offload = tap_set_offload,
762 .set_vnet_hdr_len = tap_set_vnet_hdr_len,
763 };
764
765 static int tap_win32_init(NetClientState *peer, const char *model,
766 const char *name, const char *ifname)
767 {
768 NetClientState *nc;
769 TAPState *s;
770 tap_win32_overlapped_t *handle;
771
772 if (tap_win32_open(&handle, ifname) < 0) {
773 printf("tap: Could not open '%s'\n", ifname);
774 return -1;
775 }
776
777 nc = qemu_new_net_client(&net_tap_win32_info, peer, model, name);
778
779 s = DO_UPCAST(TAPState, nc, nc);
780
781 snprintf(s->nc.info_str, sizeof(s->nc.info_str),
782 "tap: ifname=%s", ifname);
783
784 s->handle = handle;
785
786 qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
787
788 return 0;
789 }
790
791 int net_init_tap(const Netdev *netdev, const char *name,
792 NetClientState *peer, Error **errp)
793 {
794 /* FIXME error_setg(errp, ...) on failure */
795 const NetdevTapOptions *tap;
796
797 assert(netdev->type == NET_CLIENT_DRIVER_TAP);
798 tap = &netdev->u.tap;
799
800 if (!tap->has_ifname) {
801 error_report("tap: no interface name");
802 return -1;
803 }
804
805 if (tap_win32_init(peer, "tap", name, tap->ifname) == -1) {
806 return -1;
807 }
808
809 return 0;
810 }
811
812 int tap_enable(NetClientState *nc)
813 {
814 abort();
815 }
816
817 int tap_disable(NetClientState *nc)
818 {
819 abort();
820 }