change *map to map; *chan to chan; new(T) to new(*T)

fix bugs left over from *[] to [] conversion.

TBR=r
OCL=21576
CL=21581

13 files changed, 96 insertions, 104 deletions

diff --git a/src/lib/net/dialgoogle_test.go b/src/lib/net/dialgoogle_test.go
index c23d7b7c7b..684439d0b0 100644
--- a/src/lib/net/dialgoogle_test.go
+++ b/src/lib/net/dialgoogle_test.go
@@ -22,7 +22,7 @@ func FetchGoogle(t *testing.T, fd net.Conn, network, addr string) {
 	req := io.StringBytes("GET / HTTP/1.0\r\nHost: www.google.com\r\n\r\n");
 	n, errno := fd.Write(req);
 
-	buf := new([1000]byte);
+	buf := new([]byte, 1000);
 	n, errno = io.Readn(fd, buf);
 
 	if n < 1000 {
diff --git a/src/lib/net/dnsclient.go b/src/lib/net/dnsclient.go
index 2e8c638d26..eff46f8b19 100644
--- a/src/lib/net/dnsclient.go
+++ b/src/lib/net/dnsclient.go
@@ -44,7 +44,7 @@ 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 }
@@ -71,7 +71,7 @@ func Exchange(cfg *DNS_Config, c Conn, name string) (m *DNS_Msg, err *os.Error)
 			continue
 		}
 		buf = buf[0:n];
-		in := new(DNS_Msg);
+		in := new(*DNS_Msg);
 		if !in.Unpack(buf) || in.id != out.id {
 			continue
 		}
@@ -80,24 +80,22 @@ func Exchange(cfg *DNS_Config, c Conn, name string) (m *DNS_Msg, err *os.Error)
 	return nil, DNS_NoAnswer
 }
 
-var NIL []string // TODO(rsc)
-
 
 // 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) {
-	addrs = new([]string, len(dns.answer))[0:0];
+	addrs = new([]string, 0, len(dns.answer));
 
 	if dns.rcode == DNS_RcodeNameError && dns.authoritative {
-		return NIL, DNS_NameNotFound	// authoritative "no such host"
+		return nil, DNS_NameNotFound	// authoritative "no such host"
 	}
 	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,
 		// the server is behaving incorrectly.
-		return NIL, DNS_ServerFailure
+		return nil, DNS_ServerFailure
 	}
 
 	// Look for the name.
@@ -126,13 +124,13 @@ Cname:
 			}
 		}
 		if len(addrs) == 0 {
-			return NIL, DNS_NameNotFound
+			return nil, DNS_NameNotFound
 		}
 		return addrs, nil
 	}
 
 	// Too many redirects
-	return NIL, DNS_RedirectLoop
+	return nil, DNS_RedirectLoop
 }
 
 // Do a lookup for a single name, which must be rooted
diff --git a/src/lib/net/dnsconfig.go b/src/lib/net/dnsconfig.go
index 0dff681b6f..5c2b45812a 100644
--- a/src/lib/net/dnsconfig.go
+++ b/src/lib/net/dnsconfig.go
@@ -31,7 +31,7 @@ export func DNS_ReadConfig() *DNS_Config {
 	if file == nil {
 		return nil
 	}
-	conf := new(DNS_Config);
+	conf := new(*DNS_Config);
 	conf.servers = new([]string, 3)[0:0];		// small, but the standard limit
 	conf.search = new([]string, 0);
 	conf.ndots = 1;
diff --git a/src/lib/net/dnsmsg.go b/src/lib/net/dnsmsg.go
index a94d039cee..1c85c935ef 100644
--- a/src/lib/net/dnsmsg.go
+++ b/src/lib/net/dnsmsg.go
@@ -198,18 +198,18 @@ export type DNS_RR_A struct {
 
 // Map of constructors for each RR wire type.
 var rr_mk = map[int]*()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) },
+	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:].
@@ -545,7 +545,6 @@ export type DNS_Msg struct {
 	extra []DNS_RR;
 }
 
