Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-05 22:26:39 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/sdk/include/psdk/wspiapi.h

569 lines
15 KiB
C++
Raw Blame History

#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#if (NTDDI_VERSION >= NTDDI_WIN2K)
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#if defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L
#define _WSPIAPI_STRCPY_S strcpy_s
#define _WSPIAPI_STRCAT_S strcat_s
#else
#define _WSPIAPI_STRCPY_S(_Dst, _Size, _Src) strcpy((_Dst), (_Src))
#define _WSPIAPI_STRCAT_S(_Dst, _Size, _Src) strcat((_Dst), (_Src))
#endif /* defined(__GOT_SECURE_LIB__) && __GOT_SECURE_LIB__ >= 200402L */
#define _WSPIAPI_STRNCPY_S(_Dst, _Size, _Src, _Count) strncpy((_Dst), (_Src), (_Count)); (_Dst)[(_Size) - 1] = 0 //FIXME
#define _WSPIAPI_SPRINTF_S_1(_Dst, _Size, _Format, _Arg1) sprintf((_Dst), (_Format), (_Arg1)) //FIXME
#if !defined(_WSPIAPI_COUNTOF)
#if !defined(__cplusplus)
#define _WSPIAPI_COUNTOF(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#else
template <typename __CountofType, size_t _N>
char (&__wspiapi_countof_helper(__CountofType (&_Array)[_N]))[_N];
#define _WSPIAPI_COUNTOF(_Array) sizeof(__wspiapi_countof_helper(_Array))
#endif
#endif /* !defined(_WSPIAPI_COUNTOF) */
#define WspiapiMalloc(tSize) calloc(1, (tSize))
#define WspiapiFree(p) free(p)
#define WspiapiSwap(a, b, c) {(c) = (a); (a) = (b); (b) = (c);}
#define getaddrinfo WspiapiGetAddrInfo
#define getnameinfo WspiapiGetNameInfo
#define freeaddrinfo WspiapiFreeAddrInfo
#if _MSC_VER
#define WSPIAPI_INLINE __inline
#else
#define WSPIAPI_INLINE static inline
#endif
typedef int
(WINAPI *WSPIAPI_PGETADDRINFO)(
IN const char *nodename,
IN const char *servname,
IN const struct addrinfo *hints,
OUT struct addrinfo **res);
typedef int
(WINAPI *WSPIAPI_PGETNAMEINFO)(
IN const struct sockaddr *sa,
IN socklen_t salen,
OUT char *host,
IN size_t hostlen,
OUT char *serv,
IN size_t servlen,
IN int flags);
typedef void
(WINAPI *WSPIAPI_PFREEADDRINFO)(
IN struct addrinfo *ai);
FORCEINLINE
char *
WINAPI
WspiapiStrdup(
IN const char *pszString)
{
char *pszMemory;
size_t cchMemory;
if (!pszString) return(NULL);
cchMemory = strlen(pszString) + 1;
pszMemory = (char *) WspiapiMalloc(cchMemory);
if (!pszMemory) return(NULL);
_WSPIAPI_STRCPY_S(pszMemory, cchMemory, pszString);
return pszMemory;
}
FORCEINLINE
BOOL
WINAPI
WspiapiParseV4Address(
IN const char *pszAddress,
OUT PDWORD pdwAddress)
{
DWORD dwAddress = 0;
const char *pcNext = NULL;
int iCount = 0;
for (pcNext = pszAddress; *pcNext != '\0'; pcNext++)
if (*pcNext == '.') iCount++;
if (iCount != 3) return FALSE;
dwAddress = inet_addr(pszAddress);
if (dwAddress == INADDR_NONE) return FALSE;
*pdwAddress = dwAddress;
return TRUE;
}
FORCEINLINE
struct addrinfo *
WINAPI
WspiapiNewAddrInfo(
IN int iSocketType,
IN int iProtocol,
IN WORD wPort,
IN DWORD dwAddress)
{
struct addrinfo *ptNew;
struct sockaddr_in *ptAddress;
ptNew = (struct addrinfo *) WspiapiMalloc(sizeof(struct addrinfo));
if (!ptNew) return NULL;
ptAddress = (struct sockaddr_in *) WspiapiMalloc(sizeof(struct sockaddr_in));
if (!ptAddress) {
WspiapiFree(ptNew);
return NULL;
}
ptAddress->sin_family = AF_INET;
ptAddress->sin_port = wPort;
ptAddress->sin_addr.s_addr = dwAddress;
ptNew->ai_family = PF_INET;
ptNew->ai_socktype = iSocketType;
ptNew->ai_protocol = iProtocol;
ptNew->ai_addrlen = sizeof(struct sockaddr_in);
ptNew->ai_addr = (struct sockaddr *) ptAddress;
return ptNew;
}
FORCEINLINE
int
WINAPI
WspiapiQueryDNS(
IN const char *pszNodeName,
IN int iSocketType,
IN int iProtocol,
IN WORD wPort,
OUT char pszAlias[NI_MAXHOST],
OUT struct addrinfo **pptResult)
{
struct addrinfo **pptNext = pptResult;
struct hostent *ptHost = NULL;
char **ppAddresses;
*pptNext = NULL;
pszAlias[0] = '\0';
ptHost = gethostbyname(pszNodeName);
if (ptHost) {
if ((ptHost->h_addrtype == AF_INET) && (ptHost->h_length == sizeof(struct in_addr))) {
for (ppAddresses = ptHost->h_addr_list; *ppAddresses != NULL; ppAddresses++) {
*pptNext = WspiapiNewAddrInfo(iSocketType, iProtocol, wPort, ((struct in_addr *) *ppAddresses)->s_addr);
if (!*pptNext) return EAI_MEMORY;
pptNext = &((*pptNext)->ai_next);
}
}
_WSPIAPI_STRNCPY_S(pszAlias, NI_MAXHOST, ptHost->h_name, NI_MAXHOST - 1);
return 0;
}
switch (WSAGetLastError()) {
case WSAHOST_NOT_FOUND: return EAI_NONAME;
case WSATRY_AGAIN: return EAI_AGAIN;
case WSANO_RECOVERY: return EAI_FAIL;
case WSANO_DATA: return EAI_NODATA;
default: return EAI_NONAME;
}
}
FORCEINLINE
int
WINAPI
WspiapiLookupNode(
IN const char *pszNodeName,
IN int iSocketType,
IN int iProtocol,
IN WORD wPort,
IN BOOL bAI_CANONNAME,
OUT struct addrinfo **pptResult)
{
int iError = 0;
int iAliasCount = 0;
char szFQDN1[NI_MAXHOST] = "";
char szFQDN2[NI_MAXHOST] = "";
char *pszName = szFQDN1;
char *pszAlias = szFQDN2;
char *pszScratch = NULL;
_WSPIAPI_STRNCPY_S(pszName, NI_MAXHOST, pszNodeName, NI_MAXHOST - 1);
for (;;) {
iError = WspiapiQueryDNS(pszNodeName, iSocketType, iProtocol, wPort, pszAlias, pptResult);
if (iError) break;
if (*pptResult) break;
if ((!strlen(pszAlias)) || (!strcmp(pszName, pszAlias)) || (++iAliasCount == 16)) {
iError = EAI_FAIL;
break;
}
WspiapiSwap(pszName, pszAlias, pszScratch);
}
if (!iError && bAI_CANONNAME) {
(*pptResult)->ai_canonname = WspiapiStrdup(pszAlias);
if (!(*pptResult)->ai_canonname) iError = EAI_MEMORY;
}
return iError;
}
FORCEINLINE
int
WINAPI
WspiapiClone(
IN WORD wPort,
IN struct addrinfo *ptResult)
{
struct addrinfo *ptNext = NULL;
struct addrinfo *ptNew = NULL;
for (ptNext = ptResult; ptNext != NULL; ) {
ptNew = WspiapiNewAddrInfo(SOCK_DGRAM, ptNext->ai_protocol, wPort,
((struct sockaddr_in *) ptNext->ai_addr)->sin_addr.s_addr);
if (!ptNew) break;
ptNew->ai_next = ptNext->ai_next;
ptNext->ai_next = ptNew;
ptNext = ptNew->ai_next;
}
if (ptNext != NULL) return EAI_MEMORY;
return 0;
}
static __inline
void
WINAPI
WspiapiLegacyFreeAddrInfo(
IN struct addrinfo *ptHead)
{
struct addrinfo *ptNext;
for (ptNext = ptHead; ptNext != NULL; ptNext = ptHead) {
if (ptNext->ai_canonname) WspiapiFree(ptNext->ai_canonname);
if (ptNext->ai_addr) WspiapiFree(ptNext->ai_addr);
ptHead = ptNext->ai_next;
WspiapiFree(ptNext);
}
}
static __inline
int
WINAPI
WspiapiLegacyGetAddrInfo(
IN const char *pszNodeName,
IN const char *pszServiceName,
IN const struct addrinfo *ptHints,
OUT struct addrinfo **pptResult)
{
int iError = 0;
int iFlags = 0;
int iFamily = PF_UNSPEC;
int iSocketType = 0;
int iProtocol = 0;
WORD wPort = 0;
DWORD dwAddress = 0;
struct servent *ptService = NULL;
char *pc = NULL;
BOOL bClone = FALSE;
WORD wTcpPort = 0;
WORD wUdpPort = 0;
*pptResult = NULL;
if ((!pszNodeName) && (!pszServiceName)) return EAI_NONAME;
if (ptHints) {
if ((ptHints->ai_addrlen != 0) ||
(ptHints->ai_canonname != NULL) ||
(ptHints->ai_addr != NULL) ||
(ptHints->ai_next != NULL)) {
return EAI_FAIL;
}
iFlags = ptHints->ai_flags;
if ((iFlags & AI_CANONNAME) && !pszNodeName) return EAI_BADFLAGS;
iFamily = ptHints->ai_family;
if ((iFamily != PF_UNSPEC) && (iFamily != PF_INET)) return EAI_FAMILY;
iSocketType = ptHints->ai_socktype;
if ((iSocketType != 0) &&
(iSocketType != SOCK_STREAM) &&
(iSocketType != SOCK_DGRAM) &&
(iSocketType != SOCK_RAW))
return EAI_SOCKTYPE;
iProtocol = ptHints->ai_protocol;
}
if (pszServiceName) {
wPort = (WORD) strtoul(pszServiceName, &pc, 10);
if (*pc == '\0') {
wPort = wTcpPort = wUdpPort = htons(wPort);
if (iSocketType == 0) {
bClone = TRUE;
iSocketType = SOCK_STREAM;
}
}
else {
if ((iSocketType == 0) || (iSocketType == SOCK_DGRAM)) {
ptService = getservbyname(pszServiceName, "udp");
if (ptService) wPort = wUdpPort = ptService->s_port;
}
if ((iSocketType == 0) || (iSocketType == SOCK_STREAM)) {
ptService = getservbyname(pszServiceName, "tcp");
if (ptService) wPort = wTcpPort = ptService->s_port;
}
if (wPort == 0) return (iSocketType ? EAI_SERVICE : EAI_NONAME);
if (iSocketType == 0) {
iSocketType = (wTcpPort) ? SOCK_STREAM : SOCK_DGRAM;
bClone = (wTcpPort && wUdpPort);
}
}
}
if ((!pszNodeName) || (WspiapiParseV4Address(pszNodeName, &dwAddress))) {
if (!pszNodeName) dwAddress = htonl((iFlags & AI_PASSIVE) ? INADDR_ANY : INADDR_LOOPBACK);
*pptResult = WspiapiNewAddrInfo(iSocketType, iProtocol, wPort, dwAddress);
if (!(*pptResult)) iError = EAI_MEMORY;
if (!iError && pszNodeName) {
(*pptResult)->ai_flags |= AI_NUMERICHOST;
if (iFlags & AI_CANONNAME) {
(*pptResult)->ai_canonname = WspiapiStrdup(inet_ntoa(*((struct in_addr *) &dwAddress)));
if (!(*pptResult)->ai_canonname) iError = EAI_MEMORY;
}
}
}
else if (iFlags & AI_NUMERICHOST) {
iError = EAI_NONAME;
}
else {
iError = WspiapiLookupNode(pszNodeName, iSocketType,
iProtocol, wPort,
(iFlags & AI_CANONNAME),
pptResult);
}
if (!iError && bClone) {
iError = WspiapiClone(wUdpPort, *pptResult);
}
if (iError) {
WspiapiLegacyFreeAddrInfo(*pptResult);
*pptResult = NULL;
}
return (iError);
}
static __inline
int
WINAPI
WspiapiLegacyGetNameInfo(
IN const struct sockaddr *ptSocketAddress,
IN socklen_t tSocketLength,
OUT char *pszNodeName,
IN size_t tNodeLength,
OUT char *pszServiceName,
IN size_t tServiceLength,
IN int iFlags)
{
struct servent *ptService;
WORD wPort;
char szBuffer[] = "65535";
char *pszService = szBuffer;
struct hostent *ptHost;
struct in_addr tAddress;
char *pszNode = NULL;
char *pc = NULL;
if ((!ptSocketAddress) || (tSocketLength < sizeof(struct sockaddr))) return EAI_FAIL;
if (ptSocketAddress->sa_family != AF_INET) return EAI_FAMILY;
if (tSocketLength < sizeof(struct sockaddr_in)) return EAI_FAIL;
if (!(pszNodeName && tNodeLength) && !(pszServiceName && tServiceLength)) {
return EAI_NONAME;
}
if ((iFlags & NI_NUMERICHOST) && (iFlags & NI_NAMEREQD)) {
return EAI_BADFLAGS;
}
if (pszServiceName && tServiceLength) {
wPort = ((struct sockaddr_in *) ptSocketAddress)->sin_port;
if (iFlags & NI_NUMERICSERV) {
_WSPIAPI_SPRINTF_S_1(szBuffer, _WSPIAPI_COUNTOF(szBuffer), "%u", ntohs(wPort));
}
else {
ptService = getservbyport(wPort, (iFlags & NI_DGRAM) ? "udp" : NULL);
if (ptService && ptService->s_name) {
pszService = ptService->s_name;
}
else {
_WSPIAPI_SPRINTF_S_1(szBuffer, _WSPIAPI_COUNTOF(szBuffer), "%u", ntohs(wPort));
}
}
if (tServiceLength > strlen(pszService))
_WSPIAPI_STRCPY_S(pszServiceName, tServiceLength, pszService);
else return EAI_FAIL;
}
if (pszNodeName && tNodeLength) {
tAddress = ((struct sockaddr_in *) ptSocketAddress)->sin_addr;
if (iFlags & NI_NUMERICHOST) {
pszNode = inet_ntoa(tAddress);
}
else {
ptHost = gethostbyaddr((char *) &tAddress, sizeof(struct in_addr), AF_INET);
if (ptHost && ptHost->h_name) {
pszNode = ptHost->h_name;
if ((iFlags & NI_NOFQDN) && ((pc = strchr(pszNode, '.')) != NULL)) *pc = '\0';
}
else {
if (iFlags & NI_NAMEREQD) {
switch (WSAGetLastError()) {
case WSAHOST_NOT_FOUND: return EAI_NONAME;
case WSATRY_AGAIN: return EAI_AGAIN;
case WSANO_RECOVERY: return EAI_FAIL;
default: return EAI_NONAME;
}
}
else pszNode = inet_ntoa(tAddress);
}
}
if (tNodeLength > strlen(pszNode)) _WSPIAPI_STRCPY_S(pszNodeName, tNodeLength, pszNode);
else return EAI_FAIL;
}
return 0;
}
typedef struct {
char const *pszName;
FARPROC pfAddress;
} WSPIAPI_FUNCTION;
#define WSPIAPI_FUNCTION_ARRAY { \
{"getaddrinfo", (FARPROC) WspiapiLegacyGetAddrInfo}, \
{"getnameinfo", (FARPROC) WspiapiLegacyGetNameInfo}, \
{"freeaddrinfo", (FARPROC) WspiapiLegacyFreeAddrInfo} \
}
WSPIAPI_INLINE
FARPROC
WINAPI
WspiapiLoad(
IN WORD wFunction)
{
HMODULE hLibrary = NULL;
static BOOL bInitialized = FALSE;
static WSPIAPI_FUNCTION rgtGlobal[] = WSPIAPI_FUNCTION_ARRAY;
static const int iNumGlobal = (sizeof(rgtGlobal) / sizeof(WSPIAPI_FUNCTION));
WSPIAPI_FUNCTION rgtLocal[] = WSPIAPI_FUNCTION_ARRAY;
FARPROC fScratch = NULL;
int i = 0;
if (bInitialized) return (rgtGlobal[wFunction].pfAddress);
for (;;) {
CHAR SystemDir[MAX_PATH + 1];
CHAR Path[MAX_PATH + 8];
if (GetSystemDirectoryA(SystemDir, MAX_PATH) == 0) break;
_WSPIAPI_STRCPY_S(Path, _WSPIAPI_COUNTOF(Path), SystemDir);
_WSPIAPI_STRCAT_S(Path, _WSPIAPI_COUNTOF(Path), "\\ws2_32");
hLibrary = LoadLibraryA(Path);
if (hLibrary != NULL) {
fScratch = GetProcAddress(hLibrary, "getaddrinfo");
if (fScratch == NULL) {
FreeLibrary(hLibrary);
hLibrary = NULL;
}
}
if (hLibrary != NULL) break;
_WSPIAPI_STRCPY_S(Path, _WSPIAPI_COUNTOF(Path), SystemDir);
_WSPIAPI_STRCAT_S(Path, _WSPIAPI_COUNTOF(Path), "\\wship6");
hLibrary = LoadLibraryA(Path);
if (hLibrary != NULL) {
fScratch = GetProcAddress(hLibrary, "getaddrinfo");
if (fScratch == NULL) {
FreeLibrary(hLibrary);
hLibrary = NULL;
}
}
break;
}
if (hLibrary != NULL) {
for (i = 0; i < iNumGlobal; i++) {
rgtLocal[i].pfAddress = GetProcAddress(hLibrary, rgtLocal[i].pszName);
if (rgtLocal[i].pfAddress == NULL) {
FreeLibrary(hLibrary);
hLibrary = NULL;
break;
}
}
if (hLibrary != NULL) {
for (i = 0; i < iNumGlobal; i++)
rgtGlobal[i].pfAddress = rgtLocal[i].pfAddress;
}
}
bInitialized = TRUE;
return (rgtGlobal[wFunction].pfAddress);
}
WSPIAPI_INLINE
int
WINAPI
WspiapiGetAddrInfo(
IN const char *nodename OPTIONAL,
IN const char *servname OPTIONAL,
IN const struct addrinfo *hints OPTIONAL,
OUT struct addrinfo **res)
{
int iError;
static WSPIAPI_PGETADDRINFO pfGetAddrInfo = NULL;
if (!pfGetAddrInfo) pfGetAddrInfo = (WSPIAPI_PGETADDRINFO) WspiapiLoad(0);
iError = (*pfGetAddrInfo)(nodename, servname, hints, res);
WSASetLastError(iError);
return iError;
}
WSPIAPI_INLINE
int
WINAPI
WspiapiGetNameInfo(
IN const struct sockaddr *sa,
IN socklen_t salen,
OUT char *host,
IN size_t hostlen,
OUT char *serv,
IN size_t servlen,
IN int flags)
{
int iError;
static WSPIAPI_PGETNAMEINFO pfGetNameInfo = NULL;
if (!pfGetNameInfo) pfGetNameInfo = (WSPIAPI_PGETNAMEINFO) WspiapiLoad(1);
iError = (*pfGetNameInfo)(sa, salen, host, hostlen, serv, servlen, flags);
WSASetLastError(iError);
return iError;
}
WSPIAPI_INLINE
void
WINAPI
WspiapiFreeAddrInfo(
IN struct addrinfo *ai)
{
static WSPIAPI_PFREEADDRINFO pfFreeAddrInfo = NULL;
if (!pfFreeAddrInfo) pfFreeAddrInfo = (WSPIAPI_PFREEADDRINFO) WspiapiLoad(2);
(*pfFreeAddrInfo)(ai);
}
#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
#ifdef __cplusplus
}
#endif
Reference in a new issue View git blame Copy permalink