Andrea Campanella | 7167ebb | 2020-02-24 09:56:38 +0100 | [diff] [blame^] | 1 | // Copyright 2012 Google, Inc. All rights reserved. |
| 2 | // |
| 3 | // Use of this source code is governed by a BSD-style license |
| 4 | // that can be found in the LICENSE file in the root of the source |
| 5 | // tree. |
| 6 | |
| 7 | package layers |
| 8 | |
| 9 | import ( |
| 10 | "encoding/binary" |
| 11 | "errors" |
| 12 | "github.com/google/gopacket" |
| 13 | ) |
| 14 | |
| 15 | // MPLS is the MPLS packet header. |
| 16 | type MPLS struct { |
| 17 | BaseLayer |
| 18 | Label uint32 |
| 19 | TrafficClass uint8 |
| 20 | StackBottom bool |
| 21 | TTL uint8 |
| 22 | } |
| 23 | |
| 24 | // LayerType returns gopacket.LayerTypeMPLS. |
| 25 | func (m *MPLS) LayerType() gopacket.LayerType { return LayerTypeMPLS } |
| 26 | |
| 27 | // ProtocolGuessingDecoder attempts to guess the protocol of the bytes it's |
| 28 | // given, then decode the packet accordingly. Its algorithm for guessing is: |
| 29 | // If the packet starts with byte 0x45-0x4F: IPv4 |
| 30 | // If the packet starts with byte 0x60-0x6F: IPv6 |
| 31 | // Otherwise: Error |
| 32 | // See draft-hsmit-isis-aal5mux-00.txt for more detail on this approach. |
| 33 | type ProtocolGuessingDecoder struct{} |
| 34 | |
| 35 | func (ProtocolGuessingDecoder) Decode(data []byte, p gopacket.PacketBuilder) error { |
| 36 | switch data[0] { |
| 37 | // 0x40 | header_len, where header_len is at least 5. |
| 38 | case 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f: |
| 39 | return decodeIPv4(data, p) |
| 40 | // IPv6 can start with any byte whose first 4 bits are 0x6. |
| 41 | case 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f: |
| 42 | return decodeIPv6(data, p) |
| 43 | } |
| 44 | return errors.New("Unable to guess protocol of packet data") |
| 45 | } |
| 46 | |
| 47 | // MPLSPayloadDecoder is the decoder used to data encapsulated by each MPLS |
| 48 | // layer. MPLS contains no type information, so we have to explicitly decide |
| 49 | // which decoder to use. This is initially set to ProtocolGuessingDecoder, our |
| 50 | // simple attempt at guessing protocols based on the first few bytes of data |
| 51 | // available to us. However, if you know that in your environment MPLS always |
| 52 | // encapsulates a specific protocol, you may reset this. |
| 53 | var MPLSPayloadDecoder gopacket.Decoder = ProtocolGuessingDecoder{} |
| 54 | |
| 55 | func decodeMPLS(data []byte, p gopacket.PacketBuilder) error { |
| 56 | decoded := binary.BigEndian.Uint32(data[:4]) |
| 57 | mpls := &MPLS{ |
| 58 | Label: decoded >> 12, |
| 59 | TrafficClass: uint8(decoded>>9) & 0x7, |
| 60 | StackBottom: decoded&0x100 != 0, |
| 61 | TTL: uint8(decoded), |
| 62 | BaseLayer: BaseLayer{data[:4], data[4:]}, |
| 63 | } |
| 64 | p.AddLayer(mpls) |
| 65 | if mpls.StackBottom { |
| 66 | return p.NextDecoder(MPLSPayloadDecoder) |
| 67 | } |
| 68 | return p.NextDecoder(gopacket.DecodeFunc(decodeMPLS)) |
| 69 | } |
| 70 | |
| 71 | // SerializeTo writes the serialized form of this layer into the |
| 72 | // SerializationBuffer, implementing gopacket.SerializableLayer. |
| 73 | // See the docs for gopacket.SerializableLayer for more info. |
| 74 | func (m *MPLS) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| 75 | bytes, err := b.PrependBytes(4) |
| 76 | if err != nil { |
| 77 | return err |
| 78 | } |
| 79 | encoded := m.Label << 12 |
| 80 | encoded |= uint32(m.TrafficClass) << 9 |
| 81 | encoded |= uint32(m.TTL) |
| 82 | if m.StackBottom { |
| 83 | encoded |= 0x100 |
| 84 | } |
| 85 | binary.BigEndian.PutUint32(bytes, encoded) |
| 86 | return nil |
| 87 | } |