layers

package
v1.1.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 29, 2014 License: BSD-3-Clause Imports: 9 Imported by: 9

Documentation

Overview

Package layers provides decoding layers for many common protocols.

The layers package contains decode implementations for a number of different types of packet layers. Users of gopacket will almost always want to also use layers to actually decode packet data into useful pieces. To see the set of protocols that gopacket/layers is currently able to decode, look at the set of LayerTypes defined in the Variables sections. The layers package also defines endpoints for many of the common packet layers that have source/destination addresses associated with them, for example IPv4/6 (IPs) and TCP/UDP (ports). Finally, layers contains a number of useful enumerations (IPProtocol, EthernetType, LinkType, PPPType, etc...). Many of these implement the gopacket.Decoder interface, so they can be passed into gopacket as decoders.

Most common protocol layers are named using acronyms or other industry-common names (IPv4, TCP, PPP). Some of the less common ones have their names expanded (CiscoDiscoveryProtocol). For certain protocols, sub-parts of the protocol are split out into their own layers (SCTP, for example). This is done mostly in cases where portions of the protocol may fulfill the capabilities of interesting layers (SCTPData implements ApplicationLayer, while base SCTP implements TransportLayer), or possibly because splitting a protocol into a few layers makes decoding easier.

This package is meant to be used with its parent, http://code.google.com/p/gopacket.

Port Types

Instead of using raw uint16 or uint8 values for ports, we use a different port type for every protocol, for example TCPPort and UDPPort. This allows us to override string behavior for each port, which we do by setting up port name maps (TCPPortNames, UDPPortNames, etc...). Well-known ports are annotated with their protocol names, and their String function displays these names: 

p := TCPPort(80)
fmt.Printf("Number: %d  String: %v", p, p)
// Prints: "Number: 80  String: 80(http)"

Modifying Decode Behavior

layers links together decoding through its enumerations. For example, after decoding layer type Ethernet, it uses Ethernet.EthernetType as its next decoder. All enumerations that act as decoders, like EthernetType, can be modified by users depending on their preferences. For example, if you have a spiffy new IPv4 decoder that works way better than the one built into layers, you can do this: 

var mySpiffyIPv4Decoder gopacket.Decoder = ...
layers.EthernetTypeMetadata[EthernetTypeIPv4].DecodeWith = mySpiffyIPv4Decoder

This will make all future ethernet packets use your new decoder to decode IPv4 packets, instead of the built-in decoder used by gopacket.

Index

Constants

View Source 
const (
	ARPRequest = 1
	ARPReply   = 2
)
View Source 
const (
	CDPPoEFourWire  byte = 0x01
	CDPPoEPDArch    byte = 0x02
	CDPPoEPDRequest byte = 0x04
	CDPPoEPSE       byte = 0x08
)
View Source 
const (
	CDPProtocolTypeNLPID byte = 1
	CDPProtocolType802_2 byte = 2
)

CDP Protocol Types

View Source 
const (
	EAPCodeRequest  EAPCode = 1
	EAPCodeResponse EAPCode = 2
	EAPCodeSuccess  EAPCode = 3
	EAPCodeFailure  EAPCode = 4

	// EAPTypeNone means that this EAP layer has no Type or TypeData.
	// Success and Failure EAPs will have this set.
	EAPTypeNone EAPType = 0

	EAPTypeIdentity     EAPType = 1
	EAPTypeNotification EAPType = 2
	EAPTypeNACK         EAPType = 3
	EAPTypeOTP          EAPType = 4
	EAPTypeTokenCard    EAPType = 5
)
View Source 
const (
	ICMPv4TypeEchoReply              = 0
	ICMPv4TypeDestinationUnreachable = 3
	ICMPv4TypeSourceQuench           = 4
	ICMPv4TypeRedirect               = 5
	ICMPv4TypeEchoRequest            = 8
	ICMPv4TypeRouterAdvertisement    = 9
	ICMPv4TypeRouterSolicitation     = 10
	ICMPv4TypeTimeExceeded           = 11
	ICMPv4TypeParameterProblem       = 12
	ICMPv4TypeTimestampRequest       = 13
	ICMPv4TypeTimestampReply         = 14
	ICMPv4TypeInfoRequest            = 15
	ICMPv4TypeInfoReply              = 16
	ICMPv4TypeAddressMaskRequest     = 17
	ICMPv4TypeAddressMaskReply       = 18
)
View Source 
const (
	ICMPv6TypeDestinationUnreachable = 1
	ICMPv6TypePacketTooBig           = 2
	ICMPv6TypeTimeExceeded           = 3
	ICMPv6TypeParameterProblem       = 4
	ICMPv6TypeEchoRequest            = 128
	ICMPv6TypeEchoReply              = 129
	// The following are from RFC 4861
	ICMPv6TypeRouterSolicitation    = 133
	ICMPv6TypeRouterAdvertisement   = 134
	ICMPv6TypeNeighborSolicitation  = 135
	ICMPv6TypeNeighborAdvertisement = 136
	ICMPv6TypeRedirect              = 137
)
View Source 
const (
	LLDPCapsOther       uint16 = 1 << 0
	LLDPCapsRepeater    uint16 = 1 << 1
	LLDPCapsBridge      uint16 = 1 << 2
	LLDPCapsWLANAP      uint16 = 1 << 3
	LLDPCapsRouter      uint16 = 1 << 4
	LLDPCapsPhone       uint16 = 1 << 5
	LLDPCapsDocSis      uint16 = 1 << 6
	LLDPCapsStationOnly uint16 = 1 << 7
	LLDPCapsCVLAN       uint16 = 1 << 8
	LLDPCapsSVLAN       uint16 = 1 << 9
	LLDPCapsTmpr        uint16 = 1 << 10
)

LLDPCapabilities Types

View Source 
const (
	LLDP8021SubtypePortVLANID       uint8 = 1
	LLDP8021SubtypeProtocolVLANID   uint8 = 2
	LLDP8021SubtypeVLANName         uint8 = 3
	LLDP8021SubtypeProtocolIdentity uint8 = 4
	LLDP8021SubtypeVDIUsageDigest   uint8 = 5
	LLDP8021SubtypeManagementVID    uint8 = 6
	LLDP8021SubtypeLinkAggregation  uint8 = 7
)

/ IEEE 802.1 TLV Subtypes

View Source 
const (
	LLDPProtocolVLANIDCapability byte = 1 << 1
	LLDPProtocolVLANIDStatus     byte = 1 << 2
)

VLAN Port Protocol ID options

View Source 
const (
	LLDPAggregationCapability byte = 1 << 0
	LLDPAggregationStatus     byte = 1 << 1
)

LACP options

View Source 
const (
	LLDP8023SubtypeMACPHY          uint8 = 1
	LLDP8023SubtypeMDIPower        uint8 = 2
	LLDP8023SubtypeLinkAggregation uint8 = 3
	LLDP8023SubtypeMTU             uint8 = 4
)

IEEE 802.3 TLV Subtypes

View Source 
const (
	LLDPMACPHYCapability byte = 1 << 0
	LLDPMACPHYStatus     byte = 1 << 1
)

MACPHY options

View Source 
const (
	LLDPMAUTypeUnknown         uint16 = 0
	LLDPMAUTypeAUI             uint16 = 1
	LLDPMAUType10Base5         uint16 = 2
	LLDPMAUTypeFOIRL           uint16 = 3
	LLDPMAUType10Base2         uint16 = 4
	LLDPMAUType10BaseT         uint16 = 5
	LLDPMAUType10BaseFP        uint16 = 6
	LLDPMAUType10BaseFB        uint16 = 7
	LLDPMAUType10BaseFL        uint16 = 8
	LLDPMAUType10BROAD36       uint16 = 9
	LLDPMAUType10BaseT_HD      uint16 = 10
	LLDPMAUType10BaseT_FD      uint16 = 11
	LLDPMAUType10BaseFL_HD     uint16 = 12
	LLDPMAUType10BaseFL_FD     uint16 = 13
	LLDPMAUType100BaseT4       uint16 = 14
	LLDPMAUType100BaseTX_HD    uint16 = 15
	LLDPMAUType100BaseTX_FD    uint16 = 16
	LLDPMAUType100BaseFX_HD    uint16 = 17
	LLDPMAUType100BaseFX_FD    uint16 = 18
	LLDPMAUType100BaseT2_HD    uint16 = 19
	LLDPMAUType100BaseT2_FD    uint16 = 20
	LLDPMAUType1000BaseX_HD    uint16 = 21
	LLDPMAUType1000BaseX_FD    uint16 = 22
	LLDPMAUType1000BaseLX_HD   uint16 = 23
	LLDPMAUType1000BaseLX_FD   uint16 = 24
	LLDPMAUType1000BaseSX_HD   uint16 = 25
	LLDPMAUType1000BaseSX_FD   uint16 = 26
	LLDPMAUType1000BaseCX_HD   uint16 = 27
	LLDPMAUType1000BaseCX_FD   uint16 = 28
	LLDPMAUType1000BaseT_HD    uint16 = 29
	LLDPMAUType1000BaseT_FD    uint16 = 30
	LLDPMAUType10GBaseX        uint16 = 31
	LLDPMAUType10GBaseLX4      uint16 = 32
	LLDPMAUType10GBaseR        uint16 = 33
	LLDPMAUType10GBaseER       uint16 = 34
	LLDPMAUType10GBaseLR       uint16 = 35
	LLDPMAUType10GBaseSR       uint16 = 36
	LLDPMAUType10GBaseW        uint16 = 37
	LLDPMAUType10GBaseEW       uint16 = 38
	LLDPMAUType10GBaseLW       uint16 = 39
	LLDPMAUType10GBaseSW       uint16 = 40
	LLDPMAUType10GBaseCX4      uint16 = 41
	LLDPMAUType2BaseTL         uint16 = 42
	LLDPMAUType10PASS_TS       uint16 = 43
	LLDPMAUType100BaseBX10D    uint16 = 44
	LLDPMAUType100BaseBX10U    uint16 = 45
	LLDPMAUType100BaseLX10     uint16 = 46
	LLDPMAUType1000BaseBX10D   uint16 = 47
	LLDPMAUType1000BaseBX10U   uint16 = 48
	LLDPMAUType1000BaseLX10    uint16 = 49
	LLDPMAUType1000BasePX10D   uint16 = 50
	LLDPMAUType1000BasePX10U   uint16 = 51
	LLDPMAUType1000BasePX20D   uint16 = 52
	LLDPMAUType1000BasePX20U   uint16 = 53
	LLDPMAUType10GBaseT        uint16 = 54
	LLDPMAUType10GBaseLRM      uint16 = 55
	LLDPMAUType1000BaseKX      uint16 = 56
	LLDPMAUType10GBaseKX4      uint16 = 57
	LLDPMAUType10GBaseKR       uint16 = 58
	LLDPMAUType10_1GBasePRX_D1 uint16 = 59
	LLDPMAUType10_1GBasePRX_D2 uint16 = 60
	LLDPMAUType10_1GBasePRX_D3 uint16 = 61
	LLDPMAUType10_1GBasePRX_U1 uint16 = 62
	LLDPMAUType10_1GBasePRX_U2 uint16 = 63
	LLDPMAUType10_1GBasePRX_U3 uint16 = 64
	LLDPMAUType10GBasePR_D1    uint16 = 65
	LLDPMAUType10GBasePR_D2    uint16 = 66
	LLDPMAUType10GBasePR_D3    uint16 = 67
	LLDPMAUType10GBasePR_U1    uint16 = 68
	LLDPMAUType10GBasePR_U3    uint16 = 69
)

From IANA-MAU-MIB (introduced by RFC 4836) - dot3MauType

View Source 
const (
	LLDPMAUPMDOther        uint16 = 1 << 15
	LLDPMAUPMD10BaseT      uint16 = 1 << 14
	LLDPMAUPMD10BaseT_FD   uint16 = 1 << 13
	LLDPMAUPMD100BaseT4    uint16 = 1 << 12
	LLDPMAUPMD100BaseTX    uint16 = 1 << 11
	LLDPMAUPMD100BaseTX_FD uint16 = 1 << 10
	LLDPMAUPMD100BaseT2    uint16 = 1 << 9
	LLDPMAUPMD100BaseT2_FD uint16 = 1 << 8
	LLDPMAUPMDFDXPAUSE     uint16 = 1 << 7
	LLDPMAUPMDFDXAPAUSE    uint16 = 1 << 6
	LLDPMAUPMDFDXSPAUSE    uint16 = 1 << 5
	LLDPMAUPMDFDXBPAUSE    uint16 = 1 << 4
	LLDPMAUPMD1000BaseX    uint16 = 1 << 3
	LLDPMAUPMD1000BaseX_FD uint16 = 1 << 2
	LLDPMAUPMD1000BaseT    uint16 = 1 << 1
	LLDPMAUPMD1000BaseT_FD uint16 = 1 << 0
)

From RFC 3636 - ifMauAutoNegCapAdvertisedBits

View Source 
const (
	LLDPMAUPMDOtherInv        uint16 = 1 << 0
	LLDPMAUPMD10BaseTInv      uint16 = 1 << 1
	LLDPMAUPMD10BaseT_FDInv   uint16 = 1 << 2
	LLDPMAUPMD100BaseT4Inv    uint16 = 1 << 3
	LLDPMAUPMD100BaseTXInv    uint16 = 1 << 4
	LLDPMAUPMD100BaseTX_FDInv uint16 = 1 << 5
	LLDPMAUPMD100BaseT2Inv    uint16 = 1 << 6
	LLDPMAUPMD100BaseT2_FDInv uint16 = 1 << 7
	LLDPMAUPMDFDXPAUSEInv     uint16 = 1 << 8
	LLDPMAUPMDFDXAPAUSEInv    uint16 = 1 << 9
	LLDPMAUPMDFDXSPAUSEInv    uint16 = 1 << 10
	LLDPMAUPMDFDXBPAUSEInv    uint16 = 1 << 11
	LLDPMAUPMD1000BaseXInv    uint16 = 1 << 12
	LLDPMAUPMD1000BaseX_FDInv uint16 = 1 << 13
	LLDPMAUPMD1000BaseTInv    uint16 = 1 << 14
	LLDPMAUPMD1000BaseT_FDInv uint16 = 1 << 15
)

Inverted ifMauAutoNegCapAdvertisedBits if required (Some manufacturers misinterpreted the spec - see https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=1455)

View Source 
const (
	LLDPMDIPowerPortClass    byte = 1 << 0
	LLDPMDIPowerCapability   byte = 1 << 1
	LLDPMDIPowerStatus       byte = 1 << 2
	LLDPMDIPowerPairsAbility byte = 1 << 3
)

MDI Power options

View Source 
const (
	LLDP8021QbgEVB   uint8 = 0
	LLDP8021QbgCDCP  uint8 = 1
	LLDP8021QbgVDP   uint8 = 2
	LLDP8021QbgEVB22 uint8 = 13
)

IEEE 802.1Qbg TLV Subtypes

View Source 
const (
	LLDPEVBCapsSTD uint16 = 1 << 7
	LLDPEVBCapsRR  uint16 = 1 << 6
	LLDPEVBCapsRTE uint16 = 1 << 2
	LLDPEVBCapsECP uint16 = 1 << 1
	LLDPEVBCapsVDP uint16 = 1 << 0
)

LLDPEVBCapabilities Types

View Source 
const (
	LLDPMediaCapsLLDP      uint16 = 1 << 0
	LLDPMediaCapsNetwork   uint16 = 1 << 1
	LLDPMediaCapsLocation  uint16 = 1 << 2
	LLDPMediaCapsPowerPSE  uint16 = 1 << 3
	LLDPMediaCapsPowerPD   uint16 = 1 << 4
	LLDPMediaCapsInventory uint16 = 1 << 5
)

LLDPMediaCapabilities Types

View Source 
const (
	LLDPCiscoPSESupport   uint8 = 1 << 0
	LLDPCiscoArchShared   uint8 = 1 << 1
	LLDPCiscoPDSparePair  uint8 = 1 << 2
	LLDPCiscoPSESparePair uint8 = 1 << 3
)
View Source 
const (
	IPv6HopByHopOptionJumbogram = 0xC2 // RFC 2675
)

Variables

