cdp.go

// Copyright 2012 Google, Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.

// Enum types courtesy of...
//   http://search.cpan.org/~mchapman/Net-CDP-0.09/lib/Net/CDP.pm
//   https://code.google.com/p/ladvd/
//   http://anonsvn.wireshark.org/viewvc/releases/wireshark-1.8.6/epan/dissectors/packet-cdp.c

package layers

import (
	"encoding/binary"
	"errors"
	"fmt"
	"net"

	"github.com/randomizedcoder/gopacket"
)

// CDPTLVType is the type of each TLV value in a CiscoDiscovery packet.
type CDPTLVType uint16

// CDPTLVType values.
const (
	CDPTLVDevID              CDPTLVType = 0x0001
	CDPTLVAddress            CDPTLVType = 0x0002
	CDPTLVPortID             CDPTLVType = 0x0003
	CDPTLVCapabilities       CDPTLVType = 0x0004
	CDPTLVVersion            CDPTLVType = 0x0005
	CDPTLVPlatform           CDPTLVType = 0x0006
	CDPTLVIPPrefix           CDPTLVType = 0x0007
	CDPTLVHello              CDPTLVType = 0x0008
	CDPTLVVTPDomain          CDPTLVType = 0x0009
	CDPTLVNativeVLAN         CDPTLVType = 0x000a
	CDPTLVFullDuplex         CDPTLVType = 0x000b
	CDPTLVVLANReply          CDPTLVType = 0x000e
	CDPTLVVLANQuery          CDPTLVType = 0x000f
	CDPTLVPower              CDPTLVType = 0x0010
	CDPTLVMTU                CDPTLVType = 0x0011
	CDPTLVExtendedTrust      CDPTLVType = 0x0012
	CDPTLVUntrustedCOS       CDPTLVType = 0x0013
	CDPTLVSysName            CDPTLVType = 0x0014
	CDPTLVSysOID             CDPTLVType = 0x0015
	CDPTLVMgmtAddresses      CDPTLVType = 0x0016
	CDPTLVLocation           CDPTLVType = 0x0017
	CDPTLVExternalPortID     CDPTLVType = 0x0018
	CDPTLVPowerRequested     CDPTLVType = 0x0019
	CDPTLVPowerAvailable     CDPTLVType = 0x001a
	CDPTLVPortUnidirectional CDPTLVType = 0x001b
	CDPTLVEnergyWise         CDPTLVType = 0x001d
	CDPTLVSparePairPOE       CDPTLVType = 0x001f
)

// CiscoDiscoveryValue is a TLV value inside a CiscoDiscovery packet layer.
type CiscoDiscoveryValue struct {
	Type   CDPTLVType
	Length uint16
	Value  []byte
}

// CiscoDiscovery is a packet layer containing the Cisco Discovery Protocol.
// See http://www.cisco.com/univercd/cc/td/doc/product/lan/trsrb/frames.htm#31885
type CiscoDiscovery struct {
	BaseLayer
	Version  byte
	TTL      byte
	Checksum uint16
	Values   []CiscoDiscoveryValue
}

// CDPCapability is the set of capabilities advertised by a CDP device.
type CDPCapability uint32

// CDPCapability values.
const (
	CDPCapMaskRouter     CDPCapability = 0x0001
	CDPCapMaskTBBridge   CDPCapability = 0x0002
	CDPCapMaskSPBridge   CDPCapability = 0x0004
	CDPCapMaskSwitch     CDPCapability = 0x0008
	CDPCapMaskHost       CDPCapability = 0x0010
	CDPCapMaskIGMPFilter CDPCapability = 0x0020
	CDPCapMaskRepeater   CDPCapability = 0x0040
	CDPCapMaskPhone      CDPCapability = 0x0080
	CDPCapMaskRemote     CDPCapability = 0x0100
)

// CDPCapabilities represents the capabilities of a device
type CDPCapabilities struct {
	L3Router        bool
	TBBridge        bool
	SPBridge        bool
	L2Switch        bool
	IsHost          bool
	IGMPFilter      bool
	L1Repeater      bool
	IsPhone         bool
	RemotelyManaged bool
}

// CDP Power-over-Ethernet values.
const (
	CDPPoEFourWire  byte = 0x01
	CDPPoEPDArch    byte = 0x02
	CDPPoEPDRequest byte = 0x04
	CDPPoEPSE       byte = 0x08
)

