internal/testbinapi/binapi2001/nat/nat_rpc.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2
   3 package nat
   4
   5 import (
   6         "context"
   7         "fmt"
   8         api "git.fd.io/govpp.git/api"
   9         vpe "git.fd.io/govpp.git/internal/testbinapi/binapi2001/vpe"
  10         "io"
  11 )
  12
  13 // RPCService defines RPC service  nat.
  14 type RPCService interface {
  15         DsliteAddDelPoolAddrRange(ctx context.Context, in *DsliteAddDelPoolAddrRange) (*DsliteAddDelPoolAddrRangeReply, error)
  16         DsliteAddressDump(ctx context.Context, in *DsliteAddressDump) (RPCService_DsliteAddressDumpClient, error)
  17         DsliteGetAftrAddr(ctx context.Context, in *DsliteGetAftrAddr) (*DsliteGetAftrAddrReply, error)
  18         DsliteGetB4Addr(ctx context.Context, in *DsliteGetB4Addr) (*DsliteGetB4AddrReply, error)
  19         DsliteSetAftrAddr(ctx context.Context, in *DsliteSetAftrAddr) (*DsliteSetAftrAddrReply, error)
  20         DsliteSetB4Addr(ctx context.Context, in *DsliteSetB4Addr) (*DsliteSetB4AddrReply, error)
  21         Nat44AddDelAddressRange(ctx context.Context, in *Nat44AddDelAddressRange) (*Nat44AddDelAddressRangeReply, error)
  22         Nat44AddDelIdentityMapping(ctx context.Context, in *Nat44AddDelIdentityMapping) (*Nat44AddDelIdentityMappingReply, error)
  23         Nat44AddDelInterfaceAddr(ctx context.Context, in *Nat44AddDelInterfaceAddr) (*Nat44AddDelInterfaceAddrReply, error)
  24         Nat44AddDelLbStaticMapping(ctx context.Context, in *Nat44AddDelLbStaticMapping) (*Nat44AddDelLbStaticMappingReply, error)
  25         Nat44AddDelStaticMapping(ctx context.Context, in *Nat44AddDelStaticMapping) (*Nat44AddDelStaticMappingReply, error)
  26         Nat44AddressDump(ctx context.Context, in *Nat44AddressDump) (RPCService_Nat44AddressDumpClient, error)
  27         Nat44DelSession(ctx context.Context, in *Nat44DelSession) (*Nat44DelSessionReply, error)
  28         Nat44ForwardingEnableDisable(ctx context.Context, in *Nat44ForwardingEnableDisable) (*Nat44ForwardingEnableDisableReply, error)
  29         Nat44ForwardingIsEnabled(ctx context.Context, in *Nat44ForwardingIsEnabled) (*Nat44ForwardingIsEnabledReply, error)
  30         Nat44IdentityMappingDump(ctx context.Context, in *Nat44IdentityMappingDump) (RPCService_Nat44IdentityMappingDumpClient, error)
  31         Nat44InterfaceAddDelFeature(ctx context.Context, in *Nat44InterfaceAddDelFeature) (*Nat44InterfaceAddDelFeatureReply, error)
  32         Nat44InterfaceAddDelOutputFeature(ctx context.Context, in *Nat44InterfaceAddDelOutputFeature) (*Nat44InterfaceAddDelOutputFeatureReply, error)
  33         Nat44InterfaceAddrDump(ctx context.Context, in *Nat44InterfaceAddrDump) (RPCService_Nat44InterfaceAddrDumpClient, error)
  34         Nat44InterfaceDump(ctx context.Context, in *Nat44InterfaceDump) (RPCService_Nat44InterfaceDumpClient, error)
  35         Nat44InterfaceOutputFeatureDump(ctx context.Context, in *Nat44InterfaceOutputFeatureDump) (RPCService_Nat44InterfaceOutputFeatureDumpClient, error)
  36         Nat44LbStaticMappingAddDelLocal(ctx context.Context, in *Nat44LbStaticMappingAddDelLocal) (*Nat44LbStaticMappingAddDelLocalReply, error)
  37         Nat44LbStaticMappingDump(ctx context.Context, in *Nat44LbStaticMappingDump) (RPCService_Nat44LbStaticMappingDumpClient, error)
  38         Nat44StaticMappingDump(ctx context.Context, in *Nat44StaticMappingDump) (RPCService_Nat44StaticMappingDumpClient, error)
  39         Nat44UserDump(ctx context.Context, in *Nat44UserDump) (RPCService_Nat44UserDumpClient, error)
  40         Nat44UserSessionDump(ctx context.Context, in *Nat44UserSessionDump) (RPCService_Nat44UserSessionDumpClient, error)
  41         Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error)
  42         Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error)
  43         Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error)
  44         Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error)
  45         Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error)
  46         Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error)
  47         Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error)
  48         Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error)
  49         Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error)
  50         Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error)
  51         Nat66AddDelInterface(ctx context.Context, in *Nat66AddDelInterface) (*Nat66AddDelInterfaceReply, error)
  52         Nat66AddDelStaticMapping(ctx context.Context, in *Nat66AddDelStaticMapping) (*Nat66AddDelStaticMappingReply, error)
  53         Nat66InterfaceDump(ctx context.Context, in *Nat66InterfaceDump) (RPCService_Nat66InterfaceDumpClient, error)
  54         Nat66StaticMappingDump(ctx context.Context, in *Nat66StaticMappingDump) (RPCService_Nat66StaticMappingDumpClient, error)
  55         NatControlPing(ctx context.Context, in *NatControlPing) (*NatControlPingReply, error)
  56         NatDetAddDelMap(ctx context.Context, in *NatDetAddDelMap) (*NatDetAddDelMapReply, error)
  57         NatDetCloseSessionIn(ctx context.Context, in *NatDetCloseSessionIn) (*NatDetCloseSessionInReply, error)
  58         NatDetCloseSessionOut(ctx context.Context, in *NatDetCloseSessionOut) (*NatDetCloseSessionOutReply, error)
  59         NatDetForward(ctx context.Context, in *NatDetForward) (*NatDetForwardReply, error)
  60         NatDetMapDump(ctx context.Context, in *NatDetMapDump) (RPCService_NatDetMapDumpClient, error)
  61         NatDetReverse(ctx context.Context, in *NatDetReverse) (*NatDetReverseReply, error)
  62         NatDetSessionDump(ctx context.Context, in *NatDetSessionDump) (RPCService_NatDetSessionDumpClient, error)
  63         NatGetAddrAndPortAllocAlg(ctx context.Context, in *NatGetAddrAndPortAllocAlg) (*NatGetAddrAndPortAllocAlgReply, error)
  64         NatGetMssClamping(ctx context.Context, in *NatGetMssClamping) (*NatGetMssClampingReply, error)
  65         NatGetTimeouts(ctx context.Context, in *NatGetTimeouts) (*NatGetTimeoutsReply, error)
  66         NatHaFlush(ctx context.Context, in *NatHaFlush) (*NatHaFlushReply, error)
  67         NatHaGetFailover(ctx context.Context, in *NatHaGetFailover) (*NatHaGetFailoverReply, error)
  68         NatHaGetListener(ctx context.Context, in *NatHaGetListener) (*NatHaGetListenerReply, error)
  69         NatHaResync(ctx context.Context, in *NatHaResync) (*NatHaResyncReply, error)
  70         NatHaSetFailover(ctx context.Context, in *NatHaSetFailover) (*NatHaSetFailoverReply, error)
  71         NatHaSetListener(ctx context.Context, in *NatHaSetListener) (*NatHaSetListenerReply, error)
  72         NatIpfixEnableDisable(ctx context.Context, in *NatIpfixEnableDisable) (*NatIpfixEnableDisableReply, error)
  73         NatSetAddrAndPortAllocAlg(ctx context.Context, in *NatSetAddrAndPortAllocAlg) (*NatSetAddrAndPortAllocAlgReply, error)
  74         NatSetLogLevel(ctx context.Context, in *NatSetLogLevel) (*NatSetLogLevelReply, error)
  75         NatSetMssClamping(ctx context.Context, in *NatSetMssClamping) (*NatSetMssClampingReply, error)
  76         NatSetTimeouts(ctx context.Context, in *NatSetTimeouts) (*NatSetTimeoutsReply, error)
  77         NatSetWorkers(ctx context.Context, in *NatSetWorkers) (*NatSetWorkersReply, error)
  78         NatShowConfig(ctx context.Context, in *NatShowConfig) (*NatShowConfigReply, error)
  79         NatWorkerDump(ctx context.Context, in *NatWorkerDump) (RPCService_NatWorkerDumpClient, error)
  80 }
  81
  82 type serviceClient struct {
  83         conn api.Connection
  84 }
  85
  86 func NewServiceClient(conn api.Connection) RPCService {
  87         return &serviceClient{conn}
  88 }
  89
  90 func (c *serviceClient) DsliteAddDelPoolAddrRange(ctx context.Context, in *DsliteAddDelPoolAddrRange) (*DsliteAddDelPoolAddrRangeReply, error) {
  91         out := new(DsliteAddDelPoolAddrRangeReply)
  92         err := c.conn.Invoke(ctx, in, out)
  93         if err != nil {
  94                 return nil, err
  95         }
  96         return out, nil
  97 }
  98
  99 func (c *serviceClient) DsliteAddressDump(ctx context.Context, in *DsliteAddressDump) (RPCService_DsliteAddressDumpClient, error) {
 100         stream, err := c.conn.NewStream(ctx)
 101         if err != nil {
 102                 return nil, err
 103         }
 104         x := &serviceClient_DsliteAddressDumpClient{stream}
 105         if err := x.Stream.SendMsg(in); err != nil {
 106                 return nil, err
 107         }
 108         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 109                 return nil, err
 110         }
 111         return x, nil
 112 }
 113
 114 type RPCService_DsliteAddressDumpClient interface {
 115         Recv() (*DsliteAddressDetails, error)
 116         api.Stream
 117 }
 118
 119 type serviceClient_DsliteAddressDumpClient struct {
 120         api.Stream
 121 }
 122
 123 func (c *serviceClient_DsliteAddressDumpClient) Recv() (*DsliteAddressDetails, error) {
 124         msg, err := c.Stream.RecvMsg()
 125         if err != nil {
 126                 return nil, err
 127         }
 128         switch m := msg.(type) {
 129         case *DsliteAddressDetails:
 130                 return m, nil
 131         case *vpe.ControlPingReply:
 132                 return nil, io.EOF
 133         default:
 134                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 135         }
 136 }
 137
 138 func (c *serviceClient) DsliteGetAftrAddr(ctx context.Context, in *DsliteGetAftrAddr) (*DsliteGetAftrAddrReply, error) {
 139         out := new(DsliteGetAftrAddrReply)
 140         err := c.conn.Invoke(ctx, in, out)
 141         if err != nil {
 142                 return nil, err
 143         }
 144         return out, nil
 145 }
 146
 147 func (c *serviceClient) DsliteGetB4Addr(ctx context.Context, in *DsliteGetB4Addr) (*DsliteGetB4AddrReply, error) {
 148         out := new(DsliteGetB4AddrReply)
 149         err := c.conn.Invoke(ctx, in, out)
 150         if err != nil {
 151                 return nil, err
 152         }
 153         return out, nil
 154 }
 155
 156 func (c *serviceClient) DsliteSetAftrAddr(ctx context.Context, in *DsliteSetAftrAddr) (*DsliteSetAftrAddrReply, error) {
 157         out := new(DsliteSetAftrAddrReply)
 158         err := c.conn.Invoke(ctx, in, out)
 159         if err != nil {
 160                 return nil, err
 161         }
 162         return out, nil
 163 }
 164
 165 func (c *serviceClient) DsliteSetB4Addr(ctx context.Context, in *DsliteSetB4Addr) (*DsliteSetB4AddrReply, error) {
 166         out := new(DsliteSetB4AddrReply)
 167         err := c.conn.Invoke(ctx, in, out)
 168         if err != nil {
 169                 return nil, err
 170         }
 171         return out, nil
 172 }
 173
 174 func (c *serviceClient) Nat44AddDelAddressRange(ctx context.Context, in *Nat44AddDelAddressRange) (*Nat44AddDelAddressRangeReply, error) {
 175         out := new(Nat44AddDelAddressRangeReply)
 176         err := c.conn.Invoke(ctx, in, out)
 177         if err != nil {
 178                 return nil, err
 179         }
 180         return out, nil
 181 }
 182
 183 func (c *serviceClient) Nat44AddDelIdentityMapping(ctx context.Context, in *Nat44AddDelIdentityMapping) (*Nat44AddDelIdentityMappingReply, error) {
 184         out := new(Nat44AddDelIdentityMappingReply)
 185         err := c.conn.Invoke(ctx, in, out)
 186         if err != nil {
 187                 return nil, err
 188         }
 189         return out, nil
 190 }
 191
 192 func (c *serviceClient) Nat44AddDelInterfaceAddr(ctx context.Context, in *Nat44AddDelInterfaceAddr) (*Nat44AddDelInterfaceAddrReply, error) {
 193         out := new(Nat44AddDelInterfaceAddrReply)
 194         err := c.conn.Invoke(ctx, in, out)
 195         if err != nil {
 196                 return nil, err
 197         }
 198         return out, nil
 199 }
 200
 201 func (c *serviceClient) Nat44AddDelLbStaticMapping(ctx context.Context, in *Nat44AddDelLbStaticMapping) (*Nat44AddDelLbStaticMappingReply, error) {
 202         out := new(Nat44AddDelLbStaticMappingReply)
 203         err := c.conn.Invoke(ctx, in, out)
 204         if err != nil {
 205                 return nil, err
 206         }
 207         return out, nil
 208 }
 209
 210 func (c *serviceClient) Nat44AddDelStaticMapping(ctx context.Context, in *Nat44AddDelStaticMapping) (*Nat44AddDelStaticMappingReply, error) {
 211         out := new(Nat44AddDelStaticMappingReply)
 212         err := c.conn.Invoke(ctx, in, out)
 213         if err != nil {
 214                 return nil, err
 215         }
 216         return out, nil
 217 }
 218
 219 func (c *serviceClient) Nat44AddressDump(ctx context.Context, in *Nat44AddressDump) (RPCService_Nat44AddressDumpClient, error) {
 220         stream, err := c.conn.NewStream(ctx)
 221         if err != nil {
 222                 return nil, err
 223         }
 224         x := &serviceClient_Nat44AddressDumpClient{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_Nat44AddressDumpClient interface {
 235         Recv() (*Nat44AddressDetails, error)
 236         api.Stream
 237 }
 238
 239 type serviceClient_Nat44AddressDumpClient struct {
 240         api.Stream
 241 }
 242
 243 func (c *serviceClient_Nat44AddressDumpClient) Recv() (*Nat44AddressDetails, error) {
 244         msg, err := c.Stream.RecvMsg()
 245         if err != nil {
 246                 return nil, err
 247         }
 248         switch m := msg.(type) {
 249         case *Nat44AddressDetails:
 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) Nat44DelSession(ctx context.Context, in *Nat44DelSession) (*Nat44DelSessionReply, error) {
 259         out := new(Nat44DelSessionReply)
 260         err := c.conn.Invoke(ctx, in, out)
 261         if err != nil {
 262                 return nil, err
 263         }
 264         return out, nil
 265 }
 266
 267 func (c *serviceClient) Nat44ForwardingEnableDisable(ctx context.Context, in *Nat44ForwardingEnableDisable) (*Nat44ForwardingEnableDisableReply, error) {
 268         out := new(Nat44ForwardingEnableDisableReply)
 269         err := c.conn.Invoke(ctx, in, out)
 270         if err != nil {
 271                 return nil, err
 272         }
 273         return out, nil
 274 }
 275
 276 func (c *serviceClient) Nat44ForwardingIsEnabled(ctx context.Context, in *Nat44ForwardingIsEnabled) (*Nat44ForwardingIsEnabledReply, error) {
 277         out := new(Nat44ForwardingIsEnabledReply)
 278         err := c.conn.Invoke(ctx, in, out)
 279         if err != nil {
 280                 return nil, err
 281         }
 282         return out, nil
 283 }
 284
 285 func (c *serviceClient) Nat44IdentityMappingDump(ctx context.Context, in *Nat44IdentityMappingDump) (RPCService_Nat44IdentityMappingDumpClient, error) {
 286         stream, err := c.conn.NewStream(ctx)
 287         if err != nil {
 288                 return nil, err
 289         }
 290         x := &serviceClient_Nat44IdentityMappingDumpClient{stream}
 291         if err := x.Stream.SendMsg(in); err != nil {
 292                 return nil, err
 293         }
 294         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 295                 return nil, err
 296         }
 297         return x, nil
 298 }
 299
 300 type RPCService_Nat44IdentityMappingDumpClient interface {
 301         Recv() (*Nat44IdentityMappingDetails, error)
 302         api.Stream
 303 }
 304
 305 type serviceClient_Nat44IdentityMappingDumpClient struct {
 306         api.Stream
 307 }
 308
 309 func (c *serviceClient_Nat44IdentityMappingDumpClient) Recv() (*Nat44IdentityMappingDetails, error) {
 310         msg, err := c.Stream.RecvMsg()
 311         if err != nil {
 312                 return nil, err
 313         }
 314         switch m := msg.(type) {
 315         case *Nat44IdentityMappingDetails:
 316                 return m, nil
 317         case *vpe.ControlPingReply:
 318                 return nil, io.EOF
 319         default:
 320                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 321         }
 322 }
 323
 324 func (c *serviceClient) Nat44InterfaceAddDelFeature(ctx context.Context, in *Nat44InterfaceAddDelFeature) (*Nat44InterfaceAddDelFeatureReply, error) {
 325         out := new(Nat44InterfaceAddDelFeatureReply)
 326         err := c.conn.Invoke(ctx, in, out)
 327         if err != nil {
 328                 return nil, err
 329         }
 330         return out, nil
 331 }
 332
 333 func (c *serviceClient) Nat44InterfaceAddDelOutputFeature(ctx context.Context, in *Nat44InterfaceAddDelOutputFeature) (*Nat44InterfaceAddDelOutputFeatureReply, error) {
 334         out := new(Nat44InterfaceAddDelOutputFeatureReply)
 335         err := c.conn.Invoke(ctx, in, out)
 336         if err != nil {
 337                 return nil, err
 338         }
 339         return out, nil
 340 }
 341
 342 func (c *serviceClient) Nat44InterfaceAddrDump(ctx context.Context, in *Nat44InterfaceAddrDump) (RPCService_Nat44InterfaceAddrDumpClient, error) {
 343         stream, err := c.conn.NewStream(ctx)
 344         if err != nil {
 345                 return nil, err
 346         }
 347         x := &serviceClient_Nat44InterfaceAddrDumpClient{stream}
 348         if err := x.Stream.SendMsg(in); err != nil {
 349                 return nil, err
 350         }
 351         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 352                 return nil, err
 353         }
 354         return x, nil
 355 }
 356
 357 type RPCService_Nat44InterfaceAddrDumpClient interface {
 358         Recv() (*Nat44InterfaceAddrDetails, error)
 359         api.Stream
 360 }
 361
 362 type serviceClient_Nat44InterfaceAddrDumpClient struct {
 363         api.Stream
 364 }
 365
 366 func (c *serviceClient_Nat44InterfaceAddrDumpClient) Recv() (*Nat44InterfaceAddrDetails, error) {
 367         msg, err := c.Stream.RecvMsg()
 368         if err != nil {
 369                 return nil, err
 370         }
 371         switch m := msg.(type) {
 372         case *Nat44InterfaceAddrDetails:
 373                 return m, nil
 374         case *vpe.ControlPingReply:
 375                 return nil, io.EOF
 376         default:
 377                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 378         }
 379 }
 380
 381 func (c *serviceClient) Nat44InterfaceDump(ctx context.Context, in *Nat44InterfaceDump) (RPCService_Nat44InterfaceDumpClient, error) {
 382         stream, err := c.conn.NewStream(ctx)
 383         if err != nil {
 384                 return nil, err
 385         }
 386         x := &serviceClient_Nat44InterfaceDumpClient{stream}
 387         if err := x.Stream.SendMsg(in); err != nil {
 388                 return nil, err
 389         }
 390         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 391                 return nil, err
 392         }
 393         return x, nil
 394 }
 395
 396 type RPCService_Nat44InterfaceDumpClient interface {
 397         Recv() (*Nat44InterfaceDetails, error)
 398         api.Stream
 399 }
 400
 401 type serviceClient_Nat44InterfaceDumpClient struct {
 402         api.Stream
 403 }
 404
 405 func (c *serviceClient_Nat44InterfaceDumpClient) Recv() (*Nat44InterfaceDetails, error) {
 406         msg, err := c.Stream.RecvMsg()
 407         if err != nil {
 408                 return nil, err
 409         }
 410         switch m := msg.(type) {
 411         case *Nat44InterfaceDetails:
 412                 return m, nil
 413         case *vpe.ControlPingReply:
 414                 return nil, io.EOF
 415         default:
 416                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 417         }
 418 }
 419
 420 func (c *serviceClient) Nat44InterfaceOutputFeatureDump(ctx context.Context, in *Nat44InterfaceOutputFeatureDump) (RPCService_Nat44InterfaceOutputFeatureDumpClient, error) {
 421         stream, err := c.conn.NewStream(ctx)
 422         if err != nil {
 423                 return nil, err
 424         }
 425         x := &serviceClient_Nat44InterfaceOutputFeatureDumpClient{stream}
 426         if err := x.Stream.SendMsg(in); err != nil {
 427                 return nil, err
 428         }
 429         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 430                 return nil, err
 431         }
 432         return x, nil
 433 }
 434
 435 type RPCService_Nat44InterfaceOutputFeatureDumpClient interface {
 436         Recv() (*Nat44InterfaceOutputFeatureDetails, error)
 437         api.Stream
 438 }
 439
 440 type serviceClient_Nat44InterfaceOutputFeatureDumpClient struct {
 441         api.Stream
 442 }
 443
 444 func (c *serviceClient_Nat44InterfaceOutputFeatureDumpClient) Recv() (*Nat44InterfaceOutputFeatureDetails, error) {
 445         msg, err := c.Stream.RecvMsg()
 446         if err != nil {
 447                 return nil, err
 448         }
 449         switch m := msg.(type) {
 450         case *Nat44InterfaceOutputFeatureDetails:
 451                 return m, nil
 452         case *vpe.ControlPingReply:
 453                 return nil, io.EOF
 454         default:
 455                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 456         }
 457 }
 458
 459 func (c *serviceClient) Nat44LbStaticMappingAddDelLocal(ctx context.Context, in *Nat44LbStaticMappingAddDelLocal) (*Nat44LbStaticMappingAddDelLocalReply, error) {
 460         out := new(Nat44LbStaticMappingAddDelLocalReply)
 461         err := c.conn.Invoke(ctx, in, out)
 462         if err != nil {
 463                 return nil, err
 464         }
 465         return out, nil
 466 }
 467
 468 func (c *serviceClient) Nat44LbStaticMappingDump(ctx context.Context, in *Nat44LbStaticMappingDump) (RPCService_Nat44LbStaticMappingDumpClient, error) {
 469         stream, err := c.conn.NewStream(ctx)
 470         if err != nil {
 471                 return nil, err
 472         }
 473         x := &serviceClient_Nat44LbStaticMappingDumpClient{stream}
 474         if err := x.Stream.SendMsg(in); err != nil {
 475                 return nil, err
 476         }
 477         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 478                 return nil, err
 479         }
 480         return x, nil
 481 }
 482
 483 type RPCService_Nat44LbStaticMappingDumpClient interface {
 484         Recv() (*Nat44LbStaticMappingDetails, error)
 485         api.Stream
 486 }
 487
 488 type serviceClient_Nat44LbStaticMappingDumpClient struct {
 489         api.Stream
 490 }
 491
 492 func (c *serviceClient_Nat44LbStaticMappingDumpClient) Recv() (*Nat44LbStaticMappingDetails, error) {
 493         msg, err := c.Stream.RecvMsg()
 494         if err != nil {
 495                 return nil, err
 496         }
 497         switch m := msg.(type) {
 498         case *Nat44LbStaticMappingDetails:
 499                 return m, nil
 500         case *vpe.ControlPingReply:
 501                 return nil, io.EOF
 502         default:
 503                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 504         }
 505 }
 506
 507 func (c *serviceClient) Nat44StaticMappingDump(ctx context.Context, in *Nat44StaticMappingDump) (RPCService_Nat44StaticMappingDumpClient, error) {
 508         stream, err := c.conn.NewStream(ctx)
 509         if err != nil {
 510                 return nil, err
 511         }
 512         x := &serviceClient_Nat44StaticMappingDumpClient{stream}
 513         if err := x.Stream.SendMsg(in); err != nil {
 514                 return nil, err
 515         }
 516         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 517                 return nil, err
 518         }
 519         return x, nil
 520 }
 521
 522 type RPCService_Nat44StaticMappingDumpClient interface {
 523         Recv() (*Nat44StaticMappingDetails, error)
 524         api.Stream
 525 }
 526
 527 type serviceClient_Nat44StaticMappingDumpClient struct {
 528         api.Stream
 529 }
 530
 531 func (c *serviceClient_Nat44StaticMappingDumpClient) Recv() (*Nat44StaticMappingDetails, error) {
 532         msg, err := c.Stream.RecvMsg()
 533         if err != nil {
 534                 return nil, err
 535         }
 536         switch m := msg.(type) {
 537         case *Nat44StaticMappingDetails:
 538                 return m, nil
 539         case *vpe.ControlPingReply:
 540                 return nil, io.EOF
 541         default:
 542                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 543         }
 544 }
 545
 546 func (c *serviceClient) Nat44UserDump(ctx context.Context, in *Nat44UserDump) (RPCService_Nat44UserDumpClient, error) {
 547         stream, err := c.conn.NewStream(ctx)
 548         if err != nil {
 549                 return nil, err
 550         }
 551         x := &serviceClient_Nat44UserDumpClient{stream}
 552         if err := x.Stream.SendMsg(in); err != nil {
 553                 return nil, err
 554         }
 555         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 556                 return nil, err
 557         }
 558         return x, nil
 559 }
 560
 561 type RPCService_Nat44UserDumpClient interface {
 562         Recv() (*Nat44UserDetails, error)
 563         api.Stream
 564 }
 565
 566 type serviceClient_Nat44UserDumpClient struct {
 567         api.Stream
 568 }
 569
 570 func (c *serviceClient_Nat44UserDumpClient) Recv() (*Nat44UserDetails, error) {
 571         msg, err := c.Stream.RecvMsg()
 572         if err != nil {
 573                 return nil, err
 574         }
 575         switch m := msg.(type) {
 576         case *Nat44UserDetails:
 577                 return m, nil
 578         case *vpe.ControlPingReply:
 579                 return nil, io.EOF
 580         default:
 581                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 582         }
 583 }
 584
 585 func (c *serviceClient) Nat44UserSessionDump(ctx context.Context, in *Nat44UserSessionDump) (RPCService_Nat44UserSessionDumpClient, error) {
 586         stream, err := c.conn.NewStream(ctx)
 587         if err != nil {
 588                 return nil, err
 589         }
 590         x := &serviceClient_Nat44UserSessionDumpClient{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_Nat44UserSessionDumpClient interface {
 601         Recv() (*Nat44UserSessionDetails, error)
 602         api.Stream
 603 }
 604
 605 type serviceClient_Nat44UserSessionDumpClient struct {
 606         api.Stream
 607 }
 608
 609 func (c *serviceClient_Nat44UserSessionDumpClient) Recv() (*Nat44UserSessionDetails, error) {
 610         msg, err := c.Stream.RecvMsg()
 611         if err != nil {
 612                 return nil, err
 613         }
 614         switch m := msg.(type) {
 615         case *Nat44UserSessionDetails:
 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) Nat64AddDelInterface(ctx context.Context, in *Nat64AddDelInterface) (*Nat64AddDelInterfaceReply, error) {
 625         out := new(Nat64AddDelInterfaceReply)
 626         err := c.conn.Invoke(ctx, in, out)
 627         if err != nil {
 628                 return nil, err
 629         }
 630         return out, nil
 631 }
 632
 633 func (c *serviceClient) Nat64AddDelInterfaceAddr(ctx context.Context, in *Nat64AddDelInterfaceAddr) (*Nat64AddDelInterfaceAddrReply, error) {
 634         out := new(Nat64AddDelInterfaceAddrReply)
 635         err := c.conn.Invoke(ctx, in, out)
 636         if err != nil {
 637                 return nil, err
 638         }
 639         return out, nil
 640 }
 641
 642 func (c *serviceClient) Nat64AddDelPoolAddrRange(ctx context.Context, in *Nat64AddDelPoolAddrRange) (*Nat64AddDelPoolAddrRangeReply, error) {
 643         out := new(Nat64AddDelPoolAddrRangeReply)
 644         err := c.conn.Invoke(ctx, in, out)
 645         if err != nil {
 646                 return nil, err
 647         }
 648         return out, nil
 649 }
 650
 651 func (c *serviceClient) Nat64AddDelPrefix(ctx context.Context, in *Nat64AddDelPrefix) (*Nat64AddDelPrefixReply, error) {
 652         out := new(Nat64AddDelPrefixReply)
 653         err := c.conn.Invoke(ctx, in, out)
 654         if err != nil {
 655                 return nil, err
 656         }
 657         return out, nil
 658 }
 659
 660 func (c *serviceClient) Nat64AddDelStaticBib(ctx context.Context, in *Nat64AddDelStaticBib) (*Nat64AddDelStaticBibReply, error) {
 661         out := new(Nat64AddDelStaticBibReply)
 662         err := c.conn.Invoke(ctx, in, out)
 663         if err != nil {
 664                 return nil, err
 665         }
 666         return out, nil
 667 }
 668
 669 func (c *serviceClient) Nat64BibDump(ctx context.Context, in *Nat64BibDump) (RPCService_Nat64BibDumpClient, error) {
 670         stream, err := c.conn.NewStream(ctx)
 671         if err != nil {
 672                 return nil, err
 673         }
 674         x := &serviceClient_Nat64BibDumpClient{stream}
 675         if err := x.Stream.SendMsg(in); err != nil {
 676                 return nil, err
 677         }
 678         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 679                 return nil, err
 680         }
 681         return x, nil
 682 }
 683
 684 type RPCService_Nat64BibDumpClient interface {
 685         Recv() (*Nat64BibDetails, error)
 686         api.Stream
 687 }
 688
 689 type serviceClient_Nat64BibDumpClient struct {
 690         api.Stream
 691 }
 692
 693 func (c *serviceClient_Nat64BibDumpClient) Recv() (*Nat64BibDetails, error) {
 694         msg, err := c.Stream.RecvMsg()
 695         if err != nil {
 696                 return nil, err
 697         }
 698         switch m := msg.(type) {
 699         case *Nat64BibDetails:
 700                 return m, nil
 701         case *vpe.ControlPingReply:
 702                 return nil, io.EOF
 703         default:
 704                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 705         }
 706 }
 707
 708 func (c *serviceClient) Nat64InterfaceDump(ctx context.Context, in *Nat64InterfaceDump) (RPCService_Nat64InterfaceDumpClient, error) {
 709         stream, err := c.conn.NewStream(ctx)
 710         if err != nil {
 711                 return nil, err
 712         }
 713         x := &serviceClient_Nat64InterfaceDumpClient{stream}
 714         if err := x.Stream.SendMsg(in); err != nil {
 715                 return nil, err
 716         }
 717         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 718                 return nil, err
 719         }
 720         return x, nil
 721 }
 722
 723 type RPCService_Nat64InterfaceDumpClient interface {
 724         Recv() (*Nat64InterfaceDetails, error)
 725         api.Stream
 726 }
 727
 728 type serviceClient_Nat64InterfaceDumpClient struct {
 729         api.Stream
 730 }
 731
 732 func (c *serviceClient_Nat64InterfaceDumpClient) Recv() (*Nat64InterfaceDetails, error) {
 733         msg, err := c.Stream.RecvMsg()
 734         if err != nil {
 735                 return nil, err
 736         }
 737         switch m := msg.(type) {
 738         case *Nat64InterfaceDetails:
 739                 return m, nil
 740         case *vpe.ControlPingReply:
 741                 return nil, io.EOF
 742         default:
 743                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 744         }
 745 }
 746
 747 func (c *serviceClient) Nat64PoolAddrDump(ctx context.Context, in *Nat64PoolAddrDump) (RPCService_Nat64PoolAddrDumpClient, error) {
 748         stream, err := c.conn.NewStream(ctx)
 749         if err != nil {
 750                 return nil, err
 751         }
 752         x := &serviceClient_Nat64PoolAddrDumpClient{stream}
 753         if err := x.Stream.SendMsg(in); err != nil {
 754                 return nil, err
 755         }
 756         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 757                 return nil, err
 758         }
 759         return x, nil
 760 }
 761
 762 type RPCService_Nat64PoolAddrDumpClient interface {
 763         Recv() (*Nat64PoolAddrDetails, error)
 764         api.Stream
 765 }
 766
 767 type serviceClient_Nat64PoolAddrDumpClient struct {
 768         api.Stream
 769 }
 770
 771 func (c *serviceClient_Nat64PoolAddrDumpClient) Recv() (*Nat64PoolAddrDetails, error) {
 772         msg, err := c.Stream.RecvMsg()
 773         if err != nil {
 774                 return nil, err
 775         }
 776         switch m := msg.(type) {
 777         case *Nat64PoolAddrDetails:
 778                 return m, nil
 779         case *vpe.ControlPingReply:
 780                 return nil, io.EOF
 781         default:
 782                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 783         }
 784 }
 785
 786 func (c *serviceClient) Nat64PrefixDump(ctx context.Context, in *Nat64PrefixDump) (RPCService_Nat64PrefixDumpClient, error) {
 787         stream, err := c.conn.NewStream(ctx)
 788         if err != nil {
 789                 return nil, err
 790         }
 791         x := &serviceClient_Nat64PrefixDumpClient{stream}
 792         if err := x.Stream.SendMsg(in); err != nil {
 793                 return nil, err
 794         }
 795         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 796                 return nil, err
 797         }
 798         return x, nil
 799 }
 800
 801 type RPCService_Nat64PrefixDumpClient interface {
 802         Recv() (*Nat64PrefixDetails, error)
 803         api.Stream
 804 }
 805
 806 type serviceClient_Nat64PrefixDumpClient struct {
 807         api.Stream
 808 }
 809
 810 func (c *serviceClient_Nat64PrefixDumpClient) Recv() (*Nat64PrefixDetails, error) {
 811         msg, err := c.Stream.RecvMsg()
 812         if err != nil {
 813                 return nil, err
 814         }
 815         switch m := msg.(type) {
 816         case *Nat64PrefixDetails:
 817                 return m, nil
 818         case *vpe.ControlPingReply:
 819                 return nil, io.EOF
 820         default:
 821                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 822         }
 823 }
 824
 825 func (c *serviceClient) Nat64StDump(ctx context.Context, in *Nat64StDump) (RPCService_Nat64StDumpClient, error) {
 826         stream, err := c.conn.NewStream(ctx)
 827         if err != nil {
 828                 return nil, err
 829         }
 830         x := &serviceClient_Nat64StDumpClient{stream}
 831         if err := x.Stream.SendMsg(in); err != nil {
 832                 return nil, err
 833         }
 834         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 835                 return nil, err
 836         }
 837         return x, nil
 838 }
 839
 840 type RPCService_Nat64StDumpClient interface {
 841         Recv() (*Nat64StDetails, error)
 842         api.Stream
 843 }
 844
 845 type serviceClient_Nat64StDumpClient struct {
 846         api.Stream
 847 }
 848
 849 func (c *serviceClient_Nat64StDumpClient) Recv() (*Nat64StDetails, error) {
 850         msg, err := c.Stream.RecvMsg()
 851         if err != nil {
 852                 return nil, err
 853         }
 854         switch m := msg.(type) {
 855         case *Nat64StDetails:
 856                 return m, nil
 857         case *vpe.ControlPingReply:
 858                 return nil, io.EOF
 859         default:
 860                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 861         }
 862 }
 863
 864 func (c *serviceClient) Nat66AddDelInterface(ctx context.Context, in *Nat66AddDelInterface) (*Nat66AddDelInterfaceReply, error) {
 865         out := new(Nat66AddDelInterfaceReply)
 866         err := c.conn.Invoke(ctx, in, out)
 867         if err != nil {
 868                 return nil, err
 869         }
 870         return out, nil
 871 }
 872
 873 func (c *serviceClient) Nat66AddDelStaticMapping(ctx context.Context, in *Nat66AddDelStaticMapping) (*Nat66AddDelStaticMappingReply, error) {
 874         out := new(Nat66AddDelStaticMappingReply)
 875         err := c.conn.Invoke(ctx, in, out)
 876         if err != nil {
 877                 return nil, err
 878         }
 879         return out, nil
 880 }
 881
 882 func (c *serviceClient) Nat66InterfaceDump(ctx context.Context, in *Nat66InterfaceDump) (RPCService_Nat66InterfaceDumpClient, error) {
 883         stream, err := c.conn.NewStream(ctx)
 884         if err != nil {
 885                 return nil, err
 886         }
 887         x := &serviceClient_Nat66InterfaceDumpClient{stream}
 888         if err := x.Stream.SendMsg(in); err != nil {
 889                 return nil, err
 890         }
 891         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 892                 return nil, err
 893         }
 894         return x, nil
 895 }
 896
 897 type RPCService_Nat66InterfaceDumpClient interface {
 898         Recv() (*Nat66InterfaceDetails, error)
 899         api.Stream
 900 }
 901
 902 type serviceClient_Nat66InterfaceDumpClient struct {
 903         api.Stream
 904 }
 905
 906 func (c *serviceClient_Nat66InterfaceDumpClient) Recv() (*Nat66InterfaceDetails, error) {
 907         msg, err := c.Stream.RecvMsg()
 908         if err != nil {
 909                 return nil, err
 910         }
 911         switch m := msg.(type) {
 912         case *Nat66InterfaceDetails:
 913                 return m, nil
 914         case *vpe.ControlPingReply:
 915                 return nil, io.EOF
 916         default:
 917                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 918         }
 919 }
 920
 921 func (c *serviceClient) Nat66StaticMappingDump(ctx context.Context, in *Nat66StaticMappingDump) (RPCService_Nat66StaticMappingDumpClient, error) {
 922         stream, err := c.conn.NewStream(ctx)
 923         if err != nil {
 924                 return nil, err
 925         }
 926         x := &serviceClient_Nat66StaticMappingDumpClient{stream}
 927         if err := x.Stream.SendMsg(in); err != nil {
 928                 return nil, err
 929         }
 930         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
 931                 return nil, err
 932         }
 933         return x, nil
 934 }
 935
 936 type RPCService_Nat66StaticMappingDumpClient interface {
 937         Recv() (*Nat66StaticMappingDetails, error)
 938         api.Stream
 939 }
 940
 941 type serviceClient_Nat66StaticMappingDumpClient struct {
 942         api.Stream
 943 }
 944
 945 func (c *serviceClient_Nat66StaticMappingDumpClient) Recv() (*Nat66StaticMappingDetails, error) {
 946         msg, err := c.Stream.RecvMsg()
 947         if err != nil {
 948                 return nil, err
 949         }
 950         switch m := msg.(type) {
 951         case *Nat66StaticMappingDetails:
 952                 return m, nil
 953         case *vpe.ControlPingReply:
 954                 return nil, io.EOF
 955         default:
 956                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
 957         }
 958 }
 959
 960 func (c *serviceClient) NatControlPing(ctx context.Context, in *NatControlPing) (*NatControlPingReply, error) {
 961         out := new(NatControlPingReply)
 962         err := c.conn.Invoke(ctx, in, out)
 963         if err != nil {
 964                 return nil, err
 965         }
 966         return out, nil
 967 }
 968
 969 func (c *serviceClient) NatDetAddDelMap(ctx context.Context, in *NatDetAddDelMap) (*NatDetAddDelMapReply, error) {
 970         out := new(NatDetAddDelMapReply)
 971         err := c.conn.Invoke(ctx, in, out)
 972         if err != nil {
 973                 return nil, err
 974         }
 975         return out, nil
 976 }
 977
 978 func (c *serviceClient) NatDetCloseSessionIn(ctx context.Context, in *NatDetCloseSessionIn) (*NatDetCloseSessionInReply, error) {
 979         out := new(NatDetCloseSessionInReply)
 980         err := c.conn.Invoke(ctx, in, out)
 981         if err != nil {
 982                 return nil, err
 983         }
 984         return out, nil
 985 }
 986
 987 func (c *serviceClient) NatDetCloseSessionOut(ctx context.Context, in *NatDetCloseSessionOut) (*NatDetCloseSessionOutReply, error) {
 988         out := new(NatDetCloseSessionOutReply)
 989         err := c.conn.Invoke(ctx, in, out)
 990         if err != nil {
 991                 return nil, err
 992         }
 993         return out, nil
 994 }
 995
 996 func (c *serviceClient) NatDetForward(ctx context.Context, in *NatDetForward) (*NatDetForwardReply, error) {
 997         out := new(NatDetForwardReply)
 998         err := c.conn.Invoke(ctx, in, out)
 999         if err != nil {
1000                 return nil, err
1001         }
1002         return out, nil
1003 }
1004
1005 func (c *serviceClient) NatDetMapDump(ctx context.Context, in *NatDetMapDump) (RPCService_NatDetMapDumpClient, error) {
1006         stream, err := c.conn.NewStream(ctx)
1007         if err != nil {
1008                 return nil, err
1009         }
1010         x := &serviceClient_NatDetMapDumpClient{stream}
1011         if err := x.Stream.SendMsg(in); err != nil {
1012                 return nil, err
1013         }
1014         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
1015                 return nil, err
1016         }
1017         return x, nil
1018 }
1019
1020 type RPCService_NatDetMapDumpClient interface {
1021         Recv() (*NatDetMapDetails, error)
1022         api.Stream
1023 }
1024
1025 type serviceClient_NatDetMapDumpClient struct {
1026         api.Stream
1027 }
1028
1029 func (c *serviceClient_NatDetMapDumpClient) Recv() (*NatDetMapDetails, error) {
1030         msg, err := c.Stream.RecvMsg()
1031         if err != nil {
1032                 return nil, err
1033         }
1034         switch m := msg.(type) {
1035         case *NatDetMapDetails:
1036                 return m, nil
1037         case *vpe.ControlPingReply:
1038                 return nil, io.EOF
1039         default:
1040                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
1041         }
1042 }
1043
1044 func (c *serviceClient) NatDetReverse(ctx context.Context, in *NatDetReverse) (*NatDetReverseReply, error) {
1045         out := new(NatDetReverseReply)
1046         err := c.conn.Invoke(ctx, in, out)
1047         if err != nil {
1048                 return nil, err
1049         }
1050         return out, nil
1051 }
1052
1053 func (c *serviceClient) NatDetSessionDump(ctx context.Context, in *NatDetSessionDump) (RPCService_NatDetSessionDumpClient, error) {
1054         stream, err := c.conn.NewStream(ctx)
1055         if err != nil {
1056                 return nil, err
1057         }
1058         x := &serviceClient_NatDetSessionDumpClient{stream}
1059         if err := x.Stream.SendMsg(in); err != nil {
1060                 return nil, err
1061         }
1062         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
1063                 return nil, err
1064         }
1065         return x, nil
1066 }
1067
1068 type RPCService_NatDetSessionDumpClient interface {
1069         Recv() (*NatDetSessionDetails, error)
1070         api.Stream
1071 }
1072
1073 type serviceClient_NatDetSessionDumpClient struct {
1074         api.Stream
1075 }
1076
1077 func (c *serviceClient_NatDetSessionDumpClient) Recv() (*NatDetSessionDetails, error) {
1078         msg, err := c.Stream.RecvMsg()
1079         if err != nil {
1080                 return nil, err
1081         }
1082         switch m := msg.(type) {
1083         case *NatDetSessionDetails:
1084                 return m, nil
1085         case *vpe.ControlPingReply:
1086                 return nil, io.EOF
1087         default:
1088                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
1089         }
1090 }
1091
1092 func (c *serviceClient) NatGetAddrAndPortAllocAlg(ctx context.Context, in *NatGetAddrAndPortAllocAlg) (*NatGetAddrAndPortAllocAlgReply, error) {
1093         out := new(NatGetAddrAndPortAllocAlgReply)
1094         err := c.conn.Invoke(ctx, in, out)
1095         if err != nil {
1096                 return nil, err
1097         }
1098         return out, nil
1099 }
1100
1101 func (c *serviceClient) NatGetMssClamping(ctx context.Context, in *NatGetMssClamping) (*NatGetMssClampingReply, error) {
1102         out := new(NatGetMssClampingReply)
1103         err := c.conn.Invoke(ctx, in, out)
1104         if err != nil {
1105                 return nil, err
1106         }
1107         return out, nil
1108 }
1109
1110 func (c *serviceClient) NatGetTimeouts(ctx context.Context, in *NatGetTimeouts) (*NatGetTimeoutsReply, error) {
1111         out := new(NatGetTimeoutsReply)
1112         err := c.conn.Invoke(ctx, in, out)
1113         if err != nil {
1114                 return nil, err
1115         }
1116         return out, nil
1117 }
1118
1119 func (c *serviceClient) NatHaFlush(ctx context.Context, in *NatHaFlush) (*NatHaFlushReply, error) {
1120         out := new(NatHaFlushReply)
1121         err := c.conn.Invoke(ctx, in, out)
1122         if err != nil {
1123                 return nil, err
1124         }
1125         return out, nil
1126 }
1127
1128 func (c *serviceClient) NatHaGetFailover(ctx context.Context, in *NatHaGetFailover) (*NatHaGetFailoverReply, error) {
1129         out := new(NatHaGetFailoverReply)
1130         err := c.conn.Invoke(ctx, in, out)
1131         if err != nil {
1132                 return nil, err
1133         }
1134         return out, nil
1135 }
1136
1137 func (c *serviceClient) NatHaGetListener(ctx context.Context, in *NatHaGetListener) (*NatHaGetListenerReply, error) {
1138         out := new(NatHaGetListenerReply)
1139         err := c.conn.Invoke(ctx, in, out)
1140         if err != nil {
1141                 return nil, err
1142         }
1143         return out, nil
1144 }
1145
1146 func (c *serviceClient) NatHaResync(ctx context.Context, in *NatHaResync) (*NatHaResyncReply, error) {
1147         out := new(NatHaResyncReply)
1148         err := c.conn.Invoke(ctx, in, out)
1149         if err != nil {
1150                 return nil, err
1151         }
1152         return out, nil
1153 }
1154
1155 func (c *serviceClient) NatHaSetFailover(ctx context.Context, in *NatHaSetFailover) (*NatHaSetFailoverReply, error) {
1156         out := new(NatHaSetFailoverReply)
1157         err := c.conn.Invoke(ctx, in, out)
1158         if err != nil {
1159                 return nil, err
1160         }
1161         return out, nil
1162 }
1163
1164 func (c *serviceClient) NatHaSetListener(ctx context.Context, in *NatHaSetListener) (*NatHaSetListenerReply, error) {
1165         out := new(NatHaSetListenerReply)
1166         err := c.conn.Invoke(ctx, in, out)
1167         if err != nil {
1168                 return nil, err
1169         }
1170         return out, nil
1171 }
1172
1173 func (c *serviceClient) NatIpfixEnableDisable(ctx context.Context, in *NatIpfixEnableDisable) (*NatIpfixEnableDisableReply, error) {
1174         out := new(NatIpfixEnableDisableReply)
1175         err := c.conn.Invoke(ctx, in, out)
1176         if err != nil {
1177                 return nil, err
1178         }
1179         return out, nil
1180 }
1181
1182 func (c *serviceClient) NatSetAddrAndPortAllocAlg(ctx context.Context, in *NatSetAddrAndPortAllocAlg) (*NatSetAddrAndPortAllocAlgReply, error) {
1183         out := new(NatSetAddrAndPortAllocAlgReply)
1184         err := c.conn.Invoke(ctx, in, out)
1185         if err != nil {
1186                 return nil, err
1187         }
1188         return out, nil
1189 }
1190
1191 func (c *serviceClient) NatSetLogLevel(ctx context.Context, in *NatSetLogLevel) (*NatSetLogLevelReply, error) {
1192         out := new(NatSetLogLevelReply)
1193         err := c.conn.Invoke(ctx, in, out)
1194         if err != nil {
1195                 return nil, err
1196         }
1197         return out, nil
1198 }
1199
1200 func (c *serviceClient) NatSetMssClamping(ctx context.Context, in *NatSetMssClamping) (*NatSetMssClampingReply, error) {
1201         out := new(NatSetMssClampingReply)
1202         err := c.conn.Invoke(ctx, in, out)
1203         if err != nil {
1204                 return nil, err
1205         }
1206         return out, nil
1207 }
1208
1209 func (c *serviceClient) NatSetTimeouts(ctx context.Context, in *NatSetTimeouts) (*NatSetTimeoutsReply, error) {
1210         out := new(NatSetTimeoutsReply)
1211         err := c.conn.Invoke(ctx, in, out)
1212         if err != nil {
1213                 return nil, err
1214         }
1215         return out, nil
1216 }
1217
1218 func (c *serviceClient) NatSetWorkers(ctx context.Context, in *NatSetWorkers) (*NatSetWorkersReply, error) {
1219         out := new(NatSetWorkersReply)
1220         err := c.conn.Invoke(ctx, in, out)
1221         if err != nil {
1222                 return nil, err
1223         }
1224         return out, nil
1225 }
1226
1227 func (c *serviceClient) NatShowConfig(ctx context.Context, in *NatShowConfig) (*NatShowConfigReply, error) {
1228         out := new(NatShowConfigReply)
1229         err := c.conn.Invoke(ctx, in, out)
1230         if err != nil {
1231                 return nil, err
1232         }
1233         return out, nil
1234 }
1235
1236 func (c *serviceClient) NatWorkerDump(ctx context.Context, in *NatWorkerDump) (RPCService_NatWorkerDumpClient, error) {
1237         stream, err := c.conn.NewStream(ctx)
1238         if err != nil {
1239                 return nil, err
1240         }
1241         x := &serviceClient_NatWorkerDumpClient{stream}
1242         if err := x.Stream.SendMsg(in); err != nil {
1243                 return nil, err
1244         }
1245         if err = x.Stream.SendMsg(&vpe.ControlPing{}); err != nil {
1246                 return nil, err
1247         }
1248         return x, nil
1249 }
1250
1251 type RPCService_NatWorkerDumpClient interface {
1252         Recv() (*NatWorkerDetails, error)
1253         api.Stream
1254 }
1255
1256 type serviceClient_NatWorkerDumpClient struct {
1257         api.Stream
1258 }
1259
1260 func (c *serviceClient_NatWorkerDumpClient) Recv() (*NatWorkerDetails, error) {
1261         msg, err := c.Stream.RecvMsg()
1262         if err != nil {
1263                 return nil, err
1264         }
1265         switch m := msg.(type) {
1266         case *NatWorkerDetails:
1267                 return m, nil
1268         case *vpe.ControlPingReply:
1269                 return nil, io.EOF
1270         default:
1271                 return nil, fmt.Errorf("unexpected message: %T %v", m, m)
1272         }
1273 }