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