View Source 
var (
	// We use two different endpoint types for IPv4 vs IPv6 addresses, so that
	// ordering with endpointA.LessThan(endpointB) sanely groups all IPv4
	// addresses and all IPv6 addresses, such that IPv6 > IPv4 for all addresses.
	EndpointIPv4 = gopacket.RegisterEndpointType(1, gopacket.EndpointTypeMetadata{"IPv4", func(b []byte) string {
		return net.IP(b).String()
	}})
	EndpointIPv6 = gopacket.RegisterEndpointType(2, gopacket.EndpointTypeMetadata{"IPv6", func(b []byte) string {
		return net.IP(b).String()
	}})

	EndpointMAC = gopacket.RegisterEndpointType(3, gopacket.EndpointTypeMetadata{"MAC", func(b []byte) string {
		return net.HardwareAddr(b).String()
	}})
	EndpointTCPPort = gopacket.RegisterEndpointType(4, gopacket.EndpointTypeMetadata{"TCP", func(b []byte) string {
		return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
	}})
	EndpointUDPPort = gopacket.RegisterEndpointType(5, gopacket.EndpointTypeMetadata{"UDP", func(b []byte) string {
		return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
	}})
	EndpointSCTPPort = gopacket.RegisterEndpointType(6, gopacket.EndpointTypeMetadata{"SCTP", func(b []byte) string {
		return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
	}})
	EndpointRUDPPort = gopacket.RegisterEndpointType(7, gopacket.EndpointTypeMetadata{"RUDP", func(b []byte) string {
		return strconv.Itoa(int(b[0]))
	}})
	EndpointUDPLitePort = gopacket.RegisterEndpointType(8, gopacket.EndpointTypeMetadata{"UDPLite", func(b []byte) string {
		return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
	}})
	EndpointPPP = gopacket.RegisterEndpointType(9, gopacket.EndpointTypeMetadata{"PPP", func([]byte) string {
		return "point"
	}})
)
View Source 
var (
	// Each of the following arrays contains mappings of how to handle enum
	// values for various enum types in gopacket/layers.
	//
	// So, EthernetTypeMetadata[2] contains information on how to handle EthernetType
	// 2, including which name to give it and which decoder to use to decode
	// packet data of that type.  These arrays are filled by default with all of the
	// protocols gopacket/layers knows how to handle, but users of the library can
	// add new decoders or override existing ones.  For example, if you write a better
	// TCP decoder, you can override IPProtocolMetadata[IPProtocolTCP].DecodeWith
	// with your new decoder, and all gopacket/layers decoding will use your new
	// decoder whenever they encounter that IPProtocol.
	EthernetTypeMetadata     [65536]EnumMetadata
	IPProtocolMetadata       [265]EnumMetadata
	SCTPChunkTypeMetadata    [265]EnumMetadata
	PPPTypeMetadata          [65536]EnumMetadata
	PPPoECodeMetadata        [256]EnumMetadata
	LinkTypeMetadata         [256]EnumMetadata
	FDDIFrameControlMetadata [256]EnumMetadata
	EAPOLTypeMetadata        [256]EnumMetadata
	ProtocolFamilyMetadata   [256]EnumMetadata
	Dot11TypeMetadata        [256]EnumMetadata
)
View Source 
var (
	LayerTypeARP                         = gopacket.RegisterLayerType(10, gopacket.LayerTypeMetadata{"ARP", gopacket.DecodeFunc(decodeARP)})
	LayerTypeCiscoDiscovery              = gopacket.RegisterLayerType(11, gopacket.LayerTypeMetadata{"CiscoDiscovery", gopacket.DecodeFunc(decodeCiscoDiscovery)})
	LayerTypeEthernetCTP                 = gopacket.RegisterLayerType(12, gopacket.LayerTypeMetadata{"EthernetCTP", gopacket.DecodeFunc(decodeEthernetCTP)})
	LayerTypeEthernetCTPForwardData      = gopacket.RegisterLayerType(13, gopacket.LayerTypeMetadata{"EthernetCTPForwardData", nil})
	LayerTypeEthernetCTPReply            = gopacket.RegisterLayerType(14, gopacket.LayerTypeMetadata{"EthernetCTPReply", nil})
	LayerTypeDot1Q                       = gopacket.RegisterLayerType(15, gopacket.LayerTypeMetadata{"Dot1Q", gopacket.DecodeFunc(decodeDot1Q)})
	LayerTypeEtherIP                     = gopacket.RegisterLayerType(16, gopacket.LayerTypeMetadata{"EtherIP", gopacket.DecodeFunc(decodeEtherIP)})
	LayerTypeEthernet                    = gopacket.RegisterLayerType(17, gopacket.LayerTypeMetadata{"Ethernet", gopacket.DecodeFunc(decodeEthernet)})
	LayerTypeGRE                         = gopacket.RegisterLayerType(18, gopacket.LayerTypeMetadata{"GRE", gopacket.DecodeFunc(decodeGRE)})
	LayerTypeICMPv4                      = gopacket.RegisterLayerType(19, gopacket.LayerTypeMetadata{"ICMPv4", gopacket.DecodeFunc(decodeICMPv4)})
	LayerTypeIPv4                        = gopacket.RegisterLayerType(20, gopacket.LayerTypeMetadata{"IPv4", gopacket.DecodeFunc(decodeIPv4)})
	LayerTypeIPv6                        = gopacket.RegisterLayerType(21, gopacket.LayerTypeMetadata{"IPv6", gopacket.DecodeFunc(decodeIPv6)})
	LayerTypeLLC                         = gopacket.RegisterLayerType(22, gopacket.LayerTypeMetadata{"LLC", gopacket.DecodeFunc(decodeLLC)})
	LayerTypeSNAP                        = gopacket.RegisterLayerType(23, gopacket.LayerTypeMetadata{"SNAP", gopacket.DecodeFunc(decodeSNAP)})
	LayerTypeMPLS                        = gopacket.RegisterLayerType(24, gopacket.LayerTypeMetadata{"MPLS", gopacket.DecodeFunc(decodeMPLS)})
	LayerTypePPP                         = gopacket.RegisterLayerType(25, gopacket.LayerTypeMetadata{"PPP", gopacket.DecodeFunc(decodePPP)})
	LayerTypePPPoE                       = gopacket.RegisterLayerType(26, gopacket.LayerTypeMetadata{"PPPoE", gopacket.DecodeFunc(decodePPPoE)})
	LayerTypeRUDP                        = gopacket.RegisterLayerType(27, gopacket.LayerTypeMetadata{"RUDP", gopacket.DecodeFunc(decodeRUDP)})
	LayerTypeSCTP                        = gopacket.RegisterLayerType(28, gopacket.LayerTypeMetadata{"SCTP", gopacket.DecodeFunc(decodeSCTP)})
	LayerTypeSCTPUnknownChunkType        = gopacket.RegisterLayerType(29, gopacket.LayerTypeMetadata{"SCTPUnknownChunkType", nil})
	LayerTypeSCTPData                    = gopacket.RegisterLayerType(30, gopacket.LayerTypeMetadata{"SCTPData", nil})
	LayerTypeSCTPInit                    = gopacket.RegisterLayerType(31, gopacket.LayerTypeMetadata{"SCTPInit", nil})
	LayerTypeSCTPSack                    = gopacket.RegisterLayerType(32, gopacket.LayerTypeMetadata{"SCTPSack", nil})
	LayerTypeSCTPHeartbeat               = gopacket.RegisterLayerType(33, gopacket.LayerTypeMetadata{"SCTPHeartbeat", nil})
	LayerTypeSCTPError                   = gopacket.RegisterLayerType(34, gopacket.LayerTypeMetadata{"SCTPError", nil})
	LayerTypeSCTPShutdown                = gopacket.RegisterLayerType(35, gopacket.LayerTypeMetadata{"SCTPShutdown", nil})
	LayerTypeSCTPShutdownAck             = gopacket.RegisterLayerType(36, gopacket.LayerTypeMetadata{"SCTPShutdownAck", nil})
	LayerTypeSCTPCookieEcho              = gopacket.RegisterLayerType(37, gopacket.LayerTypeMetadata{"SCTPCookieEcho", nil})
	LayerTypeSCTPEmptyLayer              = gopacket.RegisterLayerType(38, gopacket.LayerTypeMetadata{"SCTPEmptyLayer", nil})
	LayerTypeSCTPInitAck                 = gopacket.RegisterLayerType(39, gopacket.LayerTypeMetadata{"SCTPInitAck", nil})
	LayerTypeSCTPHeartbeatAck            = gopacket.RegisterLayerType(40, gopacket.LayerTypeMetadata{"SCTPHeartbeatAck", nil})
	LayerTypeSCTPAbort                   = gopacket.RegisterLayerType(41, gopacket.LayerTypeMetadata{"SCTPAbort", nil})
	LayerTypeSCTPShutdownComplete        = gopacket.RegisterLayerType(42, gopacket.LayerTypeMetadata{"SCTPShutdownComplete", nil})
	LayerTypeSCTPCookieAck               = gopacket.RegisterLayerType(43, gopacket.LayerTypeMetadata{"SCTPCookieAck", nil})
	LayerTypeTCP                         = gopacket.RegisterLayerType(44, gopacket.LayerTypeMetadata{"TCP", gopacket.DecodeFunc(decodeTCP)})
	LayerTypeUDP                         = gopacket.RegisterLayerType(45, gopacket.LayerTypeMetadata{"UDP", gopacket.DecodeFunc(decodeUDP)})
	LayerTypeIPv6HopByHop                = gopacket.RegisterLayerType(46, gopacket.LayerTypeMetadata{"IPv6HopByHop", gopacket.DecodeFunc(decodeIPv6HopByHop)})
	LayerTypeIPv6Routing                 = gopacket.RegisterLayerType(47, gopacket.LayerTypeMetadata{"IPv6Routing", gopacket.DecodeFunc(decodeIPv6Routing)})
	LayerTypeIPv6Fragment                = gopacket.RegisterLayerType(48, gopacket.LayerTypeMetadata{"IPv6Fragment", gopacket.DecodeFunc(decodeIPv6Fragment)})
	LayerTypeIPv6Destination             = gopacket.RegisterLayerType(49, gopacket.LayerTypeMetadata{"IPv6Destination", gopacket.DecodeFunc(decodeIPv6Destination)})
	LayerTypeIPSecAH                     = gopacket.RegisterLayerType(50, gopacket.LayerTypeMetadata{"IPSecAH", gopacket.DecodeFunc(decodeIPSecAH)})
	LayerTypeIPSecESP                    = gopacket.RegisterLayerType(51, gopacket.LayerTypeMetadata{"IPSecESP", gopacket.DecodeFunc(decodeIPSecESP)})
	LayerTypeUDPLite                     = gopacket.RegisterLayerType(52, gopacket.LayerTypeMetadata{"UDPLite", gopacket.DecodeFunc(decodeUDPLite)})
	LayerTypeFDDI                        = gopacket.RegisterLayerType(53, gopacket.LayerTypeMetadata{"FDDI", gopacket.DecodeFunc(decodeFDDI)})
	LayerTypeLoopback                    = gopacket.RegisterLayerType(54, gopacket.LayerTypeMetadata{"Loopback", gopacket.DecodeFunc(decodeLoopback)})
	LayerTypeEAP                         = gopacket.RegisterLayerType(55, gopacket.LayerTypeMetadata{"EAP", gopacket.DecodeFunc(decodeEAP)})
	LayerTypeEAPOL                       = gopacket.RegisterLayerType(56, gopacket.LayerTypeMetadata{"EAPOL", gopacket.DecodeFunc(decodeEAPOL)})
	LayerTypeICMPv6                      = gopacket.RegisterLayerType(57, gopacket.LayerTypeMetadata{"ICMPv6", gopacket.DecodeFunc(decodeICMPv6)})
	LayerTypeLinkLayerDiscovery          = gopacket.RegisterLayerType(58, gopacket.LayerTypeMetadata{"LinkLayerDiscovery", gopacket.DecodeFunc(decodeLinkLayerDiscovery)})
	LayerTypeCiscoDiscoveryInfo          = gopacket.RegisterLayerType(59, gopacket.LayerTypeMetadata{"CiscoDiscoveryInfo", gopacket.DecodeFunc(decodeCiscoDiscoveryInfo)})
	LayerTypeLinkLayerDiscoveryInfo      = gopacket.RegisterLayerType(60, gopacket.LayerTypeMetadata{"LinkLayerDiscoveryInfo", nil})
	LayerTypeNortelDiscovery             = gopacket.RegisterLayerType(61, gopacket.LayerTypeMetadata{"NortelDiscovery", gopacket.DecodeFunc(decodeNortelDiscovery)})
	LayerTypeIGMP                        = gopacket.RegisterLayerType(62, gopacket.LayerTypeMetadata{"IGMP", gopacket.DecodeFunc(decodeIGMP)})
	LayerTypePFLog                       = gopacket.RegisterLayerType(63, gopacket.LayerTypeMetadata{"PFLog", gopacket.DecodeFunc(decodePFLog)})
	LayerTypeRadioTap                    = gopacket.RegisterLayerType(64, gopacket.LayerTypeMetadata{"RadioTap", gopacket.DecodeFunc(decodeRadioTap)})
	LayerTypeDot11                       = gopacket.RegisterLayerType(65, gopacket.LayerTypeMetadata{"Dot11", gopacket.DecodeFunc(decodeDot11)})
	LayerTypeDot11Ctrl                   = gopacket.RegisterLayerType(66, gopacket.LayerTypeMetadata{"Dot11Ctrl", gopacket.DecodeFunc(decodeDot11Ctrl)})
	LayerTypeDot11Data                   = gopacket.RegisterLayerType(67, gopacket.LayerTypeMetadata{"Dot11Data", gopacket.DecodeFunc(decodeDot11Data)})
	LayerTypeDot11DataCFAck              = gopacket.RegisterLayerType(68, gopacket.LayerTypeMetadata{"Dot11DataCFAck", gopacket.DecodeFunc(decodeDot11DataCFAck)})
	LayerTypeDot11DataCFPoll             = gopacket.RegisterLayerType(69, gopacket.LayerTypeMetadata{"Dot11DataCFPoll", gopacket.DecodeFunc(decodeDot11DataCFPoll)})
	LayerTypeDot11DataCFAckPoll          = gopacket.RegisterLayerType(70, gopacket.LayerTypeMetadata{"Dot11DataCFAckPoll", gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
	LayerTypeDot11DataNull               = gopacket.RegisterLayerType(71, gopacket.LayerTypeMetadata{"Dot11DataNull", gopacket.DecodeFunc(decodeDot11DataNull)})
	LayerTypeDot11DataCFAckNoData        = gopacket.RegisterLayerType(72, gopacket.LayerTypeMetadata{"Dot11DataCFAck", gopacket.DecodeFunc(decodeDot11DataCFAck)})
	LayerTypeDot11DataCFPollNoData       = gopacket.RegisterLayerType(73, gopacket.LayerTypeMetadata{"Dot11DataCFPoll", gopacket.DecodeFunc(decodeDot11DataCFPoll)})
	LayerTypeDot11DataCFAckPollNoData    = gopacket.RegisterLayerType(74, gopacket.LayerTypeMetadata{"Dot11DataCFAckPoll", gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
	LayerTypeDot11DataQOSData            = gopacket.RegisterLayerType(75, gopacket.LayerTypeMetadata{"Dot11DataQOSData", gopacket.DecodeFunc(decodeDot11DataQOSData)})
	LayerTypeDot11DataQOSDataCFAck       = gopacket.RegisterLayerType(76, gopacket.LayerTypeMetadata{"Dot11DataQOSDataCFAck", gopacket.DecodeFunc(decodeDot11DataQOSDataCFAck)})
	LayerTypeDot11DataQOSDataCFPoll      = gopacket.RegisterLayerType(77, gopacket.LayerTypeMetadata{"Dot11DataQOSDataCFPoll", gopacket.DecodeFunc(decodeDot11DataQOSDataCFPoll)})
	LayerTypeDot11DataQOSDataCFAckPoll   = gopacket.RegisterLayerType(78, gopacket.LayerTypeMetadata{"Dot11DataQOSDataCFAckPoll", gopacket.DecodeFunc(decodeDot11DataQOSDataCFAckPoll)})
	LayerTypeDot11DataQOSNull            = gopacket.RegisterLayerType(79, gopacket.LayerTypeMetadata{"Dot11DataQOSNull", gopacket.DecodeFunc(decodeDot11DataQOSNull)})
	LayerTypeDot11DataQOSCFPollNoData    = gopacket.RegisterLayerType(80, gopacket.LayerTypeMetadata{"Dot11DataQOSCFPoll", gopacket.DecodeFunc(decodeDot11DataQOSCFPollNoData)})
	LayerTypeDot11DataQOSCFAckPollNoData = gopacket.RegisterLayerType(81, gopacket.LayerTypeMetadata{"Dot11DataQOSCFAckPoll", gopacket.DecodeFunc(decodeDot11DataQOSCFAckPollNoData)})
	LayerTypeDot11InformationElement     = gopacket.RegisterLayerType(82, gopacket.LayerTypeMetadata{"Dot11InformationElement", gopacket.DecodeFunc(decodeDot11InformationElement)})
	LayerTypeDot11CtrlCTS                = gopacket.RegisterLayerType(83, gopacket.LayerTypeMetadata{"Dot11CtrlCTS", gopacket.DecodeFunc(decodeDot11CtrlCTS)})
	LayerTypeDot11CtrlRTS                = gopacket.RegisterLayerType(84, gopacket.LayerTypeMetadata{"Dot11CtrlRTS", gopacket.DecodeFunc(decodeDot11CtrlRTS)})
	LayerTypeDot11CtrlBlockAckReq        = gopacket.RegisterLayerType(85, gopacket.LayerTypeMetadata{"Dot11CtrlBlockAckReq", gopacket.DecodeFunc(decodeDot11CtrlBlockAckReq)})
	LayerTypeDot11CtrlBlockAck           = gopacket.RegisterLayerType(86, gopacket.LayerTypeMetadata{"Dot11CtrlBlockAck", gopacket.DecodeFunc(decodeDot11CtrlBlockAck)})
	LayerTypeDot11CtrlPowersavePoll      = gopacket.RegisterLayerType(87, gopacket.LayerTypeMetadata{"Dot11CtrlPowersavePoll", gopacket.DecodeFunc(decodeDot11CtrlPowersavePoll)})
	LayerTypeDot11CtrlAck                = gopacket.RegisterLayerType(88, gopacket.LayerTypeMetadata{"Dot11CtrlAck", gopacket.DecodeFunc(decodeDot11CtrlAck)})
	LayerTypeDot11CtrlCFEnd              = gopacket.RegisterLayerType(89, gopacket.LayerTypeMetadata{"Dot11CtrlCFEnd", gopacket.DecodeFunc(decodeDot11CtrlCFEnd)})
	LayerTypeDot11CtrlCFEndAck           = gopacket.RegisterLayerType(90, gopacket.LayerTypeMetadata{"Dot11CtrlCFEndAck", gopacket.DecodeFunc(decodeDot11CtrlCFEndAck)})
	LayerTypeDot11MgmtAssociationReq     = gopacket.RegisterLayerType(91, gopacket.LayerTypeMetadata{"Dot11MgmtAssociationReq", gopacket.DecodeFunc(decodeDot11MgmtAssociationReq)})
	LayerTypeDot11MgmtAssociationResp    = gopacket.RegisterLayerType(92, gopacket.LayerTypeMetadata{"Dot11MgmtAssociationResp", gopacket.DecodeFunc(decodeDot11MgmtAssociationResp)})
	LayerTypeDot11MgmtReassociationReq   = gopacket.RegisterLayerType(93, gopacket.LayerTypeMetadata{"Dot11MgmtReassociationReq", gopacket.DecodeFunc(decodeDot11MgmtReassociationReq)})
	LayerTypeDot11MgmtReassociationResp  = gopacket.RegisterLayerType(94, gopacket.LayerTypeMetadata{"Dot11MgmtReassociationResp", gopacket.DecodeFunc(decodeDot11MgmtReassociationResp)})
	LayerTypeDot11MgmtProbeReq           = gopacket.RegisterLayerType(95, gopacket.LayerTypeMetadata{"Dot11MgmtProbeReq", gopacket.DecodeFunc(decodeDot11MgmtProbeReq)})
	LayerTypeDot11MgmtProbeResp          = gopacket.RegisterLayerType(96, gopacket.LayerTypeMetadata{"Dot11MgmtProbeResp", gopacket.DecodeFunc(decodeDot11MgmtProbeResp)})
	LayerTypeDot11MgmtMeasurementPilot   = gopacket.RegisterLayerType(97, gopacket.LayerTypeMetadata{"Dot11MgmtMeasurementPilot", gopacket.DecodeFunc(decodeDot11MgmtMeasurementPilot)})
	LayerTypeDot11MgmtBeacon             = gopacket.RegisterLayerType(98, gopacket.LayerTypeMetadata{"Dot11MgmtBeacon", gopacket.DecodeFunc(decodeDot11MgmtBeacon)})
	LayerTypeDot11MgmtATIM               = gopacket.RegisterLayerType(99, gopacket.LayerTypeMetadata{"Dot11MgmtATIM", gopacket.DecodeFunc(decodeDot11MgmtATIM)})
	LayerTypeDot11MgmtDisassociation     = gopacket.RegisterLayerType(100, gopacket.LayerTypeMetadata{"Dot11MgmtDisassociation", gopacket.DecodeFunc(decodeDot11MgmtDisassociation)})
	LayerTypeDot11MgmtAuthentication     = gopacket.RegisterLayerType(101, gopacket.LayerTypeMetadata{"Dot11MgmtAuthentication", gopacket.DecodeFunc(decodeDot11MgmtAuthentication)})
	LayerTypeDot11MgmtDeauthentication   = gopacket.RegisterLayerType(102, gopacket.LayerTypeMetadata{"Dot11MgmtDeauthentication", gopacket.DecodeFunc(decodeDot11MgmtDeauthentication)})
	LayerTypeDot11MgmtAction             = gopacket.RegisterLayerType(103, gopacket.LayerTypeMetadata{"Dot11MgmtAction", gopacket.DecodeFunc(decodeDot11MgmtAction)})
	LayerTypeDot11MgmtActionNoAck        = gopacket.RegisterLayerType(104, gopacket.LayerTypeMetadata{"Dot11MgmtActionNoAck", gopacket.DecodeFunc(decodeDot11MgmtActionNoAck)})
	LayerTypeDot11MgmtArubaWLAN          = gopacket.RegisterLayerType(105, gopacket.LayerTypeMetadata{"Dot11MgmtArubaWLAN", gopacket.DecodeFunc(decodeDot11MgmtArubaWLAN)})
	LayerTypeDot11WEP                    = gopacket.RegisterLayerType(106, gopacket.LayerTypeMetadata{"Dot11WEP", gopacket.DecodeFunc(decodeDot11WEP)})
)
View Source 
var (
	// LayerClassIPNetwork contains TCP/IP network layer types.
	LayerClassIPNetwork = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeIPv4,
		LayerTypeIPv6,
	})
	// LayerClassIPTransport contains TCP/IP transport layer types.
	LayerClassIPTransport = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeTCP,
		LayerTypeUDP,
		LayerTypeSCTP,
	})
	// LayerClassIPControl contains TCP/IP control protocols.
	LayerClassIPControl = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeICMPv4,
		LayerTypeICMPv6,
	})
	// LayerClassSCTPChunk contains SCTP chunk types (not the top-level SCTP
	// layer).
	LayerClassSCTPChunk = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeSCTPUnknownChunkType,
		LayerTypeSCTPData,
		LayerTypeSCTPInit,
		LayerTypeSCTPSack,
		LayerTypeSCTPHeartbeat,
		LayerTypeSCTPError,
		LayerTypeSCTPShutdown,
		LayerTypeSCTPShutdownAck,
		LayerTypeSCTPCookieEcho,
		LayerTypeSCTPEmptyLayer,
		LayerTypeSCTPInitAck,
		LayerTypeSCTPHeartbeatAck,
		LayerTypeSCTPAbort,
		LayerTypeSCTPShutdownComplete,
		LayerTypeSCTPCookieAck,
	})
	// LayerClassIPv6Extension contains IPv6 extension headers.
	LayerClassIPv6Extension = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeIPv6HopByHop,
		LayerTypeIPv6Routing,
		LayerTypeIPv6Fragment,
		LayerTypeIPv6Destination,
	})
	LayerClassIPSec = gopacket.NewLayerClass([]gopacket.LayerType{
		LayerTypeIPSecAH,
		LayerTypeIPSecESP,
	})
)
View Source 
var MPLSPayloadDecoder gopacket.Decoder = ProtocolGuessingDecoder{}

MPLSPayloadDecoder is the decoder used to data encapsulated by each MPLS layer. MPLS contains no type information, so we have to explicitly decide which decoder to use. This is initially set to ProtocolGuessingDecoder, our simple attempt at guessing protocols based on the first few bytes of data available to us. However, if you know that in your environment MPLS always encapsulates a specific protocol, you may reset this.

View Source 
var PPPEndpoint = gopacket.NewEndpoint(EndpointPPP, nil)

PPPEndpoint is a singleton endpoint for PPP. Since there is no actual addressing for the two ends of a PPP connection, we use a singleton value named 'point' for each endpoint.

View Source 
var PPPFlow = gopacket.NewFlow(EndpointPPP, nil, nil)

PPPFlow is a singleton flow for PPP. Since there is no actual addressing for the two ends of a PPP connection, we use a singleton value to represent the flow for all PPP connections.

View Source 
var RUDPPortNames = map[RUDPPort]string{}

RUDPPortNames contains the string names for all RUDP ports.

View Source 
var SCTPPortNames = sctpPortNames

SCTPPortNames contains the port names for all SCTP ports.

View Source 
var TCPPortNames = tcpPortNames

TCPPortNames contains the port names for all TCP ports.

View Source 
var UDPLitePortNames = map[UDPLitePort]string{}

UDPLitePortNames contains the string names for all UDPLite ports.

View Source 
var UDPPortNames = udpPortNames

UDPPortNames contains the port names for all UDP ports.

Functions

func NewIPEndpoint 

func NewIPEndpoint(a net.IP) gopacket.Endpoint

NewIPEndpoint creates a new IP (v4 or v6) endpoint from a net.IP address. It returns gopacket.InvalidEndpoint if the IP address is invalid.

func NewMACEndpoint 

func NewMACEndpoint(a net.HardwareAddr) gopacket.Endpoint

NewMACEndpoint returns a new MAC address endpoint.

func NewRUDPPortEndpoint 

func NewRUDPPortEndpoint(p RUDPPort) gopacket.Endpoint

NewRUDPPortEndpoint returns an endpoint based on a RUDP port.

func NewSCTPPortEndpoint 

func NewSCTPPortEndpoint(p SCTPPort) gopacket.Endpoint

NewSCTPPortEndpoint returns an endpoint based on a SCTP port.

func NewTCPPortEndpoint 

func NewTCPPortEndpoint(p TCPPort) gopacket.Endpoint

NewTCPPortEndpoint returns an endpoint based on a TCP port.

func NewUDPLitePortEndpoint 

func NewUDPLitePortEndpoint(p UDPLitePort) gopacket.Endpoint

