libgo: Update to weekly.2011-11-18.

From-SVN: r182266

1 files changed, 105 insertions, 99 deletions

diff --git a/libgo/go/net/fd.go b/libgo/go/net/fd.go
index 025075d..70e04a2 100644
--- a/libgo/go/net/fd.go
+++ b/libgo/go/net/fd.go
@@ -278,8 +278,8 @@ func startServer() {
 
 func newFD(fd, family, proto int, net string) (f *netFD, err error) {
 	onceStartServer.Do(startServer)
-	if e := syscall.SetNonblock(fd, true); e != 0 {
-		return nil, os.Errno(e)
+	if e := syscall.SetNonblock(fd, true); e != nil {
+		return nil, e
 	}
 	f = &netFD{
 		sysfd:  fd,
@@ -306,19 +306,19 @@ func (fd *netFD) setAddr(laddr, raddr Addr) {
 }
 
 func (fd *netFD) connect(ra syscall.Sockaddr) (err error) {
-	e := syscall.Connect(fd.sysfd, ra)
-	if e == syscall.EINPROGRESS {
-		var errno int
+	err = syscall.Connect(fd.sysfd, ra)
+	if err == syscall.EINPROGRESS {
 		pollserver.WaitWrite(fd)
-		e, errno = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
-		if errno != 0 {
-			return os.NewSyscallError("getsockopt", errno)
+		var e int
+		e, err = syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
+		if err != nil {
+			return os.NewSyscallError("getsockopt", err)
+		}
+		if e != 0 {
+			err = syscall.Errno(e)
 		}
 	}
-	if e != 0 {
-		return os.Errno(e)
-	}
-	return nil
+	return err
 }
 
 // Add a reference to this fd.
@@ -362,9 +362,9 @@ func (fd *netFD) shutdown(how int) error {
 	if fd == nil || fd.sysfile == nil {
 		return os.EINVAL
 	}
-	errno := syscall.Shutdown(fd.sysfd, how)
-	if errno != 0 {
-		return &OpError{"shutdown", fd.net, fd.laddr, os.Errno(errno)}
+	err := syscall.Shutdown(fd.sysfd, how)
+	if err != nil {
+		return &OpError{"shutdown", fd.net, fd.laddr, err}
 	}
 	return nil
 }
@@ -377,6 +377,14 @@ func (fd *netFD) CloseWrite() error {
 	return fd.shutdown(syscall.SHUT_WR)
 }
 
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
+
+var errTimeout error = &timeoutError{}
+
 func (fd *netFD) Read(p []byte) (n int, err error) {
 	if fd == nil {
 		return 0, os.EINVAL
@@ -393,24 +401,24 @@ func (fd *netFD) Read(p []byte) (n int, err error) {
 	} else {
 		fd.rdeadline = 0
 	}
-	var oserr error
 	for {
-		var errno int
-		n, errno = syscall.Read(fd.sysfile.Fd(), p)
-		if errno == syscall.EAGAIN && fd.rdeadline >= 0 {
-			pollserver.WaitRead(fd)
-			continue
+		n, err = syscall.Read(fd.sysfile.Fd(), p)
+		if err == syscall.EAGAIN {
+			if fd.rdeadline >= 0 {
+				pollserver.WaitRead(fd)
+				continue
+			}
+			err = errTimeout
 		}
-		if errno != 0 {
+		if err != nil {
 			n = 0
-			oserr = os.Errno(errno)
-		} else if n == 0 && errno == 0 && fd.proto != syscall.SOCK_DGRAM {
+		} else if n == 0 && err == nil && fd.proto != syscall.SOCK_DGRAM {
 			err = io.EOF
 		}
 		break
 	}
-	if oserr != nil {
-		err = &OpError{"read", fd.net, fd.raddr, oserr}
+	if err != nil && err != io.EOF {
+		err = &OpError{"read", fd.net, fd.raddr, err}
 	}
 	return
 }
@@ -428,22 +436,22 @@ func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 	} else {
 		fd.rdeadline = 0
 	}
-	var oserr error
 	for {
-		var errno int
-		n, sa, errno = syscall.Recvfrom(fd.sysfd, p, 0)
-		if errno == syscall.EAGAIN && fd.rdeadline >= 0 {
-			pollserver.WaitRead(fd)
-			continue
+		n, sa, err = syscall.Recvfrom(fd.sysfd, p, 0)
+		if err == syscall.EAGAIN {
+			if fd.rdeadline >= 0 {
+				pollserver.WaitRead(fd)
+				continue
+			}
+			err = errTimeout
 		}
-		if errno != 0 {
+		if err != nil {
 			n = 0
-			oserr = os.Errno(errno)
 		}
 		break
 	}
-	if oserr != nil {
-		err = &OpError{"read", fd.net, fd.laddr, oserr}
+	if err != nil {
+		err = &OpError{"read", fd.net, fd.laddr, err}
 	}
 	return
 }
@@ -461,24 +469,22 @@ func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.S
 	} else {
 		fd.rdeadline = 0
 	}
-	var oserr error
 	for {
-		var errno int
-		n, oobn, flags, sa, errno = syscall.Recvmsg(fd.sysfd, p, oob, 0)
-		if errno == syscall.EAGAIN && fd.rdeadline >= 0 {
-			pollserver.WaitRead(fd)
-			continue
-		}
-		if errno != 0 {
-			oserr = os.Errno(errno)
+		n, oobn, flags, sa, err = syscall.Recvmsg(fd.sysfd, p, oob, 0)
+		if err == syscall.EAGAIN {
+			if fd.rdeadline >= 0 {
+				pollserver.WaitRead(fd)
+				continue
+			}
+			err = errTimeout
 		}
-		if n == 0 {
-			oserr = io.EOF
+		if err == nil && n == 0 {
+			err = io.EOF
 		}
 		break
 	}
-	if oserr != nil {
-		err = &OpError{"read", fd.net, fd.laddr, oserr}
+	if err != nil && err != io.EOF {
+		err = &OpError{"read", fd.net, fd.laddr, err}
 		return
 	}
 	return
@@ -501,32 +507,34 @@ func (fd *netFD) Write(p []byte) (n int, err error) {
 		fd.wdeadline = 0
 	}
 	nn := 0
-	var oserr error
 
 	for {
-		n, errno := syscall.Write(fd.sysfile.Fd(), p[nn:])
+		var n int
+		n, err = syscall.Write(fd.sysfile.Fd(), p[nn:])
 		if n > 0 {
 			nn += n
 		}
 		if nn == len(p) {
 			break
 		}
-		if errno == syscall.EAGAIN && fd.wdeadline >= 0 {
-			pollserver.WaitWrite(fd)
-			continue
+		if err == syscall.EAGAIN {
+			if fd.wdeadline >= 0 {
+				pollserver.WaitWrite(fd)
+				continue
+			}
+			err = errTimeout
 		}
-		if errno != 0 {
+		if err != nil {
 			n = 0
-			oserr = os.Errno(errno)
 			break
 		}
 		if n == 0 {
-			oserr = io.ErrUnexpectedEOF
+			err = io.ErrUnexpectedEOF
 			break
 		}
 	}
-	if oserr != nil {
-		err = &OpError{"write", fd.net, fd.raddr, oserr}
+	if err != nil {
+		err = &OpError{"write", fd.net, fd.raddr, err}
 	}
 	return nn, err
 }
@@ -544,22 +552,21 @@ func (fd *netFD) WriteTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
 	} else {
 		fd.wdeadline = 0
 	}
-	var oserr error
 	for {
-		errno := syscall.Sendto(fd.sysfd, p, 0, sa)
-		if errno == syscall.EAGAIN && fd.wdeadline >= 0 {
-			pollserver.WaitWrite(fd)
-			continue
-		}
-		if errno != 0 {
-			oserr = os.Errno(errno)
+		err = syscall.Sendto(fd.sysfd, p, 0, sa)
+		if err == syscall.EAGAIN {
+			if fd.wdeadline >= 0 {
+				pollserver.WaitWrite(fd)
+				continue
+			}
+			err = errTimeout
 		}
 		break
 	}
-	if oserr == nil {
+	if err == nil {
 		n = len(p)
 	} else {
-		err = &OpError{"write", fd.net, fd.raddr, oserr}
+		err = &OpError{"write", fd.net, fd.raddr, err}
 	}
 	return
 }
@@ -577,24 +584,22 @@ func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob
 	} else {
 		fd.wdeadline = 0
 	}
-	var oserr error
 	for {
-		var errno int
-		errno = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0)
-		if errno == syscall.EAGAIN && fd.wdeadline >= 0 {
-			pollserver.WaitWrite(fd)
-			continue
-		}
-		if errno != 0 {
-			oserr = os.Errno(errno)
+		err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0)
+		if err == syscall.EAGAIN {
+			if fd.wdeadline >= 0 {
+				pollserver.WaitWrite(fd)
+				continue
+			}
+			err = errTimeout
 		}
 		break
 	}
-	if oserr == nil {
+	if err == nil {
 		n = len(p)
 		oobn = len(oob)
 	} else {
-		err = &OpError{"write", fd.net, fd.raddr, oserr}
+		err = &OpError{"write", fd.net, fd.raddr, err}
 	}
 	return
 }
@@ -615,25 +620,26 @@ func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err err
 	// See ../syscall/exec.go for description of ForkLock.
 	// It is okay to hold the lock across syscall.Accept
 	// because we have put fd.sysfd into non-blocking mode.
-	syscall.ForkLock.RLock()
-	var s, e int
+	var s int
 	var rsa syscall.Sockaddr
 	for {
 		if fd.closing {
-			syscall.ForkLock.RUnlock()
 			return nil, os.EINVAL
 		}
-		s, rsa, e = syscall.Accept(fd.sysfd)
-		if e != syscall.EAGAIN || fd.rdeadline < 0 {
-			break
-		}
-		syscall.ForkLock.RUnlock()
-		pollserver.WaitRead(fd)
 		syscall.ForkLock.RLock()
-	}
-	if e != 0 {
-		syscall.ForkLock.RUnlock()
-		return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)}
+		s, rsa, err = syscall.Accept(fd.sysfd)
+		if err != nil {
+			syscall.ForkLock.RUnlock()
+			if err == syscall.EAGAIN {
+				if fd.rdeadline >= 0 {
+					pollserver.WaitRead(fd)
+					continue
+				}
+				err = errTimeout
+			}
+			return nil, &OpError{"accept", fd.net, fd.laddr, err}
+		}
+		break
 	}
 	syscall.CloseOnExec(s)
 	syscall.ForkLock.RUnlock()
@@ -648,19 +654,19 @@ func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err err
 }
 
 func (fd *netFD) dup() (f *os.File, err error) {
-	ns, e := syscall.Dup(fd.sysfd)
-	if e != 0 {
-		return nil, &OpError{"dup", fd.net, fd.laddr, os.Errno(e)}
+	ns, err := syscall.Dup(fd.sysfd)
+	if err != nil {
+		return nil, &OpError{"dup", fd.net, fd.laddr, err}
 	}
 
 	// We want blocking mode for the new fd, hence the double negative.
-	if e = syscall.SetNonblock(ns, false); e != 0 {
-		return nil, &OpError{"setnonblock", fd.net, fd.laddr, os.Errno(e)}
+	if err = syscall.SetNonblock(ns, false); err != nil {
+		return nil, &OpError{"setnonblock", fd.net, fd.laddr, err}
 	}
 
 	return os.NewFile(ns, fd.sysfile.Name()), nil
 }
 
-func closesocket(s int) (errno int) {
+func closesocket(s int) error {
 	return syscall.Close(s)
 }