github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-07-06 04:52:10 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix: updated gopacket to fix compilation issues on macOS (ref #357)

Browse source
This commit is contained in:
evilsocket 2018-10-12 18:11:01 +02:00
parent 5be3fcbf20
commit a95ae94957
23 changed files with 1625 additions and 205 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Gopkg.lock generated
View file

@ -106,7 +106,7 @@
version = "v1.0.0" version = "v1.0.0"
[[projects]] [[projects]]
digest = "1:eebcd2c096c6e4dada58e468e794146753d035fed7150cc0e2ff79ef28650709" digest = "1:65e00adfb37f64ce3c24f139bc73db70bfe45224ebaf88250eff4038e32ac9cf"
name = "github.com/google/gopacket" name = "github.com/google/gopacket"
packages = [ packages = [
".", ".",
@ -115,8 +115,7 @@
"pcapgo", "pcapgo",
] ]
pruneopts = "UT" pruneopts = "UT"
revision = "a6b099ece4680a8bdea84fa78166d0712108a95c" revision = "d67ddb98d5a1b7c79a8977ec2d552e1db45eda86"
version = "v1.1.15"
[[projects]] [[projects]]
digest = "1:c79fb010be38a59d657c48c6ba1d003a8aa651fa56b579d959d74573b7dff8e1" digest = "1:c79fb010be38a59d657c48c6ba1d003a8aa651fa56b579d959d74573b7dff8e1"

2
Gopkg.toml
View file

@ -55,7 +55,7 @@
[[constraint]] [[constraint]]
name = "github.com/google/gopacket" name = "github.com/google/gopacket"
version = "1.1.15" revision = "d67ddb98d5a1b7c79a8977ec2d552e1db45eda86"
[[constraint]] [[constraint]]
name = "github.com/gorilla/mux" name = "github.com/gorilla/mux"

3
packets/dhcp6_layer.go
View file

@ -2,12 +2,15 @@ package packets
import ( import (
"github.com/google/gopacket" "github.com/google/gopacket"
"github.com/google/gopacket/layers"
) )
type DHCPv6Layer struct { type DHCPv6Layer struct {
Raw []byte Raw []byte
} }
func (l *DHCPv6Layer) LayerType() gopacket.LayerType { return layers.LayerTypeDHCPv6 }
func (l DHCPv6Layer) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { func (l DHCPv6Layer) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
bytes, err := b.PrependBytes(len(l.Raw)) bytes, err := b.PrependBytes(len(l.Raw))
if err != nil { if err != nil {

2
vendor/github.com/google/gopacket/AUTHORS generated vendored
View file

@ -13,6 +13,7 @@ Hiroaki Kawai <Hiroaki.Kawai@gmail.com>
Lukas Lueg <lukas.lueg@gmail.com> Lukas Lueg <lukas.lueg@gmail.com>
Laurent Hausermann <laurent.hausermann@gmail.com> Laurent Hausermann <laurent.hausermann@gmail.com>
Bill Green <bgreen@newrelic.com> Bill Green <bgreen@newrelic.com>
Christian Mäder <christian.maeder@nine.ch>
CONTRIBUTORS: CONTRIBUTORS:
Attila Oláh <attila@attilaolah.eu> Attila Oláh <attila@attilaolah.eu>
@ -26,6 +27,7 @@ Satoshi Matsumoto <kaorimatz@gmail.com>
David Stainton <dstainton415@gmail.com> David Stainton <dstainton415@gmail.com>
Jesse Ward <jesse@jesseward.com> Jesse Ward <jesse@jesseward.com>
Kane Mathers <kane@kanemathers.name> Kane Mathers <kane@kanemathers.name>
Jose Selvi <jselvi@pentester.es>
----------------------------------------------- -----------------------------------------------
FORKED FROM github.com/akrennmair/gopcap FORKED FROM github.com/akrennmair/gopcap

6
vendor/github.com/google/gopacket/layers/.lint_blacklist generated vendored
View file

@ -27,6 +27,12 @@ sctp.go
sflow.go sflow.go
tcp.go tcp.go
tcpip.go tcpip.go
tls.go
tls_alert.go
tls_appdata.go
tls_cipherspec.go
tls_hanshake.go
tls_test.go
udp.go udp.go
udplite.go udplite.go
usb.go usb.go

2
vendor/github.com/google/gopacket/layers/dhcpv6.go generated vendored
View file

@ -188,7 +188,7 @@ func decodeDHCPv6(data []byte, p gopacket.PacketBuilder) error {
} }
// DHCPv6StatusCode represents a DHCP status code - RFC-3315 // DHCPv6StatusCode represents a DHCP status code - RFC-3315
type DHCPv6StatusCode byte type DHCPv6StatusCode uint16
// Constants for the DHCPv6StatusCode. // Constants for the DHCPv6StatusCode.
const ( const (

24
vendor/github.com/google/gopacket/layers/geneve.go generated vendored
View file

@ -8,6 +8,7 @@ package layers
import ( import (
"encoding/binary" "encoding/binary"
"errors"
"github.com/google/gopacket" "github.com/google/gopacket"
) )
@ -52,19 +53,25 @@ func (gn *Geneve) LayerType() gopacket.LayerType { return LayerTypeGeneve }
func decodeGeneveOption(data []byte, gn *Geneve) (*GeneveOption, uint8) { func decodeGeneveOption(data []byte, gn *Geneve) (*GeneveOption, uint8) {
opt := &GeneveOption{} opt := &GeneveOption{}
opt.Class = binary.BigEndian.Uint16(data[0:1]) opt.Class = binary.BigEndian.Uint16(data[0:2])
opt.Type = data[2] opt.Type = data[2]
opt.Flags = data[3] >> 4 opt.Flags = data[3] >> 4
opt.Length = data[3] & 0xf opt.Length = (data[3]&0xf)*4 + 4
opt.Data = make([]byte, opt.Length-4)
copy(opt.Data, data[4:opt.Length]) copy(opt.Data, data[4:opt.Length])
return opt, 4 + opt.Length return opt, opt.Length
} }
func (gn *Geneve) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { func (gn *Geneve) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
if len(data) < 7 {
df.SetTruncated()
return errors.New("geneve packet too short")
}
gn.Version = data[0] >> 7 gn.Version = data[0] >> 7
gn.OptionsLength = data[0] & 0x3f gn.OptionsLength = (data[0] & 0x3f) * 4
gn.OAMPacket = data[1]&0x80 > 0 gn.OAMPacket = data[1]&0x80 > 0
gn.CriticalOption = data[1]&0x40 > 0 gn.CriticalOption = data[1]&0x40 > 0
@ -74,12 +81,17 @@ func (gn *Geneve) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error
copy(buf[1:], data[4:7]) copy(buf[1:], data[4:7])
gn.VNI = binary.BigEndian.Uint32(buf[:]) gn.VNI = binary.BigEndian.Uint32(buf[:])
offset, length := uint8(8), gn.OptionsLength offset, length := uint8(8), int32(gn.OptionsLength)
if len(data) < int(length+7) {
df.SetTruncated()
return errors.New("geneve packet too short")
}
for length > 0 { for length > 0 {
opt, len := decodeGeneveOption(data[offset:], gn) opt, len := decodeGeneveOption(data[offset:], gn)
gn.Options = append(gn.Options, opt) gn.Options = append(gn.Options, opt)
length -= len length -= int32(len)
offset += len offset += len
} }

21
vendor/github.com/google/gopacket/layers/icmp6.go generated vendored
View file

@ -24,12 +24,21 @@ const (
ICMPv6TypeParameterProblem = 4 ICMPv6TypeParameterProblem = 4
ICMPv6TypeEchoRequest = 128 ICMPv6TypeEchoRequest = 128
ICMPv6TypeEchoReply = 129 ICMPv6TypeEchoReply = 129
// The following are from RFC 4861 // The following are from RFC 4861
ICMPv6TypeRouterSolicitation = 133 ICMPv6TypeRouterSolicitation = 133
ICMPv6TypeRouterAdvertisement = 134 ICMPv6TypeRouterAdvertisement = 134
ICMPv6TypeNeighborSolicitation = 135 ICMPv6TypeNeighborSolicitation = 135
ICMPv6TypeNeighborAdvertisement = 136 ICMPv6TypeNeighborAdvertisement = 136
ICMPv6TypeRedirect = 137 ICMPv6TypeRedirect = 137
// The following are from RFC 2710
ICMPv6TypeMLDv1MulticastListenerQueryMessage = 130
ICMPv6TypeMLDv1MulticastListenerReportMessage = 131
ICMPv6TypeMLDv1MulticastListenerDoneMessage = 132
// The following are from RFC 3810
ICMPv6TypeMLDv2MulticastListenerReportMessageV2 = 143
) )
const ( const (
@ -234,6 +243,18 @@ func (i *ICMPv6) NextLayerType() gopacket.LayerType {
return LayerTypeICMPv6NeighborAdvertisement return LayerTypeICMPv6NeighborAdvertisement
case ICMPv6TypeRedirect: case ICMPv6TypeRedirect:
return LayerTypeICMPv6Redirect return LayerTypeICMPv6Redirect
case ICMPv6TypeMLDv1MulticastListenerQueryMessage: // Same Code for MLDv1 Query and MLDv2 Query
if len(i.Payload) > 20 { // Only payload size differs
return LayerTypeMLDv2MulticastListenerQuery
} else {
return LayerTypeMLDv1MulticastListenerQuery
}
case ICMPv6TypeMLDv1MulticastListenerDoneMessage:
return LayerTypeMLDv1MulticastListenerDone
case ICMPv6TypeMLDv1MulticastListenerReportMessage:
return LayerTypeMLDv1MulticastListenerReport
case ICMPv6TypeMLDv2MulticastListenerReportMessageV2:
return LayerTypeMLDv2MulticastListenerReport
} }
return gopacket.LayerTypePayload return gopacket.LayerTypePayload

153
vendor/github.com/google/gopacket/layers/ip6.go generated vendored
View file

@ -17,7 +17,8 @@ import (
) )
const ( const (
IPv6HopByHopOptionJumbogram = 0xC2 // RFC 2675 // IPv6HopByHopOptionJumbogram code as defined in RFC 2675
IPv6HopByHopOptionJumbogram = 0xC2
) )
const ( const (
@ -42,10 +43,11 @@ type IPv6 struct {
} }
// LayerType returns LayerTypeIPv6 // LayerType returns LayerTypeIPv6
func (i *IPv6) LayerType() gopacket.LayerType { return LayerTypeIPv6 } func (ipv6 *IPv6) LayerType() gopacket.LayerType { return LayerTypeIPv6 }
func (i *IPv6) NetworkFlow() gopacket.Flow { // NetworkFlow returns this new Flow (EndpointIPv6, SrcIP, DstIP)
return gopacket.NewFlow(EndpointIPv6, i.SrcIP, i.DstIP) func (ipv6 *IPv6) NetworkFlow() gopacket.Flow {
return gopacket.NewFlow(EndpointIPv6, ipv6.SrcIP, ipv6.DstIP)
} }
// Search for Jumbo Payload TLV in IPv6HopByHop and return (length, true) if found // Search for Jumbo Payload TLV in IPv6HopByHop and return (length, true) if found
@ -115,7 +117,7 @@ func setIPv6PayloadJumboLength(hbh []byte) error {
opt := hbh[offset] opt := hbh[offset]
if opt == 0 { if opt == 0 {
//Pad1 //Pad1
offset += 1 offset++
continue continue
} }
optLen := int(hbh[offset+1]) optLen := int(hbh[offset+1])
@ -134,7 +136,7 @@ func setIPv6PayloadJumboLength(hbh []byte) error {
// SerializeTo writes the serialized form of this layer into the // SerializeTo writes the serialized form of this layer into the
// SerializationBuffer, implementing gopacket.SerializableLayer. // SerializationBuffer, implementing gopacket.SerializableLayer.
// See the docs for gopacket.SerializableLayer for more info. // See the docs for gopacket.SerializableLayer for more info.
func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { func (ipv6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
var jumbo bool var jumbo bool
var err error var err error
@ -145,11 +147,11 @@ func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.Serialize
if opts.FixLengths { if opts.FixLengths {
// We need to set the length later because the hop-by-hop header may // We need to set the length later because the hop-by-hop header may
// not exist or else need padding, so pLen may yet change // not exist or else need padding, so pLen may yet change
addIPv6JumboOption(ip6) addIPv6JumboOption(ipv6)
} else if ip6.HopByHop == nil { } else if ipv6.HopByHop == nil {
return fmt.Errorf("Cannot fit payload length of %d into IPv6 packet", pLen) return fmt.Errorf("Cannot fit payload length of %d into IPv6 packet", pLen)
} else { } else {
_, ok, err := getIPv6HopByHopJumboLength(ip6.HopByHop) _, ok, err := getIPv6HopByHopJumboLength(ipv6.HopByHop)
if err != nil { if err != nil {
return err return err
} }
@ -158,12 +160,22 @@ func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.Serialize
} }
} }
} }
if ip6.HopByHop != nil {
if ip6.NextHeader != IPProtocolIPv6HopByHop { hbhAlreadySerialized := false
// Just fix it instead of throwing an error if ipv6.HopByHop != nil {
ip6.NextHeader = IPProtocolIPv6HopByHop for _, l := range b.Layers() {
if l == LayerTypeIPv6HopByHop {
hbhAlreadySerialized = true
break
}
} }
err = ip6.HopByHop.SerializeTo(b, opts) }
if ipv6.HopByHop != nil && !hbhAlreadySerialized {
if ipv6.NextHeader != IPProtocolIPv6HopByHop {
// Just fix it instead of throwing an error
ipv6.NextHeader = IPProtocolIPv6HopByHop
}
err = ipv6.HopByHop.SerializeTo(b, opts)
if err != nil { if err != nil {
return err return err
} }
@ -176,6 +188,7 @@ func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.Serialize
} }
} }
} }
if !jumbo && pLen > ipv6MaxPayloadLength { if !jumbo && pLen > ipv6MaxPayloadLength {
return errors.New("Cannot fit payload into IPv6 header") return errors.New("Cannot fit payload into IPv6 header")
} }
@ -183,90 +196,94 @@ func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.Serialize
if err != nil { if err != nil {
return err return err
} }
bytes[0] = (ip6.Version << 4) | (ip6.TrafficClass >> 4) bytes[0] = (ipv6.Version << 4) | (ipv6.TrafficClass >> 4)
bytes[1] = (ip6.TrafficClass << 4) | uint8(ip6.FlowLabel>>16) bytes[1] = (ipv6.TrafficClass << 4) | uint8(ipv6.FlowLabel>>16)
binary.BigEndian.PutUint16(bytes[2:], uint16(ip6.FlowLabel)) binary.BigEndian.PutUint16(bytes[2:], uint16(ipv6.FlowLabel))
if opts.FixLengths { if opts.FixLengths {
if jumbo { if jumbo {
ip6.Length = 0 ipv6.Length = 0
} else { } else {
ip6.Length = uint16(pLen) ipv6.Length = uint16(pLen)
} }
} }
binary.BigEndian.PutUint16(bytes[4:], ip6.Length) binary.BigEndian.PutUint16(bytes[4:], ipv6.Length)
bytes[6] = byte(ip6.NextHeader) bytes[6] = byte(ipv6.NextHeader)
bytes[7] = byte(ip6.HopLimit) bytes[7] = byte(ipv6.HopLimit)
if err := ip6.AddressTo16(); err != nil { if err := ipv6.AddressTo16(); err != nil {
return err return err
} }
copy(bytes[8:], ip6.SrcIP) copy(bytes[8:], ipv6.SrcIP)
copy(bytes[24:], ip6.DstIP) copy(bytes[24:], ipv6.DstIP)
return nil return nil
} }
func (ip6 *IPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { // DecodeFromBytes implementation according to gopacket.DecodingLayer
ip6.Version = uint8(data[0]) >> 4 func (ipv6 *IPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
ip6.TrafficClass = uint8((binary.BigEndian.Uint16(data[0:2]) >> 4) & 0x00FF) ipv6.Version = uint8(data[0]) >> 4
ip6.FlowLabel = binary.BigEndian.Uint32(data[0:4]) & 0x000FFFFF ipv6.TrafficClass = uint8((binary.BigEndian.Uint16(data[0:2]) >> 4) & 0x00FF)
ip6.Length = binary.BigEndian.Uint16(data[4:6]) ipv6.FlowLabel = binary.BigEndian.Uint32(data[0:4]) & 0x000FFFFF
ip6.NextHeader = IPProtocol(data[6]) ipv6.Length = binary.BigEndian.Uint16(data[4:6])
ip6.HopLimit = data[7] ipv6.NextHeader = IPProtocol(data[6])
ip6.SrcIP = data[8:24] ipv6.HopLimit = data[7]
ip6.DstIP = data[24:40] ipv6.SrcIP = data[8:24]
ip6.HopByHop = nil ipv6.DstIP = data[24:40]
ip6.BaseLayer = BaseLayer{data[:40], data[40:]} ipv6.HopByHop = nil
ipv6.BaseLayer = BaseLayer{data[:40], data[40:]}
// We treat a HopByHop IPv6 option as part of the IPv6 packet, since its // We treat a HopByHop IPv6 option as part of the IPv6 packet, since its
// options are crucial for understanding what's actually happening per packet. // options are crucial for understanding what's actually happening per packet.
if ip6.NextHeader == IPProtocolIPv6HopByHop { if ipv6.NextHeader == IPProtocolIPv6HopByHop {
err := ip6.hbh.DecodeFromBytes(ip6.Payload, df) err := ipv6.hbh.DecodeFromBytes(ipv6.Payload, df)
if err != nil { if err != nil {
return err return err
} }
ip6.HopByHop = &ip6.hbh ipv6.HopByHop = &ipv6.hbh
pEnd, jumbo, err := getIPv6HopByHopJumboLength(ip6.HopByHop) pEnd, jumbo, err := getIPv6HopByHopJumboLength(ipv6.HopByHop)
if err != nil { if err != nil {
return err return err
} }
if jumbo && ip6.Length == 0 { if jumbo && ipv6.Length == 0 {
pEnd := int(pEnd) pEnd := int(pEnd)
if pEnd > len(ip6.Payload) { if pEnd > len(ipv6.Payload) {
df.SetTruncated() df.SetTruncated()
pEnd = len(ip6.Payload) pEnd = len(ipv6.Payload)
} }
ip6.Payload = ip6.Payload[:pEnd] ipv6.Payload = ipv6.Payload[:pEnd]
return nil return nil
} else if jumbo && ip6.Length != 0 { } else if jumbo && ipv6.Length != 0 {
return errors.New("IPv6 has jumbo length and IPv6 length is not 0") return errors.New("IPv6 has jumbo length and IPv6 length is not 0")
} else if !jumbo && ip6.Length == 0 { } else if !jumbo && ipv6.Length == 0 {
return errors.New("IPv6 length 0, but HopByHop header does not have jumbogram option") return errors.New("IPv6 length 0, but HopByHop header does not have jumbogram option")
} else { } else {
ip6.Payload = ip6.Payload[ip6.hbh.ActualLength:] ipv6.Payload = ipv6.Payload[ipv6.hbh.ActualLength:]
} }
} }
if ip6.Length == 0 { if ipv6.Length == 0 {
return fmt.Errorf("IPv6 length 0, but next header is %v, not HopByHop", ip6.NextHeader) return fmt.Errorf("IPv6 length 0, but next header is %v, not HopByHop", ipv6.NextHeader)
} else {
pEnd := int(ip6.Length)
if pEnd > len(ip6.Payload) {
df.SetTruncated()
pEnd = len(ip6.Payload)
}
ip6.Payload = ip6.Payload[:pEnd]
} }
pEnd := int(ipv6.Length)
if pEnd > len(ipv6.Payload) {
df.SetTruncated()
pEnd = len(ipv6.Payload)
}
ipv6.Payload = ipv6.Payload[:pEnd]
return nil return nil
} }
func (i *IPv6) CanDecode() gopacket.LayerClass { // CanDecode implementation according to gopacket.DecodingLayer
func (ipv6 *IPv6) CanDecode() gopacket.LayerClass {
return LayerTypeIPv6 return LayerTypeIPv6
} }
func (i *IPv6) NextLayerType() gopacket.LayerType { // NextLayerType implementation according to gopacket.DecodingLayer
if i.HopByHop != nil { func (ipv6 *IPv6) NextLayerType() gopacket.LayerType {
return i.HopByHop.NextHeader.LayerType() if ipv6.HopByHop != nil {
return ipv6.HopByHop.NextHeader.LayerType()
} }
return i.NextHeader.LayerType() return ipv6.NextHeader.LayerType()
} }
func decodeIPv6(data []byte, p gopacket.PacketBuilder) error { func decodeIPv6(data []byte, p gopacket.PacketBuilder) error {
@ -403,6 +420,7 @@ type IPv6ExtensionSkipper struct {
BaseLayer BaseLayer
} }
// DecodeFromBytes implementation according to gopacket.DecodingLayer
func (i *IPv6ExtensionSkipper) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { func (i *IPv6ExtensionSkipper) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
extension := decodeIPv6ExtensionBase(data) extension := decodeIPv6ExtensionBase(data)
i.BaseLayer = BaseLayer{data[:extension.ActualLength], data[extension.ActualLength:]} i.BaseLayer = BaseLayer{data[:extension.ActualLength], data[extension.ActualLength:]}
@ -410,10 +428,12 @@ func (i *IPv6ExtensionSkipper) DecodeFromBytes(data []byte, df gopacket.DecodeFe
return nil return nil
} }
// CanDecode implementation according to gopacket.DecodingLayer
func (i *IPv6ExtensionSkipper) CanDecode() gopacket.LayerClass { func (i *IPv6ExtensionSkipper) CanDecode() gopacket.LayerClass {
return LayerClassIPv6Extension return LayerClassIPv6Extension
} }
// NextLayerType implementation according to gopacket.DecodingLayer
func (i *IPv6ExtensionSkipper) NextLayerType() gopacket.LayerType { func (i *IPv6ExtensionSkipper) NextLayerType() gopacket.LayerType {
return i.NextHeader.LayerType() return i.NextHeader.LayerType()
} }
@ -430,6 +450,7 @@ type IPv6HopByHop struct {
// LayerType returns LayerTypeIPv6HopByHop. // LayerType returns LayerTypeIPv6HopByHop.
func (i *IPv6HopByHop) LayerType() gopacket.LayerType { return LayerTypeIPv6HopByHop } func (i *IPv6HopByHop) LayerType() gopacket.LayerType { return LayerTypeIPv6HopByHop }
// SerializeTo implementation according to gopacket.SerializableLayer
func (i *IPv6HopByHop) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { func (i *IPv6HopByHop) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
var bytes []byte var bytes []byte
var err error var err error
@ -462,6 +483,7 @@ func (i *IPv6HopByHop) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.Ser
return nil return nil
} }
// DecodeFromBytes implementation according to gopacket.DecodingLayer
func (i *IPv6HopByHop) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { func (i *IPv6HopByHop) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data) i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data)
offset := 2 offset := 2
@ -483,6 +505,7 @@ func decodeIPv6HopByHop(data []byte, p gopacket.PacketBuilder) error {
return p.NextDecoder(i.NextHeader) return p.NextDecoder(i.NextHeader)
} }
// SetJumboLength adds the IPv6HopByHopOptionJumbogram with the given length
func (o *IPv6HopByHopOption) SetJumboLength(len uint32) { func (o *IPv6HopByHopOption) SetJumboLength(len uint32) {
o.OptionType = IPv6HopByHopOptionJumbogram o.OptionType = IPv6HopByHopOptionJumbogram
o.OptionLength = 4 o.OptionLength = 4
@ -575,6 +598,7 @@ type IPv6Destination struct {
// LayerType returns LayerTypeIPv6Destination. // LayerType returns LayerTypeIPv6Destination.
func (i *IPv6Destination) LayerType() gopacket.LayerType { return LayerTypeIPv6Destination } func (i *IPv6Destination) LayerType() gopacket.LayerType { return LayerTypeIPv6Destination }
// DecodeFromBytes implementation according to gopacket.DecodingLayer
func (i *IPv6Destination) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { func (i *IPv6Destination) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data) i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data)
offset := 2 offset := 2
@ -641,11 +665,12 @@ func checkIPv6Address(addr net.IP) error {
return fmt.Errorf("wrong length of %d bytes instead of %d", len(addr), net.IPv6len) return fmt.Errorf("wrong length of %d bytes instead of %d", len(addr), net.IPv6len)
} }
func (ip *IPv6) AddressTo16() error { // AddressTo16 ensures IPv6.SrcIP and IPv6.DstIP are actually IPv6 addresses (i.e. 16 byte addresses)
if err := checkIPv6Address(ip.SrcIP); err != nil { func (ipv6 *IPv6) AddressTo16() error {
if err := checkIPv6Address(ipv6.SrcIP); err != nil {
return fmt.Errorf("Invalid source IPv6 address (%s)", err) return fmt.Errorf("Invalid source IPv6 address (%s)", err)
} }
if err := checkIPv6Address(ip.DstIP); err != nil { if err := checkIPv6Address(ipv6.DstIP); err != nil {
return fmt.Errorf("Invalid destination IPv6 address (%s)", err) return fmt.Errorf("Invalid destination IPv6 address (%s)", err)
} }
return nil return nil

271
vendor/github.com/google/gopacket/layers/layertypes.go generated vendored
View file

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

182
vendor/github.com/google/gopacket/layers/mldv1.go generated vendored Normal file
View file

@ -0,0 +1,182 @@
// Copyright 2018 GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"encoding/binary"
"errors"
"fmt"
"math"
"net"
"time"
"github.com/google/gopacket"
)
// MLDv1Message represents the common structure of all MLDv1 messages
type MLDv1Message struct {
BaseLayer
// 3.4. Maximum Response Delay
MaximumResponseDelay time.Duration
// 3.6. Multicast Address
// Zero in general query
// Specific IPv6 multicast address otherwise
MulticastAddress net.IP
}
// DecodeFromBytes decodes the given bytes into this layer.
func (m *MLDv1Message) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
if len(data) < 20 {
df.SetTruncated()
return errors.New("ICMP layer less than 20 bytes for Multicast Listener Query Message V1")
}
m.MaximumResponseDelay = time.Duration(binary.BigEndian.Uint16(data[0:2])) * time.Millisecond
// data[2:4] is reserved and not used in mldv1
m.MulticastAddress = data[4:20]
return nil
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (*MLDv1Message) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypeZero
}
// SerializeTo writes the serialized form of this layer into the
// SerializationBuffer, implementing gopacket.SerializableLayer.
// See the docs for gopacket.SerializableLayer for more info.
func (m *MLDv1Message) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
buf, err := b.PrependBytes(20)
if err != nil {
return err
}
if m.MaximumResponseDelay < 0 {
return errors.New("maximum response delay must not be negative")
}
dms := m.MaximumResponseDelay / time.Millisecond
if dms > math.MaxUint16 {
return fmt.Errorf("maximum response delay %dms is more than the allowed 65535ms", dms)
}
binary.BigEndian.PutUint16(buf[0:2], uint16(dms))
copy(buf[2:4], []byte{0x0, 0x0})
ma16 := m.MulticastAddress.To16()
if ma16 == nil {
return fmt.Errorf("invalid multicast address '%s'", m.MulticastAddress)
}
copy(buf[4:20], ma16)
return nil
}
// Sums this layer up nicely formatted
func (m *MLDv1Message) String() string {
return fmt.Sprintf(
"Maximum Response Delay: %dms, Multicast Address: %s",
m.MaximumResponseDelay/time.Millisecond,
m.MulticastAddress)
}
// MLDv1MulticastListenerQueryMessage are sent by the router to determine
// whether there are multicast listeners on the link.
// https://tools.ietf.org/html/rfc2710 Page 5
type MLDv1MulticastListenerQueryMessage struct {
MLDv1Message
}
// DecodeFromBytes decodes the given bytes into this layer.
func (m *MLDv1MulticastListenerQueryMessage) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
err := m.MLDv1Message.DecodeFromBytes(data, df)
if err != nil {
return err
}
if len(data) > 20 {
m.Payload = data[20:]
}
return nil
}
// LayerType returns LayerTypeMLDv1MulticastListenerQuery.
func (*MLDv1MulticastListenerQueryMessage) LayerType() gopacket.LayerType {
return LayerTypeMLDv1MulticastListenerQuery
}
// CanDecode returns the set of layer types that this DecodingLayer can decode.
func (*MLDv1MulticastListenerQueryMessage) CanDecode() gopacket.LayerClass {
return LayerTypeMLDv1MulticastListenerQuery
}
// IsGeneralQuery is true when this is a general query.
// In a Query message, the Multicast Address field is set to zero when
// sending a General Query.
// https://tools.ietf.org/html/rfc2710#section-3.6
func (m *MLDv1MulticastListenerQueryMessage) IsGeneralQuery() bool {
return net.IPv6zero.Equal(m.MulticastAddress)
}
// IsSpecificQuery is true when this is not a general query.
// In a Query message, the Multicast Address field is set to a specific
// IPv6 multicast address when sending a Multicast-Address-Specific Query.
// https://tools.ietf.org/html/rfc2710#section-3.6
func (m *MLDv1MulticastListenerQueryMessage) IsSpecificQuery() bool {
return !m.IsGeneralQuery()
}
// MLDv1MulticastListenerReportMessage is sent by a client listening on
// a specific multicast address to indicate that it is (still) listening
// on the specific multicast address.
// https://tools.ietf.org/html/rfc2710 Page 6
type MLDv1MulticastListenerReportMessage struct {
MLDv1Message
}
// LayerType returns LayerTypeMLDv1MulticastListenerReport.
func (*MLDv1MulticastListenerReportMessage) LayerType() gopacket.LayerType {
return LayerTypeMLDv1MulticastListenerReport
}
// CanDecode returns the set of layer types that this DecodingLayer can decode.
func (*MLDv1MulticastListenerReportMessage) CanDecode() gopacket.LayerClass {
return LayerTypeMLDv1MulticastListenerReport
}
// MLDv1MulticastListenerDoneMessage should be sent by a client when it ceases
// to listen to a multicast address on an interface.
// https://tools.ietf.org/html/rfc2710 Page 7
type MLDv1MulticastListenerDoneMessage struct {
MLDv1Message
}
// LayerType returns LayerTypeMLDv1MulticastListenerDone.
func (*MLDv1MulticastListenerDoneMessage) LayerType() gopacket.LayerType {
return LayerTypeMLDv1MulticastListenerDone
}
// CanDecode returns the set of layer types that this DecodingLayer can decode.
func (*MLDv1MulticastListenerDoneMessage) CanDecode() gopacket.LayerClass {
return LayerTypeMLDv1MulticastListenerDone
}
func decodeMLDv1MulticastListenerReport(data []byte, p gopacket.PacketBuilder) error {
m := &MLDv1MulticastListenerReportMessage{}
return decodingLayerDecoder(m, data, p)
}
func decodeMLDv1MulticastListenerQuery(data []byte, p gopacket.PacketBuilder) error {
m := &MLDv1MulticastListenerQueryMessage{}
return decodingLayerDecoder(m, data, p)
}
func decodeMLDv1MulticastListenerDone(data []byte, p gopacket.PacketBuilder) error {
m := &MLDv1MulticastListenerDoneMessage{}
return decodingLayerDecoder(m, data, p)
}

