[qemu.git] / tap-win32.c

/*
 *  TAP-Win32 -- A kernel driver to provide virtual tap device functionality
 *               on Windows.  Originally derived from the CIPE-Win32
 *               project by Damion K. Wilson, with extensive modifications by
 *               James Yonan.
 *
 *  All source code which derives from the CIPE-Win32 project is
 *  Copyright (C) Damion K. Wilson, 2003, and is released under the
 *  GPL version 2 (see below).
 *
 *  All other source code is Copyright (C) James Yonan, 2003-2004,
 *  and is released under the GPL version 2 (see below).
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program (see the file COPYING included with this
 *  distribution); if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "vl.h"
#include <stdio.h>
#include <windows.h>

/* NOTE: PCIBus is redefined in winddk.h */
#define PCIBus _PCIBus
#include <ddk/ntapi.h>
#include <ddk/winddk.h>
#include <ddk/ntddk.h>
#undef PCIBus

//=============
// TAP IOCTLs
//=============

#define TAP_CONTROL_CODE(request,method) \
  CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)

#define TAP_IOCTL_GET_MAC               TAP_CONTROL_CODE (1, METHOD_BUFFERED)
#define TAP_IOCTL_GET_VERSION           TAP_CONTROL_CODE (2, METHOD_BUFFERED)
#define TAP_IOCTL_GET_MTU               TAP_CONTROL_CODE (3, METHOD_BUFFERED)
#define TAP_IOCTL_GET_INFO              TAP_CONTROL_CODE (4, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
#define TAP_IOCTL_SET_MEDIA_STATUS      TAP_CONTROL_CODE (6, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_MASQ      TAP_CONTROL_CODE (7, METHOD_BUFFERED)
#define TAP_IOCTL_GET_LOG_LINE          TAP_CONTROL_CODE (8, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_SET_OPT   TAP_CONTROL_CODE (9, METHOD_BUFFERED)

//=================
// Registry keys
//=================

#define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"

#define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"

//======================
// Filesystem prefixes
//======================

#define USERMODEDEVICEDIR "\\\\.\\Global\\"
#define TAPSUFFIX         ".tap"


//======================
// Compile time configuration
//======================

//#define DEBUG_TAP_WIN32 1

#define TUN_ASYNCHRONOUS_WRITES 1

#define TUN_BUFFER_SIZE 1560
#define TUN_MAX_BUFFER_COUNT 32

/*
 * The data member "buffer" must be the first element in the tun_buffer
 * structure. See the function, tap_win32_free_buffer.
 */
typedef struct tun_buffer_s {
    unsigned char buffer [TUN_BUFFER_SIZE];
    unsigned long read_size;
    struct tun_buffer_s* next;
} tun_buffer_t;

typedef struct tap_win32_overlapped {
    HANDLE handle;
    HANDLE read_event;
    HANDLE write_event;
    HANDLE output_queue_semaphore;
    HANDLE free_list_semaphore;
    HANDLE tap_semaphore;
    CRITICAL_SECTION output_queue_cs;
    CRITICAL_SECTION free_list_cs;
    OVERLAPPED read_overlapped;
    OVERLAPPED write_overlapped;
    tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
    tun_buffer_t* free_list;
    tun_buffer_t* output_queue_front;
    tun_buffer_t* output_queue_back;
} tap_win32_overlapped_t;

static tap_win32_overlapped_t tap_overlapped;

static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
{
    tun_buffer_t* buffer = NULL;
    WaitForSingleObject(overlapped->free_list_semaphore, INFINITE);
    EnterCriticalSection(&overlapped->free_list_cs);
    buffer = overlapped->free_list;
//    assert(buffer != NULL);
    overlapped->free_list = buffer->next;
    LeaveCriticalSection(&overlapped->free_list_cs);
    buffer->next = NULL;
    return buffer;
}

static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
{
    EnterCriticalSection(&overlapped->free_list_cs);
    buffer->next = overlapped->free_list;
    overlapped->free_list = buffer;
    LeaveCriticalSection(&overlapped->free_list_cs);
    ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL);
}