// CDPSparePairPoE provides information on PoE.
type CDPSparePairPoE struct {
	PSEFourWire  bool // Supported / Not supported
	PDArchShared bool // Shared / Independent
	PDRequestOn  bool // On / Off
	PSEOn        bool // On / Off
}

// CDPVLANDialogue encapsulates a VLAN Query/Reply
type CDPVLANDialogue struct {
	ID   uint8
	VLAN uint16
}

// CDPPowerDialogue encapsulates a Power Query/Reply
type CDPPowerDialogue struct {
	ID     uint16
	MgmtID uint16
	Values []uint32
}

// CDPLocation provides location information for a CDP device.
type CDPLocation struct {
	Type     uint8 // Undocumented
	Location string
}

// CDPHello is a Cisco Hello message (undocumented, hence the "Unknown" fields)
type CDPHello struct {
	OUI              []byte
	ProtocolID       uint16
	ClusterMaster    net.IP
	Unknown1         net.IP
	Version          byte
	SubVersion       byte
	Status           byte
	Unknown2         byte
	ClusterCommander net.HardwareAddr
	SwitchMAC        net.HardwareAddr
	Unknown3         byte
	ManagementVLAN   uint16
}

// CDPEnergyWiseSubtype is used within CDP to define TLV values.
type CDPEnergyWiseSubtype uint32

// CDPEnergyWiseSubtype values.
const (
	CDPEnergyWiseRole    CDPEnergyWiseSubtype = 0x00000007
	CDPEnergyWiseDomain  CDPEnergyWiseSubtype = 0x00000008
	CDPEnergyWiseName    CDPEnergyWiseSubtype = 0x00000009
	CDPEnergyWiseReplyTo CDPEnergyWiseSubtype = 0x00000017
)

// CDPEnergyWise is used by CDP to monitor and control power usage.
type CDPEnergyWise struct {
	EncryptedData  []byte
	Unknown1       uint32
	SequenceNumber uint32
	ModelNumber    string
	Unknown2       uint16
	HardwareID     string
	SerialNum      string
	Unknown3       []byte
	Role           string
	Domain         string
	Name           string
	ReplyUnknown1  []byte
	ReplyPort      []byte
	ReplyAddress   []byte
	ReplyUnknown2  []byte
	ReplyUnknown3  []byte
}

// CiscoDiscoveryInfo represents the decoded details for a set of CiscoDiscoveryValues
type CiscoDiscoveryInfo struct {
	BaseLayer
	CDPHello
	DeviceID         string
	Addresses        []net.IP
	PortID           string
	Capabilities     CDPCapabilities
	Version          string
	Platform         string
	IPPrefixes       []net.IPNet
	VTPDomain        string
	NativeVLAN       uint16
	FullDuplex       bool
	VLANReply        CDPVLANDialogue
	VLANQuery        CDPVLANDialogue
	PowerConsumption uint16
	MTU              uint32
	ExtendedTrust    uint8
	UntrustedCOS     uint8
	SysName          string
	SysOID           string
	MgmtAddresses    []net.IP
	Location         CDPLocation
	PowerRequest     CDPPowerDialogue
	PowerAvailable   CDPPowerDialogue
	SparePairPoe     CDPSparePairPoE
	EnergyWise       CDPEnergyWise
	Unknown          []CiscoDiscoveryValue
}

// LayerType returns gopacket.LayerTypeCiscoDiscovery.
func (c *CiscoDiscovery) LayerType() gopacket.LayerType {
	return LayerTypeCiscoDiscovery
}

func decodeCiscoDiscovery(data []byte, p gopacket.PacketBuilder) error {
	c := &CiscoDiscovery{
		Version:  data[0],
		TTL:      data[1],
		Checksum: binary.BigEndian.Uint16(data[2:4]),
	}
	if c.Version != 1 && c.Version != 2 {
		return fmt.Errorf("Invalid CiscoDiscovery version number %d", c.Version)
	}
	var err error
	c.Values, err = decodeCiscoDiscoveryTLVs(data[4:], p)
	if err != nil {
		return err
	}
	c.Contents = data[0:4]
	c.Payload = data[4:]
	p.AddLayer(c)
	return p.NextDecoder(gopacket.DecodeFunc(decodeCiscoDiscoveryInfo))
}