NewUDPLitePortEndpoint returns an endpoint based on a UDPLite port.

func NewUDPPortEndpoint 

func NewUDPPortEndpoint(p UDPPort) gopacket.Endpoint

NewUDPPortEndpoint returns an endpoint based on a UDP port.

Types

type ARP 

type ARP struct {
	BaseLayer
	AddrType          LinkType
	Protocol          EthernetType
	HwAddressSize     uint8
	ProtAddressSize   uint8
	Operation         uint16
	SourceHwAddress   []byte
	SourceProtAddress []byte
	DstHwAddress      []byte
	DstProtAddress    []byte
}

ARP is a ARP packet header.

func (*ARP) CanDecode 

func (arp *ARP) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*ARP) DecodeFromBytes 

func (arp *ARP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*ARP) LayerType 

func (arp *ARP) LayerType() gopacket.LayerType

LayerType returns LayerTypeARP

func (*ARP) NextLayerType 

func (arp *ARP) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ARP) SerializeTo added in v1.0.1 

func (arp *ARP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type BaseLayer 

type BaseLayer struct {
	// Contents is the set of bytes that make up this layer.  IE: for an
	// Ethernet packet, this would be the set of bytes making up the
	// Ethernet frame.
	Contents []byte
	// Payload is the set of bytes contained by (but not part of) this
	// Layer.  Again, to take Ethernet as an example, this would be the
	// set of bytes encapsulated by the Ethernet protocol.
	Payload []byte
}

BaseLayer is a convenience struct which implements the LayerData and LayerPayload functions of the Layer interface.

func (*BaseLayer) LayerContents 

func (b *BaseLayer) LayerContents() []byte

LayerContents returns the bytes of the packet layer.

func (*BaseLayer) LayerPayload 

func (b *BaseLayer) LayerPayload() []byte

LayerPayload returns the bytes contained within the packet layer.

type CDPAddressType 

type CDPAddressType uint64
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
)

CDP Address types.

func (CDPAddressType) String 

func (a CDPAddressType) String() (s string)

type CDPCapabilities 

type CDPCapabilities struct {
	L3Router        bool
	TBBridge        bool
	SPBridge        bool
	L2Switch        bool
	IsHost          bool
	IGMPFilter      bool
	L1Repeater      bool
	IsPhone         bool
	RemotelyManaged bool
}

CDPCapabilities represents the capabilities of a device

type CDPCapability 

type CDPCapability uint32
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
)

type CDPEnergyWise 

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
}

type CDPEnergyWiseSubtype 

type CDPEnergyWiseSubtype uint32
const (
	CDPEnergyWiseRole    CDPEnergyWiseSubtype = 0x00000007
	CDPEnergyWiseDomain  CDPEnergyWiseSubtype = 0x00000008
	CDPEnergyWiseName    CDPEnergyWiseSubtype = 0x00000009
	CDPEnergyWiseReplyTo CDPEnergyWiseSubtype = 0x00000017
)

func (CDPEnergyWiseSubtype) String 

func (t CDPEnergyWiseSubtype) String() (s string)

type CDPHello 

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
}

CDPHello is a Cisco Hello message (undocumented, hence the "Unknown" fields)

type CDPLocation 

type CDPLocation struct {
	Type     uint8 // Undocumented
	Location string
}

type CDPPowerDialogue 

type CDPPowerDialogue struct {
	ID     uint16
	MgmtID uint16
	Values []uint32
}

CDPPowerDialogue encapsulates a Power Query/Reply

type CDPSparePairPoE 

type CDPSparePairPoE struct {
	PSEFourWire  bool // Supported / Not supported
	PDArchShared bool // Shared / Independent
	PDRequestOn  bool // On / Off
	PSEOn        bool // On / Off
}

type CDPTLVType 

type CDPTLVType uint16

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

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
)

func (CDPTLVType) String 

func (t CDPTLVType) String() (s string)

type CDPVLANDialogue 

type CDPVLANDialogue struct {
	ID   uint8
	VLAN uint16
}

CDPVLANDialogue encapsulates a VLAN Query/Reply

type CiscoDiscovery 

type CiscoDiscovery struct {
	BaseLayer
	Version  byte
	TTL      byte
	Checksum uint16
	Values   []CiscoDiscoveryValue
}

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

func (*CiscoDiscovery) LayerType 

func (c *CiscoDiscovery) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeCiscoDiscovery.

type CiscoDiscoveryInfo 

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
}

CiscoDiscoveryInfo represents the decoded details for a set of CiscoDiscoveryValues

func (*CiscoDiscoveryInfo) LayerType 

func (c *CiscoDiscoveryInfo) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeCiscoDiscoveryInfo.

type CiscoDiscoveryValue 

type CiscoDiscoveryValue struct {
	Type   CDPTLVType
	Length uint16
	Value  []byte
}

CiscoDiscoveryValue is a TLV value inside a CiscoDiscovery packet layer.

type Dot11 added in v1.1.4 

type Dot11 struct {
	BaseLayer
	Type           Dot11Type
	Proto          uint8
	Flags          Dot11Flags
	DurationID     uint16
	Address1       net.HardwareAddr
	Address2       net.HardwareAddr
	Address3       net.HardwareAddr
	Address4       net.HardwareAddr
	SequenceNumber uint16
	FragmentNumber uint16
	Checksum       uint32
}

Dot11 provides an IEEE 802.11 base packet header. See http://standards.ieee.org/findstds/standard/802.11-2012.html for excrutiating detail.

func (*Dot11) CanDecode added in v1.1.4 

func (m *Dot11) CanDecode() gopacket.LayerClass

func (*Dot11) ChecksumValid added in v1.1.4 

func (m *Dot11) ChecksumValid() bool

func (*Dot11) DecodeFromBytes added in v1.1.4 

func (m *Dot11) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11) LayerType added in v1.1.4 

func (m *Dot11) LayerType() gopacket.LayerType

func (*Dot11) NextLayerType added in v1.1.4 

func (m *Dot11) NextLayerType() gopacket.LayerType

type Dot11AckPolicy added in v1.1.4 

type Dot11AckPolicy uint8
const (
	Dot11AckPolicyNormal     Dot11AckPolicy = 0
	Dot11AckPolicyNone       Dot11AckPolicy = 1
	Dot11AckPolicyNoExplicit Dot11AckPolicy = 2
	Dot11AckPolicyBlock      Dot11AckPolicy = 3
)

func (Dot11AckPolicy) String added in v1.1.4 

func (a Dot11AckPolicy) String() string

String provides a human readable string for Dot11AckPolicy. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11AckPolicy value, not its string.

type Dot11Algorithm added in v1.1.4 

type Dot11Algorithm uint16
const (
	Dot11AlgorithmOpen      Dot11Algorithm = 0
	Dot11AlgorithmSharedKey Dot11Algorithm = 1
)

func (Dot11Algorithm) String added in v1.1.4 

func (a Dot11Algorithm) String() string

String provides a human readable string for Dot11Algorithm. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11Algorithm value, not its string.

type Dot11Ctrl added in v1.1.4 

type Dot11Ctrl struct {
	BaseLayer
}

Dot11Ctrl is a base for all IEEE 802.11 control layers.

func (*Dot11Ctrl) CanDecode added in v1.1.4 

func (m *Dot11Ctrl) CanDecode() gopacket.LayerClass

func (*Dot11Ctrl) DecodeFromBytes added in v1.1.4 

func (m *Dot11Ctrl) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11Ctrl) LayerType added in v1.1.4 

func (m *Dot11Ctrl) LayerType() gopacket.LayerType

func (*Dot11Ctrl) NextLayerType added in v1.1.4 

func (m *Dot11Ctrl) NextLayerType() gopacket.LayerType

type Dot11CtrlAck added in v1.1.4 

type Dot11CtrlAck struct {
	Dot11Ctrl
}

func (*Dot11CtrlAck) CanDecode added in v1.1.4 

func (m *Dot11CtrlAck) CanDecode() gopacket.LayerClass

func (*Dot11CtrlAck) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlAck) LayerType added in v1.1.4 

func (m *Dot11CtrlAck) LayerType() gopacket.LayerType

type Dot11CtrlBlockAck added in v1.1.4 

type Dot11CtrlBlockAck struct {
	Dot11Ctrl
}

func (*Dot11CtrlBlockAck) CanDecode added in v1.1.4 

func (m *Dot11CtrlBlockAck) CanDecode() gopacket.LayerClass

func (*Dot11CtrlBlockAck) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlBlockAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlBlockAck) LayerType added in v1.1.4 

func (m *Dot11CtrlBlockAck) LayerType() gopacket.LayerType

type Dot11CtrlBlockAckReq added in v1.1.4 

type Dot11CtrlBlockAckReq struct {
	Dot11Ctrl
}

func (*Dot11CtrlBlockAckReq) CanDecode added in v1.1.4 

func (m *Dot11CtrlBlockAckReq) CanDecode() gopacket.LayerClass

func (*Dot11CtrlBlockAckReq) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlBlockAckReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlBlockAckReq) LayerType added in v1.1.4 

func (m *Dot11CtrlBlockAckReq) LayerType() gopacket.LayerType

type Dot11CtrlCFEnd added in v1.1.4 

type Dot11CtrlCFEnd struct {
	Dot11Ctrl
}

func (*Dot11CtrlCFEnd) CanDecode added in v1.1.4 

func (m *Dot11CtrlCFEnd) CanDecode() gopacket.LayerClass

func (*Dot11CtrlCFEnd) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlCFEnd) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlCFEnd) LayerType added in v1.1.4 

func (m *Dot11CtrlCFEnd) LayerType() gopacket.LayerType

type Dot11CtrlCFEndAck added in v1.1.4 

type Dot11CtrlCFEndAck struct {
	Dot11Ctrl
}

func (*Dot11CtrlCFEndAck) CanDecode added in v1.1.4 

func (m *Dot11CtrlCFEndAck) CanDecode() gopacket.LayerClass

func (*Dot11CtrlCFEndAck) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlCFEndAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlCFEndAck) LayerType added in v1.1.4 

func (m *Dot11CtrlCFEndAck) LayerType() gopacket.LayerType

type Dot11CtrlCTS added in v1.1.4 

type Dot11CtrlCTS struct {
	Dot11Ctrl
}

func (*Dot11CtrlCTS) CanDecode added in v1.1.4 

func (m *Dot11CtrlCTS) CanDecode() gopacket.LayerClass

func (*Dot11CtrlCTS) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlCTS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlCTS) LayerType added in v1.1.4 

func (m *Dot11CtrlCTS) LayerType() gopacket.LayerType

type Dot11CtrlPowersavePoll added in v1.1.4 

type Dot11CtrlPowersavePoll struct {
	Dot11Ctrl
}

func (*Dot11CtrlPowersavePoll) CanDecode added in v1.1.4 

func (m *Dot11CtrlPowersavePoll) CanDecode() gopacket.LayerClass

func (*Dot11CtrlPowersavePoll) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlPowersavePoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlPowersavePoll) LayerType added in v1.1.4 

func (m *Dot11CtrlPowersavePoll) LayerType() gopacket.LayerType

type Dot11CtrlRTS added in v1.1.4 

type Dot11CtrlRTS struct {
	Dot11Ctrl
}

func (*Dot11CtrlRTS) CanDecode added in v1.1.4 

func (m *Dot11CtrlRTS) CanDecode() gopacket.LayerClass

func (*Dot11CtrlRTS) DecodeFromBytes added in v1.1.4 

func (m *Dot11CtrlRTS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11CtrlRTS) LayerType added in v1.1.4 

func (m *Dot11CtrlRTS) LayerType() gopacket.LayerType

type Dot11Data added in v1.1.4 

type Dot11Data struct {
	BaseLayer
}

Dot11Data is a base for all IEEE 802.11 data layers.

func (*Dot11Data) CanDecode added in v1.1.4 

func (m *Dot11Data) CanDecode() gopacket.LayerClass

func (*Dot11Data) DecodeFromBytes added in v1.1.4 

func (m *Dot11Data) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11Data) LayerType added in v1.1.4 

func (m *Dot11Data) LayerType() gopacket.LayerType

func (*Dot11Data) NextLayerType added in v1.1.4 

func (m *Dot11Data) NextLayerType() gopacket.LayerType

type Dot11DataCFAck added in v1.1.4 

type Dot11DataCFAck struct {
	Dot11Data
}

func (*Dot11DataCFAck) CanDecode added in v1.1.4 

func (m *Dot11DataCFAck) CanDecode() gopacket.LayerClass

func (*Dot11DataCFAck) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFAck) LayerType added in v1.1.4 

func (m *Dot11DataCFAck) LayerType() gopacket.LayerType

type Dot11DataCFAckNoData added in v1.1.4 

type Dot11DataCFAckNoData struct {
	Dot11Data
}

func (*Dot11DataCFAckNoData) CanDecode added in v1.1.4 

func (m *Dot11DataCFAckNoData) CanDecode() gopacket.LayerClass

func (*Dot11DataCFAckNoData) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFAckNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFAckNoData) LayerType added in v1.1.4 

func (m *Dot11DataCFAckNoData) LayerType() gopacket.LayerType

type Dot11DataCFAckPoll added in v1.1.4 

type Dot11DataCFAckPoll struct {
	Dot11Data
}

func (*Dot11DataCFAckPoll) CanDecode added in v1.1.4 

func (m *Dot11DataCFAckPoll) CanDecode() gopacket.LayerClass

func (*Dot11DataCFAckPoll) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFAckPoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFAckPoll) LayerType added in v1.1.4 

func (m *Dot11DataCFAckPoll) LayerType() gopacket.LayerType

type Dot11DataCFAckPollNoData added in v1.1.4 

type Dot11DataCFAckPollNoData struct {
	Dot11Data
}

func (*Dot11DataCFAckPollNoData) CanDecode added in v1.1.4 

func (m *Dot11DataCFAckPollNoData) CanDecode() gopacket.LayerClass

func (*Dot11DataCFAckPollNoData) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFAckPollNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFAckPollNoData) LayerType added in v1.1.4 

func (m *Dot11DataCFAckPollNoData) LayerType() gopacket.LayerType

type Dot11DataCFPoll added in v1.1.4 

type Dot11DataCFPoll struct {
	Dot11Data
}

func (*Dot11DataCFPoll) CanDecode added in v1.1.4 

func (m *Dot11DataCFPoll) CanDecode() gopacket.LayerClass

func (*Dot11DataCFPoll) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFPoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFPoll) LayerType added in v1.1.4 

func (m *Dot11DataCFPoll) LayerType() gopacket.LayerType

type Dot11DataCFPollNoData added in v1.1.4 

type Dot11DataCFPollNoData struct {
	Dot11Data
}

func (*Dot11DataCFPollNoData) CanDecode added in v1.1.4 

func (m *Dot11DataCFPollNoData) CanDecode() gopacket.LayerClass

func (*Dot11DataCFPollNoData) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataCFPollNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataCFPollNoData) LayerType added in v1.1.4 

func (m *Dot11DataCFPollNoData) LayerType() gopacket.LayerType

type Dot11DataNull added in v1.1.4 

type Dot11DataNull struct {
	Dot11Data
}

func (*Dot11DataNull) CanDecode added in v1.1.4 

func (m *Dot11DataNull) CanDecode() gopacket.LayerClass

func (*Dot11DataNull) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataNull) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11DataNull) LayerType added in v1.1.4 

func (m *Dot11DataNull) LayerType() gopacket.LayerType

type Dot11DataQOS added in v1.1.4 

type Dot11DataQOS struct {
	Dot11Ctrl
	TID       uint8 /* Traffic IDentifier */
	EOSP      bool  /* End of service period */
	AckPolicy Dot11AckPolicy
	TXOP      uint8
}

func (*Dot11DataQOS) DecodeFromBytes added in v1.1.4 

func (m *Dot11DataQOS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

type Dot11DataQOSCFAckPollNoData added in v1.1.4 

type Dot11DataQOSCFAckPollNoData struct {
	Dot11DataQOS
}

func (*Dot11DataQOSCFAckPollNoData) CanDecode added in v1.1.4 

func (m *Dot11DataQOSCFAckPollNoData) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSCFAckPollNoData) LayerType added in v1.1.4 

func (m *Dot11DataQOSCFAckPollNoData) LayerType() gopacket.LayerType

func (*Dot11DataQOSCFAckPollNoData) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSCFAckPollNoData) NextLayerType() gopacket.LayerType

type Dot11DataQOSCFPollNoData added in v1.1.4 

type Dot11DataQOSCFPollNoData struct {
	Dot11DataQOS
}

func (*Dot11DataQOSCFPollNoData) CanDecode added in v1.1.4 

func (m *Dot11DataQOSCFPollNoData) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSCFPollNoData) LayerType added in v1.1.4 

func (m *Dot11DataQOSCFPollNoData) LayerType() gopacket.LayerType

func (*Dot11DataQOSCFPollNoData) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSCFPollNoData) NextLayerType() gopacket.LayerType

type Dot11DataQOSData added in v1.1.4 

type Dot11DataQOSData struct {
	Dot11DataQOS
}

func (*Dot11DataQOSData) CanDecode added in v1.1.4 

func (m *Dot11DataQOSData) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSData) LayerType added in v1.1.4 

func (m *Dot11DataQOSData) LayerType() gopacket.LayerType

func (*Dot11DataQOSData) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSData) NextLayerType() gopacket.LayerType

type Dot11DataQOSDataCFAck added in v1.1.4 

type Dot11DataQOSDataCFAck struct {
	Dot11DataQOS
}

func (*Dot11DataQOSDataCFAck) CanDecode added in v1.1.4 

func (m *Dot11DataQOSDataCFAck) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSDataCFAck) LayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFAck) LayerType() gopacket.LayerType

func (*Dot11DataQOSDataCFAck) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFAck) NextLayerType() gopacket.LayerType

type Dot11DataQOSDataCFAckPoll added in v1.1.4 

type Dot11DataQOSDataCFAckPoll struct {
	Dot11DataQOS
}

func (*Dot11DataQOSDataCFAckPoll) CanDecode added in v1.1.4 

func (m *Dot11DataQOSDataCFAckPoll) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSDataCFAckPoll) LayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFAckPoll) LayerType() gopacket.LayerType

func (*Dot11DataQOSDataCFAckPoll) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFAckPoll) NextLayerType() gopacket.LayerType

type Dot11DataQOSDataCFPoll added in v1.1.4 

type Dot11DataQOSDataCFPoll struct {
	Dot11DataQOS
}

func (*Dot11DataQOSDataCFPoll) CanDecode added in v1.1.4 

func (m *Dot11DataQOSDataCFPoll) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSDataCFPoll) LayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFPoll) LayerType() gopacket.LayerType

func (*Dot11DataQOSDataCFPoll) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSDataCFPoll) NextLayerType() gopacket.LayerType

type Dot11DataQOSNull added in v1.1.4 

type Dot11DataQOSNull struct {
	Dot11DataQOS
}

func (*Dot11DataQOSNull) CanDecode added in v1.1.4 

func (m *Dot11DataQOSNull) CanDecode() gopacket.LayerClass

func (*Dot11DataQOSNull) LayerType added in v1.1.4 

func (m *Dot11DataQOSNull) LayerType() gopacket.LayerType

func (*Dot11DataQOSNull) NextLayerType added in v1.1.4 

func (m *Dot11DataQOSNull) NextLayerType() gopacket.LayerType

type Dot11Flags added in v1.1.4 

type Dot11Flags uint8

Dot11Flags contains the set of 8 flags in the IEEE 802.11 frame control header, all in one place. 

const (
	Dot11FlagsToDS Dot11Flags = 1 << iota
	Dot11FlagsFromDS
	Dot11FlagsMF
	Dot11FlagsRetry
	Dot11FlagsPowerManagement
	Dot11FlagsMD
	Dot11FlagsWEP
	Dot11FlagsOrder
)

func (Dot11Flags) FromDS added in v1.1.4 

func (d Dot11Flags) FromDS() bool

func (Dot11Flags) MD added in v1.1.4 

func (d Dot11Flags) MD() bool

func (Dot11Flags) MF added in v1.1.4 

func (d Dot11Flags) MF() bool

func (Dot11Flags) Order added in v1.1.4 

func (d Dot11Flags) Order() bool

func (Dot11Flags) PowerManagement added in v1.1.4 

func (d Dot11Flags) PowerManagement() bool

func (Dot11Flags) Retry added in v1.1.4 

func (d Dot11Flags) Retry() bool

func (Dot11Flags) String added in v1.1.4 

func (a Dot11Flags) String() string

String provides a human readable string for Dot11Flags. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11Flags value, not its string.

func (Dot11Flags) ToDS added in v1.1.4 

func (d Dot11Flags) ToDS() bool

func (Dot11Flags) WEP added in v1.1.4 

func (d Dot11Flags) WEP() bool

type Dot11InformationElement added in v1.1.4 

type Dot11InformationElement struct {
	BaseLayer
	ID     Dot11InformationElementID
	Length uint8
	OUI    []byte
	Info   []byte
}

func (*Dot11InformationElement) CanDecode added in v1.1.4 

func (m *Dot11InformationElement) CanDecode() gopacket.LayerClass

func (*Dot11InformationElement) DecodeFromBytes added in v1.1.4 

func (m *Dot11InformationElement) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11InformationElement) LayerType added in v1.1.4 

func (m *Dot11InformationElement) LayerType() gopacket.LayerType

func (*Dot11InformationElement) NextLayerType added in v1.1.4 

func (m *Dot11InformationElement) NextLayerType() gopacket.LayerType

func (*Dot11InformationElement) String added in v1.1.4 

func (d *Dot11InformationElement) String() string

type Dot11InformationElementID added in v1.1.4 

