From 5f6228d4cc746ff0cfe4e5aac13e49712b0a3e45 Mon Sep 17 00:00:00 2001 From: Miek Gieben Date: Thu, 20 Jun 2013 07:27:28 +0100 Subject: [PATCH] Use the non-exported version err --- defaults.go | 2 +- msg.go | 126 ++++++++++++++++++++++++++-------------------------- server.go | 4 +- 3 files changed, 66 insertions(+), 66 deletions(-) diff --git a/defaults.go b/defaults.go index cc72ad81..87da6054 100644 --- a/defaults.go +++ b/defaults.go @@ -265,7 +265,7 @@ func Fqdn(s string) string { func ReverseAddr(addr string) (arpa string, err error) { ip := net.ParseIP(addr) if ip == nil { - return "", &Error{Err: "unrecognized address: " + addr} + return "", &Error{err: "unrecognized address: " + addr} } if ip.To4() != nil { return strconv.Itoa(int(ip[15])) + "." + strconv.Itoa(int(ip[14])) + "." + strconv.Itoa(int(ip[13])) + "." + diff --git a/msg.go b/msg.go index fdc0bb1f..2f25c1d1 100644 --- a/msg.go +++ b/msg.go @@ -28,27 +28,27 @@ import ( const maxCompressionOffset = 2 << 13 // We have 14 bits for the compression pointer var ( - ErrFqdn error = &Error{Err: "domain must be fully qualified"} - ErrId error = &Error{Err: "id mismatch"} - ErrRdata error = &Error{Err: "bad rdata"} - ErrBuf error = &Error{Err: "buffer size too small"} - ErrShortRead error = &Error{Err: "short read"} - ErrConn error = &Error{Err: "conn holds both UDP and TCP connection"} - ErrConnEmpty error = &Error{Err: "conn has no connection"} - ErrServ error = &Error{Err: "no servers could be reached"} - ErrKey error = &Error{Err: "bad key"} - ErrPrivKey error = &Error{Err: "bad private key"} - ErrKeySize error = &Error{Err: "bad key size"} - ErrKeyAlg error = &Error{Err: "bad key algorithm"} - ErrAlg error = &Error{Err: "bad algorithm"} - ErrTime error = &Error{Err: "bad time"} - ErrNoSig error = &Error{Err: "no signature found"} - ErrSig error = &Error{Err: "bad signature"} - ErrSecret error = &Error{Err: "no secrets defined"} - ErrSigGen error = &Error{Err: "bad signature generation"} - ErrAuth error = &Error{Err: "bad authentication"} - ErrSoa error = &Error{Err: "no SOA"} - ErrRRset error = &Error{Err: "bad rrset"} + ErrFqdn error = &Error{err: "domain must be fully qualified"} + ErrId error = &Error{err: "id mismatch"} + ErrRdata error = &Error{err: "bad rdata"} + ErrBuf error = &Error{err: "buffer size too small"} + ErrShortRead error = &Error{err: "short read"} + ErrConn error = &Error{err: "conn holds both UDP and TCP connection"} + ErrConnEmpty error = &Error{err: "conn has no connection"} + ErrServ error = &Error{err: "no servers could be reached"} + ErrKey error = &Error{err: "bad key"} + ErrPrivKey error = &Error{err: "bad private key"} + ErrKeySize error = &Error{err: "bad key size"} + ErrKeyAlg error = &Error{err: "bad key algorithm"} + ErrAlg error = &Error{err: "bad algorithm"} + ErrTime error = &Error{err: "bad time"} + ErrNoSig error = &Error{err: "no signature found"} + ErrSig error = &Error{err: "bad signature"} + ErrSecret error = &Error{err: "no secrets defined"} + ErrSigGen error = &Error{err: "bad signature generation"} + ErrAuth error = &Error{err: "bad authentication"} + ErrSoa error = &Error{err: "no SOA"} + ErrRRset error = &Error{err: "bad rrset"} ) // A manually-unpacked version of (id, bits). @@ -379,7 +379,7 @@ Loop: off1 = off } if ptr++; ptr > 10 { - return "", lenmsg, &Error{Err: "too many compression pointers"} + return "", lenmsg, &Error{err: "too many compression pointers"} } off = (c^0xC0)<<8 | int(c1) default: @@ -400,7 +400,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str for i := 0; i < val.NumField(); i++ { switch fv := val.Field(i); fv.Kind() { default: - return lenmsg, &Error{Err: "bad kind packing"} + return lenmsg, &Error{err: "bad kind packing"} case reflect.Slice: switch val.Type().Field(i).Tag { default: @@ -418,7 +418,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str element := val.Field(i).Index(j).String() // Counted string: 1 byte length. if len(element) > 255 || off+1+len(element) > lenmsg { - return lenmsg, &Error{Err: "overflow packing txt"} + return lenmsg, &Error{err: "overflow packing txt"} } msg[off] = byte(len(element)) off++ @@ -432,7 +432,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str element := val.Field(i).Index(j).Interface() b, e := element.(EDNS0).pack() if e != nil { - return lenmsg, &Error{Err: "overflow packing opt"} + return lenmsg, &Error{err: "overflow packing opt"} } // Option code msg[off], msg[off+1] = packUint16(element.(EDNS0).Option()) @@ -447,7 +447,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str // It must be a slice of 4, even if it is 16, we encode // only the first 4 if off+net.IPv4len > lenmsg { - return lenmsg, &Error{Err: "overflow packing a"} + return lenmsg, &Error{err: "overflow packing a"} } switch fv.Len() { case net.IPv6len: @@ -465,12 +465,12 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str case 0: // Allowed, for dynamic updates default: - return lenmsg, &Error{Err: "overflow packing a"} + return lenmsg, &Error{err: "overflow packing a"} } case `dns:"aaaa"`: // fv.Len TODO(mg) dynamisc updates? if fv.Len() > net.IPv6len || off+fv.Len() > lenmsg { - return lenmsg, &Error{Err: "overflow packing aaaa"} + return lenmsg, &Error{err: "overflow packing aaaa"} } for j := 0; j < net.IPv6len; j++ { msg[off] = byte(fv.Index(j).Uint()) @@ -485,7 +485,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str serv := uint16((fv.Index(j).Uint())) bitmapbyte = uint16(serv / 8) if int(bitmapbyte) > lenmsg { - return lenmsg, &Error{Err: "overflow packing wks"} + return lenmsg, &Error{err: "overflow packing wks"} } bit := uint16(serv) - bitmapbyte*8 msg[bitmapbyte] = byte(1 << (7 - bit)) @@ -501,7 +501,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str lastwindow := uint16(0) length := uint16(0) if off+2 > lenmsg { - return lenmsg, &Error{Err: "overflow packing nsecx"} + return lenmsg, &Error{err: "overflow packing nsecx"} } for j := 0; j < val.Field(i).Len(); j++ { t := uint16((fv.Index(j).Uint())) @@ -510,13 +510,13 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str // New window, jump to the new offset off += int(length) + 3 if off > lenmsg { - return lenmsg, &Error{Err: "overflow packing nsecx bitmap"} + return lenmsg, &Error{err: "overflow packing nsecx bitmap"} } } length = (t - window*256) / 8 bit := t - (window * 256) - (length * 8) if off+2+int(length) > lenmsg { - return lenmsg, &Error{Err: "overflow packing nsecx bitmap"} + return lenmsg, &Error{err: "overflow packing nsecx bitmap"} } // Setting the window # @@ -530,7 +530,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str off += 2 + int(length) off++ if off > lenmsg { - return lenmsg, &Error{Err: "overflow packing nsecx bitmap"} + return lenmsg, &Error{err: "overflow packing nsecx bitmap"} } } case reflect.Struct: @@ -540,13 +540,13 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str } case reflect.Uint8: if off+1 > lenmsg { - return lenmsg, &Error{Err: "overflow packing uint8"} + return lenmsg, &Error{err: "overflow packing uint8"} } msg[off] = byte(fv.Uint()) off++ case reflect.Uint16: if off+2 > lenmsg { - return lenmsg, &Error{Err: "overflow packing uint16"} + return lenmsg, &Error{err: "overflow packing uint16"} } i := fv.Uint() msg[off] = byte(i >> 8) @@ -554,7 +554,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str off += 2 case reflect.Uint32: if off+4 > lenmsg { - return lenmsg, &Error{Err: "overflow packing uint32"} + return lenmsg, &Error{err: "overflow packing uint32"} } i := fv.Uint() msg[off] = byte(i >> 24) @@ -566,7 +566,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str switch val.Type().Field(i).Tag { default: if off+8 > lenmsg { - return lenmsg, &Error{Err: "overflow packing uint64"} + return lenmsg, &Error{err: "overflow packing uint64"} } i := fv.Uint() msg[off] = byte(i >> 56) @@ -581,7 +581,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str case `dns:"uint48"`: // Used in TSIG, where it stops at 48 bits, so we discard the upper 16 if off+6 > lenmsg { - return lenmsg, &Error{Err: "overflow packing uint64 as uint48"} + return lenmsg, &Error{err: "overflow packing uint64 as uint48"} } i := fv.Uint() msg[off] = byte(i >> 40) @@ -602,7 +602,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str case `dns:"base64"`: b64, err := packBase64([]byte(s)) if err != nil { - return lenmsg, &Error{Err: "overflow packing base64"} + return lenmsg, &Error{err: "overflow packing base64"} } copy(msg[off:off+len(b64)], b64) off += len(b64) @@ -623,7 +623,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str case `dns:"base32"`: b32, err := packBase32([]byte(s)) if err != nil { - return lenmsg, &Error{Err: "overflow packing base32"} + return lenmsg, &Error{err: "overflow packing base32"} } copy(msg[off:off+len(b32)], b32) off += len(b32) @@ -633,10 +633,10 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str // There is no length encoded here h, e := hex.DecodeString(s) if e != nil { - return lenmsg, &Error{Err: "overflow packing hex"} + return lenmsg, &Error{err: "overflow packing hex"} } if off+hex.DecodedLen(len(s)) > lenmsg { - return lenmsg, &Error{Err: "overflow packing hex"} + return lenmsg, &Error{err: "overflow packing hex"} } copy(msg[off:off+hex.DecodedLen(len(s))], h) off += hex.DecodedLen(len(s)) @@ -650,7 +650,7 @@ func packStructValue(val reflect.Value, msg []byte, off int, compression map[str case "": // Counted string: 1 byte length. if len(s) > 255 || off+1+len(s) > lenmsg { - return lenmsg, &Error{Err: "overflow packing string"} + return lenmsg, &Error{err: "overflow packing string"} } msg[off] = byte(len(s)) off++ @@ -687,7 +687,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er for i := 0; i < val.NumField(); i++ { switch fv := val.Field(i); fv.Kind() { default: - return lenmsg, &Error{Err: "bad kind unpacking"} + return lenmsg, &Error{err: "bad kind unpacking"} case reflect.Slice: switch val.Type().Field(i).Tag { default: @@ -710,7 +710,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er Txts: l := int(msg[off]) if off+l+1 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking txt"} + return lenmsg, &Error{err: "overflow unpacking txt"} } txt = append(txt, string(msg[off+1:off+l+1])) off += l + 1 @@ -731,12 +731,12 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er Option: code := uint16(0) if off+2 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking opt"} + return lenmsg, &Error{err: "overflow unpacking opt"} } code, off = unpackUint16(msg, off) optlen, off1 := unpackUint16(msg, off) if off1+int(optlen) > off+rdlength { - return lenmsg, &Error{Err: "overflow unpacking opt"} + return lenmsg, &Error{err: "overflow unpacking opt"} } switch code { case EDNS0NSID: @@ -784,13 +784,13 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er fv.Set(reflect.ValueOf(edns)) case `dns:"a"`: if off+net.IPv4len > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking a"} + return lenmsg, &Error{err: "overflow unpacking a"} } fv.Set(reflect.ValueOf(net.IPv4(msg[off], msg[off+1], msg[off+2], msg[off+3]))) off += net.IPv4len case `dns:"aaaa"`: if off+net.IPv6len > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking aaaa"} + return lenmsg, &Error{err: "overflow unpacking aaaa"} } fv.Set(reflect.ValueOf(net.IP{msg[off], msg[off+1], msg[off+2], msg[off+3], msg[off+4], msg[off+5], msg[off+6], msg[off+7], msg[off+8], msg[off+9], msg[off+10], @@ -839,7 +839,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er endrr := rdstart + rdlength if off+2 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking nsecx"} + return lenmsg, &Error{err: "overflow unpacking nsecx"} } nsec := make([]uint16, 0) length := 0 @@ -902,20 +902,20 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er } case reflect.Uint8: if off+1 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking uint8"} + return lenmsg, &Error{err: "overflow unpacking uint8"} } fv.SetUint(uint64(uint8(msg[off]))) off++ case reflect.Uint16: var i uint16 if off+2 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking uint16"} + return lenmsg, &Error{err: "overflow unpacking uint16"} } i, off = unpackUint16(msg, off) fv.SetUint(uint64(i)) case reflect.Uint32: if off+4 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking uint32"} + return lenmsg, &Error{err: "overflow unpacking uint32"} } fv.SetUint(uint64(uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3]))) off += 4 @@ -923,7 +923,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er switch val.Type().Field(i).Tag { default: if off+8 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking uint64"} + return lenmsg, &Error{err: "overflow unpacking uint64"} } fv.SetUint(uint64(uint64(msg[off])<<56 | uint64(msg[off+1])<<48 | uint64(msg[off+2])<<40 | uint64(msg[off+3])<<32 | uint64(msg[off+4])<<24 | uint64(msg[off+5])<<16 | uint64(msg[off+6])<<8 | uint64(msg[off+7]))) @@ -931,7 +931,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er case `dns:"uint48"`: // Used in TSIG where the last 48 bits are occupied, so for now, assume a uint48 (6 bytes) if off+6 > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking uint64 as uint48"} + return lenmsg, &Error{err: "overflow unpacking uint64 as uint48"} } fv.SetUint(uint64(uint64(msg[off])<<40 | uint64(msg[off+1])<<32 | uint64(msg[off+2])<<24 | uint64(msg[off+3])<<16 | uint64(msg[off+4])<<8 | uint64(msg[off+5]))) @@ -947,7 +947,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er rdlength := int(val.FieldByName("Hdr").FieldByName("Rdlength").Uint()) endrr := rdstart + rdlength if endrr > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking hex"} + return lenmsg, &Error{err: "overflow unpacking hex"} } s = hex.EncodeToString(msg[off:endrr]) off = endrr @@ -956,7 +956,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er rdlength := int(val.FieldByName("Hdr").FieldByName("Rdlength").Uint()) endrr := rdstart + rdlength if endrr > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking base64"} + return lenmsg, &Error{err: "overflow unpacking base64"} } s = unpackBase64(msg[off:endrr]) off = endrr @@ -978,7 +978,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er } } if off+size > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking base32"} + return lenmsg, &Error{err: "overflow unpacking base32"} } s = unpackBase32(msg[off : off+size]) off += size @@ -1006,7 +1006,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er } } if off+size > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking hex"} + return lenmsg, &Error{err: "overflow unpacking hex"} } s = hex.EncodeToString(msg[off : off+size]) off += size @@ -1015,7 +1015,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er rdlength := int(val.FieldByName("Hdr").FieldByName("Rdlength").Uint()) Txt: if off >= lenmsg || off+1+int(msg[off]) > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking txt"} + return lenmsg, &Error{err: "overflow unpacking txt"} } n := int(msg[off]) off++ @@ -1029,7 +1029,7 @@ func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err er } case "": if off >= lenmsg || off+1+int(msg[off]) > lenmsg { - return lenmsg, &Error{Err: "overflow unpacking string"} + return lenmsg, &Error{err: "overflow unpacking string"} } n := int(msg[off]) off++ @@ -1102,7 +1102,7 @@ func packBase32(s []byte) ([]byte, error) { // about the compression. func PackRR(rr RR, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) { if rr == nil { - return len(msg), &Error{Err: "nil rr"} + return len(msg), &Error{err: "nil rr"} } off1, err = packStructCompress(rr, msg, off, compression, compress) @@ -1131,7 +1131,7 @@ func UnpackRR(msg []byte, off int) (rr RR, off1 int, err error) { } off, err = UnpackStruct(rr, msg, off0) if off != end { - return &h, end, &Error{Err: "bad rdlength"} + return &h, end, &Error{err: "bad rdlength"} } return rr, off, err } diff --git a/server.go b/server.go index 721477f5..6cb9e7dc 100644 --- a/server.go +++ b/server.go @@ -298,7 +298,7 @@ func (srv *Server) ListenAndServe() error { } return srv.serveUDP(l) } - return &Error{Err: "bad network"} + return &Error{err: "bad network"} } // serveTCP starts a TCP listener for the server. @@ -454,7 +454,7 @@ func (w *response) Write(m []byte) (int, error) { case w.tcp != nil: lm := len(m) if len(m) > MaxMsgSize { - return 0, &Error{Err: "message too large"} + return 0, &Error{err: "message too large"} } l := make([]byte, 2) l[0], l[1] = packUint16(uint16(lm))