Change os.Error convention:
echo back context of call in error if likely to be useful.
For example, if os.Open("/etc/passwd", os.O_RDONLY)
fails with syscall.EPERM, it returns as the os.Error
&PathError{
Op: "open",
Path: "/etc/passwd"
Error: os.EPERM
}
which formats as
open /etc/passwd: permission denied
Not converted:
datafmt
go/...
google/...
regexp
tabwriter
template
R=r
DELTA=1153 (561 added, 156 deleted, 436 changed)
OCL=30738
CL=30781
diff --git a/doc/progs/file.go b/doc/progs/file.go
index ff796c5..bda3890 100644
--- a/doc/progs/file.go
+++ b/doc/progs/file.go
@@ -29,7 +29,10 @@
func Open(name string, mode int, perm int) (file *File, err os.Error) {
r, e := syscall.Open(name, mode, perm);
- return newFile(r, name), os.ErrnoToError(e)
+ if e != 0 {
+ err = os.Errno(e);
+ }
+ return newFile(r, name), err
}
func (file *File) Close() os.Error {
@@ -38,7 +41,10 @@
}
e := syscall.Close(file.fd);
file.fd = -1; // so it can't be closed again
- return os.ErrnoToError(e);
+ if e != 0 {
+ return os.Errno(e);
+ }
+ return nil
}
func (file *File) Read(b []byte) (ret int, err os.Error) {
@@ -46,7 +52,10 @@
return -1, os.EINVAL
}
r, e := syscall.Read(file.fd, b);
- return int(r), os.ErrnoToError(e)
+ if e != 0 {
+ err = os.Errno(e);
+ }
+ return int(r), err
}
func (file *File) Write(b []byte) (ret int, err os.Error) {
@@ -54,7 +63,10 @@
return -1, os.EINVAL
}
r, e := syscall.Write(file.fd, b);
- return int(r), os.ErrnoToError(e)
+ if e != 0 {
+ err = os.Errno(e);
+ }
+ return int(r), err
}
func (file *File) String() string {
diff --git a/src/cmd/gobuild/util.go b/src/cmd/gobuild/util.go
index 7fec135..4bcf97a 100644
--- a/src/cmd/gobuild/util.go
+++ b/src/cmd/gobuild/util.go
@@ -290,8 +290,8 @@
if err != nil {
fatal("run /bin/rm: %v", err);
}
- w, err1 := p.Wait(0);
- if err1 != nil {
+ w, err := p.Wait(0);
+ if err != nil {
fatal("wait /bin/rm: %v", err);
}
if !w.Exited() || w.ExitStatus() != 0 {
diff --git a/src/pkg/Make.deps b/src/pkg/Make.deps
index 9df9db4..6a5a0c4 100644
--- a/src/pkg/Make.deps
+++ b/src/pkg/Make.deps
@@ -1,14 +1,14 @@
archive/tar.install: bufio.install bytes.install io.install os.install strconv.install
base64.install: bytes.install io.install os.install strconv.install
bignum.install: fmt.install
-bufio.install: io.install os.install utf8.install
+bufio.install: io.install os.install strconv.install utf8.install
bytes.install: utf8.install
compress/flate.install: bufio.install io.install os.install strconv.install
compress/gzip.install: bufio.install compress/flate.install hash.install hash/crc32.install io.install os.install
container/list.install:
container/vector.install:
-crypto/aes.install: os.install
-crypto/block.install: fmt.install io.install os.install
+crypto/aes.install: os.install strconv.install
+crypto/block.install: fmt.install io.install os.install strconv.install
crypto/hmac.install: crypto/md5.install crypto/sha1.install hash.install os.install
crypto/md5.install: hash.install os.install
crypto/sha1.install: hash.install os.install
@@ -26,7 +26,7 @@
hash.install: io.install
hash/adler32.install: hash.install os.install
hash/crc32.install: hash.install os.install
-http.install: bufio.install container/vector.install fmt.install io.install log.install net.install os.install path.install strconv.install strings.install utf8.install
+http.install: bufio.install bytes.install container/vector.install fmt.install io.install log.install net.install os.install path.install strconv.install strings.install utf8.install
io.install: bytes.install os.install sync.install
json.install: container/vector.install fmt.install io.install math.install reflect.install strconv.install strings.install utf8.install
log.install: fmt.install io.install os.install runtime.install time.install
diff --git a/src/pkg/bufio/bufio.go b/src/pkg/bufio/bufio.go
index 520fd3a..4cbebdd 100644
--- a/src/pkg/bufio/bufio.go
+++ b/src/pkg/bufio/bufio.go
@@ -10,6 +10,7 @@
import (
"io";
"os";
+ "strconv";
"utf8";
)
@@ -30,12 +31,17 @@
}
var (
- PhaseError os.Error = &Error{"bufio: phase error"};
- BufferFull os.Error = &Error{"bufio: buffer full"};
- InternalError os.Error = &Error{"bufio: internal error"};
- BadBufSize os.Error = &Error{"bufio: bad buffer size"};
+ ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"};
+ ErrBufferFull os.Error = &Error{"bufio: buffer full"};
+ errInternal os.Error = &Error{"bufio: internal error"};
)
+// BufSizeError is the error representing an invalid buffer size.
+type BufSizeError int
+func (b BufSizeError) String() string {
+ return "bufio: bad buffer size " + strconv.Itoa(int(b));
+}
+
func copySlice(dst []byte, src []byte) {
for i := 0; i < len(dst); i++ {
dst[i] = src[i]
@@ -60,7 +66,7 @@
// It returns the Reader and any error.
func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
if size <= 0 {
- return nil, BadBufSize
+ return nil, BufSizeError(size)
}
// Is it already a Reader?
b, ok := rd.(*Reader);
@@ -165,7 +171,7 @@
return c, nil
}
-// UnreadByte unreads the last byte. Only one byte may be unread at a given time.
+// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
func (b *Reader) UnreadByte() os.Error {
if b.err != nil {
return b.err
@@ -178,7 +184,7 @@
return nil;
}
if b.r <= 0 {
- return PhaseError
+ return ErrInvalidUnreadByte
}
b.r--;
b.lastbyte = -1;
@@ -261,7 +267,7 @@
// Buffer is full?
if b.Buffered() >= len(b.buf) {
- return nil, BufferFull
+ return nil, ErrBufferFull
}
}
@@ -292,7 +298,7 @@
if e == nil { // got final fragment
break
}
- if e != BufferFull { // unexpected error
+ if e != ErrBufferFull { // unexpected error
err = e;
break
}
@@ -308,7 +314,7 @@
}
if n != len(buf) {
frag = buf[0:n];
- err = InternalError;
+ err = errInternal;
break
}
@@ -378,7 +384,7 @@
// It returns the Writer and any error.
func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
if size <= 0 {
- return nil, BadBufSize
+ return nil, BufSizeError(size)
}
// Is it already a Writer?
b, ok := wr.(*Writer);
diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go
index 1e81aff..31289c8 100644
--- a/src/pkg/compress/flate/inflate.go
+++ b/src/pkg/compress/flate/inflate.go
@@ -61,7 +61,7 @@
// A CorruptInputError reports the presence of corrupt input at a given offset.
type CorruptInputError int64
func (e CorruptInputError) String() string {
- return "flate: corrupt input at offset " + strconv.Itoa64(int64(e));
+ return "flate: corrupt input before offset " + strconv.Itoa64(int64(e));
}
// An InternalError reports an error in the flate code itself.
@@ -263,11 +263,6 @@
buf [4]byte;
}
-// TODO(rsc): This works around a 6g bug.
-func (f *inflater) getRoffset() int64 {
- return f.roffset;
-}
-
func (f *inflater) dataBlock() os.Error
func (f *inflater) readHuffman() os.Error
func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error
@@ -301,10 +296,7 @@
}
default:
// 3 is reserved.
- // TODO(rsc): Works around the same 6g bug.
- var i int64 = f.getRoffset();
- i--;
- err = CorruptInputError(i);
+ err = CorruptInputError(f.roffset);
}
}
return;
@@ -347,7 +339,7 @@
f.codebits[codeOrder[i]] = 0;
}
if !f.h1.init(&f.codebits) {
- return os.ErrorString("huff and puff");
+ return CorruptInputError(f.roffset);
}
// HLIT + 257 code lengths, HDIST + 1 code lengths,
@@ -374,7 +366,7 @@
rep = 3;
nb = 2;
if i == 0 {
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
}
b = f.bits[i-1];
case 17:
@@ -395,7 +387,7 @@
f.b >>= nb;
f.nb -= nb;
if i+rep > n {
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
}
for j := 0; j < rep; j++ {
f.bits[i] = b;
@@ -404,7 +396,7 @@
}
if !f.h1.init(f.bits[0:nlit]) || !f.h2.init(f.bits[nlit:nlit+ndist]) {
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
}
return nil;
@@ -488,7 +480,7 @@
case dist < 4:
dist++;
case dist >= 30:
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
default:
nb := uint(dist - 2) >> 1;
// have 1 bit in bottom of dist, need nb more.
@@ -511,7 +503,7 @@
// No check on length; encoding can be prescient.
if !f.hfull && dist > f.hp {
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
}
p := f.hp - dist;
@@ -551,7 +543,7 @@
n := int(f.buf[0]) | int(f.buf[1])<<8;
nn := int(f.buf[2]) | int(f.buf[3])<<8;
if nn != ^n {
- return CorruptInputError(f.getRoffset());
+ return CorruptInputError(f.roffset);
}
// Read len bytes into history,
@@ -580,6 +572,9 @@
func (f *inflater) moreBits() os.Error {
c, err := f.r.ReadByte();
if err != nil {
+ if err == os.EOF {
+ err = io.ErrUnexpectedEOF;
+ }
return err;
}
f.roffset++;
@@ -609,7 +604,7 @@
return h.codes[v - h.base[n]], nil;
}
}
- return 0, CorruptInputError(f.getRoffset());
+ return 0, CorruptInputError(f.roffset);
}
// Flush any buffered output to the underlying writer.
diff --git a/src/pkg/crypto/aes/cipher.go b/src/pkg/crypto/aes/cipher.go
index fd8e43e..e430c9e 100644
--- a/src/pkg/crypto/aes/cipher.go
+++ b/src/pkg/crypto/aes/cipher.go
@@ -7,6 +7,7 @@
import (
"crypto/aes";
"os";
+ "strconv";
)
// The AES block size in bytes.
@@ -18,19 +19,25 @@
dec []uint32;
}
+type KeySizeError int
+func (k KeySizeError) String() string {
+ return "crypto/aes: invalid key size " + strconv.Itoa(int(k));
+}
+
// NewCipher creates and returns a new Cipher.
// The key argument should be the AES key,
// either 16, 24, or 32 bytes to select
// AES-128, AES-192, or AES-256.
func NewCipher(key []byte) (*Cipher, os.Error) {
- switch len(key) {
+ k := len(key);
+ switch k {
default:
- return nil, os.ErrorString("crypto/aes: invalid key size");
+ return nil, KeySizeError(k);
case 16, 24, 32:
break;
}
- n := len(key) + 28;
+ n := k + 28;
c := &Cipher{make([]uint32, n), make([]uint32, n)};
expandKey(key, c.enc, c.dec);
return c, nil;
diff --git a/src/pkg/crypto/block/ecb.go b/src/pkg/crypto/block/ecb.go
index d1f1dee..134ac6d 100644
--- a/src/pkg/crypto/block/ecb.go
+++ b/src/pkg/crypto/block/ecb.go
@@ -17,6 +17,7 @@
"crypto/block";
"io";
"os";
+ "strconv";
)
type ecbDecrypter struct {
@@ -73,6 +74,11 @@
return n;
}
+type ecbFragmentError int
+func (n ecbFragmentError) String() string {
+ return "crypto/block: " + strconv.Itoa(int(n)) + "-byte fragment at EOF";
+}
+
func (x *ecbDecrypter) Read(p []byte) (n int, err os.Error) {
if len(p) == 0 {
return;
diff --git a/src/pkg/exec/exec.go b/src/pkg/exec/exec.go
index ebb40a2..7ddb98b 100644
--- a/src/pkg/exec/exec.go
+++ b/src/pkg/exec/exec.go
@@ -140,8 +140,8 @@
// other options cause Wait to return for other
// process events; see package os for details.
func (p *Cmd) Wait(options int) (*os.Waitmsg, os.Error) {
- if p.Pid < 0 {
- return nil, os.EINVAL;
+ if p.Pid <= 0 {
+ return nil, os.ErrorString("exec: invalid use of Cmd.Wait");
}
w, err := os.Wait(p.Pid, options);
if w != nil && (w.Exited() || w.Signaled()) {
@@ -154,7 +154,7 @@
// if it hasn't already, and then closes the non-nil file descriptors
// p.Stdin, p.Stdout, and p.Stderr.
func (p *Cmd) Close() os.Error {
- if p.Pid >= 0 {
+ if p.Pid > 0 {
// Loop on interrupt, but
// ignore other errors -- maybe
// caller has already waited for pid.
diff --git a/src/pkg/http/client.go b/src/pkg/http/client.go
index 8c17eb8..14131ec 100644
--- a/src/pkg/http/client.go
+++ b/src/pkg/http/client.go
@@ -78,7 +78,7 @@
// connections, it may no longer make sense to have a method with this signature.
func send(req *Request) (resp *Response, err os.Error) {
if req.Url.Scheme != "http" {
- return nil, os.ErrorString("Unsupported protocol: " + req.Url.Scheme);
+ return nil, &badStringError{"unsupported protocol scheme", req.Url.Scheme};
}
addr := req.Url.Host;
@@ -87,7 +87,7 @@
}
conn, err := net.Dial("tcp", "", addr);
if err != nil {
- return nil, os.ErrorString("Error dialing " + addr + ": " + err.String());
+ return nil, err;
}
// Close the connection if we encounter an error during header parsing. We'll
@@ -110,12 +110,12 @@
}
f := strings.Split(line, " ", 3);
if len(f) < 3 {
- return nil, os.ErrorString(fmt.Sprintf("Invalid first line in HTTP response: %q", line));
+ return nil, &badStringError{"malformed HTTP response", line};
}
resp.Status = f[1] + " " + f[2];
resp.StatusCode, err = strconv.Atoi(f[1]);
if err != nil {
- return nil, os.ErrorString(fmt.Sprintf("Invalid status code in HTTP response: %q", line));
+ return nil, &badStringError{"malformed HTTP status code", f[1]};
}
// Parse the response headers.
@@ -165,34 +165,36 @@
// URL unless redirects were followed.
//
// Caller should close r.Body when done reading it.
-func Get(url string) (r *Response, finalUrl string, err os.Error) {
+func Get(url string) (r *Response, finalURL string, err os.Error) {
// TODO: if/when we add cookie support, the redirected request shouldn't
// necessarily supply the same cookies as the original.
- // TODO: adjust referrer header on redirects.
- for redirectCount := 0; redirectCount < 10; redirectCount++ {
+ // TODO: set referrer header on redirects.
+ for redirect := 0;; redirect++ {
+ if redirect >= 10 {
+ err = os.ErrorString("stopped after 10 redirects");
+ break;
+ }
+
var req Request;
- req.Url, err = ParseURL(url);
- if err != nil {
- return nil, url, err;
+ if req.Url, err = ParseURL(url); err != nil {
+ break;
}
-
- r, err := send(&req);
- if err != nil {
- return nil, url, err;
+ if r, err = send(&req); err != nil {
+ break;
}
-
- if !shouldRedirect(r.StatusCode) {
- return r, url, nil;
+ if shouldRedirect(r.StatusCode) {
+ r.Body.Close();
+ if url = r.GetHeader("Location"); url == "" {
+ err = os.ErrorString(fmt.Sprintf("%d response missing Location header", r.StatusCode));
+ break;
+ }
}
-
- r.Body.Close();
- url := r.GetHeader("Location");
- if url == "" {
- return r, url, os.ErrorString("302 result with no Location header");
- }
+ finalURL = url;
+ return;
}
- return nil, url, os.ErrorString("Too many redirects");
+ err = &URLError{"Get", url, err};
+ return;
}
diff --git a/src/pkg/http/client_test.go b/src/pkg/http/client_test.go
index 919e556..f697fb8 100644
--- a/src/pkg/http/client_test.go
+++ b/src/pkg/http/client_test.go
@@ -24,9 +24,8 @@
b, err = io.ReadAll(r.Body);
r.Body.Close();
}
-
if err != nil {
- t.Errorf("Error fetching URL: %v", err);
+ t.Error(err);
} else if s := string(b); !strings.HasPrefix(s, "User-agent:") {
t.Errorf("Incorrect page body (did not begin with User-agent): %q", s);
}
diff --git a/src/pkg/http/request.go b/src/pkg/http/request.go
index 9051d4c..86b37d4 100644
--- a/src/pkg/http/request.go
+++ b/src/pkg/http/request.go
@@ -11,6 +11,7 @@
import (
"bufio";
+ "bytes";
"container/vector";
"fmt";
"http";
@@ -32,19 +33,20 @@
os.ErrorString
}
var (
- LineTooLong = &ProtocolError{"http header line too long"};
- ValueTooLong = &ProtocolError{"http header value too long"};
- HeaderTooLong = &ProtocolError{"http header too long"};
- BadContentLength = &ProtocolError{"invalid content length"};
- ShortEntityBody = &ProtocolError{"entity body too short"};
- NoEntityBody = &ProtocolError{"no entity body"};
- BadHeader = &ProtocolError{"malformed http header"};
- BadRequest = &ProtocolError{"invalid http request"};
- BadHTTPVersion = &ProtocolError{"unsupported http version"};
- UnknownContentType = &ProtocolError{"unknown content type"};
- BadChunkedEncoding = &ProtocolError{"bad chunked encoding"};
+ ErrLineTooLong = &ProtocolError{"header line too long"};
+ ErrHeaderTooLong = &ProtocolError{"header too long"};
+ ErrShortBody = &ProtocolError{"entity body too short"};
)
+type badStringError struct {
+ what string;
+ str string;
+}
+
+func (e *badStringError) String() string {
+ return fmt.Sprintf("%s %q", e.what, e.str);
+}
+
// A Request represents a parsed HTTP request header.
type Request struct {
Method string; // GET, POST, PUT, etc.
@@ -204,10 +206,15 @@
// the bufio, so they are only valid until the next bufio read.
func readLineBytes(b *bufio.Reader) (p []byte, err os.Error) {
if p, err = b.ReadLineSlice('\n'); err != nil {
+ // We always know when EOF is coming.
+ // If the caller asked for a line, there should be a line.
+ if err == os.EOF {
+ err = io.ErrUnexpectedEOF;
+ }
return nil, err
}
if len(p) >= maxLineLength {
- return nil, LineTooLong
+ return nil, ErrLineTooLong
}
// Chop off trailing white space.
@@ -229,6 +236,8 @@
return string(p), nil
}
+var colon = []byte{':'}
+
// Read a key/value pair from b.
// A key/value has the form Key: Value\r\n
// and the Value can continue on multiple lines if each continuation line
@@ -243,58 +252,60 @@
}
// Scan first line for colon.
- for i := 0; i < len(line); i++ {
- switch line[i] {
- case ' ':
- // Key field has space - no good.
- return "", "", BadHeader;
- case ':':
- key = string(line[0:i]);
- // Skip initial space before value.
- for i++; i < len(line); i++ {
- if line[i] != ' ' {
- break
- }
- }
- value = string(line[i:len(line)]);
-
- // Look for extension lines, which must begin with space.
- for {
- var c byte;
-
- if c, e = b.ReadByte(); e != nil {
- return "", "", e
- }
- if c != ' ' {
- // Not leading space; stop.
- b.UnreadByte();
- break
- }
-
- // Eat leading space.
- for c == ' ' {
- if c, e = b.ReadByte(); e != nil {
- return "", "", e
- }
- }
- b.UnreadByte();
-
- // Read the rest of the line and add to value.
- if line, e = readLineBytes(b); e != nil {
- return "", "", e
- }
- value += " " + string(line);
-
- if len(value) >= maxValueLength {
- return "", "", ValueTooLong
- }
- }
- return key, value, nil
- }
+ i := bytes.Index(line, colon);
+ if i < 0 {
+ goto Malformed;
}
- // Line ended before space or colon.
- return "", "", BadHeader;
+ key = string(line[0:i]);
+ if strings.Index(key, " ") >= 0 {
+ // Key field has space - no good.
+ goto Malformed;
+ }
+
+ // Skip initial space before value.
+ for i++; i < len(line); i++ {
+ if line[i] != ' ' {
+ break
+ }
+ }
+ value = string(line[i:len(line)]);
+
+ // Look for extension lines, which must begin with space.
+ for {
+ c, e := b.ReadByte();
+ if c != ' ' {
+ if e != os.EOF {
+ b.UnreadByte();
+ }
+ break;
+ }
+
+ // Eat leading space.
+ for c == ' ' {
+ if c, e = b.ReadByte(); e != nil {
+ if e == os.EOF {
+ e = io.ErrUnexpectedEOF;
+ }
+ return "", "", e
+ }
+ }
+ b.UnreadByte();
+
+ // Read the rest of the line and add to value.
+ if line, e = readLineBytes(b); e != nil {
+ return "", "", e
+ }
+ value += " " + string(line);
+
+ if len(value) >= maxValueLength {
+ return "", "", &badStringError{"value too long for key", key};
+ }
+ }
+ return key, value, nil;
+
+Malformed:
+ return "", "", &badStringError{"malformed header line", string(line)};
}
// Convert decimal at s[i:len(s)] to integer,
@@ -424,7 +435,7 @@
var nb int;
if nb, cr.err = io.ReadFull(cr.r, b); cr.err == nil {
if b[0] != '\r' || b[1] != '\n' {
- cr.err = BadChunkedEncoding;
+ cr.err = os.NewError("malformed chunked encoding");
}
}
}
@@ -443,12 +454,12 @@
var f []string;
if f = strings.Split(s, " ", 3); len(f) < 3 {
- return nil, BadRequest
+ return nil, &badStringError{"malformed HTTP request", s};
}
req.Method, req.RawUrl, req.Proto = f[0], f[1], f[2];
var ok bool;
if req.ProtoMajor, req.ProtoMinor, ok = parseHTTPVersion(req.Proto); !ok {
- return nil, BadHTTPVersion
+ return nil, &badStringError{"malformed HTTP version", req.Proto};
}
if req.Url, err = ParseURL(req.RawUrl); err != nil {
@@ -467,7 +478,7 @@
break
}
if nheader++; nheader >= maxHeaderLines {
- return nil, HeaderTooLong
+ return nil, ErrHeaderTooLong
}
key = CanonicalHeaderKey(key);
@@ -556,13 +567,13 @@
} else if v, present := req.Header["Content-Length"]; present {
length, err := strconv.Btoui64(v, 10);
if err != nil {
- return nil, BadContentLength
+ return nil, &badStringError{"invalid Content-Length", v};
}
// TODO: limit the Content-Length. This is an easy DoS vector.
raw := make([]byte, length);
n, err := b.Read(raw);
if err != nil || uint64(n) < length {
- return nil, ShortEntityBody
+ return nil, ErrShortBody
}
req.Body = io.NewByteReader(raw);
}
@@ -599,7 +610,7 @@
// TODO(dsymonds): Parse r.Url.RawQuery instead for GET requests.
func (r *Request) ParseForm() (err os.Error) {
if r.Body == nil {
- return NoEntityBody
+ return os.ErrorString("missing form body");
}
ct, ok := r.Header["Content-Type"];
if !ok {
@@ -613,5 +624,5 @@
return err
// TODO(dsymonds): Handle multipart/form-data
}
- return UnknownContentType
+ return &badStringError{"unknown Content-Type", ct};
}
diff --git a/src/pkg/http/url.go b/src/pkg/http/url.go
index 156f3ad..87612a9 100644
--- a/src/pkg/http/url.go
+++ b/src/pkg/http/url.go
@@ -9,12 +9,19 @@
import (
"os";
- "strings"
+ "strconv";
+ "strings";
)
-// Errors introduced by ParseURL.
-type BadURL struct {
- os.ErrorString
+// URLError reports an error and the operation and URL that caused it.
+type URLError struct {
+ Op string;
+ URL string;
+ Error os.Error;
+}
+
+func (e *URLError) String() string {
+ return e.Op + " " + e.URL + ": " + e.Error.String();
}
func ishex(c byte) bool {
@@ -41,6 +48,11 @@
return 0
}
+type URLEscapeError string
+func (e URLEscapeError) String() string {
+ return "invalid URL escape " + strconv.Quote(string(e));
+}
+
// Return true if the specified character should be escaped when appearing in a
// URL string.
//
@@ -56,7 +68,7 @@
// URLUnescape unescapes a URL-encoded string,
// converting %AB into the byte 0xAB and '+' into ' ' (space).
-// It returns a BadURL error if any % is not followed
+// It returns an error if any % is not followed
// by two hexadecimal digits.
func URLUnescape(s string) (string, os.Error) {
// Count %, check that they're well-formed.
@@ -67,7 +79,11 @@
case '%':
n++;
if i+2 >= len(s) || !ishex(s[i+1]) || !ishex(s[i+2]) {
- return "", BadURL{"invalid hexadecimal escape"}
+ s = s[i:len(s)];
+ if len(s) > 3 {
+ s = s[0:3];
+ }
+ return "", URLEscapeError(s);
}
i += 3;
case '+':
@@ -124,18 +140,18 @@
t := make([]byte, len(s)+2*hexCount);
j := 0;
for i := 0; i < len(s); i++ {
- c := s[i];
- if !shouldEscape(c) {
- t[j] = s[i];
- j++;
- } else if c == ' ' {
+ switch c := s[i]; {
+ case c == ' ':
t[j] = '+';
j++;
- } else {
+ case shouldEscape(c):
t[j] = '%';
t[j+1] = "0123456789abcdef"[c>>4];
t[j+2] = "0123456789abcdef"[c&15];
j += 3;
+ default:
+ t[j] = s[i];
+ j++;
}
}
return string(t);
@@ -177,7 +193,7 @@
}
case c == ':':
if i == 0 {
- return "", "", BadURL{"missing protocol scheme"}
+ return "", "", os.ErrorString("missing protocol scheme")
}
return rawurl[0:i], rawurl[i+1:len(rawurl)], nil
default:
@@ -204,15 +220,21 @@
return s, ""
}
+// TODO(rsc): The BUG comment is supposed to appear in the godoc output
+// in a BUGS section, but that got lost in the transition to godoc.
+
// BUG(rsc): ParseURL should canonicalize the path,
// removing unnecessary . and .. elements.
+
+
// ParseURL parses rawurl into a URL structure.
// The string rawurl is assumed not to have a #fragment suffix.
// (Web browsers strip #fragment before sending the URL to a web server.)
func ParseURL(rawurl string) (url *URL, err os.Error) {
if rawurl == "" {
- return nil, BadURL{"empty url"}
+ err = os.ErrorString("empty url");
+ goto Error;
}
url = new(URL);
url.Raw = rawurl;
@@ -220,7 +242,7 @@
// split off possible leading "http:", "mailto:", etc.
var path string;
if url.Scheme, path, err = getscheme(rawurl); err != nil {
- return nil, err
+ goto Error;
}
url.RawPath = path;
@@ -245,25 +267,31 @@
// What's left is the path.
// TODO: Canonicalize (remove . and ..)?
if url.Path, err = URLUnescape(path); err != nil {
- return nil, err
+ goto Error;
}
// Remove escapes from the Authority and Userinfo fields, and verify
// that Scheme and Host contain no escapes (that would be illegal).
if url.Authority, err = URLUnescape(url.Authority); err != nil {
- return nil, err
+ goto Error;
}
if url.Userinfo, err = URLUnescape(url.Userinfo); err != nil {
- return nil, err
+ goto Error;
}
if strings.Index(url.Scheme, "%") >= 0 {
- return nil, BadURL{"hexadecimal escape in scheme"}
+ err = os.ErrorString("hexadecimal escape in scheme");
+ goto Error;
}
if strings.Index(url.Host, "%") >= 0 {
- return nil, BadURL{"hexadecimal escape in host"}
+ err = os.ErrorString("hexadecimal escape in host");
+ goto Error;
}
- return url, nil
+ return url, nil;
+
+Error:
+ return nil, &URLError{"parse", rawurl, err}
+
}
// ParseURLReference is like ParseURL but allows a trailing #fragment.
@@ -274,7 +302,7 @@
return nil, err
}
if url.Fragment, err = URLUnescape(frag); err != nil {
- return nil, err
+ return nil, &URLError{"parse", rawurl, err}
}
return url, nil
}
diff --git a/src/pkg/http/url_test.go b/src/pkg/http/url_test.go
index ea05ed3..51d0283 100644
--- a/src/pkg/http/url_test.go
+++ b/src/pkg/http/url_test.go
@@ -281,27 +281,27 @@
URLEscapeTest{
"%", // not enough characters after %
"",
- BadURL{"invalid hexadecimal escape"}
+ URLEscapeError("%"),
},
URLEscapeTest{
"%a", // not enough characters after %
"",
- BadURL{"invalid hexadecimal escape"}
+ URLEscapeError("%a"),
},
URLEscapeTest{
"%1", // not enough characters after %
"",
- BadURL{"invalid hexadecimal escape"}
+ URLEscapeError("%1"),
},
URLEscapeTest{
"123%45%6", // not enough characters after %
"",
- BadURL{"invalid hexadecimal escape"}
+ URLEscapeError("%6"),
},
URLEscapeTest{
- "%zz", // invalid hex digits
+ "%zzzzz", // invalid hex digits
"",
- BadURL{"invalid hexadecimal escape"}
+ URLEscapeError("%zz"),
},
}
diff --git a/src/pkg/io/bytebuffer.go b/src/pkg/io/bytebuffer.go
index 2c35619..6971c0e 100644
--- a/src/pkg/io/bytebuffer.go
+++ b/src/pkg/io/bytebuffer.go
@@ -113,7 +113,7 @@
if b.off >= len(b.buf) {
return 0, os.EOF;
}
- c = b.buf[b.off];
+ c = b.buf[b.off];
b.off++;
return c, nil;
}
diff --git a/src/pkg/net/Makefile b/src/pkg/net/Makefile
index 61c8720..7705619 100644
--- a/src/pkg/net/Makefile
+++ b/src/pkg/net/Makefile
@@ -2,6 +2,7 @@
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
+
# DO NOT EDIT. Automatically generated by gobuild.
# gobuild -m dnsclient.go dnsconfig.go dnsmsg.go fd.go fd_${GOOS}.go ip.go net.go parse.go port.go >Makefile
@@ -20,7 +21,7 @@
coverage: packages
gotest
- 6cov -g `pwd` | grep -v '_test\.go:'
+ 6cov -g $$(pwd) | grep -v '_test\.go:'
%.$O: %.go
$(GC) -I_obj $*.go
@@ -32,48 +33,42 @@
$(AS) $*.s
O1=\
- dnsmsg.$O\
+ fd_$(GOOS).$O\
parse.$O\
O2=\
- fd_$(GOOS).$O\
+ fd.$O\
ip.$O\
- port.$O\
O3=\
dnsconfig.$O\
- fd.$O\
-
-O4=\
+ dnsmsg.$O\
net.$O\
-O5=\
+O4=\
dnsclient.$O\
+ port.$O\
-phases: a1 a2 a3 a4 a5
+phases: a1 a2 a3 a4
_obj$D/net.a: phases
a1: $(O1)
- $(AR) grc _obj$D/net.a dnsmsg.$O parse.$O
+ $(AR) grc _obj$D/net.a fd_$(GOOS).$O parse.$O
rm -f $(O1)
a2: $(O2)
- $(AR) grc _obj$D/net.a fd_$(GOOS).$O ip.$O port.$O
+ $(AR) grc _obj$D/net.a fd.$O ip.$O
rm -f $(O2)
a3: $(O3)
- $(AR) grc _obj$D/net.a dnsconfig.$O fd.$O
+ $(AR) grc _obj$D/net.a dnsconfig.$O dnsmsg.$O net.$O
rm -f $(O3)
a4: $(O4)
- $(AR) grc _obj$D/net.a net.$O
+ $(AR) grc _obj$D/net.a dnsclient.$O port.$O
rm -f $(O4)
-a5: $(O5)
- $(AR) grc _obj$D/net.a dnsclient.$O
- rm -f $(O5)
-
newpkg: clean
mkdir -p _obj$D
@@ -84,7 +79,6 @@
$(O3): a2
$(O4): a3
$(O5): a4
-$(O6): a5
nuke: clean
rm -f $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D/net.a
diff --git a/src/pkg/net/dialgoogle_test.go b/src/pkg/net/dialgoogle_test.go
index 3792195..f259cba 100644
--- a/src/pkg/net/dialgoogle_test.go
+++ b/src/pkg/net/dialgoogle_test.go
@@ -6,7 +6,6 @@
import (
"flag";
- "fmt";
"io";
"net";
"os";
diff --git a/src/pkg/net/dnsclient.go b/src/pkg/net/dnsclient.go
index cfd67ea..72af10f 100644
--- a/src/pkg/net/dnsclient.go
+++ b/src/pkg/net/dnsclient.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// DNS client.
+// DNS client: see RFC 1035.
// Has to be linked into package net for Dial.
// TODO(rsc):
@@ -12,12 +12,10 @@
// Random UDP source port (net.Dial should do that for us).
// Random request IDs.
// More substantial error reporting.
-// Remove use of fmt?
package net
import (
- "fmt";
"io";
"net";
"once";
@@ -25,28 +23,29 @@
"strings";
)
-// DNS errors returned by LookupHost.
+// DNSError represents a DNS lookup error.
type DNSError struct {
- os.ErrorString
+ Error string; // description of the error
+ Name string; // name looked for
+ Server string; // server used
}
-var (
- DNS_InternalError os.Error = &DNSError{"internal dns error"};
- DNS_MissingConfig os.Error = &DNSError{"no dns configuration"};
- DNS_No_Answer os.Error = &DNSError{"dns got no answer"};
- DNS_BadRequest os.Error = &DNSError{"malformed dns request"};
- DNS_BadReply os.Error = &DNSError{"malformed dns reply"};
- DNS_ServerFailure os.Error = &DNSError{"dns server failure"};
- DNS_NoServers os.Error = &DNSError{"no dns servers"};
- DNS_NameTooLong os.Error = &DNSError{"dns name too long"};
- DNS_RedirectLoop os.Error = &DNSError{"dns redirect loop"};
- DNS_NameNotFound os.Error = &DNSError{"dns name not found"};
-)
+
+func (e *DNSError) String() string {
+ s := "lookup " + e.Name;
+ if e.Server != "" {
+ s += " on " + e.Server;
+ }
+ s += ": " + e.Error;
+ return s;
+}
+
+const noSuchHost = "no such host"
// 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) {
if len(name) >= 256 {
- return nil, DNS_NameTooLong
+ return nil, &DNSError{"name too long", name, ""}
}
out := new(_DNS_Msg);
out.id = 0x1234;
@@ -56,7 +55,7 @@
out.recursion_desired = true;
msg, ok := out.Pack();
if !ok {
- return nil, DNS_InternalError
+ return nil, &DNSError{"internal error - cannot pack message", name, ""}
}
for attempt := 0; attempt < cfg.attempts; attempt++ {
@@ -69,7 +68,8 @@
buf := make([]byte, 2000); // More than enough.
n, err = c.Read(buf);
- if err == os.EAGAIN {
+ if isEAGAIN(err) {
+ err = nil;
continue;
}
if err != nil {
@@ -82,25 +82,25 @@
}
return in, nil
}
- return nil, DNS_No_Answer
+ return nil, &DNSError{"no answer from server", name, c.RemoteAddr()}
}
// Find answer for name in dns message.
// On return, if err == nil, addrs != nil.
// TODO(rsc): Maybe return []IP instead?
-func answer(name string, dns *_DNS_Msg) (addrs []string, err os.Error) {
+func answer(name, server string, dns *_DNS_Msg) (addrs []string, err *DNSError) {
addrs = make([]string, 0, len(dns.answer));
- if dns.rcode == _DNS_RcodeNameError && dns.authoritative {
- return nil, DNS_NameNotFound // authoritative "no such host"
+ if dns.rcode == _DNS_RcodeNameError && dns.recursion_available {
+ return nil, &DNSError{noSuchHost, name, ""}
}
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, &DNSError{"server misbehaving", name, server}
}
// Look for the name.
@@ -120,7 +120,7 @@
n := len(addrs);
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);
+ addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String();
case _DNS_TypeCNAME:
// redirect to cname
name = rr.(*_DNS_RR_CNAME).cname;
@@ -129,19 +129,20 @@
}
}
if len(addrs) == 0 {
- return nil, DNS_NameNotFound
+ return nil, &DNSError{noSuchHost, name, server}
}
return addrs, nil
}
- // Too many redirects
- return nil, DNS_RedirectLoop
+ return nil, &DNSError{"too many redirects", name, server}
}
// 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) {
- err = DNS_NoServers;
+ if len(cfg.servers) == 0 {
+ return nil, &DNSError{"no DNS servers", name, ""}
+ }
for i := 0; i < len(cfg.servers); i++ {
// Calling Dial here is scary -- we have to be sure
// not to dial a name that will require a DNS lookup,
@@ -149,7 +150,8 @@
// The DNS config parser has already checked that
// all the cfg.servers[i] are IP addresses, which
// Dial will use without a DNS lookup.
- c, cerr := Dial("udp", "", cfg.servers[i] + ":53");
+ server := cfg.servers[i] + ":53";
+ c, cerr := Dial("udp", "", server);
if cerr != nil {
err = cerr;
continue;
@@ -160,12 +162,16 @@
err = merr;
continue;
}
- addrs, aerr := answer(name, msg);
- if aerr != nil && aerr != DNS_NameNotFound {
- err = aerr;
- continue;
+ var dnserr *DNSError;
+ addrs, dnserr = answer(name, server, msg);
+ if dnserr != nil {
+ err = dnserr;
+ } else {
+ err = nil; // nil os.Error, not nil *DNSError
}
- return addrs, aerr;
+ if dnserr == nil || dnserr.Error == noSuchHost {
+ break;
+ }
}
return;
}
@@ -177,18 +183,60 @@
cfg, dnserr = _DNS_ReadConfig();
}
+func isDomainName(s string) bool {
+ // Requirements on DNS name:
+ // * must not be empty.
+ // * must be alphanumeric plus - and .
+ // * each of the dot-separated elements must begin
+ // and end with a letter or digit.
+ // RFC 1035 required the element to begin with a letter,
+ // but RFC 3696 says this has been relaxed to allow digits too.
+ // still, there must be a letter somewhere in the entire name.
+ if len(s) == 0 {
+ return false;
+ }
+ if s[len(s)-1] != '.' { // simplify checking loop: make name end in dot
+ s += ".";
+ }
+
+ last := byte('.');
+ ok := false; // ok once we've seen a letter
+ for i := 0; i < len(s); i++ {
+ c := s[i];
+ switch {
+ default:
+ return false;
+ case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
+ ok = true;
+ case '0' <= c && c <= '9':
+ // fine
+ case c == '-':
+ // byte before dash cannot be dot
+ if last == '.' {
+ return false;
+ }
+ case c == '.':
+ // byte before dot cannot be dot, dash
+ if last == '.' || last == '-' {
+ return false;
+ }
+ }
+ last = c;
+ }
+
+ return ok;
+}
+
// 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?
-
+func LookupHost(name string) (cname string, addrs []string, err os.Error) {
+ if !isDomainName(name) {
+ return name, nil, &DNSError{"invalid domain name", name, ""};
+ }
once.Do(loadConfig);
if dnserr != nil || cfg == nil {
- // better error than file not found.
- err = DNS_MissingConfig;
+ err = dnserr;
return;
}
@@ -201,11 +249,12 @@
rname += ".";
}
// Can try as ordinary name.
- addrs, aerr := tryOneName(cfg, rname);
- if aerr == nil {
- return rname, addrs, nil;
+ var dnserr *DNSError;
+ addrs, err = tryOneName(cfg, rname);
+ if err == nil {
+ cname = rname;
+ return;
}
- err = aerr;
}
if rooted {
return
@@ -213,15 +262,16 @@
// Otherwise, try suffixes.
for i := 0; i < len(cfg.search); i++ {
- newname := name+"."+cfg.search[i];
- if newname[len(newname)-1] != '.' {
- newname += "."
+ rname := name+"."+cfg.search[i];
+ if rname[len(rname)-1] != '.' {
+ rname += "."
}
- addrs, aerr := tryOneName(cfg, newname);
- if aerr == nil {
- return newname, addrs, nil;
+ var dnserr *DNSError;
+ addrs, err = tryOneName(cfg, rname);
+ if err == nil {
+ cname = rname;
+ return;
}
- err = aerr;
}
return
}
diff --git a/src/pkg/net/dnsmsg.go b/src/pkg/net/dnsmsg.go
index d7a467f..728e898 100644
--- a/src/pkg/net/dnsmsg.go
+++ b/src/pkg/net/dnsmsg.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// DNS packet assembly.
+// DNS packet assembly. See RFC 1035.
//
// This is intended to support name resolution during net.Dial.
// It doesn't have to be blazing fast.
@@ -25,6 +25,7 @@
import (
"fmt";
+ "net";
"os";
"reflect";
)
@@ -464,7 +465,7 @@
s += printStructValue(fld.(reflect.StructValue));
case kind == reflect.Uint32Kind && tag == "ipv4":
i := fld.(reflect.Uint32Value).Get();
- s += fmt.Sprintf("%d.%d.%d.%d", (i>>24)&0xFF, (i>>16)&0xFF, (i>>8)&0xFF, i&0xFF);
+ s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String();
default:
s += fmt.Sprint(fld.Interface())
}
diff --git a/src/pkg/net/fd.go b/src/pkg/net/fd.go
index 17598af..0917c50 100644
--- a/src/pkg/net/fd.go
+++ b/src/pkg/net/fd.go
@@ -85,7 +85,7 @@
var e int;
if e = syscall.SetNonblock(s.pr.Fd(), true); e != 0 {
Errno:
- err = os.ErrnoToError(e);
+ err = &os.PathError{"setnonblock", s.pr.Name(), os.Errno(e)};
Error:
s.pr.Close();
s.pw.Close();
@@ -304,19 +304,46 @@
once.Do(_StartServer);
}
if e := syscall.SetNonblock(fd, true); e != 0 {
- return nil, os.ErrnoToError(e);
+ return nil, &os.PathError{"setnonblock", laddr, os.Errno(e)};
}
f = new(netFD);
f.fd = fd;
f.net = net;
f.laddr = laddr;
f.raddr = raddr;
- f.file = os.NewFile(fd, "net: " + net + " " + laddr + " " + raddr);
+ f.file = os.NewFile(fd, net + "!" + laddr + "->" + raddr);
f.cr = make(chan *netFD, 1);
f.cw = make(chan *netFD, 1);
return f, nil
}
+func isEAGAIN(e os.Error) bool {
+ if e1, ok := e.(*os.PathError); ok {
+ return e1.Error == os.EAGAIN;
+ }
+ return e == os.EAGAIN;
+}
+
+func sockaddrToString(sa syscall.Sockaddr) (name string, err os.Error)
+
+func (fd *netFD) addr() string {
+ sa, e := syscall.Getsockname(fd.fd);
+ if e != 0 {
+ return "";
+ }
+ addr, err := sockaddrToString(sa);
+ return addr;
+}
+
+func (fd *netFD) remoteAddr() string {
+ sa, e := syscall.Getpeername(fd.fd);
+ if e != 0 {
+ return "";
+ }
+ addr, err := sockaddrToString(sa);
+ return addr;
+}
+
func (fd *netFD) Close() os.Error {
if fd == nil || fd.file == nil {
return os.EINVAL
@@ -338,7 +365,7 @@
func (fd *netFD) Read(p []byte) (n int, err os.Error) {
if fd == nil || fd.file == nil {
- return -1, os.EINVAL
+ return 0, os.EINVAL
}
fd.rio.Lock();
defer fd.rio.Unlock();
@@ -347,17 +374,20 @@
} else {
fd.rdeadline = 0;
}
- n, err = fd.file.Read(p);
- for err == os.EAGAIN && fd.rdeadline >= 0 {
- pollserver.WaitRead(fd);
- n, err = fd.file.Read(p)
+ for {
+ n, err = fd.file.Read(p);
+ if isEAGAIN(err) && fd.rdeadline >= 0 {
+ pollserver.WaitRead(fd);
+ continue;
+ }
+ break;
}
- return n, err
+ return;
}
func (fd *netFD) Write(p []byte) (n int, err os.Error) {
if fd == nil || fd.file == nil {
- return -1, os.EINVAL
+ return 0, os.EINVAL
}
fd.wio.Lock();
defer fd.wio.Unlock();
@@ -376,7 +406,7 @@
if nn == len(p) {
break;
}
- if err == os.EAGAIN && fd.wdeadline >= 0 {
+ if isEAGAIN(err) && fd.wdeadline >= 0 {
pollserver.WaitWrite(fd);
continue;
}
@@ -387,8 +417,6 @@
return nn, err
}
-func sockaddrToString(sa syscall.Sockaddr) (name string, err os.Error)
-
func (fd *netFD) accept() (nfd *netFD, err os.Error) {
if fd == nil || fd.file == nil {
return nil, os.EINVAL
@@ -411,7 +439,7 @@
}
if e != 0 {
syscall.ForkLock.RUnlock();
- return nil, os.ErrnoToError(e)
+ return nil, &os.PathError{"accept", fd.addr(), os.Errno(e)}
}
syscall.CloseOnExec(s);
syscall.ForkLock.RUnlock();
@@ -426,23 +454,3 @@
}
return nfd, nil
}
-
-func (fd *netFD) addr() string {
- sa, err := syscall.Getsockname(fd.fd);
- if err != 0 {
- return "";
- }
- // TODO(rsc): woud like to say err not err1 but 6g complains
- addr, err1 := sockaddrToString(sa);
- return addr;
-}
-
-func (fd *netFD) remoteAddr() string {
- sa, err := syscall.Getpeername(fd.fd);
- if err != 0 {
- return "";
- }
- // TODO(rsc): woud like to say err not err1 but 6g complains
- addr, err1 := sockaddrToString(sa);
- return addr;
-}
diff --git a/src/pkg/net/fd_darwin.go b/src/pkg/net/fd_darwin.go
index 42bf512..c5b38eb 100644
--- a/src/pkg/net/fd_darwin.go
+++ b/src/pkg/net/fd_darwin.go
@@ -12,8 +12,6 @@
"syscall";
)
-var kqueuePhaseError = &Error{"kqueue phase error"}
-
type pollster struct {
kq int;
eventbuf [10]syscall.Kevent_t;
@@ -24,7 +22,7 @@
p = new(pollster);
var e int;
if p.kq, e = syscall.Kqueue(); e != 0 {
- return nil, os.ErrnoToError(e)
+ return nil, os.NewSyscallError("kqueue", e)
}
p.events = p.eventbuf[0:0];
return p, nil
@@ -51,13 +49,13 @@
n, e := syscall.Kevent(p.kq, &events, &events, nil);
if e != 0 {
- return os.ErrnoToError(e)
+ return os.NewSyscallError("kevent", e);
}
if n != 1 || (ev.Flags & syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
- return kqueuePhaseError
+ return os.ErrorString("kqueue phase error");
}
if ev.Data != 0 {
- return os.ErrnoToError(int(ev.Data))
+ return os.Errno(int(ev.Data))
}
return nil
}
@@ -92,7 +90,7 @@
if e == syscall.EINTR {
continue
}
- return -1, 0, os.ErrnoToError(e)
+ return -1, 0, os.NewSyscallError("kevent", e)
}
if nn == 0 {
return -1, 0, nil;
@@ -111,5 +109,5 @@
}
func (p *pollster) Close() os.Error {
- return os.ErrnoToError(syscall.Close(p.kq))
+ return os.NewSyscallError("close", syscall.Close(p.kq))
}
diff --git a/src/pkg/net/fd_linux.go b/src/pkg/net/fd_linux.go
index bd82258..04cf8ea 100644
--- a/src/pkg/net/fd_linux.go
+++ b/src/pkg/net/fd_linux.go
@@ -32,7 +32,7 @@
// about the number of FDs we will care about.
// We don't know.
if p.epfd, e = syscall.EpollCreate(16); e != 0 {
- return nil, os.ErrnoToError(e)
+ return nil, os.NewSyscallError("epoll_create", e)
}
p.events = make(map[int] uint32);
return p, nil
@@ -59,7 +59,7 @@
op = syscall.EPOLL_CTL_ADD;
}
if e := syscall.EpollCtl(p.epfd, op, fd, &ev); e != 0 {
- return os.ErrnoToError(e)
+ return os.NewSyscallError("epoll_ctl", e)
}
p.events[fd] = ev.Events;
return nil
@@ -87,12 +87,12 @@
ev.Fd = int32(fd);
ev.Events = events;
if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &ev); e != 0 {
- print("Epoll modify fd=", fd, ": ", os.ErrnoToError(e).String(), "\n");
+ print("Epoll modify fd=", fd, ": ", os.Errno(e).String(), "\n");
}
p.events[fd] = events;
} else {
if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_DEL, fd, nil); e != 0 {
- print("Epoll delete fd=", fd, ": ", os.ErrnoToError(e).String(), "\n");
+ print("Epoll delete fd=", fd, ": ", os.Errno(e).String(), "\n");
}
p.events[fd] = 0, false;
}
@@ -119,7 +119,7 @@
n, e = syscall.EpollWait(p.epfd, &evarray, msec);
}
if e != 0 {
- return -1, 0, os.ErrnoToError(e);
+ return -1, 0, os.NewSyscallError("epoll_wait", e);
}
if n == 0 {
return -1, 0, nil;
@@ -146,5 +146,5 @@
}
func (p *pollster) Close() os.Error {
- return os.ErrnoToError(syscall.Close(p.epfd));
+ return os.NewSyscallError("close", syscall.Close(p.epfd));
}
diff --git a/src/pkg/net/net.go b/src/pkg/net/net.go
index 91d498a..bbd89ca 100644
--- a/src/pkg/net/net.go
+++ b/src/pkg/net/net.go
@@ -7,18 +7,50 @@
import (
"net";
"os";
+ "reflect";
"strconv";
+ "strings";
"syscall";
)
-var (
- BadAddress os.Error = &Error{"malformed address"};
- MissingAddress os.Error = &Error{"missing address"};
- UnknownNetwork os.Error = &Error{"unknown network"};
- UnknownHost os.Error = &Error{"unknown host"};
- UnknownSocketFamily os.Error = &Error{"unknown socket family"};
-)
+var errMissingAddress = os.ErrorString("missing address")
+type OpError struct {
+ Op string;
+ Net string;
+ Addr string;
+ Error os.Error;
+}
+
+func (e *OpError) String() string {
+ s := e.Op;
+ if e.Net != "" {
+ s += " " + e.Net;
+ }
+ if e.Addr != "" {
+ s += " " + e.Addr;
+ }
+ s += ": " + e.Error.String();
+ return s;
+}
+
+type AddrError struct {
+ Error string;
+ Addr string;
+}
+
+func (e *AddrError) String() string {
+ s := e.Error;
+ if e.Addr != "" {
+ s += " " + e.Addr;
+ }
+ return s;
+}
+
+type UnknownNetworkError string
+func (e UnknownNetworkError) String() string {
+ return "unknown network " + string(e);
+}
// Conn is a generic network connection.
type Conn interface {
@@ -127,23 +159,19 @@
}
func LookupHost(name string) (cname string, addrs []string, err os.Error)
+func LookupPort(network, service string) (port int, err os.Error)
// Split "host:port" into "host" and "port".
// Host cannot contain colons unless it is bracketed.
func splitHostPort(hostport string) (host, port string, err os.Error) {
// The port starts after the last colon.
- var i int;
- for i = len(hostport)-1; i >= 0; i-- {
- if hostport[i] == ':' {
- break
- }
- }
+ i := strings.LastIndex(hostport, ":");
if i < 0 {
- return "", "", BadAddress
+ err = &AddrError{"missing port in address", hostport};
+ return;
}
- host = hostport[0:i];
- port = hostport[i+1:len(hostport)];
+ host, port = hostport[0:i], hostport[i+1:len(hostport)];
// Can put brackets around host ...
if len(host) > 0 && host[0] == '[' && host[len(host)-1] == ']' {
@@ -151,10 +179,11 @@
} else {
// ... but if there are no brackets, no colons.
if byteIndex(host, ':') >= 0 {
- return "", "", BadAddress
+ err = &AddrError{"too many colons in address", hostport};
+ return;
}
}
- return host, port, nil
+ return;
}
// Join "host" and "port" into "host:port".
@@ -171,22 +200,21 @@
// For now, host and port must be numeric literals.
// Eventually, we'll have name resolution.
func hostPortToIP(net, hostport, mode string) (ip IP, iport int, err os.Error) {
- var host, port string;
- host, port, err = splitHostPort(hostport);
+ host, port, err := splitHostPort(hostport);
if err != nil {
- return nil, 0, err
+ goto Error;
}
var addr IP;
if host == "" {
- if mode == "listen" {
- if preferIPv4 {
- addr = IPv4zero;
- } else {
- addr = IPzero; // wildcard - listen to all
- }
+ if mode != "listen" {
+ err = &AddrError{"no host in address", hostport};
+ goto Error;
+ }
+ if preferIPv4 {
+ addr = IPv4zero;
} else {
- return nil, 0, MissingAddress;
+ addr = IPzero; // wildcard - listen to all
}
}
@@ -196,17 +224,16 @@
}
if addr == nil {
// Not an IP address. Try as a DNS name.
- hostname, addrs, err := LookupHost(host);
- if err != nil {
- return nil, 0, err
- }
- if len(addrs) == 0 {
- return nil, 0, UnknownHost
+ hostname, addrs, err1 := LookupHost(host);
+ if err1 != nil {
+ err = err1;
+ goto Error;
}
addr = ParseIP(addrs[0]);
if addr == nil {
// should not happen
- return nil, 0, BadAddress
+ err = &AddrError{"LookupHost returned invalid address", addrs[0]};
+ goto Error;
}
}
@@ -214,14 +241,25 @@
if !ok || i != len(port) {
p, err = LookupPort(net, port);
if err != nil {
- return nil, 0, err
+ goto Error;
}
}
if p < 0 || p > 0xFFFF {
- return nil, 0, BadAddress
+ err = &AddrError{"invalid port", port};
+ goto Error;
}
- return addr, p, nil
+ return addr, p, nil;
+
+Error:
+ return nil, 0, err;
+}
+
+type UnknownSocketError struct {
+ sa syscall.Sockaddr;
+}
+func (e *UnknownSocketError) String() string {
+ return "unknown socket address type " + reflect.Typeof(e.sa).String()
}
func sockaddrToString(sa syscall.Sockaddr) (name string, err os.Error) {
@@ -233,7 +271,8 @@
case *syscall.SockaddrUnix:
return a.Name, nil;
}
- return "", UnknownSocketFamily
+
+ return "", &UnknownSocketError{sa};
}
func ipToSockaddr(family int, ip IP, port int) (syscall.Sockaddr, os.Error) {
@@ -283,7 +322,7 @@
s, e := syscall.Socket(f, p, t);
if e != 0 {
syscall.ForkLock.RUnlock();
- return nil, os.ErrnoToError(e)
+ return nil, os.Errno(e)
}
syscall.CloseOnExec(s);
syscall.ForkLock.RUnlock();
@@ -296,7 +335,7 @@
e = syscall.Bind(s, la);
if e != 0 {
syscall.Close(s);
- return nil, os.ErrnoToError(e)
+ return nil, os.Errno(e)
}
}
@@ -304,7 +343,7 @@
e = syscall.Connect(s, ra);
if e != 0 {
syscall.Close(s);
- return nil, os.ErrnoToError(e)
+ return nil, os.Errno(e)
}
}
@@ -390,12 +429,12 @@
func setsockoptInt(fd, level, opt int, value int) os.Error {
- return os.ErrnoToError(syscall.SetsockoptInt(fd, level, opt, value));
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(fd, level, opt, value));
}
func setsockoptNsec(fd, level, opt int, nsec int64) os.Error {
var tv = syscall.NsecToTimeval(nsec);
- return os.ErrnoToError(syscall.SetsockoptTimeval(fd, level, opt, &tv));
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptTimeval(fd, level, opt, &tv));
}
func (c *connBase) SetReadBuffer(bytes int) os.Error {
@@ -450,7 +489,7 @@
l.Linger = 0;
}
e := syscall.SetsockoptLinger(c.sysFD(), syscall.SOL_SOCKET, syscall.SO_LINGER, &l);
- return os.ErrnoToError(e);
+ return os.NewSyscallError("setsockopt", e);
}
@@ -463,12 +502,12 @@
if laddr != "" {
if lip, lport, err = hostPortToIP(net, laddr, mode); err != nil {
- return
+ goto Error;
}
}
if raddr != "" {
if rip, rport, err = hostPortToIP(net, raddr, mode); err != nil {
- return
+ goto Error;
}
}
@@ -500,17 +539,27 @@
var la, ra syscall.Sockaddr;
if lip != nil {
if la, err = ipToSockaddr(family, lip, lport); err != nil {
- return
+ goto Error;
}
}
if rip != nil {
if ra, err = ipToSockaddr(family, rip, rport); err != nil {
- return
+ goto Error;
}
}
fd, err = socket(net, laddr, raddr, family, proto, 0, la, ra);
- return fd, err
+ if err != nil {
+ goto Error;
+ }
+ return fd, nil;
+
+Error:
+ addr := raddr;
+ if mode == "listen" {
+ addr = laddr;
+ }
+ return nil, &OpError{mode, net, addr, err};
}
@@ -541,7 +590,7 @@
// and returns a ConnTCP structure.
func DialTCP(net, laddr, raddr string) (c *ConnTCP, err os.Error) {
if raddr == "" {
- return nil, MissingAddress
+ return nil, &OpError{"dial", "tcp", "", errMissingAddress}
}
fd, e := internetSocket(net, laddr, raddr, syscall.SOCK_STREAM, "dial");
if e != nil {
@@ -572,7 +621,7 @@
// and returns a ConnUDP structure.
func DialUDP(net, laddr, raddr string) (c *ConnUDP, err os.Error) {
if raddr == "" {
- return nil, MissingAddress
+ return nil, &OpError{"dial", "udp", "", errMissingAddress}
}
fd, e := internetSocket(net, laddr, raddr, syscall.SOCK_DGRAM, "dial");
if e != nil {
@@ -593,7 +642,7 @@
var proto int;
switch net {
default:
- return nil, UnknownNetwork;
+ return nil, UnknownNetworkError(net);
case "unix":
proto = syscall.SOCK_STREAM;
case "unix-dgram":
@@ -602,27 +651,40 @@
var la, ra syscall.Sockaddr;
switch mode {
+ default:
+ panic("unixSocket", mode);
+
case "dial":
if laddr != "" {
- return nil, BadAddress;
+ return nil, &OpError{mode, net, raddr, &AddrError{"unexpected local address", laddr}}
}
if raddr == "" {
- return nil, MissingAddress;
+ return nil, &OpError{mode, net, "", errMissingAddress}
}
ra = &syscall.SockaddrUnix{Name: raddr};
case "listen":
if laddr == "" {
- return nil, MissingAddress;
+ return nil, &OpError{mode, net, "", errMissingAddress}
}
la = &syscall.SockaddrUnix{Name: laddr};
if raddr != "" {
- return nil, BadAddress;
+ return nil, &OpError{mode, net, laddr, &AddrError{"unexpected remote address", raddr}}
}
}
fd, err = socket(net, laddr, raddr, syscall.AF_UNIX, proto, 0, la, ra);
- return fd, err
+ if err != nil {
+ goto Error;
+ }
+ return fd, nil;
+
+Error:
+ addr := raddr;
+ if mode == "listen" {
+ addr = laddr;
+ }
+ return nil, &OpError{mode, net, addr, err};
}
// ConnUnix is an implementation of the Conn interface
@@ -663,6 +725,9 @@
func ListenUnix(net, laddr string) (l *ListenerUnix, err os.Error) {
fd, e := unixSocket(net, laddr, "", "listen");
if e != nil {
+ if pe, ok := e.(*os.PathError); ok {
+ e = pe.Error;
+ }
// Check for socket ``in use'' but ``refusing connections,''
// which means some program created it and exited
// without unlinking it from the file system.
@@ -675,6 +740,9 @@
if e1 == nil {
fd1.Close();
}
+ if pe, ok := e1.(*os.PathError); ok {
+ e1 = pe.Error;
+ }
if e1 != os.ECONNREFUSED {
return nil, e;
}
@@ -688,7 +756,7 @@
e1 := syscall.Listen(fd.fd, 8); // listenBacklog());
if e1 != 0 {
syscall.Close(fd.fd);
- return nil, os.ErrnoToError(e1);
+ return nil, &OpError{"listen", "unix", laddr, os.Errno(e1)};
}
return &ListenerUnix{fd, laddr}, nil;
}
@@ -788,7 +856,7 @@
return c, err
*/
}
- return nil, UnknownNetwork
+ return nil, &OpError{"dial", net, raddr, UnknownNetworkError(net)};
}
// A Listener is a generic network listener.
@@ -818,7 +886,7 @@
e1 := syscall.Listen(fd.fd, listenBacklog());
if e1 != 0 {
syscall.Close(fd.fd);
- return nil, os.ErrnoToError(e1)
+ return nil, &OpError{"listen", "tcp", laddr, os.Errno(e1)};
}
l = new(ListenerTCP);
l.fd = fd;
@@ -884,6 +952,6 @@
*/
// BUG(rsc): Listen should support UDP.
}
- return nil, UnknownNetwork
+ return nil, UnknownNetworkError(net);
}
diff --git a/src/pkg/net/net_test.go b/src/pkg/net/net_test.go
new file mode 100644
index 0000000..cafca3c
--- /dev/null
+++ b/src/pkg/net/net_test.go
@@ -0,0 +1,72 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package net
+
+import (
+ "net";
+ "os";
+ "regexp";
+ "testing";
+)
+
+type DialErrorTest struct {
+ Net string;
+ Laddr string;
+ Raddr string;
+ Pattern string;
+}
+
+var dialErrorTests = []DialErrorTest {
+ DialErrorTest{
+ "datakit", "", "mh/astro/r70",
+ "dial datakit mh/astro/r70: unknown network datakit",
+ },
+ DialErrorTest{
+ "tcp", "", "127.0.0.1:☺",
+ "dial tcp 127.0.0.1:☺: unknown port tcp/☺",
+ },
+ DialErrorTest{
+ "tcp", "", "no-such-name.google.com.:80",
+ "dial tcp no-such-name.google.com.:80: lookup no-such-name.google.com.: no such host",
+ },
+ DialErrorTest{
+ "tcp", "", "no-such-name.no-such-top-level-domain.:80",
+ "dial tcp no-such-name.no-such-top-level-domain.:80: lookup no-such-name.no-such-top-level-domain.: no such host",
+ },
+ DialErrorTest{
+ "tcp", "", "no-such-name:80",
+ "dial tcp no-such-name:80: lookup no-such-name.google.com.: no such host",
+ },
+ DialErrorTest{
+ "tcp", "", "mh/astro/r70:http",
+ "dial tcp mh/astro/r70:http: lookup mh/astro/r70: invalid domain name",
+ },
+ DialErrorTest{
+ "unix", "", "/etc/file-not-found",
+ "dial unix /etc/file-not-found: no such file or directory",
+ },
+ DialErrorTest{
+ "unix", "", "/etc/",
+ "dial unix /etc/: (permission denied|socket operation on non-socket)",
+ },
+}
+
+func TestDialError(t *testing.T) {
+ for i, tt := range dialErrorTests {
+ c, e := net.Dial(tt.Net, tt.Laddr, tt.Raddr);
+ if c != nil {
+ c.Close();
+ }
+ if e == nil {
+ t.Errorf("#%d: nil error, want match for %#q", i, tt.Pattern);
+ continue;
+ }
+ s := e.String();
+ match, err := regexp.Match(tt.Pattern, s);
+ if !match {
+ t.Errorf("#%d: %q, want match for %#q", i, s, tt.Pattern);
+ }
+ }
+}
diff --git a/src/pkg/net/parse.go b/src/pkg/net/parse.go
index 7d5dd8f..8b10519 100644
--- a/src/pkg/net/parse.go
+++ b/src/pkg/net/parse.go
@@ -12,10 +12,6 @@
"os";
)
-type Error struct {
- os.ErrorString
-}
-
type file struct {
file *os.File;
data []byte;
diff --git a/src/pkg/net/port.go b/src/pkg/net/port.go
index 21e3b48a..a9cd98d 100644
--- a/src/pkg/net/port.go
+++ b/src/pkg/net/port.go
@@ -11,13 +11,8 @@
"net";
"once";
"os";
- "strconv";
)
-// The error returned by LookupPort when a network service
-// is not listed in the database.
-var ErrNoService = &Error{"unknown network service"};
-
var services map[string] map[string] int
var servicesError os.Error
@@ -65,13 +60,10 @@
network = "udp";
}
- m, ok := services[network];
- if !ok {
- return 0, ErrNoService;
+ if m, ok := services[network]; ok {
+ if port, ok = m[service]; ok {
+ return;
+ }
}
- port, ok = m[service];
- if !ok {
- return 0, ErrNoService;
- }
- return port, nil;
+ return 0, &AddrError{"unknown port", network + "/" + service};
}
diff --git a/src/pkg/net/timeout_test.go b/src/pkg/net/timeout_test.go
index e08ce88..0aebce8 100644
--- a/src/pkg/net/timeout_test.go
+++ b/src/pkg/net/timeout_test.go
@@ -22,7 +22,7 @@
var b [100]byte;
n, err1 := fd.Read(&b);
t1 := time.Nanoseconds();
- if n != 0 || err1 != os.EAGAIN {
+ if n != 0 || !isEAGAIN(err1) {
t.Errorf("fd.Read on %s %s did not return 0, EAGAIN: %v, %v", network, addr, n, err1);
}
if t1 - t0 < 0.5e8 || t1 - t0 > 1.5e8 {
diff --git a/src/pkg/os/dir_darwin_386.go b/src/pkg/os/dir_darwin_386.go
index 2803ece..791499d 100644
--- a/src/pkg/os/dir_darwin_386.go
+++ b/src/pkg/os/dir_darwin_386.go
@@ -38,9 +38,9 @@
d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr));
if errno != 0 {
d.nbuf = 0;
- return names, ErrnoToError(errno)
+ return names, NewSyscallError("getdirentries", errno);
}
- if d.nbuf == 0 {
+ if d.nbuf <= 0 {
break // EOF
}
}
diff --git a/src/pkg/os/dir_darwin_amd64.go b/src/pkg/os/dir_darwin_amd64.go
index 2803ece..791499d 100644
--- a/src/pkg/os/dir_darwin_amd64.go
+++ b/src/pkg/os/dir_darwin_amd64.go
@@ -38,9 +38,9 @@
d.nbuf, errno = syscall.Getdirentries(file.fd, d.buf, new(uintptr));
if errno != 0 {
d.nbuf = 0;
- return names, ErrnoToError(errno)
+ return names, NewSyscallError("getdirentries", errno);
}
- if d.nbuf == 0 {
+ if d.nbuf <= 0 {
break // EOF
}
}
diff --git a/src/pkg/os/dir_linux_386.go b/src/pkg/os/dir_linux_386.go
index c4594a5..d6d700b 100644
--- a/src/pkg/os/dir_linux_386.go
+++ b/src/pkg/os/dir_linux_386.go
@@ -47,10 +47,10 @@
if d.bufp >= d.nbuf {
var errno int;
d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
- if d.nbuf < 0 {
- return names, ErrnoToError(errno)
+ if errno != 0 {
+ return names, NewSyscallError("getdents", errno)
}
- if d.nbuf == 0 {
+ if d.nbuf <= 0 {
break // EOF
}
d.bufp = 0;
diff --git a/src/pkg/os/dir_linux_amd64.go b/src/pkg/os/dir_linux_amd64.go
index 05b3d4c..8b1664f 100644
--- a/src/pkg/os/dir_linux_amd64.go
+++ b/src/pkg/os/dir_linux_amd64.go
@@ -43,10 +43,10 @@
if d.bufp >= d.nbuf {
var errno int;
d.nbuf, errno = syscall.Getdents(file.fd, d.buf);
- if d.nbuf < 0 {
- return names, ErrnoToError(errno)
+ if errno != 0 {
+ return names, NewSyscallError("getdents", errno)
}
- if d.nbuf == 0 {
+ if d.nbuf <= 0 {
break // EOF
}
d.bufp = 0;
diff --git a/src/pkg/os/error.go b/src/pkg/os/error.go
index 718499b..10a7d04 100644
--- a/src/pkg/os/error.go
+++ b/src/pkg/os/error.go
@@ -30,15 +30,6 @@
return syscall.Errstr(int(e))
}
-// ErrnoToError converts errno to an Error (underneath, an Errno).
-// It returns nil for the "no error" errno.
-func ErrnoToError(errno int) Error {
- if errno == 0 {
- return nil
- }
- return Errno(errno)
-}
-
// Commonly known Unix errors.
var (
EPERM Error = Errno(syscall.EPERM);
@@ -81,3 +72,33 @@
ENAMETOOLONG Error = Errno(syscall.ENAMETOOLONG);
)
+// PathError records an error and the operation and file path that caused it.
+type PathError struct {
+ Op string;
+ Path string;
+ Error Error;
+}
+
+func (e *PathError) String() string {
+ return e.Op + " " + e.Path + ": " + e.Error.String();
+}
+
+// SyscallError records an error from a specific system call.
+type SyscallError struct {
+ Syscall string;
+ Errno Errno;
+}
+
+func (e *SyscallError) String() string {
+ return e.Syscall + ": " + e.Errno.String();
+}
+
+// NewSyscallError returns, as an os.Error, a new SyscallError
+// with the given system call name and error number.
+// As a convenience, if errno is 0, NewSyscallError returns nil.
+func NewSyscallError(syscall string, errno int) os.Error {
+ if errno == 0 {
+ return nil;
+ }
+ return &SyscallError{syscall, Errno(errno)}
+}
diff --git a/src/pkg/os/exec.go b/src/pkg/os/exec.go
index c1551f8..a7430ef 100644
--- a/src/pkg/os/exec.go
+++ b/src/pkg/os/exec.go
@@ -30,7 +30,10 @@
}
p, e := syscall.ForkExec(argv0, argv, envv, dir, intfd);
- return int(p), ErrnoToError(e);
+ if e != 0 {
+ return 0, &PathError{"fork/exec", argv0, Errno(e)};
+ }
+ return p, nil;
}
// Exec replaces the current process with an execution of the program
@@ -42,7 +45,10 @@
envv = Environ();
}
e := syscall.Exec(argv0, argv, envv);
- return ErrnoToError(e);
+ if e != 0 {
+ return &PathError{"exec", argv0, Errno(e)};
+ }
+ return nil;
}
// TODO(rsc): Should os implement its own syscall.WaitStatus
@@ -79,10 +85,10 @@
}
pid1, e := syscall.Wait4(pid, &status, options, rusage);
if e != 0 {
- return nil, ErrnoToError(e);
+ return nil, NewSyscallError("wait", e);
}
w = new(Waitmsg);
- w.Pid = pid;
+ w.Pid = pid1;
w.WaitStatus = status;
w.Rusage = rusage;
return w, nil;
diff --git a/src/pkg/os/file.go b/src/pkg/os/file.go
index 5b61159..8c76735 100644
--- a/src/pkg/os/file.go
+++ b/src/pkg/os/file.go
@@ -37,11 +37,11 @@
}
// NewFile returns a new File with the given file descriptor and name.
-func NewFile(file int, name string) *File {
- if file < 0 {
+func NewFile(fd int, name string) *File {
+ if fd < 0 {
return nil
}
- return &File{file, name, nil, 0}
+ return &File{fd, name, nil, 0}
}
// Stdin, Stdout, and Stderr are open Files pointing to the standard input,
@@ -74,7 +74,7 @@
func Open(name string, flag int, perm int) (file *File, err Error) {
r, e := syscall.Open(name, flag | syscall.O_CLOEXEC, perm);
if e != 0 {
- return nil, ErrnoToError(e);
+ return nil, &PathError{"open", name, Errno(e)};
}
// There's a race here with fork/exec, which we are
@@ -83,7 +83,7 @@
syscall.CloseOnExec(r);
}
- return NewFile(r, name), ErrnoToError(e)
+ return NewFile(r, name), nil;
}
// Close closes the File, rendering it unusable for I/O.
@@ -92,7 +92,10 @@
if file == nil {
return EINVAL
}
- err := ErrnoToError(syscall.Close(file.fd));
+ var err os.Error;
+ if e := syscall.Close(file.fd); e != 0 {
+ err = &PathError{"close", file.name, Errno(e)};
+ }
file.fd = -1; // so it can't be closed again
return err;
}
@@ -124,7 +127,10 @@
if n == 0 && e == 0 {
return 0, EOF
}
- return n, ErrnoToError(e);
+ if e != 0 {
+ err = &PathError{"read", file.name, Errno(e)};
+ }
+ return n, err
}
// Write writes len(b) bytes to the File.
@@ -146,7 +152,10 @@
} else {
file.nepipe = 0;
}
- return n, ErrnoToError(e)
+ if e != 0 {
+ err = &PathError{"write", file.name, Errno(e)};
+ }
+ return n, err
}
// Seek sets the offset for the next Read or Write on file to offset, interpreted
@@ -155,11 +164,11 @@
// It returns the new offset and an Error, if any.
func (file *File) Seek(offset int64, whence int) (ret int64, err Error) {
r, e := syscall.Seek(file.fd, offset, whence);
- if e != 0 {
- return -1, ErrnoToError(e)
+ if e == 0 && file.dirinfo != nil && r != 0 {
+ e = syscall.EISDIR;
}
- if file.dirinfo != nil && r != 0 {
- return -1, ErrnoToError(syscall.EISDIR)
+ if e != 0 {
+ return 0, &PathError{"seek", file.name, Errno(e)};
}
return r, nil
}
@@ -172,11 +181,7 @@
}
b := syscall.StringByteSlice(s);
b = b[0:len(b)-1];
- r, e := syscall.Write(file.fd, b);
- if r < 0 {
- r = 0
- }
- return int(r), ErrnoToError(e)
+ return file.Write(b);
}
// Pipe returns a connected pair of Files; reads from r return bytes written to w.
@@ -189,7 +194,7 @@
e := syscall.Pipe(&p);
if e != 0 {
syscall.ForkLock.RUnlock();
- return nil, nil, ErrnoToError(e)
+ return nil, nil, NewSyscallError("pipe", e);
}
syscall.CloseOnExec(p[0]);
syscall.CloseOnExec(p[1]);
@@ -201,7 +206,11 @@
// Mkdir creates a new directory with the specified name and permission bits.
// It returns an error, if any.
func Mkdir(name string, perm int) Error {
- return ErrnoToError(syscall.Mkdir(name, perm));
+ e := syscall.Mkdir(name, perm);
+ if e != 0 {
+ return &PathError{"mkdir", name, Errno(e)};
+ }
+ return nil;
}
// Stat returns a Dir structure describing the named file and an error, if any.
@@ -213,7 +222,7 @@
var lstat, stat syscall.Stat_t;
e := syscall.Lstat(name, &lstat);
if e != 0 {
- return nil, ErrnoToError(e);
+ return nil, &PathError{"stat", name, Errno(e)};
}
statp := &lstat;
if lstat.Mode & syscall.S_IFMT == syscall.S_IFLNK {
@@ -231,7 +240,7 @@
var stat syscall.Stat_t;
e := syscall.Fstat(file.fd, &stat);
if e != 0 {
- return nil, ErrnoToError(e)
+ return nil, &PathError{"stat", file.name, Errno(e)};
}
return dirFromStat(file.name, new(Dir), &stat, &stat), nil
}
@@ -243,7 +252,7 @@
var stat syscall.Stat_t;
e := syscall.Lstat(name, &stat);
if e != 0 {
- return nil, ErrnoToError(e)
+ return nil, &PathError{"lstat", name, Errno(e)};
}
return dirFromStat(name, new(Dir), &stat, &stat), nil
}
@@ -290,13 +299,19 @@
// Chdir changes the current working directory to the named directory.
func Chdir(dir string) Error {
- return ErrnoToError(syscall.Chdir(dir));
+ if e := syscall.Chdir(dir); e != 0 {
+ return &PathError{"chdir", dir, Errno(e)};
+ }
+ return nil;
}
// Chdir changes the current working directory to the file,
// which must be a directory.
func (f *File) Chdir() Error {
- return ErrnoToError(syscall.Fchdir(f.fd));
+ if e := syscall.Fchdir(f.fd); e != 0 {
+ return &PathError{"chdir", f.name, Errno(e)};
+ }
+ return nil;
}
// Remove removes the named file or directory.
@@ -326,17 +341,38 @@
if e1 != syscall.ENOTDIR {
e = e1;
}
- return ErrnoToError(e);
+ return &PathError{"remove", name, Errno(e)};
+}
+
+// LinkError records an error during a link or symlink
+// system call and the paths that caused it.
+type LinkError struct {
+ Op string;
+ Old string;
+ New string;
+ Error Error;
+}
+
+func (e *LinkError) String() string {
+ return e.Op + " " + e.Old + " " + e.New + ": " + e.Error.String();
}
// Link creates a hard link.
func Link(oldname, newname string) Error {
- return ErrnoToError(syscall.Link(oldname, newname));
+ e := syscall.Link(oldname, newname);
+ if e != 0 {
+ return &LinkError{"link", oldname, newname, Errno(e)};
+ }
+ return nil;
}
// Symlink creates a symbolic link.
func Symlink(oldname, newname string) Error {
- return ErrnoToError(syscall.Symlink(oldname, newname));
+ e := syscall.Symlink(oldname, newname);
+ if e != 0 {
+ return &LinkError{"symlink", oldname, newname, Errno(e)};
+ }
+ return nil;
}
// Readlink reads the contents of a symbolic link: the destination of
@@ -346,7 +382,7 @@
b := make([]byte, len);
n, e := syscall.Readlink(name, b);
if e != 0 {
- return "", ErrnoToError(e);
+ return "", &PathError{"readlink", name, Errno(e)};
}
if n < len {
return string(b[0:n]), nil;
@@ -359,40 +395,61 @@
// Chmod changes the mode of the named file to mode.
// If the file is a symbolic link, it changes the uid and gid of the link's target.
func Chmod(name string, mode int) Error {
- return ErrnoToError(syscall.Chmod(name, mode));
+ if e := syscall.Chmod(name, mode); e != 0 {
+ return &PathError{"chmod", name, Errno(e)};
+ }
+ return nil;
}
// Chmod changes the mode of the file to mode.
func (f *File) Chmod(mode int) Error {
- return ErrnoToError(syscall.Fchmod(f.fd, mode));
+ if e := syscall.Fchmod(f.fd, mode); e != 0 {
+ return &PathError{"chmod", f.name, Errno(e)};
+ }
+ return nil;
}
// Chown changes the numeric uid and gid of the named file.
// If the file is a symbolic link, it changes the uid and gid of the link's target.
func Chown(name string, uid, gid int) Error {
- return ErrnoToError(syscall.Chown(name, uid, gid));
+ if e := syscall.Chown(name, uid, gid); e != 0 {
+ return &PathError{"chown", name, Errno(e)};
+ }
+ return nil;
}
// Lchown changes the numeric uid and gid of the named file.
// If the file is a symbolic link, it changes the uid and gid of the link itself.
func Lchown(name string, uid, gid int) Error {
- return ErrnoToError(syscall.Lchown(name, uid, gid));
+ if e := syscall.Lchown(name, uid, gid); e != 0 {
+ return &PathError{"lchown", name, Errno(e)};
+ }
+ return nil;
}
// Chown changes the numeric uid and gid of the named file.
func (f *File) Chown(uid, gid int) Error {
- return ErrnoToError(syscall.Fchown(f.fd, uid, gid));
+ if e := syscall.Fchown(f.fd, uid, gid); e != 0 {
+ return &PathError{"chown", f.name, Errno(e)};
+ }
+ return nil;
}
// Truncate changes the size of the named file.
// If the file is a symbolic link, it changes the size of the link's target.
func Truncate(name string, size int64) Error {
- return ErrnoToError(syscall.Truncate(name, size));
+ if e := syscall.Truncate(name, size); e != 0 {
+ return &PathError{"truncate", name, Errno(e)};
+ }
+ return nil;
}
// Truncate changes the size of the file.
// It does not change the I/O offset.
func (f *File) Truncate(size int64) Error {
- return ErrnoToError(syscall.Ftruncate(f.fd, size));
+ if e := syscall.Ftruncate(f.fd, size); e != 0 {
+ return &PathError{"truncate", f.name, Errno(e)};
+ }
+ return nil;
}
diff --git a/src/pkg/os/getwd.go b/src/pkg/os/getwd.go
index 2d7b754..cbc6134 100644
--- a/src/pkg/os/getwd.go
+++ b/src/pkg/os/getwd.go
@@ -17,7 +17,7 @@
// If the operating system provides a Getwd call, use it.
if syscall.ImplementsGetwd {
s, e := syscall.Getwd();
- return s, ErrnoToError(e);
+ return s, NewSyscallError("getwd", e);
}
// Otherwise, we're trying to find our way back to ".".
diff --git a/src/pkg/os/os_test.go b/src/pkg/os/os_test.go
index 77b6944..fb555eb 100644
--- a/src/pkg/os/os_test.go
+++ b/src/pkg/os/os_test.go
@@ -549,3 +549,41 @@
}
f.Close();
}
+
+type openErrorTest struct {
+ path string;
+ mode int;
+ error string;
+}
+
+var openErrorTests = []openErrorTest {
+ openErrorTest {
+ "/etc/no-such-file",
+ O_RDONLY,
+ "open /etc/no-such-file: no such file or directory",
+ },
+ openErrorTest {
+ "/etc",
+ O_WRONLY,
+ "open /etc: is a directory",
+ },
+ openErrorTest {
+ "/etc/passwd/group",
+ O_WRONLY,
+ "open /etc/passwd/group: not a directory",
+ },
+}
+
+func TestOpenError(t *testing.T) {
+ for i, tt := range openErrorTests {
+ f, err := Open(tt.path, tt.mode, 0);
+ if err == nil {
+ t.Errorf("Open(%q, %d) succeeded", tt.path, tt.mode);
+ f.Close();
+ continue;
+ }
+ if s := err.String(); s != tt.error {
+ t.Errorf("Open(%q, %d) = _, %q; want %q", tt.path, tt.mode, s, tt.error);
+ }
+ }
+}
diff --git a/src/pkg/os/path.go b/src/pkg/os/path.go
index 0b86b8f..d8efe51 100644
--- a/src/pkg/os/path.go
+++ b/src/pkg/os/path.go
@@ -6,16 +6,6 @@
import "os"
-// PathError reports an error and the file path where it occurred.
-type PathError struct {
- Path string;
- Error Error;
-}
-
-func (p *PathError) String() string {
- return p.Path + ": " + p.Error.String();
-}
-
// MkdirAll creates a directory named path,
// along with any necessary parents, and returns nil,
// or else returns an error.
@@ -30,7 +20,7 @@
if dir.IsDirectory() {
return nil;
}
- return &PathError{path, ENOTDIR};
+ return &PathError{"mkdir", path, ENOTDIR};
}
// Doesn't already exist; make sure parent does.
@@ -61,7 +51,7 @@
if err1 == nil && dir.IsDirectory() {
return nil;
}
- return &PathError{path, err};
+ return err;
}
return nil;
}
@@ -77,19 +67,19 @@
}
// Otherwise, is this a directory we need to recurse into?
- dir, err1 := os.Lstat(path);
- if err1 != nil {
- return &PathError{path, err1};
+ dir, err := os.Lstat(path);
+ if err != nil {
+ return err;
}
if !dir.IsDirectory() {
// Not a directory; return the error from Remove.
- return &PathError{path, err};
+ return err;
}
// Directory.
fd, err := Open(path, os.O_RDONLY, 0);
if err != nil {
- return &PathError{path, err};
+ return err;
}
defer fd.Close();
@@ -99,13 +89,13 @@
names, err1 := fd.Readdirnames(100);
for i, name := range names {
err1 := RemoveAll(path + "/" + name);
- if err1 != nil && err == nil {
+ if err == nil {
err = err1;
}
}
// If Readdirnames returned an error, use it.
- if err1 != nil && err == nil {
- err = &PathError{path, err1};
+ if err == nil {
+ err = err1;
}
if len(names) == 0 {
break;
@@ -113,9 +103,9 @@
}
// Remove directory.
- err1 = Remove(path);
- if err1 != nil && err == nil {
- err = &PathError{path, err1};
+ err1 := Remove(path);
+ if err == nil {
+ err = err1;
}
return err;
}
diff --git a/src/pkg/os/proc.go b/src/pkg/os/proc.go
index d2fd649..9920c13 100644
--- a/src/pkg/os/proc.go
+++ b/src/pkg/os/proc.go
@@ -39,7 +39,7 @@
// Getgroups returns a list of the numeric ids of groups that the caller belongs to.
func Getgroups() ([]int, os.Error) {
gids, errno := syscall.Getgroups();
- return gids, ErrnoToError(errno);
+ return gids, NewSyscallError("getgroups", errno);
}
// Exit causes the current program to exit with the given status code.
diff --git a/src/pkg/os/time.go b/src/pkg/os/time.go
index 3eee243..e102206 100644
--- a/src/pkg/os/time.go
+++ b/src/pkg/os/time.go
@@ -17,7 +17,7 @@
func Time() (sec int64, nsec int64, err Error) {
var tv syscall.Timeval;
if errno := syscall.Gettimeofday(&tv); errno != 0 {
- return 0, 0, ErrnoToError(errno)
+ return 0, 0, NewSyscallError("gettimeofday", errno);
}
return int64(tv.Sec), int64(tv.Usec)*1000, err;
}
diff --git a/src/pkg/runtime/Makefile b/src/pkg/runtime/Makefile
index 281dca9..e1c320c 100644
--- a/src/pkg/runtime/Makefile
+++ b/src/pkg/runtime/Makefile
@@ -85,9 +85,13 @@
all: $(LIB) runtime.acid
-install: $(LIB) runtime.acid
+TARG=$(GOROOT)/pkg/$(GOOS)_$(GOARCH)/$(LIB)
+
+install: $(TARG)
+
+$(TARG): $(LIB) runtime.acid
test -d $(GOROOT)/pkg && mkdir -p $(GOROOT)/pkg/$(GOOS)_$(GOARCH)
- cp $(LIB) $(GOROOT)/pkg/$(GOOS)_$(GOARCH)/$(LIB)
+ cp $(LIB) $(TARG)
cp runtime.acid $(GOROOT)/acid/runtime.acid
$(LIB): $(OFILES)
@@ -96,7 +100,7 @@
$(OFILES): $(HFILES)
nuke:
- rm -f *.[568] *.a $(GOROOT)/lib/$(LIB)
+ rm -f *.[568] *.a $(TARG)
clean:
rm -f *.[568] *.a runtime.acid cgo2c */asm.h
diff --git a/src/pkg/strconv/Makefile b/src/pkg/strconv/Makefile
index 499f8c1..f295218 100644
--- a/src/pkg/strconv/Makefile
+++ b/src/pkg/strconv/Makefile
@@ -2,6 +2,7 @@
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
+
# DO NOT EDIT. Automatically generated by gobuild.
# gobuild -m >Makefile
@@ -20,7 +21,7 @@
coverage: packages
gotest
- 6cov -g `pwd` | grep -v '_test\.go:'
+ 6cov -g $$(pwd) | grep -v '_test\.go:'
%.$O: %.go
$(GC) -I_obj $*.go
@@ -32,12 +33,12 @@
$(AS) $*.s
O1=\
- atoi.$O\
decimal.$O\
itoa.$O\
quote.$O\
O2=\
+ atoi.$O\
ftoa.$O\
O3=\
@@ -48,11 +49,11 @@
_obj$D/strconv.a: phases
a1: $(O1)
- $(AR) grc _obj$D/strconv.a atoi.$O decimal.$O itoa.$O quote.$O
+ $(AR) grc _obj$D/strconv.a decimal.$O itoa.$O quote.$O
rm -f $(O1)
a2: $(O2)
- $(AR) grc _obj$D/strconv.a ftoa.$O
+ $(AR) grc _obj$D/strconv.a atoi.$O ftoa.$O
rm -f $(O2)
a3: $(O3)
diff --git a/src/pkg/strconv/atof.go b/src/pkg/strconv/atof.go
index c257b2a..6d6ec56 100644
--- a/src/pkg/strconv/atof.go
+++ b/src/pkg/strconv/atof.go
@@ -316,15 +316,18 @@
// Atof32 returns the nearest floating point number rounded
// using IEEE754 unbiased rounding.
//
-// If s is not syntactically well-formed, Atof32 returns err = os.EINVAL.
+// The errors that Atof32 returns have concrete type *NumError
+// and include err.Num = s.
+//
+// If s is not syntactically well-formed, Atof32 returns err.Error = os.EINVAL.
//
// If s is syntactically well-formed but is more than 1/2 ULP
// away from the largest floating point number of the given size,
-// Atof32 returns f = ±Inf, err = os.ERANGE.
+// Atof32 returns f = ±Inf, err.Error = os.ERANGE.
func Atof32(s string) (f float32, err os.Error) {
neg, d, trunc, ok := stringToDecimal(s);
if !ok {
- return 0, os.EINVAL;
+ return 0, &NumError{s, os.EINVAL};
}
if optimize {
if f, ok := decimalAtof32(neg, d, trunc); ok {
@@ -334,7 +337,7 @@
b, ovf := decimalToFloatBits(neg, d, trunc, &float32info);
f = math.Float32frombits(uint32(b));
if ovf {
- err = os.ERANGE;
+ err = &NumError{s, os.ERANGE};
}
return f, err
}
@@ -345,7 +348,7 @@
func Atof64(s string) (f float64, err os.Error) {
neg, d, trunc, ok := stringToDecimal(s);
if !ok {
- return 0, os.EINVAL;
+ return 0, &NumError{s, os.EINVAL};
}
if optimize {
if f, ok := decimalAtof64(neg, d, trunc); ok {
@@ -355,7 +358,7 @@
b, ovf := decimalToFloatBits(neg, d, trunc, &float64info);
f = math.Float64frombits(b);
if ovf {
- err = os.ERANGE;
+ err = &NumError{s, os.ERANGE};
}
return f, err
}
diff --git a/src/pkg/strconv/atof_test.go b/src/pkg/strconv/atof_test.go
index 6782f27..ecccab7 100644
--- a/src/pkg/strconv/atof_test.go
+++ b/src/pkg/strconv/atof_test.go
@@ -6,6 +6,7 @@
import (
"fmt";
"os";
+ "reflect";
"strconv";
"testing"
)
@@ -91,6 +92,17 @@
atofTest{ ".e-1", "0", os.EINVAL },
}
+func init() {
+ // The atof routines return NumErrors wrapping
+ // the error and the string. Convert the table above.
+ for i := range atoftests {
+ test := &atoftests[i];
+ if test.err != nil {
+ test.err = &NumError{test.in, test.err}
+ }
+ }
+}
+
func testAtof(t *testing.T, opt bool) {
oldopt := strconv.optimize;
strconv.optimize = opt;
@@ -98,7 +110,7 @@
test := &atoftests[i];
out, err := strconv.Atof64(test.in);
outs := strconv.Ftoa64(out, 'g', -1);
- if outs != test.out || err != test.err {
+ if outs != test.out || !reflect.DeepEqual(err, test.err) {
t.Errorf("strconv.Atof64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
@@ -106,7 +118,7 @@
if float64(float32(out)) == out {
out32, err := strconv.Atof32(test.in);
outs := strconv.Ftoa32(out32, 'g', -1);
- if outs != test.out || err != test.err {
+ if outs != test.out || !reflect.DeepEqual(err, test.err) {
t.Errorf("strconv.Atof32(%v) = %v, %v want %v, %v # %v\n",
test.in, out32, err, test.out, test.err, out);
}
@@ -115,7 +127,7 @@
if FloatSize == 64 || float64(float32(out)) == out {
outf, err := strconv.Atof(test.in);
outs := strconv.Ftoa(outf, 'g', -1);
- if outs != test.out || err != test.err {
+ if outs != test.out || !reflect.DeepEqual(err, test.err) {
t.Errorf("strconv.Ftoa(%v) = %v, %v want %v, %v # %v\n",
test.in, outf, err, test.out, test.err, out);
}
diff --git a/src/pkg/strconv/atoi.go b/src/pkg/strconv/atoi.go
index a5d896a..857b1af 100644
--- a/src/pkg/strconv/atoi.go
+++ b/src/pkg/strconv/atoi.go
@@ -3,7 +3,20 @@
// license that can be found in the LICENSE file.
package strconv
-import "os"
+import (
+ "os";
+ "strconv"
+)
+
+type NumError struct {
+ Num string;
+ Error os.Error;
+}
+
+func (e *NumError) String() string {
+ return "parsing " + e.Num + ": " + e.Error.String();
+}
+
func computeIntsize() uint {
siz := uint(8);
@@ -25,13 +38,18 @@
// Btoui64 interprets a string s in an arbitrary base b (2 to 36)
// and returns the corresponding value n.
//
-// Btoui64 returns err == os.EINVAL if b is out of
-// range or s is empty or contains invalid digits.
-// It returns err == os.ERANGE if the value corresponding
-// to s cannot be represented by a uint64.
+// The errors that Btoui64 returns have concrete type *NumError
+// and include err.Num = s. If s is empty or contains invalid
+// digits, err.Error = os.EINVAL; if the value corresponding
+// to s cannot be represented by a uint64, err.Error = os.ERANGE.
func Btoui64(s string, b int) (n uint64, err os.Error) {
- if b < 2 || b > 36 || len(s) < 1 {
- return 0, os.EINVAL;
+ if b < 2 || b > 36 {
+ err = os.ErrorString("invalid base " + Itoa(b));
+ goto Error;
+ }
+ if len(s) < 1 {
+ err = os.EINVAL;
+ goto Error;
}
n = 0;
@@ -47,27 +65,38 @@
case 'A' <= s[i] && s[i] <= 'Z':
v = s[i] - 'A' + 10;
default:
- return 0, os.EINVAL;
+ n = 0;
+ err = os.EINVAL;
+ goto Error;
}
if int(v) >= b {
- return 0, os.EINVAL;
+ n = 0;
+ err = os.EINVAL;
+ goto Error;
}
if n >= cutoff {
// n*b overflows
- return 1<<64-1, os.ERANGE;
+ n = 1<<64-1;
+ err = os.ERANGE;
+ goto Error;
}
n *= uint64(b);
n1 := n+uint64(v);
if n1 < n {
// n+v overflows
- return 1<<64-1, os.ERANGE;
+ n = 1<<64-1;
+ err = os.ERANGE;
+ goto Error;
}
n = n1;
}
return n, nil;
+
+Error:
+ return n, &NumError{s, err};
}
// Atoui64 interprets a string s as an unsigned decimal, octal, or
@@ -80,7 +109,7 @@
func Atoui64(s string) (n uint64, err os.Error) {
// Empty string bad.
if len(s) == 0 {
- return 0, os.EINVAL
+ return 0, &NumError{s, os.EINVAL}
}
// Look for octal, hex prefix.
@@ -102,7 +131,7 @@
func Atoi64(s string) (i int64, err os.Error) {
// Empty string bad.
if len(s) == 0 {
- return 0, os.EINVAL
+ return 0, &NumError{s, os.EINVAL}
}
// Pick off leading sign.
@@ -117,14 +146,14 @@
// Convert unsigned and check range.
var un uint64;
un, err = Atoui64(s);
- if err != nil && err != os.ERANGE {
+ if err != nil && err.(*NumError).Error != os.ERANGE {
return 0, err
}
if !neg && un >= 1<<63 {
- return 1<<63-1, os.ERANGE
+ return 1<<63-1, &NumError{s, os.ERANGE}
}
if neg && un > 1<<63 {
- return -1<<63, os.ERANGE
+ return -1<<63, &NumError{s, os.ERANGE}
}
n := int64(un);
if neg {
@@ -136,14 +165,12 @@
// Atoui is like Atoui64 but returns its result as a uint.
func Atoui(s string) (i uint, err os.Error) {
i1, e1 := Atoui64(s);
- if e1 != nil && e1 != os.ERANGE {
+ if e1 != nil && e1.(*NumError).Error != os.ERANGE {
return 0, e1
}
i = uint(i1);
if uint64(i) != i1 {
- // TODO: return uint(^0), os.ERANGE.
- i1 = 1<<64-1;
- return uint(i1), os.ERANGE
+ return ^uint(0), &NumError{s, os.ERANGE}
}
return i, nil
}
@@ -151,15 +178,15 @@
// Atoi is like Atoi64 but returns its result as an int.
func Atoi(s string) (i int, err os.Error) {
i1, e1 := Atoi64(s);
- if e1 != nil && e1 != os.ERANGE {
+ if e1 != nil && e1.(*NumError).Error != os.ERANGE {
return 0, e1
}
i = int(i1);
if int64(i) != i1 {
if i1 < 0 {
- return -1<<(intsize-1), os.ERANGE
+ return -1<<(intsize-1), &NumError{s, os.ERANGE}
}
- return 1<<(intsize-1) - 1, os.ERANGE
+ return 1<<(intsize-1) - 1, &NumError{s, os.ERANGE}
}
return i, nil
}
diff --git a/src/pkg/strconv/atoi_test.go b/src/pkg/strconv/atoi_test.go
index e4a9f95..2483a6f 100644
--- a/src/pkg/strconv/atoi_test.go
+++ b/src/pkg/strconv/atoi_test.go
@@ -7,6 +7,7 @@
import (
"fmt";
"os";
+ "reflect";
"strconv";
"testing"
)
@@ -44,7 +45,7 @@
err os.Error;
}
-var atoi64test = []atoi64Test {
+var atoi64tests = []atoi64Test {
atoi64Test{"", 0, os.EINVAL},
atoi64Test{"0", 0, nil},
atoi64Test{"-0", 0, nil},
@@ -118,11 +119,40 @@
atoi32Test{"-2147483649", -1<<31, os.ERANGE},
}
+func init() {
+ // The atoi routines return NumErrors wrapping
+ // the error and the string. Convert the tables above.
+ for i := range atoui64tests {
+ test := &atoui64tests[i];
+ if test.err != nil {
+ test.err = &NumError{test.in, test.err}
+ }
+ }
+ for i := range atoi64tests {
+ test := &atoi64tests[i];
+ if test.err != nil {
+ test.err = &NumError{test.in, test.err}
+ }
+ }
+ for i := range atoui32tests {
+ test := &atoui32tests[i];
+ if test.err != nil {
+ test.err = &NumError{test.in, test.err}
+ }
+ }
+ for i := range atoi32tests {
+ test := &atoi32tests[i];
+ if test.err != nil {
+ test.err = &NumError{test.in, test.err}
+ }
+ }
+}
+
func TestAtoui64(t *testing.T) {
- for i := 0; i < len(atoui64tests); i++ {
+ for i := range atoui64tests {
test := &atoui64tests[i];
out, err := strconv.Atoui64(test.in);
- if test.out != out || test.err != err {
+ if test.out != out || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoui64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
@@ -130,10 +160,10 @@
}
func TestAtoi64(t *testing.T) {
- for i := 0; i < len(atoi64test); i++ {
- test := &atoi64test[i];
+ for i := range atoi64tests {
+ test := &atoi64tests[i];
out, err := strconv.Atoi64(test.in);
- if test.out != out || test.err != err {
+ if test.out != out || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoi64(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
@@ -143,19 +173,19 @@
func TestAtoui(t *testing.T) {
switch intsize {
case 32:
- for i := 0; i < len(atoui32tests); i++ {
+ for i := range atoui32tests {
test := &atoui32tests[i];
out, err := strconv.Atoui(test.in);
- if test.out != uint32(out) || test.err != err {
+ if test.out != uint32(out) || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoui(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
case 64:
- for i := 0; i < len(atoui64tests); i++ {
+ for i := range atoui64tests {
test := &atoui64tests[i];
out, err := strconv.Atoui(test.in);
- if test.out != uint64(out) || test.err != err {
+ if test.out != uint64(out) || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoui(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
@@ -166,19 +196,19 @@
func TestAtoi(t *testing.T) {
switch intsize {
case 32:
- for i := 0; i < len(atoi32tests); i++ {
+ for i := range atoi32tests {
test := &atoi32tests[i];
out, err := strconv.Atoi(test.in);
- if test.out != int32(out) || test.err != err {
+ if test.out != int32(out) || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoi(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
}
case 64:
- for i := 0; i < len(atoi64test); i++ {
- test := &atoi64test[i];
+ for i := range atoi64tests {
+ test := &atoi64tests[i];
out, err := strconv.Atoi(test.in);
- if test.out != int64(out) || test.err != err {
+ if test.out != int64(out) || !reflect.DeepEqual(test.err, err) {
t.Errorf("strconv.Atoi(%v) = %v, %v want %v, %v\n",
test.in, out, err, test.out, test.err);
}
diff --git a/src/pkg/time/sleep.go b/src/pkg/time/sleep.go
index 3bb76cf..6f9ab12 100644
--- a/src/pkg/time/sleep.go
+++ b/src/pkg/time/sleep.go
@@ -13,5 +13,5 @@
// Sleep pauses the current goroutine for ns nanoseconds.
// It returns os.EINTR if interrupted.
func Sleep(ns int64) os.Error {
- return os.ErrnoToError(syscall.Sleep(ns));
+ return os.NewSyscallError("sleep", syscall.Sleep(ns));
}
diff --git a/src/pkg/time/time.go b/src/pkg/time/time.go
index ea9b66c..3d69d99 100644
--- a/src/pkg/time/time.go
+++ b/src/pkg/time/time.go
@@ -159,10 +159,7 @@
// SecondsToLocalTime converts sec, in number of seconds since the Unix epoch,
// into a parsed Time value in the local time zone.
func SecondsToLocalTime(sec int64) *Time {
- z, offset, err := time.lookupTimezone(sec);
- if err != nil {
- return SecondsToUTC(sec)
- }
+ z, offset := time.lookupTimezone(sec);
t := SecondsToUTC(sec+int64(offset));
t.Zone = z;
t.ZoneOffset = offset;
diff --git a/src/pkg/time/zoneinfo.go b/src/pkg/time/zoneinfo.go
index c4fe814..e2102f1 100644
--- a/src/pkg/time/zoneinfo.go
+++ b/src/pkg/time/zoneinfo.go
@@ -21,14 +21,6 @@
zoneDir = "/usr/share/zoneinfo/";
)
-// Errors that can be generated recovering time zone information.
-type TimeZoneError struct {
- os.ErrorString
-}
-
-var errShort = TimeZoneError{ "time: short zone file" }
-var errInvalid = TimeZoneError{ "time: invalid zone file" }
-
// Simple I/O interface to binary blob of data.
type data struct {
p []byte;
@@ -89,18 +81,18 @@
isstd, isutc bool; // ignored - no idea what these mean
}
-func parseinfo(bytes []byte) (zt []zonetime, err os.Error) {
+func parseinfo(bytes []byte) (zt []zonetime, ok bool) {
d := data{bytes, false};
// 4-byte magic "TZif"
if magic := d.read(4); string(magic) != "TZif" {
- return nil, TimeZoneError{ "time: bad zone magic" }
+ return nil, false
}
// 1-byte version, then 15 bytes of padding
var p []byte;
if p = d.read(16); len(p) != 16 || p[0] != 0 && p[0] != '2' {
- return nil, TimeZoneError { "time: bad zone file version" }
+ return nil, false
}
vers := p[0];
@@ -123,7 +115,7 @@
for i := 0; i < 6; i++ {
nn, ok := d.big4();
if !ok {
- return nil, errShort
+ return nil, false
}
n[i] = int(nn);
}
@@ -152,7 +144,7 @@
isutc := d.read(n[NUTCLocal]);
if d.error { // ran out of data
- return nil, errShort
+ return nil, false
}
// If version == 2, the entire file repeats, this time using
@@ -167,16 +159,16 @@
var ok bool;
var n uint32;
if n, ok = zonedata.big4(); !ok {
- return nil, errShort
+ return nil, false
}
z[i].utcoff = int(n);
var b byte;
if b, ok = zonedata.byte(); !ok {
- return nil, errShort
+ return nil, false
}
z[i].isdst = b != 0;
if b, ok = zonedata.byte(); !ok || int(b) >= len(abbrev) {
- return nil, errInvalid
+ return nil, false
}
z[i].name = byteString(abbrev[b:len(abbrev)])
}
@@ -187,11 +179,11 @@
var ok bool;
var n uint32;
if n, ok = txtimes.big4(); !ok {
- return nil, errShort
+ return nil, false
}
zt[i].time = int32(n);
if int(txzones[i]) >= len(z) {
- return nil, errInvalid
+ return nil, false
}
zt[i].zone = &z[txzones[i]];
if i < len(isstd) {
@@ -201,29 +193,18 @@
zt[i].isutc = isutc[i] != 0
}
}
- return zt, nil
+ return zt, true
}
-func readinfofile(name string) ([]zonetime, os.Error) {
+func readinfofile(name string) ([]zonetime, bool) {
buf, err := io.ReadFile(name);
if err != nil {
- goto Error;
+ return nil, false
}
- tx, err := parseinfo(buf);
- if err != nil {
- goto Error;
- }
- return tx, nil;
-
-Error:
- if tzerr, ok := err.(TimeZoneError); ok {
- tzerr.ErrorString = os.ErrorString(tzerr.String() + ": " + name)
- }
- return nil, err
+ return parseinfo(buf);
}
var zones []zonetime
-var zoneerr os.Error
func setupZone() {
// consult $TZ to find the time zone to use.
@@ -232,23 +213,21 @@
// $TZ="foo" means use /usr/share/zoneinfo/foo.
tz, err := os.Getenv("TZ");
- var file string;
+ var ok bool;
switch {
case err == os.ENOENV:
- zones, zoneerr = readinfofile("/etc/localtime");
- case err != nil:
- zoneerr = err;
+ zones, ok = readinfofile("/etc/localtime");
case len(tz) > 0:
- zones, zoneerr = readinfofile(zoneDir + tz);
+ zones, ok = readinfofile(zoneDir + tz);
case len(tz) == 0:
// do nothing: use UTC
}
}
-func lookupTimezone(sec int64) (zone string, offset int, err os.Error) {
+func lookupTimezone(sec int64) (zone string, offset int) {
once.Do(setupZone);
- if zoneerr != nil || len(zones) == 0 {
- return "UTC", 0, zoneerr
+ if len(zones) == 0 {
+ return "UTC", 0
}
// Binary search for entry with largest time <= sec
@@ -262,5 +241,5 @@
}
}
z := tz[0].zone;
- return z.name, z.utcoff, nil
+ return z.name, z.utcoff
}
