--- /dev/null
+// Copyright (c) 2020 Cisco and/or its affiliates.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package codec_test
+
+import (
+ "bytes"
+ "encoding/binary"
+ "reflect"
+ "testing"
+
+ "github.com/lunixbochs/struc"
+
+ "git.fd.io/govpp.git/api"
+ "git.fd.io/govpp.git/codec"
+ "git.fd.io/govpp.git/examples/binapi/fib_types"
+ "git.fd.io/govpp.git/examples/binapi/interface_types"
+ "git.fd.io/govpp.git/examples/binapi/interfaces"
+ "git.fd.io/govpp.git/examples/binapi/ip"
+ "git.fd.io/govpp.git/examples/binapi/ip_types"
+ "git.fd.io/govpp.git/examples/binapi/sr"
+)
+
+/*func TestNewCodecEncodeDecode(t *testing.T) {
+ tests := []struct {
+ name string
+ msg Codec
+ }{
+ {
+ "", &TestAllMsg{
+ Bool: true,
+ AliasUint32: 5,
+ AliasArray: MacAddress{0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
+ BaseArray: []uint32{0x00, 0x00, 0x00, 0x00},
+ Enum: IF_STATUS_API_FLAG_LINK_UP,
+ Uint8: 8,
+ Uint16: 16,
+ Uint32: 32,
+ Int8: 88,
+ Int16: 1616,
+ Int32: 3232,
+ Slice: []byte{10, 20, 30, 40, 0, 0, 0},
+ String: "abcdefghikl",
+ SizeOf: 2,
+ VariableSlice: []SliceType{
+ {Proto: IP_API_PROTO_AH},
+ {Proto: IP_API_PROTO_ESP},
+ },
+ TypeUnion: Address{
+ Af: ADDRESS_IP4,
+ Un: AddressUnionIP4(IP4Address{1, 2, 3, 4}),
+ },
+ },
+ },
+ }
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ data, err := test.msg.Marshal()
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ var m2 TestAllMsg
+ if err := m2.Unmarshal(data); err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", m, &m2)
+
+ if !reflect.DeepEqual(m, &m2) {
+ t.Fatalf("newData differs from oldData")
+ }
+ })
+ }
+}*/
+
+func NewTestAllMsg() *TestAllMsg {
+ return &TestAllMsg{
+ Bool: true,
+ AliasUint32: 5,
+ AliasArray: MacAddress{0x11, 0x22, 0x33, 0x44, 0x55, 0x66},
+ BaseArray: []uint32{0x00, 0x00, 0x00, 0x00},
+ Enum: IF_STATUS_API_FLAG_LINK_UP,
+ Uint8: 8,
+ Uint16: 16,
+ Uint32: 32,
+ Int8: 88,
+ Int16: 1616,
+ Int32: 3232,
+ Slice: []byte{10, 20, 30, 40, 0, 0, 0},
+ String: "abcdefghikl",
+ SizeOf: 2,
+ VariableSlice: []SliceType{
+ {Proto: IP_API_PROTO_AH},
+ {Proto: IP_API_PROTO_ESP},
+ },
+ TypeUnion: Address{
+ Af: ADDRESS_IP4,
+ Un: AddressUnionIP4(IP4Address{1, 2, 3, 4}),
+ },
+ }
+}
+
+func TestNewCodecEncodeDecode_(t *testing.T) {
+ m := NewTestAllMsg()
+
+ data, err := m.Marshal(nil)
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ var m2 TestAllMsg
+ if err := m2.Unmarshal(data); err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", m, &m2)
+
+ if !reflect.DeepEqual(m, &m2) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+
+// -------------
+
+func TestNewCodecEncodeDecode3(t *testing.T) {
+ m := NewTestAllMsg()
+ data, err := m.Marshal(nil)
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ var m2 TestAllMsg
+ if err := m2.Unmarshal(data); err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", m, &m2)
+
+ if !reflect.DeepEqual(m, &m2) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+func TestNewCodecEncodeDecode4(t *testing.T) {
+ m := &interfaces.SwInterfaceSetRxMode{
+ Mode: interface_types.RX_MODE_API_POLLING,
+ QueueID: 70000,
+ QueueIDValid: true,
+ SwIfIndex: 300,
+ }
+
+ b := make([]byte, 2+m.Size())
+
+ data, err := m.Marshal(b[2:])
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("ENCODED DATA(%d): % 03x", len(data), data)
+
+ var m2 interfaces.SwInterfaceSetRxMode
+ if err := m2.Unmarshal(b[2:]); err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", m, &m2)
+
+ if !reflect.DeepEqual(m, &m2) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+func TestNewCodecEncodeDecode2(t *testing.T) {
+ m := &sr.SrPoliciesDetails{
+ Bsid: sr.IP6Address{00, 11, 22, 33, 44, 55, 66, 77, 88, 99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
+ IsSpray: true,
+ IsEncap: false,
+ FibTable: 33,
+ NumSidLists: 1,
+ SidLists: []sr.Srv6SidList{
+ {
+ Weight: 555,
+ NumSids: 2,
+ Sids: [16]sr.IP6Address{
+ {99},
+ {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ },
+ },
+ },
+ }
+
+ b := make([]byte, 0, m.Size())
+ data, err := m.Marshal(b)
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("ENCODED DATA(%d): % 03x", len(data), data)
+
+ var m2 sr.SrPoliciesDetails
+ if err := m2.Unmarshal(data); err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", m, &m2)
+
+ if !reflect.DeepEqual(m, &m2) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+
+func TestNewCodecEncode(t *testing.T) {
+ //m := NewIPRouteLookupReply()
+ m := &sr.SrPoliciesDetails{
+ Bsid: sr.IP6Address{00, 11, 22, 33, 44, 55, 66, 77, 88, 99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
+ IsSpray: true,
+ IsEncap: false,
+ FibTable: 33,
+ NumSidLists: 1,
+ SidLists: []sr.Srv6SidList{
+ {
+ Weight: 555,
+ NumSids: 2,
+ Sids: [16]sr.IP6Address{
+ {99},
+ {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+ },
+ },
+ },
+ }
+
+ size := m.Size()
+ t.Logf("size: %d", size)
+
+ var err error
+ var oldData, newData []byte
+ {
+ var c codec.OldCodec
+ oldData, err = c.Marshal(m)
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+ }
+ {
+ newData, err = m.Marshal(nil)
+ if err != nil {
+ t.Fatalf("expected nil error, got: %v", err)
+ }
+ }
+ t.Logf("Data:\nOLD[%d]: % 03x\nNEW[%d]: % 03x", len(oldData), oldData, len(newData), newData)
+
+ if !bytes.Equal(oldData, newData) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+
+func TestNewCodecDecode(t *testing.T) {
+ /*m := &ip.IPRouteLookupReply{}
+ size := m.Size()
+ t.Logf("size: %d", size)*/
+ data := []byte{
+ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03,
+ 0x00, 0x00, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00,
+ 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x06, 0x00,
+ 0x00, 0x00, 0x08, 0x09, 0x0a, 0x00, 0x00, 0x00,
+ 0x0b, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
+ 0x01, 0x00, 0x00, 0x00, 0x02, 0x01, 0x09, 0x00,
+ 0x00, 0x00, 0x08, 0x07, 0x06, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ }
+
+ var err error
+ var oldData, newData ip.IPRouteLookupReply
+ {
+ var c codec.OldCodec
+ err = c.Unmarshal(data, &oldData)
+ if err != nil {
+ t.Errorf("expected nil error, got: %v", err)
+ }
+ }
+ {
+ err = newData.Unmarshal(data)
+ if err != nil {
+ t.Errorf("expected nil error, got: %v", err)
+ }
+ }
+ t.Logf("Data:\nOLD: %+v\nNEW: %+v", oldData, newData)
+
+ if !reflect.DeepEqual(oldData, newData) {
+ t.Fatalf("newData differs from oldData")
+ }
+}
+
+func NewIPRouteLookupReply() *ip.IPRouteLookupReply {
+ return &ip.IPRouteLookupReply{
+ Retval: 1,
+ Route: ip.IPRoute{
+ TableID: 3,
+ StatsIndex: 5,
+ Prefix: ip.Prefix{
+ Address: ip_types.Address{
+ Af: fib_types.ADDRESS_IP6,
+ Un: ip_types.AddressUnion{},
+ },
+ Len: 24,
+ },
+ NPaths: 2,
+ Paths: []ip.FibPath{
+ {
+ SwIfIndex: 5,
+ TableID: 6,
+ RpfID: 8,
+ Weight: 9,
+ Preference: 10,
+ Type: 11,
+ Flags: 1,
+ Proto: 2,
+ Nh: ip.FibPathNh{
+ Address: ip.AddressUnion{},
+ ViaLabel: 3,
+ ObjID: 1,
+ ClassifyTableIndex: 2,
+ },
+ NLabels: 1,
+ LabelStack: [16]ip.FibMplsLabel{
+ {
+ IsUniform: 9,
+ Label: 8,
+ TTL: 7,
+ Exp: 6,
+ },
+ },
+ },
+ {
+ SwIfIndex: 7,
+ TableID: 6,
+ RpfID: 8,
+ Weight: 9,
+ Preference: 10,
+ Type: 11,
+ Flags: 1,
+ Proto: 1,
+ Nh: ip.FibPathNh{
+ Address: ip.AddressUnion{},
+ ViaLabel: 3,
+ ObjID: 1,
+ ClassifyTableIndex: 2,
+ },
+ NLabels: 2,
+ LabelStack: [16]ip.FibMplsLabel{
+ {
+ IsUniform: 9,
+ Label: 8,
+ TTL: 7,
+ Exp: 6,
+ },
+ {
+ IsUniform: 10,
+ Label: 8,
+ TTL: 7,
+ Exp: 6,
+ },
+ },
+ },
+ },
+ },
+ }
+}
+
+func TestSize(t *testing.T) {
+ m := NewTestAllMsg()
+ size := binary.Size(*m)
+ t.Logf("size: %v", size)
+}
+
+func (m *TestAllMsg) Marshal(b []byte) ([]byte, error) {
+ order := binary.BigEndian
+ tmp := make([]byte, 143)
+ pos := 0
+
+ tmp[pos] = boolToUint(m.Bool)
+ pos += 1
+
+ tmp[pos] = m.Uint8
+ pos += 1
+
+ order.PutUint16(tmp[pos:pos+2], m.Uint16)
+ pos += 2
+
+ order.PutUint32(tmp[pos:pos+4], m.Uint32)
+ pos += 4
+
+ tmp[pos] = byte(m.Int8)
+ pos += 1
+
+ order.PutUint16(tmp[pos:pos+2], uint16(m.Int16))
+ pos += 2
+
+ order.PutUint32(tmp[pos:pos+4], uint32(m.Int32))
+ pos += 4
+
+ order.PutUint32(tmp[pos:pos+4], uint32(m.AliasUint32))
+ pos += 4
+
+ copy(tmp[pos:pos+6], m.AliasArray[:])
+ pos += 6
+
+ order.PutUint32(tmp[pos:pos+4], uint32(m.Enum))
+ pos += 4
+
+ for i := 0; i < 4; i++ {
+ var x uint32
+ if i < len(m.BaseArray) {
+ x = m.BaseArray[i]
+ }
+ order.PutUint32(tmp[pos:pos+4], uint32(x))
+ pos += 4
+ }
+
+ copy(tmp[pos:pos+7], m.Slice)
+ pos += 7
+
+ copy(tmp[pos:pos+64], m.String)
+ pos += 64
+
+ order.PutUint32(tmp[pos:pos+4], uint32(len(m.VlaStr)) /*m.SizeOf*/)
+ pos += 4
+
+ copy(tmp[pos:pos+len(m.VlaStr)], m.VlaStr[:])
+ pos += len(m.VlaStr)
+
+ order.PutUint32(tmp[pos:pos+4], uint32(len(m.VariableSlice)) /*m.SizeOf*/)
+ pos += 4
+
+ for i := range m.VariableSlice {
+ tmp[pos+i*1] = uint8(m.VariableSlice[i].Proto)
+ //copy(tmp[102+i:103+i], []byte{byte(m.VariableSlice[i].Proto)})
+ }
+ pos += len(m.VariableSlice) * 1
+
+ tmp[pos] = uint8(m.TypeUnion.Af)
+ pos += 1
+
+ copy(tmp[pos:pos+16], m.TypeUnion.Un.XXX_UnionData[:])
+ pos += 16
+
+ return tmp, nil
+
+ /*_, err := buf.Write(tmp)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil*/
+}
+
+func (m *TestAllMsg) Unmarshal(tmp []byte) error {
+ order := binary.BigEndian
+
+ //tmp := make([]byte, 143)
+ pos := 0
+
+ m.Bool = tmp[pos] != 0
+ pos += 1
+
+ //tmp[pos] = m.Uint8
+ m.Uint8 = tmp[pos]
+ pos += 1
+
+ //order.PutUint16(tmp[pos:pos+2], m.Uint16)
+ m.Uint16 = order.Uint16(tmp[pos : pos+2])
+ pos += 2
+
+ //order.PutUint32(tmp[pos:pos+4], m.Uint32)
+ m.Uint32 = order.Uint32(tmp[pos : pos+4])
+ pos += 4
+
+ //tmp[pos] = byte(m.Int8)
+ m.Int8 = int8(tmp[pos])
+ pos += 1
+
+ //order.PutUint16(tmp[pos:pos+2], uint16(m.Int16))
+ m.Int16 = int16(order.Uint16(tmp[pos : pos+2]))
+ pos += 2
+
+ //order.PutUint32(tmp[pos:pos+4], uint32(m.Int32))
+ m.Int32 = int32(order.Uint32(tmp[pos : pos+4]))
+ pos += 4
+
+ //order.PutUint32(tmp[pos:pos+4], uint32(m.AliasUint32))
+ m.AliasUint32 = InterfaceIndex(order.Uint32(tmp[pos : pos+4]))
+ pos += 4
+
+ //copy(tmp[pos:pos+6], m.AliasArray[:])
+ copy(m.AliasArray[:], tmp[pos:pos+6])
+ pos += 6
+
+ //order.PutUint32(tmp[pos:pos+4], uint32(m.Enum))
+ m.Enum = IfStatusFlags(order.Uint32(tmp[pos : pos+4]))
+ pos += 4
+
+ m.BaseArray = make([]uint32, 4)
+ for i := 0; i < 4; i++ {
+ /*var x uint32
+ if i < len(m.BaseArray) {
+ x = m.BaseArray[i]
+ }
+ order.PutUint32(tmp[pos:pos+4], uint32(x))*/
+ m.BaseArray[i] = order.Uint32(tmp[pos : pos+4])
+ pos += 4
+ }
+
+ m.Slice = make([]byte, 7)
+ copy(m.Slice[:7], tmp[pos:pos+7])
+ //copy(tmp[pos:pos+7], m.Slice)
+ pos += 7
+
+ i := bytes.Index(tmp[pos:pos+64], []byte{0x00})
+ m.String = string(tmp[pos : pos+i])
+ //copy(tmp[pos:pos+64], m.String)
+ pos += 64
+
+ //order.PutUint32(tmp[pos:pos+4], uint32(len(m.VlaStr)) /*m.SizeOf*/)
+ VlaStrLen := int(order.Uint32(tmp[pos : pos+4]))
+ pos += 4
+
+ m.VlaStr = string(tmp[pos : pos+VlaStrLen])
+ //copy(m.VlaStr[pos:pos+VlaStrLen], tmp[pos:pos+64])
+ pos += len(m.VlaStr)
+
+ m.SizeOf = uint32(order.Uint32(tmp[pos : pos+4]))
+ pos += 4
+
+ /*order.PutUint32(tmp[pos:pos+4], uint32(len(m.VariableSlice)))
+ m.VariableSlice = IfStatusFlags(order.Uint32(tmp[pos : pos+4]))
+ pos += 4*/
+
+ m.VariableSlice = make([]SliceType, m.SizeOf)
+ for i := range m.VariableSlice {
+ //tmp[pos+i*1] = uint8(m.VariableSlice[i].Proto)
+ m.VariableSlice[i].Proto = IPProto(tmp[pos+i*1])
+ //copy(tmp[102+i:103+i], []byte{byte(m.VariableSlice[i].Proto)})
+ }
+ pos += len(m.VariableSlice) * 1
+
+ //tmp[pos] = uint8(m.TypeUnion.Af)
+ m.TypeUnion.Af = AddressFamily(tmp[pos])
+ pos += 1
+
+ //copy(tmp[pos:pos+16], m.TypeUnion.Un.XXX_UnionData[:])
+ copy(m.TypeUnion.Un.XXX_UnionData[:], tmp[pos:pos+16])
+ pos += 16
+
+ return nil
+ /*_, err := buf.Write(tmp)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil*/
+}
+
+func boolToUint(b bool) uint8 {
+ if b {
+ return 1
+ }
+ return 0
+}
+
+// SwInterfaceDetails represents VPP binary API message 'sw_interface_details'.
+type TestAllMsg struct {
+ Bool bool
+ Uint8 uint8
+ Uint16 uint16
+ Uint32 uint32
+ Int8 int8
+ Int16 int16
+ Int32 int32
+ AliasUint32 InterfaceIndex
+ AliasArray MacAddress
+ Enum IfStatusFlags
+ BaseArray []uint32 `struc:"[4]uint32"`
+ Slice []byte `struc:"[7]byte"`
+ String string `struc:"[64]byte"`
+ XXX_VlaStrLen uint32 `struc:"sizeof=VlaStr"`
+ VlaStr string
+ SizeOf uint32 `struc:"sizeof=VariableSlice"`
+ VariableSlice []SliceType
+ TypeUnion Address
+}
+
+type InterfaceIndex uint32
+type MacAddress [6]uint8
+type IfStatusFlags uint32
+
+const (
+ IF_STATUS_API_FLAG_ADMIN_UP IfStatusFlags = 1
+ IF_STATUS_API_FLAG_LINK_UP IfStatusFlags = 2
+)
+
+// Address represents VPP binary API type 'address'.
+type Address struct {
+ Af AddressFamily
+ Un AddressUnion
+}
+
+// AddressFamily represents VPP binary API enum 'address_family'.
+type AddressFamily uint8
+
+const (
+ ADDRESS_IP4 AddressFamily = 0
+ ADDRESS_IP6 AddressFamily = 1
+)
+
+// AddressUnion represents VPP binary API union 'address_union'.
+type AddressUnion struct {
+ XXX_UnionData [16]byte
+}
+
+func (*AddressUnion) GetTypeName() string { return "address_union" }
+
+func AddressUnionIP4(a IP4Address) (u AddressUnion) {
+ u.SetIP4(a)
+ return
+}
+func (u *AddressUnion) SetIP4(a IP4Address) {
+ var b = new(bytes.Buffer)
+ if err := struc.Pack(b, &a); err != nil {
+ return
+ }
+ copy(u.XXX_UnionData[:], b.Bytes())
+}
+func (u *AddressUnion) GetIP4() (a IP4Address) {
+ var b = bytes.NewReader(u.XXX_UnionData[:])
+ struc.Unpack(b, &a)
+ return
+}
+
+func AddressUnionIP6(a IP6Address) (u AddressUnion) {
+ u.SetIP6(a)
+ return
+}
+func (u *AddressUnion) SetIP6(a IP6Address) {
+ var b = new(bytes.Buffer)
+ if err := struc.Pack(b, &a); err != nil {
+ return
+ }
+ copy(u.XXX_UnionData[:], b.Bytes())
+}
+func (u *AddressUnion) GetIP6() (a IP6Address) {
+ var b = bytes.NewReader(u.XXX_UnionData[:])
+ struc.Unpack(b, &a)
+ return
+}
+
+// IP4Address represents VPP binary API alias 'ip4_address'.
+type IP4Address [4]uint8
+
+// IP6Address represents VPP binary API alias 'ip6_address'.
+type IP6Address [16]uint8
+
+type SliceType struct {
+ Proto IPProto
+}
+
+type IPProto uint8
+
+const (
+ IP_API_PROTO_HOPOPT IPProto = 0
+ IP_API_PROTO_ICMP IPProto = 1
+ IP_API_PROTO_IGMP IPProto = 2
+ IP_API_PROTO_TCP IPProto = 6
+ IP_API_PROTO_UDP IPProto = 17
+ IP_API_PROTO_GRE IPProto = 47
+ IP_API_PROTO_ESP IPProto = 50
+ IP_API_PROTO_AH IPProto = 51
+ IP_API_PROTO_ICMP6 IPProto = 58
+ IP_API_PROTO_EIGRP IPProto = 88
+ IP_API_PROTO_OSPF IPProto = 89
+ IP_API_PROTO_SCTP IPProto = 132
+ IP_API_PROTO_RESERVED IPProto = 255
+)
+
+func (m *TestAllMsg) Reset() { *m = TestAllMsg{} }
+func (*TestAllMsg) GetMessageName() string { return "sw_interface_details" }
+func (*TestAllMsg) GetCrcString() string { return "17b69fa2" }
+func (*TestAllMsg) GetMessageType() api.MessageType { return api.ReplyMessage }
Code Review / govpp.git / blobdiff