type Dot11InformationElementID uint8
const (
	Dot11InformationElementIDSSID          Dot11InformationElementID = 0
	Dot11InformationElementIDRates         Dot11InformationElementID = 1
	Dot11InformationElementIDFHSet         Dot11InformationElementID = 2
	Dot11InformationElementIDDSSet         Dot11InformationElementID = 3
	Dot11InformationElementIDCFSet         Dot11InformationElementID = 4
	Dot11InformationElementIDTIM           Dot11InformationElementID = 5
	Dot11InformationElementIDIBSSSet       Dot11InformationElementID = 6
	Dot11InformationElementIDChallenge     Dot11InformationElementID = 16
	Dot11InformationElementIDERPInfo       Dot11InformationElementID = 42
	Dot11InformationElementIDQOSCapability Dot11InformationElementID = 46
	Dot11InformationElementIDERPInfo2      Dot11InformationElementID = 47
	Dot11InformationElementIDRSNInfo       Dot11InformationElementID = 48
	Dot11InformationElementIDESRates       Dot11InformationElementID = 50
	Dot11InformationElementIDVendor        Dot11InformationElementID = 221
	Dot11InformationElementIDReserved      Dot11InformationElementID = 68
)

func (Dot11InformationElementID) String added in v1.1.4 

func (a Dot11InformationElementID) String() string

String provides a human readable string for Dot11InformationElementID. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11InformationElementID value, not its string.

type Dot11Mgmt added in v1.1.4 

type Dot11Mgmt struct {
	BaseLayer
}

Dot11Mgmt is a base for all IEEE 802.11 management layers.

func (*Dot11Mgmt) DecodeFromBytes added in v1.1.4 

func (m *Dot11Mgmt) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11Mgmt) NextLayerType added in v1.1.4 

func (m *Dot11Mgmt) NextLayerType() gopacket.LayerType

type Dot11MgmtATIM added in v1.1.4 

type Dot11MgmtATIM struct {
	Dot11Mgmt
}

func (*Dot11MgmtATIM) CanDecode added in v1.1.4 

func (m *Dot11MgmtATIM) CanDecode() gopacket.LayerClass

func (*Dot11MgmtATIM) LayerType added in v1.1.4 

func (m *Dot11MgmtATIM) LayerType() gopacket.LayerType

type Dot11MgmtAction added in v1.1.4 

type Dot11MgmtAction struct {
	Dot11Mgmt
}

func (*Dot11MgmtAction) CanDecode added in v1.1.4 

func (m *Dot11MgmtAction) CanDecode() gopacket.LayerClass

func (*Dot11MgmtAction) LayerType added in v1.1.4 

func (m *Dot11MgmtAction) LayerType() gopacket.LayerType

type Dot11MgmtActionNoAck added in v1.1.4 

type Dot11MgmtActionNoAck struct {
	Dot11Mgmt
}

func (*Dot11MgmtActionNoAck) CanDecode added in v1.1.4 

func (m *Dot11MgmtActionNoAck) CanDecode() gopacket.LayerClass

func (*Dot11MgmtActionNoAck) LayerType added in v1.1.4 

func (m *Dot11MgmtActionNoAck) LayerType() gopacket.LayerType

type Dot11MgmtArubaWLAN added in v1.1.4 

type Dot11MgmtArubaWLAN struct {
	Dot11Mgmt
}

func (*Dot11MgmtArubaWLAN) CanDecode added in v1.1.4 

func (m *Dot11MgmtArubaWLAN) CanDecode() gopacket.LayerClass

func (*Dot11MgmtArubaWLAN) LayerType added in v1.1.4 

func (m *Dot11MgmtArubaWLAN) LayerType() gopacket.LayerType

type Dot11MgmtAssociationReq added in v1.1.4 

type Dot11MgmtAssociationReq struct {
	Dot11Mgmt
	CapabilityInfo uint16
	ListenInterval uint16
}

func (*Dot11MgmtAssociationReq) CanDecode added in v1.1.4 

func (m *Dot11MgmtAssociationReq) CanDecode() gopacket.LayerClass

func (*Dot11MgmtAssociationReq) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtAssociationReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtAssociationReq) LayerType added in v1.1.4 

func (m *Dot11MgmtAssociationReq) LayerType() gopacket.LayerType

func (*Dot11MgmtAssociationReq) NextLayerType added in v1.1.4 

func (m *Dot11MgmtAssociationReq) NextLayerType() gopacket.LayerType

type Dot11MgmtAssociationResp added in v1.1.4 

type Dot11MgmtAssociationResp struct {
	Dot11Mgmt
	CapabilityInfo uint16
	Status         Dot11Status
	AID            uint16
}

func (*Dot11MgmtAssociationResp) CanDecode added in v1.1.4 

func (m *Dot11MgmtAssociationResp) CanDecode() gopacket.LayerClass

func (*Dot11MgmtAssociationResp) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtAssociationResp) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtAssociationResp) LayerType added in v1.1.4 

func (m *Dot11MgmtAssociationResp) LayerType() gopacket.LayerType

func (*Dot11MgmtAssociationResp) NextLayerType added in v1.1.4 

func (m *Dot11MgmtAssociationResp) NextLayerType() gopacket.LayerType

type Dot11MgmtAuthentication added in v1.1.4 

type Dot11MgmtAuthentication struct {
	Dot11Mgmt
	Algorithm Dot11Algorithm
	Sequence  uint16
	Status    Dot11Status
}

func (*Dot11MgmtAuthentication) CanDecode added in v1.1.4 

func (m *Dot11MgmtAuthentication) CanDecode() gopacket.LayerClass

func (*Dot11MgmtAuthentication) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtAuthentication) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtAuthentication) LayerType added in v1.1.4 

func (m *Dot11MgmtAuthentication) LayerType() gopacket.LayerType

func (*Dot11MgmtAuthentication) NextLayerType added in v1.1.4 

func (m *Dot11MgmtAuthentication) NextLayerType() gopacket.LayerType

type Dot11MgmtBeacon added in v1.1.4 

type Dot11MgmtBeacon struct {
	Dot11Mgmt
	Timestamp uint64
	Interval  uint16
	Flags     uint16
}

func (*Dot11MgmtBeacon) CanDecode added in v1.1.4 

func (m *Dot11MgmtBeacon) CanDecode() gopacket.LayerClass

func (*Dot11MgmtBeacon) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtBeacon) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtBeacon) LayerType added in v1.1.4 

func (m *Dot11MgmtBeacon) LayerType() gopacket.LayerType

func (*Dot11MgmtBeacon) NextLayerType added in v1.1.4 

func (m *Dot11MgmtBeacon) NextLayerType() gopacket.LayerType

type Dot11MgmtDeauthentication added in v1.1.4 

type Dot11MgmtDeauthentication struct {
	Dot11Mgmt
	Reason Dot11Reason
}

func (*Dot11MgmtDeauthentication) CanDecode added in v1.1.4 

func (m *Dot11MgmtDeauthentication) CanDecode() gopacket.LayerClass

func (*Dot11MgmtDeauthentication) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtDeauthentication) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtDeauthentication) LayerType added in v1.1.4 

func (m *Dot11MgmtDeauthentication) LayerType() gopacket.LayerType

type Dot11MgmtDisassociation added in v1.1.4 

type Dot11MgmtDisassociation struct {
	Dot11Mgmt
	Reason Dot11Reason
}

func (*Dot11MgmtDisassociation) CanDecode added in v1.1.4 

func (m *Dot11MgmtDisassociation) CanDecode() gopacket.LayerClass

func (*Dot11MgmtDisassociation) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtDisassociation) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtDisassociation) LayerType added in v1.1.4 

func (m *Dot11MgmtDisassociation) LayerType() gopacket.LayerType

type Dot11MgmtMeasurementPilot added in v1.1.4 

type Dot11MgmtMeasurementPilot struct {
	Dot11Mgmt
}

func (*Dot11MgmtMeasurementPilot) CanDecode added in v1.1.4 

func (m *Dot11MgmtMeasurementPilot) CanDecode() gopacket.LayerClass

func (*Dot11MgmtMeasurementPilot) LayerType added in v1.1.4 

func (m *Dot11MgmtMeasurementPilot) LayerType() gopacket.LayerType

type Dot11MgmtProbeReq added in v1.1.4 

type Dot11MgmtProbeReq struct {
	Dot11Mgmt
}

func (*Dot11MgmtProbeReq) CanDecode added in v1.1.4 

func (m *Dot11MgmtProbeReq) CanDecode() gopacket.LayerClass

func (*Dot11MgmtProbeReq) LayerType added in v1.1.4 

func (m *Dot11MgmtProbeReq) LayerType() gopacket.LayerType

func (*Dot11MgmtProbeReq) NextLayerType added in v1.1.4 

func (m *Dot11MgmtProbeReq) NextLayerType() gopacket.LayerType

type Dot11MgmtProbeResp added in v1.1.4 

type Dot11MgmtProbeResp struct {
	Dot11Mgmt
}

func (*Dot11MgmtProbeResp) CanDecode added in v1.1.4 

func (m *Dot11MgmtProbeResp) CanDecode() gopacket.LayerClass

func (*Dot11MgmtProbeResp) LayerType added in v1.1.4 

func (m *Dot11MgmtProbeResp) LayerType() gopacket.LayerType

func (*Dot11MgmtProbeResp) NextLayerType added in v1.1.4 

func (m *Dot11MgmtProbeResp) NextLayerType() gopacket.LayerType

type Dot11MgmtReassociationReq added in v1.1.4 

type Dot11MgmtReassociationReq struct {
	Dot11Mgmt
	CapabilityInfo   uint16
	ListenInterval   uint16
	CurrentApAddress net.HardwareAddr
}

func (*Dot11MgmtReassociationReq) CanDecode added in v1.1.4 

func (m *Dot11MgmtReassociationReq) CanDecode() gopacket.LayerClass

func (*Dot11MgmtReassociationReq) DecodeFromBytes added in v1.1.4 

func (m *Dot11MgmtReassociationReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11MgmtReassociationReq) LayerType added in v1.1.4 

func (m *Dot11MgmtReassociationReq) LayerType() gopacket.LayerType

func (*Dot11MgmtReassociationReq) NextLayerType added in v1.1.4 

func (m *Dot11MgmtReassociationReq) NextLayerType() gopacket.LayerType

type Dot11MgmtReassociationResp added in v1.1.4 

type Dot11MgmtReassociationResp struct {
	Dot11Mgmt
}

func (*Dot11MgmtReassociationResp) CanDecode added in v1.1.4 

func (m *Dot11MgmtReassociationResp) CanDecode() gopacket.LayerClass

func (*Dot11MgmtReassociationResp) LayerType added in v1.1.4 

func (m *Dot11MgmtReassociationResp) LayerType() gopacket.LayerType

func (*Dot11MgmtReassociationResp) NextLayerType added in v1.1.4 

func (m *Dot11MgmtReassociationResp) NextLayerType() gopacket.LayerType

type Dot11Reason added in v1.1.4 

type Dot11Reason uint16
const (
	Dot11ReasonReserved          Dot11Reason = 1
	Dot11ReasonUnspecified       Dot11Reason = 2
	Dot11ReasonAuthExpired       Dot11Reason = 3
	Dot11ReasonDeauthStLeaving   Dot11Reason = 4
	Dot11ReasonInactivity        Dot11Reason = 5
	Dot11ReasonApFull            Dot11Reason = 6
	Dot11ReasonClass2FromNonAuth Dot11Reason = 7
	Dot11ReasonClass3FromNonAss  Dot11Reason = 8
	Dot11ReasonDisasStLeaving    Dot11Reason = 9
	Dot11ReasonStNotAuth         Dot11Reason = 10
)

func (Dot11Reason) String added in v1.1.4 

func (a Dot11Reason) String() string

String provides a human readable string for Dot11Reason. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11Reason value, not its string.

type Dot11Status added in v1.1.4 

type Dot11Status uint16
const (
	Dot11StatusSuccess                      Dot11Status = 0
	Dot11StatusFailure                      Dot11Status = 1  // Unspecified failure
	Dot11StatusCannotSupportAllCapabilities Dot11Status = 10 // Cannot support all requested capabilities in the Capability Information field
	Dot11StatusInabilityExistsAssociation   Dot11Status = 11 // Reassociation denied due to inability to confirm that association exists
	Dot11StatusAssociationDenied            Dot11Status = 12 // Association denied due to reason outside the scope of this standard
	Dot11StatusAlgorithmUnsupported         Dot11Status = 13 // Responding station does not support the specified authentication algorithm
	Dot11StatusOufOfExpectedSequence        Dot11Status = 14 // Received an Authentication frame with authentication transaction sequence number out of expected sequence
	Dot11StatusChallengeFailure             Dot11Status = 15 // Authentication rejected because of challenge failure
	Dot11StatusTimeout                      Dot11Status = 16 // Authentication rejected due to timeout waiting for next frame in sequence
	Dot11StatusAPUnableToHandle             Dot11Status = 17 // Association denied because AP is unable to handle additional associated stations
	Dot11StatusRateUnsupported              Dot11Status = 18 // Association denied due to requesting station not supporting all of the data rates in the BSSBasicRateSet parameter
)

func (Dot11Status) String added in v1.1.4 

func (a Dot11Status) String() string

String provides a human readable string for Dot11Status. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the Dot11Status value, not its string.

type Dot11Type added in v1.1.4 

type Dot11Type uint8

Dot11Type is a combination of IEEE 802.11 frame's Type and Subtype fields. By combining these two fields together into a single type, we're able to provide a String function that correctly displays the subtype given the top-level type.

If you just care about the top-level type, use the MainType function. 

const (
	Dot11TypeMgmt     Dot11Type = 0x00
	Dot11TypeCtrl     Dot11Type = 0x01
	Dot11TypeData     Dot11Type = 0x02
	Dot11TypeReserved Dot11Type = 0x03

	// Management
	Dot11TypeMgmtAssociationReq    Dot11Type = 0x00
	Dot11TypeMgmtAssociationResp   Dot11Type = 0x04
	Dot11TypeMgmtReassociationReq  Dot11Type = 0x08
	Dot11TypeMgmtReassociationResp Dot11Type = 0x0c
	Dot11TypeMgmtProbeReq          Dot11Type = 0x10
	Dot11TypeMgmtProbeResp         Dot11Type = 0x14
	Dot11TypeMgmtMeasurementPilot  Dot11Type = 0x18
	Dot11TypeMgmtBeacon            Dot11Type = 0x20
	Dot11TypeMgmtATIM              Dot11Type = 0x24
	Dot11TypeMgmtDisassociation    Dot11Type = 0x28
	Dot11TypeMgmtAuthentication    Dot11Type = 0x2c
	Dot11TypeMgmtDeauthentication  Dot11Type = 0x30
	Dot11TypeMgmtAction            Dot11Type = 0x34
	Dot11TypeMgmtActionNoAck       Dot11Type = 0x38

	// Control
	Dot11TypeCtrlWrapper       Dot11Type = 0x1d
	Dot11TypeCtrlBlockAckReq   Dot11Type = 0x21
	Dot11TypeCtrlBlockAck      Dot11Type = 0x25
	Dot11TypeCtrlPowersavePoll Dot11Type = 0x29
	Dot11TypeCtrlRTS           Dot11Type = 0x2d
	Dot11TypeCtrlCTS           Dot11Type = 0x31
	Dot11TypeCtrlAck           Dot11Type = 0x35
	Dot11TypeCtrlCFEnd         Dot11Type = 0x39
	Dot11TypeCtrlCFEndAck      Dot11Type = 0x3d

	// Data
	Dot11TypeDataCFAck              Dot11Type = 0x06
	Dot11TypeDataCFPoll             Dot11Type = 0x0a
	Dot11TypeDataCFAckPoll          Dot11Type = 0x0e
	Dot11TypeDataNull               Dot11Type = 0x12
	Dot11TypeDataCFAckNoData        Dot11Type = 0x16
	Dot11TypeDataCFPollNoData       Dot11Type = 0x1a
	Dot11TypeDataCFAckPollNoData    Dot11Type = 0x1e
	Dot11TypeDataQOSData            Dot11Type = 0x22
	Dot11TypeDataQOSDataCFAck       Dot11Type = 0x26
	Dot11TypeDataQOSDataCFPoll      Dot11Type = 0x2a
	Dot11TypeDataQOSDataCFAckPoll   Dot11Type = 0x2e
	Dot11TypeDataQOSNull            Dot11Type = 0x32
	Dot11TypeDataQOSCFPollNoData    Dot11Type = 0x3a
	Dot11TypeDataQOSCFAckPollNoData Dot11Type = 0x3e
)

func (Dot11Type) Decode added in v1.1.4 

func (a Dot11Type) Decode(data []byte, p gopacket.PacketBuilder) error

func (Dot11Type) LayerType added in v1.1.4 

func (a Dot11Type) LayerType() gopacket.LayerType

func (Dot11Type) MainType added in v1.1.4 

func (d Dot11Type) MainType() Dot11Type

MainType strips the subtype information from the given type, returning just the overarching type (Mgmt, Ctrl, Data, Reserved).

func (Dot11Type) String added in v1.1.4 

func (a Dot11Type) String() string

type Dot11WEP added in v1.1.4 

type Dot11WEP struct {
	BaseLayer
}

Dot11WEP contains WEP encrpted IEEE 802.11 data.

func (*Dot11WEP) CanDecode added in v1.1.4 

func (m *Dot11WEP) CanDecode() gopacket.LayerClass

func (*Dot11WEP) DecodeFromBytes added in v1.1.4 

func (m *Dot11WEP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Dot11WEP) LayerType added in v1.1.4 

func (m *Dot11WEP) LayerType() gopacket.LayerType

func (*Dot11WEP) NextLayerType added in v1.1.4 

func (m *Dot11WEP) NextLayerType() gopacket.LayerType

type Dot1Q 

type Dot1Q struct {
	BaseLayer
	Priority       uint8
	DropEligible   bool
	VLANIdentifier uint16
	Type           EthernetType
}

Dot1Q is the packet layer for 802.1Q VLAN headers.

func (*Dot1Q) CanDecode 

func (d *Dot1Q) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*Dot1Q) DecodeFromBytes 

func (d *Dot1Q) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*Dot1Q) LayerType 

func (d *Dot1Q) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeDot1Q

func (*Dot1Q) NextLayerType 

func (d *Dot1Q) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

func (*Dot1Q) SerializeTo 

func (d *Dot1Q) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type EAP 

type EAP struct {
	BaseLayer
	Code     EAPCode
	Id       uint8
	Length   uint16
	Type     EAPType
	TypeData []byte
}

EAP defines an Extensible Authentication Protocol (rfc 3748) layer.

func (*EAP) CanDecode 

func (e *EAP) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*EAP) DecodeFromBytes 

func (e *EAP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*EAP) LayerType 

func (e *EAP) LayerType() gopacket.LayerType

LayerType returns LayerTypeEAP.

func (*EAP) NextLayerType 

func (e *EAP) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

func (*EAP) SerializeTo added in v1.0.1 

func (e *EAP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type EAPCode 

type EAPCode uint8

type EAPOL 

type EAPOL struct {
	BaseLayer
	Version uint8
	Type    EAPOLType
}

EAPOL defines an EAP over LAN (802.1x) layer.

func (*EAPOL) CanDecode 

func (e *EAPOL) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*EAPOL) DecodeFromBytes 

func (e *EAPOL) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*EAPOL) LayerType 

func (e *EAPOL) LayerType() gopacket.LayerType

LayerType returns LayerTypeEAPOL.

func (*EAPOL) NextLayerType 

func (e *EAPOL) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

type EAPOLType 

type EAPOLType uint8

EAPOLType is an enumeration of EAPOL packet types. 

const (
	EAPOLTypeEAP      EAPOLType = 0
	EAPOLTypeStart    EAPOLType = 1
	EAPOLTypeLogOff   EAPOLType = 2
	EAPOLTypeKey      EAPOLType = 3
	EAPOLTypeASFAlert EAPOLType = 4
)

func (EAPOLType) Decode 

func (a EAPOLType) Decode(data []byte, p gopacket.PacketBuilder) error

func (EAPOLType) LayerType 

func (a EAPOLType) LayerType() gopacket.LayerType

func (EAPOLType) String 

func (a EAPOLType) String() string

type EAPType 

type EAPType uint8

type EnumMetadata 

type EnumMetadata struct {
	// DecodeWith is the decoder to use to decode this protocol's data.
	DecodeWith gopacket.Decoder
	// Name is the name of the enumeration value.
	Name string
	// LayerType is the layer type implied by the given enum.
	LayerType gopacket.LayerType
}

EnumMetadata keeps track of a set of metadata for each enumeration value for protocol enumerations.

type EtherIP 

type EtherIP struct {
	BaseLayer
	Version  uint8
	Reserved uint16
}

EtherIP is the struct for storing RFC 3378 EtherIP packet headers.

func (*EtherIP) CanDecode 

func (e *EtherIP) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*EtherIP) DecodeFromBytes 

func (e *EtherIP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*EtherIP) LayerType 

func (e *EtherIP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeEtherIP.

func (*EtherIP) NextLayerType 

func (e *EtherIP) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

type Ethernet 

type Ethernet struct {
	BaseLayer
	SrcMAC, DstMAC net.HardwareAddr
	EthernetType   EthernetType
	// Length is only set if a length field exists within this header.  Ethernet
	// headers follow two different standards, one that uses an EthernetType, the
	// other which defines a length the follows with a LLC header (802.3).  If the
	// former is the case, we set EthernetType and Length stays 0.  In the latter
	// case, we set Length and EthernetType = EthernetTypeLLC.
	Length uint16
}

Ethernet is the layer for Ethernet frame headers.

func (*Ethernet) CanDecode 

func (eth *Ethernet) CanDecode() gopacket.LayerClass

func (*Ethernet) DecodeFromBytes 

func (eth *Ethernet) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Ethernet) LayerType 

