binapi/ip/ip_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package ip
   4
   5 import (
   6         "context"
   7         "fmt"
   8         "io"
   9
  10         api "git.fd.io/govpp.git/api"
  11         memclnt "git.fd.io/govpp.git/binapi/memclnt"
  12 )
  13
  14 // RPCService defines RPC service ip.
  15 type RPCService interface {
  16         AddDelIPPuntRedirectV2(ctx context.Context, in *AddDelIPPuntRedirectV2) (*AddDelIPPuntRedirectV2Reply, error)
  17         IoamDisable(ctx context.Context, in *IoamDisable) (*IoamDisableReply, error)
  18         IoamEnable(ctx context.Context, in *IoamEnable) (*IoamEnableReply, error)
  19         IPAddressDump(ctx context.Context, in *IPAddressDump) (RPCService_IPAddressDumpClient, error)
  20         IPContainerProxyAddDel(ctx context.Context, in *IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
  21         IPContainerProxyDump(ctx context.Context, in *IPContainerProxyDump) (RPCService_IPContainerProxyDumpClient, error)
  22         IPDump(ctx context.Context, in *IPDump) (RPCService_IPDumpClient, error)
  23         IPMrouteAddDel(ctx context.Context, in *IPMrouteAddDel) (*IPMrouteAddDelReply, error)
  24         IPMrouteDump(ctx context.Context, in *IPMrouteDump) (RPCService_IPMrouteDumpClient, error)
  25         IPMtableDump(ctx context.Context, in *IPMtableDump) (RPCService_IPMtableDumpClient, error)
  26         IPPathMtuGet(ctx context.Context, in *IPPathMtuGet) (RPCService_IPPathMtuGetClient, error)
  27         IPPathMtuReplaceBegin(ctx context.Context, in *IPPathMtuReplaceBegin) (*IPPathMtuReplaceBeginReply, error)
  28         IPPathMtuReplaceEnd(ctx context.Context, in *IPPathMtuReplaceEnd) (*IPPathMtuReplaceEndReply, error)
  29         IPPathMtuUpdate(ctx context.Context, in *IPPathMtuUpdate) (*IPPathMtuUpdateReply, error)
  30         IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error)
  31         IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error)
  32         IPPuntRedirectDump(ctx context.Context, in *IPPuntRedirectDump) (RPCService_IPPuntRedirectDumpClient, error)
  33         IPPuntRedirectV2Dump(ctx context.Context, in *IPPuntRedirectV2Dump) (RPCService_IPPuntRedirectV2DumpClient, error)
  34         IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
  35         IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error)
  36         IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error)
  37         IPRouteAddDel(ctx context.Context, in *IPRouteAddDel) (*IPRouteAddDelReply, error)
  38         IPRouteAddDelV2(ctx context.Context, in *IPRouteAddDelV2) (*IPRouteAddDelV2Reply, error)
  39         IPRouteDump(ctx context.Context, in *IPRouteDump) (RPCService_IPRouteDumpClient, error)
  40         IPRouteLookup(ctx context.Context, in *IPRouteLookup) (*IPRouteLookupReply, error)
  41         IPRouteLookupV2(ctx context.Context, in *IPRouteLookupV2) (*IPRouteLookupV2Reply, error)
  42         IPRouteV2Dump(ctx context.Context, in *IPRouteV2Dump) (RPCService_IPRouteV2DumpClient, error)
  43         IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
  44         IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
  45         IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error)
  46         IPTableAllocate(ctx context.Context, in *IPTableAllocate) (*IPTableAllocateReply, error)
  47         IPTableDump(ctx context.Context, in *IPTableDump) (RPCService_IPTableDumpClient, error)
  48         IPTableFlush(ctx context.Context, in *IPTableFlush) (*IPTableFlushReply, error)
  49         IPTableReplaceBegin(ctx context.Context, in *IPTableReplaceBegin) (*IPTableReplaceBeginReply, error)
  50         IPTableReplaceEnd(ctx context.Context, in *IPTableReplaceEnd) (*IPTableReplaceEndReply, error)
  51         IPUnnumberedDump(ctx context.Context, in *IPUnnumberedDump) (RPCService_IPUnnumberedDumpClient, error)
  52         MfibSignalDump(ctx context.Context, in *MfibSignalDump) (RPCService_MfibSignalDumpClient, error)
  53         SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error)
  54         SetIPFlowHashRouterID(ctx context.Context, in *SetIPFlowHashRouterID) (*SetIPFlowHashRouterIDReply, error)
  55         SetIPFlowHashV2(ctx context.Context, in *SetIPFlowHashV2) (*SetIPFlowHashV2Reply, error)
  56         SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
  57         SwInterfaceIP6GetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6GetLinkLocalAddress) (*SwInterfaceIP6GetLinkLocalAddressReply, error)
  58         SwInterfaceIP6SetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error)
  59 }
  60
  61 type serviceClient struct {
  62         conn api.Connection
  63 }
  64
  65 func NewServiceClient(conn api.Connection) RPCService {
  66         return &serviceClient{conn}
  67 }
  68
  69 func (c *serviceClient) AddDelIPPuntRedirectV2(ctx context.Context, in *AddDelIPPuntRedirectV2) (*AddDelIPPuntRedirectV2Reply, error) {
  70         out := new(AddDelIPPuntRedirectV2Reply)
  71         err := c.conn.Invoke(ctx, in, out)
  72         if err != nil {
  73                 return nil, err
  74         }
  75         return out, api.RetvalToVPPApiError(out.Retval)
  76 }
  77
  78 func (c *serviceClient) IoamDisable(ctx context.Context, in *IoamDisable) (*IoamDisableReply, error) {
  79         out := new(IoamDisableReply)
  80         err := c.conn.Invoke(ctx, in, out)
  81         if err != nil {
  82                 return nil, err
  83         }
  84         return out, api.RetvalToVPPApiError(out.Retval)
  85 }
  86
  87 func (c *serviceClient) IoamEnable(ctx context.Context, in *IoamEnable) (*IoamEnableReply, error) {
  88         out := new(IoamEnableReply)
  89         err := c.conn.Invoke(ctx, in, out)
  90         if err != nil {
  91                 return nil, err
  92         }
  93         return out, api.RetvalToVPPApiError(out.Retval)
  94 }
  95
  96 func (c *serviceClient) IPAddressDump(ctx context.Context, in *IPAddressDump) (RPCService_IPAddressDumpClient, error) {
  97         stream, err := c.conn.NewStream(ctx)
  98         if err != nil {
  99                 return nil, err
 100         }
 101         x := &serviceClient_IPAddressDumpClient{stream}
 102         if err := x.Stream.SendMsg(in); err != nil {
 103                 return nil, err
 104         }
 105         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 106                 return nil, err
 107         }
 108         return x, nil
 109 }
 110
 111 type RPCService_IPAddressDumpClient interface {
 112         Recv() (*IPAddressDetails, error)
 113         api.Stream
 114 }
 115
 116 type serviceClient_IPAddressDumpClient struct {
 117         api.Stream
 118 }
 119
 120 func (c *serviceClient_IPAddressDumpClient) Recv() (*IPAddressDetails, error) {
 121         msg, err := c.Stream.RecvMsg()
 122         if err != nil {
 123                 return nil, err
 124         }
 125         switch m := msg.(type) {
 126         case *IPAddressDetails:
 127                 return m, nil
 128         case *memclnt.ControlPingReply:
 129                 err = c.Stream.Close()
 130                 if err != nil {
 131                         return nil, err
 132                 }
 133                 return nil, io.EOF
 134         default:
 135                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 136         }
 137 }
 138
 139 func (c *serviceClient) IPContainerProxyAddDel(ctx context.Context, in *IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error) {
 140         out := new(IPContainerProxyAddDelReply)
 141         err := c.conn.Invoke(ctx, in, out)
 142         if err != nil {
 143                 return nil, err
 144         }
 145         return out, api.RetvalToVPPApiError(out.Retval)
 146 }
 147
 148 func (c *serviceClient) IPContainerProxyDump(ctx context.Context, in *IPContainerProxyDump) (RPCService_IPContainerProxyDumpClient, error) {
 149         stream, err := c.conn.NewStream(ctx)
 150         if err != nil {
 151                 return nil, err
 152         }
 153         x := &serviceClient_IPContainerProxyDumpClient{stream}
 154         if err := x.Stream.SendMsg(in); err != nil {
 155                 return nil, err
 156         }
 157         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 158                 return nil, err
 159         }
 160         return x, nil
 161 }
 162
 163 type RPCService_IPContainerProxyDumpClient interface {
 164         Recv() (*IPContainerProxyDetails, error)
 165         api.Stream
 166 }
 167
 168 type serviceClient_IPContainerProxyDumpClient struct {
 169         api.Stream
 170 }
 171
 172 func (c *serviceClient_IPContainerProxyDumpClient) Recv() (*IPContainerProxyDetails, error) {
 173         msg, err := c.Stream.RecvMsg()
 174         if err != nil {
 175                 return nil, err
 176         }
 177         switch m := msg.(type) {
 178         case *IPContainerProxyDetails:
 179                 return m, nil
 180         case *memclnt.ControlPingReply:
 181                 err = c.Stream.Close()
 182                 if err != nil {
 183                         return nil, err
 184                 }
 185                 return nil, io.EOF
 186         default:
 187                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 188         }
 189 }
 190
 191 func (c *serviceClient) IPDump(ctx context.Context, in *IPDump) (RPCService_IPDumpClient, error) {
 192         stream, err := c.conn.NewStream(ctx)
 193         if err != nil {
 194                 return nil, err
 195         }
 196         x := &serviceClient_IPDumpClient{stream}
 197         if err := x.Stream.SendMsg(in); err != nil {
 198                 return nil, err
 199         }
 200         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 201                 return nil, err
 202         }
 203         return x, nil
 204 }
 205
 206 type RPCService_IPDumpClient interface {
 207         Recv() (*IPDetails, error)
 208         api.Stream
 209 }
 210
 211 type serviceClient_IPDumpClient struct {
 212         api.Stream
 213 }
 214
 215 func (c *serviceClient_IPDumpClient) Recv() (*IPDetails, error) {
 216         msg, err := c.Stream.RecvMsg()
 217         if err != nil {
 218                 return nil, err
 219         }
 220         switch m := msg.(type) {
 221         case *IPDetails:
 222                 return m, nil
 223         case *memclnt.ControlPingReply:
 224                 err = c.Stream.Close()
 225                 if err != nil {
 226                         return nil, err
 227                 }
 228                 return nil, io.EOF
 229         default:
 230                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 231         }
 232 }
 233
 234 func (c *serviceClient) IPMrouteAddDel(ctx context.Context, in *IPMrouteAddDel) (*IPMrouteAddDelReply, error) {
 235         out := new(IPMrouteAddDelReply)
 236         err := c.conn.Invoke(ctx, in, out)
 237         if err != nil {
 238                 return nil, err
 239         }
 240         return out, api.RetvalToVPPApiError(out.Retval)
 241 }
 242
 243 func (c *serviceClient) IPMrouteDump(ctx context.Context, in *IPMrouteDump) (RPCService_IPMrouteDumpClient, error) {
 244         stream, err := c.conn.NewStream(ctx)
 245         if err != nil {
 246                 return nil, err
 247         }
 248         x := &serviceClient_IPMrouteDumpClient{stream}
 249         if err := x.Stream.SendMsg(in); err != nil {
 250                 return nil, err
 251         }
 252         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 253                 return nil, err
 254         }
 255         return x, nil
 256 }
 257
 258 type RPCService_IPMrouteDumpClient interface {
 259         Recv() (*IPMrouteDetails, error)
 260         api.Stream
 261 }
 262
 263 type serviceClient_IPMrouteDumpClient struct {
 264         api.Stream
 265 }
 266
 267 func (c *serviceClient_IPMrouteDumpClient) Recv() (*IPMrouteDetails, error) {
 268         msg, err := c.Stream.RecvMsg()
 269         if err != nil {
 270                 return nil, err
 271         }
 272         switch m := msg.(type) {
 273         case *IPMrouteDetails:
 274                 return m, nil
 275         case *memclnt.ControlPingReply:
 276                 err = c.Stream.Close()
 277                 if err != nil {
 278                         return nil, err
 279                 }
 280                 return nil, io.EOF
 281         default:
 282                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 283         }
 284 }
 285
 286 func (c *serviceClient) IPMtableDump(ctx context.Context, in *IPMtableDump) (RPCService_IPMtableDumpClient, error) {
 287         stream, err := c.conn.NewStream(ctx)
 288         if err != nil {
 289                 return nil, err
 290         }
 291         x := &serviceClient_IPMtableDumpClient{stream}
 292         if err := x.Stream.SendMsg(in); err != nil {
 293                 return nil, err
 294         }
 295         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 296                 return nil, err
 297         }
 298         return x, nil
 299 }
 300
 301 type RPCService_IPMtableDumpClient interface {
 302         Recv() (*IPMtableDetails, error)
 303         api.Stream
 304 }
 305
 306 type serviceClient_IPMtableDumpClient struct {
 307         api.Stream
 308 }
 309
 310 func (c *serviceClient_IPMtableDumpClient) Recv() (*IPMtableDetails, error) {
 311         msg, err := c.Stream.RecvMsg()
 312         if err != nil {
 313                 return nil, err
 314         }
 315         switch m := msg.(type) {
 316         case *IPMtableDetails:
 317                 return m, nil
 318         case *memclnt.ControlPingReply:
 319                 err = c.Stream.Close()
 320                 if err != nil {
 321                         return nil, err
 322                 }
 323                 return nil, io.EOF
 324         default:
 325                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 326         }
 327 }
 328
 329 func (c *serviceClient) IPPathMtuGet(ctx context.Context, in *IPPathMtuGet) (RPCService_IPPathMtuGetClient, error) {
 330         stream, err := c.conn.NewStream(ctx)
 331         if err != nil {
 332                 return nil, err
 333         }
 334         x := &serviceClient_IPPathMtuGetClient{stream}
 335         if err := x.Stream.SendMsg(in); err != nil {
 336                 return nil, err
 337         }
 338         return x, nil
 339 }
 340
 341 type RPCService_IPPathMtuGetClient interface {
 342         Recv() (*IPPathMtuDetails, error)
 343         api.Stream
 344 }
 345
 346 type serviceClient_IPPathMtuGetClient struct {
 347         api.Stream
 348 }
 349
 350 func (c *serviceClient_IPPathMtuGetClient) Recv() (*IPPathMtuDetails, error) {
 351         msg, err := c.Stream.RecvMsg()
 352         if err != nil {
 353                 return nil, err
 354         }
 355         switch m := msg.(type) {
 356         case *IPPathMtuDetails:
 357                 return m, nil
 358         case *IPPathMtuGetReply:
 359                 err = c.Stream.Close()
 360                 if err != nil {
 361                         return nil, err
 362                 }
 363                 return nil, io.EOF
 364         default:
 365                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 366         }
 367 }
 368
 369 func (c *serviceClient) IPPathMtuReplaceBegin(ctx context.Context, in *IPPathMtuReplaceBegin) (*IPPathMtuReplaceBeginReply, error) {
 370         out := new(IPPathMtuReplaceBeginReply)
 371         err := c.conn.Invoke(ctx, in, out)
 372         if err != nil {
 373                 return nil, err
 374         }
 375         return out, api.RetvalToVPPApiError(out.Retval)
 376 }
 377
 378 func (c *serviceClient) IPPathMtuReplaceEnd(ctx context.Context, in *IPPathMtuReplaceEnd) (*IPPathMtuReplaceEndReply, error) {
 379         out := new(IPPathMtuReplaceEndReply)
 380         err := c.conn.Invoke(ctx, in, out)
 381         if err != nil {
 382                 return nil, err
 383         }
 384         return out, api.RetvalToVPPApiError(out.Retval)
 385 }
 386
 387 func (c *serviceClient) IPPathMtuUpdate(ctx context.Context, in *IPPathMtuUpdate) (*IPPathMtuUpdateReply, error) {
 388         out := new(IPPathMtuUpdateReply)
 389         err := c.conn.Invoke(ctx, in, out)
 390         if err != nil {
 391                 return nil, err
 392         }
 393         return out, api.RetvalToVPPApiError(out.Retval)
 394 }
 395
 396 func (c *serviceClient) IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error) {
 397         out := new(IPPuntPoliceReply)
 398         err := c.conn.Invoke(ctx, in, out)
 399         if err != nil {
 400                 return nil, err
 401         }
 402         return out, api.RetvalToVPPApiError(out.Retval)
 403 }
 404
 405 func (c *serviceClient) IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error) {
 406         out := new(IPPuntRedirectReply)
 407         err := c.conn.Invoke(ctx, in, out)
 408         if err != nil {
 409                 return nil, err
 410         }
 411         return out, api.RetvalToVPPApiError(out.Retval)
 412 }
 413
 414 func (c *serviceClient) IPPuntRedirectDump(ctx context.Context, in *IPPuntRedirectDump) (RPCService_IPPuntRedirectDumpClient, error) {
 415         stream, err := c.conn.NewStream(ctx)
 416         if err != nil {
 417                 return nil, err
 418         }
 419         x := &serviceClient_IPPuntRedirectDumpClient{stream}
 420         if err := x.Stream.SendMsg(in); err != nil {
 421                 return nil, err
 422         }
 423         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 424                 return nil, err
 425         }
 426         return x, nil
 427 }
 428
 429 type RPCService_IPPuntRedirectDumpClient interface {
 430         Recv() (*IPPuntRedirectDetails, error)
 431         api.Stream
 432 }
 433
 434 type serviceClient_IPPuntRedirectDumpClient struct {
 435         api.Stream
 436 }
 437
 438 func (c *serviceClient_IPPuntRedirectDumpClient) Recv() (*IPPuntRedirectDetails, error) {
 439         msg, err := c.Stream.RecvMsg()
 440         if err != nil {
 441                 return nil, err
 442         }
 443         switch m := msg.(type) {
 444         case *IPPuntRedirectDetails:
 445                 return m, nil
 446         case *memclnt.ControlPingReply:
 447                 err = c.Stream.Close()
 448                 if err != nil {
 449                         return nil, err
 450                 }
 451                 return nil, io.EOF
 452         default:
 453                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 454         }
 455 }
 456
 457 func (c *serviceClient) IPPuntRedirectV2Dump(ctx context.Context, in *IPPuntRedirectV2Dump) (RPCService_IPPuntRedirectV2DumpClient, error) {
 458         stream, err := c.conn.NewStream(ctx)
 459         if err != nil {
 460                 return nil, err
 461         }
 462         x := &serviceClient_IPPuntRedirectV2DumpClient{stream}
 463         if err := x.Stream.SendMsg(in); err != nil {
 464                 return nil, err
 465         }
 466         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 467                 return nil, err
 468         }
 469         return x, nil
 470 }
 471
 472 type RPCService_IPPuntRedirectV2DumpClient interface {
 473         Recv() (*IPPuntRedirectV2Details, error)
 474         api.Stream
 475 }
 476
 477 type serviceClient_IPPuntRedirectV2DumpClient struct {
 478         api.Stream
 479 }
 480
 481 func (c *serviceClient_IPPuntRedirectV2DumpClient) Recv() (*IPPuntRedirectV2Details, error) {
 482         msg, err := c.Stream.RecvMsg()
 483         if err != nil {
 484                 return nil, err
 485         }
 486         switch m := msg.(type) {
 487         case *IPPuntRedirectV2Details:
 488                 return m, nil
 489         case *memclnt.ControlPingReply:
 490                 err = c.Stream.Close()
 491                 if err != nil {
 492                         return nil, err
 493                 }
 494                 return nil, io.EOF
 495         default:
 496                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 497         }
 498 }
 499
 500 func (c *serviceClient) IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error) {
 501         out := new(IPReassemblyEnableDisableReply)
 502         err := c.conn.Invoke(ctx, in, out)
 503         if err != nil {
 504                 return nil, err
 505         }
 506         return out, api.RetvalToVPPApiError(out.Retval)
 507 }
 508
 509 func (c *serviceClient) IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error) {
 510         out := new(IPReassemblyGetReply)
 511         err := c.conn.Invoke(ctx, in, out)
 512         if err != nil {
 513                 return nil, err
 514         }
 515         return out, api.RetvalToVPPApiError(out.Retval)
 516 }
 517
 518 func (c *serviceClient) IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error) {
 519         out := new(IPReassemblySetReply)
 520         err := c.conn.Invoke(ctx, in, out)
 521         if err != nil {
 522                 return nil, err
 523         }
 524         return out, api.RetvalToVPPApiError(out.Retval)
 525 }
 526
 527 func (c *serviceClient) IPRouteAddDel(ctx context.Context, in *IPRouteAddDel) (*IPRouteAddDelReply, error) {
 528         out := new(IPRouteAddDelReply)
 529         err := c.conn.Invoke(ctx, in, out)
 530         if err != nil {
 531                 return nil, err
 532         }
 533         return out, api.RetvalToVPPApiError(out.Retval)
 534 }
 535
 536 func (c *serviceClient) IPRouteAddDelV2(ctx context.Context, in *IPRouteAddDelV2) (*IPRouteAddDelV2Reply, error) {
 537         out := new(IPRouteAddDelV2Reply)
 538         err := c.conn.Invoke(ctx, in, out)
 539         if err != nil {
 540                 return nil, err
 541         }
 542         return out, api.RetvalToVPPApiError(out.Retval)
 543 }
 544
 545 func (c *serviceClient) IPRouteDump(ctx context.Context, in *IPRouteDump) (RPCService_IPRouteDumpClient, error) {
 546         stream, err := c.conn.NewStream(ctx)
 547         if err != nil {
 548                 return nil, err
 549         }
 550         x := &serviceClient_IPRouteDumpClient{stream}
 551         if err := x.Stream.SendMsg(in); err != nil {
 552                 return nil, err
 553         }
 554         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 555                 return nil, err
 556         }
 557         return x, nil
 558 }
 559
 560 type RPCService_IPRouteDumpClient interface {
 561         Recv() (*IPRouteDetails, error)
 562         api.Stream
 563 }
 564
 565 type serviceClient_IPRouteDumpClient struct {
 566         api.Stream
 567 }
 568
 569 func (c *serviceClient_IPRouteDumpClient) Recv() (*IPRouteDetails, error) {
 570         msg, err := c.Stream.RecvMsg()
 571         if err != nil {
 572                 return nil, err
 573         }
 574         switch m := msg.(type) {
 575         case *IPRouteDetails:
 576                 return m, nil
 577         case *memclnt.ControlPingReply:
 578                 err = c.Stream.Close()
 579                 if err != nil {
 580                         return nil, err
 581                 }
 582                 return nil, io.EOF
 583         default:
 584                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 585         }
 586 }
 587
 588 func (c *serviceClient) IPRouteLookup(ctx context.Context, in *IPRouteLookup) (*IPRouteLookupReply, error) {
 589         out := new(IPRouteLookupReply)
 590         err := c.conn.Invoke(ctx, in, out)
 591         if err != nil {
 592                 return nil, err
 593         }
 594         return out, api.RetvalToVPPApiError(out.Retval)
 595 }
 596
 597 func (c *serviceClient) IPRouteLookupV2(ctx context.Context, in *IPRouteLookupV2) (*IPRouteLookupV2Reply, error) {
 598         out := new(IPRouteLookupV2Reply)
 599         err := c.conn.Invoke(ctx, in, out)
 600         if err != nil {
 601                 return nil, err
 602         }
 603         return out, api.RetvalToVPPApiError(out.Retval)
 604 }
 605
 606 func (c *serviceClient) IPRouteV2Dump(ctx context.Context, in *IPRouteV2Dump) (RPCService_IPRouteV2DumpClient, error) {
 607         stream, err := c.conn.NewStream(ctx)
 608         if err != nil {
 609                 return nil, err
 610         }
 611         x := &serviceClient_IPRouteV2DumpClient{stream}
 612         if err := x.Stream.SendMsg(in); err != nil {
 613                 return nil, err
 614         }
 615         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 616                 return nil, err
 617         }
 618         return x, nil
 619 }
 620
 621 type RPCService_IPRouteV2DumpClient interface {
 622         Recv() (*IPRouteV2Details, error)
 623         api.Stream
 624 }
 625
 626 type serviceClient_IPRouteV2DumpClient struct {
 627         api.Stream
 628 }
 629
 630 func (c *serviceClient_IPRouteV2DumpClient) Recv() (*IPRouteV2Details, error) {
 631         msg, err := c.Stream.RecvMsg()
 632         if err != nil {
 633                 return nil, err
 634         }
 635         switch m := msg.(type) {
 636         case *IPRouteV2Details:
 637                 return m, nil
 638         case *memclnt.ControlPingReply:
 639                 err = c.Stream.Close()
 640                 if err != nil {
 641                         return nil, err
 642                 }
 643                 return nil, io.EOF
 644         default:
 645                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 646         }
 647 }
 648
 649 func (c *serviceClient) IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error) {
 650         out := new(IPSourceAndPortRangeCheckAddDelReply)
 651         err := c.conn.Invoke(ctx, in, out)
 652         if err != nil {
 653                 return nil, err
 654         }
 655         return out, api.RetvalToVPPApiError(out.Retval)
 656 }
 657
 658 func (c *serviceClient) IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error) {
 659         out := new(IPSourceAndPortRangeCheckInterfaceAddDelReply)
 660         err := c.conn.Invoke(ctx, in, out)
 661         if err != nil {
 662                 return nil, err
 663         }
 664         return out, api.RetvalToVPPApiError(out.Retval)
 665 }
 666
 667 func (c *serviceClient) IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error) {
 668         out := new(IPTableAddDelReply)
 669         err := c.conn.Invoke(ctx, in, out)
 670         if err != nil {
 671                 return nil, err
 672         }
 673         return out, api.RetvalToVPPApiError(out.Retval)
 674 }
 675
 676 func (c *serviceClient) IPTableAllocate(ctx context.Context, in *IPTableAllocate) (*IPTableAllocateReply, error) {
 677         out := new(IPTableAllocateReply)
 678         err := c.conn.Invoke(ctx, in, out)
 679         if err != nil {
 680                 return nil, err
 681         }
 682         return out, api.RetvalToVPPApiError(out.Retval)
 683 }
 684
 685 func (c *serviceClient) IPTableDump(ctx context.Context, in *IPTableDump) (RPCService_IPTableDumpClient, error) {
 686         stream, err := c.conn.NewStream(ctx)
 687         if err != nil {
 688                 return nil, err
 689         }
 690         x := &serviceClient_IPTableDumpClient{stream}
 691         if err := x.Stream.SendMsg(in); err != nil {
 692                 return nil, err
 693         }
 694         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 695                 return nil, err
 696         }
 697         return x, nil
 698 }
 699
 700 type RPCService_IPTableDumpClient interface {
 701         Recv() (*IPTableDetails, error)
 702         api.Stream
 703 }
 704
 705 type serviceClient_IPTableDumpClient struct {
 706         api.Stream
 707 }
 708
 709 func (c *serviceClient_IPTableDumpClient) Recv() (*IPTableDetails, error) {
 710         msg, err := c.Stream.RecvMsg()
 711         if err != nil {
 712                 return nil, err
 713         }
 714         switch m := msg.(type) {
 715         case *IPTableDetails:
 716                 return m, nil
 717         case *memclnt.ControlPingReply:
 718                 err = c.Stream.Close()
 719                 if err != nil {
 720                         return nil, err
 721                 }
 722                 return nil, io.EOF
 723         default:
 724                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 725         }
 726 }
 727
 728 func (c *serviceClient) IPTableFlush(ctx context.Context, in *IPTableFlush) (*IPTableFlushReply, error) {
 729         out := new(IPTableFlushReply)
 730         err := c.conn.Invoke(ctx, in, out)
 731         if err != nil {
 732                 return nil, err
 733         }
 734         return out, api.RetvalToVPPApiError(out.Retval)
 735 }
 736
 737 func (c *serviceClient) IPTableReplaceBegin(ctx context.Context, in *IPTableReplaceBegin) (*IPTableReplaceBeginReply, error) {
 738         out := new(IPTableReplaceBeginReply)
 739         err := c.conn.Invoke(ctx, in, out)
 740         if err != nil {
 741                 return nil, err
 742         }
 743         return out, api.RetvalToVPPApiError(out.Retval)
 744 }
 745
 746 func (c *serviceClient) IPTableReplaceEnd(ctx context.Context, in *IPTableReplaceEnd) (*IPTableReplaceEndReply, error) {
 747         out := new(IPTableReplaceEndReply)
 748         err := c.conn.Invoke(ctx, in, out)
 749         if err != nil {
 750                 return nil, err
 751         }
 752         return out, api.RetvalToVPPApiError(out.Retval)
 753 }
 754
 755 func (c *serviceClient) IPUnnumberedDump(ctx context.Context, in *IPUnnumberedDump) (RPCService_IPUnnumberedDumpClient, error) {
 756         stream, err := c.conn.NewStream(ctx)
 757         if err != nil {
 758                 return nil, err
 759         }
 760         x := &serviceClient_IPUnnumberedDumpClient{stream}
 761         if err := x.Stream.SendMsg(in); err != nil {
 762                 return nil, err
 763         }
 764         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 765                 return nil, err
 766         }
 767         return x, nil
 768 }
 769
 770 type RPCService_IPUnnumberedDumpClient interface {
 771         Recv() (*IPUnnumberedDetails, error)
 772         api.Stream
 773 }
 774
 775 type serviceClient_IPUnnumberedDumpClient struct {
 776         api.Stream
 777 }
 778
 779 func (c *serviceClient_IPUnnumberedDumpClient) Recv() (*IPUnnumberedDetails, error) {
 780         msg, err := c.Stream.RecvMsg()
 781         if err != nil {
 782                 return nil, err
 783         }
 784         switch m := msg.(type) {
 785         case *IPUnnumberedDetails:
 786                 return m, nil
 787         case *memclnt.ControlPingReply:
 788                 err = c.Stream.Close()
 789                 if err != nil {
 790                         return nil, err
 791                 }
 792                 return nil, io.EOF
 793         default:
 794                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 795         }
 796 }
 797
 798 func (c *serviceClient) MfibSignalDump(ctx context.Context, in *MfibSignalDump) (RPCService_MfibSignalDumpClient, error) {
 799         stream, err := c.conn.NewStream(ctx)
 800         if err != nil {
 801                 return nil, err
 802         }
 803         x := &serviceClient_MfibSignalDumpClient{stream}
 804         if err := x.Stream.SendMsg(in); err != nil {
 805                 return nil, err
 806         }
 807         if err = x.Stream.SendMsg(&memclnt.ControlPing{}); err != nil {
 808                 return nil, err
 809         }
 810         return x, nil
 811 }
 812
 813 type RPCService_MfibSignalDumpClient interface {
 814         Recv() (*MfibSignalDetails, error)
 815         api.Stream
 816 }
 817
 818 type serviceClient_MfibSignalDumpClient struct {
 819         api.Stream
 820 }
 821
 822 func (c *serviceClient_MfibSignalDumpClient) Recv() (*MfibSignalDetails, error) {
 823         msg, err := c.Stream.RecvMsg()
 824         if err != nil {
 825                 return nil, err
 826         }
 827         switch m := msg.(type) {
 828         case *MfibSignalDetails:
 829                 return m, nil
 830         case *memclnt.ControlPingReply:
 831                 err = c.Stream.Close()
 832                 if err != nil {
 833                         return nil, err
 834                 }
 835                 return nil, io.EOF
 836         default:
 837                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 838         }
 839 }
 840
 841 func (c *serviceClient) SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error) {
 842         out := new(SetIPFlowHashReply)
 843         err := c.conn.Invoke(ctx, in, out)
 844         if err != nil {
 845                 return nil, err
 846         }
 847         return out, api.RetvalToVPPApiError(out.Retval)
 848 }
 849
 850 func (c *serviceClient) SetIPFlowHashRouterID(ctx context.Context, in *SetIPFlowHashRouterID) (*SetIPFlowHashRouterIDReply, error) {
 851         out := new(SetIPFlowHashRouterIDReply)
 852         err := c.conn.Invoke(ctx, in, out)
 853         if err != nil {
 854                 return nil, err
 855         }
 856         return out, api.RetvalToVPPApiError(out.Retval)
 857 }
 858
 859 func (c *serviceClient) SetIPFlowHashV2(ctx context.Context, in *SetIPFlowHashV2) (*SetIPFlowHashV2Reply, error) {
 860         out := new(SetIPFlowHashV2Reply)
 861         err := c.conn.Invoke(ctx, in, out)
 862         if err != nil {
 863                 return nil, err
 864         }
 865         return out, api.RetvalToVPPApiError(out.Retval)
 866 }
 867
 868 func (c *serviceClient) SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error) {
 869         out := new(SwInterfaceIP6EnableDisableReply)
 870         err := c.conn.Invoke(ctx, in, out)
 871         if err != nil {
 872                 return nil, err
 873         }
 874         return out, api.RetvalToVPPApiError(out.Retval)
 875 }
 876
 877 func (c *serviceClient) SwInterfaceIP6GetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6GetLinkLocalAddress) (*SwInterfaceIP6GetLinkLocalAddressReply, error) {
 878         out := new(SwInterfaceIP6GetLinkLocalAddressReply)
 879         err := c.conn.Invoke(ctx, in, out)
 880         if err != nil {
 881                 return nil, err
 882         }
 883         return out, api.RetvalToVPPApiError(out.Retval)
 884 }
 885
 886 func (c *serviceClient) SwInterfaceIP6SetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error) {
 887         out := new(SwInterfaceIP6SetLinkLocalAddressReply)
 888         err := c.conn.Invoke(ctx, in, out)
 889         if err != nil {
 890                 return nil, err
 891         }
 892         return out, api.RetvalToVPPApiError(out.Retval)
 893 }