diff --git a/project.raddbg b/project.raddbg index fb4d5d7a..e1df3c4e 100755 --- a/project.raddbg +++ b/project.raddbg @@ -7,6 +7,7 @@ target: working_directory: build arguments: "--user:raddbg_test.user" debug_subprocesses: 0 + enabled: 1 } target: { @@ -17,7 +18,6 @@ target: { executable: "build/mule_main.exe" working_directory: build - enabled: 1 } target: { diff --git a/src/base/base_entry_point.c b/src/base/base_entry_point.c index ddf34406..169f2573 100644 --- a/src/base/base_entry_point.c +++ b/src/base/base_entry_point.c @@ -58,6 +58,9 @@ main_thread_base_entry_point(int arguments_count, char **arguments) } //- rjf: initialize all included layers +#if defined(SOCKET_H) && !defined(SOCKET_INIT_MANUAL) + sock_init(); +#endif #if defined(HTTP_H) && !defined(HTTP_INIT_MANUAL) http_init(); #endif @@ -222,6 +225,9 @@ async_thread_entry_point(void *params) #if defined(FILE_STREAM_H) fs_async_tick(); #endif +#if defined(SOCKET_H) + sock_async_tick(); +#endif #if defined(HTTP_H) http_async_tick(); #endif diff --git a/src/base/base_ring.c b/src/base/base_ring.c index 41f26095..a9145e82 100644 --- a/src/base/base_ring.c +++ b/src/base/base_ring.c @@ -13,16 +13,42 @@ make_ring(Arena *arena, U64 size) return ring; } -internal B32 -ring_try_write(Ring *ring, U64 size, void *ptr) +internal void * +ring_try_push(Ring *ring, U64 size) { U64 bytes_unconsumed = (ring->write_pos - ring->read_pos); U64 bytes_available = ring->size - bytes_unconsumed; - B32 result = 0; + void *base = 0; if(bytes_available >= size) + { + base = ring->base + ring->write_pos%ring->size; + ring->write_pos += size; + } + return base; +} + +internal void * +ring_try_pop(Ring *ring, U64 size) +{ + U64 bytes_unconsumed = (ring->write_pos - ring->read_pos); + void *base = 0; + if(bytes_unconsumed >= size) + { + base = ring->base + ring->read_pos%ring->size; + ring->read_pos += size; + } + return base; +} + +internal B32 +ring_try_write(Ring *ring, U64 size, void *ptr) +{ + B32 result = 0; + void *dst = ring_try_push(ring, size); + if(dst) { result = 1; - ring->write_pos += wrapped_write(ring->base, ring->size, ring->write_pos, ptr, size); + MemoryCopy(dst, ptr, size); } return result; } @@ -30,12 +56,12 @@ ring_try_write(Ring *ring, U64 size, void *ptr) internal B32 ring_try_read(Ring *ring, U64 size, void *ptr) { - U64 bytes_unconsumed = (ring->write_pos - ring->read_pos); B32 result = 0; - if(bytes_unconsumed >= size) + void *src = ring_try_pop(ring, size); + if(src) { result = 1; - ring->read_pos += wrapped_read(ring->base, ring->size, ring->read_pos, ptr, size); + MemoryCopy(ptr, src, size); } return result; } @@ -76,16 +102,27 @@ internal void guarded_ring_close(RingGuard *guard) { mutex_drop(guard->r->mutex); + cond_var_broadcast(guard->r->cv); +} + +internal void * +guarded_ring_try_push(RingGuard *guard, U64 size) +{ + void *result = ring_try_push(guard->r->ring, size); + return result; +} + +internal void * +guarded_ring_try_pop(RingGuard *guard, U64 size) +{ + void *result = ring_try_pop(guard->r->ring, size); + return result; } internal B32 guarded_ring_try_write(RingGuard *guard, U64 size, void *ptr) { B32 result = ring_try_write(guard->r->ring, size, ptr); - if(result) - { - cond_var_broadcast(guard->r->cv); - } return result; } @@ -93,9 +130,43 @@ internal B32 guarded_ring_try_read(RingGuard *guard, U64 size, void *ptr) { B32 result = ring_try_read(guard->r->ring, size, ptr); - if(result) + return result; +} + +internal void * +guarded_ring_push_or_wait(RingGuard *guard, U64 size, U64 endt_us) +{ + void *result = 0; + for(;!result;) { - cond_var_broadcast(guard->r->cv); + result = guarded_ring_try_push(guard, size); + if(now_time_us() >= endt_us) + { + break; + } + if(!result) + { + cond_var_wait(guard->r->cv, guard->r->mutex, endt_us); + } + } + return result; +} + +internal void * +guarded_ring_pop_or_wait(RingGuard *guard, U64 size, U64 endt_us) +{ + void *result = 0; + for(;!result;) + { + result = guarded_ring_try_pop(guard, size); + if(now_time_us() >= endt_us) + { + break; + } + if(!result) + { + cond_var_wait(guard->r->cv, guard->r->mutex, endt_us); + } } return result; } @@ -103,37 +174,23 @@ guarded_ring_try_read(RingGuard *guard, U64 size, void *ptr) internal B32 guarded_ring_write_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us) { - B32 write_good = 0; - for(;!write_good;) + void *dst = guarded_ring_push_or_wait(guard, size, endt_us); + B32 result = !!dst; + if(dst) { - write_good = guarded_ring_try_write(guard, size, ptr); - if(now_time_us() >= endt_us) - { - break; - } - if(!write_good) - { - cond_var_wait(guard->r->cv, guard->r->mutex, endt_us); - } + MemoryCopy(dst, ptr, size); } - return write_good; + return result; } internal B32 guarded_ring_read_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us) { - B32 read_good = 0; - for(;!read_good;) + void *src = guarded_ring_pop_or_wait(guard, size, endt_us); + B32 result = !!src; + if(src) { - read_good = guarded_ring_try_read(guard, size, ptr); - if(now_time_us() >= endt_us) - { - break; - } - if(!read_good) - { - cond_var_wait(guard->r->cv, guard->r->mutex, endt_us); - } + MemoryCopy(ptr, src, size); } - return read_good; + return result; } diff --git a/src/base/base_ring.h b/src/base/base_ring.h index 59b07b86..f7e8e188 100644 --- a/src/base/base_ring.h +++ b/src/base/base_ring.h @@ -31,6 +31,8 @@ struct RingGuard //~ rjf: Ring Functions internal Ring *make_ring(Arena *arena, U64 size); +internal void *ring_try_push(Ring *ring, U64 size); +internal void *ring_try_pop(Ring *ring, U64 size); internal B32 ring_try_write(Ring *ring, U64 size, void *ptr); internal B32 ring_try_read(Ring *ring, U64 size, void *ptr); #define ring_try_write_struct(ring, ptr) ring_try_write((ring), sizeof(*(ptr)), (ptr)) @@ -43,10 +45,14 @@ internal GuardedRing *guarded_ring_alloc(Arena *arena, U64 size); internal void guarded_ring_release(GuardedRing *ring); internal RingGuard guarded_ring_open(GuardedRing *ring); internal void guarded_ring_close(RingGuard *guard); +internal void *guarded_ring_try_push(RingGuard *guard, U64 size); +internal void *guarded_ring_try_pop(RingGuard *guard, U64 size); internal B32 guarded_ring_try_write(RingGuard *guard, U64 size, void *ptr); internal B32 guarded_ring_try_read(RingGuard *guard, U64 size, void *ptr); #define guarded_ring_try_write_struct(ring, ptr) guarded_ring_try_write((ring), sizeof(*(ptr)), (ptr)) #define guarded_ring_try_read_struct(ring, ptr) guarded_ring_try_read((ring), sizeof(*(ptr)), (ptr)) +internal void *guarded_ring_push_or_wait(RingGuard *guard, U64 size, U64 endt_us); +internal void *guarded_ring_pop_or_wait(RingGuard *guard, U64 size, U64 endt_us); internal B32 guarded_ring_write_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us); internal B32 guarded_ring_read_or_wait(RingGuard *guard, U64 size, void *ptr, U64 endt_us); #define guarded_ring_write_struct_or_wait(ring, ptr, endt_us) guarded_ring_write_or_wait((ring), sizeof(*(ptr)), (ptr), (endt_us)) diff --git a/src/raddbg/raddbg_core.c b/src/raddbg/raddbg_core.c index 9f529b1b..88c4427e 100644 --- a/src/raddbg/raddbg_core.c +++ b/src/raddbg/raddbg_core.c @@ -7442,6 +7442,7 @@ rd_window_frame(void) { rd_cmd_kind_info_table[RD_CmdKind_Open].string, rd_cmd_kind_info_table[RD_CmdKind_OpenSourceFileFromDebugInfo].string, + rd_cmd_kind_info_table[RD_CmdKind_OpenCrashDump].string, {0},//- rd_cmd_kind_info_table[RD_CmdKind_NewProject].string, rd_cmd_kind_info_table[RD_CmdKind_OpenProject].string, @@ -7460,6 +7461,7 @@ rd_window_frame(void) { 'o', 'i', + 'd', 0,//- 'j', 'p', diff --git a/src/raddbg/raddbg_main.c b/src/raddbg/raddbg_main.c index 3e419070..eb7459c9 100644 --- a/src/raddbg/raddbg_main.c +++ b/src/raddbg/raddbg_main.c @@ -388,6 +388,7 @@ #include "mdesk/mdesk.h" #include "window_manager/window_manager_inc.h" #include "shell/shell_inc.h" +// #include "socket/socket_inc.h" #include "http/http_inc.h" #include "symbol_server/symbol_server_inc.h" #include "config/config_inc.h" @@ -450,6 +451,7 @@ #include "mdesk/mdesk.c" #include "window_manager/window_manager_inc.c" #include "shell/shell_inc.c" +// #include "socket/socket_inc.c" #include "http/http_inc.c" #include "symbol_server/symbol_server_inc.c" #include "config/config_inc.c" diff --git a/src/socket/socket.c b/src/socket/socket.c new file mode 100644 index 00000000..8accf484 --- /dev/null +++ b/src/socket/socket.c @@ -0,0 +1,96 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Helpers + +internal SOCK_Endpoint +sock_endpoint_from_string_port(String8 address, U16 port) +{ + //- rjf: detect kind + SOCK_EndpointKind kind = SOCK_EndpointKind_IPv4; + { + if(str8_find_needle(address, 0, s(":"), 0) < address.size) + { + kind = SOCK_EndpointKind_IPv6; + } + } + + //- rjf: fill based on format + SOCK_Endpoint ep = {0}; + ep.port = port; + ep.kind = kind; + switch(kind) + { + default: + case SOCK_EndpointKind_IPv4: + { + U64 off = 0; + U64 part_start_off = 0; + for(;off < 4;) + { + U64 part_end_off = str8_find_needle(address, part_start_off+1, s("."), 0); + String8 part = str8_substr(address, r1u64(part_start_off, part_end_off)); + U64 part_val = u64_from_str8(part, 10); + ep.address_u8[off] = (U8)part_val; + part_start_off = part_end_off+1; + off += 1; + if(part_end_off >= address.size) + { + break; + } + } + }break; + case SOCK_EndpointKind_IPv6: + { + U64 off = 0; + U64 part_start_off = 0; + U64 double_colon_off = 0; + for(;off < 8;) + { + U64 part_end_off = str8_find_needle(address, part_start_off+1, s(":"), 0); + String8 part = str8_substr(address, r1u64(part_start_off, part_end_off)); + U64 part_val = u64_from_str8(part, 16); + ep.address_u16[off] = (U16)part_val; + part_start_off = part_end_off+1; + if(part_end_off+1 < address.size && address.str[part_end_off+1] == ':') + { + double_colon_off = off; + } + off += 1; + if(part_end_off >= address.size) + { + break; + } + } + if(off < 8 && double_colon_off < 8) + { + U64 shift_amt = 8 - off; + MemoryCopy(&ep.address_u16[0] + double_colon_off + shift_amt, &ep.address_u16[0] + double_colon_off, sizeof(U16) * (off - double_colon_off)); + } + }break; + } +} + +internal SOCK_Endpoint +sock_endpoint_from_string(String8 address_and_port) +{ + String8 addr = {0}; + U64 port_off = 0; + if(address_and_port.size > 0 && address_and_port.str[0] == '[') + { + U64 addr_end_off = str8_find_needle(address_and_port, 1, s("]"), 0); + addr = str8_substr(address_and_port, r1u64(1, addr_end_off)); + port_off = str8_find_needle(address_and_port, addr_end_off+1, s(":"), 0)+1; + } + else + { + U64 colon_off = str8_find_needle(address_and_port, 0, s(":"), 0); + port_off = colon_off + 1; + addr = str8_prefix(address_and_port, colon_off); + } + String8 port_string = str8_skip(address_and_port, port_off); + U16 port = u64_from_str8(port_string, 10); + SOCK_Endpoint ep = sock_endpoint_from_string_port(addr, port); + return ep; +} diff --git a/src/socket/socket.h b/src/socket/socket.h new file mode 100644 index 00000000..cc07e715 --- /dev/null +++ b/src/socket/socket.h @@ -0,0 +1,67 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef SOCKET_H +#define SOCKET_H + +#if !defined(SOCKET_PORT) +# define SOCKET_PORT 7423 +#endif + +typedef enum SOCK_Protocol +{ + SOCK_Protocol_TCP, + SOCK_Protocol_UDP, +} +SOCK_Protocol; + +typedef U8 SOCK_EndpointKind; +typedef enum SOCK_EndpointKindEnum +{ + SOCK_EndpointKind_IPv4, + SOCK_EndpointKind_IPv6, +} +SOCK_EndpointKindEnum; + +typedef struct SOCK_Endpoint SOCK_Endpoint; +struct SOCK_Endpoint +{ + U16 port; + SOCK_EndpointKind kind; + U8 _pad_0; + U32 _pad_1; + union + { + U8 address_u8[16]; + U16 address_u16[8]; + }; +}; + +//////////////////////////////// +//~ rjf: Helpers + +internal SOCK_Endpoint sock_endpoint_from_string_port(String8 address, U16 port); +internal SOCK_Endpoint sock_endpoint_from_string(String8 address_and_port); + +//////////////////////////////// +//~ rjf: @per_os_impl Top-Level Layer Calls + +#if !defined(NEED_ASYNC) +# define NEED_ASYNC 1 +#endif +internal void sock_init(void); +internal void sock_async_tick(void); + +//////////////////////////////// +//~ rjf: @per_os_impl Sends + +internal U64 sock_send(U8 *ptr, U64 size, SOCK_Protocol *protocol_in, SOCK_Endpoint *endpoint_in, U64 endt_us); +#define sock_send_struct(ptr, protocol_in, endpoint_in, endt_us) sock_send((ptr), sizeof(*(ptr)), (endpoint_in), (endt_us)) + +//////////////////////////////// +//~ rjf: @per_os_impl Receives + +internal U64 sock_recv(U8 *ptr, U64 size, SOCK_Protocol *protocol_out, SOCK_Endpoint *endpoint_out, U64 endt_us); +#define sock_recv_struct(ptr, protocol_out, endpoint_out, endt_us) sock_recv((ptr), sizeof(*(ptr)), (endpoint_out), (endt_us)) + +#endif // SOCKET_H diff --git a/src/socket/socket_inc.c b/src/socket/socket_inc.c new file mode 100644 index 00000000..28e10284 --- /dev/null +++ b/src/socket/socket_inc.c @@ -0,0 +1,9 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#include "socket.c" +#if OS_WINDOWS +# include "win32/socket/win32_socket.c" +#else +# include "socket_stub.c" +#endif diff --git a/src/socket/socket_inc.h b/src/socket/socket_inc.h new file mode 100644 index 00000000..56928a79 --- /dev/null +++ b/src/socket/socket_inc.h @@ -0,0 +1,14 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef SOCKET_INC_H +#define SOCKET_INC_H + +#include "socket.h" +#if OS_WINDOWS +# include "win32/socket/win32_socket.h" +#else +# include "socket_stub.h" +#endif + +#endif // SOCKET_INC_H diff --git a/src/socket/socket_stub.c b/src/socket/socket_stub.c new file mode 100644 index 00000000..639c9a8a --- /dev/null +++ b/src/socket/socket_stub.c @@ -0,0 +1,7 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +internal void sock_init(void){} +internal void sock_async_tick(void){} +internal U64 sock_send(U8 *ptr, U64 size, SOCK_Protocol *protocol_in, SOCK_Endpoint *endpoint_in, U64 endt_us){return 0;} +internal U64 sock_recv(U8 *ptr, U64 size, SOCK_Protocol *protocol_in, SOCK_Endpoint *endpoint_in, U64 endt_us){return 0;} diff --git a/src/socket/socket_stub.h b/src/socket/socket_stub.h new file mode 100644 index 00000000..6ffde4b0 --- /dev/null +++ b/src/socket/socket_stub.h @@ -0,0 +1,7 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef SOCKET_STUB_H +#define SOCKET_STUB_H + +#endif // SOCKET_STUB_H diff --git a/src/win32/socket/win32_socket.c b/src/win32/socket/win32_socket.c new file mode 100644 index 00000000..00adcc40 --- /dev/null +++ b/src/win32/socket/win32_socket.c @@ -0,0 +1,136 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Listener Threads + +internal void +w32_sock_tcp_listener_thread_entry_point(void *p) +{ + ThreadNameF("w32_sock_tcp_listener_thread"); + for(;;) + { + SOCKET new_socket = accept(w32_sock_state->tcp_listen_socket, 0, 0); + if(new_socket != INVALID_SOCKET) + { + // TODO(rjf) + } + } +} + +internal void +w32_sock_udp_listener_thread_entry_point(void *p) +{ + ThreadNameF("w32_sock_udp_listener_thread"); + for(;;) + { + SOCKET new_socket = accept(w32_sock_state->udp_listen_socket, 0, 0); + if(new_socket != INVALID_SOCKET) + { + // TODO(rjf) + } + } +} + +//////////////////////////////// +//~ rjf: @per_os_impl Top-Level Layer Calls + +internal void +sock_init(void) +{ + // NOTE(rjf): winsock2 is already initialized by the base layer for RIO function grabbing. + + //- rjf: set up state + Arena *arena = arena_alloc(); + w32_sock_state = push_array(arena, W32_SOCK_State, 1); + w32_sock_state->arena = arena; + w32_sock_state->u2s_ring = guarded_ring_alloc(arena, KB(256)); + w32_sock_state->s2u_ring = guarded_ring_alloc(arena, KB(256)); + + //- rjf: create listener sockets + w32_sock_state->tcp_listen_socket = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP); + w32_sock_state->udp_listen_socket = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP); + { + DWORD ipv6only = 0; + setsockopt(w32_sock_state->tcp_listen_socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only)); + setsockopt(w32_sock_state->udp_listen_socket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only, sizeof(ipv6only)); + } + + //- rjf: bind listener sockets + { + struct sockaddr_in server_addr; + server_addr.sin_family = AF_INET6; + server_addr.sin_addr.s_addr = INADDR_ANY; + server_addr.sin_port = htons(SOCKET_PORT); + bind(w32_sock_state->tcp_listen_socket, (SOCKADDR *)&server_addr, sizeof(server_addr)); + bind(w32_sock_state->udp_listen_socket, (SOCKADDR *)&server_addr, sizeof(server_addr)); + } + + //- rjf: start listening + { + listen(w32_sock_state->tcp_listen_socket, SOMAXCONN); + listen(w32_sock_state->udp_listen_socket, SOMAXCONN); + } + + //- rjf: launch one-off listener threads to block & accept connections + w32_sock_state->tcp_listener_thread = thread_launch(w32_sock_tcp_listener_thread_entry_point, 0); + w32_sock_state->udp_listener_thread = thread_launch(w32_sock_udp_listener_thread_entry_point, 0); +} + +internal void +sock_async_tick(void) +{ + +} + +//////////////////////////////// +//~ rjf: @per_os_impl Sends + +internal U64 +sock_send(U8 *ptr, U64 size, SOCK_Protocol *protocol_in, SOCK_Endpoint *endpoint_in, U64 endt_us) +{ + U64 result = 0; + U64 needed_size = sizeof(*protocol_in) + sizeof(*endpoint_in) + sizeof(U64) + size; + RingGuard guard = guarded_ring_open(w32_sock_state->u2s_ring); + { + void *dst = guarded_ring_push_or_wait(&guard, needed_size, endt_us); + if(dst != 0) + { + MemoryCopy((U8 *)dst + 0, protocol_in, sizeof(*protocol_in)); + MemoryCopy((U8 *)dst + sizeof(*protocol_in), endpoint_in, sizeof(*endpoint_in)); + MemoryCopy((U8 *)dst + sizeof(*protocol_in) + sizeof(endpoint_in), &size, sizeof(size)); + MemoryCopy((U8 *)dst + sizeof(*protocol_in) + sizeof(endpoint_in) + sizeof(U64), ptr, size); + result = needed_size; + } + } + guarded_ring_close(&guard); + return result; +} + +//////////////////////////////// +//~ rjf: @per_os_impl Receives + +internal U64 +sock_recv(U8 *ptr, U64 size, SOCK_Protocol *protocol_out, SOCK_Endpoint *endpoint_out, U64 endt_us) +{ + U64 received_size = 0; + U64 header_size = sizeof(*protocol_out) + sizeof(*endpoint_out) + sizeof(U64); + { + RingGuard guard = guarded_ring_open(w32_sock_state->u2s_ring); + { + void *src = guarded_ring_pop_or_wait(&guard, header_size, endt_us); + if(src != 0) + { + U64 payload_size = 0; + MemoryCopy(protocol_out, (U8 *)src + 0, sizeof(*protocol_out)); + MemoryCopy(endpoint_out, (U8 *)src + sizeof(*protocol_out), sizeof(*endpoint_out)); + MemoryCopy(&payload_size, (U8 *)src + sizeof(*protocol_out) + sizeof(*endpoint_out), sizeof(U64)); + void *payload = guarded_ring_pop_or_wait(&guard, payload_size, max_U64); + MemoryCopy(ptr, payload, payload_size); + received_size = payload_size; + } + } + guarded_ring_close(&guard); + } + return received_size; +} diff --git a/src/win32/socket/win32_socket.h b/src/win32/socket/win32_socket.h new file mode 100644 index 00000000..d411836e --- /dev/null +++ b/src/win32/socket/win32_socket.h @@ -0,0 +1,39 @@ +// Copyright (c) Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef WIN32_SOCKET_H +#define WIN32_SOCKET_H + +#include +#pragma comment(lib, "ws2_32") + +typedef struct W32_SOCK_Connection W32_SOCK_Connection; +struct W32_SOCK_Connection +{ + W32_SOCK_Connection *next; + SOCK_Endpoint endpoint; + SOCK_Protocol protocol; + SOCKET socket; +}; + +typedef struct W32_SOCK_State W32_SOCK_State; +struct W32_SOCK_State +{ + Arena *arena; + GuardedRing *u2s_ring; + GuardedRing *s2u_ring; + SOCKET tcp_listen_socket; + SOCKET udp_listen_socket; + Thread tcp_listener_thread; + Thread udp_listener_thread; +}; + +global W32_SOCK_State *w32_sock_state = 0; + +//////////////////////////////// +//~ rjf: Listener Threads + +internal void w32_sock_tcp_listener_thread_entry_point(void *p); +internal void w32_sock_udp_listener_thread_entry_point(void *p); + +#endif // WIN32_SOCKET_H