func (e *Ethernet) LayerType() gopacket.LayerType

LayerType returns LayerTypeEthernet

func (*Ethernet) LinkFlow 

func (e *Ethernet) LinkFlow() gopacket.Flow

func (*Ethernet) NextLayerType 

func (eth *Ethernet) NextLayerType() gopacket.LayerType

func (*Ethernet) SerializeTo 

func (eth *Ethernet) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type EthernetCTP 

type EthernetCTP struct {
	BaseLayer
	SkipCount uint16
}

EthernetCTP implements the EthernetCTP protocol, see http://www.mit.edu/people/jhawk/ctp.html. We split EthernetCTP up into the top-level EthernetCTP layer, followed by zero or more EthernetCTPForwardData layers, followed by a final EthernetCTPReply layer.

func (*EthernetCTP) LayerType 

func (c *EthernetCTP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeEthernetCTP.

type EthernetCTPForwardData 

type EthernetCTPForwardData struct {
	BaseLayer
	Function       EthernetCTPFunction
	ForwardAddress []byte
}

EthernetCTPForwardData is the ForwardData layer inside EthernetCTP. See EthernetCTP's docs for more details.

func (*EthernetCTPForwardData) ForwardEndpoint 

func (c *EthernetCTPForwardData) ForwardEndpoint() gopacket.Endpoint

ForwardEndpoint returns the EthernetCTPForwardData ForwardAddress as an endpoint.

func (*EthernetCTPForwardData) LayerType 

func (c *EthernetCTPForwardData) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeEthernetCTPForwardData.

type EthernetCTPFunction 

type EthernetCTPFunction uint16

EthernetCTPFunction is the function code used by the EthernetCTP protocol to identify each EthernetCTP layer. 

const (
	EthernetCTPFunctionReply       EthernetCTPFunction = 1
	EthernetCTPFunctionForwardData EthernetCTPFunction = 2
)

type EthernetCTPReply 

type EthernetCTPReply struct {
	BaseLayer
	Function      EthernetCTPFunction
	ReceiptNumber uint16
	Data          []byte
}

EthernetCTPReply is the Reply layer inside EthernetCTP. See EthernetCTP's docs for more details.

func (*EthernetCTPReply) LayerType 

func (c *EthernetCTPReply) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeEthernetCTPReply.

func (*EthernetCTPReply) Payload 

func (c *EthernetCTPReply) Payload() []byte

Payload returns the EthernetCTP reply's Data bytes.

type EthernetType 

type EthernetType uint16

EthernetType is an enumeration of ethernet type values, and acts as a decoder for any type it supports. 

const (
	// EthernetTypeLLC is not an actual ethernet type.  It is instead a
	// placeholder we use in Ethernet frames that use the 802.3 standard of
	// srcmac|dstmac|length|LLC instead of srcmac|dstmac|ethertype.
	EthernetTypeLLC                EthernetType = 0
	EthernetTypeIPv4               EthernetType = 0x0800
	EthernetTypeARP                EthernetType = 0x0806
	EthernetTypeIPv6               EthernetType = 0x86DD
	EthernetTypeCiscoDiscovery     EthernetType = 0x2000
	EthernetTypeNortelDiscovery    EthernetType = 0x01a2
	EthernetTypeDot1Q              EthernetType = 0x8100
	EthernetTypePPPoEDiscovery     EthernetType = 0x8863
	EthernetTypePPPoESession       EthernetType = 0x8864
	EthernetTypeMPLSUnicast        EthernetType = 0x8847
	EthernetTypeMPLSMulticast      EthernetType = 0x8848
	EthernetTypeEAPOL              EthernetType = 0x888e
	EthernetTypeLinkLayerDiscovery EthernetType = 0x88cc
	EthernetTypeEthernetCTP        EthernetType = 0x9000
)

func (EthernetType) Decode 

func (a EthernetType) Decode(data []byte, p gopacket.PacketBuilder) error

func (EthernetType) LayerType 

func (a EthernetType) LayerType() gopacket.LayerType

func (EthernetType) String 

func (a EthernetType) String() string

type FDDI 

type FDDI struct {
	BaseLayer
	FrameControl   FDDIFrameControl
	Priority       uint8
	SrcMAC, DstMAC net.HardwareAddr
}

FDDI contains the header for FDDI frames.

func (*FDDI) LayerType 

func (f *FDDI) LayerType() gopacket.LayerType

LayerType returns LayerTypeFDDI.

func (*FDDI) LinkFlow 

func (f *FDDI) LinkFlow() gopacket.Flow

LinkFlow returns a new flow of type EndpointMAC.

type FDDIFrameControl 

type FDDIFrameControl uint8

FDDIFrameControl is an enumeration of FDDI frame control bytes. 

const (
	FDDIFrameControlLLC FDDIFrameControl = 0x50
)

func (FDDIFrameControl) Decode 

func (a FDDIFrameControl) Decode(data []byte, p gopacket.PacketBuilder) error

func (FDDIFrameControl) String 

func (a FDDIFrameControl) String() string

type GRE 

type GRE struct {
	BaseLayer
	ChecksumPresent, RoutingPresent, KeyPresent, SeqPresent, StrictSourceRoute bool
	RecursionControl, Flags, Version                                           uint8
	Protocol                                                                   EthernetType
	Checksum, Offset                                                           uint16
	Key, Seq                                                                   uint32
	*GRERouting
}

GRE is a Generic Routing Encapsulation header.

func (*GRE) CanDecode 

func (g *GRE) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*GRE) DecodeFromBytes 

func (g *GRE) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*GRE) LayerType 

func (g *GRE) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeGRE.

func (*GRE) NextLayerType 

func (g *GRE) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

type GRERouting 

type GRERouting struct {
	AddressFamily        uint16
	SREOffset, SRELength uint8
	RoutingInformation   []byte
}

GRERouting is GRE routing information, present if the RoutingPresent flag is set.

type IANAAddressFamily 

type IANAAddressFamily byte
const (
	IANAAddressFamilyReserved IANAAddressFamily = 0
	IANAAddressFamilyIPV4     IANAAddressFamily = 1
	IANAAddressFamilyIPV6     IANAAddressFamily = 2
	IANAAddressFamilyNSAP     IANAAddressFamily = 3
	IANAAddressFamilyHDLC     IANAAddressFamily = 4
	IANAAddressFamilyBBN1822  IANAAddressFamily = 5
	IANAAddressFamily802      IANAAddressFamily = 6
	IANAAddressFamilyE163     IANAAddressFamily = 7
	IANAAddressFamilyE164     IANAAddressFamily = 8
	IANAAddressFamilyF69      IANAAddressFamily = 9
	IANAAddressFamilyX121     IANAAddressFamily = 10
	IANAAddressFamilyIPX      IANAAddressFamily = 11
	IANAAddressFamilyAtalk    IANAAddressFamily = 12
	IANAAddressFamilyDecnet   IANAAddressFamily = 13
	IANAAddressFamilyBanyan   IANAAddressFamily = 14
	IANAAddressFamilyE164NSAP IANAAddressFamily = 15
	IANAAddressFamilyDNS      IANAAddressFamily = 16
	IANAAddressFamilyDistname IANAAddressFamily = 17
	IANAAddressFamilyASNumber IANAAddressFamily = 18
	IANAAddressFamilyXTPIPV4  IANAAddressFamily = 19
	IANAAddressFamilyXTPIPV6  IANAAddressFamily = 20
	IANAAddressFamilyXTP      IANAAddressFamily = 21
	IANAAddressFamilyFcWWPN   IANAAddressFamily = 22
	IANAAddressFamilyFcWWNN   IANAAddressFamily = 23
	IANAAddressFamilyGWID     IANAAddressFamily = 24
	IANAAddressFamilyL2VPN    IANAAddressFamily = 25
)

LLDP Management Address Subtypes http://www.iana.org/assignments/address-family-numbers/address-family-numbers.xml

func (IANAAddressFamily) String 

func (t IANAAddressFamily) String() (s string)

type ICMPv4 

type ICMPv4 struct {
	BaseLayer
	TypeCode ICMPv4TypeCode
	Checksum uint16
	Id       uint16
	Seq      uint16
}

ICMPv4 is the layer for IPv4 ICMP packet data.

func (*ICMPv4) CanDecode 

func (i *ICMPv4) CanDecode() gopacket.LayerClass

func (*ICMPv4) DecodeFromBytes 

func (i *ICMPv4) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*ICMPv4) LayerType 

func (i *ICMPv4) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeICMPv4

func (*ICMPv4) NextLayerType 

func (i *ICMPv4) NextLayerType() gopacket.LayerType

func (*ICMPv4) SerializeTo added in v1.0.1 

func (i *ICMPv4) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type ICMPv4TypeCode 

type ICMPv4TypeCode uint16

func (ICMPv4TypeCode) String 

func (a ICMPv4TypeCode) String() string

type ICMPv6 

type ICMPv6 struct {
	BaseLayer
	TypeCode  ICMPv6TypeCode
	Checksum  uint16
	TypeBytes []byte
	// contains filtered or unexported fields
}

ICMPv6 is the layer for IPv6 ICMP packet data

func (*ICMPv6) CanDecode 

func (i *ICMPv6) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*ICMPv6) DecodeFromBytes 

func (i *ICMPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6) LayerType 

func (i *ICMPv6) LayerType() gopacket.LayerType

LayerType returns LayerTypeICMPv6.

func (*ICMPv6) NextLayerType 

func (i *ICMPv6) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6) SerializeTo added in v1.0.1 

func (i *ICMPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

func (*ICMPv6) SetNetworkLayerForChecksum added in v1.0.1 

func (i *ICMPv6) SetNetworkLayerForChecksum(l gopacket.NetworkLayer) error

SetNetworkLayerForChecksum tells this layer which network layer is wrapping it. This is needed for computing the checksum when serializing, since TCP/IP transport layer checksums depends on fields in the IPv4 or IPv6 layer that contains it. The passed in layer must be an *IPv4 or *IPv6.

type ICMPv6TypeCode 

type ICMPv6TypeCode uint16

func (ICMPv6TypeCode) String 

func (a ICMPv6TypeCode) String() string

type IEEEOUI 

type IEEEOUI uint32
const (
	IEEEOUI8021     IEEEOUI = 0x0080c2
	IEEEOUI8023     IEEEOUI = 0x00120f
	IEEEOUI80211    IEEEOUI = 0x000fac
	IEEEOUI8021Qbg  IEEEOUI = 0x0013BF
	IEEEOUICisco2   IEEEOUI = 0x000142
	IEEEOUIMedia    IEEEOUI = 0x0012bb // TR-41
	IEEEOUIProfinet IEEEOUI = 0x000ecf
	IEEEOUIDCBX     IEEEOUI = 0x001b21
)

http://standards.ieee.org/develop/regauth/oui/oui.txt

type IGMP 

type IGMP struct {
	BaseLayer
	Type            IGMPType
	MaxResponseTime time.Duration
	Checksum        uint16
	GroupAddress    net.IP
	// The following are used only by IGMPv3
	SupressRouterProcessing bool
	RobustnessValue         uint8
	IntervalTime            time.Duration
	SourceAddresses         []net.IP
}

IGMP is the packet structure for IGMP messages.

func (*IGMP) CanDecode 

func (i *IGMP) CanDecode() gopacket.LayerClass

CanDecode returns the set of layer types that this DecodingLayer can decode.

func (*IGMP) DecodeFromBytes 

func (i *IGMP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*IGMP) LayerType 

func (i *IGMP) LayerType() gopacket.LayerType

LayerType returns LayerTypeIGMP

func (*IGMP) NextLayerType 

func (i *IGMP) NextLayerType() gopacket.LayerType

NextLayerType returns the layer type contained by this DecodingLayer.

type IGMPType 

type IGMPType uint8

type IPProtocol 

type IPProtocol uint8

IPProtocol is an enumeration of IP protocol values, and acts as a decoder for any type it supports. 

const (
	IPProtocolIPv6HopByHop    IPProtocol = 0
	IPProtocolICMPv4          IPProtocol = 1
	IPProtocolIGMP            IPProtocol = 2
	IPProtocolTCP             IPProtocol = 6
	IPProtocolUDP             IPProtocol = 17
	IPProtocolRUDP            IPProtocol = 27
	IPProtocolIPv6            IPProtocol = 41
	IPProtocolIPv6Routing     IPProtocol = 43
	IPProtocolIPv6Fragment    IPProtocol = 44
	IPProtocolGRE             IPProtocol = 47
	IPProtocolESP             IPProtocol = 50
	IPProtocolAH              IPProtocol = 51
	IPProtocolICMPv6          IPProtocol = 58
	IPProtocolNoNextHeader    IPProtocol = 59
	IPProtocolIPv6Destination IPProtocol = 60
	IPProtocolIPIP            IPProtocol = 94
	IPProtocolEtherIP         IPProtocol = 97
	IPProtocolSCTP            IPProtocol = 132
	IPProtocolUDPLite         IPProtocol = 136
	IPProtocolMPLSInIP        IPProtocol = 137
)

func (IPProtocol) Decode 

func (a IPProtocol) Decode(data []byte, p gopacket.PacketBuilder) error

func (IPProtocol) LayerType 

func (a IPProtocol) LayerType() gopacket.LayerType

func (IPProtocol) String 

func (a IPProtocol) String() string

type IPSecAH 

type IPSecAH struct {
	Reserved           uint16
	SPI, Seq           uint32
	AuthenticationData []byte
	// contains filtered or unexported fields
}

IPSecAH is the authentication header for IPv4/6 defined in http://tools.ietf.org/html/rfc2402

func (*IPSecAH) LayerType 

func (i *IPSecAH) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPSecAH.

type IPSecESP 

type IPSecESP struct {
	BaseLayer
	SPI, Seq uint32
	// Encrypted contains the encrypted set of bytes sent in an ESP
	Encrypted []byte
}

IPSecESP is the encapsulating security payload defined in http://tools.ietf.org/html/rfc2406

func (*IPSecESP) LayerType 

func (i *IPSecESP) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPSecESP.

type IPv4 

type IPv4 struct {
	BaseLayer
	Version    uint8
	IHL        uint8
	TOS        uint8
	Length     uint16
	Id         uint16
	Flags      IPv4Flag
	FragOffset uint16
	TTL        uint8
	Protocol   IPProtocol
	Checksum   uint16
	SrcIP      net.IP
	DstIP      net.IP
	Options    []IPv4Option
	Padding    []byte
}

IPv4 is the header of an IP packet.

func (*IPv4) CanDecode 

func (i *IPv4) CanDecode() gopacket.LayerClass

func (*IPv4) DecodeFromBytes 

func (ip *IPv4) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*IPv4) LayerType 

func (i *IPv4) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv4

func (*IPv4) NetworkFlow 

func (i *IPv4) NetworkFlow() gopacket.Flow

func (*IPv4) NextLayerType 

func (i *IPv4) NextLayerType() gopacket.LayerType

func (*IPv4) SerializeTo 

func (ip *IPv4) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer.

type IPv4Flag 

type IPv4Flag uint8
const (
	IPv4EvilBit       IPv4Flag = 1 << 2 // http://tools.ietf.org/html/rfc3514 ;)
	IPv4DontFragment  IPv4Flag = 1 << 1
	IPv4MoreFragments IPv4Flag = 1 << 0
)

func (IPv4Flag) String 

func (f IPv4Flag) String() string

type IPv4Option 

type IPv4Option struct {
	OptionType   uint8
	OptionLength uint8
	OptionData   []byte
}

func (IPv4Option) String 

func (i IPv4Option) String() string

type IPv6 

type IPv6 struct {
	// http://www.networksorcery.com/enp/protocol/ipv6.htm
	BaseLayer
	Version      uint8
	TrafficClass uint8
	FlowLabel    uint32
	Length       uint16
	NextHeader   IPProtocol
	HopLimit     uint8
	SrcIP        net.IP
	DstIP        net.IP
	HopByHop     *IPv6HopByHop
	// contains filtered or unexported fields
}

IPv6 is the layer for the IPv6 header.

func (*IPv6) CanDecode 

func (i *IPv6) CanDecode() gopacket.LayerClass

func (*IPv6) DecodeFromBytes 

func (ip6 *IPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*IPv6) LayerType 

func (i *IPv6) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv6

func (*IPv6) NetworkFlow 

func (i *IPv6) NetworkFlow() gopacket.Flow

func (*IPv6) NextLayerType 

func (i *IPv6) NextLayerType() gopacket.LayerType

func (*IPv6) SerializeTo 

func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type IPv6Destination 

type IPv6Destination struct {
	Options []IPv6DestinationOption
	// contains filtered or unexported fields
}

IPv6Destination is the IPv6 destination options header.

func (*IPv6Destination) LayerType 

func (i *IPv6Destination) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv6Destination.

func (*IPv6Destination) SerializeTo added in v1.1.6 

func (i *IPv6Destination) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type IPv6DestinationOption 

type IPv6DestinationOption ipv6HeaderTLVOption

IPv6DestinationOption is a TLV option present in an IPv6 destination options extension.

type IPv6ExtensionSkipper 

type IPv6ExtensionSkipper struct {
	NextHeader IPProtocol
	BaseLayer
}

IPv6ExtensionSkipper is a DecodingLayer which decodes and ignores v6 extensions. You can use it with a DecodingLayerParser to handle IPv6 stacks which may or may not have extensions.

func (*IPv6ExtensionSkipper) CanDecode 

func (i *IPv6ExtensionSkipper) CanDecode() gopacket.LayerClass

func (*IPv6ExtensionSkipper) DecodeFromBytes 

func (i *IPv6ExtensionSkipper) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*IPv6ExtensionSkipper) NextLayerType 

func (i *IPv6ExtensionSkipper) NextLayerType() gopacket.LayerType

type IPv6Fragment 

type IPv6Fragment struct {
	BaseLayer
	NextHeader IPProtocol
	// Reserved1 is bits [8-16), from least to most significant, 0-indexed
	Reserved1      uint8
	FragmentOffset uint16
	// Reserved2 is bits [29-31), from least to most significant, 0-indexed
	Reserved2      uint8
	MoreFragments  bool
	Identification uint32
}

IPv6Fragment is the IPv6 fragment header, used for packet fragmentation/defragmentation.

func (*IPv6Fragment) LayerType 

func (i *IPv6Fragment) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv6Fragment.

type IPv6HopByHop 

type IPv6HopByHop struct {
	Options []IPv6HopByHopOption
	// contains filtered or unexported fields
}

IPv6HopByHop is the IPv6 hop-by-hop extension.

func (*IPv6HopByHop) DecodeFromBytes 

func (i *IPv6HopByHop) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*IPv6HopByHop) LayerType 

func (i *IPv6HopByHop) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv6HopByHop.

type IPv6HopByHopOption 

type IPv6HopByHopOption ipv6HeaderTLVOption

IPv6HopByHopOption is a TLV option present in an IPv6 hop-by-hop extension.

type IPv6Routing 

type IPv6Routing struct {
	RoutingType  uint8
	SegmentsLeft uint8
	// This segment is supposed to be zero according to RFC2460, the second set of
	// 4 bytes in the extension.
	Reserved []byte
	// SourceRoutingIPs is the set of IPv6 addresses requested for source routing,
	// set only if RoutingType == 0.
	SourceRoutingIPs []net.IP
	// contains filtered or unexported fields
}

IPv6Routing is the IPv6 routing extension.

func (*IPv6Routing) LayerType 

func (i *IPv6Routing) LayerType() gopacket.LayerType

LayerType returns LayerTypeIPv6Routing.

type LLC 

type LLC struct {
	BaseLayer
	DSAP    uint8
	IG      bool // true means group, false means individual
	SSAP    uint8
	CR      bool // true means response, false means command
	Control uint16
}

LLC is the layer used for 802.2 Logical Link Control headers. See http://standards.ieee.org/getieee802/download/802.2-1998.pdf

func (*LLC) LayerType 

func (l *LLC) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeLLC.

type LLDPApplicationType 

type LLDPApplicationType uint8
const (
	LLDPAppTypeReserved            LLDPApplicationType = 0
	LLDPAppTypeVoice               LLDPApplicationType = 1
	LLDPappTypeVoiceSignaling      LLDPApplicationType = 2
	LLDPappTypeGuestVoice          LLDPApplicationType = 3
	LLDPappTypeGuestVoiceSignaling LLDPApplicationType = 4
	LLDPappTypeSoftphoneVoice      LLDPApplicationType = 5
	LLDPappTypeVideoConferencing   LLDPApplicationType = 6
	LLDPappTypeStreamingVideo      LLDPApplicationType = 7
	LLDPappTypeVideoSignaling      LLDPApplicationType = 8
)

func (LLDPApplicationType) String 

func (t LLDPApplicationType) String() (s string)

type LLDPCapabilities 

type LLDPCapabilities struct {
	Other       bool
	Repeater    bool
	Bridge      bool
	WLANAP      bool
	Router      bool
	Phone       bool
	DocSis      bool
	StationOnly bool
	CVLAN       bool
	SVLAN       bool
	TMPR        bool
}

LLDPCapabilities represents the capabilities of a device

type LLDPChassisID 

type LLDPChassisID struct {
	Subtype LLDPChassisIDSubType
	ID      []byte
}

type LLDPChassisIDSubType 

type LLDPChassisIDSubType byte

LLDPChassisIDSubType specifies the value type for a single LLDPChassisID.ID 

