gopacket: github.com/google/gopacket/layers Index | Files

package layers

import "github.com/google/gopacket/layers"

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://github.com/google/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

Package Files

arp.go base.go bfd.go cdp.go ctp.go dhcpv4.go dhcpv6.go dns.go doc.go dot11.go dot1q.go eap.go eapol.go endpoints.go enums.go enums_generated.go etherip.go ethernet.go fddi.go geneve.go gre.go gtp.go iana_ports.go icmp4.go icmp6.go icmp6msg.go igmp.go ip4.go ip6.go ipsec.go layertypes.go lcm.go linux_sll.go llc.go lldp.go loopback.go mpls.go ndp.go ntp.go ospf.go pflog.go ports.go ppp.go pppoe.go prism.go radiotap.go rudp.go sctp.go sflow.go sip.go stp.go tcp.go tcpip.go udp.go udplite.go usb.go vrrp.go vxlan.go

Constants

const (
    ARPRequest = 1
    ARPReply   = 2
)

Potential values for ARP.Operation.

const (
    CDPPoEFourWire  byte = 0x01
    CDPPoEPDArch    byte = 0x02
    CDPPoEPDRequest byte = 0x04
    CDPPoEPSE       byte = 0x08
)

CDP Power-over-Ethernet values.

const (
    CDPProtocolTypeNLPID byte = 1
    CDPProtocolType802_2 byte = 2
)

CDP Protocol Types

const (
    // DecOptionNotEnoughData is returned when there is not enough data during option's decode process
    DecOptionNotEnoughData = DHCPv4Error("Not enough data to decode")
    // DecOptionMalformed is returned when the option is malformed
    DecOptionMalformed = DHCPv4Error("Option is malformed")
    // InvalidMagicCookie is returned when Magic cookie is missing into BOOTP header
    InvalidMagicCookie = DHCPv4Error("Bad DHCP header")
)
const (
    Dot11CodingTypeBCC  = 0
    Dot11CodingTypeLDPC = 1
)
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
)
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
)
const (
    // DestinationUnreachable
    ICMPv4CodeNet                 = 0
    ICMPv4CodeHost                = 1
    ICMPv4CodeProtocol            = 2
    ICMPv4CodePort                = 3
    ICMPv4CodeFragmentationNeeded = 4
    ICMPv4CodeSourceRoutingFailed = 5
    ICMPv4CodeNetUnknown          = 6
    ICMPv4CodeHostUnknown         = 7
    ICMPv4CodeSourceIsolated      = 8
    ICMPv4CodeNetAdminProhibited  = 9
    ICMPv4CodeHostAdminProhibited = 10
    ICMPv4CodeNetTOS              = 11
    ICMPv4CodeHostTOS             = 12
    ICMPv4CodeCommAdminProhibited = 13
    ICMPv4CodeHostPrecedence      = 14
    ICMPv4CodePrecedenceCutoff    = 15

    // TimeExceeded
    ICMPv4CodeTTLExceeded                    = 0
    ICMPv4CodeFragmentReassemblyTimeExceeded = 1

    // ParameterProblem
    ICMPv4CodePointerIndicatesError = 0
    ICMPv4CodeMissingOption         = 1
    ICMPv4CodeBadLength             = 2

    // Redirect
    // ICMPv4CodeNet  = same as for DestinationUnreachable
    // ICMPv4CodeHost = same as for DestinationUnreachable
    ICMPv4CodeTOSNet  = 2
    ICMPv4CodeTOSHost = 3
)
const (
    // The following are from RFC 4443
    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
)
const (
    // DestinationUnreachable
    ICMPv6CodeNoRouteToDst           = 0
    ICMPv6CodeAdminProhibited        = 1
    ICMPv6CodeBeyondScopeOfSrc       = 2
    ICMPv6CodeAddressUnreachable     = 3
    ICMPv6CodePortUnreachable        = 4
    ICMPv6CodeSrcAddressFailedPolicy = 5
    ICMPv6CodeRejectRouteToDst       = 6

    // TimeExceeded
    ICMPv6CodeHopLimitExceeded               = 0
    ICMPv6CodeFragmentReassemblyTimeExceeded = 1

    // ParameterProblem
    ICMPv6CodeErroneousHeaderField   = 0
    ICMPv6CodeUnrecognizedNextHeader = 1
    ICMPv6CodeUnrecognizedIPv6Option = 2
)
const (
    // LCMShortHeaderMagic is the LCM small message header magic number
    LCMShortHeaderMagic uint32 = 0x4c433032
    // LCMFragmentedHeaderMagic is the LCM fragmented message header magic number
    LCMFragmentedHeaderMagic uint32 = 0x4c433033
)
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

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

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

VLAN Port Protocol ID options

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

LACP options

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

IEEE 802.3 TLV Subtypes

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

MACPHY options

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

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

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)

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

MDI Power options

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

IEEE 802.1Qbg TLV Subtypes

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

LLDPEVBCapabilities Types

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

const (
    LLDPCiscoPSESupport   uint8 = 1 << 0
    LLDPCiscoArchShared   uint8 = 1 << 1
    LLDPCiscoPDSparePair  uint8 = 1 << 2
    LLDPCiscoPSESparePair uint8 = 1 << 3
)
const (
    RouterLSAtypeV2         = 0x1
    RouterLSAtype           = 0x2001
    NetworkLSAtypeV2        = 0x2
    NetworkLSAtype          = 0x2002
    SummaryLSANetworktypeV2 = 0x3
    InterAreaPrefixLSAtype  = 0x2003
    SummaryLSAASBRtypeV2    = 0x4
    InterAreaRouterLSAtype  = 0x2004
    ASExternalLSAtypeV2     = 0x5
    ASExternalLSAtype       = 0x4005
    NSSALSAtype             = 0x2007
    LinkLSAtype             = 0x0008
    IntraAreaPrefixLSAtype  = 0x2009
)

LSA Function Codes for LSAheader.LSType

const (
    PrismType1MessageCode uint16 = 0x00000044
    PrismType2MessageCode uint16 = 0x00000041
)
const (
    RadioTapMCSFlagsBandwidthMask RadioTapMCSFlags = 0x03
    RadioTapMCSFlagsShortGI                        = 0x04
    RadioTapMCSFlagsGreenfield                     = 0x08
    RadioTapMCSFlagsFECLDPC                        = 0x10
    RadioTapMCSFlagsSTBCMask                       = 0x60
    RadioTapMCSFlagsNESS0                          = 0x80
)
const (
    SCTPProtocolReserved  SCTPPayloadProtocol = 0
    SCTPPayloadUIA                            = 1
    SCTPPayloadM2UA                           = 2
    SCTPPayloadM3UA                           = 3
    SCTPPayloadSUA                            = 4
    SCTPPayloadM2PA                           = 5
    SCTPPayloadV5UA                           = 6
    SCTPPayloadH248                           = 7
    SCTPPayloadBICC                           = 8
    SCTPPayloadTALI                           = 9
    SCTPPayloadDUA                            = 10
    SCTPPayloadASAP                           = 11
    SCTPPayloadENRP                           = 12
    SCTPPayloadH323                           = 13
    SCTPPayloadQIPC                           = 14
    SCTPPayloadSIMCO                          = 15
    SCTPPayloadDDPSegment                     = 16
    SCTPPayloadDDPStream                      = 17
    SCTPPayloadS1AP                           = 18
)

SCTPPayloadProtocol constonts from http://www.iana.org/assignments/sctp-parameters/sctp-parameters.xhtml

const (
    TCPOptionKindEndList                         = 0
    TCPOptionKindNop                             = 1
    TCPOptionKindMSS                             = 2  // len = 4
    TCPOptionKindWindowScale                     = 3  // len = 3
    TCPOptionKindSACKPermitted                   = 4  // len = 2
    TCPOptionKindSACK                            = 5  // len = n
    TCPOptionKindEcho                            = 6  // len = 6, obsolete
    TCPOptionKindEchoReply                       = 7  // len = 6, obsolete
    TCPOptionKindTimestamps                      = 8  // len = 10
    TCPOptionKindPartialOrderConnectionPermitted = 9  // len = 2, obsolete
    TCPOptionKindPartialOrderServiceProfile      = 10 // len = 3, obsolete
    TCPOptionKindCC                              = 11 // obsolete
    TCPOptionKindCCNew                           = 12 // obsolete
    TCPOptionKindCCEcho                          = 13 // obsolete
    TCPOptionKindAltChecksum                     = 14 // len = 3, obsolete
    TCPOptionKindAltChecksumData                 = 15 // len = n, obsolete
)
const (
    IPv6HopByHopOptionJumbogram = 0xC2 // RFC 2675
)