// LayerType returns gopacket.LayerTypeCiscoDiscoveryInfo.
func (c *CiscoDiscoveryInfo) LayerType() gopacket.LayerType {
	return LayerTypeCiscoDiscoveryInfo
}

func decodeCiscoDiscoveryTLVs(data []byte, p gopacket.PacketBuilder) (values []CiscoDiscoveryValue, err error) {
	for len(data) > 0 {
		if len(data) < 4 {
			p.SetTruncated()
			return nil, errors.New("CDP TLV < 4 bytes")
		}
		val := CiscoDiscoveryValue{
			Type:   CDPTLVType(binary.BigEndian.Uint16(data[:2])),
			Length: binary.BigEndian.Uint16(data[2:4]),
		}
		if val.Length < 4 {
			err = fmt.Errorf("Invalid CiscoDiscovery value length %d", val.Length)
			break
		} else if len(data) < int(val.Length) {
			p.SetTruncated()
			return nil, fmt.Errorf("CDP TLV < length %d", val.Length)
		}
		val.Value = data[4:val.Length]
		values = append(values, val)
		data = data[val.Length:]
	}
	return
}

func decodeCiscoDiscoveryInfo(data []byte, p gopacket.PacketBuilder) error {
	var err error
	info := &CiscoDiscoveryInfo{BaseLayer: BaseLayer{Contents: data}}
	p.AddLayer(info)
	values, err := decodeCiscoDiscoveryTLVs(data, p)
	if err != nil { // Unlikely, as parent decode will fail, but better safe...
		return err
	}
	for _, val := range values {
		switch val.Type {
		case CDPTLVDevID:
			info.DeviceID = string(val.Value)
		case CDPTLVAddress:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			info.Addresses, err = decodeAddresses(val.Value)
			if err != nil {
				return err
			}
		case CDPTLVPortID:
			info.PortID = string(val.Value)
		case CDPTLVCapabilities:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			val := CDPCapability(binary.BigEndian.Uint32(val.Value[0:4]))
			info.Capabilities.L3Router = (val&CDPCapMaskRouter > 0)
			info.Capabilities.TBBridge = (val&CDPCapMaskTBBridge > 0)
			info.Capabilities.SPBridge = (val&CDPCapMaskSPBridge > 0)
			info.Capabilities.L2Switch = (val&CDPCapMaskSwitch > 0)
			info.Capabilities.IsHost = (val&CDPCapMaskHost > 0)
			info.Capabilities.IGMPFilter = (val&CDPCapMaskIGMPFilter > 0)
			info.Capabilities.L1Repeater = (val&CDPCapMaskRepeater > 0)
			info.Capabilities.IsPhone = (val&CDPCapMaskPhone > 0)
			info.Capabilities.RemotelyManaged = (val&CDPCapMaskRemote > 0)
		case CDPTLVVersion:
			info.Version = string(val.Value)
		case CDPTLVPlatform:
			info.Platform = string(val.Value)
		case CDPTLVIPPrefix:
			v := val.Value
			l := len(v)
			if l%5 == 0 && l >= 5 {
				for len(v) > 0 {
					_, ipnet, _ := net.ParseCIDR(fmt.Sprintf("%d.%d.%d.%d/%d", v[0], v[1], v[2], v[3], v[4]))
					info.IPPrefixes = append(info.IPPrefixes, *ipnet)
					v = v[5:]
				}
			} else {
				return fmt.Errorf("Invalid TLV %v length %d", val.Type, len(val.Value))
			}
		case CDPTLVHello:
			if err = checkCDPTLVLen(val, 32); err != nil {
				return err
			}
			v := val.Value
			info.CDPHello.OUI = v[0:3]
			info.CDPHello.ProtocolID = binary.BigEndian.Uint16(v[3:5])
			info.CDPHello.ClusterMaster = v[5:9]
			info.CDPHello.Unknown1 = v[9:13]
			info.CDPHello.Version = v[13]
			info.CDPHello.SubVersion = v[14]
			info.CDPHello.Status = v[15]
			info.CDPHello.Unknown2 = v[16]
			info.CDPHello.ClusterCommander = v[17:23]
			info.CDPHello.SwitchMAC = v[23:29]
			info.CDPHello.Unknown3 = v[29]
			info.CDPHello.ManagementVLAN = binary.BigEndian.Uint16(v[30:32])
		case CDPTLVVTPDomain:
			info.VTPDomain = string(val.Value)
		case CDPTLVNativeVLAN:
			if err = checkCDPTLVLen(val, 2); err != nil {
				return err
			}
			info.NativeVLAN = binary.BigEndian.Uint16(val.Value[0:2])
		case CDPTLVFullDuplex:
			if err = checkCDPTLVLen(val, 1); err != nil {
				return err
			}
			info.FullDuplex = (val.Value[0] == 1)
		case CDPTLVVLANReply:
			if err = checkCDPTLVLen(val, 3); err != nil {
				return err
			}
			info.VLANReply.ID = uint8(val.Value[0])
			info.VLANReply.VLAN = binary.BigEndian.Uint16(val.Value[1:3])
		case CDPTLVVLANQuery:
			if err = checkCDPTLVLen(val, 3); err != nil {
				return err
			}
			info.VLANQuery.ID = uint8(val.Value[0])
			info.VLANQuery.VLAN = binary.BigEndian.Uint16(val.Value[1:3])
		case CDPTLVPower:
			if err = checkCDPTLVLen(val, 2); err != nil {
				return err
			}
			info.PowerConsumption = binary.BigEndian.Uint16(val.Value[0:2])
		case CDPTLVMTU:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			info.MTU = binary.BigEndian.Uint32(val.Value[0:4])
		case CDPTLVExtendedTrust:
			if err = checkCDPTLVLen(val, 1); err != nil {
				return err
			}
			info.ExtendedTrust = uint8(val.Value[0])
		case CDPTLVUntrustedCOS:
			if err = checkCDPTLVLen(val, 1); err != nil {
				return err
			}
			info.UntrustedCOS = uint8(val.Value[0])
		case CDPTLVSysName:
			info.SysName = string(val.Value)
		case CDPTLVSysOID:
			info.SysOID = string(val.Value)
		case CDPTLVMgmtAddresses:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			info.MgmtAddresses, err = decodeAddresses(val.Value)
			if err != nil {
				return err
			}
		case CDPTLVLocation:
			if err = checkCDPTLVLen(val, 2); err != nil {
				return err
			}
			info.Location.Type = uint8(val.Value[0])
			info.Location.Location = string(val.Value[1:])

			//		case CDPTLVLExternalPortID:
			//			Undocumented
		case CDPTLVPowerRequested:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			info.PowerRequest.ID = binary.BigEndian.Uint16(val.Value[0:2])
			info.PowerRequest.MgmtID = binary.BigEndian.Uint16(val.Value[2:4])
			for n := 4; n < len(val.Value); n += 4 {
				info.PowerRequest.Values = append(info.PowerRequest.Values, binary.BigEndian.Uint32(val.Value[n:n+4]))
			}
		case CDPTLVPowerAvailable:
			if err = checkCDPTLVLen(val, 4); err != nil {
				return err
			}
			info.PowerAvailable.ID = binary.BigEndian.Uint16(val.Value[0:2])
			info.PowerAvailable.MgmtID = binary.BigEndian.Uint16(val.Value[2:4])
			for n := 4; n < len(val.Value); n += 4 {
				info.PowerAvailable.Values = append(info.PowerAvailable.Values, binary.BigEndian.Uint32(val.Value[n:n+4]))
			}
			//		case CDPTLVPortUnidirectional
			//			Undocumented
		case CDPTLVEnergyWise:
			if err = checkCDPTLVLen(val, 72); err != nil {
				return err
			}
			info.EnergyWise.EncryptedData = val.Value[0:20]
			info.EnergyWise.Unknown1 = binary.BigEndian.Uint32(val.Value[20:24])
			info.EnergyWise.SequenceNumber = binary.BigEndian.Uint32(val.Value[24:28])
			info.EnergyWise.ModelNumber = string(val.Value[28:44])
			info.EnergyWise.Unknown2 = binary.BigEndian.Uint16(val.Value[44:46])
			info.EnergyWise.HardwareID = string(val.Value[46:49])
			info.EnergyWise.SerialNum = string(val.Value[49:60])
			info.EnergyWise.Unknown3 = val.Value[60:68]
			tlvLen := binary.BigEndian.Uint16(val.Value[68:70])
			tlvNum := binary.BigEndian.Uint16(val.Value[70:72])
			data := val.Value[72:]
			if len(data) < int(tlvLen) {
				return fmt.Errorf("Invalid TLV length %d vs %d", tlvLen, len(data))
			}
			numSeen := 0
			for len(data) > 8 {
				numSeen++
				if numSeen > int(tlvNum) { // Too many TLV's ?
					return fmt.Errorf("Too many TLV's - wanted %d, saw %d", tlvNum, numSeen)
				}
				tType := CDPEnergyWiseSubtype(binary.BigEndian.Uint32(data[0:4]))
				tLen := int(binary.BigEndian.Uint32(data[4:8]))
				if tLen > len(data)-8 {
					return fmt.Errorf("Invalid TLV length %d vs %d", tLen, len(data)-8)
				}
				data = data[8:]
				switch tType {
				case CDPEnergyWiseRole:
					info.EnergyWise.Role = string(data[:])
				case CDPEnergyWiseDomain:
					info.EnergyWise.Domain = string(data[:])
				case CDPEnergyWiseName:
					info.EnergyWise.Name = string(data[:])
				case CDPEnergyWiseReplyTo:
					if len(data) >= 18 {
						info.EnergyWise.ReplyUnknown1 = data[0:2]
						info.EnergyWise.ReplyPort = data[2:4]
						info.EnergyWise.ReplyAddress = data[4:8]
						info.EnergyWise.ReplyUnknown2 = data[8:10]
						info.EnergyWise.ReplyUnknown3 = data[10:14]
					}
				}
				data = data[tLen:]
			}
		case CDPTLVSparePairPOE:
			if err = checkCDPTLVLen(val, 1); err != nil {
				return err
			}
			v := val.Value[0]
			info.SparePairPoe.PSEFourWire = (v&CDPPoEFourWire > 0)
			info.SparePairPoe.PDArchShared = (v&CDPPoEPDArch > 0)
			info.SparePairPoe.PDRequestOn = (v&CDPPoEPDRequest > 0)
			info.SparePairPoe.PSEOn = (v&CDPPoEPSE > 0)
		default:
			info.Unknown = append(info.Unknown, val)
		}
	}
	return nil
}