const (
	LLDPChassisIDSubTypeReserved    LLDPChassisIDSubType = 0
	LLDPChassisIDSubTypeChassisComp LLDPChassisIDSubType = 1
	LLDPChassisIDSubtypeIfaceAlias  LLDPChassisIDSubType = 2
	LLDPChassisIDSubTypePortComp    LLDPChassisIDSubType = 3
	LLDPChassisIDSubTypeMACAddr     LLDPChassisIDSubType = 4
	LLDPChassisIDSubTypeNetworkAddr LLDPChassisIDSubType = 5
	LLDPChassisIDSubtypeIfaceName   LLDPChassisIDSubType = 6
	LLDPChassisIDSubTypeLocal       LLDPChassisIDSubType = 7
)

LLDP Chassis Types

func (LLDPChassisIDSubType) String 

func (t LLDPChassisIDSubType) String() (s string)

type LLDPCisco2Subtype 

type LLDPCisco2Subtype uint8
const (
	LLDPCisco2PowerViaMDI LLDPCisco2Subtype = 1
)

Cisco2 TLV Subtypes

type LLDPEVBCapabilities 

type LLDPEVBCapabilities struct {
	StandardBridging            bool
	ReflectiveRelay             bool
	RetransmissionTimerExponent bool
	EdgeControlProtocol         bool
	VSIDiscoveryProtocol        bool
}

LLDPEVBCapabilities represents the EVB capabilities of a device

type LLDPEVBSettings 

type LLDPEVBSettings struct {
	Supported      LLDPEVBCapabilities
	Enabled        LLDPEVBCapabilities
	SupportedVSIs  uint16
	ConfiguredVSIs uint16
	RTEExponent    uint8
}

type LLDPInfo8021 

type LLDPInfo8021 struct {
	PVID               uint16
	PPVIDs             []PortProtocolVLANID
	VLANNames          []VLANName
	ProtocolIdentities []ProtocolIdentity
	VIDUsageDigest     uint32
	ManagementVID      uint16
	LinkAggregation    LLDPLinkAggregation
}

LLDPInfo8021 represents the information carried in 802.1 Org-specific TLVs

type LLDPInfo8021Qbg 

type LLDPInfo8021Qbg struct {
	EVBSettings LLDPEVBSettings
}

LLDPInfo8021Qbg represents the information carried in 802.1Qbg Org-specific TLVs

type LLDPInfo8023 

type LLDPInfo8023 struct {
	MACPHYConfigStatus LLDPMACPHYConfigStatus
	PowerViaMDI        LLDPPowerViaMDI8023
	LinkAggregation    LLDPLinkAggregation
	MTU                uint16
}

LLDPInfo8023 represents the information carried in 802.3 Org-specific TLVs

type LLDPInfoCisco2 

type LLDPInfoCisco2 struct {
	PSEFourWirePoESupported       bool
	PDSparePairArchitectureShared bool
	PDRequestSparePairPoEOn       bool
	PSESparePairPoEOn             bool
}

LLDPInfoCisco2 represents the information carried in Cisco Org-specific TLVs

type LLDPInfoMedia 

type LLDPInfoMedia struct {
	MediaCapabilities LLDPMediaCapabilities
	NetworkPolicy     LLDPNetworkPolicy
	Location          LLDPLocation
	PowerViaMDI       LLDPPowerViaMDI
	HardwareRevision  string
	FirmwareRevision  string
	SoftwareRevision  string
	SerialNumber      string
	Manufacturer      string
	Model             string
	AssetID           string
}

LLDPInfoMedia represents the information carried in TR-41 Org-specific TLVs

type LLDPInfoProfinet 

type LLDPInfoProfinet struct {
	PNIODelay         LLDPPNIODelay
	PNIOPortStatus    LLDPPNIOPortStatus
	PNIOMRPPortStatus LLDPPNIOMRPPortStatus
	ChassisMAC        []byte
	PNIOPTCPStatus    LLDPPNIOPTCPStatus
}

LLDPInfoProfinet represents the information carried in Profinet Org-specific TLVs

type LLDPInterfaceSubtype 

type LLDPInterfaceSubtype byte
const (
	LLDPInterfaceSubtypeUnknown LLDPInterfaceSubtype = 1
	LLDPInterfaceSubtypeifIndex LLDPInterfaceSubtype = 2
	LLDPInterfaceSubtypeSysPort LLDPInterfaceSubtype = 3
)

LLDP Interface Subtypes

func (LLDPInterfaceSubtype) String 

func (t LLDPInterfaceSubtype) String() (s string)

type LLDPLinkAggregation 

type LLDPLinkAggregation struct {
	Supported bool
	Enabled   bool
	PortID    uint32
}

IEEE 802 Link Aggregation parameters

type LLDPLocation 

type LLDPLocation struct {
	Format     LLDPLocationFormat
	Coordinate LLDPLocationCoordinate
	Address    LLDPLocationAddress
	ECS        LLDPLocationECS
}

LLDP represents a physical location. Only one of the embedded types will contain values, depending on Format.

type LLDPLocationAddress 

type LLDPLocationAddress struct {
	What         LLDPLocationAddressWhat
	CountryCode  string
	AddressLines []LLDPLocationAddressLine
}

type LLDPLocationAddressLine 

type LLDPLocationAddressLine struct {
	Type  LLDPLocationAddressType
	Value string
}

type LLDPLocationAddressType 

type LLDPLocationAddressType uint8
const (
	LLDPLocationAddressTypeLanguage       LLDPLocationAddressType = 0
	LLDPLocationAddressTypeNational       LLDPLocationAddressType = 1
	LLDPLocationAddressTypeCounty         LLDPLocationAddressType = 2
	LLDPLocationAddressTypeCity           LLDPLocationAddressType = 3
	LLDPLocationAddressTypeCityDivision   LLDPLocationAddressType = 4
	LLDPLocationAddressTypeNeighborhood   LLDPLocationAddressType = 5
	LLDPLocationAddressTypeStreet         LLDPLocationAddressType = 6
	LLDPLocationAddressTypeLeadingStreet  LLDPLocationAddressType = 16
	LLDPLocationAddressTypeTrailingStreet LLDPLocationAddressType = 17
	LLDPLocationAddressTypeStreetSuffix   LLDPLocationAddressType = 18
	LLDPLocationAddressTypeHouseNum       LLDPLocationAddressType = 19
	LLDPLocationAddressTypeHouseSuffix    LLDPLocationAddressType = 20
	LLDPLocationAddressTypeLandmark       LLDPLocationAddressType = 21
	LLDPLocationAddressTypeAdditional     LLDPLocationAddressType = 22
	LLDPLocationAddressTypeName           LLDPLocationAddressType = 23
	LLDPLocationAddressTypePostal         LLDPLocationAddressType = 24
	LLDPLocationAddressTypeBuilding       LLDPLocationAddressType = 25
	LLDPLocationAddressTypeUnit           LLDPLocationAddressType = 26
	LLDPLocationAddressTypeFloor          LLDPLocationAddressType = 27
	LLDPLocationAddressTypeRoom           LLDPLocationAddressType = 28
	LLDPLocationAddressTypePlace          LLDPLocationAddressType = 29
	LLDPLocationAddressTypeScript         LLDPLocationAddressType = 128
)

func (LLDPLocationAddressType) String 

func (t LLDPLocationAddressType) String() (s string)

type LLDPLocationAddressWhat 

type LLDPLocationAddressWhat uint8
const (
	LLDPLocationAddressWhatDHCP    LLDPLocationAddressWhat = 0
	LLDPLocationAddressWhatNetwork LLDPLocationAddressWhat = 1
	LLDPLocationAddressWhatClient  LLDPLocationAddressWhat = 2
)

type LLDPLocationCoordinate 

type LLDPLocationCoordinate struct {
	LatitudeResolution  uint8
	Latitude            uint64
	LongitudeResolution uint8
	Longitude           uint64
	AltitudeType        uint8
	AltitudeResolution  uint16
	Altitude            uint32
	Datum               uint8
}

type LLDPLocationECS 

type LLDPLocationECS struct {
	ELIN string
}

type LLDPLocationFormat 

type LLDPLocationFormat uint8
const (
	LLDPLocationFormatInvalid    LLDPLocationFormat = 0
	LLDPLocationFormatCoordinate LLDPLocationFormat = 1
	LLDPLocationFormatAddress    LLDPLocationFormat = 2
	LLDPLocationFormatECS        LLDPLocationFormat = 3
)

func (LLDPLocationFormat) String 

func (t LLDPLocationFormat) String() (s string)

type LLDPMACPHYConfigStatus 

type LLDPMACPHYConfigStatus struct {
	AutoNegSupported  bool
	AutoNegEnabled    bool
	AutoNegCapability uint16
	MAUType           uint16
}

type LLDPMediaCapabilities 

type LLDPMediaCapabilities struct {
	Capabilities  bool
	NetworkPolicy bool
	Location      bool
	PowerPSE      bool
	PowerPD       bool
	Inventory     bool
	Class         LLDPMediaClass
}

LLDPMediaCapabilities represents the LLDP Media capabilities of a device

type LLDPMediaClass 

type LLDPMediaClass uint8
const (
	LLDPMediaClassUndefined   LLDPMediaClass = 0
	LLDPMediaClassEndpointI   LLDPMediaClass = 1
	LLDPMediaClassEndpointII  LLDPMediaClass = 2
	LLDPMediaClassEndpointIII LLDPMediaClass = 3
	LLDPMediaClassNetwork     LLDPMediaClass = 4
)

Media Class Values

func (LLDPMediaClass) String 

func (t LLDPMediaClass) String() (s string)

type LLDPMediaSubtype 

type LLDPMediaSubtype uint8
const (
	LLDPMediaTypeCapabilities LLDPMediaSubtype = 1
	LLDPMediaTypeNetwork      LLDPMediaSubtype = 2
	LLDPMediaTypeLocation     LLDPMediaSubtype = 3
	LLDPMediaTypePower        LLDPMediaSubtype = 4
	LLDPMediaTypeHardware     LLDPMediaSubtype = 5
	LLDPMediaTypeFirmware     LLDPMediaSubtype = 6
	LLDPMediaTypeSoftware     LLDPMediaSubtype = 7
	LLDPMediaTypeSerial       LLDPMediaSubtype = 8
	LLDPMediaTypeManufacturer LLDPMediaSubtype = 9
	LLDPMediaTypeModel        LLDPMediaSubtype = 10
	LLDPMediaTypeAssetID      LLDPMediaSubtype = 11
)

Media TLV Subtypes

func (LLDPMediaSubtype) String 

func (t LLDPMediaSubtype) String() (s string)

type LLDPMgmtAddress 

type LLDPMgmtAddress struct {
	Subtype          IANAAddressFamily
	Address          []byte
	InterfaceSubtype LLDPInterfaceSubtype
	InterfaceNumber  uint32
	OID              string
}

type LLDPNetworkPolicy 

type LLDPNetworkPolicy struct {
	ApplicationType LLDPApplicationType
	Defined         bool
	Tagged          bool
	VLANId          uint16
	L2Priority      uint16
	DSCPValue       uint8
}

type LLDPOrgSpecificTLV 

type LLDPOrgSpecificTLV struct {
	OUI     IEEEOUI
	SubType uint8
	Info    []byte
}

LLDPOrgSpecificTLV is an Organisation-specific TLV

type LLDPPNIODelay 

type LLDPPNIODelay struct {
	RXLocal    uint32
	RXRemote   uint32
	TXLocal    uint32
	TXRemote   uint32
	CableLocal uint32
}

type LLDPPNIOMRPPortStatus 

type LLDPPNIOMRPPortStatus struct {
	UUID   []byte
	Status uint16
}

type LLDPPNIOPTCPStatus 

type LLDPPNIOPTCPStatus struct {
	MasterAddress     []byte
	SubdomainUUID     []byte
	IRDataUUID        []byte
	PeriodValid       bool
	PeriodLength      uint32
	RedPeriodValid    bool
	RedPeriodBegin    uint32
	OrangePeriodValid bool
	OrangePeriodBegin uint32
	GreenPeriodValid  bool
	GreenPeriodBegin  uint32
}

type LLDPPNIOPortStatus 

type LLDPPNIOPortStatus struct {
	Class2 uint16
	Class3 uint16
}

type LLDPPortID 

type LLDPPortID struct {
	Subtype LLDPPortIDSubType
	ID      []byte
}

type LLDPPortIDSubType 

type LLDPPortIDSubType byte

LLDPPortIDSubType specifies the value type for a single LLDPPortID.ID 

const (
	LLDPPortIDSubtypeReserved       LLDPPortIDSubType = 0
	LLDPPortIDSubtypeIfaceAlias     LLDPPortIDSubType = 1
	LLDPPortIDSubtypePortComp       LLDPPortIDSubType = 2
	LLDPPortIDSubtypeMACAddr        LLDPPortIDSubType = 3
	LLDPPortIDSubtypeNetworkAddr    LLDPPortIDSubType = 4
	LLDPPortIDSubtypeIfaceName      LLDPPortIDSubType = 5
	LLDPPortIDSubtypeAgentCircuitID LLDPPortIDSubType = 6
	LLDPPortIDSubtypeLocal          LLDPPortIDSubType = 7
)

LLDP PortID types

func (LLDPPortIDSubType) String 

func (t LLDPPortIDSubType) String() (s string)

type LLDPPowerPriority 

type LLDPPowerPriority byte
const (
	LLDPPowerPriorityUnknown LLDPPowerPriority = 0
	LLDPPowerPriorityMedium  LLDPPowerPriority = 1
	LLDPPowerPriorityHigh    LLDPPowerPriority = 2
	LLDPPowerPriorityLow     LLDPPowerPriority = 3
)

func (LLDPPowerPriority) String 

func (t LLDPPowerPriority) String() (s string)

type LLDPPowerSource 

type LLDPPowerSource byte

func (LLDPPowerSource) String 

func (t LLDPPowerSource) String() (s string)

type LLDPPowerType 

type LLDPPowerType byte

func (LLDPPowerType) String 

func (t LLDPPowerType) String() (s string)

type LLDPPowerViaMDI 

type LLDPPowerViaMDI struct {
	Type     LLDPPowerType
	Source   LLDPPowerSource
	Priority LLDPPowerPriority
	Value    uint16
}

type LLDPPowerViaMDI8023 

type LLDPPowerViaMDI8023 struct {
	PortClassPSE    bool // false = PD
	PSESupported    bool
	PSEEnabled      bool
	PSEPairsAbility bool
	PSEPowerPair    uint8
	PSEClass        uint8
	Type            LLDPPowerType
	Source          LLDPPowerSource
	Priority        LLDPPowerPriority
	Requested       uint16 // 1-510 Watts
	Allocated       uint16 // 1-510 Watts
}

type LLDPProfinetSubtype 

type LLDPProfinetSubtype uint8

Profinet Subtypes 

const (
	LLDPProfinetPNIODelay         LLDPProfinetSubtype = 1
	LLDPProfinetPNIOPortStatus    LLDPProfinetSubtype = 2
	LLDPProfinetPNIOMRPPortStatus LLDPProfinetSubtype = 4
	LLDPProfinetPNIOChassisMAC    LLDPProfinetSubtype = 5
	LLDPProfinetPNIOPTCPStatus    LLDPProfinetSubtype = 6
)

type LLDPSysCapabilities 

type LLDPSysCapabilities struct {
	SystemCap  LLDPCapabilities
	EnabledCap LLDPCapabilities
}

type LLDPTLVType 

type LLDPTLVType byte

LLDPTLVType is the type of each TLV value in a LinkLayerDiscovery packet. 

const (
	LLDPTLVEnd             LLDPTLVType = 0
	LLDPTLVChassisID       LLDPTLVType = 1
	LLDPTLVPortID          LLDPTLVType = 2
	LLDPTLVTTL             LLDPTLVType = 3
	LLDPTLVPortDescription LLDPTLVType = 4
	LLDPTLVSysName         LLDPTLVType = 5
	LLDPTLVSysDescription  LLDPTLVType = 6
	LLDPTLVSysCapabilities LLDPTLVType = 7
	LLDPTLVMgmtAddress     LLDPTLVType = 8
	LLDPTLVOrgSpecific     LLDPTLVType = 127
)

func (LLDPTLVType) String 

func (t LLDPTLVType) String() (s string)

type LinkLayerDiscovery 

type LinkLayerDiscovery struct {
	BaseLayer
	ChassisID LLDPChassisID
	PortID    LLDPPortID
	TTL       uint16
	Values    []LinkLayerDiscoveryValue
}

LinkLayerDiscovery is a packet layer containing the LinkLayer Discovery Protocol. See http:http://standards.ieee.org/getieee802/download/802.1AB-2009.pdf ChassisID, PortID and TTL are mandatory TLV's. Other values can be decoded with DecodeValues()

func (*LinkLayerDiscovery) LayerType 

func (c *LinkLayerDiscovery) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeLinkLayerDiscovery.

type LinkLayerDiscoveryInfo 

type LinkLayerDiscoveryInfo struct {
	BaseLayer
	PortDescription string
	SysName         string
	SysDescription  string
	SysCapabilities LLDPSysCapabilities
	MgmtAddress     LLDPMgmtAddress
	OrgTLVs         []LLDPOrgSpecificTLV      // Private TLVs
	Unknown         []LinkLayerDiscoveryValue // undecoded TLVs
}

LinkLayerDiscoveryInfo represents the decoded details for a set of LinkLayerDiscoveryValues Organisation-specific TLV's can be decoded using the various Decode() methods

func (*LinkLayerDiscoveryInfo) Decode8021 

func (l *LinkLayerDiscoveryInfo) Decode8021() (info LLDPInfo8021, err error)

func (*LinkLayerDiscoveryInfo) Decode8021Qbg 

func (l *LinkLayerDiscoveryInfo) Decode8021Qbg() (info LLDPInfo8021Qbg, err error)

func (*LinkLayerDiscoveryInfo) Decode8023 

func (l *LinkLayerDiscoveryInfo) Decode8023() (info LLDPInfo8023, err error)

func (*LinkLayerDiscoveryInfo) DecodeCisco2 

func (l *LinkLayerDiscoveryInfo) DecodeCisco2() (info LLDPInfoCisco2, err error)

func (*LinkLayerDiscoveryInfo) DecodeMedia 

func (l *LinkLayerDiscoveryInfo) DecodeMedia() (info LLDPInfoMedia, err error)

func (*LinkLayerDiscoveryInfo) DecodeProfinet 

func (l *LinkLayerDiscoveryInfo) DecodeProfinet() (info LLDPInfoProfinet, err error)

func (*LinkLayerDiscoveryInfo) LayerType 

func (c *LinkLayerDiscoveryInfo) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeLinkLayerDiscoveryInfo.

type LinkLayerDiscoveryValue 

type LinkLayerDiscoveryValue struct {
	Type   LLDPTLVType
	Length uint16
	Value  []byte
}

LinkLayerDiscoveryValue is a TLV value inside a LinkLayerDiscovery packet layer.

type LinkType 

type LinkType uint8

LinkType is an enumeration of link types, and acts as a decoder for any link type it supports. 

const (
	// According to pcap-linktype(7).
	LinkTypeNull           LinkType = 0
	LinkTypeEthernet       LinkType = 1
	LinkTypeTokenRing      LinkType = 6
	LinkTypeArcNet         LinkType = 7
	LinkTypeSLIP           LinkType = 8
	LinkTypePPP            LinkType = 9
	LinkTypeFDDI           LinkType = 10
	LinkTypeATM_RFC1483    LinkType = 100
	LinkTypeRaw            LinkType = 101
	LinkTypePPP_HDLC       LinkType = 50
	LinkTypePPPEthernet    LinkType = 51
	LinkTypeC_HDLC         LinkType = 104
	LinkTypeIEEE802_11     LinkType = 105
	LinkTypeFRelay         LinkType = 107
	LinkTypeLoop           LinkType = 108
	LinkTypeLinuxSLL       LinkType = 113
	LinkTypeLTalk          LinkType = 104
	LinkTypePFLog          LinkType = 117
	LinkTypePrismHeader    LinkType = 119
	LinkTypeIPOverFC       LinkType = 122
	LinkTypeSunATM         LinkType = 123
	LinkTypeIEEE80211Radio LinkType = 127
	LinkTypeARCNetLinux    LinkType = 129
	LinkTypeLinuxIRDA      LinkType = 144
	LinkTypeLinuxLAPD      LinkType = 177
)

func (LinkType) Decode 

func (a LinkType) Decode(data []byte, p gopacket.PacketBuilder) error

func (LinkType) String 

func (a LinkType) String() string

type Loopback 

type Loopback struct {
	BaseLayer
	Family ProtocolFamily
}