619
vendor/github.com/google/gopacket/layers/mldv2.go generated vendored Normal file
View file

@ -0,0 +1,619 @@
// Copyright 2018 GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"encoding/binary"
"errors"
"fmt"
"math"
"net"
"time"
"github.com/google/gopacket"
)
const (
// S Flag bit is 1
mldv2STrue uint8 = 0x8
// S Flag value mask
// mldv2STrue & mldv2SMask == mldv2STrue // true
// 0x1 & mldv2SMask == mldv2STrue // true
// 0x0 & mldv2SMask == mldv2STrue // false
mldv2SMask uint8 = 0x8
// QRV value mask
mldv2QRVMask uint8 = 0x7
)
// MLDv2MulticastListenerQueryMessage are sent by multicast routers to query the
// multicast listening state of neighboring interfaces.
// https://tools.ietf.org/html/rfc3810#section-5.1
//
// Some information, like Maximum Response Code and Multicast Address are in the
// previous layer LayerTypeMLDv1MulticastListenerQuery
type MLDv2MulticastListenerQueryMessage struct {
BaseLayer
// 5.1.3. Maximum Response Delay COde
MaximumResponseCode uint16
// 5.1.5. Multicast Address
// Zero in general query
// Specific IPv6 multicast address otherwise
MulticastAddress net.IP
// 5.1.7. S Flag (Suppress Router-Side Processing)
SuppressRoutersideProcessing bool
// 5.1.8. QRV (Querier's Robustness Variable)
QueriersRobustnessVariable uint8
// 5.1.9. QQIC (Querier's Query Interval Code)
QueriersQueryIntervalCode uint8
// 5.1.10. Number of Sources (N)
NumberOfSources uint16
// 5.1.11 Source Address [i]
SourceAddresses []net.IP
}
// DecodeFromBytes decodes the given bytes into this layer.
func (m *MLDv2MulticastListenerQueryMessage) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
if len(data) < 24 {
df.SetTruncated()
return errors.New("ICMP layer less than 24 bytes for Multicast Listener Query Message V2")
}
m.MaximumResponseCode = binary.BigEndian.Uint16(data[0:2])
// ignore data[2:4] as per https://tools.ietf.org/html/rfc3810#section-5.1.4
m.MulticastAddress = data[4:20]
m.SuppressRoutersideProcessing = (data[20] & mldv2SMask) == mldv2STrue
m.QueriersRobustnessVariable = data[20] & mldv2QRVMask
m.QueriersQueryIntervalCode = data[21]
m.NumberOfSources = binary.BigEndian.Uint16(data[22:24])
var end int
for i := uint16(0); i < m.NumberOfSources; i++ {
begin := 24 + (int(i) * 16)
end = begin + 16
if end > len(data) {
df.SetTruncated()
return fmt.Errorf("ICMP layer less than %d bytes for Multicast Listener Query Message V2", end)
}
m.SourceAddresses = append(m.SourceAddresses, data[begin:end])
}
return nil
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (*MLDv2MulticastListenerQueryMessage) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypeZero
}
// SerializeTo writes the serialized form of this layer into the
// SerializationBuffer, implementing gopacket.SerializableLayer.
// See the docs for gopacket.SerializableLayer for more info.
func (m *MLDv2MulticastListenerQueryMessage) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
if err := m.serializeSourceAddressesTo(b, opts); err != nil {
return err
}
buf, err := b.PrependBytes(24)
if err != nil {
return err
}
binary.BigEndian.PutUint16(buf[0:2], m.MaximumResponseCode)
copy(buf[2:4], []byte{0x00, 0x00}) // set reserved bytes to zero
ma16 := m.MulticastAddress.To16()
if ma16 == nil {
return fmt.Errorf("invalid MulticastAddress '%s'", m.MulticastAddress)
}
copy(buf[4:20], ma16)
byte20 := m.QueriersRobustnessVariable & mldv2QRVMask
if m.SuppressRoutersideProcessing {
byte20 |= mldv2STrue
} else {
byte20 &= ^mldv2STrue // the complement of mldv2STrue
}
byte20 &= 0x0F // set reserved bits to zero
buf[20] = byte20
binary.BigEndian.PutUint16(buf[22:24], m.NumberOfSources)
buf[21] = m.QueriersQueryIntervalCode
return nil
}
// writes each source address to the buffer preserving the order
func (m *MLDv2MulticastListenerQueryMessage) serializeSourceAddressesTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
numberOfSourceAddresses := len(m.SourceAddresses)
if numberOfSourceAddresses > math.MaxUint16 {
return fmt.Errorf(
"there are more than %d source addresses, but 65535 is the maximum number of supported addresses",
numberOfSourceAddresses)
}
if opts.FixLengths {
m.NumberOfSources = uint16(numberOfSourceAddresses)
}
lastSAIdx := numberOfSourceAddresses - 1
for k := range m.SourceAddresses {
i := lastSAIdx - k // reverse order
buf, err := b.PrependBytes(16)
if err != nil {
return err
}
sa16 := m.SourceAddresses[i].To16()
if sa16 == nil {
return fmt.Errorf("invalid source address [%d] '%s'", i, m.SourceAddresses[i])
}
copy(buf[0:16], sa16)
}
return nil
}
// String sums this layer up nicely formatted
func (m *MLDv2MulticastListenerQueryMessage) String() string {
return fmt.Sprintf(
"Maximum Response Code: %#x (%dms), Multicast Address: %s, Suppress Routerside Processing: %t, QRV: %#x, QQIC: %#x (%ds), Number of Source Address: %d (actual: %d), Source Addresses: %s",
m.MaximumResponseCode,
m.MaximumResponseDelay(),
m.MulticastAddress,
m.SuppressRoutersideProcessing,
m.QueriersRobustnessVariable,
m.QueriersQueryIntervalCode,
m.QQI()/time.Second,
m.NumberOfSources,
len(m.SourceAddresses),
m.SourceAddresses)
}
// LayerType returns LayerTypeMLDv2MulticastListenerQuery.
func (*MLDv2MulticastListenerQueryMessage) LayerType() gopacket.LayerType {
return LayerTypeMLDv2MulticastListenerQuery
}
// CanDecode returns the set of layer types that this DecodingLayer can decode.
func (*MLDv2MulticastListenerQueryMessage) CanDecode() gopacket.LayerClass {
return LayerTypeMLDv2MulticastListenerQuery
}
// QQI calculates the Querier's Query Interval based on the QQIC
// according to https://tools.ietf.org/html/rfc3810#section-5.1.9
func (m *MLDv2MulticastListenerQueryMessage) QQI() time.Duration {
data := m.QueriersQueryIntervalCode
if data < 128 {
return time.Second * time.Duration(data)
}
exp := uint16(data) & 0x70 >> 4
mant := uint16(data) & 0x0F
return time.Second * time.Duration(mant|0x1000<<(exp+3))
}
// SetQQI calculates and updates the Querier's Query Interval Code (QQIC)
// according to https://tools.ietf.org/html/rfc3810#section-5.1.9
func (m *MLDv2MulticastListenerQueryMessage) SetQQI(d time.Duration) error {
if d < 0 {
m.QueriersQueryIntervalCode = 0
return errors.New("QQI duration is negative")
}
if d == 0 {
m.QueriersQueryIntervalCode = 0
return nil
}
dms := d / time.Second
if dms < 128 {
m.QueriersQueryIntervalCode = uint8(dms)
}
if dms > 31744 { // mant=0xF, exp=0x7
m.QueriersQueryIntervalCode = 0xFF
return fmt.Errorf("QQI duration %ds is, maximum allowed is 31744s", dms)
}
value := uint16(dms) // ok, because 31744 < math.MaxUint16
exp := uint8(7)
for mask := uint16(0x4000); exp > 0; exp-- {
if mask&value != 0 {
break
}
mask >>= 1
}
mant := uint8(0x000F & (value >> (exp + 3)))
sig := uint8(0x10)
m.QueriersQueryIntervalCode = sig | exp<<4 | mant
return nil
}
// MaximumResponseDelay returns the Maximum Response Delay based on the
// Maximum Response Code according to
// https://tools.ietf.org/html/rfc3810#section-5.1.3
func (m *MLDv2MulticastListenerQueryMessage) MaximumResponseDelay() time.Duration {
if m.MaximumResponseCode < 0x8000 {
return time.Duration(m.MaximumResponseCode)
}
exp := m.MaximumResponseCode & 0x7000 >> 12
mant := m.MaximumResponseCode & 0x0FFF
return time.Millisecond * time.Duration(mant|0x1000<<(exp+3))
}
// SetMLDv2MaximumResponseDelay updates the Maximum Response Code according to
// https://tools.ietf.org/html/rfc3810#section-5.1.3
func (m *MLDv2MulticastListenerQueryMessage) SetMLDv2MaximumResponseDelay(d time.Duration) error {
if d == 0 {
m.MaximumResponseCode = 0
return nil
}
if d < 0 {
return errors.New("maximum response delay must not be negative")
}
dms := d / time.Millisecond
if dms < 32768 {
m.MaximumResponseCode = uint16(dms)
}
if dms > 4193280 { // mant=0xFFF, exp=0x7
return fmt.Errorf("maximum response delay %dms is bigger the than maximum of 4193280ms", dms)
}
value := uint32(dms) // ok, because 4193280 < math.MaxUint32
exp := uint8(7)
for mask := uint32(0x40000000); exp > 0; exp-- {
if mask&value != 0 {
break
}
mask >>= 1
}
mant := uint16(0x00000FFF & (value >> (exp + 3)))
sig := uint16(0x1000)
m.MaximumResponseCode = sig | uint16(exp)<<12 | mant
return nil
}
// MLDv2MulticastListenerReportMessage is sent by an IP node to report the
// current multicast listening state, or changes therein.
// https://tools.ietf.org/html/rfc3810#section-5.2
type MLDv2MulticastListenerReportMessage struct {
BaseLayer
// 5.2.3. Nr of Mcast Address Records
NumberOfMulticastAddressRecords uint16
// 5.2.4. Multicast Address Record [i]
MulticastAddressRecords []MLDv2MulticastAddressRecord
}
// DecodeFromBytes decodes the given bytes into this layer.
func (m *MLDv2MulticastListenerReportMessage) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
if len(data) < 4 {
df.SetTruncated()
return errors.New("ICMP layer less than 4 bytes for Multicast Listener Report Message V2")
}
// ignore data[0:2] as per RFC
// https://tools.ietf.org/html/rfc3810#section-5.2.1
m.NumberOfMulticastAddressRecords = binary.BigEndian.Uint16(data[2:4])
begin := 4
for i := uint16(0); i < m.NumberOfMulticastAddressRecords; i++ {
mar := MLDv2MulticastAddressRecord{}
read, err := mar.decode(data[begin:], df)
if err != nil {
return err
}
m.MulticastAddressRecords = append(m.MulticastAddressRecords, mar)
begin += read
}
return nil
}
// SerializeTo writes the serialized form of this layer into the
// SerializationBuffer, implementing gopacket.SerializableLayer.
// See the docs for gopacket.SerializableLayer for more info.
func (m *MLDv2MulticastListenerReportMessage) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
lastItemIdx := len(m.MulticastAddressRecords) - 1
for k := range m.MulticastAddressRecords {
i := lastItemIdx - k // reverse order
err := m.MulticastAddressRecords[i].serializeTo(b, opts)
if err != nil {
return err
}
}
if opts.FixLengths {
numberOfMAR := len(m.MulticastAddressRecords)
if numberOfMAR > math.MaxUint16 {
return fmt.Errorf(
"%d multicast address records added, but the maximum is 65535",
numberOfMAR)
}
m.NumberOfMulticastAddressRecords = uint16(numberOfMAR)
}
buf, err := b.PrependBytes(4)
if err != nil {
return err
}
copy(buf[0:2], []byte{0x0, 0x0})
binary.BigEndian.PutUint16(buf[2:4], m.NumberOfMulticastAddressRecords)
return nil
}
// Sums this layer up nicely formatted
func (m *MLDv2MulticastListenerReportMessage) String() string {
return fmt.Sprintf(
"Number of Mcast Addr Records: %d (actual %d), Multicast Address Records: %+v",
m.NumberOfMulticastAddressRecords,
len(m.MulticastAddressRecords),
m.MulticastAddressRecords)
}
// LayerType returns LayerTypeMLDv2MulticastListenerQuery.
func (*MLDv2MulticastListenerReportMessage) LayerType() gopacket.LayerType {
return LayerTypeMLDv2MulticastListenerReport
}
// CanDecode returns the set of layer types that this DecodingLayer can decode.
func (*MLDv2MulticastListenerReportMessage) CanDecode() gopacket.LayerClass {
return LayerTypeMLDv2MulticastListenerReport
}
// NextLayerType returns the layer type contained by this DecodingLayer.
func (*MLDv2MulticastListenerReportMessage) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypePayload
}
// MLDv2MulticastAddressRecordType holds the type of a
// Multicast Address Record, according to
// https://tools.ietf.org/html/rfc3810#section-5.2.5 and
// https://tools.ietf.org/html/rfc3810#section-5.2.12
type MLDv2MulticastAddressRecordType uint8
const (
// MLDv2MulticastAddressRecordTypeModeIsIncluded stands for
// MODE_IS_INCLUDE - indicates that the interface has a filter
// mode of INCLUDE for the specified multicast address.
MLDv2MulticastAddressRecordTypeModeIsIncluded MLDv2MulticastAddressRecordType = 1
// MLDv2MulticastAddressRecordTypeModeIsExcluded stands for
// MODE_IS_EXCLUDE - indicates that the interface has a filter
// mode of EXCLUDE for the specified multicast address.
MLDv2MulticastAddressRecordTypeModeIsExcluded MLDv2MulticastAddressRecordType = 2
// MLDv2MulticastAddressRecordTypeChangeToIncludeMode stands for
// CHANGE_TO_INCLUDE_MODE - indicates that the interface has
// changed to INCLUDE filter mode for the specified multicast
// address.
MLDv2MulticastAddressRecordTypeChangeToIncludeMode MLDv2MulticastAddressRecordType = 3
// MLDv2MulticastAddressRecordTypeChangeToExcludeMode stands for
// CHANGE_TO_EXCLUDE_MODE - indicates that the interface has
// changed to EXCLUDE filter mode for the specified multicast
// address
MLDv2MulticastAddressRecordTypeChangeToExcludeMode MLDv2MulticastAddressRecordType = 4
// MLDv2MulticastAddressRecordTypeAllowNewSources stands for
// ALLOW_NEW_SOURCES - indicates that the Source Address [i]
// fields in this Multicast Address Record contain a list of
// the additional sources that the node wishes to listen to,
// for packets sent to the specified multicast address.
MLDv2MulticastAddressRecordTypeAllowNewSources MLDv2MulticastAddressRecordType = 5
// MLDv2MulticastAddressRecordTypeBlockOldSources stands for
// BLOCK_OLD_SOURCES - indicates that the Source Address [i]
// fields in this Multicast Address Record contain a list of
// the sources that the node no longer wishes to listen to,
// for packets sent to the specified multicast address.
MLDv2MulticastAddressRecordTypeBlockOldSources MLDv2MulticastAddressRecordType = 6
)
// Human readable record types
// Naming follows https://tools.ietf.org/html/rfc3810#section-5.2.12
func (m MLDv2MulticastAddressRecordType) String() string {
switch m {
case MLDv2MulticastAddressRecordTypeModeIsIncluded:
return "MODE_IS_INCLUDE"
case MLDv2MulticastAddressRecordTypeModeIsExcluded:
return "MODE_IS_EXCLUDE"
case MLDv2MulticastAddressRecordTypeChangeToIncludeMode:
return "CHANGE_TO_INCLUDE_MODE"
case MLDv2MulticastAddressRecordTypeChangeToExcludeMode:
return "CHANGE_TO_EXCLUDE_MODE"
case MLDv2MulticastAddressRecordTypeAllowNewSources:
return "ALLOW_NEW_SOURCES"
case MLDv2MulticastAddressRecordTypeBlockOldSources:
return "BLOCK_OLD_SOURCES"
default:
return fmt.Sprintf("UNKNOWN(%d)", m)
}
}
// MLDv2MulticastAddressRecord contains information on the sender listening to a
// single multicast address on the interface the report is sent.
// https://tools.ietf.org/html/rfc3810#section-5.2.4
type MLDv2MulticastAddressRecord struct {
// 5.2.5. Record Type
RecordType MLDv2MulticastAddressRecordType
// 5.2.6. Auxiliary Data Length (number of 32-bit words)
AuxDataLen uint8
// 5.2.7. Number Of Sources (N)
N uint16
// 5.2.8. Multicast Address
MulticastAddress net.IP
// 5.2.9 Source Address [i]
SourceAddresses []net.IP
// 5.2.10 Auxiliary Data
AuxiliaryData []byte
}
// decodes a multicast address record from bytes
func (m *MLDv2MulticastAddressRecord) decode(data []byte, df gopacket.DecodeFeedback) (int, error) {
if len(data) < 4 {
df.SetTruncated()
return 0, errors.New(
"Multicast Listener Report Message V2 layer less than 4 bytes for Multicast Address Record")
}
m.RecordType = MLDv2MulticastAddressRecordType(data[0])
m.AuxDataLen = data[1]
m.N = binary.BigEndian.Uint16(data[2:4])
m.MulticastAddress = data[4:20]
for i := uint16(0); i < m.N; i++ {
begin := 20 + (int(i) * 16)
end := begin + 16
if len(data) < end {
df.SetTruncated()
return begin, fmt.Errorf(
"Multicast Listener Report Message V2 layer less than %d bytes for Multicast Address Record", end)
}
m.SourceAddresses = append(m.SourceAddresses, data[begin:end])
}
expectedLengthWithouAuxData := 20 + (int(m.N) * 16)
expectedTotalLength := (int(m.AuxDataLen) * 4) + expectedLengthWithouAuxData // *4 because AuxDataLen are 32bit words
if len(data) < expectedTotalLength {
return expectedLengthWithouAuxData, fmt.Errorf(
"Multicast Listener Report Message V2 layer less than %d bytes for Multicast Address Record",
expectedLengthWithouAuxData)
}
m.AuxiliaryData = data[expectedLengthWithouAuxData:expectedTotalLength]
return expectedTotalLength, nil
}
// String sums this layer up nicely formatted
func (m *MLDv2MulticastAddressRecord) String() string {
return fmt.Sprintf(
"RecordType: %d (%s), AuxDataLen: %d [32-bit words], N: %d, Multicast Address: %s, SourceAddresses: %s, Auxiliary Data: %#x",
m.RecordType,
m.RecordType.String(),
m.AuxDataLen,
m.N,
m.MulticastAddress.To16(),
m.SourceAddresses,
m.AuxiliaryData)
}
// serializes a multicast address record
func (m *MLDv2MulticastAddressRecord) serializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
if err := m.serializeAuxiliaryDataTo(b, opts); err != nil {
return err
}
if err := m.serializeSourceAddressesTo(b, opts); err != nil {
return err
}
buf, err := b.PrependBytes(20)
if err != nil {
return err
}
buf[0] = uint8(m.RecordType)
buf[1] = m.AuxDataLen
binary.BigEndian.PutUint16(buf[2:4], m.N)
ma16 := m.MulticastAddress.To16()
if ma16 == nil {
return fmt.Errorf("invalid multicast address '%s'", m.MulticastAddress)
}
copy(buf[4:20], ma16)
return nil
}
// serializes the auxiliary data of a multicast address record
func (m *MLDv2MulticastAddressRecord) serializeAuxiliaryDataTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
if remainder := len(m.AuxiliaryData) % 4; remainder != 0 {
zeroWord := []byte{0x0, 0x0, 0x0, 0x0}
m.AuxiliaryData = append(m.AuxiliaryData, zeroWord[:remainder]...)
}
if opts.FixLengths {
auxDataLen := len(m.AuxiliaryData) / 4
if auxDataLen > math.MaxUint8 {
return fmt.Errorf("auxilary data is %d 32-bit words, but the maximum is 255 32-bit words", auxDataLen)
}
m.AuxDataLen = uint8(auxDataLen)
}
buf, err := b.PrependBytes(len(m.AuxiliaryData))
if err != nil {
return err
}
copy(buf, m.AuxiliaryData)
return nil
}
// serializes the source addresses of a multicast address record preserving the order
func (m *MLDv2MulticastAddressRecord) serializeSourceAddressesTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
if opts.FixLengths {
numberOfSourceAddresses := len(m.SourceAddresses)
if numberOfSourceAddresses > math.MaxUint16 {
return fmt.Errorf(
"%d source addresses added, but the maximum is 65535",
numberOfSourceAddresses)
}
m.N = uint16(numberOfSourceAddresses)
}
lastItemIdx := len(m.SourceAddresses) - 1
for k := range m.SourceAddresses {
i := lastItemIdx - k // reverse order
buf, err := b.PrependBytes(16)
if err != nil {
return err
}
sa16 := m.SourceAddresses[i].To16()
if sa16 == nil {
return fmt.Errorf("invalid source address [%d] '%s'", i, m.SourceAddresses[i])
}
copy(buf, sa16)
}
return nil
}
func decodeMLDv2MulticastListenerReport(data []byte, p gopacket.PacketBuilder) error {
m := &MLDv2MulticastListenerReportMessage{}
return decodingLayerDecoder(m, data, p)
}
func decodeMLDv2MulticastListenerQuery(data []byte, p gopacket.PacketBuilder) error {
m := &MLDv2MulticastListenerQueryMessage{}
return decodingLayerDecoder(m, data, p)
}