Variables

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{Name: "IPv4", Formatter: func(b []byte) string {
        return net.IP(b).String()
    }})
    EndpointIPv6 = gopacket.RegisterEndpointType(2, gopacket.EndpointTypeMetadata{Name: "IPv6", Formatter: func(b []byte) string {
        return net.IP(b).String()
    }})

    EndpointMAC = gopacket.RegisterEndpointType(3, gopacket.EndpointTypeMetadata{Name: "MAC", Formatter: func(b []byte) string {
        return net.HardwareAddr(b).String()
    }})
    EndpointTCPPort = gopacket.RegisterEndpointType(4, gopacket.EndpointTypeMetadata{Name: "TCP", Formatter: func(b []byte) string {
        return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
    }})
    EndpointUDPPort = gopacket.RegisterEndpointType(5, gopacket.EndpointTypeMetadata{Name: "UDP", Formatter: func(b []byte) string {
        return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
    }})
    EndpointSCTPPort = gopacket.RegisterEndpointType(6, gopacket.EndpointTypeMetadata{Name: "SCTP", Formatter: func(b []byte) string {
        return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
    }})
    EndpointRUDPPort = gopacket.RegisterEndpointType(7, gopacket.EndpointTypeMetadata{Name: "RUDP", Formatter: func(b []byte) string {
        return strconv.Itoa(int(b[0]))
    }})
    EndpointUDPLitePort = gopacket.RegisterEndpointType(8, gopacket.EndpointTypeMetadata{Name: "UDPLite", Formatter: func(b []byte) string {
        return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
    }})
    EndpointPPP = gopacket.RegisterEndpointType(9, gopacket.EndpointTypeMetadata{Name: "PPP", Formatter: func([]byte) string {
        return "point"
    }})
)
var (
    LayerTypeARP                         = gopacket.RegisterLayerType(10, gopacket.LayerTypeMetadata{Name: "ARP", Decoder: gopacket.DecodeFunc(decodeARP)})
    LayerTypeCiscoDiscovery              = gopacket.RegisterLayerType(11, gopacket.LayerTypeMetadata{Name: "CiscoDiscovery", Decoder: gopacket.DecodeFunc(decodeCiscoDiscovery)})
    LayerTypeEthernetCTP                 = gopacket.RegisterLayerType(12, gopacket.LayerTypeMetadata{Name: "EthernetCTP", Decoder: gopacket.DecodeFunc(decodeEthernetCTP)})
    LayerTypeEthernetCTPForwardData      = gopacket.RegisterLayerType(13, gopacket.LayerTypeMetadata{Name: "EthernetCTPForwardData", Decoder: nil})
    LayerTypeEthernetCTPReply            = gopacket.RegisterLayerType(14, gopacket.LayerTypeMetadata{Name: "EthernetCTPReply", Decoder: nil})
    LayerTypeDot1Q                       = gopacket.RegisterLayerType(15, gopacket.LayerTypeMetadata{Name: "Dot1Q", Decoder: gopacket.DecodeFunc(decodeDot1Q)})
    LayerTypeEtherIP                     = gopacket.RegisterLayerType(16, gopacket.LayerTypeMetadata{Name: "EtherIP", Decoder: gopacket.DecodeFunc(decodeEtherIP)})
    LayerTypeEthernet                    = gopacket.RegisterLayerType(17, gopacket.LayerTypeMetadata{Name: "Ethernet", Decoder: gopacket.DecodeFunc(decodeEthernet)})
    LayerTypeGRE                         = gopacket.RegisterLayerType(18, gopacket.LayerTypeMetadata{Name: "GRE", Decoder: gopacket.DecodeFunc(decodeGRE)})
    LayerTypeICMPv4                      = gopacket.RegisterLayerType(19, gopacket.LayerTypeMetadata{Name: "ICMPv4", Decoder: gopacket.DecodeFunc(decodeICMPv4)})
    LayerTypeIPv4                        = gopacket.RegisterLayerType(20, gopacket.LayerTypeMetadata{Name: "IPv4", Decoder: gopacket.DecodeFunc(decodeIPv4)})
    LayerTypeIPv6                        = gopacket.RegisterLayerType(21, gopacket.LayerTypeMetadata{Name: "IPv6", Decoder: gopacket.DecodeFunc(decodeIPv6)})
    LayerTypeLLC                         = gopacket.RegisterLayerType(22, gopacket.LayerTypeMetadata{Name: "LLC", Decoder: gopacket.DecodeFunc(decodeLLC)})
    LayerTypeSNAP                        = gopacket.RegisterLayerType(23, gopacket.LayerTypeMetadata{Name: "SNAP", Decoder: gopacket.DecodeFunc(decodeSNAP)})
    LayerTypeMPLS                        = gopacket.RegisterLayerType(24, gopacket.LayerTypeMetadata{Name: "MPLS", Decoder: gopacket.DecodeFunc(decodeMPLS)})
    LayerTypePPP                         = gopacket.RegisterLayerType(25, gopacket.LayerTypeMetadata{Name: "PPP", Decoder: gopacket.DecodeFunc(decodePPP)})
    LayerTypePPPoE                       = gopacket.RegisterLayerType(26, gopacket.LayerTypeMetadata{Name: "PPPoE", Decoder: gopacket.DecodeFunc(decodePPPoE)})
    LayerTypeRUDP                        = gopacket.RegisterLayerType(27, gopacket.LayerTypeMetadata{Name: "RUDP", Decoder: gopacket.DecodeFunc(decodeRUDP)})
    LayerTypeSCTP                        = gopacket.RegisterLayerType(28, gopacket.LayerTypeMetadata{Name: "SCTP", Decoder: gopacket.DecodeFunc(decodeSCTP)})
    LayerTypeSCTPUnknownChunkType        = gopacket.RegisterLayerType(29, gopacket.LayerTypeMetadata{Name: "SCTPUnknownChunkType", Decoder: nil})
    LayerTypeSCTPData                    = gopacket.RegisterLayerType(30, gopacket.LayerTypeMetadata{Name: "SCTPData", Decoder: nil})
    LayerTypeSCTPInit                    = gopacket.RegisterLayerType(31, gopacket.LayerTypeMetadata{Name: "SCTPInit", Decoder: nil})
    LayerTypeSCTPSack                    = gopacket.RegisterLayerType(32, gopacket.LayerTypeMetadata{Name: "SCTPSack", Decoder: nil})
    LayerTypeSCTPHeartbeat               = gopacket.RegisterLayerType(33, gopacket.LayerTypeMetadata{Name: "SCTPHeartbeat", Decoder: nil})
    LayerTypeSCTPError                   = gopacket.RegisterLayerType(34, gopacket.LayerTypeMetadata{Name: "SCTPError", Decoder: nil})
    LayerTypeSCTPShutdown                = gopacket.RegisterLayerType(35, gopacket.LayerTypeMetadata{Name: "SCTPShutdown", Decoder: nil})
    LayerTypeSCTPShutdownAck             = gopacket.RegisterLayerType(36, gopacket.LayerTypeMetadata{Name: "SCTPShutdownAck", Decoder: nil})
    LayerTypeSCTPCookieEcho              = gopacket.RegisterLayerType(37, gopacket.LayerTypeMetadata{Name: "SCTPCookieEcho", Decoder: nil})
    LayerTypeSCTPEmptyLayer              = gopacket.RegisterLayerType(38, gopacket.LayerTypeMetadata{Name: "SCTPEmptyLayer", Decoder: nil})
    LayerTypeSCTPInitAck                 = gopacket.RegisterLayerType(39, gopacket.LayerTypeMetadata{Name: "SCTPInitAck", Decoder: nil})
    LayerTypeSCTPHeartbeatAck            = gopacket.RegisterLayerType(40, gopacket.LayerTypeMetadata{Name: "SCTPHeartbeatAck", Decoder: nil})
    LayerTypeSCTPAbort                   = gopacket.RegisterLayerType(41, gopacket.LayerTypeMetadata{Name: "SCTPAbort", Decoder: nil})
    LayerTypeSCTPShutdownComplete        = gopacket.RegisterLayerType(42, gopacket.LayerTypeMetadata{Name: "SCTPShutdownComplete", Decoder: nil})
    LayerTypeSCTPCookieAck               = gopacket.RegisterLayerType(43, gopacket.LayerTypeMetadata{Name: "SCTPCookieAck", Decoder: nil})
    LayerTypeTCP                         = gopacket.RegisterLayerType(44, gopacket.LayerTypeMetadata{Name: "TCP", Decoder: gopacket.DecodeFunc(decodeTCP)})
    LayerTypeUDP                         = gopacket.RegisterLayerType(45, gopacket.LayerTypeMetadata{Name: "UDP", Decoder: gopacket.DecodeFunc(decodeUDP)})
    LayerTypeIPv6HopByHop                = gopacket.RegisterLayerType(46, gopacket.LayerTypeMetadata{Name: "IPv6HopByHop", Decoder: gopacket.DecodeFunc(decodeIPv6HopByHop)})
    LayerTypeIPv6Routing                 = gopacket.RegisterLayerType(47, gopacket.LayerTypeMetadata{Name: "IPv6Routing", Decoder: gopacket.DecodeFunc(decodeIPv6Routing)})
    LayerTypeIPv6Fragment                = gopacket.RegisterLayerType(48, gopacket.LayerTypeMetadata{Name: "IPv6Fragment", Decoder: gopacket.DecodeFunc(decodeIPv6Fragment)})
    LayerTypeIPv6Destination             = gopacket.RegisterLayerType(49, gopacket.LayerTypeMetadata{Name: "IPv6Destination", Decoder: gopacket.DecodeFunc(decodeIPv6Destination)})
    LayerTypeIPSecAH                     = gopacket.RegisterLayerType(50, gopacket.LayerTypeMetadata{Name: "IPSecAH", Decoder: gopacket.DecodeFunc(decodeIPSecAH)})
    LayerTypeIPSecESP                    = gopacket.RegisterLayerType(51, gopacket.LayerTypeMetadata{Name: "IPSecESP", Decoder: gopacket.DecodeFunc(decodeIPSecESP)})
    LayerTypeUDPLite                     = gopacket.RegisterLayerType(52, gopacket.LayerTypeMetadata{Name: "UDPLite", Decoder: gopacket.DecodeFunc(decodeUDPLite)})
    LayerTypeFDDI                        = gopacket.RegisterLayerType(53, gopacket.LayerTypeMetadata{Name: "FDDI", Decoder: gopacket.DecodeFunc(decodeFDDI)})
    LayerTypeLoopback                    = gopacket.RegisterLayerType(54, gopacket.LayerTypeMetadata{Name: "Loopback", Decoder: gopacket.DecodeFunc(decodeLoopback)})
    LayerTypeEAP                         = gopacket.RegisterLayerType(55, gopacket.LayerTypeMetadata{Name: "EAP", Decoder: gopacket.DecodeFunc(decodeEAP)})
    LayerTypeEAPOL                       = gopacket.RegisterLayerType(56, gopacket.LayerTypeMetadata{Name: "EAPOL", Decoder: gopacket.DecodeFunc(decodeEAPOL)})
    LayerTypeICMPv6                      = gopacket.RegisterLayerType(57, gopacket.LayerTypeMetadata{Name: "ICMPv6", Decoder: gopacket.DecodeFunc(decodeICMPv6)})
    LayerTypeLinkLayerDiscovery          = gopacket.RegisterLayerType(58, gopacket.LayerTypeMetadata{Name: "LinkLayerDiscovery", Decoder: gopacket.DecodeFunc(decodeLinkLayerDiscovery)})
    LayerTypeCiscoDiscoveryInfo          = gopacket.RegisterLayerType(59, gopacket.LayerTypeMetadata{Name: "CiscoDiscoveryInfo", Decoder: gopacket.DecodeFunc(decodeCiscoDiscoveryInfo)})
    LayerTypeLinkLayerDiscoveryInfo      = gopacket.RegisterLayerType(60, gopacket.LayerTypeMetadata{Name: "LinkLayerDiscoveryInfo", Decoder: nil})
    LayerTypeNortelDiscovery             = gopacket.RegisterLayerType(61, gopacket.LayerTypeMetadata{Name: "NortelDiscovery", Decoder: gopacket.DecodeFunc(decodeNortelDiscovery)})
    LayerTypeIGMP                        = gopacket.RegisterLayerType(62, gopacket.LayerTypeMetadata{Name: "IGMP", Decoder: gopacket.DecodeFunc(decodeIGMP)})
    LayerTypePFLog                       = gopacket.RegisterLayerType(63, gopacket.LayerTypeMetadata{Name: "PFLog", Decoder: gopacket.DecodeFunc(decodePFLog)})
    LayerTypeRadioTap                    = gopacket.RegisterLayerType(64, gopacket.LayerTypeMetadata{Name: "RadioTap", Decoder: gopacket.DecodeFunc(decodeRadioTap)})
    LayerTypeDot11                       = gopacket.RegisterLayerType(65, gopacket.LayerTypeMetadata{Name: "Dot11", Decoder: gopacket.DecodeFunc(decodeDot11)})
    LayerTypeDot11Ctrl                   = gopacket.RegisterLayerType(66, gopacket.LayerTypeMetadata{Name: "Dot11Ctrl", Decoder: gopacket.DecodeFunc(decodeDot11Ctrl)})
    LayerTypeDot11Data                   = gopacket.RegisterLayerType(67, gopacket.LayerTypeMetadata{Name: "Dot11Data", Decoder: gopacket.DecodeFunc(decodeDot11Data)})
    LayerTypeDot11DataCFAck              = gopacket.RegisterLayerType(68, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAck)})
    LayerTypeDot11DataCFPoll             = gopacket.RegisterLayerType(69, gopacket.LayerTypeMetadata{Name: "Dot11DataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFPoll)})
    LayerTypeDot11DataCFAckPoll          = gopacket.RegisterLayerType(70, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
    LayerTypeDot11DataNull               = gopacket.RegisterLayerType(71, gopacket.LayerTypeMetadata{Name: "Dot11DataNull", Decoder: gopacket.DecodeFunc(decodeDot11DataNull)})
    LayerTypeDot11DataCFAckNoData        = gopacket.RegisterLayerType(72, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAck)})
    LayerTypeDot11DataCFPollNoData       = gopacket.RegisterLayerType(73, gopacket.LayerTypeMetadata{Name: "Dot11DataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFPoll)})
    LayerTypeDot11DataCFAckPollNoData    = gopacket.RegisterLayerType(74, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
    LayerTypeDot11DataQOSData            = gopacket.RegisterLayerType(75, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSData", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSData)})
    LayerTypeDot11DataQOSDataCFAck       = gopacket.RegisterLayerType(76, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAck)})
    LayerTypeDot11DataQOSDataCFPoll      = gopacket.RegisterLayerType(77, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFPoll)})
    LayerTypeDot11DataQOSDataCFAckPoll   = gopacket.RegisterLayerType(78, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAckPoll)})
    LayerTypeDot11DataQOSNull            = gopacket.RegisterLayerType(79, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSNull", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSNull)})
    LayerTypeDot11DataQOSCFPollNoData    = gopacket.RegisterLayerType(80, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSCFPollNoData)})
    LayerTypeDot11DataQOSCFAckPollNoData = gopacket.RegisterLayerType(81, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSCFAckPollNoData)})
    LayerTypeDot11InformationElement     = gopacket.RegisterLayerType(82, gopacket.LayerTypeMetadata{Name: "Dot11InformationElement", Decoder: gopacket.DecodeFunc(decodeDot11InformationElement)})
    LayerTypeDot11CtrlCTS                = gopacket.RegisterLayerType(83, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCTS", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCTS)})
    LayerTypeDot11CtrlRTS                = gopacket.RegisterLayerType(84, gopacket.LayerTypeMetadata{Name: "Dot11CtrlRTS", Decoder: gopacket.DecodeFunc(decodeDot11CtrlRTS)})
    LayerTypeDot11CtrlBlockAckReq        = gopacket.RegisterLayerType(85, gopacket.LayerTypeMetadata{Name: "Dot11CtrlBlockAckReq", Decoder: gopacket.DecodeFunc(decodeDot11CtrlBlockAckReq)})
    LayerTypeDot11CtrlBlockAck           = gopacket.RegisterLayerType(86, gopacket.LayerTypeMetadata{Name: "Dot11CtrlBlockAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlBlockAck)})
    LayerTypeDot11CtrlPowersavePoll      = gopacket.RegisterLayerType(87, gopacket.LayerTypeMetadata{Name: "Dot11CtrlPowersavePoll", Decoder: gopacket.DecodeFunc(decodeDot11CtrlPowersavePoll)})
    LayerTypeDot11CtrlAck                = gopacket.RegisterLayerType(88, gopacket.LayerTypeMetadata{Name: "Dot11CtrlAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlAck)})
    LayerTypeDot11CtrlCFEnd              = gopacket.RegisterLayerType(89, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCFEnd", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCFEnd)})
    LayerTypeDot11CtrlCFEndAck           = gopacket.RegisterLayerType(90, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCFEndAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCFEndAck)})
    LayerTypeDot11MgmtAssociationReq     = gopacket.RegisterLayerType(91, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAssociationReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAssociationReq)})
    LayerTypeDot11MgmtAssociationResp    = gopacket.RegisterLayerType(92, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAssociationResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAssociationResp)})
    LayerTypeDot11MgmtReassociationReq   = gopacket.RegisterLayerType(93, gopacket.LayerTypeMetadata{Name: "Dot11MgmtReassociationReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtReassociationReq)})
    LayerTypeDot11MgmtReassociationResp  = gopacket.RegisterLayerType(94, gopacket.LayerTypeMetadata{Name: "Dot11MgmtReassociationResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtReassociationResp)})
    LayerTypeDot11MgmtProbeReq           = gopacket.RegisterLayerType(95, gopacket.LayerTypeMetadata{Name: "Dot11MgmtProbeReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtProbeReq)})
    LayerTypeDot11MgmtProbeResp          = gopacket.RegisterLayerType(96, gopacket.LayerTypeMetadata{Name: "Dot11MgmtProbeResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtProbeResp)})
    LayerTypeDot11MgmtMeasurementPilot   = gopacket.RegisterLayerType(97, gopacket.LayerTypeMetadata{Name: "Dot11MgmtMeasurementPilot", Decoder: gopacket.DecodeFunc(decodeDot11MgmtMeasurementPilot)})
    LayerTypeDot11MgmtBeacon             = gopacket.RegisterLayerType(98, gopacket.LayerTypeMetadata{Name: "Dot11MgmtBeacon", Decoder: gopacket.DecodeFunc(decodeDot11MgmtBeacon)})
    LayerTypeDot11MgmtATIM               = gopacket.RegisterLayerType(99, gopacket.LayerTypeMetadata{Name: "Dot11MgmtATIM", Decoder: gopacket.DecodeFunc(decodeDot11MgmtATIM)})
    LayerTypeDot11MgmtDisassociation     = gopacket.RegisterLayerType(100, gopacket.LayerTypeMetadata{Name: "Dot11MgmtDisassociation", Decoder: gopacket.DecodeFunc(decodeDot11MgmtDisassociation)})
    LayerTypeDot11MgmtAuthentication     = gopacket.RegisterLayerType(101, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAuthentication", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAuthentication)})
    LayerTypeDot11MgmtDeauthentication   = gopacket.RegisterLayerType(102, gopacket.LayerTypeMetadata{Name: "Dot11MgmtDeauthentication", Decoder: gopacket.DecodeFunc(decodeDot11MgmtDeauthentication)})
    LayerTypeDot11MgmtAction             = gopacket.RegisterLayerType(103, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAction", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAction)})
    LayerTypeDot11MgmtActionNoAck        = gopacket.RegisterLayerType(104, gopacket.LayerTypeMetadata{Name: "Dot11MgmtActionNoAck", Decoder: gopacket.DecodeFunc(decodeDot11MgmtActionNoAck)})
    LayerTypeDot11MgmtArubaWLAN          = gopacket.RegisterLayerType(105, gopacket.LayerTypeMetadata{Name: "Dot11MgmtArubaWLAN", Decoder: gopacket.DecodeFunc(decodeDot11MgmtArubaWLAN)})
    LayerTypeDot11WEP                    = gopacket.RegisterLayerType(106, gopacket.LayerTypeMetadata{Name: "Dot11WEP", Decoder: gopacket.DecodeFunc(decodeDot11WEP)})
    LayerTypeDNS                         = gopacket.RegisterLayerType(107, gopacket.LayerTypeMetadata{Name: "DNS", Decoder: gopacket.DecodeFunc(decodeDNS)})
    LayerTypeUSB                         = gopacket.RegisterLayerType(108, gopacket.LayerTypeMetadata{Name: "USB", Decoder: gopacket.DecodeFunc(decodeUSB)})
    LayerTypeUSBRequestBlockSetup        = gopacket.RegisterLayerType(109, gopacket.LayerTypeMetadata{Name: "USBRequestBlockSetup", Decoder: gopacket.DecodeFunc(decodeUSBRequestBlockSetup)})
    LayerTypeUSBControl                  = gopacket.RegisterLayerType(110, gopacket.LayerTypeMetadata{Name: "USBControl", Decoder: gopacket.DecodeFunc(decodeUSBControl)})
    LayerTypeUSBInterrupt                = gopacket.RegisterLayerType(111, gopacket.LayerTypeMetadata{Name: "USBInterrupt", Decoder: gopacket.DecodeFunc(decodeUSBInterrupt)})
    LayerTypeUSBBulk                     = gopacket.RegisterLayerType(112, gopacket.LayerTypeMetadata{Name: "USBBulk", Decoder: gopacket.DecodeFunc(decodeUSBBulk)})
    LayerTypeLinuxSLL                    = gopacket.RegisterLayerType(113, gopacket.LayerTypeMetadata{Name: "Linux SLL", Decoder: gopacket.DecodeFunc(decodeLinuxSLL)})
    LayerTypeSFlow                       = gopacket.RegisterLayerType(114, gopacket.LayerTypeMetadata{Name: "SFlow", Decoder: gopacket.DecodeFunc(decodeSFlow)})
    LayerTypePrismHeader                 = gopacket.RegisterLayerType(115, gopacket.LayerTypeMetadata{Name: "Prism monitor mode header", Decoder: gopacket.DecodeFunc(decodePrismHeader)})
    LayerTypeVXLAN                       = gopacket.RegisterLayerType(116, gopacket.LayerTypeMetadata{Name: "VXLAN", Decoder: gopacket.DecodeFunc(decodeVXLAN)})
    LayerTypeNTP                         = gopacket.RegisterLayerType(117, gopacket.LayerTypeMetadata{Name: "NTP", Decoder: gopacket.DecodeFunc(decodeNTP)})
    LayerTypeDHCPv4                      = gopacket.RegisterLayerType(118, gopacket.LayerTypeMetadata{Name: "DHCPv4", Decoder: gopacket.DecodeFunc(decodeDHCPv4)})
    LayerTypeVRRP                        = gopacket.RegisterLayerType(119, gopacket.LayerTypeMetadata{Name: "VRRP", Decoder: gopacket.DecodeFunc(decodeVRRP)})
    LayerTypeGeneve                      = gopacket.RegisterLayerType(120, gopacket.LayerTypeMetadata{Name: "Geneve", Decoder: gopacket.DecodeFunc(decodeGeneve)})
    LayerTypeSTP                         = gopacket.RegisterLayerType(121, gopacket.LayerTypeMetadata{Name: "STP", Decoder: gopacket.DecodeFunc(decodeSTP)})
    LayerTypeBFD                         = gopacket.RegisterLayerType(122, gopacket.LayerTypeMetadata{Name: "BFD", Decoder: gopacket.DecodeFunc(decodeBFD)})
    LayerTypeOSPF                        = gopacket.RegisterLayerType(123, gopacket.LayerTypeMetadata{Name: "OSPF", Decoder: gopacket.DecodeFunc(decodeOSPF)})
    LayerTypeICMPv6RouterSolicitation    = gopacket.RegisterLayerType(124, gopacket.LayerTypeMetadata{Name: "ICMPv6RouterSolicitation", Decoder: gopacket.DecodeFunc(decodeICMPv6RouterSolicitation)})
    LayerTypeICMPv6RouterAdvertisement   = gopacket.RegisterLayerType(125, gopacket.LayerTypeMetadata{Name: "ICMPv6RouterAdvertisement", Decoder: gopacket.DecodeFunc(decodeICMPv6RouterAdvertisement)})
    LayerTypeICMPv6NeighborSolicitation  = gopacket.RegisterLayerType(126, gopacket.LayerTypeMetadata{Name: "ICMPv6NeighborSolicitation", Decoder: gopacket.DecodeFunc(decodeICMPv6NeighborSolicitation)})
    LayerTypeICMPv6NeighborAdvertisement = gopacket.RegisterLayerType(127, gopacket.LayerTypeMetadata{Name: "ICMPv6NeighborAdvertisement", Decoder: gopacket.DecodeFunc(decodeICMPv6NeighborAdvertisement)})
    LayerTypeICMPv6Redirect              = gopacket.RegisterLayerType(128, gopacket.LayerTypeMetadata{Name: "ICMPv6Redirect", Decoder: gopacket.DecodeFunc(decodeICMPv6Redirect)})
    LayerTypeGTPv1U                      = gopacket.RegisterLayerType(129, gopacket.LayerTypeMetadata{Name: "GTPv1U", Decoder: gopacket.DecodeFunc(decodeGTPv1u)})
    LayerTypeEAPOLKey                    = gopacket.RegisterLayerType(130, gopacket.LayerTypeMetadata{Name: "EAPOLKey", Decoder: gopacket.DecodeFunc(decodeEAPOLKey)})
    LayerTypeLCM                         = gopacket.RegisterLayerType(131, gopacket.LayerTypeMetadata{Name: "LCM", Decoder: gopacket.DecodeFunc(decodeLCM)})
    LayerTypeICMPv6Echo                  = gopacket.RegisterLayerType(132, gopacket.LayerTypeMetadata{Name: "ICMPv6Echo", Decoder: gopacket.DecodeFunc(decodeICMPv6Echo)})
    LayerTypeSIP                         = gopacket.RegisterLayerType(133, gopacket.LayerTypeMetadata{Name: "SIP", Decoder: gopacket.DecodeFunc(decodeSIP)})
    LayerTypeDHCPv6                      = gopacket.RegisterLayerType(134, gopacket.LayerTypeMetadata{Name: "DHCPv6", Decoder: gopacket.DecodeFunc(decodeDHCPv6)})
)
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,
    })
    // LayerClassICMPv6NDP contains ICMPv6 neighbor discovery protocol
    // messages.
    LayerClassICMPv6NDP = gopacket.NewLayerClass([]gopacket.LayerType{
        LayerTypeICMPv6RouterSolicitation,
        LayerTypeICMPv6RouterAdvertisement,
        LayerTypeICMPv6NeighborSolicitation,
        LayerTypeICMPv6NeighborAdvertisement,
        LayerTypeICMPv6Redirect,
    })
)
var DHCPMagic uint32 = 0x63825363

DHCPMagic is the RFC 2131 "magic cooke" for DHCP.

var Dot11TypeMetadata [256]EnumMetadata
var EAPOLTypeMetadata [256]EnumMetadata
var ErrPrismExpectedMoreData = errors.New("Expected more data.")
var ErrPrismInvalidCode = errors.New("Invalid header code.")
var EthernetBroadcast = net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}

EthernetBroadcast is the broadcast MAC address used by Ethernet.

var EthernetTypeMetadata [65536]EnumMetadata
var FDDIFrameControlMetadata [256]EnumMetadata
var IPProtocolMetadata [256]EnumMetadata
var LinkTypeMetadata [256]EnumMetadata
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.

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.

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.

var PPPTypeMetadata [65536]EnumMetadata
var PPPoECodeMetadata [256]EnumMetadata
var ProtocolFamilyMetadata [256]EnumMetadata
var RUDPPortNames = map[RUDPPort]string{}

RUDPPortNames contains the string names for all RUDP ports.

var SCTPChunkTypeMetadata [256]EnumMetadata
var SCTPPortNames = sctpPortNames

SCTPPortNames contains the port names for all SCTP ports.

var TCPPortNames = tcpPortNames

TCPPortNames contains the port names for all TCP ports.

var UDPLitePortNames = map[UDPLitePort]string{}

UDPLitePortNames contains the string names for all UDPLite ports.

var UDPPortNames = udpPortNames

UDPPortNames contains the port names for all UDP ports.

var USBTransportTypeMetadata [256]EnumMetadata

func GetLCMLayerType Uses

func GetLCMLayerType(fingerprint LCMFingerprint) gopacket.LayerType

GetLCMLayerType returns the underlying LCM message's LayerType. This LayerType has to be registered by using RegisterLCMLayerType.

func NewIPEndpoint Uses

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 Uses

func NewMACEndpoint(a net.HardwareAddr) gopacket.Endpoint

NewMACEndpoint returns a new MAC address endpoint.

func NewRUDPPortEndpoint Uses

func NewRUDPPortEndpoint(p RUDPPort) gopacket.Endpoint

NewRUDPPortEndpoint returns an endpoint based on a RUDP port.

func NewSCTPPortEndpoint Uses

func NewSCTPPortEndpoint(p SCTPPort) gopacket.Endpoint

NewSCTPPortEndpoint returns an endpoint based on a SCTP port.

func NewTCPPortEndpoint Uses

func NewTCPPortEndpoint(p TCPPort) gopacket.Endpoint

NewTCPPortEndpoint returns an endpoint based on a TCP port.

func NewUDPLitePortEndpoint Uses

func NewUDPLitePortEndpoint(p UDPLitePort) gopacket.Endpoint

NewUDPLitePortEndpoint returns an endpoint based on a UDPLite port.

func NewUDPPortEndpoint Uses

func NewUDPPortEndpoint(p UDPPort) gopacket.Endpoint

NewUDPPortEndpoint returns an endpoint based on a UDP port.

func RegisterLCMLayerType Uses

func RegisterLCMLayerType(num int, name string, fingerprint LCMFingerprint,
    decoder gopacket.Decoder) gopacket.LayerType

RegisterLCMLayerType allows users to register decoders for the underlying LCM payload. This is done based on the fingerprint that every LCM message contains and which identifies it uniquely. If num is not the zero value it will be used when registering with RegisterLayerType towards gopacket, otherwise an incremental value starting from 1001 will be used.

func RegisterTCPPortLayerType Uses

func RegisterTCPPortLayerType(port TCPPort, layerType gopacket.LayerType)

RegisterTCPPortLayerType creates a new mapping between a TCPPort and an underlaying LayerType.

func RegisterUDPPortLayerType Uses

func RegisterUDPPortLayerType(port UDPPort, layerType gopacket.LayerType)

RegisterUDPPortLayerType creates a new mapping between a UDPPort and an underlaying LayerType.

type ARP Uses

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 Uses

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

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

func (*ARP) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ARP) LayerType Uses

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

LayerType returns LayerTypeARP

func (*ARP) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ARP) SerializeTo Uses

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 ASExternalLSA Uses

type ASExternalLSA struct {
    Flags             uint8
    Metric            uint32
    PrefixLength      uint8
    PrefixOptions     uint8
    RefLSType         uint16
    AddressPrefix     []byte
    ForwardingAddress []byte
    ExternalRouteTag  uint32
    RefLinkStateID    uint32
}

ASExternalLSA is the struct from RFC 5340 A.4.7.

type ASExternalLSAV2 Uses

type ASExternalLSAV2 struct {
    NetworkMask       uint32
    ExternalBit       uint8
    Metric            uint32
    ForwardingAddress uint32
    ExternalRouteTag  uint32
}

ASExternalLSAV2 is the struct from RFC 2328 A.4.5.

type BFD Uses

type BFD struct {
    BaseLayer // Stores the packet bytes and payload bytes.

    Version                   BFDVersion          // Version of the BFD protocol.
    Diagnostic                BFDDiagnostic       // Diagnostic code for last state change
    State                     BFDState            // Current state
    Poll                      bool                // Requesting verification
    Final                     bool                // Responding to a received BFD Control packet that had the Poll (P) bit set.
    ControlPlaneIndependent   bool                // BFD implementation does not share fate with its control plane
    AuthPresent               bool                // Authentication Section is present and the session is to be authenticated
    Demand                    bool                // Demand mode is active
    Multipoint                bool                // For future point-to-multipoint extensions. Must always be zero
    DetectMultiplier          BFDDetectMultiplier // Detection time multiplier
    MyDiscriminator           BFDDiscriminator    // A unique, nonzero discriminator value
    YourDiscriminator         BFDDiscriminator    // discriminator received from the remote system.
    DesiredMinTxInterval      BFDTimeInterval     // Minimum interval, in microseconds,  the local system would like to use when transmitting BFD Control packets
    RequiredMinRxInterval     BFDTimeInterval     // Minimum interval, in microseconds, between received BFD Control packets that this system is capable of supporting
    RequiredMinEchoRxInterval BFDTimeInterval     // Minimum interval, in microseconds, between received BFD Echo packets that this system is capable of supporting
    AuthHeader                *BFDAuthHeader      // Authentication data, variable length.
}

BFD represents a BFD control message packet whose payload contains the control information required to for a BFD session.

References ----------

Wikipedia's BFD entry:

https://en.wikipedia.org/wiki/Bidirectional_Forwarding_Detection
This is the best place to get an overview of BFD.

RFC 5880 "Bidirectional Forwarding Detection (BFD)" (2010)

https://tools.ietf.org/html/rfc5880
This is the original BFD specification.

RFC 5881 "Bidirectional Forwarding Detection (BFD) for IPv4 and IPv6 (Single Hop)" (2010)

https://tools.ietf.org/html/rfc5881
Describes the use of the Bidirectional Forwarding Detection (BFD)
protocol over IPv4 and IPv6 for single IP hops.

func (*BFD) CanDecode Uses

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

CanDecode returns a set of layers that BFD objects can decode. As BFD objects can only decide the BFD layer, we can return just that layer. Apparently a single layer type implements LayerClass.

func (*BFD) DecodeFromBytes Uses

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

DecodeFromBytes analyses a byte slice and attempts to decode it as a BFD control packet.

Upon succeeds, it loads the BFD object with information about the packet and returns nil. Upon failure, it returns an error (non nil).

func (*BFD) LayerType Uses

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

LayerType returns the layer type of the BFD object, which is LayerTypeBFD.

func (*BFD) Length Uses

func (d *BFD) Length() int

Length returns the data length of a BFD Control message which changes based on the presence and type of authentication contained in the message

func (*BFD) NextLayerType Uses

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

NextLayerType specifies the next layer that GoPacket should attempt to analyse after this (BFD) layer. As BFD packets do not contain any payload bytes, there are no further layers to analyse.

func (*BFD) Payload Uses

func (d *BFD) Payload() []byte

Payload returns an empty byte slice as BFD packets do not carry a payload

func (*BFD) SerializeTo Uses

func (d *BFD) 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 BFDAuthData Uses

type BFDAuthData []byte

BFDAuthData represents the authentication key or digest

type BFDAuthHeader Uses

type BFDAuthHeader struct {
    AuthType       BFDAuthType
    KeyID          BFDAuthKeyID
    SequenceNumber BFDAuthSequenceNumber
    Data           BFDAuthData
}

BFDAuthHeader represents authentication data used in the BFD session

func (*BFDAuthHeader) Length Uses

func (h *BFDAuthHeader) Length() int

Length returns the data length of the BFDAuthHeader based on the authentication type

type BFDAuthKeyID Uses

type BFDAuthKeyID uint8

BFDAuthKeyID represents the authentication key ID in use for this packet. This allows multiple keys to be active simultaneously.

type BFDAuthSequenceNumber Uses

type BFDAuthSequenceNumber uint32

BFDAuthSequenceNumber represents the sequence number for this packet. For Keyed Authentication, this value is incremented occasionally. For Meticulous Keyed Authentication, this value is incremented for each successive packet transmitted for a session. This provides protection against replay attacks.

type BFDAuthType Uses

type BFDAuthType uint8

BFDAuthType represents the authentication used in the BFD session

const (
    BFDAuthTypeNone                BFDAuthType = 0 // No Auth
    BFDAuthTypePassword            BFDAuthType = 1 // Simple Password
    BFDAuthTypeKeyedMD5            BFDAuthType = 2 // Keyed MD5
    BFDAuthTypeMeticulousKeyedMD5  BFDAuthType = 3 // Meticulous Keyed MD5
    BFDAuthTypeKeyedSHA1           BFDAuthType = 4 // Keyed SHA1
    BFDAuthTypeMeticulousKeyedSHA1 BFDAuthType = 5 // Meticulous Keyed SHA1
)

constants that define the BFDAuthType

func (BFDAuthType) String Uses

func (at BFDAuthType) String() string

String returns a string version of BFDAuthType

type BFDDetectMultiplier Uses

type BFDDetectMultiplier uint8

BFDDetectMultiplier represents the negotiated transmit interval, multiplied by this value, provides the Detection Time for the receiving system in Asynchronous mode.

type BFDDiagnostic Uses

type BFDDiagnostic uint8

BFDDiagnostic represents diagnostic infomation about a BFD session

const (
    BFDDiagnosticNone               BFDDiagnostic = 0 // No Diagnostic
    BFDDiagnosticTimeExpired        BFDDiagnostic = 1 // Control Detection Time Expired
    BFDDiagnosticEchoFailed         BFDDiagnostic = 2 // Echo Function Failed
    BFDDiagnosticNeighborSignalDown BFDDiagnostic = 3 // Neighbor Signaled Session Down
    BFDDiagnosticForwardPlaneReset  BFDDiagnostic = 4 // Forwarding Plane Reset
    BFDDiagnosticPathDown           BFDDiagnostic = 5 // Path Down
    BFDDiagnosticConcatPathDown     BFDDiagnostic = 6 // Concatenated Path Down
    BFDDiagnosticAdminDown          BFDDiagnostic = 7 // Administratively Down
    BFDDiagnosticRevConcatPathDown  BFDDiagnostic = 8 // Reverse Concatenated Path Dow
)

constants that define BFDDiagnostic flags

func (BFDDiagnostic) String Uses

func (bd BFDDiagnostic) String() string

String returns a string version of BFDDiagnostic

type BFDDiscriminator Uses

type BFDDiscriminator uint32

BFDDiscriminator is a unique, nonzero discriminator value used to demultiplex multiple BFD sessions between the same pair of systems.

type BFDState Uses

type BFDState uint8

BFDState represents the state of a BFD session

const (
    BFDStateAdminDown BFDState = 0
    BFDStateDown      BFDState = 1
    BFDStateInit      BFDState = 2
    BFDStateUp        BFDState = 3
)

constants that define BFDState

func (BFDState) String Uses

func (s BFDState) String() string

String returns a string version of BFDState

type BFDTimeInterval Uses

type BFDTimeInterval uint32

BFDTimeInterval represents a time interval in microseconds

type BFDVersion Uses

type BFDVersion uint8

BFDVersion represents the version as decoded from the BFD control message

type BaseLayer Uses

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 Uses

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

LayerContents returns the bytes of the packet layer.

func (*BaseLayer) LayerPayload Uses

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

LayerPayload returns the bytes contained within the packet layer.

type CDPAddressType Uses

type CDPAddressType uint64

CDPAddressType is used to define TLV values within CDP addresses.

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 Uses

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

type CDPCapabilities Uses

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 Uses

type CDPCapability uint32

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

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
)

CDPCapability values.

type CDPEnergyWise Uses

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
}

CDPEnergyWise is used by CDP to monitor and control power usage.

type CDPEnergyWiseSubtype Uses

type CDPEnergyWiseSubtype uint32

CDPEnergyWiseSubtype is used within CDP to define TLV values.

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

CDPEnergyWiseSubtype values.

func (CDPEnergyWiseSubtype) String Uses

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

type CDPHello Uses

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 Uses

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

CDPLocation provides location information for a CDP device.

type CDPPowerDialogue Uses

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

CDPPowerDialogue encapsulates a Power Query/Reply

type CDPSparePairPoE Uses

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

CDPSparePairPoE provides information on PoE.

type CDPTLVType Uses

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
)