-var NIL []byte // TODO(rsc): remove
 
 func (dns *DNS_Msg) Pack() (msg []byte, ok bool) {
 	var dh DNS_Header;
@@ -569,9 +568,11 @@ func (dns *DNS_Msg) Pack() (msg []byte, ok bool) {
 		dh.bits |= QR;
 	}
 
-	// Prepare variable sized arrays; paper over nils.
-	var question []DNS_Question;
-	var answer, ns, extra []DNS_RR;
+	// Prepare variable sized arrays.
+	question := dns.question;
+	answer := dns.answer;
+	ns := dns.ns;
+	extra := dns.extra;
 
 	dh.qdcount = uint16(len(question));
 	dh.ancount = uint16(len(answer));
@@ -599,7 +600,7 @@ func (dns *DNS_Msg) Pack() (msg []byte, ok bool) {
 		off, ok = PackStruct(extra[i], msg, off);
 	}
 	if !ok {
-		return NIL, false
+		return nil, false
 	}
 	return msg[0:off], true
 }
diff --git a/src/lib/net/fd.go b/src/lib/net/fd.go
index 600ac38f65..a9c90c87cc 100644
--- a/src/lib/net/fd.go
+++ b/src/lib/net/fd.go
@@ -19,8 +19,8 @@ export type FD struct {
 	// immutable until Close
 	fd int64;
 	osfd *os.FD;
-	cr *chan *FD;
-	cw *chan *FD;
+	cr chan *FD;
+	cw chan *FD;
 
 	// owned by fd wait server
 	ncr, ncw int;
@@ -70,15 +70,15 @@ func SetNonblock(fd int64) *os.Error {
 // might help batch requests.
 
 type PollServer struct {
-	cr, cw *chan *FD;	// buffered >= 1
+	cr, cw chan *FD;	// buffered >= 1
 	pr, pw *os.FD;
-	pending *map[int64] *FD;
+	pending map[int64] *FD;
 	poll *Pollster;	// low-level OS hooks
 }
 func (s *PollServer) Run();
 
 func NewPollServer() (s *PollServer, err *os.Error) {
-	s = new(PollServer);
+	s = new(*PollServer);
 	s.cr = new(chan *FD, 1);
 	s.cw = new(chan *FD, 1);
 	if s.pr, s.pw, err = os.Pipe(); err != nil {
@@ -214,7 +214,7 @@ export func NewFD(fd int64) (f *FD, err *os.Error) {
 	if err = SetNonblock(fd); err != nil {
 		return nil, err
 	}
-	f = new(FD);
+	f = new(*FD);
 	f.fd = fd;
 	f.osfd = os.NewFD(fd);
 	f.cr = new(chan *FD, 1);
diff --git a/src/lib/net/fd_darwin.go b/src/lib/net/fd_darwin.go
index b0eaf0594e..5a21be58e3 100644
--- a/src/lib/net/fd_darwin.go
+++ b/src/lib/net/fd_darwin.go
@@ -18,10 +18,8 @@ export type Pollster struct {
 	events []syscall.Kevent;
 }
 
-var NIL []syscall.Kevent;  // TODO(rsc): remove
-
 export func NewPollster() (p *Pollster, err *os.Error) {
-	p = new(Pollster);
+	p = new(*Pollster);
 	var e int64;
 	if p.kq, e = syscall.kqueue(); e != 0 {
 		return nil, os.ErrnoToError(e)
@@ -66,7 +64,7 @@ func (p *Pollster) AddFD(fd int64, mode int, repeat bool) *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);
+		nn, e := syscall.kevent(p.kq, nil, p.eventbuf, nil);
 		if e != 0 {
 			if e == syscall.EAGAIN || e == syscall.EINTR {
 				continue
diff --git a/src/lib/net/fd_linux.go b/src/lib/net/fd_linux.go
index 282be20c47..e459dddc4a 100644
--- a/src/lib/net/fd_linux.go
+++ b/src/lib/net/fd_linux.go
@@ -21,11 +21,11 @@ export type Pollster struct {
 	epfd int64;
 
 	// Events we're already waiting for
-	events *map[int64] uint32;
+	events map[int64] uint32;
 }
 
 export func NewPollster() (p *Pollster, err *os.Error) {
-	p = new(Pollster);
+	p = new(*Pollster);
 	var e int64;
 
 	// The arg to epoll_create is a hint to the kernel
@@ -102,9 +102,9 @@ func (p *Pollster) WaitFD() (fd int64, mode int, err *os.Error) {
 	// Get an event.
 	var evarray [1]syscall.EpollEvent;
 	ev := &evarray[0];
-	n, e := syscall.epoll_wait(p.epfd, &evarray, -1);
+	n, e := syscall.epoll_wait(p.epfd, evarray, -1);
 	for e == syscall.EAGAIN || e == syscall.EINTR {
-		n, e = syscall.epoll_wait(p.epfd, &evarray, -1)
+		n, e = syscall.epoll_wait(p.epfd, evarray, -1)
 	}
 	if e != 0 {
 		return -1, 0, os.ErrnoToError(e)
diff --git a/src/lib/net/ip.go b/src/lib/net/ip.go
index 4cf56dc8ae..883a1c63e5 100644
--- a/src/lib/net/ip.go
+++ b/src/lib/net/ip.go
@@ -39,8 +39,6 @@ func MakeIPv4(a, b, c, d byte) []byte {
 // Well-known IP addresses
 export var IPv4bcast, IPv4allsys, IPv4allrouter, IPv4prefix, IPallbits, IPnoaddr []byte
 
-var NIL []byte // TODO(rsc)
-
 func init() {
 	IPv4bcast = MakeIPv4(0xff, 0xff, 0xff, 0xff);
 	IPv4allsys = MakeIPv4(0xe0, 0x00, 0x00, 0x01);
@@ -75,7 +73,7 @@ export func ToIPv4(p []byte) []byte {
 	&& p[11] == 0xff {
 		return p[12:16]
 	}
-	return NIL
+	return nil
 }
 
 // Convert p to IPv6 form.
@@ -86,7 +84,7 @@ export func ToIPv6(p []byte) []byte {
 	if len(p) == IPv6len {
 		return p
 	}
-	return NIL
+	return nil
 }
 
 // Default route masks for IPv4.
@@ -97,8 +95,8 @@ export var (
 )
 
 export func DefaultMask(p []byte) []byte {
-	if p = ToIPv4(p); len(p) == 0 {
-		return NIL
+	if p = ToIPv4(p); p == nil {
+		return nil
 	}
 	switch true {
 	case p[0] < 0x80:
@@ -108,14 +106,14 @@ export func DefaultMask(p []byte) []byte {
 	default:
 		return ClassCMask;
 	}
-	return NIL;	// not reached
+	return nil;	// not reached
 }
 
 // Apply mask to ip, returning new address.
 export func Mask(ip []byte, mask []byte) []byte {
 	n := len(ip);
 	if n != len(mask) {
-		return NIL
+		return nil
 	}
 	out := new([]byte, n);
 	for i := 0; i < n; i++ {
@@ -253,7 +251,7 @@ func ParseIPv4(s string) []byte {
 	for j := 0; j < IPv4len; j++ {
 		if j > 0 {
 			if s[i] != '.' {
-				return NIL
+				return nil
 			}
 			i++;
 		}
@@ -263,12 +261,12 @@ func ParseIPv4(s string) []byte {
 		)
 		n, i, ok = Dtoi(s, i);
 		if !ok || n > 0xFF {
-			return NIL
+			return nil
 		}
 		p[j] = byte(n)
 	}
 	if i != len(s) {
-		return NIL
+		return nil
 	}
 	return MakeIPv4(p[0], p[1], p[2], p[3])
 }
@@ -302,22 +300,22 @@ L:	for j < IPv6len {
 		// Hex number.
 		n, i1, ok := Xtoi(s, i);
 		if !ok || n > 0xFFFF {
-			return NIL
+			return nil
 		}
 
 		// If followed by dot, might be in trailing IPv4.
 		if i1 < len(s) && s[i1] == '.' {
 			if ellipsis < 0 && j != IPv6len - IPv4len {
 				// Not the right place.
-				return NIL
+				return nil
 			}
 			if j+IPv4len > IPv6len {
 				// Not enough room.
-				return NIL
+				return nil
 			}
 			p4 := ParseIPv4(s[i:len(s)]);
-			if len(p4) == 0 {
-				return NIL
+			if p4 == nil {
+				return nil
 			}
 			// BUG: p[j:j+4] = p4
 			p[j] = p4[12];
@@ -342,14 +340,14 @@ L:	for j < IPv6len {
 
 		// Otherwise must be followed by colon and more.
 		if s[i] != ':' && i+1 == len(s) {
-			return NIL
+			return nil
 		}
 		i++;
 
 		// Look for ellipsis.
 		if s[i] == ':' {
 			if ellipsis >= 0 {	// already have one
-				return NIL
+				return nil
 			}
 			ellipsis = j;
 			if i++; i == len(s) {	// can be at end
@@ -360,13 +358,13 @@ L:	for j < IPv6len {
 
 	// Must have used entire string.
 	if i != len(s) {
-		return NIL
+		return nil
 	}
 
 	// If didn't parse enough, expand ellipsis.
 	if j < IPv6len {
 		if ellipsis < 0 {
-			return NIL
+			return nil
 		}
 		n := IPv6len - j;
 		for k := j-1; k >= ellipsis; k-- {
@@ -381,7 +379,7 @@ L:	for j < IPv6len {
 
 export func ParseIP(s string) []byte {
 	p := ParseIPv4(s);
-	if len(p) != 0 {
+	if p != nil {
 		return p
 	}
 	return ParseIPv6(s)
diff --git a/src/lib/net/net.go b/src/lib/net/net.go
index ca5f33733c..2fae03e5af 100644
--- a/src/lib/net/net.go
+++ b/src/lib/net/net.go
@@ -62,8 +62,6 @@ func JoinHostPort(host, port string) string {
 	return host + ":" + port
 }
 
-var NIL []byte
-
 // Convert "host:port" into IP address and port.
 // For now, host and port must be numeric literals.
 // Eventually, we'll have name resolution.
@@ -71,24 +69,24 @@ func HostPortToIP(net string, hostport string) (ip []byte, iport int, err *os.Er
 	var host, port string;
 	host, port, err = SplitHostPort(hostport);
 	if err != nil {
-		return NIL, 0, err
+		return nil, 0, err
 	}
 
 	// Try as an IP address.
 	addr := ParseIP(host);
-	if len(addr) == 0 {
+	if addr == nil {
 		// Not an IP address.  Try as a DNS name.
 		hostname, addrs, err := LookupHost(host);
 		if err != nil {
-			return NIL, 0, err
+			return nil, 0, err
 		}
 		if len(addrs) == 0 {
-			return NIL, 0, UnknownHost
+			return nil, 0, UnknownHost
 		}
 		addr = ParseIP(addrs[0]);
-		if len(addr) == 0 {
+		if addr == nil {
 			// should not happen
-			return NIL, 0, BadAddress
+			return nil, 0, BadAddress
 		}
 	}
 
@@ -96,11 +94,11 @@ func HostPortToIP(net string, hostport string) (ip []byte, iport int, err *os.Er
 	if !ok || i != len(port) {
 		p, ok = LookupPort(net, port);
 		if !ok {
-			return NIL, 0, UnknownPort
+			return nil, 0, UnknownPort
 		}
 	}
 	if p < 0 || p > 0xFFFF {
-		return NIL, 0, BadAddress
+		return nil, 0, BadAddress
 	}
 
 	return addr, p, nil
@@ -311,7 +309,7 @@ func InternetSocket(net, laddr, raddr string, proto int64) (fd *FD, err *os.Erro
 	default:
 		// Otherwise, guess.
 		// If the addresses are IPv4 and we prefer IPv4, use 4; else 6.
-		if PreferIPv4 && len(ToIPv4(lip)) != 0 && len(ToIPv4(rip)) != 0 {
+		if PreferIPv4 && ToIPv4(lip) != nil && ToIPv4(rip) != nil {
 			vers = 4
 		} else {
 			vers = 6
@@ -329,13 +327,13 @@ func InternetSocket(net, laddr, raddr string, proto int64) (fd *FD, err *os.Erro
 	}
 
 	var la, ra *syscall.Sockaddr;
-	if len(lip) != 0 {
+	if lip != nil {
 		la, lerr = cvt(lip, lport);
 		if lerr != nil {
 			return nil, lerr
 		}
 	}
-	if len(rip) != 0 {
+	if rip != nil {
 		ra, rerr = cvt(rip, rport);
 		if rerr != nil {
 			return nil, rerr
@@ -361,7 +359,7 @@ func (c *ConnTCP) SetNoDelay(nodelay bool) *os.Error {
 }
 
 func NewConnTCP(fd *FD, raddr string) *ConnTCP {
-	c := new(ConnTCP);
+	c := new(*ConnTCP);
 	c.fd = fd;
 	c.raddr = raddr;
 	c.SetNoDelay(true);
@@ -389,7 +387,7 @@ export type ConnUDP struct {
 }
 
 func NewConnUDP(fd *FD, raddr string) *ConnUDP {
-	c := new(ConnUDP);
+	c := new(*ConnUDP);
 	c.fd = fd;
 	c.raddr = raddr;
 	return c
@@ -488,7 +486,7 @@ export func ListenTCP(net, laddr string) (l *ListenerTCP, err *os.Error) {
 		syscall.close(fd.fd);
 		return nil, os.ErrnoToError(e1)
 	}
-	l = new(ListenerTCP);
+	l = new(*ListenerTCP);
 	l.fd = fd;
 	return l, nil
 }
diff --git a/src/lib/net/net_darwin.go b/src/lib/net/net_darwin.go
index 2a23decc24..9d143d3499 100644
--- a/src/lib/net/net_darwin.go
+++ b/src/lib/net/net_darwin.go
@@ -13,10 +13,10 @@ import (
 
 export func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
 	p = ToIPv4(p);
-	if len(p) == 0 || port < 0 || port > 0xFFFF {
+	if p == nil || port < 0 || port > 0xFFFF {
 		return nil, os.EINVAL
 	}
-	sa := new(syscall.SockaddrInet4);
+	sa := new(*syscall.SockaddrInet4);
 	sa.len = syscall.SizeofSockaddrInet4;
 	sa.family = syscall.AF_INET;
 	sa.port[0] = byte(port>>8);
@@ -29,10 +29,10 @@ export func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.E
 
 export func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) {
 	p = ToIPv6(p);
-	if len(p) == 0 || port < 0 || port > 0xFFFF {
+	if p == nil || port < 0 || port > 0xFFFF {
 		return nil, os.EINVAL
 	}
-	sa := new(syscall.SockaddrInet6);
+	sa := new(*syscall.SockaddrInet6);
 	sa.len = syscall.SizeofSockaddrInet6;
 	sa.family = syscall.AF_INET6;
 	sa.port[0] = byte(port>>8);
@@ -43,28 +43,27 @@ export func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.E
 	return unsafe.pointer(sa).(*syscall.Sockaddr), nil
 }
 
-var NIL []byte	// TODO(rsc)
 
 export func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Error) {
 	switch sa1.family {
 	case syscall.AF_INET:
 		sa := unsafe.pointer(sa1).(*syscall.SockaddrInet4);
 		a := ToIPv6(sa.addr);
-		if len(a) == 0 {
-			return NIL, 0, os.EINVAL
+		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 := unsafe.pointer(sa1).(*syscall.SockaddrInet6);
 		a := ToIPv6(sa.addr);
-		if len(a) == 0 {
-			return NIL, 0, os.EINVAL
+		if a == nil {
+			return nil, 0, os.EINVAL
 		}
-		return NIL, int(sa.port[0])<<8 + int(sa.port[1]), nil;
+		return nil, int(sa.port[0])<<8 + int(sa.port[1]), nil;
 	default:
-		return NIL, 0, os.EINVAL
+		return nil, 0, os.EINVAL
 	}
-	return NIL, 0, nil	// not reached
+	return nil, 0, nil	// not reached
 }
 
 export func ListenBacklog() int64 {
diff --git a/src/lib/net/net_linux.go b/src/lib/net/net_linux.go
index 3d9dd69fe3..028e6e23b5 100644
--- a/src/lib/net/net_linux.go
+++ b/src/lib/net/net_linux.go
@@ -16,7 +16,7 @@ export func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.E
 	if p == nil || port < 0 || port > 0xFFFF {
 		return nil, os.EINVAL
 	}
-	sa := new(syscall.SockaddrInet4);
+	sa := new(*syscall.SockaddrInet4);
 	sa.family = syscall.AF_INET;
 	sa.port[0] = byte(port>>8);
 	sa.port[1] = byte(port);
@@ -38,10 +38,10 @@ export func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.E
 	// 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;
+		p = IPv6zero;
 	}
 
-	sa := new(syscall.SockaddrInet6);
+	sa := new(*syscall.SockaddrInet6);
 	sa.family = syscall.AF_INET6;
 	sa.port[0] = byte(port>>8);
 	sa.port[1] = byte(port);
@@ -55,14 +55,14 @@ export func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Err
 	switch sa1.family {
 	case syscall.AF_INET:
 		sa := unsafe.pointer(sa1).(*syscall.SockaddrInet4);
-		a := ToIPv6(&sa.addr);
+		a := ToIPv6(sa.addr);
 		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 := unsafe.pointer(sa1).(*syscall.SockaddrInet6);
-		a := ToIPv6(&sa.addr);
+		a := ToIPv6(sa.addr);
 		if a == nil {
 			return nil, 0, os.EINVAL
 		}
diff --git a/src/lib/net/port.go b/src/lib/net/port.go
index 5ff1e5805a..efcbc0ad93 100644
--- a/src/lib/net/port.go
+++ b/src/lib/net/port.go
@@ -14,10 +14,10 @@ import (
 	"strconv";
 )
 
-var services *map[string] *map[string] int
+var services map[string] map[string] int
 
 func ReadServices() {
-	services = new(map[string] *map[string] int);
+	services = new(map[string] map[string] int);
 	file := Open("/etc/services");
 	for line, ok := file.ReadLine(); ok; line, ok = file.ReadLine() {
 		// "http 80/tcp www www-http # World Wide Web HTTP"
diff --git a/src/lib/net/tcpserver_test.go b/src/lib/net/tcpserver_test.go
index 9489c8cf27..0e50369742 100644
--- a/src/lib/net/tcpserver_test.go
+++ b/src/lib/net/tcpserver_test.go
@@ -11,7 +11,7 @@ import (
 	"testing";
 )
 
-func Echo(fd io.ReadWrite, done *chan<- int) {
+func Echo(fd io.ReadWrite, done chan<- int) {
 	var buf [1024]byte;
 
 	for {
@@ -24,7 +24,7 @@ func Echo(fd io.ReadWrite, done *chan<- int) {
 	done <- 1
 }
 
-func Serve(t *testing.T, network, addr string, listening, done *chan<- int) {
+func Serve(t *testing.T, network, addr string, listening, done chan<- int) {
 	l, err := net.Listen(network, addr);
 	if err != nil {
 		t.Fatalf("net.Listen(%q, %q) = _, %v", network, addr, err);
@@ -76,9 +76,9 @@ func DoTest(t *testing.T, network, listenaddr, dialaddr string) {
 }
 
 export func TestTcpServer(t *testing.T) {
-	DoTest(t,  "tcp", "0.0.0.0:9999", "127.0.0.1:9999");
-	DoTest(t, "tcp", "[::]:9999", "[::ffff:127.0.0.1]:9999");
-	DoTest(t, "tcp", "[::]:9999", "127.0.0.1:9999");
-	DoTest(t, "tcp", "0.0.0.0:9999", "[::ffff:127.0.0.1]:9999");
+	DoTest(t,  "tcp", "0.0.0.0:9997", "127.0.0.1:9997");
+	DoTest(t, "tcp", "[::]:9997", "[::ffff:127.0.0.1]:9997");
+	DoTest(t, "tcp", "[::]:9997", "127.0.0.1:9997");
+	DoTest(t, "tcp", "0.0.0.0:9997", "[::ffff:127.0.0.1]:9997");
 }