11
vendor/github.com/google/gopacket/layers/ports.go generated vendored
View file

@ -60,7 +60,16 @@ func (a TCPPort) LayerType() gopacket.LayerType {
} }
var tcpPortLayerType = [65536]gopacket.LayerType{ var tcpPortLayerType = [65536]gopacket.LayerType{
53: LayerTypeDNS, 53: LayerTypeDNS,
443: LayerTypeTLS, // https
636: LayerTypeTLS, // ldaps
989: LayerTypeTLS, // ftps-data
990: LayerTypeTLS, // ftps
992: LayerTypeTLS, // telnets
993: LayerTypeTLS, // imaps
994: LayerTypeTLS, // ircs
995: LayerTypeTLS, // pop3s
5061: LayerTypeTLS, // ips
} }
// RegisterTCPPortLayerType creates a new mapping between a TCPPort // RegisterTCPPortLayerType creates a new mapping between a TCPPort

208
vendor/github.com/google/gopacket/layers/tls.go generated vendored Normal file
View file

@ -0,0 +1,208 @@
// Copyright 2018 The GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"encoding/binary"
"errors"
"github.com/google/gopacket"
)
// TLSType defines the type of data after the TLS Record
type TLSType uint8
// TLSType known values.
const (
TLSChangeCipherSpec TLSType = 20
TLSAlert TLSType = 21
TLSHandshake TLSType = 22
TLSApplicationData TLSType = 23
TLSUnknown TLSType = 255
)
// String shows the register type nicely formatted
func (tt TLSType) String() string {
switch tt {
default:
return "Unknown"
case TLSChangeCipherSpec:
return "Change Cipher Spec"
case TLSAlert:
return "Alert"
case TLSHandshake:
return "Handshake"
case TLSApplicationData:
return "Application Data"
}
}
// TLSVersion represents the TLS version in numeric format
type TLSVersion uint16
// Strings shows the TLS version nicely formatted
func (tv TLSVersion) String() string {
switch tv {
default:
return "Unknown"
case 0x0200:
return "SSL 2.0"
case 0x0300:
return "SSL 3.0"
case 0x0301:
return "TLS 1.0"
case 0x0302:
return "TLS 1.1"
case 0x0303:
return "TLS 1.2"
case 0x0304:
return "TLS 1.3"
}
}
// TLS is specified in RFC 5246
//
// TLS Record Protocol
// 0 1 2 3 4 5 6 7 8
// +--+--+--+--+--+--+--+--+
// | Content Type |
// +--+--+--+--+--+--+--+--+
// | Version (major) |
// +--+--+--+--+--+--+--+--+
// | Version (minor) |
// +--+--+--+--+--+--+--+--+
// | Length |
// +--+--+--+--+--+--+--+--+
// | Length |
// +--+--+--+--+--+--+--+--+
// TLS is actually a slide of TLSrecord structures
type TLS struct {
BaseLayer
// TLS Records
ChangeCipherSpec []TLSChangeCipherSpecRecord
Handshake []TLSHandshakeRecord
AppData []TLSAppDataRecord
Alert []TLSAlertRecord
}
// TLSRecordHeader contains all the information that each TLS Record types should have
type TLSRecordHeader struct {
ContentType TLSType
Version TLSVersion
Length uint16
}
// LayerType returns gopacket.LayerTypeTLS.
func (t *TLS) LayerType() gopacket.LayerType { return LayerTypeTLS }
// decodeTLS decodes the byte slice into a TLS type. It also
// setups the application Layer in PacketBuilder.
func decodeTLS(data []byte, p gopacket.PacketBuilder) error {
t := &TLS{}
err := t.DecodeFromBytes(data, p)
if err != nil {
return err
}
p.AddLayer(t)
p.SetApplicationLayer(t)
return nil
}
// DecodeFromBytes decodes the slice into the TLS struct.
func (t *TLS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
t.BaseLayer.Contents = data
t.BaseLayer.Payload = nil
t.ChangeCipherSpec = t.ChangeCipherSpec[:0]
t.Handshake = t.Handshake[:0]
t.AppData = t.AppData[:0]
t.Alert = t.Alert[:0]
return t.decodeTLSRecords(data, df)
}
func (t *TLS) decodeTLSRecords(data []byte, df gopacket.DecodeFeedback) error {
if len(data) < 5 {
df.SetTruncated()
return errors.New("TLS record too short")
}
// since there are no further layers, the baselayer's content is
// pointing to this layer
t.BaseLayer = BaseLayer{Contents: data[:len(data)]}
var h TLSRecordHeader
h.ContentType = TLSType(data[0])
h.Version = TLSVersion(binary.BigEndian.Uint16(data[1:3]))
h.Length = binary.BigEndian.Uint16(data[3:5])
if h.ContentType.String() == "Unknown" {
return errors.New("Unknown TLS record type")
}
hl := 5 // header length
tl := hl + int(h.Length)
if len(data) < tl {
df.SetTruncated()
return errors.New("TLS packet length mismatch")
}
switch h.ContentType {
default:
return errors.New("Unknown TLS record type")
case TLSChangeCipherSpec:
var r TLSChangeCipherSpecRecord
e := r.decodeFromBytes(h, data[hl:tl], df)
if e != nil {
return e
}
t.ChangeCipherSpec = append(t.ChangeCipherSpec, r)
case TLSAlert:
var r TLSAlertRecord
e := r.decodeFromBytes(h, data[hl:tl], df)
if e != nil {
return e
}
t.Alert = append(t.Alert, r)
case TLSHandshake:
var r TLSHandshakeRecord
e := r.decodeFromBytes(h, data[hl:tl], df)
if e != nil {
return e
}
t.Handshake = append(t.Handshake, r)
case TLSApplicationData:
var r TLSAppDataRecord
e := r.decodeFromBytes(h, data[hl:tl], df)
if e != nil {
return e
}
t.AppData = append(t.AppData, r)
}
if len(data) == tl {
return nil
}
return t.decodeTLSRecords(data[tl:len(data)], df)
}
// CanDecode implements gopacket.DecodingLayer.
func (t *TLS) CanDecode() gopacket.LayerClass {
return LayerTypeTLS
}
// NextLayerType implements gopacket.DecodingLayer.
func (t *TLS) NextLayerType() gopacket.LayerType {
return gopacket.LayerTypeZero
}
// Payload returns nil, since TLS encrypted payload is inside TLSAppDataRecord
func (t *TLS) Payload() []byte {
return nil
}

