diff --git a/.gitignore b/.gitignore index 0d40a96..38d45d7 100644 --- a/.gitignore +++ b/.gitignore @@ -8,7 +8,6 @@ # Global glob patterns. *.log *.coverprofile -*.pb.go /.noseids /nosetests.xml /release-notes-* @@ -20,7 +19,6 @@ /dist/ .go-pkg-cache/ /.glide/ -/vendor/ # IDE files. /.idea/ diff --git a/buildinfo/version.go b/buildinfo/version.go index 5f01bda..2b1b0c7 100644 --- a/buildinfo/version.go +++ b/buildinfo/version.go @@ -16,7 +16,7 @@ package buildinfo // Filled in by the build process. var ( - GitVersion string - BuildDate string - GitRevision string + GitVersion string = "3.0.4" + BuildDate string = "2018-06-11T20:16:57GMT" + GitRevision string = "808fb2d23cc8300d3b9164c7e001e77c65f855ff" ) diff --git a/dataplane/aix/aix_dataplane.go b/dataplane/aix/aix_dataplane.go new file mode 100644 index 0000000..1f8e76e --- /dev/null +++ b/dataplane/aix/aix_dataplane.go @@ -0,0 +1,368 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package aixdataplane + +import ( + "fmt" + "net" + "time" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/dataplane/aix/ipsets" + "github.com/projectcalico/felix/dataplane/aix/policysets" + "github.com/projectcalico/felix/jitter" + "github.com/projectcalico/felix/proto" + "github.com/projectcalico/felix/throttle" + "github.com/projectcalico/libcalico-go/lib/health" +) + +const ( + // msgPeekLimit is the maximum number of messages we'll try to grab from the to-dataplane + // channel before we apply the changes. Higher values allow us to batch up more work on + // the channel for greater throughput when we're under load (at cost of higher latency). + msgPeekLimit = 100 + + // After a failure to apply dataplane updates, we will delay for this amount of time + // before rescheduling another attempt to apply the pending updates. + reschedDelay = time.Duration(5) * time.Second +) + +var ( + processStartTime time.Time +) + +func init() { + processStartTime = time.Now() +} + +type Config struct { + IPv6Enabled bool + IPIPEnabled bool + IPIPTunnelAddress net.IP + IPIPMTU int + HealthAggregator *health.HealthAggregator +} + +// aixDataplane implements an in-process Felix dataplane driver capable of applying network policy +// dataplane updates on AIX. It communicates with the +// datastore-facing part of Felix via the Send/RecvMessage methods, which operate on the +// protobuf-defined API objects. +// +// Architecture +// +// The AIX dataplane driver is organised around a main event loop, which handles +// update events from the datastore and dataplane. +// +// Each pass around the main loop has two phases. In the first phase, updates are fanned +// out to "manager" objects, which calculate the changes that are needed. In the second phase, +// the set of pending changes are communicated to the IPSec service so that they will be immediately +// applied to the dataplane. The second phase is skipped until the datastore is in sync; this +// ensures that the first update to the dataplane applies a consistent snapshot. +// +// Several optimizations and improvements are forthcoming. At this time, the AIX dataplane does +// not have a native concept similar to IP sets, which means that IP set information needs to be +// cached in the driver along with associated Policies/Profiles. As datastore updates are received, +// we refer back to the caches to recalculate the sets of rules which need to be sent to genfilt. +// +// Requirements on the API +// +// The dataplane does not do consistency checks on the incoming data. It expects to be told about +// dependent resources before they are needed and for their lifetime to exceed that of the resources +// that depend on them. For example, it is important the the datastore layer send an IP set create +// event before it sends a rule that references that IP set. +type AIXDataplane struct { + // the channel which we receive messages from felix + toDataplane chan interface{} + // the channel used to send messages from the dataplane to felix + fromDataplane chan interface{} + // stores all of the managers which will be processing the various updates from felix. + allManagers []Manager + ipipManager *ipipManager + // each IPSets manages a whole "plane" of IP sets, i.e. all the IPv4 sets, or all the IPv6 + // IP sets. + ipSets []*ipsets.IPSets + // PolicySets manages all of the policies and profiles which have been communicated to the + // dataplane driver + policySets *policysets.PolicySets + // dataplaneNeedsSync is set if the dataplane is dirty in some way, i.e. we need to + // call apply(). + dataplaneNeedsSync bool + // doneFirstApply is set after we finish the first update to the dataplane. It indicates + // that the dataplane should now be in sync. + doneFirstApply bool + // the reschedule timer/channel enable us to force the dataplane driver to attempt to + // apply any pending updates to the dataplane. This is only enabled and used if a previous + // apply operation has failed and needs to be retried. + reschedTimer *time.Timer + reschedC <-chan time.Time + // a simple throttle to control how frequently the driver is allowed to apply updates + // to the dataplane. + applyThrottle *throttle.Throttle + // config provides a way for felix to provide some additional configuration options + // to the dataplane driver. This isn't really used currently, but will be in the future. + config Config +} + +// Interface for Managers. Each Manager is responsible for processing updates from felix and +// for applying any necessary updates to the dataplane. +type Manager interface { + // OnUpdate is called for each protobuf message from the datastore. May either directly + // send updates to the IPSets and PolicySets objects (which will queue the updates + // until the main loop instructs them to act) or (for efficiency) may wait until + // a call to CompleteDeferredWork() to flush updates to the dataplane. + OnUpdate(protoBufMsg interface{}) + // Called to allow for any batched work to be completed. + CompleteDeferredWork() error +} + +// Registers a new Manager with the driver. +func (d *AIXDataplane) RegisterManager(mgr Manager) { + d.allManagers = append(d.allManagers, mgr) +} + +// NewAIXDataplaneDriver creates and initializes a new dataplane driver using the provided +// configuration. +func NewAIXDataplaneDriver(config Config) *AIXDataplane { + log.WithField("config", config).Info("Creating AIX dataplane driver.") + + ipSetsConfigV4 := ipsets.NewIPVersionConfig( + ipsets.IPFamilyV4, + ) + + ipSetsV4 := ipsets.NewIPSets(ipSetsConfigV4) + + dp := &AIXDataplane{ + toDataplane: make(chan interface{}, msgPeekLimit), + fromDataplane: make(chan interface{}, 100), + config: config, + applyThrottle: throttle.New(10), + } + + dp.applyThrottle.Refill() // Allow the first apply() immediately. + + dp.ipSets = append(dp.ipSets, ipSetsV4) + dp.policySets = policysets.NewPolicySets(dp.ipSets) + + dp.RegisterManager(newIPSetsManager(ipSetsV4)) + dp.RegisterManager(newPolicyManager(dp.policySets)) + dp.RegisterManager(newEndpointManager(dp.policySets)) + if config.IPIPEnabled { + dp.ipipManager = newIPIPManager() + dp.RegisterManager(dp.ipipManager) // IPv4-only + } + + return dp +} + +// Starts the driver. +func (d *AIXDataplane) Start() { + if d.config.IPIPEnabled { + log.Info("IPIP enabled, starting thread to keep tunnel configuration in sync.") + go d.ipipManager.KeepIPIPDeviceInSync( + d.config.IPIPMTU, + d.config.IPIPTunnelAddress, + ) + } else { + log.Info("IPIP disabled. Not starting tunnel update thread.") + } + + go d.loopUpdatingDataplane() +} + +// Called by someone to put a message into our channel so that the loop will pick it up +// and process it. +func (d *AIXDataplane) SendMessage(msg interface{}) error { + log.Debugf("AIXDataPlane->SendMessage to felix: %T", msg) + + d.toDataplane <- msg + return nil +} + +// Called by Felix.go so that it can receive a channel to listen for message being +// sent by this dataplane driver. +func (d *AIXDataplane) RecvMessage() (interface{}, error) { + log.Debug("AIXDataPlane->RecvMessage was invoked") + + return <-d.fromDataplane, nil +} + +// The main loop which is responsible for picking up any updates and providing them +// to the managers for processing. After managers have had a chance to process the updates +// the loop will call Apply() to actually apply changes to the dataplane. +func (d *AIXDataplane) loopUpdatingDataplane() { + log.Debug("Started AIX dataplane driver loop") + + // Fill the apply throttle leaky bucket. + throttleC := jitter.NewTicker(100*time.Millisecond, 10*time.Millisecond).C + beingThrottled := false + + datastoreInSync := false + + // function to pass messages to the managers for processing + processMsgFromCalcGraph := func(msg interface{}) { + log.WithField("msg", msgStringer{msg: msg}).Infof( + "Received %T update from calculation graph", msg) + for _, mgr := range d.allManagers { + mgr.OnUpdate(msg) + } + switch msg.(type) { + case *proto.InSync: + log.WithField("timeSinceStart", time.Since(processStartTime)).Info( + "Datastore in sync, flushing the dataplane for the first time...") + datastoreInSync = true + } + } + + for { + select { + case msg := <-d.toDataplane: + // Process the message we received, then opportunistically process any other + // pending messages. + batchSize := 1 + processMsgFromCalcGraph(msg) + msgLoop1: + for i := 0; i < msgPeekLimit; i++ { + select { + case msg := <-d.toDataplane: + processMsgFromCalcGraph(msg) + batchSize++ + default: + // Channel blocked so we must be caught up. + break msgLoop1 + } + } + d.dataplaneNeedsSync = true + case <-throttleC: + d.applyThrottle.Refill() + case <-d.reschedC: + log.Debug("Reschedule kick received") + d.dataplaneNeedsSync = true + d.reschedC = nil + } + + if datastoreInSync && d.dataplaneNeedsSync { + // Dataplane is out-of-sync, check if we're throttled. + if d.applyThrottle.Admit() { + if beingThrottled && d.applyThrottle.WouldAdmit() { + log.Info("Dataplane updates no longer throttled") + beingThrottled = false + } + log.Info("Applying dataplane updates") + applyStart := time.Now() + + // Actually apply the changes to the dataplane. + d.apply() + + applyTime := time.Since(applyStart) + log.WithField("msecToApply", applyTime.Seconds()*1000.0).Info( + "Finished applying updates to dataplane.") + + if !d.doneFirstApply { + log.WithField( + "secsSinceStart", time.Since(processStartTime).Seconds(), + ).Info("Completed first update to dataplane.") + d.doneFirstApply = true + } + } else { + if !beingThrottled { + log.Info("Dataplane updates throttled") + beingThrottled = true + } + } + } + } +} + +// Applies any pending changes to the dataplane by giving each of the managers a chance to +// complete their deffered work. If the operation fails, then this will also set up a +// rescheduling kick so that the apply can be reattempted. +func (d *AIXDataplane) apply() { + // Unset the needs-sync flag, a rescheduling kick will reset it later if something failed + d.dataplaneNeedsSync = false + + // Allow each of the managers to complete any deferred work. + scheduleRetry := false + for _, mgr := range d.allManagers { + err := mgr.CompleteDeferredWork() + if err != nil { + // schedule a retry + log.WithError(err).Warning("CompleteDeferredWork returned an error - scheduling a retry") + scheduleRetry = true + } + } + + // Set up any needed rescheduling kick. + if d.reschedC != nil { + // We have an active rescheduling timer, stop it so we can restart it with a + // different timeout below if it is still needed. + if !d.reschedTimer.Stop() { + // Timer had already popped, drain its channel. + <-d.reschedC + } + // Nil out our copy of the channel to record that the timer is inactive. + d.reschedC = nil + } + + if scheduleRetry { + if d.reschedTimer == nil { + // First time, create the timer. + d.reschedTimer = time.NewTimer(reschedDelay) + } else { + // Have an existing timer, reset it. + d.reschedTimer.Reset(reschedDelay) + } + + d.reschedC = d.reschedTimer.C + } +} + +// msgStringer wraps an API message to customise how we stringify it. For example, it truncates +// the lists of members in the (potentially very large) IPSetsUpdate messages. +type msgStringer struct { + msg interface{} +} + +func (m msgStringer) String() string { + if log.GetLevel() < log.DebugLevel && m.msg != nil { + const truncateAt = 10 + switch msg := m.msg.(type) { + case *proto.IPSetUpdate: + if len(msg.Members) < truncateAt { + return fmt.Sprintf("%v", msg) + } + return fmt.Sprintf("id:%#v members(%d):%#v(truncated)", + msg.Id, len(msg.Members), msg.Members[:truncateAt]) + case *proto.IPSetDeltaUpdate: + if len(msg.AddedMembers) < truncateAt && len(msg.RemovedMembers) < truncateAt { + return fmt.Sprintf("%v", msg) + } + addedNum := truncateAt + removedNum := truncateAt + if len(msg.AddedMembers) < addedNum { + addedNum = len(msg.AddedMembers) + } + if len(msg.RemovedMembers) < removedNum { + removedNum = len(msg.RemovedMembers) + } + return fmt.Sprintf("id:%#v addedMembers(%d):%#v(truncated) removedMembers(%d):%#v(truncated)", + msg.Id, len(msg.AddedMembers), msg.AddedMembers[:addedNum], + len(msg.RemovedMembers), msg.RemovedMembers[:removedNum]) + } + } + return fmt.Sprintf("%v", m.msg) +} diff --git a/dataplane/aix/endpoint_mgr.go b/dataplane/aix/endpoint_mgr.go new file mode 100644 index 0000000..d9e9e0d --- /dev/null +++ b/dataplane/aix/endpoint_mgr.go @@ -0,0 +1,203 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package aixdataplane + +import ( + "errors" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/dataplane/aix/ipsec" + "github.com/projectcalico/felix/dataplane/aix/policysets" + "github.com/projectcalico/felix/proto" +) + +var ( + ErrorUnknownEndpoint = errors.New("Endpoint could not be found") + ErrorUpdateFailed = errors.New("Endpoint update failed") +) + +// endpointManager processes WorkloadEndpoint* updates from the datastore. Updates are +// stored and pended for processing during CompleteDeferredWork. endpointManager is also +// responsible for orchestrating a refresh of all impacted endpoints after a IPSet update. +type endpointManager struct { + // the policysets dataplane to be used when looking up endpoint policies/profiles. + policysetsDataplane policysets.PolicySetsDataplane + // pendingWlEpUpdates stores any pending updates to be performed per endpoint. + pendingWlEpUpdates map[proto.WorkloadEndpointID]*proto.WorkloadEndpoint + // activeWlEndpoints stores the active/current state that was applied per endpoint + activeWlEndpoints map[proto.WorkloadEndpointID]*proto.WorkloadEndpoint + // addressToEndpoint store the ipsec endpoint per workload endpoint + addressToEndpoint map[proto.WorkloadEndpointID]*ipsec.Endpoint +} + +func newEndpointManager(policysets policysets.PolicySetsDataplane) *endpointManager { + return &endpointManager{ + policysetsDataplane: policysets, + addressToEndpoint: map[proto.WorkloadEndpointID]*ipsec.Endpoint{}, + activeWlEndpoints: map[proto.WorkloadEndpointID]*proto.WorkloadEndpoint{}, + pendingWlEpUpdates: map[proto.WorkloadEndpointID]*proto.WorkloadEndpoint{}, + } +} + +// OnUpdate is called by the main dataplane driver loop during the first phase. It processes +// specific types of updates from the datastore. +func (m *endpointManager) OnUpdate(msg interface{}) { + switch msg := msg.(type) { + case *proto.WorkloadEndpointUpdate: + log.WithField("workloadEndpointId", msg.Id).Info("Processing WorkloadEndpointUpdate") + m.pendingWlEpUpdates[*msg.Id] = msg.Endpoint + case *proto.WorkloadEndpointRemove: + log.WithField("workloadEndpointId", msg.Id).Info("Processing WorkloadEndpointRemove") + m.pendingWlEpUpdates[*msg.Id] = nil + case *proto.IPSetUpdate: + log.WithField("ipSetId", msg.Id).Info("Processing IPSetUpdate") + m.ProcessIpSetUpdate(msg.Id) + case *proto.IPSetDeltaUpdate: + log.WithField("ipSetId", msg.Id).Info("Processing IPSetDeltaUpdate") + m.ProcessIpSetUpdate(msg.Id) + } +} + +// ProcessIpSetUpdate is called when a IPSet has changed. The ipSetsManager will have already updated +// the IPSet itself, but the endpointManager is responsible for requesting all impacted policy sets +// to be updated and for marking all impacted endpoints as pending so that updated policies can be +// pushed to them. +func (m *endpointManager) ProcessIpSetUpdate(ipSetId string) { + log.WithField("ipSetId", ipSetId).Debug("Requesting PolicySetsDataplane to process the IP set update") + updatedPolicies := m.policysetsDataplane.ProcessIpSetUpdate(ipSetId) + if updatedPolicies == nil { + return + } + + log.Debugf("Checking if any active endpoint policies need to be refreshed") + for endpointId, workload := range m.activeWlEndpoints { + if _, present := m.pendingWlEpUpdates[endpointId]; present { + // skip this endpoint as it is already marked as pending update + continue + } + + var activePolicyNames []string + if len(workload.Tiers) > 0 { + activePolicyNames = append(activePolicyNames, workload.Tiers[0].IngressPolicies...) + activePolicyNames = append(activePolicyNames, workload.Tiers[0].EgressPolicies...) + } else { + if len(workload.ProfileIds) > 0 { + activePolicyNames = workload.ProfileIds + } + } + + Policies: + for _, policyName := range activePolicyNames { + for _, updatedPolicy := range updatedPolicies { + if policyName == updatedPolicy { + log.WithFields(log.Fields{"policyName": policyName, "endpointId": endpointId}).Info("Endpoint is being marked for policy refresh") + m.pendingWlEpUpdates[endpointId] = workload + break Policies + } + } + } + } +} + +// CompleteDeferredWork will apply all pending updates by gathering the rules to be updated per +// endpoint and communicating them to ipsec. Note that CompleteDeferredWork is called during the +// second phase of the main dataplane driver loop, so all IPSet/Policy/Profile/Workload updates +// have already been processed by the various managers and we should now have a complete picture +// of the policy/rules to be applied for each pending endpoint. +func (m *endpointManager) CompleteDeferredWork() error { + // Loop through each pending update + for id, workload := range m.pendingWlEpUpdates { + logCxt := log.WithField("id", id) + + var policyNames []string + + endpoint, ok := m.addressToEndpoint[id] + + // A non-nil workload indicates this is a pending add or update operation + if workload != nil { + if !ok { + var err error + endpoint, err = ipsec.NewEndpoint(workload.Ipv4Nets) + if err != nil { + return ErrorUnknownEndpoint + } + m.addressToEndpoint[id] = endpoint + } + + logCxt.Info("Processing endpoint add/update") + + if len(workload.Tiers) > 0 { + logCxt.Debug("Workload tiers are present - Policies will be applied") + policyNames = append(policyNames, workload.Tiers[0].IngressPolicies...) + policyNames = append(policyNames, workload.Tiers[0].EgressPolicies...) + } else { + if len(workload.ProfileIds) > 0 { + logCxt.Debug("Workload tiers are not present - Profiles will be applied") + policyNames = workload.ProfileIds + } + } + + err := m.applyRules(id, endpoint, policyNames) + if err != nil { + // Failed to apply, this will be rescheduled and retried + return err + } + + m.activeWlEndpoints[id] = workload + delete(m.pendingWlEpUpdates, id) + } else { + logCxt.Info("Processing endpoint removal") + if ok { + ipsec.RemoveEndpoint(endpoint) + delete(m.addressToEndpoint, id) + } + delete(m.activeWlEndpoints, id) + delete(m.pendingWlEpUpdates, id) + } + } + + return nil +} + +// applyRules gathers all of the rules for the specified policies and sends them to ipsec +// as an endpoint policy update (this actually applies the rules to the dataplane). +func (m *endpointManager) applyRules(workloadId proto.WorkloadEndpointID, endpoint *ipsec.Endpoint, policyNames []string) error { + logCxt := log.WithFields(log.Fields{"id": workloadId}) + logCxt.WithField("policies", policyNames).Info("Applying endpoint rules") + + var rules []*ipsec.Rule + if len(policyNames) > 0 { + rules = m.policysetsDataplane.GetPolicySetRules(policyNames) + if log.GetLevel() >= log.DebugLevel { + for _, rule := range rules { + logCxt.WithField("rule", rule).Debug("Complete set of rules to be applied") + } + } + } else { + logCxt.Info("No policies/profiles were specified, all rules will be removed from this endpoint") + } + + logCxt.Debug("Sending request to ipsec to apply the rules") + + if err := endpoint.ApplyIPSecRules(rules...); err != nil { + logCxt.WithError(err).Warning("Failed to apply rules. This operation will be retried.") + return ErrorUpdateFailed + } + + return nil +} diff --git a/dataplane/aix/ipip_mgr.go b/dataplane/aix/ipip_mgr.go new file mode 100644 index 0000000..1625f1f --- /dev/null +++ b/dataplane/aix/ipip_mgr.go @@ -0,0 +1,178 @@ +//+build aix + +// Copyright (c) 2016-2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package aixdataplane + +import ( + "net" + "os/exec" + "strconv" + "time" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/proto" +) + +// ipipManager takes care of the configuration of the IPIP tunnel device. +type ipipManager struct { + cachedMTU int +} + +func newIPIPManager() *ipipManager { + ipipMgr := &ipipManager{ + } + return ipipMgr +} + +// KeepIPIPDeviceInSync is a goroutine that configures the IPIP tunnel device, then periodically +// checks that it is still correctly configured. +func (d *ipipManager) KeepIPIPDeviceInSync(mtu int, address net.IP) { + log.Info("IPIP thread started.") + for { + err := d.configureIPIPDevice(mtu, address) + if err != nil { + log.WithError(err).Warn("Failed configure IPIP tunnel device, retrying...") + time.Sleep(1 * time.Second) + continue + } + time.Sleep(10 * time.Second) + } +} + +// configureIPIPDevice ensures the IPIP tunnel device is up and configured correctly. +func (d *ipipManager) configureIPIPDevice(mtu int, address net.IP) error { + logCxt := log.WithFields(log.Fields{ + "mtu": mtu, + "tunnelAddr": address, + }) + logCxt.Debug("Configuring IPIP tunnel") + + ifi, err := net.InterfaceByName("tunl0") + if err != nil { + log.WithError(err).Info("Failed to get IPIP tunnel device, assuming it isn't present") + // We call out to "ifconfig", which takes care of loading the kernel extension if + // needed. + err = exec.Command("ifconfig", "tunl0").Run() + if err != nil { + log.WithError(err).Warning("Failed to add IPIP tunnel device") + return err + } + ifi, err = net.InterfaceByName("tunl0") + if err != nil { + log.WithError(err).Warning("Failed to get tunnel device") + return err + } + } + + // On AIX, InterfaceByName() does not return the MTU in ifi.MTU. +// SIOCGIFMTU + if d.cachedMTU != mtu { + logCxt.WithField("cachedMTU", d.cachedMTU).Info("Tunnel device MTU needs to be updated") +// SIOCSIFMTU + err = exec.Command("ifconfig", ifi.Name, "mtu", strconv.Itoa(mtu)).Run() + if err != nil { + log.WithError(err).Warn("Failed to set tunnel device MTU") + return err + } + d.cachedMTU = mtu + logCxt.Info("Updated tunnel MTU") + } + + if ifi.Flags&net.FlagUp == 0 { + logCxt.WithField("flags", ifi.Flags).Info("Tunnel wasn't admin up, enabling it") +// SIOCSIFFLAGS + err := exec.Command("ifconfig", ifi.Name, "up").Run() + if err != nil { + log.WithError(err).Warn("Failed to set tunnel device up") + return err + } + logCxt.Info("Set tunnel admin up") + } + + if err := d.setLinkAddressV4(ifi, address); err != nil { + log.WithError(err).Warn("Failed to set tunnel device IP") + return err + } + return nil +} + +// setLinkAddressV4 updates the given link to set its local IP address. It removes any other +// addresses. +func (d *ipipManager) setLinkAddressV4(ifi *net.Interface, address net.IP) error { + logCxt := log.WithFields(log.Fields{ + "link": ifi.Name, + "addr": address, + }) + logCxt.Debug("Setting local IPv4 address on link.") + + addrs, err := ifi.Addrs() + if err != nil { + log.WithError(err).Warn("Failed to list interface addresses") + return err + } + + found := false + for _, oldAddr := range addrs { + oldIP, _, err := net.ParseCIDR(oldAddr.String()) + if err != nil { + continue + } + if address != nil && oldIP.Equal(address) { + logCxt.Debug("Address already present.") + found = true + continue + } + logCxt.WithField("oldIP", oldIP).Info("Removing old address") +// SIOCDIFADDR + err = exec.Command("ifconfig", ifi.Name, "delete", oldIP.String()).Run() + if err != nil { + log.WithError(err).Warn("Failed to delete address") + return err + } + } + + if !found && address != nil { + logCxt.Info("Address wasn't present, adding it.") + mask := net.CIDRMask(32, 32) + ipNet := net.IPNet{ + IP: address.Mask(mask), // Mask the IP to match ParseCIDR()'s behaviour. + Mask: mask, + } +// SIOCSIFADDR + err = exec.Command("ifconfig", ifi.Name, ipNet.IP.String(), "netmask", net.IP(ipNet.Mask).String()).Run() + if err != nil { + log.WithError(err).WithField("addr", address).Warn("Failed to add address") + return err + } + } + logCxt.Debug("Address set.") + + return nil +} + +func (d *ipipManager) OnUpdate(msg interface{}) { + switch msg := msg.(type) { + case *proto.HostMetadataUpdate: + log.WithField("hostanme", msg.Hostname).Debug("Host update/create") + case *proto.HostMetadataRemove: + log.WithField("hostname", msg.Hostname).Debug("Host removed") + } +} + +func (m *ipipManager) CompleteDeferredWork() error { + return nil +} diff --git a/dataplane/aix/ipsec/ipsec.go b/dataplane/aix/ipsec/ipsec.go new file mode 100644 index 0000000..c7ae63a --- /dev/null +++ b/dataplane/aix/ipsec/ipsec.go @@ -0,0 +1,352 @@ +package ipsec + +import ( + "encoding/binary" + "fmt" + "net" + "os" + "unsafe" +) + +type DfId int32 + +const ( + FLTR_BEGIN DfId = -1 + FLTR_END DfId = -2 +) + +const DFMAXTYPE = 10 + +type IdEntry struct { + Id DfId + Type [DFMAXTYPE]byte + InitTime uint32 + LifeTime uint32 + Status byte +} + +type ModDfRules struct { + PtrRules uint64 + RulesCnt int32 + IdAfter DfId + PtrBase uint64 + Len int32 +} + +type FwTime struct { + Month int32 + DayNum int32 + Day int32 + Hour int32 +} + +type FwTimeRange struct { + Type int32 + Start FwTime + End FwTime +} + +const MAX_RULE_ADAPTERS = 8 + +// Action +const ( + FLTR_PERMIT = 1 << 0 + FLTR_DENY = 1 << 1 + FLTR_IF = 1 << 2 + FLTR_ELSE = 1 << 3 + FLTR_ENDIF = 1 << 4 + FLTR_SHUN_HOST = 1 << 5 + FLTR_SHUN_PORT = 1 << 6 +) + +// Mask or range (Smr/Dmr) +const ( + FLTR_MASK = 4 + FLTR_RANGE = 7 +) + +// Direction +const ( + FLTR_INBOUND = 1 + FLTR_OUTBOUND = 2 + FLTR_BOTH = 4 +) + +// Protocol +const ( + FWPROTO_TCP_FIN = 246 + FWPROTO_TCP_SYN = 247 + FWPROTO_TCP_RST = 248 + FWPROTO_TCP_PUSH = 249 + FWPROTO_TCP_URG = 250 + FWPROTO_TCP_ECN_ECHO = 251 + FWPROTO_TCP_CWR = 252 + FWPROTO_TCP_ACK = 253 + FWPROTO_ALL = 254 +) + +// PortOp +const ( + FLTR_LT = 1 + FLTR_EQ = 2 + FLTR_GT = 4 + FLTR_ANY = 0x80 + FLTR_LE = FLTR_LT | FLTR_EQ + FLTR_GE = FLTR_GT | FLTR_EQ + FLTR_NE = FLTR_LT | FLTR_GT +) + +// RuleScope +const ( + FLTR_LOCAL = 1 + FLTR_ROUTE = 2 +) + +// Flags +const ( + FRAGMENTS_HEAD = 0x1000 + FRAGMENTS_NO = 0x2000 + FRAGMENTS_YES = 0x4000 + FRAGMENTS_ONLY = 0x8000 + FLTR_LOGFLAG = 0x0C00 + FLTR_LOGNO = 0x0400 + FLTR_LOGYES = 0x0800 + FLTR_DF_RULE = 0x0200 +) + +type InAddr struct { + Addr uint32 +} + +type In6Addr struct { + Addr [4]uint32 +} + +// Dynamic Filter Rule +type DfFltrEntry struct { + Id DfId + Jump int32 + + Action uint8 + Smr uint8 + Dmr uint8 + SrcAddr InAddr + SrcMaskOrRange InAddr + DstAddr InAddr + DstMaskOrRange InAddr + Protocol uint8 + SrcPortOp uint8 + SrcPort uint16 // or ICMP type + SrcPortEnd uint16 + DstPortOp uint8 + DstPort uint16 // or ICMP code + DstPortEnd uint16 + Adapter uint8 + RuleScope uint8 + Direction uint8 + TunnelId uint32 + Flags uint16 + TimeRange FwTimeRange + RuleAdaptCnt int32 + RuleAdapt [MAX_RULE_ADAPTERS]InAddr +} + +type Df6FltrEntry struct { + Id DfId + Jump int32 + + Action uint8 + Smr uint8 + Dmr uint8 + SrcAddr In6Addr + SrcMaskOrRange In6Addr + DstAddr In6Addr + DstMaskOrRange In6Addr + Protocol uint8 + SrcPortOp uint8 + SrcPort uint16 // or ICMP type + SrcPortEnd uint16 + DstPortOp uint8 + DstPort uint16 // or ICMP code + DstPortEnd uint16 + Adapter uint8 + RuleScope uint8 + Direction uint8 + TunnelId uint32 + Flags uint16 + TimeRange FwTimeRange + RuleAdaptCnt int32 + RuleAdapt [MAX_RULE_ADAPTERS]In6Addr +} + +func ToInAddr(ip net.IP) InAddr { + ip4 := ip.To4() + return InAddr{Addr: binary.BigEndian.Uint32(ip4)} +} + +func ToIn6Addr(ip net.IP) In6Addr { + ip6 := ip.To16() + var in6 In6Addr + in6.Addr[0] = binary.BigEndian.Uint32(ip6[0:]) + in6.Addr[1] = binary.BigEndian.Uint32(ip6[4:]) + in6.Addr[2] = binary.BigEndian.Uint32(ip6[8:]) + in6.Addr[3] = binary.BigEndian.Uint32(ip6[12:]) + return in6 +} + +const ( + SIOCGFWLVL = 0x400469c9 + SIOCSFWDF_ENABL = 0xc004692c + SIOCSFWDF_NEWID = 0xc01c692e + SIOCSFWDF_ADDRULES = 0xc020692f + SIOCSFWDF_DELID = 0xc0046931 + SIOCSFWDF_DELTYPE = 0xc0086933 +) + +//extern ioctl +func ioctl(fd int32, req uint32, arg uintptr) int32 + +const ( + FilterDev4 = "/dev/ipsec4_filt" + FilterDev6 = "/dev/ipsec6_filt" +) + +type DynamicFilter struct { + Level int32 + + dev *os.File +} + +func NewFilter(devName string) (*DynamicFilter, error) { + dev, err := os.OpenFile(devName, os.O_RDWR, 0755) + if err != nil { + return nil, err + } + + // Get firewall version + klvl := int32(0) + if rc := ioctl(int32(dev.Fd()), SIOCGFWLVL, uintptr(unsafe.Pointer(&klvl))); rc < 0 { + dev.Close() + return nil, fmt.Errorf("SIOCGFWLVL failed") + } + + // Enable dynamic filter rules + val := int32(0) + if rc := ioctl(int32(dev.Fd()), SIOCSFWDF_ENABL, uintptr(unsafe.Pointer(&val))); rc < 0 { + dev.Close() + return nil, fmt.Errorf("SIOCSFWDF_ENABL failed") + } + + // Remove any pre-existing "CALICO" filter + var dfType [DFMAXTYPE]byte + copy(dfType[:], "CALICO") + ioctl(int32(dev.Fd()), SIOCSFWDF_DELTYPE, uintptr(unsafe.Pointer(&dfType[0]))) + + df := &DynamicFilter{dev: dev, Level: klvl} + + return df, nil +} + +func (df *DynamicFilter) Close() { + if df.dev != nil { + df.dev.Close() + } +} + +func (df *DynamicFilter) NewId() (DfId, error) { + // Create new id with type "CALICO" + id := IdEntry{} + copy(id.Type[:], "CALICO") + if rc := ioctl(int32(df.dev.Fd()), SIOCSFWDF_NEWID, uintptr(unsafe.Pointer(&id))); rc < 0 { + return id.Id, fmt.Errorf("SIOCSFWDF_NEWID failed") + } + return id.Id, nil +} + +func (df *DynamicFilter) DeleteId(id DfId) error { + if rc := ioctl(int32(df.dev.Fd()), SIOCSFWDF_DELID, uintptr(unsafe.Pointer(&id))); rc < 0 { + return fmt.Errorf("SIOCSFWDF_DELID failed") + } + return nil +} + +func (df *DynamicFilter) addRules(ptrRules uintptr, count int, idAfter DfId) error { + mdf := ModDfRules{ + IdAfter: idAfter, + PtrRules: uint64(ptrRules), + RulesCnt: int32(count), + } + if rc := ioctl(int32(df.dev.Fd()), SIOCSFWDF_ADDRULES, uintptr(unsafe.Pointer(&mdf))); rc < 0 { + return fmt.Errorf("SIOCSFWDF_ADDRULES failed") + } + return nil +} + +func (df *DynamicFilter) AddRules(rules []DfFltrEntry, idAfter DfId) error { + if len(rules) == 0 { + return nil + } + return df.addRules(uintptr(unsafe.Pointer(&rules[0])), len(rules), idAfter) +} + +func (df *DynamicFilter) AddRules6(rules []Df6FltrEntry, idAfter DfId) error { + if len(rules) == 0 { + return nil + } + return df.addRules(uintptr(unsafe.Pointer(&rules[0])), len(rules), idAfter) +} + +const Allow = 1 +const Block = 2 + +const Out = 1 +const In = 2 + +const ACL = 1 + +const Switch = 1 +const Host = 2 + +type Rule struct { + Type int + RuleType int + Action int + + Direction int + Priority uint16 + RemotePort uint16 + LocalPort uint16 + Protocol uint16 + LocalAddress string + RemoteAddress string +} + +type Endpoint struct { + Ipv4Nets []string + Id DfId +} + +func (e *Endpoint) ApplyIPSecRules(rules ...*Rule) error { +// deja vu un endpoint quand calico-felix est relance + fmt.Println("ApplyIPSecRules", e) + for _, rule := range rules { + fmt.Println("rule:", rule) + } + return nil +} + +func NewEndpoint(ipv4Nets []string) (*Endpoint, error) { + endpoint := &Endpoint{Ipv4Nets: ipv4Nets} +fmt.Println("new endpoint: ipv4=", ipv4Nets) + +// endpoint.DfId, err := df.NewId() +// if err != nil { +// return nil, err +// } + return endpoint, nil +} + +func RemoveEndpoint(e *Endpoint) { +fmt.Println("remove endpoint: ", e) +// df.DeleteId(e.DfId) +} diff --git a/dataplane/aix/ipsets/ipset_defs.go b/dataplane/aix/ipsets/ipset_defs.go new file mode 100644 index 0000000..c2b9502 --- /dev/null +++ b/dataplane/aix/ipsets/ipset_defs.go @@ -0,0 +1,88 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package ipsets + +import ( + "github.com/projectcalico/libcalico-go/lib/set" +) + +// IPSetMetadata contains the metadata for a particular IP set, such as its name and type. +type IPSetMetadata struct { + SetID string + Type IPSetType +} + +// IPSetsDataplane is interface for managing a plane of ipSet objects. +type IPSetsDataplane interface { + AddOrReplaceIPSet(setMetadata IPSetMetadata, members []string) + AddMembers(setID string, newMembers []string) + RemoveMembers(setID string, removedMembers []string) + RemoveIPSet(setID string) +} + +// IPSetType constants for the different kinds of IP set. +type IPSetType string + +const ( + IPSetTypeHashIP IPSetType = "hash:ip" + IPSetTypeHashNet IPSetType = "hash:net" +) + +func (t IPSetType) SetType() string { + return string(t) +} + +func (t IPSetType) IsValid() bool { + switch t { + case IPSetTypeHashIP, IPSetTypeHashNet: + return true + } + return false +} + +// IPFamily constants to represent the IP family being managed by this IPSet +type IPFamily string + +const ( + IPFamilyV4 = IPFamily("inet") + IPFamilyV6 = IPFamily("inet6") +) + +func (f IPFamily) IsValid() bool { + switch f { + case IPFamilyV4, IPFamilyV6: + return true + } + return false +} + +// ipSet holds the state for a particular IP set. +type ipSet struct { + IPSetMetadata + Members set.Set +} + +// IPVersionConfig wraps up the metadata for a particular IP version. +type IPVersionConfig struct { + Family IPFamily +} + +func NewIPVersionConfig(family IPFamily) *IPVersionConfig { + return &IPVersionConfig{ + Family: family, + } +} diff --git a/dataplane/aix/ipsets/ipsets.go b/dataplane/aix/ipsets/ipsets.go new file mode 100644 index 0000000..32c24bf --- /dev/null +++ b/dataplane/aix/ipsets/ipsets.go @@ -0,0 +1,141 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package ipsets + +import ( + "strings" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/libcalico-go/lib/set" +) + +// IPSets manages a whole plane of IP sets, i.e. all the IPv4 sets, or all the IPv6 IP sets. +type IPSets struct { + IPVersionConfig *IPVersionConfig + ipSetIDToIPSet map[string]*ipSet + logCxt *log.Entry +} + +func NewIPSets(ipVersionConfig *IPVersionConfig) *IPSets { + return &IPSets{ + IPVersionConfig: ipVersionConfig, + ipSetIDToIPSet: map[string]*ipSet{}, + logCxt: log.WithFields(log.Fields{ + "family": ipVersionConfig.Family, + }), + } +} + +// AddOrReplaceIPSet is responsible for the creation (or replacement) of an IP set in the store +func (s *IPSets) AddOrReplaceIPSet(setMetadata IPSetMetadata, members []string) { + s.logCxt.WithFields(log.Fields{ + "setID": setMetadata.SetID, + "setType": setMetadata.Type, + }).Info("Creating IP set") + filteredMembers := s.filterMembers(members) + + // Create the IP set struct and stores it by id + setID := setMetadata.SetID + ipSet := &ipSet{ + IPSetMetadata: setMetadata, + Members: filteredMembers, + } + s.ipSetIDToIPSet[setID] = ipSet +} + +// RemoveIPSet is responsible for the removal of an IP set from the store +func (s *IPSets) RemoveIPSet(setID string) { + s.logCxt.WithField("setID", setID).Info("Removing IP set") + delete(s.ipSetIDToIPSet, setID) +} + +// AddMembers adds a range of new members to an existing IP set in the store +func (s *IPSets) AddMembers(setID string, newMembers []string) { + if len(newMembers) == 0 { + return + } + + ipSet := s.ipSetIDToIPSet[setID] + filteredMembers := s.filterMembers(newMembers) + if filteredMembers.Len() == 0 { + return + } + s.logCxt.WithFields(log.Fields{ + "setID": setID, + "filteredMembers": filteredMembers, + }).Info("Adding new members to IP set") + filteredMembers.Iter(func(m interface{}) error { + ipSet.Members.Add(m) + return nil + }) +} + +// RemoveMembers removes a range of members from an existing IP set in the store +func (s *IPSets) RemoveMembers(setID string, removedMembers []string) { + if len(removedMembers) == 0 { + return + } + + ipSet := s.ipSetIDToIPSet[setID] + filteredMembers := s.filterMembers(removedMembers) + if filteredMembers.Len() == 0 { + return + } + s.logCxt.WithFields(log.Fields{ + "setID": setID, + "filteredMembers": filteredMembers, + }).Info("Removing members from IP set") + + filteredMembers.Iter(func(m interface{}) error { + ipSet.Members.Discard(m) + return nil + }) +} + +// GetIPSetMembers returns all of the members for a given IP set +func (s *IPSets) GetIPSetMembers(setID string) []string { + var retVal []string + + ipSet := s.ipSetIDToIPSet[setID] + if ipSet == nil { + return nil + } + + ipSet.Members.Iter(func(item interface{}) error { + member := item.(string) + retVal = append(retVal, member) + return nil + }) + + return retVal +} + +// filterMembers filters out any members which are not of the correct +// ip family for the IPSet +func (s *IPSets) filterMembers(members []string) set.Set { + filtered := set.New() + wantIPV6 := s.IPVersionConfig.Family == IPFamilyV6 + for _, member := range members { + isIPV6 := strings.Index(member, ":") >= 0 + if wantIPV6 != isIPV6 { + continue + } + filtered.Add(member) + } + return filtered +} diff --git a/dataplane/aix/ipsets_mgr.go b/dataplane/aix/ipsets_mgr.go new file mode 100644 index 0000000..c443859 --- /dev/null +++ b/dataplane/aix/ipsets_mgr.go @@ -0,0 +1,62 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package aixdataplane + +import ( + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/dataplane/aix/ipsets" + "github.com/projectcalico/felix/proto" +) + +// ipSetsManager simply passes through IP set updates from the datastore to the ipsets.IPSets +// dataplane layer. +type ipSetsManager struct { + ipsetsDataplane ipsets.IPSetsDataplane +} + +func newIPSetsManager(ipsets ipsets.IPSetsDataplane) *ipSetsManager { + return &ipSetsManager{ + ipsetsDataplane: ipsets, + } +} + +// OnUpdate is called by the main dataplane driver loop during the first phase. It processes +// specific types of updates from the datastore. +func (m *ipSetsManager) OnUpdate(msg interface{}) { + switch msg := msg.(type) { + case *proto.IPSetDeltaUpdate: + log.WithField("ipSetId", msg.Id).Info("Processing IPSetDeltaUpdate") + m.ipsetsDataplane.AddMembers(msg.Id, msg.AddedMembers) + m.ipsetsDataplane.RemoveMembers(msg.Id, msg.RemovedMembers) + case *proto.IPSetUpdate: + log.WithField("ipSetId", msg.Id).Info("Processing IPSetUpdate") + metadata := ipsets.IPSetMetadata{ + Type: ipsets.IPSetTypeHashIP, + SetID: msg.Id, + } + m.ipsetsDataplane.AddOrReplaceIPSet(metadata, msg.Members) + case *proto.IPSetRemove: + log.WithField("ipSetId", msg.Id).Info("Processing IPSetRemove") + m.ipsetsDataplane.RemoveIPSet(msg.Id) + } +} + +func (m *ipSetsManager) CompleteDeferredWork() error { + // Nothing to do, we don't defer any work. + return nil +} diff --git a/dataplane/aix/policy_mgr.go b/dataplane/aix/policy_mgr.go new file mode 100644 index 0000000..09a3390 --- /dev/null +++ b/dataplane/aix/policy_mgr.go @@ -0,0 +1,64 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package aixdataplane + +import ( + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/dataplane/aix/policysets" + "github.com/projectcalico/felix/proto" +) + +// policyManager simply passes through Policy and Profile updates from the datastore to the +// PolicySets dataplane layer. +type policyManager struct { + policysetsDataplane policysets.PolicySetsDataplane +} + +func newPolicyManager(policysets policysets.PolicySetsDataplane) *policyManager { + return &policyManager{ + policysetsDataplane: policysets, + } +} + +// OnUpdate is called by the main dataplane driver loop during the first phase. It processes +// specific types of updates from the datastore. +func (m *policyManager) OnUpdate(msg interface{}) { + switch msg := msg.(type) { + case *proto.ActivePolicyUpdate: + log.WithField("policyID", msg.Id).Info("Processing ActivePolicyUpdate") + m.policysetsDataplane.AddOrReplacePolicySet(msg.Id.Name, msg.Policy) +//DBe m.policysetsDataplane.AddOrReplacePolicySet(policysets.PolicyNamePrefix+msg.Id.Name, msg.Policy) + case *proto.ActivePolicyRemove: + log.WithField("policyID", msg.Id).Info("Processing ActivePolicyRemove") + m.policysetsDataplane.RemovePolicySet(msg.Id.Name) +//DBe m.policysetsDataplane.RemovePolicySet(policysets.PolicyNamePrefix+msg.Id.Name) + case *proto.ActiveProfileUpdate: + log.WithField("profileId", msg.Id).Info("Processing ActiveProfileUpdate") + m.policysetsDataplane.AddOrReplacePolicySet(msg.Id.Name, msg.Profile) +//DBe m.policysetsDataplane.AddOrReplacePolicySet(policysets.ProfileNamePrefix+msg.Id.Name, msg.Profile) + case *proto.ActiveProfileRemove: + log.WithField("profileId", msg.Id).Info("Processing ActiveProfileRemove") + m.policysetsDataplane.RemovePolicySet(msg.Id.Name) +// DBe m.policysetsDataplane.RemovePolicySet(policysets.ProfileNamePrefix+msg.Id.Name) + } +} + +func (m *policyManager) CompleteDeferredWork() error { + // Nothing to do, we don't defer any work. + return nil +} diff --git a/dataplane/aix/policysets/policyset_defs.go b/dataplane/aix/policysets/policyset_defs.go new file mode 100644 index 0000000..1381578 --- /dev/null +++ b/dataplane/aix/policysets/policyset_defs.go @@ -0,0 +1,86 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package policysets + +import ( + "errors" + + "github.com/projectcalico/felix/dataplane/aix/ipsec" + "github.com/projectcalico/libcalico-go/lib/set" +) + +const ( + // the ip family of this policy set, currently set to V4. + // V6 will be added once dataplane support is available. + ipVersion uint8 = 4 + // default dataplane rule priority for any rules generated + // from a Policy set. + rulePriority uint16 = 1000 + // prefix to use for all policy names + PolicyNamePrefix string = "policy-" + // prefix to use for all profile names + ProfileNamePrefix string = "profile-" +) + +var ( + SkipRule = errors.New("Rule skipped") + MissingSet = errors.New("Missing IPSet") +) + +// PolicySetType constants for the different kinds of Policy set. +type PolicySetType string + +const ( + PolicySetTypePolicy PolicySetType = "policy" + PolicySetTypeProfile PolicySetType = "profile" +) + +func (t PolicySetType) SetType() string { + return string(t) +} + +// PolicySetMetadata contains the metadata for a particular Policy set, such as its name and type. +type PolicySetMetadata struct { + SetId string + Type PolicySetType +} + +// PolicySetsDataplane is a interface for managing a plane of policySet objects +type PolicySetsDataplane interface { + AddOrReplacePolicySet(setId string, policy interface{}) + RemovePolicySet(setId string) + NewRule(isInbound bool, priority uint16) *ipsec.Rule + GetPolicySetRules(setIds []string) (rules []*ipsec.Rule) + ProcessIpSetUpdate(ipSetId string) []string +} + +// policySet holds the state for a particular Policy set. +type policySet struct { + // metadata for the Policy set. + PolicySetMetadata + // the original policy received from the datatore, which could be + // either a Profile or a Policy. + Policy interface{} + // Each member of the Policy set is an ipsec rule computed from the + // Policy. When this Policy set needs to be applied, this set of + // rules is what will be sent to ipsec for enforcement. + Members set.Set + // The set of IP set ids which are referenced by this Policy set. We + // maintain this to make it easier to look up which Policy sets are + // impacted (in need of recomputation) after a IP set update occurs. + IpSetIds set.Set +} diff --git a/dataplane/aix/policysets/policysets.go b/dataplane/aix/policysets/policysets.go new file mode 100644 index 0000000..96f01e1 --- /dev/null +++ b/dataplane/aix/policysets/policysets.go @@ -0,0 +1,556 @@ +//+build aix + +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package policysets + +import ( +"fmt" + "strings" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/dataplane/aix/ipsec" + "github.com/projectcalico/felix/dataplane/aix/ipsets" + "github.com/projectcalico/felix/proto" + "github.com/projectcalico/libcalico-go/lib/set" +) + +// PolicySets manages a whole plane of policies/profiles +type PolicySets struct { + policySetIdToPolicySet map[string]*policySet + + IpSets []*ipsets.IPSets + + resyncRequired bool +} + +func NewPolicySets(ipsets []*ipsets.IPSets) *PolicySets { + return &PolicySets{ + policySetIdToPolicySet: map[string]*policySet{}, + IpSets: ipsets, + } +} + +// AddOrReplacePolicySet is responsible for the creation (or replacement) of a Policy set +// and it is capable of processing either Profiles or Policies from the datastore. +func (s *PolicySets) AddOrReplacePolicySet(setId string, policy interface{}) { + log.WithField("setID", setId).Info("Processing add/replace of Policy set") + + // Process the policy/profile from the datastore and convert it into + // equivalent rules which can be communicated to ipsec for enforcement in the + // dataplane. We compute these rules up front and cache them to avoid needing + // to recompute them each time the policy is applied to an endpoint. We also + // keep track of any IP sets which were referenced by the policy/profile so that + // we can easily tell which Policy sets are impacted when a IP set is modified. + var rules []*ipsec.Rule + var policyIpSetIds set.Set + + setMetadata := PolicySetMetadata{ + SetId: setId, + } + + switch p := policy.(type) { + case *proto.Policy: + // Incoming datastore object is a Policy + rules = s.convertPolicyToRules(setId, p.InboundRules, p.OutboundRules) + policyIpSetIds = getReferencedIpSetIds(p.InboundRules, p.OutboundRules) + setMetadata.Type = PolicySetTypePolicy + case *proto.Profile: + // Incoming datastore object is a Profile + rules = s.convertPolicyToRules(setId, p.InboundRules, p.OutboundRules) + policyIpSetIds = getReferencedIpSetIds(p.InboundRules, p.OutboundRules) + setMetadata.Type = PolicySetTypeProfile + } + + // Create the struct and store it off + policySet := &policySet{ + PolicySetMetadata: setMetadata, + Policy: policy, + Members: set.FromArray(rules), + IpSetIds: policyIpSetIds, + } + s.policySetIdToPolicySet[setMetadata.SetId] = policySet +} + +// RemovePolicySet is responsible for the removal of a Policy set +func (s *PolicySets) RemovePolicySet(setId string) { + log.WithField("setId", setId).Info("Processing removal of Policy set") + delete(s.policySetIdToPolicySet, setId) +} + +// GetPolicySetRules receives a list of Policy set ids and it computes the complete +// set of resultant ipsec rules which are needed to enforce all of the Policy sets. As +// the Policy sets are processed, we increment a priority number and assign it to each rule +// from the current set. By incremening the rule priority for each set, we ensure that all of +// the sets will be enforced and considered by the dataplane in the order intended by felix. +// Once all rules are gathered, we add a final pair of rules to default deny any traffic which +// has not matched any rules from any Policy sets. +func (s *PolicySets) GetPolicySetRules(setIds []string) (rules []*ipsec.Rule) { + // Rules from the first set will receive the default rule priority + currentPriority := rulePriority + + for _, setId := range setIds { + log.WithField("setId", setId).Debug("Gathering rules for policy set") + + policySet := s.policySetIdToPolicySet[setId] + if policySet == nil { + log.WithField("setId", setId).Error("Unable to find Policy set, this set will be skipped") + continue + } + + policySet.Members.Iter(func(item interface{}) error { + member := item.(*ipsec.Rule) + member.Priority = currentPriority + rules = append(rules, member) + return nil + }) + + // Increment the priority so that rules from the next set will be 'weaker' priority + // and therefore considered only after this current set of rules has failed to match. + currentPriority += 1 + } + + // Apply a default block rule for each direction at the end of the policy + rules = append(rules, s.NewRule(true, currentPriority), s.NewRule(false, currentPriority)) + + return +} + +// ProcessIpSetUpdate locates any Policy set(s) which reference the provided IP set, and causes +// those Policy sets to be recomputed (to ensure any rule address conditions are using the latest +// addres values from the IP set). A list of the Policy sets which were found and recomputed are +// is returned to the caller. +func (s *PolicySets) ProcessIpSetUpdate(ipSetId string) []string { + log.WithField("IPSetId", ipSetId).Info("IP set has changed, looking for associated policies") + stalePolicies := s.getPoliciesByIpSetId(ipSetId) + if len(stalePolicies) == 0 { + return nil + } + + log.WithFields(log.Fields{"IPSetId": ipSetId, "Policies": stalePolicies}).Info("Associated policies need to be refreshed") + for _, policyId := range stalePolicies { + policySet := s.policySetIdToPolicySet[policyId] + if policySet == nil { + log.WithFields(log.Fields{"IPSetId": ipSetId, "Policy": policyId}).Error("Unable to find Policy set, this set will be skipped") + continue + } + + s.AddOrReplacePolicySet(policySet.PolicySetMetadata.SetId, policySet.Policy) + } + + // Return the policies which were recalculated as a result of this update + return stalePolicies +} + +// getPoliciesByIpSetId locates any Policy set(s) which reference the provided IP set +func (s *PolicySets) getPoliciesByIpSetId(ipSetId string) (policies []string) { + for policySetId, policySet := range s.policySetIdToPolicySet { + policySet.IpSetIds.Iter(func(item interface{}) error { + id := item.(string) + if id == ipSetId { + policies = append(policies, policySetId) + } + return nil + }) + } + return +} + +// getReferencedIpSetIds returns all of the IP sets which are referenced by the provided +// inbound and outbound proto Rules. +func getReferencedIpSetIds(inboundRules []*proto.Rule, outboundRules []*proto.Rule) set.Set { + var rules []*proto.Rule + rules = append(rules, inboundRules...) + rules = append(rules, outboundRules...) + + ipSetIds := set.New() + for _, rule := range rules { + ipSetIds.AddAll(rule.SrcIpSetIds) + ipSetIds.AddAll(rule.DstIpSetIds) + } + + return ipSetIds +} + +// convertPolicyToRules converts the provided inbound and outbound proto rules into ipsec rules. +func (s *PolicySets) convertPolicyToRules(policyId string, inboundRules []*proto.Rule, outboundRules []*proto.Rule) (ipsecRules []*ipsec.Rule) { + log.WithField("policyId", policyId).Debug("ConvertPolicyToRules") + + inbound := s.protoRulesToIPSecRules(policyId, inboundRules, true) + ipsecRules = append(ipsecRules, inbound...) + + outbound := s.protoRulesToIPSecRules(policyId, outboundRules, false) + ipsecRules = append(ipsecRules, outbound...) + + for _, rule := range ipsecRules { + log.WithFields(log.Fields{"policyId": policyId, "rule": rule}).Debug("ConvertPolicyToRules final rule output") + } + + return +} + +// protoRulesToIPSecRules converts a set of proto rules into ipsec rules. +func (s *PolicySets) protoRulesToIPSecRules(policyId string, protoRules []*proto.Rule, isInbound bool) (rules []*ipsec.Rule) { + log.WithField("policyId", policyId).Debug("protoRulesToIPSecRules") + + for _, protoRule := range protoRules { + ipsecRules, err := s.protoRuleToIPSecRules(policyId, protoRule, isInbound) + if err != nil { + switch err { + case SkipRule: + log.WithField("rule", protoRule).Info("Rule was skipped") + default: + log.WithField("rule", protoRule).Infof("Rule could not be converted, error: %v", err) + } + continue + } + rules = append(rules, ipsecRules...) + } + + return +} + +// protoRuleToIPSecRules converts a proto rule into equivalent ipsec rules (one or more resultant rules). For Windows RS3, +// there are a few limitations to be aware of: +// +// The following types of rules are not supported in this release and will be logged+skipped: +// Rules with: Negative match criteria, Actions other than 'allow' or 'deny', Port ranges, and ICMP type/codes. +// +func (s *PolicySets) protoRuleToIPSecRules(policyId string, pRule *proto.Rule, isInbound bool) ([]*ipsec.Rule, error) { + log.WithField("policyId", policyId).Debug("protoRuleToIPSecRules") + +fmt.Println("***** protoRuleToIPSecRules", pRule) + + // Check IpVersion + if pRule.IpVersion != 0 && pRule.IpVersion != proto.IPVersion(ipVersion) { + log.WithField("rule", pRule).Info("Skipping rule because it is for an unsupported IP version.") + return nil, SkipRule + } + + // Skip rules with negative match criteria, these are not supported in this version + if ruleHasNegativeMatches(pRule) { + log.WithField("rule", pRule).Info("Skipping rule because it contains negative matches (currently unsupported).") + return nil, SkipRule + } + + // Skip rules with port ranges, only a single port is supported in this version + if portsContainRanges(pRule.SrcPorts) || portsContainRanges(pRule.DstPorts) { + log.WithField("rule", pRule).Info("Skipping rule because it contains port ranges (currently unsupported).") + return nil, SkipRule + } + + // Skip rules with ICMP type/codes, these are not supported + if pRule.Icmp != nil { + log.WithField("rule", pRule).Info("Skipping rule because it contains ICMP type or code (currently unsupported).") + return nil, SkipRule + } + + // Filter the Src and Dst CIDRs to only the IP version that we're rendering + ruleCopy := *pRule + + ruleCopy.SrcNet = pRule.SrcNet + ruleCopy.NotSrcNet = pRule.NotSrcNet + ruleCopy.DstNet = pRule.DstNet + ruleCopy.NotDstNet = pRule.NotDstNet + + // Log with the rule details for context + logCxt := log.WithField("rule", ruleCopy) + + // Start with a new empty ipsec rule + var ipsecRules []*ipsec.Rule + ipsecRule := s.NewRule(isInbound, rulePriority) + +/* +dfEntry := &DfFltrEntry{} +dfEntry.Smr = ipsec.FLTR_MASK +dfEntry.Dmr = ipsec.FLTR_MASK +dfEntry.RuleScope = ipsec.FLTR_LOCAL +dfEntry.Flags = ipsec.FLTR_LOGNO | ipsec.FRAGMENTS_YES +if isInbound { + dfEntry.Direction = ipsec.FLTR_INBOUND +} else { + dfEntry.Direction = ipsec.FLTR_OUTBOUND +} +switch strings.ToLower(pRule.Action) { +case "", "allow": + dfEntry.Action = ipsec.FLTR_PERMIT +case "deny": + dfEntry.Action = ipsec.FLTR_DENY +default: + return nil, SkipRule +} +if pRule.Icmp != nil { // XXX et protocol == ICMP (v6)? + switch icmp := pRule.Icmp.(type) { + case *proto.Rule_IcmpType: + dfEntry.SrcPortOp = ipsec.FLTR_EQ + dfEntry.SrcPort = icmp.IcmpType + dfEntry.SrcPortEnd = 0 + dfEntry.DstPortOp = ipsec.FLTR_ANY + case *proto.Rule_IcmpTypeCode: + dfEntry.SrcPortOp = ipsec.FLTR_EQ + dfEntry.SrcPort = icmp.IcmpTypeCode.Type + dfEntry.SrcPortEnd = 0 + dfEntry.DstPortOp = ipsec.FLTR_EQ + dfEntry.DstPort = icmp.IcmpTypeCode.Code + dfEntry.DstPortEnd = 0 + } +} +if srcNet != "" { + ip, ipnet, err := net.ParseCIDR(srcNet) + dfEntry.SrcAddr = ipsec.ToInAddr(ip.To4()) + dfEntry.SrcMaskOrRange = ipsec.ToInAddr(ipnet.Mask.To4()) +} +if dstNet != "" { + ip, ipnet, err := net.ParseCIDR(dstNet) + dfEntry.DstAddr = ipsec.ToInAddr(ip.To4()) + dfEntry.DstMaskOrRange = ipsec.ToInAddr(ipnet.Mask.To4()) +} +if srcPortRange != nil { + dfEntry.SrcPortOp = ipsec.FLTR_EQ + dfEntry.SrcPort = srcPortRange.First + dfEntry.SrcPortEnd = srcPortRange.Last +} else { + dfEntry.SrcPortOp = ipsec.FLTR_ANY // XXX do not overwrite icmp! +} +if dstPortRange != nil { + dfEntry.DstPortOp = ipsec.FLTR_EQ + dfEntry.DstPort = dstPortRange.First + dfEntry.DstPortEnd = dstPortRange.Last +} else { + dfEntry.DstPortOp = ipsec.FLTR_ANY // XXX do not overwrite icmp! +} +*/ + // + // Action + // + switch strings.ToLower(ruleCopy.Action) { + case "", "allow": + ipsecRule.Action = ipsec.Allow + case "deny": + ipsecRule.Action = ipsec.Block + case "next-tier", "pass", "log": + logCxt.WithField("action", ruleCopy.Action).Info("This rule action is not supported, rule will be skipped") + return nil, SkipRule + default: + logCxt.WithField("action", ruleCopy.Action).Panic("Unknown rule action") + } + + // + // Source ports + // + if len(ruleCopy.SrcPorts) > 0 { + // Windows RS3 limitation, single port + ports := uint16(ruleCopy.SrcPorts[0].First) + + if isInbound { + ipsecRule.RemotePort = ports + logCxt.WithField("RemotePort", ipsecRule.RemotePort).Debug("Adding Source Ports as RemotePort condition") + } else { + ipsecRule.LocalPort = ports + logCxt.WithField("LocalPort", ipsecRule.LocalPort).Debug("Adding Source Ports as LocalPort condition") + } + } + + // + // Destination Ports + // + if len(ruleCopy.DstPorts) > 0 { + // Windows RS3 limitation, single port (start port) + ports := uint16(ruleCopy.DstPorts[0].First) + + if isInbound { + ipsecRule.LocalPort = ports + logCxt.WithField("LocalPort", ipsecRule.LocalPort).Debug("Adding Destination Ports as LocalPort condition") + } else { + ipsecRule.RemotePort = ports + logCxt.WithField("RemotePort", ipsecRule.RemotePort).Debug("Adding Destination Ports as RemotePort condition") + } + } + + // + // Protocol + // + if ruleCopy.Protocol != nil { + switch p := ruleCopy.Protocol.NumberOrName.(type) { + case *proto.Protocol_Name: + logCxt.WithField("protoName", p.Name).Debug("Adding Protocol Name condition") + ipsecRule.Protocol = protocolNameToNumber(p.Name) + case *proto.Protocol_Number: + logCxt.WithField("protoNum", p.Number).Debug("Adding Protocol number condition") + ipsecRule.Protocol = uint16(p.Number) + } + } + + // + // Source Neworks and IPSets + // + localAddresses := []string{""} // ensures slice always has at least one value + remoteAddresses := []string{""} + + srcAddresses := ruleCopy.SrcNet + + if len(ruleCopy.SrcIpSetIds) > 0 { + ipsetAddresses, err := s.getIPSetAddresses(ruleCopy.SrcIpSetIds) + if err != nil { + logCxt.Info("SrcIpSetIds could not be resolved, rule will be skipped") + return nil, SkipRule + } + srcAddresses = append(srcAddresses, ipsetAddresses...) + } + + if len(srcAddresses) > 0 { + if isInbound { + remoteAddresses = srcAddresses + logCxt.WithField("RemoteAddress", remoteAddresses).Debug("Adding Source Networks/IPsets as RemoteAddress conditions") + } else { + localAddresses = srcAddresses + logCxt.WithField("LocalAddress", localAddresses).Debug("Adding Source Networks/IPsets as LocalAddress conditions") + } + } + + // + // Destination Networks and IPSets + // + dstAddresses := ruleCopy.DstNet + + if len(ruleCopy.DstIpSetIds) > 0 { + ipsetAddresses, err := s.getIPSetAddresses(ruleCopy.DstIpSetIds) + if err != nil { + logCxt.Info("DstIpSetIds could not be resolved, rule will be skipped") + return nil, SkipRule + } + dstAddresses = append(dstAddresses, ipsetAddresses...) + } + + if len(dstAddresses) > 0 { + if isInbound { + localAddresses = dstAddresses + logCxt.WithField("LocalAddress", localAddresses).Debug("Adding Destination Networks/IPsets as LocalAddress condition") + } else { + remoteAddresses = dstAddresses + logCxt.WithField("RemoteAddress", remoteAddresses).Debug("Adding Destination Networks/IPsets as RemoteAddress condition") + } + } + + // ipsec only supports a single address/cidr per source or destination condition. + for _, localAddr := range localAddresses { + for _, remoteAddr := range remoteAddresses { + newRule := *ipsecRule + newRule.LocalAddress = localAddr + newRule.RemoteAddress = remoteAddr + // Add this rule to the rules being returned + ipsecRules = append(ipsecRules, &newRule) + } + } + + return ipsecRules, nil +} + +func ruleHasNegativeMatches(pRule *proto.Rule) bool { + if len(pRule.NotSrcNet) > 0 || len(pRule.NotDstNet) > 0 { + return true + } + if len(pRule.NotSrcPorts) > 0 || len(pRule.NotDstPorts) > 0 { + return true + } + if len(pRule.NotSrcIpSetIds) > 0 || len(pRule.NotDstIpSetIds) > 0 { + return true + } + if pRule.NotProtocol != nil { + return true + } + if pRule.NotIcmp != nil { + return true + } + return false +} + +func portsContainRanges(ports []*proto.PortRange) bool { + if len(ports) > 1 { + return true + } + + for _, portRange := range ports { + if portRange.First != portRange.Last { + return true + } + } + return false +} + +// getIPSetAddresses retrieves all of the ip addresses (members) referenced by the provided +// IP sets. +func (s *PolicySets) getIPSetAddresses(setIds []string) ([]string, error) { + var addresses []string + var found bool + + for _, ipsetId := range setIds { + found = false + for _, ipSets := range s.IpSets { + ipSet := ipSets.GetIPSetMembers(ipsetId) + if ipSet == nil { + continue + } + addresses = append(addresses, ipSet...) + found = true + break + } + + if !found { + log.WithField("ipsetId", ipsetId).Info("IPSet could not be found") + return nil, MissingSet + } + } + + return addresses, nil +} + +// protocolNameToNumber converts a protocol name to its numeric representation (returned as string) +func protocolNameToNumber(protocolName string) uint16 { + switch strings.ToLower(protocolName) { + case "tcp": + return 6 + case "udp": + return 17 + case "icmp": + return 1 + case "icmpv6": + return 58 + case "sctp": + return 132 + case "udplite": + return 136 + default: + return ipsec.FWPROTO_ALL // any + } +} + +// NewRule returns a new ipsec rule object instantiated with default values. +func (s *PolicySets) NewRule(isInbound bool, priority uint16) *ipsec.Rule { + direction := ipsec.Out + if isInbound { + direction = ipsec.In + } + + return &ipsec.Rule{ + Type: ipsec.ACL, + RuleType: ipsec.Switch, + Action: ipsec.Block, + Direction: direction, + Protocol: 254, // Any, only required for RS3 XXX ipsec.FWPROTO_ALL + Priority: priority, + } +} diff --git a/dataplane/driver.go b/dataplane/driver.go index 089b0d2..68c4986 100644 --- a/dataplane/driver.go +++ b/dataplane/driver.go @@ -1,4 +1,4 @@ -// +build !windows +// +build !aix,!windows // Copyright (c) 2017 Tigera, Inc. All rights reserved. // diff --git a/dataplane/driver_aix.go b/dataplane/driver_aix.go new file mode 100644 index 0000000..70d9cd7 --- /dev/null +++ b/dataplane/driver_aix.go @@ -0,0 +1,42 @@ +// Copyright (c) 2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package dataplane + +import ( + "os/exec" + + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/config" + "github.com/projectcalico/felix/dataplane/aix" + "github.com/projectcalico/libcalico-go/lib/health" +) + +func StartDataplaneDriver(configParams *config.Config, healthAggregator *health.HealthAggregator) (DataplaneDriver, *exec.Cmd) { + log.Info("Using AIX dataplane driver.") + + dpConfig := aixdataplane.Config{ + IPv6Enabled: configParams.Ipv6Support, + IPIPEnabled: configParams.IpInIpEnabled, + IPIPTunnelAddress: configParams.IpInIpTunnelAddr, + IPIPMTU: configParams.IpInIpMtu, + HealthAggregator: healthAggregator, + } + + aixDP := aixdataplane.NewAIXDataplaneDriver(dpConfig) + aixDP.Start() + + return aixDP, nil +} diff --git a/logutils/logutils_aix.go b/logutils/logutils_aix.go new file mode 100644 index 0000000..cbb6c54 --- /dev/null +++ b/logutils/logutils_aix.go @@ -0,0 +1,69 @@ +// Copyright (c) 2016-2017 Tigera, Inc. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package logutils + +import ( + "io" + "log/syslog" + "os" + "path" + + "github.com/mipearson/rfw" + log "github.com/sirupsen/logrus" + + "github.com/projectcalico/felix/config" + "github.com/projectcalico/libcalico-go/lib/logutils" +) + +func getFileDestination(configParams *config.Config, logLevel log.Level) (fileDest *logutils.Destination, fileDirErr error, fileOpenErr error) { + fileDirErr = os.MkdirAll(path.Dir(configParams.LogFilePath), 0755) + var rotAwareFile io.Writer + rotAwareFile, fileOpenErr = rfw.Open(configParams.LogFilePath, 0644) + if fileDirErr == nil && fileOpenErr == nil { + fileDest = logutils.NewStreamDestination( + logLevel, + rotAwareFile, + make(chan logutils.QueuedLog, logQueueSize), + configParams.DebugDisableLogDropping, + counterLogErrors, + ) + } + return +} + +func getSyslogDestination(configParams *config.Config, logLevel log.Level) (*logutils.Destination, error) { + // Set net/addr to "" so we connect to the system syslog server rather + // than a remote one. + net := "" + addr := "" + // The priority parameter is a combination of facility and default + // severity. We want to log with the standard LOG_USER facility; the + // severity is actually irrelevant because the hook always overrides + // it. + priority := syslog.LOG_USER | syslog.LOG_INFO + tag := "calico-felix" + w, sysErr := syslog.Dial(net, addr, priority, tag) + if sysErr == nil { + syslogDest := logutils.NewSyslogDestination( + logLevel, + w, + make(chan logutils.QueuedLog, logQueueSize), + configParams.DebugDisableLogDropping, + counterLogErrors, + ) + return syslogDest, sysErr + } + return nil, sysErr +} diff --git a/proto/felixbackend.pb.go b/proto/felixbackend.pb.go new file mode 100644 index 0000000..2dee946 --- /dev/null +++ b/proto/felixbackend.pb.go @@ -0,0 +1,11602 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: felixbackend.proto + +/* + Package proto is a generated protocol buffer package. + + It is generated from these files: + felixbackend.proto + + It has these top-level messages: + ToDataplane + FromDataplane + ConfigUpdate + InSync + IPSetUpdate + IPSetDeltaUpdate + IPSetRemove + ActiveProfileUpdate + ActiveProfileRemove + ProfileID + Profile + ActivePolicyUpdate + ActivePolicyRemove + PolicyID + Policy + Rule + IcmpTypeAndCode + Protocol + PortRange + WorkloadEndpointID + WorkloadEndpointUpdate + WorkloadEndpoint + WorkloadEndpointRemove + HostEndpointID + HostEndpointUpdate + HostEndpoint + HostEndpointRemove + TierInfo + NatInfo + ProcessStatusUpdate + HostEndpointStatusUpdate + EndpointStatus + HostEndpointStatusRemove + WorkloadEndpointStatusUpdate + WorkloadEndpointStatusRemove + HostMetadataUpdate + HostMetadataRemove + IPAMPoolUpdate + IPAMPoolRemove + IPAMPool +*/ +package proto + +import proto1 "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +import binary "encoding/binary" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto1.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto1.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +type IPVersion int32 + +const ( + IPVersion_ANY IPVersion = 0 + IPVersion_IPV4 IPVersion = 4 + IPVersion_IPV6 IPVersion = 6 +) + +var IPVersion_name = map[int32]string{ + 0: "ANY", + 4: "IPV4", + 6: "IPV6", +} +var IPVersion_value = map[string]int32{ + "ANY": 0, + "IPV4": 4, + "IPV6": 6, +} + +func (x IPVersion) String() string { + return proto1.EnumName(IPVersion_name, int32(x)) +} +func (IPVersion) EnumDescriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{0} } + +type IPSetUpdate_IPSetType int32 + +const ( + IPSetUpdate_IP IPSetUpdate_IPSetType = 0 + IPSetUpdate_IP_AND_PORT IPSetUpdate_IPSetType = 1 +) + +var IPSetUpdate_IPSetType_name = map[int32]string{ + 0: "IP", + 1: "IP_AND_PORT", +} +var IPSetUpdate_IPSetType_value = map[string]int32{ + "IP": 0, + "IP_AND_PORT": 1, +} + +func (x IPSetUpdate_IPSetType) String() string { + return proto1.EnumName(IPSetUpdate_IPSetType_name, int32(x)) +} +func (IPSetUpdate_IPSetType) EnumDescriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{4, 0} +} + +type ToDataplane struct { + // Sequence number incremented with each message. Useful for correlating + // messages in logs. + SequenceNumber uint64 `protobuf:"varint,15,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"` + // Types that are valid to be assigned to Payload: + // *ToDataplane_InSync + // *ToDataplane_IpsetUpdate + // *ToDataplane_IpsetDeltaUpdate + // *ToDataplane_IpsetRemove + // *ToDataplane_ActiveProfileUpdate + // *ToDataplane_ActiveProfileRemove + // *ToDataplane_ActivePolicyUpdate + // *ToDataplane_ActivePolicyRemove + // *ToDataplane_HostEndpointUpdate + // *ToDataplane_HostEndpointRemove + // *ToDataplane_WorkloadEndpointUpdate + // *ToDataplane_WorkloadEndpointRemove + // *ToDataplane_ConfigUpdate + // *ToDataplane_HostMetadataUpdate + // *ToDataplane_HostMetadataRemove + // *ToDataplane_IpamPoolUpdate + // *ToDataplane_IpamPoolRemove + Payload isToDataplane_Payload `protobuf_oneof:"payload"` +} + +func (m *ToDataplane) Reset() { *m = ToDataplane{} } +func (m *ToDataplane) String() string { return proto1.CompactTextString(m) } +func (*ToDataplane) ProtoMessage() {} +func (*ToDataplane) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{0} } + +type isToDataplane_Payload interface { + isToDataplane_Payload() + MarshalTo([]byte) (int, error) + Size() int +} + +type ToDataplane_InSync struct { + InSync *InSync `protobuf:"bytes,1,opt,name=in_sync,json=inSync,oneof"` +} +type ToDataplane_IpsetUpdate struct { + IpsetUpdate *IPSetUpdate `protobuf:"bytes,2,opt,name=ipset_update,json=ipsetUpdate,oneof"` +} +type ToDataplane_IpsetDeltaUpdate struct { + IpsetDeltaUpdate *IPSetDeltaUpdate `protobuf:"bytes,3,opt,name=ipset_delta_update,json=ipsetDeltaUpdate,oneof"` +} +type ToDataplane_IpsetRemove struct { + IpsetRemove *IPSetRemove `protobuf:"bytes,4,opt,name=ipset_remove,json=ipsetRemove,oneof"` +} +type ToDataplane_ActiveProfileUpdate struct { + ActiveProfileUpdate *ActiveProfileUpdate `protobuf:"bytes,5,opt,name=active_profile_update,json=activeProfileUpdate,oneof"` +} +type ToDataplane_ActiveProfileRemove struct { + ActiveProfileRemove *ActiveProfileRemove `protobuf:"bytes,6,opt,name=active_profile_remove,json=activeProfileRemove,oneof"` +} +type ToDataplane_ActivePolicyUpdate struct { + ActivePolicyUpdate *ActivePolicyUpdate `protobuf:"bytes,7,opt,name=active_policy_update,json=activePolicyUpdate,oneof"` +} +type ToDataplane_ActivePolicyRemove struct { + ActivePolicyRemove *ActivePolicyRemove `protobuf:"bytes,8,opt,name=active_policy_remove,json=activePolicyRemove,oneof"` +} +type ToDataplane_HostEndpointUpdate struct { + HostEndpointUpdate *HostEndpointUpdate `protobuf:"bytes,9,opt,name=host_endpoint_update,json=hostEndpointUpdate,oneof"` +} +type ToDataplane_HostEndpointRemove struct { + HostEndpointRemove *HostEndpointRemove `protobuf:"bytes,10,opt,name=host_endpoint_remove,json=hostEndpointRemove,oneof"` +} +type ToDataplane_WorkloadEndpointUpdate struct { + WorkloadEndpointUpdate *WorkloadEndpointUpdate `protobuf:"bytes,11,opt,name=workload_endpoint_update,json=workloadEndpointUpdate,oneof"` +} +type ToDataplane_WorkloadEndpointRemove struct { + WorkloadEndpointRemove *WorkloadEndpointRemove `protobuf:"bytes,12,opt,name=workload_endpoint_remove,json=workloadEndpointRemove,oneof"` +} +type ToDataplane_ConfigUpdate struct { + ConfigUpdate *ConfigUpdate `protobuf:"bytes,13,opt,name=config_update,json=configUpdate,oneof"` +} +type ToDataplane_HostMetadataUpdate struct { + HostMetadataUpdate *HostMetadataUpdate `protobuf:"bytes,14,opt,name=host_metadata_update,json=hostMetadataUpdate,oneof"` +} +type ToDataplane_HostMetadataRemove struct { + HostMetadataRemove *HostMetadataRemove `protobuf:"bytes,18,opt,name=host_metadata_remove,json=hostMetadataRemove,oneof"` +} +type ToDataplane_IpamPoolUpdate struct { + IpamPoolUpdate *IPAMPoolUpdate `protobuf:"bytes,16,opt,name=ipam_pool_update,json=ipamPoolUpdate,oneof"` +} +type ToDataplane_IpamPoolRemove struct { + IpamPoolRemove *IPAMPoolRemove `protobuf:"bytes,17,opt,name=ipam_pool_remove,json=ipamPoolRemove,oneof"` +} + +func (*ToDataplane_InSync) isToDataplane_Payload() {} +func (*ToDataplane_IpsetUpdate) isToDataplane_Payload() {} +func (*ToDataplane_IpsetDeltaUpdate) isToDataplane_Payload() {} +func (*ToDataplane_IpsetRemove) isToDataplane_Payload() {} +func (*ToDataplane_ActiveProfileUpdate) isToDataplane_Payload() {} +func (*ToDataplane_ActiveProfileRemove) isToDataplane_Payload() {} +func (*ToDataplane_ActivePolicyUpdate) isToDataplane_Payload() {} +func (*ToDataplane_ActivePolicyRemove) isToDataplane_Payload() {} +func (*ToDataplane_HostEndpointUpdate) isToDataplane_Payload() {} +func (*ToDataplane_HostEndpointRemove) isToDataplane_Payload() {} +func (*ToDataplane_WorkloadEndpointUpdate) isToDataplane_Payload() {} +func (*ToDataplane_WorkloadEndpointRemove) isToDataplane_Payload() {} +func (*ToDataplane_ConfigUpdate) isToDataplane_Payload() {} +func (*ToDataplane_HostMetadataUpdate) isToDataplane_Payload() {} +func (*ToDataplane_HostMetadataRemove) isToDataplane_Payload() {} +func (*ToDataplane_IpamPoolUpdate) isToDataplane_Payload() {} +func (*ToDataplane_IpamPoolRemove) isToDataplane_Payload() {} + +func (m *ToDataplane) GetPayload() isToDataplane_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *ToDataplane) GetSequenceNumber() uint64 { + if m != nil { + return m.SequenceNumber + } + return 0 +} + +func (m *ToDataplane) GetInSync() *InSync { + if x, ok := m.GetPayload().(*ToDataplane_InSync); ok { + return x.InSync + } + return nil +} + +func (m *ToDataplane) GetIpsetUpdate() *IPSetUpdate { + if x, ok := m.GetPayload().(*ToDataplane_IpsetUpdate); ok { + return x.IpsetUpdate + } + return nil +} + +func (m *ToDataplane) GetIpsetDeltaUpdate() *IPSetDeltaUpdate { + if x, ok := m.GetPayload().(*ToDataplane_IpsetDeltaUpdate); ok { + return x.IpsetDeltaUpdate + } + return nil +} + +func (m *ToDataplane) GetIpsetRemove() *IPSetRemove { + if x, ok := m.GetPayload().(*ToDataplane_IpsetRemove); ok { + return x.IpsetRemove + } + return nil +} + +func (m *ToDataplane) GetActiveProfileUpdate() *ActiveProfileUpdate { + if x, ok := m.GetPayload().(*ToDataplane_ActiveProfileUpdate); ok { + return x.ActiveProfileUpdate + } + return nil +} + +func (m *ToDataplane) GetActiveProfileRemove() *ActiveProfileRemove { + if x, ok := m.GetPayload().(*ToDataplane_ActiveProfileRemove); ok { + return x.ActiveProfileRemove + } + return nil +} + +func (m *ToDataplane) GetActivePolicyUpdate() *ActivePolicyUpdate { + if x, ok := m.GetPayload().(*ToDataplane_ActivePolicyUpdate); ok { + return x.ActivePolicyUpdate + } + return nil +} + +func (m *ToDataplane) GetActivePolicyRemove() *ActivePolicyRemove { + if x, ok := m.GetPayload().(*ToDataplane_ActivePolicyRemove); ok { + return x.ActivePolicyRemove + } + return nil +} + +func (m *ToDataplane) GetHostEndpointUpdate() *HostEndpointUpdate { + if x, ok := m.GetPayload().(*ToDataplane_HostEndpointUpdate); ok { + return x.HostEndpointUpdate + } + return nil +} + +func (m *ToDataplane) GetHostEndpointRemove() *HostEndpointRemove { + if x, ok := m.GetPayload().(*ToDataplane_HostEndpointRemove); ok { + return x.HostEndpointRemove + } + return nil +} + +func (m *ToDataplane) GetWorkloadEndpointUpdate() *WorkloadEndpointUpdate { + if x, ok := m.GetPayload().(*ToDataplane_WorkloadEndpointUpdate); ok { + return x.WorkloadEndpointUpdate + } + return nil +} + +func (m *ToDataplane) GetWorkloadEndpointRemove() *WorkloadEndpointRemove { + if x, ok := m.GetPayload().(*ToDataplane_WorkloadEndpointRemove); ok { + return x.WorkloadEndpointRemove + } + return nil +} + +func (m *ToDataplane) GetConfigUpdate() *ConfigUpdate { + if x, ok := m.GetPayload().(*ToDataplane_ConfigUpdate); ok { + return x.ConfigUpdate + } + return nil +} + +func (m *ToDataplane) GetHostMetadataUpdate() *HostMetadataUpdate { + if x, ok := m.GetPayload().(*ToDataplane_HostMetadataUpdate); ok { + return x.HostMetadataUpdate + } + return nil +} + +func (m *ToDataplane) GetHostMetadataRemove() *HostMetadataRemove { + if x, ok := m.GetPayload().(*ToDataplane_HostMetadataRemove); ok { + return x.HostMetadataRemove + } + return nil +} + +func (m *ToDataplane) GetIpamPoolUpdate() *IPAMPoolUpdate { + if x, ok := m.GetPayload().(*ToDataplane_IpamPoolUpdate); ok { + return x.IpamPoolUpdate + } + return nil +} + +func (m *ToDataplane) GetIpamPoolRemove() *IPAMPoolRemove { + if x, ok := m.GetPayload().(*ToDataplane_IpamPoolRemove); ok { + return x.IpamPoolRemove + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*ToDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) { + return _ToDataplane_OneofMarshaler, _ToDataplane_OneofUnmarshaler, _ToDataplane_OneofSizer, []interface{}{ + (*ToDataplane_InSync)(nil), + (*ToDataplane_IpsetUpdate)(nil), + (*ToDataplane_IpsetDeltaUpdate)(nil), + (*ToDataplane_IpsetRemove)(nil), + (*ToDataplane_ActiveProfileUpdate)(nil), + (*ToDataplane_ActiveProfileRemove)(nil), + (*ToDataplane_ActivePolicyUpdate)(nil), + (*ToDataplane_ActivePolicyRemove)(nil), + (*ToDataplane_HostEndpointUpdate)(nil), + (*ToDataplane_HostEndpointRemove)(nil), + (*ToDataplane_WorkloadEndpointUpdate)(nil), + (*ToDataplane_WorkloadEndpointRemove)(nil), + (*ToDataplane_ConfigUpdate)(nil), + (*ToDataplane_HostMetadataUpdate)(nil), + (*ToDataplane_HostMetadataRemove)(nil), + (*ToDataplane_IpamPoolUpdate)(nil), + (*ToDataplane_IpamPoolRemove)(nil), + } +} + +func _ToDataplane_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error { + m := msg.(*ToDataplane) + // payload + switch x := m.Payload.(type) { + case *ToDataplane_InSync: + _ = b.EncodeVarint(1<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.InSync); err != nil { + return err + } + case *ToDataplane_IpsetUpdate: + _ = b.EncodeVarint(2<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IpsetUpdate); err != nil { + return err + } + case *ToDataplane_IpsetDeltaUpdate: + _ = b.EncodeVarint(3<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IpsetDeltaUpdate); err != nil { + return err + } + case *ToDataplane_IpsetRemove: + _ = b.EncodeVarint(4<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IpsetRemove); err != nil { + return err + } + case *ToDataplane_ActiveProfileUpdate: + _ = b.EncodeVarint(5<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ActiveProfileUpdate); err != nil { + return err + } + case *ToDataplane_ActiveProfileRemove: + _ = b.EncodeVarint(6<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ActiveProfileRemove); err != nil { + return err + } + case *ToDataplane_ActivePolicyUpdate: + _ = b.EncodeVarint(7<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ActivePolicyUpdate); err != nil { + return err + } + case *ToDataplane_ActivePolicyRemove: + _ = b.EncodeVarint(8<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ActivePolicyRemove); err != nil { + return err + } + case *ToDataplane_HostEndpointUpdate: + _ = b.EncodeVarint(9<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostEndpointUpdate); err != nil { + return err + } + case *ToDataplane_HostEndpointRemove: + _ = b.EncodeVarint(10<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostEndpointRemove); err != nil { + return err + } + case *ToDataplane_WorkloadEndpointUpdate: + _ = b.EncodeVarint(11<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.WorkloadEndpointUpdate); err != nil { + return err + } + case *ToDataplane_WorkloadEndpointRemove: + _ = b.EncodeVarint(12<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.WorkloadEndpointRemove); err != nil { + return err + } + case *ToDataplane_ConfigUpdate: + _ = b.EncodeVarint(13<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ConfigUpdate); err != nil { + return err + } + case *ToDataplane_HostMetadataUpdate: + _ = b.EncodeVarint(14<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostMetadataUpdate); err != nil { + return err + } + case *ToDataplane_HostMetadataRemove: + _ = b.EncodeVarint(18<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostMetadataRemove); err != nil { + return err + } + case *ToDataplane_IpamPoolUpdate: + _ = b.EncodeVarint(16<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IpamPoolUpdate); err != nil { + return err + } + case *ToDataplane_IpamPoolRemove: + _ = b.EncodeVarint(17<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IpamPoolRemove); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("ToDataplane.Payload has unexpected type %T", x) + } + return nil +} + +func _ToDataplane_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { + m := msg.(*ToDataplane) + switch tag { + case 1: // payload.in_sync + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(InSync) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_InSync{msg} + return true, err + case 2: // payload.ipset_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IPSetUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_IpsetUpdate{msg} + return true, err + case 3: // payload.ipset_delta_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IPSetDeltaUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_IpsetDeltaUpdate{msg} + return true, err + case 4: // payload.ipset_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IPSetRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_IpsetRemove{msg} + return true, err + case 5: // payload.active_profile_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ActiveProfileUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_ActiveProfileUpdate{msg} + return true, err + case 6: // payload.active_profile_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ActiveProfileRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_ActiveProfileRemove{msg} + return true, err + case 7: // payload.active_policy_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ActivePolicyUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_ActivePolicyUpdate{msg} + return true, err + case 8: // payload.active_policy_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ActivePolicyRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_ActivePolicyRemove{msg} + return true, err + case 9: // payload.host_endpoint_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostEndpointUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_HostEndpointUpdate{msg} + return true, err + case 10: // payload.host_endpoint_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostEndpointRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_HostEndpointRemove{msg} + return true, err + case 11: // payload.workload_endpoint_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(WorkloadEndpointUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_WorkloadEndpointUpdate{msg} + return true, err + case 12: // payload.workload_endpoint_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(WorkloadEndpointRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_WorkloadEndpointRemove{msg} + return true, err + case 13: // payload.config_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ConfigUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_ConfigUpdate{msg} + return true, err + case 14: // payload.host_metadata_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostMetadataUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_HostMetadataUpdate{msg} + return true, err + case 18: // payload.host_metadata_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostMetadataRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_HostMetadataRemove{msg} + return true, err + case 16: // payload.ipam_pool_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IPAMPoolUpdate) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_IpamPoolUpdate{msg} + return true, err + case 17: // payload.ipam_pool_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IPAMPoolRemove) + err := b.DecodeMessage(msg) + m.Payload = &ToDataplane_IpamPoolRemove{msg} + return true, err + default: + return false, nil + } +} + +func _ToDataplane_OneofSizer(msg proto1.Message) (n int) { + m := msg.(*ToDataplane) + // payload + switch x := m.Payload.(type) { + case *ToDataplane_InSync: + s := proto1.Size(x.InSync) + n += proto1.SizeVarint(1<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_IpsetUpdate: + s := proto1.Size(x.IpsetUpdate) + n += proto1.SizeVarint(2<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_IpsetDeltaUpdate: + s := proto1.Size(x.IpsetDeltaUpdate) + n += proto1.SizeVarint(3<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_IpsetRemove: + s := proto1.Size(x.IpsetRemove) + n += proto1.SizeVarint(4<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_ActiveProfileUpdate: + s := proto1.Size(x.ActiveProfileUpdate) + n += proto1.SizeVarint(5<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_ActiveProfileRemove: + s := proto1.Size(x.ActiveProfileRemove) + n += proto1.SizeVarint(6<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_ActivePolicyUpdate: + s := proto1.Size(x.ActivePolicyUpdate) + n += proto1.SizeVarint(7<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_ActivePolicyRemove: + s := proto1.Size(x.ActivePolicyRemove) + n += proto1.SizeVarint(8<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_HostEndpointUpdate: + s := proto1.Size(x.HostEndpointUpdate) + n += proto1.SizeVarint(9<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_HostEndpointRemove: + s := proto1.Size(x.HostEndpointRemove) + n += proto1.SizeVarint(10<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_WorkloadEndpointUpdate: + s := proto1.Size(x.WorkloadEndpointUpdate) + n += proto1.SizeVarint(11<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_WorkloadEndpointRemove: + s := proto1.Size(x.WorkloadEndpointRemove) + n += proto1.SizeVarint(12<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_ConfigUpdate: + s := proto1.Size(x.ConfigUpdate) + n += proto1.SizeVarint(13<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_HostMetadataUpdate: + s := proto1.Size(x.HostMetadataUpdate) + n += proto1.SizeVarint(14<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_HostMetadataRemove: + s := proto1.Size(x.HostMetadataRemove) + n += proto1.SizeVarint(18<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_IpamPoolUpdate: + s := proto1.Size(x.IpamPoolUpdate) + n += proto1.SizeVarint(16<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *ToDataplane_IpamPoolRemove: + s := proto1.Size(x.IpamPoolRemove) + n += proto1.SizeVarint(17<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type FromDataplane struct { + SequenceNumber uint64 `protobuf:"varint,8,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"` + // Types that are valid to be assigned to Payload: + // *FromDataplane_ProcessStatusUpdate + // *FromDataplane_HostEndpointStatusUpdate + // *FromDataplane_HostEndpointStatusRemove + // *FromDataplane_WorkloadEndpointStatusUpdate + // *FromDataplane_WorkloadEndpointStatusRemove + Payload isFromDataplane_Payload `protobuf_oneof:"payload"` +} + +func (m *FromDataplane) Reset() { *m = FromDataplane{} } +func (m *FromDataplane) String() string { return proto1.CompactTextString(m) } +func (*FromDataplane) ProtoMessage() {} +func (*FromDataplane) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{1} } + +type isFromDataplane_Payload interface { + isFromDataplane_Payload() + MarshalTo([]byte) (int, error) + Size() int +} + +type FromDataplane_ProcessStatusUpdate struct { + ProcessStatusUpdate *ProcessStatusUpdate `protobuf:"bytes,3,opt,name=process_status_update,json=processStatusUpdate,oneof"` +} +type FromDataplane_HostEndpointStatusUpdate struct { + HostEndpointStatusUpdate *HostEndpointStatusUpdate `protobuf:"bytes,4,opt,name=host_endpoint_status_update,json=hostEndpointStatusUpdate,oneof"` +} +type FromDataplane_HostEndpointStatusRemove struct { + HostEndpointStatusRemove *HostEndpointStatusRemove `protobuf:"bytes,5,opt,name=host_endpoint_status_remove,json=hostEndpointStatusRemove,oneof"` +} +type FromDataplane_WorkloadEndpointStatusUpdate struct { + WorkloadEndpointStatusUpdate *WorkloadEndpointStatusUpdate `protobuf:"bytes,6,opt,name=workload_endpoint_status_update,json=workloadEndpointStatusUpdate,oneof"` +} +type FromDataplane_WorkloadEndpointStatusRemove struct { + WorkloadEndpointStatusRemove *WorkloadEndpointStatusRemove `protobuf:"bytes,7,opt,name=workload_endpoint_status_remove,json=workloadEndpointStatusRemove,oneof"` +} + +func (*FromDataplane_ProcessStatusUpdate) isFromDataplane_Payload() {} +func (*FromDataplane_HostEndpointStatusUpdate) isFromDataplane_Payload() {} +func (*FromDataplane_HostEndpointStatusRemove) isFromDataplane_Payload() {} +func (*FromDataplane_WorkloadEndpointStatusUpdate) isFromDataplane_Payload() {} +func (*FromDataplane_WorkloadEndpointStatusRemove) isFromDataplane_Payload() {} + +func (m *FromDataplane) GetPayload() isFromDataplane_Payload { + if m != nil { + return m.Payload + } + return nil +} + +func (m *FromDataplane) GetSequenceNumber() uint64 { + if m != nil { + return m.SequenceNumber + } + return 0 +} + +func (m *FromDataplane) GetProcessStatusUpdate() *ProcessStatusUpdate { + if x, ok := m.GetPayload().(*FromDataplane_ProcessStatusUpdate); ok { + return x.ProcessStatusUpdate + } + return nil +} + +func (m *FromDataplane) GetHostEndpointStatusUpdate() *HostEndpointStatusUpdate { + if x, ok := m.GetPayload().(*FromDataplane_HostEndpointStatusUpdate); ok { + return x.HostEndpointStatusUpdate + } + return nil +} + +func (m *FromDataplane) GetHostEndpointStatusRemove() *HostEndpointStatusRemove { + if x, ok := m.GetPayload().(*FromDataplane_HostEndpointStatusRemove); ok { + return x.HostEndpointStatusRemove + } + return nil +} + +func (m *FromDataplane) GetWorkloadEndpointStatusUpdate() *WorkloadEndpointStatusUpdate { + if x, ok := m.GetPayload().(*FromDataplane_WorkloadEndpointStatusUpdate); ok { + return x.WorkloadEndpointStatusUpdate + } + return nil +} + +func (m *FromDataplane) GetWorkloadEndpointStatusRemove() *WorkloadEndpointStatusRemove { + if x, ok := m.GetPayload().(*FromDataplane_WorkloadEndpointStatusRemove); ok { + return x.WorkloadEndpointStatusRemove + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*FromDataplane) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) { + return _FromDataplane_OneofMarshaler, _FromDataplane_OneofUnmarshaler, _FromDataplane_OneofSizer, []interface{}{ + (*FromDataplane_ProcessStatusUpdate)(nil), + (*FromDataplane_HostEndpointStatusUpdate)(nil), + (*FromDataplane_HostEndpointStatusRemove)(nil), + (*FromDataplane_WorkloadEndpointStatusUpdate)(nil), + (*FromDataplane_WorkloadEndpointStatusRemove)(nil), + } +} + +func _FromDataplane_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error { + m := msg.(*FromDataplane) + // payload + switch x := m.Payload.(type) { + case *FromDataplane_ProcessStatusUpdate: + _ = b.EncodeVarint(3<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.ProcessStatusUpdate); err != nil { + return err + } + case *FromDataplane_HostEndpointStatusUpdate: + _ = b.EncodeVarint(4<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostEndpointStatusUpdate); err != nil { + return err + } + case *FromDataplane_HostEndpointStatusRemove: + _ = b.EncodeVarint(5<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.HostEndpointStatusRemove); err != nil { + return err + } + case *FromDataplane_WorkloadEndpointStatusUpdate: + _ = b.EncodeVarint(6<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.WorkloadEndpointStatusUpdate); err != nil { + return err + } + case *FromDataplane_WorkloadEndpointStatusRemove: + _ = b.EncodeVarint(7<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.WorkloadEndpointStatusRemove); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("FromDataplane.Payload has unexpected type %T", x) + } + return nil +} + +func _FromDataplane_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { + m := msg.(*FromDataplane) + switch tag { + case 3: // payload.process_status_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(ProcessStatusUpdate) + err := b.DecodeMessage(msg) + m.Payload = &FromDataplane_ProcessStatusUpdate{msg} + return true, err + case 4: // payload.host_endpoint_status_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostEndpointStatusUpdate) + err := b.DecodeMessage(msg) + m.Payload = &FromDataplane_HostEndpointStatusUpdate{msg} + return true, err + case 5: // payload.host_endpoint_status_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(HostEndpointStatusRemove) + err := b.DecodeMessage(msg) + m.Payload = &FromDataplane_HostEndpointStatusRemove{msg} + return true, err + case 6: // payload.workload_endpoint_status_update + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(WorkloadEndpointStatusUpdate) + err := b.DecodeMessage(msg) + m.Payload = &FromDataplane_WorkloadEndpointStatusUpdate{msg} + return true, err + case 7: // payload.workload_endpoint_status_remove + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(WorkloadEndpointStatusRemove) + err := b.DecodeMessage(msg) + m.Payload = &FromDataplane_WorkloadEndpointStatusRemove{msg} + return true, err + default: + return false, nil + } +} + +func _FromDataplane_OneofSizer(msg proto1.Message) (n int) { + m := msg.(*FromDataplane) + // payload + switch x := m.Payload.(type) { + case *FromDataplane_ProcessStatusUpdate: + s := proto1.Size(x.ProcessStatusUpdate) + n += proto1.SizeVarint(3<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *FromDataplane_HostEndpointStatusUpdate: + s := proto1.Size(x.HostEndpointStatusUpdate) + n += proto1.SizeVarint(4<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *FromDataplane_HostEndpointStatusRemove: + s := proto1.Size(x.HostEndpointStatusRemove) + n += proto1.SizeVarint(5<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *FromDataplane_WorkloadEndpointStatusUpdate: + s := proto1.Size(x.WorkloadEndpointStatusUpdate) + n += proto1.SizeVarint(6<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case *FromDataplane_WorkloadEndpointStatusRemove: + s := proto1.Size(x.WorkloadEndpointStatusRemove) + n += proto1.SizeVarint(7<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type ConfigUpdate struct { + Config map[string]string `protobuf:"bytes,1,rep,name=config" json:"config,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *ConfigUpdate) Reset() { *m = ConfigUpdate{} } +func (m *ConfigUpdate) String() string { return proto1.CompactTextString(m) } +func (*ConfigUpdate) ProtoMessage() {} +func (*ConfigUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{2} } + +func (m *ConfigUpdate) GetConfig() map[string]string { + if m != nil { + return m.Config + } + return nil +} + +type InSync struct { +} + +func (m *InSync) Reset() { *m = InSync{} } +func (m *InSync) String() string { return proto1.CompactTextString(m) } +func (*InSync) ProtoMessage() {} +func (*InSync) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{3} } + +type IPSetUpdate struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Members []string `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + Type IPSetUpdate_IPSetType `protobuf:"varint,3,opt,name=type,proto3,enum=felix.IPSetUpdate_IPSetType" json:"type,omitempty"` +} + +func (m *IPSetUpdate) Reset() { *m = IPSetUpdate{} } +func (m *IPSetUpdate) String() string { return proto1.CompactTextString(m) } +func (*IPSetUpdate) ProtoMessage() {} +func (*IPSetUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{4} } + +func (m *IPSetUpdate) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *IPSetUpdate) GetMembers() []string { + if m != nil { + return m.Members + } + return nil +} + +func (m *IPSetUpdate) GetType() IPSetUpdate_IPSetType { + if m != nil { + return m.Type + } + return IPSetUpdate_IP +} + +type IPSetDeltaUpdate struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + AddedMembers []string `protobuf:"bytes,2,rep,name=added_members,json=addedMembers" json:"added_members,omitempty"` + RemovedMembers []string `protobuf:"bytes,3,rep,name=removed_members,json=removedMembers" json:"removed_members,omitempty"` +} + +func (m *IPSetDeltaUpdate) Reset() { *m = IPSetDeltaUpdate{} } +func (m *IPSetDeltaUpdate) String() string { return proto1.CompactTextString(m) } +func (*IPSetDeltaUpdate) ProtoMessage() {} +func (*IPSetDeltaUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{5} } + +func (m *IPSetDeltaUpdate) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *IPSetDeltaUpdate) GetAddedMembers() []string { + if m != nil { + return m.AddedMembers + } + return nil +} + +func (m *IPSetDeltaUpdate) GetRemovedMembers() []string { + if m != nil { + return m.RemovedMembers + } + return nil +} + +type IPSetRemove struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *IPSetRemove) Reset() { *m = IPSetRemove{} } +func (m *IPSetRemove) String() string { return proto1.CompactTextString(m) } +func (*IPSetRemove) ProtoMessage() {} +func (*IPSetRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{6} } + +func (m *IPSetRemove) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +type ActiveProfileUpdate struct { + Id *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Profile *Profile `protobuf:"bytes,2,opt,name=profile" json:"profile,omitempty"` +} + +func (m *ActiveProfileUpdate) Reset() { *m = ActiveProfileUpdate{} } +func (m *ActiveProfileUpdate) String() string { return proto1.CompactTextString(m) } +func (*ActiveProfileUpdate) ProtoMessage() {} +func (*ActiveProfileUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{7} } + +func (m *ActiveProfileUpdate) GetId() *ProfileID { + if m != nil { + return m.Id + } + return nil +} + +func (m *ActiveProfileUpdate) GetProfile() *Profile { + if m != nil { + return m.Profile + } + return nil +} + +type ActiveProfileRemove struct { + Id *ProfileID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *ActiveProfileRemove) Reset() { *m = ActiveProfileRemove{} } +func (m *ActiveProfileRemove) String() string { return proto1.CompactTextString(m) } +func (*ActiveProfileRemove) ProtoMessage() {} +func (*ActiveProfileRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{8} } + +func (m *ActiveProfileRemove) GetId() *ProfileID { + if m != nil { + return m.Id + } + return nil +} + +type ProfileID struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *ProfileID) Reset() { *m = ProfileID{} } +func (m *ProfileID) String() string { return proto1.CompactTextString(m) } +func (*ProfileID) ProtoMessage() {} +func (*ProfileID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{9} } + +func (m *ProfileID) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +type Profile struct { + InboundRules []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"` + OutboundRules []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"` +} + +func (m *Profile) Reset() { *m = Profile{} } +func (m *Profile) String() string { return proto1.CompactTextString(m) } +func (*Profile) ProtoMessage() {} +func (*Profile) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{10} } + +func (m *Profile) GetInboundRules() []*Rule { + if m != nil { + return m.InboundRules + } + return nil +} + +func (m *Profile) GetOutboundRules() []*Rule { + if m != nil { + return m.OutboundRules + } + return nil +} + +type ActivePolicyUpdate struct { + Id *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Policy *Policy `protobuf:"bytes,2,opt,name=policy" json:"policy,omitempty"` +} + +func (m *ActivePolicyUpdate) Reset() { *m = ActivePolicyUpdate{} } +func (m *ActivePolicyUpdate) String() string { return proto1.CompactTextString(m) } +func (*ActivePolicyUpdate) ProtoMessage() {} +func (*ActivePolicyUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{11} } + +func (m *ActivePolicyUpdate) GetId() *PolicyID { + if m != nil { + return m.Id + } + return nil +} + +func (m *ActivePolicyUpdate) GetPolicy() *Policy { + if m != nil { + return m.Policy + } + return nil +} + +type ActivePolicyRemove struct { + Id *PolicyID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *ActivePolicyRemove) Reset() { *m = ActivePolicyRemove{} } +func (m *ActivePolicyRemove) String() string { return proto1.CompactTextString(m) } +func (*ActivePolicyRemove) ProtoMessage() {} +func (*ActivePolicyRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{12} } + +func (m *ActivePolicyRemove) GetId() *PolicyID { + if m != nil { + return m.Id + } + return nil +} + +type PolicyID struct { + Tier string `protobuf:"bytes,1,opt,name=tier,proto3" json:"tier,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` +} + +func (m *PolicyID) Reset() { *m = PolicyID{} } +func (m *PolicyID) String() string { return proto1.CompactTextString(m) } +func (*PolicyID) ProtoMessage() {} +func (*PolicyID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{13} } + +func (m *PolicyID) GetTier() string { + if m != nil { + return m.Tier + } + return "" +} + +func (m *PolicyID) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +type Policy struct { + InboundRules []*Rule `protobuf:"bytes,1,rep,name=inbound_rules,json=inboundRules" json:"inbound_rules,omitempty"` + OutboundRules []*Rule `protobuf:"bytes,2,rep,name=outbound_rules,json=outboundRules" json:"outbound_rules,omitempty"` + Untracked bool `protobuf:"varint,3,opt,name=untracked,proto3" json:"untracked,omitempty"` + PreDnat bool `protobuf:"varint,4,opt,name=pre_dnat,json=preDnat,proto3" json:"pre_dnat,omitempty"` +} + +func (m *Policy) Reset() { *m = Policy{} } +func (m *Policy) String() string { return proto1.CompactTextString(m) } +func (*Policy) ProtoMessage() {} +func (*Policy) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{14} } + +func (m *Policy) GetInboundRules() []*Rule { + if m != nil { + return m.InboundRules + } + return nil +} + +func (m *Policy) GetOutboundRules() []*Rule { + if m != nil { + return m.OutboundRules + } + return nil +} + +func (m *Policy) GetUntracked() bool { + if m != nil { + return m.Untracked + } + return false +} + +func (m *Policy) GetPreDnat() bool { + if m != nil { + return m.PreDnat + } + return false +} + +type Rule struct { + Action string `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"` + IpVersion IPVersion `protobuf:"varint,2,opt,name=ip_version,json=ipVersion,proto3,enum=felix.IPVersion" json:"ip_version,omitempty"` + Protocol *Protocol `protobuf:"bytes,3,opt,name=protocol" json:"protocol,omitempty"` + SrcNet []string `protobuf:"bytes,4,rep,name=src_net,json=srcNet" json:"src_net,omitempty"` + // The list of ports is split into numeric and named ports, where named ports are represented + // by (IP, port) IP sets. A packet matches this rule if it matches any numeric port range *or* + // any listed named port IP set. + SrcPorts []*PortRange `protobuf:"bytes,5,rep,name=src_ports,json=srcPorts" json:"src_ports,omitempty"` + SrcNamedPortIpSetIds []string `protobuf:"bytes,12,rep,name=src_named_port_ip_set_ids,json=srcNamedPortIpSetIds" json:"src_named_port_ip_set_ids,omitempty"` + DstNet []string `protobuf:"bytes,6,rep,name=dst_net,json=dstNet" json:"dst_net,omitempty"` + DstPorts []*PortRange `protobuf:"bytes,7,rep,name=dst_ports,json=dstPorts" json:"dst_ports,omitempty"` + DstNamedPortIpSetIds []string `protobuf:"bytes,13,rep,name=dst_named_port_ip_set_ids,json=dstNamedPortIpSetIds" json:"dst_named_port_ip_set_ids,omitempty"` + // Types that are valid to be assigned to Icmp: + // *Rule_IcmpType + // *Rule_IcmpTypeCode + Icmp isRule_Icmp `protobuf_oneof:"icmp"` + SrcIpSetIds []string `protobuf:"bytes,10,rep,name=src_ip_set_ids,json=srcIpSetIds" json:"src_ip_set_ids,omitempty"` + DstIpSetIds []string `protobuf:"bytes,11,rep,name=dst_ip_set_ids,json=dstIpSetIds" json:"dst_ip_set_ids,omitempty"` + NotProtocol *Protocol `protobuf:"bytes,102,opt,name=not_protocol,json=notProtocol" json:"not_protocol,omitempty"` + NotSrcNet []string `protobuf:"bytes,103,rep,name=not_src_net,json=notSrcNet" json:"not_src_net,omitempty"` + NotSrcPorts []*PortRange `protobuf:"bytes,104,rep,name=not_src_ports,json=notSrcPorts" json:"not_src_ports,omitempty"` + NotDstNet []string `protobuf:"bytes,105,rep,name=not_dst_net,json=notDstNet" json:"not_dst_net,omitempty"` + NotDstPorts []*PortRange `protobuf:"bytes,106,rep,name=not_dst_ports,json=notDstPorts" json:"not_dst_ports,omitempty"` + // Types that are valid to be assigned to NotIcmp: + // *Rule_NotIcmpType + // *Rule_NotIcmpTypeCode + NotIcmp isRule_NotIcmp `protobuf_oneof:"not_icmp"` + NotSrcIpSetIds []string `protobuf:"bytes,109,rep,name=not_src_ip_set_ids,json=notSrcIpSetIds" json:"not_src_ip_set_ids,omitempty"` + NotDstIpSetIds []string `protobuf:"bytes,110,rep,name=not_dst_ip_set_ids,json=notDstIpSetIds" json:"not_dst_ip_set_ids,omitempty"` + NotSrcNamedPortIpSetIds []string `protobuf:"bytes,112,rep,name=not_src_named_port_ip_set_ids,json=notSrcNamedPortIpSetIds" json:"not_src_named_port_ip_set_ids,omitempty"` + NotDstNamedPortIpSetIds []string `protobuf:"bytes,113,rep,name=not_dst_named_port_ip_set_ids,json=notDstNamedPortIpSetIds" json:"not_dst_named_port_ip_set_ids,omitempty"` + // An opaque ID/hash for the rule. + RuleId string `protobuf:"bytes,201,opt,name=rule_id,json=ruleId,proto3" json:"rule_id,omitempty"` +} + +func (m *Rule) Reset() { *m = Rule{} } +func (m *Rule) String() string { return proto1.CompactTextString(m) } +func (*Rule) ProtoMessage() {} +func (*Rule) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{15} } + +type isRule_Icmp interface { + isRule_Icmp() + MarshalTo([]byte) (int, error) + Size() int +} +type isRule_NotIcmp interface { + isRule_NotIcmp() + MarshalTo([]byte) (int, error) + Size() int +} + +type Rule_IcmpType struct { + IcmpType int32 `protobuf:"varint,8,opt,name=icmp_type,json=icmpType,proto3,oneof"` +} +type Rule_IcmpTypeCode struct { + IcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,9,opt,name=icmp_type_code,json=icmpTypeCode,oneof"` +} +type Rule_NotIcmpType struct { + NotIcmpType int32 `protobuf:"varint,107,opt,name=not_icmp_type,json=notIcmpType,proto3,oneof"` +} +type Rule_NotIcmpTypeCode struct { + NotIcmpTypeCode *IcmpTypeAndCode `protobuf:"bytes,108,opt,name=not_icmp_type_code,json=notIcmpTypeCode,oneof"` +} + +func (*Rule_IcmpType) isRule_Icmp() {} +func (*Rule_IcmpTypeCode) isRule_Icmp() {} +func (*Rule_NotIcmpType) isRule_NotIcmp() {} +func (*Rule_NotIcmpTypeCode) isRule_NotIcmp() {} + +func (m *Rule) GetIcmp() isRule_Icmp { + if m != nil { + return m.Icmp + } + return nil +} +func (m *Rule) GetNotIcmp() isRule_NotIcmp { + if m != nil { + return m.NotIcmp + } + return nil +} + +func (m *Rule) GetAction() string { + if m != nil { + return m.Action + } + return "" +} + +func (m *Rule) GetIpVersion() IPVersion { + if m != nil { + return m.IpVersion + } + return IPVersion_ANY +} + +func (m *Rule) GetProtocol() *Protocol { + if m != nil { + return m.Protocol + } + return nil +} + +func (m *Rule) GetSrcNet() []string { + if m != nil { + return m.SrcNet + } + return nil +} + +func (m *Rule) GetSrcPorts() []*PortRange { + if m != nil { + return m.SrcPorts + } + return nil +} + +func (m *Rule) GetSrcNamedPortIpSetIds() []string { + if m != nil { + return m.SrcNamedPortIpSetIds + } + return nil +} + +func (m *Rule) GetDstNet() []string { + if m != nil { + return m.DstNet + } + return nil +} + +func (m *Rule) GetDstPorts() []*PortRange { + if m != nil { + return m.DstPorts + } + return nil +} + +func (m *Rule) GetDstNamedPortIpSetIds() []string { + if m != nil { + return m.DstNamedPortIpSetIds + } + return nil +} + +func (m *Rule) GetIcmpType() int32 { + if x, ok := m.GetIcmp().(*Rule_IcmpType); ok { + return x.IcmpType + } + return 0 +} + +func (m *Rule) GetIcmpTypeCode() *IcmpTypeAndCode { + if x, ok := m.GetIcmp().(*Rule_IcmpTypeCode); ok { + return x.IcmpTypeCode + } + return nil +} + +func (m *Rule) GetSrcIpSetIds() []string { + if m != nil { + return m.SrcIpSetIds + } + return nil +} + +func (m *Rule) GetDstIpSetIds() []string { + if m != nil { + return m.DstIpSetIds + } + return nil +} + +func (m *Rule) GetNotProtocol() *Protocol { + if m != nil { + return m.NotProtocol + } + return nil +} + +func (m *Rule) GetNotSrcNet() []string { + if m != nil { + return m.NotSrcNet + } + return nil +} + +func (m *Rule) GetNotSrcPorts() []*PortRange { + if m != nil { + return m.NotSrcPorts + } + return nil +} + +func (m *Rule) GetNotDstNet() []string { + if m != nil { + return m.NotDstNet + } + return nil +} + +func (m *Rule) GetNotDstPorts() []*PortRange { + if m != nil { + return m.NotDstPorts + } + return nil +} + +func (m *Rule) GetNotIcmpType() int32 { + if x, ok := m.GetNotIcmp().(*Rule_NotIcmpType); ok { + return x.NotIcmpType + } + return 0 +} + +func (m *Rule) GetNotIcmpTypeCode() *IcmpTypeAndCode { + if x, ok := m.GetNotIcmp().(*Rule_NotIcmpTypeCode); ok { + return x.NotIcmpTypeCode + } + return nil +} + +func (m *Rule) GetNotSrcIpSetIds() []string { + if m != nil { + return m.NotSrcIpSetIds + } + return nil +} + +func (m *Rule) GetNotDstIpSetIds() []string { + if m != nil { + return m.NotDstIpSetIds + } + return nil +} + +func (m *Rule) GetNotSrcNamedPortIpSetIds() []string { + if m != nil { + return m.NotSrcNamedPortIpSetIds + } + return nil +} + +func (m *Rule) GetNotDstNamedPortIpSetIds() []string { + if m != nil { + return m.NotDstNamedPortIpSetIds + } + return nil +} + +func (m *Rule) GetRuleId() string { + if m != nil { + return m.RuleId + } + return "" +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Rule) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) { + return _Rule_OneofMarshaler, _Rule_OneofUnmarshaler, _Rule_OneofSizer, []interface{}{ + (*Rule_IcmpType)(nil), + (*Rule_IcmpTypeCode)(nil), + (*Rule_NotIcmpType)(nil), + (*Rule_NotIcmpTypeCode)(nil), + } +} + +func _Rule_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error { + m := msg.(*Rule) + // icmp + switch x := m.Icmp.(type) { + case *Rule_IcmpType: + _ = b.EncodeVarint(8<<3 | proto1.WireVarint) + _ = b.EncodeVarint(uint64(x.IcmpType)) + case *Rule_IcmpTypeCode: + _ = b.EncodeVarint(9<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.IcmpTypeCode); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Rule.Icmp has unexpected type %T", x) + } + // not_icmp + switch x := m.NotIcmp.(type) { + case *Rule_NotIcmpType: + _ = b.EncodeVarint(107<<3 | proto1.WireVarint) + _ = b.EncodeVarint(uint64(x.NotIcmpType)) + case *Rule_NotIcmpTypeCode: + _ = b.EncodeVarint(108<<3 | proto1.WireBytes) + if err := b.EncodeMessage(x.NotIcmpTypeCode); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Rule.NotIcmp has unexpected type %T", x) + } + return nil +} + +func _Rule_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { + m := msg.(*Rule) + switch tag { + case 8: // icmp.icmp_type + if wire != proto1.WireVarint { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Icmp = &Rule_IcmpType{int32(x)} + return true, err + case 9: // icmp.icmp_type_code + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IcmpTypeAndCode) + err := b.DecodeMessage(msg) + m.Icmp = &Rule_IcmpTypeCode{msg} + return true, err + case 107: // not_icmp.not_icmp_type + if wire != proto1.WireVarint { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.NotIcmp = &Rule_NotIcmpType{int32(x)} + return true, err + case 108: // not_icmp.not_icmp_type_code + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + msg := new(IcmpTypeAndCode) + err := b.DecodeMessage(msg) + m.NotIcmp = &Rule_NotIcmpTypeCode{msg} + return true, err + default: + return false, nil + } +} + +func _Rule_OneofSizer(msg proto1.Message) (n int) { + m := msg.(*Rule) + // icmp + switch x := m.Icmp.(type) { + case *Rule_IcmpType: + n += proto1.SizeVarint(8<<3 | proto1.WireVarint) + n += proto1.SizeVarint(uint64(x.IcmpType)) + case *Rule_IcmpTypeCode: + s := proto1.Size(x.IcmpTypeCode) + n += proto1.SizeVarint(9<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + // not_icmp + switch x := m.NotIcmp.(type) { + case *Rule_NotIcmpType: + n += proto1.SizeVarint(107<<3 | proto1.WireVarint) + n += proto1.SizeVarint(uint64(x.NotIcmpType)) + case *Rule_NotIcmpTypeCode: + s := proto1.Size(x.NotIcmpTypeCode) + n += proto1.SizeVarint(108<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +type IcmpTypeAndCode struct { + Type int32 `protobuf:"varint,1,opt,name=type,proto3" json:"type,omitempty"` + Code int32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"` +} + +func (m *IcmpTypeAndCode) Reset() { *m = IcmpTypeAndCode{} } +func (m *IcmpTypeAndCode) String() string { return proto1.CompactTextString(m) } +func (*IcmpTypeAndCode) ProtoMessage() {} +func (*IcmpTypeAndCode) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{16} } + +func (m *IcmpTypeAndCode) GetType() int32 { + if m != nil { + return m.Type + } + return 0 +} + +func (m *IcmpTypeAndCode) GetCode() int32 { + if m != nil { + return m.Code + } + return 0 +} + +type Protocol struct { + // Types that are valid to be assigned to NumberOrName: + // *Protocol_Number + // *Protocol_Name + NumberOrName isProtocol_NumberOrName `protobuf_oneof:"number_or_name"` +} + +func (m *Protocol) Reset() { *m = Protocol{} } +func (m *Protocol) String() string { return proto1.CompactTextString(m) } +func (*Protocol) ProtoMessage() {} +func (*Protocol) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{17} } + +type isProtocol_NumberOrName interface { + isProtocol_NumberOrName() + MarshalTo([]byte) (int, error) + Size() int +} + +type Protocol_Number struct { + Number int32 `protobuf:"varint,1,opt,name=number,proto3,oneof"` +} +type Protocol_Name struct { + Name string `protobuf:"bytes,2,opt,name=name,proto3,oneof"` +} + +func (*Protocol_Number) isProtocol_NumberOrName() {} +func (*Protocol_Name) isProtocol_NumberOrName() {} + +func (m *Protocol) GetNumberOrName() isProtocol_NumberOrName { + if m != nil { + return m.NumberOrName + } + return nil +} + +func (m *Protocol) GetNumber() int32 { + if x, ok := m.GetNumberOrName().(*Protocol_Number); ok { + return x.Number + } + return 0 +} + +func (m *Protocol) GetName() string { + if x, ok := m.GetNumberOrName().(*Protocol_Name); ok { + return x.Name + } + return "" +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Protocol) XXX_OneofFuncs() (func(msg proto1.Message, b *proto1.Buffer) error, func(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error), func(msg proto1.Message) (n int), []interface{}) { + return _Protocol_OneofMarshaler, _Protocol_OneofUnmarshaler, _Protocol_OneofSizer, []interface{}{ + (*Protocol_Number)(nil), + (*Protocol_Name)(nil), + } +} + +func _Protocol_OneofMarshaler(msg proto1.Message, b *proto1.Buffer) error { + m := msg.(*Protocol) + // number_or_name + switch x := m.NumberOrName.(type) { + case *Protocol_Number: + _ = b.EncodeVarint(1<<3 | proto1.WireVarint) + _ = b.EncodeVarint(uint64(x.Number)) + case *Protocol_Name: + _ = b.EncodeVarint(2<<3 | proto1.WireBytes) + _ = b.EncodeStringBytes(x.Name) + case nil: + default: + return fmt.Errorf("Protocol.NumberOrName has unexpected type %T", x) + } + return nil +} + +func _Protocol_OneofUnmarshaler(msg proto1.Message, tag, wire int, b *proto1.Buffer) (bool, error) { + m := msg.(*Protocol) + switch tag { + case 1: // number_or_name.number + if wire != proto1.WireVarint { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.NumberOrName = &Protocol_Number{int32(x)} + return true, err + case 2: // number_or_name.name + if wire != proto1.WireBytes { + return true, proto1.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.NumberOrName = &Protocol_Name{x} + return true, err + default: + return false, nil + } +} + +func _Protocol_OneofSizer(msg proto1.Message) (n int) { + m := msg.(*Protocol) + // number_or_name + switch x := m.NumberOrName.(type) { + case *Protocol_Number: + n += proto1.SizeVarint(1<<3 | proto1.WireVarint) + n += proto1.SizeVarint(uint64(x.Number)) + case *Protocol_Name: + n += proto1.SizeVarint(2<<3 | proto1.WireBytes) + n += proto1.SizeVarint(uint64(len(x.Name))) + n += len(x.Name) + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Individual ports are sent with first == last. +type PortRange struct { + First int32 `protobuf:"varint,1,opt,name=first,proto3" json:"first,omitempty"` + Last int32 `protobuf:"varint,2,opt,name=last,proto3" json:"last,omitempty"` +} + +func (m *PortRange) Reset() { *m = PortRange{} } +func (m *PortRange) String() string { return proto1.CompactTextString(m) } +func (*PortRange) ProtoMessage() {} +func (*PortRange) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{18} } + +func (m *PortRange) GetFirst() int32 { + if m != nil { + return m.First + } + return 0 +} + +func (m *PortRange) GetLast() int32 { + if m != nil { + return m.Last + } + return 0 +} + +type WorkloadEndpointID struct { + OrchestratorId string `protobuf:"bytes,2,opt,name=orchestrator_id,json=orchestratorId,proto3" json:"orchestrator_id,omitempty"` + WorkloadId string `protobuf:"bytes,3,opt,name=workload_id,json=workloadId,proto3" json:"workload_id,omitempty"` + EndpointId string `protobuf:"bytes,4,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"` +} + +func (m *WorkloadEndpointID) Reset() { *m = WorkloadEndpointID{} } +func (m *WorkloadEndpointID) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpointID) ProtoMessage() {} +func (*WorkloadEndpointID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{19} } + +func (m *WorkloadEndpointID) GetOrchestratorId() string { + if m != nil { + return m.OrchestratorId + } + return "" +} + +func (m *WorkloadEndpointID) GetWorkloadId() string { + if m != nil { + return m.WorkloadId + } + return "" +} + +func (m *WorkloadEndpointID) GetEndpointId() string { + if m != nil { + return m.EndpointId + } + return "" +} + +type WorkloadEndpointUpdate struct { + Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Endpoint *WorkloadEndpoint `protobuf:"bytes,5,opt,name=endpoint" json:"endpoint,omitempty"` +} + +func (m *WorkloadEndpointUpdate) Reset() { *m = WorkloadEndpointUpdate{} } +func (m *WorkloadEndpointUpdate) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpointUpdate) ProtoMessage() {} +func (*WorkloadEndpointUpdate) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{20} +} + +func (m *WorkloadEndpointUpdate) GetId() *WorkloadEndpointID { + if m != nil { + return m.Id + } + return nil +} + +func (m *WorkloadEndpointUpdate) GetEndpoint() *WorkloadEndpoint { + if m != nil { + return m.Endpoint + } + return nil +} + +type WorkloadEndpoint struct { + State string `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Mac string `protobuf:"bytes,3,opt,name=mac,proto3" json:"mac,omitempty"` + ProfileIds []string `protobuf:"bytes,4,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"` + Ipv4Nets []string `protobuf:"bytes,5,rep,name=ipv4_nets,json=ipv4Nets" json:"ipv4_nets,omitempty"` + Ipv6Nets []string `protobuf:"bytes,6,rep,name=ipv6_nets,json=ipv6Nets" json:"ipv6_nets,omitempty"` + Tiers []*TierInfo `protobuf:"bytes,7,rep,name=tiers" json:"tiers,omitempty"` + Ipv4Nat []*NatInfo `protobuf:"bytes,8,rep,name=ipv4_nat,json=ipv4Nat" json:"ipv4_nat,omitempty"` + Ipv6Nat []*NatInfo `protobuf:"bytes,9,rep,name=ipv6_nat,json=ipv6Nat" json:"ipv6_nat,omitempty"` +} + +func (m *WorkloadEndpoint) Reset() { *m = WorkloadEndpoint{} } +func (m *WorkloadEndpoint) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpoint) ProtoMessage() {} +func (*WorkloadEndpoint) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{21} } + +func (m *WorkloadEndpoint) GetState() string { + if m != nil { + return m.State + } + return "" +} + +func (m *WorkloadEndpoint) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *WorkloadEndpoint) GetMac() string { + if m != nil { + return m.Mac + } + return "" +} + +func (m *WorkloadEndpoint) GetProfileIds() []string { + if m != nil { + return m.ProfileIds + } + return nil +} + +func (m *WorkloadEndpoint) GetIpv4Nets() []string { + if m != nil { + return m.Ipv4Nets + } + return nil +} + +func (m *WorkloadEndpoint) GetIpv6Nets() []string { + if m != nil { + return m.Ipv6Nets + } + return nil +} + +func (m *WorkloadEndpoint) GetTiers() []*TierInfo { + if m != nil { + return m.Tiers + } + return nil +} + +func (m *WorkloadEndpoint) GetIpv4Nat() []*NatInfo { + if m != nil { + return m.Ipv4Nat + } + return nil +} + +func (m *WorkloadEndpoint) GetIpv6Nat() []*NatInfo { + if m != nil { + return m.Ipv6Nat + } + return nil +} + +type WorkloadEndpointRemove struct { + Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *WorkloadEndpointRemove) Reset() { *m = WorkloadEndpointRemove{} } +func (m *WorkloadEndpointRemove) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpointRemove) ProtoMessage() {} +func (*WorkloadEndpointRemove) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{22} +} + +func (m *WorkloadEndpointRemove) GetId() *WorkloadEndpointID { + if m != nil { + return m.Id + } + return nil +} + +type HostEndpointID struct { + EndpointId string `protobuf:"bytes,2,opt,name=endpoint_id,json=endpointId,proto3" json:"endpoint_id,omitempty"` +} + +func (m *HostEndpointID) Reset() { *m = HostEndpointID{} } +func (m *HostEndpointID) String() string { return proto1.CompactTextString(m) } +func (*HostEndpointID) ProtoMessage() {} +func (*HostEndpointID) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{23} } + +func (m *HostEndpointID) GetEndpointId() string { + if m != nil { + return m.EndpointId + } + return "" +} + +type HostEndpointUpdate struct { + Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Endpoint *HostEndpoint `protobuf:"bytes,3,opt,name=endpoint" json:"endpoint,omitempty"` +} + +func (m *HostEndpointUpdate) Reset() { *m = HostEndpointUpdate{} } +func (m *HostEndpointUpdate) String() string { return proto1.CompactTextString(m) } +func (*HostEndpointUpdate) ProtoMessage() {} +func (*HostEndpointUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{24} } + +func (m *HostEndpointUpdate) GetId() *HostEndpointID { + if m != nil { + return m.Id + } + return nil +} + +func (m *HostEndpointUpdate) GetEndpoint() *HostEndpoint { + if m != nil { + return m.Endpoint + } + return nil +} + +type HostEndpoint struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + ProfileIds []string `protobuf:"bytes,2,rep,name=profile_ids,json=profileIds" json:"profile_ids,omitempty"` + Tiers []*TierInfo `protobuf:"bytes,3,rep,name=tiers" json:"tiers,omitempty"` + UntrackedTiers []*TierInfo `protobuf:"bytes,6,rep,name=untracked_tiers,json=untrackedTiers" json:"untracked_tiers,omitempty"` + PreDnatTiers []*TierInfo `protobuf:"bytes,7,rep,name=pre_dnat_tiers,json=preDnatTiers" json:"pre_dnat_tiers,omitempty"` + ForwardTiers []*TierInfo `protobuf:"bytes,8,rep,name=forward_tiers,json=forwardTiers" json:"forward_tiers,omitempty"` + ExpectedIpv4Addrs []string `protobuf:"bytes,4,rep,name=expected_ipv4_addrs,json=expectedIpv4Addrs" json:"expected_ipv4_addrs,omitempty"` + ExpectedIpv6Addrs []string `protobuf:"bytes,5,rep,name=expected_ipv6_addrs,json=expectedIpv6Addrs" json:"expected_ipv6_addrs,omitempty"` +} + +func (m *HostEndpoint) Reset() { *m = HostEndpoint{} } +func (m *HostEndpoint) String() string { return proto1.CompactTextString(m) } +func (*HostEndpoint) ProtoMessage() {} +func (*HostEndpoint) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{25} } + +func (m *HostEndpoint) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *HostEndpoint) GetProfileIds() []string { + if m != nil { + return m.ProfileIds + } + return nil +} + +func (m *HostEndpoint) GetTiers() []*TierInfo { + if m != nil { + return m.Tiers + } + return nil +} + +func (m *HostEndpoint) GetUntrackedTiers() []*TierInfo { + if m != nil { + return m.UntrackedTiers + } + return nil +} + +func (m *HostEndpoint) GetPreDnatTiers() []*TierInfo { + if m != nil { + return m.PreDnatTiers + } + return nil +} + +func (m *HostEndpoint) GetForwardTiers() []*TierInfo { + if m != nil { + return m.ForwardTiers + } + return nil +} + +func (m *HostEndpoint) GetExpectedIpv4Addrs() []string { + if m != nil { + return m.ExpectedIpv4Addrs + } + return nil +} + +func (m *HostEndpoint) GetExpectedIpv6Addrs() []string { + if m != nil { + return m.ExpectedIpv6Addrs + } + return nil +} + +type HostEndpointRemove struct { + Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *HostEndpointRemove) Reset() { *m = HostEndpointRemove{} } +func (m *HostEndpointRemove) String() string { return proto1.CompactTextString(m) } +func (*HostEndpointRemove) ProtoMessage() {} +func (*HostEndpointRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{26} } + +func (m *HostEndpointRemove) GetId() *HostEndpointID { + if m != nil { + return m.Id + } + return nil +} + +type TierInfo struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + IngressPolicies []string `protobuf:"bytes,2,rep,name=ingress_policies,json=ingressPolicies" json:"ingress_policies,omitempty"` + EgressPolicies []string `protobuf:"bytes,3,rep,name=egress_policies,json=egressPolicies" json:"egress_policies,omitempty"` +} + +func (m *TierInfo) Reset() { *m = TierInfo{} } +func (m *TierInfo) String() string { return proto1.CompactTextString(m) } +func (*TierInfo) ProtoMessage() {} +func (*TierInfo) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{27} } + +func (m *TierInfo) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *TierInfo) GetIngressPolicies() []string { + if m != nil { + return m.IngressPolicies + } + return nil +} + +func (m *TierInfo) GetEgressPolicies() []string { + if m != nil { + return m.EgressPolicies + } + return nil +} + +type NatInfo struct { + ExtIp string `protobuf:"bytes,1,opt,name=ext_ip,json=extIp,proto3" json:"ext_ip,omitempty"` + IntIp string `protobuf:"bytes,2,opt,name=int_ip,json=intIp,proto3" json:"int_ip,omitempty"` +} + +func (m *NatInfo) Reset() { *m = NatInfo{} } +func (m *NatInfo) String() string { return proto1.CompactTextString(m) } +func (*NatInfo) ProtoMessage() {} +func (*NatInfo) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{28} } + +func (m *NatInfo) GetExtIp() string { + if m != nil { + return m.ExtIp + } + return "" +} + +func (m *NatInfo) GetIntIp() string { + if m != nil { + return m.IntIp + } + return "" +} + +type ProcessStatusUpdate struct { + IsoTimestamp string `protobuf:"bytes,1,opt,name=iso_timestamp,json=isoTimestamp,proto3" json:"iso_timestamp,omitempty"` + Uptime float64 `protobuf:"fixed64,2,opt,name=uptime,proto3" json:"uptime,omitempty"` +} + +func (m *ProcessStatusUpdate) Reset() { *m = ProcessStatusUpdate{} } +func (m *ProcessStatusUpdate) String() string { return proto1.CompactTextString(m) } +func (*ProcessStatusUpdate) ProtoMessage() {} +func (*ProcessStatusUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{29} } + +func (m *ProcessStatusUpdate) GetIsoTimestamp() string { + if m != nil { + return m.IsoTimestamp + } + return "" +} + +func (m *ProcessStatusUpdate) GetUptime() float64 { + if m != nil { + return m.Uptime + } + return 0 +} + +type HostEndpointStatusUpdate struct { + Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Status *EndpointStatus `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` +} + +func (m *HostEndpointStatusUpdate) Reset() { *m = HostEndpointStatusUpdate{} } +func (m *HostEndpointStatusUpdate) String() string { return proto1.CompactTextString(m) } +func (*HostEndpointStatusUpdate) ProtoMessage() {} +func (*HostEndpointStatusUpdate) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{30} +} + +func (m *HostEndpointStatusUpdate) GetId() *HostEndpointID { + if m != nil { + return m.Id + } + return nil +} + +func (m *HostEndpointStatusUpdate) GetStatus() *EndpointStatus { + if m != nil { + return m.Status + } + return nil +} + +type EndpointStatus struct { + Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` +} + +func (m *EndpointStatus) Reset() { *m = EndpointStatus{} } +func (m *EndpointStatus) String() string { return proto1.CompactTextString(m) } +func (*EndpointStatus) ProtoMessage() {} +func (*EndpointStatus) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{31} } + +func (m *EndpointStatus) GetStatus() string { + if m != nil { + return m.Status + } + return "" +} + +type HostEndpointStatusRemove struct { + Id *HostEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *HostEndpointStatusRemove) Reset() { *m = HostEndpointStatusRemove{} } +func (m *HostEndpointStatusRemove) String() string { return proto1.CompactTextString(m) } +func (*HostEndpointStatusRemove) ProtoMessage() {} +func (*HostEndpointStatusRemove) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{32} +} + +func (m *HostEndpointStatusRemove) GetId() *HostEndpointID { + if m != nil { + return m.Id + } + return nil +} + +type WorkloadEndpointStatusUpdate struct { + Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + Status *EndpointStatus `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"` +} + +func (m *WorkloadEndpointStatusUpdate) Reset() { *m = WorkloadEndpointStatusUpdate{} } +func (m *WorkloadEndpointStatusUpdate) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpointStatusUpdate) ProtoMessage() {} +func (*WorkloadEndpointStatusUpdate) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{33} +} + +func (m *WorkloadEndpointStatusUpdate) GetId() *WorkloadEndpointID { + if m != nil { + return m.Id + } + return nil +} + +func (m *WorkloadEndpointStatusUpdate) GetStatus() *EndpointStatus { + if m != nil { + return m.Status + } + return nil +} + +type WorkloadEndpointStatusRemove struct { + Id *WorkloadEndpointID `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` +} + +func (m *WorkloadEndpointStatusRemove) Reset() { *m = WorkloadEndpointStatusRemove{} } +func (m *WorkloadEndpointStatusRemove) String() string { return proto1.CompactTextString(m) } +func (*WorkloadEndpointStatusRemove) ProtoMessage() {} +func (*WorkloadEndpointStatusRemove) Descriptor() ([]byte, []int) { + return fileDescriptorFelixbackend, []int{34} +} + +func (m *WorkloadEndpointStatusRemove) GetId() *WorkloadEndpointID { + if m != nil { + return m.Id + } + return nil +} + +type HostMetadataUpdate struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"` +} + +func (m *HostMetadataUpdate) Reset() { *m = HostMetadataUpdate{} } +func (m *HostMetadataUpdate) String() string { return proto1.CompactTextString(m) } +func (*HostMetadataUpdate) ProtoMessage() {} +func (*HostMetadataUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{35} } + +func (m *HostMetadataUpdate) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *HostMetadataUpdate) GetIpv4Addr() string { + if m != nil { + return m.Ipv4Addr + } + return "" +} + +type HostMetadataRemove struct { + Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"` + Ipv4Addr string `protobuf:"bytes,2,opt,name=ipv4_addr,json=ipv4Addr,proto3" json:"ipv4_addr,omitempty"` +} + +func (m *HostMetadataRemove) Reset() { *m = HostMetadataRemove{} } +func (m *HostMetadataRemove) String() string { return proto1.CompactTextString(m) } +func (*HostMetadataRemove) ProtoMessage() {} +func (*HostMetadataRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{36} } + +func (m *HostMetadataRemove) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *HostMetadataRemove) GetIpv4Addr() string { + if m != nil { + return m.Ipv4Addr + } + return "" +} + +type IPAMPoolUpdate struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Pool *IPAMPool `protobuf:"bytes,2,opt,name=pool" json:"pool,omitempty"` +} + +func (m *IPAMPoolUpdate) Reset() { *m = IPAMPoolUpdate{} } +func (m *IPAMPoolUpdate) String() string { return proto1.CompactTextString(m) } +func (*IPAMPoolUpdate) ProtoMessage() {} +func (*IPAMPoolUpdate) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{37} } + +func (m *IPAMPoolUpdate) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *IPAMPoolUpdate) GetPool() *IPAMPool { + if m != nil { + return m.Pool + } + return nil +} + +type IPAMPoolRemove struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *IPAMPoolRemove) Reset() { *m = IPAMPoolRemove{} } +func (m *IPAMPoolRemove) String() string { return proto1.CompactTextString(m) } +func (*IPAMPoolRemove) ProtoMessage() {} +func (*IPAMPoolRemove) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{38} } + +func (m *IPAMPoolRemove) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +type IPAMPool struct { + Cidr string `protobuf:"bytes,1,opt,name=cidr,proto3" json:"cidr,omitempty"` + Masquerade bool `protobuf:"varint,2,opt,name=masquerade,proto3" json:"masquerade,omitempty"` +} + +func (m *IPAMPool) Reset() { *m = IPAMPool{} } +func (m *IPAMPool) String() string { return proto1.CompactTextString(m) } +func (*IPAMPool) ProtoMessage() {} +func (*IPAMPool) Descriptor() ([]byte, []int) { return fileDescriptorFelixbackend, []int{39} } + +func (m *IPAMPool) GetCidr() string { + if m != nil { + return m.Cidr + } + return "" +} + +func (m *IPAMPool) GetMasquerade() bool { + if m != nil { + return m.Masquerade + } + return false +} + +func init() { + proto1.RegisterType((*ToDataplane)(nil), "felix.ToDataplane") + proto1.RegisterType((*FromDataplane)(nil), "felix.FromDataplane") + proto1.RegisterType((*ConfigUpdate)(nil), "felix.ConfigUpdate") + proto1.RegisterType((*InSync)(nil), "felix.InSync") + proto1.RegisterType((*IPSetUpdate)(nil), "felix.IPSetUpdate") + proto1.RegisterType((*IPSetDeltaUpdate)(nil), "felix.IPSetDeltaUpdate") + proto1.RegisterType((*IPSetRemove)(nil), "felix.IPSetRemove") + proto1.RegisterType((*ActiveProfileUpdate)(nil), "felix.ActiveProfileUpdate") + proto1.RegisterType((*ActiveProfileRemove)(nil), "felix.ActiveProfileRemove") + proto1.RegisterType((*ProfileID)(nil), "felix.ProfileID") + proto1.RegisterType((*Profile)(nil), "felix.Profile") + proto1.RegisterType((*ActivePolicyUpdate)(nil), "felix.ActivePolicyUpdate") + proto1.RegisterType((*ActivePolicyRemove)(nil), "felix.ActivePolicyRemove") + proto1.RegisterType((*PolicyID)(nil), "felix.PolicyID") + proto1.RegisterType((*Policy)(nil), "felix.Policy") + proto1.RegisterType((*Rule)(nil), "felix.Rule") + proto1.RegisterType((*IcmpTypeAndCode)(nil), "felix.IcmpTypeAndCode") + proto1.RegisterType((*Protocol)(nil), "felix.Protocol") + proto1.RegisterType((*PortRange)(nil), "felix.PortRange") + proto1.RegisterType((*WorkloadEndpointID)(nil), "felix.WorkloadEndpointID") + proto1.RegisterType((*WorkloadEndpointUpdate)(nil), "felix.WorkloadEndpointUpdate") + proto1.RegisterType((*WorkloadEndpoint)(nil), "felix.WorkloadEndpoint") + proto1.RegisterType((*WorkloadEndpointRemove)(nil), "felix.WorkloadEndpointRemove") + proto1.RegisterType((*HostEndpointID)(nil), "felix.HostEndpointID") + proto1.RegisterType((*HostEndpointUpdate)(nil), "felix.HostEndpointUpdate") + proto1.RegisterType((*HostEndpoint)(nil), "felix.HostEndpoint") + proto1.RegisterType((*HostEndpointRemove)(nil), "felix.HostEndpointRemove") + proto1.RegisterType((*TierInfo)(nil), "felix.TierInfo") + proto1.RegisterType((*NatInfo)(nil), "felix.NatInfo") + proto1.RegisterType((*ProcessStatusUpdate)(nil), "felix.ProcessStatusUpdate") + proto1.RegisterType((*HostEndpointStatusUpdate)(nil), "felix.HostEndpointStatusUpdate") + proto1.RegisterType((*EndpointStatus)(nil), "felix.EndpointStatus") + proto1.RegisterType((*HostEndpointStatusRemove)(nil), "felix.HostEndpointStatusRemove") + proto1.RegisterType((*WorkloadEndpointStatusUpdate)(nil), "felix.WorkloadEndpointStatusUpdate") + proto1.RegisterType((*WorkloadEndpointStatusRemove)(nil), "felix.WorkloadEndpointStatusRemove") + proto1.RegisterType((*HostMetadataUpdate)(nil), "felix.HostMetadataUpdate") + proto1.RegisterType((*HostMetadataRemove)(nil), "felix.HostMetadataRemove") + proto1.RegisterType((*IPAMPoolUpdate)(nil), "felix.IPAMPoolUpdate") + proto1.RegisterType((*IPAMPoolRemove)(nil), "felix.IPAMPoolRemove") + proto1.RegisterType((*IPAMPool)(nil), "felix.IPAMPool") + proto1.RegisterEnum("felix.IPVersion", IPVersion_name, IPVersion_value) + proto1.RegisterEnum("felix.IPSetUpdate_IPSetType", IPSetUpdate_IPSetType_name, IPSetUpdate_IPSetType_value) +} +func (m *ToDataplane) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ToDataplane) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Payload != nil { + nn1, err := m.Payload.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += nn1 + } + if m.SequenceNumber != 0 { + dAtA[i] = 0x78 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.SequenceNumber)) + } + return i, nil +} + +func (m *ToDataplane_InSync) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.InSync != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.InSync.Size())) + n2, err := m.InSync.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + } + return i, nil +} +func (m *ToDataplane_IpsetUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IpsetUpdate != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetUpdate.Size())) + n3, err := m.IpsetUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + } + return i, nil +} +func (m *ToDataplane_IpsetDeltaUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IpsetDeltaUpdate != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetDeltaUpdate.Size())) + n4, err := m.IpsetDeltaUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n4 + } + return i, nil +} +func (m *ToDataplane_IpsetRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IpsetRemove != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpsetRemove.Size())) + n5, err := m.IpsetRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n5 + } + return i, nil +} +func (m *ToDataplane_ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ActiveProfileUpdate != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActiveProfileUpdate.Size())) + n6, err := m.ActiveProfileUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n6 + } + return i, nil +} +func (m *ToDataplane_ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ActiveProfileRemove != nil { + dAtA[i] = 0x32 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActiveProfileRemove.Size())) + n7, err := m.ActiveProfileRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n7 + } + return i, nil +} +func (m *ToDataplane_ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ActivePolicyUpdate != nil { + dAtA[i] = 0x3a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActivePolicyUpdate.Size())) + n8, err := m.ActivePolicyUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n8 + } + return i, nil +} +func (m *ToDataplane_ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ActivePolicyRemove != nil { + dAtA[i] = 0x42 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ActivePolicyRemove.Size())) + n9, err := m.ActivePolicyRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n9 + } + return i, nil +} +func (m *ToDataplane_HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostEndpointUpdate != nil { + dAtA[i] = 0x4a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointUpdate.Size())) + n10, err := m.HostEndpointUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n10 + } + return i, nil +} +func (m *ToDataplane_HostEndpointRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostEndpointRemove != nil { + dAtA[i] = 0x52 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointRemove.Size())) + n11, err := m.HostEndpointRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n11 + } + return i, nil +} +func (m *ToDataplane_WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.WorkloadEndpointUpdate != nil { + dAtA[i] = 0x5a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointUpdate.Size())) + n12, err := m.WorkloadEndpointUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n12 + } + return i, nil +} +func (m *ToDataplane_WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.WorkloadEndpointRemove != nil { + dAtA[i] = 0x62 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointRemove.Size())) + n13, err := m.WorkloadEndpointRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n13 + } + return i, nil +} +func (m *ToDataplane_ConfigUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ConfigUpdate != nil { + dAtA[i] = 0x6a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ConfigUpdate.Size())) + n14, err := m.ConfigUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n14 + } + return i, nil +} +func (m *ToDataplane_HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostMetadataUpdate != nil { + dAtA[i] = 0x72 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataUpdate.Size())) + n15, err := m.HostMetadataUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n15 + } + return i, nil +} +func (m *ToDataplane_IpamPoolUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IpamPoolUpdate != nil { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpamPoolUpdate.Size())) + n16, err := m.IpamPoolUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n16 + } + return i, nil +} +func (m *ToDataplane_IpamPoolRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IpamPoolRemove != nil { + dAtA[i] = 0x8a + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpamPoolRemove.Size())) + n17, err := m.IpamPoolRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n17 + } + return i, nil +} +func (m *ToDataplane_HostMetadataRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostMetadataRemove != nil { + dAtA[i] = 0x92 + i++ + dAtA[i] = 0x1 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostMetadataRemove.Size())) + n18, err := m.HostMetadataRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n18 + } + return i, nil +} +func (m *FromDataplane) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *FromDataplane) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Payload != nil { + nn19, err := m.Payload.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += nn19 + } + if m.SequenceNumber != 0 { + dAtA[i] = 0x40 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.SequenceNumber)) + } + return i, nil +} + +func (m *FromDataplane_ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.ProcessStatusUpdate != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.ProcessStatusUpdate.Size())) + n20, err := m.ProcessStatusUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n20 + } + return i, nil +} +func (m *FromDataplane_HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostEndpointStatusUpdate != nil { + dAtA[i] = 0x22 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointStatusUpdate.Size())) + n21, err := m.HostEndpointStatusUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n21 + } + return i, nil +} +func (m *FromDataplane_HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.HostEndpointStatusRemove != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.HostEndpointStatusRemove.Size())) + n22, err := m.HostEndpointStatusRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n22 + } + return i, nil +} +func (m *FromDataplane_WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.WorkloadEndpointStatusUpdate != nil { + dAtA[i] = 0x32 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointStatusUpdate.Size())) + n23, err := m.WorkloadEndpointStatusUpdate.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n23 + } + return i, nil +} +func (m *FromDataplane_WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.WorkloadEndpointStatusRemove != nil { + dAtA[i] = 0x3a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.WorkloadEndpointStatusRemove.Size())) + n24, err := m.WorkloadEndpointStatusRemove.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n24 + } + return i, nil +} +func (m *ConfigUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ConfigUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Config) > 0 { + for k, _ := range m.Config { + dAtA[i] = 0xa + i++ + v := m.Config[k] + mapSize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v))) + i = encodeVarintFelixbackend(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(v))) + i += copy(dAtA[i:], v) + } + } + return i, nil +} + +func (m *InSync) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *InSync) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + return i, nil +} + +func (m *IPSetUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPSetUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + if len(m.Members) > 0 { + for _, s := range m.Members { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.Type != 0 { + dAtA[i] = 0x18 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Type)) + } + return i, nil +} + +func (m *IPSetDeltaUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPSetDeltaUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + if len(m.AddedMembers) > 0 { + for _, s := range m.AddedMembers { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.RemovedMembers) > 0 { + for _, s := range m.RemovedMembers { + dAtA[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + return i, nil +} + +func (m *IPSetRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPSetRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + return i, nil +} + +func (m *ActiveProfileUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ActiveProfileUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n25, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n25 + } + if m.Profile != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Profile.Size())) + n26, err := m.Profile.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n26 + } + return i, nil +} + +func (m *ActiveProfileRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ActiveProfileRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n27, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n27 + } + return i, nil +} + +func (m *ProfileID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProfileID) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + return i, nil +} + +func (m *Profile) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Profile) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.InboundRules) > 0 { + for _, msg := range m.InboundRules { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.OutboundRules) > 0 { + for _, msg := range m.OutboundRules { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *ActivePolicyUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ActivePolicyUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n28, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n28 + } + if m.Policy != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Policy.Size())) + n29, err := m.Policy.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n29 + } + return i, nil +} + +func (m *ActivePolicyRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ActivePolicyRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n30, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n30 + } + return i, nil +} + +func (m *PolicyID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PolicyID) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Tier) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Tier))) + i += copy(dAtA[i:], m.Tier) + } + if len(m.Name) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + return i, nil +} + +func (m *Policy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Policy) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.InboundRules) > 0 { + for _, msg := range m.InboundRules { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.OutboundRules) > 0 { + for _, msg := range m.OutboundRules { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Untracked { + dAtA[i] = 0x18 + i++ + if m.Untracked { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.PreDnat { + dAtA[i] = 0x20 + i++ + if m.PreDnat { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func (m *Rule) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Rule) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Action) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Action))) + i += copy(dAtA[i:], m.Action) + } + if m.IpVersion != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IpVersion)) + } + if m.Protocol != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Protocol.Size())) + n31, err := m.Protocol.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n31 + } + if len(m.SrcNet) > 0 { + for _, s := range m.SrcNet { + dAtA[i] = 0x22 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.SrcPorts) > 0 { + for _, msg := range m.SrcPorts { + dAtA[i] = 0x2a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.DstNet) > 0 { + for _, s := range m.DstNet { + dAtA[i] = 0x32 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.DstPorts) > 0 { + for _, msg := range m.DstPorts { + dAtA[i] = 0x3a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.Icmp != nil { + nn32, err := m.Icmp.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += nn32 + } + if len(m.SrcIpSetIds) > 0 { + for _, s := range m.SrcIpSetIds { + dAtA[i] = 0x52 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.DstIpSetIds) > 0 { + for _, s := range m.DstIpSetIds { + dAtA[i] = 0x5a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.SrcNamedPortIpSetIds) > 0 { + for _, s := range m.SrcNamedPortIpSetIds { + dAtA[i] = 0x62 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.DstNamedPortIpSetIds) > 0 { + for _, s := range m.DstNamedPortIpSetIds { + dAtA[i] = 0x6a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if m.NotProtocol != nil { + dAtA[i] = 0xb2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotProtocol.Size())) + n33, err := m.NotProtocol.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n33 + } + if len(m.NotSrcNet) > 0 { + for _, s := range m.NotSrcNet { + dAtA[i] = 0xba + i++ + dAtA[i] = 0x6 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.NotSrcPorts) > 0 { + for _, msg := range m.NotSrcPorts { + dAtA[i] = 0xc2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.NotDstNet) > 0 { + for _, s := range m.NotDstNet { + dAtA[i] = 0xca + i++ + dAtA[i] = 0x6 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.NotDstPorts) > 0 { + for _, msg := range m.NotDstPorts { + dAtA[i] = 0xd2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.NotIcmp != nil { + nn34, err := m.NotIcmp.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += nn34 + } + if len(m.NotSrcIpSetIds) > 0 { + for _, s := range m.NotSrcIpSetIds { + dAtA[i] = 0xea + i++ + dAtA[i] = 0x6 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.NotDstIpSetIds) > 0 { + for _, s := range m.NotDstIpSetIds { + dAtA[i] = 0xf2 + i++ + dAtA[i] = 0x6 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.NotSrcNamedPortIpSetIds) > 0 { + for _, s := range m.NotSrcNamedPortIpSetIds { + dAtA[i] = 0x82 + i++ + dAtA[i] = 0x7 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.NotDstNamedPortIpSetIds) > 0 { + for _, s := range m.NotDstNamedPortIpSetIds { + dAtA[i] = 0x8a + i++ + dAtA[i] = 0x7 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.RuleId) > 0 { + dAtA[i] = 0xca + i++ + dAtA[i] = 0xc + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.RuleId))) + i += copy(dAtA[i:], m.RuleId) + } + return i, nil +} + +func (m *Rule_IcmpType) MarshalTo(dAtA []byte) (int, error) { + i := 0 + dAtA[i] = 0x40 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IcmpType)) + return i, nil +} +func (m *Rule_IcmpTypeCode) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.IcmpTypeCode != nil { + dAtA[i] = 0x4a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.IcmpTypeCode.Size())) + n35, err := m.IcmpTypeCode.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n35 + } + return i, nil +} +func (m *Rule_NotIcmpType) MarshalTo(dAtA []byte) (int, error) { + i := 0 + dAtA[i] = 0xd8 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotIcmpType)) + return i, nil +} +func (m *Rule_NotIcmpTypeCode) MarshalTo(dAtA []byte) (int, error) { + i := 0 + if m.NotIcmpTypeCode != nil { + dAtA[i] = 0xe2 + i++ + dAtA[i] = 0x6 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.NotIcmpTypeCode.Size())) + n36, err := m.NotIcmpTypeCode.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n36 + } + return i, nil +} +func (m *IcmpTypeAndCode) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IcmpTypeAndCode) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Type != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Type)) + } + if m.Code != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Code)) + } + return i, nil +} + +func (m *Protocol) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Protocol) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.NumberOrName != nil { + nn37, err := m.NumberOrName.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += nn37 + } + return i, nil +} + +func (m *Protocol_Number) MarshalTo(dAtA []byte) (int, error) { + i := 0 + dAtA[i] = 0x8 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Number)) + return i, nil +} +func (m *Protocol_Name) MarshalTo(dAtA []byte) (int, error) { + i := 0 + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + return i, nil +} +func (m *PortRange) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PortRange) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.First != 0 { + dAtA[i] = 0x8 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.First)) + } + if m.Last != 0 { + dAtA[i] = 0x10 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Last)) + } + return i, nil +} + +func (m *WorkloadEndpointID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpointID) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.OrchestratorId) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.OrchestratorId))) + i += copy(dAtA[i:], m.OrchestratorId) + } + if len(m.WorkloadId) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.WorkloadId))) + i += copy(dAtA[i:], m.WorkloadId) + } + if len(m.EndpointId) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.EndpointId))) + i += copy(dAtA[i:], m.EndpointId) + } + return i, nil +} + +func (m *WorkloadEndpointUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpointUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n38, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n38 + } + if m.Endpoint != nil { + dAtA[i] = 0x2a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Endpoint.Size())) + n39, err := m.Endpoint.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n39 + } + return i, nil +} + +func (m *WorkloadEndpoint) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpoint) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.State) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.State))) + i += copy(dAtA[i:], m.State) + } + if len(m.Name) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.Mac) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Mac))) + i += copy(dAtA[i:], m.Mac) + } + if len(m.ProfileIds) > 0 { + for _, s := range m.ProfileIds { + dAtA[i] = 0x22 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.Ipv4Nets) > 0 { + for _, s := range m.Ipv4Nets { + dAtA[i] = 0x2a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.Ipv6Nets) > 0 { + for _, s := range m.Ipv6Nets { + dAtA[i] = 0x32 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.Tiers) > 0 { + for _, msg := range m.Tiers { + dAtA[i] = 0x3a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Ipv4Nat) > 0 { + for _, msg := range m.Ipv4Nat { + dAtA[i] = 0x42 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.Ipv6Nat) > 0 { + for _, msg := range m.Ipv6Nat { + dAtA[i] = 0x4a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *WorkloadEndpointRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpointRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n40, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n40 + } + return i, nil +} + +func (m *HostEndpointID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpointID) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.EndpointId) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.EndpointId))) + i += copy(dAtA[i:], m.EndpointId) + } + return i, nil +} + +func (m *HostEndpointUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpointUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n41, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n41 + } + if m.Endpoint != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Endpoint.Size())) + n42, err := m.Endpoint.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n42 + } + return i, nil +} + +func (m *HostEndpoint) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpoint) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.ProfileIds) > 0 { + for _, s := range m.ProfileIds { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.Tiers) > 0 { + for _, msg := range m.Tiers { + dAtA[i] = 0x1a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.ExpectedIpv4Addrs) > 0 { + for _, s := range m.ExpectedIpv4Addrs { + dAtA[i] = 0x22 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.ExpectedIpv6Addrs) > 0 { + for _, s := range m.ExpectedIpv6Addrs { + dAtA[i] = 0x2a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.UntrackedTiers) > 0 { + for _, msg := range m.UntrackedTiers { + dAtA[i] = 0x32 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.PreDnatTiers) > 0 { + for _, msg := range m.PreDnatTiers { + dAtA[i] = 0x3a + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if len(m.ForwardTiers) > 0 { + for _, msg := range m.ForwardTiers { + dAtA[i] = 0x42 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func (m *HostEndpointRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpointRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n43, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n43 + } + return i, nil +} + +func (m *TierInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TierInfo) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Name) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Name))) + i += copy(dAtA[i:], m.Name) + } + if len(m.IngressPolicies) > 0 { + for _, s := range m.IngressPolicies { + dAtA[i] = 0x12 + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + if len(m.EgressPolicies) > 0 { + for _, s := range m.EgressPolicies { + dAtA[i] = 0x1a + i++ + l = len(s) + for l >= 1<<7 { + dAtA[i] = uint8(uint64(l)&0x7f | 0x80) + l >>= 7 + i++ + } + dAtA[i] = uint8(l) + i++ + i += copy(dAtA[i:], s) + } + } + return i, nil +} + +func (m *NatInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *NatInfo) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.ExtIp) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.ExtIp))) + i += copy(dAtA[i:], m.ExtIp) + } + if len(m.IntIp) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.IntIp))) + i += copy(dAtA[i:], m.IntIp) + } + return i, nil +} + +func (m *ProcessStatusUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ProcessStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.IsoTimestamp) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.IsoTimestamp))) + i += copy(dAtA[i:], m.IsoTimestamp) + } + if m.Uptime != 0 { + dAtA[i] = 0x11 + i++ + binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Uptime)))) + i += 8 + } + return i, nil +} + +func (m *HostEndpointStatusUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n44, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n44 + } + if m.Status != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Status.Size())) + n45, err := m.Status.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n45 + } + return i, nil +} + +func (m *EndpointStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EndpointStatus) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Status) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Status))) + i += copy(dAtA[i:], m.Status) + } + return i, nil +} + +func (m *HostEndpointStatusRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n46, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n46 + } + return i, nil +} + +func (m *WorkloadEndpointStatusUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpointStatusUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n47, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n47 + } + if m.Status != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Status.Size())) + n48, err := m.Status.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n48 + } + return i, nil +} + +func (m *WorkloadEndpointStatusRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *WorkloadEndpointStatusRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if m.Id != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Id.Size())) + n49, err := m.Id.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n49 + } + return i, nil +} + +func (m *HostMetadataUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostMetadataUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Hostname) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname))) + i += copy(dAtA[i:], m.Hostname) + } + if len(m.Ipv4Addr) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr))) + i += copy(dAtA[i:], m.Ipv4Addr) + } + return i, nil +} + +func (m *HostMetadataRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HostMetadataRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Hostname) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Hostname))) + i += copy(dAtA[i:], m.Hostname) + } + if len(m.Ipv4Addr) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Ipv4Addr))) + i += copy(dAtA[i:], m.Ipv4Addr) + } + return i, nil +} + +func (m *IPAMPoolUpdate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPAMPoolUpdate) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + if m.Pool != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(m.Pool.Size())) + n50, err := m.Pool.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n50 + } + return i, nil +} + +func (m *IPAMPoolRemove) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPAMPoolRemove) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + return i, nil +} + +func (m *IPAMPool) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IPAMPool) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Cidr) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintFelixbackend(dAtA, i, uint64(len(m.Cidr))) + i += copy(dAtA[i:], m.Cidr) + } + if m.Masquerade { + dAtA[i] = 0x10 + i++ + if m.Masquerade { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + return i, nil +} + +func encodeVarintFelixbackend(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ToDataplane) Size() (n int) { + var l int + _ = l + if m.Payload != nil { + n += m.Payload.Size() + } + if m.SequenceNumber != 0 { + n += 1 + sovFelixbackend(uint64(m.SequenceNumber)) + } + return n +} + +func (m *ToDataplane_InSync) Size() (n int) { + var l int + _ = l + if m.InSync != nil { + l = m.InSync.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_IpsetUpdate) Size() (n int) { + var l int + _ = l + if m.IpsetUpdate != nil { + l = m.IpsetUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_IpsetDeltaUpdate) Size() (n int) { + var l int + _ = l + if m.IpsetDeltaUpdate != nil { + l = m.IpsetDeltaUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_IpsetRemove) Size() (n int) { + var l int + _ = l + if m.IpsetRemove != nil { + l = m.IpsetRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_ActiveProfileUpdate) Size() (n int) { + var l int + _ = l + if m.ActiveProfileUpdate != nil { + l = m.ActiveProfileUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_ActiveProfileRemove) Size() (n int) { + var l int + _ = l + if m.ActiveProfileRemove != nil { + l = m.ActiveProfileRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_ActivePolicyUpdate) Size() (n int) { + var l int + _ = l + if m.ActivePolicyUpdate != nil { + l = m.ActivePolicyUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_ActivePolicyRemove) Size() (n int) { + var l int + _ = l + if m.ActivePolicyRemove != nil { + l = m.ActivePolicyRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_HostEndpointUpdate) Size() (n int) { + var l int + _ = l + if m.HostEndpointUpdate != nil { + l = m.HostEndpointUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_HostEndpointRemove) Size() (n int) { + var l int + _ = l + if m.HostEndpointRemove != nil { + l = m.HostEndpointRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_WorkloadEndpointUpdate) Size() (n int) { + var l int + _ = l + if m.WorkloadEndpointUpdate != nil { + l = m.WorkloadEndpointUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_WorkloadEndpointRemove) Size() (n int) { + var l int + _ = l + if m.WorkloadEndpointRemove != nil { + l = m.WorkloadEndpointRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_ConfigUpdate) Size() (n int) { + var l int + _ = l + if m.ConfigUpdate != nil { + l = m.ConfigUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_HostMetadataUpdate) Size() (n int) { + var l int + _ = l + if m.HostMetadataUpdate != nil { + l = m.HostMetadataUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_IpamPoolUpdate) Size() (n int) { + var l int + _ = l + if m.IpamPoolUpdate != nil { + l = m.IpamPoolUpdate.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_IpamPoolRemove) Size() (n int) { + var l int + _ = l + if m.IpamPoolRemove != nil { + l = m.IpamPoolRemove.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ToDataplane_HostMetadataRemove) Size() (n int) { + var l int + _ = l + if m.HostMetadataRemove != nil { + l = m.HostMetadataRemove.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *FromDataplane) Size() (n int) { + var l int + _ = l + if m.Payload != nil { + n += m.Payload.Size() + } + if m.SequenceNumber != 0 { + n += 1 + sovFelixbackend(uint64(m.SequenceNumber)) + } + return n +} + +func (m *FromDataplane_ProcessStatusUpdate) Size() (n int) { + var l int + _ = l + if m.ProcessStatusUpdate != nil { + l = m.ProcessStatusUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *FromDataplane_HostEndpointStatusUpdate) Size() (n int) { + var l int + _ = l + if m.HostEndpointStatusUpdate != nil { + l = m.HostEndpointStatusUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *FromDataplane_HostEndpointStatusRemove) Size() (n int) { + var l int + _ = l + if m.HostEndpointStatusRemove != nil { + l = m.HostEndpointStatusRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *FromDataplane_WorkloadEndpointStatusUpdate) Size() (n int) { + var l int + _ = l + if m.WorkloadEndpointStatusUpdate != nil { + l = m.WorkloadEndpointStatusUpdate.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *FromDataplane_WorkloadEndpointStatusRemove) Size() (n int) { + var l int + _ = l + if m.WorkloadEndpointStatusRemove != nil { + l = m.WorkloadEndpointStatusRemove.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *ConfigUpdate) Size() (n int) { + var l int + _ = l + if len(m.Config) > 0 { + for k, v := range m.Config { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovFelixbackend(uint64(len(k))) + 1 + len(v) + sovFelixbackend(uint64(len(v))) + n += mapEntrySize + 1 + sovFelixbackend(uint64(mapEntrySize)) + } + } + return n +} + +func (m *InSync) Size() (n int) { + var l int + _ = l + return n +} + +func (m *IPSetUpdate) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.Members) > 0 { + for _, s := range m.Members { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if m.Type != 0 { + n += 1 + sovFelixbackend(uint64(m.Type)) + } + return n +} + +func (m *IPSetDeltaUpdate) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.AddedMembers) > 0 { + for _, s := range m.AddedMembers { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.RemovedMembers) > 0 { + for _, s := range m.RemovedMembers { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + return n +} + +func (m *IPSetRemove) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *ActiveProfileUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Profile != nil { + l = m.Profile.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *ActiveProfileRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *ProfileID) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *Profile) Size() (n int) { + var l int + _ = l + if len(m.InboundRules) > 0 { + for _, e := range m.InboundRules { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.OutboundRules) > 0 { + for _, e := range m.OutboundRules { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + return n +} + +func (m *ActivePolicyUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Policy != nil { + l = m.Policy.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *ActivePolicyRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *PolicyID) Size() (n int) { + var l int + _ = l + l = len(m.Tier) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *Policy) Size() (n int) { + var l int + _ = l + if len(m.InboundRules) > 0 { + for _, e := range m.InboundRules { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.OutboundRules) > 0 { + for _, e := range m.OutboundRules { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if m.Untracked { + n += 2 + } + if m.PreDnat { + n += 2 + } + return n +} + +func (m *Rule) Size() (n int) { + var l int + _ = l + l = len(m.Action) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.IpVersion != 0 { + n += 1 + sovFelixbackend(uint64(m.IpVersion)) + } + if m.Protocol != nil { + l = m.Protocol.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.SrcNet) > 0 { + for _, s := range m.SrcNet { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.SrcPorts) > 0 { + for _, e := range m.SrcPorts { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.DstNet) > 0 { + for _, s := range m.DstNet { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.DstPorts) > 0 { + for _, e := range m.DstPorts { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if m.Icmp != nil { + n += m.Icmp.Size() + } + if len(m.SrcIpSetIds) > 0 { + for _, s := range m.SrcIpSetIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.DstIpSetIds) > 0 { + for _, s := range m.DstIpSetIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.SrcNamedPortIpSetIds) > 0 { + for _, s := range m.SrcNamedPortIpSetIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.DstNamedPortIpSetIds) > 0 { + for _, s := range m.DstNamedPortIpSetIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if m.NotProtocol != nil { + l = m.NotProtocol.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + if len(m.NotSrcNet) > 0 { + for _, s := range m.NotSrcNet { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotSrcPorts) > 0 { + for _, e := range m.NotSrcPorts { + l = e.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotDstNet) > 0 { + for _, s := range m.NotDstNet { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotDstPorts) > 0 { + for _, e := range m.NotDstPorts { + l = e.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if m.NotIcmp != nil { + n += m.NotIcmp.Size() + } + if len(m.NotSrcIpSetIds) > 0 { + for _, s := range m.NotSrcIpSetIds { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotDstIpSetIds) > 0 { + for _, s := range m.NotDstIpSetIds { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotSrcNamedPortIpSetIds) > 0 { + for _, s := range m.NotSrcNamedPortIpSetIds { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.NotDstNamedPortIpSetIds) > 0 { + for _, s := range m.NotDstNamedPortIpSetIds { + l = len(s) + n += 2 + l + sovFelixbackend(uint64(l)) + } + } + l = len(m.RuleId) + if l > 0 { + n += 2 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *Rule_IcmpType) Size() (n int) { + var l int + _ = l + n += 1 + sovFelixbackend(uint64(m.IcmpType)) + return n +} +func (m *Rule_IcmpTypeCode) Size() (n int) { + var l int + _ = l + if m.IcmpTypeCode != nil { + l = m.IcmpTypeCode.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *Rule_NotIcmpType) Size() (n int) { + var l int + _ = l + n += 2 + sovFelixbackend(uint64(m.NotIcmpType)) + return n +} +func (m *Rule_NotIcmpTypeCode) Size() (n int) { + var l int + _ = l + if m.NotIcmpTypeCode != nil { + l = m.NotIcmpTypeCode.Size() + n += 2 + l + sovFelixbackend(uint64(l)) + } + return n +} +func (m *IcmpTypeAndCode) Size() (n int) { + var l int + _ = l + if m.Type != 0 { + n += 1 + sovFelixbackend(uint64(m.Type)) + } + if m.Code != 0 { + n += 1 + sovFelixbackend(uint64(m.Code)) + } + return n +} + +func (m *Protocol) Size() (n int) { + var l int + _ = l + if m.NumberOrName != nil { + n += m.NumberOrName.Size() + } + return n +} + +func (m *Protocol_Number) Size() (n int) { + var l int + _ = l + n += 1 + sovFelixbackend(uint64(m.Number)) + return n +} +func (m *Protocol_Name) Size() (n int) { + var l int + _ = l + l = len(m.Name) + n += 1 + l + sovFelixbackend(uint64(l)) + return n +} +func (m *PortRange) Size() (n int) { + var l int + _ = l + if m.First != 0 { + n += 1 + sovFelixbackend(uint64(m.First)) + } + if m.Last != 0 { + n += 1 + sovFelixbackend(uint64(m.Last)) + } + return n +} + +func (m *WorkloadEndpointID) Size() (n int) { + var l int + _ = l + l = len(m.OrchestratorId) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.WorkloadId) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.EndpointId) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *WorkloadEndpointUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Endpoint != nil { + l = m.Endpoint.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *WorkloadEndpoint) Size() (n int) { + var l int + _ = l + l = len(m.State) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.Name) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.Mac) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.ProfileIds) > 0 { + for _, s := range m.ProfileIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Ipv4Nets) > 0 { + for _, s := range m.Ipv4Nets { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Ipv6Nets) > 0 { + for _, s := range m.Ipv6Nets { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Tiers) > 0 { + for _, e := range m.Tiers { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Ipv4Nat) > 0 { + for _, e := range m.Ipv4Nat { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Ipv6Nat) > 0 { + for _, e := range m.Ipv6Nat { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + return n +} + +func (m *WorkloadEndpointRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostEndpointID) Size() (n int) { + var l int + _ = l + l = len(m.EndpointId) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostEndpointUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Endpoint != nil { + l = m.Endpoint.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostEndpoint) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.ProfileIds) > 0 { + for _, s := range m.ProfileIds { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.Tiers) > 0 { + for _, e := range m.Tiers { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.ExpectedIpv4Addrs) > 0 { + for _, s := range m.ExpectedIpv4Addrs { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.ExpectedIpv6Addrs) > 0 { + for _, s := range m.ExpectedIpv6Addrs { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.UntrackedTiers) > 0 { + for _, e := range m.UntrackedTiers { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.PreDnatTiers) > 0 { + for _, e := range m.PreDnatTiers { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.ForwardTiers) > 0 { + for _, e := range m.ForwardTiers { + l = e.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + return n +} + +func (m *HostEndpointRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *TierInfo) Size() (n int) { + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if len(m.IngressPolicies) > 0 { + for _, s := range m.IngressPolicies { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + if len(m.EgressPolicies) > 0 { + for _, s := range m.EgressPolicies { + l = len(s) + n += 1 + l + sovFelixbackend(uint64(l)) + } + } + return n +} + +func (m *NatInfo) Size() (n int) { + var l int + _ = l + l = len(m.ExtIp) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.IntIp) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *ProcessStatusUpdate) Size() (n int) { + var l int + _ = l + l = len(m.IsoTimestamp) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Uptime != 0 { + n += 9 + } + return n +} + +func (m *HostEndpointStatusUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *EndpointStatus) Size() (n int) { + var l int + _ = l + l = len(m.Status) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostEndpointStatusRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *WorkloadEndpointStatusUpdate) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Status != nil { + l = m.Status.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *WorkloadEndpointStatusRemove) Size() (n int) { + var l int + _ = l + if m.Id != nil { + l = m.Id.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostMetadataUpdate) Size() (n int) { + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.Ipv4Addr) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *HostMetadataRemove) Size() (n int) { + var l int + _ = l + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + l = len(m.Ipv4Addr) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *IPAMPoolUpdate) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Pool != nil { + l = m.Pool.Size() + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *IPAMPoolRemove) Size() (n int) { + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + return n +} + +func (m *IPAMPool) Size() (n int) { + var l int + _ = l + l = len(m.Cidr) + if l > 0 { + n += 1 + l + sovFelixbackend(uint64(l)) + } + if m.Masquerade { + n += 2 + } + return n +} + +func sovFelixbackend(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozFelixbackend(x uint64) (n int) { + return sovFelixbackend(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *ToDataplane) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ToDataplane: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ToDataplane: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InSync", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &InSync{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_InSync{v} + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpsetUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IPSetUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_IpsetUpdate{v} + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpsetDeltaUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IPSetDeltaUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_IpsetDeltaUpdate{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpsetRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IPSetRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_IpsetRemove{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveProfileUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ActiveProfileUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_ActiveProfileUpdate{v} + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveProfileRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ActiveProfileRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_ActiveProfileRemove{v} + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActivePolicyUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ActivePolicyUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_ActivePolicyUpdate{v} + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ActivePolicyRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ActivePolicyRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_ActivePolicyRemove{v} + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostEndpointUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_HostEndpointUpdate{v} + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostEndpointRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_HostEndpointRemove{v} + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WorkloadEndpointUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_WorkloadEndpointUpdate{v} + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WorkloadEndpointRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_WorkloadEndpointRemove{v} + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ConfigUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_ConfigUpdate{v} + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostMetadataUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_HostMetadataUpdate{v} + iNdEx = postIndex + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType) + } + m.SequenceNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SequenceNumber |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpamPoolUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IPAMPoolUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_IpamPoolUpdate{v} + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IpamPoolRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IPAMPoolRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_IpamPoolRemove{v} + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostMetadataRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostMetadataRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &ToDataplane_HostMetadataRemove{v} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *FromDataplane) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: FromDataplane: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: FromDataplane: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessStatusUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ProcessStatusUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &FromDataplane_ProcessStatusUpdate{v} + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointStatusUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostEndpointStatusUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &FromDataplane_HostEndpointStatusUpdate{v} + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HostEndpointStatusRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &HostEndpointStatusRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &FromDataplane_HostEndpointStatusRemove{v} + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointStatusUpdate", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WorkloadEndpointStatusUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &FromDataplane_WorkloadEndpointStatusUpdate{v} + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadEndpointStatusRemove", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WorkloadEndpointStatusRemove{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Payload = &FromDataplane_WorkloadEndpointStatusRemove{v} + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType) + } + m.SequenceNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SequenceNumber |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ConfigUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ConfigUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Config == nil { + m.Config = make(map[string]string) + } + var mapkey string + var mapvalue string + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthFelixbackend + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthFelixbackend + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + } else { + iNdEx = entryPreIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.Config[mapkey] = mapvalue + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *InSync) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: InSync: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: InSync: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPSetUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPSetUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPSetUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Members = append(m.Members, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= (IPSetUpdate_IPSetType(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPSetDeltaUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPSetDeltaUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPSetDeltaUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AddedMembers", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AddedMembers = append(m.AddedMembers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RemovedMembers", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RemovedMembers = append(m.RemovedMembers, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPSetRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPSetRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPSetRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActiveProfileUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActiveProfileUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActiveProfileUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &ProfileID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Profile", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Profile == nil { + m.Profile = &Profile{} + } + if err := m.Profile.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActiveProfileRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActiveProfileRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActiveProfileRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &ProfileID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProfileID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProfileID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProfileID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Profile) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Profile: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Profile: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InboundRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InboundRules = append(m.InboundRules, &Rule{}) + if err := m.InboundRules[len(m.InboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutboundRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutboundRules = append(m.OutboundRules, &Rule{}) + if err := m.OutboundRules[len(m.OutboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActivePolicyUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActivePolicyUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActivePolicyUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &PolicyID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Policy == nil { + m.Policy = &Policy{} + } + if err := m.Policy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ActivePolicyRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ActivePolicyRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ActivePolicyRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &PolicyID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PolicyID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PolicyID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PolicyID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tier", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tier = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Policy) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Policy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Policy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InboundRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InboundRules = append(m.InboundRules, &Rule{}) + if err := m.InboundRules[len(m.InboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OutboundRules", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OutboundRules = append(m.OutboundRules, &Rule{}) + if err := m.OutboundRules[len(m.OutboundRules)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Untracked", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Untracked = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PreDnat", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.PreDnat = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Rule) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Rule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Rule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Action = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IpVersion", wireType) + } + m.IpVersion = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.IpVersion |= (IPVersion(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Protocol == nil { + m.Protocol = &Protocol{} + } + if err := m.Protocol.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcNet", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SrcNet = append(m.SrcNet, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcPorts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SrcPorts = append(m.SrcPorts, &PortRange{}) + if err := m.SrcPorts[len(m.SrcPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstNet", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DstNet = append(m.DstNet, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstPorts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DstPorts = append(m.DstPorts, &PortRange{}) + if err := m.DstPorts[len(m.DstPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IcmpType", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Icmp = &Rule_IcmpType{v} + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IcmpTypeCode", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IcmpTypeAndCode{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Icmp = &Rule_IcmpTypeCode{v} + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SrcIpSetIds = append(m.SrcIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DstIpSetIds = append(m.DstIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SrcNamedPortIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SrcNamedPortIpSetIds = append(m.SrcNamedPortIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstNamedPortIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DstNamedPortIpSetIds = append(m.DstNamedPortIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 102: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotProtocol", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NotProtocol == nil { + m.NotProtocol = &Protocol{} + } + if err := m.NotProtocol.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 103: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotSrcNet", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotSrcNet = append(m.NotSrcNet, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 104: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotSrcPorts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotSrcPorts = append(m.NotSrcPorts, &PortRange{}) + if err := m.NotSrcPorts[len(m.NotSrcPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 105: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotDstNet", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotDstNet = append(m.NotDstNet, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 106: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotDstPorts", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotDstPorts = append(m.NotDstPorts, &PortRange{}) + if err := m.NotDstPorts[len(m.NotDstPorts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 107: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NotIcmpType", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NotIcmp = &Rule_NotIcmpType{v} + case 108: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotIcmpTypeCode", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &IcmpTypeAndCode{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.NotIcmp = &Rule_NotIcmpTypeCode{v} + iNdEx = postIndex + case 109: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotSrcIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotSrcIpSetIds = append(m.NotSrcIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 110: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotDstIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotDstIpSetIds = append(m.NotDstIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 112: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotSrcNamedPortIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotSrcNamedPortIpSetIds = append(m.NotSrcNamedPortIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 113: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NotDstNamedPortIpSetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NotDstNamedPortIpSetIds = append(m.NotDstNamedPortIpSetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 201: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RuleId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RuleId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IcmpTypeAndCode) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IcmpTypeAndCode: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IcmpTypeAndCode: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + m.Code = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Code |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Protocol) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Protocol: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Protocol: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType) + } + var v int32 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.NumberOrName = &Protocol_Number{v} + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.NumberOrName = &Protocol_Name{string(dAtA[iNdEx:postIndex])} + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PortRange) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PortRange: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PortRange: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field First", wireType) + } + m.First = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.First |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Last", wireType) + } + m.Last = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Last |= (int32(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpointID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpointID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpointID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OrchestratorId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.OrchestratorId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.WorkloadId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndpointId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndpointId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpointUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpointUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &WorkloadEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Endpoint == nil { + m.Endpoint = &WorkloadEndpoint{} + } + if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpoint) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.State = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Mac", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Mac = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProfileIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProfileIds = append(m.ProfileIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Nets", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv4Nets = append(m.Ipv4Nets, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Nets", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv6Nets = append(m.Ipv6Nets, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tiers = append(m.Tiers, &TierInfo{}) + if err := m.Tiers[len(m.Tiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Nat", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv4Nat = append(m.Ipv4Nat, &NatInfo{}) + if err := m.Ipv4Nat[len(m.Ipv4Nat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv6Nat", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv6Nat = append(m.Ipv6Nat, &NatInfo{}) + if err := m.Ipv6Nat[len(m.Ipv6Nat)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpointRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpointRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &WorkloadEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpointID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpointID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpointID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndpointId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EndpointId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpointUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpointUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpointUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &HostEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Endpoint", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Endpoint == nil { + m.Endpoint = &HostEndpoint{} + } + if err := m.Endpoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpoint) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpoint: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpoint: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProfileIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProfileIds = append(m.ProfileIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tiers = append(m.Tiers, &TierInfo{}) + if err := m.Tiers[len(m.Tiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpectedIpv4Addrs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExpectedIpv4Addrs = append(m.ExpectedIpv4Addrs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpectedIpv6Addrs", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExpectedIpv6Addrs = append(m.ExpectedIpv6Addrs, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UntrackedTiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.UntrackedTiers = append(m.UntrackedTiers, &TierInfo{}) + if err := m.UntrackedTiers[len(m.UntrackedTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreDnatTiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreDnatTiers = append(m.PreDnatTiers, &TierInfo{}) + if err := m.PreDnatTiers[len(m.PreDnatTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ForwardTiers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ForwardTiers = append(m.ForwardTiers, &TierInfo{}) + if err := m.ForwardTiers[len(m.ForwardTiers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpointRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpointRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpointRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &HostEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TierInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TierInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TierInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IngressPolicies", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IngressPolicies = append(m.IngressPolicies, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EgressPolicies", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EgressPolicies = append(m.EgressPolicies, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NatInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NatInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NatInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtIp", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExtIp = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IntIp", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IntIp = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ProcessStatusUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ProcessStatusUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ProcessStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IsoTimestamp", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IsoTimestamp = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Uptime = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpointStatusUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpointStatusUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpointStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &HostEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = &EndpointStatus{} + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EndpointStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EndpointStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EndpointStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostEndpointStatusRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostEndpointStatusRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostEndpointStatusRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &HostEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpointStatusUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpointStatusUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpointStatusUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &WorkloadEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Status == nil { + m.Status = &EndpointStatus{} + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WorkloadEndpointStatusRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WorkloadEndpointStatusRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadEndpointStatusRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Id == nil { + m.Id = &WorkloadEndpointID{} + } + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostMetadataUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostMetadataUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostMetadataUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv4Addr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostMetadataRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HostMetadataRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostMetadataRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ipv4Addr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ipv4Addr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPAMPoolUpdate) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPAMPoolUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPAMPoolUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pool == nil { + m.Pool = &IPAMPool{} + } + if err := m.Pool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPAMPoolRemove) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPAMPoolRemove: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPAMPoolRemove: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IPAMPool) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IPAMPool: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IPAMPool: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cidr", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthFelixbackend + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cidr = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Masquerade", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.Masquerade = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipFelixbackend(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthFelixbackend + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipFelixbackend(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthFelixbackend + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowFelixbackend + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipFelixbackend(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthFelixbackend = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowFelixbackend = fmt.Errorf("proto: integer overflow") +) + +func init() { proto1.RegisterFile("felixbackend.proto", fileDescriptorFelixbackend) } + +var fileDescriptorFelixbackend = []byte{ + // 2178 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x72, 0xdc, 0xb6, + 0xf5, 0xd7, 0xae, 0xf6, 0x83, 0x3c, 0xfb, 0x19, 0xf8, 0x6b, 0xed, 0xd8, 0xb2, 0x86, 0x8e, 0x27, + 0x72, 0xfe, 0x13, 0x27, 0xa3, 0xd8, 0x72, 0x92, 0xff, 0x8c, 0x67, 0x64, 0xaf, 0x5b, 0x6d, 0xa6, + 0x52, 0x77, 0x28, 0x35, 0x9d, 0x74, 0x3a, 0xc3, 0xd2, 0x4b, 0x48, 0x62, 0xbd, 0x4b, 0xd0, 0x24, + 0x56, 0x96, 0x6e, 0xfb, 0x00, 0x6d, 0x1f, 0xa0, 0xd7, 0xed, 0x13, 0xf4, 0x1d, 0x92, 0xbb, 0x3e, + 0x42, 0xc7, 0x7d, 0x82, 0xbe, 0x41, 0x07, 0xc0, 0x01, 0x96, 0x5c, 0x72, 0x65, 0xbb, 0x17, 0xbd, + 0x22, 0x71, 0xce, 0x0f, 0x3f, 0x1c, 0x9c, 0x73, 0x00, 0x1c, 0x00, 0xc8, 0x31, 0x9d, 0x86, 0xe7, + 0x2f, 0xfd, 0xc9, 0x2b, 0x1a, 0x05, 0x0f, 0xe3, 0x84, 0x71, 0x46, 0xea, 0x52, 0xe6, 0xfc, 0x05, + 0xa0, 0x75, 0xc4, 0x86, 0x3e, 0xf7, 0xe3, 0xa9, 0x1f, 0x51, 0xb2, 0x05, 0xcd, 0x30, 0xf2, 0xd2, + 0x8b, 0x68, 0x32, 0xa8, 0x6c, 0x56, 0xb6, 0x5a, 0xdb, 0x9d, 0x87, 0x12, 0xf8, 0x70, 0x14, 0x1d, + 0x5e, 0x44, 0x93, 0xbd, 0x35, 0xb7, 0x11, 0xca, 0x3f, 0xf2, 0x04, 0xda, 0x61, 0x9c, 0x52, 0xee, + 0xcd, 0xe3, 0xc0, 0xe7, 0x74, 0x50, 0x95, 0x70, 0xa2, 0xe1, 0xe3, 0x43, 0xca, 0x7f, 0x25, 0x35, + 0x7b, 0x6b, 0x6e, 0x4b, 0x22, 0x55, 0x93, 0xfc, 0x1c, 0x88, 0xea, 0x18, 0xd0, 0x29, 0xf7, 0x75, + 0xf7, 0x75, 0xd9, 0xfd, 0x46, 0xb6, 0xfb, 0x50, 0xe8, 0x0d, 0x47, 0x5f, 0x76, 0xca, 0xc8, 0x16, + 0x16, 0x24, 0x74, 0xc6, 0xce, 0xe8, 0xa0, 0x56, 0xb4, 0xc0, 0x95, 0x1a, 0x63, 0x81, 0x6a, 0x92, + 0x31, 0x5c, 0xf3, 0x27, 0x3c, 0x3c, 0xa3, 0x5e, 0x9c, 0xb0, 0xe3, 0x70, 0x4a, 0xb5, 0x11, 0x75, + 0xc9, 0x70, 0x0b, 0x19, 0x76, 0x25, 0x66, 0xac, 0x20, 0xc6, 0x8e, 0x2b, 0x7e, 0x51, 0x5c, 0xc2, + 0x88, 0x36, 0x35, 0x56, 0x33, 0x1a, 0xdb, 0xf2, 0x8c, 0x68, 0xe3, 0x3e, 0x5c, 0xd5, 0x8c, 0x6c, + 0x1a, 0x4e, 0x2e, 0xb4, 0x89, 0x4d, 0x49, 0x78, 0x33, 0x4f, 0x28, 0x11, 0xc6, 0x42, 0xe2, 0x17, + 0xa4, 0x45, 0x3a, 0xb4, 0xcf, 0x5a, 0x49, 0x67, 0xcc, 0xcb, 0xd1, 0x2d, 0xac, 0x3b, 0x65, 0x29, + 0xf7, 0x68, 0x14, 0xc4, 0x2c, 0x8c, 0x4c, 0x12, 0xd8, 0x39, 0xba, 0x3d, 0x96, 0xf2, 0x17, 0x88, + 0x58, 0x58, 0x77, 0x5a, 0x90, 0x16, 0xe9, 0xd0, 0x3a, 0x58, 0x49, 0xb7, 0xb0, 0xee, 0xb4, 0x20, + 0x25, 0x3f, 0xc0, 0xe0, 0x0d, 0x4b, 0x5e, 0x4d, 0x99, 0x1f, 0x14, 0x2c, 0x6c, 0x49, 0xca, 0x3b, + 0x48, 0xf9, 0x6b, 0x84, 0x15, 0xac, 0xbc, 0xfe, 0xa6, 0x54, 0x53, 0x4e, 0x8d, 0xd6, 0xb6, 0x2f, + 0xa5, 0x36, 0x16, 0x17, 0xa8, 0xd1, 0xea, 0x6f, 0xa1, 0x33, 0x61, 0xd1, 0x71, 0x78, 0xa2, 0x4d, + 0xed, 0x48, 0xbe, 0x2b, 0xc8, 0xf7, 0x5c, 0xea, 0x8c, 0x81, 0xed, 0x49, 0xa6, 0x6d, 0x1c, 0x38, + 0xa3, 0xdc, 0x0f, 0xfc, 0xc5, 0xaa, 0xea, 0x16, 0x1c, 0xb8, 0x8f, 0x88, 0x7c, 0x3c, 0xf2, 0x52, + 0xf2, 0x29, 0xf4, 0x52, 0xfa, 0x7a, 0x4e, 0xa3, 0x09, 0xf5, 0xa2, 0xf9, 0xec, 0x25, 0x4d, 0x06, + 0xbd, 0xcd, 0xca, 0x56, 0xcd, 0xed, 0x6a, 0xf1, 0x81, 0x94, 0x92, 0x5d, 0xe8, 0x87, 0xb1, 0x3f, + 0xf3, 0x62, 0xc6, 0xa6, 0x7a, 0xcc, 0xbe, 0x1c, 0xf3, 0x9a, 0x59, 0x86, 0xbb, 0xfb, 0x63, 0xc6, + 0xa6, 0x66, 0xbc, 0xae, 0xe8, 0xb0, 0x90, 0xe4, 0x29, 0xd0, 0x93, 0x1f, 0x95, 0x52, 0x18, 0x0f, + 0x1a, 0x8a, 0xa5, 0x6c, 0x34, 0xb3, 0x47, 0x1a, 0xb2, 0x72, 0xf6, 0xf9, 0xf4, 0xc9, 0x4b, 0x9f, + 0xd9, 0xd0, 0x8c, 0xfd, 0x0b, 0x11, 0x21, 0xe7, 0xef, 0x35, 0xe8, 0xfc, 0x2c, 0x61, 0xb3, 0xc5, + 0x06, 0x39, 0x86, 0x6b, 0x71, 0xc2, 0x26, 0x34, 0x4d, 0xbd, 0x94, 0xfb, 0x7c, 0x9e, 0xe6, 0x37, + 0x30, 0xbd, 0xd2, 0xc7, 0x0a, 0x73, 0x28, 0x21, 0x8b, 0xbd, 0x23, 0x2e, 0x8a, 0xc9, 0xef, 0xe0, + 0xe3, 0x7c, 0xf2, 0xe7, 0x79, 0xd5, 0xae, 0x76, 0xb7, 0x64, 0x0d, 0x2c, 0x91, 0x0f, 0x4e, 0x57, + 0xe8, 0x56, 0x8e, 0x80, 0x6e, 0xaa, 0xbf, 0x63, 0x04, 0xe3, 0xac, 0x92, 0x11, 0x30, 0x02, 0x53, + 0xb8, 0x5b, 0x5c, 0x16, 0xf9, 0x79, 0xa8, 0x9d, 0xf0, 0xde, 0x8a, 0xd5, 0xb1, 0x34, 0x97, 0xdb, + 0x6f, 0x2e, 0xd1, 0x5f, 0x3a, 0x1a, 0xce, 0xa9, 0xf9, 0x1e, 0xa3, 0x99, 0x79, 0xad, 0x18, 0x0d, + 0xe7, 0x56, 0xb2, 0x18, 0xac, 0xb2, 0xc5, 0x90, 0xcd, 0x9b, 0x3f, 0x54, 0xa0, 0x9d, 0x5d, 0xb0, + 0xe4, 0x09, 0x34, 0xd4, 0x82, 0x1d, 0x54, 0x36, 0xd7, 0x33, 0xde, 0xce, 0x82, 0xb0, 0xf1, 0x22, + 0xe2, 0xc9, 0x85, 0x8b, 0xf0, 0x5b, 0xdf, 0x40, 0x2b, 0x23, 0x26, 0x7d, 0x58, 0x7f, 0x45, 0x2f, + 0xe4, 0xd9, 0x6c, 0xbb, 0xe2, 0x97, 0x5c, 0x85, 0xfa, 0x99, 0x3f, 0x9d, 0xab, 0x03, 0xd8, 0x76, + 0x55, 0xe3, 0xdb, 0xea, 0xd7, 0x15, 0xc7, 0x82, 0x86, 0x3a, 0xb5, 0x9d, 0x3f, 0x55, 0xa0, 0x95, + 0x39, 0x91, 0x49, 0x17, 0xaa, 0x61, 0x80, 0x24, 0xd5, 0x30, 0x20, 0x03, 0x68, 0xce, 0xa8, 0x98, + 0x43, 0x3a, 0xa8, 0x6e, 0xae, 0x6f, 0xd9, 0xae, 0x6e, 0x92, 0x2f, 0xa1, 0xc6, 0x2f, 0x62, 0x95, + 0xdd, 0xdd, 0xed, 0xdb, 0xc5, 0xd3, 0x5d, 0xfd, 0x1f, 0x5d, 0xc4, 0xd4, 0x95, 0x48, 0xe7, 0x13, + 0xb0, 0x8d, 0x88, 0x34, 0xa0, 0x3a, 0x1a, 0xf7, 0xd7, 0x48, 0x4f, 0x8c, 0xef, 0xed, 0x1e, 0x0c, + 0xbd, 0xf1, 0x2f, 0xdd, 0xa3, 0x7e, 0xc5, 0x89, 0xa1, 0xbf, 0x7c, 0xc6, 0x17, 0xac, 0xba, 0x07, + 0x1d, 0x3f, 0x08, 0x68, 0xe0, 0xe5, 0x6d, 0x6b, 0x4b, 0xe1, 0x3e, 0x1a, 0xf8, 0x29, 0xf4, 0x54, + 0xc8, 0x17, 0xb0, 0x75, 0x09, 0xeb, 0xa2, 0x18, 0x81, 0xce, 0x1d, 0x74, 0x01, 0x46, 0x75, 0x69, + 0x30, 0xc7, 0x87, 0x2b, 0x25, 0xe7, 0x3d, 0xd9, 0x34, 0xb0, 0xd6, 0x76, 0x7f, 0xb1, 0xb6, 0x05, + 0x62, 0x34, 0x94, 0x56, 0x6e, 0x41, 0x13, 0xcf, 0x7c, 0x2c, 0x81, 0xba, 0x79, 0x98, 0xab, 0xd5, + 0xce, 0x93, 0xa5, 0x21, 0xd0, 0x92, 0x77, 0x0e, 0xe1, 0xdc, 0x05, 0xdb, 0x08, 0x08, 0x81, 0x5a, + 0xe4, 0xcf, 0x28, 0x9a, 0x2e, 0xff, 0x1d, 0x06, 0x4d, 0x04, 0x90, 0x2f, 0xa1, 0x13, 0x46, 0x2f, + 0xd9, 0x3c, 0x0a, 0xbc, 0x64, 0x3e, 0xa5, 0x29, 0xe6, 0x5b, 0x0b, 0x89, 0xdd, 0xf9, 0x94, 0xba, + 0x6d, 0x44, 0x88, 0x46, 0x4a, 0xb6, 0xa1, 0xcb, 0xe6, 0x3c, 0xdb, 0xa5, 0x5a, 0xec, 0xd2, 0xd1, + 0x10, 0xd9, 0xc7, 0xf9, 0x2d, 0x90, 0x62, 0xe9, 0x41, 0xee, 0x66, 0x66, 0xd2, 0xd3, 0x33, 0x91, + 0x00, 0xf4, 0xd5, 0x7d, 0x68, 0xa8, 0xf2, 0x03, 0x5d, 0xd5, 0xc9, 0x81, 0x5c, 0x54, 0x3a, 0x8f, + 0xf3, 0xec, 0xe8, 0xa7, 0x77, 0xb1, 0x3b, 0xdb, 0x60, 0xe9, 0xb6, 0xf0, 0x12, 0x0f, 0x69, 0xa2, + 0xbd, 0x24, 0xfe, 0x8d, 0xe7, 0xaa, 0x19, 0xcf, 0xfd, 0xad, 0x02, 0x0d, 0xd5, 0xe9, 0x7f, 0xe3, + 0x39, 0x72, 0x1b, 0xec, 0x79, 0xc4, 0x13, 0x51, 0x8b, 0x07, 0x72, 0x55, 0x59, 0xee, 0x42, 0x40, + 0x6e, 0x82, 0x15, 0x27, 0xd4, 0x0b, 0x22, 0x9f, 0xcb, 0x8d, 0xdf, 0x12, 0xd9, 0x43, 0x87, 0x91, + 0xcf, 0x9d, 0x3f, 0xda, 0x50, 0x13, 0x14, 0xe4, 0x3a, 0x34, 0x44, 0x45, 0xc6, 0x22, 0x9c, 0x1c, + 0xb6, 0xc8, 0x17, 0x00, 0x61, 0xec, 0x9d, 0xd1, 0x24, 0x15, 0xba, 0xaa, 0x5c, 0xb0, 0x7d, 0xb3, + 0x60, 0xbf, 0x57, 0x72, 0xd7, 0x0e, 0x63, 0xfc, 0x25, 0xff, 0x27, 0x06, 0x63, 0x9c, 0x4d, 0xd8, + 0x14, 0x4f, 0xaf, 0xde, 0x22, 0xfd, 0xa4, 0xd8, 0x35, 0x00, 0x72, 0x03, 0x9a, 0x69, 0x32, 0xf1, + 0x22, 0x2a, 0x0c, 0x13, 0xeb, 0xab, 0x91, 0x26, 0x93, 0x03, 0xca, 0xc9, 0xe7, 0x60, 0x0b, 0x45, + 0xcc, 0x12, 0x9e, 0x0e, 0xea, 0x72, 0xfe, 0x26, 0x8b, 0x59, 0xc2, 0x5d, 0x3f, 0x3a, 0xa1, 0xae, + 0x95, 0x26, 0x13, 0xd1, 0x4a, 0x05, 0x4f, 0x90, 0x72, 0xc9, 0xd3, 0x50, 0x3c, 0x41, 0xca, 0x91, + 0x47, 0x28, 0x14, 0x4f, 0x73, 0x15, 0x4f, 0x90, 0x72, 0xc5, 0x73, 0x07, 0xec, 0x70, 0x32, 0x8b, + 0x3d, 0xb9, 0x3b, 0x89, 0xfd, 0xb8, 0xbe, 0xb7, 0xe6, 0x5a, 0x42, 0x24, 0x37, 0x9e, 0xa7, 0xd0, + 0x35, 0x6a, 0x6f, 0xc2, 0x02, 0x5d, 0x9a, 0x5e, 0xd7, 0x0e, 0x41, 0xe0, 0x6e, 0x14, 0x3c, 0x67, + 0x81, 0x2c, 0xa8, 0x74, 0x5f, 0xd1, 0x26, 0xf7, 0xa0, 0x2b, 0x66, 0x15, 0xc6, 0x9e, 0xb8, 0x60, + 0x84, 0x41, 0x3a, 0x00, 0x69, 0x6d, 0x2b, 0x4d, 0x26, 0xa3, 0xf8, 0x90, 0xf2, 0x51, 0x90, 0x0a, + 0x90, 0x30, 0x39, 0x03, 0x6a, 0x29, 0x50, 0x90, 0x72, 0x03, 0x7a, 0x02, 0x37, 0xa5, 0xe3, 0xfc, + 0x19, 0x0d, 0xe4, 0xec, 0xb2, 0xf8, 0xb6, 0xc4, 0x5f, 0x15, 0xae, 0x14, 0x7a, 0x31, 0xb5, 0x6c, + 0x47, 0xe9, 0xa9, 0xd2, 0x8e, 0x1d, 0xd5, 0x51, 0xf8, 0xae, 0xd0, 0x71, 0x1b, 0xda, 0x11, 0xe3, + 0x9e, 0x89, 0xed, 0x71, 0x79, 0x6c, 0x5b, 0x11, 0xe3, 0xba, 0x41, 0x36, 0x40, 0x34, 0x3d, 0x1d, + 0xe2, 0x13, 0x49, 0x6f, 0x47, 0x8c, 0x1f, 0xaa, 0x28, 0x3f, 0x82, 0x8e, 0xd6, 0xab, 0x08, 0x9d, + 0xae, 0x88, 0x50, 0x4b, 0xf5, 0x51, 0x41, 0x42, 0x56, 0x1d, 0xf0, 0xd0, 0xb0, 0x0e, 0x55, 0xcc, + 0x91, 0x75, 0x11, 0xf7, 0xdf, 0x5f, 0xc2, 0x3a, 0xd4, 0xa1, 0xff, 0x44, 0xf5, 0x5a, 0x84, 0xff, + 0x95, 0x0c, 0x7f, 0x45, 0xa2, 0x74, 0x60, 0xc9, 0x0b, 0x20, 0x39, 0x94, 0xca, 0x82, 0xe9, 0xa5, + 0x59, 0x50, 0x71, 0x7b, 0x19, 0x0a, 0x99, 0x08, 0x9f, 0x29, 0x9a, 0xa5, 0x64, 0x98, 0xa9, 0x23, + 0x46, 0xcd, 0xd5, 0x38, 0x1e, 0xb1, 0x4b, 0x39, 0x11, 0x19, 0xec, 0x30, 0x93, 0x16, 0x4f, 0xe1, + 0x8e, 0x71, 0x78, 0x69, 0x84, 0x63, 0xd9, 0xed, 0x06, 0x86, 0xa0, 0x10, 0x64, 0xec, 0xbf, 0x3a, + 0x43, 0x5e, 0x9b, 0xfe, 0xc3, 0xb2, 0x24, 0x19, 0x40, 0x53, 0x6c, 0x59, 0x5e, 0x18, 0x0c, 0x7e, + 0xc2, 0x7d, 0x44, 0xb4, 0x47, 0xc1, 0xb3, 0x06, 0xd4, 0x84, 0xd3, 0x9e, 0x01, 0x58, 0xda, 0x81, + 0xdf, 0x35, 0xac, 0x1f, 0x2b, 0xfd, 0x9f, 0x2a, 0x2e, 0x4c, 0xd9, 0x89, 0x17, 0x27, 0xf4, 0x38, + 0x3c, 0x77, 0xbe, 0x81, 0xde, 0x92, 0xff, 0xe4, 0xae, 0x2b, 0x02, 0x22, 0x08, 0xeb, 0xaa, 0x1e, + 0x10, 0x32, 0xe9, 0xf9, 0xaa, 0x92, 0x89, 0x7f, 0xe7, 0x17, 0x60, 0x99, 0xcc, 0x1b, 0x40, 0x03, + 0xab, 0xaa, 0x0a, 0xae, 0x62, 0x6c, 0x93, 0xab, 0xd9, 0xfd, 0x7a, 0x6f, 0x4d, 0xed, 0xd8, 0xcf, + 0xfa, 0xd0, 0x55, 0x7a, 0x8f, 0x25, 0x72, 0xea, 0xce, 0x63, 0xb0, 0x4d, 0xa6, 0x88, 0x72, 0xe8, + 0x38, 0x4c, 0x52, 0x8e, 0x36, 0xa8, 0x86, 0x30, 0x62, 0xea, 0xa7, 0x5c, 0x1b, 0x21, 0xfe, 0x45, + 0x51, 0x44, 0x96, 0x0b, 0xc3, 0xd1, 0x50, 0x14, 0x14, 0x2c, 0x99, 0x9c, 0xd2, 0x94, 0x27, 0x3e, + 0x67, 0x89, 0x70, 0x90, 0x3a, 0x30, 0xba, 0x59, 0xf1, 0x28, 0x20, 0x77, 0xa1, 0x65, 0xaa, 0xd0, + 0x50, 0xed, 0xe5, 0xb6, 0x0b, 0x5a, 0xa4, 0x00, 0xa6, 0x3a, 0x0d, 0x03, 0xb9, 0x9f, 0xdb, 0x2e, + 0x68, 0xd1, 0x28, 0xf8, 0xae, 0x66, 0x55, 0xfa, 0x55, 0xd7, 0x12, 0x55, 0xb5, 0x9c, 0xc8, 0x39, + 0x5c, 0x2f, 0xbf, 0x90, 0x92, 0x07, 0x99, 0xb3, 0xef, 0xe6, 0x8a, 0xa2, 0x16, 0xcf, 0xd8, 0xaf, + 0xc0, 0xd2, 0x43, 0x60, 0x65, 0x7f, 0x63, 0xd5, 0x8d, 0xd4, 0x00, 0x9d, 0xbf, 0x56, 0xa1, 0xbf, + 0xac, 0x16, 0xae, 0x14, 0x45, 0xb5, 0x2e, 0x35, 0x54, 0xa3, 0xec, 0x14, 0x15, 0x55, 0xe9, 0xcc, + 0x9f, 0xa0, 0x0b, 0xc4, 0xaf, 0x98, 0xbb, 0x7e, 0x09, 0x11, 0xc9, 0xa8, 0x8e, 0x0c, 0x40, 0x91, + 0xc8, 0xbf, 0x8f, 0xc1, 0x0e, 0xe3, 0xb3, 0x47, 0x62, 0x5f, 0x50, 0xc7, 0x86, 0xed, 0x5a, 0x42, + 0x70, 0x40, 0xb9, 0x56, 0xee, 0x28, 0x65, 0xc3, 0x28, 0x77, 0xa4, 0xf2, 0x3e, 0xd4, 0xc5, 0x71, + 0xae, 0x0f, 0x09, 0xbd, 0xaf, 0x1d, 0x85, 0x34, 0x19, 0x45, 0xc7, 0xcc, 0x55, 0x5a, 0xf2, 0x00, + 0x2c, 0x35, 0x80, 0xcf, 0x07, 0x96, 0x44, 0xea, 0xc2, 0xec, 0xc0, 0xe7, 0x12, 0xd8, 0x94, 0xe3, + 0xf9, 0x1c, 0xa1, 0x3b, 0x12, 0x6a, 0xaf, 0x84, 0xee, 0x1c, 0xf8, 0xdc, 0x79, 0x5e, 0x0c, 0x11, + 0x96, 0x27, 0xef, 0x1f, 0x22, 0x67, 0x17, 0xba, 0xd9, 0x5b, 0xd6, 0x68, 0xb8, 0x9c, 0x2a, 0xd5, + 0x77, 0xa6, 0xca, 0x14, 0x48, 0xf1, 0x75, 0x85, 0xdc, 0xcf, 0xd8, 0x70, 0xad, 0xe4, 0x3e, 0x87, + 0x29, 0xf2, 0x45, 0x26, 0x45, 0xd6, 0x73, 0x8f, 0x0c, 0xb9, 0x27, 0x96, 0x45, 0x7a, 0xfc, 0xbb, + 0x0a, 0xed, 0xac, 0xaa, 0xac, 0x08, 0x5d, 0x0e, 0x79, 0xb5, 0x10, 0x72, 0x13, 0xb8, 0xf5, 0x4b, + 0x03, 0xf7, 0x10, 0xae, 0xd0, 0xf3, 0x98, 0x4e, 0x38, 0x0d, 0x3c, 0x19, 0x41, 0x3f, 0x08, 0x12, + 0x9d, 0x42, 0x1f, 0x69, 0xd5, 0x28, 0x3e, 0x7b, 0xb4, 0x2b, 0x14, 0xcb, 0xf8, 0x1d, 0xc4, 0xd7, + 0x0b, 0xf8, 0x1d, 0x85, 0xff, 0x1a, 0x7a, 0xa6, 0xe0, 0xf2, 0x94, 0x41, 0x8d, 0x72, 0x83, 0xba, + 0x06, 0x77, 0x24, 0x2d, 0x7b, 0x0c, 0x5d, 0x5d, 0x9d, 0x79, 0x97, 0xa6, 0x60, 0x1b, 0x8b, 0x36, + 0xd5, 0xed, 0x11, 0x74, 0x8e, 0x59, 0xf2, 0xc6, 0x4f, 0xf4, 0x70, 0xd6, 0x8a, 0x5e, 0x88, 0x92, + 0xbd, 0x9c, 0xff, 0xcf, 0x47, 0x18, 0xb3, 0xec, 0xfd, 0x22, 0xec, 0x24, 0x60, 0x69, 0xda, 0xd2, + 0x58, 0x3d, 0x80, 0x7e, 0x18, 0x9d, 0x24, 0x34, 0x4d, 0xd5, 0x7b, 0x60, 0x48, 0x75, 0xc0, 0x7a, + 0x28, 0x1f, 0xa3, 0x58, 0xec, 0x87, 0x74, 0x09, 0x89, 0x17, 0x2c, 0x9a, 0x03, 0x3a, 0x4f, 0xa0, + 0x89, 0xcb, 0x85, 0x5c, 0x83, 0x06, 0x3d, 0x17, 0xa7, 0x91, 0xde, 0x3a, 0xe8, 0x39, 0x1f, 0xc5, + 0x42, 0x2c, 0x13, 0x3c, 0xd6, 0x77, 0x55, 0x61, 0x70, 0xec, 0xb8, 0x70, 0xa5, 0xe4, 0xb9, 0x44, + 0x5c, 0xff, 0xc2, 0x94, 0x79, 0x3c, 0x9c, 0xd1, 0x94, 0xfb, 0x33, 0xcd, 0xd5, 0x0e, 0x53, 0x76, + 0xa4, 0x65, 0xa2, 0x18, 0x9e, 0xc7, 0x02, 0x22, 0x29, 0x2b, 0x2e, 0xb6, 0x9c, 0x18, 0x06, 0xab, + 0x9e, 0x4a, 0xde, 0x77, 0x95, 0x7c, 0x0e, 0x0d, 0xf5, 0xa6, 0x80, 0x97, 0x15, 0x0d, 0x5d, 0x7a, + 0x24, 0x40, 0x90, 0xb3, 0x05, 0xdd, 0xbc, 0x46, 0xd8, 0x86, 0x04, 0x78, 0xc0, 0x22, 0x72, 0xb7, + 0xcc, 0xb6, 0x0f, 0x8b, 0xef, 0x39, 0xdc, 0xbe, 0xec, 0x05, 0xe5, 0x43, 0xce, 0x8b, 0x0f, 0x9c, + 0xe6, 0x68, 0xd5, 0xc8, 0x1f, 0xbe, 0x0d, 0xee, 0xab, 0x0c, 0x5f, 0x7a, 0x7b, 0xbc, 0x05, 0x66, + 0x97, 0x43, 0xbf, 0x99, 0xb6, 0x39, 0x34, 0xc4, 0x0a, 0xc7, 0x1c, 0x92, 0x9b, 0xbc, 0x58, 0xd8, + 0xcb, 0x74, 0x68, 0xcf, 0x7f, 0x4d, 0xf7, 0x02, 0xba, 0xf9, 0xb7, 0xcb, 0x92, 0xf7, 0x89, 0x5a, + 0xcc, 0xd8, 0x14, 0xfd, 0xd6, 0x5b, 0x7e, 0xad, 0x94, 0x4a, 0x67, 0x73, 0x41, 0xb3, 0xe2, 0xe5, + 0xe1, 0x29, 0x58, 0x1a, 0x21, 0x8b, 0xa5, 0x30, 0x30, 0xd7, 0x56, 0xf1, 0x4f, 0x36, 0x00, 0x66, + 0x7e, 0xfa, 0x7a, 0x4e, 0x13, 0x1f, 0xcb, 0x28, 0xcb, 0xcd, 0x48, 0x3e, 0xdb, 0x02, 0xdb, 0x5c, + 0xef, 0x48, 0x13, 0xd6, 0x77, 0x0f, 0x7e, 0xe8, 0xaf, 0x11, 0x0b, 0x6a, 0xa3, 0xf1, 0xf7, 0x8f, + 0xfa, 0x35, 0xfc, 0xdb, 0xe9, 0x37, 0x9e, 0xdd, 0xf8, 0xf1, 0xed, 0x46, 0xe5, 0x1f, 0x6f, 0x37, + 0x2a, 0xff, 0x7c, 0xbb, 0x51, 0xf9, 0xf3, 0xbf, 0x36, 0xd6, 0x7e, 0x53, 0x97, 0x97, 0x84, 0x97, + 0x0d, 0xf9, 0xf9, 0xea, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x58, 0xfc, 0xd3, 0x8d, 0x29, 0x1a, + 0x00, 0x00, +} diff --git a/vendor/github.com/sirupsen/logrus/terminal_aix.go b/vendor/github.com/sirupsen/logrus/terminal_aix.go new file mode 100644 index 0000000..6841999 --- /dev/null +++ b/vendor/github.com/sirupsen/logrus/terminal_aix.go @@ -0,0 +1,26 @@ +// Based on ssh/terminal: +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build aix + +package logrus + +import ( + "io" + "os" + "syscall" +) + +// IsTerminal returns true if stderr's file descriptor is a terminal. +func IsTerminal(f io.Writer) bool { + var termios syscall.Termios + switch v := f.(type) { + case *os.File: + err := syscall.Tcgetattr(int(v.Fd()), &termios) + return err == nil + default: + return false + } +} diff --git a/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go b/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go new file mode 100644 index 0000000..c906345 --- /dev/null +++ b/vendor/golang.org/x/crypto/ssh/terminal/util_aix.go @@ -0,0 +1,102 @@ +// Based on ssh/terminal: +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package terminal + +import ( + "io" + "syscall" +) + +// State represents the state of the terminal. +type State struct { + termios syscall.Termios +} + +// IsTerminal returns true if the given file descriptor is a terminal. +func IsTerminal(fd int) bool { + var termios syscall.Termios + err := syscall.Tcgetattr(fd, &termios) + return err == nil +} + +// MakeRaw put the terminal connected to the given file descriptor into raw +// mode and returns the previous state of the terminal so that it can be +// restored. +func MakeRaw(fd int) (*State, error) { + var oldState State + if err := syscall.Tcgetattr(fd, &oldState.termios); err != nil { + return nil, err + } + + newState := oldState.termios + newState.Iflag &^= syscall.IGNBRK | syscall.BRKINT | syscall.PARMRK | syscall.ISTRIP | syscall.INLCR | syscall.IGNCR | syscall.ICRNL | syscall.IXON + newState.Oflag &^= syscall.OPOST + newState.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG | syscall.IEXTEN + newState.Cflag &^= syscall.CSIZE | syscall.PARENB + newState.Cflag |= syscall.CS8 + + if err := syscall.Tcsetattr(fd, syscall.TCSANOW, &newState); err != nil { + return nil, err + } + return &oldState, nil +} + +// Restore restores the terminal connected to the given file descriptor to a +// previous state. +func Restore(fd int, oldState *State) error { + return syscall.Tcsetattr(fd, syscall.TCSANOW, &oldState.termios) +} + +// passwordReader is an io.Reader that reads from a specific file descriptor. +type passwordReader int + +func (r passwordReader) Read(buf []byte) (int, error) { + return syscall.Read(int(r), buf) +} + +// ReadPassword reads a line of input from a terminal without local echo. This +// is commonly used for inputting passwords and other sensitive data. The slice +// returned does not include the \n. +func ReadPassword(fd int) ([]byte, error) { + var oldState syscall.Termios + if err := syscall.Tcgetattr(fd, &oldState); err != nil { + return nil, err + } + + newState := oldState + newState.Lflag &^= syscall.ECHO | syscall.ECHOE | syscall.ECHOK | syscall.ECHONL + if err := syscall.Tcsetattr(fd, syscall.TCSANOW, &newState); err != nil { + return nil, err + } + + defer func() { + syscall.Tcsetattr(fd, syscall.TCSANOW, &oldState) + }() + + var buf [16]byte + var ret []byte + for { + n, err := syscall.Read(fd, buf[:]) + if err != nil { + return nil, err + } + if n == 0 { + if len(ret) == 0 { + return nil, io.EOF + } + break + } + if buf[n-1] == '\n' { + n-- + } + ret = append(ret, buf[:n]...) + if n < len(buf) { + break + } + } + + return ret, nil +}