Loopback contains the header for loopback encapsulation. This header is used by both BSD and OpenBSD style loopback decoding (pcap's DLT_NULL and DLT_LOOP, respectively).

func (*Loopback) LayerType 

func (l *Loopback) LayerType() gopacket.LayerType

LayerType returns LayerTypeLoopback.

type MPLS 

type MPLS struct {
	BaseLayer
	Label        uint32
	TrafficClass uint8
	StackBottom  bool
	TTL          uint8
}

MPLS is the MPLS packet header.

func (*MPLS) LayerType 

func (m *MPLS) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeMPLS.

func (*MPLS) SerializeTo added in v1.0.1 

func (m *MPLS) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type NDPBackplaneType 

type NDPBackplaneType uint8
const (
	NDPBackplaneOther                                       NDPBackplaneType = 1
	NDPBackplaneEthernet                                    NDPBackplaneType = 2
	NDPBackplaneEthernetTokenring                           NDPBackplaneType = 3
	NDPBackplaneEthernetFDDI                                NDPBackplaneType = 4
	NDPBackplaneEthernetTokenringFDDI                       NDPBackplaneType = 5
	NDPBackplaneEthernetTokenringRedundantPower             NDPBackplaneType = 6
	NDPBackplaneEthernetTokenringFDDIRedundantPower         NDPBackplaneType = 7
	NDPBackplaneTokenRing                                   NDPBackplaneType = 8
	NDPBackplaneEthernetTokenringFastEthernet               NDPBackplaneType = 9
	NDPBackplaneEthernetFastEthernet                        NDPBackplaneType = 10
	NDPBackplaneEthernetTokenringFastEthernetRedundantPower NDPBackplaneType = 11
	NDPBackplaneEthernetFastEthernetGigabitEthernet         NDPBackplaneType = 12
)

Nortel Backplane Types

func (NDPBackplaneType) String 

func (t NDPBackplaneType) String() (s string)

type NDPChassisType 

type NDPChassisType uint8
const (
	NDPChassisother                                       NDPChassisType = 1
	NDPChassis3000                                        NDPChassisType = 2
	NDPChassis3030                                        NDPChassisType = 3
	NDPChassis2310                                        NDPChassisType = 4
	NDPChassis2810                                        NDPChassisType = 5
	NDPChassis2912                                        NDPChassisType = 6
	NDPChassis2914                                        NDPChassisType = 7
	NDPChassis271x                                        NDPChassisType = 8
	NDPChassis2813                                        NDPChassisType = 9
	NDPChassis2814                                        NDPChassisType = 10
	NDPChassis2915                                        NDPChassisType = 11
	NDPChassis5000                                        NDPChassisType = 12
	NDPChassis2813SA                                      NDPChassisType = 13
	NDPChassis2814SA                                      NDPChassisType = 14
	NDPChassis810M                                        NDPChassisType = 15
	NDPChassisEthercell                                   NDPChassisType = 16
	NDPChassis5005                                        NDPChassisType = 17
	NDPChassisAlcatelEWC                                  NDPChassisType = 18
	NDPChassis2715SA                                      NDPChassisType = 20
	NDPChassis2486                                        NDPChassisType = 21
	NDPChassis28000series                                 NDPChassisType = 22
	NDPChassis23000series                                 NDPChassisType = 23
	NDPChassis5DN00xseries                                NDPChassisType = 24
	NDPChassisBayStackEthernet                            NDPChassisType = 25
	NDPChassis23100series                                 NDPChassisType = 26
	NDPChassis100BaseTHub                                 NDPChassisType = 27
	NDPChassis3000FastEthernet                            NDPChassisType = 28
	NDPChassisOrionSwitch                                 NDPChassisType = 29
	NDPChassisDDS                                         NDPChassisType = 31
	NDPChassisCentillion6slot                             NDPChassisType = 32
	NDPChassisCentillion12slot                            NDPChassisType = 33
	NDPChassisCentillion1slot                             NDPChassisType = 34
	NDPChassisBayStack301                                 NDPChassisType = 35
	NDPChassisBayStackTokenRingHub                        NDPChassisType = 36
	NDPChassisFVCMultimediaSwitch                         NDPChassisType = 37
	NDPChassisSwitchNode                                  NDPChassisType = 38
	NDPChassisBayStack302Switch                           NDPChassisType = 39
	NDPChassisBayStack350Switch                           NDPChassisType = 40
	NDPChassisBayStack150EthernetHub                      NDPChassisType = 41
	NDPChassisCentillion50NSwitch                         NDPChassisType = 42
	NDPChassisCentillion50TSwitch                         NDPChassisType = 43
	NDPChassisBayStack303304Switches                      NDPChassisType = 44
	NDPChassisBayStack200EthernetHub                      NDPChassisType = 45
	NDPChassisBayStack25010100EthernetHub                 NDPChassisType = 46
	NDPChassisBayStack450101001000Switches                NDPChassisType = 48
	NDPChassisBayStack41010100Switches                    NDPChassisType = 49
	NDPChassisPassport1200L3Switch                        NDPChassisType = 50
	NDPChassisPassport1250L3Switch                        NDPChassisType = 51
	NDPChassisPassport1100L3Switch                        NDPChassisType = 52
	NDPChassisPassport1150L3Switch                        NDPChassisType = 53
	NDPChassisPassport1050L3Switch                        NDPChassisType = 54
	NDPChassisPassport1051L3Switch                        NDPChassisType = 55
	NDPChassisPassport8610L3Switch                        NDPChassisType = 56
	NDPChassisPassport8606L3Switch                        NDPChassisType = 57
	NDPChassisPassport8010                                NDPChassisType = 58
	NDPChassisPassport8006                                NDPChassisType = 59
	NDPChassisBayStack670wirelessaccesspoint              NDPChassisType = 60
	NDPChassisPassport740                                 NDPChassisType = 61
	NDPChassisPassport750                                 NDPChassisType = 62
	NDPChassisPassport790                                 NDPChassisType = 63
	NDPChassisBusinessPolicySwitch200010100Switches       NDPChassisType = 64
	NDPChassisPassport8110L2Switch                        NDPChassisType = 65
	NDPChassisPassport8106L2Switch                        NDPChassisType = 66
	NDPChassisBayStack3580GigSwitch                       NDPChassisType = 67
	NDPChassisBayStack10PowerSupplyUnit                   NDPChassisType = 68
	NDPChassisBayStack42010100Switch                      NDPChassisType = 69
	NDPChassisOPTeraMetro1200EthernetServiceModule        NDPChassisType = 70
	NDPChassisOPTera8010co                                NDPChassisType = 71
	NDPChassisOPTera8610coL3Switch                        NDPChassisType = 72
	NDPChassisOPTera8110coL2Switch                        NDPChassisType = 73
	NDPChassisOPTera8003                                  NDPChassisType = 74
	NDPChassisOPTera8603L3Switch                          NDPChassisType = 75
	NDPChassisOPTera8103L2Switch                          NDPChassisType = 76
	NDPChassisBayStack380101001000Switch                  NDPChassisType = 77
	NDPChassisEthernetSwitch47048T                        NDPChassisType = 78
	NDPChassisOPTeraMetro1450EthernetServiceModule        NDPChassisType = 79
	NDPChassisOPTeraMetro1400EthernetServiceModule        NDPChassisType = 80
	NDPChassisAlteonSwitchFamily                          NDPChassisType = 81
	NDPChassisEthernetSwitch46024TPWR                     NDPChassisType = 82
	NDPChassisOPTeraMetro8010OPML2Switch                  NDPChassisType = 83
	NDPChassisOPTeraMetro8010coOPML2Switch                NDPChassisType = 84
	NDPChassisOPTeraMetro8006OPML2Switch                  NDPChassisType = 85
	NDPChassisOPTeraMetro8003OPML2Switch                  NDPChassisType = 86
	NDPChassisAlteon180e                                  NDPChassisType = 87
	NDPChassisAlteonAD3                                   NDPChassisType = 88
	NDPChassisAlteon184                                   NDPChassisType = 89
	NDPChassisAlteonAD4                                   NDPChassisType = 90
	NDPChassisPassport1424L3Switch                        NDPChassisType = 91
	NDPChassisPassport1648L3Switch                        NDPChassisType = 92
	NDPChassisPassport1612L3Switch                        NDPChassisType = 93
	NDPChassisPassport1624L3Switch                        NDPChassisType = 94
	NDPChassisBayStack38024FFiber1000Switch               NDPChassisType = 95
	NDPChassisEthernetRoutingSwitch551024T                NDPChassisType = 96
	NDPChassisEthernetRoutingSwitch551048T                NDPChassisType = 97
	NDPChassisEthernetSwitch47024T                        NDPChassisType = 98
	NDPChassisNortelNetworksWirelessLANAccessPoint2220    NDPChassisType = 99
	NDPChassisPassportRBS2402L3Switch                     NDPChassisType = 100
	NDPChassisAlteonApplicationSwitch2424                 NDPChassisType = 101
	NDPChassisAlteonApplicationSwitch2224                 NDPChassisType = 102
	NDPChassisAlteonApplicationSwitch2208                 NDPChassisType = 103
	NDPChassisAlteonApplicationSwitch2216                 NDPChassisType = 104
	NDPChassisAlteonApplicationSwitch3408                 NDPChassisType = 105
	NDPChassisAlteonApplicationSwitch3416                 NDPChassisType = 106
	NDPChassisNortelNetworksWirelessLANSecuritySwitch2250 NDPChassisType = 107
	NDPChassisEthernetSwitch42548T                        NDPChassisType = 108
	NDPChassisEthernetSwitch42524T                        NDPChassisType = 109
	NDPChassisNortelNetworksWirelessLANAccessPoint2221    NDPChassisType = 110
	NDPChassisNortelMetroEthernetServiceUnit24TSPFswitch  NDPChassisType = 111
	NDPChassisNortelMetroEthernetServiceUnit24TLXDCswitch NDPChassisType = 112
	NDPChassisPassport830010slotchassis                   NDPChassisType = 113
	NDPChassisPassport83006slotchassis                    NDPChassisType = 114
	NDPChassisEthernetRoutingSwitch552024TPWR             NDPChassisType = 115
	NDPChassisEthernetRoutingSwitch552048TPWR             NDPChassisType = 116
	NDPChassisNortelNetworksVPNGateway3050                NDPChassisType = 117
	NDPChassisAlteonSSL31010100                           NDPChassisType = 118
	NDPChassisAlteonSSL31010100Fiber                      NDPChassisType = 119
	NDPChassisAlteonSSL31010100FIPS                       NDPChassisType = 120
	NDPChassisAlteonSSL410101001000                       NDPChassisType = 121
	NDPChassisAlteonSSL410101001000Fiber                  NDPChassisType = 122
	NDPChassisAlteonApplicationSwitch2424SSL              NDPChassisType = 123
	NDPChassisEthernetSwitch32524T                        NDPChassisType = 124
	NDPChassisEthernetSwitch32524G                        NDPChassisType = 125
	NDPChassisNortelNetworksWirelessLANAccessPoint2225    NDPChassisType = 126
	NDPChassisNortelNetworksWirelessLANSecuritySwitch2270 NDPChassisType = 127
	NDPChassis24portEthernetSwitch47024TPWR               NDPChassisType = 128
	NDPChassis48portEthernetSwitch47048TPWR               NDPChassisType = 129
	NDPChassisEthernetRoutingSwitch553024TFD              NDPChassisType = 130
	NDPChassisEthernetSwitch351024T                       NDPChassisType = 131
	NDPChassisNortelMetroEthernetServiceUnit12GACL3Switch NDPChassisType = 132
	NDPChassisNortelMetroEthernetServiceUnit12GDCL3Switch NDPChassisType = 133
	NDPChassisNortelSecureAccessSwitch                    NDPChassisType = 134
	NDPChassisNortelNetworksVPNGateway3070                NDPChassisType = 135
	NDPChassisOPTeraMetro3500                             NDPChassisType = 136
	NDPChassisSMBBES101024T                               NDPChassisType = 137
	NDPChassisSMBBES101048T                               NDPChassisType = 138
	NDPChassisSMBBES102024TPWR                            NDPChassisType = 139
	NDPChassisSMBBES102048TPWR                            NDPChassisType = 140
	NDPChassisSMBBES201024T                               NDPChassisType = 141
	NDPChassisSMBBES201048T                               NDPChassisType = 142
	NDPChassisSMBBES202024TPWR                            NDPChassisType = 143
	NDPChassisSMBBES202048TPWR                            NDPChassisType = 144
	NDPChassisSMBBES11024T                                NDPChassisType = 145
	NDPChassisSMBBES11048T                                NDPChassisType = 146
	NDPChassisSMBBES12024TPWR                             NDPChassisType = 147
	NDPChassisSMBBES12048TPWR                             NDPChassisType = 148
	NDPChassisSMBBES21024T                                NDPChassisType = 149
	NDPChassisSMBBES21048T                                NDPChassisType = 150
	NDPChassisSMBBES22024TPWR                             NDPChassisType = 151
	NDPChassisSMBBES22048TPWR                             NDPChassisType = 152
	NDPChassisOME6500                                     NDPChassisType = 153
	NDPChassisEthernetRoutingSwitch4548GT                 NDPChassisType = 154
	NDPChassisEthernetRoutingSwitch4548GTPWR              NDPChassisType = 155
	NDPChassisEthernetRoutingSwitch4550T                  NDPChassisType = 156
	NDPChassisEthernetRoutingSwitch4550TPWR               NDPChassisType = 157
	NDPChassisEthernetRoutingSwitch4526FX                 NDPChassisType = 158
	NDPChassisEthernetRoutingSwitch250026T                NDPChassisType = 159
	NDPChassisEthernetRoutingSwitch250026TPWR             NDPChassisType = 160
	NDPChassisEthernetRoutingSwitch250050T                NDPChassisType = 161
	NDPChassisEthernetRoutingSwitch250050TPWR             NDPChassisType = 162
)

Nortel Chassis Types

func (NDPChassisType) String 

func (t NDPChassisType) String() (s string)

type NDPState 

type NDPState uint8
const (
	NDPStateTopology  NDPState = 1
	NDPStateHeartbeat NDPState = 2
	NDPStateNew       NDPState = 3
)

Device State

func (NDPState) String 

func (t NDPState) String() (s string)

type NortelDiscovery 

type NortelDiscovery struct {
	BaseLayer
	IPAddress net.IP
	SegmentID []byte
	Chassis   NDPChassisType
	Backplane NDPBackplaneType
	State     NDPState
	NumLinks  uint8
}

NortelDiscovery is a packet layer containing the Nortel Discovery Protocol.

func (*NortelDiscovery) LayerType 

func (c *NortelDiscovery) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeNortelDiscovery.

type PFLog added in v1.1.0 

type PFLog struct {
	BaseLayer
	Length              uint8
	Family              ProtocolFamily
	Action, Reason      uint8
	IFName, Ruleset     []byte
	RuleNum, SubruleNum uint32
}

PFLog provides the layer for 'pf' packet-filter logging, as described at http://www.freebsd.org/cgi/man.cgi?query=pflog&sektion=4

func (*PFLog) CanDecode added in v1.1.0 

func (pf *PFLog) CanDecode() gopacket.LayerClass

func (*PFLog) DecodeFromBytes added in v1.1.0 

func (pf *PFLog) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*PFLog) LayerType added in v1.1.0 

func (pf *PFLog) LayerType() gopacket.LayerType

LayerType returns layers.LayerTypePFLog

func (*PFLog) NextLayerType added in v1.1.0 

func (pf *PFLog) NextLayerType() gopacket.LayerType

type PPP 

type PPP struct {
	BaseLayer
	PPPType PPPType
}

PPP is the layer for PPP encapsulation headers.

func (*PPP) LayerType 

func (p *PPP) LayerType() gopacket.LayerType

LayerType returns LayerTypePPP

func (*PPP) LinkFlow 

func (p *PPP) LinkFlow() gopacket.Flow

LinkFlow returns PPPFlow.

func (*PPP) SerializeTo added in v1.0.1 