165
vendor/github.com/google/gopacket/layers/tls_alert.go generated vendored Normal file
View file

@ -0,0 +1,165 @@
// Copyright 2018 The GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"errors"
"fmt"
"github.com/google/gopacket"
)
// TLSAlertLevel defines the alert level data type
type TLSAlertLevel uint8
// TLSAlertDescr defines the alert descrption data type
type TLSAlertDescr uint8
const (
TLSAlertWarning TLSAlertLevel = 1
TLSAlertFatal TLSAlertLevel = 2
TLSAlertUnknownLevel TLSAlertLevel = 255
TLSAlertCloseNotify TLSAlertDescr = 0
TLSAlertUnexpectedMessage TLSAlertDescr = 10
TLSAlertBadRecordMac TLSAlertDescr = 20
TLSAlertDecryptionFailedRESERVED TLSAlertDescr = 21
TLSAlertRecordOverflow TLSAlertDescr = 22
TLSAlertDecompressionFailure TLSAlertDescr = 30
TLSAlertHandshakeFailure TLSAlertDescr = 40
TLSAlertNoCertificateRESERVED TLSAlertDescr = 41
TLSAlertBadCertificate TLSAlertDescr = 42
TLSAlertUnsupportedCertificate TLSAlertDescr = 43
TLSAlertCertificateRevoked TLSAlertDescr = 44
TLSAlertCertificateExpired TLSAlertDescr = 45
TLSAlertCertificateUnknown TLSAlertDescr = 46
TLSAlertIllegalParameter TLSAlertDescr = 47
TLSAlertUnknownCa TLSAlertDescr = 48
TLSAlertAccessDenied TLSAlertDescr = 49
TLSAlertDecodeError TLSAlertDescr = 50
TLSAlertDecryptError TLSAlertDescr = 51
TLSAlertExportRestrictionRESERVED TLSAlertDescr = 60
TLSAlertProtocolVersion TLSAlertDescr = 70
TLSAlertInsufficientSecurity TLSAlertDescr = 71
TLSAlertInternalError TLSAlertDescr = 80
TLSAlertUserCanceled TLSAlertDescr = 90
TLSAlertNoRenegotiation TLSAlertDescr = 100
TLSAlertUnsupportedExtension TLSAlertDescr = 110
TLSAlertUnknownDescription TLSAlertDescr = 255
)
// TLS Alert
// 0 1 2 3 4 5 6 7 8
// +--+--+--+--+--+--+--+--+
// | Level |
// +--+--+--+--+--+--+--+--+
// | Description |
// +--+--+--+--+--+--+--+--+
// TLSAlertRecord contains all the information that each Alert Record type should have
type TLSAlertRecord struct {
TLSRecordHeader
Level TLSAlertLevel
Description TLSAlertDescr
EncryptedMsg []byte
}
// DecodeFromBytes decodes the slice into the TLS struct.
func (t *TLSAlertRecord) decodeFromBytes(h TLSRecordHeader, data []byte, df gopacket.DecodeFeedback) error {
// TLS Record Header
t.ContentType = h.ContentType
t.Version = h.Version
t.Length = h.Length
if len(data) < 2 {
df.SetTruncated()
return errors.New("TLS Alert packet too short")
}
if t.Length == 2 {
t.Level = TLSAlertLevel(data[0])
t.Description = TLSAlertDescr(data[1])
} else {
t.Level = TLSAlertUnknownLevel
t.Description = TLSAlertUnknownDescription
t.EncryptedMsg = data
}
return nil
}
// Strings shows the TLS alert level nicely formatted
func (al TLSAlertLevel) String() string {
switch al {
default:
return fmt.Sprintf("Unknown(%d)", al)
case TLSAlertWarning:
return "Warning"
case TLSAlertFatal:
return "Fatal"
}
}
// Strings shows the TLS alert description nicely formatted
func (ad TLSAlertDescr) String() string {
switch ad {
default:
return "Unknown"
case TLSAlertCloseNotify:
return "close_notify"
case TLSAlertUnexpectedMessage:
return "unexpected_message"
case TLSAlertBadRecordMac:
return "bad_record_mac"
case TLSAlertDecryptionFailedRESERVED:
return "decryption_failed_RESERVED"
case TLSAlertRecordOverflow:
return "record_overflow"
case TLSAlertDecompressionFailure:
return "decompression_failure"
case TLSAlertHandshakeFailure:
return "handshake_failure"
case TLSAlertNoCertificateRESERVED:
return "no_certificate_RESERVED"
case TLSAlertBadCertificate:
return "bad_certificate"
case TLSAlertUnsupportedCertificate:
return "unsupported_certificate"
case TLSAlertCertificateRevoked:
return "certificate_revoked"
case TLSAlertCertificateExpired:
return "certificate_expired"
case TLSAlertCertificateUnknown:
return "certificate_unknown"
case TLSAlertIllegalParameter:
return "illegal_parameter"
case TLSAlertUnknownCa:
return "unknown_ca"
case TLSAlertAccessDenied:
return "access_denied"
case TLSAlertDecodeError:
return "decode_error"
case TLSAlertDecryptError:
return "decrypt_error"
case TLSAlertExportRestrictionRESERVED:
return "export_restriction_RESERVED"
case TLSAlertProtocolVersion:
return "protocol_version"
case TLSAlertInsufficientSecurity:
return "insufficient_security"
case TLSAlertInternalError:
return "internal_error"
case TLSAlertUserCanceled:
return "user_canceled"
case TLSAlertNoRenegotiation:
return "no_renegotiation"
case TLSAlertUnsupportedExtension:
return "unsupported_extension"
}
}