static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
{
    tun_buffer_t* buffer = NULL;
    DWORD result, timeout = block ? INFINITE : 0L;

    // Non-blocking call
    result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);

    switch (result)
    {
        // The semaphore object was signaled.
        case WAIT_OBJECT_0:
            EnterCriticalSection(&overlapped->output_queue_cs);

            buffer = overlapped->output_queue_front;
            overlapped->output_queue_front = buffer->next;

            if(overlapped->output_queue_front == NULL) {
                overlapped->output_queue_back = NULL;
            }

            LeaveCriticalSection(&overlapped->output_queue_cs);
            break;

        // Semaphore was nonsignaled, so a time-out occurred.
        case WAIT_TIMEOUT:
            // Cannot open another window.
            break;
    }

    return buffer;
}

static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
{
    return get_buffer_from_output_queue(overlapped, 0);
}

static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
{
    EnterCriticalSection(&overlapped->output_queue_cs);

    if(overlapped->output_queue_front == NULL && overlapped->output_queue_back == NULL) {
        overlapped->output_queue_front = overlapped->output_queue_back = buffer;
    } else {
        buffer->next = NULL;
        overlapped->output_queue_back->next = buffer;
        overlapped->output_queue_back = buffer;
    }

    LeaveCriticalSection(&overlapped->output_queue_cs);

    ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
}


static int is_tap_win32_dev(const char *guid)
{
    HKEY netcard_key;
    LONG status;
    DWORD len;
    int i = 0;

    status = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        ADAPTER_KEY,
        0,
        KEY_READ,
        &netcard_key);

    if (status != ERROR_SUCCESS) {
        return FALSE;
    }

    for (;;) {
        char enum_name[256];
        char unit_string[256];
        HKEY unit_key;
        char component_id_string[] = "ComponentId";
        char component_id[256];
        char net_cfg_instance_id_string[] = "NetCfgInstanceId";
        char net_cfg_instance_id[256];
        DWORD data_type;

        len = sizeof (enum_name);
        status = RegEnumKeyEx(
            netcard_key,
            i,
            enum_name,
            &len,
            NULL,
            NULL,
            NULL,
            NULL);

        if (status == ERROR_NO_MORE_ITEMS)
            break;
        else if (status != ERROR_SUCCESS) {
            return FALSE;
        }

        snprintf (unit_string, sizeof(unit_string), "%s\\%s",
                  ADAPTER_KEY, enum_name);

        status = RegOpenKeyEx(
            HKEY_LOCAL_MACHINE,
            unit_string,
            0,
            KEY_READ,
            &unit_key);

        if (status != ERROR_SUCCESS) {
            return FALSE;
        } else {
            len = sizeof (component_id);
            status = RegQueryValueEx(
                unit_key,
                component_id_string,
                NULL,
                &data_type,
                component_id,
                &len);

            if (!(status != ERROR_SUCCESS || data_type != REG_SZ)) {
                len = sizeof (net_cfg_instance_id);
                status = RegQueryValueEx(
                    unit_key,
                    net_cfg_instance_id_string,
                    NULL,
                    &data_type,
                    net_cfg_instance_id,
                    &len);

                if (status == ERROR_SUCCESS && data_type == REG_SZ) {
                    if (/* !strcmp (component_id, TAP_COMPONENT_ID) &&*/
                        !strcmp (net_cfg_instance_id, guid)) {
                        RegCloseKey (unit_key);
                        RegCloseKey (netcard_key);
                        return TRUE;
                    }
                }
            }
            RegCloseKey (unit_key);
        }
        ++i;
    }

    RegCloseKey (netcard_key);
    return FALSE;
}

