...
Run Format

Source file src/net/lookup_windows.go

Documentation: net

  // 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"
  	"os"
  	"runtime"
  	"syscall"
  	"unsafe"
  )
  
  const _WSAHOST_NOT_FOUND = syscall.Errno(11001)
  
  func winError(call string, err error) error {
  	switch err {
  	case _WSAHOST_NOT_FOUND:
  		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() {
  		acquireThread()
  		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 = &DNSError{Err: r.err.Error(), Name: 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, 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, name string) ([]IPAddr, error) {
  	// TODO(bradfitz,brainman): use ctx more. See TODO below.
  
  	type ret struct {
  		addrs []IPAddr
  		err   error
  	}
  	ch := make(chan ret, 1)
  	go func() {
  		acquireThread()
  		defer releaseThread()
  		hints := syscall.AddrinfoW{
  			Family:   syscall.AF_UNSPEC,
  			Socktype: syscall.SOCK_STREAM,
  			Protocol: syscall.IPPROTO_IP,
  		}
  		var result *syscall.AddrinfoW
  		e := syscall.GetAddrInfoW(syscall.StringToUTF16Ptr(name), nil, &hints, &result)
  		if e != nil {
  			ch <- ret{err: &DNSError{Err: winError("getaddrinfow", e).Error(), Name: 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: IPv4(a[0], a[1], a[2], a[3])})
  			case syscall.AF_INET6:
  				a := (*syscall.RawSockaddrInet6)(addr).Addr
  				zone := zoneCache.name(int((*syscall.RawSockaddrInet6)(addr).Scope_id))
  				addrs = append(addrs, IPAddr{IP: IP{a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]}, Zone: zone})
  			default:
  				ch <- ret{err: &DNSError{Err: syscall.EWINDOWS.Error(), Name: name}}
  			}
  		}
  		ch <- ret{addrs: addrs}
  	}()
  	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, &DNSError{
  			Name:      name,
  			Err:       ctx.Err().Error(),
  			IsTimeout: ctx.Err() == context.DeadlineExceeded,
  		}
  	}
  }
  
  func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
  	if r.PreferGo {
  		return lookupPortMap(network, service)
  	}
  
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var stype int32
  	switch network {
  	case "tcp4", "tcp6":
  		stype = syscall.SOCK_STREAM
  	case "udp4", "udp6":
  		stype = syscall.SOCK_DGRAM
  	}
  	hints := syscall.AddrinfoW{
  		Family:   syscall.AF_UNSPEC,
  		Socktype: stype,
  		Protocol: syscall.IPPROTO_IP,
  	}
  	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
  		}
  		return 0, &DNSError{Err: winError("getaddrinfow", e).Error(), Name: network + "/" + service}
  	}
  	defer syscall.FreeAddrInfoW(result)
  	if result == nil {
  		return 0, &DNSError{Err: syscall.EINVAL.Error(), Name: 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, &DNSError{Err: syscall.EINVAL.Error(), Name: network + "/" + service}
  }
  
  func (*Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &r, 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([]byte(name)), nil
  	}
  	if e != nil {
  		return "", &DNSError{Err: winError("dnsquery", e).Error(), Name: name}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), r)
  	cname := syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(resolved))[:])
  	return absDomainName([]byte(cname)), nil
  }
  
  func (*Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var target string
  	if service == "" && proto == "" {
  		target = name
  	} else {
  		target = "_" + service + "._" + proto + "." + name
  	}
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &r, nil)
  	if e != nil {
  		return "", nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: target}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	srvs := make([]*SRV, 0, 10)
  	for _, p := range validRecs(r, syscall.DNS_TYPE_SRV, target) {
  		v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
  		srvs = append(srvs, &SRV{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:]))), v.Port, v.Priority, v.Weight})
  	}
  	byPriorityWeight(srvs).sort()
  	return absDomainName([]byte(target)), srvs, nil
  }
  
  func (*Resolver) lookupMX(ctx context.Context, name string) ([]*MX, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(name, syscall.DNS_TYPE_MX, 0, nil, &r, nil)
  	if e != nil {
  		return nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: name}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	mxs := make([]*MX, 0, 10)
  	for _, p := range validRecs(r, syscall.DNS_TYPE_MX, name) {
  		v := (*syscall.DNSMXData)(unsafe.Pointer(&p.Data[0]))
  		mxs = append(mxs, &MX{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.NameExchange))[:]))), v.Preference})
  	}
  	byPref(mxs).sort()
  	return mxs, nil
  }
  
  func (*Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(name, syscall.DNS_TYPE_NS, 0, nil, &r, nil)
  	if e != nil {
  		return nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: name}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	nss := make([]*NS, 0, 10)
  	for _, p := range validRecs(r, syscall.DNS_TYPE_NS, name) {
  		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
  		nss = append(nss, &NS{absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:])))})
  	}
  	return nss, nil
  }
  
  func (*Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(name, syscall.DNS_TYPE_TEXT, 0, nil, &r, nil)
  	if e != nil {
  		return nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: name}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	txts := make([]string, 0, 10)
  	for _, p := range validRecs(r, syscall.DNS_TYPE_TEXT, name) {
  		d := (*syscall.DNSTXTData)(unsafe.Pointer(&p.Data[0]))
  		for _, v := range (*[1 << 10]*uint16)(unsafe.Pointer(&(d.StringArray[0])))[:d.StringCount] {
  			s := syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(v))[:])
  			txts = append(txts, s)
  		}
  	}
  	return txts, nil
  }
  
  func (*Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
  	// TODO(bradfitz): finish ctx plumbing. Nothing currently depends on this.
  	acquireThread()
  	defer releaseThread()
  	arpa, err := reverseaddr(addr)
  	if err != nil {
  		return nil, err
  	}
  	var r *syscall.DNSRecord
  	e := syscall.DnsQuery(arpa, syscall.DNS_TYPE_PTR, 0, nil, &r, nil)
  	if e != nil {
  		return nil, &DNSError{Err: winError("dnsquery", e).Error(), Name: addr}
  	}
  	defer syscall.DnsRecordListFree(r, 1)
  
  	ptrs := make([]string, 0, 10)
  	for _, p := range validRecs(r, syscall.DNS_TYPE_PTR, arpa) {
  		v := (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0]))
  		ptrs = append(ptrs, absDomainName([]byte(syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(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 {
  		if p.Dw&dnsSectionMask != syscall.DnsSectionAnswer {
  			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 a 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
  }
  

View as plain text