34
vendor/github.com/google/gopacket/layers/tls_appdata.go generated vendored Normal file
View file

@ -0,0 +1,34 @@
// Copyright 2018 The GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"errors"
"github.com/google/gopacket"
)
// TLSAppDataRecord contains all the information that each AppData Record types should have
type TLSAppDataRecord struct {
TLSRecordHeader
Payload []byte
}
// DecodeFromBytes decodes the slice into the TLS struct.
func (t *TLSAppDataRecord) decodeFromBytes(h TLSRecordHeader, data []byte, df gopacket.DecodeFeedback) error {
// TLS Record Header
t.ContentType = h.ContentType
t.Version = h.Version
t.Length = h.Length
if len(data) != int(t.Length) {
return errors.New("TLS Application Data length mismatch")
}
t.Payload = data
return nil
}

64
vendor/github.com/google/gopacket/layers/tls_cipherspec.go generated vendored Normal file
View file

@ -0,0 +1,64 @@
// Copyright 2018 The GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"errors"
"github.com/google/gopacket"
)
// TLSchangeCipherSpec defines the message value inside ChangeCipherSpec Record
type TLSchangeCipherSpec uint8
const (
TLSChangecipherspecMessage TLSchangeCipherSpec = 1
TLSChangecipherspecUnknown TLSchangeCipherSpec = 255
)
// TLS Change Cipher Spec
// 0 1 2 3 4 5 6 7 8
// +--+--+--+--+--+--+--+--+
// | Message |
// +--+--+--+--+--+--+--+--+
// TLSChangeCipherSpecRecord defines the type of data inside ChangeCipherSpec Record
type TLSChangeCipherSpecRecord struct {
TLSRecordHeader
Message TLSchangeCipherSpec
}
// DecodeFromBytes decodes the slice into the TLS struct.
func (t *TLSChangeCipherSpecRecord) decodeFromBytes(h TLSRecordHeader, data []byte, df gopacket.DecodeFeedback) error {
// TLS Record Header
t.ContentType = h.ContentType
t.Version = h.Version
t.Length = h.Length
if len(data) != 1 {
df.SetTruncated()
return errors.New("TLS Change Cipher Spec record incorrect length")
}
t.Message = TLSchangeCipherSpec(data[0])
if t.Message != TLSChangecipherspecMessage {
t.Message = TLSChangecipherspecUnknown
}
return nil
}
// String shows the message value nicely formatted
func (ccs TLSchangeCipherSpec) String() string {
switch ccs {
default:
return "Unknown"
case TLSChangecipherspecMessage:
return "Change Cipher Spec Message"
}
}

