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