CDPTLVType values.

func (CDPTLVType) String Uses

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

type CDPVLANDialogue Uses

type CDPVLANDialogue struct {
    ID   uint8
    VLAN uint16
}

CDPVLANDialogue encapsulates a VLAN Query/Reply

type CiscoDiscovery Uses

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 Uses

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

LayerType returns gopacket.LayerTypeCiscoDiscovery.

type CiscoDiscoveryInfo Uses

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 Uses

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

LayerType returns gopacket.LayerTypeCiscoDiscoveryInfo.

type CiscoDiscoveryValue Uses

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

CiscoDiscoveryValue is a TLV value inside a CiscoDiscovery packet layer.

type DHCPMsgType Uses

type DHCPMsgType byte

DHCPMsgType represents a DHCP operation

const (
    DHCPMsgTypeUnspecified DHCPMsgType = iota
    DHCPMsgTypeDiscover
    DHCPMsgTypeOffer
    DHCPMsgTypeRequest
    DHCPMsgTypeDecline
    DHCPMsgTypeAck
    DHCPMsgTypeNak
    DHCPMsgTypeRelease
    DHCPMsgTypeInform
)

Constants that represent DHCP operations

func (DHCPMsgType) String Uses

func (o DHCPMsgType) String() string

String returns a string version of a DHCPMsgType.

type DHCPOp Uses

type DHCPOp byte

DHCPOp rerprents a bootp operation

const (
    DHCPOpRequest DHCPOp = 1
    DHCPOpReply   DHCPOp = 2
)

bootp operations

func (DHCPOp) String Uses

func (o DHCPOp) String() string

String returns a string version of a DHCPOp.

type DHCPOpt Uses

type DHCPOpt byte

DHCPOpt represents a DHCP option or parameter from RFC-2132

const (
    DHCPOptPad                   DHCPOpt = 0
    DHCPOptSubnetMask            DHCPOpt = 1   // 4, net.IP
    DHCPOptTimeOffset            DHCPOpt = 2   // 4, int32 (signed seconds from UTC)
    DHCPOptRouter                DHCPOpt = 3   // n*4, [n]net.IP
    DHCPOptTimeServer            DHCPOpt = 4   // n*4, [n]net.IP
    DHCPOptNameServer            DHCPOpt = 5   // n*4, [n]net.IP
    DHCPOptDNS                   DHCPOpt = 6   // n*4, [n]net.IP
    DHCPOptLogServer             DHCPOpt = 7   // n*4, [n]net.IP
    DHCPOptCookieServer          DHCPOpt = 8   // n*4, [n]net.IP
    DHCPOptLPRServer             DHCPOpt = 9   // n*4, [n]net.IP
    DHCPOptImpressServer         DHCPOpt = 10  // n*4, [n]net.IP
    DHCPOptResLocServer          DHCPOpt = 11  // n*4, [n]net.IP
    DHCPOptHostname              DHCPOpt = 12  // n, string
    DHCPOptBootfileSize          DHCPOpt = 13  // 2, uint16
    DHCPOptMeritDumpFile         DHCPOpt = 14  // >1, string
    DHCPOptDomainName            DHCPOpt = 15  // n, string
    DHCPOptSwapServer            DHCPOpt = 16  // n*4, [n]net.IP
    DHCPOptRootPath              DHCPOpt = 17  // n, string
    DHCPOptExtensionsPath        DHCPOpt = 18  // n, string
    DHCPOptIPForwarding          DHCPOpt = 19  // 1, bool
    DHCPOptSourceRouting         DHCPOpt = 20  // 1, bool
    DHCPOptPolicyFilter          DHCPOpt = 21  // 8*n, [n]{net.IP/net.IP}
    DHCPOptDatagramMTU           DHCPOpt = 22  // 2, uint16
    DHCPOptDefaultTTL            DHCPOpt = 23  // 1, byte
    DHCPOptPathMTUAgingTimeout   DHCPOpt = 24  // 4, uint32
    DHCPOptPathPlateuTableOption DHCPOpt = 25  // 2*n, []uint16
    DHCPOptInterfaceMTU          DHCPOpt = 26  // 2, uint16
    DHCPOptAllSubsLocal          DHCPOpt = 27  // 1, bool
    DHCPOptBroadcastAddr         DHCPOpt = 28  // 4, net.IP
    DHCPOptMaskDiscovery         DHCPOpt = 29  // 1, bool
    DHCPOptMaskSupplier          DHCPOpt = 30  // 1, bool
    DHCPOptRouterDiscovery       DHCPOpt = 31  // 1, bool
    DHCPOptSolicitAddr           DHCPOpt = 32  // 4, net.IP
    DHCPOptStaticRoute           DHCPOpt = 33  // n*8, [n]{net.IP/net.IP} -- note the 2nd is router not mask
    DHCPOptARPTrailers           DHCPOpt = 34  // 1, bool
    DHCPOptARPTimeout            DHCPOpt = 35  // 4, uint32
    DHCPOptEthernetEncap         DHCPOpt = 36  // 1, bool
    DHCPOptTCPTTL                DHCPOpt = 37  // 1, byte
    DHCPOptTCPKeepAliveInt       DHCPOpt = 38  // 4, uint32
    DHCPOptTCPKeepAliveGarbage   DHCPOpt = 39  // 1, bool
    DHCPOptNISDomain             DHCPOpt = 40  // n, string
    DHCPOptNISServers            DHCPOpt = 41  // 4*n,  [n]net.IP
    DHCPOptNTPServers            DHCPOpt = 42  // 4*n, [n]net.IP
    DHCPOptVendorOption          DHCPOpt = 43  // n, [n]byte // may be encapsulated.
    DHCPOptNetBIOSTCPNS          DHCPOpt = 44  // 4*n, [n]net.IP
    DHCPOptNetBIOSTCPDDS         DHCPOpt = 45  // 4*n, [n]net.IP
    DHCPOptNETBIOSTCPNodeType    DHCPOpt = 46  // 1, magic byte
    DHCPOptNetBIOSTCPScope       DHCPOpt = 47  // n, string
    DHCPOptXFontServer           DHCPOpt = 48  // n, string
    DHCPOptXDisplayManager       DHCPOpt = 49  // n, string
    DHCPOptRequestIP             DHCPOpt = 50  // 4, net.IP
    DHCPOptLeaseTime             DHCPOpt = 51  // 4, uint32
    DHCPOptExtOptions            DHCPOpt = 52  // 1, 1/2/3
    DHCPOptMessageType           DHCPOpt = 53  // 1, 1-7
    DHCPOptServerID              DHCPOpt = 54  // 4, net.IP
    DHCPOptParamsRequest         DHCPOpt = 55  // n, []byte
    DHCPOptMessage               DHCPOpt = 56  // n, 3
    DHCPOptMaxMessageSize        DHCPOpt = 57  // 2, uint16
    DHCPOptT1                    DHCPOpt = 58  // 4, uint32
    DHCPOptT2                    DHCPOpt = 59  // 4, uint32
    DHCPOptClassID               DHCPOpt = 60  // n, []byte
    DHCPOptClientID              DHCPOpt = 61  // n >=  2, []byte
    DHCPOptDomainSearch          DHCPOpt = 119 // n, string
    DHCPOptSIPServers            DHCPOpt = 120 // n, url
    DHCPOptClasslessStaticRoute  DHCPOpt = 121 //
    DHCPOptEnd                   DHCPOpt = 255
)