static int get_device_guid(
    char *name,
    int name_size,
    char *actual_name,
    int actual_name_size)
{
    LONG status;
    HKEY control_net_key;
    DWORD len;
    int i = 0;
    int stop = 0;

    status = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        NETWORK_CONNECTIONS_KEY,
        0,
        KEY_READ,
        &control_net_key);

    if (status != ERROR_SUCCESS) {
        return -1;
    }

    while (!stop)
    {
        char enum_name[256];
        char connection_string[256];
        HKEY connection_key;
        char name_data[256];
        DWORD name_type;
        const char name_string[] = "Name";

        len = sizeof (enum_name);
        status = RegEnumKeyEx(
            control_net_key,
            i,
            enum_name,
            &len,
            NULL,
            NULL,
            NULL,
            NULL);

        if (status == ERROR_NO_MORE_ITEMS)
            break;
        else if (status != ERROR_SUCCESS) {
            return -1;
        }

        snprintf(connection_string,
             sizeof(connection_string),
             "%s\\%s\\Connection",
             NETWORK_CONNECTIONS_KEY, enum_name);

        status = RegOpenKeyEx(
            HKEY_LOCAL_MACHINE,
            connection_string,
            0,
            KEY_READ,
            &connection_key);

        if (status == ERROR_SUCCESS) {
            len = sizeof (name_data);
            status = RegQueryValueEx(
                connection_key,
                name_string,
                NULL,
                &name_type,
                name_data,
                &len);

            if (status != ERROR_SUCCESS || name_type != REG_SZ) {
                    return -1;
            }
            else {
                if (is_tap_win32_dev(enum_name)) {
                    snprintf(name, name_size, "%s", enum_name);
                    if (actual_name) {
                        if (strcmp(actual_name, "") != 0) {
                            if (strcmp(name_data, actual_name) != 0) {
                                RegCloseKey (connection_key);
                                ++i;
                                continue;
                            }
                        }
                        else {
                            snprintf(actual_name, actual_name_size, "%s", name_data);
                        }
                    }
                    stop = 1;
                }
            }

            RegCloseKey (connection_key);
        }
        ++i;
    }

    RegCloseKey (control_net_key);

    if (stop == 0)
        return -1;

    return 0;
}

static int tap_win32_set_status(HANDLE handle, int status)
{
    unsigned long len = 0;

    return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
                &status, sizeof (status),
                &status, sizeof (status), &len, NULL);
}

static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
{
    overlapped->handle = handle;

    overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
    overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);

    overlapped->read_overlapped.Offset = 0;
    overlapped->read_overlapped.OffsetHigh = 0;
    overlapped->read_overlapped.hEvent = overlapped->read_event;

    overlapped->write_overlapped.Offset = 0;
    overlapped->write_overlapped.OffsetHigh = 0;
    overlapped->write_overlapped.hEvent = overlapped->write_event;

    InitializeCriticalSection(&overlapped->output_queue_cs);
    InitializeCriticalSection(&overlapped->free_list_cs);

    overlapped->output_queue_semaphore = CreateSemaphore(
        NULL,   // default security attributes
        0,   // initial count
        TUN_MAX_BUFFER_COUNT,   // maximum count
        NULL);  // unnamed semaphore

    if(!overlapped->output_queue_semaphore)  {
        fprintf(stderr, "error creating output queue semaphore!\n");
    }

    overlapped->free_list_semaphore = CreateSemaphore(
        NULL,   // default security attributes
        TUN_MAX_BUFFER_COUNT,   // initial count
        TUN_MAX_BUFFER_COUNT,   // maximum count
        NULL);  // unnamed semaphore

    if(!overlapped->free_list_semaphore)  {
        fprintf(stderr, "error creating free list semaphore!\n");
    }

    overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;

    {
        unsigned index;
        for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
            tun_buffer_t* element = &overlapped->buffers[index];
            element->next = overlapped->free_list;
            overlapped->free_list = element;
        }
    }
    /* To count buffers, initially no-signal. */
    overlapped->tap_semaphore = CreateSemaphore(NULL, 0, TUN_MAX_BUFFER_COUNT, NULL);
    if(!overlapped->tap_semaphore)
        fprintf(stderr, "error creating tap_semaphore.\n");
}

static int tap_win32_write(tap_win32_overlapped_t *overlapped,
                           const void *buffer, unsigned long size)
{
    unsigned long write_size;
    BOOL result;
    DWORD error;

    result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
                                  &write_size, FALSE);

    if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
        WaitForSingleObject(overlapped->write_event, INFINITE);

    result = WriteFile(overlapped->handle, buffer, size,
                       &write_size, &overlapped->write_overlapped);

    if (!result) {
        switch (error = GetLastError())
        {
        case ERROR_IO_PENDING:
#ifndef TUN_ASYNCHRONOUS_WRITES
            WaitForSingleObject(overlapped->write_event, INFINITE);
#endif
            break;
        default:
            return -1;
        }
    }

    return 0;
}

