From a101d966133a70b8a76526be25070436d14fcf9f Mon Sep 17 00:00:00 2001 From: Rastislav Szabo Date: Thu, 4 May 2017 11:09:03 +0200 Subject: initial commit Signed-off-by: Rastislav Szabo --- core/bin_api/vpe/vpe.go | 3053 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3053 insertions(+) create mode 100644 core/bin_api/vpe/vpe.go (limited to 'core/bin_api/vpe') diff --git a/core/bin_api/vpe/vpe.go b/core/bin_api/vpe/vpe.go new file mode 100644 index 0000000..e93f808 --- /dev/null +++ b/core/bin_api/vpe/vpe.go @@ -0,0 +1,3053 @@ +// Package vpe represents the VPP binary API of the 'vpe' VPP module. +// DO NOT EDIT. Generated from '/usr/share/vpp/api/vpe.api.json' on Thu, 27 Apr 2017 11:34:11 CEST. +package vpe + +import "gerrit.fd.io/r/govpp/api" + +// VlApiVersion contains version of the API. +const VlAPIVersion = 0xd3bcc288 + +// IP4FibCounter represents the VPP binary API data type 'ip4_fib_counter'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 3: +// +// ["ip4_fib_counter", +// ["u32", "address"], +// ["u8", "address_length"], +// ["u64", "packets"], +// ["u64", "bytes"], +// {"crc" : "0xb2739495"} +// ], +// +type IP4FibCounter struct { + Address uint32 + AddressLength uint8 + Packets uint64 + Bytes uint64 +} + +func (*IP4FibCounter) GetTypeName() string { + return "ip4_fib_counter" +} +func (*IP4FibCounter) GetCrcString() string { + return "b2739495" +} + +// IP4NbrCounter represents the VPP binary API data type 'ip4_nbr_counter'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 10: +// +// ["ip4_nbr_counter", +// ["u32", "address"], +// ["u8", "link_type"], +// ["u64", "packets"], +// ["u64", "bytes"], +// {"crc" : "0x487e2e85"} +// ], +// +type IP4NbrCounter struct { + Address uint32 + LinkType uint8 + Packets uint64 + Bytes uint64 +} + +func (*IP4NbrCounter) GetTypeName() string { + return "ip4_nbr_counter" +} +func (*IP4NbrCounter) GetCrcString() string { + return "487e2e85" +} + +// IP6FibCounter represents the VPP binary API data type 'ip6_fib_counter'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 17: +// +// ["ip6_fib_counter", +// ["u64", "address", 2], +// ["u8", "address_length"], +// ["u64", "packets"], +// ["u64", "bytes"], +// {"crc" : "0xcf35769b"} +// ], +// +type IP6FibCounter struct { + Address []uint64 `struc:"[2]uint64"` + AddressLength uint8 + Packets uint64 + Bytes uint64 +} + +func (*IP6FibCounter) GetTypeName() string { + return "ip6_fib_counter" +} +func (*IP6FibCounter) GetCrcString() string { + return "cf35769b" +} + +// IP6NbrCounter represents the VPP binary API data type 'ip6_nbr_counter'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 24: +// +// ["ip6_nbr_counter", +// ["u64", "address", 2], +// ["u8", "link_type"], +// ["u64", "packets"], +// ["u64", "bytes"], +// {"crc" : "0xefca741e"} +// ] +// +type IP6NbrCounter struct { + Address []uint64 `struc:"[2]uint64"` + LinkType uint8 + Packets uint64 + Bytes uint64 +} + +func (*IP6NbrCounter) GetTypeName() string { + return "ip6_nbr_counter" +} +func (*IP6NbrCounter) GetCrcString() string { + return "efca741e" +} + +// CreateVlanSubif represents the VPP binary API message 'create_vlan_subif'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 33: +// +// ["create_vlan_subif", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "vlan_id"], +// {"crc" : "0xaf9ae1e9"} +// ], +// +type CreateVlanSubif struct { + SwIfIndex uint32 + VlanID uint32 +} + +func (*CreateVlanSubif) GetMessageName() string { + return "create_vlan_subif" +} +func (*CreateVlanSubif) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CreateVlanSubif) GetCrcString() string { + return "af9ae1e9" +} +func NewCreateVlanSubif() api.Message { + return &CreateVlanSubif{} +} + +// CreateVlanSubifReply represents the VPP binary API message 'create_vlan_subif_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 41: +// +// ["create_vlan_subif_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "sw_if_index"], +// {"crc" : "0x8f36b888"} +// ], +// +type CreateVlanSubifReply struct { + Retval int32 + SwIfIndex uint32 +} + +func (*CreateVlanSubifReply) GetMessageName() string { + return "create_vlan_subif_reply" +} +func (*CreateVlanSubifReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CreateVlanSubifReply) GetCrcString() string { + return "8f36b888" +} +func NewCreateVlanSubifReply() api.Message { + return &CreateVlanSubifReply{} +} + +// SwInterfaceSetMplsEnable represents the VPP binary API message 'sw_interface_set_mpls_enable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 48: +// +// ["sw_interface_set_mpls_enable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u8", "enable"], +// {"crc" : "0x37f6357e"} +// ], +// +type SwInterfaceSetMplsEnable struct { + SwIfIndex uint32 + Enable uint8 +} + +func (*SwInterfaceSetMplsEnable) GetMessageName() string { + return "sw_interface_set_mpls_enable" +} +func (*SwInterfaceSetMplsEnable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*SwInterfaceSetMplsEnable) GetCrcString() string { + return "37f6357e" +} +func NewSwInterfaceSetMplsEnable() api.Message { + return &SwInterfaceSetMplsEnable{} +} + +// SwInterfaceSetMplsEnableReply represents the VPP binary API message 'sw_interface_set_mpls_enable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 56: +// +// ["sw_interface_set_mpls_enable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x5ffd3ca9"} +// ], +// +type SwInterfaceSetMplsEnableReply struct { + Retval int32 +} + +func (*SwInterfaceSetMplsEnableReply) GetMessageName() string { + return "sw_interface_set_mpls_enable_reply" +} +func (*SwInterfaceSetMplsEnableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*SwInterfaceSetMplsEnableReply) GetCrcString() string { + return "5ffd3ca9" +} +func NewSwInterfaceSetMplsEnableReply() api.Message { + return &SwInterfaceSetMplsEnableReply{} +} + +// ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 62: +// +// ["proxy_arp_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "vrf_id"], +// ["u8", "is_add"], +// ["u8", "low_address", 4], +// ["u8", "hi_address", 4], +// {"crc" : "0x4bef9951"} +// ], +// +type ProxyArpAddDel struct { + VrfID uint32 + IsAdd uint8 + LowAddress []byte `struc:"[4]byte"` + HiAddress []byte `struc:"[4]byte"` +} + +func (*ProxyArpAddDel) GetMessageName() string { + return "proxy_arp_add_del" +} +func (*ProxyArpAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ProxyArpAddDel) GetCrcString() string { + return "4bef9951" +} +func NewProxyArpAddDel() api.Message { + return &ProxyArpAddDel{} +} + +// ProxyArpAddDelReply represents the VPP binary API message 'proxy_arp_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 72: +// +// ["proxy_arp_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x8e2d621d"} +// ], +// +type ProxyArpAddDelReply struct { + Retval int32 +} + +func (*ProxyArpAddDelReply) GetMessageName() string { + return "proxy_arp_add_del_reply" +} +func (*ProxyArpAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ProxyArpAddDelReply) GetCrcString() string { + return "8e2d621d" +} +func NewProxyArpAddDelReply() api.Message { + return &ProxyArpAddDelReply{} +} + +// ProxyArpIntfcEnableDisable represents the VPP binary API message 'proxy_arp_intfc_enable_disable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 78: +// +// ["proxy_arp_intfc_enable_disable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u8", "enable_disable"], +// {"crc" : "0x3ee1998e"} +// ], +// +type ProxyArpIntfcEnableDisable struct { + SwIfIndex uint32 + EnableDisable uint8 +} + +func (*ProxyArpIntfcEnableDisable) GetMessageName() string { + return "proxy_arp_intfc_enable_disable" +} +func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ProxyArpIntfcEnableDisable) GetCrcString() string { + return "3ee1998e" +} +func NewProxyArpIntfcEnableDisable() api.Message { + return &ProxyArpIntfcEnableDisable{} +} + +// ProxyArpIntfcEnableDisableReply represents the VPP binary API message 'proxy_arp_intfc_enable_disable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 86: +// +// ["proxy_arp_intfc_enable_disable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x23d273cd"} +// ], +// +type ProxyArpIntfcEnableDisableReply struct { + Retval int32 +} + +func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string { + return "proxy_arp_intfc_enable_disable_reply" +} +func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string { + return "23d273cd" +} +func NewProxyArpIntfcEnableDisableReply() api.Message { + return &ProxyArpIntfcEnableDisableReply{} +} + +// ResetVrf represents the VPP binary API message 'reset_vrf'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 92: +// +// ["reset_vrf", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_ipv6"], +// ["u32", "vrf_id"], +// {"crc" : "0xeb07deb0"} +// ], +// +type ResetVrf struct { + IsIpv6 uint8 + VrfID uint32 +} + +func (*ResetVrf) GetMessageName() string { + return "reset_vrf" +} +func (*ResetVrf) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ResetVrf) GetCrcString() string { + return "eb07deb0" +} +func NewResetVrf() api.Message { + return &ResetVrf{} +} + +// ResetVrfReply represents the VPP binary API message 'reset_vrf_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 100: +// +// ["reset_vrf_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x5f283863"} +// ], +// +type ResetVrfReply struct { + Retval int32 +} + +func (*ResetVrfReply) GetMessageName() string { + return "reset_vrf_reply" +} +func (*ResetVrfReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ResetVrfReply) GetCrcString() string { + return "5f283863" +} +func NewResetVrfReply() api.Message { + return &ResetVrfReply{} +} + +// IsAddressReachable represents the VPP binary API message 'is_address_reachable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 106: +// +// ["is_address_reachable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "next_hop_sw_if_index"], +// ["u8", "is_known"], +// ["u8", "is_ipv6"], +// ["u8", "is_error"], +// ["u8", "address", 16], +// {"crc" : "0xa8b6e322"} +// ], +// +type IsAddressReachable struct { + NextHopSwIfIndex uint32 + IsKnown uint8 + IsIpv6 uint8 + IsError uint8 + Address []byte `struc:"[16]byte"` +} + +func (*IsAddressReachable) GetMessageName() string { + return "is_address_reachable" +} +func (*IsAddressReachable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IsAddressReachable) GetCrcString() string { + return "a8b6e322" +} +func NewIsAddressReachable() api.Message { + return &IsAddressReachable{} +} + +// WantStats represents the VPP binary API message 'want_stats'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 117: +// +// ["want_stats", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "enable_disable"], +// ["u32", "pid"], +// {"crc" : "0x4f2effb4"} +// ], +// +type WantStats struct { + EnableDisable uint32 + Pid uint32 +} + +func (*WantStats) GetMessageName() string { + return "want_stats" +} +func (*WantStats) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*WantStats) GetCrcString() string { + return "4f2effb4" +} +func NewWantStats() api.Message { + return &WantStats{} +} + +// WantStatsReply represents the VPP binary API message 'want_stats_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 125: +// +// ["want_stats_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xb36abf5f"} +// ], +// +type WantStatsReply struct { + Retval int32 +} + +func (*WantStatsReply) GetMessageName() string { + return "want_stats_reply" +} +func (*WantStatsReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*WantStatsReply) GetCrcString() string { + return "b36abf5f" +} +func NewWantStatsReply() api.Message { + return &WantStatsReply{} +} + +// VnetIP4FibCounters represents the VPP binary API message 'vnet_ip4_fib_counters'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 131: +// +// ["vnet_ip4_fib_counters", +// ["u16", "_vl_msg_id"], +// ["u32", "vrf_id"], +// ["u32", "count"], +// ["vl_api_ip4_fib_counter_t", "c", 0, "count"], +// {"crc" : "0x1ab9d6c5"} +// ], +// +type VnetIP4FibCounters struct { + VrfID uint32 + Count uint32 `struc:"sizeof=C"` + C []IP4FibCounter +} + +func (*VnetIP4FibCounters) GetMessageName() string { + return "vnet_ip4_fib_counters" +} +func (*VnetIP4FibCounters) GetMessageType() api.MessageType { + return api.OtherMessage +} +func (*VnetIP4FibCounters) GetCrcString() string { + return "1ab9d6c5" +} +func NewVnetIP4FibCounters() api.Message { + return &VnetIP4FibCounters{} +} + +// VnetIP4NbrCounters represents the VPP binary API message 'vnet_ip4_nbr_counters'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 138: +// +// ["vnet_ip4_nbr_counters", +// ["u16", "_vl_msg_id"], +// ["u32", "count"], +// ["u32", "sw_if_index"], +// ["u8", "begin"], +// ["vl_api_ip4_nbr_counter_t", "c", 0, "count"], +// {"crc" : "0xfc2b5092"} +// ], +// +type VnetIP4NbrCounters struct { + Count uint32 `struc:"sizeof=C"` + SwIfIndex uint32 + Begin uint8 + C []IP4NbrCounter +} + +func (*VnetIP4NbrCounters) GetMessageName() string { + return "vnet_ip4_nbr_counters" +} +func (*VnetIP4NbrCounters) GetMessageType() api.MessageType { + return api.OtherMessage +} +func (*VnetIP4NbrCounters) GetCrcString() string { + return "fc2b5092" +} +func NewVnetIP4NbrCounters() api.Message { + return &VnetIP4NbrCounters{} +} + +// VnetIP6FibCounters represents the VPP binary API message 'vnet_ip6_fib_counters'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 146: +// +// ["vnet_ip6_fib_counters", +// ["u16", "_vl_msg_id"], +// ["u32", "vrf_id"], +// ["u32", "count"], +// ["vl_api_ip6_fib_counter_t", "c", 0, "count"], +// {"crc" : "0x9ab453ae"} +// ], +// +type VnetIP6FibCounters struct { + VrfID uint32 + Count uint32 `struc:"sizeof=C"` + C []IP6FibCounter +} + +func (*VnetIP6FibCounters) GetMessageName() string { + return "vnet_ip6_fib_counters" +} +func (*VnetIP6FibCounters) GetMessageType() api.MessageType { + return api.OtherMessage +} +func (*VnetIP6FibCounters) GetCrcString() string { + return "9ab453ae" +} +func NewVnetIP6FibCounters() api.Message { + return &VnetIP6FibCounters{} +} + +// VnetIP6NbrCounters represents the VPP binary API message 'vnet_ip6_nbr_counters'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 153: +// +// ["vnet_ip6_nbr_counters", +// ["u16", "_vl_msg_id"], +// ["u32", "count"], +// ["u32", "sw_if_index"], +// ["u8", "begin"], +// ["vl_api_ip6_nbr_counter_t", "c", 0, "count"], +// {"crc" : "0x181b673f"} +// ], +// +type VnetIP6NbrCounters struct { + Count uint32 `struc:"sizeof=C"` + SwIfIndex uint32 + Begin uint8 + C []IP6NbrCounter +} + +func (*VnetIP6NbrCounters) GetMessageName() string { + return "vnet_ip6_nbr_counters" +} +func (*VnetIP6NbrCounters) GetMessageType() api.MessageType { + return api.OtherMessage +} +func (*VnetIP6NbrCounters) GetCrcString() string { + return "181b673f" +} +func NewVnetIP6NbrCounters() api.Message { + return &VnetIP6NbrCounters{} +} + +// VnetGetSummaryStats represents the VPP binary API message 'vnet_get_summary_stats'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 161: +// +// ["vnet_get_summary_stats", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// {"crc" : "0x16435c20"} +// ], +// +type VnetGetSummaryStats struct { +} + +func (*VnetGetSummaryStats) GetMessageName() string { + return "vnet_get_summary_stats" +} +func (*VnetGetSummaryStats) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*VnetGetSummaryStats) GetCrcString() string { + return "16435c20" +} +func NewVnetGetSummaryStats() api.Message { + return &VnetGetSummaryStats{} +} + +// VnetSummaryStatsReply represents the VPP binary API message 'vnet_summary_stats_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 167: +// +// ["vnet_summary_stats_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u64", "total_pkts", 2], +// ["u64", "total_bytes", 2], +// ["f64", "vector_rate"], +// {"crc" : "0x87a8fa9f"} +// ], +// +type VnetSummaryStatsReply struct { + Retval int32 + TotalPkts []uint64 `struc:"[2]uint64"` + TotalBytes []uint64 `struc:"[2]uint64"` + VectorRate float64 +} + +func (*VnetSummaryStatsReply) GetMessageName() string { + return "vnet_summary_stats_reply" +} +func (*VnetSummaryStatsReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*VnetSummaryStatsReply) GetCrcString() string { + return "87a8fa9f" +} +func NewVnetSummaryStatsReply() api.Message { + return &VnetSummaryStatsReply{} +} + +// OamEvent represents the VPP binary API message 'oam_event'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 176: +// +// ["oam_event", +// ["u16", "_vl_msg_id"], +// ["u8", "dst_address", 4], +// ["u8", "state"], +// {"crc" : "0x4f285ade"} +// ], +// +type OamEvent struct { + DstAddress []byte `struc:"[4]byte"` + State uint8 +} + +func (*OamEvent) GetMessageName() string { + return "oam_event" +} +func (*OamEvent) GetMessageType() api.MessageType { + return api.OtherMessage +} +func (*OamEvent) GetCrcString() string { + return "4f285ade" +} +func NewOamEvent() api.Message { + return &OamEvent{} +} + +// WantOamEvents represents the VPP binary API message 'want_oam_events'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 182: +// +// ["want_oam_events", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "enable_disable"], +// ["u32", "pid"], +// {"crc" : "0x948ef12a"} +// ], +// +type WantOamEvents struct { + EnableDisable uint32 + Pid uint32 +} + +func (*WantOamEvents) GetMessageName() string { + return "want_oam_events" +} +func (*WantOamEvents) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*WantOamEvents) GetCrcString() string { + return "948ef12a" +} +func NewWantOamEvents() api.Message { + return &WantOamEvents{} +} + +// WantOamEventsReply represents the VPP binary API message 'want_oam_events_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 190: +// +// ["want_oam_events_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x266a677d"} +// ], +// +type WantOamEventsReply struct { + Retval int32 +} + +func (*WantOamEventsReply) GetMessageName() string { + return "want_oam_events_reply" +} +func (*WantOamEventsReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*WantOamEventsReply) GetCrcString() string { + return "266a677d" +} +func NewWantOamEventsReply() api.Message { + return &WantOamEventsReply{} +} + +// OamAddDel represents the VPP binary API message 'oam_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 196: +// +// ["oam_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "vrf_id"], +// ["u8", "src_address", 4], +// ["u8", "dst_address", 4], +// ["u8", "is_add"], +// {"crc" : "0xb14bc7df"} +// ], +// +type OamAddDel struct { + VrfID uint32 + SrcAddress []byte `struc:"[4]byte"` + DstAddress []byte `struc:"[4]byte"` + IsAdd uint8 +} + +func (*OamAddDel) GetMessageName() string { + return "oam_add_del" +} +func (*OamAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*OamAddDel) GetCrcString() string { + return "b14bc7df" +} +func NewOamAddDel() api.Message { + return &OamAddDel{} +} + +// OamAddDelReply represents the VPP binary API message 'oam_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 206: +// +// ["oam_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xc5594eec"} +// ], +// +type OamAddDelReply struct { + Retval int32 +} + +func (*OamAddDelReply) GetMessageName() string { + return "oam_add_del_reply" +} +func (*OamAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*OamAddDelReply) GetCrcString() string { + return "c5594eec" +} +func NewOamAddDelReply() api.Message { + return &OamAddDelReply{} +} + +// ResetFib represents the VPP binary API message 'reset_fib'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 212: +// +// ["reset_fib", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "vrf_id"], +// ["u8", "is_ipv6"], +// {"crc" : "0x6f17106b"} +// ], +// +type ResetFib struct { + VrfID uint32 + IsIpv6 uint8 +} + +func (*ResetFib) GetMessageName() string { + return "reset_fib" +} +func (*ResetFib) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ResetFib) GetCrcString() string { + return "6f17106b" +} +func NewResetFib() api.Message { + return &ResetFib{} +} + +// ResetFibReply represents the VPP binary API message 'reset_fib_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 220: +// +// ["reset_fib_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x990dcbf8"} +// ], +// +type ResetFibReply struct { + Retval int32 +} + +func (*ResetFibReply) GetMessageName() string { + return "reset_fib_reply" +} +func (*ResetFibReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ResetFibReply) GetCrcString() string { + return "990dcbf8" +} +func NewResetFibReply() api.Message { + return &ResetFibReply{} +} + +// CreateLoopback represents the VPP binary API message 'create_loopback'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 226: +// +// ["create_loopback", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "mac_address", 6], +// {"crc" : "0xb2602de5"} +// ], +// +type CreateLoopback struct { + MacAddress []byte `struc:"[6]byte"` +} + +func (*CreateLoopback) GetMessageName() string { + return "create_loopback" +} +func (*CreateLoopback) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CreateLoopback) GetCrcString() string { + return "b2602de5" +} +func NewCreateLoopback() api.Message { + return &CreateLoopback{} +} + +// CreateLoopbackReply represents the VPP binary API message 'create_loopback_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 233: +// +// ["create_loopback_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "sw_if_index"], +// {"crc" : "0x9520f804"} +// ], +// +type CreateLoopbackReply struct { + Retval int32 + SwIfIndex uint32 +} + +func (*CreateLoopbackReply) GetMessageName() string { + return "create_loopback_reply" +} +func (*CreateLoopbackReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CreateLoopbackReply) GetCrcString() string { + return "9520f804" +} +func NewCreateLoopbackReply() api.Message { + return &CreateLoopbackReply{} +} + +// CreateLoopbackInstance represents the VPP binary API message 'create_loopback_instance'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 240: +// +// ["create_loopback_instance", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "mac_address", 6], +// ["u8", "is_specified"], +// ["u32", "user_instance"], +// {"crc" : "0x967694f1"} +// ], +// +type CreateLoopbackInstance struct { + MacAddress []byte `struc:"[6]byte"` + IsSpecified uint8 + UserInstance uint32 +} + +func (*CreateLoopbackInstance) GetMessageName() string { + return "create_loopback_instance" +} +func (*CreateLoopbackInstance) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CreateLoopbackInstance) GetCrcString() string { + return "967694f1" +} +func NewCreateLoopbackInstance() api.Message { + return &CreateLoopbackInstance{} +} + +// CreateLoopbackInstanceReply represents the VPP binary API message 'create_loopback_instance_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 249: +// +// ["create_loopback_instance_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "sw_if_index"], +// {"crc" : "0xd52c63b6"} +// ], +// +type CreateLoopbackInstanceReply struct { + Retval int32 + SwIfIndex uint32 +} + +func (*CreateLoopbackInstanceReply) GetMessageName() string { + return "create_loopback_instance_reply" +} +func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CreateLoopbackInstanceReply) GetCrcString() string { + return "d52c63b6" +} +func NewCreateLoopbackInstanceReply() api.Message { + return &CreateLoopbackInstanceReply{} +} + +// DeleteLoopback represents the VPP binary API message 'delete_loopback'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 256: +// +// ["delete_loopback", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// {"crc" : "0xded428b0"} +// ], +// +type DeleteLoopback struct { + SwIfIndex uint32 +} + +func (*DeleteLoopback) GetMessageName() string { + return "delete_loopback" +} +func (*DeleteLoopback) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*DeleteLoopback) GetCrcString() string { + return "ded428b0" +} +func NewDeleteLoopback() api.Message { + return &DeleteLoopback{} +} + +// DeleteLoopbackReply represents the VPP binary API message 'delete_loopback_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 263: +// +// ["delete_loopback_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xc91dafa5"} +// ], +// +type DeleteLoopbackReply struct { + Retval int32 +} + +func (*DeleteLoopbackReply) GetMessageName() string { + return "delete_loopback_reply" +} +func (*DeleteLoopbackReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*DeleteLoopbackReply) GetCrcString() string { + return "c91dafa5" +} +func NewDeleteLoopbackReply() api.Message { + return &DeleteLoopbackReply{} +} + +// ControlPing represents the VPP binary API message 'control_ping'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 269: +// +// ["control_ping", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// {"crc" : "0xea1bf4f7"} +// ], +// +type ControlPing struct { +} + +func (*ControlPing) GetMessageName() string { + return "control_ping" +} +func (*ControlPing) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ControlPing) GetCrcString() string { + return "ea1bf4f7" +} +func NewControlPing() api.Message { + return &ControlPing{} +} + +// ControlPingReply represents the VPP binary API message 'control_ping_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 275: +// +// ["control_ping_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "client_index"], +// ["u32", "vpe_pid"], +// {"crc" : "0xaa016e7b"} +// ], +// +type ControlPingReply struct { + Retval int32 + ClientIndex uint32 + VpePid uint32 +} + +func (*ControlPingReply) GetMessageName() string { + return "control_ping_reply" +} +func (*ControlPingReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ControlPingReply) GetCrcString() string { + return "aa016e7b" +} +func NewControlPingReply() api.Message { + return &ControlPingReply{} +} + +// CliRequest represents the VPP binary API message 'cli_request'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 283: +// +// ["cli_request", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u64", "cmd_in_shmem"], +// {"crc" : "0xfef056d0"} +// ], +// +type CliRequest struct { + CmdInShmem uint64 +} + +func (*CliRequest) GetMessageName() string { + return "cli_request" +} +func (*CliRequest) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CliRequest) GetCrcString() string { + return "fef056d0" +} +func NewCliRequest() api.Message { + return &CliRequest{} +} + +// CliInband represents the VPP binary API message 'cli_inband'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 290: +// +// ["cli_inband", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "length"], +// ["u8", "cmd", 0, "length"], +// {"crc" : "0x22345937"} +// ], +// +type CliInband struct { + Length uint32 `struc:"sizeof=Cmd"` + Cmd []byte +} + +func (*CliInband) GetMessageName() string { + return "cli_inband" +} +func (*CliInband) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CliInband) GetCrcString() string { + return "22345937" +} +func NewCliInband() api.Message { + return &CliInband{} +} + +// CliReply represents the VPP binary API message 'cli_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 298: +// +// ["cli_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u64", "reply_in_shmem"], +// {"crc" : "0x594a0b2e"} +// ], +// +type CliReply struct { + Retval int32 + ReplyInShmem uint64 +} + +func (*CliReply) GetMessageName() string { + return "cli_reply" +} +func (*CliReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CliReply) GetCrcString() string { + return "594a0b2e" +} +func NewCliReply() api.Message { + return &CliReply{} +} + +// CliInbandReply represents the VPP binary API message 'cli_inband_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 305: +// +// ["cli_inband_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "length"], +// ["u8", "reply", 0, "length"], +// {"crc" : "0xc1835761"} +// ], +// +type CliInbandReply struct { + Retval int32 + Length uint32 `struc:"sizeof=Reply"` + Reply []byte +} + +func (*CliInbandReply) GetMessageName() string { + return "cli_inband_reply" +} +func (*CliInbandReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CliInbandReply) GetCrcString() string { + return "c1835761" +} +func NewCliInbandReply() api.Message { + return &CliInbandReply{} +} + +// SetArpNeighborLimit represents the VPP binary API message 'set_arp_neighbor_limit'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 313: +// +// ["set_arp_neighbor_limit", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_ipv6"], +// ["u32", "arp_neighbor_limit"], +// {"crc" : "0xc1690cb4"} +// ], +// +type SetArpNeighborLimit struct { + IsIpv6 uint8 + ArpNeighborLimit uint32 +} + +func (*SetArpNeighborLimit) GetMessageName() string { + return "set_arp_neighbor_limit" +} +func (*SetArpNeighborLimit) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*SetArpNeighborLimit) GetCrcString() string { + return "c1690cb4" +} +func NewSetArpNeighborLimit() api.Message { + return &SetArpNeighborLimit{} +} + +// SetArpNeighborLimitReply represents the VPP binary API message 'set_arp_neighbor_limit_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 321: +// +// ["set_arp_neighbor_limit_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xa6b30518"} +// ], +// +type SetArpNeighborLimitReply struct { + Retval int32 +} + +func (*SetArpNeighborLimitReply) GetMessageName() string { + return "set_arp_neighbor_limit_reply" +} +func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*SetArpNeighborLimitReply) GetCrcString() string { + return "a6b30518" +} +func NewSetArpNeighborLimitReply() api.Message { + return &SetArpNeighborLimitReply{} +} + +// L2PatchAddDel represents the VPP binary API message 'l2_patch_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 327: +// +// ["l2_patch_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "rx_sw_if_index"], +// ["u32", "tx_sw_if_index"], +// ["u8", "is_add"], +// {"crc" : "0x9b10029a"} +// ], +// +type L2PatchAddDel struct { + RxSwIfIndex uint32 + TxSwIfIndex uint32 + IsAdd uint8 +} + +func (*L2PatchAddDel) GetMessageName() string { + return "l2_patch_add_del" +} +func (*L2PatchAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*L2PatchAddDel) GetCrcString() string { + return "9b10029a" +} +func NewL2PatchAddDel() api.Message { + return &L2PatchAddDel{} +} + +// L2PatchAddDelReply represents the VPP binary API message 'l2_patch_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 336: +// +// ["l2_patch_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xa85e37be"} +// ], +// +type L2PatchAddDelReply struct { + Retval int32 +} + +func (*L2PatchAddDelReply) GetMessageName() string { + return "l2_patch_add_del_reply" +} +func (*L2PatchAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*L2PatchAddDelReply) GetCrcString() string { + return "a85e37be" +} +func NewL2PatchAddDelReply() api.Message { + return &L2PatchAddDelReply{} +} + +// SwInterfaceSetVpath represents the VPP binary API message 'sw_interface_set_vpath'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 342: +// +// ["sw_interface_set_vpath", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u8", "enable"], +// {"crc" : "0x1bc2fd5e"} +// ], +// +type SwInterfaceSetVpath struct { + SwIfIndex uint32 + Enable uint8 +} + +func (*SwInterfaceSetVpath) GetMessageName() string { + return "sw_interface_set_vpath" +} +func (*SwInterfaceSetVpath) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*SwInterfaceSetVpath) GetCrcString() string { + return "1bc2fd5e" +} +func NewSwInterfaceSetVpath() api.Message { + return &SwInterfaceSetVpath{} +} + +// SwInterfaceSetVpathReply represents the VPP binary API message 'sw_interface_set_vpath_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 350: +// +// ["sw_interface_set_vpath_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x828dbe62"} +// ], +// +type SwInterfaceSetVpathReply struct { + Retval int32 +} + +func (*SwInterfaceSetVpathReply) GetMessageName() string { + return "sw_interface_set_vpath_reply" +} +func (*SwInterfaceSetVpathReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*SwInterfaceSetVpathReply) GetCrcString() string { + return "828dbe62" +} +func NewSwInterfaceSetVpathReply() api.Message { + return &SwInterfaceSetVpathReply{} +} + +// SwInterfaceSetL2Xconnect represents the VPP binary API message 'sw_interface_set_l2_xconnect'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 356: +// +// ["sw_interface_set_l2_xconnect", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "rx_sw_if_index"], +// ["u32", "tx_sw_if_index"], +// ["u8", "enable"], +// {"crc" : "0x48a4c4c8"} +// ], +// +type SwInterfaceSetL2Xconnect struct { + RxSwIfIndex uint32 + TxSwIfIndex uint32 + Enable uint8 +} + +func (*SwInterfaceSetL2Xconnect) GetMessageName() string { + return "sw_interface_set_l2_xconnect" +} +func (*SwInterfaceSetL2Xconnect) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*SwInterfaceSetL2Xconnect) GetCrcString() string { + return "48a4c4c8" +} +func NewSwInterfaceSetL2Xconnect() api.Message { + return &SwInterfaceSetL2Xconnect{} +} + +// SwInterfaceSetL2XconnectReply represents the VPP binary API message 'sw_interface_set_l2_xconnect_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 365: +// +// ["sw_interface_set_l2_xconnect_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x6e45eed4"} +// ], +// +type SwInterfaceSetL2XconnectReply struct { + Retval int32 +} + +func (*SwInterfaceSetL2XconnectReply) GetMessageName() string { + return "sw_interface_set_l2_xconnect_reply" +} +func (*SwInterfaceSetL2XconnectReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*SwInterfaceSetL2XconnectReply) GetCrcString() string { + return "6e45eed4" +} +func NewSwInterfaceSetL2XconnectReply() api.Message { + return &SwInterfaceSetL2XconnectReply{} +} + +// SwInterfaceSetL2Bridge represents the VPP binary API message 'sw_interface_set_l2_bridge'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 371: +// +// ["sw_interface_set_l2_bridge", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "rx_sw_if_index"], +// ["u32", "bd_id"], +// ["u8", "shg"], +// ["u8", "bvi"], +// ["u8", "enable"], +// {"crc" : "0x36c739e8"} +// ], +// +type SwInterfaceSetL2Bridge struct { + RxSwIfIndex uint32 + BdID uint32 + Shg uint8 + Bvi uint8 + Enable uint8 +} + +func (*SwInterfaceSetL2Bridge) GetMessageName() string { + return "sw_interface_set_l2_bridge" +} +func (*SwInterfaceSetL2Bridge) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*SwInterfaceSetL2Bridge) GetCrcString() string { + return "36c739e8" +} +func NewSwInterfaceSetL2Bridge() api.Message { + return &SwInterfaceSetL2Bridge{} +} + +// SwInterfaceSetL2BridgeReply represents the VPP binary API message 'sw_interface_set_l2_bridge_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 382: +// +// ["sw_interface_set_l2_bridge_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x347e08d9"} +// ], +// +type SwInterfaceSetL2BridgeReply struct { + Retval int32 +} + +func (*SwInterfaceSetL2BridgeReply) GetMessageName() string { + return "sw_interface_set_l2_bridge_reply" +} +func (*SwInterfaceSetL2BridgeReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*SwInterfaceSetL2BridgeReply) GetCrcString() string { + return "347e08d9" +} +func NewSwInterfaceSetL2BridgeReply() api.Message { + return &SwInterfaceSetL2BridgeReply{} +} + +// BdIPMacAddDel represents the VPP binary API message 'bd_ip_mac_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 388: +// +// ["bd_ip_mac_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "bd_id"], +// ["u8", "is_add"], +// ["u8", "is_ipv6"], +// ["u8", "ip_address", 16], +// ["u8", "mac_address", 6], +// {"crc" : "0xad819817"} +// ], +// +type BdIPMacAddDel struct { + BdID uint32 + IsAdd uint8 + IsIpv6 uint8 + IPAddress []byte `struc:"[16]byte"` + MacAddress []byte `struc:"[6]byte"` +} + +func (*BdIPMacAddDel) GetMessageName() string { + return "bd_ip_mac_add_del" +} +func (*BdIPMacAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*BdIPMacAddDel) GetCrcString() string { + return "ad819817" +} +func NewBdIPMacAddDel() api.Message { + return &BdIPMacAddDel{} +} + +// BdIPMacAddDelReply represents the VPP binary API message 'bd_ip_mac_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 399: +// +// ["bd_ip_mac_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x55bab3b4"} +// ], +// +type BdIPMacAddDelReply struct { + Retval int32 +} + +func (*BdIPMacAddDelReply) GetMessageName() string { + return "bd_ip_mac_add_del_reply" +} +func (*BdIPMacAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*BdIPMacAddDelReply) GetCrcString() string { + return "55bab3b4" +} +func NewBdIPMacAddDelReply() api.Message { + return &BdIPMacAddDelReply{} +} + +// ClassifySetInterfaceIPTable represents the VPP binary API message 'classify_set_interface_ip_table'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 405: +// +// ["classify_set_interface_ip_table", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_ipv6"], +// ["u32", "sw_if_index"], +// ["u32", "table_index"], +// {"crc" : "0x0dc45308"} +// ], +// +type ClassifySetInterfaceIPTable struct { + IsIpv6 uint8 + SwIfIndex uint32 + TableIndex uint32 +} + +func (*ClassifySetInterfaceIPTable) GetMessageName() string { + return "classify_set_interface_ip_table" +} +func (*ClassifySetInterfaceIPTable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ClassifySetInterfaceIPTable) GetCrcString() string { + return "0dc45308" +} +func NewClassifySetInterfaceIPTable() api.Message { + return &ClassifySetInterfaceIPTable{} +} + +// ClassifySetInterfaceIPTableReply represents the VPP binary API message 'classify_set_interface_ip_table_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 414: +// +// ["classify_set_interface_ip_table_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xdc391c34"} +// ], +// +type ClassifySetInterfaceIPTableReply struct { + Retval int32 +} + +func (*ClassifySetInterfaceIPTableReply) GetMessageName() string { + return "classify_set_interface_ip_table_reply" +} +func (*ClassifySetInterfaceIPTableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ClassifySetInterfaceIPTableReply) GetCrcString() string { + return "dc391c34" +} +func NewClassifySetInterfaceIPTableReply() api.Message { + return &ClassifySetInterfaceIPTableReply{} +} + +// ClassifySetInterfaceL2Tables represents the VPP binary API message 'classify_set_interface_l2_tables'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 420: +// +// ["classify_set_interface_l2_tables", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "ip4_table_index"], +// ["u32", "ip6_table_index"], +// ["u32", "other_table_index"], +// ["u8", "is_input"], +// {"crc" : "0xed9ccf0d"} +// ], +// +type ClassifySetInterfaceL2Tables struct { + SwIfIndex uint32 + IP4TableIndex uint32 + IP6TableIndex uint32 + OtherTableIndex uint32 + IsInput uint8 +} + +func (*ClassifySetInterfaceL2Tables) GetMessageName() string { + return "classify_set_interface_l2_tables" +} +func (*ClassifySetInterfaceL2Tables) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ClassifySetInterfaceL2Tables) GetCrcString() string { + return "ed9ccf0d" +} +func NewClassifySetInterfaceL2Tables() api.Message { + return &ClassifySetInterfaceL2Tables{} +} + +// ClassifySetInterfaceL2TablesReply represents the VPP binary API message 'classify_set_interface_l2_tables_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 431: +// +// ["classify_set_interface_l2_tables_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x8df20579"} +// ], +// +type ClassifySetInterfaceL2TablesReply struct { + Retval int32 +} + +func (*ClassifySetInterfaceL2TablesReply) GetMessageName() string { + return "classify_set_interface_l2_tables_reply" +} +func (*ClassifySetInterfaceL2TablesReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ClassifySetInterfaceL2TablesReply) GetCrcString() string { + return "8df20579" +} +func NewClassifySetInterfaceL2TablesReply() api.Message { + return &ClassifySetInterfaceL2TablesReply{} +} + +// GetNodeIndex represents the VPP binary API message 'get_node_index'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 437: +// +// ["get_node_index", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "node_name", 64], +// {"crc" : "0x226d3f8c"} +// ], +// +type GetNodeIndex struct { + NodeName []byte `struc:"[64]byte"` +} + +func (*GetNodeIndex) GetMessageName() string { + return "get_node_index" +} +func (*GetNodeIndex) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*GetNodeIndex) GetCrcString() string { + return "226d3f8c" +} +func NewGetNodeIndex() api.Message { + return &GetNodeIndex{} +} + +// GetNodeIndexReply represents the VPP binary API message 'get_node_index_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 444: +// +// ["get_node_index_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "node_index"], +// {"crc" : "0x29116865"} +// ], +// +type GetNodeIndexReply struct { + Retval int32 + NodeIndex uint32 +} + +func (*GetNodeIndexReply) GetMessageName() string { + return "get_node_index_reply" +} +func (*GetNodeIndexReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*GetNodeIndexReply) GetCrcString() string { + return "29116865" +} +func NewGetNodeIndexReply() api.Message { + return &GetNodeIndexReply{} +} + +// AddNodeNext represents the VPP binary API message 'add_node_next'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 451: +// +// ["add_node_next", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "node_name", 64], +// ["u8", "next_name", 64], +// {"crc" : "0xe4202993"} +// ], +// +type AddNodeNext struct { + NodeName []byte `struc:"[64]byte"` + NextName []byte `struc:"[64]byte"` +} + +func (*AddNodeNext) GetMessageName() string { + return "add_node_next" +} +func (*AddNodeNext) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*AddNodeNext) GetCrcString() string { + return "e4202993" +} +func NewAddNodeNext() api.Message { + return &AddNodeNext{} +} + +// AddNodeNextReply represents the VPP binary API message 'add_node_next_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 459: +// +// ["add_node_next_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "next_index"], +// {"crc" : "0xe89d6eed"} +// ], +// +type AddNodeNextReply struct { + Retval int32 + NextIndex uint32 +} + +func (*AddNodeNextReply) GetMessageName() string { + return "add_node_next_reply" +} +func (*AddNodeNextReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*AddNodeNextReply) GetCrcString() string { + return "e89d6eed" +} +func NewAddNodeNextReply() api.Message { + return &AddNodeNextReply{} +} + +// L2InterfaceEfpFilter represents the VPP binary API message 'l2_interface_efp_filter'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 466: +// +// ["l2_interface_efp_filter", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "enable_disable"], +// {"crc" : "0x07c9d601"} +// ], +// +type L2InterfaceEfpFilter struct { + SwIfIndex uint32 + EnableDisable uint32 +} + +func (*L2InterfaceEfpFilter) GetMessageName() string { + return "l2_interface_efp_filter" +} +func (*L2InterfaceEfpFilter) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*L2InterfaceEfpFilter) GetCrcString() string { + return "07c9d601" +} +func NewL2InterfaceEfpFilter() api.Message { + return &L2InterfaceEfpFilter{} +} + +// L2InterfaceEfpFilterReply represents the VPP binary API message 'l2_interface_efp_filter_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 474: +// +// ["l2_interface_efp_filter_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x0f4bb0c0"} +// ], +// +type L2InterfaceEfpFilterReply struct { + Retval int32 +} + +func (*L2InterfaceEfpFilterReply) GetMessageName() string { + return "l2_interface_efp_filter_reply" +} +func (*L2InterfaceEfpFilterReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*L2InterfaceEfpFilterReply) GetCrcString() string { + return "0f4bb0c0" +} +func NewL2InterfaceEfpFilterReply() api.Message { + return &L2InterfaceEfpFilterReply{} +} + +// CreateSubif represents the VPP binary API message 'create_subif'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 480: +// +// ["create_subif", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "sub_id"], +// ["u8", "no_tags"], +// ["u8", "one_tag"], +// ["u8", "two_tags"], +// ["u8", "dot1ad"], +// ["u8", "exact_match"], +// ["u8", "default_sub"], +// ["u8", "outer_vlan_id_any"], +// ["u8", "inner_vlan_id_any"], +// ["u16", "outer_vlan_id"], +// ["u16", "inner_vlan_id"], +// {"crc" : "0x150e6757"} +// ], +// +type CreateSubif struct { + SwIfIndex uint32 + SubID uint32 + NoTags uint8 + OneTag uint8 + TwoTags uint8 + Dot1ad uint8 + ExactMatch uint8 + DefaultSub uint8 + OuterVlanIDAny uint8 + InnerVlanIDAny uint8 + OuterVlanID uint16 + InnerVlanID uint16 +} + +func (*CreateSubif) GetMessageName() string { + return "create_subif" +} +func (*CreateSubif) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*CreateSubif) GetCrcString() string { + return "150e6757" +} +func NewCreateSubif() api.Message { + return &CreateSubif{} +} + +// CreateSubifReply represents the VPP binary API message 'create_subif_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 498: +// +// ["create_subif_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "sw_if_index"], +// {"crc" : "0x92272bcb"} +// ], +// +type CreateSubifReply struct { + Retval int32 + SwIfIndex uint32 +} + +func (*CreateSubifReply) GetMessageName() string { + return "create_subif_reply" +} +func (*CreateSubifReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*CreateSubifReply) GetCrcString() string { + return "92272bcb" +} +func NewCreateSubifReply() api.Message { + return &CreateSubifReply{} +} + +// ShowVersion represents the VPP binary API message 'show_version'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 505: +// +// ["show_version", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// {"crc" : "0xf18f9480"} +// ], +// +type ShowVersion struct { +} + +func (*ShowVersion) GetMessageName() string { + return "show_version" +} +func (*ShowVersion) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*ShowVersion) GetCrcString() string { + return "f18f9480" +} +func NewShowVersion() api.Message { + return &ShowVersion{} +} + +// ShowVersionReply represents the VPP binary API message 'show_version_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 511: +// +// ["show_version_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u8", "program", 32], +// ["u8", "version", 32], +// ["u8", "build_date", 32], +// ["u8", "build_directory", 256], +// {"crc" : "0x83186d9e"} +// ], +// +type ShowVersionReply struct { + Retval int32 + Program []byte `struc:"[32]byte"` + Version []byte `struc:"[32]byte"` + BuildDate []byte `struc:"[32]byte"` + BuildDirectory []byte `struc:"[256]byte"` +} + +func (*ShowVersionReply) GetMessageName() string { + return "show_version_reply" +} +func (*ShowVersionReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*ShowVersionReply) GetCrcString() string { + return "83186d9e" +} +func NewShowVersionReply() api.Message { + return &ShowVersionReply{} +} + +// InterfaceNameRenumber represents the VPP binary API message 'interface_name_renumber'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 521: +// +// ["interface_name_renumber", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "new_show_dev_instance"], +// {"crc" : "0x11b7bcec"} +// ], +// +type InterfaceNameRenumber struct { + SwIfIndex uint32 + NewShowDevInstance uint32 +} + +func (*InterfaceNameRenumber) GetMessageName() string { + return "interface_name_renumber" +} +func (*InterfaceNameRenumber) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*InterfaceNameRenumber) GetCrcString() string { + return "11b7bcec" +} +func NewInterfaceNameRenumber() api.Message { + return &InterfaceNameRenumber{} +} + +// InterfaceNameRenumberReply represents the VPP binary API message 'interface_name_renumber_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 529: +// +// ["interface_name_renumber_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x31594963"} +// ], +// +type InterfaceNameRenumberReply struct { + Retval int32 +} + +func (*InterfaceNameRenumberReply) GetMessageName() string { + return "interface_name_renumber_reply" +} +func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*InterfaceNameRenumberReply) GetCrcString() string { + return "31594963" +} +func NewInterfaceNameRenumberReply() api.Message { + return &InterfaceNameRenumberReply{} +} + +// WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 535: +// +// ["want_ip4_arp_events", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "enable_disable"], +// ["u32", "pid"], +// ["u32", "address"], +// {"crc" : "0x5ae044c2"} +// ], +// +type WantIP4ArpEvents struct { + EnableDisable uint8 + Pid uint32 + Address uint32 +} + +func (*WantIP4ArpEvents) GetMessageName() string { + return "want_ip4_arp_events" +} +func (*WantIP4ArpEvents) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*WantIP4ArpEvents) GetCrcString() string { + return "5ae044c2" +} +func NewWantIP4ArpEvents() api.Message { + return &WantIP4ArpEvents{} +} + +// WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 544: +// +// ["want_ip4_arp_events_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xe1c0b59e"} +// ], +// +type WantIP4ArpEventsReply struct { + Retval int32 +} + +func (*WantIP4ArpEventsReply) GetMessageName() string { + return "want_ip4_arp_events_reply" +} +func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*WantIP4ArpEventsReply) GetCrcString() string { + return "e1c0b59e" +} +func NewWantIP4ArpEventsReply() api.Message { + return &WantIP4ArpEventsReply{} +} + +// IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 550: +// +// ["ip4_arp_event", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "address"], +// ["u32", "pid"], +// ["u32", "sw_if_index"], +// ["u8", "new_mac", 6], +// ["u8", "mac_ip"], +// {"crc" : "0x7de1837b"} +// ], +// +type IP4ArpEvent struct { + Address uint32 + Pid uint32 + SwIfIndex uint32 + NewMac []byte `struc:"[6]byte"` + MacIP uint8 +} + +func (*IP4ArpEvent) GetMessageName() string { + return "ip4_arp_event" +} +func (*IP4ArpEvent) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IP4ArpEvent) GetCrcString() string { + return "7de1837b" +} +func NewIP4ArpEvent() api.Message { + return &IP4ArpEvent{} +} + +// WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 561: +// +// ["want_ip6_nd_events", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "enable_disable"], +// ["u32", "pid"], +// ["u8", "address", 16], +// {"crc" : "0x9586ba55"} +// ], +// +type WantIP6NdEvents struct { + EnableDisable uint8 + Pid uint32 + Address []byte `struc:"[16]byte"` +} + +func (*WantIP6NdEvents) GetMessageName() string { + return "want_ip6_nd_events" +} +func (*WantIP6NdEvents) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*WantIP6NdEvents) GetCrcString() string { + return "9586ba55" +} +func NewWantIP6NdEvents() api.Message { + return &WantIP6NdEvents{} +} + +// WantIP6NdEventsReply represents the VPP binary API message 'want_ip6_nd_events_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 570: +// +// ["want_ip6_nd_events_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x95458aad"} +// ], +// +type WantIP6NdEventsReply struct { + Retval int32 +} + +func (*WantIP6NdEventsReply) GetMessageName() string { + return "want_ip6_nd_events_reply" +} +func (*WantIP6NdEventsReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*WantIP6NdEventsReply) GetCrcString() string { + return "95458aad" +} +func NewWantIP6NdEventsReply() api.Message { + return &WantIP6NdEventsReply{} +} + +// IP6NdEvent represents the VPP binary API message 'ip6_nd_event'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 576: +// +// ["ip6_nd_event", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "pid"], +// ["u32", "sw_if_index"], +// ["u8", "address", 16], +// ["u8", "new_mac", 6], +// ["u8", "mac_ip"], +// {"crc" : "0x777bb71c"} +// ], +// +type IP6NdEvent struct { + Pid uint32 + SwIfIndex uint32 + Address []byte `struc:"[16]byte"` + NewMac []byte `struc:"[6]byte"` + MacIP uint8 +} + +func (*IP6NdEvent) GetMessageName() string { + return "ip6_nd_event" +} +func (*IP6NdEvent) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IP6NdEvent) GetCrcString() string { + return "777bb71c" +} +func NewIP6NdEvent() api.Message { + return &IP6NdEvent{} +} + +// InputACLSetInterface represents the VPP binary API message 'input_acl_set_interface'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 587: +// +// ["input_acl_set_interface", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u32", "ip4_table_index"], +// ["u32", "ip6_table_index"], +// ["u32", "l2_table_index"], +// ["u8", "is_add"], +// {"crc" : "0x34d2fc33"} +// ], +// +type InputACLSetInterface struct { + SwIfIndex uint32 + IP4TableIndex uint32 + IP6TableIndex uint32 + L2TableIndex uint32 + IsAdd uint8 +} + +func (*InputACLSetInterface) GetMessageName() string { + return "input_acl_set_interface" +} +func (*InputACLSetInterface) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*InputACLSetInterface) GetCrcString() string { + return "34d2fc33" +} +func NewInputACLSetInterface() api.Message { + return &InputACLSetInterface{} +} + +// InputACLSetInterfaceReply represents the VPP binary API message 'input_acl_set_interface_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 598: +// +// ["input_acl_set_interface_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xba0110e3"} +// ], +// +type InputACLSetInterfaceReply struct { + Retval int32 +} + +func (*InputACLSetInterfaceReply) GetMessageName() string { + return "input_acl_set_interface_reply" +} +func (*InputACLSetInterfaceReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*InputACLSetInterfaceReply) GetCrcString() string { + return "ba0110e3" +} +func NewInputACLSetInterfaceReply() api.Message { + return &InputACLSetInterfaceReply{} +} + +// GetNodeGraph represents the VPP binary API message 'get_node_graph'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 604: +// +// ["get_node_graph", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// {"crc" : "0xf8636a76"} +// ], +// +type GetNodeGraph struct { +} + +func (*GetNodeGraph) GetMessageName() string { + return "get_node_graph" +} +func (*GetNodeGraph) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*GetNodeGraph) GetCrcString() string { + return "f8636a76" +} +func NewGetNodeGraph() api.Message { + return &GetNodeGraph{} +} + +// GetNodeGraphReply represents the VPP binary API message 'get_node_graph_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 610: +// +// ["get_node_graph_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u64", "reply_in_shmem"], +// {"crc" : "0x816d91b6"} +// ], +// +type GetNodeGraphReply struct { + Retval int32 + ReplyInShmem uint64 +} + +func (*GetNodeGraphReply) GetMessageName() string { + return "get_node_graph_reply" +} +func (*GetNodeGraphReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*GetNodeGraphReply) GetCrcString() string { + return "816d91b6" +} +func NewGetNodeGraphReply() api.Message { + return &GetNodeGraphReply{} +} + +// IoamEnable represents the VPP binary API message 'ioam_enable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 617: +// +// ["ioam_enable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u16", "id"], +// ["u8", "seqno"], +// ["u8", "analyse"], +// ["u8", "pot_enable"], +// ["u8", "trace_enable"], +// ["u32", "node_id"], +// {"crc" : "0x7bd4abf9"} +// ], +// +type IoamEnable struct { + ID uint16 + Seqno uint8 + Analyse uint8 + PotEnable uint8 + TraceEnable uint8 + NodeID uint32 +} + +func (*IoamEnable) GetMessageName() string { + return "ioam_enable" +} +func (*IoamEnable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IoamEnable) GetCrcString() string { + return "7bd4abf9" +} +func NewIoamEnable() api.Message { + return &IoamEnable{} +} + +// IoamEnableReply represents the VPP binary API message 'ioam_enable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 629: +// +// ["ioam_enable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x58a8fedc"} +// ], +// +type IoamEnableReply struct { + Retval int32 +} + +func (*IoamEnableReply) GetMessageName() string { + return "ioam_enable_reply" +} +func (*IoamEnableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*IoamEnableReply) GetCrcString() string { + return "58a8fedc" +} +func NewIoamEnableReply() api.Message { + return &IoamEnableReply{} +} + +// IoamDisable represents the VPP binary API message 'ioam_disable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 635: +// +// ["ioam_disable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u16", "id"], +// {"crc" : "0xaff26d33"} +// ], +// +type IoamDisable struct { + ID uint16 +} + +func (*IoamDisable) GetMessageName() string { + return "ioam_disable" +} +func (*IoamDisable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IoamDisable) GetCrcString() string { + return "aff26d33" +} +func NewIoamDisable() api.Message { + return &IoamDisable{} +} + +// IoamDisableReply represents the VPP binary API message 'ioam_disable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 642: +// +// ["ioam_disable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xef118a9d"} +// ], +// +type IoamDisableReply struct { + Retval int32 +} + +func (*IoamDisableReply) GetMessageName() string { + return "ioam_disable_reply" +} +func (*IoamDisableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*IoamDisableReply) GetCrcString() string { + return "ef118a9d" +} +func NewIoamDisableReply() api.Message { + return &IoamDisableReply{} +} + +// GetNextIndex represents the VPP binary API message 'get_next_index'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 648: +// +// ["get_next_index", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "node_name", 64], +// ["u8", "next_name", 64], +// {"crc" : "0x52f0e416"} +// ], +// +type GetNextIndex struct { + NodeName []byte `struc:"[64]byte"` + NextName []byte `struc:"[64]byte"` +} + +func (*GetNextIndex) GetMessageName() string { + return "get_next_index" +} +func (*GetNextIndex) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*GetNextIndex) GetCrcString() string { + return "52f0e416" +} +func NewGetNextIndex() api.Message { + return &GetNextIndex{} +} + +// GetNextIndexReply represents the VPP binary API message 'get_next_index_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 656: +// +// ["get_next_index_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "next_index"], +// {"crc" : "0x671fbdb1"} +// ], +// +type GetNextIndexReply struct { + Retval int32 + NextIndex uint32 +} + +func (*GetNextIndexReply) GetMessageName() string { + return "get_next_index_reply" +} +func (*GetNextIndexReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*GetNextIndexReply) GetCrcString() string { + return "671fbdb1" +} +func NewGetNextIndexReply() api.Message { + return &GetNextIndexReply{} +} + +// PgCreateInterface represents the VPP binary API message 'pg_create_interface'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 663: +// +// ["pg_create_interface", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "interface_id"], +// {"crc" : "0x253c5959"} +// ], +// +type PgCreateInterface struct { + InterfaceID uint32 +} + +func (*PgCreateInterface) GetMessageName() string { + return "pg_create_interface" +} +func (*PgCreateInterface) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*PgCreateInterface) GetCrcString() string { + return "253c5959" +} +func NewPgCreateInterface() api.Message { + return &PgCreateInterface{} +} + +// PgCreateInterfaceReply represents the VPP binary API message 'pg_create_interface_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 670: +// +// ["pg_create_interface_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// ["u32", "sw_if_index"], +// {"crc" : "0x21b4f949"} +// ], +// +type PgCreateInterfaceReply struct { + Retval int32 + SwIfIndex uint32 +} + +func (*PgCreateInterfaceReply) GetMessageName() string { + return "pg_create_interface_reply" +} +func (*PgCreateInterfaceReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*PgCreateInterfaceReply) GetCrcString() string { + return "21b4f949" +} +func NewPgCreateInterfaceReply() api.Message { + return &PgCreateInterfaceReply{} +} + +// PgCapture represents the VPP binary API message 'pg_capture'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 677: +// +// ["pg_capture", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "interface_id"], +// ["u8", "is_enabled"], +// ["u32", "count"], +// ["u32", "pcap_name_length"], +// ["u8", "pcap_file_name", 0, "pcap_name_length"], +// {"crc" : "0x6ac7fe78"} +// ], +// +type PgCapture struct { + InterfaceID uint32 + IsEnabled uint8 + Count uint32 + PcapNameLength uint32 `struc:"sizeof=PcapFileName"` + PcapFileName []byte +} + +func (*PgCapture) GetMessageName() string { + return "pg_capture" +} +func (*PgCapture) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*PgCapture) GetCrcString() string { + return "6ac7fe78" +} +func NewPgCapture() api.Message { + return &PgCapture{} +} + +// PgCaptureReply represents the VPP binary API message 'pg_capture_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 688: +// +// ["pg_capture_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xf403693b"} +// ], +// +type PgCaptureReply struct { + Retval int32 +} + +func (*PgCaptureReply) GetMessageName() string { + return "pg_capture_reply" +} +func (*PgCaptureReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*PgCaptureReply) GetCrcString() string { + return "f403693b" +} +func NewPgCaptureReply() api.Message { + return &PgCaptureReply{} +} + +// PgEnableDisable represents the VPP binary API message 'pg_enable_disable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 694: +// +// ["pg_enable_disable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_enabled"], +// ["u32", "stream_name_length"], +// ["u8", "stream_name", 0, "stream_name_length"], +// {"crc" : "0x7d0b90ff"} +// ], +// +type PgEnableDisable struct { + IsEnabled uint8 + StreamNameLength uint32 `struc:"sizeof=StreamName"` + StreamName []byte +} + +func (*PgEnableDisable) GetMessageName() string { + return "pg_enable_disable" +} +func (*PgEnableDisable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*PgEnableDisable) GetCrcString() string { + return "7d0b90ff" +} +func NewPgEnableDisable() api.Message { + return &PgEnableDisable{} +} + +// PgEnableDisableReply represents the VPP binary API message 'pg_enable_disable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 703: +// +// ["pg_enable_disable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x02253bd6"} +// ], +// +type PgEnableDisableReply struct { + Retval int32 +} + +func (*PgEnableDisableReply) GetMessageName() string { + return "pg_enable_disable_reply" +} +func (*PgEnableDisableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*PgEnableDisableReply) GetCrcString() string { + return "02253bd6" +} +func NewPgEnableDisableReply() api.Message { + return &PgEnableDisableReply{} +} + +// IPSourceAndPortRangeCheckAddDel represents the VPP binary API message 'ip_source_and_port_range_check_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 709: +// +// ["ip_source_and_port_range_check_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_ipv6"], +// ["u8", "is_add"], +// ["u8", "mask_length"], +// ["u8", "address", 16], +// ["u8", "number_of_ranges"], +// ["u16", "low_ports", 32], +// ["u16", "high_ports", 32], +// ["u32", "vrf_id"], +// {"crc" : "0x0f8c6ba0"} +// ], +// +type IPSourceAndPortRangeCheckAddDel struct { + IsIpv6 uint8 + IsAdd uint8 + MaskLength uint8 + Address []byte `struc:"[16]byte"` + NumberOfRanges uint8 + LowPorts []uint16 `struc:"[32]uint16"` + HighPorts []uint16 `struc:"[32]uint16"` + VrfID uint32 +} + +func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string { + return "ip_source_and_port_range_check_add_del" +} +func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string { + return "0f8c6ba0" +} +func NewIPSourceAndPortRangeCheckAddDel() api.Message { + return &IPSourceAndPortRangeCheckAddDel{} +} + +// IPSourceAndPortRangeCheckAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 723: +// +// ["ip_source_and_port_range_check_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x35df8160"} +// ], +// +type IPSourceAndPortRangeCheckAddDelReply struct { + Retval int32 +} + +func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string { + return "ip_source_and_port_range_check_add_del_reply" +} +func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string { + return "35df8160" +} +func NewIPSourceAndPortRangeCheckAddDelReply() api.Message { + return &IPSourceAndPortRangeCheckAddDelReply{} +} + +// IPSourceAndPortRangeCheckInterfaceAddDel represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 729: +// +// ["ip_source_and_port_range_check_interface_add_del", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_add"], +// ["u32", "sw_if_index"], +// ["u32", "tcp_in_vrf_id"], +// ["u32", "tcp_out_vrf_id"], +// ["u32", "udp_in_vrf_id"], +// ["u32", "udp_out_vrf_id"], +// {"crc" : "0x4a6438f1"} +// ], +// +type IPSourceAndPortRangeCheckInterfaceAddDel struct { + IsAdd uint8 + SwIfIndex uint32 + TCPInVrfID uint32 + TCPOutVrfID uint32 + UDPInVrfID uint32 + UDPOutVrfID uint32 +} + +func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string { + return "ip_source_and_port_range_check_interface_add_del" +} +func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string { + return "4a6438f1" +} +func NewIPSourceAndPortRangeCheckInterfaceAddDel() api.Message { + return &IPSourceAndPortRangeCheckInterfaceAddDel{} +} + +// IPSourceAndPortRangeCheckInterfaceAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 741: +// +// ["ip_source_and_port_range_check_interface_add_del_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x6b940f04"} +// ], +// +type IPSourceAndPortRangeCheckInterfaceAddDelReply struct { + Retval int32 +} + +func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string { + return "ip_source_and_port_range_check_interface_add_del_reply" +} +func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string { + return "6b940f04" +} +func NewIPSourceAndPortRangeCheckInterfaceAddDelReply() api.Message { + return &IPSourceAndPortRangeCheckInterfaceAddDelReply{} +} + +// DeleteSubif represents the VPP binary API message 'delete_subif'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 747: +// +// ["delete_subif", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// {"crc" : "0x6038f848"} +// ], +// +type DeleteSubif struct { + SwIfIndex uint32 +} + +func (*DeleteSubif) GetMessageName() string { + return "delete_subif" +} +func (*DeleteSubif) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*DeleteSubif) GetCrcString() string { + return "6038f848" +} +func NewDeleteSubif() api.Message { + return &DeleteSubif{} +} + +// DeleteSubifReply represents the VPP binary API message 'delete_subif_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 754: +// +// ["delete_subif_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0x9d6015dc"} +// ], +// +type DeleteSubifReply struct { + Retval int32 +} + +func (*DeleteSubifReply) GetMessageName() string { + return "delete_subif_reply" +} +func (*DeleteSubifReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*DeleteSubifReply) GetCrcString() string { + return "9d6015dc" +} +func NewDeleteSubifReply() api.Message { + return &DeleteSubifReply{} +} + +// Punt represents the VPP binary API message 'punt'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 760: +// +// ["punt", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u8", "is_add"], +// ["u8", "ipv"], +// ["u8", "l4_protocol"], +// ["u16", "l4_port"], +// {"crc" : "0x4559c976"} +// ], +// +type Punt struct { + IsAdd uint8 + Ipv uint8 + L4Protocol uint8 + L4Port uint16 +} + +func (*Punt) GetMessageName() string { + return "punt" +} +func (*Punt) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*Punt) GetCrcString() string { + return "4559c976" +} +func NewPunt() api.Message { + return &Punt{} +} + +// PuntReply represents the VPP binary API message 'punt_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 770: +// +// ["punt_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xcca27fbe"} +// ], +// +type PuntReply struct { + Retval int32 +} + +func (*PuntReply) GetMessageName() string { + return "punt_reply" +} +func (*PuntReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*PuntReply) GetCrcString() string { + return "cca27fbe" +} +func NewPuntReply() api.Message { + return &PuntReply{} +} + +// FeatureEnableDisable represents the VPP binary API message 'feature_enable_disable'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 776: +// +// ["feature_enable_disable", +// ["u16", "_vl_msg_id"], +// ["u32", "client_index"], +// ["u32", "context"], +// ["u32", "sw_if_index"], +// ["u8", "enable"], +// ["u8", "arc_name", 64], +// ["u8", "feature_name", 64], +// {"crc" : "0xbc86393b"} +// ], +// +type FeatureEnableDisable struct { + SwIfIndex uint32 + Enable uint8 + ArcName []byte `struc:"[64]byte"` + FeatureName []byte `struc:"[64]byte"` +} + +func (*FeatureEnableDisable) GetMessageName() string { + return "feature_enable_disable" +} +func (*FeatureEnableDisable) GetMessageType() api.MessageType { + return api.RequestMessage +} +func (*FeatureEnableDisable) GetCrcString() string { + return "bc86393b" +} +func NewFeatureEnableDisable() api.Message { + return &FeatureEnableDisable{} +} + +// FeatureEnableDisableReply represents the VPP binary API message 'feature_enable_disable_reply'. +// Generated from '/usr/share/vpp/api/vpe.api.json', line 786: +// +// ["feature_enable_disable_reply", +// ["u16", "_vl_msg_id"], +// ["u32", "context"], +// ["i32", "retval"], +// {"crc" : "0xf6e14373"} +// ] +// +type FeatureEnableDisableReply struct { + Retval int32 +} + +func (*FeatureEnableDisableReply) GetMessageName() string { + return "feature_enable_disable_reply" +} +func (*FeatureEnableDisableReply) GetMessageType() api.MessageType { + return api.ReplyMessage +} +func (*FeatureEnableDisableReply) GetCrcString() string { + return "f6e14373" +} +func NewFeatureEnableDisableReply() api.Message { + return &FeatureEnableDisableReply{} +} -- cgit 1.2.3-korg