* Makefile.in (DLL_OFILES): Add minires-os-if.o and minires.o.

	(SUBLIBS): Add libresolv.a.
	Add rule for libresolv.a.
	* autoload.cc: Fix return code handling for IP Helper API in case
	of being unable to load iphlpapi.dll.
	(DnsQuery_A): Define.
	(DnsRecordListFree): Define.
	* cygwin.din: Export resolver functions.
	* include/resolv.h: New header.
	* include/arpa/nameser.h: New header.
	* include/arpa/nameser_compat.h: New header.
	* include/cygwin/version.h: Bump API minor number.
	* libc/minires-os-if.c: New file.
	* libc/minires.c: New file.
	* libc/minires.h: New file.

3 files changed, 1556 insertions, 0 deletions

diff --git a/winsup/cygwin/libc/minires-os-if.c b/winsup/cygwin/libc/minires-os-if.c
new file mode 100644
index 000000000..28676cada
--- /dev/null
+++ b/winsup/cygwin/libc/minires-os-if.c
@@ -0,0 +1,572 @@
+/* minires-os-if.c.  Stub synchronous resolver for Cygwin.
+
+   Copyright 2006 Red Hat, Inc.
+
+   Written by Pierre A. Humblet <Pierre.Humblet@ieee.org>
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include "minires.h"
+
+#ifdef __CYGWIN__
+/***********************************************************************
+ *
+ Windows interface code
+
+***********************************************************************/
+
+/* Conflict between Windows definitions and others */
+#undef ERROR
+#undef NOERROR
+#undef DELETE
+
+#include <windows.h>
+#include <iphlpapi.h>
+#include <windns.h>
+#include <sys/cygwin.h>
+
+/***********************************************************************
+ *
+ write_record: Translates a Windows DNS record into a compressed record
+
+ ***********************************************************************/
+
+#define PUTDOMAIN(d,p)\
+ {int res = dn_comp(d, p, EndPtr - p, dnptrs, lastdnptr); p += res < 0 ? strlen(d) : res; }
+
+static u_char * write_record(unsigned char * ptr, PDNS_RECORD rr, unsigned char * EndPtr,
+			   unsigned char ** dnptrs, unsigned char ** lastdnptr, int debug)
+{
+  u_char * rd_length_ptr;
+
+  PUTDOMAIN(rr->pName, ptr);
+
+  if (ptr + 4 > EndPtr)
+    ptr += 4;
+  else {
+    PUTSHORT(rr->wType, ptr);
+    PUTSHORT(ns_c_in, ptr);
+  }
+  if ((rr->Flags.DW & 0x3) == DnsSectionQuestion)
+    return ptr;
+
+  if (ptr + 4 > EndPtr)
+    ptr += 4;
+  else {
+    PUTLONG(rr->dwTtl, ptr);
+  }
+  rd_length_ptr = ptr;
+  ptr += 2; /* Placeholder for RDLENGTH */
+
+  /* The default case uses an undocumented feature of the Windows
+     resolver for types greater than 16. 
+     The DNS_RECORD Data contains the record in wire format. */
+
+  switch(rr->wType) {
+  case DNS_TYPE_A:
+  {
+    u_char * aptr = (u_char *) & rr->Data.A.IpAddress;
+    if (ptr + 4 <= EndPtr) {
+      ptr[0] = aptr[0];
+      ptr[1] = aptr[1];
+      ptr[2] = aptr[2];
+      ptr[3] = aptr[3];
+    }
+    ptr += 4;
+    break;
+  }
+  case DNS_TYPE_NS:
+  case DNS_TYPE_MD:
+  case DNS_TYPE_MF:
+  case DNS_TYPE_CNAME:
+  case DNS_TYPE_MB:
+  case DNS_TYPE_MG:
+  case DNS_TYPE_MR:
+  case DNS_TYPE_PTR:
+    PUTDOMAIN(rr->Data.PTR.pNameHost, ptr);
+    break;
+  case DNS_TYPE_SOA:
+    PUTDOMAIN(rr->Data.SOA.pNamePrimaryServer, ptr);
+    PUTDOMAIN(rr->Data.SOA.pNameAdministrator, ptr);
+    if (ptr + 20 > EndPtr)
+      ptr += 20;
+    else {
+      PUTLONG(rr->Data.SOA.dwSerialNo, ptr);
+      PUTLONG(rr->Data.SOA.dwRefresh, ptr);
+      PUTLONG(rr->Data.SOA.dwRetry, ptr);
+      PUTLONG(rr->Data.SOA.dwExpire, ptr);
+      PUTLONG(rr->Data.SOA.dwDefaultTtl, ptr);
+    }
+    break;
+  case DNS_TYPE_NULL:
+    if (ptr +  rr->Data.Null.dwByteCount <= EndPtr)
+      memcpy(ptr, rr->Data.Null.Data, rr->Data.Null.dwByteCount);
+    ptr += rr->Data.Null.dwByteCount;
+    if (rr->Data.Null.dwByteCount == rr->wDataLength - sizeof(DNS_NULL_DATA) + 1)
+      DPRINTF(debug, "Null byte count has an unexpected value\n");
+    break;
+  case DNS_TYPE_WKS:
+    if (ptr + rr->wDataLength - sizeof(DNS_WKS_DATA) + 1 + 5 > EndPtr)
+      ptr += rr->wDataLength - sizeof(DNS_WKS_DATA) + 1 + 5;
+    else {
+      PUTLONG(rr->Data.WKS.IpAddress, ptr);
+      *ptr++ = rr->Data.WKS.chProtocol;
+      memcpy(ptr, rr->Data.WKS.BitMask, rr->wDataLength - sizeof(DNS_WKS_DATA) + 1);
+      ptr += rr->wDataLength - sizeof(DNS_WKS_DATA) + 1;
+    }
+    break;
+  case DNS_TYPE_MINFO:
+    PUTDOMAIN(rr->Data.MINFO.pNameMailbox, ptr);
+    PUTDOMAIN(rr->Data.MINFO.pNameErrorsMailbox, ptr);
+    break;
+  case DNS_TYPE_MX:
+    if (ptr + 2 > EndPtr)
+      ptr += 2;
+    else
+      PUTSHORT(rr->Data.MX.wPreference, ptr);
+    PUTDOMAIN(rr->Data.MX.pNameExchange, ptr);
+    break;
+  case DNS_TYPE_HINFO:
+  case DNS_TYPE_TEXT: 
+  {
+    unsigned int i, len;
+    for (i = 0; i < rr->Data.TXT.dwStringCount; i++) {
+      len = strlen(rr->Data.TXT.pStringArray[i]) & 0xFF;
+      if (ptr + len + 1 > EndPtr)
+	ptr += len + 1;
+      else {
+	*ptr++ = len;
+	memcpy(ptr, rr->Data.TXT.pStringArray[i], len);
+	ptr += len;
+      }
+    }
+    break;
+  }
+  default:
+  {
+    unsigned int len = rr->wDataLength;
+    DPRINTF(debug, "No structure for wType %d\n", rr->wType);
+    if (ptr + len <= EndPtr)
+      memcpy(ptr, (char *) &rr->Data, len);
+    ptr += len;
+    break;
+  }
+  }
+  if (rd_length_ptr + 2 <= EndPtr)
+    PUTSHORT(ptr - rd_length_ptr - 2, rd_length_ptr);
+  return ptr;
+}
+
+/***********************************************************************
+ *
+ cygwin_query: implements res_nquery by calling DnsQuery
+
+ ***********************************************************************/
+static int cygwin_query(res_state statp, const char * DomName, int Class, int Type, 
+			unsigned char * AnsPtr, int AnsLength)
+{
+  DNS_STATUS res;
+  PDNS_RECORD pQueryResultsSet, rr;
+  int section, len, counts[4] = {0, 0, 0, 0}, debug = statp->options & RES_DEBUG;
+  unsigned char * dnptrs[256], * ptr;
+
+  dnptrs[0] = AnsPtr;
+  dnptrs[1] = NULL;
+  
+  if (Class != ns_c_in) {
+    errno = ENOSYS;
+    statp->res_h_errno = NETDB_INTERNAL;
+    return -1;
+  }
+
+  res = DnsQuery_A(DomName, Type, DNS_QUERY_TREAT_AS_FQDN,
+		   NULL, &pQueryResultsSet, NULL);
+#if 0
+#define NETDB_INTERNAL -1 /* see errno */
+#define HOST_NOT_FOUND  1 /* Authoritative Answer Host not found */
+#define TRY_AGAIN       2 /* Non-Authoritive Host not found, or SERVERFAIL */
+#define NO_RECOVERY     3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
+#define NO_DATA         4 /* Valid name, no data record of requested type */
+#endif
+
+  DPRINTF(debug, "DnsQuery: %lu (Windows)\n", res);
+  if (res) {
+    switch (res) {
+    case ERROR_PROC_NOT_FOUND:
+      errno = ENOSYS;
+      statp->res_h_errno = NO_RECOVERY;
+      break;
+    case ERROR_INVALID_NAME:
+      errno = EINVAL;
+      statp->res_h_errno = NETDB_INTERNAL;;
+      break;
+    case ERROR_TIMEOUT:
+      statp->res_h_errno = TRY_AGAIN;
+      break;
+    case DNS_ERROR_RCODE_NAME_ERROR:
+      statp->res_h_errno = HOST_NOT_FOUND;
+      break;
+    case DNS_ERROR_RCODE_SERVER_FAILURE:
+      statp->res_h_errno = TRY_AGAIN;
+      break;
+    case DNS_ERROR_NO_DNS_SERVERS:
+    case DNS_ERROR_RCODE_FORMAT_ERROR:
+    case DNS_ERROR_RCODE_NOT_IMPLEMENTED:
+    case DNS_ERROR_RCODE_REFUSED:
+      statp->res_h_errno = NO_RECOVERY;
+      break;
+    case DNS_INFO_NO_RECORDS:      /* May be returned even if the host doesn't exist */
+      statp->res_h_errno = NO_DATA;
+      break;
+    default:
+      DPRINTF(debug, "Unknown code %lu for %s %d\n", res, DomName, Type);
+      statp->res_h_errno = NO_RECOVERY;
+      break;
+    }
+    len = -1;
+    goto done;
+  }
+
+  ptr = AnsPtr + HFIXEDSZ; /* Skip header */
+
+  rr = pQueryResultsSet;
+  section = 0;
+  while (rr) {
+    if (!counts[0] && (rr->Flags.DW & 0x3)) {
+      /* No question. Adopt the first name as the name in the question */
+      if ((len = dn_comp(rr->pName, ptr, AnsLength - 4,
+			 dnptrs, &dnptrs[DIM(dnptrs) - 1])) < 0) {
+	ptr = NULL;
+	break;
+      }
+      ptr += len;
+      PUTSHORT(Type, ptr);
+      PUTSHORT(ns_c_in, ptr);
+      counts[0] = 1;
+    }
+    
+    DPRINTF(debug, "%s Section %d Type %u Windows Record Length %u\n", 
+	    rr->pName, rr->Flags.DW & 0x3, rr->wType, rr->wDataLength);
+
+    /* Check the records are in correct section order */
+    if ((rr->Flags.DW & 0x3) < section) {
+      DPRINTF(debug, "Unexpected section order %s %d\n", DomName, Type);
+      continue;
+    }
+    section =  rr->Flags.DW & 0x3;
+
+    ptr = write_record(ptr, rr, AnsPtr + AnsLength, dnptrs, 
+		       &dnptrs[DIM(dnptrs) - 1], debug);
+
+    counts[section]++;
+    rr = rr->pNext;
+  }
+
+  DnsRecordListFree(pQueryResultsSet, DnsFreeRecordList);
+
+  len = ptr - AnsPtr;
+done:
+  ptr = AnsPtr;
+  PUTSHORT(0, ptr); /* Id */
+  PUTSHORT((QR << 8) + RA + RD, ptr);
+  for (section = 0; section < DIM(counts); section++) {
+    PUTSHORT(counts[section], ptr);
+  }
+  return len;
+}
+
+/***********************************************************************
+ *
+ get_registry_items: returns dns items from the registry
+ 
+ kHey: Handle to registry key
+ KeyValue: key value to read
+ what: 0 addresses ; 1 search list
+
+***********************************************************************/
+static void get_registry_dns_items(HKEY hKey, LPCTSTR KeyValue, 
+				   res_state statp, int what)
+{
+  DWORD size = 0;
+  LONG res;
+  LPBYTE list;
+  int debug = statp->options & RES_DEBUG;
+  
+  res = RegQueryValueEx( hKey, KeyValue, NULL, NULL, NULL, &size);
+  DPRINTF(debug, "value %s, error %lu (Windows), size %lu\n", 
+	  KeyValue, res, size);
+  if ((res == ERROR_SUCCESS) && (size > 1)) { 
+    if (!(list = (LPBYTE) alloca(size))) {
+      DPRINTF(debug, "alloca: %s\n", strerror(errno));
+    }
+    else if ((res = RegQueryValueEx( hKey, KeyValue, NULL, NULL, list,
+				     &size )) != ERROR_SUCCESS) {
+      DPRINTF(debug, "RegQueryValueEx: error %lu (Windows)\n", res);
+    }
+    else if (what == 0) { /* Get the addresses */
+      BYTE *ap, *srch;
+      int numAddresses = 0;
+      for (ap = list; ap < list + size && *ap; ap = srch) {
+        /* The separation character can be 0, ' ', or ','. */
+	for (srch = ap; *srch && (isdigit(*srch) || *srch == '.' ); srch++);
+	*srch++ = 0;
+	if (numAddresses < DIM(statp->nsaddr_list)) {
+	  DPRINTF(debug, "server \"%s\"\n", ap);
+	  statp->nsaddr_list[numAddresses].sin_addr.s_addr = cygwin_inet_addr(ap);
+	  if ( statp->nsaddr_list[numAddresses].sin_addr.s_addr != 0 )
+	    numAddresses++;
+	}
+	else 
+	  DPRINTF(debug, "no space for server \"%s\"\n", ap);
+      }
+      statp->nscount = numAddresses;
+    }
+    else /* Parse the search line */
+      minires_get_search(list, statp); 
+  }
+  return;
+}
+
+/***********************************************************************
+ *
+ get_registry_dns: 
+
+ Read the registry to get dns server addresses in Network Byte Order,
+    and set statp->nscount
+    (for Win9x and NT <= 4.0, but not Win95 with DHCP)
+ Read the registry SearchList
+ 
+***********************************************************************/
+
+static void get_registry_dns(res_state statp)
+{
+  HKEY hKey;     
+  DWORD  res;
+  const char *keyName[] = {"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
+			   "System\\CurrentControlSet\\Services\\VxD\\MSTCP"};
+  int is9x = !!(GetVersion() & 0x80000000);
+  
+  DPRINTF(statp->options & RES_DEBUG, "key %s\n", keyName[is9x]);
+  if ((res = RegOpenKeyEx( HKEY_LOCAL_MACHINE, keyName[is9x], 0, 
+			   KEY_QUERY_VALUE | KEY_READ, &hKey)) != ERROR_SUCCESS) {
+    DPRINTF(statp->options & RES_DEBUG, "RegOpenKeyEx: error %lu (Windows)\n", res);
+    return;
+  }
+
+  if (statp->nscount == 0)
+    get_registry_dns_items(hKey, "NameServer", statp, 0);
+  if (statp->nscount == 0 && !is9x) 
+    get_registry_dns_items(hKey, "DhcpNameServer", statp, 0);
+  if (statp->dnsrch[0] == NULL)
+    get_registry_dns_items(hKey, "SearchList", statp, 1);
+
+  RegCloseKey(hKey);
+
+  return;
+}
+
+/***********************************************************************
+ *
+ get_dns_info: Get the search list or the domain name
+               and the dns server addresses in Network Byte Order
+	       Set statp->os_query if DnsQuery is available.
+ 
+***********************************************************************/
+void get_dns_info(res_state statp)
+{
+#if MAX_HOSTNAME_LEN > MAXHOSTNAMELEN
+#define MAX_HOSTNAME_SIZE (MAX_HOSTNAME_LEN + 1)
+#else
+#define MAX_HOSTNAME_SIZE (MAXHOSTNAMELEN + 1)
+#endif
+#if MAX_HOSTNAME_SIZE > 256 /* sizeof(defdname) */
+#error stap->defdname too short
+#endif
+
+  int res, debug = statp->options & RES_DEBUG;
+
+  ULONG ulOutBufLen = 0;
+  DWORD dwRetVal;
+  IP_ADDR_STRING * pIPAddr;
+  FIXED_INFO * pFixedInfo;
+  HINSTANCE kerneldll;
+  typedef DWORD WINAPI (*GNPType)(PFIXED_INFO, PULONG);
+  GNPType PGetNetworkParams;
+  int numAddresses = 0;
+
+  if (statp->use_os) {
+    DPRINTF(debug, "using dnsapi.dll\n");
+    statp->os_query = (typeof(statp->os_query)) cygwin_query;
+    /* We just need the search list. Avoid loading iphlpapi. */
+    statp->nscount = -1;
+  }
+
+  if (statp->nscount != 0)
+    goto use_registry;
+
+  if (!(kerneldll = LoadLibrary("IPHLPAPI.DLL"))) {
+    DPRINTF(debug, "LoadLibrary: error %lu (Windows)\n", GetLastError());
+    goto use_registry;
+  }
+  if (!(PGetNetworkParams = (GNPType) GetProcAddress(kerneldll, 
+						     "GetNetworkParams"))) {
+    DPRINTF(debug, "GetProcAddress: error %lu (Windows)\n", GetLastError());
+    goto use_registry;
+  }
+  /* First call to get the buffer length we need */
+  dwRetVal = PGetNetworkParams((FIXED_INFO *) 0, &ulOutBufLen);
+  if (dwRetVal != ERROR_BUFFER_OVERFLOW) {
+    DPRINTF(debug, "GetNetworkParams: error %lu (Windows)\n", dwRetVal);
+    goto use_registry;
+  }
+  if ((pFixedInfo = (FIXED_INFO *) alloca(ulOutBufLen)) == 0) {
+    DPRINTF(debug, "alloca: %s\n", strerror(errno));
+    goto use_registry;
+  }
+  if ((dwRetVal = PGetNetworkParams((FIXED_INFO *) pFixedInfo, & ulOutBufLen))) {
+    DPRINTF(debug, "GetNetworkParams: error %lu (Windows)\n", dwRetVal);
+    goto use_registry;
+  }
+
+  DPRINTF(debug, "GetNetworkParams: OK\n");
+  /* Record server addresses, up to array size */
+  for (pIPAddr = &(pFixedInfo->DnsServerList), numAddresses = 0;
+       pIPAddr;
+       pIPAddr = pIPAddr->Next) {
+    if (numAddresses < DIM(statp->nsaddr_list)) {
+	DPRINTF(debug, "server \"%s\"\n", pIPAddr->IpAddress.String);
+      statp->nsaddr_list[numAddresses].sin_addr.s_addr = cygwin_inet_addr(pIPAddr->IpAddress.String);
+      if (statp->nsaddr_list[numAddresses].sin_addr.s_addr != 0) {
+	numAddresses++;
+	statp->nscount++;
+      }
+    }
+    else 
+      DPRINTF(debug, "no space for server \"%s\"\n", pIPAddr->IpAddress.String);
+  }
+
+ use_registry:
+  get_registry_dns(statp);
+
+  if (!statp->dnsrch[0]) {
+    statp->defdname[sizeof(statp->defdname) - 1] = 0;
+    if (!(res = getdomainname(statp->defdname, sizeof(statp->defdname)))) {
+      if (statp->defdname[0] && !statp->defdname[sizeof(statp->defdname) - 1])
+	statp->dnsrch[0] = statp->defdname;
+    }
+    DPRINTF(debug, "getdomainname \"%s\"\n",
+	    (res)? strerror(errno) : statp->defdname);
+  }
+}
+
+#else
+/***********************************************************************
+ *
+ Default interface code
+
+***********************************************************************/
+
+void get_dns_info(res_state statp)
+{
+  return;
+}
+
+#endif
+
+
+
+#if 0
+#define DNS_ERROR_RCODE_FORMAT_ERROR 9001L
+#define DNS_ERROR_RCODE_SERVER_FAILURE 9002L
+#define DNS_ERROR_RCODE_NAME_ERROR 9003L
+#define DNS_ERROR_RCODE_NOT_IMPLEMENTED 9004L
+#define DNS_ERROR_RCODE_REFUSED 9005L
+#define DNS_ERROR_RCODE_YXDOMAIN 9006L
+#define DNS_ERROR_RCODE_YXRRSET 9007L
+#define DNS_ERROR_RCODE_NXRRSET 9008L
+#define DNS_ERROR_RCODE_NOTAUTH 9009L
+#define DNS_ERROR_RCODE_NOTZONE 9010L
+#define DNS_ERROR_RCODE_BADSIG 9016L
+#define DNS_ERROR_RCODE_BADKEY 9017L
+#define DNS_ERROR_RCODE_BADTIME 9018L
+#define DNS_INFO_NO_RECORDS 9501L
+#define DNS_ERROR_BAD_PACKET 9502L
+#define DNS_ERROR_NO_PACKET 9503L
+#define DNS_ERROR_RCODE 9504L
+#define DNS_ERROR_UNSECURE_PACKET 9505L
+#define DNS_ERROR_INVALID_TYPE 9551L
+#define DNS_ERROR_INVALID_IP_ADDRESS 9552L
+#define DNS_ERROR_INVALID_PROPERTY 9553L
+#define DNS_ERROR_TRY_AGAIN_LATER 9554L
+#define DNS_ERROR_NOT_UNIQUE 9555L
+#define DNS_ERROR_NON_RFC_NAME 9556L
+#define DNS_STATUS_FQDN 9557L
+#define DNS_STATUS_DOTTED_NAME 9558L
+#define DNS_STATUS_SINGLE_PART_NAME 9559L
+#define DNS_ERROR_INVALID_NAME_CHAR 9560L
+#define DNS_ERROR_NUMERIC_NAME 9561L
+#define DNS_ERROR_NOT_LALOWED_ON_ROOT_SERVER 9562L
+#define DNS_ERROR_NOT_ALLOWED_UNDER_DELEGATION 9563L
+#define DNS_ERROR_CANNOT_FIND_ROOT_HINTS 9564L
+#define DNS_ERROR_INCONSISTENT_ROOT_HINTS 9565L
+#define DNS_ERROR_ZONE_DOES_NOT_EXIST 9601L
+#define DNS_ERROR_NO_ZONE_INFO 9602L
+#define DNS_ERROR_INVALID_ZONE_OPERATION 9603L
+#define DNS_ERROR_ZONE_CONFIGURATION_ERROR 9604L
+#define DNS_ERROR_ZONE_HAS_NO_SOA_RECORD 9605L
+#define DNS_ERROR_ZONE_HAS_NO_NS_RECORDS 9606L
+#define DNS_ERROR_ZONE_LOCKED 9607L
+#define DNS_ERROR_ZONE_CREATION_FAILED 9608L
+#define DNS_ERROR_ZONE_ALREADY_EXISTS 9609L
+#define DNS_ERROR_AUTOZONE_ALREADY_EXISTS 9610L
+#define DNS_ERROR_INVALID_ZONE_TYPE 9611L
+#define DNS_ERROR_SECONDARY_REQUIRES_MASTER_IP 9612L
+#define DNS_ERROR_ZONE_NOT_SECONDARY 9613L
+#define DNS_ERROR_NEED_SECONDARY_ADDRESSES 9614L
+#define DNS_ERROR_WINS_INIT_FAILED 9615L
+#define DNS_ERROR_NEED_WINS_SERVERS 9616L
+#define DNS_ERROR_NBSTAT_INIT_FAILED 9617L
+#define DNS_ERROR_SOA_DELETE_INVALID 9618L
+#define DNS_ERROR_FORWARDER_ALREADY_EXISTS 9619L
+#define DNS_ERROR_ZONE_REQUIRES_MASTER_IP 9620L
+#define DNS_ERROR_ZONE_IS_SHUTDOWN 9621L
+#define DNS_ERROR_PRIMARY_REQUIRES_DATAFILE 9651L
+#define DNS_ERROR_INVALID_DATAFILE_NAME 9652L
+#define DNS_ERROR_DATAFILE_OPEN_FAILURE 9653L
+#define DNS_ERROR_FILE_WRITEBACK_FAILED 9654L
+#define DNS_ERROR_DATAFILE_PARSING 9655L
+#define DNS_ERROR_RECORD_DOES_NOT_EXIST 9701L
+#define DNS_ERROR_RECORD_FORMAT 9702L
+#define DNS_ERROR_NODE_CREATION_FAILED 9703L
+#define DNS_ERROR_UNKNOWN_RECORD_TYPE 9704L
+#define DNS_ERROR_RECORD_TIMED_OUT 9705L
+#define DNS_ERROR_NAME_NOT_IN_ZONE 9706L
+#define DNS_ERROR_CNAME_LOOP 9707L
+#define DNS_ERROR_NODE_IS_CNAME 9708L
+#define DNS_ERROR_CNAME_COLLISION 9709L
+#define DNS_ERROR_RECORD_ONLY_AT_ZONE_ROOT 9710L
+#define DNS_ERROR_RECORD_ALREADY_EXISTS 9711L
+#define DNS_ERROR_SECONDARY_DATA 9712L
+#define DNS_ERROR_NO_CREATE_CACHE_DATA 9713L
+#define DNS_ERROR_NAME_DOES_NOT_EXIST 9714L
+#define DNS_WARNING_PTR_CREATE_FAILED 9715L
+#define DNS_WARNING_DOMAIN_UNDELETED 9716L
+#define DNS_ERROR_DS_UNAVAILABLE 9717L
+#define DNS_ERROR_DS_ZONE_ALREADY_EXISTS 9718L
+#define DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE 9719L
+#define DNS_INFO_AXFR_COMPLETE 9751L
+#define DNS_ERROR_AXFR 9752L
+#define DNS_INFO_ADDED_LOCAL_WINS 9753L
+#define DNS_STATUS_CONTINUE_NEEDED 9801L
+#define DNS_ERROR_NO_TCPIP 9851L
+#define DNS_ERROR_NO_DNS_SERVERS 9852L
+#define DNS_ERROR_DP_DOES_NOT_EXIST 9901L
+#define DNS_ERROR_DP_ALREADY_EXISTS 9902L
+#define DNS_ERROR_DP_NOT_ENLISTED 9903L
+#define DNS_ERROR_DP_ALREADY_ENLISTED 9904L
+#define DNS_ERROR_DP_NOT_AVAILABLE 9905L
+#endif
diff --git a/winsup/cygwin/libc/minires.c b/winsup/cygwin/libc/minires.c
new file mode 100644
index 000000000..4c9495831
--- /dev/null
+++ b/winsup/cygwin/libc/minires.c
@@ -0,0 +1,916 @@
+/* minires.c.  Stub synchronous resolver for Cygwin.
+
+   Copyright 2006 Red Hat, Inc.
+
+   Written by Pierre A. Humblet <Pierre.Humblet@ieee.org>
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include "minires.h"
+
+/***********************************************************************
+
+Utilities
+
+***********************************************************************/
+/***********************************************************************
+
+dprintf
+***********************************************************************/
+void minires_dprintf(const char * format, ...)
+{
+  va_list args;
+  
+  va_start(args, format);
+  fprintf(stderr, "Minires: ");
+  vfprintf(stderr, format, args);
+  va_end(args);
+}
+
+/***********************************************************************
+
+scanline
+Put pointers in list[] to the beginning of each space or comma delimited
+word in "in", and put the lengths in sizes[] (counting the final 0).
+Return the number of words found  
+***********************************************************************/
+static int scanline(char * in, char **list, int * sizes, int maxnum)
+{
+  int i;
+  char * startp;
+  for (i = 0; i < maxnum; i++) {
+    while((*in) && (isspace(*in) || *in == ',')) in++;
+    if (*in == 0) 
+      break;
+    startp = in++;
+    while((*in) && !isspace(*in) && *in != ',') in++;
+    list[i] = startp;
+    sizes[i] = in - startp + 1; 
+    if (*in)
+      *in++ = 0;
+  }
+  return i;
+}
+
+/***********************************************************************
+
+Read the search string.
+
+***********************************************************************/
+void minires_get_search(char * string, res_state statp)
+{
+  char * words[MAXDNSRCH+1], * ptr;
+  int sizes[MAXDNSRCH+1];
+  int i, j, debug = statp->options & RES_DEBUG;
+
+  i = scanline(string, words, sizes, MAXDNSRCH+1);
+  ptr = statp->defdname;
+  for (j = 0; j < i; j++) {
+    if (j < MAXDNSRCH 
+	&& ptr + sizes[j] < &statp->defdname[DIM(statp->defdname)]) {
+      statp->dnsrch[j] = strcpy(ptr, words[j]);
+      statp->dnsrch[j+1] = NULL;
+      ptr += sizes[j];
+      DPRINTF(debug, "search \"%s\"\n", words[j]);
+    }
+    else
+      DPRINTF(debug, "no space for \"%s\"\n", words[j]);
+  }
+}
+
+/***********************************************************************
+
+Read options
+
+
+***********************************************************************/
+static void get_options(res_state statp, int i, char **words)
+{
+  char *ptr;
+  int value;
+
+  while (i-- > 0) {
+    if (!strcasecmp("debug", words[i])) {
+      statp->options |= RES_DEBUG;
+      DPRINTF(statp->options & RES_DEBUG, "%s: 1\n", words[i]);
+      continue;
+    }
+    if (!strcasecmp("osquery", words[i])) {
+      statp->use_os = 1;
+      DPRINTF(statp->options & RES_DEBUG, "%s: 1\n", words[i]);
+      continue;
+    }
+
+    if ((ptr = strchr(words[i], ':'))) {
+      *ptr++ = 0;
+      value = atoi(ptr);
+      /* Not supported 
+	 if (!strcasecmp("ndots", words[i])) {
+	 statp->ndots = value;
+	 continue;
+	 }
+      */
+      if (!strcasecmp("retry", words[i])) {
+	if (value < 1)
+	  value = 1;
+	statp->retry = value;
+	DPRINTF(statp->options & RES_DEBUG, "%s: %d\n", words[i], value);
+	continue;
+      }
+      if (!strcasecmp("retrans", words[i])) {
+	if (value < 1)
+	  value = 1;
+	statp->retrans = value;
+	DPRINTF(statp->options & RES_DEBUG, "%s: %d\n", words[i], value);
+	continue;
+      }
+    }
+    DPRINTF(statp->options & RES_DEBUG, "unknown option: \"%s\"\n", words[i]);
+  }
+}
+
+/***********************************************************************
+
+Read the resolv.conf file.
+We only look for nameserver, domain, search and options
+
+***********************************************************************/
+#if MAXNS > MAXDNSRCH + 1
+#define MAXSIZE MAXNS
+#else 
+#define MAXSIZE MAXDNSRCH + 1 /* Make unused one visible */
+#endif
+static void get_resolv(res_state statp)
+{
+  FILE * fd;
+  char *words[MAXSIZE + 1], line[4096], *ptr;
+  int sizes[DIM(words)];
+  int i, j, ns = 0, have_search, have_address, debug = statp->options & RES_DEBUG;
+
+  fd = fopen(_PATH_RESCONF, "r");
+  DPRINTF(debug, _PATH_RESCONF ": %s\n", fd?"OK":strerror(errno));
+  if (fd == NULL)
+    return;
+
+  statp->use_os = 0; /* Do not use os_query, except if allowed by "options" */
+  have_search = (statp->dnsrch[0] != NULL);
+  have_address = (statp->nscount != 0);
+
+  while ( fgets(line, sizeof(line), fd) != 0) {
+    DPRINTF(debug, "resolv.conf %s", line);
+    if ((i = scanline(line, words, sizes, DIM(words))) > 0) {
+      if (!have_address 
+	  && !strncasecmp("nameserver", words[0], sizes[0])) {
+	for ( j = 1; j < i ; j++) {
+	  unsigned int address;
+	  address = cygwin_inet_addr(words[j]);
+	  if (address == -1) {
+	    DPRINTF(debug, "invalid server \"%s\"\n", words[j]);
+	  }
+	  else if (ns >= MAXNS) {
+	    DPRINTF(debug, "no space for server \"%s\"\n", words[j]);
+	  }
+	  else {
+	    statp->nsaddr_list[ns++].sin_addr.s_addr = address;
+	    statp->nscount++;
+	    DPRINTF(debug, "server \"%s\"\n", words[j]);
+	  }
+	}
+      }
+      else if (!have_search 
+	       && (!strncasecmp("search", words[0], sizes[0])
+		   || !strncasecmp("domain", words[0], sizes[0]))) {
+	ptr = statp->defdname;
+	for (j = 0; j + 1 < i; j++) {
+	  if (j < MAXDNSRCH
+	      && ptr + sizes[j + 1] < &statp->defdname[DIM(statp->defdname)]) {
+	    statp->dnsrch[j] = strcpy(ptr, words[j+1]);
+	    statp->dnsrch[j+1] = 0;
+	    ptr += sizes[j+1];
+	    DPRINTF(debug, "domain|search \"%s\"\n", statp->dnsrch[j]);
+	  }
+	  else {
+	    DPRINTF(debug, "no space for \"%s\"\n", words[j+1]);
+	  }
+	}
+      }
+      /* Options line */
+      else if (!strncasecmp("options", words[0], sizes[0]))
+	get_options(statp, i - 1, &words[1]);
+    }
+  }
+  fclose(fd);
+  return;
+}
+
+/****************************************************************************/
+/* 
+   open_sock()
+   Create a datagram socket and call bind.
+
+****************************************************************************/
+
+static int open_sock(struct sockaddr_in *CliAddr, int debug)
+{
+  int fd;
+  
+  DPRINTF(debug, "opening UDP socket\n");
+
+  /* Create a datagram socket */
+  if ((fd = cygwin_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+    DPRINTF(debug, "socket(UDP): %s\n", strerror(errno));
+    return -1;
+  }
+  CliAddr->sin_family = AF_INET;
+  CliAddr->sin_addr.s_addr = htonl(INADDR_ANY);
+  CliAddr->sin_port = htons(0);
+  bzero(CliAddr->sin_zero, sizeof(CliAddr->sin_zero));
+  /* Get a port */
+  if (cygwin_bind(fd, (struct sockaddr *) CliAddr, sizeof(*CliAddr)) < 0) {
+    DPRINTF(debug, "bind: %s\n", strerror(errno));
+    return -1;
+  }
+  return fd;
+}
+
+/*****************************************************************
+ *
+ __res_state()
+ Undocumented but public. Accessed through _res
+
+ *****************************************************************/
+static struct __res_state res;
+struct __res_state *__res_state(void)
+{
+  return & res;
+}
+
+/*****************************************************************
+ *
+ res_init()
+
+ *****************************************************************/
+int res_ninit(res_state statp)
+{
+  int i;
+  char * ptr;
+  
+  statp->res_h_errno = NETDB_SUCCESS;
+  statp->nscount = 0;
+  statp->os_query = NULL;
+  statp->retrans = RES_TIMEOUT; /* timeout in seconds */
+  statp->retry = RES_MAXRETRY;  /* max number of retries */
+  statp->use_os = 1;            /* use os_query if available and allowed by get_resolv */
+  statp->mypid = -1;
+  statp->sockfd = -1;
+
+  for (i = 0; i < DIM(statp->dnsrch); i++)  statp->dnsrch[i] = 0;
+
+  /* Get search list from LOCALDOMAIN */
+  if ((ptr = getenv("LOCALDOMAIN")) != 0 ) {
+    DPRINTF(statp->options & RES_DEBUG, "LOCALDOMAIN \"%s\"\n", ptr);
+    minires_get_search(ptr, statp); /* domain or dnsrch */
+  }
+  /* resolv.conf (dns servers & search list)*/
+  get_resolv(statp);
+  /* Get dns servers and search list from an os-specific routine, set os_query */
+  get_dns_info(statp);
+      
+  if (statp->nscount == 0 && !statp->os_query) {
+    errno = ENONET;
+    statp->res_h_errno = NETDB_INTERNAL;
+    DPRINTF(statp->options & RES_DEBUG, "no dns server found\n"); 
+    return -1;
+  }
+  for (i = 0; i < statp->nscount; i++) {
+    statp->nsaddr_list[i].sin_family = AF_INET;
+    statp->nsaddr_list[i].sin_port = htons(NAMESERVER_PORT);
+    bzero(statp->nsaddr_list[i].sin_zero, sizeof(statp->nsaddr_list[i].sin_zero));
+  }
+  /* Only debug may be set before calling init */
+  statp->options &= RES_DEBUG;
+  statp->options |= RES_INIT | RES_DEFAULT;
+  return 0;
+}
+
+int res_init()
+{
+  int r = res_ninit(& res);
+  h_errno = res.res_h_errno;
+  return r;
+}
+
+/*****************************************************************
+ *
+ res_close()
+
+ *****************************************************************/
+void res_nclose(res_state statp)
+{
+  int res;
+  if (statp->sockfd != -1) {
+    res = close(statp->sockfd);
+    DPRINTF(statp->options & RES_DEBUG, "close sockfd %d: %s\n", 
+	    statp->sockfd, (res == 0)?"OK":strerror(errno));
+    statp->sockfd = -1;
+  }
+}
+
+void res_close()
+{
+  res_nclose(& res);
+}  
+
+/*****************************************************************
+ *
+ get_tcp_buf()
+
+ *****************************************************************/
+static int get_tcp_buf(int fd, unsigned char *buf, int size, int debug)
+{
+  int res;
+  while (size > 0) {
+    if ((res = read(fd, buf, size)) < 0) {
+      DPRINTF(debug, "read: %s\n", strerror(errno));
+      return -1;
+    }
+    DPRINTF(debug, "read %d out of %d\n", res, size);
+    size -= res;
+    buf += res;
+  }
+  return 0;
+}
+
+/*****************************************************************
+ *
+ get_tcp()
+
+ *****************************************************************/
+static int get_tcp(struct sockaddr_in *CliAddr, 
+		   const unsigned char * MsgPtr, int MsgLength,
+		   unsigned char * AnsPtr, int AnsLength, int debug)
+{
+  int fd, res = -1;
+  unsigned short ans_length;
+  union {short len; u_char buf[sizeof(short)];} len_buf;
+
+  DPRINTF(debug, "retrying with TCP\n");
+
+  /* Create a tcp socket */
+  if ((fd = cygwin_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+    DPRINTF(debug, "socket(TCP): %s\n", strerror(errno));
+    return -1;
+  }
+
+  if (cygwin_connect(fd, (struct sockaddr *)  CliAddr, sizeof(* CliAddr)) < 0) {
+    DPRINTF(debug, "connect: %s\n", strerror(errno));
+    goto done;
+  }
+
+  /* Send the length then the message */
+  len_buf.len = htons(MsgLength);
+  if (write(fd, len_buf.buf, sizeof(len_buf)) != sizeof(len_buf)
+      || write(fd, MsgPtr, MsgLength) != MsgLength) {
+    DPRINTF(debug, "write: %s\n", strerror(errno));
+    goto done;
+  }
+
+  /* Read the answer length */
+  if (get_tcp_buf(fd, len_buf.buf, sizeof(len_buf), debug))
+    goto done;
+  ans_length = ntohs(len_buf.len);
+
+  /* Read the answer */
+  if (get_tcp_buf(fd, AnsPtr, MIN(ans_length, AnsLength), debug)) 
+    goto done;
+  res = ans_length;
+
+ done:
+  close (fd);
+  return res;
+}
+
+/*****************************************************************
+ **
+ res_send
+ Assumes that the message is a query starting with a short id.
+ Handles retransmissions until that id is received.
+ 
+*****************************************************************/
+int res_nsend( res_state statp, const unsigned char * MsgPtr, 
+	       int MsgLength, unsigned char * AnsPtr, int AnsLength)
+{
+  /* Current server, shared by all tasks */
+  volatile static unsigned int SServ = 0XFFFFFFFF;
+  int tcp;
+  const int debug = statp->options & RES_DEBUG;
+
+  fd_set fdset_read; 
+  int rslt, addrLen, transNum, wServ;
+  struct sockaddr_in mySockAddr, dnsSockAddr;
+  struct timeval timeOut;
+  
+  statp->res_h_errno = NETDB_SUCCESS;
+  if (((statp->options & RES_INIT) == 0) && (res_ninit(statp) != 0)) 
+    return -1;
+
+  /* Close the socket if it had been opened before a fork.
+     Reuse of pid's cannot hurt */
+  if ((statp->sockfd != -1) && (statp->mypid != getpid())) {
+    res_nclose(statp);
+  }
+
+  /* Open a socket for this process */
+  if (statp->sockfd == -1) {
+    /* Create a socket and bind it (to any port) */
+    statp->sockfd = open_sock(& mySockAddr, debug);
+    if (statp->sockfd  < 0 ) {
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    }
+    /* Set close on exec flag */
+    if (fcntl(statp->sockfd, F_SETFD, 1) == -1) {
+      DPRINTF(debug, "fcntl: %s\n", 
+	      strerror(errno));
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    }
+    statp->mypid = getpid();
+    if (SServ == 0XFFFFFFFF) /* Pseudo random */
+      SServ =  statp->mypid % statp->nscount;
+  }
+
+  transNum = 0;  
+  while ( transNum++ < statp->retry) {
+    if ((wServ = SServ + 1) >= statp->nscount) 
+      wServ = 0;
+    SServ = wServ;
+    /* Send the message */
+    rslt = cygwin_sendto(statp->sockfd, MsgPtr, MsgLength, 0, 
+			 (struct sockaddr *) &statp->nsaddr_list[wServ],
+			 sizeof(struct sockaddr_in));
+    DPRINTF(debug, "sendto: server %08x sockfd %d %s\n",
+	    statp->nsaddr_list[wServ].sin_addr.s_addr, 
+	    statp->sockfd, (rslt == MsgLength)?"OK":strerror(errno));
+    if (rslt != MsgLength) {
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    };
+    /*
+      Wait for a reply with select()
+    */
+    FD_ZERO(&fdset_read);
+    FD_SET (statp->sockfd, &fdset_read );
+    timeOut.tv_sec = statp->retrans;
+    timeOut.tv_usec = 0;
+    rslt = cygwin_select(statp->sockfd + 1, &fdset_read, NULL, NULL, &timeOut);
+    if ( rslt == 0 ) { /* Timeout */
+      DPRINTF(statp->options & RES_DEBUG, "timeout for server %08x\n",
+	      statp->nsaddr_list[wServ].sin_addr.s_addr);
+      continue;
+    }
+    else if ((rslt != 1) || (FD_ISSET(statp->sockfd, &fdset_read) == 0)) {
+      DPRINTF(debug, "select: %s\n", strerror(errno));
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    }
+
+    addrLen = sizeof(dnsSockAddr);
+    rslt = cygwin_recvfrom(statp->sockfd, AnsPtr, AnsLength, 0, 
+			   (struct sockaddr *) & dnsSockAddr, & addrLen);
+    if (rslt <= 0) {
+      DPRINTF(debug, "recvfrom: %s\n", strerror(errno));
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    }
+    /* 
+       Prepare to retry with tcp 
+    */
+    for (tcp = 0; tcp < 2; tcp++) {
+      /* Check if this is the message we expected */
+      if ((*MsgPtr == *AnsPtr)     /* Ids match */
+	  && (*(MsgPtr + 1) == *(AnsPtr + 1))
+/* We have stopped checking this because the question may not be present on error,
+   in particular when the name in the question is not a valid name.
+   Simply check that the header is present. */
+	  && (rslt >= HFIXEDSZ)
+/*        && (rslt >= MsgLength )
+	  && (memcmp(MsgPtr + HFIXEDSZ, AnsPtr + HFIXEDSZ, MsgLength - HFIXEDSZ) == 0) */
+	  && ((AnsPtr[2] & QR) != 0)) {
+
+	DPRINTF(debug, "answer %u from %08x. Error %d. Count %d.\n",
+		rslt, dnsSockAddr.sin_addr.s_addr, 
+		AnsPtr[3] & ERR_MASK, AnsPtr[6]*256 + AnsPtr[7]);
+#if 0
+ NETDB_INTERNAL -1 /* see errno */
+ NETDB_SUCCESS   0 /* no problem */
+ HOST_NOT_FOUND  1 /* Authoritative Answer Host not found */
+ TRY_AGAIN       2 /* Non-Authoritive Host not found, or SERVERFAIL */
+                         Also seen returned by some servers when the name is too long
+ NO_RECOVERY     3 /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */
+ NO_DATA         4 /* Valid name, no data record of requested type */
+#endif
+	if ((AnsPtr[3] & ERR_MASK) == NOERROR) {
+	  if ((AnsPtr[2] & TC) && !(statp->options & RES_IGNTC)) { /* Truncated. Try TCP */
+	    rslt = get_tcp(&statp->nsaddr_list[wServ], MsgPtr, MsgLength,
+			   AnsPtr, AnsLength, statp->options & RES_DEBUG);
+	    continue; 
+	  }
+	  else if ((AnsPtr[6] | AnsPtr[7])!= 0) 
+	    return rslt;
+	  else 
+	    statp->res_h_errno = NO_DATA;
+	}
+	else {
+	  /* return HOST_NOT_FOUND even for non-authoritative answers */
+	  if ((AnsPtr[3] & ERR_MASK) == NXDOMAIN) 
+	    statp->res_h_errno = HOST_NOT_FOUND;
+	  else if ((AnsPtr[3] & ERR_MASK) == SERVFAIL) 
+	    statp->res_h_errno = TRY_AGAIN;
+	  else 
+	    statp->res_h_errno = NO_RECOVERY;
+	}
+	return -1;
+      }
+      else {
+	DPRINTF(debug, "unexpected answer %u from %x to query to %x\n",
+		rslt, dnsSockAddr.sin_addr.s_addr, 
+		statp->nsaddr_list[wServ].sin_addr.s_addr);
+	break;
+      }
+    } /* TCP */
+  }
+  DPRINTF(debug, "too many retries\n");
+  statp->res_h_errno = TRY_AGAIN;
+  return -1;
+}
+
+int res_send( const unsigned char * MsgPtr, int MsgLength, 
+	      unsigned char * AnsPtr, int AnsLength)
+{
+  int r = res_nsend(& res, MsgPtr, MsgLength, AnsPtr, AnsLength);
+  h_errno = res.res_h_errno;
+  return r;
+}
+
+/*****************************************************************
+ *
+ res_mkquery
+
+ Return: packet size
+        -1 name format is incorrect 
+*****************************************************************/
+int res_nmkquery (res_state statp,
+		  int op, const char * dnameptr, int qclass, int qtype, 
+		  const unsigned char * dataptr, int datalen,
+		  const unsigned char * newrr, unsigned char * buf, int buflen)
+{
+  int i, len;
+  short id;
+
+  if (op == QUERY) {
+    /* Write the name and verify buffer length */
+    len = dn_comp(dnameptr, buf + HFIXEDSZ, buflen - HFIXEDSZ - QFIXEDSZ, NULL, NULL);
+    if (len < 0) {
+      DPRINTF(statp->options & RES_DEBUG, 
+	      "\"%s\" invalid or buffer too short\n", dnameptr);
+      statp->res_h_errno = NETDB_INTERNAL;
+      return -1;
+    }
+    /* Fill the header */
+    id = statp->id;
+    PUTSHORT(id, buf);
+    PUTSHORT(RD, buf); 
+    PUTSHORT(1, buf); /* Number of questions */
+    for (i = 0; i < 3; i++)
+      PUTSHORT(0, buf); /* Number of answers */
+
+    /* Write qtype and qclass */
+    buf += len;
+    PUTSHORT(qtype, buf);
+    PUTSHORT(qclass, buf);
+    return len + 16; /* packet size */
+  }
+  else { /* Not implemented */
+    errno = ENOSYS;
+    statp->res_h_errno = NETDB_INTERNAL;
+    return -1;
+  }
+}
+
+int res_mkquery (int op, const char * dnameptr, int qclass, int qtype, 
+		 const unsigned char * dataptr, int datalen,
+		 const unsigned char * newrr, unsigned char * buf, int buflen)
+{
+  int r = res_nmkquery (& res, op, dnameptr, qclass, qtype, 
+			dataptr, datalen, newrr, buf, buflen);
+  h_errno = res.res_h_errno;
+  return r;
+
+}
+
+/*****************************************************************
+ *
+ res_query()
+                                                                  
+ *****************************************************************/
+
+int res_nquery( res_state statp, const char * DomName, int Class, int Type, 
+		unsigned char * AnsPtr, int AnsLength)
+{
+  u_char packet[PACKETSZ];
+  int len;
+  
+  DPRINTF(statp->options & RES_DEBUG, "query \"%s\" type %d\n", DomName, Type);
+  statp->res_h_errno = NETDB_SUCCESS;
+
+  /* If a hook exists to a native implementation, use it */
+  if (statp->os_query)
+    return ((os_query_t *) statp->os_query)(statp, DomName, Class, Type, AnsPtr, AnsLength);
+
+  if ((len = res_nmkquery (statp, QUERY, DomName, Class, Type, 
+			   0, 0, 0, packet, PACKETSZ)) < 0)
+    return -1;
+  return res_nsend( statp, packet, len, AnsPtr, AnsLength);
+}
+
+int res_query( const char * DomName, int Class, int Type, unsigned char * AnsPtr, int AnsLength)
+{
+  int r = res_nquery(& res, DomName, Class, Type, AnsPtr, AnsLength);
+  h_errno = res.res_h_errno;
+  return r;
+}
+
+/*****************************************************************
+ *
+ res_querydomain()
+                                                                  
+ *****************************************************************/
+int res_nquerydomain( res_state statp, const char * Name, const char * DomName,
+		      int Class, int Type, unsigned char * AnsPtr, int AnsLength)
+{
+  char fqdn[MAXDNAME], *ptr;
+  int nlen;
+
+  if (!DomName)
+    ptr = (char *) Name;
+  else if ((nlen = strlen(Name)) >= sizeof(fqdn) - 1)
+    goto error;
+  else {
+    strcpy(fqdn, Name);
+    ptr = &fqdn[nlen];
+    if (nlen && *(ptr - 1) != '.') 
+      *(ptr++ - 1) = '.';
+    fqdn[sizeof(fqdn) - 1] = 0;
+    strncpy(ptr, DomName, sizeof(fqdn) - (ptr - fqdn));
+    if (fqdn[sizeof(fqdn) - 1])
+      goto error;
+    ptr = fqdn;
+  }
+  return res_nquery(statp, ptr, Class, Type, AnsPtr, AnsLength);
+
+ error:
+  DPRINTF(statp->options & RES_DEBUG, "querydomain: name too long\n");
+  errno = EINVAL;
+  statp->res_h_errno = NETDB_INTERNAL;;
+  return -1;
+}
+
+int res_querydomain( const char * Name, const char * DomName, int Class,
+		     int Type, unsigned char * AnsPtr, int AnsLength)
+{
+  int r = res_nquerydomain(& res, Name, DomName, Class, Type, AnsPtr,
+			   AnsLength);
+  h_errno = res.res_h_errno;
+  return r;
+}
+
+/*****************************************************************
+ *
+ res_search()
+
+ *****************************************************************/
+
+int res_nsearch( res_state statp, const char * DomName, int Class, int Type, 
+		 unsigned char * AnsPtr, int AnsLength)
+{
+  int len, stat, i;
+  char fullDomName[MAXDNAME], *ptr, *sptr;
+
+  DPRINTF(statp->options & RES_DEBUG, "search \"%s\" type %d\n", DomName, Type);
+
+  if (((statp->options & RES_INIT) == 0) && (res_ninit(statp) != 0)) 
+    return -1;
+
+  stat = res_nquery( statp, DomName, Class, Type, AnsPtr, AnsLength);
+
+  /* Check if will skip search */
+  if (statp->res_h_errno != HOST_NOT_FOUND               /* Success or hard failure */
+      || ((ptr = strrchr(DomName, '.')) && (!*(ptr+1)))  /* Final dot */ 
+      || (((statp->options & RES_DNSRCH) == 0)           /* Or no search */
+	  && ((ptr != NULL)                              /*  And some dot */
+	      || ((statp->options & RES_DEFNAMES) == 0)))/*    or no def domain */
+      || (!(sptr = statp->dnsrch[0])))                 
+    return stat;
+
+  len = strlen(DomName);
+  if (len >= MAXDNAME - 1) /* Space for next dot */
+    goto error;
+  strcpy(fullDomName, DomName); 
+  fullDomName[len++] = '.';
+  fullDomName[MAXDNAME - 1] = 0; /* Overflow indicator */
+  i = 0;
+  do {
+    strncpy(fullDomName + len, sptr, MAXDNAME - len);
+    if (fullDomName[MAXDNAME - 1])
+      goto error;      
+    stat = res_nquery(statp, fullDomName, Class, Type, AnsPtr, AnsLength);
+  } while ((sptr = statp->dnsrch[++i]) != NULL
+	   && statp->res_h_errno == HOST_NOT_FOUND
+	   && (statp->options & RES_DNSRCH) != 0);
+
+  /* Return last stat */
+  return stat;
+
+ error:
+  DPRINTF(statp->options & RES_DEBUG, "name too long during search\n");
+  errno = EINVAL;
+  statp->res_h_errno = NETDB_INTERNAL;
+  return -1;
+}
+
+int res_search( const char * DomName, int Class, int Type, 
+		unsigned char * AnsPtr, int AnsLength)
+{
+  int r = res_nsearch(& res, DomName, Class, Type, AnsPtr, AnsLength);
+  h_errno = res.res_h_errno;
+  return r;
+}
+
+/*****************************************************************
+ *
+ dn_expand
+                                                                  
+ *****************************************************************/
+
+int dn_expand(const unsigned char *msg, const unsigned char *eomorig,
+              const unsigned char *comp_dn, char *exp_dn, int length)
+{
+  unsigned int len, complen = 0;
+  const unsigned char *comp_dn_orig = comp_dn;
+/*  char * exp_start = exp_dn; */
+
+  errno = EINVAL;
+  if (comp_dn >= eomorig)
+    goto expand_fail;
+  if ((len = *comp_dn++) == 0)       /* Weird case */
+    exp_dn++;
+  else do {
+    if (len <= MAXLABEL) {
+      if ((length -= (len + 1)) > 0 /* Need space for final . */
+	  && comp_dn + len <= eomorig) {
+        do { *exp_dn++ = *comp_dn++; } while (--len != 0);
+        *exp_dn++ = '.';
+      }
+      else 
+	goto expand_fail;
+    }
+    else if (len >= (128+64)) {
+      if (!complen)   /* Still in the original field? */
+	complen = (comp_dn - comp_dn_orig) + 1; 
+      comp_dn = msg + (((len & ~(128+64)) << 8) + *comp_dn);
+      if (comp_dn >= eomorig) 
+	goto expand_fail;
+    }
+    else 
+      goto expand_fail;
+  } while ((len = *comp_dn++) != 0);
+  /* Replace last . with a 0 */
+  *(--exp_dn) = 0;
+  if (!complen) 
+    complen = comp_dn - comp_dn_orig;
+/*  fprintf(stderr, "dn_expand %s\n", exp_start); */
+  return complen;
+  
+expand_fail:
+/*  fprintf(stderr, "dn_expand fails\n"); */ 
+  return -1;
+}
+
+
+/*****************************************************************
+ *
+ dn_comp
+
+ Return -1 in case of overflow, but still fill buffer correctly.
+ We do not check the alphabet of the host names
+ nor the length of the compressed name and we
+ preserve the letter cases.
+
+ *****************************************************************/
+int dn_comp(const char * exp_dn, u_char * comp_dn, int length, 
+	    u_char ** dnptrs, u_char ** lastdnptr)
+{
+  u_char *cptr = comp_dn, *dptr, *lptr, *rptr;
+  unsigned int i, len;
+  u_char * const eptr = comp_dn + length - 1; /* Last valid */
+  
+  errno = EINVAL;
+
+  if (*exp_dn == '.' && !*(exp_dn + 1))
+    exp_dn++;
+  while (1) {
+    if (*exp_dn == '.' || cptr > eptr)
+      return -1;
+    if (*exp_dn == 0) {
+      *cptr++ = 0;
+      break;
+    }
+    /* Try to compress */
+    if (dnptrs) {
+      for (i = 1; dnptrs[i]; i++) {
+	dptr = dnptrs[i];
+	if (dptr >= comp_dn) /* Handle name.name */
+	  continue;
+	rptr = (u_char *) exp_dn;
+	len = *dptr++;
+	while (1) {
+	  do {
+	    if (*dptr++ != *rptr++)
+	      goto next_dn;
+	  } while (--len);
+	  len = *dptr++; 
+	  if (len == 0) { /* last label */
+	    if (!*rptr || (*rptr == '.' && !*(rptr + 1))) { /* Full match */
+	      len = (dnptrs[i] - dnptrs[0]) | 0xC000;
+	      /* Write pointer */
+	      *cptr++ = len >> 8;
+	      if (cptr > eptr)
+		return -1;
+	      *cptr++ = len;
+	      goto done;
+	    }
+	    goto next_dn;
+	  }
+	  if (*rptr++ != '.')
+	    goto next_dn;
+	  if (len >= 128 + 64) {
+	    dptr = dnptrs[0] + ((len - 128 - 64) << 8) + *dptr;
+	    len = *dptr++;
+	  }
+	}
+      next_dn: ;
+      }
+      /* Record label if asked and if space is available and if not too far off */
+      if (lastdnptr && (lastdnptr != &dnptrs[i]) && (cptr - dnptrs[0]) < 0xC000) {
+	dnptrs[i] = cptr;
+	dnptrs[i+1] = NULL;
+      }
+    }
+    /* Write label */
+    lptr = cptr++; /* Length byte */
+    rptr = (u_char *) exp_dn;
+    do {
+      if (cptr <= eptr)
+	*cptr++ = *rptr;
+    } while ((*++rptr != '.') && (*rptr != 0));
+    len = rptr - (u_char *) exp_dn;
+    if (len > MAXLABEL)
+      return -1;
+    *lptr = len;
+    exp_dn = (char *) rptr;
+    if (*exp_dn != 0)
+      exp_dn++; /* Skip over . */
+  }
+ done:
+  return cptr - comp_dn;
+}
+
+/*****************************************************************
+ *
+ dn_skipname
+
+ Measures the compressed domain name length and returns it.
+ *****************************************************************/
+int dn_skipname(const unsigned char *comp_dn, const unsigned char *eom)
+{
+  int len;
+  const unsigned char *comp_dn_orig = comp_dn;
+
+  do {
+    len = *comp_dn++;
+    if (len >= (128 + 64)) {
+      comp_dn++;
+      break;
+    }
+    if (len > MAXLABEL ||
+	(comp_dn += len) > eom)
+      return -1;	
+  } while (len != 0);
+
+  return comp_dn - comp_dn_orig;
+}
diff --git a/winsup/cygwin/libc/minires.h b/winsup/cygwin/libc/minires.h
new file mode 100644
index 000000000..ce063d16f
--- /dev/null
+++ b/winsup/cygwin/libc/minires.h
@@ -0,0 +1,68 @@
+/* minires.h.  Stub synchronous resolver for Cygwin.
+
+   Copyright 2006 Red Hat, Inc.
+
+   Written by Pierre A. Humblet <Pierre.Humblet@ieee.org>
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#define  __INSIDE_CYGWIN_NET__
+
+#include "winsup.h"
+#include <string.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <netdb.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/unistd.h>
+#include <netdb.h> 
+#include <arpa/nameser.h>
+#include <resolv.h>
+
+extern in_addr_t cygwin_inet_addr (const char *);
+extern int cygwin_socket (int, int, int);
+extern int cygwin_bind (int, const struct sockaddr *, socklen_t);
+extern int cygwin_connect (int, const struct sockaddr *, socklen_t);
+extern int cygwin_select (int, fd_set *, fd_set *, fd_set *, struct timeval *);
+extern int cygwin_sendto (int, const void *, size_t, int,
+			  const struct sockaddr *, socklen_t);
+extern int cygwin_recvfrom (int, void *, size_t, int, struct sockaddr *,
+			    socklen_t *);
+
+/* Number of elements is an array */
+#define DIM(x) (sizeof(x) / sizeof(*(x)))
+
+/* Definitions to parse the messages */
+#define RD (1<<8) /* Offset in a short */
+#define RA (1<<7)
+#define QR (1<<7) /* Offsets in a char */
+#define TC (1<<1)
+#define ERR_MASK 0xF
+
+/* Type for os specific res_lookup */
+typedef int (os_query_t) (res_state, const char *, int, int, u_char *, int);
+
+/* Special use of state elements */
+#define sockfd _vcsock
+#define mypid _flags
+#define os_query qhook
+#define use_os pfcode
+
+#define DPRINTF(cond, format...)  if (cond) minires_dprintf(format)
+
+/* Utility functions */
+void minires_dprintf(const char * format, ...);
+void minires_get_search(char * string, res_state statp);
+void get_dns_info(res_state statp);