28
vendor/github.com/google/gopacket/layers/tls_handshake.go generated vendored Normal file
View file

@ -0,0 +1,28 @@
// Copyright 2018 The GoPacket Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.
package layers
import (
"github.com/google/gopacket"
)
// TLSHandshakeRecord defines the structure of a Handshare Record
type TLSHandshakeRecord struct {
TLSRecordHeader
}
// DecodeFromBytes decodes the slice into the TLS struct.
func (t *TLSHandshakeRecord) decodeFromBytes(h TLSRecordHeader, data []byte, df gopacket.DecodeFeedback) error {
// TLS Record Header
t.ContentType = h.ContentType
t.Version = h.Version
t.Length = h.Length
// TODO
return nil
}

1
vendor/github.com/google/gopacket/layers/udp.go generated vendored
View file

@ -10,6 +10,7 @@ package layers
import ( import (
"encoding/binary" "encoding/binary"
"fmt" "fmt"
"github.com/google/gopacket" "github.com/google/gopacket"
) )

2
vendor/github.com/google/gopacket/parser.go generated vendored
View file

@ -116,7 +116,7 @@ func NewDecodingLayerParser(first LayerType, decoders ...DecodingLayer) *Decodin
// decodedLayers := make([]gopacket.LayerType, 0, 10) // decodedLayers := make([]gopacket.LayerType, 0, 10)
// for { // for {
// data, _, err := source.ReadPacketData() // data, _, err := source.ReadPacketData()
// if err == nil { // if err != nil {
// fmt.Println("Error reading packet data: ", err) // fmt.Println("Error reading packet data: ", err)
// continue // continue
// } // }