// CDP Protocol Types
const (
	CDPProtocolTypeNLPID byte = 1
	CDPProtocolType802_2 byte = 2
)

// CDPAddressType is used to define TLV values within CDP addresses.
type CDPAddressType uint64

// CDP Address types.
const (
	CDPAddressTypeCLNP      CDPAddressType = 0x81
	CDPAddressTypeIPV4      CDPAddressType = 0xcc
	CDPAddressTypeIPV6      CDPAddressType = 0xaaaa030000000800
	CDPAddressTypeDECNET    CDPAddressType = 0xaaaa030000006003
	CDPAddressTypeAPPLETALK CDPAddressType = 0xaaaa03000000809b
	CDPAddressTypeIPX       CDPAddressType = 0xaaaa030000008137
	CDPAddressTypeVINES     CDPAddressType = 0xaaaa0300000080c4
	CDPAddressTypeXNS       CDPAddressType = 0xaaaa030000000600
	CDPAddressTypeAPOLLO    CDPAddressType = 0xaaaa030000008019
)

func decodeAddresses(v []byte) (addresses []net.IP, err error) {
	numaddr := int(binary.BigEndian.Uint32(v[0:4]))
	if numaddr < 1 {
		return nil, fmt.Errorf("Invalid Address TLV number %d", numaddr)
	}
	v = v[4:]
	if len(v) < numaddr*8 {
		return nil, fmt.Errorf("Invalid Address TLV length %d", len(v))
	}
	for i := 0; i < numaddr; i++ {
		prottype := v[0]
		if prottype != CDPProtocolTypeNLPID && prottype != CDPProtocolType802_2 { // invalid protocol type
			return nil, fmt.Errorf("Invalid Address Protocol %d", prottype)
		}
		protlen := int(v[1])
		if (prottype == CDPProtocolTypeNLPID && protlen != 1) ||
			(prottype == CDPProtocolType802_2 && protlen != 3 && protlen != 8) { // invalid length
			return nil, fmt.Errorf("Invalid Address Protocol length %d", protlen)
		}
		plen := make([]byte, 8)
		copy(plen[8-protlen:], v[2:2+protlen])
		protocol := CDPAddressType(binary.BigEndian.Uint64(plen))
		v = v[2+protlen:]
		addrlen := binary.BigEndian.Uint16(v[0:2])
		ab := v[2 : 2+addrlen]
		if protocol == CDPAddressTypeIPV4 && addrlen == 4 {
			addresses = append(addresses, net.IPv4(ab[0], ab[1], ab[2], ab[3]))
		} else if protocol == CDPAddressTypeIPV6 && addrlen == 16 {
			addresses = append(addresses, net.IP(ab))
		} else {
			// only handle IPV4 & IPV6 for now
		}
		v = v[2+addrlen:]
		if len(v) < 8 {
			break
		}
	}
	return
}

