Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: 9493b7563b
Fetching contributors…

Cannot retrieve contributors at this time

459 lines (354 sloc) 13.08 kb
/*
* This file contains all winsock-related stuff.
* Socketpair() for winsock is implemented here.
* There are also functions to create a non-overlapped socket (which windows normally doesn't do)
* and to create a socketpair that has one synchronous and one async socket.
* Synchronous sockets are required because async sockets can't be used by child processes.
*/
#include <platform_win32_winsock.h>
namespace node {
/*
* Guids and typedefs for winsock extension functions
* Mingw32 doesn't have these :-(
*/
#ifndef WSAID_ACCEPTEX
const GUID WSAID_ACCEPTEX =
{0xb5367df1, 0xcbac, 0x11cf, {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}};
const GUID WSAID_CONNECTEX =
{0x25a207b9, 0xddf3, 0x4660, {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}};
const GUID WSAID_GETACCEPTEXSOCKADDRS =
{0xb5367df2, 0xcbac, 0x11cf, {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}};
const GUID WSAID_DISCONNECTEX =
{0x7fda2e11, 0x8630, 0x436f, {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}};
const GUID WSAID_TRANSMITFILE =
{0xb5367df0, 0xcbac, 0x11cf, {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}};
typedef BOOL(*LPFN_ACCEPTEX)
(SOCKET sListenSocket,
SOCKET sAcceptSocket,
PVOID lpOutputBuffer,
DWORD dwReceiveDataLength,
DWORD dwLocalAddressLength,
DWORD dwRemoteAddressLength,
LPDWORD lpdwBytesReceived,
LPOVERLAPPED lpOverlapped);
typedef BOOL(*LPFN_CONNECTEX)
(SOCKET s,
const struct sockaddr *name,
int namelen,
PVOID lpSendBuffer,
DWORD dwSendDataLength,
LPDWORD lpdwBytesSent,
LPOVERLAPPED lpOverlapped);
typedef void(*LPFN_GETACCEPTEXSOCKADDRS)
(PVOID lpOutputBuffer,
DWORD dwReceiveDataLength,
DWORD dwLocalAddressLength,
DWORD dwRemoteAddressLength,
LPSOCKADDR *LocalSockaddr,
LPINT LocalSockaddrLength,
LPSOCKADDR *RemoteSockaddr,
LPINT RemoteSockaddrLength);
typedef BOOL(*LPFN_DISCONNECTEX)
(SOCKET hSocket,
LPOVERLAPPED lpOverlapped,
DWORD dwFlags,
DWORD reserved);
typedef BOOL(*LPFN_TRANSMITFILE)
(SOCKET hSocket,
HANDLE hFile,
DWORD nNumberOfBytesToWrite,
DWORD nNumberOfBytesPerSend,
LPOVERLAPPED lpOverlapped,
LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
DWORD dwFlags);
#endif
/*
* Winsock version data goes here
*/
static WSAData winsock_info;
/*
* Cache for WSAPROTOCOL_INFOW structures for protocols used in node
* [0] TCP/IP
* [1] UDP/IP
* [2] TCP/IPv6
* [3] UDP/IPv6
*/
static WSAPROTOCOL_INFOW proto_info_cache[4];
/*
* Pointers to winsock extension functions that have to be retrieved dynamically
*/
static struct WINSOCK_EXTENSION_FUNCTIONS {
//LPFN_CONNECTEX ConnectEx;
//LPFN_ACCEPTEX AcceptEx;
//LPFN_GETACCEPTEXSOCKADDRS GetAcceptExSockAddrs;
LPFN_DISCONNECTEX DisconnectEx;
//LPFN_TRANSMITFILE TransmitFile;
} wsexf;
/*
* Does the about the same as perror(), but for winsock errors
*/
void wsa_perror(const char *prefix) {
DWORD errorno = WSAGetLastError();
const char *errmsg = NULL;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&errmsg, 0, NULL);
if (!errmsg) {
errmsg = "Unknown error\n";
}
// FormatMessage messages include a newline character
if (prefix) {
fprintf(stderr, "%s: %s", prefix, errmsg);
} else {
fputs(errmsg, stderr);
}
}
/*
* Wrapper for DisconnectEx extension function
*/
BOOL wsa_disconnect_ex(SOCKET socket, OVERLAPPED *overlapped, DWORD flags, DWORD reserved) {
return wsexf.DisconnectEx(socket, overlapped, flags, reserved);
}
/*
* Retrieves a pointer to a WSAPROTOCOL_INFOW structure
* related to a certain winsock protocol from the cache
*/
inline static WSAPROTOCOL_INFOW *wsa_get_cached_proto_info(int af, int type, int proto) {
assert(proto == IPPROTO_IP
|| proto == IPPROTO_TCP
|| proto == IPPROTO_UDP);
switch (af) {
case AF_INET:
switch (type) {
case SOCK_STREAM:
return &proto_info_cache[0];
case SOCK_DGRAM:
return &proto_info_cache[1];
}
break;
case AF_INET6:
switch (type) {
case SOCK_STREAM:
return &proto_info_cache[2];
case SOCK_DGRAM:
return &proto_info_cache[3];
}
break;
}
WSASetLastError(WSAEPROTONOSUPPORT);
return NULL;
}
/*
* Creates a synchronous, non-overlapped socket.
* (The sockets that are created with socket() or accept() are always in overlapped mode.)
* Doubles the winsock api, e.g. returns a SOCKET handle, not an FD
*/
SOCKET wsa_sync_socket(int af, int type, int proto) {
WSAPROTOCOL_INFOW *protoInfo = wsa_get_cached_proto_info(af, type, proto);
if (protoInfo == NULL)
return INVALID_SOCKET;
return WSASocketW(af, type, proto, protoInfo, 0, 0);
}
/*
* Create a socketpair using the protocol specified
* This function uses winsock semantics, it returns SOCKET handles, not FDs
* Currently supports TCP/IPv4 socket pairs only
*/
int wsa_socketpair(int af, int type, int proto, SOCKET sock[2]) {
assert(af == AF_INET
&& type == SOCK_STREAM
&& (proto == IPPROTO_IP || proto == IPPROTO_TCP));
SOCKET listen_sock;
SOCKADDR_IN addr1;
SOCKADDR_IN addr2;
int addr1_len = sizeof (addr1);
int addr2_len = sizeof (addr2);
sock[1] = INVALID_SOCKET;
sock[2] = INVALID_SOCKET;
if ((listen_sock = socket(af, type, proto)) == INVALID_SOCKET)
goto error;
memset((void*)&addr1, 0, sizeof(addr1));
addr1.sin_family = af;
addr1.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr1.sin_port = 0;
if (bind(listen_sock, (SOCKADDR*)&addr1, addr1_len) == SOCKET_ERROR)
goto error;
if (getsockname(listen_sock, (SOCKADDR*)&addr1, &addr1_len) == SOCKET_ERROR)
goto error;
if (listen(listen_sock, 1))
goto error;
if ((sock[0] = socket(af, type, proto)) == INVALID_SOCKET)
goto error;
if (connect(sock[0], (SOCKADDR*)&addr1, addr1_len))
goto error;
if ((sock[1] = accept(listen_sock, 0, 0)) == INVALID_SOCKET)
goto error;
if (getpeername(sock[0], (SOCKADDR*)&addr1, &addr1_len) == SOCKET_ERROR)
goto error;
if (getsockname(sock[1], (SOCKADDR*)&addr2, &addr2_len) == SOCKET_ERROR)
goto error;
if (addr1_len != addr2_len
|| addr1.sin_addr.s_addr != addr2.sin_addr.s_addr
|| addr1.sin_port != addr2.sin_port)
goto error;
closesocket(listen_sock);
return 0;
error:
int error = WSAGetLastError();
if (listen_sock != INVALID_SOCKET)
closesocket(listen_sock);
if (sock[0] != INVALID_SOCKET)
closesocket(sock[0]);
if (sock[1] != INVALID_SOCKET)
closesocket(sock[1]);
WSASetLastError(error);
return SOCKET_ERROR;
}
/*
* Create a sync-async socketpair using the protocol specified,
* returning a synchronous socket and an asynchronous socket.
* Upon completion asyncSocket is opened with the WSA_FLAG_OVERLAPPED flag set,
* syncSocket won't have it set.
* Currently supports TCP/IPv4 socket pairs only
*/
int wsa_sync_async_socketpair(int af, int type, int proto, SOCKET *syncSocket, SOCKET *asyncSocket) {
assert(af == AF_INET
&& type == SOCK_STREAM
&& (proto == IPPROTO_IP || proto == IPPROTO_TCP));
SOCKET listen_sock;
SOCKET sock1 = INVALID_SOCKET;
SOCKET sock2 = INVALID_SOCKET;
SOCKADDR_IN addr1;
SOCKADDR_IN addr2;
int addr1_len = sizeof (addr1);
int addr2_len = sizeof (addr2);
if ((listen_sock = socket(af, type, proto)) == INVALID_SOCKET)
goto error;
memset((void*)&addr1, 0, sizeof(addr1));
addr1.sin_family = af;
addr1.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr1.sin_port = 0;
if (bind(listen_sock, (SOCKADDR*)&addr1, addr1_len) == SOCKET_ERROR)
goto error;
if (getsockname(listen_sock, (SOCKADDR*)&addr1, &addr1_len) == SOCKET_ERROR)
goto error;
if (listen(listen_sock, 1))
goto error;
if ((sock1 = wsa_sync_socket(af, type, proto)) == INVALID_SOCKET)
goto error;
if (connect(sock1, (SOCKADDR*)&addr1, addr1_len))
goto error;
if ((sock2 = accept(listen_sock, 0, 0)) == INVALID_SOCKET)
goto error;
if (getpeername(sock1, (SOCKADDR*)&addr1, &addr1_len) == SOCKET_ERROR)
goto error;
if (getsockname(sock2, (SOCKADDR*)&addr2, &addr2_len) == SOCKET_ERROR)
goto error;
if (addr1_len != addr2_len
|| addr1.sin_addr.s_addr != addr2.sin_addr.s_addr
|| addr1.sin_port != addr2.sin_port)
goto error;
closesocket(listen_sock);
*syncSocket = sock1;
*asyncSocket = sock2;
return 0;
error:
int error = WSAGetLastError();
if (listen_sock != INVALID_SOCKET)
closesocket(listen_sock);
if (sock1 != INVALID_SOCKET)
closesocket(sock1);
if (sock2 != INVALID_SOCKET)
closesocket(sock2);
WSASetLastError(error);
return SOCKET_ERROR;
}
/*
* Retrieves a WSAPROTOCOL_INFOW structure for a certain protocol
*/
static void wsa_get_proto_info(int af, int type, int proto, WSAPROTOCOL_INFOW *target) {
WSAPROTOCOL_INFOW *info_buffer = NULL;
unsigned long info_buffer_length = 0;
int protocol_count, i, error;
if (WSCEnumProtocols(NULL, NULL, &info_buffer_length, &error) != SOCKET_ERROR) {
error = WSAEOPNOTSUPP;
goto error;
}
info_buffer = (WSAPROTOCOL_INFOW *)malloc(info_buffer_length);
if ((protocol_count = WSCEnumProtocols(NULL, info_buffer, &info_buffer_length, &error)) == SOCKET_ERROR)
goto error;
for (i = 0; i < protocol_count; i++) {
if (af == info_buffer[i].iAddressFamily
&& type == info_buffer[i].iSocketType
&& proto == info_buffer[i].iProtocol
&& info_buffer[i].dwServiceFlags1 & XP1_IFS_HANDLES) {
memcpy(target, (WSAPROTOCOL_INFOW*)&info_buffer[i], sizeof(WSAPROTOCOL_INFOW));
free(info_buffer);
return;
}
}
error = WSAEPROTONOSUPPORT;
error:
WSASetLastError(error);
wsa_perror("Error obtaining winsock protocol information");
if (info_buffer != NULL) {
free(info_buffer);
}
}
/*
* Initializes (fills) the WSAPROTOCOL_INFOW structure cache
*/
static void wsa_init_proto_info_cache() {
wsa_get_proto_info(AF_INET, SOCK_STREAM, IPPROTO_TCP, &proto_info_cache[0]);
wsa_get_proto_info(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &proto_info_cache[1]);
wsa_get_proto_info(AF_INET6, SOCK_STREAM, IPPROTO_TCP, &proto_info_cache[2]);
wsa_get_proto_info(AF_INET6, SOCK_DGRAM, IPPROTO_UDP, &proto_info_cache[3]);
}
/*
* Gets the pointer to a winsock extension function
*/
inline static void wsa_get_extension_function(SOCKET socket, GUID guid, void **target) {
DWORD bytes;
if (WSAIoctl(socket,
SIO_GET_EXTENSION_FUNCTION_POINTER,
&guid,
sizeof(guid),
(void*)target,
sizeof(*target),
&bytes,
NULL,
NULL) == SOCKET_ERROR) {
*target = NULL;
wsa_perror("WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)");
}
}
/*
* Retrieves the needed winsock extension function pointers for the tcp/ip subsystem,
* storing them in the `wsexf` cache
*/
inline static void wsa_init_extension_functions() {
SOCKET dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (dummy == INVALID_SOCKET) {
memset((void*)&wsexf, 0, sizeof(wsexf));
wsa_perror("socket");
return;
}
//wsa_get_extension_function(dummy, WSAID_CONNECTEX, (void**)&wsexf.ConnectEx );
//wsa_get_extension_function(dummy, WSAID_ACCEPTEX, (void**)&wsexf.AcceptEx );
//wsa_get_extension_function(dummy, WSAID_GETACCEPTEXSOCKADDRS, (void**)&wsexf.GetAcceptExSockAddrs);
wsa_get_extension_function(dummy, WSAID_DISCONNECTEX, (void**)&wsexf.DisconnectEx );
//wsa_get_extension_function(dummy, WSAID_TRANSMITFILE, (void**)&wsexf.TransmitFile );
closesocket(dummy);
}
/*
* Initializes winsock and winsock-related stuff
*/
void wsa_init() {
WORD version = MAKEWORD(2, 2);
if (WSAStartup(version, &winsock_info)) {
wsa_perror("WSAStartup");
}
wsa_init_proto_info_cache();
wsa_init_extension_functions();
}
} // namespace node
Jump to Line
Something went wrong with that request. Please try again.