static DWORD WINAPI tap_win32_thread_entry(LPVOID param)
{
    tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
    unsigned long read_size;
    BOOL result;
    DWORD dwError;
    tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);


    for (;;) {
        result = ReadFile(overlapped->handle,
                          buffer->buffer,
                          sizeof(buffer->buffer),
                          &read_size,
                          &overlapped->read_overlapped);
        if (!result) {
            dwError = GetLastError();
            if (dwError == ERROR_IO_PENDING) {
                WaitForSingleObject(overlapped->read_event, INFINITE);
                result = GetOverlappedResult( overlapped->handle, &overlapped->read_overlapped,
                                              &read_size, FALSE);
                if (!result) {
#if DEBUG_TAP_WIN32
                    LPVOID lpBuffer;
                    dwError = GetLastError();
                    FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                   NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                                   (LPTSTR) & lpBuffer, 0, NULL );
                    fprintf(stderr, "Tap-Win32: Error GetOverlappedResult %d - %s\n", dwError, lpBuffer);
                    LocalFree( lpBuffer );
#endif
                }
            } else {
#if DEBUG_TAP_WIN32
                LPVOID lpBuffer;
                FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                               NULL, dwError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                               (LPTSTR) & lpBuffer, 0, NULL );
                fprintf(stderr, "Tap-Win32: Error ReadFile %d - %s\n", dwError, lpBuffer);
                LocalFree( lpBuffer );
#endif
            }
        }

        if(read_size > 0) {
            buffer->read_size = read_size;
            put_buffer_on_output_queue(overlapped, buffer);
            ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
            buffer = get_buffer_from_free_list(overlapped);
        }
    }

    return 0;
}

static int tap_win32_read(tap_win32_overlapped_t *overlapped,
                          uint8_t **pbuf, int max_size)
{
    int size = 0;

    tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);

    if(buffer != NULL) {
        *pbuf = buffer->buffer;
        size = (int)buffer->read_size;
        if(size > max_size) {
            size = max_size;
        }
    }

    return size;
}

static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
                                  char* pbuf)
{
    tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
    put_buffer_on_free_list(overlapped, buffer);
}

static int tap_win32_open(tap_win32_overlapped_t **phandle,
                          const char *prefered_name)
{
    char device_path[256];
    char device_guid[0x100];
    int rc;
    HANDLE handle;
    BOOL bret;
    char name_buffer[0x100] = {0, };
    struct {
        unsigned long major;
        unsigned long minor;
        unsigned long debug;
    } version;
    LONG version_len;
    DWORD idThread;
    HANDLE hThread;

    if (prefered_name != NULL)
        snprintf(name_buffer, sizeof(name_buffer), "%s", prefered_name);

    rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
    if (rc)
        return -1;

    snprintf (device_path, sizeof(device_path), "%s%s%s",
              USERMODEDEVICEDIR,
              device_guid,
              TAPSUFFIX);

    handle = CreateFile (
        device_path,
        GENERIC_READ | GENERIC_WRITE,
        0,
        0,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
        0 );

    if (handle == INVALID_HANDLE_VALUE) {
        return -1;
    }

    bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
                           &version, sizeof (version),
                           &version, sizeof (version), &version_len, NULL);

    if (bret == FALSE) {
        CloseHandle(handle);
        return -1;
    }

    if (!tap_win32_set_status(handle, TRUE)) {
        return -1;
    }

    tap_win32_overlapped_init(&tap_overlapped, handle);

    *phandle = &tap_overlapped;

    hThread = CreateThread(NULL, 0, tap_win32_thread_entry,
                           (LPVOID)&tap_overlapped, 0, &idThread);
    return 0;
}

/********************************************/

 typedef struct TAPState {
     VLANClientState *vc;
     tap_win32_overlapped_t *handle;
 } TAPState;

static void tap_receive(void *opaque, const uint8_t *buf, int size)
{
    TAPState *s = opaque;

    tap_win32_write(s->handle, buf, size);
}

static void tap_win32_send(void *opaque)
{
    TAPState *s = opaque;
    uint8_t *buf;
    int max_size = 4096;
    int size;

    size = tap_win32_read(s->handle, &buf, max_size);
    if (size > 0) {
        qemu_send_packet(s->vc, buf, size);
        tap_win32_free_buffer(s->handle, buf);
    }
}

