← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/net/lookup_windows.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-08-03 17:04:59 UTC
  • mfrom: (14.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110803170459-wzd99m3567y80ila
Tags: 1:59-1
http://bugs.debian.org/634270
* Imported Upstream version 59
* Refresh patches to a new release
* Fix FTBFS on ARM (Closes: #634270)
* Update version.bash to work with Debian packaging and not hg
  repository

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/lookup_windows.go
 
1
// Copyright 2009 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
        "syscall"
 
9
        "unsafe"
 
10
        "os"
 
11
        "sync"
 
12
)
 
13
 
 
14
var hostentLock sync.Mutex
 
15
var serventLock sync.Mutex
 
16
 
 
17
func LookupHost(name string) (addrs []string, err os.Error) {
 
18
        ips, err := LookupIP(name)
 
19
        if err != nil {
 
20
                return
 
21
        }
 
22
        addrs = make([]string, 0, len(ips))
 
23
        for _, ip := range ips {
 
24
                addrs = append(addrs, ip.String())
 
25
        }
 
26
        return
 
27
}
 
28
 
 
29
func LookupIP(name string) (addrs []IP, err os.Error) {
 
30
        hostentLock.Lock()
 
31
        defer hostentLock.Unlock()
 
32
        h, e := syscall.GetHostByName(name)
 
33
        if e != 0 {
 
34
                return nil, os.NewSyscallError("GetHostByName", e)
 
35
        }
 
36
        switch h.AddrType {
 
37
        case syscall.AF_INET:
 
38
                i := 0
 
39
                addrs = make([]IP, 100) // plenty of room to grow
 
40
                for p := (*[100](*[4]byte))(unsafe.Pointer(h.AddrList)); i < cap(addrs) && p[i] != nil; i++ {
 
41
                        addrs[i] = IPv4(p[i][0], p[i][1], p[i][2], p[i][3])
 
42
                }
 
43
                addrs = addrs[0:i]
 
44
        default: // TODO(vcc): Implement non IPv4 address lookups.
 
45
                return nil, os.NewSyscallError("LookupHost", syscall.EWINDOWS)
 
46
        }
 
47
        return addrs, nil
 
48
}
 
49
 
 
50
func LookupPort(network, service string) (port int, err os.Error) {
 
51
        switch network {
 
52
        case "tcp4", "tcp6":
 
53
                network = "tcp"
 
54
        case "udp4", "udp6":
 
55
                network = "udp"
 
56
        }
 
57
        serventLock.Lock()
 
58
        defer serventLock.Unlock()
 
59
        s, e := syscall.GetServByName(service, network)
 
60
        if e != 0 {
 
61
                return 0, os.NewSyscallError("GetServByName", e)
 
62
        }
 
63
        return int(syscall.Ntohs(s.Port)), nil
 
64
}
 
65
 
 
66
func LookupCNAME(name string) (cname string, err os.Error) {
 
67
        var r *syscall.DNSRecord
 
68
        e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &r, nil)
 
69
        if int(e) != 0 {
 
70
                return "", os.NewSyscallError("LookupCNAME", int(e))
 
71
        }
 
72
        defer syscall.DnsRecordListFree(r, 1)
 
73
        if r != nil && r.Type == syscall.DNS_TYPE_CNAME {
 
74
                v := (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0]))
 
75
                cname = syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Host))[:]) + "."
 
76
        }
 
77
        return
 
78
}
 
79
 
 
80
func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err os.Error) {
 
81
        var r *syscall.DNSRecord
 
82
        target := "_" + service + "._" + proto + "." + name
 
83
        e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &r, nil)
 
84
        if int(e) != 0 {
 
85
                return "", nil, os.NewSyscallError("LookupSRV", int(e))
 
86
        }
 
87
        defer syscall.DnsRecordListFree(r, 1)
 
88
        addrs = make([]*SRV, 100)
 
89
        i := 0
 
90
        for p := r; p != nil && p.Type == syscall.DNS_TYPE_SRV; p = p.Next {
 
91
                v := (*syscall.DNSSRVData)(unsafe.Pointer(&p.Data[0]))
 
92
                addrs[i] = &SRV{syscall.UTF16ToString((*[256]uint16)(unsafe.Pointer(v.Target))[:]), v.Port, v.Priority, v.Weight}
 
93
                i++
 
94
        }
 
95
        addrs = addrs[0:i]
 
96
        return name, addrs, nil
 
97
}
 
98
 
 
99
// TODO(brainman): implement LookupMX and LookupAddr.
 
100
 
 
101
func LookupMX(name string) (mx []*MX, err os.Error) {
 
102
        return nil, os.NewSyscallError("LookupMX", syscall.EWINDOWS)
 
103
}
 
104
 
 
105
func LookupAddr(addr string) (name []string, err os.Error) {
 
106
        return nil, os.NewSyscallError("LookupAddr", syscall.EWINDOWS)
 
107
}