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