Add various generator improvements
[govpp.git] / examples / binapi / ip / ip.ba.go
similarity index 68%
rename from examples/bin_api/ip/ip.ba.go
rename to examples/binapi/ip/ip.ba.go
index b566608..71a6476 100644 (file)
@@ -1,75 +1,46 @@
 // Code generated by GoVPP binapi-generator. DO NOT EDIT.
-//  source: ip.api.json
+// source: /usr/share/vpp/api/core/ip.api.json
 
 /*
- Package ip is a generated from VPP binary API module 'ip'.
+Package ip is a generated from VPP binary API module 'ip'.
 
- It contains following objects:
-        44 services
-         1 enum
+ The ip module consists of:
+         2 enums
          3 aliases
-        11 types
+        12 types
          1 union
         91 messages
+        44 services
 */
 package ip
 
 import api "git.fd.io/govpp.git/api"
-import struc "github.com/lunixbochs/struc"
 import bytes "bytes"
+import context "context"
+import strconv "strconv"
+import struc "github.com/lunixbochs/struc"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = api.RegisterMessage
-var _ = struc.Pack
 var _ = bytes.NewBuffer
+var _ = context.Background
+var _ = strconv.Itoa
+var _ = struc.Pack
 
-// Services represents VPP binary API services:
-type Services interface {
-       DumpIP6Fib(*IP6FibDump) ([]*IP6FibDetails, error)
-       DumpIP6Mfib(*IP6MfibDump) ([]*IP6MfibDetails, error)
-       DumpIP6ndProxy(*IP6ndProxyDump) ([]*IP6ndProxyDetails, error)
-       DumpIPAddress(*IPAddressDump) ([]*IPAddressDetails, error)
-       DumpIPContainerProxy(*IPContainerProxyDump) ([]*IPContainerProxyDetails, error)
-       DumpIP(*IPDump) ([]*IPDetails, error)
-       DumpIPFib(*IPFibDump) ([]*IPFibDetails, error)
-       DumpIPMfib(*IPMfibDump) ([]*IPMfibDetails, error)
-       DumpIPNeighbor(*IPNeighborDump) ([]*IPNeighborDetails, error)
-       DumpIPPuntRedirect(*IPPuntRedirectDump) ([]*IPPuntRedirectDetails, error)
-       DumpIPUnnumbered(*IPUnnumberedDump) ([]*IPUnnumberedDetails, error)
-       DumpMfibSignal(*MfibSignalDump) ([]*MfibSignalDetails, error)
-       DumpProxyArp(*ProxyArpDump) ([]*ProxyArpDetails, error)
-       DumpProxyArpIntfc(*ProxyArpIntfcDump) ([]*ProxyArpIntfcDetails, error)
-       IoamDisable(*IoamDisable) (*IoamDisableReply, error)
-       IoamEnable(*IoamEnable) (*IoamEnableReply, error)
-       IP6ndProxyAddDel(*IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error)
-       IP6ndSendRouterSolicitation(*IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error)
-       IPAddDelRoute(*IPAddDelRoute) (*IPAddDelRouteReply, error)
-       IPContainerProxyAddDel(*IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
-       IPMrouteAddDel(*IPMrouteAddDel) (*IPMrouteAddDelReply, error)
-       IPNeighborAddDel(*IPNeighborAddDel) (*IPNeighborAddDelReply, error)
-       IPProbeNeighbor(*IPProbeNeighbor) (*IPProbeNeighborReply, error)
-       IPPuntPolice(*IPPuntPolice) (*IPPuntPoliceReply, error)
-       IPPuntRedirect(*IPPuntRedirect) (*IPPuntRedirectReply, error)
-       IPReassemblyEnableDisable(*IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
-       IPReassemblyGet(*IPReassemblyGet) (*IPReassemblyGetReply, error)
-       IPReassemblySet(*IPReassemblySet) (*IPReassemblySetReply, error)
-       IPScanNeighborEnableDisable(*IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error)
-       IPSourceAndPortRangeCheckAddDel(*IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
-       IPSourceAndPortRangeCheckInterfaceAddDel(*IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
-       IPSourceCheckInterfaceAddDel(*IPSourceCheckInterfaceAddDel) (*IPSourceCheckInterfaceAddDelReply, error)
-       IPTableAddDel(*IPTableAddDel) (*IPTableAddDelReply, error)
-       ProxyArpAddDel(*ProxyArpAddDel) (*ProxyArpAddDelReply, error)
-       ProxyArpIntfcEnableDisable(*ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error)
-       ResetFib(*ResetFib) (*ResetFibReply, error)
-       SetArpNeighborLimit(*SetArpNeighborLimit) (*SetArpNeighborLimitReply, error)
-       SetIPFlowHash(*SetIPFlowHash) (*SetIPFlowHashReply, error)
-       SwInterfaceIP6EnableDisable(*SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
-       SwInterfaceIP6ndRaConfig(*SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error)
-       SwInterfaceIP6ndRaPrefix(*SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error)
-       WantIP4ArpEvents(*WantIP4ArpEvents) (*WantIP4ArpEventsReply, error)
-       WantIP6NdEvents(*WantIP6NdEvents) (*WantIP6NdEventsReply, error)
-       WantIP6RaEvents(*WantIP6RaEvents) (*WantIP6RaEventsReply, error)
-}
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the GoVPP api package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// GoVPP api package needs to be updated.
+const _ = api.GoVppAPIPackageIsVersion1 // please upgrade the GoVPP api package
+
+const (
+       // ModuleName is the name of this module.
+       ModuleName = "ip"
+       // APIVersion is the API version of this module.
+       APIVersion = "2.0.0"
+       // VersionCrc is the CRC of this module.
+       VersionCrc = 0x51ac4ce0
+)
 
 /* Enums */
 
@@ -81,6 +52,53 @@ const (
        ADDRESS_IP6 AddressFamily = 1
 )
 
+var AddressFamily_name = map[uint32]string{
+       0: "ADDRESS_IP4",
+       1: "ADDRESS_IP6",
+}
+
+var AddressFamily_value = map[string]uint32{
+       "ADDRESS_IP4": 0,
+       "ADDRESS_IP6": 1,
+}
+
+func (x AddressFamily) String() string {
+       s, ok := AddressFamily_name[uint32(x)]
+       if ok {
+               return s
+       }
+       return strconv.Itoa(int(x))
+}
+
+// IPNeighborFlags represents VPP binary API enum 'ip_neighbor_flags':
+type IPNeighborFlags uint32
+
+const (
+       IP_API_NEIGHBOR_FLAG_NONE         IPNeighborFlags = 0
+       IP_API_NEIGHBOR_FLAG_STATIC       IPNeighborFlags = 1
+       IP_API_NEIGHBOR_FLAG_NO_FIB_ENTRY IPNeighborFlags = 2
+)
+
+var IPNeighborFlags_name = map[uint32]string{
+       0: "IP_API_NEIGHBOR_FLAG_NONE",
+       1: "IP_API_NEIGHBOR_FLAG_STATIC",
+       2: "IP_API_NEIGHBOR_FLAG_NO_FIB_ENTRY",
+}
+
+var IPNeighborFlags_value = map[string]uint32{
+       "IP_API_NEIGHBOR_FLAG_NONE":         0,
+       "IP_API_NEIGHBOR_FLAG_STATIC":       1,
+       "IP_API_NEIGHBOR_FLAG_NO_FIB_ENTRY": 2,
+}
+
+func (x IPNeighborFlags) String() string {
+       s, ok := IPNeighborFlags_name[uint32(x)]
+       if ok {
+               return s
+       }
+       return strconv.Itoa(int(x))
+}
+
 /* Aliases */
 
 // IP4Address represents VPP binary API alias 'ip4_address':
@@ -182,18 +200,32 @@ func (*IP6Prefix) GetCrcString() string {
 
 // IP6RaPrefixInfo represents VPP binary API type 'ip6_ra_prefix_info':
 type IP6RaPrefixInfo struct {
-       DstAddress       []byte `struc:"[16]byte"`
-       DstAddressLength uint8
-       Flags            uint8
-       ValidTime        uint32
-       PreferredTime    uint32
+       Prefix        Prefix
+       Flags         uint8
+       ValidTime     uint32
+       PreferredTime uint32
 }
 
 func (*IP6RaPrefixInfo) GetTypeName() string {
        return "ip6_ra_prefix_info"
 }
 func (*IP6RaPrefixInfo) GetCrcString() string {
-       return "83d7c6e5"
+       return "fa025b72"
+}
+
+// IPNeighbor represents VPP binary API type 'ip_neighbor':
+type IPNeighbor struct {
+       SwIfIndex  uint32
+       Flags      IPNeighborFlags
+       MacAddress MacAddress
+       IPAddress  Address
+}
+
+func (*IPNeighbor) GetTypeName() string {
+       return "ip_neighbor"
+}
+func (*IPNeighbor) GetCrcString() string {
+       return "4bf82d5d"
 }
 
 // MfibPath represents VPP binary API type 'mfib_path':
@@ -239,16 +271,16 @@ func (*Prefix) GetCrcString() string {
 
 // ProxyArp represents VPP binary API type 'proxy_arp':
 type ProxyArp struct {
-       VrfID      uint32
-       LowAddress []byte `struc:"[4]byte"`
-       HiAddress  []byte `struc:"[4]byte"`
+       TableID uint32
+       Low     IP4Address
+       Hi      IP4Address
 }
 
 func (*ProxyArp) GetTypeName() string {
        return "proxy_arp"
 }
 func (*ProxyArp) GetCrcString() string {
-       return "6d88106e"
+       return "e9067693"
 }
 
 // PuntRedirect represents VPP binary API type 'punt_redirect':
@@ -269,7 +301,7 @@ func (*PuntRedirect) GetCrcString() string {
 
 // AddressUnion represents VPP binary API union 'address_union':
 type AddressUnion struct {
-       Union_data [16]byte
+       XXX_UnionData [16]byte
 }
 
 func (*AddressUnion) GetTypeName() string {
@@ -288,10 +320,10 @@ func (u *AddressUnion) SetIP4(a IP4Address) {
        if err := struc.Pack(b, &a); err != nil {
                return
        }
-       copy(u.Union_data[:], b.Bytes())
+       copy(u.XXX_UnionData[:], b.Bytes())
 }
 func (u *AddressUnion) GetIP4() (a IP4Address) {
-       var b = bytes.NewReader(u.Union_data[:])
+       var b = bytes.NewReader(u.XXX_UnionData[:])
        struc.Unpack(b, &a)
        return
 }
@@ -305,10 +337,10 @@ func (u *AddressUnion) SetIP6(a IP6Address) {
        if err := struc.Pack(b, &a); err != nil {
                return
        }
-       copy(u.Union_data[:], b.Bytes())
+       copy(u.XXX_UnionData[:], b.Bytes())
 }
 func (u *AddressUnion) GetIP6() (a IP6Address) {
-       var b = bytes.NewReader(u.Union_data[:])
+       var b = bytes.NewReader(u.XXX_UnionData[:])
        struc.Unpack(b, &a)
        return
 }
@@ -382,10 +414,10 @@ func (*IoamEnableReply) GetMessageType() api.MessageType {
 
 // IP4ArpEvent represents VPP binary API message 'ip4_arp_event':
 type IP4ArpEvent struct {
-       Address   uint32
+       IP        IP4Address
        PID       uint32
        SwIfIndex uint32
-       NewMac    []byte `struc:"[6]byte"`
+       Mac       MacAddress
        MacIP     uint8
 }
 
@@ -393,7 +425,7 @@ func (*IP4ArpEvent) GetMessageName() string {
        return "ip4_arp_event"
 }
 func (*IP4ArpEvent) GetCrcString() string {
-       return "ef7235f7"
+       return "72cdde7c"
 }
 func (*IP4ArpEvent) GetMessageType() api.MessageType {
        return api.EventMessage
@@ -470,8 +502,8 @@ func (*IP6MfibDump) GetMessageType() api.MessageType {
 type IP6NdEvent struct {
        PID       uint32
        SwIfIndex uint32
-       Address   []byte `struc:"[16]byte"`
-       NewMac    []byte `struc:"[6]byte"`
+       IP        IP6Address
+       Mac       MacAddress
        MacIP     uint8
 }
 
@@ -479,7 +511,7 @@ func (*IP6NdEvent) GetMessageName() string {
        return "ip6_nd_event"
 }
 func (*IP6NdEvent) GetCrcString() string {
-       return "96ab2fdd"
+       return "3a23e7d4"
 }
 func (*IP6NdEvent) GetMessageType() api.MessageType {
        return api.EventMessage
@@ -489,7 +521,7 @@ func (*IP6NdEvent) GetMessageType() api.MessageType {
 type IP6RaEvent struct {
        PID                                                 uint32
        SwIfIndex                                           uint32
-       RouterAddress                                       []byte `struc:"[16]byte"`
+       RouterAddr                                          IP6Address
        CurrentHopLimit                                     uint8
        Flags                                               uint8
        RouterLifetimeInSec                                 uint16
@@ -503,7 +535,7 @@ func (*IP6RaEvent) GetMessageName() string {
        return "ip6_ra_event"
 }
 func (*IP6RaEvent) GetCrcString() string {
-       return "c5e54257"
+       return "2e718fcc"
 }
 func (*IP6RaEvent) GetMessageType() api.MessageType {
        return api.EventMessage
@@ -513,14 +545,14 @@ func (*IP6RaEvent) GetMessageType() api.MessageType {
 type IP6ndProxyAddDel struct {
        SwIfIndex uint32
        IsDel     uint8
-       Address   []byte `struc:"[16]byte"`
+       IP        IP6Address
 }
 
 func (*IP6ndProxyAddDel) GetMessageName() string {
        return "ip6nd_proxy_add_del"
 }
 func (*IP6ndProxyAddDel) GetCrcString() string {
-       return "d95f0fa0"
+       return "bff10d55"
 }
 func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -544,14 +576,14 @@ func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
 // IP6ndProxyDetails represents VPP binary API message 'ip6nd_proxy_details':
 type IP6ndProxyDetails struct {
        SwIfIndex uint32
-       Address   []byte `struc:"[16]byte"`
+       IP        IP6Address
 }
 
 func (*IP6ndProxyDetails) GetMessageName() string {
        return "ip6nd_proxy_details"
 }
 func (*IP6ndProxyDetails) GetCrcString() string {
-       return "6a47c974"
+       return "bbbd7894"
 }
 func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
        return api.ReplyMessage
@@ -698,9 +730,7 @@ func (*IPAddressDump) GetMessageType() api.MessageType {
 
 // IPContainerProxyAddDel represents VPP binary API message 'ip_container_proxy_add_del':
 type IPContainerProxyAddDel struct {
-       IP        []byte `struc:"[16]byte"`
-       IsIP4     uint8
-       Plen      uint8
+       Pfx       Prefix
        SwIfIndex uint32
        IsAdd     uint8
 }
@@ -709,7 +739,7 @@ func (*IPContainerProxyAddDel) GetMessageName() string {
        return "ip_container_proxy_add_del"
 }
 func (*IPContainerProxyAddDel) GetCrcString() string {
-       return "0a355d39"
+       return "5938e73a"
 }
 func (*IPContainerProxyAddDel) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -906,20 +936,15 @@ func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
 
 // IPNeighborAddDel represents VPP binary API message 'ip_neighbor_add_del':
 type IPNeighborAddDel struct {
-       SwIfIndex  uint32
-       IsAdd      uint8
-       IsIPv6     uint8
-       IsStatic   uint8
-       IsNoAdjFib uint8
-       MacAddress []byte `struc:"[6]byte"`
-       DstAddress []byte `struc:"[16]byte"`
+       IsAdd    uint8
+       Neighbor IPNeighbor
 }
 
 func (*IPNeighborAddDel) GetMessageName() string {
        return "ip_neighbor_add_del"
 }
 func (*IPNeighborAddDel) GetCrcString() string {
-       return "4711eb25"
+       return "adea3ef4"
 }
 func (*IPNeighborAddDel) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -943,19 +968,14 @@ func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
 
 // IPNeighborDetails represents VPP binary API message 'ip_neighbor_details':
 type IPNeighborDetails struct {
-       SwIfIndex  uint32
-       StatsIndex uint32
-       IsStatic   uint8
-       IsIPv6     uint8
-       MacAddress []byte `struc:"[6]byte"`
-       IPAddress  []byte `struc:"[16]byte"`
+       Neighbor IPNeighbor
 }
 
 func (*IPNeighborDetails) GetMessageName() string {
        return "ip_neighbor_details"
 }
 func (*IPNeighborDetails) GetCrcString() string {
-       return "c7001770"
+       return "512fb08d"
 }
 func (*IPNeighborDetails) GetMessageType() api.MessageType {
        return api.ReplyMessage
@@ -979,16 +999,15 @@ func (*IPNeighborDump) GetMessageType() api.MessageType {
 
 // IPProbeNeighbor represents VPP binary API message 'ip_probe_neighbor':
 type IPProbeNeighbor struct {
-       SwIfIndex  uint32
-       DstAddress []byte `struc:"[16]byte"`
-       IsIPv6     uint8
+       SwIfIndex uint32
+       Dst       Address
 }
 
 func (*IPProbeNeighbor) GetMessageName() string {
        return "ip_probe_neighbor"
 }
 func (*IPProbeNeighbor) GetCrcString() string {
-       return "1e44bfd7"
+       return "1e6c0a77"
 }
 func (*IPProbeNeighbor) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -1239,10 +1258,8 @@ func (*IPScanNeighborEnableDisableReply) GetMessageType() api.MessageType {
 
 // IPSourceAndPortRangeCheckAddDel represents VPP binary API message 'ip_source_and_port_range_check_add_del':
 type IPSourceAndPortRangeCheckAddDel struct {
-       IsIPv6         uint8
        IsAdd          uint8
-       MaskLength     uint8
-       Address        []byte `struc:"[16]byte"`
+       Prefix         Prefix
        NumberOfRanges uint8
        LowPorts       []uint16 `struc:"[32]uint16"`
        HighPorts      []uint16 `struc:"[32]uint16"`
@@ -1253,7 +1270,7 @@ func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
        return "ip_source_and_port_range_check_add_del"
 }
 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string {
-       return "03d6b03a"
+       return "ea07c429"
 }
 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -1733,24 +1750,23 @@ func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
 
 // SwInterfaceIP6ndRaPrefix represents VPP binary API message 'sw_interface_ip6nd_ra_prefix':
 type SwInterfaceIP6ndRaPrefix struct {
-       SwIfIndex     uint32
-       Address       []byte `struc:"[16]byte"`
-       AddressLength uint8
-       UseDefault    uint8
-       NoAdvertise   uint8
-       OffLink       uint8
-       NoAutoconfig  uint8
-       NoOnlink      uint8
-       IsNo          uint8
-       ValLifetime   uint32
-       PrefLifetime  uint32
+       SwIfIndex    uint32
+       Prefix       Prefix
+       UseDefault   uint8
+       NoAdvertise  uint8
+       OffLink      uint8
+       NoAutoconfig uint8
+       NoOnlink     uint8
+       IsNo         uint8
+       ValLifetime  uint32
+       PrefLifetime uint32
 }
 
 func (*SwInterfaceIP6ndRaPrefix) GetMessageName() string {
        return "sw_interface_ip6nd_ra_prefix"
 }
 func (*SwInterfaceIP6ndRaPrefix) GetCrcString() string {
-       return "ca763c9a"
+       return "59934d3b"
 }
 func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -1775,14 +1791,14 @@ func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
 type WantIP4ArpEvents struct {
        EnableDisable uint8
        PID           uint32
-       Address       uint32
+       IP            IP4Address
 }
 
 func (*WantIP4ArpEvents) GetMessageName() string {
        return "want_ip4_arp_events"
 }
 func (*WantIP4ArpEvents) GetCrcString() string {
-       return "77e06379"
+       return "70fd7195"
 }
 func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -1807,14 +1823,14 @@ func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
 type WantIP6NdEvents struct {
        EnableDisable uint8
        PID           uint32
-       Address       []byte `struc:"[16]byte"`
+       IP            IP6Address
 }
 
 func (*WantIP6NdEvents) GetMessageName() string {
        return "want_ip6_nd_events"
 }
 func (*WantIP6NdEvents) GetCrcString() string {
-       return "1cf65fbb"
+       return "ba330719"
 }
 func (*WantIP6NdEvents) GetMessageType() api.MessageType {
        return api.RequestMessage
@@ -1960,96 +1976,663 @@ func init() {
        api.RegisterMessage((*WantIP6RaEventsReply)(nil), "ip.WantIP6RaEventsReply")
 }
 
-var Messages = []api.Message{
-       (*IoamDisable)(nil),
-       (*IoamDisableReply)(nil),
-       (*IoamEnable)(nil),
-       (*IoamEnableReply)(nil),
-       (*IP4ArpEvent)(nil),
-       (*IP6FibDetails)(nil),
-       (*IP6FibDump)(nil),
-       (*IP6MfibDetails)(nil),
-       (*IP6MfibDump)(nil),
-       (*IP6NdEvent)(nil),
-       (*IP6RaEvent)(nil),
-       (*IP6ndProxyAddDel)(nil),
-       (*IP6ndProxyAddDelReply)(nil),
-       (*IP6ndProxyDetails)(nil),
-       (*IP6ndProxyDump)(nil),
-       (*IP6ndSendRouterSolicitation)(nil),
-       (*IP6ndSendRouterSolicitationReply)(nil),
-       (*IPAddDelRoute)(nil),
-       (*IPAddDelRouteReply)(nil),
-       (*IPAddressDetails)(nil),
-       (*IPAddressDump)(nil),
-       (*IPContainerProxyAddDel)(nil),
-       (*IPContainerProxyAddDelReply)(nil),
-       (*IPContainerProxyDetails)(nil),
-       (*IPContainerProxyDump)(nil),
-       (*IPDetails)(nil),
-       (*IPDump)(nil),
-       (*IPFibDetails)(nil),
-       (*IPFibDump)(nil),
-       (*IPMfibDetails)(nil),
-       (*IPMfibDump)(nil),
-       (*IPMrouteAddDel)(nil),
-       (*IPMrouteAddDelReply)(nil),
-       (*IPNeighborAddDel)(nil),
-       (*IPNeighborAddDelReply)(nil),
-       (*IPNeighborDetails)(nil),
-       (*IPNeighborDump)(nil),
-       (*IPProbeNeighbor)(nil),
-       (*IPProbeNeighborReply)(nil),
-       (*IPPuntPolice)(nil),
-       (*IPPuntPoliceReply)(nil),
-       (*IPPuntRedirect)(nil),
-       (*IPPuntRedirectDetails)(nil),
-       (*IPPuntRedirectDump)(nil),
-       (*IPPuntRedirectReply)(nil),
-       (*IPReassemblyEnableDisable)(nil),
-       (*IPReassemblyEnableDisableReply)(nil),
-       (*IPReassemblyGet)(nil),
-       (*IPReassemblyGetReply)(nil),
-       (*IPReassemblySet)(nil),
-       (*IPReassemblySetReply)(nil),
-       (*IPScanNeighborEnableDisable)(nil),
-       (*IPScanNeighborEnableDisableReply)(nil),
-       (*IPSourceAndPortRangeCheckAddDel)(nil),
-       (*IPSourceAndPortRangeCheckAddDelReply)(nil),
-       (*IPSourceAndPortRangeCheckInterfaceAddDel)(nil),
-       (*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil),
-       (*IPSourceCheckInterfaceAddDel)(nil),
-       (*IPSourceCheckInterfaceAddDelReply)(nil),
-       (*IPTableAddDel)(nil),
-       (*IPTableAddDelReply)(nil),
-       (*IPUnnumberedDetails)(nil),
-       (*IPUnnumberedDump)(nil),
-       (*MfibSignalDetails)(nil),
-       (*MfibSignalDump)(nil),
-       (*ProxyArpAddDel)(nil),
-       (*ProxyArpAddDelReply)(nil),
-       (*ProxyArpDetails)(nil),
-       (*ProxyArpDump)(nil),
-       (*ProxyArpIntfcDetails)(nil),
-       (*ProxyArpIntfcDump)(nil),
-       (*ProxyArpIntfcEnableDisable)(nil),
-       (*ProxyArpIntfcEnableDisableReply)(nil),
-       (*ResetFib)(nil),
-       (*ResetFibReply)(nil),
-       (*SetArpNeighborLimit)(nil),
-       (*SetArpNeighborLimitReply)(nil),
-       (*SetIPFlowHash)(nil),
-       (*SetIPFlowHashReply)(nil),
-       (*SwInterfaceIP6EnableDisable)(nil),
-       (*SwInterfaceIP6EnableDisableReply)(nil),
-       (*SwInterfaceIP6ndRaConfig)(nil),
-       (*SwInterfaceIP6ndRaConfigReply)(nil),
-       (*SwInterfaceIP6ndRaPrefix)(nil),
-       (*SwInterfaceIP6ndRaPrefixReply)(nil),
-       (*WantIP4ArpEvents)(nil),
-       (*WantIP4ArpEventsReply)(nil),
-       (*WantIP6NdEvents)(nil),
-       (*WantIP6NdEventsReply)(nil),
-       (*WantIP6RaEvents)(nil),
-       (*WantIP6RaEventsReply)(nil),
+// Messages returns list of all messages in this module.
+func AllMessages() []api.Message {
+       return []api.Message{
+               (*IoamDisable)(nil),
+               (*IoamDisableReply)(nil),
+               (*IoamEnable)(nil),
+               (*IoamEnableReply)(nil),
+               (*IP4ArpEvent)(nil),
+               (*IP6FibDetails)(nil),
+               (*IP6FibDump)(nil),
+               (*IP6MfibDetails)(nil),
+               (*IP6MfibDump)(nil),
+               (*IP6NdEvent)(nil),
+               (*IP6RaEvent)(nil),
+               (*IP6ndProxyAddDel)(nil),
+               (*IP6ndProxyAddDelReply)(nil),
+               (*IP6ndProxyDetails)(nil),
+               (*IP6ndProxyDump)(nil),
+               (*IP6ndSendRouterSolicitation)(nil),
+               (*IP6ndSendRouterSolicitationReply)(nil),
+               (*IPAddDelRoute)(nil),
+               (*IPAddDelRouteReply)(nil),
+               (*IPAddressDetails)(nil),
+               (*IPAddressDump)(nil),
+               (*IPContainerProxyAddDel)(nil),
+               (*IPContainerProxyAddDelReply)(nil),
+               (*IPContainerProxyDetails)(nil),
+               (*IPContainerProxyDump)(nil),
+               (*IPDetails)(nil),
+               (*IPDump)(nil),
+               (*IPFibDetails)(nil),
+               (*IPFibDump)(nil),
+               (*IPMfibDetails)(nil),
+               (*IPMfibDump)(nil),
+               (*IPMrouteAddDel)(nil),
+               (*IPMrouteAddDelReply)(nil),
+               (*IPNeighborAddDel)(nil),
+               (*IPNeighborAddDelReply)(nil),
+               (*IPNeighborDetails)(nil),
+               (*IPNeighborDump)(nil),
+               (*IPProbeNeighbor)(nil),
+               (*IPProbeNeighborReply)(nil),
+               (*IPPuntPolice)(nil),
+               (*IPPuntPoliceReply)(nil),
+               (*IPPuntRedirect)(nil),
+               (*IPPuntRedirectDetails)(nil),
+               (*IPPuntRedirectDump)(nil),
+               (*IPPuntRedirectReply)(nil),
+               (*IPReassemblyEnableDisable)(nil),
+               (*IPReassemblyEnableDisableReply)(nil),
+               (*IPReassemblyGet)(nil),
+               (*IPReassemblyGetReply)(nil),
+               (*IPReassemblySet)(nil),
+               (*IPReassemblySetReply)(nil),
+               (*IPScanNeighborEnableDisable)(nil),
+               (*IPScanNeighborEnableDisableReply)(nil),
+               (*IPSourceAndPortRangeCheckAddDel)(nil),
+               (*IPSourceAndPortRangeCheckAddDelReply)(nil),
+               (*IPSourceAndPortRangeCheckInterfaceAddDel)(nil),
+               (*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil),
+               (*IPSourceCheckInterfaceAddDel)(nil),
+               (*IPSourceCheckInterfaceAddDelReply)(nil),
+               (*IPTableAddDel)(nil),
+               (*IPTableAddDelReply)(nil),
+               (*IPUnnumberedDetails)(nil),
+               (*IPUnnumberedDump)(nil),
+               (*MfibSignalDetails)(nil),
+               (*MfibSignalDump)(nil),
+               (*ProxyArpAddDel)(nil),
+               (*ProxyArpAddDelReply)(nil),
+               (*ProxyArpDetails)(nil),
+               (*ProxyArpDump)(nil),
+               (*ProxyArpIntfcDetails)(nil),
+               (*ProxyArpIntfcDump)(nil),
+               (*ProxyArpIntfcEnableDisable)(nil),
+               (*ProxyArpIntfcEnableDisableReply)(nil),
+               (*ResetFib)(nil),
+               (*ResetFibReply)(nil),
+               (*SetArpNeighborLimit)(nil),
+               (*SetArpNeighborLimitReply)(nil),
+               (*SetIPFlowHash)(nil),
+               (*SetIPFlowHashReply)(nil),
+               (*SwInterfaceIP6EnableDisable)(nil),
+               (*SwInterfaceIP6EnableDisableReply)(nil),
+               (*SwInterfaceIP6ndRaConfig)(nil),
+               (*SwInterfaceIP6ndRaConfigReply)(nil),
+               (*SwInterfaceIP6ndRaPrefix)(nil),
+               (*SwInterfaceIP6ndRaPrefixReply)(nil),
+               (*WantIP4ArpEvents)(nil),
+               (*WantIP4ArpEventsReply)(nil),
+               (*WantIP6NdEvents)(nil),
+               (*WantIP6NdEventsReply)(nil),
+               (*WantIP6RaEvents)(nil),
+               (*WantIP6RaEventsReply)(nil),
+       }
+}
+
+// Service represents services in VPP binary API.
+type Service interface {
+       DumpIP6Fib(ctx context.Context, in *IP6FibDump) ([]*IP6FibDetails, error)
+       DumpIP6Mfib(ctx context.Context, in *IP6MfibDump) ([]*IP6MfibDetails, error)
+       DumpIP6ndProxy(ctx context.Context, in *IP6ndProxyDump) ([]*IP6ndProxyDetails, error)
+       DumpIPAddress(ctx context.Context, in *IPAddressDump) ([]*IPAddressDetails, error)
+       DumpIPContainerProxy(ctx context.Context, in *IPContainerProxyDump) ([]*IPContainerProxyDetails, error)
+       DumpIP(ctx context.Context, in *IPDump) ([]*IPDetails, error)
+       DumpIPFib(ctx context.Context, in *IPFibDump) ([]*IPFibDetails, error)
+       DumpIPMfib(ctx context.Context, in *IPMfibDump) ([]*IPMfibDetails, error)
+       DumpIPNeighbor(ctx context.Context, in *IPNeighborDump) ([]*IPNeighborDetails, error)
+       DumpIPPuntRedirect(ctx context.Context, in *IPPuntRedirectDump) ([]*IPPuntRedirectDetails, error)
+       DumpIPUnnumbered(ctx context.Context, in *IPUnnumberedDump) ([]*IPUnnumberedDetails, error)
+       DumpMfibSignal(ctx context.Context, in *MfibSignalDump) ([]*MfibSignalDetails, error)
+       DumpProxyArp(ctx context.Context, in *ProxyArpDump) ([]*ProxyArpDetails, error)
+       DumpProxyArpIntfc(ctx context.Context, in *ProxyArpIntfcDump) ([]*ProxyArpIntfcDetails, error)
+       IoamDisable(ctx context.Context, in *IoamDisable) (*IoamDisableReply, error)
+       IoamEnable(ctx context.Context, in *IoamEnable) (*IoamEnableReply, error)
+       IP6ndProxyAddDel(ctx context.Context, in *IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error)
+       IP6ndSendRouterSolicitation(ctx context.Context, in *IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error)
+       IPAddDelRoute(ctx context.Context, in *IPAddDelRoute) (*IPAddDelRouteReply, error)
+       IPContainerProxyAddDel(ctx context.Context, in *IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
+       IPMrouteAddDel(ctx context.Context, in *IPMrouteAddDel) (*IPMrouteAddDelReply, error)
+       IPNeighborAddDel(ctx context.Context, in *IPNeighborAddDel) (*IPNeighborAddDelReply, error)
+       IPProbeNeighbor(ctx context.Context, in *IPProbeNeighbor) (*IPProbeNeighborReply, error)
+       IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error)
+       IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error)
+       IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
+       IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error)
+       IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error)
+       IPScanNeighborEnableDisable(ctx context.Context, in *IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error)
+       IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
+       IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
+       IPSourceCheckInterfaceAddDel(ctx context.Context, in *IPSourceCheckInterfaceAddDel) (*IPSourceCheckInterfaceAddDelReply, error)
+       IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error)
+       ProxyArpAddDel(ctx context.Context, in *ProxyArpAddDel) (*ProxyArpAddDelReply, error)
+       ProxyArpIntfcEnableDisable(ctx context.Context, in *ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error)
+       ResetFib(ctx context.Context, in *ResetFib) (*ResetFibReply, error)
+       SetArpNeighborLimit(ctx context.Context, in *SetArpNeighborLimit) (*SetArpNeighborLimitReply, error)
+       SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error)
+       SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
+       SwInterfaceIP6ndRaConfig(ctx context.Context, in *SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error)
+       SwInterfaceIP6ndRaPrefix(ctx context.Context, in *SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error)
+       WantIP4ArpEvents(ctx context.Context, in *WantIP4ArpEvents) (*WantIP4ArpEventsReply, error)
+       WantIP6NdEvents(ctx context.Context, in *WantIP6NdEvents) (*WantIP6NdEventsReply, error)
+       WantIP6RaEvents(ctx context.Context, in *WantIP6RaEvents) (*WantIP6RaEventsReply, error)
+}
+
+type service struct {
+       ch api.Channel
+}
+
+func NewService(ch api.Channel) Service {
+       return &service{ch}
+}
+
+func (c *service) DumpIP6Fib(ctx context.Context, in *IP6FibDump) ([]*IP6FibDetails, error) {
+       var dump []*IP6FibDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IP6FibDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIP6Mfib(ctx context.Context, in *IP6MfibDump) ([]*IP6MfibDetails, error) {
+       var dump []*IP6MfibDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IP6MfibDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIP6ndProxy(ctx context.Context, in *IP6ndProxyDump) ([]*IP6ndProxyDetails, error) {
+       var dump []*IP6ndProxyDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IP6ndProxyDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPAddress(ctx context.Context, in *IPAddressDump) ([]*IPAddressDetails, error) {
+       var dump []*IPAddressDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPAddressDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPContainerProxy(ctx context.Context, in *IPContainerProxyDump) ([]*IPContainerProxyDetails, error) {
+       var dump []*IPContainerProxyDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPContainerProxyDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIP(ctx context.Context, in *IPDump) ([]*IPDetails, error) {
+       var dump []*IPDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPFib(ctx context.Context, in *IPFibDump) ([]*IPFibDetails, error) {
+       var dump []*IPFibDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPFibDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPMfib(ctx context.Context, in *IPMfibDump) ([]*IPMfibDetails, error) {
+       var dump []*IPMfibDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPMfibDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPNeighbor(ctx context.Context, in *IPNeighborDump) ([]*IPNeighborDetails, error) {
+       var dump []*IPNeighborDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPNeighborDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPPuntRedirect(ctx context.Context, in *IPPuntRedirectDump) ([]*IPPuntRedirectDetails, error) {
+       var dump []*IPPuntRedirectDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPPuntRedirectDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpIPUnnumbered(ctx context.Context, in *IPUnnumberedDump) ([]*IPUnnumberedDetails, error) {
+       var dump []*IPUnnumberedDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(IPUnnumberedDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpMfibSignal(ctx context.Context, in *MfibSignalDump) ([]*MfibSignalDetails, error) {
+       var dump []*MfibSignalDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(MfibSignalDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpProxyArp(ctx context.Context, in *ProxyArpDump) ([]*ProxyArpDetails, error) {
+       var dump []*ProxyArpDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(ProxyArpDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) DumpProxyArpIntfc(ctx context.Context, in *ProxyArpIntfcDump) ([]*ProxyArpIntfcDetails, error) {
+       var dump []*ProxyArpIntfcDetails
+       req := c.ch.SendMultiRequest(in)
+       for {
+               m := new(ProxyArpIntfcDetails)
+               stop, err := req.ReceiveReply(m)
+               if stop {
+                       break
+               }
+               if err != nil {
+                       return nil, err
+               }
+               dump = append(dump, m)
+       }
+       return dump, nil
+}
+
+func (c *service) IoamDisable(ctx context.Context, in *IoamDisable) (*IoamDisableReply, error) {
+       out := new(IoamDisableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IoamEnable(ctx context.Context, in *IoamEnable) (*IoamEnableReply, error) {
+       out := new(IoamEnableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IP6ndProxyAddDel(ctx context.Context, in *IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error) {
+       out := new(IP6ndProxyAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IP6ndSendRouterSolicitation(ctx context.Context, in *IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error) {
+       out := new(IP6ndSendRouterSolicitationReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPAddDelRoute(ctx context.Context, in *IPAddDelRoute) (*IPAddDelRouteReply, error) {
+       out := new(IPAddDelRouteReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPContainerProxyAddDel(ctx context.Context, in *IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error) {
+       out := new(IPContainerProxyAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPMrouteAddDel(ctx context.Context, in *IPMrouteAddDel) (*IPMrouteAddDelReply, error) {
+       out := new(IPMrouteAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPNeighborAddDel(ctx context.Context, in *IPNeighborAddDel) (*IPNeighborAddDelReply, error) {
+       out := new(IPNeighborAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPProbeNeighbor(ctx context.Context, in *IPProbeNeighbor) (*IPProbeNeighborReply, error) {
+       out := new(IPProbeNeighborReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error) {
+       out := new(IPPuntPoliceReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error) {
+       out := new(IPPuntRedirectReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error) {
+       out := new(IPReassemblyEnableDisableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error) {
+       out := new(IPReassemblyGetReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error) {
+       out := new(IPReassemblySetReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPScanNeighborEnableDisable(ctx context.Context, in *IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error) {
+       out := new(IPScanNeighborEnableDisableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error) {
+       out := new(IPSourceAndPortRangeCheckAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error) {
+       out := new(IPSourceAndPortRangeCheckInterfaceAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPSourceCheckInterfaceAddDel(ctx context.Context, in *IPSourceCheckInterfaceAddDel) (*IPSourceCheckInterfaceAddDelReply, error) {
+       out := new(IPSourceCheckInterfaceAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error) {
+       out := new(IPTableAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) ProxyArpAddDel(ctx context.Context, in *ProxyArpAddDel) (*ProxyArpAddDelReply, error) {
+       out := new(ProxyArpAddDelReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) ProxyArpIntfcEnableDisable(ctx context.Context, in *ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error) {
+       out := new(ProxyArpIntfcEnableDisableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) ResetFib(ctx context.Context, in *ResetFib) (*ResetFibReply, error) {
+       out := new(ResetFibReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) SetArpNeighborLimit(ctx context.Context, in *SetArpNeighborLimit) (*SetArpNeighborLimitReply, error) {
+       out := new(SetArpNeighborLimitReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error) {
+       out := new(SetIPFlowHashReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error) {
+       out := new(SwInterfaceIP6EnableDisableReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) SwInterfaceIP6ndRaConfig(ctx context.Context, in *SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error) {
+       out := new(SwInterfaceIP6ndRaConfigReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) SwInterfaceIP6ndRaPrefix(ctx context.Context, in *SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error) {
+       out := new(SwInterfaceIP6ndRaPrefixReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) WantIP4ArpEvents(ctx context.Context, in *WantIP4ArpEvents) (*WantIP4ArpEventsReply, error) {
+       out := new(WantIP4ArpEventsReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) WantIP6NdEvents(ctx context.Context, in *WantIP6NdEvents) (*WantIP6NdEventsReply, error) {
+       out := new(WantIP6NdEventsReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
+}
+
+func (c *service) WantIP6RaEvents(ctx context.Context, in *WantIP6RaEvents) (*WantIP6RaEventsReply, error) {
+       out := new(WantIP6RaEventsReply)
+       err := c.ch.SendRequest(in).ReceiveReply(out)
+       if err != nil {
+               return nil, err
+       }
+       return out, nil
 }