initial commit

Signed-off-by: Rastislav Szabo <raszabo@cisco.com>

6 files changed, 3985 insertions, 0 deletions

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{}
+}
diff --git a/core/core.go b/core/core.go
new file mode 100644
index 0000000..e11a30f
--- /dev/null
+++ b/core/core.go
@@ -0,0 +1,340 @@
+// Copyright (c) 2017 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 core
+
+//go:generate binapi_generator --input-file=/usr/share/vpp/api/vpe.api.json --output-dir=./bin_api
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"sync"
+	"sync/atomic"
+
+	logger "github.com/Sirupsen/logrus"
+
+	"gerrit.fd.io/r/govpp/adapter"
+	"gerrit.fd.io/r/govpp/api"
+	"gerrit.fd.io/r/govpp/core/bin_api/vpe"
+)
+
+const (
+	requestChannelBufSize = 100 // default size of the request channel buffers
+	replyChannelBufSize   = 100 // default size of the reply channel buffers
+)
+
+// Connection represents a shared memory connection to VPP via vppAdapter.
+type Connection struct {
+	vpp   adapter.VppAdapter // VPP adapter
+	codec *MsgCodec          // message codec
+
+	msgIDs     map[string]uint16 // map os message IDs indexed by message name + CRC
+	msgIDsLock sync.RWMutex      // lock for the message IDs map
+
+	channels     map[uint32]*api.Channel // map of all API channels indexed by the channel ID
+	channelsLock sync.RWMutex            // lock for the channels map
+
+	notifSubscriptions     map[uint16][]*api.NotifSubscription // map od all notification subscriptions indexed by message ID
+	notifSubscriptionsLock sync.RWMutex                        // lock for the subscriptions map
+
+	maxChannelID uint32 // maximum used client ID
+	pingReqID    uint16 // ID if the ControlPing message
+	pingReplyID  uint16 // ID of the ControlPingReply message
+}
+
+// channelMetadata contains core-local metadata of an API channel.
+type channelMetadata struct {
+	id        uint32 // channel ID
+	multipart uint32 // 1 if multipart request is being processed, 0 otherwise
+}
+
+var (
+	log      *logger.Logger // global logger
+	conn     *Connection    // global handle to the Connection (used in the message receive callback)
+	connLock sync.RWMutex   // lock for the global connection
+)
+
+// init initializes global logger, which logs debug level messages to stdout.
+func init() {
+	log = logger.New()
+	log.Out = os.Stdout
+	log.Level = logger.DebugLevel
+}
+
+// SetLogger sets global logger to provided one.
+func SetLogger(l *logger.Logger) {
+	log = l
+}
+
+// Connect connects to VPP using specified VPP adapter and returns the connection handle.
+func Connect(vppAdapter adapter.VppAdapter) (*Connection, error) {
+	connLock.Lock()
+	defer connLock.Unlock()
+
+	if conn != nil {
+		return nil, errors.New("only one connection per process is supported")
+	}
+
+	conn = &Connection{vpp: vppAdapter, codec: &MsgCodec{}}
+	conn.channels = make(map[uint32]*api.Channel)
+	conn.msgIDs = make(map[string]uint16)
+	conn.notifSubscriptions = make(map[uint16][]*api.NotifSubscription)
+
+	conn.vpp.SetMsgCallback(msgCallback)
+
+	logger.Debug("Connecting to VPP...")
+
+	err := conn.vpp.Connect()
+	if err != nil {
+		return nil, err
+	}
+
+	// store control ping IDs
+	conn.pingReqID, _ = conn.GetMessageID(&vpe.ControlPing{})
+	conn.pingReplyID, _ = conn.GetMessageID(&vpe.ControlPingReply{})
+
+	logger.Debug("VPP connected.")
+
+	return conn, nil
+}
+
+// Disconnect disconnects from VPP.
+func (c *Connection) Disconnect() {
+	connLock.Lock()
+	defer connLock.Unlock()
+
+	if c != nil && c.vpp != nil {
+		c.vpp.Disconnect()
+	}
+	conn = nil
+}
+
+// NewAPIChannel returns a new API channel for communication with VPP via govpp core.
+// It uses default buffer sizes for the request and reply Go channels.
+func (c *Connection) NewAPIChannel() (*api.Channel, error) {
+	return c.NewAPIChannelBuffered(requestChannelBufSize, replyChannelBufSize)
+}
+
+// NewAPIChannelBuffered returns a new API channel for communication with VPP via govpp core.
+// It allows to specify custom buffer sizes for the request and reply Go channels.
+func (c *Connection) NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (*api.Channel, error) {
+	chID := atomic.AddUint32(&c.maxChannelID, 1)
+	chMeta := &channelMetadata{id: chID}
+
+	ch := api.NewChannelInternal(chMeta)
+	ch.MsgDecoder = c.codec
+	ch.MsgIdentifier = c
+
+	// create the communication channels
+	ch.ReqChan = make(chan *api.VppRequest, reqChanBufSize)
+	ch.ReplyChan = make(chan *api.VppReply, replyChanBufSize)
+	ch.NotifSubsChan = make(chan *api.NotifSubscribeRequest, reqChanBufSize)
+	ch.NotifSubsReplyChan = make(chan error, replyChanBufSize)
+
+	// store API channel within the client
+	c.channelsLock.Lock()
+	c.channels[chID] = ch
+	c.channelsLock.Unlock()
+
+	// start watching on the request channel
+	go c.watchRequests(ch, chMeta)
+
+	return ch, nil
+}
+
+// watchRequests watches for requests on the request API channel and forwards them as messages to VPP.
+func (c *Connection) watchRequests(ch *api.Channel, chMeta *channelMetadata) {
+	for {
+		select {
+		case req, ok := <-ch.ReqChan:
+			// new request on the request channel
+			if !ok {
+				// after closing the request channel, release API channel and return
+				c.releaseAPIChannel(ch, chMeta)
+				return
+			}
+			c.processRequest(ch, chMeta, req)
+
+		case req := <-ch.NotifSubsChan:
+			// new request on the notification subscribe channel
+			c.processNotifSubscribeRequest(ch, req)
+		}
+	}
+}
+
+// processRequest processes a single request received on the request channel.
+func (c *Connection) processRequest(ch *api.Channel, chMeta *channelMetadata, req *api.VppRequest) error {
+	// retrieve message ID
+	msgID, err := c.GetMessageID(req.Message)
+	if err != nil {
+		error := fmt.Errorf("unable to retrieve message ID: %v", err)
+		log.WithFields(logger.Fields{
+			"msg_name": req.Message.GetMessageName(),
+			"msg_crc":  req.Message.GetCrcString(),
+		}).Errorf("unable to retrieve message ID: %v", err)
+		sendReply(ch, &api.VppReply{Error: error})
+		return error
+	}
+
+	// encode the message into binary
+	data, err := c.codec.EncodeMsg(req.Message, msgID)
+	if err != nil {
+		error := fmt.Errorf("unable to encode the messge: %v", err)
+		log.WithFields(logger.Fields{
+			"context": chMeta.id,
+			"msg_id":  msgID,
+		}).Errorf("%v", error)
+		sendReply(ch, &api.VppReply{Error: error})
+		return error
+	}
+
+	// send the message
+	log.WithFields(logger.Fields{
+		"context":  chMeta.id,
+		"msg_id":   msgID,
+		"msg_size": len(data),
+	}).Debug("Sending a message to VPP.")
+
+	c.vpp.SendMsg(chMeta.id, data)
+
+	if req.Multipart {
+		// multipart request
+		atomic.StoreUint32(&chMeta.multipart, 1)
+
+		// send a control ping
+		ping := &vpe.ControlPing{}
+		pingData, _ := c.codec.EncodeMsg(ping, c.pingReqID)
+
+		log.WithFields(logger.Fields{
+			"context":  chMeta.id,
+			"msg_id":   c.pingReqID,
+			"msg_size": len(pingData),
+		}).Debug("Sending a control ping to VPP.")
+
+		c.vpp.SendMsg(chMeta.id, pingData)
+	}
+
+	return nil
+}
+
+// releaseAPIChannel releases API channel that needs to be closed.
+func (c *Connection) releaseAPIChannel(ch *api.Channel, chMeta *channelMetadata) {
+	log.WithFields(logger.Fields{
+		"context": chMeta.id,
+	}).Debug("API channel closed.")
+
+	// delete the channel from channels map
+	c.channelsLock.Lock()
+	delete(c.channels, chMeta.id)
+	c.channelsLock.Unlock()
+}
+
+// msgCallback is called whenever any binary API message comes from VPP.
+func msgCallback(context uint32, msgID uint16, data []byte) {
+	connLock.RLock()
+	defer connLock.RUnlock()
+
+	if conn == nil {
+		log.Warn("Already disconnected, ignoring the message.")
+		return
+	}
+
+	log.WithFields(logger.Fields{
+		"context":  context,
+		"msg_id":   msgID,
+		"msg_size": len(data),
+	}).Debug("Received a message from VPP.")
+
+	if context == 0 || conn.isNotificationMessage(msgID) {
+		// process the message as a notification
+		conn.sendNotifications(msgID, data)
+		return
+	}
+
+	// match ch according to the context
+	conn.channelsLock.RLock()
+	ch, ok := conn.channels[context]
+	conn.channelsLock.RUnlock()
+
+	if !ok {
+		log.WithFields(logger.Fields{
+			"context": context,
+			"msg_id":  msgID,
+		}).Error("Context ID not known, ignoring the message.")
+		return
+	}
+
+	chMeta := ch.Metadata().(*channelMetadata)
+	lastReplyReceived := false
+	// if this is a control ping reply and multipart request is being processed, treat this as a last part of the reply
+	if msgID == conn.pingReplyID && atomic.CompareAndSwapUint32(&chMeta.multipart, 1, 0) {
+		lastReplyReceived = true
+	}
+
+	// send the data to the channel
+	sendReply(ch, &api.VppReply{
+		MessageID:         msgID,
+		Data:              data,
+		LastReplyReceived: lastReplyReceived,
+	})
+}
+
+// sendReply sends the reply into the go channel, if it cannot be completed without blocking, otherwise
+// it logs the error and do not send the message.
+func sendReply(ch *api.Channel, reply *api.VppReply) {
+	select {
+	case ch.ReplyChan <- reply:
+		// reply sent successfully
+	default:
+		// unable to write into the channel without blocking
+		log.WithFields(logger.Fields{
+			"channel": ch,
+			"msg_id":  reply.MessageID,
+		}).Warn("Unable to send the reply, reciever end not ready.")
+	}
+}
+
+// GetMessageID returns message identifier of given API message.
+func (c *Connection) GetMessageID(msg api.Message) (uint16, error) {
+	return c.messageNameToID(msg.GetMessageName(), msg.GetCrcString())
+}
+
+// messageNameToID returns message ID of a message identified by its name and CRC.
+func (c *Connection) messageNameToID(msgName string, msgCrc string) (uint16, error) {
+	// try to get the ID from the map
+	c.msgIDsLock.RLock()
+	id, ok := c.msgIDs[msgName+msgCrc]
+	c.msgIDsLock.RUnlock()
+	if ok {
+		return id, nil
+	}
+
+	// get the ID using VPP API
+	id, err := c.vpp.GetMsgID(msgName, msgCrc)
+	if err != nil {
+		error := fmt.Errorf("unable to retrieve message ID: %v", err)
+		log.WithFields(logger.Fields{
+			"msg_name": msgName,
+			"msg_crc":  msgCrc,
+		}).Errorf("unable to retrieve message ID: %v", err)
+		return id, error
+	}
+
+	c.msgIDsLock.Lock()
+	c.msgIDs[msgName+msgCrc] = id
+	c.msgIDsLock.Unlock()
+
+	return id, nil
+}
diff --git a/core/core_test.go b/core/core_test.go
new file mode 100644
index 0000000..c95ef04
--- /dev/null
+++ b/core/core_test.go
@@ -0,0 +1,244 @@
+// Copyright (c) 2017 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 core
+
+import (
+	"testing"
+
+	"gerrit.fd.io/r/govpp/adapter/mock"
+	"gerrit.fd.io/r/govpp/api"
+	"gerrit.fd.io/r/govpp/core/bin_api/vpe"
+	"gerrit.fd.io/r/govpp/examples/bin_api/interfaces"
+
+	. "github.com/onsi/gomega"
+)
+
+type testCtx struct {
+	mockVpp *mock.VppAdapter
+	conn    *Connection
+	ch      *api.Channel
+}
+
+func setupTest(t *testing.T) *testCtx {
+	RegisterTestingT(t)
+
+	ctx := &testCtx{}
+	ctx.mockVpp = &mock.VppAdapter{}
+
+	var err error
+	ctx.conn, err = Connect(ctx.mockVpp)
+	Expect(err).ShouldNot(HaveOccurred())
+
+	ctx.ch, err = ctx.conn.NewAPIChannel()
+	Expect(err).ShouldNot(HaveOccurred())
+
+	return ctx
+}
+
+func (ctx *testCtx) teardownTest() {
+	ctx.ch.Close()
+	ctx.conn.Disconnect()
+}
+
+func TestSimpleRequest(t *testing.T) {
+	ctx := setupTest(t)
+	defer ctx.teardownTest()
+
+	ctx.mockVpp.MockReply(&vpe.ControlPingReply{Retval: -5})
+
+	req := &vpe.ControlPing{}
+	reply := &vpe.ControlPingReply{}
+
+	// send the request and receive a reply
+	ctx.ch.ReqChan <- &api.VppRequest{Message: req}
+	vppReply := <-ctx.ch.ReplyChan
+
+	Expect(vppReply).ShouldNot(BeNil())
+	Expect(vppReply.Error).ShouldNot(HaveOccurred())
+
+	// decode the message
+	err := ctx.ch.MsgDecoder.DecodeMsg(vppReply.Data, reply)
+	Expect(err).ShouldNot(HaveOccurred())
+
+	Expect(reply.Retval).To(BeEquivalentTo(-5))
+}
+
+func TestMultiRequest(t *testing.T) {
+	ctx := setupTest(t)
+	defer ctx.teardownTest()
+
+	for m := 0; m < 10; m++ {
+		ctx.mockVpp.MockReply(&interfaces.SwInterfaceDetails{})
+	}
+	ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
+
+	// send multipart request
+	ctx.ch.ReqChan <- &api.VppRequest{Message: &interfaces.SwInterfaceDump{}, Multipart: true}
+
+	cnt := 0
+	for {
+		// receive a reply
+		vppReply := <-ctx.ch.ReplyChan
+		if vppReply.LastReplyReceived {
+			break // break out of the loop
+		}
+		Expect(vppReply.Error).ShouldNot(HaveOccurred())
+
+		// decode the message
+		reply := &interfaces.SwInterfaceDetails{}
+		err := ctx.ch.MsgDecoder.DecodeMsg(vppReply.Data, reply)
+		Expect(err).ShouldNot(HaveOccurred())
+		cnt++
+	}
+
+	Expect(cnt).To(BeEquivalentTo(10))
+}
+
+func TestNotifications(t *testing.T) {
+	ctx := setupTest(t)
+	defer ctx.teardownTest()
+
+	// subscribe for notification
+	notifChan := make(chan api.Message, 1)
+	subscription := &api.NotifSubscription{
+		NotifChan:  notifChan,
+		MsgFactory: interfaces.NewSwInterfaceSetFlags,
+	}
+	ctx.ch.NotifSubsChan <- &api.NotifSubscribeRequest{
+		Subscription: subscription,
+		Subscribe:    true,
+	}
+	err := <-ctx.ch.NotifSubsReplyChan
+	Expect(err).ShouldNot(HaveOccurred())
+
+	// mock the notification and force its delivery
+	ctx.mockVpp.MockReply(&interfaces.SwInterfaceSetFlags{
+		SwIfIndex:   3,
+		AdminUpDown: 1,
+	})
+	ctx.mockVpp.SendMsg(0, []byte{0})
+
+	// receive the notification
+	notif := (<-notifChan).(*interfaces.SwInterfaceSetFlags)
+
+	Expect(notif.SwIfIndex).To(BeEquivalentTo(3))
+
+	// unsubscribe notification
+	ctx.ch.NotifSubsChan <- &api.NotifSubscribeRequest{
+		Subscription: subscription,
+		Subscribe:    false,
+	}
+	err = <-ctx.ch.NotifSubsReplyChan
+	Expect(err).ShouldNot(HaveOccurred())
+}
+
+func TestDoubleConnection(t *testing.T) {
+	ctx := setupTest(t)
+	defer ctx.teardownTest()
+
+	conn, err := Connect(ctx.mockVpp)
+	Expect(err).Should(HaveOccurred())
+	Expect(err.Error()).To(ContainSubstring("only one connection per process"))
+	Expect(conn).Should(BeNil())
+}
+
+func TestFullBuffer(t *testing.T) {
+	ctx := setupTest(t)
+	defer ctx.teardownTest()
+
+	// close the default API channel
+	ctx.ch.Close()
+
+	// create a new channel with limited buffer sizes
+	var err error
+	ctx.ch, err = ctx.conn.NewAPIChannelBuffered(10, 1)
+	Expect(err).ShouldNot(HaveOccurred())
+
+	// send multiple requests, only one reply should be read
+	for i := 0; i < 20; i++ {
+		ctx.mockVpp.MockReply(&vpe.ControlPingReply{})
+		ctx.ch.ReqChan <- &api.VppRequest{Message: &vpe.ControlPing{}}
+	}
+
+	vppReply := <-ctx.ch.ReplyChan
+	Expect(vppReply).ShouldNot(BeNil())
+
+	received := false
+	select {
+	case vppReply = <-ctx.ch.ReplyChan:
+		received = true // this should not happen
+	default:
+		received = false // no reply to be received
+	}
+	Expect(received).Should(BeFalse(), "A reply has been recieved, should had been ignored.")
+}
+
+func TestCodec(t *testing.T) {
+	RegisterTestingT(t)
+
+	codec := &MsgCodec{}
+
+	// request
+	data, err := codec.EncodeMsg(&vpe.CreateLoopback{MacAddress: []byte{1, 2, 3, 4, 5, 6}}, 11)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(data).ShouldNot(BeEmpty())
+
+	msg1 := &vpe.CreateLoopback{}
+	err = codec.DecodeMsg(data, msg1)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(msg1.MacAddress).To(BeEquivalentTo([]byte{1, 2, 3, 4, 5, 6}))
+
+	// reply
+	data, err = codec.EncodeMsg(&vpe.ControlPingReply{Retval: 55}, 22)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(data).ShouldNot(BeEmpty())
+
+	msg2 := &vpe.ControlPingReply{}
+	err = codec.DecodeMsg(data, msg2)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(msg2.Retval).To(BeEquivalentTo(55))
+
+	// other
+	data, err = codec.EncodeMsg(&vpe.VnetIP4FibCounters{VrfID: 77}, 33)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(data).ShouldNot(BeEmpty())
+
+	msg3 := &vpe.VnetIP4FibCounters{}
+	err = codec.DecodeMsg(data, msg3)
+	Expect(err).ShouldNot(HaveOccurred())
+	Expect(msg3.VrfID).To(BeEquivalentTo(77))
+}
+
+func TestCodecNegative(t *testing.T) {
+	RegisterTestingT(t)
+
+	codec := &MsgCodec{}
+
+	// nil message for encoding
+	data, err := codec.EncodeMsg(nil, 15)
+	Expect(err).Should(HaveOccurred())
+	Expect(err.Error()).To(ContainSubstring("nil message"))
+	Expect(data).Should(BeNil())
+
+	// nil message for decoding
+	err = codec.DecodeMsg(data, nil)
+	Expect(err).Should(HaveOccurred())
+	Expect(err.Error()).To(ContainSubstring("nil message"))
+
+	// nil data for decoding
+	err = codec.DecodeMsg(nil, &vpe.ControlPingReply{})
+	Expect(err).Should(HaveOccurred())
+	Expect(err.Error()).To(ContainSubstring("EOF"))
+}
diff --git a/core/doc.go b/core/doc.go
new file mode 100644
index 0000000..a4ecd50
--- /dev/null
+++ b/core/doc.go
@@ -0,0 +1,20 @@
+// Package core provides connectivity to VPP via the adapter: sends and receives the messages to/from VPP,
+// marshalls/unmarshalls them and forwards them between the client Go channels and the VPP.
+//
+// The interface_plugin APIs the core exposes is tied to a connection: Connect provides a connection, that cane be
+// later used to request an API channel via NewAPIChannel / NewAPIChannelBuffered functions:
+//
+//	conn, err := govpp.Connect()
+//	if err != nil {
+//		// handle error!
+//	}
+//	defer conn.Disconnect()
+//
+//	ch, err := conn.NewAPIChannel()
+//	if err != nil {
+//		// handle error!
+//	}
+//	defer ch.Close()
+//
+// Note that one application can open only one connection, that can serve multiple API channels.
+package core
diff --git a/core/msg_codec.go b/core/msg_codec.go
new file mode 100644
index 0000000..1543f3d
--- /dev/null
+++ b/core/msg_codec.go
@@ -0,0 +1,146 @@
+// Copyright (c) 2017 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 core
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+
+	logger "github.com/Sirupsen/logrus"
+	"github.com/lunixbochs/struc"
+
+	"gerrit.fd.io/r/govpp/api"
+)
+
+// MsgCodec provides encoding and decoding functionality of `api.Message` structs into/from
+// binary format as accepted by VPP.
+type MsgCodec struct{}
+
+// vppRequestHeader struct contains header fields implemented by all VPP requests.
+type vppRequestHeader struct {
+	VlMsgID     uint16
+	ClientIndex uint32
+	Context     uint32
+}
+
+// vppReplyHeader struct contains header fields implemented by all VPP replies.
+type vppReplyHeader struct {
+	VlMsgID uint16
+	Context uint32
+}
+
+// vppOtherHeader struct contains header fields implemented by other VPP messages (not requests nor replies).
+type vppOtherHeader struct {
+	VlMsgID uint16
+}
+
+const (
+	vppRequestHeaderSize = 10 // size of a VPP request header
+	vppReplyHeaderSize   = 6  // size of a VPP reply header
+	vppOtherHeaderSize   = 2  // size of the header of other VPP messages
+)
+
+// EncodeMsg encodes provided `Message` structure into its binary-encoded data representation.
+func (*MsgCodec) EncodeMsg(msg api.Message, msgID uint16) ([]byte, error) {
+	if msg == nil {
+		return nil, errors.New("nil message passed in")
+	}
+
+	buf := new(bytes.Buffer)
+
+	// encode message header
+	var header interface{}
+	if msg.GetMessageType() == api.RequestMessage {
+		header = &vppRequestHeader{VlMsgID: msgID}
+	} else if msg.GetMessageType() == api.ReplyMessage {
+		header = &vppReplyHeader{VlMsgID: msgID}
+	} else {
+		header = &vppOtherHeader{VlMsgID: msgID}
+	}
+	err := struc.Pack(buf, header)
+	if err != nil {
+		log.WithFields(logger.Fields{
+			"error":  err,
+			"header": header,
+		}).Error("Unable to encode the message header: ", err)
+		return nil, fmt.Errorf("unable to encode the message header: %v", err)
+	}
+
+	// encode message content
+	if reflect.Indirect(reflect.ValueOf(msg)).NumField() > 0 {
+		err := struc.Pack(buf, msg)
+		if err != nil {
+			log.WithFields(logger.Fields{
+				"error":   err,
+				"message": msg,
+			}).Error("Unable to encode the message: ", err)
+			return nil, fmt.Errorf("unable to encode the message: %v", err)
+		}
+	}
+
+	return buf.Bytes(), nil
+}
+
+// DecodeMsg decodes binary-encoded data of a message into provided `Message` structure.
+func (*MsgCodec) DecodeMsg(data []byte, msg api.Message) error {
+	if msg == nil {
+		return errors.New("nil message passed in")
+	}
+
+	buf := bytes.NewReader(data)
+
+	// check which header is expected
+	var header interface{}
+	if msg.GetMessageType() == api.RequestMessage {
+		header = &vppRequestHeader{}
+	} else if msg.GetMessageType() == api.ReplyMessage {
+		header = &vppReplyHeader{}
+	} else {
+		header = &vppOtherHeader{}
+	}
+
+	// decode message header
+	err := struc.Unpack(buf, header)
+	if err != nil {
+		log.WithFields(logger.Fields{
+			"error": err,
+			"data":  data,
+		}).Error("Unable to decode header of the message.")
+		return fmt.Errorf("unable to decode the message header: %v", err)
+	}
+
+	// get rid of the message header
+	if msg.GetMessageType() == api.RequestMessage {
+		buf = bytes.NewReader(data[vppRequestHeaderSize:])
+	} else if msg.GetMessageType() == api.ReplyMessage {
+		buf = bytes.NewReader(data[vppReplyHeaderSize:])
+	} else {
+		buf = bytes.NewReader(data[vppOtherHeaderSize:])
+	}
+
+	// decode message content
+	err = struc.Unpack(buf, msg)
+	if err != nil {
+		log.WithFields(logger.Fields{
+			"error": err,
+			"data":  buf,
+		}).Error("Unable to decode the message.")
+		return fmt.Errorf("unable to decode the message: %v", err)
+	}
+
+	return nil
+}
diff --git a/core/notifications.go b/core/notifications.go
new file mode 100644
index 0000000..b44eb1a
--- /dev/null
+++ b/core/notifications.go
@@ -0,0 +1,182 @@
+// Copyright (c) 2017 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 core
+
+import (
+	"fmt"
+	"reflect"
+
+	logger "github.com/Sirupsen/logrus"
+
+	"gerrit.fd.io/r/govpp/api"
+)
+
+// processNotifSubscribeRequest processes a notification subscribe request.
+func (c *Connection) processNotifSubscribeRequest(ch *api.Channel, req *api.NotifSubscribeRequest) error {
+	var err error
+
+	// subscribe / unsubscribe
+	if req.Subscribe {
+		err = c.addNotifSubscription(req.Subscription)
+	} else {
+		err = c.removeNotifSubscription(req.Subscription)
+	}
+
+	// send the reply into the go channel
+	select {
+	case ch.NotifSubsReplyChan <- err:
+		// reply sent successfully
+	default:
+		// unable to write into the channel without blocking
+		log.WithFields(logger.Fields{
+			"channel": ch,
+		}).Warn("Unable to deliver the subscribe reply, reciever end not ready.")
+	}
+
+	return err
+}
+
+// addNotifSubscription adds the notification subscription into the subscriptions map of the connection.
+func (c *Connection) addNotifSubscription(subs *api.NotifSubscription) error {
+	// get message ID of the notification message
+	msgID, err := c.getSubscriptionMessageID(subs)
+	if err != nil {
+		return err
+	}
+
+	log.WithFields(logger.Fields{
+		"msg_id":       msgID,
+		"subscription": subs,
+	}).Debug("Adding new notification subscription.")
+
+	// add the subscription into map
+	c.notifSubscriptionsLock.Lock()
+	defer c.notifSubscriptionsLock.Unlock()
+
+	c.notifSubscriptions[msgID] = append(c.notifSubscriptions[msgID], subs)
+
+	return nil
+}
+
+// removeNotifSubscription removes the notification subscription from the subscriptions map of the connection.
+func (c *Connection) removeNotifSubscription(subs *api.NotifSubscription) error {
+	// get message ID of the notification message
+	msgID, err := c.getSubscriptionMessageID(subs)
+	if err != nil {
+		return err
+	}
+
+	log.WithFields(logger.Fields{
+		"msg_id":       msgID,
+		"subscription": subs,
+	}).Debug("Removing notification subscription.")
+
+	// remove the subscription from the map
+	c.notifSubscriptionsLock.Lock()
+	defer c.notifSubscriptionsLock.Unlock()
+
+	for i, item := range c.notifSubscriptions[msgID] {
+		if item == subs {
+			// remove i-th item in the slice
+			c.notifSubscriptions[msgID] = append(c.notifSubscriptions[msgID][:i], c.notifSubscriptions[msgID][i+1:]...)
+			break
+		}
+	}
+
+	return nil
+}
+
+// isNotificationMessage returns true if someone has subscribed to provided message ID.
+func (c *Connection) isNotificationMessage(msgID uint16) bool {
+	c.notifSubscriptionsLock.RLock()
+	defer c.notifSubscriptionsLock.RUnlock()
+
+	_, exists := c.notifSubscriptions[msgID]
+	return exists
+}
+
+// sendNotifications send a notification message to all subscribers subscribed for that message.
+func (c *Connection) sendNotifications(msgID uint16, data []byte) {
+	c.notifSubscriptionsLock.RLock()
+	defer c.notifSubscriptionsLock.RUnlock()
+
+	matched := false
+
+	// send to notification to each subscriber
+	for _, subs := range c.notifSubscriptions[msgID] {
+		log.WithFields(logger.Fields{
+			"msg_id":       msgID,
+			"msg_size":     len(data),
+			"subscription": subs,
+		}).Debug("Sending a notification to the subscription channel.")
+
+		msg := subs.MsgFactory()
+		err := c.codec.DecodeMsg(data, msg)
+		if err != nil {
+			log.WithFields(logger.Fields{
+				"msg_id":       msgID,
+				"msg_size":     len(data),
+				"subscription": subs,
+			}).Error("Unable to decode the notification message.")
+			continue
+		}
+
+		// special case for the strange interface counters message
+		if msg.GetMessageName() == "vnet_interface_counters" {
+			v := reflect.ValueOf(msg).Elem().FieldByName("Data")
+			if v.IsValid() {
+				v.SetBytes(data[8:]) // include the Count and Data fields in the data
+			}
+		}
+
+		// send the message into the go channel of the subscription
+		select {
+		case subs.NotifChan <- msg:
+			// message sent successfully
+		default:
+			// unable to write into the channel without blocking
+			log.WithFields(logger.Fields{
+				"msg_id":       msgID,
+				"msg_size":     len(data),
+				"subscription": subs,
+			}).Warn("Unable to deliver the notification, reciever end not ready.")
+		}
+
+		matched = true
+	}
+
+	if !matched {
+		log.WithFields(logger.Fields{
+			"msg_id":   msgID,
+			"msg_size": len(data),
+		}).Debug("No subscription found for the notification message.")
+	}
+}
+
+// getSubscriptionMessageID returns ID of the message the subscription is tied to.
+func (c *Connection) getSubscriptionMessageID(subs *api.NotifSubscription) (uint16, error) {
+	msg := subs.MsgFactory()
+	msgID, err := c.GetMessageID(msg)
+
+	if err != nil {
+		log.WithFields(logger.Fields{
+			"msg_name": msg.GetMessageName(),
+			"msg_crc":  msg.GetCrcString(),
+		}).Errorf("unable to retrieve message ID: %v", err)
+		return 0, fmt.Errorf("unable to retrieve message ID: %v", err)
+	}
+
+	return msgID, nil
+}