blob: 8aee611f7d25cf632af14a7ca7d26118e29cf29d [file] [log] [blame]
bellard7fb843f2006-02-01 23:06:55 +00001/*
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
Blue Swirl8167ee82009-07-16 20:47:01 +000026 * distribution); if not, see <http://www.gnu.org/licenses/>.
bellard7fb843f2006-02-01 23:06:55 +000027 */
Mark McLoughlina8ed73f2009-10-22 17:49:05 +010028
Paolo Bonzini1422e322012-10-24 08:43:34 +020029#include "tap_int.h"
Mark McLoughlina8ed73f2009-10-22 17:49:05 +010030
pbrook87ecb682007-11-17 17:14:51 +000031#include "qemu-common.h"
Stefan Weil08778b32012-10-17 19:53:50 +020032#include "clients.h" /* net_init_tap */
Paolo Bonzini1422e322012-10-24 08:43:34 +020033#include "net/net.h"
Stefan Weilb2136142012-12-20 23:09:53 +010034#include "net/tap.h" /* tap_has_ufo, ... */
Paolo Bonzini9c17d612012-12-17 18:20:04 +010035#include "sysemu/sysemu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/error-report.h"
bellard7fb843f2006-02-01 23:06:55 +000037#include <stdio.h>
38#include <windows.h>
Filip Navaraf8bfb1d2009-07-27 10:02:01 -050039#include <winioctl.h>
bellard7fb843f2006-02-01 23:06:55 +000040
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
aurel32978d5d72008-11-06 09:38:51 +000078//#define DEBUG_TAP_WIN32
bellard7fb843f2006-02-01 23:06:55 +000079
80#define TUN_ASYNCHRONOUS_WRITES 1
81
82#define TUN_BUFFER_SIZE 1560
83#define TUN_MAX_BUFFER_COUNT 32
84
85/*
86 * The data member "buffer" must be the first element in the tun_buffer
87 * structure. See the function, tap_win32_free_buffer.
88 */
89typedef struct tun_buffer_s {
90 unsigned char buffer [TUN_BUFFER_SIZE];
91 unsigned long read_size;
92 struct tun_buffer_s* next;
Anthony Liguoric227f092009-10-01 16:12:16 -050093} tun_buffer_t;
bellard7fb843f2006-02-01 23:06:55 +000094
95typedef struct tap_win32_overlapped {
96 HANDLE handle;
97 HANDLE read_event;
98 HANDLE write_event;
99 HANDLE output_queue_semaphore;
100 HANDLE free_list_semaphore;
bellarde6cda8e2006-08-19 12:37:52 +0000101 HANDLE tap_semaphore;
bellard7fb843f2006-02-01 23:06:55 +0000102 CRITICAL_SECTION output_queue_cs;
103 CRITICAL_SECTION free_list_cs;
104 OVERLAPPED read_overlapped;
105 OVERLAPPED write_overlapped;
Anthony Liguoric227f092009-10-01 16:12:16 -0500106 tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
107 tun_buffer_t* free_list;
108 tun_buffer_t* output_queue_front;
109 tun_buffer_t* output_queue_back;
110} tap_win32_overlapped_t;
bellard7fb843f2006-02-01 23:06:55 +0000111
Anthony Liguoric227f092009-10-01 16:12:16 -0500112static tap_win32_overlapped_t tap_overlapped;
bellard7fb843f2006-02-01 23:06:55 +0000113
Anthony Liguoric227f092009-10-01 16:12:16 -0500114static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
bellard7fb843f2006-02-01 23:06:55 +0000115{
Anthony Liguoric227f092009-10-01 16:12:16 -0500116 tun_buffer_t* buffer = NULL;
bellard7fb843f2006-02-01 23:06:55 +0000117 WaitForSingleObject(overlapped->free_list_semaphore, INFINITE);
118 EnterCriticalSection(&overlapped->free_list_cs);
119 buffer = overlapped->free_list;
120// assert(buffer != NULL);
121 overlapped->free_list = buffer->next;
122 LeaveCriticalSection(&overlapped->free_list_cs);
123 buffer->next = NULL;
124 return buffer;
125}
126
Anthony Liguoric227f092009-10-01 16:12:16 -0500127static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
bellard7fb843f2006-02-01 23:06:55 +0000128{
129 EnterCriticalSection(&overlapped->free_list_cs);
130 buffer->next = overlapped->free_list;
131 overlapped->free_list = buffer;
132 LeaveCriticalSection(&overlapped->free_list_cs);
133 ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL);
134}
135
Anthony Liguoric227f092009-10-01 16:12:16 -0500136static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
bellard7fb843f2006-02-01 23:06:55 +0000137{
Anthony Liguoric227f092009-10-01 16:12:16 -0500138 tun_buffer_t* buffer = NULL;
bellard7fb843f2006-02-01 23:06:55 +0000139 DWORD result, timeout = block ? INFINITE : 0L;
140
141 // Non-blocking call
ths5fafdf22007-09-16 21:08:06 +0000142 result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);
bellard7fb843f2006-02-01 23:06:55 +0000143
ths5fafdf22007-09-16 21:08:06 +0000144 switch (result)
145 {
bellard7fb843f2006-02-01 23:06:55 +0000146 // The semaphore object was signaled.
ths5fafdf22007-09-16 21:08:06 +0000147 case WAIT_OBJECT_0:
bellard7fb843f2006-02-01 23:06:55 +0000148 EnterCriticalSection(&overlapped->output_queue_cs);
149
150 buffer = overlapped->output_queue_front;
151 overlapped->output_queue_front = buffer->next;
152
153 if(overlapped->output_queue_front == NULL) {
154 overlapped->output_queue_back = NULL;
155 }
156
157 LeaveCriticalSection(&overlapped->output_queue_cs);
ths5fafdf22007-09-16 21:08:06 +0000158 break;
bellard7fb843f2006-02-01 23:06:55 +0000159
160 // Semaphore was nonsignaled, so a time-out occurred.
ths5fafdf22007-09-16 21:08:06 +0000161 case WAIT_TIMEOUT:
bellard7fb843f2006-02-01 23:06:55 +0000162 // Cannot open another window.
ths5fafdf22007-09-16 21:08:06 +0000163 break;
bellard7fb843f2006-02-01 23:06:55 +0000164 }
165
166 return buffer;
167}
168
Anthony Liguoric227f092009-10-01 16:12:16 -0500169static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
bellard7fb843f2006-02-01 23:06:55 +0000170{
171 return get_buffer_from_output_queue(overlapped, 0);
172}
173
Anthony Liguoric227f092009-10-01 16:12:16 -0500174static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
bellard7fb843f2006-02-01 23:06:55 +0000175{
176 EnterCriticalSection(&overlapped->output_queue_cs);
177
178 if(overlapped->output_queue_front == NULL && overlapped->output_queue_back == NULL) {
179 overlapped->output_queue_front = overlapped->output_queue_back = buffer;
180 } else {
181 buffer->next = NULL;
182 overlapped->output_queue_back->next = buffer;
183 overlapped->output_queue_back = buffer;
184 }
185
186 LeaveCriticalSection(&overlapped->output_queue_cs);
187
188 ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
189}
190
191
192static int is_tap_win32_dev(const char *guid)
193{
194 HKEY netcard_key;
195 LONG status;
196 DWORD len;
197 int i = 0;
198
199 status = RegOpenKeyEx(
200 HKEY_LOCAL_MACHINE,
201 ADAPTER_KEY,
202 0,
203 KEY_READ,
204 &netcard_key);
205
206 if (status != ERROR_SUCCESS) {
207 return FALSE;
208 }
209
210 for (;;) {
211 char enum_name[256];
212 char unit_string[256];
213 HKEY unit_key;
214 char component_id_string[] = "ComponentId";
215 char component_id[256];
216 char net_cfg_instance_id_string[] = "NetCfgInstanceId";
217 char net_cfg_instance_id[256];
218 DWORD data_type;
219
220 len = sizeof (enum_name);
221 status = RegEnumKeyEx(
222 netcard_key,
223 i,
224 enum_name,
225 &len,
226 NULL,
227 NULL,
228 NULL,
229 NULL);
230
231 if (status == ERROR_NO_MORE_ITEMS)
232 break;
233 else if (status != ERROR_SUCCESS) {
234 return FALSE;
235 }
236
237 snprintf (unit_string, sizeof(unit_string), "%s\\%s",
238 ADAPTER_KEY, enum_name);
239
240 status = RegOpenKeyEx(
241 HKEY_LOCAL_MACHINE,
242 unit_string,
243 0,
244 KEY_READ,
245 &unit_key);
246
247 if (status != ERROR_SUCCESS) {
248 return FALSE;
249 } else {
250 len = sizeof (component_id);
251 status = RegQueryValueEx(
252 unit_key,
253 component_id_string,
254 NULL,
255 &data_type,
blueswir1b9e82a52009-04-05 18:03:31 +0000256 (LPBYTE)component_id,
bellard7fb843f2006-02-01 23:06:55 +0000257 &len);
258
259 if (!(status != ERROR_SUCCESS || data_type != REG_SZ)) {
260 len = sizeof (net_cfg_instance_id);
261 status = RegQueryValueEx(
262 unit_key,
263 net_cfg_instance_id_string,
264 NULL,
265 &data_type,
blueswir1b9e82a52009-04-05 18:03:31 +0000266 (LPBYTE)net_cfg_instance_id,
bellard7fb843f2006-02-01 23:06:55 +0000267 &len);
268
269 if (status == ERROR_SUCCESS && data_type == REG_SZ) {
270 if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
271 !strcmp (net_cfg_instance_id, guid)) {
272 RegCloseKey (unit_key);
273 RegCloseKey (netcard_key);
274 return TRUE;
275 }
276 }
277 }
278 RegCloseKey (unit_key);
279 }
280 ++i;
281 }
282
283 RegCloseKey (netcard_key);
284 return FALSE;
285}
286
287static int get_device_guid(
288 char *name,
289 int name_size,
290 char *actual_name,
291 int actual_name_size)
292{
293 LONG status;
294 HKEY control_net_key;
295 DWORD len;
296 int i = 0;
297 int stop = 0;
298
299 status = RegOpenKeyEx(
300 HKEY_LOCAL_MACHINE,
301 NETWORK_CONNECTIONS_KEY,
302 0,
303 KEY_READ,
304 &control_net_key);
305
306 if (status != ERROR_SUCCESS) {
307 return -1;
308 }
309
310 while (!stop)
311 {
312 char enum_name[256];
313 char connection_string[256];
314 HKEY connection_key;
315 char name_data[256];
316 DWORD name_type;
317 const char name_string[] = "Name";
318
319 len = sizeof (enum_name);
320 status = RegEnumKeyEx(
321 control_net_key,
322 i,
323 enum_name,
324 &len,
325 NULL,
326 NULL,
327 NULL,
328 NULL);
329
330 if (status == ERROR_NO_MORE_ITEMS)
331 break;
332 else if (status != ERROR_SUCCESS) {
333 return -1;
334 }
335
ths5fafdf22007-09-16 21:08:06 +0000336 snprintf(connection_string,
bellard7fb843f2006-02-01 23:06:55 +0000337 sizeof(connection_string),
338 "%s\\%s\\Connection",
339 NETWORK_CONNECTIONS_KEY, enum_name);
340
341 status = RegOpenKeyEx(
342 HKEY_LOCAL_MACHINE,
343 connection_string,
344 0,
345 KEY_READ,
346 &connection_key);
ths3b46e622007-09-17 08:09:54 +0000347
bellard7fb843f2006-02-01 23:06:55 +0000348 if (status == ERROR_SUCCESS) {
349 len = sizeof (name_data);
350 status = RegQueryValueEx(
351 connection_key,
352 name_string,
353 NULL,
354 &name_type,
blueswir1b9e82a52009-04-05 18:03:31 +0000355 (LPBYTE)name_data,
bellard7fb843f2006-02-01 23:06:55 +0000356 &len);
357
358 if (status != ERROR_SUCCESS || name_type != REG_SZ) {
359 return -1;
360 }
361 else {
362 if (is_tap_win32_dev(enum_name)) {
363 snprintf(name, name_size, "%s", enum_name);
364 if (actual_name) {
365 if (strcmp(actual_name, "") != 0) {
366 if (strcmp(name_data, actual_name) != 0) {
367 RegCloseKey (connection_key);
368 ++i;
369 continue;
370 }
371 }
372 else {
373 snprintf(actual_name, actual_name_size, "%s", name_data);
374 }
375 }
376 stop = 1;
377 }
378 }
379
380 RegCloseKey (connection_key);
381 }
382 ++i;
383 }
384
385 RegCloseKey (control_net_key);
386
387 if (stop == 0)
388 return -1;
389
390 return 0;
391}
392
393static int tap_win32_set_status(HANDLE handle, int status)
394{
395 unsigned long len = 0;
396
397 return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
398 &status, sizeof (status),
399 &status, sizeof (status), &len, NULL);
400}
401
Anthony Liguoric227f092009-10-01 16:12:16 -0500402static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
bellard7fb843f2006-02-01 23:06:55 +0000403{
404 overlapped->handle = handle;
405
406 overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
407 overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);
408
409 overlapped->read_overlapped.Offset = 0;
410 overlapped->read_overlapped.OffsetHigh = 0;
411 overlapped->read_overlapped.hEvent = overlapped->read_event;
412
413 overlapped->write_overlapped.Offset = 0;
414 overlapped->write_overlapped.OffsetHigh = 0;
415 overlapped->write_overlapped.hEvent = overlapped->write_event;
416
417 InitializeCriticalSection(&overlapped->output_queue_cs);
418 InitializeCriticalSection(&overlapped->free_list_cs);
419
ths5fafdf22007-09-16 21:08:06 +0000420 overlapped->output_queue_semaphore = CreateSemaphore(
bellard7fb843f2006-02-01 23:06:55 +0000421 NULL, // default security attributes
422 0, // initial count
423 TUN_MAX_BUFFER_COUNT, // maximum count
424 NULL); // unnamed semaphore
425
426 if(!overlapped->output_queue_semaphore) {
427 fprintf(stderr, "error creating output queue semaphore!\n");
428 }
429
ths5fafdf22007-09-16 21:08:06 +0000430 overlapped->free_list_semaphore = CreateSemaphore(
bellard7fb843f2006-02-01 23:06:55 +0000431 NULL, // default security attributes
432 TUN_MAX_BUFFER_COUNT, // initial count
433 TUN_MAX_BUFFER_COUNT, // maximum count
434 NULL); // unnamed semaphore
435
436 if(!overlapped->free_list_semaphore) {
437 fprintf(stderr, "error creating free list semaphore!\n");
438 }
439
440 overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;
441
442 {
443 unsigned index;
444 for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
Anthony Liguoric227f092009-10-01 16:12:16 -0500445 tun_buffer_t* element = &overlapped->buffers[index];
bellard7fb843f2006-02-01 23:06:55 +0000446 element->next = overlapped->free_list;
447 overlapped->free_list = element;
448 }
449 }
bellarde6cda8e2006-08-19 12:37:52 +0000450 /* To count buffers, initially no-signal. */
451 overlapped->tap_semaphore = CreateSemaphore(NULL, 0, TUN_MAX_BUFFER_COUNT, NULL);
452 if(!overlapped->tap_semaphore)
453 fprintf(stderr, "error creating tap_semaphore.\n");
bellard7fb843f2006-02-01 23:06:55 +0000454}
455
Anthony Liguoric227f092009-10-01 16:12:16 -0500456static int tap_win32_write(tap_win32_overlapped_t *overlapped,
bellard7fb843f2006-02-01 23:06:55 +0000457 const void *buffer, unsigned long size)
458{
459 unsigned long write_size;
460 BOOL result;
461 DWORD error;
462
463 result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
464 &write_size, FALSE);
465
466 if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
467 WaitForSingleObject(overlapped->write_event, INFINITE);
468
469 result = WriteFile(overlapped->handle, buffer, size,
470 &write_size, &overlapped->write_overlapped);
ths3b46e622007-09-17 08:09:54 +0000471
ths5fafdf22007-09-16 21:08:06 +0000472 if (!result) {
bellard7fb843f2006-02-01 23:06:55 +0000473 switch (error = GetLastError())
ths5fafdf22007-09-16 21:08:06 +0000474 {
475 case ERROR_IO_PENDING:
bellard7fb843f2006-02-01 23:06:55 +0000476#ifndef TUN_ASYNCHRONOUS_WRITES
477 WaitForSingleObject(overlapped->write_event, INFINITE);
478#endif
479 break;
480 default:
481 return -1;
ths5fafdf22007-09-16 21:08:06 +0000482 }
bellard7fb843f2006-02-01 23:06:55 +0000483 }
484
Pavel Dovgalukc3febae2011-02-21 14:47:50 +0300485 return write_size;
bellard7fb843f2006-02-01 23:06:55 +0000486}
487
488static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
489{
Anthony Liguoric227f092009-10-01 16:12:16 -0500490 tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
bellard7fb843f2006-02-01 23:06:55 +0000491 unsigned long read_size;
492 BOOL result;
493 DWORD dwError;
Anthony Liguoric227f092009-10-01 16:12:16 -0500494 tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);
bellard7fb843f2006-02-01 23:06:55 +0000495
496
497 for (;;) {
498 result = ReadFile(overlapped->handle,
499 buffer->buffer,
500 sizeof(buffer->buffer),
501 &read_size,
502 &overlapped->read_overlapped);
503 if (!result) {
504 dwError = GetLastError();
505 if (dwError == ERROR_IO_PENDING) {
506 WaitForSingleObject(overlapped->read_event, INFINITE);
507 result = GetOverlappedResult( overlapped->handle, &overlapped->read_overlapped,
508 &read_size, FALSE);
509 if (!result) {
aurel32978d5d72008-11-06 09:38:51 +0000510#ifdef DEBUG_TAP_WIN32
bellard7fb843f2006-02-01 23:06:55 +0000511 LPVOID lpBuffer;
512 dwError = GetLastError();
513 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
514 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
515 (LPTSTR) & lpBuffer, 0, NULL );
516 fprintf(stderr, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError, lpBuffer);
517 LocalFree( lpBuffer );
518#endif
519 }
520 } else {
aurel32978d5d72008-11-06 09:38:51 +0000521#ifdef DEBUG_TAP_WIN32
bellard7fb843f2006-02-01 23:06:55 +0000522 LPVOID lpBuffer;
523 FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
524 NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
525 (LPTSTR) & lpBuffer, 0, NULL );
526 fprintf(stderr, "Tap-Win32: Error ReadFile %d - %s\n", dwError, lpBuffer);
527 LocalFree( lpBuffer );
528#endif
529 }
530 }
531
532 if(read_size > 0) {
533 buffer->read_size = read_size;
534 put_buffer_on_output_queue(overlapped, buffer);
bellarde6cda8e2006-08-19 12:37:52 +0000535 ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
bellard7fb843f2006-02-01 23:06:55 +0000536 buffer = get_buffer_from_free_list(overlapped);
537 }
538 }
539
540 return 0;
541}
542
Anthony Liguoric227f092009-10-01 16:12:16 -0500543static int tap_win32_read(tap_win32_overlapped_t *overlapped,
bellard7fb843f2006-02-01 23:06:55 +0000544 uint8_t **pbuf, int max_size)
545{
546 int size = 0;
547
Anthony Liguoric227f092009-10-01 16:12:16 -0500548 tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
bellard7fb843f2006-02-01 23:06:55 +0000549
550 if(buffer != NULL) {
551 *pbuf = buffer->buffer;
552 size = (int)buffer->read_size;
553 if(size > max_size) {
554 size = max_size;
555 }
556 }
557
558 return size;
559}
560
Anthony Liguoric227f092009-10-01 16:12:16 -0500561static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
blueswir1b9e82a52009-04-05 18:03:31 +0000562 uint8_t *pbuf)
bellard7fb843f2006-02-01 23:06:55 +0000563{
Anthony Liguoric227f092009-10-01 16:12:16 -0500564 tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
bellard7fb843f2006-02-01 23:06:55 +0000565 put_buffer_on_free_list(overlapped, buffer);
566}
567
Anthony Liguoric227f092009-10-01 16:12:16 -0500568static int tap_win32_open(tap_win32_overlapped_t **phandle,
Stefan Weileac29d82012-11-02 08:14:12 +0100569 const char *preferred_name)
bellard7fb843f2006-02-01 23:06:55 +0000570{
571 char device_path[256];
572 char device_guid[0x100];
573 int rc;
574 HANDLE handle;
575 BOOL bret;
576 char name_buffer[0x100] = {0, };
577 struct {
578 unsigned long major;
579 unsigned long minor;
580 unsigned long debug;
581 } version;
blueswir1b9e82a52009-04-05 18:03:31 +0000582 DWORD version_len;
bellard7fb843f2006-02-01 23:06:55 +0000583 DWORD idThread;
bellard7fb843f2006-02-01 23:06:55 +0000584
Stefan Weileac29d82012-11-02 08:14:12 +0100585 if (preferred_name != NULL) {
586 snprintf(name_buffer, sizeof(name_buffer), "%s", preferred_name);
587 }
bellard7fb843f2006-02-01 23:06:55 +0000588
589 rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
590 if (rc)
591 return -1;
592
593 snprintf (device_path, sizeof(device_path), "%s%s%s",
594 USERMODEDEVICEDIR,
595 device_guid,
596 TAPSUFFIX);
597
598 handle = CreateFile (
599 device_path,
600 GENERIC_READ | GENERIC_WRITE,
601 0,
602 0,
603 OPEN_EXISTING,
604 FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
605 0 );
606
607 if (handle == INVALID_HANDLE_VALUE) {
608 return -1;
609 }
610
611 bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
612 &version, sizeof (version),
613 &version, sizeof (version), &version_len, NULL);
614
615 if (bret == FALSE) {
616 CloseHandle(handle);
617 return -1;
618 }
619
620 if (!tap_win32_set_status(handle, TRUE)) {
621 return -1;
622 }
623
624 tap_win32_overlapped_init(&tap_overlapped, handle);
625
626 *phandle = &tap_overlapped;
627
Blue Swirl49a29422010-10-13 18:41:29 +0000628 CreateThread(NULL, 0, tap_win32_thread_entry,
629 (LPVOID)&tap_overlapped, 0, &idThread);
bellard7fb843f2006-02-01 23:06:55 +0000630 return 0;
631}
632
633/********************************************/
634
635 typedef struct TAPState {
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100636 NetClientState nc;
Anthony Liguoric227f092009-10-01 16:12:16 -0500637 tap_win32_overlapped_t *handle;
bellard7fb843f2006-02-01 23:06:55 +0000638 } TAPState;
639
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100640static void tap_cleanup(NetClientState *nc)
aliguorib946a152009-04-17 17:11:08 +0000641{
Mark McLoughlindca91812009-11-25 18:49:05 +0000642 TAPState *s = DO_UPCAST(TAPState, nc, nc);
aliguorib946a152009-04-17 17:11:08 +0000643
644 qemu_del_wait_object(s->handle->tap_semaphore, NULL, NULL);
645
646 /* FIXME: need to kill thread and close file handle:
647 tap_win32_close(s);
648 */
aliguorib946a152009-04-17 17:11:08 +0000649}
650
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100651static ssize_t tap_receive(NetClientState *nc, const uint8_t *buf, size_t size)
bellard7fb843f2006-02-01 23:06:55 +0000652{
Mark McLoughlindca91812009-11-25 18:49:05 +0000653 TAPState *s = DO_UPCAST(TAPState, nc, nc);
bellard7fb843f2006-02-01 23:06:55 +0000654
Mark McLoughlin4f1c9422009-05-18 13:40:55 +0100655 return tap_win32_write(s->handle, buf, size);
bellard7fb843f2006-02-01 23:06:55 +0000656}
657
bellarde6cda8e2006-08-19 12:37:52 +0000658static void tap_win32_send(void *opaque)
bellard7fb843f2006-02-01 23:06:55 +0000659{
bellarde6cda8e2006-08-19 12:37:52 +0000660 TAPState *s = opaque;
bellard7fb843f2006-02-01 23:06:55 +0000661 uint8_t *buf;
662 int max_size = 4096;
663 int size;
664
bellard7fb843f2006-02-01 23:06:55 +0000665 size = tap_win32_read(s->handle, &buf, max_size);
666 if (size > 0) {
Mark McLoughlindca91812009-11-25 18:49:05 +0000667 qemu_send_packet(&s->nc, buf, size);
bellard7fb843f2006-02-01 23:06:55 +0000668 tap_win32_free_buffer(s->handle, buf);
669 }
670}
671
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100672static bool tap_has_ufo(NetClientState *nc)
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100673{
674 return false;
675}
676
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100677static bool tap_has_vnet_hdr(NetClientState *nc)
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100678{
679 return false;
680}
681
682int tap_probe_vnet_hdr_len(int fd, int len)
683{
684 return 0;
685}
686
687void tap_fd_set_vnet_hdr_len(int fd, int len)
688{
689}
690
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100691static void tap_using_vnet_hdr(NetClientState *nc, bool using_vnet_hdr)
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100692{
693}
694
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100695static void tap_set_offload(NetClientState *nc, int csum, int tso4,
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100696 int tso6, int ecn, int ufo)
697{
698}
699
700struct vhost_net *tap_get_vhost_net(NetClientState *nc)
701{
702 return NULL;
703}
704
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100705static bool tap_has_vnet_hdr_len(NetClientState *nc, int len)
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100706{
707 return false;
708}
709
Vincenzo Maffione3bac80d2014-02-06 17:02:19 +0100710static void tap_set_vnet_hdr_len(NetClientState *nc, int len)
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100711{
712 abort();
713}
714
Mark McLoughlindca91812009-11-25 18:49:05 +0000715static NetClientInfo net_tap_win32_info = {
Laszlo Ersek2be64a62012-07-17 16:17:12 +0200716 .type = NET_CLIENT_OPTIONS_KIND_TAP,
Mark McLoughlindca91812009-11-25 18:49:05 +0000717 .size = sizeof(TAPState),
718 .receive = tap_receive,
719 .cleanup = tap_cleanup,
Vincenzo Maffione2e753bc2014-02-06 17:02:17 +0100720 .has_ufo = tap_has_ufo,
721 .has_vnet_hdr = tap_has_vnet_hdr,
722 .has_vnet_hdr_len = tap_has_vnet_hdr_len,
723 .using_vnet_hdr = tap_using_vnet_hdr,
724 .set_offload = tap_set_offload,
725 .set_vnet_hdr_len = tap_set_vnet_hdr_len,
Mark McLoughlindca91812009-11-25 18:49:05 +0000726};
727
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100728static int tap_win32_init(NetClientState *peer, const char *model,
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100729 const char *name, const char *ifname)
bellard7fb843f2006-02-01 23:06:55 +0000730{
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100731 NetClientState *nc;
bellard7fb843f2006-02-01 23:06:55 +0000732 TAPState *s;
Mark McLoughlindca91812009-11-25 18:49:05 +0000733 tap_win32_overlapped_t *handle;
ths3b46e622007-09-17 08:09:54 +0000734
Mark McLoughlindca91812009-11-25 18:49:05 +0000735 if (tap_win32_open(&handle, ifname) < 0) {
bellard7fb843f2006-02-01 23:06:55 +0000736 printf("tap: Could not open '%s'\n", ifname);
737 return -1;
738 }
739
Stefan Hajnocziab5f3f82012-07-24 16:35:08 +0100740 nc = qemu_new_net_client(&net_tap_win32_info, peer, model, name);
ths3b46e622007-09-17 08:09:54 +0000741
Blue Swirl08fd0fa2009-12-04 18:06:20 +0000742 s = DO_UPCAST(TAPState, nc, nc);
743
Mark McLoughlindca91812009-11-25 18:49:05 +0000744 snprintf(s->nc.info_str, sizeof(s->nc.info_str),
bellard7fb843f2006-02-01 23:06:55 +0000745 "tap: ifname=%s", ifname);
bellarda18e5242006-06-25 17:18:27 +0000746
Mark McLoughlindca91812009-11-25 18:49:05 +0000747 s->handle = handle;
748
bellarde6cda8e2006-08-19 12:37:52 +0000749 qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
Mark McLoughlindca91812009-11-25 18:49:05 +0000750
bellard7fb843f2006-02-01 23:06:55 +0000751 return 0;
752}
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100753
Laszlo Ersek1a0c0952012-07-17 16:17:21 +0200754int net_init_tap(const NetClientOptions *opts, const char *name,
Stefan Hajnoczi4e68f7a2012-07-24 16:35:13 +0100755 NetClientState *peer)
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100756{
Laszlo Ersek08c573a2012-07-17 16:17:19 +0200757 const NetdevTapOptions *tap;
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100758
Laszlo Ersek08c573a2012-07-17 16:17:19 +0200759 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_TAP);
760 tap = opts->tap;
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100761
Laszlo Ersek08c573a2012-07-17 16:17:19 +0200762 if (!tap->has_ifname) {
Markus Armbruster1ecda022010-02-18 17:25:24 +0100763 error_report("tap: no interface name");
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100764 return -1;
765 }
766
Stefan Hajnoczid33d93b2012-07-24 16:35:05 +0100767 if (tap_win32_init(peer, "tap", name, tap->ifname) == -1) {
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100768 return -1;
769 }
770
Mark McLoughlina8ed73f2009-10-22 17:49:05 +0100771 return 0;
772}
773
Jason Wang16dbaf92013-01-30 19:12:32 +0800774int tap_enable(NetClientState *nc)
775{
776 abort();
777}
778
779int tap_disable(NetClientState *nc)
780{
781 abort();
782}