1378 lines
43 KiB
C
1378 lines
43 KiB
C
#include "windows.h"
|
||
#include "types.h"
|
||
#include "winsock.h"
|
||
#include "wsasync.h"
|
||
|
||
#ifdef UNDER_CE
|
||
#include <ceconfig.h>
|
||
#endif
|
||
|
||
DWORD CopyHostEnt(PHOSTENT lpWinsockHostEnt, PHOSTENT lpHostEnt,
|
||
LPDWORD lpdwHostEntBufferSize);
|
||
|
||
#define ProxyDbgAssert(x) ASSERT(x)
|
||
// If Count is not already aligned, then
|
||
// round Count up to an even multiple of "Pow2". "Pow2" must be a power of 2.
|
||
//
|
||
// DWORD
|
||
// ROUND_UP_COUNT(
|
||
// IN DWORD Count,
|
||
// IN DWORD Pow2
|
||
// );
|
||
#define ROUND_UP_COUNT(Count,Pow2) \
|
||
( ((Count)+(Pow2)-1) & (~((Pow2)-1)) )
|
||
#define ALIGN_DWORD 4
|
||
|
||
#ifdef DEBUG
|
||
|
||
DBGPARAM dpCurSettings = {
|
||
TEXT("WSASYNC"), {
|
||
TEXT("Init"), TEXT("HostName"),TEXT("Undefined"),TEXT("Undefined"),
|
||
TEXT("Recv"),TEXT("Send"),TEXT("Undefined"),TEXT("Undefined"),
|
||
TEXT("Undefined"),TEXT("Undefined"),TEXT("Interface"),TEXT("Misc"),
|
||
TEXT("Alloc"), TEXT("Function"), TEXT("Warning"), TEXT("Error") },
|
||
0x0000c000
|
||
};
|
||
|
||
#define ZONE_INIT DEBUGZONE(0) // 0x0001
|
||
#define ZONE_HNAME DEBUGZONE(1) // 0x0002
|
||
//#define ZONE_??? DEBUGZONE(2) // 0x0004
|
||
//#define ZONE_??? DEBUGZONE(3) // 0x0008
|
||
#define ZONE_RECV DEBUGZONE(4) // 0x0010
|
||
#define ZONE_SEND DEBUGZONE(5) // 0x0020
|
||
#define ZONE_SELECT DEBUGZONE(6) // 0x0040
|
||
#define ZONE_CLOSE DEBUGZONE(7) // 0x0080
|
||
//#define ZONE_??? DEBUGZONE(8) // 0x0100
|
||
#define ZONE_MSG DEBUGZONE(9) // 0x0200
|
||
#define ZONE_INTERFACE DEBUGZONE(10) // 0x0400
|
||
#define ZONE_MISC DEBUGZONE(11) // 0x0800
|
||
#define ZONE_ALLOC DEBUGZONE(12) // 0x1000
|
||
#define ZONE_FUNCTION DEBUGZONE(13) // 0x2000
|
||
#define ZONE_WARN DEBUGZONE(14) // 0x4000
|
||
#define ZONE_ERROR DEBUGZONE(15) // 0x8000
|
||
|
||
#endif
|
||
|
||
|
||
typedef struct GetNames {
|
||
struct GetNames *pNext;
|
||
HANDLE hThread;
|
||
HWND hWnd;
|
||
uint wMsg;
|
||
char *pBuf;
|
||
DWORD dwBufLen;
|
||
char *pName;
|
||
DWORD Status;
|
||
} GetNames;
|
||
|
||
GetNames *v_pNameList;
|
||
CRITICAL_SECTION v_NameListCS;
|
||
BOOL v_fNameListInit = FALSE;
|
||
|
||
#define MAXALIASES 15 // We only support 5 aliases
|
||
#define AVG_HOST_LEN 40 // To calculate buff space
|
||
#define MAXADDRS 15 // Max of 5 IP addrs
|
||
|
||
typedef struct FULL_HOSTENT {
|
||
HOSTENT hostent;
|
||
PSTR host_aliases[MAXALIASES+1];
|
||
char hostbuf[(MAXALIASES+1)*AVG_HOST_LEN];
|
||
PSTR h_addr_ptrs[MAXADDRS + 1];
|
||
uchar hostaddr[MAXADDRS*4];
|
||
} FULL_HOSTENT;
|
||
|
||
|
||
GetNames **_FindName(HANDLE hThread) {
|
||
GetNames **ppName;
|
||
|
||
ppName = &v_pNameList;
|
||
while (*ppName && hThread != (*ppName)->hThread)
|
||
ppName = &(*ppName)->pNext;
|
||
|
||
return ppName;
|
||
|
||
} // _FindName()
|
||
|
||
// HANDLE CreateThread(NULL, 0, Addr, pParam, NULL, ThreadId);
|
||
// BOOL PostMessage(hWnd, wMsg, wParam, lParam);
|
||
|
||
|
||
void CallGetHostByName(DWORD Name) {
|
||
GetNames **ppName, *pName = (GetNames *)Name;
|
||
HOSTENT *pHostent;
|
||
#if 0
|
||
FULL_HOSTENT *pFull;
|
||
int cLen, i;
|
||
char *p;
|
||
#endif
|
||
DWORD lParam;
|
||
|
||
EnterCriticalSection(&v_NameListCS);
|
||
// put it in list of pending items
|
||
pName->pNext = v_pNameList;
|
||
v_pNameList = pName;
|
||
LeaveCriticalSection(&v_NameListCS);
|
||
|
||
pHostent = gethostbyname(pName->pName);
|
||
|
||
DEBUGMSG(ZONE_HNAME, (TEXT("gethostbyname returned %x\r\n"), pHostent));
|
||
// take this task out of the pending items list
|
||
EnterCriticalSection(&v_NameListCS);
|
||
ppName = _FindName(pName->hThread);
|
||
ASSERT(*ppName);
|
||
ASSERT(*ppName == pName);
|
||
*ppName = pName->pNext;
|
||
pName->pNext = NULL;
|
||
LeaveCriticalSection(&v_NameListCS);
|
||
|
||
if (pName->Status != 0xffffffff) {
|
||
if (pHostent) {
|
||
#if 0
|
||
lParam = 0;
|
||
pFull = (FULL_HOSTENT *)pName->pBuf;
|
||
memcpy(pFull, pHostent, sizeof(FULL_HOSTENT));
|
||
// now change the pointers to point to the correct places
|
||
pFull->hostent.h_name = pFull->hostbuf;
|
||
cLen = strlen(pFull->hostbuf) + 1;
|
||
|
||
p = pFull->hostbuf + cLen;
|
||
|
||
// do the aliases
|
||
pFull->hostent.h_aliases = pFull->host_aliases;
|
||
i = 0;
|
||
while (pHostent->h_aliases[i]) {
|
||
p += strlen(pHostent->h_aliases[i]) + 1;
|
||
pFull->hostent.h_aliases[i++] = p;
|
||
}
|
||
// h_addrtype & h_length should have been copied with memcpy
|
||
|
||
|
||
// do the h_addr_list
|
||
pFull->hostent.h_addr_list = pFull->h_addr_ptrs;
|
||
while(pHostent->h_addr_list[i]) {
|
||
pFull->h_adddr_ptrs[i] =
|
||
}
|
||
|
||
p = pFull->hostaddr;
|
||
i = 0;
|
||
while (pHostent->h_addr_list[i]) {
|
||
pFull->h_addr_ptrs[i] = p;
|
||
(int *)p = *(int *)pHostent->h_addr_list[i++];
|
||
p += 4;
|
||
}
|
||
#endif
|
||
lParam = CopyHostEnt(pHostent, (PHOSTENT)pName->pBuf,
|
||
&pName->dwBufLen);
|
||
lParam <<= 16;
|
||
lParam += pName->dwBufLen;
|
||
} else { // if (pHostent)
|
||
// we must have some error condition
|
||
lParam = GetLastError();
|
||
lParam <<= 16;
|
||
lParam += sizeof(FULL_HOSTENT);
|
||
}
|
||
// BUGBUG: we don't retry on failure
|
||
PostMessage(pName->hWnd, pName->wMsg, (WPARAM)pName->hThread, lParam);
|
||
} // if (pName->Status)
|
||
|
||
LocalFree(pName->pName);
|
||
LocalFree(pName);
|
||
|
||
} // CallGetHostByName()
|
||
|
||
|
||
HANDLE WSAAsyncGetHostByName(HWND hWnd, unsigned wMsg, const char FAR *name,
|
||
char FAR * buf, int buflen) {
|
||
HANDLE hThread;
|
||
DWORD ThreadId;
|
||
GetNames *pName;
|
||
DWORD Status = 0;
|
||
int cc;
|
||
|
||
if (buflen < sizeof(HOSTENT)) {
|
||
Status = WSAENOBUFS;
|
||
} else if (pName = LocalAlloc(LPTR, sizeof(*pName))) {
|
||
pName->hWnd = hWnd;
|
||
pName->wMsg = wMsg;
|
||
pName->pBuf = buf;
|
||
pName->dwBufLen = (DWORD)buflen;
|
||
cc = strlen(name) + 1;
|
||
if (pName->pName = LocalAlloc(LPTR, cc)) {
|
||
memcpy(pName->pName, name, cc);
|
||
pName->Status = 0;
|
||
if (!v_fNameListInit) {
|
||
InitializeCriticalSection(&v_NameListCS);
|
||
v_fNameListInit = TRUE;
|
||
}
|
||
EnterCriticalSection(&v_NameListCS);
|
||
pName->hThread = hThread = CreateThread(NULL, 0,
|
||
(LPTHREAD_START_ROUTINE)CallGetHostByName, pName, 0, &ThreadId);
|
||
|
||
LeaveCriticalSection(&v_NameListCS);
|
||
CloseHandle(hThread);
|
||
} else {
|
||
LocalFree(pName);
|
||
Status = WSAENOBUFS;
|
||
}
|
||
} else {
|
||
Status = WSAENOBUFS;
|
||
}
|
||
|
||
if (Status) {
|
||
SetLastError(Status);
|
||
return (HANDLE)0;
|
||
} else
|
||
return (HANDLE)hThread;
|
||
} // WSAASyncGetHostByName()
|
||
|
||
|
||
int WSACancelAsyncRequest (HANDLE hAsyncTaskHandle) {
|
||
GetNames **ppName;
|
||
int Status;
|
||
|
||
EnterCriticalSection(&v_NameListCS);
|
||
ppName = _FindName(hAsyncTaskHandle);
|
||
if (*ppName) {
|
||
(*ppName)->Status = 0xffffffff;
|
||
LeaveCriticalSection(&v_NameListCS);
|
||
Status = 0;
|
||
} else {
|
||
LeaveCriticalSection(&v_NameListCS);
|
||
Status = SOCKET_ERROR;
|
||
SetLastError(WSAEINVAL);
|
||
}
|
||
|
||
return Status;
|
||
} // WSACancelAsyncRequest()
|
||
|
||
|
||
typedef int (*WSRecvFn)(SOCKET, char *, int, int);
|
||
typedef int (*WSSendFn)(SOCKET, const char *, int, int);
|
||
typedef int (*WSCloseFn)(SOCKET);
|
||
|
||
WSRecvFn v_pRecv;
|
||
WSSendFn v_pSend;
|
||
WSCloseFn v_pClose;
|
||
SOCKADDR_IN SockAddr;
|
||
|
||
#ifndef IP_LOOPBACK
|
||
#define IP_LOOPBACK 0x100007f
|
||
#endif
|
||
|
||
static fd_set ReadSet, WriteSet, ExcSet;
|
||
static int v_fDone;
|
||
static SOCKET v_Sock= INVALID_SOCKET;
|
||
static SOCKET v_WakeSock;
|
||
static SOCKET v_SendSock;
|
||
static int v_SelEvents;
|
||
static int v_Disabled;
|
||
static HWND v_hWnd;
|
||
static int v_wMsg;
|
||
static int v_fAlready; // implicitly set to FALSE
|
||
|
||
CRITICAL_SECTION v_EventCS;
|
||
|
||
void SelectWorker(DWORD Sock);
|
||
|
||
int WSAAsyncSelect (SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent) {
|
||
static int fInit = FALSE;
|
||
HINSTANCE hinst;
|
||
HANDLE hThread;
|
||
DWORD ThreadId;
|
||
int True = 1;
|
||
int len;
|
||
|
||
if (! fInit) {
|
||
fInit = TRUE;
|
||
InitializeCriticalSection(&v_EventCS);
|
||
if (hinst = LoadLibrary(TEXT("winsock.dll"))) {
|
||
v_pRecv = (WSRecvFn)GetProcAddressW(hinst, TEXT("recv"));
|
||
v_pSend = (WSSendFn)GetProcAddressW(hinst, TEXT("send"));
|
||
v_pClose = (WSCloseFn)GetProcAddressW(hinst, TEXT("closesocket"));
|
||
if (! (v_pRecv && v_pSend && v_pClose)) {
|
||
DEBUGMSG(ZONE_WARN | ZONE_ERROR,
|
||
(TEXT("Couldn't get ProcAddr of winsock recv/send\r\n")));
|
||
SetLastError(WSAENOBUFS);
|
||
return SOCKET_ERROR;
|
||
}
|
||
} else {
|
||
DEBUGMSG(ZONE_WARN | ZONE_ERROR,
|
||
(TEXT("Couldn't LoadLibrary winsock.dll\r\n")));
|
||
SetLastError(WSAENOBUFS);
|
||
return SOCKET_ERROR;
|
||
}
|
||
// now WakeSock and SendSock initialized at init time only
|
||
v_WakeSock = socket(AF_INET, SOCK_DGRAM, 0);
|
||
if (INVALID_SOCKET == v_WakeSock) {
|
||
DEBUGMSG(ZONE_WARN|ZONE_ERROR,
|
||
(TEXT("Can't create dgram socket\r\n")));
|
||
SetLastError(WSAENOBUFS);
|
||
return SOCKET_ERROR;
|
||
}
|
||
memset ((char *)&SockAddr, 0, sizeof(SockAddr));
|
||
SockAddr.sin_family = AF_INET;
|
||
SockAddr.sin_port = 0;
|
||
SockAddr.sin_addr.S_un.S_addr = IP_LOOPBACK;
|
||
if (SOCKET_ERROR == bind(v_WakeSock, (SOCKADDR *)&SockAddr,
|
||
sizeof(SockAddr))) {
|
||
DEBUGMSG(ZONE_WARN|ZONE_ERROR, (TEXT("Can't bind WakeSock\r\n")));
|
||
return SOCKET_ERROR;
|
||
}
|
||
|
||
v_SendSock = socket(AF_INET, SOCK_DGRAM, 0);
|
||
if (INVALID_SOCKET == v_SendSock) {
|
||
DEBUGMSG(ZONE_WARN|ZONE_ERROR,
|
||
(TEXT("Can't create send socket\r\n")));
|
||
v_pClose(v_WakeSock);
|
||
SetLastError(WSAENOBUFS);
|
||
return SOCKET_ERROR;
|
||
}
|
||
len = sizeof(SockAddr);
|
||
getsockname (v_WakeSock, (SOCKADDR *)&SockAddr, &len);
|
||
connect(v_SendSock, (SOCKADDR *)&SockAddr, sizeof(SockAddr));
|
||
} // if (! fInit)
|
||
|
||
EnterCriticalSection(&v_EventCS);
|
||
if (! lEvent) {
|
||
v_fDone = TRUE;
|
||
LeaveCriticalSection(&v_EventCS);
|
||
return 0;
|
||
}
|
||
|
||
if (v_fAlready) {
|
||
LeaveCriticalSection(&v_EventCS);
|
||
return 0;
|
||
} else {
|
||
v_fAlready = TRUE;
|
||
v_fDone = FALSE;
|
||
v_hWnd = hWnd;
|
||
v_wMsg = wMsg;
|
||
v_SelEvents = lEvent;
|
||
ASSERT(INVALID_SOCKET == v_Sock);
|
||
v_Sock = s;
|
||
v_Disabled = 0;
|
||
LeaveCriticalSection(&v_EventCS);
|
||
|
||
// set socket to non-blocking
|
||
if (SOCKET_ERROR == ioctlsocket(s, FIONBIO, &True)) {
|
||
DEBUGMSG(ZONE_WARN, (TEXT("ioctlsocket FIONBIO failed w/ %d\r\n"),
|
||
GetLastError()));
|
||
}
|
||
|
||
hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SelectWorker,
|
||
(void *)s, 0, &ThreadId);
|
||
CloseHandle(hThread);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void SelectWorker(DWORD Sock) {
|
||
SOCKET s = (SOCKET) Sock;
|
||
char c;
|
||
DWORD lParam = 0;
|
||
int Status;
|
||
#ifdef OS_WINCE
|
||
TIMEVAL tv = {0, 25000};
|
||
#endif // OS_WINCE
|
||
|
||
|
||
while (2) {
|
||
FD_ZERO(&ReadSet);
|
||
FD_ZERO(&WriteSet);
|
||
FD_ZERO(&ExcSet);
|
||
if (INVALID_SOCKET != v_WakeSock) {
|
||
FD_SET(v_WakeSock, &ReadSet);
|
||
}
|
||
EnterCriticalSection(&v_EventCS);
|
||
if (v_fDone) { // do this here b/c of CS
|
||
v_fAlready = FALSE;
|
||
// LeaveCriticalSection(&v_EventCS);
|
||
break;
|
||
}
|
||
|
||
if (v_SelEvents & ~v_Disabled & (FD_WRITE | FD_CONNECT)) {
|
||
FD_SET(s, &WriteSet);
|
||
DEBUGMSG(ZONE_MSG, (TEXT("W\r\n")));
|
||
}
|
||
if (v_SelEvents & ~v_Disabled & FD_READ) {
|
||
FD_SET(s, &ReadSet);
|
||
DEBUGMSG(ZONE_MSG, (TEXT("R\r\n")));
|
||
}
|
||
//FD_SET(s, &ExcSet);
|
||
|
||
LeaveCriticalSection(&v_EventCS);
|
||
DEBUGMSG(ZONE_SELECT, (TEXT("calling select\r\n")));
|
||
|
||
#ifdef OS_WINCE
|
||
/* When select(...) is called with a NULL timeval parameter,
|
||
it does not return after closesocket(...) is called on
|
||
that socket. To work around that behavior, use a time-
|
||
out on the call to select(...) (and take advantage of
|
||
the while(2) wrapping this code-block. */
|
||
|
||
// This was only made for HPCs, WBT was always fine using the old way,
|
||
// so we're going to keep it the same.
|
||
if (g_CEConfig != CE_CONFIG_WBT)
|
||
{
|
||
Status = select(0, &ReadSet, &WriteSet, NULL, &tv);
|
||
}
|
||
else
|
||
{
|
||
Status = select(0, &ReadSet, &WriteSet, NULL, NULL);
|
||
}
|
||
#else // OS_WINCE
|
||
Status = select(0, &ReadSet, &WriteSet, NULL, NULL);
|
||
#endif // OS_WINCE
|
||
|
||
|
||
|
||
if (SOCKET_ERROR == Status) {
|
||
//v_fDone = TRUE;
|
||
Status = GetLastError();
|
||
DEBUGMSG(ZONE_WARN|ZONE_SELECT,
|
||
(TEXT("Select returned error: %d \r\n"), Status));
|
||
} else {
|
||
if (FD_ISSET(v_WakeSock, &ReadSet)) {
|
||
v_pRecv(v_WakeSock, &c, 1, 0);
|
||
}
|
||
EnterCriticalSection(&v_EventCS);
|
||
|
||
if (FD_ISSET(s, &WriteSet)) {
|
||
// we need to report connect events only once
|
||
if (v_SelEvents & ~v_Disabled & FD_CONNECT) {
|
||
v_Disabled |= FD_CONNECT;
|
||
lParam = FD_CONNECT;
|
||
DEBUGMSG(ZONE_MSG, (TEXT("p-C\r\n")));
|
||
PostMessage(v_hWnd, v_wMsg, (WPARAM)s, lParam);
|
||
}
|
||
if (v_SelEvents & ~v_Disabled & FD_WRITE) {
|
||
v_Disabled |= FD_WRITE;
|
||
lParam = FD_WRITE;
|
||
DEBUGMSG(ZONE_MSG, (TEXT("p-W\r\n")));
|
||
PostMessage(v_hWnd, v_wMsg, (WPARAM)s, lParam);
|
||
}
|
||
}
|
||
if (FD_ISSET(s, &ReadSet)) {
|
||
v_Disabled |= FD_READ;
|
||
lParam = FD_READ;
|
||
DEBUGMSG(ZONE_MSG, (TEXT("p-R\r\n")));
|
||
PostMessage(v_hWnd, v_wMsg, (WPARAM)s, lParam);
|
||
}
|
||
if (FD_ISSET(s, &ExcSet)) {
|
||
DEBUGMSG(ZONE_WARN, (TEXT("Selects ExcSet is set!!\r\n")));
|
||
}
|
||
LeaveCriticalSection(&v_EventCS);
|
||
} // else SOCKET_ERROR == Status
|
||
}
|
||
// note we have the CS here!!!
|
||
v_Sock = INVALID_SOCKET;
|
||
v_hWnd = NULL;
|
||
LeaveCriticalSection(&v_EventCS);
|
||
|
||
return;
|
||
|
||
} // SelectWorker()
|
||
|
||
|
||
int recv(SOCKET s, char *buf, int len, int flags) {
|
||
char c = (char)7;
|
||
int Status;
|
||
|
||
DEBUGMSG(ZONE_RECV, (TEXT("+recv\r\n")));
|
||
Status = v_pRecv(s, buf, len, flags);
|
||
|
||
EnterCriticalSection(&v_EventCS);
|
||
if (v_Sock != INVALID_SOCKET && v_Sock == s) {
|
||
// BUGBUG: should we check for errors as well?
|
||
if (! Status) { // recv'd 0 bytes
|
||
DEBUGMSG(ZONE_MSG, (TEXT("p-Close\r\n")));
|
||
PostMessage(v_hWnd, v_wMsg, (WPARAM)s, FD_CLOSE);
|
||
// after this we don't want to re-enable FD_READ's
|
||
} else if (v_Disabled & FD_READ) {
|
||
v_Disabled &= ~FD_READ;
|
||
v_pSend(v_SendSock, &c, 1, 0);
|
||
}
|
||
}
|
||
LeaveCriticalSection(&v_EventCS);
|
||
|
||
DEBUGMSG(ZONE_RECV, (TEXT("-recv\r\n")));
|
||
return Status;
|
||
|
||
} // recv
|
||
|
||
int send(SOCKET s, const char *buf, int len, int flags) {
|
||
char c = (char)8;
|
||
int Status;
|
||
|
||
DEBUGMSG(ZONE_SEND, (TEXT("+send\r\n")));
|
||
Status = v_pSend(s, buf, len, flags);
|
||
|
||
EnterCriticalSection(&v_EventCS);
|
||
if (v_Sock != INVALID_SOCKET && v_Sock == s) {
|
||
// BUGBUG: should we check for errors??
|
||
if (v_Disabled & FD_WRITE) {
|
||
v_Disabled &= ~FD_WRITE;
|
||
v_pSend(v_SendSock, &c, 1, 0);
|
||
}
|
||
}
|
||
LeaveCriticalSection(&v_EventCS);
|
||
|
||
DEBUGMSG(ZONE_SEND, (TEXT("-send\r\n")));
|
||
return Status;
|
||
|
||
} // send()
|
||
|
||
int closesocket(SOCKET s) {
|
||
int Status;
|
||
|
||
DEBUGMSG(ZONE_CLOSE, (TEXT("+close\r\n")));
|
||
Status = v_pClose(s);
|
||
|
||
EnterCriticalSection(&v_EventCS);
|
||
if (v_Sock != INVALID_SOCKET && v_Sock == s) {
|
||
v_fDone = TRUE;
|
||
}
|
||
LeaveCriticalSection(&v_EventCS);
|
||
|
||
DEBUGMSG(ZONE_CLOSE, (TEXT("-close\r\n")));
|
||
return Status;
|
||
} // closesocket()
|
||
|
||
|
||
BOOL __stdcall
|
||
dllentry (
|
||
HANDLE hinstDLL,
|
||
DWORD Op,
|
||
LPVOID lpvReserved
|
||
)
|
||
{
|
||
switch (Op) {
|
||
case DLL_PROCESS_ATTACH :
|
||
DEBUGREGISTER(hinstDLL);
|
||
DEBUGMSG (ZONE_INIT, (TEXT(" CXPORT:dllentry ProcessAttach\r\n")));
|
||
break;
|
||
case DLL_PROCESS_DETACH :
|
||
break;
|
||
default :
|
||
break;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
DWORD
|
||
CopyHostEnt(
|
||
PHOSTENT lpWinsockHostEnt,
|
||
PHOSTENT lpHostEnt,
|
||
LPDWORD lpdwHostEntBufferSize
|
||
)
|
||
/*++
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
Windows Error Code.
|
||
|
||
--*/
|
||
{
|
||
DWORD dwSize;
|
||
LPSTR *lpAliasNames;
|
||
LPSTR *lpDestAliasNames;
|
||
LPSTR *lpAddrList;
|
||
LPSTR *lpDestAddrList;
|
||
LPBYTE lpNextVariable;
|
||
LPBYTE lpEndBuffer;
|
||
DWORD dwNumAliasNames = 0;
|
||
DWORD dwNumAddresses = 0;
|
||
DWORD dwDnsNameLen;
|
||
|
||
//
|
||
// compute the size required.
|
||
//
|
||
|
||
dwSize = sizeof(HOSTENT);
|
||
|
||
dwDnsNameLen =
|
||
ROUND_UP_COUNT(
|
||
(strlen(lpWinsockHostEnt->h_name) + sizeof(CHAR)),
|
||
ALIGN_DWORD );
|
||
|
||
dwSize += dwDnsNameLen;
|
||
|
||
lpAliasNames = lpWinsockHostEnt->h_aliases;
|
||
while( *lpAliasNames != NULL ) {
|
||
|
||
dwSize += ROUND_UP_COUNT(
|
||
(strlen(*lpAliasNames) + sizeof(CHAR)),
|
||
ALIGN_DWORD );
|
||
|
||
dwSize += sizeof(LPSTR);
|
||
dwNumAliasNames++;
|
||
lpAliasNames++;
|
||
}
|
||
|
||
dwSize += sizeof(LPSTR);
|
||
|
||
lpAddrList = lpWinsockHostEnt->h_addr_list;
|
||
|
||
while( *lpAddrList != NULL ) {
|
||
dwSize += sizeof(DWORD);
|
||
dwSize += sizeof(LPSTR);
|
||
dwNumAddresses++;
|
||
lpAddrList++;
|
||
}
|
||
|
||
dwSize += sizeof(LPSTR);
|
||
|
||
if( dwSize > *lpdwHostEntBufferSize ) {
|
||
*lpdwHostEntBufferSize = dwSize;
|
||
return( WSAENOBUFS );
|
||
}
|
||
|
||
//
|
||
// copy data.
|
||
//
|
||
|
||
lpNextVariable = (LPBYTE)lpHostEnt + sizeof(HOSTENT);
|
||
lpEndBuffer = (LPBYTE)lpHostEnt + dwSize;
|
||
|
||
//
|
||
// copy fixed part.
|
||
//
|
||
|
||
lpHostEnt->h_addrtype = lpWinsockHostEnt->h_addrtype;
|
||
lpHostEnt->h_length = lpWinsockHostEnt->h_length;
|
||
|
||
//
|
||
// copy variable parts.
|
||
//
|
||
|
||
lpHostEnt->h_name = (LPSTR)lpNextVariable;
|
||
|
||
strcpy( lpHostEnt->h_name, lpWinsockHostEnt->h_name );
|
||
|
||
lpNextVariable += dwDnsNameLen;
|
||
ProxyDbgAssert( lpNextVariable < lpEndBuffer);
|
||
|
||
|
||
lpHostEnt->h_aliases = (LPSTR *)lpNextVariable;
|
||
lpNextVariable += (dwNumAliasNames + 1) * sizeof(LPSTR);
|
||
ProxyDbgAssert( lpNextVariable < lpEndBuffer);
|
||
|
||
lpAliasNames = lpWinsockHostEnt->h_aliases;
|
||
lpDestAliasNames = lpHostEnt->h_aliases;
|
||
|
||
while( *lpAliasNames != NULL ) {
|
||
|
||
*lpDestAliasNames = (LPSTR)lpNextVariable;
|
||
strcpy( *lpDestAliasNames, *lpAliasNames );
|
||
|
||
lpNextVariable += ROUND_UP_COUNT(
|
||
(strlen(*lpAliasNames) + sizeof(CHAR)),
|
||
ALIGN_DWORD );
|
||
|
||
ProxyDbgAssert( lpNextVariable < lpEndBuffer);
|
||
|
||
lpDestAliasNames++;
|
||
lpAliasNames++;
|
||
}
|
||
|
||
*lpDestAliasNames = NULL;
|
||
|
||
lpHostEnt->h_addr_list = (LPSTR *)lpNextVariable;
|
||
lpNextVariable += (dwNumAddresses + 1) * sizeof(LPSTR);
|
||
ProxyDbgAssert( lpNextVariable < lpEndBuffer);
|
||
|
||
lpAddrList = lpWinsockHostEnt->h_addr_list;
|
||
lpDestAddrList = lpHostEnt->h_addr_list;
|
||
|
||
while( *lpAddrList != NULL ) {
|
||
|
||
*lpDestAddrList = (LPSTR)lpNextVariable;
|
||
*(LPDWORD)(*lpDestAddrList) = *(LPDWORD)(*lpAddrList);
|
||
|
||
lpNextVariable += sizeof(DWORD);
|
||
ProxyDbgAssert( lpNextVariable <= lpEndBuffer);
|
||
|
||
lpDestAddrList++;
|
||
lpAddrList++;
|
||
}
|
||
|
||
*lpDestAddrList = NULL;
|
||
|
||
return( ERROR_SUCCESS );
|
||
}
|
||
|
||
|
||
// ----------------------------------------------------------------
|
||
//
|
||
// The Windows Sockets WSAAsyncGetHostByName function gets host
|
||
// information corresponding to a host name asynchronously.
|
||
//
|
||
// HANDLE WSAAsyncGetHostByName ( HWND hWnd, unsigned int wMsg, const
|
||
// char FAR * name, char FAR * buf, int buflen );
|
||
//
|
||
// Parameters
|
||
//
|
||
// hWnd
|
||
//
|
||
// [in] The handle of the window that will receive a message when the
|
||
// asynchronous request completes.
|
||
//
|
||
// wMsg
|
||
//
|
||
// [in] The message to be received when the asynchronous request
|
||
// completes.
|
||
//
|
||
// name
|
||
//
|
||
// [in] A pointer to the null-terminated name of the host.
|
||
//
|
||
// buf
|
||
//
|
||
// [out] A pointer to the data area to receive the HOSTENT data. It must
|
||
// be larger than the size of a HOSTENT structure because the supplied
|
||
// data area is used by Windows Sockets to contain not only a HOSTENT
|
||
// structure but any and all of the data referenced by members of the
|
||
// HOSTENT structure. A buffer of MAXGETHOSTSTRUCT bytes is recommended.
|
||
//
|
||
// buflen
|
||
//
|
||
// [in] The size of data area the buf parameter.
|
||
//
|
||
// Remarks
|
||
//
|
||
// This function is an asynchronous version of gethostbyname, and is
|
||
// used to retrieve host name and address information corresponding to a
|
||
// host name. Windows Sockets initiates the operation and returns to the
|
||
// caller immediately, passing back an opaque "asynchronous task handle"
|
||
// that whichthe application can use to identify the operation. When the
|
||
// operation is completed, the results (if any) are copied into the
|
||
// buffer provided by the caller and a message is sent to the
|
||
// application's window.
|
||
//
|
||
// When the asynchronous operation is complete the application's window
|
||
// hWnd receives message wMsg. The wParam parameter contains the
|
||
// asynchronous task handle as returned by the original function call.
|
||
// The high 16 bits of lParam contain any error code. The error code can
|
||
// be any error as defined in WINSOCK2.H. An error code of zero
|
||
// indicates successful completion of the asynchronous operation. On
|
||
// successful completion, the buffer supplied to the original function
|
||
// call contains a HOSTENT structure. To access the elements of this
|
||
// structure, the original buffer address should be cast to a HOSTENT
|
||
// structure pointer and accessed as appropriate.
|
||
//
|
||
// If the error code is WSAENOBUFS, the size of the buffer specified by
|
||
// buflen in the original call was too small to contain all the
|
||
// resulting information. In this case, the low 16 bits of lParam
|
||
// contain the size of buffer required to supply all the requisite
|
||
// information. If the application decides that the partial data is
|
||
// inadequate, it can reissue the WSAAsyncGetHostByAddr function call
|
||
// with a buffer large enough to receive all the desired information
|
||
// (that is, no smaller than the low 16 bits of lParam).
|
||
//
|
||
// The buffer supplied to this function is used by Windows Sockets to
|
||
// construct a HOSTENT structure together with the contents of data
|
||
// areas referenced by members of the same HOSTENT structure. To avoid
|
||
// the WSAENOBUFS error, the application should provide a buffer of at
|
||
// least MAXGETHOSTSTRUCT bytes (as defined in WINSOCK2.H).
|
||
//
|
||
// The error code and buffer length should be extracted from the lParam
|
||
// using the macros WSAGETASYNCERROR and WSAGETASYNCBUFLEN, defined in
|
||
// WINSOCK2.H as:
|
||
//
|
||
// #define WSAGETASYNCERROR(lParam) HIWORD(lParam) #define
|
||
// WSAGETASYNCBUFLEN(lParam) LOWORD(lParam) The use of these macros will
|
||
// maximize the portability of the source code for the application.
|
||
//
|
||
// WSAAsyncGetHostByName is guaranteed to resolve the string returned by
|
||
// a successful call to gethostname.
|
||
//
|
||
// Return Values
|
||
//
|
||
// The return value specifies whether or not the asynchronous operation
|
||
// was successfully initiated. Note that it does not imply success or
|
||
// failure of the operation itself.
|
||
//
|
||
// If the operation was successfully initiated, WSAAsyncGetHostByName
|
||
// returns a nonzero value of type HANDLE that is the asynchronous task
|
||
// handle (not to be confused with a Windows HTASK) for the request.
|
||
// This value can be used in two ways. It can be used to cancel the
|
||
// operation using WSACancelAsyncRequest. It can also be used to match
|
||
// up asynchronous operations and completion messages by examining the
|
||
// wParam message parameter.
|
||
//
|
||
// If the asynchronous operation could not be initiated,
|
||
// WSAAsyncGetHostByName returns a zero value, and a specific error
|
||
// number can be retrieved by calling WSAGetLastError.
|
||
//
|
||
// Error Codes
|
||
//
|
||
// The following error codes can be set when an application window
|
||
// receives a message. As described above, they can be extracted from
|
||
// the lParam in the reply message using the WSAGETASYNCERROR macro.
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// WSAENOBUFS Insufficient buffer space is available.
|
||
//
|
||
// WSAEFAULT name or buf is not in a valid part of the process address
|
||
// space.
|
||
//
|
||
// WSAHOST_NOT_FOUND Authoritative Answer Host not found.
|
||
//
|
||
// WSATRY_AGAIN Non-Authoritative Host not found, or SERVERFAIL.
|
||
//
|
||
// WSANO_RECOVERY Nonrecoverable errors, FORMERR, REFUSED, NOTIMP.
|
||
//
|
||
// WSANO_DATA Valid name, no data record of requested type.
|
||
//
|
||
// The following errors can occur at the time of the function call, and
|
||
// indicate that the asynchronous operation could not be initiated.
|
||
//
|
||
// WSANOTINITIALISED A successful WSAStartup must occur before using
|
||
// this function.
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// WSAEINPROGRESS A blocking Windows Sockets 1.1 call is in progress, or
|
||
// the service provider is still processing a callback function.
|
||
//
|
||
// WSAEWOULDBLOCK The asynchronous operation cannot be scheduled at this
|
||
// time due to resource or other constraints within the Windows Sockets
|
||
// implementation.
|
||
//
|
||
// ----------------------------------------------------------------
|
||
|
||
|
||
//
|
||
// ----------------------------------------------------------------
|
||
//
|
||
// The Windows Sockets WSACancelAsyncRequest function cancels an
|
||
// incomplete asynchronous operation.
|
||
//
|
||
// int WSACancelAsyncRequest (
|
||
// HANDLE hAsyncTaskHandle
|
||
// );
|
||
//
|
||
// Parameters
|
||
// hAsyncTaskHandle
|
||
// [in] Specifies the asynchronous operation to be canceled.
|
||
//
|
||
// Remarks
|
||
// The WSACancelAsyncRequest function is used to cancel an asynchronous
|
||
// operation that was initiated by one of the WSAAsyncGetXByY functions
|
||
// such as WSAAsyncGetHostByName. The operation to be canceled is
|
||
// identified by the hAsyncTaskHandle parameter, which should be set to
|
||
// the asynchronous task handle as returned by the initiating
|
||
// WSAAsyncGetXByY function.
|
||
//
|
||
// Return Values
|
||
// The value returned by WSACancelAsyncRequest is zero if the operation
|
||
// was successfully canceled. Otherwise, the value SOCKET_ERROR is
|
||
// returned, and a specific error number may be retrieved by calling
|
||
// WSAGetLastError.
|
||
//
|
||
// Comments
|
||
// An attempt to cancel an existing asynchronous WSAAsyncGetXByY
|
||
// operation can fail with an error code of WSAEALREADY for two reasons.
|
||
// First, the original operation has already completed and the
|
||
// application has dealt with the resultant message. Second, the
|
||
// original operation has already completed but the resultant message is
|
||
// still waiting in the application window queue.
|
||
//
|
||
// Note
|
||
// It is unclear whether the application can usefully distinguish
|
||
// between WSAEINVAL and WSAEALREADY, since in both cases the error
|
||
// indicates that there is no asynchronous operation in progress with
|
||
// the indicated handle. [Trivial exception: zero is always an invalid
|
||
// asynchronous task handle.] The Windows Sockets specification does not
|
||
// prescribe how a conformant Windows Sockets provider should
|
||
// distinguish between the two cases. For maximum portability, a Windows
|
||
// Sockets application should treat the two errors as equivalent.
|
||
//
|
||
//
|
||
// Error Codes
|
||
// WSANOTINITIALISED A successful WSAStartup must occur before using
|
||
// this function.
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// WSAEINVAL Indicates that the specified asynchronous task handle was
|
||
// invalid
|
||
//
|
||
// WSAEINPROGRESS A blocking Windows Sockets 1.1 call is in progress, or
|
||
// the service provider is still processing a callback function.
|
||
//
|
||
// WSAEALREADY The asynchronous routine being canceled has already
|
||
// completed.
|
||
//
|
||
// ----------------------------------------------------------------
|
||
|
||
|
||
// ----------------------------------------------------------------
|
||
//
|
||
//
|
||
// The Windows Sockets WSAAsyncSelect function requests Windows message-based notification of network events for a socket.
|
||
//
|
||
// int WSAAsyncSelect (
|
||
// SOCKET s,
|
||
// HWND hWnd,
|
||
// unsigned int wMsg,
|
||
// long lEvent
|
||
// );
|
||
//
|
||
// Parameters
|
||
// s
|
||
// [in] A descriptor identifying the socket for which event notification
|
||
// is required.
|
||
//
|
||
// hWnd
|
||
// [in] A handle identifying the window that should receive a message
|
||
// when a network event occurs.
|
||
//
|
||
// wMsg
|
||
// [in] The message to be received when a network event occurs.
|
||
//
|
||
// lEvent
|
||
// [in] A bitmask that specifies a combination of network events in
|
||
// which the application is interested.
|
||
//
|
||
// Remarks
|
||
// This function is used to request that the Windows Sockets DLL should
|
||
// send a message to the window hWnd whenever it detects any of the
|
||
// network events specified by the lEvent parameter. The message that
|
||
// should be sent is specified by the wMsg parameter. The socket for
|
||
// which notification is required is identified by s.
|
||
//
|
||
// This function automatically sets socket s to nonblocking mode,
|
||
// regardless of the value of lEvent. See ioctlsocket about how to set
|
||
// the nonoverlapped socket back to blocking mode.
|
||
//
|
||
// The lEvent parameter is constructed by or'ing any of the values
|
||
// specified in the following list.
|
||
//
|
||
// Value Meaning
|
||
// FD_READ Want to receive notification of readiness for reading
|
||
//
|
||
// FD_WRITE Want to receive notification of readiness for writing
|
||
//
|
||
// FD_OOB Want to receive notification of the arrival of
|
||
// out-of-band data
|
||
//
|
||
// FD_ACCEPT Want to receive notification of incoming connections
|
||
//
|
||
// FD_CONNECT Want to receive notification of completed connection
|
||
//
|
||
// FD_CLOSE Want to receive notification of socket closure
|
||
//
|
||
// FD_QOS Want to receive notification of socket Quality of Service
|
||
// (QOS) changes
|
||
//
|
||
// FD_GROUP_QOS Want to receive notification of socket group Quality of
|
||
// Service (QOS) changes
|
||
//
|
||
// Issuing a WSAAsyncSelect for a socket cancels any previous
|
||
// WSAAsyncSelect or WSAEventSelect for the same socket. For example, to
|
||
// receive notification for both reading and writing, the application
|
||
// must call WSAAsyncSelect with both FD_READ and FD_WRITE, as follows:
|
||
//
|
||
// rc = WSAAsyncSelect(s, hWnd, wMsg, FD_READ|FD_WRITE);
|
||
//
|
||
// It is not possible to specify different messages for different
|
||
// events. The following code will not work; the second call will cancel
|
||
// the effects of the first, and only FD_WRITE events will be reported
|
||
// with message wMsg2:
|
||
//
|
||
// rc = WSAAsyncSelect(s, hWnd, wMsg1, FD_READ);
|
||
// rc = WSAAsyncSelect(s, hWnd, wMsg2, FD_WRITE);
|
||
//
|
||
// To cancel all notification (that is, to indicate that Windows Sockets
|
||
// should send no further messages related to network events on the
|
||
// socket) lEvent should be set to zero.
|
||
//
|
||
// rc = WSAAsyncSelect(s, hWnd, 0, 0);
|
||
//
|
||
// Although in this instance WSAAsyncSelect immediately disables event
|
||
// message posting for the socket, it is possible that messages can be
|
||
// waiting in the application's message queue. The application must
|
||
// therefore be prepared to receive network event messages even after
|
||
// cancellation. Closing a socket with closesocket also cancels
|
||
// WSAAsyncSelect message sending, but the same caveat about messages in
|
||
// the queue prior to the closesocket still applies.
|
||
//
|
||
// Since an accept'ed socket has the same properties as the listening
|
||
// socket used to accept it, any WSAAsyncSelect events set for the
|
||
// listening socket apply to the accepted socket. For example, if a
|
||
// listening socket has WSAAsyncSelect events FD_ACCEPT, FD_READ, and
|
||
// FD_WRITE, then any socket accepted on that listening socket will also
|
||
// have FD_ACCEPT, FD_READ, and FD_WRITE events with the same wMsg value
|
||
// used for messages. If a different wMsg or events are desired, the
|
||
// application should call WSAAsyncSelect, passing the accepted socket
|
||
// and the desired new information.
|
||
//
|
||
// When one of the nominated network events occurs on the specified
|
||
// socket s, the application's window hWnd receives message wMsg. The
|
||
// wParam parameter identifies the socket on which a network event has
|
||
// occurred. The low word of lParam specifies the network event that has
|
||
// occurred. The high word of lParam contains any error code. The error
|
||
// code be any error as defined in WINSOCK2.H. Note Upon receipt of an
|
||
// event notification message the WSAGetLastError function cannot be
|
||
// used to check the error value, because the error value returned can
|
||
// differ from the value in the high word of lParam.
|
||
//
|
||
// The error and event codes can be extracted from the lParam using the
|
||
// macros WSAGETSELECTERROR and WSAGETSELECTEVENT, defined in WINSOCK2.H
|
||
// as:
|
||
//
|
||
// #define WSAGETSELECTERROR(lParam) HIWORD(lParam)
|
||
// #define WSAGETSELECTEVENT(lParam) LOWORD(lParam)
|
||
//
|
||
// The use of these macros will maximize the portability of the source
|
||
// code for the application.
|
||
//
|
||
// The possible network event codes that can be returned are as follows:
|
||
//
|
||
// Value Meaning
|
||
// FD_READ Socket s ready for reading
|
||
//
|
||
// FD_WRITE Socket s ready for writing
|
||
//
|
||
// FD_OOB Out-of-band data ready for reading on socket s
|
||
//
|
||
// FD_ACCEPT Socket s ready for accepting a new incoming connection
|
||
//
|
||
// FD_CONNECT Connection initiated on socket s completed
|
||
//
|
||
// FD_CLOSE Connection identified by socket s has been closed
|
||
//
|
||
// FD_QOS Quality of Service associated with socket s has changed
|
||
//
|
||
// FD_GROUP_QOS Quality of Service associated with the socket group to
|
||
// which s belongs has changed
|
||
//
|
||
// Return Values
|
||
//
|
||
// The return value is zero if the application's declaration of interest
|
||
// in the network event set was successful. Otherwise, the value
|
||
// SOCKET_ERROR is returned, and a specific error number can be
|
||
// retrieved by calling WSAGetLastError.
|
||
//
|
||
// Comments
|
||
//
|
||
// Although WSAAsyncSelect can be called with interest in multiple
|
||
// events, the application window will receive a single message for each
|
||
// network event.
|
||
//
|
||
// As in the case of the select function, WSAAsyncSelect will frequently
|
||
// be used to determine when a data transfer operation (send or recv)
|
||
// can be issued with the expectation of immediate success.
|
||
// Nevertheless, a robust application must be prepared for the
|
||
// possibility that it can receive a message and issue a Windows Sockets
|
||
// 2 call that returns WSAEWOULDBLOCK immediately. For example, the
|
||
// following sequence of events is possible:
|
||
//
|
||
// 1. data arrives on socket s; Windows Sockets 2 posts WSAAsyncSelect
|
||
// message
|
||
//
|
||
// 2. application processes some other message
|
||
//
|
||
// 3. while processing, application issues an ioctlsocket(s,
|
||
// FIONREAD...) and notices that there is data ready to be read
|
||
//
|
||
// 4. application issues a recv(s,...) to read the data
|
||
//
|
||
// 5. application loops to process next message, eventually reaching the
|
||
// WSAAsyncSelect message indicating that data is ready to read
|
||
//
|
||
// 6. application issues recv(s,...), which fails with the error
|
||
// WSAEWOULDBLOCK.
|
||
//
|
||
// Other sequences are possible.
|
||
//
|
||
// The Windows Sockets DLL will not continually flood an application
|
||
// with messages for a particular network event. Having successfully
|
||
// posted notification of a particular event to an application window,
|
||
// no further message(s) for that network event will be posted to the
|
||
// application window until the application makes the function call that
|
||
// implicitly re-enables notification of that network event.
|
||
//
|
||
// Event Re-enabling function
|
||
//
|
||
// FD_READ recv, recvfrom, WSARecv, or WSARecvFrom
|
||
//
|
||
// FD_WRITE send, sendto, WSASend, or WSASendTo
|
||
//
|
||
// FD_OOB recv, recvfrom, WSARecv, or WSARecvFrom
|
||
//
|
||
// FD_ACCEPT accept or WSAAccept unless the error code is WSATRY_AGAIN
|
||
// indicating that the condition function returned CF_DEFER
|
||
//
|
||
// FD_CONNECT NONE
|
||
//
|
||
// FD_CLOSE NONE
|
||
//
|
||
// FD_QOS WSAIoctl with command SIO_GET_QOS
|
||
//
|
||
// FD_GROUP_QOS WSAIoctl with command SIO_GET_GROUP_QOS
|
||
//
|
||
// Any call to the re-enabling routine, even one that fails, results in
|
||
// re-enabling of message posting for the relevant event.
|
||
//
|
||
// For FD_READ, FD_OOB, and FD_ACCEPT events, message posting is
|
||
// "level-triggered." This means that if the re-enabling routine is
|
||
// called and the relevant condition is still met after the call, a
|
||
// WSAAsyncSelect message is posted to the application. This allows an
|
||
// application to be event-driven and not be concerned with the amount
|
||
// of data that arrives at any one time. Consider the following sequence:
|
||
//
|
||
// 1. Network transport stack receives 100 bytes of data on socket s and
|
||
// causes Windows Sockets 2 to post an FD_READ message.
|
||
//
|
||
// 2. The application issues recv( s, buffptr, 50, 0) to read 50 bytes.
|
||
//
|
||
// 3. Another FD_READ message is posted since there is still data to be
|
||
// read.
|
||
//
|
||
// With these semantics, an application need not read all available data
|
||
// in response to an FD_READ message<67>a single recv in response to each
|
||
// FD_READ message is appropriate. If an application issues multiple
|
||
// recv calls in response to a single FD_READ, it can receive multiple
|
||
// FD_READ messages. Such an application may need to disable FD_READ
|
||
// messages before starting the recv calls by calling WSAAsyncSelect
|
||
// with the FD_READ event not set.
|
||
//
|
||
// The FD_QOS and FD_GROUP_QOS events are considered edge triggered. A
|
||
// message will be posted exactly once when a QOS change occurs. Further
|
||
// messages will not be forthcoming until either the provider detects a
|
||
// further change in QOS or the application renegotiates the QOS for the
|
||
// socket.
|
||
//
|
||
// If any event has already happened when the application calls
|
||
// WSAAsyncSelect or when the re-enabling function is called, then a
|
||
// message is posted as appropriate. For example, consider the following
|
||
// sequence:
|
||
//
|
||
// 1. an application calls listen,
|
||
//
|
||
// 2. a connect request is received but not yet accepted,
|
||
//
|
||
// 3. the application calls WSAAsyncSelect specifying that it wants to
|
||
// receive FD_ACCEPT messages for the socket. Due to the persistence of
|
||
// events, Windows Sockets 2 posts an FD_ACCEPT message immediately.
|
||
//
|
||
// The FD_WRITE event is handled slightly differently. An FD_WRITE
|
||
// message is posted when a socket is first connected with
|
||
// connect/WSAConnect (after FD_CONNECT, if also registered) or accepted
|
||
// with accept/WSAAccept, and then after a send operation fails with
|
||
// WSAEWOULDBLOCK and buffer space becomes available. Therefore, an
|
||
// application can assume that sends are possible starting from the
|
||
// first FD_WRITE message and lasting until a send returns
|
||
// WSAEWOULDBLOCK. After such a failure the application will be notified
|
||
// that sends are again possible with an FD_WRITE message.
|
||
//
|
||
// The FD_OOB event is used only when a socket is configured to receive
|
||
// out-of-band data separately. (See section Out-Of-Band data for a
|
||
// discussion of this topic.) If the socket is configured to receive
|
||
// out-of-band data in-line, the out-of-band (expedited) data is treated
|
||
// as normal data and the application should register an interest in,
|
||
// and will receive, FD_READ events, not FD_OOB events. An application
|
||
// may set or inspect the way in which out-of-band data is to be handled
|
||
// by using setsockopt or getsockopt for the SO_OOBINLINE option.
|
||
//
|
||
// The error code in an FD_CLOSE message indicates whether the socket
|
||
// close was graceful or abortive. If the error code is zero, then the
|
||
// close was graceful; if the error code is WSAECONNRESET, then the
|
||
// socket's virtual circuit was reset. This only applies to
|
||
// connection-oriented sockets such as SOCK_STREAM.
|
||
//
|
||
// The FD_CLOSE message is posted when a close indication is received
|
||
// for the virtual circuit corresponding to the socket. In TCP terms,
|
||
// this means that the FD_CLOSE is posted when the connection goes into
|
||
// the TIME WAIT or CLOSE WAIT states. This results from the remote end
|
||
// performing a shutdown on the send side or a closesocket. FD_CLOSE
|
||
// should only be posted after all data is read from a socket, but an
|
||
// application should check for remaining data upon receipt of FD_CLOSE
|
||
// to avoid any possibility of losing data.
|
||
//
|
||
// Please note your application will receive ONLY an FD_CLOSE message to
|
||
// indicate closure of a virtual circuit, and only when all the received
|
||
// data has been read if this is a graceful close. It will not receive
|
||
// an FD_READ message to indicate this condition.
|
||
//
|
||
// The FD_QOS or FD_GROUP_QOS message is posted when any field in the
|
||
// flow specification associated with socket s or the socket group that
|
||
// s belongs to has changed, respectively. Applications should use
|
||
// WSAIoctl with command SIO_GET_QOS or SIO_GET_GROUP_QOS to get the
|
||
// current QOS for socket s or for the socket group s belongs to,
|
||
// respectively.
|
||
//
|
||
// Here is a summary of events and conditions for each asynchronous
|
||
// notification message:
|
||
//
|
||
// FD_READ:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if there is data currently available
|
||
// to receive,
|
||
//
|
||
// 2. when data arrives, if FD_READ not already posted,
|
||
//
|
||
// 3. after recv or recvfrom called (with or without MSG_PEEK), if data
|
||
// is still available to receive. Note when setsockopt SO_OOBINLINE is
|
||
// enabled "data" includes both normal data and out-of-band (OOB) data
|
||
// in the instances noted above. FD_WRITE:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if a send or sendto is possible
|
||
//
|
||
// 2. after connect or accept called, when connection established
|
||
//
|
||
// 3. after send or sendto fail with WSAEWOULDBLOCK, when send or sendto
|
||
// are likely to succeed,
|
||
//
|
||
// 4. after bind on a datagram socket.
|
||
//
|
||
// FD_OOB: Only valid when setsockopt SO_OOBINLINE is disabled (default).
|
||
//
|
||
// 1. when WSAAsyncSelect called, if there is OOB data currently
|
||
// available to receive with the MSG_OOB flag,
|
||
//
|
||
// 2. when OOB data arrives, if FD_OOB not already posted,
|
||
//
|
||
// 3. after recv or recvfrom called with or without MSG_OOB flag, if OOB
|
||
// data is still available to receive.
|
||
//
|
||
// FD_ACCEPT:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if there is currently a connection
|
||
// request available to accept,
|
||
//
|
||
// 2. when a connection request arrives, if FD_ACCEPT not already
|
||
// posted,
|
||
//
|
||
// 3. after accept called, if there is another connection request
|
||
// available to accept.
|
||
//
|
||
// FD_CONNECT:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if there is currently a connection
|
||
// established,
|
||
//
|
||
// 2. after connect called, when connection is established (even when
|
||
// connect succeeds immediately, as is typical with a datagram socket)
|
||
//
|
||
// FD_CLOSE: Only valid on connection-oriented sockets (for example,
|
||
// SOCK_STREAM) 1. when WSAAsyncSelect called, if socket connection has
|
||
// been closed,
|
||
//
|
||
// 2. after remote system initiated graceful close, when no data
|
||
// currently available to receive (note: if data has been received and
|
||
// is waiting to be read when the remote system initiates a graceful
|
||
// close, the FD_CLOSE is not delivered until all pending data has been
|
||
// read),
|
||
//
|
||
// 3. after local system initiates graceful close with shutdown and
|
||
// remote system has responded with "End of Data" notification (for
|
||
// example, TCP FIN), when no data currently available to receive,
|
||
//
|
||
// 4. when remote system terminates connection (for example, sent TCP
|
||
// RST), and lParam will contain WSAECONNRESET error value.
|
||
//
|
||
//
|
||
// Note FD_CLOSE is not posted after closesocket is called. FD_QOS:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if the QOS associated with the socket
|
||
// has been changed,
|
||
//
|
||
// 2. after WSAIoctl with SIO_GET_QOS called, when the QOS is changed.
|
||
//
|
||
// FD_GROUP_QOS:
|
||
//
|
||
// 1. when WSAAsyncSelect called, if the group QOS associated with the
|
||
// socket has been changed,
|
||
//
|
||
// 2. after WSAIoctl with SIO_GET_GROUP_QOS called, when the group QOS
|
||
// is changed. Error Codes
|
||
//
|
||
// WSANOTINITIALISED A successful WSAStartup must occur before using
|
||
// this function.
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// WSAEINVAL Indicates that one of the specified parameters was invalid
|
||
// such as the window handle not referring to an existing window, or the
|
||
// specified socket is in an invalid state.
|
||
//
|
||
// WSAEINPROGRESS A blocking Windows Sockets 1.1 call is in progress, or
|
||
// the service provider is still processing a callback function.
|
||
//
|
||
// WSAENOTSOCK The descriptor is not a socket. Additional error codes
|
||
// may be set when an application window receives a message. This error
|
||
// code is extracted from the lParam in the reply message using the
|
||
// WSAGETSELECTERROR macro. Possible error codes for each network event
|
||
// are:
|
||
//
|
||
// Event: FD_CONNECT
|
||
//
|
||
// Error Code Meaning
|
||
//
|
||
// WSAEADDRINUSE The specified address is already in use.
|
||
//
|
||
// WSAEADDRNOTAVAIL The specified address is not available from the
|
||
// local machine.
|
||
//
|
||
// WSAEAFNOSUPPORT Addresses in the specified family cannot be used with
|
||
// this socket.
|
||
//
|
||
// WSAECONNREFUSED The attempt to connect was forcefully rejected.
|
||
//
|
||
// WSAENETUNREACH The network cannot be reached from this host at this
|
||
// time.
|
||
//
|
||
// WSAEFAULT The namelen parameter is incorrect.
|
||
//
|
||
// WSAEINVAL The socket is already bound to an address.
|
||
//
|
||
// WSAEISCONN The socket is already connected.
|
||
//
|
||
// WSAEMFILE No more file descriptors are available.
|
||
//
|
||
// WSAENOBUFS No buffer space is available. The socket cannot be
|
||
// connected.
|
||
//
|
||
// WSAENOTCONN The socket is not connected.
|
||
//
|
||
// WSAETIMEDOUT Attempt to connect timed out without establishing a
|
||
// connection.
|
||
//
|
||
//
|
||
//
|
||
// Event: FD_CLOSE
|
||
//
|
||
// Error Code Meaning
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// WSAECONNRESET The connection was reset by the remote side.
|
||
//
|
||
// WSAECONNABORTED The connection was terminated due to a time-out or
|
||
// other failure.
|
||
//
|
||
//
|
||
// Event: FD_READ
|
||
//
|
||
// Event: FD_WRITE
|
||
//
|
||
// Event: FD_OOB
|
||
//
|
||
// Event: FD_ACCEPT
|
||
//
|
||
// Event: FD_QOS
|
||
//
|
||
// Event: FD_GROUP_QOS
|
||
//
|
||
// Error Code Meaning
|
||
//
|
||
// WSAENETDOWN The network subsystem has failed.
|
||
//
|
||
// ----------------------------------------------------------------
|