Revision 99a0949b tap-win32.c
| b/tap-win32.c | ||
|---|---|---|
| 84 | 84 |
unsigned char buffer [TUN_BUFFER_SIZE]; |
| 85 | 85 |
unsigned long read_size; |
| 86 | 86 |
struct tun_buffer_s* next; |
| 87 |
} tun_buffer_t;
|
|
| 87 |
} a_tun_buffer;
|
|
| 88 | 88 |
|
| 89 | 89 |
typedef struct tap_win32_overlapped {
|
| 90 | 90 |
HANDLE handle; |
| ... | ... | |
| 97 | 97 |
CRITICAL_SECTION free_list_cs; |
| 98 | 98 |
OVERLAPPED read_overlapped; |
| 99 | 99 |
OVERLAPPED write_overlapped; |
| 100 |
tun_buffer_t buffers[TUN_MAX_BUFFER_COUNT];
|
|
| 101 |
tun_buffer_t* free_list;
|
|
| 102 |
tun_buffer_t* output_queue_front;
|
|
| 103 |
tun_buffer_t* output_queue_back;
|
|
| 104 |
} tap_win32_overlapped_t;
|
|
| 100 |
a_tun_buffer buffers[TUN_MAX_BUFFER_COUNT];
|
|
| 101 |
a_tun_buffer* free_list;
|
|
| 102 |
a_tun_buffer* output_queue_front;
|
|
| 103 |
a_tun_buffer* output_queue_back;
|
|
| 104 |
} a_tap_win32_overlapped;
|
|
| 105 | 105 |
|
| 106 |
static tap_win32_overlapped_t tap_overlapped;
|
|
| 106 |
static a_tap_win32_overlapped tap_overlapped;
|
|
| 107 | 107 |
|
| 108 |
static tun_buffer_t* get_buffer_from_free_list(tap_win32_overlapped_t* const overlapped)
|
|
| 108 |
static a_tun_buffer* get_buffer_from_free_list(a_tap_win32_overlapped* const overlapped)
|
|
| 109 | 109 |
{
|
| 110 |
tun_buffer_t* buffer = NULL;
|
|
| 110 |
a_tun_buffer* buffer = NULL;
|
|
| 111 | 111 |
WaitForSingleObject(overlapped->free_list_semaphore, INFINITE); |
| 112 | 112 |
EnterCriticalSection(&overlapped->free_list_cs); |
| 113 | 113 |
buffer = overlapped->free_list; |
| ... | ... | |
| 118 | 118 |
return buffer; |
| 119 | 119 |
} |
| 120 | 120 |
|
| 121 |
static void put_buffer_on_free_list(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
|
|
| 121 |
static void put_buffer_on_free_list(a_tap_win32_overlapped* const overlapped, a_tun_buffer* const buffer)
|
|
| 122 | 122 |
{
|
| 123 | 123 |
EnterCriticalSection(&overlapped->free_list_cs); |
| 124 | 124 |
buffer->next = overlapped->free_list; |
| ... | ... | |
| 127 | 127 |
ReleaseSemaphore(overlapped->free_list_semaphore, 1, NULL); |
| 128 | 128 |
} |
| 129 | 129 |
|
| 130 |
static tun_buffer_t* get_buffer_from_output_queue(tap_win32_overlapped_t* const overlapped, const int block)
|
|
| 130 |
static a_tun_buffer* get_buffer_from_output_queue(a_tap_win32_overlapped* const overlapped, const int block)
|
|
| 131 | 131 |
{
|
| 132 |
tun_buffer_t* buffer = NULL;
|
|
| 132 |
a_tun_buffer* buffer = NULL;
|
|
| 133 | 133 |
DWORD result, timeout = block ? INFINITE : 0L; |
| 134 | 134 |
|
| 135 | 135 |
// Non-blocking call |
| ... | ... | |
| 160 | 160 |
return buffer; |
| 161 | 161 |
} |
| 162 | 162 |
|
| 163 |
static tun_buffer_t* get_buffer_from_output_queue_immediate (tap_win32_overlapped_t* const overlapped)
|
|
| 163 |
static a_tun_buffer* get_buffer_from_output_queue_immediate (a_tap_win32_overlapped* const overlapped)
|
|
| 164 | 164 |
{
|
| 165 | 165 |
return get_buffer_from_output_queue(overlapped, 0); |
| 166 | 166 |
} |
| 167 | 167 |
|
| 168 |
static void put_buffer_on_output_queue(tap_win32_overlapped_t* const overlapped, tun_buffer_t* const buffer)
|
|
| 168 |
static void put_buffer_on_output_queue(a_tap_win32_overlapped* const overlapped, a_tun_buffer* const buffer)
|
|
| 169 | 169 |
{
|
| 170 | 170 |
EnterCriticalSection(&overlapped->output_queue_cs); |
| 171 | 171 |
|
| ... | ... | |
| 393 | 393 |
&status, sizeof (status), &len, NULL); |
| 394 | 394 |
} |
| 395 | 395 |
|
| 396 |
static void tap_win32_overlapped_init(tap_win32_overlapped_t* const overlapped, const HANDLE handle)
|
|
| 396 |
static void tap_win32_overlapped_init(a_tap_win32_overlapped* const overlapped, const HANDLE handle)
|
|
| 397 | 397 |
{
|
| 398 | 398 |
overlapped->handle = handle; |
| 399 | 399 |
|
| ... | ... | |
| 436 | 436 |
{
|
| 437 | 437 |
unsigned index; |
| 438 | 438 |
for(index = 0; index < TUN_MAX_BUFFER_COUNT; index++) {
|
| 439 |
tun_buffer_t* element = &overlapped->buffers[index];
|
|
| 439 |
a_tun_buffer* element = &overlapped->buffers[index];
|
|
| 440 | 440 |
element->next = overlapped->free_list; |
| 441 | 441 |
overlapped->free_list = element; |
| 442 | 442 |
} |
| ... | ... | |
| 447 | 447 |
fprintf(stderr, "error creating tap_semaphore.\n"); |
| 448 | 448 |
} |
| 449 | 449 |
|
| 450 |
static int tap_win32_write(tap_win32_overlapped_t *overlapped,
|
|
| 450 |
static int tap_win32_write(a_tap_win32_overlapped *overlapped,
|
|
| 451 | 451 |
const void *buffer, unsigned long size) |
| 452 | 452 |
{
|
| 453 | 453 |
unsigned long write_size; |
| ... | ... | |
| 481 | 481 |
|
| 482 | 482 |
static DWORD WINAPI tap_win32_thread_entry(LPVOID param) |
| 483 | 483 |
{
|
| 484 |
tap_win32_overlapped_t *overlapped = (tap_win32_overlapped_t*)param;
|
|
| 484 |
a_tap_win32_overlapped *overlapped = (a_tap_win32_overlapped*)param;
|
|
| 485 | 485 |
unsigned long read_size; |
| 486 | 486 |
BOOL result; |
| 487 | 487 |
DWORD dwError; |
| 488 |
tun_buffer_t* buffer = get_buffer_from_free_list(overlapped);
|
|
| 488 |
a_tun_buffer* buffer = get_buffer_from_free_list(overlapped);
|
|
| 489 | 489 |
|
| 490 | 490 |
|
| 491 | 491 |
for (;;) {
|
| ... | ... | |
| 534 | 534 |
return 0; |
| 535 | 535 |
} |
| 536 | 536 |
|
| 537 |
static int tap_win32_read(tap_win32_overlapped_t *overlapped,
|
|
| 537 |
static int tap_win32_read(a_tap_win32_overlapped *overlapped,
|
|
| 538 | 538 |
uint8_t **pbuf, int max_size) |
| 539 | 539 |
{
|
| 540 | 540 |
int size = 0; |
| 541 | 541 |
|
| 542 |
tun_buffer_t* buffer = get_buffer_from_output_queue_immediate(overlapped);
|
|
| 542 |
a_tun_buffer* buffer = get_buffer_from_output_queue_immediate(overlapped);
|
|
| 543 | 543 |
|
| 544 | 544 |
if(buffer != NULL) {
|
| 545 | 545 |
*pbuf = buffer->buffer; |
| ... | ... | |
| 552 | 552 |
return size; |
| 553 | 553 |
} |
| 554 | 554 |
|
| 555 |
static void tap_win32_free_buffer(tap_win32_overlapped_t *overlapped,
|
|
| 555 |
static void tap_win32_free_buffer(a_tap_win32_overlapped *overlapped,
|
|
| 556 | 556 |
uint8_t *pbuf) |
| 557 | 557 |
{
|
| 558 |
tun_buffer_t* buffer = (tun_buffer_t*)pbuf;
|
|
| 558 |
a_tun_buffer* buffer = (a_tun_buffer*)pbuf;
|
|
| 559 | 559 |
put_buffer_on_free_list(overlapped, buffer); |
| 560 | 560 |
} |
| 561 | 561 |
|
| 562 |
static int tap_win32_open(tap_win32_overlapped_t **phandle,
|
|
| 562 |
static int tap_win32_open(a_tap_win32_overlapped **phandle,
|
|
| 563 | 563 |
const char *prefered_name) |
| 564 | 564 |
{
|
| 565 | 565 |
char device_path[256]; |
| ... | ... | |
| 628 | 628 |
|
| 629 | 629 |
typedef struct TAPState {
|
| 630 | 630 |
VLANClientState *vc; |
| 631 |
tap_win32_overlapped_t *handle;
|
|
| 631 |
a_tap_win32_overlapped *handle;
|
|
| 632 | 632 |
} TAPState; |
| 633 | 633 |
|
| 634 | 634 |
static void tap_cleanup(VLANClientState *vc) |
Also available in: Unified diff