Constants for the DHCPOpt options.

func (DHCPOpt) String Uses

func (o DHCPOpt) String() string

String returns a string version of a DHCPOpt.

type DHCPOption Uses

type DHCPOption struct {
    Type   DHCPOpt
    Length uint8
    Data   []byte
}

DHCPOption rerpresents a DHCP option.

func NewDHCPOption Uses

func NewDHCPOption(t DHCPOpt, data []byte) DHCPOption

NewDHCPOption constructs a new DHCPOption with a given type and data.

func (DHCPOption) String Uses

func (o DHCPOption) String() string

String returns a string version of a DHCP Option.

type DHCPOptions Uses

type DHCPOptions []DHCPOption

DHCPOptions is used to get nicely printed option lists which would normally be cut off after 5 options.

func (DHCPOptions) String Uses

func (o DHCPOptions) String() string

String returns a string version of the options list.

type DHCPv4 Uses

type DHCPv4 struct {
    BaseLayer
    Operation    DHCPOp
    HardwareType LinkType
    HardwareLen  uint8
    HardwareOpts uint8
    Xid          uint32
    Secs         uint16
    Flags        uint16
    ClientIP     net.IP
    YourClientIP net.IP
    NextServerIP net.IP
    RelayAgentIP net.IP
    ClientHWAddr net.HardwareAddr
    ServerName   []byte
    File         []byte
    Options      DHCPOptions
}

DHCPv4 contains data for a single DHCP packet.

func (*DHCPv4) CanDecode Uses

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

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

func (*DHCPv4) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*DHCPv4) LayerType Uses

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

LayerType returns gopacket.LayerTypeDHCPv4

func (*DHCPv4) Len Uses

func (d *DHCPv4) Len() uint16

Len returns the length of a DHCPv4 packet.

func (*DHCPv4) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*DHCPv4) SerializeTo Uses

func (d *DHCPv4) 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 DHCPv4Error Uses

type DHCPv4Error string

DHCPv4Error is used for constant errors for DHCPv4. It is needed for test asserts.

func (DHCPv4Error) Error Uses

func (d DHCPv4Error) Error() string

DHCPv4Error implements error interface.

type DHCPv6 Uses

type DHCPv6 struct {
    BaseLayer
    MsgType       DHCPv6MsgType
    HopCount      uint8
    LinkAddr      net.IP
    PeerAddr      net.IP
    TransactionID []byte
    Options       DHCPv6Options
}

DHCPv6 contains data for a single DHCP packet.

func (*DHCPv6) CanDecode Uses

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

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

func (*DHCPv6) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*DHCPv6) LayerType Uses

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

LayerType returns gopacket.LayerTypeDHCPv6

func (*DHCPv6) Len Uses

func (d *DHCPv6) Len() int

Len returns the length of a DHCPv6 packet.

func (*DHCPv6) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*DHCPv6) SerializeTo Uses

func (d *DHCPv6) 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 DHCPv6DUID Uses

type DHCPv6DUID struct {
    Type DHCPv6DUIDType
    // LLT, LL
    HardwareType []byte
    // EN
    EnterpriseNumber []byte
    // LLT
    Time []byte
    // LLT, LL
    LinkLayerAddress net.HardwareAddr
    // EN
    Identifier []byte
}

DHCPv6DUID means DHCP Unique Identifier as stated in RFC 3315, section 9 (https://tools.ietf.org/html/rfc3315#page-19)

func (*DHCPv6DUID) DecodeFromBytes Uses

func (d *DHCPv6DUID) DecodeFromBytes(data []byte) error

DecodeFromBytes decodes the given bytes into a DHCPv6DUID

func (*DHCPv6DUID) Encode Uses

func (d *DHCPv6DUID) Encode() []byte

Encode encodes the DHCPv6DUID in a slice of bytes

func (*DHCPv6DUID) Len Uses

func (d *DHCPv6DUID) Len() int

Len returns the length of the DHCPv6DUID, respecting the type

func (*DHCPv6DUID) String Uses

func (d *DHCPv6DUID) String() string

type DHCPv6DUIDType Uses

type DHCPv6DUIDType uint16

DHCPv6DUIDType represents a DHCP DUID - RFC-3315

const (
    DHCPv6DUIDTypeLLT DHCPv6DUIDType = iota + 1
    DHCPv6DUIDTypeEN
    DHCPv6DUIDTypeLL
)

Constants for the DHCPv6DUIDType.

func (DHCPv6DUIDType) String Uses

func (o DHCPv6DUIDType) String() string

String returns a string version of a DHCPv6DUIDType.

type DHCPv6MsgType Uses

type DHCPv6MsgType byte

DHCPv6MsgType represents a DHCPv6 operation

const (
    DHCPv6MsgTypeUnspecified DHCPv6MsgType = iota
    DHCPv6MsgTypeSolicit
    DHCPv6MsgTypeAdverstise
    DHCPv6MsgTypeRequest
    DHCPv6MsgTypeConfirm
    DHCPv6MsgTypeRenew
    DHCPv6MsgTypeRebind
    DHCPv6MsgTypeReply
    DHCPv6MsgTypeRelease
    DHCPv6MsgTypeDecline
    DHCPv6MsgTypeReconfigure
    DHCPv6MsgTypeInformationRequest
    DHCPv6MsgTypeRelayForward
    DHCPv6MsgTypeRelayReply
)

Constants that represent DHCP operations

func (DHCPv6MsgType) String Uses

func (o DHCPv6MsgType) String() string

String returns a string version of a DHCPv6MsgType.

type DHCPv6Opt Uses

type DHCPv6Opt uint16

DHCPv6Opt represents a DHCP option or parameter from RFC-3315

const (
    DHCPv6OptClientID           DHCPv6Opt = 1
    DHCPv6OptServerID           DHCPv6Opt = 2
    DHCPv6OptIANA               DHCPv6Opt = 3
    DHCPv6OptIATA               DHCPv6Opt = 4
    DHCPv6OptIAAddr             DHCPv6Opt = 5
    DHCPv6OptOro                DHCPv6Opt = 6
    DHCPv6OptPreference         DHCPv6Opt = 7
    DHCPv6OptElapsedTime        DHCPv6Opt = 8
    DHCPv6OptRelayMessage       DHCPv6Opt = 9
    DHCPv6OptAuth               DHCPv6Opt = 11
    DHCPv6OptUnicast            DHCPv6Opt = 12
    DHCPv6OptStatusCode         DHCPv6Opt = 13
    DHCPv6OptRapidCommit        DHCPv6Opt = 14
    DHCPv6OptUserClass          DHCPv6Opt = 15
    DHCPv6OptVendorClass        DHCPv6Opt = 16
    DHCPv6OptVendorOpts         DHCPv6Opt = 17
    DHCPv6OptInterfaceID        DHCPv6Opt = 18
    DHCPv6OptReconfigureMessage DHCPv6Opt = 19
    DHCPv6OptReconfigureAccept  DHCPv6Opt = 20
)

Constants for the DHCPv6Opt options.

func (DHCPv6Opt) String Uses

func (o DHCPv6Opt) String() string

String returns a string version of a DHCPv6Opt.

type DHCPv6Option Uses

type DHCPv6Option struct {
    Code   DHCPv6Opt
    Length uint16
    Data   []byte
}

DHCPv6Option rerpresents a DHCP option.

func NewDHCPv6Option Uses

func NewDHCPv6Option(code DHCPv6Opt, data []byte) DHCPv6Option

NewDHCPv6Option constructs a new DHCPv6Option with a given type and data.

func (DHCPv6Option) String Uses

func (o DHCPv6Option) String() string

String returns a string version of a DHCP Option.

type DHCPv6Options Uses

type DHCPv6Options []DHCPv6Option

DHCPv6Options is used to get nicely printed option lists which would normally be cut off after 5 options.

func (DHCPv6Options) String Uses

func (o DHCPv6Options) String() string

String returns a string version of the options list.

type DHCPv6StatusCode Uses

type DHCPv6StatusCode byte

DHCPv6StatusCode represents a DHCP status code - RFC-3315

const (
    DHCPv6StatusCodeSuccess DHCPv6StatusCode = iota
    DHCPv6StatusCodeUnspecFail
    DHCPv6StatusCodeNoAddrsAvail
    DHCPv6StatusCodeNoBinding
    DHCPv6StatusCodeNotOnLink
    DHCPv6StatusCodeUseMulticast
)

Constants for the DHCPv6StatusCode.

func (DHCPv6StatusCode) String Uses

func (o DHCPv6StatusCode) String() string

String returns a string version of a DHCPv6StatusCode.

type DNS Uses

type DNS struct {
    BaseLayer

    // Header fields
    ID     uint16
    QR     bool
    OpCode DNSOpCode

    AA  bool  // Authoritative answer
    TC  bool  // Truncated
    RD  bool  // Recursion desired
    RA  bool  // Recursion available
    Z   uint8 // Reserved for future use

    ResponseCode DNSResponseCode
    QDCount      uint16 // Number of questions to expect
    ANCount      uint16 // Number of answers to expect
    NSCount      uint16 // Number of authorities to expect
    ARCount      uint16 // Number of additional records to expect

    // Entries
    Questions   []DNSQuestion
    Answers     []DNSResourceRecord
    Authorities []DNSResourceRecord
    Additionals []DNSResourceRecord
    // contains filtered or unexported fields
}

DNS contains data from a single Domain Name Service packet.

func (*DNS) CanDecode Uses

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

CanDecode implements gopacket.DecodingLayer.

func (*DNS) DecodeFromBytes Uses

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

DecodeFromBytes decodes the slice into the DNS struct.

func (*DNS) LayerType Uses

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

LayerType returns gopacket.LayerTypeDNS.

func (*DNS) NextLayerType Uses

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

NextLayerType implements gopacket.DecodingLayer.

func (*DNS) Payload Uses

func (d *DNS) Payload() []byte

Payload returns nil.

func (*DNS) SerializeTo Uses

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

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

type DNSClass Uses

type DNSClass uint16

DNSClass defines the class associated with a request/response. Different DNS classes can be thought of as an array of parallel namespace trees.

const (
    DNSClassIN  DNSClass = 1   // Internet
    DNSClassCS  DNSClass = 2   // the CSNET class (Obsolete)
    DNSClassCH  DNSClass = 3   // the CHAOS class
    DNSClassHS  DNSClass = 4   // Hesiod [Dyer 87]
    DNSClassAny DNSClass = 255 // AnyClass
)

DNSClass known values.

func (DNSClass) String Uses

func (dc DNSClass) String() string

type DNSMX Uses

type DNSMX struct {
    Preference uint16
    Name       []byte
}

DNSMX is a mail exchange record, defining a mail server for a recipient's domain.

type DNSOpCode Uses

type DNSOpCode uint8

DNSOpCode defines a set of different operation types.

const (
    DNSOpCodeQuery  DNSOpCode = 0 // Query                  [RFC1035]
    DNSOpCodeIQuery DNSOpCode = 1 // Inverse Query Obsolete [RFC3425]
    DNSOpCodeStatus DNSOpCode = 2 // Status                 [RFC1035]
    DNSOpCodeNotify DNSOpCode = 4 // Notify                 [RFC1996]
    DNSOpCodeUpdate DNSOpCode = 5 // Update                 [RFC2136]
)

DNSOpCode known values.

func (DNSOpCode) String Uses

func (doc DNSOpCode) String() string

type DNSQuestion Uses

type DNSQuestion struct {
    Name  []byte
    Type  DNSType
    Class DNSClass
}

DNSQuestion wraps a single request (question) within a DNS query.

type DNSResourceRecord Uses

type DNSResourceRecord struct {
    // Header
    Name  []byte
    Type  DNSType
    Class DNSClass
    TTL   uint32

    // RDATA Raw Values
    DataLength uint16
    Data       []byte

    // RDATA Decoded Values
    IP             net.IP
    NS, CNAME, PTR []byte
    TXTs           [][]byte
    SOA            DNSSOA
    SRV            DNSSRV
    MX             DNSMX

    // Undecoded TXT for backward compatibility
    TXT []byte
}

DNSResourceRecord wraps the data from a single DNS resource within a response.

func (*DNSResourceRecord) String Uses

func (rr *DNSResourceRecord) String() string

type DNSResponseCode Uses

type DNSResponseCode uint8

DNSResponseCode provides response codes for question answers.

const (
    DNSResponseCodeNoErr    DNSResponseCode = 0  // No error
    DNSResponseCodeFormErr  DNSResponseCode = 1  // Format Error                       [RFC1035]
    DNSResponseCodeServFail DNSResponseCode = 2  // Server Failure                     [RFC1035]
    DNSResponseCodeNXDomain DNSResponseCode = 3  // Non-Existent Domain                [RFC1035]
    DNSResponseCodeNotImp   DNSResponseCode = 4  // Not Implemented                    [RFC1035]
    DNSResponseCodeRefused  DNSResponseCode = 5  // Query Refused                      [RFC1035]
    DNSResponseCodeYXDomain DNSResponseCode = 6  // Name Exists when it should not     [RFC2136]
    DNSResponseCodeYXRRSet  DNSResponseCode = 7  // RR Set Exists when it should not   [RFC2136]
    DNSResponseCodeNXRRSet  DNSResponseCode = 8  // RR Set that should exist does not  [RFC2136]
    DNSResponseCodeNotAuth  DNSResponseCode = 9  // Server Not Authoritative for zone  [RFC2136]
    DNSResponseCodeNotZone  DNSResponseCode = 10 // Name not contained in zone         [RFC2136]
    DNSResponseCodeBadVers  DNSResponseCode = 16 // Bad OPT Version                    [RFC2671]
    DNSResponseCodeBadSig   DNSResponseCode = 16 // TSIG Signature Failure             [RFC2845]
    DNSResponseCodeBadKey   DNSResponseCode = 17 // Key not recognized                 [RFC2845]
    DNSResponseCodeBadTime  DNSResponseCode = 18 // Signature out of time window       [RFC2845]
    DNSResponseCodeBadMode  DNSResponseCode = 19 // Bad TKEY Mode                      [RFC2930]
    DNSResponseCodeBadName  DNSResponseCode = 20 // Duplicate key name                 [RFC2930]
    DNSResponseCodeBadAlg   DNSResponseCode = 21 // Algorithm not supported            [RFC2930]
    DNSResponseCodeBadTruc  DNSResponseCode = 22 // Bad Truncation                     [RFC4635]
)

DNSResponseCode known values.

func (DNSResponseCode) String Uses

func (drc DNSResponseCode) String() string

type DNSSOA Uses

type DNSSOA struct {
    MName, RName                            []byte
    Serial, Refresh, Retry, Expire, Minimum uint32
}

DNSSOA is a Start of Authority record. Each domain requires a SOA record at the cutover where a domain is delegated from its parent.

type DNSSRV Uses

type DNSSRV struct {
    Priority, Weight, Port uint16
    Name                   []byte
}

DNSSRV is a Service record, defining a location (hostname/port) of a server/service.

type DNSType Uses

type DNSType uint16

DNSType defines the type of data being requested/returned in a question/answer.

const (
    DNSTypeA     DNSType = 1  // a host address
    DNSTypeNS    DNSType = 2  // an authoritative name server
    DNSTypeMD    DNSType = 3  // a mail destination (Obsolete - use MX)
    DNSTypeMF    DNSType = 4  // a mail forwarder (Obsolete - use MX)
    DNSTypeCNAME DNSType = 5  // the canonical name for an alias
    DNSTypeSOA   DNSType = 6  // marks the start of a zone of authority
    DNSTypeMB    DNSType = 7  // a mailbox domain name (EXPERIMENTAL)
    DNSTypeMG    DNSType = 8  // a mail group member (EXPERIMENTAL)
    DNSTypeMR    DNSType = 9  // a mail rename domain name (EXPERIMENTAL)
    DNSTypeNULL  DNSType = 10 // a null RR (EXPERIMENTAL)
    DNSTypeWKS   DNSType = 11 // a well known service description
    DNSTypePTR   DNSType = 12 // a domain name pointer
    DNSTypeHINFO DNSType = 13 // host information
    DNSTypeMINFO DNSType = 14 // mailbox or mail list information
    DNSTypeMX    DNSType = 15 // mail exchange
    DNSTypeTXT   DNSType = 16 // text strings
    DNSTypeAAAA  DNSType = 28 // a IPv6 host address [RFC3596]
    DNSTypeSRV   DNSType = 33 // server discovery [RFC2782] [RFC6195]
)

DNSType known values.

func (DNSType) String Uses

func (dt DNSType) String() string

type DbDescPkg Uses

type DbDescPkg struct {
    Options      uint32
    InterfaceMTU uint16
    Flags        uint16
    DDSeqNumber  uint32
    LSAinfo      []LSAheader
}

DbDescPkg is the struct from RFC 5340 A.3.3.

type Dot11 Uses

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
    QOS            *Dot11QOS
    HTControl      *Dot11HTControl
    DataLayer      gopacket.Layer
}

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

