src/net/lookup_windows.go - go - Git at Google

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package net

 import (
 	"context"
 	"internal/syscall/windows"
 	"os"
 	"runtime"
 	"syscall"
 	"time"
 	"unsafe"
 )

 // cgoAvailable set to true to indicate that the cgo resolver
 // is available on Windows. Note that on Windows the cgo resolver
 // does not actually use cgo.
 const cgoAvailable = true

 const (
 	_DNS_ERROR_RCODE_NAME_ERROR = syscall.Errno(9003)
 	_DNS_INFO_NO_RECORDS        = syscall.Errno(9501)

 	_WSAHOST_NOT_FOUND = syscall.Errno(11001)
 	_WSATRY_AGAIN      = syscall.Errno(11002)
 	_WSATYPE_NOT_FOUND = syscall.Errno(10109)
 )

 func winError(call string, err error) error {
 	switch err {
 	case _WSAHOST_NOT_FOUND, _DNS_ERROR_RCODE_NAME_ERROR, _DNS_INFO_NO_RECORDS:
 		return errNoSuchHost
 	}
 	return os.NewSyscallError(call, err)
 }

 func getprotobyname(name string) (proto int, err error) {
 	p, err := syscall.GetProtoByName(name)
 	if err != nil {
 		return 0, winError("getprotobyname", err)
 	}
 	return int(p.Proto), nil
 }

 // lookupProtocol looks up IP protocol name and returns correspondent protocol number.
 func lookupProtocol(ctx context.Context, name string) (int, error) {
 	// GetProtoByName return value is stored in thread local storage.
 	// Start new os thread before the call to prevent races.
 	type result struct {
 		proto int
 		err   error
 	}
 	ch := make(chan result) // unbuffered
 	go func() {
 		if err := acquireThread(ctx); err != nil {
 			ch <- result{err: mapErr(err)}
 			return
 		}
 		defer releaseThread()
 		runtime.LockOSThread()
 		defer runtime.UnlockOSThread()
 		proto, err := getprotobyname(name)
 		select {
 		case ch <- result{proto: proto, err: err}:
 		case <-ctx.Done():
 		}
 	}()
 	select {
 	case r := <-ch:
 		if r.err != nil {
 			if proto, err := lookupProtocolMap(name); err == nil {
 				return proto, nil
 			}
 			r.err = newDNSError(r.err, name, "")
 		}
 		return r.proto, r.err
 	case <-ctx.Done():
 		return 0, mapErr(ctx.Err())
 	}
 }

 func (r *Resolver) lookupHost(ctx context.Context, name string) ([]string, error) {
 	ips, err := r.lookupIP(ctx, "ip", name)
 	if err != nil {
 		return nil, err
 	}
 	addrs := make([]string, 0, len(ips))
 	for _, ip := range ips {
 		addrs = append(addrs, ip.String())
 	}
 	return addrs, nil
 }

 func (r *Resolver) lookupIP(ctx context.Context, network, name string) ([]IPAddr, error) {
 	if order, conf := systemConf().hostLookupOrder(r, name); order != hostLookupCgo {
 		return r.goLookupIP(ctx, network, name, order, conf)
 	}

 	// TODO(bradfitz,brainman): use ctx more. See TODO below.

 	var family int32 = syscall.AF_UNSPEC
 	switch ipVersion(network) {
 	case '4':
 		family = syscall.AF_INET
 	case '6':
 		family = syscall.AF_INET6
 	}

 	getaddr := func() ([]IPAddr, error) {
 		if err := acquireThread(ctx); err != nil {
 			return nil, &DNSError{
 				Name:      name,
 				Err:       mapErr(err).Error(),
 				IsTimeout: ctx.Err() == context.DeadlineExceeded,
 			}
 		}
 		defer releaseThread()
 		hints := syscall.AddrinfoW{
 			Family:   family,
 			Socktype: syscall.SOCK_STREAM,
 			Protocol: syscall.IPPROTO_IP,
 		}
 		var result *syscall.AddrinfoW
 		name16p, err := syscall.UTF16PtrFromString(name)
 		if err != nil {
 			return nil, newDNSError(err, name, "")
 		}

 		dnsConf := getSystemDNSConfig()
 		start := time.Now()

 		var e error
 		for i := 0; i < dnsConf.attempts; i++ {
 			e = syscall.GetAddrInfoW(name16p, nil, &hints, &result)
 			if e == nil || e != _WSATRY_AGAIN || time.Since(start) > dnsConf.timeout {
 				break
 			}
 		}
 		if e != nil {
 			return nil, newDNSError(winError("getaddrinfow", e), name, "")
 		}
 		defer syscall.FreeAddrInfoW(result)
 		addrs := make([]IPAddr, 0, 5)
 		for ; result != nil; result = result.Next {
 			addr := unsafe.Pointer(result.Addr)
 			switch result.Family {
 			case syscall.AF_INET:
 				a := (*syscall.RawSockaddrInet4)(addr).Addr
 				addrs = append(addrs, IPAddr{IP: copyIP(a[:])})
 			case syscall.AF_INET6:
 				a := (*syscall.RawSockaddrInet6)(addr).Addr
 				zone := zoneCache.name(int((*syscall.RawSockaddrInet6)(addr).Scope_id))
 				addrs = append(addrs, IPAddr{IP: copyIP(a[:]), Zone: zone})
 			default:
 				return nil, newDNSError(syscall.EWINDOWS, name, "")
 			}
 		}
 		return addrs, nil
 	}

 	type ret struct {
 		addrs []IPAddr
 		err   error
 	}

 	var ch chan ret
 	if ctx.Err() == nil {
 		ch = make(chan ret, 1)
 		go func() {
 			addr, err := getaddr()
 			ch <- ret{addrs: addr, err: err}
 		}()
 	}

 	select {
 	case r := <-ch:
 		return r.addrs, r.err
 	case <-ctx.Done():
 		// TODO(bradfitz,brainman): cancel the ongoing
 		// GetAddrInfoW? It would require conditionally using
 		// GetAddrInfoEx with lpOverlapped, which requires
 		// Windows 8 or newer. I guess we'll need oldLookupIP,
 		// newLookupIP, and newerLookUP.
 		//
 		// For now we just let it finish and write to the
 		// buffered channel.
 		return nil, newDNSError(mapErr(ctx.Err()), name, "")
 	}
 }

 func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
 	if systemConf().mustUseGoResolver(r) {
 		return lookupPortMap(network, service)
 	}

 	// TODO(bradfitz): finish ctx plumbing
 	if err := acquireThread(ctx); err != nil {
 		return 0, &DNSError{
 			Name:      network + "/" + service,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()

 	var hints syscall.AddrinfoW

 	switch network {
 	case "ip": // no hints
 	case "tcp", "tcp4", "tcp6":
 		hints.Socktype = syscall.SOCK_STREAM
 		hints.Protocol = syscall.IPPROTO_TCP
 	case "udp", "udp4", "udp6":
 		hints.Socktype = syscall.SOCK_DGRAM
 		hints.Protocol = syscall.IPPROTO_UDP
 	default:
 		return 0, &DNSError{Err: "unknown network", Name: network + "/" + service}
 	}

 	switch ipVersion(network) {
 	case '4':
 		hints.Family = syscall.AF_INET
 	case '6':
 		hints.Family = syscall.AF_INET6
 	}

 	var result *syscall.AddrinfoW
 	e := syscall.GetAddrInfoW(nil, syscall.StringToUTF16Ptr(service), &hints, &result)
 	if e != nil {
 		if port, err := lookupPortMap(network, service); err == nil {
 			return port, nil
 		}

 		// The _WSATYPE_NOT_FOUND error is returned by GetAddrInfoW
 		// when the service name is unknown. We are also checking
 		// for _WSAHOST_NOT_FOUND here to match the cgo (unix) version
 		// cgo_unix.go (cgoLookupServicePort).
 		if e == _WSATYPE_NOT_FOUND || e == _WSAHOST_NOT_FOUND {
 			return 0, newDNSError(errUnknownPort, network+"/"+service, "")
 		}
 		return 0, newDNSError(winError("getaddrinfow", e), network+"/"+service, "")
 	}
 	defer syscall.FreeAddrInfoW(result)
 	if result == nil {
 		return 0, newDNSError(syscall.EINVAL, network+"/"+service, "")
 	}
 	addr := unsafe.Pointer(result.Addr)
 	switch result.Family {
 	case syscall.AF_INET:
 		a := (*syscall.RawSockaddrInet4)(addr)
 		return int(syscall.Ntohs(a.Port)), nil
 	case syscall.AF_INET6:
 		a := (*syscall.RawSockaddrInet6)(addr)
 		return int(syscall.Ntohs(a.Port)), nil
 	}
 	return 0, newDNSError(syscall.EINVAL, network+"/"+service, "")
 }

 func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
 	if order, conf := systemConf().hostLookupOrder(r, name); order != hostLookupCgo {
 		return r.goLookupCNAME(ctx, name, order, conf)
 	}

 	// TODO(bradfitz): finish ctx plumbing
 	if err := acquireThread(ctx); err != nil {
 		return "", &DNSError{
 			Name:      name,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &rec, nil)
 	// windows returns DNS_INFO_NO_RECORDS if there are no CNAME-s
 	if errno, ok := e.(syscall.Errno); ok && errno == syscall.DNS_INFO_NO_RECORDS {
 		// if there are no aliases, the canonical name is the input name
 		return absDomainName(name), nil
 	}
 	if e != nil {
 		return "", newDNSError(winError("dnsquery", e), name, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), rec)
 	cname := windows.UTF16PtrToString(resolved)
 	return absDomainName(cname), nil
 }

 func (r *Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
 	if systemConf().mustUseGoResolver(r) {
 		return r.goLookupSRV(ctx, service, proto, name)
 	}
 	// TODO(bradfitz): finish ctx plumbing
 	if err := acquireThread(ctx); err != nil {
 		return "", nil, &DNSError{
 			Name:      name,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	var target string
 	if service == "" && proto == "" {
 		target = name
 	} else {
 		target = "_" + service + "._" + proto + "." + name
 	}
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &rec, nil)
 	if e != nil {
 		return "", nil, newDNSError(winError("dnsquery", e), name, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	srvs := make([]*SRV, 0, 10)
 	for _, p := range validRecs(rec, syscall.DNS_TYPE_SRV, target) {
 		v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
 		srvs = append(srvs, &SRV{absDomainName(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:])), v.Port, v.Priority, v.Weight})
 	}
 	byPriorityWeight(srvs).sort()
 	return absDomainName(target), srvs, nil
 }

 func (r *Resolver) lookupMX(ctx context.Context, name string) ([]*MX, error) {
 	if systemConf().mustUseGoResolver(r) {
 		return r.goLookupMX(ctx, name)
 	}
 	// TODO(bradfitz): finish ctx plumbing.
 	if err := acquireThread(ctx); err != nil {
 		return nil, &DNSError{
 			Name:      name,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_MX, 0, nil, &rec, nil)
 	if e != nil {
 		return nil, newDNSError(winError("dnsquery", e), name, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	mxs := make([]*MX, 0, 10)
 	for _, p := range validRecs(rec, syscall.DNS_TYPE_MX, name) {
 		v := (*syscall.DNSMXData)(unsafe.Pointer(&p.Data[0]))
 		mxs = append(mxs, &MX{absDomainName(windows.UTF16PtrToString(v.NameExchange)), v.Preference})
 	}
 	byPref(mxs).sort()
 	return mxs, nil
 }

 func (r *Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
 	if systemConf().mustUseGoResolver(r) {
 		return r.goLookupNS(ctx, name)
 	}
 	// TODO(bradfitz): finish ctx plumbing.
 	if err := acquireThread(ctx); err != nil {
 		return nil, &DNSError{
 			Name:      name,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_NS, 0, nil, &rec, nil)
 	if e != nil {
 		return nil, newDNSError(winError("dnsquery", e), name, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	nss := make([]*NS, 0, 10)
 	for _, p := range validRecs(rec, syscall.DNS_TYPE_NS, name) {
 		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
 		nss = append(nss, &NS{absDomainName(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))})
 	}
 	return nss, nil
 }

 func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
 	if systemConf().mustUseGoResolver(r) {
 		return r.goLookupTXT(ctx, name)
 	}
 	// TODO(bradfitz): finish ctx plumbing.
 	if err := acquireThread(ctx); err != nil {
 		return nil, &DNSError{
 			Name:      name,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_TEXT, 0, nil, &rec, nil)
 	if e != nil {
 		return nil, newDNSError(winError("dnsquery", e), name, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	txts := make([]string, 0, 10)
 	for _, p := range validRecs(rec, syscall.DNS_TYPE_TEXT, name) {
 		d := (*syscall.DNSTXTData)(unsafe.Pointer(&p.Data[0]))
 		s := ""
 		for _, v := range (*[1 << 10]*uint16)(unsafe.Pointer(&(d.StringArray[0])))[:d.StringCount:d.StringCount] {
 			s += windows.UTF16PtrToString(v)
 		}
 		txts = append(txts, s)
 	}
 	return txts, nil
 }

 func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
 	if order, conf := systemConf().addrLookupOrder(r, addr); order != hostLookupCgo {
 		return r.goLookupPTR(ctx, addr, order, conf)
 	}

 	// TODO(bradfitz): finish ctx plumbing.
 	if err := acquireThread(ctx); err != nil {
 		return nil, &DNSError{
 			Name:      addr,
 			Err:       mapErr(err).Error(),
 			IsTimeout: ctx.Err() == context.DeadlineExceeded,
 		}
 	}
 	defer releaseThread()
 	arpa, err := reverseaddr(addr)
 	if err != nil {
 		return nil, err
 	}
 	var rec *syscall.DNSRecord
 	e := syscall.DnsQuery(arpa, syscall.DNS_TYPE_PTR, 0, nil, &rec, nil)
 	if e != nil {
 		return nil, newDNSError(winError("dnsquery", e), addr, "")
 	}
 	defer syscall.DnsRecordListFree(rec, 1)

 	ptrs := make([]string, 0, 10)
 	for _, p := range validRecs(rec, syscall.DNS_TYPE_PTR, arpa) {
 		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
 		ptrs = append(ptrs, absDomainName(windows.UTF16PtrToString(v.Host)))
 	}
 	return ptrs, nil
 }

 const dnsSectionMask = 0x0003

 // returns only results applicable to name and resolves CNAME entries.
 func validRecs(r *syscall.DNSRecord, dnstype uint16, name string) []*syscall.DNSRecord {
 	cname := syscall.StringToUTF16Ptr(name)
 	if dnstype != syscall.DNS_TYPE_CNAME {
 		cname = resolveCNAME(cname, r)
 	}
 	rec := make([]*syscall.DNSRecord, 0, 10)
 	for p := r; p != nil; p = p.Next {
 		// in case of a local machine, DNS records are returned with DNSREC_QUESTION flag instead of DNS_ANSWER
 		if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer && p.Dw&dnsSectionMask != syscall.DnsSectionQuestion {
 			continue
 		}
 		if p.Type != dnstype {
 			continue
 		}
 		if !syscall.DnsNameCompare(cname, p.Name) {
 			continue
 		}
 		rec = append(rec, p)
 	}
 	return rec
 }

 // returns the last CNAME in chain.
 func resolveCNAME(name *uint16, r *syscall.DNSRecord) *uint16 {
 	// limit cname resolving to 10 in case of an infinite CNAME loop
 Cname:
 	for cnameloop := 0; cnameloop < 10; cnameloop++ {
 		for p := r; p != nil; p = p.Next {
 			if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer {
 				continue
 			}
 			if p.Type != syscall.DNS_TYPE_CNAME {
 				continue
 			}
 			if !syscall.DnsNameCompare(name, p.Name) {
 				continue
 			}
 			name = (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0])).Host
 			continue Cname
 		}
 		break
 	}
 	return name
 }

 // concurrentThreadsLimit returns the number of threads we permit to
 // run concurrently doing DNS lookups.
 func concurrentThreadsLimit() int {
 	return 500
 }
	// Copyright 2009 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package net

	import (
	"context"
	"internal/syscall/windows"
	"os"
	"runtime"
	"syscall"
	"time"
	"unsafe"
	)

	// cgoAvailable set to true to indicate that the cgo resolver
	// is available on Windows. Note that on Windows the cgo resolver
	// does not actually use cgo.
	const cgoAvailable = true

	const (
	_DNS_ERROR_RCODE_NAME_ERROR = syscall.Errno(9003)
	_DNS_INFO_NO_RECORDS = syscall.Errno(9501)

	_WSAHOST_NOT_FOUND = syscall.Errno(11001)
	_WSATRY_AGAIN = syscall.Errno(11002)
	_WSATYPE_NOT_FOUND = syscall.Errno(10109)
	)

	func winError(call string, err error) error {
	switch err {
	case _WSAHOST_NOT_FOUND, _DNS_ERROR_RCODE_NAME_ERROR, _DNS_INFO_NO_RECORDS:
	return errNoSuchHost
	}
	return os.NewSyscallError(call, err)
	}

	func getprotobyname(name string) (proto int, err error) {
	p, err := syscall.GetProtoByName(name)
	if err != nil {
	return 0, winError("getprotobyname", err)
	}
	return int(p.Proto), nil
	}

	// lookupProtocol looks up IP protocol name and returns correspondent protocol number.
	func lookupProtocol(ctx context.Context, name string) (int, error) {
	// GetProtoByName return value is stored in thread local storage.
	// Start new os thread before the call to prevent races.
	type result struct {
	proto int
	err error
	}
	ch := make(chan result) // unbuffered
	go func() {
	if err := acquireThread(ctx); err != nil {
	ch <- result{err: mapErr(err)}
	return
	}
	defer releaseThread()
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()
	proto, err := getprotobyname(name)
	select {
	case ch <- result{proto: proto, err: err}:
	case <-ctx.Done():
	}
	}()
	select {
	case r := <-ch:
	if r.err != nil {
	if proto, err := lookupProtocolMap(name); err == nil {
	return proto, nil
	}
	r.err = newDNSError(r.err, name, "")
	}
	return r.proto, r.err
	case <-ctx.Done():
	return 0, mapErr(ctx.Err())
	}
	}

	func (r *Resolver) lookupHost(ctx context.Context, name string) ([]string, error) {
	ips, err := r.lookupIP(ctx, "ip", name)
	if err != nil {
	return nil, err
	}
	addrs := make([]string, 0, len(ips))
	for _, ip := range ips {
	addrs = append(addrs, ip.String())
	}
	return addrs, nil
	}

	func (r *Resolver) lookupIP(ctx context.Context, network, name string) ([]IPAddr, error) {
	if order, conf := systemConf().hostLookupOrder(r, name); order != hostLookupCgo {
	return r.goLookupIP(ctx, network, name, order, conf)
	}

	// TODO(bradfitz,brainman): use ctx more. See TODO below.

	var family int32 = syscall.AF_UNSPEC
	switch ipVersion(network) {
	case '4':
	family = syscall.AF_INET
	case '6':
	family = syscall.AF_INET6
	}

	getaddr := func() ([]IPAddr, error) {
	if err := acquireThread(ctx); err != nil {
	return nil, &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	hints := syscall.AddrinfoW{
	Family: family,
	Socktype: syscall.SOCK_STREAM,
	Protocol: syscall.IPPROTO_IP,
	}
	var result *syscall.AddrinfoW
	name16p, err := syscall.UTF16PtrFromString(name)
	if err != nil {
	return nil, newDNSError(err, name, "")
	}

	dnsConf := getSystemDNSConfig()
	start := time.Now()

	var e error
	for i := 0; i < dnsConf.attempts; i++ {
	e = syscall.GetAddrInfoW(name16p, nil, &hints, &result)
	if e == nil \|\| e != _WSATRY_AGAIN \|\| time.Since(start) > dnsConf.timeout {
	break
	}
	}
	if e != nil {
	return nil, newDNSError(winError("getaddrinfow", e), name, "")
	}
	defer syscall.FreeAddrInfoW(result)
	addrs := make([]IPAddr, 0, 5)
	for ; result != nil; result = result.Next {
	addr := unsafe.Pointer(result.Addr)
	switch result.Family {
	case syscall.AF_INET:
	a := (*syscall.RawSockaddrInet4)(addr).Addr
	addrs = append(addrs, IPAddr{IP: copyIP(a[:])})
	case syscall.AF_INET6:
	a := (*syscall.RawSockaddrInet6)(addr).Addr
	zone := zoneCache.name(int((*syscall.RawSockaddrInet6)(addr).Scope_id))
	addrs = append(addrs, IPAddr{IP: copyIP(a[:]), Zone: zone})
	default:
	return nil, newDNSError(syscall.EWINDOWS, name, "")
	}
	}
	return addrs, nil
	}

	type ret struct {
	addrs []IPAddr
	err error
	}

	var ch chan ret
	if ctx.Err() == nil {
	ch = make(chan ret, 1)
	go func() {
	addr, err := getaddr()
	ch <- ret{addrs: addr, err: err}
	}()
	}

	select {
	case r := <-ch:
	return r.addrs, r.err
	case <-ctx.Done():
	// TODO(bradfitz,brainman): cancel the ongoing
	// GetAddrInfoW? It would require conditionally using
	// GetAddrInfoEx with lpOverlapped, which requires
	// Windows 8 or newer. I guess we'll need oldLookupIP,
	// newLookupIP, and newerLookUP.
	//
	// For now we just let it finish and write to the
	// buffered channel.
	return nil, newDNSError(mapErr(ctx.Err()), name, "")
	}
	}

	func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
	if systemConf().mustUseGoResolver(r) {
	return lookupPortMap(network, service)
	}

	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
	return 0, &DNSError{
	Name: network + "/" + service,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()

	var hints syscall.AddrinfoW

	switch network {
	case "ip": // no hints
	case "tcp", "tcp4", "tcp6":
	hints.Socktype = syscall.SOCK_STREAM
	hints.Protocol = syscall.IPPROTO_TCP
	case "udp", "udp4", "udp6":
	hints.Socktype = syscall.SOCK_DGRAM
	hints.Protocol = syscall.IPPROTO_UDP
	default:
	return 0, &DNSError{Err: "unknown network", Name: network + "/" + service}
	}

	switch ipVersion(network) {
	case '4':
	hints.Family = syscall.AF_INET
	case '6':
	hints.Family = syscall.AF_INET6
	}

	var result *syscall.AddrinfoW
	e := syscall.GetAddrInfoW(nil, syscall.StringToUTF16Ptr(service), &hints, &result)
	if e != nil {
	if port, err := lookupPortMap(network, service); err == nil {
	return port, nil
	}

	// The _WSATYPE_NOT_FOUND error is returned by GetAddrInfoW
	// when the service name is unknown. We are also checking
	// for _WSAHOST_NOT_FOUND here to match the cgo (unix) version
	// cgo_unix.go (cgoLookupServicePort).
	if e == _WSATYPE_NOT_FOUND \|\| e == _WSAHOST_NOT_FOUND {
	return 0, newDNSError(errUnknownPort, network+"/"+service, "")
	}
	return 0, newDNSError(winError("getaddrinfow", e), network+"/"+service, "")
	}
	defer syscall.FreeAddrInfoW(result)
	if result == nil {
	return 0, newDNSError(syscall.EINVAL, network+"/"+service, "")
	}
	addr := unsafe.Pointer(result.Addr)
	switch result.Family {
	case syscall.AF_INET:
	a := (*syscall.RawSockaddrInet4)(addr)
	return int(syscall.Ntohs(a.Port)), nil
	case syscall.AF_INET6:
	a := (*syscall.RawSockaddrInet6)(addr)
	return int(syscall.Ntohs(a.Port)), nil
	}
	return 0, newDNSError(syscall.EINVAL, network+"/"+service, "")
	}

	func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
	if order, conf := systemConf().hostLookupOrder(r, name); order != hostLookupCgo {
	return r.goLookupCNAME(ctx, name, order, conf)
	}

	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
	return "", &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &rec, nil)
	// windows returns DNS_INFO_NO_RECORDS if there are no CNAME-s
	if errno, ok := e.(syscall.Errno); ok && errno == syscall.DNS_INFO_NO_RECORDS {
	// if there are no aliases, the canonical name is the input name
	return absDomainName(name), nil
	}
	if e != nil {
	return "", newDNSError(winError("dnsquery", e), name, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), rec)
	cname := windows.UTF16PtrToString(resolved)
	return absDomainName(cname), nil
	}

	func (r Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []SRV, error) {
	if systemConf().mustUseGoResolver(r) {
	return r.goLookupSRV(ctx, service, proto, name)
	}
	// TODO(bradfitz): finish ctx plumbing
	if err := acquireThread(ctx); err != nil {
	return "", nil, &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	var target string
	if service == "" && proto == "" {
	target = name
	} else {
	target = "_" + service + "._" + proto + "." + name
	}
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &rec, nil)
	if e != nil {
	return "", nil, newDNSError(winError("dnsquery", e), name, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	srvs := make([]*SRV, 0, 10)
	for _, p := range validRecs(rec, syscall.DNS_TYPE_SRV, target) {
	v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
	srvs = append(srvs, &SRV{absDomainName(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:])), v.Port, v.Priority, v.Weight})
	}
	byPriorityWeight(srvs).sort()
	return absDomainName(target), srvs, nil
	}

	func (r Resolver) lookupMX(ctx context.Context, name string) ([]MX, error) {
	if systemConf().mustUseGoResolver(r) {
	return r.goLookupMX(ctx, name)
	}
	// TODO(bradfitz): finish ctx plumbing.
	if err := acquireThread(ctx); err != nil {
	return nil, &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(name, syscall.DNS_TYPE_MX, 0, nil, &rec, nil)
	if e != nil {
	return nil, newDNSError(winError("dnsquery", e), name, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	mxs := make([]*MX, 0, 10)
	for _, p := range validRecs(rec, syscall.DNS_TYPE_MX, name) {
	v := (*syscall.DNSMXData)(unsafe.Pointer(&p.Data[0]))
	mxs = append(mxs, &MX{absDomainName(windows.UTF16PtrToString(v.NameExchange)), v.Preference})
	}
	byPref(mxs).sort()
	return mxs, nil
	}

	func (r Resolver) lookupNS(ctx context.Context, name string) ([]NS, error) {
	if systemConf().mustUseGoResolver(r) {
	return r.goLookupNS(ctx, name)
	}
	// TODO(bradfitz): finish ctx plumbing.
	if err := acquireThread(ctx); err != nil {
	return nil, &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(name, syscall.DNS_TYPE_NS, 0, nil, &rec, nil)
	if e != nil {
	return nil, newDNSError(winError("dnsquery", e), name, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	nss := make([]*NS, 0, 10)
	for _, p := range validRecs(rec, syscall.DNS_TYPE_NS, name) {
	v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
	nss = append(nss, &NS{absDomainName(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]))})
	}
	return nss, nil
	}

	func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
	if systemConf().mustUseGoResolver(r) {
	return r.goLookupTXT(ctx, name)
	}
	// TODO(bradfitz): finish ctx plumbing.
	if err := acquireThread(ctx); err != nil {
	return nil, &DNSError{
	Name: name,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(name, syscall.DNS_TYPE_TEXT, 0, nil, &rec, nil)
	if e != nil {
	return nil, newDNSError(winError("dnsquery", e), name, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	txts := make([]string, 0, 10)
	for _, p := range validRecs(rec, syscall.DNS_TYPE_TEXT, name) {
	d := (*syscall.DNSTXTData)(unsafe.Pointer(&p.Data[0]))
	s := ""
	for _, v := range ([1 << 10]uint16)(unsafe.Pointer(&(d.StringArray[0])))[:d.StringCount:d.StringCount] {
	s += windows.UTF16PtrToString(v)
	}
	txts = append(txts, s)
	}
	return txts, nil
	}

	func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
	if order, conf := systemConf().addrLookupOrder(r, addr); order != hostLookupCgo {
	return r.goLookupPTR(ctx, addr, order, conf)
	}

	// TODO(bradfitz): finish ctx plumbing.
	if err := acquireThread(ctx); err != nil {
	return nil, &DNSError{
	Name: addr,
	Err: mapErr(err).Error(),
	IsTimeout: ctx.Err() == context.DeadlineExceeded,
	}
	}
	defer releaseThread()
	arpa, err := reverseaddr(addr)
	if err != nil {
	return nil, err
	}
	var rec *syscall.DNSRecord
	e := syscall.DnsQuery(arpa, syscall.DNS_TYPE_PTR, 0, nil, &rec, nil)
	if e != nil {
	return nil, newDNSError(winError("dnsquery", e), addr, "")
	}
	defer syscall.DnsRecordListFree(rec, 1)

	ptrs := make([]string, 0, 10)
	for _, p := range validRecs(rec, syscall.DNS_TYPE_PTR, arpa) {
	v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
	ptrs = append(ptrs, absDomainName(windows.UTF16PtrToString(v.Host)))
	}
	return ptrs, nil
	}

	const dnsSectionMask = 0x0003

	// returns only results applicable to name and resolves CNAME entries.
	func validRecs(r syscall.DNSRecord, dnstype uint16, name string) []syscall.DNSRecord {
	cname := syscall.StringToUTF16Ptr(name)
	if dnstype != syscall.DNS_TYPE_CNAME {
	cname = resolveCNAME(cname, r)
	}
	rec := make([]*syscall.DNSRecord, 0, 10)
	for p := r; p != nil; p = p.Next {
	// in case of a local machine, DNS records are returned with DNSREC_QUESTION flag instead of DNS_ANSWER
	if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer && p.Dw&dnsSectionMask != syscall.DnsSectionQuestion {
	continue
	}
	if p.Type != dnstype {
	continue
	}
	if !syscall.DnsNameCompare(cname, p.Name) {
	continue
	}
	rec = append(rec, p)
	}
	return rec
	}

	// returns the last CNAME in chain.
	func resolveCNAME(name uint16, r syscall.DNSRecord) *uint16 {
	// limit cname resolving to 10 in case of an infinite CNAME loop
	Cname:
	for cnameloop := 0; cnameloop < 10; cnameloop++ {
	for p := r; p != nil; p = p.Next {
	if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer {
	continue
	}
	if p.Type != syscall.DNS_TYPE_CNAME {
	continue
	}
	if !syscall.DnsNameCompare(name, p.Name) {
	continue
	}
	name = (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0])).Host
	continue Cname
	}
	break
	}
	return name
	}

	// concurrentThreadsLimit returns the number of threads we permit to
	// run concurrently doing DNS lookups.
	func concurrentThreadsLimit() int {
	return 500
	}