import (
"net";
"flag";
+ "fmt";
"io";
"os";
"testing";
// Run an HTTP request to fetch the appropriate page.
func fetchGoogle(t *testing.T, fd net.Conn, network, addr string) {
req := io.StringBytes("GET /intl/en/privacy.html HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
- n, errno := fd.Write(req);
+ n, err := fd.Write(req);
buf := make([]byte, 1000);
- n, errno = io.Readn(fd, buf);
+ n, err = io.Readn(fd, buf);
if n < 1000 {
- t.Errorf("fetchGoogle: short HTTP read from %s %s", network, addr);
+ t.Errorf("fetchGoogle: short HTTP read from %s %s - %v", network, addr, err);
return
}
}
"strings";
)
+// DNS errors returned by LookupHost.
var (
DNS_InternalError = os.NewError("internal dns error");
DNS_MissingConfig = os.NewError("no dns configuration");
DNS_NameTooLong = os.NewError("dns name too long");
DNS_RedirectLoop = os.NewError("dns redirect loop");
DNS_NameNotFound = os.NewError("dns name not found");
-);
+)
// Send a request on the connection and hope for a reply.
// Up to cfg.attempts attempts.
-func _Exchange(cfg *DNS_Config, c Conn, name string) (m *DNS_Msg, err *os.Error) {
+func _Exchange(cfg *_DNS_Config, c Conn, name string) (m *_DNS_Msg, err *os.Error) {
if len(name) >= 256 {
return nil, DNS_NameTooLong
}
- out := new(DNS_Msg);
+ out := new(_DNS_Msg);
out.id = 0x1234;
- out.question = []DNS_Question{
- DNS_Question{ name, DNS_TypeA, DNS_ClassINET }
+ out.question = []_DNS_Question{
+ _DNS_Question{ name, _DNS_TypeA, _DNS_ClassINET }
};
out.recursion_desired = true;
msg, ok := out.Pack();
continue
}
buf = buf[0:n];
- in := new(DNS_Msg);
+ in := new(_DNS_Msg);
if !in.Unpack(buf) || in.id != out.id {
continue
}
// Find answer for name in dns message.
// On return, if err == nil, addrs != nil.
// TODO(rsc): Maybe return [][]byte (==[]IPAddr) instead?
-func answer(name string, dns *DNS_Msg) (addrs []string, err *os.Error) {
+func answer(name string, dns *_DNS_Msg) (addrs []string, err *os.Error) {
addrs = make([]string, 0, len(dns.answer));
- if dns.rcode == DNS_RcodeNameError && dns.authoritative {
+ if dns.rcode == _DNS_RcodeNameError && dns.authoritative {
return nil, DNS_NameNotFound // authoritative "no such host"
}
- if dns.rcode != DNS_RcodeSuccess {
+ if dns.rcode != _DNS_RcodeSuccess {
// None of the error codes make sense
// for the query we sent. If we didn't get
// a name error and we didn't get success,
for i := 0; i < len(dns.answer); i++ {
rr := dns.answer[i];
h := rr.Header();
- if h.class == DNS_ClassINET && h.name == name {
+ if h.class == _DNS_ClassINET && h.name == name {
switch h.rrtype {
- case DNS_TypeA:
+ case _DNS_TypeA:
n := len(addrs);
- a := rr.(*DNS_RR_A).a;
+ a := rr.(*_DNS_RR_A).a;
addrs = addrs[0:n+1];
addrs[n] = fmt.Sprintf("%d.%d.%d.%d", (a>>24), (a>>16)&0xFF, (a>>8)&0xFF, a&0xFF);
- case DNS_TypeCNAME:
+ case _DNS_TypeCNAME:
// redirect to cname
- name = rr.(*DNS_RR_CNAME).cname;
+ name = rr.(*_DNS_RR_CNAME).cname;
continue Cname
}
}
// Do a lookup for a single name, which must be rooted
// (otherwise answer will not find the answers).
-func tryOneName(cfg *DNS_Config, name string) (addrs []string, err *os.Error) {
+func tryOneName(cfg *_DNS_Config, name string) (addrs []string, err *os.Error) {
err = DNS_NoServers;
for i := 0; i < len(cfg.servers); i++ {
// Calling Dial here is scary -- we have to be sure
return;
}
-var cfg *DNS_Config
+var cfg *_DNS_Config
+var dnserr *os.Error
func loadConfig() {
- cfg = DNS_ReadConfig();
+ cfg, dnserr = _DNS_ReadConfig();
}
-func LookupHost(name string) (name1 string, addrs []string, err *os.Error) {
+// LookupHost looks up the host name using the local DNS resolver.
+// It returns the canonical name for the host and an array of that
+// host's addresses.
+func LookupHost(name string) (cname string, addrs []string, err *os.Error)
+{
// TODO(rsc): Pick out obvious non-DNS names to avoid
// sending stupid requests to the server?
once.Do(loadConfig);
- if cfg == nil {
+ if dnserr != nil || cfg == nil {
+ // better error than file not found.
err = DNS_MissingConfig;
return;
}
"strconv";
)
-type DNS_Config struct {
+type _DNS_Config struct {
servers []string; // servers to use
search []string; // suffixes to append to local name
ndots int; // number of dots in name to trigger absolute lookup
rotate bool; // round robin among servers
}
+var _DNS_configError *os.Error;
+
// See resolv.conf(5) on a Linux machine.
// TODO(rsc): Supposed to call uname() and chop the beginning
// of the host name to get the default search domain.
// We assume it's in resolv.conf anyway.
-func DNS_ReadConfig() *DNS_Config {
+func _DNS_ReadConfig() (*_DNS_Config, *os.Error) {
// TODO(rsc): 6g won't let me use "file :="
- var file = open("/etc/resolv.conf");
- if file == nil {
- return nil
+ var file *file;
+ var err *os.Error;
+ file, err = open("/etc/resolv.conf");
+ if err != nil {
+ return nil, err
}
- conf := new(DNS_Config);
+ conf := new(_DNS_Config);
conf.servers = make([]string, 3)[0:0]; // small, but the standard limit
conf.search = make([]string, 0);
conf.ndots = 1;
conf.timeout = 1;
conf.attempts = 1;
conf.rotate = false;
- var err *os.Error;
for line, ok := file.readLine(); ok; line, ok = file.readLine() {
f := getFields(line);
if len(f) < 1 {
}
file.close();
- return conf
+ return conf, nil
}
// generic pack/unpack routines.
//
// TODO(rsc) There are enough names defined in this file that they're all
-// prefixed with DNS_. Perhaps put this in its own package later.
+// prefixed with _DNS_. Perhaps put this in its own package later.
package net
// Wire constants.
const (
- // valid DNS_RR_Header.rrtype and DNS_Question.qtype
- DNS_TypeA = 1;
- DNS_TypeNS = 2;
- DNS_TypeMD = 3;
- DNS_TypeMF = 4;
- DNS_TypeCNAME = 5;
- DNS_TypeSOA = 6;
- DNS_TypeMB = 7;
- DNS_TypeMG = 8;
- DNS_TypeMR = 9;
- DNS_TypeNULL = 10;
- DNS_TypeWKS = 11;
- DNS_TypePTR = 12;
- DNS_TypeHINFO = 13;
- DNS_TypeMINFO = 14;
- DNS_TypeMX = 15;
- DNS_TypeTXT = 16;
-
- // valid DNS_Question.qtype only
- DNS_TypeAXFR = 252;
- DNS_TypeMAILB = 253;
- DNS_TypeMAILA = 254;
- DNS_TypeALL = 255;
-
- // valid DNS_Question.qclass
- DNS_ClassINET = 1;
- DNS_ClassCSNET = 2;
- DNS_ClassCHAOS = 3;
- DNS_ClassHESIOD = 4;
- DNS_ClassANY = 255;
-
- // DNS_Msg.rcode
- DNS_RcodeSuccess = 0;
- DNS_RcodeFormatError = 1;
- DNS_RcodeServerFailure = 2;
- DNS_RcodeNameError = 3;
- DNS_RcodeNotImplemented = 4;
- DNS_RcodeRefused = 5;
+ // valid _DNS_RR_Header.rrtype and _DNS_Question.qtype
+ _DNS_TypeA = 1;
+ _DNS_TypeNS = 2;
+ _DNS_TypeMD = 3;
+ _DNS_TypeMF = 4;
+ _DNS_TypeCNAME = 5;
+ _DNS_TypeSOA = 6;
+ _DNS_TypeMB = 7;
+ _DNS_TypeMG = 8;
+ _DNS_TypeMR = 9;
+ _DNS_TypeNULL = 10;
+ _DNS_TypeWKS = 11;
+ _DNS_TypePTR = 12;
+ _DNS_TypeHINFO = 13;
+ _DNS_TypeMINFO = 14;
+ _DNS_TypeMX = 15;
+ _DNS_TypeTXT = 16;
+
+ // valid _DNS_Question.qtype only
+ _DNS_TypeAXFR = 252;
+ _DNS_TypeMAILB = 253;
+ _DNS_TypeMAILA = 254;
+ _DNS_TypeALL = 255;
+
+ // valid _DNS_Question.qclass
+ _DNS_ClassINET = 1;
+ _DNS_ClassCSNET = 2;
+ _DNS_ClassCHAOS = 3;
+ _DNS_ClassHESIOD = 4;
+ _DNS_ClassANY = 255;
+
+ // _DNS_Msg.rcode
+ _DNS_RcodeSuccess = 0;
+ _DNS_RcodeFormatError = 1;
+ _DNS_RcodeServerFailure = 2;
+ _DNS_RcodeNameError = 3;
+ _DNS_RcodeNotImplemented = 4;
+ _DNS_RcodeRefused = 5;
)
// The wire format for the DNS packet header.
-type _DNS_Header struct {
+type __DNS_Header struct {
id uint16;
bits uint16;
qdcount, ancount, nscount, arcount uint16;
}
const (
- // _DNS_Header.bits
+ // __DNS_Header.bits
_QR = 1<<15; // query/response (response=1)
_AA = 1<<10; // authoritative
_TC = 1<<9; // truncated
)
// DNS queries.
-type DNS_Question struct {
+type _DNS_Question struct {
name string "domain-name"; // "domain-name" specifies encoding; see packers below
qtype uint16;
qclass uint16;
// DNS responses (resource records).
// There are many types of messages,
// but they all share the same header.
-type DNS_RR_Header struct {
+type _DNS_RR_Header struct {
name string "domain-name";
rrtype uint16;
class uint16;
rdlength uint16; // length of data after header
}
-func (h *DNS_RR_Header) Header() *DNS_RR_Header {
+func (h *_DNS_RR_Header) Header() *_DNS_RR_Header {
return h
}
-type DNS_RR interface {
- Header() *DNS_RR_Header
+type _DNS_RR interface {
+ Header() *_DNS_RR_Header
}
// Specific DNS RR formats for each query type.
-type DNS_RR_CNAME struct {
- DNS_RR_Header;
+type _DNS_RR_CNAME struct {
+ _DNS_RR_Header;
cname string "domain-name";
}
-type DNS_RR_HINFO struct {
- DNS_RR_Header;
+type _DNS_RR_HINFO struct {
+ _DNS_RR_Header;
cpu string;
os string;
}
-type DNS_RR_MB struct {
- DNS_RR_Header;
+type _DNS_RR_MB struct {
+ _DNS_RR_Header;
mb string "domain-name";
}
-type DNS_RR_MG struct {
- DNS_RR_Header;
+type _DNS_RR_MG struct {
+ _DNS_RR_Header;
mg string "domain-name";
}
-type DNS_RR_MINFO struct {
- DNS_RR_Header;
+type _DNS_RR_MINFO struct {
+ _DNS_RR_Header;
rmail string "domain-name";
email string "domain-name";
}
-type DNS_RR_MR struct {
- DNS_RR_Header;
+type _DNS_RR_MR struct {
+ _DNS_RR_Header;
mr string "domain-name";
}
-type DNS_RR_MX struct {
- DNS_RR_Header;
+type _DNS_RR_MX struct {
+ _DNS_RR_Header;
pref uint16;
mx string "domain-name";
}
-type DNS_RR_NS struct {
- DNS_RR_Header;
+type _DNS_RR_NS struct {
+ _DNS_RR_Header;
ns string "domain-name";
}
-type DNS_RR_PTR struct {
- DNS_RR_Header;
+type _DNS_RR_PTR struct {
+ _DNS_RR_Header;
ptr string "domain-name";
}
-type DNS_RR_SOA struct {
- DNS_RR_Header;
+type _DNS_RR_SOA struct {
+ _DNS_RR_Header;
ns string "domain-name";
mbox string "domain-name";
serial uint32;
minttl uint32;
}
-type DNS_RR_TXT struct {
- DNS_RR_Header;
+type _DNS_RR_TXT struct {
+ _DNS_RR_Header;
txt string; // not domain name
}
-type DNS_RR_A struct {
- DNS_RR_Header;
+type _DNS_RR_A struct {
+ _DNS_RR_Header;
a uint32 "ipv4";
}
// packing sequence.
// Map of constructors for each RR wire type.
-var rr_mk = map[int] func()DNS_RR {
- DNS_TypeCNAME: func() DNS_RR { return new(DNS_RR_CNAME) },
- DNS_TypeHINFO: func() DNS_RR { return new(DNS_RR_HINFO) },
- DNS_TypeMB: func() DNS_RR { return new(DNS_RR_MB) },
- DNS_TypeMG: func() DNS_RR { return new(DNS_RR_MG) },
- DNS_TypeMINFO: func() DNS_RR { return new(DNS_RR_MINFO) },
- DNS_TypeMR: func() DNS_RR { return new(DNS_RR_MR) },
- DNS_TypeMX: func() DNS_RR { return new(DNS_RR_MX) },
- DNS_TypeNS: func() DNS_RR { return new(DNS_RR_NS) },
- DNS_TypePTR: func() DNS_RR { return new(DNS_RR_PTR) },
- DNS_TypeSOA: func() DNS_RR { return new(DNS_RR_SOA) },
- DNS_TypeTXT: func() DNS_RR { return new(DNS_RR_TXT) },
- DNS_TypeA: func() DNS_RR { return new(DNS_RR_A) },
+var rr_mk = map[int] func()_DNS_RR {
+ _DNS_TypeCNAME: func() _DNS_RR { return new(_DNS_RR_CNAME) },
+ _DNS_TypeHINFO: func() _DNS_RR { return new(_DNS_RR_HINFO) },
+ _DNS_TypeMB: func() _DNS_RR { return new(_DNS_RR_MB) },
+ _DNS_TypeMG: func() _DNS_RR { return new(_DNS_RR_MG) },
+ _DNS_TypeMINFO: func() _DNS_RR { return new(_DNS_RR_MINFO) },
+ _DNS_TypeMR: func() _DNS_RR { return new(_DNS_RR_MR) },
+ _DNS_TypeMX: func() _DNS_RR { return new(_DNS_RR_MX) },
+ _DNS_TypeNS: func() _DNS_RR { return new(_DNS_RR_NS) },
+ _DNS_TypePTR: func() _DNS_RR { return new(_DNS_RR_PTR) },
+ _DNS_TypeSOA: func() _DNS_RR { return new(_DNS_RR_SOA) },
+ _DNS_TypeTXT: func() _DNS_RR { return new(_DNS_RR_TXT) },
+ _DNS_TypeA: func() _DNS_RR { return new(_DNS_RR_A) },
}
// Pack a domain name s into msg[off:].
}
// Resource record packer.
-func packRR(rr DNS_RR, msg []byte, off int) (off2 int, ok bool) {
+func packRR(rr _DNS_RR, msg []byte, off int) (off2 int, ok bool) {
var off1 int;
// pack twice, once to find end of header
// and again to find end of packet.
}
// Resource record unpacker.
-func unpackRR(msg []byte, off int) (rr DNS_RR, off1 int, ok bool) {
+func unpackRR(msg []byte, off int) (rr _DNS_RR, off1 int, ok bool) {
// unpack just the header, to find the rr type and length
- var h DNS_RR_Header;
+ var h _DNS_RR_Header;
off0 := off;
if off, ok = unpackStruct(&h, msg, off); !ok {
return nil, len(msg), false
// A manually-unpacked version of (id, bits).
// This is in its own struct for easy printing.
-type _DNS_Msg_Top struct {
+type __DNS_Msg_Top struct {
id uint16;
response bool;
opcode int;
rcode int;
}
-type DNS_Msg struct {
- _DNS_Msg_Top;
- question []DNS_Question;
- answer []DNS_RR;
- ns []DNS_RR;
- extra []DNS_RR;
+type _DNS_Msg struct {
+ __DNS_Msg_Top;
+ question []_DNS_Question;
+ answer []_DNS_RR;
+ ns []_DNS_RR;
+ extra []_DNS_RR;
}
-func (dns *DNS_Msg) Pack() (msg []byte, ok bool) {
- var dh _DNS_Header;
+func (dns *_DNS_Msg) Pack() (msg []byte, ok bool) {
+ var dh __DNS_Header;
- // Convert convenient DNS_Msg into wire-like _DNS_Header.
+ // Convert convenient _DNS_Msg into wire-like __DNS_Header.
dh.id = dns.id;
dh.bits = uint16(dns.opcode)<<11 | uint16(dns.rcode);
if dns.recursion_available {
return msg[0:off], true
}
-func (dns *DNS_Msg) Unpack(msg []byte) bool {
+func (dns *_DNS_Msg) Unpack(msg []byte) bool {
// Header.
- var dh _DNS_Header;
+ var dh __DNS_Header;
off := 0;
var ok bool;
if off, ok = unpackStruct(&dh, msg, off); !ok {
dns.rcode = int(dh.bits & 0xF);
// Arrays.
- dns.question = make([]DNS_Question, dh.qdcount);
- dns.answer = make([]DNS_RR, dh.ancount);
- dns.ns = make([]DNS_RR, dh.nscount);
- dns.extra = make([]DNS_RR, dh.arcount);
+ dns.question = make([]_DNS_Question, dh.qdcount);
+ dns.answer = make([]_DNS_RR, dh.ancount);
+ dns.ns = make([]_DNS_RR, dh.nscount);
+ dns.extra = make([]_DNS_RR, dh.arcount);
for i := 0; i < len(dns.question); i++ {
off, ok = unpackStruct(&dns.question[i], msg, off);
return true
}
-func (dns *DNS_Msg) String() string {
- s := "DNS: "+printStruct(&dns._DNS_Msg_Top)+"\n";
+func (dns *_DNS_Msg) String() string {
+ s := "DNS: "+printStruct(&dns.__DNS_Msg_Top)+"\n";
if len(dns.question) > 0 {
s += "-- Questions\n";
for i := 0; i < len(dns.question); i++ {
cr, cw chan *netFD; // buffered >= 1
pr, pw *os.FD;
pending map[int64] *netFD;
- poll *Pollster; // low-level OS hooks
+ poll *pollster; // low-level OS hooks
}
func (s *pollServer) Run();
if err = setNonblock(s.pw.Fd()); err != nil {
goto Error
}
- if s.poll, err = NewPollster(); err != nil {
+ if s.poll, err = newpollster(); err != nil {
goto Error
}
if err = s.poll.AddFD(s.pr.Fd(), 'r', true); err != nil {
"syscall";
)
-type Pollster struct {
+type pollster struct {
kq int64;
eventbuf [10]syscall.Kevent_t;
events []syscall.Kevent_t;
}
-func NewPollster() (p *Pollster, err *os.Error) {
- p = new(Pollster);
+func newpollster() (p *pollster, err *os.Error) {
+ p = new(pollster);
var e int64;
if p.kq, e = syscall.Kqueue(); e != 0 {
return nil, os.ErrnoToError(e)
return p, nil
}
-func (p *Pollster) AddFD(fd int64, mode int, repeat bool) *os.Error {
+func (p *pollster) AddFD(fd int64, mode int, repeat bool) *os.Error {
var kmode int16;
if mode == 'r' {
kmode = syscall.EVFILT_READ
return nil
}
-func (p *Pollster) WaitFD() (fd int64, mode int, err *os.Error) {
+func (p *pollster) WaitFD() (fd int64, mode int, err *os.Error) {
for len(p.events) == 0 {
nn, e := syscall.Kevent(p.kq, nil, p.eventbuf, nil);
if e != 0 {
return fd, mode, nil
}
-func (p *Pollster) Close() *os.Error {
+func (p *pollster) Close() *os.Error {
r, e := syscall.Close(p.kq);
return os.ErrnoToError(e)
}
writeFlags = syscall.EPOLLOUT
)
-type Pollster struct {
+type pollster struct {
epfd int64;
// Events we're already waiting for
events map[int64] uint32;
}
-func NewPollster() (p *Pollster, err *os.Error) {
- p = new(Pollster);
+func newpollster() (p *pollster, err *os.Error) {
+ p = new(pollster);
var e int64;
// The arg to epoll_create is a hint to the kernel
return p, nil
}
-func (p *Pollster) AddFD(fd int64, mode int, repeat bool) *os.Error {
+func (p *pollster) AddFD(fd int64, mode int, repeat bool) *os.Error {
var ev syscall.EpollEvent;
var already bool;
ev.Fd = int32(fd);
return nil
}
-func (p *Pollster) StopWaiting(fd int64, bits uint) {
+func (p *pollster) StopWaiting(fd int64, bits uint) {
events, already := p.events[fd];
if !already {
print("Epoll unexpected fd=", fd, "\n");
}
}
-func (p *Pollster) WaitFD() (fd int64, mode int, err *os.Error) {
+func (p *pollster) WaitFD() (fd int64, mode int, err *os.Error) {
// Get an event.
var evarray [1]syscall.EpollEvent;
ev := &evarray[0];
return fd, 'r', nil
}
-func (p *Pollster) Close() *os.Error {
+func (p *pollster) Close() *os.Error {
r, e := syscall.Close(p.epfd);
return os.ErrnoToError(e)
}
"net"
)
+// IP address lengths (bytes).
const (
IPv4len = 4;
IPv6len = 16
)
-// Make the 4 bytes into an IPv4 address (in IPv6 form)
-func makeIPv4(a, b, c, d byte) []byte {
+// An IP is a single IP address, an array of bytes.
+// Functions in this package accept either 4-byte (IP v4)
+// or 16-byte (IP v6) arrays as input. Unless otherwise
+// specified, functions in this package always return
+// IP addresses in 16-byte form using the canonical
+// embedding.
+//
+// Note that in this documentation, referring to an
+// IP address as an IPv4 address or an IPv6 address
+// is a semantic property of the address, not just the
+// length of the byte array: a 16-byte array can still
+// be an IPv4 address.
+type IP []byte;
+
+// An IP mask is an IP address.
+type IPMask []byte;
+
+// IPv4 returns the IP address (in 16-byte form) of the
+// IPv4 address a.b.c.d.
+func IPv4(a, b, c, d byte) IP {
p := make([]byte, IPv6len);
for i := 0; i < 10; i++ {
p[i] = 0
return p
}
-// Well-known IP addresses
-var IPv4bcast, IPv4allsys, IPv4allrouter, IPv4prefix, IPallbits, IPnoaddr []byte
-
-func init() {
- IPv4bcast = makeIPv4(0xff, 0xff, 0xff, 0xff);
- IPv4allsys = makeIPv4(0xe0, 0x00, 0x00, 0x01);
- IPv4allrouter = makeIPv4(0xe0, 0x00, 0x00, 0x02);
- IPv4prefix = makeIPv4(0, 0, 0, 0);
- IPallbits = make([]byte, IPv6len);
- for i := 0; i < IPv6len; i++ {
- IPallbits[i] = 0xff
- }
- IPnoaddr = make([]byte, IPv6len); // zeroed
-}
+// Well-known IPv4 addresses
+var (
+ IPv4bcast = IPv4(255, 255, 255, 255); // broadcast
+ IPv4allsys = IPv4(224, 0, 0, 1); // all systems
+ IPv4allrouter = IPv4(224, 0, 0, 2); // all routers
+)
+
+// Well-known IPv6 addresses
+var (
+ IPzero = make(IP, IPv6len); // all zeros
+)
// Is p all zeros?
func isZeros(p []byte) bool {
return true
}
-// Is p an IPv4 address (perhaps in IPv6 form)?
-// If so, return the 4-byte V4 array.
-func ToIPv4(p []byte) []byte {
- if len(p) == IPv4len {
- return p
+// To4 converts the IPv4 address ip to a 4-byte representation.
+// If ip is not an IPv4 address, To4 returns nil.
+func (ip IP) To4() IP {
+ if len(ip) == IPv4len {
+ return ip
}
- if len(p) == IPv6len
- && isZeros(p[0:10])
- && p[10] == 0xff
- && p[11] == 0xff {
- return p[12:16]
+ if len(ip) == IPv6len
+ && isZeros(ip[0:10])
+ && ip[10] == 0xff
+ && ip[11] == 0xff {
+ return ip[12:16]
}
return nil
}
-// Convert p to IPv6 form.
-func ToIPv6(p []byte) []byte {
- if len(p) == IPv4len {
- return makeIPv4(p[0], p[1], p[2], p[3])
+// To16 converts the IP address ip to a 16-byte representation.
+// If ip is not an IP address (it is the wrong length), To16 returns nil.
+func (ip IP) To16() IP {
+ if len(ip) == IPv4len {
+ return IPv4(ip[0], ip[1], ip[2], ip[3])
}
- if len(p) == IPv6len {
- return p
+ if len(ip) == IPv6len {
+ return ip
}
return nil
}
// Default route masks for IPv4.
var (
- ClassAMask = makeIPv4(0xff, 0, 0, 0);
- ClassBMask = makeIPv4(0xff, 0xff, 0, 0);
- ClassCMask = makeIPv4(0xff, 0xff, 0xff, 0);
+ classAMask IPMask = IPv4(0xff, 0, 0, 0);
+ classBMask IPMask = IPv4(0xff, 0xff, 0, 0);
+ classCMask IPMask = IPv4(0xff, 0xff, 0xff, 0);
)
-func DefaultMask(p []byte) []byte {
- if p = ToIPv4(p); p == nil {
+// DefaultMask returns the default IP mask for the IP address ip.
+// Only IPv4 addresses have default masks; DefaultMask returns
+// nil if ip is not a valid IPv4 address.
+func (ip IP) DefaultMask() IPMask {
+ if ip = ip.To4(); ip == nil {
return nil
}
switch true {
- case p[0] < 0x80:
- return ClassAMask;
- case p[0] < 0xC0:
- return ClassBMask;
+ case ip[0] < 0x80:
+ return classAMask;
+ case ip[0] < 0xC0:
+ return classBMask;
default:
- return ClassCMask;
+ return classCMask;
}
return nil; // not reached
}
-// Apply mask to ip, returning new address.
-func Mask(ip []byte, mask []byte) []byte {
+// Mask returns the result of masking the IP address ip with mask.
+func (ip IP) Mask(mask IPMask) IP {
n := len(ip);
if n != len(mask) {
return nil
}
- out := make([]byte, n);
+ out := make(IP, n);
for i := 0; i < n; i++ {
out[i] = ip[i] & mask[i];
}
}
return string(b[bp:len(b)])
-// return string((&b)[bp:len(b)])
}
// Convert i to hexadecimal string.
}
return string(b[bp:len(b)])
- // return string((&b)[bp:len(b)])
}
-// Convert IP address to string.
-func IPToString(p []byte) string {
+// String returns the string form of the IP address ip.
+// If the address is an IPv4 address, the string representation
+// is dotted decimal ("74.125.19.99"). Otherwise the representation
+// is IPv6 ("2001:4860:0:2001::68").
+func (ip IP) String() string {
+ p := ip;
+
// If IPv4, use dotted notation.
- if p4 := ToIPv4(p); len(p4) == 4 {
+ if p4 := p.To4(); len(p4) == 4 {
return itod(uint(p4[0]))+"."
+itod(uint(p4[1]))+"."
+itod(uint(p4[2]))+"."
// If mask is a sequence of 1 bits followed by 0 bits,
// return the number of 1 bits.
-func simpleMaskLength(mask []byte) int {
+func simpleMaskLength(mask IP) int {
var i int;
for i = 0; i < len(mask); i++ {
if mask[i] != 0xFF {
return n
}
-func MaskToString(mask []byte) string {
+// String returns the string representation of mask.
+// If the mask is in the canonical form--ones followed by zeros--the
+// string representation is just the decimal number of ones.
+// If the mask is in a non-canonical form, it is formatted
+// as an IP address.
+func (mask IPMask) String() string {
switch len(mask) {
case 4:
n := simpleMaskLength(mask);
return itod(uint(n))
}
}
- return IPToString(mask)
+ return IP(mask).String();
}
// Parse IPv4 address (d.d.d.d).
-func parseIPv4(s string) []byte {
+func parseIPv4(s string) IP {
var p [IPv4len]byte;
i := 0;
for j := 0; j < IPv4len; j++ {
if i != len(s) {
return nil
}
- return makeIPv4(p[0], p[1], p[2], p[3])
+ return IPv4(p[0], p[1], p[2], p[3])
}
// Parse IPv6 address. Many forms.
// * A run of zeros can be replaced with "::".
// * The last 32 bits can be in IPv4 form.
// Thus, ::ffff:1.2.3.4 is the IPv4 address 1.2.3.4.
-func parseIPv6(s string) []byte {
- p := make([]byte, 16);
+func parseIPv6(s string) IP {
+ p := make(IP, 16);
ellipsis := -1; // position of ellipsis in p
i := 0; // index in string s
return p
}
-func ParseIP(s string) []byte {
+// ParseIP parses s as an IP address, returning the result.
+// The string s can be in dotted decimal ("74.125.19.99")
+// or IPv6 ("2001:4860:0:2001::68") form.
+// If s is not a valid textual representation of an IP address,
+// ParseIP returns nil.
+func ParseIP(s string) IP {
p := parseIPv4(s);
if p != nil {
return p
MissingAddress = os.NewError("missing address");
UnknownNetwork = os.NewError("unknown network");
UnknownHost = os.NewError("unknown host");
- DNS_Error = os.NewError("dns error looking up host");
- UnknownPort = os.NewError("unknown port");
- UnknownsocketFamily = os.NewError("unknown socket family");
+ UnknownSocketFamily = os.NewError("unknown socket family");
)
-func LookupHost(name string) (name1 string, addrs []string, err *os.Error)
+func LookupHost(name string) (cname string, addrs []string, err *os.Error)
// Split "host:port" into "host" and "port".
// Host cannot contain colons unless it is bracketed.
var addr []byte;
if host == "" {
if mode == "listen" {
- addr = IPnoaddr; // wildcard - listen to all
+ addr = IPzero; // wildcard - listen to all
} else {
return nil, 0, MissingAddress;
}
p, i, ok := dtoi(port, 0);
if !ok || i != len(port) {
- p, ok = LookupPort(net, port);
- if !ok {
- return nil, 0, UnknownPort
+ p, err = LookupPort(net, port);
+ if err != nil {
+ return nil, 0, err
}
}
if p < 0 || p > 0xFFFF {
func sockaddrToHostPort(sa *syscall.Sockaddr) (hostport string, err *os.Error) {
switch sa.Family {
case syscall.AF_INET, syscall.AF_INET6:
- addr, port, e := SockaddrToIP(sa);
+ addr, port, e := sockaddrToIP(sa);
if e != nil {
return "", e
}
- host := IPToString(addr);
+ host := addr.String();
return joinHostPort(host, strconv.Itoa(port)), nil;
default:
- return "", UnknownsocketFamily
+ return "", UnknownSocketFamily
}
return "", nil // not reached
}
(fd *netFD, err *os.Error)
{
// Parse addresses (unless they are empty).
- var lip, rip []byte;
+ var lip, rip IP;
var lport, rport int;
var lerr, rerr *os.Error;
default:
// Otherwise, guess.
// If the addresses are IPv4 and we prefer IPv4, use 4; else 6.
- if preferIPv4 && ToIPv4(lip) != nil && ToIPv4(rip) != nil {
+ if preferIPv4 && lip.To4() != nil && rip.To4() != nil {
vers = 4
} else {
vers = 6
var cvt func(addr []byte, port int) (sa *syscall.Sockaddr, err *os.Error);
var family int64;
if vers == 4 {
- cvt = IPv4ToSockaddr;
+ cvt = v4ToSockaddr;
family = syscall.AF_INET
} else {
- cvt = IPv6ToSockaddr;
+ cvt = v6ToSockaddr;
family = syscall.AF_INET6
}
// TODO: raw ethernet connections
-
+// A Conn is a generic network connection.
type Conn interface {
Read(b []byte) (n int, err *os.Error);
Write(b []byte) (n int, err *os.Error);
+ Close() *os.Error;
+
+ // For UDP sockets.
ReadFrom(b []byte) (n int, addr string, err *os.Error);
WriteTo(addr string, b []byte) (n int, err *os.Error);
- Close() *os.Error;
+
+ // Methods that have meaning only on some networks.
SetReadBuffer(bytes int) *os.Error;
SetWriteBuffer(bytes int) *os.Error;
SetTimeout(nsec int64) *os.Error;
BindToDevice(dev string) *os.Error;
}
-
-// Dial's arguments are the network, local address, and remote address.
+// Dial connects to the remote address raddr on the network net.
+// If the string laddr is not empty, it is used as the local address
+// for the connection.
+//
+// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
+// "udp", "udp4" (IPv4-only), and "udp6" (IPv6-only).
+//
+// For IP networks, addresses have the form host:port. If host is
+// a literal IPv6 address, it must be enclosed in square brackets.
+//
// Examples:
// Dial("tcp", "", "12.34.56.78:80")
+// Dial("tcp", "", "google.com:80")
// Dial("tcp", "", "[de:ad:be:ef::ca:fe]:80")
// Dial("tcp", "127.0.0.1:123", "127.0.0.1:88")
-//
-// Eventually, we plan to allow names in addition to IP addresses,
-// but that requires writing a DNS library.
-
func Dial(net, laddr, raddr string) (c Conn, err *os.Error) {
switch net {
case "tcp", "tcp4", "tcp6":
return nil, UnknownNetwork
}
-
+// A Listener is a generic network listener.
+// Accept waits for the next connection and Close closes the connection.
type Listener interface {
Accept() (c Conn, raddr string, err *os.Error);
Close() *os.Error;
}
+// ListenerTCP is a TCP network listener.
+// Clients should typically use variables of type Listener
+// instead of assuming TCP.
type ListenerTCP struct {
fd *netFD;
laddr string
}
+// ListenTCP announces on the TCP address laddr and returns a TCP listener.
+// Net must be "tcp", "tcp4", or "tcp6".
func ListenTCP(net, laddr string) (l *ListenerTCP, err *os.Error) {
fd, e := internetSocket(net, laddr, "", syscall.SOCK_STREAM, "listen");
if e != nil {
return nil, e
}
- r, e1 := syscall.Listen(fd.fd, ListenBacklog());
+ r, e1 := syscall.Listen(fd.fd, listenBacklog());
if e1 != 0 {
syscall.Close(fd.fd);
return nil, os.ErrnoToError(e1)
return l, nil
}
+// AcceptTCP accepts the next incoming call and returns the new connection
+// and the remote address.
func (l *ListenerTCP) AcceptTCP() (c *ConnTCP, raddr string, err *os.Error) {
if l == nil || l.fd == nil || l.fd.fd < 0 {
return nil, "", os.EINVAL
return newConnTCP(fd, raddr), raddr, nil
}
+// Accept implements the accept method in the Listener interface;
+// it waits for the next call and returns a generic Conn.
func (l *ListenerTCP) Accept() (c Conn, raddr string, err *os.Error) {
c1, r1, e1 := l.AcceptTCP();
if e1 != nil {
return c1, r1, nil
}
+// Close stops listening on the TCP address.
+// Already Accepted connections are not closed.
func (l *ListenerTCP) Close() *os.Error {
if l == nil || l.fd == nil {
return os.EINVAL
return l.fd.Close()
}
+// Listen announces on the local network address laddr.
+// The network string net must be "tcp", "tcp4", or "tcp6".
func Listen(net, laddr string) (l Listener, err *os.Error) {
switch net {
case "tcp", "tcp4", "tcp6":
/*
more here
*/
+ // BUG(rsc): Listen should support UDP.
}
return nil, UnknownNetwork
}
"unsafe";
)
-func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
- p = ToIPv4(p);
+func v4ToSockaddr(p IP, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
+ p = p.To4();
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil
}
-func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
- p = ToIPv6(p);
+func v6ToSockaddr(p IP, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
+ p = p.To16();
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
}
-func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Error) {
+func sockaddrToIP(sa1 *syscall.Sockaddr) (p IP, port int, err *os.Error) {
switch sa1.Family {
case syscall.AF_INET:
sa := (*syscall.SockaddrInet4)(unsafe.Pointer(sa1));
- a := ToIPv6(sa.Addr);
+ a := IP(sa.Addr).To16();
if a == nil {
return nil, 0, os.EINVAL
}
return a, int(sa.Port[0])<<8 + int(sa.Port[1]), nil;
case syscall.AF_INET6:
sa := (*syscall.SockaddrInet6)(unsafe.Pointer(sa1));
- a := ToIPv6(sa.Addr);
+ a := IP(sa.Addr).To16();
if a == nil {
return nil, 0, os.EINVAL
}
return nil, 0, nil // not reached
}
-func ListenBacklog() int64 {
+func listenBacklog() int64 {
return syscall.SOMAXCONN
}
"unsafe";
)
-func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
- p = ToIPv4(p);
+func v4ToSockaddr(p IP, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
+ p = p.To4();
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil
}
-var ipv6zero [16]byte;
-
-func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
- p = ToIPv6(p);
+func v6ToSockaddr(p IP, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
+ p = p.To16();
if p == nil || port < 0 || port > 0xFFFF {
return nil, os.EINVAL
}
// IPv4 callers use 0.0.0.0 to mean "announce on any available address".
// In IPv6 mode, Linux treats that as meaning "announce on 0.0.0.0",
// which it refuses to do. Rewrite to the IPv6 all zeros.
- if p4 := ToIPv4(p); p4 != nil && p4[0] == 0 && p4[1] == 0 && p4[2] == 0 && p4[3] == 0 {
- p = ipv6zero;
+ if p4 := p.To4(); p4 != nil && p4[0] == 0 && p4[1] == 0 && p4[2] == 0 && p4[3] == 0 {
+ p = IPzero;
}
sa := new(syscall.SockaddrInet6);
return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil
}
-func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Error) {
+func sockaddrToIP(sa1 *syscall.Sockaddr) (p IP, port int, err *os.Error) {
switch sa1.Family {
case syscall.AF_INET:
sa := (*syscall.SockaddrInet4)(unsafe.Pointer(sa1));
- a := ToIPv6(sa.Addr);
+ a := IP(sa.Addr).To16();
if a == nil {
return nil, 0, os.EINVAL
}
return a, int(sa.Port[0])<<8 + int(sa.Port[1]), nil;
case syscall.AF_INET6:
sa := (*syscall.SockaddrInet6)(unsafe.Pointer(sa1));
- a := ToIPv6(sa.Addr);
+ a := IP(sa.Addr).To16();
if a == nil {
return nil, 0, os.EINVAL
}
return nil, 0, nil // not reached
}
-func ListenBacklog() int64 {
+func listenBacklog() int64 {
// TODO: Read the limit from /proc/sys/net/core/somaxconn,
// to take advantage of kernels that have raised the limit.
return syscall.SOMAXCONN
return
}
-func open(name string) *file {
+func open(name string) (*file, *os.Error) {
fd, err := os.Open(name, os.O_RDONLY, 0);
if err != nil {
- return nil
+ return nil, err;
}
- return &file{fd, make([]byte, 1024)[0:0]};
+ return &file{fd, make([]byte, 1024)[0:0]}, nil;
}
func byteIndex(s string, c byte) int {
br := bufio.NewBufRead(fd);
// TODO(rsc): 6g rejects "file :="
- var file = open(filename);
+ var file *file;
+ file, err = open(filename);
if file == nil {
t.Fatalf("net.open(%s) = nil", filename);
}
"strconv";
)
+// The error returned by LookupPort when a network service
+// is not listed in the database.
+var ErrNoService = os.NewError("unknown network service");
+
var services map[string] map[string] int
+var servicesError *os.Error
func readServices() {
services = make(map[string] map[string] int);
- // TODO(rsc): 6g won't let me do "file := "
- var file = open("/etc/services");
+ var file *file;
+ file, servicesError = open("/etc/services");
for line, ok := file.readLine(); ok; line, ok = file.readLine() {
// "http 80/tcp www www-http # World Wide Web HTTP"
if i := byteIndex(line, '#'); i >= 0 {
file.close();
}
-func LookupPort(netw, name string) (port int, ok bool) {
+// LookupPort looks up the port for the given network and service.
+func LookupPort(network, service string) (port int, err *os.Error) {
once.Do(readServices);
- switch netw {
+ switch network {
case "tcp4", "tcp6":
- netw = "tcp";
+ network = "tcp";
case "udp4", "udp6":
- netw = "udp";
+ network = "udp";
}
- m, mok := services[netw];
- if !mok {
- return
+ m, ok := services[network];
+ if !ok {
+ return 0, ErrNoService;
+ }
+ port, ok = m[service];
+ if !ok {
+ return 0, ErrNoService;
}
- port, ok = m[name];
- return
+ return port, nil;
}
-
func TestLookupPort(t *testing.T) {
for i := 0; i < len(porttests); i++ {
tt := porttests[i];
- if port, ok := LookupPort(tt.netw, tt.name); port != tt.port || ok != tt.ok {
- t.Errorf("LookupPort(%q, %q) = %v, %v; want %v, %v",
- tt.netw, tt.name, port, ok, tt.port, tt.ok);
+ if port, err := LookupPort(tt.netw, tt.name); port != tt.port || (err == nil) != tt.ok {
+ t.Errorf("LookupPort(%q, %q) = %v, %s; want %v",
+ tt.netw, tt.name, port, err, tt.port);
}
}
}