int tap_win32_init(VLANState *vlan, const char *ifname)
{
    TAPState *s;

    s = qemu_mallocz(sizeof(TAPState));
    if (!s)
        return -1;
    if (tap_win32_open(&s->handle, ifname) < 0) {
        printf("tap: Could not open '%s'\n", ifname);
        return -1;
    }

    s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);

    snprintf(s->vc->info_str, sizeof(s->vc->info_str),
             "tap: ifname=%s", ifname);

    qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
    return 0;
}
Commit	Line	Data
7fb843f8 FB	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>
	32
	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
	39
	40	//=============
	41	// TAP IOCTLs
	42	//=============
	43
	44	#define TAP_CONTROL_CODE(request,method) \
	45	CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
	46
	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)
	56
	57	//=================
	58	// Registry keys
	59	//=================
	60
	61	#define ADAPTER_KEY "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
	62
	63	#define NETWORK_CONNECTIONS_KEY "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}"
	64
65	//======================
66	// Filesystem prefixes
67	//======================
68
69	#define USERMODEDEVICEDIR "\\\\.\\Global\\"
70	#define TAPSUFFIX ".tap"
71
72
73	//======================
74	// Compile time configuration
75	//======================
76
77	//#define DEBUG_TAP_WIN32 1
78
79	#define TUN_ASYNCHRONOUS_WRITES 1
80
81	#define TUN_BUFFER_SIZE 1560
82	#define TUN_MAX_BUFFER_COUNT 32
83
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;
93
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;
e6cda8e2	100	HANDLE tap_semaphore;
7fb843f8 FB	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;
	110
	111	static tap_win32_overlapped_t tap_overlapped;
	112
5fafdf24	113	static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
7fb843f8 FB	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	}
	125
	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	}
	134
5fafdf24	135	static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
7fb843f8 FB	136	{
	137	tun_buffer_t* buffer = NULL;
	138	DWORD result, timeout = block ? INFINITE : 0L;
	139
	140	// Non-blocking call
5fafdf24	141	result = WaitForSingleObject(overlapped->output_queue_semaphore, timeout);
7fb843f8	142
5fafdf24 TS	143	switch (result)
5fafdf24 TS	144	{
7fb843f8	145	// The semaphore object was signaled.
5fafdf24	146	case WAIT_OBJECT_0:
7fb843f8 FB	147	EnterCriticalSection(&overlapped->output_queue_cs);
	148
	149	buffer = overlapped->output_queue_front;
	150	overlapped->output_queue_front = buffer->next;
	151
	152	if(overlapped->output_queue_front == NULL) {
	153	overlapped->output_queue_back = NULL;
	154	}
	155
	156	LeaveCriticalSection(&overlapped->output_queue_cs);
5fafdf24	157	break;
7fb843f8 FB	158
7fb843f8 FB	159	// Semaphore was nonsignaled, so a time-out occurred.
5fafdf24	160	case WAIT_TIMEOUT:
7fb843f8	161	// Cannot open another window.
5fafdf24	162	break;
7fb843f8 FB	163	}
	164
	165	return buffer;
	166	}
	167
5fafdf24	168	static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
7fb843f8 FB	169	{
	170	return get_buffer_from_output_queue(overlapped, 0);
	171	}
	172
	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);
	176
	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	}
	184
	185	LeaveCriticalSection(&overlapped->output_queue_cs);
	186
	187	ReleaseSemaphore(overlapped->output_queue_semaphore, 1, NULL);
	188	}
	189
	190
	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;
	197
	198	status = RegOpenKeyEx(
	199	HKEY_LOCAL_MACHINE,
	200	ADAPTER_KEY,
	201	0,
	202	KEY_READ,
	203	&netcard_key);
	204
	205	if (status != ERROR_SUCCESS) {
	206	return FALSE;
	207	}
	208
	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;
	218
	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);
	229
	230	if (status == ERROR_NO_MORE_ITEMS)
	231	break;
	232	else if (status != ERROR_SUCCESS) {
233	return FALSE;
234	}
235
236	snprintf (unit_string, sizeof(unit_string), "%s\\%s",
237	ADAPTER_KEY, enum_name);
238
239	status = RegOpenKeyEx(
240	HKEY_LOCAL_MACHINE,
241	unit_string,
242	0,
243	KEY_READ,
244	&unit_key);
245
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);
257
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);
267
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	}
281
282	RegCloseKey (netcard_key);
283	return FALSE;
284	}
285
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;
297
298	status = RegOpenKeyEx(
299	HKEY_LOCAL_MACHINE,
300	NETWORK_CONNECTIONS_KEY,
301	0,
302	KEY_READ,
303	&control_net_key);
304
305	if (status != ERROR_SUCCESS) {
306	return -1;
307	}
308
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";
317
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);
328
329	if (status == ERROR_NO_MORE_ITEMS)
330	break;
331	else if (status != ERROR_SUCCESS) {
332	return -1;
333	}
334
5fafdf24	335	snprintf(connection_string,
7fb843f8 FB	336	sizeof(connection_string),
	337	"%s\\%s\\Connection",
	338	NETWORK_CONNECTIONS_KEY, enum_name);
	339
	340	status = RegOpenKeyEx(
	341	HKEY_LOCAL_MACHINE,
	342	connection_string,
	343	0,
	344	KEY_READ,
	345	&connection_key);