func (*Dot11) CanDecode Uses

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

func (*Dot11) ChecksumValid Uses

func (m *Dot11) ChecksumValid() bool

func (*Dot11) DecodeFromBytes Uses

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

func (*Dot11) LayerType Uses

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

func (*Dot11) NextLayerType Uses

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

func (Dot11) SerializeTo Uses

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

type Dot11ASEL Uses

type Dot11ASEL struct {
    Command uint8
    Data    uint8
}

type Dot11AckPolicy Uses

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

func (Dot11AckPolicy) String Uses

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 Uses

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

func (Dot11Algorithm) String Uses

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 Dot11CodingType Uses

type Dot11CodingType uint8

func (Dot11CodingType) String Uses

func (a Dot11CodingType) String() string

type Dot11Ctrl Uses

type Dot11Ctrl struct {
    BaseLayer
}

Dot11Ctrl is a base for all IEEE 802.11 control layers.

func (*Dot11Ctrl) CanDecode Uses

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

func (*Dot11Ctrl) DecodeFromBytes Uses

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

func (*Dot11Ctrl) LayerType Uses

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

func (*Dot11Ctrl) NextLayerType Uses

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

type Dot11CtrlAck Uses

type Dot11CtrlAck struct {
    Dot11Ctrl
}

func (*Dot11CtrlAck) CanDecode Uses

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

func (*Dot11CtrlAck) DecodeFromBytes Uses

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

func (*Dot11CtrlAck) LayerType Uses

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

type Dot11CtrlBlockAck Uses

type Dot11CtrlBlockAck struct {
    Dot11Ctrl
}

func (*Dot11CtrlBlockAck) CanDecode Uses

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

func (*Dot11CtrlBlockAck) DecodeFromBytes Uses

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

func (*Dot11CtrlBlockAck) LayerType Uses

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

type Dot11CtrlBlockAckReq Uses

type Dot11CtrlBlockAckReq struct {
    Dot11Ctrl
}

func (*Dot11CtrlBlockAckReq) CanDecode Uses

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

func (*Dot11CtrlBlockAckReq) DecodeFromBytes Uses

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

func (*Dot11CtrlBlockAckReq) LayerType Uses

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

type Dot11CtrlCFEnd Uses

type Dot11CtrlCFEnd struct {
    Dot11Ctrl
}

func (*Dot11CtrlCFEnd) CanDecode Uses

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

func (*Dot11CtrlCFEnd) DecodeFromBytes Uses

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

func (*Dot11CtrlCFEnd) LayerType Uses

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

type Dot11CtrlCFEndAck Uses

type Dot11CtrlCFEndAck struct {
    Dot11Ctrl
}

func (*Dot11CtrlCFEndAck) CanDecode Uses

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

func (*Dot11CtrlCFEndAck) DecodeFromBytes Uses

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

func (*Dot11CtrlCFEndAck) LayerType Uses

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

type Dot11CtrlCTS Uses

type Dot11CtrlCTS struct {
    Dot11Ctrl
}

func (*Dot11CtrlCTS) CanDecode Uses

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

func (*Dot11CtrlCTS) DecodeFromBytes Uses

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

func (*Dot11CtrlCTS) LayerType Uses

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

type Dot11CtrlPowersavePoll Uses

type Dot11CtrlPowersavePoll struct {
    Dot11Ctrl
}

func (*Dot11CtrlPowersavePoll) CanDecode Uses

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

func (*Dot11CtrlPowersavePoll) DecodeFromBytes Uses

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

func (*Dot11CtrlPowersavePoll) LayerType Uses

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

type Dot11CtrlRTS Uses

type Dot11CtrlRTS struct {
    Dot11Ctrl
}

func (*Dot11CtrlRTS) CanDecode Uses

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

func (*Dot11CtrlRTS) DecodeFromBytes Uses

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

func (*Dot11CtrlRTS) LayerType Uses

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

type Dot11Data Uses

type Dot11Data struct {
    BaseLayer
}

Dot11Data is a base for all IEEE 802.11 data layers.

func (*Dot11Data) CanDecode Uses

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

func (*Dot11Data) DecodeFromBytes Uses

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

func (*Dot11Data) LayerType Uses

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

func (*Dot11Data) NextLayerType Uses

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

type Dot11DataCFAck Uses

type Dot11DataCFAck struct {
    Dot11Data
}

func (*Dot11DataCFAck) CanDecode Uses

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

func (*Dot11DataCFAck) DecodeFromBytes Uses

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

func (*Dot11DataCFAck) LayerType Uses

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

type Dot11DataCFAckNoData Uses

type Dot11DataCFAckNoData struct {
    Dot11Data
}

func (*Dot11DataCFAckNoData) CanDecode Uses

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

func (*Dot11DataCFAckNoData) DecodeFromBytes Uses

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

func (*Dot11DataCFAckNoData) LayerType Uses

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

type Dot11DataCFAckPoll Uses

type Dot11DataCFAckPoll struct {
    Dot11Data
}

func (*Dot11DataCFAckPoll) CanDecode Uses

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

func (*Dot11DataCFAckPoll) DecodeFromBytes Uses

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

func (*Dot11DataCFAckPoll) LayerType Uses

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

type Dot11DataCFAckPollNoData Uses

type Dot11DataCFAckPollNoData struct {
    Dot11Data
}

func (*Dot11DataCFAckPollNoData) CanDecode Uses

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

func (*Dot11DataCFAckPollNoData) DecodeFromBytes Uses

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

func (*Dot11DataCFAckPollNoData) LayerType Uses

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

type Dot11DataCFPoll Uses

type Dot11DataCFPoll struct {
    Dot11Data
}

func (*Dot11DataCFPoll) CanDecode Uses

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

func (*Dot11DataCFPoll) DecodeFromBytes Uses

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

func (*Dot11DataCFPoll) LayerType Uses

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

type Dot11DataCFPollNoData Uses

type Dot11DataCFPollNoData struct {
    Dot11Data
}

func (*Dot11DataCFPollNoData) CanDecode Uses

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

func (*Dot11DataCFPollNoData) DecodeFromBytes Uses

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

func (*Dot11DataCFPollNoData) LayerType Uses

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

type Dot11DataNull Uses

type Dot11DataNull struct {
    Dot11Data
}

func (*Dot11DataNull) CanDecode Uses

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

func (*Dot11DataNull) DecodeFromBytes Uses

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

func (*Dot11DataNull) LayerType Uses

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

type Dot11DataQOS Uses

type Dot11DataQOS struct {
    Dot11Ctrl
}

func (*Dot11DataQOS) DecodeFromBytes Uses

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

type Dot11DataQOSCFAckPollNoData Uses

type Dot11DataQOSCFAckPollNoData struct {
    Dot11DataQOS
}

func (*Dot11DataQOSCFAckPollNoData) CanDecode Uses

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

func (*Dot11DataQOSCFAckPollNoData) LayerType Uses

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

func (*Dot11DataQOSCFAckPollNoData) NextLayerType Uses

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

type Dot11DataQOSCFPollNoData Uses

type Dot11DataQOSCFPollNoData struct {
    Dot11DataQOS
}

func (*Dot11DataQOSCFPollNoData) CanDecode Uses

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

func (*Dot11DataQOSCFPollNoData) LayerType Uses

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

func (*Dot11DataQOSCFPollNoData) NextLayerType Uses

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

type Dot11DataQOSData Uses

type Dot11DataQOSData struct {
    Dot11DataQOS
}

func (*Dot11DataQOSData) CanDecode Uses

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

func (*Dot11DataQOSData) LayerType Uses

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

func (*Dot11DataQOSData) NextLayerType Uses

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

type Dot11DataQOSDataCFAck Uses

type Dot11DataQOSDataCFAck struct {
    Dot11DataQOS
}

func (*Dot11DataQOSDataCFAck) CanDecode Uses

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

func (*Dot11DataQOSDataCFAck) LayerType Uses

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

func (*Dot11DataQOSDataCFAck) NextLayerType Uses

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

type Dot11DataQOSDataCFAckPoll Uses

type Dot11DataQOSDataCFAckPoll struct {
    Dot11DataQOS
}

func (*Dot11DataQOSDataCFAckPoll) CanDecode Uses

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

func (*Dot11DataQOSDataCFAckPoll) LayerType Uses

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

func (*Dot11DataQOSDataCFAckPoll) NextLayerType Uses

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

type Dot11DataQOSDataCFPoll Uses

type Dot11DataQOSDataCFPoll struct {
    Dot11DataQOS
}

func (*Dot11DataQOSDataCFPoll) CanDecode Uses

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

func (*Dot11DataQOSDataCFPoll) LayerType Uses

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

func (*Dot11DataQOSDataCFPoll) NextLayerType Uses

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

type Dot11DataQOSNull Uses

type Dot11DataQOSNull struct {
    Dot11DataQOS
}

func (*Dot11DataQOSNull) CanDecode Uses

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

func (*Dot11DataQOSNull) LayerType Uses

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

func (*Dot11DataQOSNull) NextLayerType Uses

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

type Dot11Flags Uses

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 Uses

func (d Dot11Flags) FromDS() bool

func (Dot11Flags) MD Uses

func (d Dot11Flags) MD() bool

func (Dot11Flags) MF Uses

func (d Dot11Flags) MF() bool

func (Dot11Flags) Order Uses

func (d Dot11Flags) Order() bool

func (Dot11Flags) PowerManagement Uses

func (d Dot11Flags) PowerManagement() bool

func (Dot11Flags) Retry Uses

func (d Dot11Flags) Retry() bool

func (Dot11Flags) String Uses

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 Uses

func (d Dot11Flags) ToDS() bool

func (Dot11Flags) WEP Uses

func (d Dot11Flags) WEP() bool

type Dot11HTControl Uses

type Dot11HTControl struct {
    ACConstraint bool
    RDGMorePPDU  bool

    VHT *Dot11HTControlVHT
    HT  *Dot11HTControlHT
}

type Dot11HTControlHT Uses

type Dot11HTControlHT struct {
    LinkAdapationControl *Dot11LinkAdapationControl
    CalibrationPosition  uint8
    CalibrationSequence  uint8
    CSISteering          uint8
    NDPAnnouncement      bool
    DEI                  bool
}

type Dot11HTControlMFB Uses

type Dot11HTControlMFB struct {
    NumSTS uint8
    VHTMCS uint8
    BW     uint8
    SNR    int8
}

func (*Dot11HTControlMFB) NoFeedBackPresent Uses

func (m *Dot11HTControlMFB) NoFeedBackPresent() bool

type Dot11HTControlVHT Uses

type Dot11HTControlVHT struct {
    MRQ            bool
    UnsolicitedMFB bool
    MSI            *uint8
    MFB            Dot11HTControlMFB
    CompressedMSI  *uint8
    STBCIndication bool
    MFSI           *uint8
    GID            *uint8
    CodingType     *Dot11CodingType
    FbTXBeamformed bool
}

type Dot11InformationElement Uses

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

func (*Dot11InformationElement) CanDecode Uses

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

func (*Dot11InformationElement) DecodeFromBytes Uses

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

func (*Dot11InformationElement) LayerType Uses

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

func (*Dot11InformationElement) NextLayerType Uses

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

func (Dot11InformationElement) SerializeTo Uses

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

func (*Dot11InformationElement) String Uses

func (d *Dot11InformationElement) String() string