func (t CDPTLVType) String() (s string) {
	switch t {
	case CDPTLVDevID:
		s = "Device ID"
	case CDPTLVAddress:
		s = "Addresses"
	case CDPTLVPortID:
		s = "Port ID"
	case CDPTLVCapabilities:
		s = "Capabilities"
	case CDPTLVVersion:
		s = "Software Version"
	case CDPTLVPlatform:
		s = "Platform"
	case CDPTLVIPPrefix:
		s = "IP Prefix"
	case CDPTLVHello:
		s = "Protocol Hello"
	case CDPTLVVTPDomain:
		s = "VTP Management Domain"
	case CDPTLVNativeVLAN:
		s = "Native VLAN"
	case CDPTLVFullDuplex:
		s = "Full Duplex"
	case CDPTLVVLANReply:
		s = "VoIP VLAN Reply"
	case CDPTLVVLANQuery:
		s = "VLANQuery"
	case CDPTLVPower:
		s = "Power consumption"
	case CDPTLVMTU:
		s = "MTU"
	case CDPTLVExtendedTrust:
		s = "Extended Trust Bitmap"
	case CDPTLVUntrustedCOS:
		s = "Untrusted Port CoS"
	case CDPTLVSysName:
		s = "System Name"
	case CDPTLVSysOID:
		s = "System OID"
	case CDPTLVMgmtAddresses:
		s = "Management Addresses"
	case CDPTLVLocation:
		s = "Location"
	case CDPTLVExternalPortID:
		s = "External Port ID"
	case CDPTLVPowerRequested:
		s = "Power Requested"
	case CDPTLVPowerAvailable:
		s = "Power Available"
	case CDPTLVPortUnidirectional:
		s = "Port Unidirectional"
	case CDPTLVEnergyWise:
		s = "Energy Wise"
	case CDPTLVSparePairPOE:
		s = "Spare Pair POE"
	default:
		s = "Unknown"
	}
	return
}

