WIP [VOL-2811] - Incorporate preliminary onu-adapter-go code into opencord repo
- reason "discovery-mibsync-complete" reached (via full MibUpload only, received data won't be stored yet)
- first review comments of patchset #4 considered
(please have a look into our inline-comments in Gerrit to know more about the current state)
- no refactoring done yet
Change-Id: Iac47817f8ce4bd28dd8132f530b0570d57ae99b8
Signed-off-by: Holger Hildebrandt <holger.hildebrandt@adtran.com>
diff --git a/vendor/github.com/google/gopacket/layers/icmp6msg.go b/vendor/github.com/google/gopacket/layers/icmp6msg.go
new file mode 100644
index 0000000..d9268db
--- /dev/null
+++ b/vendor/github.com/google/gopacket/layers/icmp6msg.go
@@ -0,0 +1,578 @@
+// Copyright 2012 Google, Inc. All rights reserved.
+// Copyright 2009-2011 Andreas Krennmair. 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"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "net"
+ "time"
+
+ "github.com/google/gopacket"
+)
+
+// Based on RFC 4861
+
+// ICMPv6Opt indicate how to decode the data associated with each ICMPv6Option.
+type ICMPv6Opt uint8
+
+const (
+ _ ICMPv6Opt = iota
+
+ // ICMPv6OptSourceAddress contains the link-layer address of the sender of
+ // the packet. It is used in the Neighbor Solicitation, Router
+ // Solicitation, and Router Advertisement packets. Must be ignored for other
+ // Neighbor discovery messages.
+ ICMPv6OptSourceAddress
+
+ // ICMPv6OptTargetAddress contains the link-layer address of the target. It
+ // is used in Neighbor Advertisement and Redirect packets. Must be ignored
+ // for other Neighbor discovery messages.
+ ICMPv6OptTargetAddress
+
+ // ICMPv6OptPrefixInfo provides hosts with on-link prefixes and prefixes
+ // for Address Autoconfiguration. The Prefix Information option appears in
+ // Router Advertisement packets and MUST be silently ignored for other
+ // messages.
+ ICMPv6OptPrefixInfo
+
+ // ICMPv6OptRedirectedHeader is used in Redirect messages and contains all
+ // or part of the packet that is being redirected.
+ ICMPv6OptRedirectedHeader
+
+ // ICMPv6OptMTU is used in Router Advertisement messages to ensure that all
+ // nodes on a link use the same MTU value in those cases where the link MTU
+ // is not well known. This option MUST be silently ignored for other
+ // Neighbor Discovery messages.
+ ICMPv6OptMTU
+)
+
+// ICMPv6Echo represents the structure of a ping.
+type ICMPv6Echo struct {
+ BaseLayer
+ Identifier uint16
+ SeqNumber uint16
+}
+
+// ICMPv6RouterSolicitation is sent by hosts to find routers.
+type ICMPv6RouterSolicitation struct {
+ BaseLayer
+ Options ICMPv6Options
+}
+
+// ICMPv6RouterAdvertisement is sent by routers in response to Solicitation.
+type ICMPv6RouterAdvertisement struct {
+ BaseLayer
+ HopLimit uint8
+ Flags uint8
+ RouterLifetime uint16
+ ReachableTime uint32
+ RetransTimer uint32
+ Options ICMPv6Options
+}
+
+// ICMPv6NeighborSolicitation is sent to request the link-layer address of a
+// target node.
+type ICMPv6NeighborSolicitation struct {
+ BaseLayer
+ TargetAddress net.IP
+ Options ICMPv6Options
+}
+
+// ICMPv6NeighborAdvertisement is sent by nodes in response to Solicitation.
+type ICMPv6NeighborAdvertisement struct {
+ BaseLayer
+ Flags uint8
+ TargetAddress net.IP
+ Options ICMPv6Options
+}
+
+// ICMPv6Redirect is sent by routers to inform hosts of a better first-hop node
+// on the path to a destination.
+type ICMPv6Redirect struct {
+ BaseLayer
+ TargetAddress net.IP
+ DestinationAddress net.IP
+ Options ICMPv6Options
+}
+
+// ICMPv6Option contains the type and data for a single option.
+type ICMPv6Option struct {
+ Type ICMPv6Opt
+ Data []byte
+}
+
+// ICMPv6Options is a slice of ICMPv6Option.
+type ICMPv6Options []ICMPv6Option
+
+func (i ICMPv6Opt) String() string {
+ switch i {
+ case ICMPv6OptSourceAddress:
+ return "SourceAddress"
+ case ICMPv6OptTargetAddress:
+ return "TargetAddress"
+ case ICMPv6OptPrefixInfo:
+ return "PrefixInfo"
+ case ICMPv6OptRedirectedHeader:
+ return "RedirectedHeader"
+ case ICMPv6OptMTU:
+ return "MTU"
+ default:
+ return fmt.Sprintf("Unknown(%d)", i)
+ }
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6Echo) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6Echo
+}
+
+// LayerType returns LayerTypeICMPv6Echo.
+func (i *ICMPv6Echo) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6Echo
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6Echo) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6Echo) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < 4 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 4 bytes for ICMPv6 Echo")
+ }
+ i.Identifier = binary.BigEndian.Uint16(data[0:2])
+ i.SeqNumber = binary.BigEndian.Uint16(data[2:4])
+
+ 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 (i *ICMPv6Echo) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ buf, err := b.PrependBytes(4)
+ if err != nil {
+ return err
+ }
+
+ binary.BigEndian.PutUint16(buf, i.Identifier)
+ binary.BigEndian.PutUint16(buf[2:], i.SeqNumber)
+ return nil
+}
+
+// LayerType returns LayerTypeICMPv6.
+func (i *ICMPv6RouterSolicitation) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6RouterSolicitation
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6RouterSolicitation) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6RouterSolicitation) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ // first 4 bytes are reserved followed by options
+ if len(data) < 4 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 4 bytes for ICMPv6 router solicitation")
+ }
+
+ // truncate old options
+ i.Options = i.Options[:0]
+
+ return i.Options.DecodeFromBytes(data[4:], df)
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (i *ICMPv6RouterSolicitation) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ if err := i.Options.SerializeTo(b, opts); err != nil {
+ return err
+ }
+
+ buf, err := b.PrependBytes(4)
+ if err != nil {
+ return err
+ }
+
+ copy(buf, lotsOfZeros[:4])
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6RouterSolicitation) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6RouterSolicitation
+}
+
+// LayerType returns LayerTypeICMPv6RouterAdvertisement.
+func (i *ICMPv6RouterAdvertisement) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6RouterAdvertisement
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6RouterAdvertisement) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6RouterAdvertisement) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < 12 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 12 bytes for ICMPv6 router advertisement")
+ }
+
+ i.HopLimit = uint8(data[0])
+ // M, O bit followed by 6 reserved bits
+ i.Flags = uint8(data[1])
+ i.RouterLifetime = binary.BigEndian.Uint16(data[2:4])
+ i.ReachableTime = binary.BigEndian.Uint32(data[4:8])
+ i.RetransTimer = binary.BigEndian.Uint32(data[8:12])
+ i.BaseLayer = BaseLayer{data, nil} // assume no payload
+
+ // truncate old options
+ i.Options = i.Options[:0]
+
+ return i.Options.DecodeFromBytes(data[12:], df)
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (i *ICMPv6RouterAdvertisement) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ if err := i.Options.SerializeTo(b, opts); err != nil {
+ return err
+ }
+
+ buf, err := b.PrependBytes(12)
+ if err != nil {
+ return err
+ }
+
+ buf[0] = byte(i.HopLimit)
+ buf[1] = byte(i.Flags)
+ binary.BigEndian.PutUint16(buf[2:], i.RouterLifetime)
+ binary.BigEndian.PutUint32(buf[4:], i.ReachableTime)
+ binary.BigEndian.PutUint32(buf[8:], i.RetransTimer)
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6RouterAdvertisement) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6RouterAdvertisement
+}
+
+// ManagedAddressConfig is true when addresses are available via DHCPv6. If
+// set, the OtherConfig flag is redundant.
+func (i *ICMPv6RouterAdvertisement) ManagedAddressConfig() bool {
+ return i.Flags&0x80 != 0
+}
+
+// OtherConfig is true when there is other configuration information available
+// via DHCPv6. For example, DNS-related information.
+func (i *ICMPv6RouterAdvertisement) OtherConfig() bool {
+ return i.Flags&0x40 != 0
+}
+
+// LayerType returns LayerTypeICMPv6NeighborSolicitation.
+func (i *ICMPv6NeighborSolicitation) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6NeighborSolicitation
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6NeighborSolicitation) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6NeighborSolicitation) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < 20 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 20 bytes for ICMPv6 neighbor solicitation")
+ }
+
+ i.TargetAddress = net.IP(data[4:20])
+ i.BaseLayer = BaseLayer{data, nil} // assume no payload
+
+ // truncate old options
+ i.Options = i.Options[:0]
+
+ return i.Options.DecodeFromBytes(data[20:], df)
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (i *ICMPv6NeighborSolicitation) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ if err := i.Options.SerializeTo(b, opts); err != nil {
+ return err
+ }
+
+ buf, err := b.PrependBytes(20)
+ if err != nil {
+ return err
+ }
+
+ copy(buf, lotsOfZeros[:4])
+ copy(buf[4:], i.TargetAddress)
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6NeighborSolicitation) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6NeighborSolicitation
+}
+
+// LayerType returns LayerTypeICMPv6NeighborAdvertisement.
+func (i *ICMPv6NeighborAdvertisement) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6NeighborAdvertisement
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6NeighborAdvertisement) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6NeighborAdvertisement) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < 20 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 20 bytes for ICMPv6 neighbor advertisement")
+ }
+
+ i.Flags = uint8(data[0])
+ i.TargetAddress = net.IP(data[4:20])
+ i.BaseLayer = BaseLayer{data, nil} // assume no payload
+
+ // truncate old options
+ i.Options = i.Options[:0]
+
+ return i.Options.DecodeFromBytes(data[20:], df)
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (i *ICMPv6NeighborAdvertisement) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ if err := i.Options.SerializeTo(b, opts); err != nil {
+ return err
+ }
+
+ buf, err := b.PrependBytes(20)
+ if err != nil {
+ return err
+ }
+
+ buf[0] = byte(i.Flags)
+ copy(buf[1:], lotsOfZeros[:3])
+ copy(buf[4:], i.TargetAddress)
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6NeighborAdvertisement) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6NeighborAdvertisement
+}
+
+// Router indicates whether the sender is a router or not.
+func (i *ICMPv6NeighborAdvertisement) Router() bool {
+ return i.Flags&0x80 != 0
+}
+
+// Solicited indicates whether the advertisement was solicited or not.
+func (i *ICMPv6NeighborAdvertisement) Solicited() bool {
+ return i.Flags&0x40 != 0
+}
+
+// Override indicates whether the advertisement should Override an existing
+// cache entry.
+func (i *ICMPv6NeighborAdvertisement) Override() bool {
+ return i.Flags&0x20 != 0
+}
+
+// LayerType returns LayerTypeICMPv6Redirect.
+func (i *ICMPv6Redirect) LayerType() gopacket.LayerType {
+ return LayerTypeICMPv6Redirect
+}
+
+// NextLayerType returns the layer type contained by this DecodingLayer.
+func (i *ICMPv6Redirect) NextLayerType() gopacket.LayerType {
+ return gopacket.LayerTypePayload
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6Redirect) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ if len(data) < 36 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 36 bytes for ICMPv6 redirect")
+ }
+
+ i.TargetAddress = net.IP(data[4:20])
+ i.DestinationAddress = net.IP(data[20:36])
+ i.BaseLayer = BaseLayer{data, nil} // assume no payload
+
+ // truncate old options
+ i.Options = i.Options[:0]
+
+ return i.Options.DecodeFromBytes(data[36:], df)
+}
+
+// SerializeTo writes the serialized form of this layer into the
+// SerializationBuffer, implementing gopacket.SerializableLayer.
+// See the docs for gopacket.SerializableLayer for more info.
+func (i *ICMPv6Redirect) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ if err := i.Options.SerializeTo(b, opts); err != nil {
+ return err
+ }
+
+ buf, err := b.PrependBytes(36)
+ if err != nil {
+ return err
+ }
+
+ copy(buf, lotsOfZeros[:4])
+ copy(buf[4:], i.TargetAddress)
+ copy(buf[20:], i.DestinationAddress)
+ return nil
+}
+
+// CanDecode returns the set of layer types that this DecodingLayer can decode.
+func (i *ICMPv6Redirect) CanDecode() gopacket.LayerClass {
+ return LayerTypeICMPv6Redirect
+}
+
+func (i ICMPv6Option) String() string {
+ hd := hex.EncodeToString(i.Data)
+ if len(hd) > 0 {
+ hd = " 0x" + hd
+ }
+
+ switch i.Type {
+ case ICMPv6OptSourceAddress, ICMPv6OptTargetAddress:
+ return fmt.Sprintf("ICMPv6Option(%s:%v)",
+ i.Type,
+ net.HardwareAddr(i.Data))
+ case ICMPv6OptPrefixInfo:
+ if len(i.Data) == 30 {
+ prefixLen := uint8(i.Data[0])
+ onLink := (i.Data[1]&0x80 != 0)
+ autonomous := (i.Data[1]&0x40 != 0)
+ validLifetime := time.Duration(binary.BigEndian.Uint32(i.Data[2:6])) * time.Second
+ preferredLifetime := time.Duration(binary.BigEndian.Uint32(i.Data[6:10])) * time.Second
+
+ prefix := net.IP(i.Data[14:])
+
+ return fmt.Sprintf("ICMPv6Option(%s:%v/%v:%t:%t:%v:%v)",
+ i.Type,
+ prefix, prefixLen,
+ onLink, autonomous,
+ validLifetime, preferredLifetime)
+ }
+ case ICMPv6OptRedirectedHeader:
+ // could invoke IP decoder on data... probably best not to
+ break
+ case ICMPv6OptMTU:
+ if len(i.Data) == 6 {
+ return fmt.Sprintf("ICMPv6Option(%s:%v)",
+ i.Type,
+ binary.BigEndian.Uint32(i.Data[2:]))
+ }
+
+ }
+ return fmt.Sprintf("ICMPv6Option(%s:%s)", i.Type, hd)
+}
+
+// DecodeFromBytes decodes the given bytes into this layer.
+func (i *ICMPv6Options) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
+ for len(data) > 0 {
+ if len(data) < 2 {
+ df.SetTruncated()
+ return errors.New("ICMP layer less then 2 bytes for ICMPv6 message option")
+ }
+
+ // unit is 8 octets, convert to bytes
+ length := int(data[1]) * 8
+
+ if length == 0 {
+ df.SetTruncated()
+ return errors.New("ICMPv6 message option with length 0")
+ }
+
+ if len(data) < length {
+ df.SetTruncated()
+ return fmt.Errorf("ICMP layer only %v bytes for ICMPv6 message option with length %v", len(data), length)
+ }
+
+ o := ICMPv6Option{
+ Type: ICMPv6Opt(data[0]),
+ Data: data[2:length],
+ }
+
+ // chop off option we just consumed
+ data = data[length:]
+
+ *i = append(*i, o)
+ }
+
+ 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 (i *ICMPv6Options) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
+ for _, opt := range []ICMPv6Option(*i) {
+ length := len(opt.Data) + 2
+ buf, err := b.PrependBytes(length)
+ if err != nil {
+ return err
+ }
+
+ buf[0] = byte(opt.Type)
+ buf[1] = byte(length / 8)
+ copy(buf[2:], opt.Data)
+ }
+
+ return nil
+}
+
+func decodeICMPv6Echo(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6Echo{}
+ return decodingLayerDecoder(i, data, p)
+}
+
+func decodeICMPv6RouterSolicitation(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6RouterSolicitation{}
+ return decodingLayerDecoder(i, data, p)
+}
+
+func decodeICMPv6RouterAdvertisement(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6RouterAdvertisement{}
+ return decodingLayerDecoder(i, data, p)
+}
+
+func decodeICMPv6NeighborSolicitation(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6NeighborSolicitation{}
+ return decodingLayerDecoder(i, data, p)
+}
+
+func decodeICMPv6NeighborAdvertisement(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6NeighborAdvertisement{}
+ return decodingLayerDecoder(i, data, p)
+}
+
+func decodeICMPv6Redirect(data []byte, p gopacket.PacketBuilder) error {
+ i := &ICMPv6Redirect{}
+ return decodingLayerDecoder(i, data, p)
+}