type Dot11InformationElementID Uses

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
    Dot11InformationElementIDCountryInfo               Dot11InformationElementID = 7
    Dot11InformationElementIDHoppingPatternParam       Dot11InformationElementID = 8
    Dot11InformationElementIDHoppingPatternTable       Dot11InformationElementID = 9
    Dot11InformationElementIDRequest                   Dot11InformationElementID = 10
    Dot11InformationElementIDQBSSLoadElem              Dot11InformationElementID = 11
    Dot11InformationElementIDEDCAParamSet              Dot11InformationElementID = 12
    Dot11InformationElementIDTrafficSpec               Dot11InformationElementID = 13
    Dot11InformationElementIDTrafficClass              Dot11InformationElementID = 14
    Dot11InformationElementIDSchedule                  Dot11InformationElementID = 15
    Dot11InformationElementIDChallenge                 Dot11InformationElementID = 16
    Dot11InformationElementIDPowerConst                Dot11InformationElementID = 32
    Dot11InformationElementIDPowerCapability           Dot11InformationElementID = 33
    Dot11InformationElementIDTPCRequest                Dot11InformationElementID = 34
    Dot11InformationElementIDTPCReport                 Dot11InformationElementID = 35
    Dot11InformationElementIDSupportedChannels         Dot11InformationElementID = 36
    Dot11InformationElementIDSwitchChannelAnnounce     Dot11InformationElementID = 37
    Dot11InformationElementIDMeasureRequest            Dot11InformationElementID = 38
    Dot11InformationElementIDMeasureReport             Dot11InformationElementID = 39
    Dot11InformationElementIDQuiet                     Dot11InformationElementID = 40
    Dot11InformationElementIDIBSSDFS                   Dot11InformationElementID = 41
    Dot11InformationElementIDERPInfo                   Dot11InformationElementID = 42
    Dot11InformationElementIDTSDelay                   Dot11InformationElementID = 43
    Dot11InformationElementIDTCLASProcessing           Dot11InformationElementID = 44
    Dot11InformationElementIDHTCapabilities            Dot11InformationElementID = 45
    Dot11InformationElementIDQOSCapability             Dot11InformationElementID = 46
    Dot11InformationElementIDERPInfo2                  Dot11InformationElementID = 47
    Dot11InformationElementIDRSNInfo                   Dot11InformationElementID = 48
    Dot11InformationElementIDESRates                   Dot11InformationElementID = 50
    Dot11InformationElementIDAPChannelReport           Dot11InformationElementID = 51
    Dot11InformationElementIDNeighborReport            Dot11InformationElementID = 52
    Dot11InformationElementIDRCPI                      Dot11InformationElementID = 53
    Dot11InformationElementIDMobilityDomain            Dot11InformationElementID = 54
    Dot11InformationElementIDFastBSSTrans              Dot11InformationElementID = 55
    Dot11InformationElementIDTimeoutInt                Dot11InformationElementID = 56
    Dot11InformationElementIDRICData                   Dot11InformationElementID = 57
    Dot11InformationElementIDDSERegisteredLoc          Dot11InformationElementID = 58
    Dot11InformationElementIDSuppOperatingClass        Dot11InformationElementID = 59
    Dot11InformationElementIDExtChanSwitchAnnounce     Dot11InformationElementID = 60
    Dot11InformationElementIDHTInfo                    Dot11InformationElementID = 61
    Dot11InformationElementIDSecChanOffset             Dot11InformationElementID = 62
    Dot11InformationElementIDBSSAverageAccessDelay     Dot11InformationElementID = 63
    Dot11InformationElementIDAntenna                   Dot11InformationElementID = 64
    Dot11InformationElementIDRSNI                      Dot11InformationElementID = 65
    Dot11InformationElementIDMeasurePilotTrans         Dot11InformationElementID = 66
    Dot11InformationElementIDBSSAvailAdmCapacity       Dot11InformationElementID = 67
    Dot11InformationElementIDBSSACAccDelayWAPIParam    Dot11InformationElementID = 68
    Dot11InformationElementIDTimeAdvertisement         Dot11InformationElementID = 69
    Dot11InformationElementIDRMEnabledCapabilities     Dot11InformationElementID = 70
    Dot11InformationElementIDMultipleBSSID             Dot11InformationElementID = 71
    Dot11InformationElementID2040BSSCoExist            Dot11InformationElementID = 72
    Dot11InformationElementID2040BSSIntChanReport      Dot11InformationElementID = 73
    Dot11InformationElementIDOverlapBSSScanParam       Dot11InformationElementID = 74
    Dot11InformationElementIDRICDescriptor             Dot11InformationElementID = 75
    Dot11InformationElementIDManagementMIC             Dot11InformationElementID = 76
    Dot11InformationElementIDEventRequest              Dot11InformationElementID = 78
    Dot11InformationElementIDEventReport               Dot11InformationElementID = 79
    Dot11InformationElementIDDiagnosticRequest         Dot11InformationElementID = 80
    Dot11InformationElementIDDiagnosticReport          Dot11InformationElementID = 81
    Dot11InformationElementIDLocationParam             Dot11InformationElementID = 82
    Dot11InformationElementIDNonTransBSSIDCapability   Dot11InformationElementID = 83
    Dot11InformationElementIDSSIDList                  Dot11InformationElementID = 84
    Dot11InformationElementIDMultipleBSSIDIndex        Dot11InformationElementID = 85
    Dot11InformationElementIDFMSDescriptor             Dot11InformationElementID = 86
    Dot11InformationElementIDFMSRequest                Dot11InformationElementID = 87
    Dot11InformationElementIDFMSResponse               Dot11InformationElementID = 88
    Dot11InformationElementIDQOSTrafficCapability      Dot11InformationElementID = 89
    Dot11InformationElementIDBSSMaxIdlePeriod          Dot11InformationElementID = 90
    Dot11InformationElementIDTFSRequest                Dot11InformationElementID = 91
    Dot11InformationElementIDTFSResponse               Dot11InformationElementID = 92
    Dot11InformationElementIDWNMSleepMode              Dot11InformationElementID = 93
    Dot11InformationElementIDTIMBroadcastRequest       Dot11InformationElementID = 94
    Dot11InformationElementIDTIMBroadcastResponse      Dot11InformationElementID = 95
    Dot11InformationElementIDCollInterferenceReport    Dot11InformationElementID = 96
    Dot11InformationElementIDChannelUsage              Dot11InformationElementID = 97
    Dot11InformationElementIDTimeZone                  Dot11InformationElementID = 98
    Dot11InformationElementIDDMSRequest                Dot11InformationElementID = 99
    Dot11InformationElementIDDMSResponse               Dot11InformationElementID = 100
    Dot11InformationElementIDLinkIdentifier            Dot11InformationElementID = 101
    Dot11InformationElementIDWakeupSchedule            Dot11InformationElementID = 102
    Dot11InformationElementIDChannelSwitchTiming       Dot11InformationElementID = 104
    Dot11InformationElementIDPTIControl                Dot11InformationElementID = 105
    Dot11InformationElementIDPUBufferStatus            Dot11InformationElementID = 106
    Dot11InformationElementIDInterworking              Dot11InformationElementID = 107
    Dot11InformationElementIDAdvertisementProtocol     Dot11InformationElementID = 108
    Dot11InformationElementIDExpBWRequest              Dot11InformationElementID = 109
    Dot11InformationElementIDQOSMapSet                 Dot11InformationElementID = 110
    Dot11InformationElementIDRoamingConsortium         Dot11InformationElementID = 111
    Dot11InformationElementIDEmergencyAlertIdentifier  Dot11InformationElementID = 112
    Dot11InformationElementIDMeshConfiguration         Dot11InformationElementID = 113
    Dot11InformationElementIDMeshID                    Dot11InformationElementID = 114
    Dot11InformationElementIDMeshLinkMetricReport      Dot11InformationElementID = 115
    Dot11InformationElementIDCongestionNotification    Dot11InformationElementID = 116
    Dot11InformationElementIDMeshPeeringManagement     Dot11InformationElementID = 117
    Dot11InformationElementIDMeshChannelSwitchParam    Dot11InformationElementID = 118
    Dot11InformationElementIDMeshAwakeWindows          Dot11InformationElementID = 119
    Dot11InformationElementIDBeaconTiming              Dot11InformationElementID = 120
    Dot11InformationElementIDMCCAOPSetupRequest        Dot11InformationElementID = 121
    Dot11InformationElementIDMCCAOPSetupReply          Dot11InformationElementID = 122
    Dot11InformationElementIDMCCAOPAdvertisement       Dot11InformationElementID = 123
    Dot11InformationElementIDMCCAOPTeardown            Dot11InformationElementID = 124
    Dot11InformationElementIDGateAnnouncement          Dot11InformationElementID = 125
    Dot11InformationElementIDRootAnnouncement          Dot11InformationElementID = 126
    Dot11InformationElementIDExtCapability             Dot11InformationElementID = 127
    Dot11InformationElementIDAgereProprietary          Dot11InformationElementID = 128
    Dot11InformationElementIDPathRequest               Dot11InformationElementID = 130
    Dot11InformationElementIDPathReply                 Dot11InformationElementID = 131
    Dot11InformationElementIDPathError                 Dot11InformationElementID = 132
    Dot11InformationElementIDCiscoCCX1CKIPDeviceName   Dot11InformationElementID = 133
    Dot11InformationElementIDCiscoCCX2                 Dot11InformationElementID = 136
    Dot11InformationElementIDProxyUpdate               Dot11InformationElementID = 137
    Dot11InformationElementIDProxyUpdateConfirmation   Dot11InformationElementID = 138
    Dot11InformationElementIDAuthMeshPerringExch       Dot11InformationElementID = 139
    Dot11InformationElementIDMIC                       Dot11InformationElementID = 140
    Dot11InformationElementIDDestinationURI            Dot11InformationElementID = 141
    Dot11InformationElementIDUAPSDCoexistence          Dot11InformationElementID = 142
    Dot11InformationElementIDWakeupSchedule80211ad     Dot11InformationElementID = 143
    Dot11InformationElementIDExtendedSchedule          Dot11InformationElementID = 144
    Dot11InformationElementIDSTAAvailability           Dot11InformationElementID = 145
    Dot11InformationElementIDDMGTSPEC                  Dot11InformationElementID = 146
    Dot11InformationElementIDNextDMGATI                Dot11InformationElementID = 147
    Dot11InformationElementIDDMSCapabilities           Dot11InformationElementID = 148
    Dot11InformationElementIDCiscoUnknown95            Dot11InformationElementID = 149
    Dot11InformationElementIDVendor2                   Dot11InformationElementID = 150
    Dot11InformationElementIDDMGOperating              Dot11InformationElementID = 151
    Dot11InformationElementIDDMGBSSParamChange         Dot11InformationElementID = 152
    Dot11InformationElementIDDMGBeamRefinement         Dot11InformationElementID = 153
    Dot11InformationElementIDChannelMeasFeedback       Dot11InformationElementID = 154
    Dot11InformationElementIDAwakeWindow               Dot11InformationElementID = 157
    Dot11InformationElementIDMultiBand                 Dot11InformationElementID = 158
    Dot11InformationElementIDADDBAExtension            Dot11InformationElementID = 159
    Dot11InformationElementIDNEXTPCPList               Dot11InformationElementID = 160
    Dot11InformationElementIDPCPHandover               Dot11InformationElementID = 161
    Dot11InformationElementIDDMGLinkMargin             Dot11InformationElementID = 162
    Dot11InformationElementIDSwitchingStream           Dot11InformationElementID = 163
    Dot11InformationElementIDSessionTransmission       Dot11InformationElementID = 164
    Dot11InformationElementIDDynamicTonePairReport     Dot11InformationElementID = 165
    Dot11InformationElementIDClusterReport             Dot11InformationElementID = 166
    Dot11InformationElementIDRelayCapabilities         Dot11InformationElementID = 167
    Dot11InformationElementIDRelayTransferParameter    Dot11InformationElementID = 168
    Dot11InformationElementIDBeamlinkMaintenance       Dot11InformationElementID = 169
    Dot11InformationElementIDMultipleMacSublayers      Dot11InformationElementID = 170
    Dot11InformationElementIDUPID                      Dot11InformationElementID = 171
    Dot11InformationElementIDDMGLinkAdaptionAck        Dot11InformationElementID = 172
    Dot11InformationElementIDSymbolProprietary         Dot11InformationElementID = 173
    Dot11InformationElementIDMCCAOPAdvertOverview      Dot11InformationElementID = 174
    Dot11InformationElementIDQuietPeriodRequest        Dot11InformationElementID = 175
    Dot11InformationElementIDQuietPeriodResponse       Dot11InformationElementID = 177
    Dot11InformationElementIDECPACPolicy               Dot11InformationElementID = 182
    Dot11InformationElementIDClusterTimeOffset         Dot11InformationElementID = 183
    Dot11InformationElementIDAntennaSectorID           Dot11InformationElementID = 190
    Dot11InformationElementIDVHTCapabilities           Dot11InformationElementID = 191
    Dot11InformationElementIDVHTOperation              Dot11InformationElementID = 192
    Dot11InformationElementIDExtendedBSSLoad           Dot11InformationElementID = 193
    Dot11InformationElementIDWideBWChannelSwitch       Dot11InformationElementID = 194
    Dot11InformationElementIDVHTTxPowerEnvelope        Dot11InformationElementID = 195
    Dot11InformationElementIDChannelSwitchWrapper      Dot11InformationElementID = 196
    Dot11InformationElementIDOperatingModeNotification Dot11InformationElementID = 199
    Dot11InformationElementIDVendor                    Dot11InformationElementID = 221
)

func (Dot11InformationElementID) String Uses

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 Dot11LinkAdapationControl Uses

type Dot11LinkAdapationControl struct {
    TRQ  bool
    MRQ  bool
    MSI  uint8
    MFSI uint8
    ASEL *Dot11ASEL
    MFB  *uint8
}

type Dot11Mgmt Uses

type Dot11Mgmt struct {
    BaseLayer
}

Dot11Mgmt is a base for all IEEE 802.11 management layers.

func (*Dot11Mgmt) DecodeFromBytes Uses

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

func (*Dot11Mgmt) NextLayerType Uses

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

type Dot11MgmtATIM Uses

type Dot11MgmtATIM struct {
    Dot11Mgmt
}

func (*Dot11MgmtATIM) CanDecode Uses

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

func (*Dot11MgmtATIM) LayerType Uses

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

type Dot11MgmtAction Uses

type Dot11MgmtAction struct {
    Dot11Mgmt
}

func (*Dot11MgmtAction) CanDecode Uses

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

func (*Dot11MgmtAction) LayerType Uses

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

type Dot11MgmtActionNoAck Uses

type Dot11MgmtActionNoAck struct {
    Dot11Mgmt
}

func (*Dot11MgmtActionNoAck) CanDecode Uses

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

func (*Dot11MgmtActionNoAck) LayerType Uses

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

type Dot11MgmtArubaWLAN Uses

type Dot11MgmtArubaWLAN struct {
    Dot11Mgmt
}

func (*Dot11MgmtArubaWLAN) CanDecode Uses

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

func (*Dot11MgmtArubaWLAN) LayerType Uses

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

type Dot11MgmtAssociationReq Uses

type Dot11MgmtAssociationReq struct {
    Dot11Mgmt
    CapabilityInfo uint16
    ListenInterval uint16
}

func (*Dot11MgmtAssociationReq) CanDecode Uses

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

func (*Dot11MgmtAssociationReq) DecodeFromBytes Uses

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

func (*Dot11MgmtAssociationReq) LayerType Uses

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

func (*Dot11MgmtAssociationReq) NextLayerType Uses

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

func (Dot11MgmtAssociationReq) SerializeTo Uses

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

type Dot11MgmtAssociationResp Uses

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

func (*Dot11MgmtAssociationResp) CanDecode Uses

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

func (*Dot11MgmtAssociationResp) DecodeFromBytes Uses

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

func (*Dot11MgmtAssociationResp) LayerType Uses

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

func (*Dot11MgmtAssociationResp) NextLayerType Uses

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

func (Dot11MgmtAssociationResp) SerializeTo Uses

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

type Dot11MgmtAuthentication Uses

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

func (*Dot11MgmtAuthentication) CanDecode Uses

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

func (*Dot11MgmtAuthentication) DecodeFromBytes Uses

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

func (*Dot11MgmtAuthentication) LayerType Uses

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

func (*Dot11MgmtAuthentication) NextLayerType Uses

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

func (Dot11MgmtAuthentication) SerializeTo Uses

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

type Dot11MgmtBeacon Uses

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

func (*Dot11MgmtBeacon) CanDecode Uses

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

func (*Dot11MgmtBeacon) DecodeFromBytes Uses

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

func (*Dot11MgmtBeacon) LayerType Uses

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

func (*Dot11MgmtBeacon) NextLayerType Uses

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

func (Dot11MgmtBeacon) SerializeTo Uses

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

type Dot11MgmtDeauthentication Uses

type Dot11MgmtDeauthentication struct {
    Dot11Mgmt
    Reason Dot11Reason
}

func (*Dot11MgmtDeauthentication) CanDecode Uses

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

func (*Dot11MgmtDeauthentication) DecodeFromBytes Uses

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

func (*Dot11MgmtDeauthentication) LayerType Uses

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

func (Dot11MgmtDeauthentication) SerializeTo Uses

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

type Dot11MgmtDisassociation Uses

type Dot11MgmtDisassociation struct {
    Dot11Mgmt
    Reason Dot11Reason
}

func (*Dot11MgmtDisassociation) CanDecode Uses

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

func (*Dot11MgmtDisassociation) DecodeFromBytes Uses

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

func (*Dot11MgmtDisassociation) LayerType Uses

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

func (Dot11MgmtDisassociation) SerializeTo Uses

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

type Dot11MgmtMeasurementPilot Uses

type Dot11MgmtMeasurementPilot struct {
    Dot11Mgmt
}

func (*Dot11MgmtMeasurementPilot) CanDecode Uses

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

func (*Dot11MgmtMeasurementPilot) LayerType Uses

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

type Dot11MgmtProbeReq Uses

type Dot11MgmtProbeReq struct {
    Dot11Mgmt
}

func (*Dot11MgmtProbeReq) CanDecode Uses

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

func (*Dot11MgmtProbeReq) LayerType Uses

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

func (*Dot11MgmtProbeReq) NextLayerType Uses

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

type Dot11MgmtProbeResp Uses

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

func (*Dot11MgmtProbeResp) CanDecode Uses

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

func (*Dot11MgmtProbeResp) DecodeFromBytes Uses

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

func (*Dot11MgmtProbeResp) LayerType Uses

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

func (*Dot11MgmtProbeResp) NextLayerType Uses

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

func (Dot11MgmtProbeResp) SerializeTo Uses

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

type Dot11MgmtReassociationReq Uses

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

func (*Dot11MgmtReassociationReq) CanDecode Uses

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

func (*Dot11MgmtReassociationReq) DecodeFromBytes Uses

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

func (*Dot11MgmtReassociationReq) LayerType Uses

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

func (*Dot11MgmtReassociationReq) NextLayerType Uses

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

func (Dot11MgmtReassociationReq) SerializeTo Uses

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

type Dot11MgmtReassociationResp Uses

type Dot11MgmtReassociationResp struct {
    Dot11Mgmt
}

func (*Dot11MgmtReassociationResp) CanDecode Uses

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

func (*Dot11MgmtReassociationResp) LayerType Uses

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

func (*Dot11MgmtReassociationResp) NextLayerType Uses

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

type Dot11QOS Uses

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

type Dot11Reason Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

Decoder calls Dot11TypeMetadata.DecodeWith's decoder.

func (Dot11Type) LayerType Uses

func (a Dot11Type) LayerType() gopacket.LayerType

LayerType returns Dot11TypeMetadata.LayerType.

func (Dot11Type) MainType Uses

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) QOS Uses

func (d Dot11Type) QOS() bool

func (Dot11Type) String Uses

func (a Dot11Type) String() string

String returns Dot11TypeMetadata.Name.

type Dot11WEP Uses

type Dot11WEP struct {
    BaseLayer
}

Dot11WEP contains WEP encrpted IEEE 802.11 data.

func (*Dot11WEP) CanDecode Uses

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

func (*Dot11WEP) DecodeFromBytes Uses

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

func (*Dot11WEP) LayerType Uses

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

func (*Dot11WEP) NextLayerType Uses

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

type Dot1Q Uses

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 Uses

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

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

func (*Dot1Q) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*Dot1Q) LayerType Uses

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

LayerType returns gopacket.LayerTypeDot1Q

func (*Dot1Q) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*Dot1Q) SerializeTo Uses

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 Uses

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 Uses

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

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

func (*EAP) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*EAP) LayerType Uses

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

LayerType returns LayerTypeEAP.

func (*EAP) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*EAP) SerializeTo Uses

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 Uses

type EAPCode uint8

type EAPOL Uses

type EAPOL struct {
    BaseLayer
    Version uint8
    Type    EAPOLType
    Length  uint16
}

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

func (*EAPOL) CanDecode Uses

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

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

func (*EAPOL) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*EAPOL) LayerType Uses

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

LayerType returns LayerTypeEAPOL.

func (*EAPOL) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*EAPOL) SerializeTo Uses

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

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

type EAPOLKey Uses

type EAPOLKey struct {
    BaseLayer
    KeyDescriptorType    EAPOLKeyDescriptorType
    KeyDescriptorVersion EAPOLKeyDescriptorVersion
    KeyType              EAPOLKeyType
    KeyIndex             uint8
    Install              bool
    KeyACK               bool
    KeyMIC               bool
    Secure               bool
    MICError             bool
    Request              bool
    HasEncryptedKeyData  bool
    SMKMessage           bool
    KeyLength            uint16
    ReplayCounter        uint64
    Nonce                []byte
    IV                   []byte
    RSC                  uint64
    ID                   uint64
    MIC                  []byte
    KeyDataLength        uint16
    EncryptedKeyData     []byte
}

EAPOLKey defines an EAPOL-Key frame for 802.1x authentication

func (*EAPOLKey) DecodeFromBytes Uses

func (ek *EAPOLKey) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*EAPOLKey) LayerType Uses

func (ek *EAPOLKey) LayerType() gopacket.LayerType

LayerType returns LayerTypeEAPOLKey.

func (*EAPOLKey) NextLayerType Uses

func (ek *EAPOLKey) NextLayerType() gopacket.LayerType

NextLayerType returns layers.LayerTypeDot11InformationElement if the key data exists and is unencrypted, otherwise it does not expect a next layer.

func (*EAPOLKey) SerializeTo Uses

func (ek *EAPOLKey) 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 EAPOLKeyDescriptorType Uses

type EAPOLKeyDescriptorType uint8

EAPOLKeyDescriptorType is an enumeration of key descriptor types as specified by 802.1x in the EAPOL-Key frame

const (
    EAPOLKeyDescriptorTypeRC4   EAPOLKeyDescriptorType = 1
    EAPOLKeyDescriptorTypeDot11 EAPOLKeyDescriptorType = 2
    EAPOLKeyDescriptorTypeWPA   EAPOLKeyDescriptorType = 254
)

Enumeration of EAPOLKeyDescriptorType

func (EAPOLKeyDescriptorType) String Uses

func (kdt EAPOLKeyDescriptorType) String() string

type EAPOLKeyDescriptorVersion Uses

type EAPOLKeyDescriptorVersion uint8

EAPOLKeyDescriptorVersion is an enumeration of versions specifying the encryption algorithm for the key data and the authentication for the message integrity code (MIC)

const (
    EAPOLKeyDescriptorVersionOther       EAPOLKeyDescriptorVersion = 0
    EAPOLKeyDescriptorVersionRC4HMACMD5  EAPOLKeyDescriptorVersion = 1
    EAPOLKeyDescriptorVersionAESHMACSHA1 EAPOLKeyDescriptorVersion = 2
    EAPOLKeyDescriptorVersionAES128CMAC  EAPOLKeyDescriptorVersion = 3
)

Enumeration of EAPOLKeyDescriptorVersion

func (EAPOLKeyDescriptorVersion) String Uses

func (v EAPOLKeyDescriptorVersion) String() string

type EAPOLKeyType Uses

type EAPOLKeyType uint8

EAPOLKeyType is an enumeration of key derivation types describing the purpose of the keys being derived.

const (
    EAPOLKeyTypeGroupSMK EAPOLKeyType = 0
    EAPOLKeyTypePairwise EAPOLKeyType = 1
)

Enumeration of EAPOLKeyType

func (EAPOLKeyType) String Uses

func (kt EAPOLKeyType) String() string

type EAPOLType Uses

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 Uses

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

Decoder calls EAPOLTypeMetadata.DecodeWith's decoder.

func (EAPOLType) LayerType Uses

func (a EAPOLType) LayerType() gopacket.LayerType

LayerType returns EAPOLTypeMetadata.LayerType.

func (EAPOLType) String Uses

func (a EAPOLType) String() string