func (a CDPAddressType) String() (s string) {
	switch a {
	case CDPAddressTypeCLNP:
		s = "Connectionless Network Protocol"
	case CDPAddressTypeIPV4:
		s = "IPv4"
	case CDPAddressTypeIPV6:
		s = "IPv6"
	case CDPAddressTypeDECNET:
		s = "DECnet Phase IV"
	case CDPAddressTypeAPPLETALK:
		s = "Apple Talk"
	case CDPAddressTypeIPX:
		s = "Novell IPX"
	case CDPAddressTypeVINES:
		s = "Banyan VINES"
	case CDPAddressTypeXNS:
		s = "Xerox Network Systems"
	case CDPAddressTypeAPOLLO:
		s = "Apollo"
	default:
		s = "Unknown"
	}
	return
}

func (t CDPEnergyWiseSubtype) String() (s string) {
	switch t {
	case CDPEnergyWiseRole:
		s = "Role"
	case CDPEnergyWiseDomain:
		s = "Domain"
	case CDPEnergyWiseName:
		s = "Name"
	case CDPEnergyWiseReplyTo:
		s = "ReplyTo"
	default:
		s = "Unknown"
	}
	return
}

func checkCDPTLVLen(v CiscoDiscoveryValue, l int) (err error) {
	if len(v.Value) < l {
		err = fmt.Errorf("Invalid TLV %v length %d", v.Type, len(v.Value))
	}
	return
}