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         IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error)
  26         IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error)
  27         IPPuntRedirectDump(ctx context.Context, in *IPPuntRedirectDump) (RPCService_IPPuntRedirectDumpClient, error)
  28         IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
  29         IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error)
  30         IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error)
  31         IPRouteAddDel(ctx context.Context, in *IPRouteAddDel) (*IPRouteAddDelReply, error)
  32         IPRouteDump(ctx context.Context, in *IPRouteDump) (RPCService_IPRouteDumpClient, error)
  33         IPRouteLookup(ctx context.Context, in *IPRouteLookup) (*IPRouteLookupReply, error)
  34         IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
  35         IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
  36         IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error)
  37         IPTableDump(ctx context.Context, in *IPTableDump) (RPCService_IPTableDumpClient, error)
  38         IPTableFlush(ctx context.Context, in *IPTableFlush) (*IPTableFlushReply, error)
  39         IPTableReplaceBegin(ctx context.Context, in *IPTableReplaceBegin) (*IPTableReplaceBeginReply, error)
  40         IPTableReplaceEnd(ctx context.Context, in *IPTableReplaceEnd) (*IPTableReplaceEndReply, error)
  41         IPUnnumberedDump(ctx context.Context, in *IPUnnumberedDump) (RPCService_IPUnnumberedDumpClient, error)
  42         MfibSignalDump(ctx context.Context, in *MfibSignalDump) (RPCService_MfibSignalDumpClient, error)
  43         SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error)
  44         SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
  45         SwInterfaceIP6SetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error)
  46 }
  47
  48 type serviceClient struct {
  49         conn api.Connection
  50 }
  51
  52 func NewServiceClient(conn api.Connection) RPCService {
  53         return &serviceClient{conn}
  54 }
  55
  56 func (c *serviceClient) IoamDisable(ctx context.Context, in *IoamDisable) (*IoamDisableReply, error) {
  57         out := new(IoamDisableReply)
  58         err := c.conn.Invoke(ctx, in, out)
  59         if err != nil {
  60                 return nil, err
  61         }
  62         return out, nil
  63 }
  64
  65 func (c *serviceClient) IoamEnable(ctx context.Context, in *IoamEnable) (*IoamEnableReply, error) {
  66         out := new(IoamEnableReply)
  67         err := c.conn.Invoke(ctx, in, out)
  68         if err != nil {
  69                 return nil, err
  70         }
  71         return out, nil
  72 }
  73
  74 func (c *serviceClient) IPAddressDump(ctx context.Context, in *IPAddressDump) (RPCService_IPAddressDumpClient, error) {
  75         stream, err := c.conn.NewStream(ctx)
  76         if err != nil {
  77                 return nil, err
  78         }
  79         x := &serviceClient_IPAddressDumpClient{stream}
  80         if err := x.Stream.SendMsg(in); err != nil {
  81                 return nil, err
  82         }
  83         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
  84                 return nil, err
  85         }
  86         return x, nil
  87 }
  88
  89 type RPCService_IPAddressDumpClient interface {
  90         Recv() (*IPAddressDetails, error)
  91         api.Stream
  92 }
  93
  94 type serviceClient_IPAddressDumpClient struct {
  95         api.Stream
  96 }
  97
  98 func (c *serviceClient_IPAddressDumpClient) Recv() (*IPAddressDetails, error) {
  99         msg, err := c.Stream.RecvMsg()
 100         if err != nil {
 101                 return nil, err
 102         }
 103         switch m := msg.(type) {
 104         case *IPAddressDetails:
 105                 return m, nil
 106         case *vpe.ControlPingReply:
 107                 return nil, io.EOF
 108         default:
 109                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 110         }
 111 }
 112
 113 func (c *serviceClient) IPContainerProxyAddDel(ctx context.Context, in *IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error) {
 114         out := new(IPContainerProxyAddDelReply)
 115         err := c.conn.Invoke(ctx, in, out)
 116         if err != nil {
 117                 return nil, err
 118         }
 119         return out, nil
 120 }
 121
 122 func (c *serviceClient) IPContainerProxyDump(ctx context.Context, in *IPContainerProxyDump) (RPCService_IPContainerProxyDumpClient, error) {
 123         stream, err := c.conn.NewStream(ctx)
 124         if err != nil {
 125                 return nil, err
 126         }
 127         x := &serviceClient_IPContainerProxyDumpClient{stream}
 128         if err := x.Stream.SendMsg(in); err != nil {
 129                 return nil, err
 130         }
 131         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 132                 return nil, err
 133         }
 134         return x, nil
 135 }
 136
 137 type RPCService_IPContainerProxyDumpClient interface {
 138         Recv() (*IPContainerProxyDetails, error)
 139         api.Stream
 140 }
 141
 142 type serviceClient_IPContainerProxyDumpClient struct {
 143         api.Stream
 144 }
 145
 146 func (c *serviceClient_IPContainerProxyDumpClient) Recv() (*IPContainerProxyDetails, error) {
 147         msg, err := c.Stream.RecvMsg()
 148         if err != nil {
 149                 return nil, err
 150         }
 151         switch m := msg.(type) {
 152         case *IPContainerProxyDetails:
 153                 return m, nil
 154         case *vpe.ControlPingReply:
 155                 return nil, io.EOF
 156         default:
 157                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 158         }
 159 }
 160
 161 func (c *serviceClient) IPDump(ctx context.Context, in *IPDump) (RPCService_IPDumpClient, error) {
 162         stream, err := c.conn.NewStream(ctx)
 163         if err != nil {
 164                 return nil, err
 165         }
 166         x := &serviceClient_IPDumpClient{stream}
 167         if err := x.Stream.SendMsg(in); err != nil {
 168                 return nil, err
 169         }
 170         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 171                 return nil, err
 172         }
 173         return x, nil
 174 }
 175
 176 type RPCService_IPDumpClient interface {
 177         Recv() (*IPDetails, error)
 178         api.Stream
 179 }
 180
 181 type serviceClient_IPDumpClient struct {
 182         api.Stream
 183 }
 184
 185 func (c *serviceClient_IPDumpClient) Recv() (*IPDetails, error) {
 186         msg, err := c.Stream.RecvMsg()
 187         if err != nil {
 188                 return nil, err
 189         }
 190         switch m := msg.(type) {
 191         case *IPDetails:
 192                 return m, nil
 193         case *vpe.ControlPingReply:
 194                 return nil, io.EOF
 195         default:
 196                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 197         }
 198 }
 199
 200 func (c *serviceClient) IPMrouteAddDel(ctx context.Context, in *IPMrouteAddDel) (*IPMrouteAddDelReply, error) {
 201         out := new(IPMrouteAddDelReply)
 202         err := c.conn.Invoke(ctx, in, out)
 203         if err != nil {
 204                 return nil, err
 205         }
 206         return out, nil
 207 }
 208
 209 func (c *serviceClient) IPMrouteDump(ctx context.Context, in *IPMrouteDump) (RPCService_IPMrouteDumpClient, error) {
 210         stream, err := c.conn.NewStream(ctx)
 211         if err != nil {
 212                 return nil, err
 213         }
 214         x := &serviceClient_IPMrouteDumpClient{stream}
 215         if err := x.Stream.SendMsg(in); err != nil {
 216                 return nil, err
 217         }
 218         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 219                 return nil, err
 220         }
 221         return x, nil
 222 }
 223
 224 type RPCService_IPMrouteDumpClient interface {
 225         Recv() (*IPMrouteDetails, error)
 226         api.Stream
 227 }
 228
 229 type serviceClient_IPMrouteDumpClient struct {
 230         api.Stream
 231 }
 232
 233 func (c *serviceClient_IPMrouteDumpClient) Recv() (*IPMrouteDetails, error) {
 234         msg, err := c.Stream.RecvMsg()
 235         if err != nil {
 236                 return nil, err
 237         }
 238         switch m := msg.(type) {
 239         case *IPMrouteDetails:
 240                 return m, nil
 241         case *vpe.ControlPingReply:
 242                 return nil, io.EOF
 243         default:
 244                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 245         }
 246 }
 247
 248 func (c *serviceClient) IPMtableDump(ctx context.Context, in *IPMtableDump) (RPCService_IPMtableDumpClient, error) {
 249         stream, err := c.conn.NewStream(ctx)
 250         if err != nil {
 251                 return nil, err
 252         }
 253         x := &serviceClient_IPMtableDumpClient{stream}
 254         if err := x.Stream.SendMsg(in); err != nil {
 255                 return nil, err
 256         }
 257         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 258                 return nil, err
 259         }
 260         return x, nil
 261 }
 262
 263 type RPCService_IPMtableDumpClient interface {
 264         Recv() (*IPMtableDetails, error)
 265         api.Stream
 266 }
 267
 268 type serviceClient_IPMtableDumpClient struct {
 269         api.Stream
 270 }
 271
 272 func (c *serviceClient_IPMtableDumpClient) Recv() (*IPMtableDetails, error) {
 273         msg, err := c.Stream.RecvMsg()
 274         if err != nil {
 275                 return nil, err
 276         }
 277         switch m := msg.(type) {
 278         case *IPMtableDetails:
 279                 return m, nil
 280         case *vpe.ControlPingReply:
 281                 return nil, io.EOF
 282         default:
 283                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 284         }
 285 }
 286
 287 func (c *serviceClient) IPPuntPolice(ctx context.Context, in *IPPuntPolice) (*IPPuntPoliceReply, error) {
 288         out := new(IPPuntPoliceReply)
 289         err := c.conn.Invoke(ctx, in, out)
 290         if err != nil {
 291                 return nil, err
 292         }
 293         return out, nil
 294 }
 295
 296 func (c *serviceClient) IPPuntRedirect(ctx context.Context, in *IPPuntRedirect) (*IPPuntRedirectReply, error) {
 297         out := new(IPPuntRedirectReply)
 298         err := c.conn.Invoke(ctx, in, out)
 299         if err != nil {
 300                 return nil, err
 301         }
 302         return out, nil
 303 }
 304
 305 func (c *serviceClient) IPPuntRedirectDump(ctx context.Context, in *IPPuntRedirectDump) (RPCService_IPPuntRedirectDumpClient, error) {
 306         stream, err := c.conn.NewStream(ctx)
 307         if err != nil {
 308                 return nil, err
 309         }
 310         x := &serviceClient_IPPuntRedirectDumpClient{stream}
 311         if err := x.Stream.SendMsg(in); err != nil {
 312                 return nil, err
 313         }
 314         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 315                 return nil, err
 316         }
 317         return x, nil
 318 }
 319
 320 type RPCService_IPPuntRedirectDumpClient interface {
 321         Recv() (*IPPuntRedirectDetails, error)
 322         api.Stream
 323 }
 324
 325 type serviceClient_IPPuntRedirectDumpClient struct {
 326         api.Stream
 327 }
 328
 329 func (c *serviceClient_IPPuntRedirectDumpClient) Recv() (*IPPuntRedirectDetails, error) {
 330         msg, err := c.Stream.RecvMsg()
 331         if err != nil {
 332                 return nil, err
 333         }
 334         switch m := msg.(type) {
 335         case *IPPuntRedirectDetails:
 336                 return m, nil
 337         case *vpe.ControlPingReply:
 338                 return nil, io.EOF
 339         default:
 340                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 341         }
 342 }
 343
 344 func (c *serviceClient) IPReassemblyEnableDisable(ctx context.Context, in *IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error) {
 345         out := new(IPReassemblyEnableDisableReply)
 346         err := c.conn.Invoke(ctx, in, out)
 347         if err != nil {
 348                 return nil, err
 349         }
 350         return out, nil
 351 }
 352
 353 func (c *serviceClient) IPReassemblyGet(ctx context.Context, in *IPReassemblyGet) (*IPReassemblyGetReply, error) {
 354         out := new(IPReassemblyGetReply)
 355         err := c.conn.Invoke(ctx, in, out)
 356         if err != nil {
 357                 return nil, err
 358         }
 359         return out, nil
 360 }
 361
 362 func (c *serviceClient) IPReassemblySet(ctx context.Context, in *IPReassemblySet) (*IPReassemblySetReply, error) {
 363         out := new(IPReassemblySetReply)
 364         err := c.conn.Invoke(ctx, in, out)
 365         if err != nil {
 366                 return nil, err
 367         }
 368         return out, nil
 369 }
 370
 371 func (c *serviceClient) IPRouteAddDel(ctx context.Context, in *IPRouteAddDel) (*IPRouteAddDelReply, error) {
 372         out := new(IPRouteAddDelReply)
 373         err := c.conn.Invoke(ctx, in, out)
 374         if err != nil {
 375                 return nil, err
 376         }
 377         return out, nil
 378 }
 379
 380 func (c *serviceClient) IPRouteDump(ctx context.Context, in *IPRouteDump) (RPCService_IPRouteDumpClient, error) {
 381         stream, err := c.conn.NewStream(ctx)
 382         if err != nil {
 383                 return nil, err
 384         }
 385         x := &serviceClient_IPRouteDumpClient{stream}
 386         if err := x.Stream.SendMsg(in); err != nil {
 387                 return nil, err
 388         }
 389         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 390                 return nil, err
 391         }
 392         return x, nil
 393 }
 394
 395 type RPCService_IPRouteDumpClient interface {
 396         Recv() (*IPRouteDetails, error)
 397         api.Stream
 398 }
 399
 400 type serviceClient_IPRouteDumpClient struct {
 401         api.Stream
 402 }
 403
 404 func (c *serviceClient_IPRouteDumpClient) Recv() (*IPRouteDetails, error) {
 405         msg, err := c.Stream.RecvMsg()
 406         if err != nil {
 407                 return nil, err
 408         }
 409         switch m := msg.(type) {
 410         case *IPRouteDetails:
 411                 return m, nil
 412         case *vpe.ControlPingReply:
 413                 return nil, io.EOF
 414         default:
 415                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 416         }
 417 }
 418
 419 func (c *serviceClient) IPRouteLookup(ctx context.Context, in *IPRouteLookup) (*IPRouteLookupReply, error) {
 420         out := new(IPRouteLookupReply)
 421         err := c.conn.Invoke(ctx, in, out)
 422         if err != nil {
 423                 return nil, err
 424         }
 425         return out, nil
 426 }
 427
 428 func (c *serviceClient) IPSourceAndPortRangeCheckAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error) {
 429         out := new(IPSourceAndPortRangeCheckAddDelReply)
 430         err := c.conn.Invoke(ctx, in, out)
 431         if err != nil {
 432                 return nil, err
 433         }
 434         return out, nil
 435 }
 436
 437 func (c *serviceClient) IPSourceAndPortRangeCheckInterfaceAddDel(ctx context.Context, in *IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error) {
 438         out := new(IPSourceAndPortRangeCheckInterfaceAddDelReply)
 439         err := c.conn.Invoke(ctx, in, out)
 440         if err != nil {
 441                 return nil, err
 442         }
 443         return out, nil
 444 }
 445
 446 func (c *serviceClient) IPTableAddDel(ctx context.Context, in *IPTableAddDel) (*IPTableAddDelReply, error) {
 447         out := new(IPTableAddDelReply)
 448         err := c.conn.Invoke(ctx, in, out)
 449         if err != nil {
 450                 return nil, err
 451         }
 452         return out, nil
 453 }
 454
 455 func (c *serviceClient) IPTableDump(ctx context.Context, in *IPTableDump) (RPCService_IPTableDumpClient, error) {
 456         stream, err := c.conn.NewStream(ctx)
 457         if err != nil {
 458                 return nil, err
 459         }
 460         x := &serviceClient_IPTableDumpClient{stream}
 461         if err := x.Stream.SendMsg(in); err != nil {
 462                 return nil, err
 463         }
 464         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 465                 return nil, err
 466         }
 467         return x, nil
 468 }
 469
 470 type RPCService_IPTableDumpClient interface {
 471         Recv() (*IPTableDetails, error)
 472         api.Stream
 473 }
 474
 475 type serviceClient_IPTableDumpClient struct {
 476         api.Stream
 477 }
 478
 479 func (c *serviceClient_IPTableDumpClient) Recv() (*IPTableDetails, error) {
 480         msg, err := c.Stream.RecvMsg()
 481         if err != nil {
 482                 return nil, err
 483         }
 484         switch m := msg.(type) {
 485         case *IPTableDetails:
 486                 return m, nil
 487         case *vpe.ControlPingReply:
 488                 return nil, io.EOF
 489         default:
 490                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 491         }
 492 }
 493
 494 func (c *serviceClient) IPTableFlush(ctx context.Context, in *IPTableFlush) (*IPTableFlushReply, error) {
 495         out := new(IPTableFlushReply)
 496         err := c.conn.Invoke(ctx, in, out)
 497         if err != nil {
 498                 return nil, err
 499         }
 500         return out, nil
 501 }
 502
 503 func (c *serviceClient) IPTableReplaceBegin(ctx context.Context, in *IPTableReplaceBegin) (*IPTableReplaceBeginReply, error) {
 504         out := new(IPTableReplaceBeginReply)
 505         err := c.conn.Invoke(ctx, in, out)
 506         if err != nil {
 507                 return nil, err
 508         }
 509         return out, nil
 510 }
 511
 512 func (c *serviceClient) IPTableReplaceEnd(ctx context.Context, in *IPTableReplaceEnd) (*IPTableReplaceEndReply, error) {
 513         out := new(IPTableReplaceEndReply)
 514         err := c.conn.Invoke(ctx, in, out)
 515         if err != nil {
 516                 return nil, err
 517         }
 518         return out, nil
 519 }
 520
 521 func (c *serviceClient) IPUnnumberedDump(ctx context.Context, in *IPUnnumberedDump) (RPCService_IPUnnumberedDumpClient, error) {
 522         stream, err := c.conn.NewStream(ctx)
 523         if err != nil {
 524                 return nil, err
 525         }
 526         x := &serviceClient_IPUnnumberedDumpClient{stream}
 527         if err := x.Stream.SendMsg(in); err != nil {
 528                 return nil, err
 529         }
 530         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 531                 return nil, err
 532         }
 533         return x, nil
 534 }
 535
 536 type RPCService_IPUnnumberedDumpClient interface {
 537         Recv() (*IPUnnumberedDetails, error)
 538         api.Stream
 539 }
 540
 541 type serviceClient_IPUnnumberedDumpClient struct {
 542         api.Stream
 543 }
 544
 545 func (c *serviceClient_IPUnnumberedDumpClient) Recv() (*IPUnnumberedDetails, error) {
 546         msg, err := c.Stream.RecvMsg()
 547         if err != nil {
 548                 return nil, err
 549         }
 550         switch m := msg.(type) {
 551         case *IPUnnumberedDetails:
 552                 return m, nil
 553         case *vpe.ControlPingReply:
 554                 return nil, io.EOF
 555         default:
 556                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 557         }
 558 }
 559
 560 func (c *serviceClient) MfibSignalDump(ctx context.Context, in *MfibSignalDump) (RPCService_MfibSignalDumpClient, error) {
 561         stream, err := c.conn.NewStream(ctx)
 562         if err != nil {
 563                 return nil, err
 564         }
 565         x := &serviceClient_MfibSignalDumpClient{stream}
 566         if err := x.Stream.SendMsg(in); err != nil {
 567                 return nil, err
 568         }
 569         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 570                 return nil, err
 571         }
 572         return x, nil
 573 }
 574
 575 type RPCService_MfibSignalDumpClient interface {
 576         Recv() (*MfibSignalDetails, error)
 577         api.Stream
 578 }
 579
 580 type serviceClient_MfibSignalDumpClient struct {
 581         api.Stream
 582 }
 583
 584 func (c *serviceClient_MfibSignalDumpClient) Recv() (*MfibSignalDetails, error) {
 585         msg, err := c.Stream.RecvMsg()
 586         if err != nil {
 587                 return nil, err
 588         }
 589         switch m := msg.(type) {
 590         case *MfibSignalDetails:
 591                 return m, nil
 592         case *vpe.ControlPingReply:
 593                 return nil, io.EOF
 594         default:
 595                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 596         }
 597 }
 598
 599 func (c *serviceClient) SetIPFlowHash(ctx context.Context, in *SetIPFlowHash) (*SetIPFlowHashReply, error) {
 600         out := new(SetIPFlowHashReply)
 601         err := c.conn.Invoke(ctx, in, out)
 602         if err != nil {
 603                 return nil, err
 604         }
 605         return out, nil
 606 }
 607
 608 func (c *serviceClient) SwInterfaceIP6EnableDisable(ctx context.Context, in *SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error) {
 609         out := new(SwInterfaceIP6EnableDisableReply)
 610         err := c.conn.Invoke(ctx, in, out)
 611         if err != nil {
 612                 return nil, err
 613         }
 614         return out, nil
 615 }
 616
 617 func (c *serviceClient) SwInterfaceIP6SetLinkLocalAddress(ctx context.Context, in *SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error) {
 618         out := new(SwInterfaceIP6SetLinkLocalAddressReply)
 619         err := c.conn.Invoke(ctx, in, out)
 620         if err != nil {
 621                 return nil, err
 622         }
 623         return out, nil
 624 }