#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef  __CRT__NO_INLINE
#define __CRT__NO_INLINE
#include <wspiapi.h>

char *WINAPI WspiapiStrdup (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;
}

WINBOOL WINAPI
WspiapiParseV4Address (const char *pszAddress,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;
}

struct addrinfo * WINAPI
WspiapiNewAddrInfo (int iSocketType,int iProtocol,WORD wPort,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;
}

int WINAPI
WspiapiQueryDNS(const char *pszNodeName,int iSocketType,int iProtocol,WORD wPort,char pszAlias[NI_MAXHOST],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;
  }
}

int WINAPI
WspiapiLookupNode(const char *pszNodeName,int iSocketType,int iProtocol,WORD wPort,WINBOOL bAI_CANONNAME,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;
}

int WINAPI
WspiapiClone (WORD wPort,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;
}

void WINAPI WspiapiLegacyFreeAddrInfo (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);
  }
}

int WINAPI
WspiapiLegacyGetAddrInfo(const char *pszNodeName,const char *pszServiceName,const struct addrinfo *ptHints,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;
  WINBOOL 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);
}

int WINAPI
WspiapiLegacyGetNameInfo(const struct sockaddr *ptSocketAddress,socklen_t tSocketLength,char *pszNodeName,size_t tNodeLength,char *pszServiceName,size_t tServiceLength,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;
}

FARPROC WINAPI
WspiapiLoad (WORD wFunction)
{
  HMODULE hLibrary = NULL;
  static WINBOOL 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) {
	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) {
	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)) {
	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);
}

int WINAPI WspiapiGetAddrInfo(const char *nodename,const char *servname,const struct addrinfo *hints,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;
}

int WINAPI
WspiapiGetNameInfo (const struct sockaddr *sa,socklen_t salen,char *host,size_t hostlen,char *serv,size_t servlen,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;
}

void WINAPI
WspiapiFreeAddrInfo (struct addrinfo *ai)
{
  static WSPIAPI_PFREEADDRINFO pfFreeAddrInfo = NULL;
  if(!pfFreeAddrInfo) pfFreeAddrInfo = (WSPIAPI_PFREEADDRINFO) WspiapiLoad(2);
  (*pfFreeAddrInfo)(ai);
}