libgo/go/net/lookup_plan9.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package net
   6
   7 import (
   8         "context"
   9         "errors"
  10         "internal/bytealg"
  11         "io"
  12         "os"
  13 )
  14
  15 func query(ctx context.Context, filename, query string, bufSize int) (addrs []string, err error) {
  16         queryAddrs := func() (addrs []string, err error) {
  17                 file, err := os.OpenFile(filename, os.O_RDWR, 0)
  18                 if err != nil {
  19                         return nil, err
  20                 }
  21                 defer file.Close()
  22
  23                 _, err = file.Seek(0, io.SeekStart)
  24                 if err != nil {
  25                         return nil, err
  26                 }
  27                 _, err = file.WriteString(query)
  28                 if err != nil {
  29                         return nil, err
  30                 }
  31                 _, err = file.Seek(0, io.SeekStart)
  32                 if err != nil {
  33                         return nil, err
  34                 }
  35                 buf := make([]byte, bufSize)
  36                 for {
  37                         n, _ := file.Read(buf)
  38                         if n <= 0 {
  39                                 break
  40                         }
  41                         addrs = append(addrs, string(buf[:n]))
  42                 }
  43                 return addrs, nil
  44         }
  45
  46         type ret struct {
  47                 addrs []string
  48                 err   error
  49         }
  50
  51         ch := make(chan ret, 1)
  52         go func() {
  53                 addrs, err := queryAddrs()
  54                 ch <- ret{addrs: addrs, err: err}
  55         }()
  56
  57         select {
  58         case r := <-ch:
  59                 return r.addrs, r.err
  60         case <-ctx.Done():
  61                 return nil, &DNSError{
  62                         Name:      query,
  63                         Err:       ctx.Err().Error(),
  64                         IsTimeout: ctx.Err() == context.DeadlineExceeded,
  65                 }
  66         }
  67 }
  68
  69 func queryCS(ctx context.Context, net, host, service string) (res []string, err error) {
  70         switch net {
  71         case "tcp4", "tcp6":
  72                 net = "tcp"
  73         case "udp4", "udp6":
  74                 net = "udp"
  75         }
  76         if host == "" {
  77                 host = "*"
  78         }
  79         return query(ctx, netdir+"/cs", net+"!"+host+"!"+service, 128)
  80 }
  81
  82 func queryCS1(ctx context.Context, net string, ip IP, port int) (clone, dest string, err error) {
  83         ips := "*"
  84         if len(ip) != 0 && !ip.IsUnspecified() {
  85                 ips = ip.String()
  86         }
  87         lines, err := queryCS(ctx, net, ips, itoa(port))
  88         if err != nil {
  89                 return
  90         }
  91         f := getFields(lines[0])
  92         if len(f) < 2 {
  93                 return "", "", errors.New("bad response from ndb/cs")
  94         }
  95         clone, dest = f[0], f[1]
  96         return
  97 }
  98
  99 func queryDNS(ctx context.Context, addr string, typ string) (res []string, err error) {
 100         return query(ctx, netdir+"/dns", addr+" "+typ, 1024)
 101 }
 102
 103 // toLower returns a lower-case version of in. Restricting us to
 104 // ASCII is sufficient to handle the IP protocol names and allow
 105 // us to not depend on the strings and unicode packages.
 106 func toLower(in string) string {
 107         for _, c := range in {
 108                 if 'A' <= c && c <= 'Z' {
 109                         // Has upper case; need to fix.
 110                         out := []byte(in)
 111                         for i := 0; i < len(in); i++ {
 112                                 c := in[i]
 113                                 if 'A' <= c && c <= 'Z' {
 114                                         c += 'a' - 'A'
 115                                 }
 116                                 out[i] = c
 117                         }
 118                         return string(out)
 119                 }
 120         }
 121         return in
 122 }
 123
 124 // lookupProtocol looks up IP protocol name and returns
 125 // the corresponding protocol number.
 126 func lookupProtocol(ctx context.Context, name string) (proto int, err error) {
 127         lines, err := query(ctx, netdir+"/cs", "!protocol="+toLower(name), 128)
 128         if err != nil {
 129                 return 0, err
 130         }
 131         if len(lines) == 0 {
 132                 return 0, UnknownNetworkError(name)
 133         }
 134         f := getFields(lines[0])
 135         if len(f) < 2 {
 136                 return 0, UnknownNetworkError(name)
 137         }
 138         s := f[1]
 139         if n, _, ok := dtoi(s[bytealg.IndexByteString(s, '=')+1:]); ok {
 140                 return n, nil
 141         }
 142         return 0, UnknownNetworkError(name)
 143 }
 144
 145 func (*Resolver) lookupHost(ctx context.Context, host string) (addrs []string, err error) {
 146         // Use netdir/cs instead of netdir/dns because cs knows about
 147         // host names in local network (e.g. from /lib/ndb/local)
 148         lines, err := queryCS(ctx, "net", host, "1")
 149         if err != nil {
 150                 dnsError := &DNSError{Err: err.Error(), Name: host}
 151                 if stringsHasSuffix(err.Error(), "dns failure") {
 152                         dnsError.Err = errNoSuchHost.Error()
 153                         dnsError.IsNotFound = true
 154                 }
 155                 return nil, dnsError
 156         }
 157 loop:
 158         for _, line := range lines {
 159                 f := getFields(line)
 160                 if len(f) < 2 {
 161                         continue
 162                 }
 163                 addr := f[1]
 164                 if i := bytealg.IndexByteString(addr, '!'); i >= 0 {
 165                         addr = addr[:i] // remove port
 166                 }
 167                 if ParseIP(addr) == nil {
 168                         continue
 169                 }
 170                 // only return unique addresses
 171                 for _, a := range addrs {
 172                         if a == addr {
 173                                 continue loop
 174                         }
 175                 }
 176                 addrs = append(addrs, addr)
 177         }
 178         return
 179 }
 180
 181 func (r *Resolver) lookupIP(ctx context.Context, _, host string) (addrs []IPAddr, err error) {
 182         lits, err := r.lookupHost(ctx, host)
 183         if err != nil {
 184                 return
 185         }
 186         for _, lit := range lits {
 187                 host, zone := splitHostZone(lit)
 188                 if ip := ParseIP(host); ip != nil {
 189                         addr := IPAddr{IP: ip, Zone: zone}
 190                         addrs = append(addrs, addr)
 191                 }
 192         }
 193         return
 194 }
 195
 196 func (*Resolver) lookupPort(ctx context.Context, network, service string) (port int, err error) {
 197         switch network {
 198         case "tcp4", "tcp6":
 199                 network = "tcp"
 200         case "udp4", "udp6":
 201                 network = "udp"
 202         }
 203         lines, err := queryCS(ctx, network, "127.0.0.1", toLower(service))
 204         if err != nil {
 205                 return
 206         }
 207         unknownPortError := &AddrError{Err: "unknown port", Addr: network + "/" + service}
 208         if len(lines) == 0 {
 209                 return 0, unknownPortError
 210         }
 211         f := getFields(lines[0])
 212         if len(f) < 2 {
 213                 return 0, unknownPortError
 214         }
 215         s := f[1]
 216         if i := bytealg.IndexByteString(s, '!'); i >= 0 {
 217                 s = s[i+1:] // remove address
 218         }
 219         if n, _, ok := dtoi(s); ok {
 220                 return n, nil
 221         }
 222         return 0, unknownPortError
 223 }
 224
 225 func (*Resolver) lookupCNAME(ctx context.Context, name string) (cname string, err error) {
 226         lines, err := queryDNS(ctx, name, "cname")
 227         if err != nil {
 228                 if stringsHasSuffix(err.Error(), "dns failure") || stringsHasSuffix(err.Error(), "resource does not exist; negrcode 0") {
 229                         cname = name + "."
 230                         err = nil
 231                 }
 232                 return
 233         }
 234         if len(lines) > 0 {
 235                 if f := getFields(lines[0]); len(f) >= 3 {
 236                         return f[2] + ".", nil
 237                 }
 238         }
 239         return "", errors.New("bad response from ndb/dns")
 240 }
 241
 242 func (*Resolver) lookupSRV(ctx context.Context, service, proto, name string) (cname string, addrs []*SRV, err error) {
 243         var target string
 244         if service == "" && proto == "" {
 245                 target = name
 246         } else {
 247                 target = "_" + service + "._" + proto + "." + name
 248         }
 249         lines, err := queryDNS(ctx, target, "srv")
 250         if err != nil {
 251                 return
 252         }
 253         for _, line := range lines {
 254                 f := getFields(line)
 255                 if len(f) < 6 {
 256                         continue
 257                 }
 258                 port, _, portOk := dtoi(f[4])
 259                 priority, _, priorityOk := dtoi(f[3])
 260                 weight, _, weightOk := dtoi(f[2])
 261                 if !(portOk && priorityOk && weightOk) {
 262                         continue
 263                 }
 264                 addrs = append(addrs, &SRV{absDomainName([]byte(f[5])), uint16(port), uint16(priority), uint16(weight)})
 265                 cname = absDomainName([]byte(f[0]))
 266         }
 267         byPriorityWeight(addrs).sort()
 268         return
 269 }
 270
 271 func (*Resolver) lookupMX(ctx context.Context, name string) (mx []*MX, err error) {
 272         lines, err := queryDNS(ctx, name, "mx")
 273         if err != nil {
 274                 return
 275         }
 276         for _, line := range lines {
 277                 f := getFields(line)
 278                 if len(f) < 4 {
 279                         continue
 280                 }
 281                 if pref, _, ok := dtoi(f[2]); ok {
 282                         mx = append(mx, &MX{absDomainName([]byte(f[3])), uint16(pref)})
 283                 }
 284         }
 285         byPref(mx).sort()
 286         return
 287 }
 288
 289 func (*Resolver) lookupNS(ctx context.Context, name string) (ns []*NS, err error) {
 290         lines, err := queryDNS(ctx, name, "ns")
 291         if err != nil {
 292                 return
 293         }
 294         for _, line := range lines {
 295                 f := getFields(line)
 296                 if len(f) < 3 {
 297                         continue
 298                 }
 299                 ns = append(ns, &NS{absDomainName([]byte(f[2]))})
 300         }
 301         return
 302 }
 303
 304 func (*Resolver) lookupTXT(ctx context.Context, name string) (txt []string, err error) {
 305         lines, err := queryDNS(ctx, name, "txt")
 306         if err != nil {
 307                 return
 308         }
 309         for _, line := range lines {
 310                 if i := bytealg.IndexByteString(line, '\t'); i >= 0 {
 311                         txt = append(txt, absDomainName([]byte(line[i+1:])))
 312                 }
 313         }
 314         return
 315 }
 316
 317 func (*Resolver) lookupAddr(ctx context.Context, addr string) (name []string, err error) {
 318         arpa, err := reverseaddr(addr)
 319         if err != nil {
 320                 return
 321         }
 322         lines, err := queryDNS(ctx, arpa, "ptr")
 323         if err != nil {
 324                 return
 325         }
 326         for _, line := range lines {
 327                 f := getFields(line)
 328                 if len(f) < 3 {
 329                         continue
 330                 }
 331                 name = append(name, absDomainName([]byte(f[2])))
 332         }
 333         return
 334 }
 335
 336 // concurrentThreadsLimit returns the number of threads we permit to
 337 // run concurrently doing DNS lookups.
 338 func concurrentThreadsLimit() int {
 339         return 500
 340 }