String returns EAPOLTypeMetadata.Name.

type EAPType Uses

type EAPType uint8

type EnumMetadata Uses

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 Uses

type EtherIP struct {
    BaseLayer
    Version  uint8
    Reserved uint16
}

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

func (*EtherIP) CanDecode Uses

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

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

func (*EtherIP) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*EtherIP) LayerType Uses

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

LayerType returns gopacket.LayerTypeEtherIP.

func (*EtherIP) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

type Ethernet Uses

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 Uses

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

func (*Ethernet) DecodeFromBytes Uses

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

func (*Ethernet) LayerType Uses

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

LayerType returns LayerTypeEthernet

func (*Ethernet) LinkFlow Uses

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

func (*Ethernet) NextLayerType Uses

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

func (*Ethernet) SerializeTo Uses

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 Uses

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 Uses

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

LayerType returns gopacket.LayerTypeEthernetCTP.

type EthernetCTPForwardData Uses

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 Uses

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

ForwardEndpoint returns the EthernetCTPForwardData ForwardAddress as an endpoint.

func (*EthernetCTPForwardData) LayerType Uses

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

LayerType returns gopacket.LayerTypeEthernetCTPForwardData.

type EthernetCTPFunction Uses

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
)

EthernetCTPFunction values.

type EthernetCTPReply Uses

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 Uses

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

LayerType returns gopacket.LayerTypeEthernetCTPReply.

func (*EthernetCTPReply) Payload Uses

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

Payload returns the EthernetCTP reply's Data bytes.

type EthernetType Uses

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
    EthernetTypeTransparentEthernetBridging EthernetType = 0x6558
    EthernetTypeDot1Q                       EthernetType = 0x8100
    EthernetTypePPPoEDiscovery              EthernetType = 0x8863
    EthernetTypePPPoESession                EthernetType = 0x8864
    EthernetTypeMPLSUnicast                 EthernetType = 0x8847
    EthernetTypeMPLSMulticast               EthernetType = 0x8848
    EthernetTypeEAPOL                       EthernetType = 0x888e
    EthernetTypeQinQ                        EthernetType = 0x88a8
    EthernetTypeLinkLayerDiscovery          EthernetType = 0x88cc
    EthernetTypeEthernetCTP                 EthernetType = 0x9000
)

func (EthernetType) Decode Uses

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

Decoder calls EthernetTypeMetadata.DecodeWith's decoder.

func (EthernetType) LayerType Uses

func (a EthernetType) LayerType() gopacket.LayerType

LayerType returns EthernetTypeMetadata.LayerType.

func (EthernetType) String Uses

func (a EthernetType) String() string

String returns EthernetTypeMetadata.Name.

type FDDI Uses

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

FDDI contains the header for FDDI frames.

func (*FDDI) LayerType Uses

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

LayerType returns LayerTypeFDDI.

func (*FDDI) LinkFlow Uses

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

LinkFlow returns a new flow of type EndpointMAC.

type FDDIFrameControl Uses

type FDDIFrameControl uint8

FDDIFrameControl is an enumeration of FDDI frame control bytes.

const (
    FDDIFrameControlLLC FDDIFrameControl = 0x50
)

func (FDDIFrameControl) Decode Uses

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

Decoder calls FDDIFrameControlMetadata.DecodeWith's decoder.

func (FDDIFrameControl) LayerType Uses

func (a FDDIFrameControl) LayerType() gopacket.LayerType

LayerType returns FDDIFrameControlMetadata.LayerType.

func (FDDIFrameControl) String Uses

func (a FDDIFrameControl) String() string

String returns FDDIFrameControlMetadata.Name.

type GRE Uses

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 Uses

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

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

func (*GRE) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*GRE) LayerType Uses

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

LayerType returns gopacket.LayerTypeGRE.

func (*GRE) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*GRE) SerializeTo Uses

func (g *GRE) 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 GRERouting Uses

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

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

type GTPExtensionHeader Uses

type GTPExtensionHeader struct {
    Type    uint8
    Content []byte
}

GTPExtensionHeader is used to carry extra data and enable future extensions of the GTP without the need to use another version number.

type GTPv1U Uses

type GTPv1U struct {
    BaseLayer
    Version             uint8
    ProtocolType        uint8
    Reserved            uint8
    ExtensionHeaderFlag bool
    SequenceNumberFlag  bool
    NPDUFlag            bool
    MessageType         uint8
    MessageLength       uint16
    TEID                uint32
    SequenceNumber      uint16
    NPDU                uint8
    GTPExtensionHeaders []GTPExtensionHeader
}

GTPv1U protocol is used to exchange user data over GTP tunnels across the Sx interfaces. Defined in https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=1595

func (*GTPv1U) CanDecode Uses

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

CanDecode returns a set of layers that GTP objects can decode.

func (*GTPv1U) DecodeFromBytes Uses

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

DecodeFromBytes analyses a byte slice and attempts to decode it as a GTPv1U packet

func (*GTPv1U) LayerType Uses

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

LayerType returns LayerTypeGTPV1U

func (*GTPv1U) NextLayerType Uses

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

NextLayerType specifies the next layer that GoPacket should attempt to

func (*GTPv1U) SerializeTo Uses

func (g *GTPv1U) 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 Geneve Uses

type Geneve struct {
    BaseLayer
    Version        uint8        // 2 bits
    OptionsLength  uint8        // 6 bits
    OAMPacket      bool         // 1 bits
    CriticalOption bool         // 1 bits
    Protocol       EthernetType // 16 bits
    VNI            uint32       // 24bits
    Options        []*GeneveOption
}

Geneve is specifed here https://tools.ietf.org/html/draft-ietf-nvo3-geneve-03 Geneve Header: +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |Ver| Opt Len |O|C| Rsvd. | Protocol Type | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Virtual Network Identifier (VNI) | Reserved | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Variable Length Options | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

func (*Geneve) DecodeFromBytes Uses

func (gn *Geneve) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*Geneve) LayerType Uses

func (gn *Geneve) LayerType() gopacket.LayerType

LayerType returns LayerTypeGeneve

func (*Geneve) NextLayerType Uses

func (gn *Geneve) NextLayerType() gopacket.LayerType

type GeneveOption Uses

type GeneveOption struct {
    Class  uint16 // 16 bits
    Type   uint8  // 8 bits
    Flags  uint8  // 3 bits
    Length uint8  // 5 bits
    Data   []byte
}

Geneve Tunnel Options +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Option Class | Type |R|R|R| Length | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Variable Option Data | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

type HelloPkg Uses

type HelloPkg struct {
    InterfaceID              uint32
    RtrPriority              uint8
    Options                  uint32
    HelloInterval            uint16
    RouterDeadInterval       uint32
    DesignatedRouterID       uint32
    BackupDesignatedRouterID uint32
    NeighborID               []uint32
}

HelloPkg is the struct from RFC 5340 A.3.2.

type HelloPkgV2 Uses

type HelloPkgV2 struct {
    HelloPkg
    NetworkMask uint32
}

HelloPkgV2 extends the HelloPkg struct with OSPFv2 information

type IANAAddressFamily Uses

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 Uses

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

type ICMPv4 Uses

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

ICMPv4 is the layer for IPv4 ICMP packet data.

func (*ICMPv4) CanDecode Uses

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

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

func (*ICMPv4) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv4) LayerType Uses

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

LayerType returns LayerTypeICMPv4.

func (*ICMPv4) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv4) SerializeTo Uses

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 Uses

type ICMPv4TypeCode uint16

func CreateICMPv4TypeCode Uses

func CreateICMPv4TypeCode(typ uint8, code uint8) ICMPv4TypeCode

CreateICMPv4TypeCode is a convenience function to create an ICMPv4TypeCode gopacket type from the ICMPv4 type and code values.

func (ICMPv4TypeCode) Code Uses

func (a ICMPv4TypeCode) Code() uint8

Code returns the ICMPv4 code field.

func (ICMPv4TypeCode) GoString Uses

func (a ICMPv4TypeCode) GoString() string

func (ICMPv4TypeCode) SerializeTo Uses

func (a ICMPv4TypeCode) SerializeTo(bytes []byte)

SerializeTo writes the ICMPv4TypeCode value to the 'bytes' buffer.

func (ICMPv4TypeCode) String Uses

func (a ICMPv4TypeCode) String() string

func (ICMPv4TypeCode) Type Uses

func (a ICMPv4TypeCode) Type() uint8

Type returns the ICMPv4 type field.

type ICMPv6 Uses

type ICMPv6 struct {
    BaseLayer
    TypeCode ICMPv6TypeCode
    Checksum uint16
    // TypeBytes is deprecated and always nil. See the different ICMPv6 message types
    // instead (e.g. ICMPv6TypeRouterSolicitation).
    TypeBytes []byte
    // contains filtered or unexported fields
}

ICMPv6 is the layer for IPv6 ICMP packet data

func (*ICMPv6) CanDecode Uses

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

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

func (*ICMPv6) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6) LayerType Uses

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

LayerType returns LayerTypeICMPv6.

func (*ICMPv6) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6) SerializeTo Uses

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 Uses

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 ICMPv6Echo Uses

type ICMPv6Echo struct {
    BaseLayer
    Identifier uint16
    SeqNumber  uint16
}

ICMPv6Echo represents the structure of a ping.

func (*ICMPv6Echo) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6Echo) LayerType Uses

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

LayerType returns LayerTypeICMPv6Echo.

func (*ICMPv6Echo) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6Echo) SerializeTo Uses

func (i *ICMPv6Echo) 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 ICMPv6NeighborAdvertisement Uses

type ICMPv6NeighborAdvertisement struct {
    BaseLayer
    Flags         uint8
    TargetAddress net.IP
    Options       ICMPv6Options
}

ICMPv6NeighborAdvertisement is sent by nodes in response to Solicitation.

func (*ICMPv6NeighborAdvertisement) CanDecode Uses

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

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

func (*ICMPv6NeighborAdvertisement) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6NeighborAdvertisement) LayerType Uses

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

LayerType returns LayerTypeICMPv6NeighborAdvertisement.

func (*ICMPv6NeighborAdvertisement) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6NeighborAdvertisement) Override Uses

func (i *ICMPv6NeighborAdvertisement) Override() bool

Override indicates whether the advertisement should Override an existing cache entry.

func (*ICMPv6NeighborAdvertisement) Router Uses

func (i *ICMPv6NeighborAdvertisement) Router() bool

Router indicates whether the sender is a router or not.

func (*ICMPv6NeighborAdvertisement) SerializeTo Uses

func (i *ICMPv6NeighborAdvertisement) 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 (*ICMPv6NeighborAdvertisement) Solicited Uses

func (i *ICMPv6NeighborAdvertisement) Solicited() bool

Solicited indicates whether the advertisement was solicited or not.

type ICMPv6NeighborSolicitation Uses

type ICMPv6NeighborSolicitation struct {
    BaseLayer
    TargetAddress net.IP
    Options       ICMPv6Options
}

ICMPv6NeighborSolicitation is sent to request the link-layer address of a target node.

func (*ICMPv6NeighborSolicitation) CanDecode Uses

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

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

func (*ICMPv6NeighborSolicitation) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6NeighborSolicitation) LayerType Uses

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

LayerType returns LayerTypeICMPv6NeighborSolicitation.

func (*ICMPv6NeighborSolicitation) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6NeighborSolicitation) SerializeTo Uses

func (i *ICMPv6NeighborSolicitation) 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 ICMPv6Opt Uses

type ICMPv6Opt uint8

ICMPv6Opt indicate how to decode the data associated with each ICMPv6Option.

const (

    // ICMPv6OptSourceAddress contains the link-layer address of the sender of
    // the packet. It is used in the Neighbor Solicitation, Router
    // Solicitation, and Router Advertisement packets. Must be ignored for other
    // Neighbor discovery messages.
    ICMPv6OptSourceAddress ICMPv6Opt

    // ICMPv6OptTargetAddress contains the link-layer address of the target. It
    // is used in Neighbor Advertisement and Redirect packets. Must be ignored
    // for other Neighbor discovery messages.
    ICMPv6OptTargetAddress

    // ICMPv6OptPrefixInfo provides hosts with on-link prefixes and prefixes
    // for Address Autoconfiguration. The Prefix Information option appears in
    // Router Advertisement packets and MUST be silently ignored for other
    // messages.
    ICMPv6OptPrefixInfo

    // ICMPv6OptRedirectedHeader is used in Redirect messages and contains all
    // or part of the packet that is being redirected.
    ICMPv6OptRedirectedHeader

    // ICMPv6OptMTU is used in Router Advertisement messages to ensure that all
    // nodes on a link use the same MTU value in those cases where the link MTU
    // is not well known. This option MUST be silently ignored for other
    // Neighbor Discovery messages.
    ICMPv6OptMTU
)

func (ICMPv6Opt) String Uses

func (i ICMPv6Opt) String() string

type ICMPv6Option Uses

type ICMPv6Option struct {
    Type ICMPv6Opt
    Data []byte
}

ICMPv6Option contains the type and data for a single option.

func (ICMPv6Option) String Uses

func (i ICMPv6Option) String() string

type ICMPv6Options Uses

type ICMPv6Options []ICMPv6Option

ICMPv6Options is a slice of ICMPv6Option.

func (*ICMPv6Options) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6Options) SerializeTo Uses

func (i *ICMPv6Options) 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 ICMPv6Redirect Uses

type ICMPv6Redirect struct {
    BaseLayer
    TargetAddress      net.IP
    DestinationAddress net.IP
    Options            ICMPv6Options
}

ICMPv6Redirect is sent by routers to inform hosts of a better first-hop node on the path to a destination.

func (*ICMPv6Redirect) CanDecode Uses

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

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

func (*ICMPv6Redirect) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6Redirect) LayerType Uses

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

LayerType returns LayerTypeICMPv6Redirect.

func (*ICMPv6Redirect) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6Redirect) SerializeTo Uses

func (i *ICMPv6Redirect) 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 ICMPv6RouterAdvertisement Uses

type ICMPv6RouterAdvertisement struct {
    BaseLayer
    HopLimit       uint8
    Flags          uint8
    RouterLifetime uint16
    ReachableTime  uint32
    RetransTimer   uint32
    Options        ICMPv6Options
}

ICMPv6RouterAdvertisement is sent by routers in response to Solicitation.

func (*ICMPv6RouterAdvertisement) CanDecode Uses

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

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

func (*ICMPv6RouterAdvertisement) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6RouterAdvertisement) LayerType Uses

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

LayerType returns LayerTypeICMPv6RouterAdvertisement.

func (*ICMPv6RouterAdvertisement) ManagedAddressConfig Uses

func (i *ICMPv6RouterAdvertisement) ManagedAddressConfig() bool

ManagedAddressConfig is true when addresses are available via DHCPv6. If set, the OtherConfig flag is redundant.

func (*ICMPv6RouterAdvertisement) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6RouterAdvertisement) OtherConfig Uses

func (i *ICMPv6RouterAdvertisement) OtherConfig() bool

OtherConfig is true when there is other configuration information available via DHCPv6. For example, DNS-related information.

func (*ICMPv6RouterAdvertisement) SerializeTo Uses

func (i *ICMPv6RouterAdvertisement) 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 ICMPv6RouterSolicitation Uses

type ICMPv6RouterSolicitation struct {
    BaseLayer
    Options ICMPv6Options
}

ICMPv6RouterSolicitation is sent by hosts to find routers.

func (*ICMPv6RouterSolicitation) CanDecode Uses

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

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

func (*ICMPv6RouterSolicitation) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*ICMPv6RouterSolicitation) LayerType Uses

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

LayerType returns LayerTypeICMPv6.

func (*ICMPv6RouterSolicitation) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*ICMPv6RouterSolicitation) SerializeTo Uses

func (i *ICMPv6RouterSolicitation) 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 ICMPv6TypeCode Uses

type ICMPv6TypeCode uint16

func CreateICMPv6TypeCode Uses

func CreateICMPv6TypeCode(typ uint8, code uint8) ICMPv6TypeCode

CreateICMPv6TypeCode is a convenience function to create an ICMPv6TypeCode gopacket type from the ICMPv6 type and code values.

func (ICMPv6TypeCode) Code Uses

func (a ICMPv6TypeCode) Code() uint8

Code returns the ICMPv6 code field.

func (ICMPv6TypeCode) GoString Uses

func (a ICMPv6TypeCode) GoString() string

func (ICMPv6TypeCode) SerializeTo Uses

func (a ICMPv6TypeCode) SerializeTo(bytes []byte)

SerializeTo writes the ICMPv6TypeCode value to the 'bytes' buffer.

func (ICMPv6TypeCode) String Uses

func (a ICMPv6TypeCode) String() string

func (ICMPv6TypeCode) Type Uses

func (a ICMPv6TypeCode) Type() uint8

Type returns the ICMPv6 type field.

type IEEEOUI Uses

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 Uses

type IGMP struct {
    BaseLayer
    Type                    IGMPType
    MaxResponseTime         time.Duration
    Checksum                uint16
    GroupAddress            net.IP
    SupressRouterProcessing bool
    RobustnessValue         uint8
    IntervalTime            time.Duration
    SourceAddresses         []net.IP
    NumberOfGroupRecords    uint16
    NumberOfSources         uint16
    GroupRecords            []IGMPv3GroupRecord
    Version                 uint8 // IGMP protocol version
}

IGMP represents an IGMPv3 message.

func (*IGMP) CanDecode Uses

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

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

func (*IGMP) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*IGMP) LayerType Uses

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

LayerType returns LayerTypeIGMP for the V1,2,3 message protocol formats.

func (*IGMP) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

type IGMPType Uses

type IGMPType uint8
const (
    IGMPMembershipQuery    IGMPType = 0x11 // General or group specific query
    IGMPMembershipReportV1 IGMPType = 0x12 // Version 1 Membership Report
    IGMPMembershipReportV2 IGMPType = 0x16 // Version 2 Membership Report
    IGMPLeaveGroup         IGMPType = 0x17 // Leave Group
    IGMPMembershipReportV3 IGMPType = 0x22 // Version 3 Membership Report
)

func (IGMPType) String Uses

func (i IGMPType) String() string

String conversions for IGMP message types

type IGMPv1or2 Uses