3b46e624	346
7fb843f8 FB	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);
	356
	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	}
	378
	379	RegCloseKey (connection_key);
	380	}
	381	++i;
	382	}
	383
	384	RegCloseKey (control_net_key);
	385
	386	if (stop == 0)
	387	return -1;
	388
	389	return 0;
	390	}
	391
	392	static int tap_win32_set_status(HANDLE handle, int status)
	393	{
	394	unsigned long len = 0;
	395
	396	return DeviceIoControl(handle, TAP_IOCTL_SET_MEDIA_STATUS,
	397	&status, sizeof (status),
	398	&status, sizeof (status), &len, NULL);
	399	}
	400
	401	static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
	402	{
	403	overlapped->handle = handle;
	404
	405	overlapped->read_event = CreateEvent(NULL, FALSE, FALSE, NULL);
	406	overlapped->write_event = CreateEvent(NULL, FALSE, FALSE, NULL);
	407
	408	overlapped->read_overlapped.Offset = 0;
	409	overlapped->read_overlapped.OffsetHigh = 0;
	410	overlapped->read_overlapped.hEvent = overlapped->read_event;
411
412	overlapped->write_overlapped.Offset = 0;
413	overlapped->write_overlapped.OffsetHigh = 0;
414	overlapped->write_overlapped.hEvent = overlapped->write_event;
415
416	InitializeCriticalSection(&overlapped->output_queue_cs);
417	InitializeCriticalSection(&overlapped->free_list_cs);
418
5fafdf24	419	overlapped->output_queue_semaphore = CreateSemaphore(
7fb843f8 FB	420	NULL, // default security attributes
	421	0, // initial count
	422	TUN_MAX_BUFFER_COUNT, // maximum count
	423	NULL); // unnamed semaphore
	424
	425	if(!overlapped->output_queue_semaphore) {
	426	fprintf(stderr, "error creating output queue semaphore!\n");
	427	}
	428
5fafdf24	429	overlapped->free_list_semaphore = CreateSemaphore(
7fb843f8 FB	430	NULL, // default security attributes
	431	TUN_MAX_BUFFER_COUNT, // initial count
	432	TUN_MAX_BUFFER_COUNT, // maximum count
	433	NULL); // unnamed semaphore
	434
	435	if(!overlapped->free_list_semaphore) {
	436	fprintf(stderr, "error creating free list semaphore!\n");
	437	}
	438
	439	overlapped->free_list = overlapped->output_queue_front = overlapped->output_queue_back = NULL;
	440
	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	}