func (p *PPP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type PPPType 

type PPPType uint16

PPPType is an enumeration of PPP type values, and acts as a decoder for any type it supports. 

const (
	PPPTypeIPv4          PPPType = 0x0021
	PPPTypeIPv6          PPPType = 0x0057
	PPPTypeMPLSUnicast   PPPType = 0x0281
	PPPTypeMPLSMulticast PPPType = 0x0283
)

func (PPPType) Decode 

func (a PPPType) Decode(data []byte, p gopacket.PacketBuilder) error

func (PPPType) String 

func (a PPPType) String() string

type PPPoE 

type PPPoE struct {
	BaseLayer
	Version   uint8
	Type      uint8
	Code      PPPoECode
	SessionId uint16
	Length    uint16
}

PPPoE is the layer for PPPoE encapsulation headers.

func (*PPPoE) LayerType 

func (p *PPPoE) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypePPPoE.

func (*PPPoE) SerializeTo added in v1.0.1 

func (p *PPPoE) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

type PPPoECode 

type PPPoECode uint8

PPPoECode is the PPPoE code enum, taken from http://tools.ietf.org/html/rfc2516 

const (
	PPPoECodePADI    PPPoECode = 0x09
	PPPoECodePADO    PPPoECode = 0x07
	PPPoECodePADR    PPPoECode = 0x19
	PPPoECodePADS    PPPoECode = 0x65
	PPPoECodePADT    PPPoECode = 0xA7
	PPPoECodeSession PPPoECode = 0x00
)

func (PPPoECode) Decode 

func (a PPPoECode) Decode(data []byte, p gopacket.PacketBuilder) error

func (PPPoECode) String 

func (a PPPoECode) String() string

type PortProtocolVLANID 

type PortProtocolVLANID struct {
	Supported bool
	Enabled   bool
	ID        uint16
}

type ProtocolFamily 

type ProtocolFamily uint8

ProtocolFamily is the set of values defined as PF_* in sys/socket.h 

const (
	ProtocolFamilyIPv4 ProtocolFamily = 2
	// BSDs use different values for INET6... glory be.  These values taken from
	// tcpdump 4.3.0.
	ProtocolFamilyIPv6BSD     ProtocolFamily = 24
	ProtocolFamilyIPv6FreeBSD ProtocolFamily = 28
	ProtocolFamilyIPv6Darwin  ProtocolFamily = 30
	ProtocolFamilyIPv6Linux   ProtocolFamily = 10
)

func (ProtocolFamily) Decode 

func (a ProtocolFamily) Decode(data []byte, p gopacket.PacketBuilder) error

func (ProtocolFamily) LayerType added in v1.1.0 

func (a ProtocolFamily) LayerType() gopacket.LayerType

func (ProtocolFamily) String 

func (a ProtocolFamily) String() string

type ProtocolGuessingDecoder 

type ProtocolGuessingDecoder struct{}

ProtocolGuessingDecoder attempts to guess the protocol of the bytes it's given, then decode the packet accordingly. Its algorithm for guessing is: 

If the packet starts with byte 0x45-0x4F: IPv4
If the packet starts with byte 0x60-0x6F: IPv6
Otherwise:  Error

See draft-hsmit-isis-aal5mux-00.txt for more detail on this approach.

func (ProtocolGuessingDecoder) Decode 

func (ProtocolGuessingDecoder) Decode(data []byte, p gopacket.PacketBuilder) error

type ProtocolIdentity 

type ProtocolIdentity []byte

type RUDP 

type RUDP struct {
	BaseLayer
	SYN, ACK, EACK, RST, NUL bool
	Version                  uint8
	HeaderLength             uint8
	SrcPort, DstPort         RUDPPort
	DataLength               uint16
	Seq, Ack, Checksum       uint32
	VariableHeaderArea       []byte
	// RUDPHeaderSyn contains SYN information for the RUDP packet,
	// if the SYN flag is set
	*RUDPHeaderSYN
	// RUDPHeaderEack contains EACK information for the RUDP packet,
	// if the EACK flag is set.
	*RUDPHeaderEACK
}

func (*RUDP) LayerType 

func (r *RUDP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeRUDP.

func (*RUDP) TransportFlow 

func (r *RUDP) TransportFlow() gopacket.Flow

type RUDPHeaderEACK 

type RUDPHeaderEACK struct {
	SeqsReceivedOK []uint32
}

type RUDPHeaderSYN 

type RUDPHeaderSYN struct {
	MaxOutstandingSegments, MaxSegmentSize, OptionFlags uint16
}

type RUDPPort 

type RUDPPort uint8

RUDPPort is a port in a RUDP layer.

func (RUDPPort) String 

func (a RUDPPort) String() string

String returns the port as "number(name)" if there's a well-known port name, or just "number" if there isn't. Well-known names are stored in RUDPPortNames.

type RadioTap added in v1.1.4 

type RadioTap struct {
	BaseLayer

	// Version 0. Only increases for drastic changes, introduction of compatible new fields does not count.
	Version uint8
	// Length of the whole header in bytes, including it_version, it_pad, it_len, and data fields.
	Length uint16
	// Present is a bitmap telling which fields are present. Set bit 31 (0x80000000) to extend the bitmap by another 32 bits. Additional extensions are made by setting bit 31.
	Present RadioTapPresent
	// TSFT: value in microseconds of the MAC's 64-bit 802.11 Time Synchronization Function timer when the first bit of the MPDU arrived at the MAC. For received frames, only.
	TSFT  uint64
	Flags RadioTapFlags
	// Rate Tx/Rx data rate
	Rate RadioTapRate
	// ChannelFrequency Tx/Rx frequency in MHz, followed by flags
	ChannelFrequency RadioTapChannelFrequency
	ChannelFlags     RadioTapChannelFlags
	// FHSS For frequency-hopping radios, the hop set (first byte) and pattern (second byte).
	FHSS uint16
	// DBMAntennaSignal RF signal power at the antenna, decibel difference from one milliwatt.
	DBMAntennaSignal int8
	// DBMAntennaNoise RF noise power at the antenna, decibel difference from one milliwatt.
	DBMAntennaNoise int8
	// LockQuality Quality of Barker code lock. Unitless. Monotonically nondecreasing with "better" lock strength. Called "Signal Quality" in datasheets.
	LockQuality uint16
	// TxAttenuation Transmit power expressed as unitless distance from max power set at factory calibration.  0 is max power. Monotonically nondecreasing with lower power levels.
	TxAttenuation uint16
	// DBTxAttenuation Transmit power expressed as decibel distance from max power set at factory calibration.  0 is max power.  Monotonically nondecreasing with lower power levels.
	DBTxAttenuation uint16
	// DBMTxPower Transmit power expressed as dBm (decibels from a 1 milliwatt reference). This is the absolute power level measured at the antenna port.
	DBMTxPower int8
	// Antenna Unitless indication of the Rx/Tx antenna for this packet. The first antenna is antenna 0.
	Antenna uint8
	// DBAntennaSignal RF signal power at the antenna, decibel difference from an arbitrary, fixed reference.
	DBAntennaSignal uint8
	// DBAntennaNoise RF noise power at the antenna, decibel difference from an arbitrary, fixed reference point.
	DBAntennaNoise uint8
}

func (*RadioTap) CanDecode added in v1.1.4 

func (m *RadioTap) CanDecode() gopacket.LayerClass

func (*RadioTap) DecodeFromBytes added in v1.1.4 

func (m *RadioTap) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*RadioTap) LayerType added in v1.1.4 

func (m *RadioTap) LayerType() gopacket.LayerType

func (*RadioTap) NextLayerType added in v1.1.4 

func (m *RadioTap) NextLayerType() gopacket.LayerType

type RadioTapChannelFlags added in v1.1.4 

type RadioTapChannelFlags uint16
const (
	RadioTapChannelFlagsTurbo   RadioTapChannelFlags = 0x0010 // Turbo channel
	RadioTapChannelFlagsCCK     RadioTapChannelFlags = 0x0020 // CCK channel
	RadioTapChannelFlagsOFDM    RadioTapChannelFlags = 0x0040 // OFDM channel
	RadioTapChannelFlagsGhz2    RadioTapChannelFlags = 0x0080 // 2 GHz spectrum channel.
	RadioTapChannelFlagsGhz5    RadioTapChannelFlags = 0x0100 // 5 GHz spectrum channel
	RadioTapChannelFlagsPassive RadioTapChannelFlags = 0x0200 // Only passive scan allowed
	RadioTapChannelFlagsDynamic RadioTapChannelFlags = 0x0400 // Dynamic CCK-OFDM channel
	RadioTapChannelFlagsGFSK    RadioTapChannelFlags = 0x0800 // GFSK channel (FHSS PHY)
)

func (RadioTapChannelFlags) CCK added in v1.1.4 

func (r RadioTapChannelFlags) CCK() bool

func (RadioTapChannelFlags) Dynamic added in v1.1.4 

func (r RadioTapChannelFlags) Dynamic() bool

func (RadioTapChannelFlags) GFSK added in v1.1.4 

func (r RadioTapChannelFlags) GFSK() bool

func (RadioTapChannelFlags) Ghz2 added in v1.1.4 

func (r RadioTapChannelFlags) Ghz2() bool

func (RadioTapChannelFlags) Ghz5 added in v1.1.4 

func (r RadioTapChannelFlags) Ghz5() bool

func (RadioTapChannelFlags) OFDM added in v1.1.4 

func (r RadioTapChannelFlags) OFDM() bool

func (RadioTapChannelFlags) Passive added in v1.1.4 

func (r RadioTapChannelFlags) Passive() bool

func (RadioTapChannelFlags) String added in v1.1.4 

func (a RadioTapChannelFlags) String() string

String provides a human readable string for RadioTapChannelFlags. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the RadioTapChannelFlags value, not its string.

func (RadioTapChannelFlags) Turbo added in v1.1.4 

func (r RadioTapChannelFlags) Turbo() bool

type RadioTapChannelFrequency added in v1.1.4 

type RadioTapChannelFrequency uint16

func (RadioTapChannelFrequency) String added in v1.1.4 

func (a RadioTapChannelFrequency) String() string

type RadioTapFlags added in v1.1.4 

type RadioTapFlags uint8
const (
	RadioTapFlagsCFP           RadioTapFlags = 1 << iota // sent/received during CFP
	RadioTapFlagsShortPreamble                           // sent/received * with short * preamble
	RadioTapFlagsWEP                                     // sent/received * with WEP encryption
	RadioTapFlagsFrag                                    // sent/received * with fragmentation
	RadioTapFlagsFCS                                     // frame includes FCS
	RadioTapFlagsDatapad                                 // frame has padding between * 802.11 header and payload * (to 32-bit boundary)
	RadioTapFlagsBadFCS                                  // does not pass FCS check
	RadioTapFlagsShortGI                                 // HT short GI
)

func (RadioTapFlags) BadFCS added in v1.1.4 

func (r RadioTapFlags) BadFCS() bool

func (RadioTapFlags) CFP added in v1.1.4 

func (r RadioTapFlags) CFP() bool

func (RadioTapFlags) Datapad added in v1.1.4 

func (r RadioTapFlags) Datapad() bool

func (RadioTapFlags) FCS added in v1.1.4 

func (r RadioTapFlags) FCS() bool

func (RadioTapFlags) Frag added in v1.1.4 

func (r RadioTapFlags) Frag() bool

func (RadioTapFlags) ShortGI added in v1.1.4 

func (r RadioTapFlags) ShortGI() bool

func (RadioTapFlags) ShortPreamble added in v1.1.4 

func (r RadioTapFlags) ShortPreamble() bool

func (RadioTapFlags) String added in v1.1.4 

func (a RadioTapFlags) String() string

String provides a human readable string for RadioTapFlags. This string is possibly subject to change over time; if you're storing this persistently, you should probably store the RadioTapFlags value, not its string.

func (RadioTapFlags) WEP added in v1.1.4 

func (r RadioTapFlags) WEP() bool

type RadioTapPresent added in v1.1.4 

type RadioTapPresent uint32
const (
	RadioTapPresentTSFT RadioTapPresent = 1 << iota
	RadioTapPresentFlags
	RadioTapPresentRate
	RadioTapPresentChannel
	RadioTapPresentFHSS
	RadioTapPresentDBMAntennaSignal
	RadioTapPresentDBMAntennaNoise
	RadioTapPresentLockQuality
	RadioTapPresentTxAttenuation
	RadioTapPresentDBTxAttenuation
	RadioTapPresentDBMTxPower
	RadioTapPresentAntenna
	RadioTapPresentDBAntennaSignal
	RadioTapPresentDBAntennaNoise
	RadioTapPresentRxFlags
	RadioTapPresentTxFlags
	RadioTapPresentRtsRetries
	RadioTapPresentDataRetries
	RadioTapPresentEXT RadioTapPresent = 1 << 31
)

func (RadioTapPresent) Antenna added in v1.1.4 

func (r RadioTapPresent) Antenna() bool

func (RadioTapPresent) Channel added in v1.1.4 

func (r RadioTapPresent) Channel() bool

func (RadioTapPresent) DBAntennaNoise added in v1.1.4 

func (r RadioTapPresent) DBAntennaNoise() bool

func (RadioTapPresent) DBAntennaSignal added in v1.1.4 

func (r RadioTapPresent) DBAntennaSignal() bool

func (RadioTapPresent) DBMAntennaNoise added in v1.1.4 

func (r RadioTapPresent) DBMAntennaNoise() bool

func (RadioTapPresent) DBMAntennaSignal added in v1.1.4 

func (r RadioTapPresent) DBMAntennaSignal() bool

func (RadioTapPresent) DBMTxPower added in v1.1.4 

func (r RadioTapPresent) DBMTxPower() bool

func (RadioTapPresent) DBTxAttenuation added in v1.1.4 

func (r RadioTapPresent) DBTxAttenuation() bool

func (RadioTapPresent) DataRetries added in v1.1.4 

func (r RadioTapPresent) DataRetries() bool

func (RadioTapPresent) EXT added in v1.1.4 

func (r RadioTapPresent) EXT() bool

func (RadioTapPresent) FHSS added in v1.1.4 

func (r RadioTapPresent) FHSS() bool

func (RadioTapPresent) Flags added in v1.1.4 

func (r RadioTapPresent) Flags() bool

func (RadioTapPresent) LockQuality added in v1.1.4 

func (r RadioTapPresent) LockQuality() bool

func (RadioTapPresent) Rate added in v1.1.4 

func (r RadioTapPresent) Rate() bool

func (RadioTapPresent) RtsRetries added in v1.1.4 

func (r RadioTapPresent) RtsRetries() bool

func (RadioTapPresent) RxFlags added in v1.1.4 

func (r RadioTapPresent) RxFlags() bool

func (RadioTapPresent) TSFT added in v1.1.4 

func (r RadioTapPresent) TSFT() bool

func (RadioTapPresent) TxAttenuation added in v1.1.4 

func (r RadioTapPresent) TxAttenuation() bool

func (RadioTapPresent) TxFlags added in v1.1.4 

func (r RadioTapPresent) TxFlags() bool

type RadioTapRate added in v1.1.4 

type RadioTapRate uint8

func (RadioTapRate) String added in v1.1.4 

func (a RadioTapRate) String() string

type SCTP 

type SCTP struct {
	BaseLayer
	SrcPort, DstPort SCTPPort
	VerificationTag  uint32
	Checksum         uint32
	// contains filtered or unexported fields
}

SCTP contains information on the top level of an SCTP packet.

func (*SCTP) LayerType 

func (s *SCTP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTP

func (SCTP) SerializeTo added in v1.1.6 

func (s SCTP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

func (*SCTP) TransportFlow 

func (s *SCTP) TransportFlow() gopacket.Flow

TransportFlow returns a flow based on the source and destination SCTP port.

type SCTPChunk 

type SCTPChunk struct {
	BaseLayer
	Type   SCTPChunkType
	Flags  uint8
	Length uint16
	// ActualLength is the total length of an SCTP chunk, including padding.
	// SCTP chunks start and end on 4-byte boundaries.  So if a chunk has a length
	// of 18, it means that it has data up to and including byte 18, then padding
	// up to the next 4-byte boundary, 20.  In this case, Length would be 18, and
	// ActualLength would be 20.
	ActualLength int
}

SCTPChunk contains the common fields in all SCTP chunks.

type SCTPChunkType 

type SCTPChunkType uint8

SCTPChunkType is an enumeration of chunk types inside SCTP packets. 

const (
	SCTPChunkTypeData             SCTPChunkType = 0
	SCTPChunkTypeInit             SCTPChunkType = 1
	SCTPChunkTypeInitAck          SCTPChunkType = 2
	SCTPChunkTypeSack             SCTPChunkType = 3
	SCTPChunkTypeHeartbeat        SCTPChunkType = 4
	SCTPChunkTypeHeartbeatAck     SCTPChunkType = 5
	SCTPChunkTypeAbort            SCTPChunkType = 6
	SCTPChunkTypeShutdown         SCTPChunkType = 7
	SCTPChunkTypeShutdownAck      SCTPChunkType = 8
	SCTPChunkTypeError            SCTPChunkType = 9
	SCTPChunkTypeCookieEcho       SCTPChunkType = 10
	SCTPChunkTypeCookieAck        SCTPChunkType = 11
	SCTPChunkTypeShutdownComplete SCTPChunkType = 14
)

func (SCTPChunkType) Decode 

func (a SCTPChunkType) Decode(data []byte, p gopacket.PacketBuilder) error

func (SCTPChunkType) String 

func (a SCTPChunkType) String() string

type SCTPCookieEcho 

type SCTPCookieEcho struct {
	SCTPChunk
	Cookie []byte
}

SCTPCookieEcho is the SCTP Cookie Echo layer.

func (*SCTPCookieEcho) LayerType 

func (sc *SCTPCookieEcho) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPCookieEcho.

func (SCTPCookieEcho) SerializeTo added in v1.1.6 

func (sc SCTPCookieEcho) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPData 

type SCTPData struct {
	SCTPChunk
	Unordered, BeginFragment, EndFragment bool
	TSN                                   uint32
	StreamId                              uint16
	StreamSequence                        uint16
	PayloadProtocol                       uint32
	PayloadData                           []byte
}

SCTPData is the SCTP Data chunk layer.

func (*SCTPData) LayerType 

func (s *SCTPData) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPData.

func (*SCTPData) Payload 

func (s *SCTPData) Payload() []byte

Payload returns the data payload of the SCTP data chunk.

func (SCTPData) SerializeTo added in v1.1.6 

func (sc SCTPData) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPEmptyLayer 

type SCTPEmptyLayer struct {
	SCTPChunk
}

This struct is used by all empty SCTP chunks (currently CookieAck and ShutdownComplete).

func (*SCTPEmptyLayer) LayerType 

func (sc *SCTPEmptyLayer) LayerType() gopacket.LayerType

LayerType returns either gopacket.LayerTypeSCTPShutdownComplete or LayerTypeSCTPCookieAck.

func (SCTPEmptyLayer) SerializeTo added in v1.1.6 

func (sc SCTPEmptyLayer) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPError 

type SCTPError struct {
	SCTPChunk
	Parameters []SCTPErrorParameter
}

SCTPError is the SCTP error layer, also used for SCTP aborts.

func (*SCTPError) LayerType 

func (sc *SCTPError) LayerType() gopacket.LayerType

LayerType returns LayerTypeSCTPAbort or LayerTypeSCTPError.

func (SCTPError) SerializeTo added in v1.1.6 

func (sc SCTPError) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPErrorParameter 

type SCTPErrorParameter SCTPParameter

SCTPErrorParameter is the parameter type used by SCTP Abort and Error layers.

type SCTPHeartbeat 

type SCTPHeartbeat struct {
	SCTPChunk
	Parameters []SCTPHeartbeatParameter
}

SCTPHeartbeat is the SCTP heartbeat layer, also used for heatbeat ack.

func (*SCTPHeartbeat) LayerType 

func (sc *SCTPHeartbeat) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPHeartbeat.

func (SCTPHeartbeat) SerializeTo added in v1.1.6 

func (sc SCTPHeartbeat) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPHeartbeatParameter 

type SCTPHeartbeatParameter SCTPParameter

SCTPHeartbeatParameter is the parameter type used by SCTP heartbeat and heartbeat ack layers.

type SCTPInit 

type SCTPInit struct {
	SCTPChunk
	InitiateTag                     uint32
	AdvertisedReceiverWindowCredit  uint32
	OutboundStreams, InboundStreams uint16
	InitialTSN                      uint32
	Parameters                      []SCTPInitParameter
}

SCTPInit is used as the return value for both SCTPInit and SCTPInitAck messages.

func (*SCTPInit) LayerType 

func (sc *SCTPInit) LayerType() gopacket.LayerType

LayerType returns either gopacket.LayerTypeSCTPInit or gopacket.LayerTypeSCTPInitAck.

func (SCTPInit) SerializeTo added in v1.1.6 

func (sc SCTPInit) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPInitParameter 

type SCTPInitParameter SCTPParameter

SCTPInitParameter is a parameter for an SCTP Init or InitAck packet.

type SCTPParameter 

type SCTPParameter struct {
	Type         uint16
	Length       uint16
	ActualLength int
	Value        []byte
}

SCTPParameter is a TLV parameter inside a SCTPChunk.

func (SCTPParameter) Bytes added in v1.1.6 

func (p SCTPParameter) Bytes() []byte

type SCTPPort 

type SCTPPort uint16

SCTPPort is a port in a SCTP layer.

func (SCTPPort) String 

func (a SCTPPort) String() string

String returns the port as "number(name)" if there's a well-known port name, or just "number" if there isn't. Well-known names are stored in SCTPPortNames.

type SCTPSack 

type SCTPSack struct {
	SCTPChunk
	CumulativeTSNAck               uint32
	AdvertisedReceiverWindowCredit uint32
	NumGapACKs, NumDuplicateTSNs   uint16
	GapACKs                        []uint16
	DuplicateTSNs                  []uint32
}

SCTPSack is the SCTP Selective ACK chunk layer.

func (*SCTPSack) LayerType 

func (sc *SCTPSack) LayerType() gopacket.LayerType

LayerType return LayerTypeSCTPSack

func (SCTPSack) SerializeTo added in v1.1.6 

func (sc SCTPSack) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPShutdown 

type SCTPShutdown struct {
	SCTPChunk
	CumulativeTSNAck uint32
}

SCTPShutdown is the SCTP shutdown layer.

func (*SCTPShutdown) LayerType 

func (sc *SCTPShutdown) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPShutdown.

func (SCTPShutdown) SerializeTo added in v1.1.6 

func (sc SCTPShutdown) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPShutdownAck 

type SCTPShutdownAck struct {
	SCTPChunk
}

SCTPShutdownAck is the SCTP shutdown layer.

func (*SCTPShutdownAck) LayerType 

func (sc *SCTPShutdownAck) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPShutdownAck.

func (SCTPShutdownAck) SerializeTo added in v1.1.6 

func (sc SCTPShutdownAck) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SCTPUnknownChunkType 

type SCTPUnknownChunkType struct {
	SCTPChunk
	// contains filtered or unexported fields
}

SCTPUnknownChunkType is the layer type returned when we don't recognize the chunk type. Since there's a length in a known location, we can skip over it even if we don't know what it is, and continue parsing the rest of the chunks. This chunk is stored as an ErrorLayer in the packet.

func (*SCTPUnknownChunkType) Error 

func (s *SCTPUnknownChunkType) Error() error

Error implements ErrorLayer.

func (*SCTPUnknownChunkType) LayerType 

func (s *SCTPUnknownChunkType) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSCTPUnknownChunkType.

func (*SCTPUnknownChunkType) Payload 

func (s *SCTPUnknownChunkType) Payload() []byte

Payload returns all bytes in this header, including the decoded Type, Length, and Flags.

func (SCTPUnknownChunkType) SerializeTo added in v1.1.6 

func (s SCTPUnknownChunkType) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo is for gopacket.SerializableLayer.

type SNAP 

type SNAP struct {
	BaseLayer
	OrganizationalCode []byte
	Type               EthernetType
}

SNAP is used inside LLC. See http://standards.ieee.org/getieee802/download/802-2001.pdf. From http://en.wikipedia.org/wiki/Subnetwork_Access_Protocol: 

"[T]he Subnetwork Access Protocol (SNAP) is a mechanism for multiplexing,
on networks using IEEE 802.2 LLC, more protocols than can be distinguished
by the 8-bit 802.2 Service Access Point (SAP) fields."

func (*SNAP) LayerType 

func (s *SNAP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeSNAP.

type TCP 

type TCP struct {
	BaseLayer
	SrcPort, DstPort                           TCPPort
	Seq                                        uint32
	Ack                                        uint32
	DataOffset                                 uint8
	FIN, SYN, RST, PSH, ACK, URG, ECE, CWR, NS bool
	Window                                     uint16
	Checksum                                   uint16
	Urgent                                     uint16

	Options []TCPOption
	Padding []byte
	// contains filtered or unexported fields
}

TCP is the layer for TCP headers.

func (*TCP) CanDecode 

func (t *TCP) CanDecode() gopacket.LayerClass

func (*TCP) DecodeFromBytes 

func (tcp *TCP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*TCP) LayerType 

func (t *TCP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeTCP

func (*TCP) NextLayerType 

func (t *TCP) NextLayerType() gopacket.LayerType

func (*TCP) SerializeTo 

func (t *TCP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

func (*TCP) SetNetworkLayerForChecksum 

func (i *TCP) SetNetworkLayerForChecksum(l gopacket.NetworkLayer) error

SetNetworkLayerForChecksum tells this layer which network layer is wrapping it. This is needed for computing the checksum when serializing, since TCP/IP transport layer checksums depends on fields in the IPv4 or IPv6 layer that contains it. The passed in layer must be an *IPv4 or *IPv6.

func (*TCP) TransportFlow 

func (t *TCP) TransportFlow() gopacket.Flow

type TCPOption 

type TCPOption struct {
	OptionType   uint8
	OptionLength uint8
	OptionData   []byte
}

func (TCPOption) String 

func (t TCPOption) String() string

type TCPPort 

type TCPPort uint16

TCPPort is a port in a TCP layer.

func (TCPPort) String 

func (a TCPPort) String() string

String returns the port as "number(name)" if there's a well-known port name, or just "number" if there isn't. Well-known names are stored in TCPPortNames.

type UDP 

type UDP struct {
	BaseLayer
	SrcPort, DstPort UDPPort
	Length           uint16
	Checksum         uint16
	// contains filtered or unexported fields
}

UDP is the layer for UDP headers.

func (*UDP) CanDecode 

func (u *UDP) CanDecode() gopacket.LayerClass

func (*UDP) DecodeFromBytes 

func (udp *UDP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*UDP) LayerType 

func (u *UDP) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeUDP

func (*UDP) NextLayerType 

func (u *UDP) NextLayerType() gopacket.LayerType

func (*UDP) SerializeTo 

func (u *UDP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo writes the serialized form of this layer into the SerializationBuffer, implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.

func (*UDP) SetNetworkLayerForChecksum 

func (i *UDP) SetNetworkLayerForChecksum(l gopacket.NetworkLayer) error

SetNetworkLayerForChecksum tells this layer which network layer is wrapping it. This is needed for computing the checksum when serializing, since TCP/IP transport layer checksums depends on fields in the IPv4 or IPv6 layer that contains it. The passed in layer must be an *IPv4 or *IPv6.

func (*UDP) TransportFlow 

func (u *UDP) TransportFlow() gopacket.Flow

type UDPLite 

type UDPLite struct {
	BaseLayer
	SrcPort, DstPort UDPLitePort
	ChecksumCoverage uint16
	Checksum         uint16
	// contains filtered or unexported fields
}

UDPLite is the layer for UDP-Lite headers (rfc 3828).

func (*UDPLite) LayerType 

func (u *UDPLite) LayerType() gopacket.LayerType

LayerType returns gopacket.LayerTypeUDPLite

func (*UDPLite) TransportFlow 

func (u *UDPLite) TransportFlow() gopacket.Flow

type UDPLitePort 

type UDPLitePort uint16

UDPLitePort is a port in a UDPLite layer.

func (UDPLitePort) String 

func (a UDPLitePort) String() string

String returns the port as "number(name)" if there's a well-known port name, or just "number" if there isn't. Well-known names are stored in UDPLitePortNames.

type UDPPort 

type UDPPort uint16

UDPPort is a port in a UDP layer.

func (UDPPort) String 

func (a UDPPort) String() string

String returns the port as "number(name)" if there's a well-known port name, or just "number" if there isn't. Well-known names are stored in UDPPortNames.

type VLANName 

type VLANName struct {
	ID   uint16
	Name string
}

Notes

Bugs

  • When decoding SNAP, we treat the SNAP type as an Ethernet type. This may not actually be an ethernet type in all cases, depending on the organizational code. Right now, we don't check.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.