type IGMPv1or2 struct {
    BaseLayer
    Type            IGMPType      // IGMP message type
    MaxResponseTime time.Duration // meaningful only in Membership Query messages
    Checksum        uint16        // 16-bit checksum of entire ip payload
    GroupAddress    net.IP        // either 0 or an IP multicast address
    Version         uint8
}

IGMPv1or2 stores header details for an IGMPv1 or IGMPv2 packet.

0                   1                   2                   3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Type | Max Resp Time | Checksum | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Group Address | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

func (*IGMPv1or2) CanDecode Uses

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

func (*IGMPv1or2) DecodeFromBytes Uses

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

func (*IGMPv1or2) LayerType Uses

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

func (*IGMPv1or2) NextLayerType Uses

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

type IGMPv3GroupRecord Uses

type IGMPv3GroupRecord struct {
    Type             IGMPv3GroupRecordType
    AuxDataLen       uint8 // this should always be 0 as per IGMPv3 spec.
    NumberOfSources  uint16
    MulticastAddress net.IP
    SourceAddresses  []net.IP
    AuxData          uint32 // NOT USED
}

IGMPv3GroupRecord stores individual group records for a V3 Membership Report message.

type IGMPv3GroupRecordType Uses

type IGMPv3GroupRecordType uint8
const (
    IGMPIsIn  IGMPv3GroupRecordType = 0x01 // Type MODE_IS_INCLUDE, source addresses x
    IGMPIsEx  IGMPv3GroupRecordType = 0x02 // Type MODE_IS_EXCLUDE, source addresses x
    IGMPToIn  IGMPv3GroupRecordType = 0x03 // Type CHANGE_TO_INCLUDE_MODE, source addresses x
    IGMPToEx  IGMPv3GroupRecordType = 0x04 // Type CHANGE_TO_EXCLUDE_MODE, source addresses x
    IGMPAllow IGMPv3GroupRecordType = 0x05 // Type ALLOW_NEW_SOURCES, source addresses x
    IGMPBlock IGMPv3GroupRecordType = 0x06 // Type BLOCK_OLD_SOURCES, source addresses x
)

func (IGMPv3GroupRecordType) String Uses

func (i IGMPv3GroupRecordType) String() string

type IPProtocol Uses

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
    IPProtocolIPv4            IPProtocol = 4
    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
    IPProtocolOSPF            IPProtocol = 89
    IPProtocolIPIP            IPProtocol = 94
    IPProtocolEtherIP         IPProtocol = 97
    IPProtocolVRRP            IPProtocol = 112
    IPProtocolSCTP            IPProtocol = 132
    IPProtocolUDPLite         IPProtocol = 136
    IPProtocolMPLSInIP        IPProtocol = 137
)

func (IPProtocol) Decode Uses

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

Decoder calls IPProtocolMetadata.DecodeWith's decoder.

func (IPProtocol) LayerType Uses

func (a IPProtocol) LayerType() gopacket.LayerType

LayerType returns IPProtocolMetadata.LayerType.

func (IPProtocol) String Uses

func (a IPProtocol) String() string

String returns IPProtocolMetadata.Name.

type IPSecAH Uses

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 Uses

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

LayerType returns LayerTypeIPSecAH.

type IPSecESP Uses

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 Uses

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

LayerType returns LayerTypeIPSecESP.

type IPv4 Uses

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) AddressTo4 Uses

func (ip *IPv4) AddressTo4() error

func (*IPv4) CanDecode Uses

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

func (*IPv4) DecodeFromBytes Uses

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

DecodeFromBytes decodes the given bytes into this layer.

func (*IPv4) LayerType Uses

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

LayerType returns LayerTypeIPv4

func (*IPv4) NetworkFlow Uses

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

func (*IPv4) NextLayerType Uses

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

func (*IPv4) SerializeTo Uses

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 Uses

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 Uses

func (f IPv4Flag) String() string

type IPv4Option Uses

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

func (IPv4Option) String Uses

func (i IPv4Option) String() string

type IPv6 Uses

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) AddressTo16 Uses

func (ip *IPv6) AddressTo16() error

func (*IPv6) CanDecode Uses

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

func (*IPv6) DecodeFromBytes Uses

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

func (*IPv6) LayerType Uses

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

LayerType returns LayerTypeIPv6

func (*IPv6) NetworkFlow Uses

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

func (*IPv6) NextLayerType Uses

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

func (*IPv6) SerializeTo Uses

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 Uses

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

IPv6Destination is the IPv6 destination options header.

func (*IPv6Destination) DecodeFromBytes Uses

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

func (*IPv6Destination) LayerType Uses

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

LayerType returns LayerTypeIPv6Destination.

func (*IPv6Destination) SerializeTo Uses

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 Uses

type IPv6DestinationOption ipv6HeaderTLVOption

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

type IPv6ExtensionSkipper Uses

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 Uses

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

func (*IPv6ExtensionSkipper) DecodeFromBytes Uses

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

func (*IPv6ExtensionSkipper) NextLayerType Uses

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

type IPv6Fragment Uses

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 Uses

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

LayerType returns LayerTypeIPv6Fragment.

type IPv6HopByHop Uses

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

IPv6HopByHop is the IPv6 hop-by-hop extension.

func (*IPv6HopByHop) DecodeFromBytes Uses

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

func (*IPv6HopByHop) LayerType Uses

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

LayerType returns LayerTypeIPv6HopByHop.

func (*IPv6HopByHop) SerializeTo Uses

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

type IPv6HopByHopOption Uses

type IPv6HopByHopOption ipv6HeaderTLVOption

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

func (*IPv6HopByHopOption) SetJumboLength Uses

func (o *IPv6HopByHopOption) SetJumboLength(len uint32)

type IPv6Routing Uses

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 Uses

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

LayerType returns LayerTypeIPv6Routing.

type InterAreaPrefixLSA Uses

type InterAreaPrefixLSA struct {
    Metric        uint32
    PrefixLength  uint8
    PrefixOptions uint8
    AddressPrefix []byte
}

InterAreaPrefixLSA is the struct from RFC 5340 A.4.5.

type InterAreaRouterLSA Uses

type InterAreaRouterLSA struct {
    Options             uint32
    Metric              uint32
    DestinationRouterID uint32
}

InterAreaRouterLSA is the struct from RFC 5340 A.4.6.

type IntraAreaPrefixLSA Uses

type IntraAreaPrefixLSA struct {
    NumOfPrefixes  uint16
    RefLSType      uint16
    RefLinkStateID uint32
    RefAdvRouter   uint32
    Prefixes       []Prefix
}

IntraAreaPrefixLSA is the struct from RFC 5340 A.4.10.

type LCM Uses

type LCM struct {
    // Common (short & fragmented header) fields
    Magic          uint32
    SequenceNumber uint32
    // Fragmented header only fields
    PayloadSize    uint32
    FragmentOffset uint32
    FragmentNumber uint16
    TotalFragments uint16
    // Common field
    ChannelName string
    // Gopacket helper fields
    Fragmented bool
    // contains filtered or unexported fields
}

LCM (Lightweight Communications and Marshalling) is a set of libraries and tools for message passing and data marshalling, targeted at real-time systems where high-bandwidth and low latency are critical. It provides a publish/subscribe message passing model and automatic marshalling/unmarshalling code generation with bindings for applications in a variety of programming languages.

References

https://lcm-proj.github.io/
https://github.com/lcm-proj/lcm

func (LCM) CanDecode Uses

func (lcm LCM) CanDecode() gopacket.LayerClass

CanDecode returns a set of layers that LCM objects can decode. As LCM objects can only decode the LCM layer, we just return that layer.

func (*LCM) DecodeFromBytes Uses

func (lcm *LCM) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (LCM) Fingerprint Uses

func (lcm LCM) Fingerprint() LCMFingerprint

Fingerprint returns the LCM fingerprint of the underlying message.

func (LCM) LayerContents Uses

func (lcm LCM) LayerContents() []byte

LayerContents returns the contents of the LCM header.

func (LCM) LayerPayload Uses

func (lcm LCM) LayerPayload() []byte

LayerPayload returns the payload following this LCM header.

func (LCM) LayerType Uses

func (lcm LCM) LayerType() gopacket.LayerType

LayerType returns LayerTypeLCM

func (LCM) NextLayerType Uses

func (lcm LCM) NextLayerType() gopacket.LayerType

NextLayerType specifies the LCM payload layer type following this header. As LCM packets are serialized structs with uniq fingerprints for each uniq combination of data types, lookup of correct layer type is based on that fingerprint.

func (LCM) Payload Uses

func (lcm LCM) Payload() []byte

Payload returns the payload following this LCM header.

type LCMFingerprint Uses

type LCMFingerprint uint64

LCMFingerprint is the type of a LCM fingerprint.

func SupportedLCMFingerprints Uses

func SupportedLCMFingerprints() []LCMFingerprint

SupportedLCMFingerprints returns a slice of all LCM fingerprints that has been registered so far.

type LLC Uses

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) CanDecode Uses

func (l *LLC) CanDecode() gopacket.LayerClass

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

func (*LLC) DecodeFromBytes Uses

func (l *LLC) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

DecodeFromBytes decodes the given bytes into this layer.

func (*LLC) LayerType Uses

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

LayerType returns gopacket.LayerTypeLLC.

func (*LLC) NextLayerType Uses

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

NextLayerType returns the layer type contained by this DecodingLayer.

func (*LLC) SerializeTo Uses

func (l *LLC) 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 LLDPApplicationType Uses

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 Uses

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

type LLDPCapabilities Uses

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 Uses

type LLDPChassisID struct {
    Subtype LLDPChassisIDSubType
    ID      []byte
}

type LLDPChassisIDSubType Uses

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 Uses

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

type LLDPCisco2Subtype Uses

type LLDPCisco2Subtype uint8
const (
    LLDPCisco2PowerViaMDI LLDPCisco2Subtype = 1
)

Cisco2 TLV Subtypes

type LLDPEVBCapabilities Uses

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

LLDPEVBCapabilities represents the EVB capabilities of a device

type LLDPEVBSettings Uses

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

type LLDPInfo8021 Uses

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 Uses

type LLDPInfo8021Qbg struct {
    EVBSettings LLDPEVBSettings
}

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

type LLDPInfo8023 Uses

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

LLDPInfo8023 represents the information carried in 802.3 Org-specific TLVs

type LLDPInfoCisco2 Uses

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

LLDPInfoCisco2 represents the information carried in Cisco Org-specific TLVs

type LLDPInfoMedia Uses

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 Uses

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 Uses

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

LLDP Interface Subtypes

func (LLDPInterfaceSubtype) String Uses

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

type LLDPLinkAggregation Uses

type LLDPLinkAggregation struct {
    Supported bool
    Enabled   bool
    PortID    uint32
}

IEEE 802 Link Aggregation parameters

type LLDPLocation Uses

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 Uses

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

type LLDPLocationAddressLine Uses

type LLDPLocationAddressLine struct {
    Type  LLDPLocationAddressType
    Value string
}

type LLDPLocationAddressType Uses

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 Uses

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

type LLDPLocationAddressWhat Uses

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

type LLDPLocationCoordinate Uses

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

type LLDPLocationECS Uses

type LLDPLocationECS struct {
    ELIN string
}

type LLDPLocationFormat Uses

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

func (LLDPLocationFormat) String Uses

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

type LLDPMACPHYConfigStatus Uses

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

type LLDPMediaCapabilities Uses

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 Uses

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 Uses

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

type LLDPMediaSubtype Uses

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 Uses

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

type LLDPMgmtAddress Uses

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

type LLDPNetworkPolicy Uses

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

type LLDPOrgSpecificTLV Uses

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

LLDPOrgSpecificTLV is an Organisation-specific TLV

type LLDPPNIODelay Uses

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

type LLDPPNIOMRPPortStatus Uses

type LLDPPNIOMRPPortStatus struct {
    UUID   []byte
    Status uint16
}

type LLDPPNIOPTCPStatus Uses

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 Uses

type LLDPPNIOPortStatus struct {
    Class2 uint16
    Class3 uint16
}

type LLDPPortID Uses

type LLDPPortID struct {
    Subtype LLDPPortIDSubType
    ID      []byte
}

type LLDPPortIDSubType Uses

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 Uses

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

type LLDPPowerPriority Uses

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

func (LLDPPowerPriority) String Uses

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

type LLDPPowerSource Uses

type LLDPPowerSource byte

func (LLDPPowerSource) String Uses

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

type LLDPPowerType Uses

type LLDPPowerType byte

func (LLDPPowerType) String Uses

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

type LLDPPowerViaMDI Uses

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

type LLDPPowerViaMDI8023 Uses

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 Uses

type LLDPProfinetSubtype uint8

Profinet Subtypes

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

type LLDPSysCapabilities Uses

type LLDPSysCapabilities struct {
    SystemCap  LLDPCapabilities
    EnabledCap LLDPCapabilities
}

type LLDPTLVType Uses

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 Uses

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

type LSA Uses

type LSA struct {
    LSAheader
    Content interface{}
}

LSA links LSAheader with the structs from RFC 5340 A.4.

type LSAheader Uses

type LSAheader struct {
    LSAge       uint16
    LSType      uint16
    LinkStateID uint32
    AdvRouter   uint32
    LSSeqNumber uint32
    LSChecksum  uint16
    Length      uint16
    LSOptions   uint8
}

LSAheader is the struct from RFC 5340 A.4.2 and RFC 2328 A.4.1.

type LSReq Uses

type LSReq struct {
    LSType    uint16
    LSID      uint32
    AdvRouter uint32
}

LSReq is the struct from RFC 5340 A.3.4.

type LSUpdate Uses

type LSUpdate struct {
    NumOfLSAs uint32
    LSAs      []LSA
}

LSUpdate is the struct from RFC 5340 A.3.5.

type LinkLSA Uses

type LinkLSA struct {
    RtrPriority      uint8
    Options          uint32
    LinkLocalAddress []byte
    NumOfPrefixes    uint32
    Prefixes         []Prefix
}

LinkLSA is the struct from RFC 5340 A.4.9.

type LinkLayerDiscovery Uses

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 Uses

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

LayerType returns gopacket.LayerTypeLinkLayerDiscovery.

func (*LinkLayerDiscovery) SerializeTo Uses

func (c *LinkLayerDiscovery) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error

SerializeTo serializes LLDP packet to bytes and writes on SerializeBuffer.

type LinkLayerDiscoveryInfo Uses

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 Uses

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

func (*LinkLayerDiscoveryInfo) Decode8021Qbg Uses

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

func (*LinkLayerDiscoveryInfo) Decode8023 Uses

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

func (*LinkLayerDiscoveryInfo) DecodeCisco2 Uses

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

func (*LinkLayerDiscoveryInfo) DecodeMedia Uses

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

func (*LinkLayerDiscoveryInfo) DecodeProfinet Uses

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

func (*LinkLayerDiscoveryInfo) LayerType Uses

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

LayerType returns gopacket.LayerTypeLinkLayerDiscoveryInfo.

type LinkLayerDiscoveryValue Uses

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

LinkLayerDiscoveryValue is a TLV value inside a LinkLayerDiscovery packet layer.

type LinkType Uses

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) and http://www.tcpdump.org/linktypes.html
    LinkTypeNull           LinkType = 0
    LinkTypeEthernet       LinkType = 1
    LinkTypeAX25           LinkType = 3
    LinkTypeTokenRing      LinkType = 6
    LinkTypeArcNet         LinkType = 7
    LinkTypeSLIP           LinkType = 8
    LinkTypePPP            LinkType = 9
    LinkTypeFDDI           LinkType = 10
    LinkTypePPP_HDLC       LinkType = 50
    LinkTypePPPEthernet    LinkType = 51
    LinkTypeATM_RFC1483    LinkType = 100
    LinkTypeRaw            LinkType = 101
    LinkTypeC_HDLC         LinkType = 104
    LinkTypeIEEE802_11     LinkType = 105
    LinkTypeFRelay         LinkType = 107
    LinkTypeLoop           LinkType = 108
    LinkTypeLinuxSLL       LinkType = 113
    LinkTypeLTalk          LinkType = 114
    LinkTypePFLog          LinkType = 117
    LinkTypePrismHeader    LinkType = 119
    LinkTypeIPOverFC       LinkType = 122
    LinkTypeSunATM         LinkType = 123
    LinkTypeIEEE80211Radio LinkType = 127
    LinkTypeARCNetLinux    LinkType = 129
    LinkTypeIPOver1394     LinkType = 138
    LinkTypeMTP2Phdr       LinkType = 139
    LinkTypeMTP2           LinkType = 140
    LinkTypeMTP3           LinkType = 141
    LinkTypeSCCP           LinkType = 142
    LinkTypeDOCSIS         LinkType = 143
    LinkTypeLinuxIRDA      LinkType = 144
    LinkTypeLinuxLAPD      LinkType = 177
    LinkTypeLinuxUSB       LinkType = 220
    LinkTypeIPv4           LinkType = 228
    LinkTypeIPv6           LinkType = 229
)

func (LinkType) Decode Uses

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

Decoder calls LinkTypeMetadata.DecodeWith's decoder.

func (LinkType) LayerType Uses

func (a LinkType) LayerType() gopacket.LayerType

LayerType returns LinkTypeMetadata.LayerType.

func (LinkType) String Uses

func (a LinkType) String() string

String returns LinkTypeMetadata.Name.

type LinuxSLL Uses

type LinuxSLL struct {
    BaseLayer
    PacketType   LinuxSLLPacketType
    AddrLen      uint16
    Addr         net.HardwareAddr
    EthernetType EthernetType
}

func (*LinuxSLL) CanDecode Uses

func (sll *LinuxSLL) CanDecode() gopacket.LayerClass

func (*LinuxSLL) DecodeFromBytes Uses

func (sll *LinuxSLL) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error

func (*LinuxSLL) LayerType Uses

func (sll *LinuxSLL) LayerType() gopacket.LayerType

LayerType returns LayerTypeLinuxSLL.

func (*LinuxSLL) LinkFlow Uses

func (sll *LinuxSLL) LinkFlow() gopacket.Flow

func (*LinuxSLL) NextLayerType Uses

func (sll *LinuxSLL) NextLayerType() gopacket.LayerType

type LinuxSLLPacketType Uses

type LinuxSLLPacketType uint16