e6cda8e2 FB	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");
7fb843f8 FB	453	}
7fb843f8 FB	454
5fafdf24	455	static int tap_win32_write(tap_win32_overlapped_t *overlapped,
7fb843f8 FB	456	const void *buffer, unsigned long size)
	457	{
	458	unsigned long write_size;
	459	BOOL result;
	460	DWORD error;
	461
	462	result = GetOverlappedResult( overlapped->handle, &overlapped->write_overlapped,
	463	&write_size, FALSE);
	464
	465	if (!result && GetLastError() == ERROR_IO_INCOMPLETE)
	466	WaitForSingleObject(overlapped->write_event, INFINITE);
	467
	468	result = WriteFile(overlapped->handle, buffer, size,
	469	&write_size, &overlapped->write_overlapped);
3b46e624	470
5fafdf24	471	if (!result) {
7fb843f8	472	switch (error = GetLastError())
5fafdf24 TS	473	{
5fafdf24 TS	474	case ERROR_IO_PENDING:
7fb843f8 FB	475	#ifndef TUN_ASYNCHRONOUS_WRITES
	476	WaitForSingleObject(overlapped->write_event, INFINITE);
	477	#endif
	478	break;
	479	default:
	480	return -1;
5fafdf24	481	}
7fb843f8 FB	482	}
	483
	484	return 0;
	485	}
	486
	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);
	494
	495
	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	}
	530
	531	if(read_size > 0) {
	532	buffer->read_size = read_size;
	533	put_buffer_on_output_queue(overlapped, buffer);
e6cda8e2	534	ReleaseSemaphore(overlapped->tap_semaphore, 1, NULL);
7fb843f8 FB	535	buffer = get_buffer_from_free_list(overlapped);
	536	}
	537	}
	538
	539	return 0;
	540	}
	541
5fafdf24	542	static int tap_win32_read(tap_win32_overlapped_t *overlapped,
7fb843f8 FB	543	uint8_t **pbuf, int max_size)
	544	{
	545	int size = 0;
	546
	547	tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
	548
	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	}
	556
	557	return size;
	558	}
	559
5fafdf24 TS	560	static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
5fafdf24 TS	561	char* pbuf)
7fb843f8 FB	562	{
	563	tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
	564	put_buffer_on_free_list(overlapped, buffer);
	565	}
	566
5fafdf24	567	static int tap_win32_open(tap_win32_overlapped_t **phandle,
7fb843f8 FB	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;
	584
	585	if (prefered_name != NULL)
	586	snprintf(name_buffer, sizeof(name_buffer), "%s", prefered_name);
	587
	588	rc = get_device_guid(device_guid, sizeof(device_guid), name_buffer, sizeof(name_buffer));
	589	if (rc)
	590	return -1;
	591
	592	snprintf (device_path, sizeof(device_path), "%s%s%s",
	593	USERMODEDEVICEDIR,
	594	device_guid,
	595	TAPSUFFIX);
	596
	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 );
	605
	606	if (handle == INVALID_HANDLE_VALUE) {
	607	return -1;
	608	}
	609
	610	bret = DeviceIoControl(handle, TAP_IOCTL_GET_VERSION,
	611	&version, sizeof (version),
	612	&version, sizeof (version), &version_len, NULL);
	613
	614	if (bret == FALSE) {
	615	CloseHandle(handle);
	616	return -1;
	617	}
	618
	619	if (!tap_win32_set_status(handle, TRUE)) {
	620	return -1;
	621	}
	622
	623	tap_win32_overlapped_init(&tap_overlapped, handle);
	624
	625	*phandle = &tap_overlapped;
	626
	627	hThread = CreateThread(NULL, 0, tap_win32_thread_entry,
	628	(LPVOID)&tap_overlapped, 0, &idThread);
7fb843f8 FB	629	return 0;
	630	}
	631
	632	/********************************************/
	633
	634	typedef struct TAPState {
	635	VLANClientState *vc;
	636	tap_win32_overlapped_t *handle;
	637	} TAPState;
	638
7fb843f8 FB	639	static void tap_receive(void opaque, const uint8_t buf, int size)
	640	{
	641	TAPState *s = opaque;
	642
	643	tap_win32_write(s->handle, buf, size);
	644	}
	645
e6cda8e2	646	static void tap_win32_send(void *opaque)
7fb843f8	647	{
e6cda8e2	648	TAPState *s = opaque;
7fb843f8 FB	649	uint8_t *buf;
	650	int max_size = 4096;
	651	int size;
	652
7fb843f8 FB	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	}
	659
	660	int tap_win32_init(VLANState vlan, const char ifname)
	661	{
	662	TAPState *s;
3b46e624	663
7fb843f8 FB	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	}
	671
4081fccf	672	s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3b46e624	673
7fb843f8 FB	674	snprintf(s->vc->info_str, sizeof(s->vc->info_str),
7fb843f8 FB	675	"tap: ifname=%s", ifname);
a18e524a	676
e6cda8e2	677	qemu_add_wait_object(s->handle->tap_semaphore, tap_win32_send, s);
7fb843f8 FB	678	return 0;
7fb843f8 FB	679	}