Fixed golint on base library.

Author: gconnell

base.go

@@ -33,14 +33,30 @@ type Layer interface {
 type Payload []byte
 
 // LayerType returns LayerTypePayload
-func (p Payload) LayerType() LayerType     { return LayerTypePayload }
-func (p Payload) LayerContents() []byte    { return []byte(p) }
-func (p Payload) LayerPayload() []byte     { return nil }
-func (p Payload) Payload() []byte          { return []byte(p) }
-func (p Payload) String() string           { return fmt.Sprintf("%d byte(s)", len(p)) }
-func (p Payload) GoString() string         { return LongBytesGoString([]byte(p)) }
-func (p Payload) CanDecode() LayerClass    { return LayerTypePayload }
+func (p Payload) LayerType() LayerType { return LayerTypePayload }
+
+// LayerContents returns the bytes making up this layer.
+func (p Payload) LayerContents() []byte { return []byte(p) }
+
+// LayerPayload returns the payload within this layer.
+func (p Payload) LayerPayload() []byte { return nil }
+
+// Payload returns this layer as bytes.
+func (p Payload) Payload() []byte { return []byte(p) }
+
+// String implements fmt.Stringer.
+func (p Payload) String() string { return fmt.Sprintf("%d byte(s)", len(p)) }
+
+// GoString implements fmt.GoStringer.
+func (p Payload) GoString() string { return LongBytesGoString([]byte(p)) }
+
+// CanDecode implements DecodingLayer.
+func (p Payload) CanDecode() LayerClass { return LayerTypePayload }
+
+// NextLayerType implements DecodingLayer.
 func (p Payload) NextLayerType() LayerType { return LayerTypeZero }
+
+// DecodeFromBytes implements DecodingLayer.
 func (p *Payload) DecodeFromBytes(data []byte, df DecodeFeedback) error {
 	*p = Payload(data)
 	return nil
@@ -74,13 +90,27 @@ func decodePayload(data []byte, p PacketBuilder) error {
 type Fragment []byte
 
 // LayerType returns LayerTypeFragment
-func (p *Fragment) LayerType() LayerType     { return LayerTypeFragment }
-func (p *Fragment) LayerContents() []byte    { return []byte(*p) }
-func (p *Fragment) LayerPayload() []byte     { return nil }
-func (p *Fragment) Payload() []byte          { return []byte(*p) }
-func (p *Fragment) String() string           { return fmt.Sprintf("%d byte(s)", len(*p)) }
-func (p *Fragment) CanDecode() LayerClass    { return LayerTypeFragment }
+func (p *Fragment) LayerType() LayerType { return LayerTypeFragment }
+
+// LayerContents implements Layer.
+func (p *Fragment) LayerContents() []byte { return []byte(*p) }
+
+// LayerPayload implements Layer.
+func (p *Fragment) LayerPayload() []byte { return nil }
+
+// Payload returns this layer as a byte slice.
+func (p *Fragment) Payload() []byte { return []byte(*p) }
+
+// String implements fmt.Stringer.
+func (p *Fragment) String() string { return fmt.Sprintf("%d byte(s)", len(*p)) }
+
+// CanDecode implements DecodingLayer.
+func (p *Fragment) CanDecode() LayerClass { return LayerTypeFragment }
+
+// NextLayerType implements DecodingLayer.
 func (p *Fragment) NextLayerType() LayerType { return LayerTypeZero }
+
+// DecodeFromBytes implements DecodingLayer.
 func (p *Fragment) DecodeFromBytes(data []byte, df DecodeFeedback) error {
 	*p = Fragment(data)
 	return nil

decode.go

@@ -79,6 +79,7 @@ type Decoder interface {
 // DecodeFunc wraps a function to make it a Decoder.
 type DecodeFunc func([]byte, PacketBuilder) error
 
+// Decode implements Decoder by calling itself.
 func (d DecodeFunc) Decode(data []byte, p PacketBuilder) error {
 	// function, call thyself.
 	return d(data, p)
@@ -99,18 +100,18 @@ var DecodeFragment Decoder = DecodeFunc(decodeFragment)
 
 // LayerTypeZero is an invalid layer type, but can be used to determine whether
 // layer type has actually been set correctly.
-var LayerTypeZero LayerType = RegisterLayerType(0, LayerTypeMetadata{"Unknown", DecodeUnknown})
+var LayerTypeZero = RegisterLayerType(0, LayerTypeMetadata{Name: "Unknown", Decoder: DecodeUnknown})
 
 // LayerTypeDecodeFailure is the layer type for the default error layer.
-var LayerTypeDecodeFailure LayerType = RegisterLayerType(1, LayerTypeMetadata{"DecodeFailure", DecodeUnknown})
+var LayerTypeDecodeFailure = RegisterLayerType(1, LayerTypeMetadata{Name: "DecodeFailure", Decoder: DecodeUnknown})
 
 // LayerTypePayload is the layer type for a payload that we don't try to decode
 // but treat as a success, IE: an application-level payload.
-var LayerTypePayload LayerType = RegisterLayerType(2, LayerTypeMetadata{"Payload", DecodePayload})
+var LayerTypePayload = RegisterLayerType(2, LayerTypeMetadata{Name: "Payload", Decoder: DecodePayload})
 
 // LayerTypeFragment is the layer type for a fragment of a layer transported
 // by an underlying layer that supports fragmentation.
-var LayerTypeFragment LayerType = RegisterLayerType(3, LayerTypeMetadata{"Fragment", DecodeFragment})
+var LayerTypeFragment = RegisterLayerType(3, LayerTypeMetadata{Name: "Fragment", Decoder: DecodeFragment})
 
 // DecodeFailure is a packet layer created if decoding of the packet data failed
 // for some reason.  It implements ErrorLayer.  LayerContents will be the entire
@@ -123,12 +124,20 @@ type DecodeFailure struct {
 }
 
 // Error returns the error encountered during decoding.
-func (d *DecodeFailure) Error() error          { return d.err }
+func (d *DecodeFailure) Error() error { return d.err }
+
+// LayerContents implements Layer.
 func (d *DecodeFailure) LayerContents() []byte { return d.data }
-func (d *DecodeFailure) LayerPayload() []byte  { return nil }
+
+// LayerPayload implements Layer.
+func (d *DecodeFailure) LayerPayload() []byte { return nil }
+
+// String implements fmt.Stringer.
 func (d *DecodeFailure) String() string {
 	return "Packet decoding error: " + d.Error().Error()
 }
+
+// Dump implements Dumper.
 func (d *DecodeFailure) Dump() (s string) {
 	if d.stack != nil {
 		s = string(d.stack)

flows.go

@@ -36,11 +36,11 @@ type Endpoint struct {
 }
 
 // EndpointType returns the endpoint type associated with this endpoint.
-func (e Endpoint) EndpointType() EndpointType { return e.typ }
+func (a Endpoint) EndpointType() EndpointType { return a.typ }
 
 // Raw returns the raw bytes of this endpoint.  These aren't human-readable
 // most of the time, but they are faster than calling String.
-func (e Endpoint) Raw() []byte { return e.raw[:e.len] }
+func (a Endpoint) Raw() []byte { return a.raw[:a.len] }
 
 // LessThan provides a stable ordering for all endpoints.  It sorts first based
 // on the EndpointType of an endpoint, then based on the raw bytes of that
@@ -130,11 +130,11 @@ func (e EndpointType) String() string {
 	return strconv.Itoa(int(e))
 }
 
-func (e Endpoint) String() string {
-	if t, ok := endpointTypes[e.typ]; ok && t.Formatter != nil {
-		return t.Formatter(e.raw[:e.len])
+func (a Endpoint) String() string {
+	if t, ok := endpointTypes[a.typ]; ok && t.Formatter != nil {
+		return t.Formatter(a.raw[:a.len])
 	}
-	return fmt.Sprintf("%v:%v", e.typ, e.raw)
+	return fmt.Sprintf("%v:%v", a.typ, a.raw)
 }
 
 // Flow represents the direction of traffic for a packet layer, as a source and destination Endpoint.
@@ -164,11 +164,11 @@ func FlowFromEndpoints(src, dst Endpoint) (_ Flow, err error) {
 //
 // The output of FastHash is not guaranteed to remain the same through future
 // code revisions, so should not be used to key values in persistent storage.
-func (a Flow) FastHash() (h uint64) {
+func (f Flow) FastHash() (h uint64) {
 	// This combination must be commutative.  We don't use ^, since that would
 	// give the same hash for all A->A flows.
-	h = fnvHash(a.src[:a.slen]) + fnvHash(a.dst[:a.dlen])
-	h ^= uint64(a.typ)
+	h = fnvHash(f.src[:f.slen]) + fnvHash(f.dst[:f.dlen])
+	h ^= uint64(f.typ)
 	h *= fnvPrime
 	return
 }
@@ -225,12 +225,12 @@ func NewFlow(t EndpointType, src, dst []byte) (f Flow) {
 
 // EndpointInvalid is an endpoint type used for invalid endpoints, IE endpoints
 // that are specified incorrectly during creation.
-var EndpointInvalid EndpointType = RegisterEndpointType(0, EndpointTypeMetadata{"invalid", func(b []byte) string {
+var EndpointInvalid = RegisterEndpointType(0, EndpointTypeMetadata{Name: "invalid", Formatter: func(b []byte) string {
 	return fmt.Sprintf("%v", b)
 }})
 
 // InvalidEndpoint is a singleton Endpoint of type EndpointInvalid.
-var InvalidEndpoint Endpoint = NewEndpoint(EndpointInvalid, nil)
+var InvalidEndpoint = NewEndpoint(EndpointInvalid, nil)
 
 // InvalidFlow is a singleton Flow of type EndpointInvalid.
-var InvalidFlow Flow = NewFlow(EndpointInvalid, nil, nil)
+var InvalidFlow = NewFlow(EndpointInvalid, nil, nil)

layerclass.go

@@ -18,11 +18,12 @@ type LayerClass interface {
 	LayerTypes() []LayerType
 }
 
-// Make LayerType itself be a LayerClass.
+// Contains implements LayerClass.
 func (l LayerType) Contains(a LayerType) bool {
 	return l == a
 }
 
+// LayerTypes implements LayerClass.
 func (l LayerType) LayerTypes() []LayerType {
 	return []LayerType{l}
 }

packet.go

@@ -359,7 +359,7 @@ func layerGoString(i interface{}, b *bytes.Buffer) {
 		t := v.Type()
 		b.WriteString(t.String())
 		b.WriteByte('{')
-		for i := 0; i < v.NumField(); i += 1 {
+		for i := 0; i < v.NumField(); i++ {
 			if i > 0 {
 				b.WriteString(", ")
 			}
@@ -424,11 +424,11 @@ type eagerPacket struct {
 	packet
 }
 
-var nilDecoderError = errors.New("NextDecoder passed nil decoder, probably an unsupported decode type")
+var errNilDecoder = errors.New("NextDecoder passed nil decoder, probably an unsupported decode type")
 
 func (p *eagerPacket) NextDecoder(next Decoder) error {
 	if next == nil {
-		return nilDecoderError
+		return errNilDecoder
 	}
 	if p.last == nil {
 		return errors.New("NextDecoder called, but no layers added yet")
@@ -495,7 +495,7 @@ type lazyPacket struct {
 
 func (p *lazyPacket) NextDecoder(next Decoder) error {
 	if next == nil {
-		return nilDecoderError
+		return errNilDecoder
 	}
 	p.next = next
 	return nil
@@ -624,13 +624,13 @@ type DecodeOptions struct {
 // though, so beware.  If you can guarantee that the packet will only be used
 // by one goroutine at a time, set Lazy decoding.  If you can guarantee that
 // the underlying slice won't change, set NoCopy decoding.
-var Default DecodeOptions = DecodeOptions{}
+var Default = DecodeOptions{}
 
 // Lazy is a DecodeOptions with just Lazy set.
-var Lazy DecodeOptions = DecodeOptions{Lazy: true}
+var Lazy = DecodeOptions{Lazy: true}
 
 // NoCopy is a DecodeOptions with just NoCopy set.
-var NoCopy DecodeOptions = DecodeOptions{NoCopy: true}
+var NoCopy = DecodeOptions{NoCopy: true}
 
 // NewPacket creates a new Packet object from a set of bytes.  The
 // firstLayerDecoder tells it how to interpret the first layer from the bytes,