7
vendor/github.com/google/gopacket/pcap/pcap.go generated vendored
View file

@ -154,6 +154,10 @@ const bpfInstructionBufferSize = 8 * MaxBpfInstructions
// //
// Handles are already pcap_activate'd // Handles are already pcap_activate'd
type Handle struct { type Handle struct {
// stop is set to a non-zero value by Handle.Close to signal to
// getNextBufPtrLocked to stop trying to read packets
// This must be the first entry to ensure alignment for sync.atomic
stop uint64
// cptr is the handle for the actual pcap C object. // cptr is the handle for the actual pcap C object.
cptr *C.pcap_t cptr *C.pcap_t
timeout time.Duration timeout time.Duration
@ -161,9 +165,6 @@ type Handle struct {
deviceIndex int deviceIndex int
mu sync.Mutex mu sync.Mutex
closeMu sync.Mutex closeMu sync.Mutex
// stop is set to a non-zero value by Handle.Close to signal to
// getNextBufPtrLocked to stop trying to read packets
stop uint64
// Since pointers to these objects are passed into a C function, if // Since pointers to these objects are passed into a C function, if
// they're declared locally then the Go compiler thinks they may have // they're declared locally then the Go compiler thinks they may have

1
vendor/github.com/google/gopacket/pcapgo/capture.go generated vendored
View file

@ -3,6 +3,7 @@
// Use of this source code is governed by a BSD-style license // Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source // that can be found in the LICENSE file in the root of the source
// tree. // tree.
// +build linux
package pcapgo package pcapgo

19
vendor/github.com/google/gopacket/writer.go generated vendored
View file

@ -36,6 +36,8 @@ type SerializableLayer interface {
// LayerPayload. It just serializes based on struct fields, neither // LayerPayload. It just serializes based on struct fields, neither
// modifying nor using contents/payload. // modifying nor using contents/payload.
SerializeTo(b SerializeBuffer, opts SerializeOptions) error SerializeTo(b SerializeBuffer, opts SerializeOptions) error
// LayerType returns the type of the layer that is being serialized to the buffer
LayerType() LayerType
} }
// SerializeOptions provides options for behaviors that SerializableLayers may want to // SerializeOptions provides options for behaviors that SerializableLayers may want to
@ -97,12 +99,19 @@ type SerializeBuffer interface {
// the byte slice returned by any previous call to Bytes() for this buffer // the byte slice returned by any previous call to Bytes() for this buffer
// should be considered invalidated. // should be considered invalidated.
Clear() error Clear() error
// Layers returns all the Layers that have been successfully serialized into this buffer
// already.
Layers() []LayerType
// PushLayer adds the current Layer to the list of Layers that have been serialized
// into this buffer.
PushLayer(LayerType)
} }
type serializeBuffer struct { type serializeBuffer struct {
data []byte data []byte
start int start int
prepended, appended int prepended, appended int
layers []LayerType
} }
// NewSerializeBuffer creates a new instance of the default implementation of // NewSerializeBuffer creates a new instance of the default implementation of
@ -171,9 +180,18 @@ func (w *serializeBuffer) AppendBytes(num int) ([]byte, error) {
func (w *serializeBuffer) Clear() error { func (w *serializeBuffer) Clear() error {
w.start = w.prepended w.start = w.prepended
w.data = w.data[:w.start] w.data = w.data[:w.start]
w.layers = w.layers[:0]
return nil return nil
} }
func (w *serializeBuffer) Layers() []LayerType {
return w.layers
}
func (w *serializeBuffer) PushLayer(l LayerType) {
w.layers = append(w.layers, l)
}
// SerializeLayers clears the given write buffer, then writes all layers into it so // SerializeLayers clears the given write buffer, then writes all layers into it so
// they correctly wrap each other. Note that by clearing the buffer, it // they correctly wrap each other. Note that by clearing the buffer, it
// invalidates all slices previously returned by w.Bytes() // invalidates all slices previously returned by w.Bytes()
@ -193,6 +211,7 @@ func SerializeLayers(w SerializeBuffer, opts SerializeOptions, layers ...Seriali
if err != nil { if err != nil {
return err return err
} }
w.PushLayer(layer.LayerType())
} }
return nil return nil
} }