diff --git a/api/resource/definitions/enums/enums.proto b/api/resource/definitions/enums/enums.proto index 8b581aea91..161692a194 100755 --- a/api/resource/definitions/enums/enums.proto +++ b/api/resource/definitions/enums/enums.proto @@ -186,6 +186,46 @@ enum NethelpersLinkType { LINK_NONE = 65534; } +// NethelpersMatchOperator is a netfilter match operator. +enum NethelpersMatchOperator { + OPERATOR_EQUAL = 0; + OPERATOR_NOT_EQUAL = 1; +} + +// NethelpersNfTablesChainHook wraps nftables.ChainHook for YAML marshaling. +enum NethelpersNfTablesChainHook { + CHAIN_HOOK_PREROUTING = 0; + CHAIN_HOOK_INPUT = 1; + CHAIN_HOOK_FORWARD = 2; + CHAIN_HOOK_OUTPUT = 3; + CHAIN_HOOK_POSTROUTING = 4; +} + +// NethelpersNfTablesChainPriority wraps nftables.ChainPriority for YAML marshaling. +enum NethelpersNfTablesChainPriority { + option allow_alias = true; + NETHELPERS_NFTABLESCHAINPRIORITY_UNSPECIFIED = 0; + CHAIN_PRIORITY_FIRST = -2147483648; + CHAIN_PRIORITY_CONNTRACK_DEFRAG = -400; + CHAIN_PRIORITY_RAW = -300; + CHAIN_PRIORITY_SE_LINUX_FIRST = -225; + CHAIN_PRIORITY_CONNTRACK = -200; + CHAIN_PRIORITY_MANGLE = -150; + CHAIN_PRIORITY_NAT_DEST = -100; + CHAIN_PRIORITY_FILTER = 0; + CHAIN_PRIORITY_SECURITY = 50; + CHAIN_PRIORITY_NAT_SOURCE = 100; + CHAIN_PRIORITY_SE_LINUX_LAST = 225; + CHAIN_PRIORITY_CONNTRACK_HELPER = 300; + CHAIN_PRIORITY_LAST = 2147483647; +} + +// NethelpersNfTablesVerdict wraps nftables.Verdict for YAML marshaling. +enum NethelpersNfTablesVerdict { + VERDICT_DROP = 0; + VERDICT_ACCEPT = 1; +} + // NethelpersOperationalState wraps rtnetlink.OperationalState for YAML marshaling. enum NethelpersOperationalState { OPER_STATE_UNKNOWN = 0; @@ -216,6 +256,13 @@ enum NethelpersPrimaryReselect { PRIMARY_RESELECT_FAILURE = 2; } +// NethelpersProtocol is a inet protocol. +enum NethelpersProtocol { + NETHELPERS_PROTOCOL_UNSPECIFIED = 0; + PROTOCOL_TCP = 6; + PROTOCOL_UDP = 17; +} + // NethelpersRouteFlag wraps RTM_F_* constants. enum NethelpersRouteFlag { NETHELPERS_ROUTEFLAG_UNSPECIFIED = 0; diff --git a/api/resource/definitions/network/network.proto b/api/resource/definitions/network/network.proto index 7f152a9a20..13c2d65293 100755 --- a/api/resource/definitions/network/network.proto +++ b/api/resource/definitions/network/network.proto @@ -166,6 +166,74 @@ message LinkStatusSpec { bytes permanent_addr = 30; } +// NfTablesAddressMatch describes the match on the IP address. +message NfTablesAddressMatch { + repeated common.NetIPPrefix include_subnets = 1; + repeated common.NetIPPrefix exclude_subnets = 2; + bool invert = 3; +} + +// NfTablesChainSpec describes status of rendered secrets. +message NfTablesChainSpec { + string type = 1; + talos.resource.definitions.enums.NethelpersNfTablesChainHook hook = 2; + talos.resource.definitions.enums.NethelpersNfTablesChainPriority priority = 3; + repeated NfTablesRule rules = 4; +} + +// NfTablesClampMSS describes the TCP MSS clamping operation. +// +// MSS is limited by the `MaxMTU` so that: +// - IPv4: MSS = MaxMTU - 40 +// - IPv6: MSS = MaxMTU - 60. +message NfTablesClampMSS { + fixed32 mtu = 1; +} + +// NfTablesIfNameMatch describes the match on the interface name. +message NfTablesIfNameMatch { + string interface_name = 1; + talos.resource.definitions.enums.NethelpersMatchOperator operator = 2; +} + +// NfTablesLayer4Match describes the match on the transport layer protocol. +message NfTablesLayer4Match { + talos.resource.definitions.enums.NethelpersProtocol protocol = 1; + NfTablesPortMatch match_source_port = 2; + NfTablesPortMatch match_destination_port = 3; +} + +// NfTablesMark encodes packet mark match/update operation. +// +// When used as a match computes the following condition: +// (mark & mask) ^ xor == value +// +// When used as an update computes the following operation: +// mark = (mark & mask) ^ xor. +message NfTablesMark { + uint32 mask = 1; + uint32 xor = 2; + uint32 value = 3; +} + +// NfTablesPortMatch describes the match on the transport layer port. +message NfTablesPortMatch { + repeated PortRange ranges = 1; +} + +// NfTablesRule describes a single rule in the nftables chain. +message NfTablesRule { + NfTablesIfNameMatch match_o_if_name = 1; + talos.resource.definitions.enums.NethelpersNfTablesVerdict verdict = 2; + NfTablesMark match_mark = 3; + NfTablesMark set_mark = 4; + NfTablesAddressMatch match_source_address = 5; + NfTablesAddressMatch match_destination_address = 6; + NfTablesLayer4Match match_layer4 = 7; + NfTablesIfNameMatch match_i_if_name = 8; + NfTablesClampMSS clamp_mss = 9; +} + // NodeAddressFilterSpec describes a filter for NodeAddresses. message NodeAddressFilterSpec { repeated common.NetIPPrefix include_subnets = 1; @@ -188,6 +256,14 @@ message OperatorSpecSpec { talos.resource.definitions.enums.NetworkConfigLayer config_layer = 7; } +// PortRange describes a range of ports. +// +// Range is [lo, hi]. +message PortRange { + fixed32 lo = 1; + fixed32 hi = 2; +} + // ProbeSpecSpec describes the Probe. message ProbeSpecSpec { google.protobuf.Duration interval = 1; diff --git a/hack/structprotogen/consts/consts.go b/hack/structprotogen/consts/consts.go index b063a36f3d..dab94b7a33 100644 --- a/hack/structprotogen/consts/consts.go +++ b/hack/structprotogen/consts/consts.go @@ -12,6 +12,7 @@ import ( "go/types" "io" "regexp" + "slices" "strconv" "strings" @@ -237,7 +238,9 @@ func (b *ConstBlocks) FormatProtoFile(w io.Writer) error { fmt.Fprintf(w, "enum %s {\n", block.ProtoMessageName()) - if hasDuplicates(block.Consts, func(c Constant) string { return c.Value }) { + hasZeroNotFirstConstValue := slices.IndexFunc(block.Consts, func(c Constant) bool { return c.Value == "0" }) > 0 + + if hasDuplicates(block.Consts, func(c Constant) string { return c.Value }) || hasZeroNotFirstConstValue { fmt.Fprintln(w, " option allow_alias = true;") } diff --git a/internal/app/machined/pkg/adapters/network/ipset.go b/internal/app/machined/pkg/adapters/network/ipset.go new file mode 100644 index 0000000000..326ffdee99 --- /dev/null +++ b/internal/app/machined/pkg/adapters/network/ipset.go @@ -0,0 +1,39 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network + +import ( + "net/netip" + + "go4.org/netipx" +) + +// BuildIPSet builds an IPSet from the given include and exclude prefixes. +func BuildIPSet(include, exclude []netip.Prefix) (*netipx.IPSet, error) { + var builder netipx.IPSetBuilder + + for _, pfx := range include { + builder.AddPrefix(pfx) + } + + for _, pfx := range exclude { + builder.RemovePrefix(pfx) + } + + return builder.IPSet() +} + +// SplitIPSet splits the given IPSet into IPv4 and IPv6 ranges. +func SplitIPSet(set *netipx.IPSet) (ipv4, ipv6 []netipx.IPRange) { + for _, rng := range set.Ranges() { + if rng.From().Is4() { + ipv4 = append(ipv4, rng) + } else { + ipv6 = append(ipv6, rng) + } + } + + return +} diff --git a/internal/app/machined/pkg/adapters/network/ipset_test.go b/internal/app/machined/pkg/adapters/network/ipset_test.go new file mode 100644 index 0000000000..8702253387 --- /dev/null +++ b/internal/app/machined/pkg/adapters/network/ipset_test.go @@ -0,0 +1,58 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network_test + +import ( + "net/netip" + "testing" + + "github.com/siderolabs/gen/xslices" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go4.org/netipx" + + "github.com/siderolabs/talos/internal/app/machined/pkg/adapters/network" +) + +func TestBuildIPSet(t *testing.T) { + ipset, err := network.BuildIPSet( + []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + netip.MustParsePrefix("2001:db8::/32"), + }, + []netip.Prefix{ + netip.MustParsePrefix("10.4.0.0/16"), + }) + require.NoError(t, err) + + assert.Equal(t, + []string{"10.0.0.0-10.3.255.255", "10.5.0.0-10.255.255.255", "2001:db8::-2001:db8:ffff:ffff:ffff:ffff:ffff:ffff"}, + xslices.Map(ipset.Ranges(), netipx.IPRange.String), + ) +} + +func TestSplitIPSet(t *testing.T) { + ipset, err := network.BuildIPSet( + []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + netip.MustParsePrefix("2001:db8::/32"), + }, + []netip.Prefix{ + netip.MustParsePrefix("10.4.0.0/16"), + }) + require.NoError(t, err) + + v4, v6 := network.SplitIPSet(ipset) + + assert.Equal(t, + []string{"10.0.0.0-10.3.255.255", "10.5.0.0-10.255.255.255"}, + xslices.Map(v4, netipx.IPRange.String), + ) + + assert.Equal(t, + []string{"2001:db8::-2001:db8:ffff:ffff:ffff:ffff:ffff:ffff"}, + xslices.Map(v6, netipx.IPRange.String), + ) +} diff --git a/internal/app/machined/pkg/adapters/network/nftables_rule.go b/internal/app/machined/pkg/adapters/network/nftables_rule.go new file mode 100644 index 0000000000..a63dc26f44 --- /dev/null +++ b/internal/app/machined/pkg/adapters/network/nftables_rule.go @@ -0,0 +1,551 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network + +import ( + "fmt" + "os" + "slices" + + "github.com/google/nftables" + "github.com/google/nftables/binaryutil" + "github.com/google/nftables/expr" + "github.com/siderolabs/gen/xslices" + "go4.org/netipx" + "golang.org/x/sys/unix" + + "github.com/siderolabs/talos/pkg/machinery/resources/network" +) + +// NfTablesRule adapter provides encoding to nftables instructions. +// +//nolint:revive,golint +func NfTablesRule(r *network.NfTablesRule) nftablesRule { + return nftablesRule{ + NfTablesRule: r, + } +} + +type nftablesRule struct { + *network.NfTablesRule +} + +// SetKind is the type of the nftables Set. +type SetKind uint8 + +// SetKind constants. +const ( + SetKindIPv4 SetKind = iota + SetKindIPv6 + SetKindPort +) + +// NfTablesSet is a compiled representation of the set. +type NfTablesSet struct { + Kind SetKind + Addresses []netipx.IPRange + Ports [][2]uint16 +} + +// KeyType returns the type of the set. +func (set NfTablesSet) KeyType() nftables.SetDatatype { + switch set.Kind { + case SetKindIPv4: + return nftables.TypeIPAddr + case SetKindIPv6: + return nftables.TypeIP6Addr + case SetKindPort: + return nftables.TypeInetService + default: + panic(fmt.Sprintf("unknown set kind: %d", set.Kind)) + } +} + +// SetElements returns the set elements. +func (set NfTablesSet) SetElements() []nftables.SetElement { + switch set.Kind { + case SetKindIPv4, SetKindIPv6: + elements := make([]nftables.SetElement, 0, len(set.Addresses)*2) + + for _, r := range set.Addresses { + fromBin, _ := r.From().MarshalBinary() //nolint:errcheck // doesn't fail + toBin, _ := r.To().Next().MarshalBinary() //nolint:errcheck // doesn't fail + + elements = append(elements, + nftables.SetElement{ + Key: fromBin, + IntervalEnd: false, + }, + nftables.SetElement{ + Key: toBin, + IntervalEnd: true, + }, + ) + } + + return elements + case SetKindPort: + elements := make([]nftables.SetElement, 0, len(set.Ports)) + + for _, p := range set.Ports { + from := binaryutil.BigEndian.PutUint16(p[0]) + to := binaryutil.BigEndian.PutUint16(p[1]) + + elements = append(elements, + nftables.SetElement{ + Key: from, + IntervalEnd: false, + }, + nftables.SetElement{ + Key: to, + IntervalEnd: true, + }, + ) + } + + return elements + default: + panic(fmt.Sprintf("unknown set kind: %d", set.Kind)) + } +} + +// NfTablesCompiled is a compiled representation of the rule. +type NfTablesCompiled struct { + Rules [][]expr.Any + Sets []NfTablesSet +} + +var ( + matchV4 = []expr.Any{ + // Store protocol type to register 1 + &expr.Meta{ + Key: expr.MetaKeyNFPROTO, + Register: 1, + }, + // Match IP Family + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv4)}, + }, + } + + matchV6 = []expr.Any{ + // Store protocol type to register 1 + &expr.Meta{ + Key: expr.MetaKeyNFPROTO, + Register: 1, + }, + // Match IP Family + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv6)}, + }, + } +) + +// Compile translates the rule into the set of nftables instructions. +// +//nolint:gocyclo,cyclop +func (a nftablesRule) Compile() (*NfTablesCompiled, error) { + var ( + // common for ipv4 & ipv6 expression, pre & post + rulePre []expr.Any + rulePost []expr.Any + // speficic for ipv4 & ipv6 expression + rule4, rule6 []expr.Any + + result NfTablesCompiled + ) + + if a.NfTablesRule.MatchIIfName != nil { + match := a.NfTablesRule.MatchIIfName + + rulePre = append(rulePre, + // [ meta load iifname => reg 1 ] + &expr.Meta{ + Key: expr.MetaKeyIIFNAME, + Register: 1, + }, + // [ cmp eq/neq reg 1 ] + &expr.Cmp{ + Op: expr.CmpOp(match.Operator), + Register: 1, + Data: ifname(match.InterfaceName), + }, + ) + } + + if a.NfTablesRule.MatchOIfName != nil { + match := a.NfTablesRule.MatchOIfName + + rulePre = append(rulePre, + // [ meta load oifname => reg 1 ] + &expr.Meta{ + Key: expr.MetaKeyOIFNAME, + Register: 1, + }, + // [ cmp eq/neq reg 1 ] + &expr.Cmp{ + Op: expr.CmpOp(match.Operator), + Register: 1, + Data: ifname(match.InterfaceName), + }, + ) + } + + if a.NfTablesRule.MatchMark != nil { + match := a.NfTablesRule.MatchMark + + rulePre = append(rulePre, + // [ meta load mark => reg 1 ] + &expr.Meta{ + Key: expr.MetaKeyMARK, + Register: 1, + }, + // Mask the mark with the configured mask: + // R1 = R1 & mask ^ xor + &expr.Bitwise{ + SourceRegister: 1, + DestRegister: 1, + Len: 4, + Xor: binaryutil.NativeEndian.PutUint32(match.Xor), + Mask: binaryutil.NativeEndian.PutUint32(match.Mask), + }, + // Compare the masked firewall mark with expected value + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: binaryutil.NativeEndian.PutUint32(match.Value), + }, + ) + } + + addressMatchExpression := func(match *network.NfTablesAddressMatch, label string, offV4, offV6 uint32) error { + ipSet, err := BuildIPSet(match.IncludeSubnets, match.ExcludeSubnets) + if err != nil { + return fmt.Errorf("failed to build IPSet for %s address match: %w", label, err) + } + + v4Set, v6Set := SplitIPSet(ipSet) + + if v4Set == nil && v6Set == nil && !match.Invert { + // this rule doesn't match anything + return os.ErrNotExist + } + + // skip v4 rule if there are not IPs to match for and not inverted + if v4Set != nil || match.Invert { + if v4Set == nil && match.Invert { + // match any v4 IP + if rule4 == nil { + rule4 = []expr.Any{} + } + } else { + // match specific v4 IPs + result.Sets = append(result.Sets, + NfTablesSet{ + Kind: SetKindIPv4, + Addresses: v4Set, + }, + ) + + rule4 = append(rule4, + // Store the destination IP address to register 1 + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: offV4, + Len: 4, + }, + // Match from target set + &expr.Lookup{ + SourceRegister: 1, + SetID: uint32(len(result.Sets) - 1), // reference will be fixed up by the controller + Invert: match.Invert, + }, + ) + } + } + + // skip v6 rule if there are not IPs to match for and not inverted + if v6Set != nil || match.Invert { + if v6Set == nil && match.Invert { + // match any v6 IP + if rule6 == nil { + rule6 = []expr.Any{} + } + } else { + // match specific v6 IPs + result.Sets = append(result.Sets, + NfTablesSet{ + Kind: SetKindIPv6, + Addresses: v6Set, + }) + + rule6 = append(rule6, + // Store the destination IP address to register 1 + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: offV6, + Len: 16, + }, + // Match from target set + &expr.Lookup{ + SourceRegister: 1, + SetID: uint32(len(result.Sets) - 1), // reference will be fixed up by the controller + Invert: match.Invert, + }, + ) + } + } + + return nil + } + + if a.NfTablesRule.MatchSourceAddress != nil { + match := a.NfTablesRule.MatchSourceAddress + + if err := addressMatchExpression(match, "source", 12, 8); err != nil { + if os.IsNotExist(err) { + return &NfTablesCompiled{}, nil + } + + return nil, err + } + } + + if a.NfTablesRule.MatchDestinationAddress != nil { + match := a.NfTablesRule.MatchDestinationAddress + + if err := addressMatchExpression(match, "destination", 16, 24); err != nil { + if os.IsNotExist(err) { + return &NfTablesCompiled{}, nil + } + + return nil, err + } + } + + if a.NfTablesRule.MatchLayer4 != nil { + match := a.NfTablesRule.MatchLayer4 + + rulePre = append(rulePre, + // [ meta load l4proto => reg 1 ] + &expr.Meta{ + Key: expr.MetaKeyL4PROTO, + Register: 1, + }, + // [ cmp eq reg 1 ] + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(match.Protocol)}, + }, + ) + + portMatch := func(off uint32, ports []network.PortRange) { + result.Sets = append(result.Sets, + NfTablesSet{ + Kind: SetKindPort, + Ports: xslices.Map(ports, func(r network.PortRange) [2]uint16 { return [2]uint16{r.Lo, r.Hi} }), + }, + ) + + rulePost = append(rulePost, + // [ payload load 2b @ transport header + => reg 1 ] + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: off, + Len: 2, + }, + // [ lookup reg 1 set ] + &expr.Lookup{ + SourceRegister: 1, + SetID: uint32(len(result.Sets) - 1), // reference will be fixed up by the controller + }, + ) + } + + if match.MatchSourcePort != nil { + portMatch(0, match.MatchSourcePort.Ranges) + } + + if match.MatchDestinationPort != nil { + portMatch(2, match.MatchDestinationPort.Ranges) + } + } + + clampMSS := func(family nftables.TableFamily, mtu uint16) []expr.Any { + var mss uint16 + + switch family { //nolint:exhaustive + case nftables.TableFamilyIPv4: + mss = mtu - 40 // TCP + IPv4 overhead + case nftables.TableFamilyIPv6: + mss = mtu - 60 // TCP + IPv6 overhead + default: + panic("unexpected IP family") + } + + return []expr.Any{ + // Load the L4 protocol into register 1 + &expr.Meta{ + Key: expr.MetaKeyL4PROTO, + Register: 1, + }, + // Match TCP Family + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{unix.IPPROTO_TCP}, + }, + // [ payload load 1b @ transport header + 13 => reg 1 ] + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: 13, + Len: 1, + }, + // [ bitwise reg 1 = ( reg 1 & 0x00000006 ) ^ 0x00000000 ] + &expr.Bitwise{ + DestRegister: 1, + SourceRegister: 1, + Len: 1, + Mask: []byte{0x02 | 0x04}, + Xor: []byte{0x00}, + }, + // [ cmp eq reg 1 0x00000002 ] + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x02}, + }, + // [ exthdr load tcpopt 2b @ 2 + 2 => reg 1 ] + &expr.Exthdr{ + DestRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + // [ cmp gte reg 1 MTU ] + &expr.Cmp{ + Op: expr.CmpOpGt, + Register: 1, + Data: binaryutil.BigEndian.PutUint16(mss), + }, + // [ immediate reg 1 MTU ] + &expr.Immediate{ + Register: 1, + Data: binaryutil.BigEndian.PutUint16(mss), + }, + // [ exthdr write tcpopt reg 1 => 2b @ 2 + 2 ] + &expr.Exthdr{ + SourceRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + } + } + + if a.NfTablesRule.ClampMSS != nil { + rule4 = append(rule4, clampMSS(nftables.TableFamilyIPv4, a.NfTablesRule.ClampMSS.MTU)...) + rule6 = append(rule6, clampMSS(nftables.TableFamilyIPv6, a.NfTablesRule.ClampMSS.MTU)...) + } + + if a.NfTablesRule.SetMark != nil { + set := a.NfTablesRule.SetMark + + rulePost = append(rulePost, + // Load the current packet mark into register 1 + &expr.Meta{ + Key: expr.MetaKeyMARK, + Register: 1, + }, + // Calculate the new mark value in register 1 + &expr.Bitwise{ + SourceRegister: 1, + DestRegister: 1, + Len: 4, + Xor: binaryutil.NativeEndian.PutUint32(set.Xor), + Mask: binaryutil.NativeEndian.PutUint32(set.Mask), + }, + // Set firewall mark to the value computed in register 1 + &expr.Meta{ + Key: expr.MetaKeyMARK, + SourceRegister: true, + Register: 1, + }, + ) + } + + if a.NfTablesRule.Verdict != nil { + rulePost = append(rulePost, + // [ verdict accept|drop ] + &expr.Verdict{ + Kind: expr.VerdictKind(*a.NfTablesRule.Verdict), + }, + ) + } + + // Build v4/v6 rules as requested. + // + // If there's no IPv4/IPv6 part, generate a single rule. + // If there's a specific IPv4/IPv6 part, generate a rule per IP version. + switch { + case rule4 == nil && rule6 == nil && rulePre == nil && rulePost == nil: + // nothing + case rule4 == nil && rule6 == nil: + result.Rules = [][]expr.Any{append(rulePre, rulePost...)} + case rule4 != nil && rule6 == nil: + result.Rules = [][]expr.Any{ + append(rulePre, + append( + append(matchV4, rule4...), + rulePost..., + )..., + ), + } + case rule4 == nil && rule6 != nil: + result.Rules = [][]expr.Any{ + append(rulePre, + append( + append(matchV6, rule6...), + rulePost..., + )..., + ), + } + case rule4 != nil && rule6 != nil: + result.Rules = [][]expr.Any{ + append(slices.Clone(rulePre), + append( + append(matchV4, rule4...), + rulePost..., + )..., + ), + append(slices.Clone(rulePre), + append( + append(matchV6, rule6...), + rulePost..., + )..., + ), + } + } + + return &result, nil +} + +func ifname(name string) []byte { + b := make([]byte, 16) + copy(b, []byte(name)) + + return b +} diff --git a/internal/app/machined/pkg/adapters/network/nftables_rule_test.go b/internal/app/machined/pkg/adapters/network/nftables_rule_test.go new file mode 100644 index 0000000000..b559b120e1 --- /dev/null +++ b/internal/app/machined/pkg/adapters/network/nftables_rule_test.go @@ -0,0 +1,597 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network_test + +import ( + "net/netip" + "testing" + + "github.com/google/nftables" + "github.com/google/nftables/expr" + "github.com/siderolabs/go-pointer" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go4.org/netipx" + + "github.com/siderolabs/talos/internal/app/machined/pkg/adapters/network" + "github.com/siderolabs/talos/pkg/machinery/nethelpers" + networkres "github.com/siderolabs/talos/pkg/machinery/resources/network" +) + +func TestNfTablesRuleCompile(t *testing.T) { //nolint:tparallel + t.Parallel() + + for _, test := range []struct { + name string + + spec networkres.NfTablesRule + + expectedRules [][]expr.Any + expectedSets []network.NfTablesSet + }{ + { + name: "empty", + }, + { + name: "match oifname", + spec: networkres.NfTablesRule{ + MatchOIfName: &networkres.NfTablesIfNameMatch{ + InterfaceName: "eth0", + Operator: nethelpers.OperatorEqual, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyOIFNAME, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte("eth0\000\000\000\000\000\000\000\000\000\000\000\000"), + }, + }, + }, + }, + { + name: "match iifname", + spec: networkres.NfTablesRule{ + MatchIIfName: &networkres.NfTablesIfNameMatch{ + InterfaceName: "lo", + Operator: nethelpers.OperatorNotEqual, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyIIFNAME, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpNeq, + Register: 1, + Data: []byte("lo\000\000\000\000\000\000\000\000\000\000\000\000\000\000"), + }, + }, + }, + }, + { + name: "verdict accept", + spec: networkres.NfTablesRule{ + MatchOIfName: &networkres.NfTablesIfNameMatch{ + InterfaceName: "eth0", + Operator: nethelpers.OperatorNotEqual, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyOIFNAME, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpNeq, + Register: 1, + Data: []byte("eth0\000\000\000\000\000\000\000\000\000\000\000\000"), + }, + &expr.Verdict{Kind: expr.VerdictAccept}, + }, + }, + }, + { + name: "match and set mark", + spec: networkres.NfTablesRule{ + MatchMark: &networkres.NfTablesMark{ + Mask: 0xff00ffff, + Xor: 0x00ff0000, + Value: 0x00ee0000, + }, + SetMark: &networkres.NfTablesMark{ + Mask: 0x0000ffff, + Xor: 0xffff0000, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyMARK, Register: 1}, + &expr.Bitwise{ + SourceRegister: 1, + DestRegister: 1, + Len: 4, + Xor: []byte{0x00, 0x00, 0xff, 0x00}, + Mask: []byte{0xff, 0xff, 0x00, 0xff}, + }, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x00, 0x00, 0xee, 0x00}, + }, + &expr.Meta{Key: expr.MetaKeyMARK, Register: 1}, + &expr.Bitwise{ + SourceRegister: 1, + DestRegister: 1, + Len: 4, + Xor: []byte{0x00, 0x00, 0xff, 0xff}, + Mask: []byte{0xff, 0xff, 0x00, 0x00}, + }, + &expr.Meta{Key: expr.MetaKeyMARK, SourceRegister: true, Register: 1}, + }, + }, + }, + { + name: "match on empty source address", + spec: networkres.NfTablesRule{ + MatchSourceAddress: &networkres.NfTablesAddressMatch{}, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + }, + { + name: "match on v4 source address", + spec: networkres.NfTablesRule{ + MatchSourceAddress: &networkres.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.0.0/16"), + }, + ExcludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.4.0/24"), + }, + }, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv4)}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: 12, + Len: 4, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindIPv4, + Addresses: []netipx.IPRange{netipx.MustParseIPRange("192.168.0.0-192.168.3.255"), netipx.MustParseIPRange("192.168.5.0-192.168.255.255")}, + }, + }, + }, + { + name: "match on v6 source and destination addresses", + spec: networkres.NfTablesRule{ + MatchSourceAddress: &networkres.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("2001::/16"), + }, + }, + MatchDestinationAddress: &networkres.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("20fe::/16"), + }, + Invert: true, + }, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv4)}, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv6)}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: 8, + Len: 16, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: 24, + Len: 16, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 1, + Invert: true, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindIPv6, + Addresses: []netipx.IPRange{netipx.MustParseIPRange("2001::-2001:ffff:ffff:ffff:ffff:ffff:ffff:ffff")}, + }, + { + Kind: network.SetKindIPv6, + Addresses: []netipx.IPRange{netipx.MustParseIPRange("20fe::-20fe:ffff:ffff:ffff:ffff:ffff:ffff:ffff")}, + }, + }, + }, + { + name: "match on v6 destination addresses", + spec: networkres.NfTablesRule{ + MatchDestinationAddress: &networkres.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("20fe::/16"), + }, + }, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv6)}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: 24, + Len: 16, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindIPv6, + Addresses: []netipx.IPRange{netipx.MustParseIPRange("20fe::-20fe:ffff:ffff:ffff:ffff:ffff:ffff:ffff")}, + }, + }, + }, + { + name: "match on any v6 address", + spec: networkres.NfTablesRule{ + MatchSourceAddress: &networkres.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.37.45/32"), + }, + Invert: true, + }, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv4)}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseNetworkHeader, + Offset: 12, + Len: 4, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + Invert: true, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + { + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv6)}, + }, + &expr.Verdict{ + Kind: expr.VerdictDrop, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindIPv4, + Addresses: []netipx.IPRange{netipx.MustParseIPRange("192.168.37.45-192.168.37.45")}, + }, + }, + }, + { + name: "clamp MSS", + spec: networkres.NfTablesRule{ + ClampMSS: &networkres.NfTablesClampMSS{ + MTU: 1280, + }, + }, + expectedRules: [][]expr.Any{ + { //nolint:dupl + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv4)}, + }, + &expr.Meta{ + Key: expr.MetaKeyL4PROTO, + Register: 1, + }, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{6}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: 13, + Len: 1, + }, + &expr.Bitwise{ + DestRegister: 1, + SourceRegister: 1, + Len: 1, + Mask: []byte{0x02 | 0x04}, + Xor: []byte{0x00}, + }, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x02}, + }, + &expr.Exthdr{ + DestRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + &expr.Cmp{ + Op: expr.CmpOpGt, + Register: 1, + Data: []byte{0x04, 0xd8}, + }, + &expr.Immediate{ + Register: 1, + Data: []byte{0x04, 0xd8}, + }, + &expr.Exthdr{ + SourceRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + }, + { //nolint:dupl + &expr.Meta{Key: expr.MetaKeyNFPROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{byte(nftables.TableFamilyIPv6)}, + }, + &expr.Meta{ + Key: expr.MetaKeyL4PROTO, + Register: 1, + }, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{6}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: 13, + Len: 1, + }, + &expr.Bitwise{ + DestRegister: 1, + SourceRegister: 1, + Len: 1, + Mask: []byte{0x02 | 0x04}, + Xor: []byte{0x00}, + }, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x02}, + }, + &expr.Exthdr{ + DestRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + &expr.Cmp{ + Op: expr.CmpOpGt, + Register: 1, + Data: []byte{0x04, 0xc4}, + }, + &expr.Immediate{ + Register: 1, + Data: []byte{0x04, 0xc4}, + }, + &expr.Exthdr{ + SourceRegister: 1, + Type: 2, + Offset: 2, + Len: 2, + Op: expr.ExthdrOpTcpopt, + }, + }, + }, + }, + { + name: "match L4 proto", + spec: networkres.NfTablesRule{ + MatchLayer4: &networkres.NfTablesLayer4Match{ + Protocol: nethelpers.ProtocolUDP, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x11}, + }, + }, + }, + }, + { + name: "match L4 proto and src port", + spec: networkres.NfTablesRule{ + MatchLayer4: &networkres.NfTablesLayer4Match{ + Protocol: nethelpers.ProtocolTCP, + MatchSourcePort: &networkres.NfTablesPortMatch{ + Ranges: []networkres.PortRange{ + { + Lo: 1000, + Hi: 1025, + }, + { + Lo: 2000, + Hi: 2000, + }, + }, + }, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x6}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: 0, + Len: 2, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindPort, + Ports: [][2]uint16{ + {1000, 1025}, + {2000, 2000}, + }, + }, + }, + }, + { + name: "match L4 proto and dst port", + spec: networkres.NfTablesRule{ + MatchLayer4: &networkres.NfTablesLayer4Match{ + Protocol: nethelpers.ProtocolTCP, + MatchDestinationPort: &networkres.NfTablesPortMatch{ + Ranges: []networkres.PortRange{ + { + Lo: 2000, + Hi: 2000, + }, + }, + }, + }, + }, + expectedRules: [][]expr.Any{ + { + &expr.Meta{Key: expr.MetaKeyL4PROTO, Register: 1}, + &expr.Cmp{ + Op: expr.CmpOpEq, + Register: 1, + Data: []byte{0x6}, + }, + &expr.Payload{ + DestRegister: 1, + Base: expr.PayloadBaseTransportHeader, + Offset: 2, + Len: 2, + }, + &expr.Lookup{ + SourceRegister: 1, + SetID: 0, + }, + }, + }, + expectedSets: []network.NfTablesSet{ + { + Kind: network.SetKindPort, + Ports: [][2]uint16{ + {2000, 2000}, + }, + }, + }, + }, + } { + t.Run(test.name, func(t *testing.T) { + result, err := network.NfTablesRule(&test.spec).Compile() + require.NoError(t, err) + + assert.Equal(t, test.expectedRules, result.Rules) + assert.Equal(t, test.expectedSets, result.Sets) + }) + } +} diff --git a/internal/app/machined/pkg/controllers/kubespan/kubespan_test.go b/internal/app/machined/pkg/controllers/kubespan/kubespan_test.go index 70ef70cd38..b7b1412bdd 100644 --- a/internal/app/machined/pkg/controllers/kubespan/kubespan_test.go +++ b/internal/app/machined/pkg/controllers/kubespan/kubespan_test.go @@ -93,21 +93,6 @@ func (suite *KubeSpanSuite) assertNoResource(md resource.Metadata) func() error } } -func (suite *KubeSpanSuite) assertNoResourceType(md resource.Metadata) func() error { - return func() error { - list, err := suite.state.List(suite.ctx, md) - if err != nil { - return err - } - - if len(list.Items) > 0 { - return retry.ExpectedErrorf("resource list is not empty: %d items", len(list.Items)) - } - - return nil - } -} - func (suite *KubeSpanSuite) assertResource(md resource.Metadata, check func(res resource.Resource) error) func() error { return func() error { r, err := suite.state.Get(suite.ctx, md) diff --git a/internal/app/machined/pkg/controllers/kubespan/manager.go b/internal/app/machined/pkg/controllers/kubespan/manager.go index 69003a44ec..c88c12d6c0 100644 --- a/internal/app/machined/pkg/controllers/kubespan/manager.go +++ b/internal/app/machined/pkg/controllers/kubespan/manager.go @@ -15,9 +15,11 @@ import ( "github.com/cosi-project/runtime/pkg/controller" "github.com/cosi-project/runtime/pkg/resource" + "github.com/cosi-project/runtime/pkg/safe" "github.com/cosi-project/runtime/pkg/state" "github.com/siderolabs/gen/optional" "github.com/siderolabs/gen/value" + "github.com/siderolabs/go-pointer" "go.uber.org/zap" "go4.org/netipx" "golang.zx2c4.com/wireguard/wgctrl" @@ -40,7 +42,6 @@ const DefaultPeerReconcileInterval = 30 * time.Second type ManagerController struct { WireguardClientFactory WireguardClientFactory RulesManagerFactory RulesManagerFactory - NfTablesManagerFactory NfTablesManagerFactory PeerReconcileInterval time.Duration } @@ -61,9 +62,6 @@ type WireguardClient interface { // RulesManagerFactory allows mocking RulesManager. type RulesManagerFactory func(targetTable, internalMark, markMask int) RulesManager -// NfTablesManagerFactory allows mocking NfTablesManager. -type NfTablesManagerFactory func(externalMark, internalMark, markMask uint32) NfTablesManager - // Inputs implements controller.Controller interface. func (ctrl *ManagerController) Inputs() []controller.Input { return []controller.Input{ @@ -102,6 +100,10 @@ func (ctrl *ManagerController) Outputs() []controller.Output { Type: network.RouteSpecType, Kind: controller.OutputShared, }, + { + Type: network.NfTablesChainType, + Kind: controller.OutputShared, + }, { Type: kubespan.PeerStatusType, Kind: controller.OutputExclusive, @@ -128,10 +130,6 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo ctrl.RulesManagerFactory = NewRulesManager } - if ctrl.NfTablesManagerFactory == nil { - ctrl.NfTablesManagerFactory = NewNfTablesManager - } - if ctrl.PeerReconcileInterval == 0 { ctrl.PeerReconcileInterval = DefaultPeerReconcileInterval } @@ -154,16 +152,6 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo } }() - var nfTablesMgr NfTablesManager - - defer func() { - if nfTablesMgr != nil { - if err := nfTablesMgr.Cleanup(); err != nil { - logger.Error("failed cleaning up nftables rules", zap.Error(err)) - } - } - }() - for { var updateSpecs bool @@ -200,14 +188,6 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo rulesMgr = nil } - if nfTablesMgr != nil { - if err = nfTablesMgr.Cleanup(); err != nil { - logger.Error("failed cleaning up nftables rules", zap.Error(err)) - } - - nfTablesMgr = nil - } - continue } @@ -223,20 +203,8 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo tickerC = ticker.C } - if rulesMgr == nil { - rulesMgr = ctrl.RulesManagerFactory(constants.KubeSpanDefaultRoutingTable, constants.KubeSpanDefaultForceFirewallMark, constants.KubeSpanDefaultFirewallMask) - - if err = rulesMgr.Install(); err != nil { - return fmt.Errorf("failed setting up routing rules: %w", err) - } - } - cfgSpec := cfg.(*kubespan.Config).TypedSpec() - if nfTablesMgr == nil { - nfTablesMgr = ctrl.NfTablesManagerFactory(constants.KubeSpanDefaultFirewallMark, constants.KubeSpanDefaultForceFirewallMark, constants.KubeSpanDefaultFirewallMask) - } - localIdentity, err := r.Get(ctx, resource.NewMetadata(kubespan.NamespaceName, kubespan.IdentityType, kubespan.LocalIdentity, resource.VersionUndefined)) if err != nil { if state.IsNotFoundError(err) { @@ -373,13 +341,13 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo for pubKey, peerStatus := range peerStatuses { peerStatus := peerStatus - if err = r.Modify(ctx, + if err = safe.WriterModify(ctx, r, kubespan.NewPeerStatus( kubespan.NamespaceName, pubKey, ), - func(r resource.Resource) error { - *r.(*kubespan.PeerStatus).TypedSpec() = *peerStatus + func(r *kubespan.PeerStatus) error { + *r.TypedSpec() = *peerStatus return nil }, @@ -395,13 +363,13 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo continue } - if err = r.Modify(ctx, + if err = safe.WriterModify(ctx, r, network.NewAddressSpec( network.ConfigNamespaceName, network.LayeredID(network.ConfigOperator, network.AddressID(constants.KubeSpanLinkName, localSpec.Address)), ), - func(r resource.Resource) error { - spec := r.(*network.AddressSpec).TypedSpec() + func(r *network.AddressSpec) error { + spec := r.TypedSpec() spec.Address = netip.PrefixFrom(localSpec.Address.Addr(), localSpec.Subnet.Bits()) spec.ConfigLayer = network.ConfigOperator @@ -452,13 +420,13 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo } { spec := spec - if err = r.Modify(ctx, + if err = safe.WriterModify(ctx, r, network.NewRouteSpec( network.ConfigNamespaceName, network.LayeredID(network.ConfigOperator, network.RouteID(spec.Table, spec.Family, spec.Destination, spec.Gateway, spec.Priority)), ), - func(r resource.Resource) error { - *r.(*network.RouteSpec).TypedSpec() = spec + func(r *network.RouteSpec) error { + *r.TypedSpec() = spec return nil }, @@ -467,13 +435,13 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo } } - if err = r.Modify(ctx, + if err = safe.WriterModify(ctx, r, network.NewLinkSpec( network.ConfigNamespaceName, network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), ), - func(r resource.Resource) error { - spec := r.(*network.LinkSpec).TypedSpec() + func(r *network.LinkSpec) error { + spec := r.TypedSpec() spec.ConfigLayer = network.ConfigOperator spec.Name = constants.KubeSpanLinkName @@ -497,8 +465,102 @@ func (ctrl *ManagerController) Run(ctx context.Context, r controller.Runtime, lo return fmt.Errorf("error modifying link spec: %w", err) } - if err = nfTablesMgr.Update(allowedIPsSet, mtu); err != nil { - return fmt.Errorf("failed updating nftables: %w", err) + if err = safe.WriterModify(ctx, r, + network.NewNfTablesChain( + network.NamespaceName, + "kubespan_prerouting", + ), + func(r *network.NfTablesChain) error { + spec := r.TypedSpec() + + spec.Type = nethelpers.ChainTypeFilter + spec.Hook = nethelpers.ChainHookPrerouting + spec.Priority = nethelpers.ChainPriorityFilter + + spec.Rules = []network.NfTablesRule{ + { + MatchMark: &network.NfTablesMark{ + Mask: constants.KubeSpanDefaultFirewallMask, + Value: constants.KubeSpanDefaultFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + { + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: allowedIPsSet.Prefixes(), + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultForceFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + } + + return nil + }, + ); err != nil { + return fmt.Errorf("error modifying nftables chain: %w", err) + } + + if err = safe.WriterModify(ctx, r, + network.NewNfTablesChain( + network.NamespaceName, + "kubespan_outgoing", + ), + func(r *network.NfTablesChain) error { + spec := r.TypedSpec() + + spec.Type = nethelpers.ChainTypeRoute + spec.Hook = nethelpers.ChainHookOutput + spec.Priority = nethelpers.ChainPriorityFilter + + spec.Rules = []network.NfTablesRule{ + { + MatchMark: &network.NfTablesMark{ + Mask: constants.KubeSpanDefaultFirewallMask, + Value: constants.KubeSpanDefaultFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + { + MatchOIfName: &network.NfTablesIfNameMatch{ + InterfaceName: "lo", + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + { + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: allowedIPsSet.Prefixes(), + }, + ClampMSS: &network.NfTablesClampMSS{ + MTU: uint16(mtu), + }, + }, + { + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: allowedIPsSet.Prefixes(), + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultForceFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + } + + return nil + }, + ); err != nil { + return fmt.Errorf("error modifying nftables chain: %w", err) + } + + if rulesMgr == nil { + rulesMgr = ctrl.RulesManagerFactory(constants.KubeSpanDefaultRoutingTable, constants.KubeSpanDefaultForceFirewallMark, constants.KubeSpanDefaultFirewallMask) + + if err = rulesMgr.Install(); err != nil { + return fmt.Errorf("failed setting up routing rules: %w", err) + } } r.ResetRestartBackoff() @@ -522,6 +584,10 @@ func (ctrl *ManagerController) cleanup(ctx context.Context, r controller.Runtime namespace: network.ConfigNamespaceName, typ: network.RouteSpecType, }, + { + namespace: network.NamespaceName, + typ: network.NfTablesChainType, + }, { namespace: kubespan.NamespaceName, typ: kubespan.PeerStatusType, diff --git a/internal/app/machined/pkg/controllers/kubespan/manager_test.go b/internal/app/machined/pkg/controllers/kubespan/manager_test.go index f68e2e7224..939b2d7001 100644 --- a/internal/app/machined/pkg/controllers/kubespan/manager_test.go +++ b/internal/app/machined/pkg/controllers/kubespan/manager_test.go @@ -4,7 +4,6 @@ package kubespan_test import ( - "fmt" "net" "net/netip" "os" @@ -12,13 +11,14 @@ import ( "testing" "time" - "github.com/cosi-project/runtime/pkg/resource" - "github.com/siderolabs/go-retry/retry" + "github.com/cosi-project/runtime/pkg/resource/rtestutils" + "github.com/siderolabs/go-pointer" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/suite" - "go4.org/netipx" "golang.zx2c4.com/wireguard/wgctrl/wgtypes" kubespanadapter "github.com/siderolabs/talos/internal/app/machined/pkg/adapters/kubespan" + "github.com/siderolabs/talos/internal/app/machined/pkg/controllers/ctest" kubespanctrl "github.com/siderolabs/talos/internal/app/machined/pkg/controllers/kubespan" "github.com/siderolabs/talos/pkg/machinery/constants" "github.com/siderolabs/talos/pkg/machinery/nethelpers" @@ -28,26 +28,18 @@ import ( ) type ManagerSuite struct { - KubeSpanSuite + ctest.DefaultSuite + + mockWireguard *mockWireguardClient } func (suite *ManagerSuite) TestDisabled() { - suite.Require().NoError(suite.runtime.RegisterController(&kubespanctrl.ManagerController{})) - - suite.startRuntime() - cfg := kubespan.NewConfig(config.NamespaceName, kubespan.ConfigID) cfg.TypedSpec().Enabled = false - suite.Require().NoError(suite.state.Create(suite.ctx, cfg)) + suite.Require().NoError(suite.State().Create(suite.Ctx(), cfg)) - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertNoResourceType( - resource.NewMetadata(kubespan.NamespaceName, kubespan.PeerStatusType, "", resource.VersionUndefined), - ), - ), - ) + ctest.AssertNoResource[*network.NfTablesChain](suite, "kubespan_outgoing") } type mockWireguardClient struct { @@ -87,60 +79,12 @@ func (mock mockRulesManager) Cleanup() error { return nil } -type mockNftablesManager struct { - mu sync.Mutex - ipSet *netipx.IPSet -} - -func (mock *mockNftablesManager) Update(ipSet *netipx.IPSet, mtu uint32) error { - mock.mu.Lock() - defer mock.mu.Unlock() - - mock.ipSet = ipSet - - return nil -} - -func (mock *mockNftablesManager) Cleanup() error { - return nil -} - -func (mock *mockNftablesManager) IPSet() *netipx.IPSet { - mock.mu.Lock() - defer mock.mu.Unlock() - - return mock.ipSet -} - -//nolint:gocyclo func (suite *ManagerSuite) TestReconcile() { - mockWireguard := &mockWireguardClient{} - mockNfTables := &mockNftablesManager{} - - suite.Require().NoError( - suite.runtime.RegisterController( - &kubespanctrl.ManagerController{ - WireguardClientFactory: func() (kubespanctrl.WireguardClient, error) { - return mockWireguard, nil - }, - RulesManagerFactory: func(_, _, _ int) kubespanctrl.RulesManager { - return mockRulesManager{} - }, - NfTablesManagerFactory: func(_, _, _ uint32) kubespanctrl.NfTablesManager { - return mockNfTables - }, - PeerReconcileInterval: time.Second, - }, - ), - ) - - suite.startRuntime() - cfg := kubespan.NewConfig(config.NamespaceName, kubespan.ConfigID) cfg.TypedSpec().Enabled = true cfg.TypedSpec().SharedSecret = "TPbGXrYlvuXgAl8dERpwjlA5tnEMoihPDPxlovcLtVg=" cfg.TypedSpec().ForceRouting = true - suite.Require().NoError(suite.state.Create(suite.ctx, cfg)) + suite.Require().NoError(suite.State().Create(suite.Ctx(), cfg)) mac, err := net.ParseMAC("ea:71:1b:b2:cc:ee") suite.Require().NoError(err) @@ -153,109 +97,73 @@ func (suite *ManagerSuite) TestReconcile() { mac, ), ) - suite.Require().NoError(suite.state.Create(suite.ctx, localIdentity)) + suite.Require().NoError(suite.State().Create(suite.Ctx(), localIdentity)) // initial setup: link should be created without any peers - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResource( - resource.NewMetadata( - network.ConfigNamespaceName, - network.LinkSpecType, - network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), - resource.VersionUndefined, - ), - func(res resource.Resource) error { - spec := res.(*network.LinkSpec).TypedSpec() - - suite.Assert().Equal(network.ConfigOperator, spec.ConfigLayer) - suite.Assert().Equal(constants.KubeSpanLinkName, spec.Name) - suite.Assert().Equal(nethelpers.LinkNone, spec.Type) - suite.Assert().Equal("wireguard", spec.Kind) - suite.Assert().True(spec.Up) - suite.Assert().True(spec.Logical) - - suite.Assert().Equal(localIdentity.TypedSpec().PrivateKey, spec.Wireguard.PrivateKey) - suite.Assert().Equal(constants.KubeSpanDefaultPort, spec.Wireguard.ListenPort) - suite.Assert().Equal(constants.KubeSpanDefaultFirewallMark, spec.Wireguard.FirewallMark) - suite.Assert().Len(spec.Wireguard.Peers, 0) - - return nil - }, - ), - ), - ) - - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResource( - resource.NewMetadata( - network.ConfigNamespaceName, - network.AddressSpecType, - network.LayeredID( - network.ConfigOperator, - network.AddressID(constants.KubeSpanLinkName, localIdentity.TypedSpec().Address), - ), - resource.VersionUndefined, - ), - func(res resource.Resource) error { - spec := res.(*network.AddressSpec).TypedSpec() - - suite.Assert().Equal(localIdentity.TypedSpec().Address.Addr(), spec.Address.Addr()) - suite.Assert().Equal(localIdentity.TypedSpec().Subnet.Bits(), spec.Address.Bits()) - suite.Assert().Equal(network.ConfigOperator, spec.ConfigLayer) - suite.Assert().Equal(nethelpers.FamilyInet6, spec.Family) - suite.Assert().Equal(nethelpers.AddressFlags(nethelpers.AddressPermanent), spec.Flags) - suite.Assert().Equal(constants.KubeSpanLinkName, spec.LinkName) - suite.Assert().Equal(nethelpers.ScopeGlobal, spec.Scope) - - return nil - }, - ), - ), + ctest.AssertResource(suite, + network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), + func(res *network.LinkSpec, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal(network.ConfigOperator, spec.ConfigLayer) + asrt.Equal(constants.KubeSpanLinkName, spec.Name) + asrt.Equal(nethelpers.LinkNone, spec.Type) + asrt.Equal("wireguard", spec.Kind) + asrt.True(spec.Up) + asrt.True(spec.Logical) + + asrt.Equal(localIdentity.TypedSpec().PrivateKey, spec.Wireguard.PrivateKey) + asrt.Equal(constants.KubeSpanDefaultPort, spec.Wireguard.ListenPort) + asrt.Equal(constants.KubeSpanDefaultFirewallMark, spec.Wireguard.FirewallMark) + asrt.Len(spec.Wireguard.Peers, 0) + }, + rtestutils.WithNamespace(network.ConfigNamespaceName), ) - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResourceIDs( - resource.NewMetadata( - network.ConfigNamespaceName, - network.RouteSpecType, - "", - resource.VersionUndefined, - ), - []resource.ID{ - network.LayeredID( - network.ConfigOperator, - network.RouteID( - constants.KubeSpanDefaultRoutingTable, - nethelpers.FamilyInet4, - netip.Prefix{}, - netip.Addr{}, - 1, - ), - ), - network.LayeredID( - network.ConfigOperator, - network.RouteID( - constants.KubeSpanDefaultRoutingTable, - nethelpers.FamilyInet6, - netip.Prefix{}, - netip.Addr{}, - 1, - ), - ), - }, + ctest.AssertResource(suite, + network.LayeredID( + network.ConfigOperator, + network.AddressID(constants.KubeSpanLinkName, localIdentity.TypedSpec().Address), + ), func(res *network.AddressSpec, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal(localIdentity.TypedSpec().Address.Addr(), spec.Address.Addr()) + asrt.Equal(localIdentity.TypedSpec().Subnet.Bits(), spec.Address.Bits()) + asrt.Equal(network.ConfigOperator, spec.ConfigLayer) + asrt.Equal(nethelpers.FamilyInet6, spec.Family) + asrt.Equal(nethelpers.AddressFlags(nethelpers.AddressPermanent), spec.Flags) + asrt.Equal(constants.KubeSpanLinkName, spec.LinkName) + asrt.Equal(nethelpers.ScopeGlobal, spec.Scope) + }, rtestutils.WithNamespace(network.ConfigNamespaceName)) + + ctest.AssertResource(suite, + network.LayeredID( + network.ConfigOperator, + network.RouteID( + constants.KubeSpanDefaultRoutingTable, + nethelpers.FamilyInet4, + netip.Prefix{}, + netip.Addr{}, + 1, ), ), + func(res *network.RouteSpec, asrt *assert.Assertions) {}, + rtestutils.WithNamespace(network.ConfigNamespaceName), ) - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertNoResourceType( - resource.NewMetadata(kubespan.NamespaceName, kubespan.PeerStatusType, "", resource.VersionUndefined), + ctest.AssertResource(suite, + network.LayeredID( + network.ConfigOperator, + network.RouteID( + constants.KubeSpanDefaultRoutingTable, + nethelpers.FamilyInet6, + netip.Prefix{}, + netip.Addr{}, + 1, ), ), + func(res *network.RouteSpec, asrt *assert.Assertions) {}, + rtestutils.WithNamespace(network.ConfigNamespaceName), ) // add two peers, they should be added to the wireguard link spec and should be tracked in peer statuses @@ -268,7 +176,7 @@ func (suite *ManagerSuite) TestReconcile() { peer1.TypedSpec().Endpoints = []netip.AddrPort{ netip.MustParseAddrPort("172.20.0.3:51280"), } - suite.Require().NoError(suite.state.Create(suite.ctx, peer1)) + suite.Require().NoError(suite.State().Create(suite.Ctx(), peer1)) key1, err := wgtypes.ParseKey(peer1.Metadata().ID()) suite.Require().NoError(err) @@ -282,113 +190,120 @@ func (suite *ManagerSuite) TestReconcile() { peer2.TypedSpec().Endpoints = []netip.AddrPort{ netip.MustParseAddrPort("172.20.0.4:51280"), } - suite.Require().NoError(suite.state.Create(suite.ctx, peer2)) + suite.Require().NoError(suite.State().Create(suite.Ctx(), peer2)) key2, err := wgtypes.ParseKey(peer2.Metadata().ID()) suite.Require().NoError(err) - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResource( - resource.NewMetadata( - network.ConfigNamespaceName, - network.LinkSpecType, - network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), - resource.VersionUndefined, - ), - func(res resource.Resource) error { - spec := res.(*network.LinkSpec).TypedSpec() - - if len(spec.Wireguard.Peers) != 2 { - return retry.ExpectedErrorf("peers not set up yet") - } - - for i, peer := range []*kubespan.PeerSpec{peer1, peer2} { - suite.Assert().Equal(peer.Metadata().ID(), spec.Wireguard.Peers[i].PublicKey) - suite.Assert().Equal(cfg.TypedSpec().SharedSecret, spec.Wireguard.Peers[i].PresharedKey) - suite.Assert().Equal(peer.TypedSpec().AllowedIPs, spec.Wireguard.Peers[i].AllowedIPs) - suite.Assert().Equal(peer.TypedSpec().Endpoints[0].String(), spec.Wireguard.Peers[i].Endpoint) - } - - return nil - }, - ), - ), + ctest.AssertResource(suite, + network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), + func(res *network.LinkSpec, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Len(spec.Wireguard.Peers, 2) + if len(spec.Wireguard.Peers) != 2 { + return + } + + for i, peer := range []*kubespan.PeerSpec{peer1, peer2} { + asrt.Equal(peer.Metadata().ID(), spec.Wireguard.Peers[i].PublicKey) + asrt.Equal(cfg.TypedSpec().SharedSecret, spec.Wireguard.Peers[i].PresharedKey) + asrt.Equal(peer.TypedSpec().AllowedIPs, spec.Wireguard.Peers[i].AllowedIPs) + asrt.Equal(peer.TypedSpec().Endpoints[0].String(), spec.Wireguard.Peers[i].Endpoint) + } + }, + rtestutils.WithNamespace(network.ConfigNamespaceName), ) for _, peer := range []*kubespan.PeerSpec{peer1, peer2} { peer := peer - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResource( - resource.NewMetadata( - kubespan.NamespaceName, - kubespan.PeerStatusType, - peer.Metadata().ID(), - resource.VersionUndefined, - ), - func(res resource.Resource) error { - spec := res.(*kubespan.PeerStatus).TypedSpec() - - suite.Assert().Equal(peer.TypedSpec().Label, spec.Label) - suite.Assert().Equal(kubespan.PeerStateUnknown, spec.State) - suite.Assert().Equal(peer.TypedSpec().Endpoints[0], spec.Endpoint) - suite.Assert().Equal(peer.TypedSpec().Endpoints[0], spec.LastUsedEndpoint) - suite.Assert().WithinDuration(time.Now(), spec.LastEndpointChange, 3*time.Second) - - return nil - }, - ), - ), + ctest.AssertResource(suite, + peer.Metadata().ID(), + func(res *kubespan.PeerStatus, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal(peer.TypedSpec().Label, spec.Label) + asrt.Equal(kubespan.PeerStateUnknown, spec.State) + asrt.Equal(peer.TypedSpec().Endpoints[0], spec.Endpoint) + asrt.Equal(peer.TypedSpec().Endpoints[0], spec.LastUsedEndpoint) + asrt.WithinDuration(time.Now(), spec.LastEndpointChange, 3*time.Second) + }, ) } - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - func() error { - ipSet := mockNfTables.IPSet() - - if ipSet == nil { - return retry.ExpectedErrorf("ipset is nil") - } - - ranges := fmt.Sprintf("%v", ipSet.Ranges()) - expected := "[10.244.1.0-10.244.2.255]" - - if ranges != expected { - return retry.ExpectedErrorf("ranges %s != expected %s", ranges, expected) - } - - return nil - }, - ), + // check firewall rules + ctest.AssertResource(suite, + "kubespan_prerouting", + func(res *network.NfTablesChain, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal(nethelpers.ChainTypeFilter, spec.Type) + asrt.Equal(nethelpers.ChainHookPrerouting, spec.Hook) + asrt.Equal(nethelpers.ChainPriorityFilter, spec.Priority) + + asrt.Len(spec.Rules, 2) + if len(spec.Rules) != 2 { + return + } + + asrt.Equal( + network.NfTablesRule{ + MatchMark: &network.NfTablesMark{ + Mask: constants.KubeSpanDefaultFirewallMask, + Value: constants.KubeSpanDefaultFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + spec.Rules[0], + ) + + asrt.Equal( + network.NfTablesRule{ + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.244.1.0/24"), + netip.MustParsePrefix("10.244.2.0/24"), + }, + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultForceFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + spec.Rules[1], + ) + }, ) // update config and disable force routing, nothing should be routed cfg.TypedSpec().ForceRouting = false - suite.Require().NoError(suite.state.Update(suite.ctx, cfg)) - - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - func() error { - ipSet := mockNfTables.IPSet() + suite.Require().NoError(suite.State().Update(suite.Ctx(), cfg)) - if ipSet == nil { - return retry.ExpectedErrorf("ipset is nil") - } + ctest.AssertResource(suite, + "kubespan_prerouting", + func(res *network.NfTablesChain, asrt *assert.Assertions) { + spec := res.TypedSpec() - if len(ipSet.Prefixes()) != 0 { - return retry.ExpectedErrorf("expected empty ipset: %v", ipSet.Ranges()) - } - - return nil - }, - ), + asrt.Equal( + network.NfTablesRule{ + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{}, + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultForceFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + spec.Rules[1], + ) + }, ) // report up status via wireguard mock - mockWireguard.update( + suite.mockWireguard.update( &wgtypes.Device{ Peers: []wgtypes.Peer{ { @@ -408,66 +323,52 @@ func (suite *ManagerSuite) TestReconcile() { for _, peer := range []*kubespan.PeerSpec{peer1, peer2} { peer := peer - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertResource( - resource.NewMetadata( - kubespan.NamespaceName, - kubespan.PeerStatusType, - peer.Metadata().ID(), - resource.VersionUndefined, - ), - func(res resource.Resource) error { - spec := res.(*kubespan.PeerStatus).TypedSpec() - - if spec.State != kubespan.PeerStateUp { - return retry.ExpectedErrorf("peer state is not up yet: %s", spec.State) - } - - return nil - }, - ), - ), + ctest.AssertResource(suite, + peer.Metadata().ID(), + func(res *kubespan.PeerStatus, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal(kubespan.PeerStateUp, spec.State) + }, ) } - // as the peers are now up, all traffic should be routed via KubeSpan - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - func() error { - ipSet := mockNfTables.IPSet() - - if ipSet == nil { - return retry.ExpectedErrorf("ipset is nil") - } - - ranges := fmt.Sprintf("%v", ipSet.Ranges()) - expected := "[10.244.1.0-10.244.2.255]" - - if ranges != expected { - return retry.ExpectedErrorf("ranges %s != expected %s", ranges, expected) - } - - return nil - }, - ), + ctest.AssertResource(suite, + "kubespan_prerouting", + func(res *network.NfTablesChain, asrt *assert.Assertions) { + spec := res.TypedSpec() + + asrt.Equal( + network.NfTablesRule{ + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.244.1.0/24"), + netip.MustParsePrefix("10.244.2.0/24"), + }, + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultForceFirewallMark, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + spec.Rules[1], + ) + }, ) // update config and disable wireguard, everything should be cleaned up cfg.TypedSpec().Enabled = false - suite.Require().NoError(suite.state.Update(suite.ctx, cfg)) - - suite.Assert().NoError( - retry.Constant(3*time.Second, retry.WithUnits(100*time.Millisecond)).Retry( - suite.assertNoResource( - resource.NewMetadata( - network.ConfigNamespaceName, - network.LinkSpecType, - network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), - resource.VersionUndefined, - ), - ), - ), + suite.Require().NoError(suite.State().Update(suite.Ctx(), cfg)) + + ctest.AssertNoResource[*network.LinkSpec]( + suite, + network.LayeredID(network.ConfigOperator, network.LinkID(constants.KubeSpanLinkName)), + rtestutils.WithNamespace(network.ConfigNamespaceName), + ) + ctest.AssertNoResource[*network.NfTablesChain]( + suite, + "kubespan_prerouting", ) } @@ -484,5 +385,23 @@ func TestManagerSuite(t *testing.T) { t.Skip("requires root") } - suite.Run(t, new(ManagerSuite)) + mockWireguard := &mockWireguardClient{} + + suite.Run(t, &ManagerSuite{ + mockWireguard: mockWireguard, + DefaultSuite: ctest.DefaultSuite{ + Timeout: 5 * time.Second, + AfterSetup: func(s *ctest.DefaultSuite) { + s.Require().NoError(s.Runtime().RegisterController(&kubespanctrl.ManagerController{ + WireguardClientFactory: func() (kubespanctrl.WireguardClient, error) { + return mockWireguard, nil + }, + RulesManagerFactory: func(_, _, _ int) kubespanctrl.RulesManager { + return mockRulesManager{} + }, + PeerReconcileInterval: time.Second, + })) + }, + }, + }) } diff --git a/internal/app/machined/pkg/controllers/kubespan/nftables.go b/internal/app/machined/pkg/controllers/kubespan/nftables.go deleted file mode 100644 index e146f05127..0000000000 --- a/internal/app/machined/pkg/controllers/kubespan/nftables.go +++ /dev/null @@ -1,515 +0,0 @@ -// This Source Code Form is subject to the terms of the Mozilla Public -// License, v. 2.0. If a copy of the MPL was not distributed with this -// file, You can obtain one at http://mozilla.org/MPL/2.0/. - -package kubespan - -import ( - "fmt" - - "github.com/google/nftables" - "github.com/google/nftables/binaryutil" - "github.com/google/nftables/expr" - "go4.org/netipx" - "golang.org/x/sys/unix" -) - -// NfTablesManager manages nftables outside of controllers/resources scope. -type NfTablesManager interface { - Update(ips *netipx.IPSet, mtu uint32) error - Cleanup() error -} - -// NewNfTablesManager initializes NfTablesManager. -func NewNfTablesManager(externalMark, internalMark, markMask uint32) NfTablesManager { - nfTable := &nftables.Table{ - Family: nftables.TableFamilyINet, - Name: "talos_kubespan", - } - - return &nfTablesManager{ - ExternalMark: externalMark, - InternalMark: internalMark, - MarkMask: markMask, - - nfTable: nfTable, - targetSet4: &nftables.Set{ - Name: "kubespan_targets_ipv4", - Table: nfTable, - Interval: true, - KeyType: nftables.TypeIPAddr, // prefix - DataType: nftables.TypeInteger, // mask - }, - targetSet6: &nftables.Set{ - Name: "kubespan_targets_ipv6", - Table: nfTable, - Interval: true, - KeyType: nftables.TypeIP6Addr, - }, - } -} - -type nfTablesManager struct { - InternalMark uint32 - ExternalMark uint32 - MarkMask uint32 - - currentSet *netipx.IPSet - currentMTU uint32 - - // nfTable is a handle for the KubeSpan root table - nfTable *nftables.Table - - // targetSet4 is a handle for the IPv4 target IP nftables set - targetSet4 *nftables.Set - - // targetSet6 is a handle for the IPv6 target IP nftables set - targetSet6 *nftables.Set -} - -// Update the nftables rules based on the IPSet. -func (m *nfTablesManager) Update(desired *netipx.IPSet, mtu uint32) error { - if m.currentSet != nil && m.currentSet.Equal(desired) && m.currentMTU == mtu { - return nil - } - - if err := m.setNFTable(desired, mtu); err != nil { - return fmt.Errorf("failed to update IP sets: %w", err) - } - - m.currentSet = desired - m.currentMTU = mtu - - return nil -} - -// Cleanup the nftables rules. -func (m *nfTablesManager) Cleanup() error { - foundExisting, err := m.tableExists() - if err != nil { - return err - } - - if !foundExisting { - return nil - } - - c := &nftables.Conn{} - - c.FlushSet(m.targetSet4) - c.FlushSet(m.targetSet6) - c.FlushTable(m.nfTable) - - c.DelSet(m.targetSet4) - c.DelSet(m.targetSet6) - c.DelTable(m.nfTable) - - if err := c.Flush(); err != nil { - return fmt.Errorf("failed to execute nftable cleanup: %w", err) - } - - return nil -} - -func (m *nfTablesManager) tableExists() (bool, error) { - c := &nftables.Conn{} - - tables, err := c.ListTables() - if err != nil { - return false, fmt.Errorf("error listing tables: %w", err) - } - - foundExisting := false - - for _, table := range tables { - if table.Name == m.nfTable.Name && table.Family == m.nfTable.Family { - foundExisting = true - - break - } - } - - return foundExisting, nil -} - -func (m *nfTablesManager) setNFTable(ips *netipx.IPSet, mtu uint32) error { - c := &nftables.Conn{} - - // NB: sets should be flushed before new members because nftables will fail - // if there are any conflicts between existing ranges and new ranges. - - foundExisting, err := m.tableExists() - if err != nil { - return err - } - - if foundExisting { - c.FlushSet(m.targetSet4) - c.FlushSet(m.targetSet6) - c.FlushTable(m.nfTable) - } - - // Basic boilerplate; create a table & chain. - c.AddTable(m.nfTable) - - preChain := c.AddChain(&nftables.Chain{ - Name: "kubespan_prerouting", - Table: m.nfTable, - Type: nftables.ChainTypeFilter, - Hooknum: nftables.ChainHookPrerouting, - Priority: nftables.ChainPriorityFilter, - }) - - outChain := c.AddChain(&nftables.Chain{ - Name: "kubespan_outgoing", - Table: m.nfTable, - Type: nftables.ChainTypeRoute, - Hooknum: nftables.ChainHookOutput, - Priority: nftables.ChainPriorityFilter, - }) - - setElements4, setElements6 := m.setElements(ips) - - if err := c.AddSet(m.targetSet4, setElements4); err != nil { - return fmt.Errorf("failed to add IPv4 set: %w", err) - } - - if err := c.AddSet(m.targetSet6, setElements6); err != nil { - return fmt.Errorf("failed to add IPv6 set: %w", err) - } - - // meta ifname "lo" accept - ruleLo := []expr.Any{ - // [ meta load oifname => reg 1 ] - &expr.Meta{Key: expr.MetaKeyOIFNAME, Register: 1}, - // [ cmp eq reg 1 lo ] - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: ifname("lo"), - }, - // Accept the packet to stop the ruleset processing - &expr.Verdict{ - Kind: expr.VerdictAccept, - }, - } - - // meta mark & 0x00000060 == 0x00000020 accept - ruleExpr := []expr.Any{ - // Load the firewall mark into register 1 - &expr.Meta{ - Key: expr.MetaKeyMARK, - Register: 1, - }, - // Mask the mark with the configured mask: - // R1 = R1 & mask - &expr.Bitwise{ - SourceRegister: 1, - DestRegister: 1, - Len: 4, - Xor: binaryutil.NativeEndian.PutUint32(0), - Mask: binaryutil.NativeEndian.PutUint32(m.MarkMask), - }, - // Compare the masked firewall mark with expected value - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: binaryutil.NativeEndian.PutUint32(m.ExternalMark), - }, - // Accept the packet to stop the ruleset processing - &expr.Verdict{ - Kind: expr.VerdictAccept, - }, - } - - // match fwmark of Wireguard interface (not kubespan mark) - // accept and return without modifying the table or mark - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: preChain, - Exprs: ruleExpr, - }) - - // match fwmark of Wireguard interface (not kubespan mark) - // accept and return without modifying the table or mark - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: ruleExpr, - }) - - // match lo interface - // accept and return without modifying the table or mark - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: ruleLo, - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: preChain, - Exprs: matchIPv4Set(m.targetSet4, m.InternalMark, m.MarkMask), - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: preChain, - Exprs: matchIPv6Set(m.targetSet6, m.InternalMark, m.MarkMask), - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: matchIPSetMSS(m.targetSet4, mtu, nftables.TableFamilyIPv4), - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: matchIPv4Set(m.targetSet4, m.InternalMark, m.MarkMask), - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: matchIPSetMSS(m.targetSet6, mtu, nftables.TableFamilyIPv6), - }) - - c.AddRule(&nftables.Rule{ - Table: m.nfTable, - Chain: outChain, - Exprs: matchIPv6Set(m.targetSet6, m.InternalMark, m.MarkMask), - }) - - if err := c.Flush(); err != nil { - return fmt.Errorf("failed to execute nftable creation: %w", err) - } - - return nil -} - -func matchIPv4Set(set *nftables.Set, mark, mask uint32) []expr.Any { - return matchIPSet(set, mark, mask, nftables.TableFamilyIPv4) -} - -func matchIPv6Set(set *nftables.Set, mark, mask uint32) []expr.Any { - return matchIPSet(set, mark, mask, nftables.TableFamilyIPv6) -} - -func ipOffsetLength(family nftables.TableFamily) (offset uint32, length uint32) { - switch family { //nolint:exhaustive - case nftables.TableFamilyIPv4: - offset = 16 - length = 4 - case nftables.TableFamilyIPv6: - offset = 24 - length = 16 - default: - panic("unexpected IP family") - } - - return offset, length -} - -func matchIPSet(set *nftables.Set, mark, mask uint32, family nftables.TableFamily) []expr.Any { - offset, length := ipOffsetLength(family) - - // ip daddr @kubespan_targets_ipv4 meta mark set meta mark & 0xffffffdf | 0x00000040 accept - return []expr.Any{ - // Store protocol type to register 1 - &expr.Meta{ - Key: expr.MetaKeyNFPROTO, - Register: 1, - }, - // Match IP Family - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: []byte{byte(family)}, - }, - // Store the destination IP address to register 1 - &expr.Payload{ - DestRegister: 1, - Base: expr.PayloadBaseNetworkHeader, - Offset: offset, - Len: length, - }, - // Match from target set - &expr.Lookup{ - SourceRegister: 1, - SetName: set.Name, - SetID: set.ID, - }, - // Load the current packet mark into register 1 - &expr.Meta{ - Key: expr.MetaKeyMARK, - Register: 1, - }, - // This bitwise is equivalent to: R1 = R1 | (R1 & mask | mark) - // - // The NFTables backend bitwise operation is R3 = R2 & MASK ^ XOR, - // so we need to do a bit of a trick to do what we need: R1 = R1 & ^mask ^ mark - &expr.Bitwise{ - SourceRegister: 1, - DestRegister: 1, - Len: 4, - Xor: binaryutil.NativeEndian.PutUint32(mark), - Mask: binaryutil.NativeEndian.PutUint32(^mask), - }, - // Set firewall mark to the value computed in register 1 - &expr.Meta{ - Key: expr.MetaKeyMARK, - SourceRegister: true, - Register: 1, - }, - // Accept the packet to stop the ruleset processing - &expr.Verdict{ - Kind: expr.VerdictAccept, - }, - } -} - -func matchIPSetMSS(set *nftables.Set, mtu uint32, family nftables.TableFamily) []expr.Any { - offset, length := ipOffsetLength(family) - - var mss uint16 - - switch family { //nolint:exhaustive - case nftables.TableFamilyIPv4: - mss = uint16(mtu) - 40 // TCP + IPv4 overhead - case nftables.TableFamilyIPv6: - mss = uint16(mtu) - 60 // TCP + IPv6 overhead - default: - panic("unexpected IP family") - } - - // ip daddr @kubespan_targets_ipv4 tcp flags & (syn|rst) == syn tcp option maxseg size > $MSS tcp option maxseg size set $MSS - return []expr.Any{ - // Store protocol type to register 1 - &expr.Meta{ - Key: expr.MetaKeyNFPROTO, - Register: 1, - }, - // Match IP Family - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: []byte{byte(family)}, - }, - - // Store the destination IP address to register 1 - &expr.Payload{ - DestRegister: 1, - Base: expr.PayloadBaseNetworkHeader, - Offset: offset, - Len: length, - }, - // Match from target set - &expr.Lookup{ - SourceRegister: 1, - SetName: set.Name, - SetID: set.ID, - }, - - // Load the current packet mark into register 1 - &expr.Meta{ - Key: expr.MetaKeyL4PROTO, - Register: 1, - }, - // Match TCP Family - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: []byte{unix.IPPROTO_TCP}, - }, - - // [ payload load 1b @ transport header + 13 => reg 1 ] - &expr.Payload{ - DestRegister: 1, - Base: expr.PayloadBaseTransportHeader, - Offset: 13, - Len: 1, - }, - // [ bitwise reg 1 = ( reg 1 & 0x00000006 ) ^ 0x00000000 ] - &expr.Bitwise{ - DestRegister: 1, - SourceRegister: 1, - Len: 1, - Mask: []byte{0x02 | 0x04}, - Xor: []byte{0x00}, - }, - // [ cmp eq reg 1 0x00000002 ] - &expr.Cmp{ - Op: expr.CmpOpEq, - Register: 1, - Data: []byte{0x02}, - }, - - // [ exthdr load tcpopt 2b @ 2 + 2 => reg 1 ] - &expr.Exthdr{ - DestRegister: 1, - Type: 2, - Offset: 2, - Len: 2, - Op: expr.ExthdrOpTcpopt, - }, - // [ cmp gte reg 1 MTU ] - &expr.Cmp{ - Op: expr.CmpOpGt, - Register: 1, - Data: binaryutil.BigEndian.PutUint16(mss), - }, - // [ immediate reg 1 MTU ] - &expr.Immediate{ - Register: 1, - Data: binaryutil.BigEndian.PutUint16(mss), - }, - // [ exthdr write tcpopt reg 1 => 2b @ 2 + 2 ] - &expr.Exthdr{ - SourceRegister: 1, - Type: 2, - Offset: 2, - Len: 2, - Op: expr.ExthdrOpTcpopt, - }, - } -} - -func ifname(name string) []byte { - b := make([]byte, 16) - copy(b, []byte(name)) - - return b -} - -func (m *nfTablesManager) setElements(ips *netipx.IPSet) (setElements4, setElements6 []nftables.SetElement) { - if ips == nil { - return nil, nil - } - - for _, r := range ips.Ranges() { - fromBin, _ := r.From().MarshalBinary() //nolint:errcheck // doesn't fail - - toBin, _ := r.To().Next().MarshalBinary() //nolint:errcheck // doesn't fail - - se := []nftables.SetElement{ - { - Key: fromBin, - IntervalEnd: false, - }, - { - Key: toBin, - IntervalEnd: true, - }, - } - - if r.From().Is6() { - setElements6 = append(setElements6, se...) - } else { - setElements4 = append(setElements4, se...) - } - } - - return setElements4, setElements6 -} diff --git a/internal/app/machined/pkg/controllers/kubespan/nftables_test.go b/internal/app/machined/pkg/controllers/kubespan/nftables_test.go deleted file mode 100644 index fef62f1ef5..0000000000 --- a/internal/app/machined/pkg/controllers/kubespan/nftables_test.go +++ /dev/null @@ -1,54 +0,0 @@ -// This Source Code Form is subject to the terms of the Mozilla Public -// License, v. 2.0. If a copy of the MPL was not distributed with this -// file, You can obtain one at http://mozilla.org/MPL/2.0/. -package kubespan_test - -import ( - "net/netip" - "os" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - "go4.org/netipx" - - "github.com/siderolabs/talos/internal/app/machined/pkg/controllers/kubespan" - "github.com/siderolabs/talos/pkg/machinery/constants" -) - -func TestNfTables(t *testing.T) { - if os.Geteuid() != 0 { - t.Skip("requires root") - } - - // use a different mark to avoid conflicts with running kubespan - mgr := kubespan.NewNfTablesManager( - constants.KubeSpanDefaultFirewallMark<<1, - constants.KubeSpanDefaultForceFirewallMark<<1, - constants.KubeSpanDefaultFirewallMask<<1, - ) - - // cleanup should be fine if nothing is installed - assert.NoError(t, mgr.Cleanup()) - - defer mgr.Cleanup() //nolint:errcheck - - var builder netipx.IPSetBuilder - - builder.AddPrefix(netip.MustParsePrefix("172.20.0.0/24")) - builder.AddPrefix(netip.MustParsePrefix("10.0.0.0/16")) - - ipSet, err := builder.IPSet() - require.NoError(t, err) - - assert.NoError(t, mgr.Update(ipSet, constants.KubeSpanLinkMTU)) - - builder.AddPrefix(netip.MustParsePrefix("10.0.0.0/8")) - - ipSet, err = builder.IPSet() - require.NoError(t, err) - - assert.NoError(t, mgr.Update(ipSet, constants.KubeSpanLinkMTU)) - - assert.NoError(t, mgr.Cleanup()) -} diff --git a/internal/app/machined/pkg/controllers/network/nftables_chain.go b/internal/app/machined/pkg/controllers/network/nftables_chain.go new file mode 100644 index 0000000000..ae00a22eaf --- /dev/null +++ b/internal/app/machined/pkg/controllers/network/nftables_chain.go @@ -0,0 +1,174 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network + +import ( + "context" + "fmt" + "slices" + "strconv" + + "github.com/cosi-project/runtime/pkg/controller" + "github.com/cosi-project/runtime/pkg/safe" + "github.com/google/nftables" + "github.com/google/nftables/expr" + "github.com/siderolabs/go-pointer" + "go.uber.org/zap" + + networkadapter "github.com/siderolabs/talos/internal/app/machined/pkg/adapters/network" + "github.com/siderolabs/talos/pkg/machinery/constants" + "github.com/siderolabs/talos/pkg/machinery/resources/network" +) + +// NfTablesChainController applies network.NfTablesChain to the Linux nftables interface. +type NfTablesChainController struct { + TableName string +} + +// Name implements controller.Controller interface. +func (ctrl *NfTablesChainController) Name() string { + return "network.NfTablesChainController" +} + +// Inputs implements controller.Controller interface. +func (ctrl *NfTablesChainController) Inputs() []controller.Input { + return []controller.Input{ + { + Namespace: network.NamespaceName, + Type: network.NfTablesChainType, + Kind: controller.InputWeak, + }, + } +} + +// Outputs implements controller.Controller interface. +func (ctrl *NfTablesChainController) Outputs() []controller.Output { + return nil +} + +// Run implements controller.Controller interface. +// +//nolint:gocyclo,cyclop +func (ctrl *NfTablesChainController) Run(ctx context.Context, r controller.Runtime, logger *zap.Logger) error { + if ctrl.TableName == "" { + ctrl.TableName = constants.DefaultNfTablesTableName + } + + for { + select { + case <-ctx.Done(): + return nil + case <-r.EventCh(): + } + + var conn nftables.Conn + + list, err := safe.ReaderListAll[*network.NfTablesChain](ctx, r) + if err != nil { + return fmt.Errorf("error listing nftables chains: %w", err) + } + + existingTables, err := conn.ListTablesOfFamily(nftables.TableFamilyINet) + if err != nil { + return fmt.Errorf("error listing existing nftables tables: %w", err) + } + + var talosTable *nftables.Table + + if idx := slices.IndexFunc(existingTables, func(t *nftables.Table) bool { return t.Name == ctrl.TableName }); idx != -1 { + talosTable = existingTables[idx] + } + + if talosTable == nil { + talosTable = &nftables.Table{ + Family: nftables.TableFamilyINet, + Name: ctrl.TableName, + } + + conn.AddTable(talosTable) + } + + // drop all chains, they will be re-created + existingChains, err := conn.ListChains() + if err != nil { + return fmt.Errorf("error listing existing nftables chains: %w", err) + } + + for _, chain := range existingChains { + if chain.Table.Name != ctrl.TableName { // not our chain + continue + } + + conn.DelChain(chain) + } + + setID := uint32(0) + + for iter := list.Iterator(); iter.Next(); { + chain := iter.Value() + + nfChain := conn.AddChain(&nftables.Chain{ + Name: chain.Metadata().ID(), + Table: talosTable, + Hooknum: pointer.To(nftables.ChainHook(chain.TypedSpec().Hook)), + Priority: pointer.To(nftables.ChainPriority(chain.TypedSpec().Priority)), + Type: nftables.ChainType(chain.TypedSpec().Type), + }) + + for _, rule := range chain.TypedSpec().Rules { + compiled, err := networkadapter.NfTablesRule(&rule).Compile() + if err != nil { + return fmt.Errorf("error compiling nftables rule for chain %s: %w", nfChain.Name, err) + } + + for _, compiledRule := range compiled.Rules { + // check for lookup rules and add/fix up the set ID if needed + for i := range compiledRule { + if lookup, ok := compiledRule[i].(*expr.Lookup); ok { + setID++ + + if lookup.SetID >= uint32(len(compiled.Sets)) { + return fmt.Errorf("invalid set ID %d in lookup", lookup.SetID) + } + + set := compiled.Sets[lookup.SetID] + setName := "_set" + strconv.Itoa(int(setID)) + + if err = conn.AddSet(&nftables.Set{ + Table: talosTable, + ID: setID, + Name: setName, + Anonymous: true, + Constant: true, + Interval: true, + KeyType: set.KeyType(), + }, set.SetElements()); err != nil { + return fmt.Errorf("error adding nftables set for chain %s: %w", nfChain.Name, err) + } + + lookup.SetID = setID + lookup.SetName = setName + } + } + + conn.AddRule(&nftables.Rule{ + Table: talosTable, + Chain: nfChain, + Exprs: compiledRule, + }) + } + } + } + + if err := conn.Flush(); err != nil { + return fmt.Errorf("error flushing nftables: %w", err) + } + + chainNames, _ := safe.Map(list, func(chain *network.NfTablesChain) (string, error) { return chain.Metadata().ID(), nil }) //nolint:errcheck // doesn't fail + logger.Info("nftables chains updated", zap.Strings("chains", chainNames)) + + r.ResetRestartBackoff() + } +} diff --git a/internal/app/machined/pkg/controllers/network/nftables_chain_test.go b/internal/app/machined/pkg/controllers/network/nftables_chain_test.go new file mode 100644 index 0000000000..28c64c3858 --- /dev/null +++ b/internal/app/machined/pkg/controllers/network/nftables_chain_test.go @@ -0,0 +1,311 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network_test + +import ( + "net/netip" + "os" + "os/exec" + "strings" + "testing" + "time" + + "github.com/siderolabs/go-pointer" + "github.com/stretchr/testify/suite" + + "github.com/siderolabs/talos/internal/app/machined/pkg/controllers/ctest" + netctrl "github.com/siderolabs/talos/internal/app/machined/pkg/controllers/network" + "github.com/siderolabs/talos/pkg/machinery/constants" + "github.com/siderolabs/talos/pkg/machinery/nethelpers" + "github.com/siderolabs/talos/pkg/machinery/resources/network" +) + +type NfTablesChainSuite struct { + ctest.DefaultSuite +} + +func (s *NfTablesChainSuite) nftOutput() string { + out, err := exec.Command("nft", "list", "table", "inet", "talos-test").CombinedOutput() + s.Require().NoError(err, "nft list table inet talos-test failed: %s", string(out)) + + return string(out) +} + +func (s *NfTablesChainSuite) checkNftOutput(expected string) { + s.T().Helper() + + var prevOutput string + + s.Eventually(func() bool { + output := s.nftOutput() + + if output != prevOutput { + if strings.TrimSpace(output) != expected { + s.T().Logf("nft list table inet talos-test:\n%s", output) + } + + prevOutput = output + } + + return strings.TrimSpace(output) == expected + }, 5*time.Second, 100*time.Millisecond) +} + +func (s *NfTablesChainSuite) TestEmpty() { + s.checkNftOutput(`table inet talos-test { +}`) +} + +func (s *NfTablesChainSuite) TestAcceptLo() { + chain := network.NewNfTablesChain(network.NamespaceName, "test1") + chain.TypedSpec().Type = nethelpers.ChainTypeFilter + chain.TypedSpec().Hook = nethelpers.ChainHookInput + chain.TypedSpec().Priority = nethelpers.ChainPrioritySecurity + chain.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchOIfName: &network.NfTablesIfNameMatch{ + InterfaceName: "lo", + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain)) + + s.checkNftOutput(`table inet talos-test { + chain test1 { + type filter hook input priority security; policy accept; + oifname "lo" accept + } +}`) +} + +func (s *NfTablesChainSuite) TestMatchMarksSubnets() { + chain1 := network.NewNfTablesChain(network.NamespaceName, "test1") + chain1.TypedSpec().Type = nethelpers.ChainTypeFilter + chain1.TypedSpec().Hook = nethelpers.ChainHookInput + chain1.TypedSpec().Priority = nethelpers.ChainPriorityFilter + chain1.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchMark: &network.NfTablesMark{ + Mask: constants.KubeSpanDefaultFirewallMask, + Value: constants.KubeSpanDefaultFirewallMark, + }, + MatchSourceAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + }, + ExcludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.3.0.0/16"), + }, + Invert: true, + }, + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.0.0/24"), + }, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain1)) + + chain2 := network.NewNfTablesChain(network.NamespaceName, "test2") + chain2.TypedSpec().Type = nethelpers.ChainTypeFilter + chain2.TypedSpec().Hook = nethelpers.ChainHookInput + chain2.TypedSpec().Priority = nethelpers.ChainPriorityFilter + chain2.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.3.5/32"), + }, + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultFirewallMark, + }, + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain2)) + + s.checkNftOutput(`table inet talos-test { + chain test1 { + type filter hook input priority filter; policy accept; + meta mark & 0x00000060 == 0x00000020 ip saddr != { 10.0.0.0-10.2.255.255, 10.4.0.0-10.255.255.255 } ip daddr { 192.168.0.0/24 } accept + meta mark & 0x00000060 == 0x00000020 meta nfproto ipv6 accept + } + + chain test2 { + type filter hook input priority filter; policy accept; + ip daddr { 192.168.3.5 } meta mark set meta mark & 0xffffffbf | 0x00000020 + } +}`) +} + +func (s *NfTablesChainSuite) TestUpdateChains() { + chain := network.NewNfTablesChain(network.NamespaceName, "test1") + chain.TypedSpec().Type = nethelpers.ChainTypeFilter + chain.TypedSpec().Hook = nethelpers.ChainHookInput + chain.TypedSpec().Priority = nethelpers.ChainPriorityFilter + chain.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchSourceAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + }, + ExcludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.3.0.0/16"), + }, + Invert: true, + }, + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("192.168.0.0/24"), + }, + }, + Verdict: pointer.To(nethelpers.VerdictAccept), + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain)) + + s.checkNftOutput(`table inet talos-test { + chain test1 { + type filter hook input priority filter; policy accept; + ip saddr != { 10.0.0.0-10.2.255.255, 10.4.0.0-10.255.255.255 } ip daddr { 192.168.0.0/24 } accept + meta nfproto ipv6 accept + } +}`) + + chain.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchSourceAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + }, + ExcludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.4.0.0/16"), + }, + Invert: true, + }, + SetMark: &network.NfTablesMark{ + Mask: ^uint32(constants.KubeSpanDefaultFirewallMask), + Xor: constants.KubeSpanDefaultFirewallMark, + }, + }, + } + + s.Require().NoError(s.State().Update(s.Ctx(), chain)) + + s.checkNftOutput(`table inet talos-test { + chain test1 { + type filter hook input priority filter; policy accept; + ip saddr != { 10.0.0.0/14, 10.5.0.0-10.255.255.255 } meta mark set meta mark & 0xffffffbf | 0x00000020 + meta nfproto ipv6 meta mark set meta mark & 0xffffffbf | 0x00000020 + } +}`) + + s.Require().NoError(s.State().Destroy(s.Ctx(), chain.Metadata())) + + s.checkNftOutput(`table inet talos-test { +}`) +} + +func (s *NfTablesChainSuite) TestClampMSS() { + chain := network.NewNfTablesChain(network.NamespaceName, "test1") + chain.TypedSpec().Type = nethelpers.ChainTypeFilter + chain.TypedSpec().Hook = nethelpers.ChainHookInput + chain.TypedSpec().Priority = nethelpers.ChainPriorityFilter + chain.TypedSpec().Rules = []network.NfTablesRule{ + { + ClampMSS: &network.NfTablesClampMSS{ + MTU: constants.KubeSpanLinkMTU, + }, + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain)) + + s.checkNftOutput(`table inet talos-test { + chain test1 { + type filter hook input priority filter; policy accept; + meta nfproto ipv4 tcp flags syn / syn,rst tcp option maxseg size > 1380 tcp option maxseg size set 1380 + meta nfproto ipv6 tcp flags syn / syn,rst tcp option maxseg size > 1360 tcp option maxseg size set 1360 + } +}`) +} + +func (s *NfTablesChainSuite) TestL4Match() { + chain := network.NewNfTablesChain(network.NamespaceName, "test-tcp") + chain.TypedSpec().Type = nethelpers.ChainTypeFilter + chain.TypedSpec().Hook = nethelpers.ChainHookInput + chain.TypedSpec().Priority = nethelpers.ChainPriorityFilter + chain.TypedSpec().Rules = []network.NfTablesRule{ + { + MatchDestinationAddress: &network.NfTablesAddressMatch{ + IncludeSubnets: []netip.Prefix{ + netip.MustParsePrefix("10.0.0.0/8"), + netip.MustParsePrefix("2001::/16"), + }, + }, + MatchLayer4: &network.NfTablesLayer4Match{ + Protocol: nethelpers.ProtocolTCP, + MatchDestinationPort: &network.NfTablesPortMatch{ + Ranges: []network.PortRange{ + { + Lo: 1023, + Hi: 1025, + }, + { + Lo: 1027, + Hi: 1029, + }, + }, + }, + }, + Verdict: pointer.To(nethelpers.VerdictDrop), + }, + } + + s.Require().NoError(s.State().Create(s.Ctx(), chain)) + + s.checkNftOutput(`table inet talos-test { + chain test-tcp { + type filter hook input priority filter; policy accept; + ip daddr { 10.0.0.0/8 } tcp dport { 1023-1024, 1027-1028 } drop + ip6 daddr { 2001::/16 } tcp dport { 1023-1024, 1027-1028 } drop + } +}`) +} + +func TestNftablesChainSuite(t *testing.T) { + if os.Geteuid() != 0 { + t.Skip("requires root") + } + + if exec.Command("nft", "list", "tables").Run() != nil { + t.Skip("requires nftables CLI to be installed") + } + + suite.Run(t, &NfTablesChainSuite{ + DefaultSuite: ctest.DefaultSuite{ + Timeout: 5 * time.Second, + AfterSetup: func(s *ctest.DefaultSuite) { + // try to see if the table is there + if exec.Command("nft", "list", "table", "inet", "talos-test").Run() == nil { + s.Require().NoError(exec.Command("nft", "delete", "table", "inet", "talos-test").Run()) + } + + s.Require().NoError(s.Runtime().RegisterController(&netctrl.NfTablesChainController{TableName: "talos-test"})) + }, + AfterTearDown: func(s *ctest.DefaultSuite) { + s.Require().NoError(exec.Command("nft", "delete", "table", "inet", "talos-test").Run()) + }, + }, + }) +} diff --git a/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_controller.go b/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_controller.go index 8e52ac8fe9..a6c831bd72 100644 --- a/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_controller.go +++ b/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_controller.go @@ -201,6 +201,7 @@ func (ctrl *Controller) Run(ctx context.Context, drainer *runtime.Drainer) error &network.LinkMergeController{}, &network.LinkSpecController{}, &network.LinkStatusController{}, + &network.NfTablesChainController{}, &network.NodeAddressController{}, &network.OperatorConfigController{ Cmdline: procfs.ProcCmdline(), diff --git a/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_state.go b/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_state.go index 65d33e54b6..3258f4c2f2 100644 --- a/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_state.go +++ b/internal/app/machined/pkg/runtime/v1alpha2/v1alpha2_state.go @@ -154,6 +154,7 @@ func NewState() (*State, error) { &network.LinkRefresh{}, &network.LinkStatus{}, &network.LinkSpec{}, + &network.NfTablesChain{}, &network.NodeAddress{}, &network.NodeAddressFilter{}, &network.OperatorSpec{}, diff --git a/pkg/machinery/api/resource/definitions/enums/enums.pb.go b/pkg/machinery/api/resource/definitions/enums/enums.pb.go index 5ef7e26bde..92374ebb0b 100644 --- a/pkg/machinery/api/resource/definitions/enums/enums.pb.go +++ b/pkg/machinery/api/resource/definitions/enums/enums.pb.go @@ -898,6 +898,239 @@ func (NethelpersLinkType) EnumDescriptor() ([]byte, []int) { return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{11} } +// NethelpersMatchOperator is a netfilter match operator. +type NethelpersMatchOperator int32 + +const ( + NethelpersMatchOperator_OPERATOR_EQUAL NethelpersMatchOperator = 0 + NethelpersMatchOperator_OPERATOR_NOT_EQUAL NethelpersMatchOperator = 1 +) + +// Enum value maps for NethelpersMatchOperator. +var ( + NethelpersMatchOperator_name = map[int32]string{ + 0: "OPERATOR_EQUAL", + 1: "OPERATOR_NOT_EQUAL", + } + NethelpersMatchOperator_value = map[string]int32{ + "OPERATOR_EQUAL": 0, + "OPERATOR_NOT_EQUAL": 1, + } +) + +func (x NethelpersMatchOperator) Enum() *NethelpersMatchOperator { + p := new(NethelpersMatchOperator) + *p = x + return p +} + +func (x NethelpersMatchOperator) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NethelpersMatchOperator) Descriptor() protoreflect.EnumDescriptor { + return file_resource_definitions_enums_enums_proto_enumTypes[12].Descriptor() +} + +func (NethelpersMatchOperator) Type() protoreflect.EnumType { + return &file_resource_definitions_enums_enums_proto_enumTypes[12] +} + +func (x NethelpersMatchOperator) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NethelpersMatchOperator.Descriptor instead. +func (NethelpersMatchOperator) EnumDescriptor() ([]byte, []int) { + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{12} +} + +// NethelpersNfTablesChainHook wraps nftables.ChainHook for YAML marshaling. +type NethelpersNfTablesChainHook int32 + +const ( + NethelpersNfTablesChainHook_CHAIN_HOOK_PREROUTING NethelpersNfTablesChainHook = 0 + NethelpersNfTablesChainHook_CHAIN_HOOK_INPUT NethelpersNfTablesChainHook = 1 + NethelpersNfTablesChainHook_CHAIN_HOOK_FORWARD NethelpersNfTablesChainHook = 2 + NethelpersNfTablesChainHook_CHAIN_HOOK_OUTPUT NethelpersNfTablesChainHook = 3 + NethelpersNfTablesChainHook_CHAIN_HOOK_POSTROUTING NethelpersNfTablesChainHook = 4 +) + +// Enum value maps for NethelpersNfTablesChainHook. +var ( + NethelpersNfTablesChainHook_name = map[int32]string{ + 0: "CHAIN_HOOK_PREROUTING", + 1: "CHAIN_HOOK_INPUT", + 2: "CHAIN_HOOK_FORWARD", + 3: "CHAIN_HOOK_OUTPUT", + 4: "CHAIN_HOOK_POSTROUTING", + } + NethelpersNfTablesChainHook_value = map[string]int32{ + "CHAIN_HOOK_PREROUTING": 0, + "CHAIN_HOOK_INPUT": 1, + "CHAIN_HOOK_FORWARD": 2, + "CHAIN_HOOK_OUTPUT": 3, + "CHAIN_HOOK_POSTROUTING": 4, + } +) + +func (x NethelpersNfTablesChainHook) Enum() *NethelpersNfTablesChainHook { + p := new(NethelpersNfTablesChainHook) + *p = x + return p +} + +func (x NethelpersNfTablesChainHook) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NethelpersNfTablesChainHook) Descriptor() protoreflect.EnumDescriptor { + return file_resource_definitions_enums_enums_proto_enumTypes[13].Descriptor() +} + +func (NethelpersNfTablesChainHook) Type() protoreflect.EnumType { + return &file_resource_definitions_enums_enums_proto_enumTypes[13] +} + +func (x NethelpersNfTablesChainHook) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NethelpersNfTablesChainHook.Descriptor instead. +func (NethelpersNfTablesChainHook) EnumDescriptor() ([]byte, []int) { + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{13} +} + +// NethelpersNfTablesChainPriority wraps nftables.ChainPriority for YAML marshaling. +type NethelpersNfTablesChainPriority int32 + +const ( + NethelpersNfTablesChainPriority_NETHELPERS_NFTABLESCHAINPRIORITY_UNSPECIFIED NethelpersNfTablesChainPriority = 0 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_FIRST NethelpersNfTablesChainPriority = -2147483648 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_CONNTRACK_DEFRAG NethelpersNfTablesChainPriority = -400 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_RAW NethelpersNfTablesChainPriority = -300 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_SE_LINUX_FIRST NethelpersNfTablesChainPriority = -225 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_CONNTRACK NethelpersNfTablesChainPriority = -200 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_MANGLE NethelpersNfTablesChainPriority = -150 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_NAT_DEST NethelpersNfTablesChainPriority = -100 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_FILTER NethelpersNfTablesChainPriority = 0 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_SECURITY NethelpersNfTablesChainPriority = 50 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_NAT_SOURCE NethelpersNfTablesChainPriority = 100 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_SE_LINUX_LAST NethelpersNfTablesChainPriority = 225 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_CONNTRACK_HELPER NethelpersNfTablesChainPriority = 300 + NethelpersNfTablesChainPriority_CHAIN_PRIORITY_LAST NethelpersNfTablesChainPriority = 2147483647 +) + +// Enum value maps for NethelpersNfTablesChainPriority. +var ( + NethelpersNfTablesChainPriority_name = map[int32]string{ + 0: "NETHELPERS_NFTABLESCHAINPRIORITY_UNSPECIFIED", + -2147483648: "CHAIN_PRIORITY_FIRST", + -400: "CHAIN_PRIORITY_CONNTRACK_DEFRAG", + -300: "CHAIN_PRIORITY_RAW", + -225: "CHAIN_PRIORITY_SE_LINUX_FIRST", + -200: "CHAIN_PRIORITY_CONNTRACK", + -150: "CHAIN_PRIORITY_MANGLE", + -100: "CHAIN_PRIORITY_NAT_DEST", + // Duplicate value: 0: "CHAIN_PRIORITY_FILTER", + 50: "CHAIN_PRIORITY_SECURITY", + 100: "CHAIN_PRIORITY_NAT_SOURCE", + 225: "CHAIN_PRIORITY_SE_LINUX_LAST", + 300: "CHAIN_PRIORITY_CONNTRACK_HELPER", + 2147483647: "CHAIN_PRIORITY_LAST", + } + NethelpersNfTablesChainPriority_value = map[string]int32{ + "NETHELPERS_NFTABLESCHAINPRIORITY_UNSPECIFIED": 0, + "CHAIN_PRIORITY_FIRST": -2147483648, + "CHAIN_PRIORITY_CONNTRACK_DEFRAG": -400, + "CHAIN_PRIORITY_RAW": -300, + "CHAIN_PRIORITY_SE_LINUX_FIRST": -225, + "CHAIN_PRIORITY_CONNTRACK": -200, + "CHAIN_PRIORITY_MANGLE": -150, + "CHAIN_PRIORITY_NAT_DEST": -100, + "CHAIN_PRIORITY_FILTER": 0, + "CHAIN_PRIORITY_SECURITY": 50, + "CHAIN_PRIORITY_NAT_SOURCE": 100, + "CHAIN_PRIORITY_SE_LINUX_LAST": 225, + "CHAIN_PRIORITY_CONNTRACK_HELPER": 300, + "CHAIN_PRIORITY_LAST": 2147483647, + } +) + +func (x NethelpersNfTablesChainPriority) Enum() *NethelpersNfTablesChainPriority { + p := new(NethelpersNfTablesChainPriority) + *p = x + return p +} + +func (x NethelpersNfTablesChainPriority) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NethelpersNfTablesChainPriority) Descriptor() protoreflect.EnumDescriptor { + return file_resource_definitions_enums_enums_proto_enumTypes[14].Descriptor() +} + +func (NethelpersNfTablesChainPriority) Type() protoreflect.EnumType { + return &file_resource_definitions_enums_enums_proto_enumTypes[14] +} + +func (x NethelpersNfTablesChainPriority) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NethelpersNfTablesChainPriority.Descriptor instead. +func (NethelpersNfTablesChainPriority) EnumDescriptor() ([]byte, []int) { + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{14} +} + +// NethelpersNfTablesVerdict wraps nftables.Verdict for YAML marshaling. +type NethelpersNfTablesVerdict int32 + +const ( + NethelpersNfTablesVerdict_VERDICT_DROP NethelpersNfTablesVerdict = 0 + NethelpersNfTablesVerdict_VERDICT_ACCEPT NethelpersNfTablesVerdict = 1 +) + +// Enum value maps for NethelpersNfTablesVerdict. +var ( + NethelpersNfTablesVerdict_name = map[int32]string{ + 0: "VERDICT_DROP", + 1: "VERDICT_ACCEPT", + } + NethelpersNfTablesVerdict_value = map[string]int32{ + "VERDICT_DROP": 0, + "VERDICT_ACCEPT": 1, + } +) + +func (x NethelpersNfTablesVerdict) Enum() *NethelpersNfTablesVerdict { + p := new(NethelpersNfTablesVerdict) + *p = x + return p +} + +func (x NethelpersNfTablesVerdict) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NethelpersNfTablesVerdict) Descriptor() protoreflect.EnumDescriptor { + return file_resource_definitions_enums_enums_proto_enumTypes[15].Descriptor() +} + +func (NethelpersNfTablesVerdict) Type() protoreflect.EnumType { + return &file_resource_definitions_enums_enums_proto_enumTypes[15] +} + +func (x NethelpersNfTablesVerdict) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NethelpersNfTablesVerdict.Descriptor instead. +func (NethelpersNfTablesVerdict) EnumDescriptor() ([]byte, []int) { + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{15} +} + // NethelpersOperationalState wraps rtnetlink.OperationalState for YAML marshaling. type NethelpersOperationalState int32 @@ -944,11 +1177,11 @@ func (x NethelpersOperationalState) String() string { } func (NethelpersOperationalState) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[12].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[16].Descriptor() } func (NethelpersOperationalState) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[12] + return &file_resource_definitions_enums_enums_proto_enumTypes[16] } func (x NethelpersOperationalState) Number() protoreflect.EnumNumber { @@ -957,7 +1190,7 @@ func (x NethelpersOperationalState) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersOperationalState.Descriptor instead. func (NethelpersOperationalState) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{12} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{16} } // NethelpersPort wraps ethtool.Port for YAML marshaling. @@ -1009,11 +1242,11 @@ func (x NethelpersPort) String() string { } func (NethelpersPort) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[13].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[17].Descriptor() } func (NethelpersPort) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[13] + return &file_resource_definitions_enums_enums_proto_enumTypes[17] } func (x NethelpersPort) Number() protoreflect.EnumNumber { @@ -1022,7 +1255,7 @@ func (x NethelpersPort) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersPort.Descriptor instead. func (NethelpersPort) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{13} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{17} } // NethelpersPrimaryReselect is an ARP targets mode. @@ -1059,11 +1292,11 @@ func (x NethelpersPrimaryReselect) String() string { } func (NethelpersPrimaryReselect) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[14].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[18].Descriptor() } func (NethelpersPrimaryReselect) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[14] + return &file_resource_definitions_enums_enums_proto_enumTypes[18] } func (x NethelpersPrimaryReselect) Number() protoreflect.EnumNumber { @@ -1072,7 +1305,57 @@ func (x NethelpersPrimaryReselect) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersPrimaryReselect.Descriptor instead. func (NethelpersPrimaryReselect) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{14} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{18} +} + +// NethelpersProtocol is a inet protocol. +type NethelpersProtocol int32 + +const ( + NethelpersProtocol_NETHELPERS_PROTOCOL_UNSPECIFIED NethelpersProtocol = 0 + NethelpersProtocol_PROTOCOL_TCP NethelpersProtocol = 6 + NethelpersProtocol_PROTOCOL_UDP NethelpersProtocol = 17 +) + +// Enum value maps for NethelpersProtocol. +var ( + NethelpersProtocol_name = map[int32]string{ + 0: "NETHELPERS_PROTOCOL_UNSPECIFIED", + 6: "PROTOCOL_TCP", + 17: "PROTOCOL_UDP", + } + NethelpersProtocol_value = map[string]int32{ + "NETHELPERS_PROTOCOL_UNSPECIFIED": 0, + "PROTOCOL_TCP": 6, + "PROTOCOL_UDP": 17, + } +) + +func (x NethelpersProtocol) Enum() *NethelpersProtocol { + p := new(NethelpersProtocol) + *p = x + return p +} + +func (x NethelpersProtocol) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NethelpersProtocol) Descriptor() protoreflect.EnumDescriptor { + return file_resource_definitions_enums_enums_proto_enumTypes[19].Descriptor() +} + +func (NethelpersProtocol) Type() protoreflect.EnumType { + return &file_resource_definitions_enums_enums_proto_enumTypes[19] +} + +func (x NethelpersProtocol) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use NethelpersProtocol.Descriptor instead. +func (NethelpersProtocol) EnumDescriptor() ([]byte, []int) { + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{19} } // NethelpersRouteFlag wraps RTM_F_* constants. @@ -1127,11 +1410,11 @@ func (x NethelpersRouteFlag) String() string { } func (NethelpersRouteFlag) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[15].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[20].Descriptor() } func (NethelpersRouteFlag) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[15] + return &file_resource_definitions_enums_enums_proto_enumTypes[20] } func (x NethelpersRouteFlag) Number() protoreflect.EnumNumber { @@ -1140,7 +1423,7 @@ func (x NethelpersRouteFlag) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersRouteFlag.Descriptor instead. func (NethelpersRouteFlag) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{15} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{20} } // NethelpersRouteProtocol is a routing protocol. @@ -1234,11 +1517,11 @@ func (x NethelpersRouteProtocol) String() string { } func (NethelpersRouteProtocol) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[16].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[21].Descriptor() } func (NethelpersRouteProtocol) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[16] + return &file_resource_definitions_enums_enums_proto_enumTypes[21] } func (x NethelpersRouteProtocol) Number() protoreflect.EnumNumber { @@ -1247,7 +1530,7 @@ func (x NethelpersRouteProtocol) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersRouteProtocol.Descriptor instead. func (NethelpersRouteProtocol) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{16} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{21} } // NethelpersRouteType is a route type. @@ -1311,11 +1594,11 @@ func (x NethelpersRouteType) String() string { } func (NethelpersRouteType) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[17].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[22].Descriptor() } func (NethelpersRouteType) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[17] + return &file_resource_definitions_enums_enums_proto_enumTypes[22] } func (x NethelpersRouteType) Number() protoreflect.EnumNumber { @@ -1324,7 +1607,7 @@ func (x NethelpersRouteType) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersRouteType.Descriptor instead. func (NethelpersRouteType) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{17} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{22} } // NethelpersRoutingTable is a routing table ID. @@ -1364,11 +1647,11 @@ func (x NethelpersRoutingTable) String() string { } func (NethelpersRoutingTable) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[18].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[23].Descriptor() } func (NethelpersRoutingTable) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[18] + return &file_resource_definitions_enums_enums_proto_enumTypes[23] } func (x NethelpersRoutingTable) Number() protoreflect.EnumNumber { @@ -1377,7 +1660,7 @@ func (x NethelpersRoutingTable) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersRoutingTable.Descriptor instead. func (NethelpersRoutingTable) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{18} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{23} } // NethelpersScope is an address scope. @@ -1420,11 +1703,11 @@ func (x NethelpersScope) String() string { } func (NethelpersScope) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[19].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[24].Descriptor() } func (NethelpersScope) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[19] + return &file_resource_definitions_enums_enums_proto_enumTypes[24] } func (x NethelpersScope) Number() protoreflect.EnumNumber { @@ -1433,7 +1716,7 @@ func (x NethelpersScope) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersScope.Descriptor instead. func (NethelpersScope) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{19} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{24} } // NethelpersVLANProtocol is a VLAN protocol. @@ -1470,11 +1753,11 @@ func (x NethelpersVLANProtocol) String() string { } func (NethelpersVLANProtocol) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[20].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[25].Descriptor() } func (NethelpersVLANProtocol) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[20] + return &file_resource_definitions_enums_enums_proto_enumTypes[25] } func (x NethelpersVLANProtocol) Number() protoreflect.EnumNumber { @@ -1483,7 +1766,7 @@ func (x NethelpersVLANProtocol) Number() protoreflect.EnumNumber { // Deprecated: Use NethelpersVLANProtocol.Descriptor instead. func (NethelpersVLANProtocol) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{20} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{25} } // KubespanPeerState is KubeSpan peer current state. @@ -1520,11 +1803,11 @@ func (x KubespanPeerState) String() string { } func (KubespanPeerState) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[21].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[26].Descriptor() } func (KubespanPeerState) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[21] + return &file_resource_definitions_enums_enums_proto_enumTypes[26] } func (x KubespanPeerState) Number() protoreflect.EnumNumber { @@ -1533,7 +1816,7 @@ func (x KubespanPeerState) Number() protoreflect.EnumNumber { // Deprecated: Use KubespanPeerState.Descriptor instead. func (KubespanPeerState) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{21} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{26} } // NetworkConfigLayer describes network configuration layers, with lowest priority first. @@ -1576,11 +1859,11 @@ func (x NetworkConfigLayer) String() string { } func (NetworkConfigLayer) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[22].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[27].Descriptor() } func (NetworkConfigLayer) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[22] + return &file_resource_definitions_enums_enums_proto_enumTypes[27] } func (x NetworkConfigLayer) Number() protoreflect.EnumNumber { @@ -1589,7 +1872,7 @@ func (x NetworkConfigLayer) Number() protoreflect.EnumNumber { // Deprecated: Use NetworkConfigLayer.Descriptor instead. func (NetworkConfigLayer) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{22} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{27} } // NetworkOperator enumerates Talos network operators. @@ -1626,11 +1909,11 @@ func (x NetworkOperator) String() string { } func (NetworkOperator) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[23].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[28].Descriptor() } func (NetworkOperator) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[23] + return &file_resource_definitions_enums_enums_proto_enumTypes[28] } func (x NetworkOperator) Number() protoreflect.EnumNumber { @@ -1639,7 +1922,7 @@ func (x NetworkOperator) Number() protoreflect.EnumNumber { // Deprecated: Use NetworkOperator.Descriptor instead. func (NetworkOperator) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{23} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{28} } // RuntimeMachineStage describes the stage of the machine boot/run process. @@ -1694,11 +1977,11 @@ func (x RuntimeMachineStage) String() string { } func (RuntimeMachineStage) Descriptor() protoreflect.EnumDescriptor { - return file_resource_definitions_enums_enums_proto_enumTypes[24].Descriptor() + return file_resource_definitions_enums_enums_proto_enumTypes[29].Descriptor() } func (RuntimeMachineStage) Type() protoreflect.EnumType { - return &file_resource_definitions_enums_enums_proto_enumTypes[24] + return &file_resource_definitions_enums_enums_proto_enumTypes[29] } func (x RuntimeMachineStage) Number() protoreflect.EnumNumber { @@ -1707,7 +1990,7 @@ func (x RuntimeMachineStage) Number() protoreflect.EnumNumber { // Deprecated: Use RuntimeMachineStage.Descriptor instead. func (RuntimeMachineStage) EnumDescriptor() ([]byte, []int) { - return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{24} + return file_resource_definitions_enums_enums_proto_rawDescGZIP(), []int{29} } var File_resource_definitions_enums_enums_proto protoreflect.FileDescriptor @@ -1895,155 +2178,214 @@ var file_resource_definitions_enums_enums_proto_rawDesc = []byte{ 0x4b, 0x36, 0x5f, 0x4c, 0x4f, 0x57, 0x50, 0x41, 0x4e, 0x10, 0xb9, 0x06, 0x12, 0x0f, 0x0a, 0x09, 0x4c, 0x49, 0x4e, 0x4b, 0x5f, 0x56, 0x4f, 0x49, 0x44, 0x10, 0xff, 0xff, 0x03, 0x12, 0x0f, 0x0a, 0x09, 0x4c, 0x49, 0x4e, 0x4b, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0xfe, 0xff, 0x03, 0x1a, 0x02, - 0x10, 0x01, 0x2a, 0xc9, 0x01, 0x0a, 0x1a, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, - 0x73, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, - 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x4f, 0x50, 0x45, - 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x50, 0x52, 0x45, 0x53, - 0x45, 0x4e, 0x54, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x45, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x4f, 0x50, - 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4c, 0x4f, 0x57, 0x45, 0x52, 0x5f, 0x4c, - 0x41, 0x59, 0x45, 0x52, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, 0x4f, - 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x49, 0x4e, - 0x47, 0x10, 0x04, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x5f, 0x44, 0x4f, 0x52, 0x4d, 0x41, 0x4e, 0x54, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x4f, - 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x50, 0x10, 0x06, 0x2a, 0x72, - 0x0a, 0x0e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x50, 0x6f, 0x72, 0x74, - 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x57, 0x49, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x50, 0x41, 0x49, 0x52, - 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x55, 0x49, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x4d, - 0x49, 0x49, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x49, 0x42, 0x52, 0x45, 0x10, 0x03, 0x12, - 0x07, 0x0a, 0x03, 0x42, 0x4e, 0x43, 0x10, 0x04, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x49, 0x52, 0x45, - 0x43, 0x54, 0x5f, 0x41, 0x54, 0x54, 0x41, 0x43, 0x48, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x04, 0x4e, - 0x4f, 0x4e, 0x45, 0x10, 0xef, 0x01, 0x12, 0x0a, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, - 0xff, 0x01, 0x2a, 0x73, 0x0a, 0x19, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, - 0x50, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x12, - 0x1b, 0x0a, 0x17, 0x50, 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, - 0x45, 0x43, 0x54, 0x5f, 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, - 0x50, 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, - 0x5f, 0x42, 0x45, 0x54, 0x54, 0x45, 0x52, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x50, 0x52, 0x49, - 0x4d, 0x41, 0x52, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x46, 0x41, - 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x02, 0x2a, 0xdf, 0x01, 0x0a, 0x13, 0x4e, 0x65, 0x74, 0x68, - 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x12, - 0x24, 0x0a, 0x20, 0x4e, 0x45, 0x54, 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x53, 0x5f, 0x52, 0x4f, - 0x55, 0x54, 0x45, 0x46, 0x4c, 0x41, 0x47, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, - 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0c, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4e, - 0x4f, 0x54, 0x49, 0x46, 0x59, 0x10, 0x80, 0x02, 0x12, 0x11, 0x0a, 0x0c, 0x52, 0x4f, 0x55, 0x54, - 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x4e, 0x45, 0x44, 0x10, 0x80, 0x04, 0x12, 0x13, 0x0a, 0x0e, 0x52, - 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x10, 0x80, 0x08, - 0x12, 0x11, 0x0a, 0x0c, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, - 0x10, 0x80, 0x10, 0x12, 0x17, 0x0a, 0x12, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, - 0x4b, 0x55, 0x50, 0x5f, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x80, 0x20, 0x12, 0x14, 0x0a, 0x0f, - 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x46, 0x49, 0x42, 0x5f, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x10, - 0x80, 0x40, 0x12, 0x13, 0x0a, 0x0d, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4f, 0x46, 0x46, 0x4c, - 0x4f, 0x41, 0x44, 0x10, 0x80, 0x80, 0x01, 0x12, 0x10, 0x0a, 0x0a, 0x52, 0x4f, 0x55, 0x54, 0x45, - 0x5f, 0x54, 0x52, 0x41, 0x50, 0x10, 0x80, 0x80, 0x02, 0x2a, 0xd2, 0x03, 0x0a, 0x17, 0x4e, 0x65, - 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, - 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x52, - 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x52, 0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10, - 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4b, 0x45, - 0x52, 0x4e, 0x45, 0x4c, 0x10, 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, - 0x4f, 0x4c, 0x5f, 0x42, 0x4f, 0x4f, 0x54, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x52, 0x4f, - 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x49, 0x43, 0x10, 0x04, 0x12, 0x0f, - 0x0a, 0x0b, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x52, 0x41, 0x10, 0x09, 0x12, - 0x10, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4d, 0x52, 0x54, 0x10, - 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x5a, 0x45, - 0x42, 0x52, 0x41, 0x10, 0x0b, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, - 0x4c, 0x5f, 0x42, 0x49, 0x52, 0x44, 0x10, 0x0c, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x54, - 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x44, 0x4e, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x44, 0x10, 0x0d, 0x12, - 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x58, 0x4f, 0x52, 0x50, - 0x10, 0x0e, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4e, - 0x54, 0x4b, 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, - 0x5f, 0x44, 0x48, 0x43, 0x50, 0x10, 0x10, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, - 0x43, 0x4f, 0x4c, 0x5f, 0x4d, 0x52, 0x54, 0x44, 0x10, 0x11, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, - 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4b, 0x45, 0x45, 0x50, 0x41, 0x4c, 0x49, 0x56, 0x45, - 0x44, 0x10, 0x12, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, - 0x42, 0x41, 0x42, 0x45, 0x4c, 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, - 0x43, 0x4f, 0x4c, 0x5f, 0x4f, 0x50, 0x45, 0x4e, 0x52, 0x10, 0x63, 0x12, 0x11, 0x0a, 0x0c, 0x50, - 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x42, 0x47, 0x50, 0x10, 0xba, 0x01, 0x12, 0x12, - 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x49, 0x53, 0x49, 0x53, 0x10, - 0xbb, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4f, - 0x53, 0x50, 0x46, 0x10, 0xbc, 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, - 0x4f, 0x4c, 0x5f, 0x52, 0x49, 0x50, 0x10, 0xbd, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x50, 0x52, 0x4f, - 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x45, 0x49, 0x47, 0x52, 0x50, 0x10, 0xc0, 0x01, 0x2a, 0xf1, - 0x01, 0x0a, 0x13, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, - 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, - 0x4e, 0x53, 0x50, 0x45, 0x43, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x55, 0x4e, 0x49, 0x43, 0x41, 0x53, 0x54, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, - 0x45, 0x5f, 0x4c, 0x4f, 0x43, 0x41, 0x4c, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x54, 0x59, 0x50, - 0x45, 0x5f, 0x42, 0x52, 0x4f, 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x03, 0x12, 0x10, 0x0a, - 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x41, 0x4e, 0x59, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, - 0x12, 0x0a, 0x0e, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x43, 0x41, 0x53, - 0x54, 0x10, 0x05, 0x12, 0x12, 0x0a, 0x0e, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4c, 0x41, 0x43, - 0x4b, 0x48, 0x4f, 0x4c, 0x45, 0x10, 0x06, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x55, 0x4e, 0x52, 0x45, 0x41, 0x43, 0x48, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x07, 0x12, 0x11, 0x0a, - 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x52, 0x4f, 0x48, 0x49, 0x42, 0x49, 0x54, 0x10, 0x08, - 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x48, 0x52, 0x4f, 0x57, 0x10, 0x09, - 0x12, 0x0c, 0x0a, 0x08, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x41, 0x54, 0x10, 0x0a, 0x12, 0x12, - 0x0a, 0x0e, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x58, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x4c, 0x56, 0x45, - 0x10, 0x0b, 0x2a, 0x61, 0x0a, 0x16, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, - 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x10, 0x0a, 0x0c, - 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x10, 0x00, 0x12, 0x12, - 0x0a, 0x0d, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x10, - 0xfd, 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x4d, 0x41, 0x49, 0x4e, - 0x10, 0xfe, 0x01, 0x12, 0x10, 0x0a, 0x0b, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x4c, 0x4f, 0x43, - 0x41, 0x4c, 0x10, 0xff, 0x01, 0x2a, 0x6a, 0x0a, 0x0f, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, - 0x65, 0x72, 0x73, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x43, 0x4f, 0x50, - 0x45, 0x5f, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0a, 0x53, 0x43, - 0x4f, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x54, 0x45, 0x10, 0xc8, 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x53, - 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0xfd, 0x01, 0x12, 0x0f, 0x0a, 0x0a, - 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x48, 0x4f, 0x53, 0x54, 0x10, 0xfe, 0x01, 0x12, 0x12, 0x0a, - 0x0d, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x57, 0x48, 0x45, 0x52, 0x45, 0x10, 0xff, - 0x01, 0x2a, 0x78, 0x0a, 0x16, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x56, - 0x4c, 0x41, 0x4e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x23, 0x4e, - 0x45, 0x54, 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x53, 0x5f, 0x56, 0x4c, 0x41, 0x4e, 0x50, 0x52, - 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, - 0x45, 0x44, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x13, 0x56, 0x4c, 0x41, 0x4e, 0x5f, 0x50, 0x52, 0x4f, - 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x38, 0x30, 0x32, 0x31, 0x5f, 0x51, 0x10, 0x80, 0x82, 0x02, 0x12, - 0x1a, 0x0a, 0x14, 0x56, 0x4c, 0x41, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, - 0x38, 0x30, 0x32, 0x31, 0x5f, 0x41, 0x44, 0x10, 0xa8, 0x91, 0x02, 0x2a, 0x53, 0x0a, 0x11, 0x4b, - 0x75, 0x62, 0x65, 0x73, 0x70, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x12, 0x16, 0x0a, 0x12, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, - 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x45, 0x45, 0x52, - 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x50, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x50, - 0x45, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x02, - 0x2a, 0x88, 0x01, 0x0a, 0x12, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x43, 0x4f, 0x4e, 0x46, 0x49, - 0x47, 0x5f, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x43, - 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x43, 0x4d, 0x44, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x01, 0x12, - 0x13, 0x0a, 0x0f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, - 0x52, 0x4d, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x4f, - 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x10, 0x03, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4e, - 0x46, 0x49, 0x47, 0x5f, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x46, - 0x49, 0x47, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x04, 0x2a, 0x4b, 0x0a, 0x0f, 0x4e, - 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x12, - 0x0a, 0x0e, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, 0x48, 0x43, 0x50, 0x34, - 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, - 0x48, 0x43, 0x50, 0x36, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, - 0x4f, 0x52, 0x5f, 0x56, 0x49, 0x50, 0x10, 0x02, 0x2a, 0x9b, 0x02, 0x0a, 0x13, 0x52, 0x75, 0x6e, - 0x74, 0x69, 0x6d, 0x65, 0x4d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65, - 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, - 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x4d, - 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x42, 0x4f, 0x4f, - 0x54, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, - 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4c, 0x4c, 0x49, - 0x4e, 0x47, 0x10, 0x02, 0x12, 0x1d, 0x0a, 0x19, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, - 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, - 0x45, 0x10, 0x03, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, - 0x54, 0x41, 0x47, 0x45, 0x5f, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x1b, - 0x0a, 0x17, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, - 0x52, 0x45, 0x42, 0x4f, 0x4f, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x05, 0x12, 0x1f, 0x0a, 0x1b, 0x4d, - 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x53, 0x48, 0x55, - 0x54, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x06, 0x12, 0x1b, 0x0a, 0x17, - 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x52, 0x45, - 0x53, 0x45, 0x54, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x07, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x43, - 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x55, 0x50, 0x47, 0x52, 0x41, - 0x44, 0x49, 0x4e, 0x47, 0x10, 0x08, 0x42, 0x4a, 0x5a, 0x48, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x69, 0x64, 0x65, 0x72, 0x6f, 0x6c, 0x61, 0x62, 0x73, 0x2f, - 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, - 0x65, 0x72, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x65, 0x6e, 0x75, - 0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x10, 0x01, 0x2a, 0x45, 0x0a, 0x17, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, + 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, + 0x0e, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, + 0x00, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4e, 0x4f, + 0x54, 0x5f, 0x45, 0x51, 0x55, 0x41, 0x4c, 0x10, 0x01, 0x2a, 0x99, 0x01, 0x0a, 0x1b, 0x4e, 0x65, + 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x43, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x6f, 0x6f, 0x6b, 0x12, 0x19, 0x0a, 0x15, 0x43, 0x48, 0x41, + 0x49, 0x4e, 0x5f, 0x48, 0x4f, 0x4f, 0x4b, 0x5f, 0x50, 0x52, 0x45, 0x52, 0x4f, 0x55, 0x54, 0x49, + 0x4e, 0x47, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x48, 0x4f, + 0x4f, 0x4b, 0x5f, 0x49, 0x4e, 0x50, 0x55, 0x54, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x43, 0x48, + 0x41, 0x49, 0x4e, 0x5f, 0x48, 0x4f, 0x4f, 0x4b, 0x5f, 0x46, 0x4f, 0x52, 0x57, 0x41, 0x52, 0x44, + 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x48, 0x4f, 0x4f, 0x4b, + 0x5f, 0x4f, 0x55, 0x54, 0x50, 0x55, 0x54, 0x10, 0x03, 0x12, 0x1a, 0x0a, 0x16, 0x43, 0x48, 0x41, + 0x49, 0x4e, 0x5f, 0x48, 0x4f, 0x4f, 0x4b, 0x5f, 0x50, 0x4f, 0x53, 0x54, 0x52, 0x4f, 0x55, 0x54, + 0x49, 0x4e, 0x47, 0x10, 0x04, 0x2a, 0xa3, 0x04, 0x0a, 0x1f, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, + 0x70, 0x65, 0x72, 0x73, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x30, 0x0a, 0x2c, 0x4e, 0x45, 0x54, + 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x53, 0x5f, 0x4e, 0x46, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x53, + 0x43, 0x48, 0x41, 0x49, 0x4e, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x55, 0x4e, + 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x21, 0x0a, 0x14, 0x43, + 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x46, 0x49, + 0x52, 0x53, 0x54, 0x10, 0x80, 0x80, 0x80, 0x80, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x2c, + 0x0a, 0x1f, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, + 0x5f, 0x43, 0x4f, 0x4e, 0x4e, 0x54, 0x52, 0x41, 0x43, 0x4b, 0x5f, 0x44, 0x45, 0x46, 0x52, 0x41, + 0x47, 0x10, 0xf0, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x1f, 0x0a, 0x12, + 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x52, + 0x41, 0x57, 0x10, 0xd4, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x2a, 0x0a, + 0x1d, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, + 0x53, 0x45, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x46, 0x49, 0x52, 0x53, 0x54, 0x10, 0x9f, + 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x25, 0x0a, 0x18, 0x43, 0x48, 0x41, + 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, + 0x54, 0x52, 0x41, 0x43, 0x4b, 0x10, 0xb8, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, + 0x12, 0x22, 0x0a, 0x15, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, + 0x54, 0x59, 0x5f, 0x4d, 0x41, 0x4e, 0x47, 0x4c, 0x45, 0x10, 0xea, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x01, 0x12, 0x24, 0x0a, 0x17, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, + 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x4e, 0x41, 0x54, 0x5f, 0x44, 0x45, 0x53, 0x54, 0x10, + 0x9c, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x43, 0x48, + 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x46, 0x49, 0x4c, + 0x54, 0x45, 0x52, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, + 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x53, 0x45, 0x43, 0x55, 0x52, 0x49, 0x54, 0x59, + 0x10, 0x32, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, + 0x52, 0x49, 0x54, 0x59, 0x5f, 0x4e, 0x41, 0x54, 0x5f, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x10, + 0x64, 0x12, 0x21, 0x0a, 0x1c, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, + 0x49, 0x54, 0x59, 0x5f, 0x53, 0x45, 0x5f, 0x4c, 0x49, 0x4e, 0x55, 0x58, 0x5f, 0x4c, 0x41, 0x53, + 0x54, 0x10, 0xe1, 0x01, 0x12, 0x24, 0x0a, 0x1f, 0x43, 0x48, 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, + 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, 0x54, 0x52, 0x41, 0x43, 0x4b, + 0x5f, 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x10, 0xac, 0x02, 0x12, 0x1b, 0x0a, 0x13, 0x43, 0x48, + 0x41, 0x49, 0x4e, 0x5f, 0x50, 0x52, 0x49, 0x4f, 0x52, 0x49, 0x54, 0x59, 0x5f, 0x4c, 0x41, 0x53, + 0x54, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x1a, 0x02, 0x10, 0x01, 0x2a, 0x41, 0x0a, 0x19, 0x4e, + 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x56, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x12, 0x10, 0x0a, 0x0c, 0x56, 0x45, 0x52, 0x44, + 0x49, 0x43, 0x54, 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x56, 0x45, + 0x52, 0x44, 0x49, 0x43, 0x54, 0x5f, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x10, 0x01, 0x2a, 0xc9, + 0x01, 0x0a, 0x1a, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, + 0x12, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, + 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, + 0x41, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10, + 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, + 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x45, 0x5f, 0x4c, 0x4f, 0x57, 0x45, 0x52, 0x5f, 0x4c, 0x41, 0x59, 0x45, 0x52, + 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x50, 0x45, 0x52, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x54, 0x45, 0x53, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, + 0x16, 0x0a, 0x12, 0x4f, 0x50, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x4f, + 0x52, 0x4d, 0x41, 0x4e, 0x54, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x50, 0x45, 0x52, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x50, 0x10, 0x06, 0x2a, 0x72, 0x0a, 0x0e, 0x4e, 0x65, + 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x0c, + 0x54, 0x57, 0x49, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x50, 0x41, 0x49, 0x52, 0x10, 0x00, 0x12, 0x07, + 0x0a, 0x03, 0x41, 0x55, 0x49, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x4d, 0x49, 0x49, 0x10, 0x02, + 0x12, 0x09, 0x0a, 0x05, 0x46, 0x49, 0x42, 0x52, 0x45, 0x10, 0x03, 0x12, 0x07, 0x0a, 0x03, 0x42, + 0x4e, 0x43, 0x10, 0x04, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x41, + 0x54, 0x54, 0x41, 0x43, 0x48, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x04, 0x4e, 0x4f, 0x4e, 0x45, 0x10, + 0xef, 0x01, 0x12, 0x0a, 0x0a, 0x05, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x10, 0xff, 0x01, 0x2a, 0x73, + 0x0a, 0x19, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x50, 0x72, 0x69, 0x6d, + 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x12, 0x1b, 0x0a, 0x17, 0x50, + 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, + 0x41, 0x4c, 0x57, 0x41, 0x59, 0x53, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x50, 0x52, 0x49, 0x4d, + 0x41, 0x52, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x42, 0x45, 0x54, + 0x54, 0x45, 0x52, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x50, 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, + 0x5f, 0x52, 0x45, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, + 0x45, 0x10, 0x02, 0x2a, 0x5d, 0x0a, 0x12, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, + 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x23, 0x0a, 0x1f, 0x4e, 0x45, 0x54, + 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x10, + 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x54, 0x43, 0x50, 0x10, 0x06, + 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x55, 0x44, 0x50, + 0x10, 0x11, 0x2a, 0xdf, 0x01, 0x0a, 0x13, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, + 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x12, 0x24, 0x0a, 0x20, 0x4e, 0x45, + 0x54, 0x48, 0x45, 0x4c, 0x50, 0x45, 0x52, 0x53, 0x5f, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x46, 0x4c, + 0x41, 0x47, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x11, 0x0a, 0x0c, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x49, 0x46, 0x59, + 0x10, 0x80, 0x02, 0x12, 0x11, 0x0a, 0x0c, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x43, 0x4c, 0x4f, + 0x4e, 0x45, 0x44, 0x10, 0x80, 0x04, 0x12, 0x13, 0x0a, 0x0e, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, + 0x45, 0x51, 0x55, 0x41, 0x4c, 0x49, 0x5a, 0x45, 0x10, 0x80, 0x08, 0x12, 0x11, 0x0a, 0x0c, 0x52, + 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x50, 0x52, 0x45, 0x46, 0x49, 0x58, 0x10, 0x80, 0x10, 0x12, 0x17, + 0x0a, 0x12, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4c, 0x4f, 0x4f, 0x4b, 0x55, 0x50, 0x5f, 0x54, + 0x41, 0x42, 0x4c, 0x45, 0x10, 0x80, 0x20, 0x12, 0x14, 0x0a, 0x0f, 0x52, 0x4f, 0x55, 0x54, 0x45, + 0x5f, 0x46, 0x49, 0x42, 0x5f, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x10, 0x80, 0x40, 0x12, 0x13, 0x0a, + 0x0d, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x4f, 0x46, 0x46, 0x4c, 0x4f, 0x41, 0x44, 0x10, 0x80, + 0x80, 0x01, 0x12, 0x10, 0x0a, 0x0a, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x50, + 0x10, 0x80, 0x80, 0x02, 0x2a, 0xd2, 0x03, 0x0a, 0x17, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, + 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, + 0x4c, 0x5f, 0x52, 0x45, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, + 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4b, 0x45, 0x52, 0x4e, 0x45, 0x4c, 0x10, + 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x42, 0x4f, + 0x4f, 0x54, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, + 0x5f, 0x53, 0x54, 0x41, 0x54, 0x49, 0x43, 0x10, 0x04, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x52, 0x4f, + 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x52, 0x41, 0x10, 0x09, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x52, + 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4d, 0x52, 0x54, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, + 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x5a, 0x45, 0x42, 0x52, 0x41, 0x10, 0x0b, + 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x42, 0x49, 0x52, + 0x44, 0x10, 0x0c, 0x12, 0x15, 0x0a, 0x11, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, + 0x44, 0x4e, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x44, 0x10, 0x0d, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, + 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x58, 0x4f, 0x52, 0x50, 0x10, 0x0e, 0x12, 0x10, 0x0a, + 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4e, 0x54, 0x4b, 0x10, 0x0f, 0x12, + 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x44, 0x48, 0x43, 0x50, + 0x10, 0x10, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4d, + 0x52, 0x54, 0x44, 0x10, 0x11, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, + 0x4c, 0x5f, 0x4b, 0x45, 0x45, 0x50, 0x41, 0x4c, 0x49, 0x56, 0x45, 0x44, 0x10, 0x12, 0x12, 0x12, + 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x42, 0x41, 0x42, 0x45, 0x4c, + 0x10, 0x2a, 0x12, 0x12, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4f, + 0x50, 0x45, 0x4e, 0x52, 0x10, 0x63, 0x12, 0x11, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, + 0x4f, 0x4c, 0x5f, 0x42, 0x47, 0x50, 0x10, 0xba, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x50, 0x52, 0x4f, + 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x49, 0x53, 0x49, 0x53, 0x10, 0xbb, 0x01, 0x12, 0x12, 0x0a, + 0x0d, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x4f, 0x53, 0x50, 0x46, 0x10, 0xbc, + 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x5f, 0x52, 0x49, + 0x50, 0x10, 0xbd, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, + 0x5f, 0x45, 0x49, 0x47, 0x52, 0x50, 0x10, 0xc0, 0x01, 0x2a, 0xf1, 0x01, 0x0a, 0x13, 0x4e, 0x65, + 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, + 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x49, 0x43, 0x41, + 0x53, 0x54, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4c, 0x4f, 0x43, + 0x41, 0x4c, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x52, 0x4f, + 0x41, 0x44, 0x43, 0x41, 0x53, 0x54, 0x10, 0x03, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x41, 0x4e, 0x59, 0x43, 0x41, 0x53, 0x54, 0x10, 0x04, 0x12, 0x12, 0x0a, 0x0e, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x4d, 0x55, 0x4c, 0x54, 0x49, 0x43, 0x41, 0x53, 0x54, 0x10, 0x05, 0x12, 0x12, + 0x0a, 0x0e, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4c, 0x41, 0x43, 0x4b, 0x48, 0x4f, 0x4c, 0x45, + 0x10, 0x06, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x52, 0x45, 0x41, + 0x43, 0x48, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x07, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x50, 0x52, 0x4f, 0x48, 0x49, 0x42, 0x49, 0x54, 0x10, 0x08, 0x12, 0x0e, 0x0a, 0x0a, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x54, 0x48, 0x52, 0x4f, 0x57, 0x10, 0x09, 0x12, 0x0c, 0x0a, 0x08, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x41, 0x54, 0x10, 0x0a, 0x12, 0x12, 0x0a, 0x0e, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x58, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x4c, 0x56, 0x45, 0x10, 0x0b, 0x2a, 0x61, 0x0a, + 0x16, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x69, + 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x41, 0x42, 0x4c, 0x45, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0d, 0x54, 0x41, 0x42, + 0x4c, 0x45, 0x5f, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x10, 0xfd, 0x01, 0x12, 0x0f, 0x0a, + 0x0a, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x4d, 0x41, 0x49, 0x4e, 0x10, 0xfe, 0x01, 0x12, 0x10, + 0x0a, 0x0b, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x4c, 0x4f, 0x43, 0x41, 0x4c, 0x10, 0xff, 0x01, + 0x2a, 0x6a, 0x0a, 0x0f, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x53, 0x63, + 0x6f, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x47, 0x4c, 0x4f, + 0x42, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0a, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, 0x53, + 0x49, 0x54, 0x45, 0x10, 0xc8, 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x53, 0x43, 0x4f, 0x50, 0x45, 0x5f, + 0x4c, 0x49, 0x4e, 0x4b, 0x10, 0xfd, 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x53, 0x43, 0x4f, 0x50, 0x45, + 0x5f, 0x48, 0x4f, 0x53, 0x54, 0x10, 0xfe, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x53, 0x43, 0x4f, 0x50, + 0x45, 0x5f, 0x4e, 0x4f, 0x57, 0x48, 0x45, 0x52, 0x45, 0x10, 0xff, 0x01, 0x2a, 0x78, 0x0a, 0x16, + 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x56, 0x4c, 0x41, 0x4e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x27, 0x0a, 0x23, 0x4e, 0x45, 0x54, 0x48, 0x45, 0x4c, + 0x50, 0x45, 0x52, 0x53, 0x5f, 0x56, 0x4c, 0x41, 0x4e, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, + 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x19, 0x0a, 0x13, 0x56, 0x4c, 0x41, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, + 0x38, 0x30, 0x32, 0x31, 0x5f, 0x51, 0x10, 0x80, 0x82, 0x02, 0x12, 0x1a, 0x0a, 0x14, 0x56, 0x4c, + 0x41, 0x4e, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x4f, 0x43, 0x4f, 0x4c, 0x38, 0x30, 0x32, 0x31, 0x5f, + 0x41, 0x44, 0x10, 0xa8, 0x91, 0x02, 0x2a, 0x53, 0x0a, 0x11, 0x4b, 0x75, 0x62, 0x65, 0x73, 0x70, + 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x12, 0x50, + 0x45, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, + 0x4e, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x53, 0x54, 0x41, 0x54, + 0x45, 0x5f, 0x55, 0x50, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x53, + 0x54, 0x41, 0x54, 0x45, 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x02, 0x2a, 0x88, 0x01, 0x0a, 0x12, + 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, + 0x65, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x44, 0x45, 0x46, + 0x41, 0x55, 0x4c, 0x54, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, + 0x5f, 0x43, 0x4d, 0x44, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x43, 0x4f, + 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x50, 0x4c, 0x41, 0x54, 0x46, 0x4f, 0x52, 0x4d, 0x10, 0x02, 0x12, + 0x13, 0x0a, 0x0f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, + 0x4f, 0x52, 0x10, 0x03, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x5f, 0x4d, + 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x46, 0x49, 0x47, 0x55, 0x52, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x04, 0x2a, 0x4b, 0x0a, 0x0f, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, + 0x6b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x0e, 0x4f, 0x50, 0x45, + 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, 0x48, 0x43, 0x50, 0x34, 0x10, 0x00, 0x12, 0x12, 0x0a, + 0x0e, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x44, 0x48, 0x43, 0x50, 0x36, 0x10, + 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x56, 0x49, + 0x50, 0x10, 0x02, 0x2a, 0x9b, 0x02, 0x0a, 0x13, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x4d, + 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x53, 0x74, 0x61, 0x67, 0x65, 0x12, 0x19, 0x0a, 0x15, 0x4d, + 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x55, 0x4e, 0x4b, + 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x19, 0x0a, 0x15, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, + 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x42, 0x4f, 0x4f, 0x54, 0x49, 0x4e, 0x47, 0x10, + 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, + 0x47, 0x45, 0x5f, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, + 0x1d, 0x0a, 0x19, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, + 0x5f, 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x03, 0x12, 0x19, + 0x0a, 0x15, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, + 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x43, + 0x48, 0x49, 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x52, 0x45, 0x42, 0x4f, 0x4f, + 0x54, 0x49, 0x4e, 0x47, 0x10, 0x05, 0x12, 0x1f, 0x0a, 0x1b, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, + 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x53, 0x48, 0x55, 0x54, 0x54, 0x49, 0x4e, 0x47, + 0x5f, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x06, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x43, 0x48, 0x49, + 0x4e, 0x45, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x45, 0x54, 0x54, 0x49, + 0x4e, 0x47, 0x10, 0x07, 0x12, 0x1b, 0x0a, 0x17, 0x4d, 0x41, 0x43, 0x48, 0x49, 0x4e, 0x45, 0x5f, + 0x53, 0x54, 0x41, 0x47, 0x45, 0x5f, 0x55, 0x50, 0x47, 0x52, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x10, + 0x08, 0x42, 0x4a, 0x5a, 0x48, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, + 0x73, 0x69, 0x64, 0x65, 0x72, 0x6f, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x74, 0x61, 0x6c, 0x6f, 0x73, + 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x72, 0x79, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -2058,33 +2400,38 @@ func file_resource_definitions_enums_enums_proto_rawDescGZIP() []byte { return file_resource_definitions_enums_enums_proto_rawDescData } -var file_resource_definitions_enums_enums_proto_enumTypes = make([]protoimpl.EnumInfo, 25) +var file_resource_definitions_enums_enums_proto_enumTypes = make([]protoimpl.EnumInfo, 30) var file_resource_definitions_enums_enums_proto_goTypes = []interface{}{ - (MachineType)(0), // 0: talos.resource.definitions.enums.MachineType - (NethelpersAddressFlag)(0), // 1: talos.resource.definitions.enums.NethelpersAddressFlag - (NethelpersADSelect)(0), // 2: talos.resource.definitions.enums.NethelpersADSelect - (NethelpersARPAllTargets)(0), // 3: talos.resource.definitions.enums.NethelpersARPAllTargets - (NethelpersARPValidate)(0), // 4: talos.resource.definitions.enums.NethelpersARPValidate - (NethelpersBondMode)(0), // 5: talos.resource.definitions.enums.NethelpersBondMode - (NethelpersBondXmitHashPolicy)(0), // 6: talos.resource.definitions.enums.NethelpersBondXmitHashPolicy - (NethelpersDuplex)(0), // 7: talos.resource.definitions.enums.NethelpersDuplex - (NethelpersFailOverMAC)(0), // 8: talos.resource.definitions.enums.NethelpersFailOverMAC - (NethelpersFamily)(0), // 9: talos.resource.definitions.enums.NethelpersFamily - (NethelpersLACPRate)(0), // 10: talos.resource.definitions.enums.NethelpersLACPRate - (NethelpersLinkType)(0), // 11: talos.resource.definitions.enums.NethelpersLinkType - (NethelpersOperationalState)(0), // 12: talos.resource.definitions.enums.NethelpersOperationalState - (NethelpersPort)(0), // 13: talos.resource.definitions.enums.NethelpersPort - (NethelpersPrimaryReselect)(0), // 14: talos.resource.definitions.enums.NethelpersPrimaryReselect - (NethelpersRouteFlag)(0), // 15: talos.resource.definitions.enums.NethelpersRouteFlag - (NethelpersRouteProtocol)(0), // 16: talos.resource.definitions.enums.NethelpersRouteProtocol - (NethelpersRouteType)(0), // 17: talos.resource.definitions.enums.NethelpersRouteType - (NethelpersRoutingTable)(0), // 18: talos.resource.definitions.enums.NethelpersRoutingTable - (NethelpersScope)(0), // 19: talos.resource.definitions.enums.NethelpersScope - (NethelpersVLANProtocol)(0), // 20: talos.resource.definitions.enums.NethelpersVLANProtocol - (KubespanPeerState)(0), // 21: talos.resource.definitions.enums.KubespanPeerState - (NetworkConfigLayer)(0), // 22: talos.resource.definitions.enums.NetworkConfigLayer - (NetworkOperator)(0), // 23: talos.resource.definitions.enums.NetworkOperator - (RuntimeMachineStage)(0), // 24: talos.resource.definitions.enums.RuntimeMachineStage + (MachineType)(0), // 0: talos.resource.definitions.enums.MachineType + (NethelpersAddressFlag)(0), // 1: talos.resource.definitions.enums.NethelpersAddressFlag + (NethelpersADSelect)(0), // 2: talos.resource.definitions.enums.NethelpersADSelect + (NethelpersARPAllTargets)(0), // 3: talos.resource.definitions.enums.NethelpersARPAllTargets + (NethelpersARPValidate)(0), // 4: talos.resource.definitions.enums.NethelpersARPValidate + (NethelpersBondMode)(0), // 5: talos.resource.definitions.enums.NethelpersBondMode + (NethelpersBondXmitHashPolicy)(0), // 6: talos.resource.definitions.enums.NethelpersBondXmitHashPolicy + (NethelpersDuplex)(0), // 7: talos.resource.definitions.enums.NethelpersDuplex + (NethelpersFailOverMAC)(0), // 8: talos.resource.definitions.enums.NethelpersFailOverMAC + (NethelpersFamily)(0), // 9: talos.resource.definitions.enums.NethelpersFamily + (NethelpersLACPRate)(0), // 10: talos.resource.definitions.enums.NethelpersLACPRate + (NethelpersLinkType)(0), // 11: talos.resource.definitions.enums.NethelpersLinkType + (NethelpersMatchOperator)(0), // 12: talos.resource.definitions.enums.NethelpersMatchOperator + (NethelpersNfTablesChainHook)(0), // 13: talos.resource.definitions.enums.NethelpersNfTablesChainHook + (NethelpersNfTablesChainPriority)(0), // 14: talos.resource.definitions.enums.NethelpersNfTablesChainPriority + (NethelpersNfTablesVerdict)(0), // 15: talos.resource.definitions.enums.NethelpersNfTablesVerdict + (NethelpersOperationalState)(0), // 16: talos.resource.definitions.enums.NethelpersOperationalState + (NethelpersPort)(0), // 17: talos.resource.definitions.enums.NethelpersPort + (NethelpersPrimaryReselect)(0), // 18: talos.resource.definitions.enums.NethelpersPrimaryReselect + (NethelpersProtocol)(0), // 19: talos.resource.definitions.enums.NethelpersProtocol + (NethelpersRouteFlag)(0), // 20: talos.resource.definitions.enums.NethelpersRouteFlag + (NethelpersRouteProtocol)(0), // 21: talos.resource.definitions.enums.NethelpersRouteProtocol + (NethelpersRouteType)(0), // 22: talos.resource.definitions.enums.NethelpersRouteType + (NethelpersRoutingTable)(0), // 23: talos.resource.definitions.enums.NethelpersRoutingTable + (NethelpersScope)(0), // 24: talos.resource.definitions.enums.NethelpersScope + (NethelpersVLANProtocol)(0), // 25: talos.resource.definitions.enums.NethelpersVLANProtocol + (KubespanPeerState)(0), // 26: talos.resource.definitions.enums.KubespanPeerState + (NetworkConfigLayer)(0), // 27: talos.resource.definitions.enums.NetworkConfigLayer + (NetworkOperator)(0), // 28: talos.resource.definitions.enums.NetworkOperator + (RuntimeMachineStage)(0), // 29: talos.resource.definitions.enums.RuntimeMachineStage } var file_resource_definitions_enums_enums_proto_depIdxs = []int32{ 0, // [0:0] is the sub-list for method output_type @@ -2104,7 +2451,7 @@ func file_resource_definitions_enums_enums_proto_init() { File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_resource_definitions_enums_enums_proto_rawDesc, - NumEnums: 25, + NumEnums: 30, NumMessages: 0, NumExtensions: 0, NumServices: 0, diff --git a/pkg/machinery/api/resource/definitions/network/network.pb.go b/pkg/machinery/api/resource/definitions/network/network.pb.go index 2c536e24cd..968a714c01 100644 --- a/pkg/machinery/api/resource/definitions/network/network.pb.go +++ b/pkg/machinery/api/resource/definitions/network/network.pb.go @@ -1401,6 +1401,544 @@ func (x *LinkStatusSpec) GetPermanentAddr() []byte { return nil } +// NfTablesAddressMatch describes the match on the IP address. +type NfTablesAddressMatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + IncludeSubnets []*common.NetIPPrefix `protobuf:"bytes,1,rep,name=include_subnets,json=includeSubnets,proto3" json:"include_subnets,omitempty"` + ExcludeSubnets []*common.NetIPPrefix `protobuf:"bytes,2,rep,name=exclude_subnets,json=excludeSubnets,proto3" json:"exclude_subnets,omitempty"` + Invert bool `protobuf:"varint,3,opt,name=invert,proto3" json:"invert,omitempty"` +} + +func (x *NfTablesAddressMatch) Reset() { + *x = NfTablesAddressMatch{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesAddressMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesAddressMatch) ProtoMessage() {} + +func (x *NfTablesAddressMatch) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesAddressMatch.ProtoReflect.Descriptor instead. +func (*NfTablesAddressMatch) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{14} +} + +func (x *NfTablesAddressMatch) GetIncludeSubnets() []*common.NetIPPrefix { + if x != nil { + return x.IncludeSubnets + } + return nil +} + +func (x *NfTablesAddressMatch) GetExcludeSubnets() []*common.NetIPPrefix { + if x != nil { + return x.ExcludeSubnets + } + return nil +} + +func (x *NfTablesAddressMatch) GetInvert() bool { + if x != nil { + return x.Invert + } + return false +} + +// NfTablesChainSpec describes status of rendered secrets. +type NfTablesChainSpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + Hook enums.NethelpersNfTablesChainHook `protobuf:"varint,2,opt,name=hook,proto3,enum=talos.resource.definitions.enums.NethelpersNfTablesChainHook" json:"hook,omitempty"` + Priority enums.NethelpersNfTablesChainPriority `protobuf:"varint,3,opt,name=priority,proto3,enum=talos.resource.definitions.enums.NethelpersNfTablesChainPriority" json:"priority,omitempty"` + Rules []*NfTablesRule `protobuf:"bytes,4,rep,name=rules,proto3" json:"rules,omitempty"` +} + +func (x *NfTablesChainSpec) Reset() { + *x = NfTablesChainSpec{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesChainSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesChainSpec) ProtoMessage() {} + +func (x *NfTablesChainSpec) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesChainSpec.ProtoReflect.Descriptor instead. +func (*NfTablesChainSpec) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{15} +} + +func (x *NfTablesChainSpec) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *NfTablesChainSpec) GetHook() enums.NethelpersNfTablesChainHook { + if x != nil { + return x.Hook + } + return enums.NethelpersNfTablesChainHook(0) +} + +func (x *NfTablesChainSpec) GetPriority() enums.NethelpersNfTablesChainPriority { + if x != nil { + return x.Priority + } + return enums.NethelpersNfTablesChainPriority(0) +} + +func (x *NfTablesChainSpec) GetRules() []*NfTablesRule { + if x != nil { + return x.Rules + } + return nil +} + +// NfTablesClampMSS describes the TCP MSS clamping operation. +// +// MSS is limited by the `MaxMTU` so that: +// - IPv4: MSS = MaxMTU - 40 +// - IPv6: MSS = MaxMTU - 60. +type NfTablesClampMSS struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Mtu uint32 `protobuf:"fixed32,1,opt,name=mtu,proto3" json:"mtu,omitempty"` +} + +func (x *NfTablesClampMSS) Reset() { + *x = NfTablesClampMSS{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesClampMSS) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesClampMSS) ProtoMessage() {} + +func (x *NfTablesClampMSS) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesClampMSS.ProtoReflect.Descriptor instead. +func (*NfTablesClampMSS) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{16} +} + +func (x *NfTablesClampMSS) GetMtu() uint32 { + if x != nil { + return x.Mtu + } + return 0 +} + +// NfTablesIfNameMatch describes the match on the interface name. +type NfTablesIfNameMatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + InterfaceName string `protobuf:"bytes,1,opt,name=interface_name,json=interfaceName,proto3" json:"interface_name,omitempty"` + Operator enums.NethelpersMatchOperator `protobuf:"varint,2,opt,name=operator,proto3,enum=talos.resource.definitions.enums.NethelpersMatchOperator" json:"operator,omitempty"` +} + +func (x *NfTablesIfNameMatch) Reset() { + *x = NfTablesIfNameMatch{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesIfNameMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesIfNameMatch) ProtoMessage() {} + +func (x *NfTablesIfNameMatch) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesIfNameMatch.ProtoReflect.Descriptor instead. +func (*NfTablesIfNameMatch) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{17} +} + +func (x *NfTablesIfNameMatch) GetInterfaceName() string { + if x != nil { + return x.InterfaceName + } + return "" +} + +func (x *NfTablesIfNameMatch) GetOperator() enums.NethelpersMatchOperator { + if x != nil { + return x.Operator + } + return enums.NethelpersMatchOperator(0) +} + +// NfTablesLayer4Match describes the match on the transport layer protocol. +type NfTablesLayer4Match struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Protocol enums.NethelpersProtocol `protobuf:"varint,1,opt,name=protocol,proto3,enum=talos.resource.definitions.enums.NethelpersProtocol" json:"protocol,omitempty"` + MatchSourcePort *NfTablesPortMatch `protobuf:"bytes,2,opt,name=match_source_port,json=matchSourcePort,proto3" json:"match_source_port,omitempty"` + MatchDestinationPort *NfTablesPortMatch `protobuf:"bytes,3,opt,name=match_destination_port,json=matchDestinationPort,proto3" json:"match_destination_port,omitempty"` +} + +func (x *NfTablesLayer4Match) Reset() { + *x = NfTablesLayer4Match{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesLayer4Match) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesLayer4Match) ProtoMessage() {} + +func (x *NfTablesLayer4Match) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesLayer4Match.ProtoReflect.Descriptor instead. +func (*NfTablesLayer4Match) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{18} +} + +func (x *NfTablesLayer4Match) GetProtocol() enums.NethelpersProtocol { + if x != nil { + return x.Protocol + } + return enums.NethelpersProtocol(0) +} + +func (x *NfTablesLayer4Match) GetMatchSourcePort() *NfTablesPortMatch { + if x != nil { + return x.MatchSourcePort + } + return nil +} + +func (x *NfTablesLayer4Match) GetMatchDestinationPort() *NfTablesPortMatch { + if x != nil { + return x.MatchDestinationPort + } + return nil +} + +// NfTablesMark encodes packet mark match/update operation. +// +// When used as a match computes the following condition: +// (mark & mask) ^ xor == value +// +// When used as an update computes the following operation: +// mark = (mark & mask) ^ xor. +type NfTablesMark struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Mask uint32 `protobuf:"varint,1,opt,name=mask,proto3" json:"mask,omitempty"` + Xor uint32 `protobuf:"varint,2,opt,name=xor,proto3" json:"xor,omitempty"` + Value uint32 `protobuf:"varint,3,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *NfTablesMark) Reset() { + *x = NfTablesMark{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesMark) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesMark) ProtoMessage() {} + +func (x *NfTablesMark) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesMark.ProtoReflect.Descriptor instead. +func (*NfTablesMark) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{19} +} + +func (x *NfTablesMark) GetMask() uint32 { + if x != nil { + return x.Mask + } + return 0 +} + +func (x *NfTablesMark) GetXor() uint32 { + if x != nil { + return x.Xor + } + return 0 +} + +func (x *NfTablesMark) GetValue() uint32 { + if x != nil { + return x.Value + } + return 0 +} + +// NfTablesPortMatch describes the match on the transport layer port. +type NfTablesPortMatch struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ranges []*PortRange `protobuf:"bytes,1,rep,name=ranges,proto3" json:"ranges,omitempty"` +} + +func (x *NfTablesPortMatch) Reset() { + *x = NfTablesPortMatch{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesPortMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesPortMatch) ProtoMessage() {} + +func (x *NfTablesPortMatch) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesPortMatch.ProtoReflect.Descriptor instead. +func (*NfTablesPortMatch) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{20} +} + +func (x *NfTablesPortMatch) GetRanges() []*PortRange { + if x != nil { + return x.Ranges + } + return nil +} + +// NfTablesRule describes a single rule in the nftables chain. +type NfTablesRule struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + MatchOIfName *NfTablesIfNameMatch `protobuf:"bytes,1,opt,name=match_o_if_name,json=matchOIfName,proto3" json:"match_o_if_name,omitempty"` + Verdict enums.NethelpersNfTablesVerdict `protobuf:"varint,2,opt,name=verdict,proto3,enum=talos.resource.definitions.enums.NethelpersNfTablesVerdict" json:"verdict,omitempty"` + MatchMark *NfTablesMark `protobuf:"bytes,3,opt,name=match_mark,json=matchMark,proto3" json:"match_mark,omitempty"` + SetMark *NfTablesMark `protobuf:"bytes,4,opt,name=set_mark,json=setMark,proto3" json:"set_mark,omitempty"` + MatchSourceAddress *NfTablesAddressMatch `protobuf:"bytes,5,opt,name=match_source_address,json=matchSourceAddress,proto3" json:"match_source_address,omitempty"` + MatchDestinationAddress *NfTablesAddressMatch `protobuf:"bytes,6,opt,name=match_destination_address,json=matchDestinationAddress,proto3" json:"match_destination_address,omitempty"` + MatchLayer4 *NfTablesLayer4Match `protobuf:"bytes,7,opt,name=match_layer4,json=matchLayer4,proto3" json:"match_layer4,omitempty"` + MatchIIfName *NfTablesIfNameMatch `protobuf:"bytes,8,opt,name=match_i_if_name,json=matchIIfName,proto3" json:"match_i_if_name,omitempty"` + ClampMss *NfTablesClampMSS `protobuf:"bytes,9,opt,name=clamp_mss,json=clampMss,proto3" json:"clamp_mss,omitempty"` +} + +func (x *NfTablesRule) Reset() { + *x = NfTablesRule{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NfTablesRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NfTablesRule) ProtoMessage() {} + +func (x *NfTablesRule) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NfTablesRule.ProtoReflect.Descriptor instead. +func (*NfTablesRule) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{21} +} + +func (x *NfTablesRule) GetMatchOIfName() *NfTablesIfNameMatch { + if x != nil { + return x.MatchOIfName + } + return nil +} + +func (x *NfTablesRule) GetVerdict() enums.NethelpersNfTablesVerdict { + if x != nil { + return x.Verdict + } + return enums.NethelpersNfTablesVerdict(0) +} + +func (x *NfTablesRule) GetMatchMark() *NfTablesMark { + if x != nil { + return x.MatchMark + } + return nil +} + +func (x *NfTablesRule) GetSetMark() *NfTablesMark { + if x != nil { + return x.SetMark + } + return nil +} + +func (x *NfTablesRule) GetMatchSourceAddress() *NfTablesAddressMatch { + if x != nil { + return x.MatchSourceAddress + } + return nil +} + +func (x *NfTablesRule) GetMatchDestinationAddress() *NfTablesAddressMatch { + if x != nil { + return x.MatchDestinationAddress + } + return nil +} + +func (x *NfTablesRule) GetMatchLayer4() *NfTablesLayer4Match { + if x != nil { + return x.MatchLayer4 + } + return nil +} + +func (x *NfTablesRule) GetMatchIIfName() *NfTablesIfNameMatch { + if x != nil { + return x.MatchIIfName + } + return nil +} + +func (x *NfTablesRule) GetClampMss() *NfTablesClampMSS { + if x != nil { + return x.ClampMss + } + return nil +} + // NodeAddressFilterSpec describes a filter for NodeAddresses. type NodeAddressFilterSpec struct { state protoimpl.MessageState @@ -1414,7 +1952,7 @@ type NodeAddressFilterSpec struct { func (x *NodeAddressFilterSpec) Reset() { *x = NodeAddressFilterSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[14] + mi := &file_resource_definitions_network_network_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1427,7 +1965,7 @@ func (x *NodeAddressFilterSpec) String() string { func (*NodeAddressFilterSpec) ProtoMessage() {} func (x *NodeAddressFilterSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[14] + mi := &file_resource_definitions_network_network_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1440,7 +1978,7 @@ func (x *NodeAddressFilterSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeAddressFilterSpec.ProtoReflect.Descriptor instead. func (*NodeAddressFilterSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{14} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{22} } func (x *NodeAddressFilterSpec) GetIncludeSubnets() []*common.NetIPPrefix { @@ -1469,7 +2007,7 @@ type NodeAddressSpec struct { func (x *NodeAddressSpec) Reset() { *x = NodeAddressSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[15] + mi := &file_resource_definitions_network_network_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1482,7 +2020,7 @@ func (x *NodeAddressSpec) String() string { func (*NodeAddressSpec) ProtoMessage() {} func (x *NodeAddressSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[15] + mi := &file_resource_definitions_network_network_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1495,7 +2033,7 @@ func (x *NodeAddressSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeAddressSpec.ProtoReflect.Descriptor instead. func (*NodeAddressSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{15} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{23} } func (x *NodeAddressSpec) GetAddresses() []*common.NetIPPrefix { @@ -1523,7 +2061,7 @@ type OperatorSpecSpec struct { func (x *OperatorSpecSpec) Reset() { *x = OperatorSpecSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[16] + mi := &file_resource_definitions_network_network_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1536,7 +2074,7 @@ func (x *OperatorSpecSpec) String() string { func (*OperatorSpecSpec) ProtoMessage() {} func (x *OperatorSpecSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[16] + mi := &file_resource_definitions_network_network_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1549,7 +2087,7 @@ func (x *OperatorSpecSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatorSpecSpec.ProtoReflect.Descriptor instead. func (*OperatorSpecSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{16} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{24} } func (x *OperatorSpecSpec) GetOperator() enums.NetworkOperator { @@ -1601,6 +2139,64 @@ func (x *OperatorSpecSpec) GetConfigLayer() enums.NetworkConfigLayer { return enums.NetworkConfigLayer(0) } +// PortRange describes a range of ports. +// +// Range is [lo, hi]. +type PortRange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Lo uint32 `protobuf:"fixed32,1,opt,name=lo,proto3" json:"lo,omitempty"` + Hi uint32 `protobuf:"fixed32,2,opt,name=hi,proto3" json:"hi,omitempty"` +} + +func (x *PortRange) Reset() { + *x = PortRange{} + if protoimpl.UnsafeEnabled { + mi := &file_resource_definitions_network_network_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PortRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PortRange) ProtoMessage() {} + +func (x *PortRange) ProtoReflect() protoreflect.Message { + mi := &file_resource_definitions_network_network_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PortRange.ProtoReflect.Descriptor instead. +func (*PortRange) Descriptor() ([]byte, []int) { + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{25} +} + +func (x *PortRange) GetLo() uint32 { + if x != nil { + return x.Lo + } + return 0 +} + +func (x *PortRange) GetHi() uint32 { + if x != nil { + return x.Hi + } + return 0 +} + // ProbeSpecSpec describes the Probe. type ProbeSpecSpec struct { state protoimpl.MessageState @@ -1616,7 +2212,7 @@ type ProbeSpecSpec struct { func (x *ProbeSpecSpec) Reset() { *x = ProbeSpecSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[17] + mi := &file_resource_definitions_network_network_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1629,7 +2225,7 @@ func (x *ProbeSpecSpec) String() string { func (*ProbeSpecSpec) ProtoMessage() {} func (x *ProbeSpecSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[17] + mi := &file_resource_definitions_network_network_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1642,7 +2238,7 @@ func (x *ProbeSpecSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use ProbeSpecSpec.ProtoReflect.Descriptor instead. func (*ProbeSpecSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{17} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{26} } func (x *ProbeSpecSpec) GetInterval() *durationpb.Duration { @@ -1686,7 +2282,7 @@ type ProbeStatusSpec struct { func (x *ProbeStatusSpec) Reset() { *x = ProbeStatusSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[18] + mi := &file_resource_definitions_network_network_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1699,7 +2295,7 @@ func (x *ProbeStatusSpec) String() string { func (*ProbeStatusSpec) ProtoMessage() {} func (x *ProbeStatusSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[18] + mi := &file_resource_definitions_network_network_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1712,7 +2308,7 @@ func (x *ProbeStatusSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use ProbeStatusSpec.ProtoReflect.Descriptor instead. func (*ProbeStatusSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{18} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{27} } func (x *ProbeStatusSpec) GetSuccess() bool { @@ -1742,7 +2338,7 @@ type ResolverSpecSpec struct { func (x *ResolverSpecSpec) Reset() { *x = ResolverSpecSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[19] + mi := &file_resource_definitions_network_network_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1755,7 +2351,7 @@ func (x *ResolverSpecSpec) String() string { func (*ResolverSpecSpec) ProtoMessage() {} func (x *ResolverSpecSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[19] + mi := &file_resource_definitions_network_network_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1768,7 +2364,7 @@ func (x *ResolverSpecSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolverSpecSpec.ProtoReflect.Descriptor instead. func (*ResolverSpecSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{19} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{28} } func (x *ResolverSpecSpec) GetDnsServers() []*common.NetIP { @@ -1797,7 +2393,7 @@ type ResolverStatusSpec struct { func (x *ResolverStatusSpec) Reset() { *x = ResolverStatusSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[20] + mi := &file_resource_definitions_network_network_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1810,7 +2406,7 @@ func (x *ResolverStatusSpec) String() string { func (*ResolverStatusSpec) ProtoMessage() {} func (x *ResolverStatusSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[20] + mi := &file_resource_definitions_network_network_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1823,7 +2419,7 @@ func (x *ResolverStatusSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolverStatusSpec.ProtoReflect.Descriptor instead. func (*ResolverStatusSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{20} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{29} } func (x *ResolverStatusSpec) GetDnsServers() []*common.NetIP { @@ -1857,7 +2453,7 @@ type RouteSpecSpec struct { func (x *RouteSpecSpec) Reset() { *x = RouteSpecSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[21] + mi := &file_resource_definitions_network_network_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1870,7 +2466,7 @@ func (x *RouteSpecSpec) String() string { func (*RouteSpecSpec) ProtoMessage() {} func (x *RouteSpecSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[21] + mi := &file_resource_definitions_network_network_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1883,7 +2479,7 @@ func (x *RouteSpecSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use RouteSpecSpec.ProtoReflect.Descriptor instead. func (*RouteSpecSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{21} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{30} } func (x *RouteSpecSpec) GetFamily() enums.NethelpersFamily { @@ -2001,7 +2597,7 @@ type RouteStatusSpec struct { func (x *RouteStatusSpec) Reset() { *x = RouteStatusSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[22] + mi := &file_resource_definitions_network_network_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2014,7 +2610,7 @@ func (x *RouteStatusSpec) String() string { func (*RouteStatusSpec) ProtoMessage() {} func (x *RouteStatusSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[22] + mi := &file_resource_definitions_network_network_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2027,7 +2623,7 @@ func (x *RouteStatusSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use RouteStatusSpec.ProtoReflect.Descriptor instead. func (*RouteStatusSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{22} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{31} } func (x *RouteStatusSpec) GetFamily() enums.NethelpersFamily { @@ -2133,7 +2729,7 @@ type STPSpec struct { func (x *STPSpec) Reset() { *x = STPSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[23] + mi := &file_resource_definitions_network_network_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2146,7 +2742,7 @@ func (x *STPSpec) String() string { func (*STPSpec) ProtoMessage() {} func (x *STPSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[23] + mi := &file_resource_definitions_network_network_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2159,7 +2755,7 @@ func (x *STPSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use STPSpec.ProtoReflect.Descriptor instead. func (*STPSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{23} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{32} } func (x *STPSpec) GetEnabled() bool { @@ -2184,7 +2780,7 @@ type StatusSpec struct { func (x *StatusSpec) Reset() { *x = StatusSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[24] + mi := &file_resource_definitions_network_network_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2197,7 +2793,7 @@ func (x *StatusSpec) String() string { func (*StatusSpec) ProtoMessage() {} func (x *StatusSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[24] + mi := &file_resource_definitions_network_network_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2210,7 +2806,7 @@ func (x *StatusSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use StatusSpec.ProtoReflect.Descriptor instead. func (*StatusSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{24} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{33} } func (x *StatusSpec) GetAddressReady() bool { @@ -2254,7 +2850,7 @@ type TCPProbeSpec struct { func (x *TCPProbeSpec) Reset() { *x = TCPProbeSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[25] + mi := &file_resource_definitions_network_network_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2267,7 +2863,7 @@ func (x *TCPProbeSpec) String() string { func (*TCPProbeSpec) ProtoMessage() {} func (x *TCPProbeSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[25] + mi := &file_resource_definitions_network_network_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2280,7 +2876,7 @@ func (x *TCPProbeSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use TCPProbeSpec.ProtoReflect.Descriptor instead. func (*TCPProbeSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{25} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{34} } func (x *TCPProbeSpec) GetEndpoint() string { @@ -2310,7 +2906,7 @@ type TimeServerSpecSpec struct { func (x *TimeServerSpecSpec) Reset() { *x = TimeServerSpecSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[26] + mi := &file_resource_definitions_network_network_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2323,7 +2919,7 @@ func (x *TimeServerSpecSpec) String() string { func (*TimeServerSpecSpec) ProtoMessage() {} func (x *TimeServerSpecSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[26] + mi := &file_resource_definitions_network_network_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2336,7 +2932,7 @@ func (x *TimeServerSpecSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use TimeServerSpecSpec.ProtoReflect.Descriptor instead. func (*TimeServerSpecSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{26} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{35} } func (x *TimeServerSpecSpec) GetNtpServers() []string { @@ -2365,7 +2961,7 @@ type TimeServerStatusSpec struct { func (x *TimeServerStatusSpec) Reset() { *x = TimeServerStatusSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[27] + mi := &file_resource_definitions_network_network_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2378,7 +2974,7 @@ func (x *TimeServerStatusSpec) String() string { func (*TimeServerStatusSpec) ProtoMessage() {} func (x *TimeServerStatusSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[27] + mi := &file_resource_definitions_network_network_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2391,7 +2987,7 @@ func (x *TimeServerStatusSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use TimeServerStatusSpec.ProtoReflect.Descriptor instead. func (*TimeServerStatusSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{27} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{36} } func (x *TimeServerStatusSpec) GetNtpServers() []string { @@ -2415,7 +3011,7 @@ type VIPEquinixMetalSpec struct { func (x *VIPEquinixMetalSpec) Reset() { *x = VIPEquinixMetalSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[28] + mi := &file_resource_definitions_network_network_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2428,7 +3024,7 @@ func (x *VIPEquinixMetalSpec) String() string { func (*VIPEquinixMetalSpec) ProtoMessage() {} func (x *VIPEquinixMetalSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[28] + mi := &file_resource_definitions_network_network_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2441,7 +3037,7 @@ func (x *VIPEquinixMetalSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use VIPEquinixMetalSpec.ProtoReflect.Descriptor instead. func (*VIPEquinixMetalSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{28} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{37} } func (x *VIPEquinixMetalSpec) GetProjectId() string { @@ -2479,7 +3075,7 @@ type VIPHCloudSpec struct { func (x *VIPHCloudSpec) Reset() { *x = VIPHCloudSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[29] + mi := &file_resource_definitions_network_network_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2492,7 +3088,7 @@ func (x *VIPHCloudSpec) String() string { func (*VIPHCloudSpec) ProtoMessage() {} func (x *VIPHCloudSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[29] + mi := &file_resource_definitions_network_network_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2505,7 +3101,7 @@ func (x *VIPHCloudSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use VIPHCloudSpec.ProtoReflect.Descriptor instead. func (*VIPHCloudSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{29} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{38} } func (x *VIPHCloudSpec) GetDeviceId() int64 { @@ -2544,7 +3140,7 @@ type VIPOperatorSpec struct { func (x *VIPOperatorSpec) Reset() { *x = VIPOperatorSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[30] + mi := &file_resource_definitions_network_network_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2557,7 +3153,7 @@ func (x *VIPOperatorSpec) String() string { func (*VIPOperatorSpec) ProtoMessage() {} func (x *VIPOperatorSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[30] + mi := &file_resource_definitions_network_network_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2570,7 +3166,7 @@ func (x *VIPOperatorSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use VIPOperatorSpec.ProtoReflect.Descriptor instead. func (*VIPOperatorSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{30} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{39} } func (x *VIPOperatorSpec) GetIp() *common.NetIP { @@ -2614,7 +3210,7 @@ type VLANSpec struct { func (x *VLANSpec) Reset() { *x = VLANSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[31] + mi := &file_resource_definitions_network_network_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2627,7 +3223,7 @@ func (x *VLANSpec) String() string { func (*VLANSpec) ProtoMessage() {} func (x *VLANSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[31] + mi := &file_resource_definitions_network_network_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2640,7 +3236,7 @@ func (x *VLANSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use VLANSpec.ProtoReflect.Descriptor instead. func (*VLANSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{31} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{40} } func (x *VLANSpec) GetVid() uint32 { @@ -2673,7 +3269,7 @@ type WireguardPeer struct { func (x *WireguardPeer) Reset() { *x = WireguardPeer{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[32] + mi := &file_resource_definitions_network_network_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2686,7 +3282,7 @@ func (x *WireguardPeer) String() string { func (*WireguardPeer) ProtoMessage() {} func (x *WireguardPeer) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[32] + mi := &file_resource_definitions_network_network_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2699,7 +3295,7 @@ func (x *WireguardPeer) ProtoReflect() protoreflect.Message { // Deprecated: Use WireguardPeer.ProtoReflect.Descriptor instead. func (*WireguardPeer) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{32} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{41} } func (x *WireguardPeer) GetPublicKey() string { @@ -2753,7 +3349,7 @@ type WireguardSpec struct { func (x *WireguardSpec) Reset() { *x = WireguardSpec{} if protoimpl.UnsafeEnabled { - mi := &file_resource_definitions_network_network_proto_msgTypes[33] + mi := &file_resource_definitions_network_network_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2766,7 +3362,7 @@ func (x *WireguardSpec) String() string { func (*WireguardSpec) ProtoMessage() {} func (x *WireguardSpec) ProtoReflect() protoreflect.Message { - mi := &file_resource_definitions_network_network_proto_msgTypes[33] + mi := &file_resource_definitions_network_network_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2779,7 +3375,7 @@ func (x *WireguardSpec) ProtoReflect() protoreflect.Message { // Deprecated: Use WireguardSpec.ProtoReflect.Descriptor instead. func (*WireguardSpec) Descriptor() ([]byte, []int) { - return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{33} + return file_resource_definitions_network_network_proto_rawDescGZIP(), []int{42} } func (x *WireguardSpec) GetPrivateKey() string { @@ -3152,133 +3748,214 @@ var file_resource_definitions_network_network_proto_rawDesc = []byte{ 0x09, 0x77, 0x69, 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x70, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x72, 0x6d, 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, - 0x72, 0x22, 0x93, 0x01, 0x0a, 0x15, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, 0x3c, 0x0a, 0x0f, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, - 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, - 0x64, 0x65, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x3c, 0x0a, 0x0f, 0x65, 0x78, 0x63, - 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, - 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, - 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x22, 0x44, 0x0a, 0x0f, 0x4e, 0x6f, 0x64, 0x65, 0x41, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, 0x31, 0x0a, 0x09, 0x61, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, - 0x69, 0x78, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x22, 0xd7, 0x03, - 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, - 0x65, 0x63, 0x12, 0x4d, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4f, - 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, - 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x69, 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, - 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x5f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x55, 0x70, 0x12, 0x4b, 0x0a, - 0x05, 0x64, 0x68, 0x63, 0x70, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x74, + 0x72, 0x22, 0xaa, 0x01, 0x0a, 0x14, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x3c, 0x0a, 0x0f, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, + 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x3c, 0x0a, 0x0f, 0x65, 0x78, 0x63, 0x6c, + 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, + 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0e, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x53, + 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x74, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x6e, 0x76, 0x65, 0x72, 0x74, 0x22, 0xa1, + 0x02, 0x0a, 0x11, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x68, 0x61, 0x69, 0x6e, + 0x53, 0x70, 0x65, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x51, 0x0a, 0x04, 0x68, 0x6f, 0x6f, 0x6b, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3d, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, + 0x70, 0x65, 0x72, 0x73, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x68, 0x61, 0x69, + 0x6e, 0x48, 0x6f, 0x6f, 0x6b, 0x52, 0x04, 0x68, 0x6f, 0x6f, 0x6b, 0x12, 0x5d, 0x0a, 0x08, 0x70, + 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x41, 0x2e, + 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, + 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x4e, 0x66, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, + 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x46, 0x0a, 0x05, 0x72, 0x75, + 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x74, 0x61, 0x6c, 0x6f, + 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x4e, + 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05, 0x72, 0x75, 0x6c, + 0x65, 0x73, 0x22, 0x24, 0x0a, 0x10, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6c, + 0x61, 0x6d, 0x70, 0x4d, 0x53, 0x53, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x74, 0x75, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x07, 0x52, 0x03, 0x6d, 0x74, 0x75, 0x22, 0x93, 0x01, 0x0a, 0x13, 0x4e, 0x66, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x49, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, + 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x55, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x74, 0x61, 0x6c, 0x6f, + 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, + 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x22, 0xb7, + 0x02, 0x0a, 0x13, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x4c, 0x61, 0x79, 0x65, 0x72, + 0x34, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x50, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, + 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, + 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x08, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x61, 0x0a, 0x11, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, + 0x73, 0x50, 0x6f, 0x72, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x52, 0x0f, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x6b, 0x0a, 0x16, 0x6d, + 0x61, 0x74, 0x63, 0x68, 0x5f, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x74, 0x61, + 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, + 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x50, 0x6f, 0x72, 0x74, 0x4d, 0x61, 0x74, + 0x63, 0x68, 0x52, 0x14, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x6f, 0x72, 0x74, 0x22, 0x4a, 0x0a, 0x0c, 0x4e, 0x66, 0x54, 0x61, + 0x62, 0x6c, 0x65, 0x73, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x61, 0x73, 0x6b, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x6d, 0x61, 0x73, 0x6b, 0x12, 0x10, 0x0a, 0x03, + 0x78, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x78, 0x6f, 0x72, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x5a, 0x0a, 0x11, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, + 0x50, 0x6f, 0x72, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x45, 0x0a, 0x06, 0x72, 0x61, 0x6e, + 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x74, 0x61, 0x6c, 0x6f, + 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x50, + 0x6f, 0x72, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x22, 0xd4, 0x06, 0x0a, 0x0c, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x52, 0x75, 0x6c, + 0x65, 0x12, 0x5e, 0x0a, 0x0f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6f, 0x5f, 0x69, 0x66, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, + 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x49, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x4d, 0x61, + 0x74, 0x63, 0x68, 0x52, 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x49, 0x66, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x55, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x3b, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, + 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x56, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x52, + 0x07, 0x76, 0x65, 0x72, 0x64, 0x69, 0x63, 0x74, 0x12, 0x4f, 0x0a, 0x0a, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, - 0x6b, 0x2e, 0x44, 0x48, 0x43, 0x50, 0x34, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, - 0x70, 0x65, 0x63, 0x52, 0x05, 0x64, 0x68, 0x63, 0x70, 0x34, 0x12, 0x4b, 0x0a, 0x05, 0x64, 0x68, - 0x63, 0x70, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, - 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x44, - 0x48, 0x43, 0x50, 0x36, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, - 0x52, 0x05, 0x64, 0x68, 0x63, 0x70, 0x36, 0x12, 0x45, 0x0a, 0x03, 0x76, 0x69, 0x70, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, + 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x4d, 0x61, 0x72, 0x6b, 0x52, 0x09, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x4b, 0x0a, 0x08, 0x73, 0x65, 0x74, + 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x74, 0x61, + 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, + 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x4d, 0x61, 0x72, 0x6b, 0x52, 0x07, 0x73, + 0x65, 0x74, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x6a, 0x0a, 0x14, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x56, 0x49, 0x50, 0x4f, 0x70, 0x65, - 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x52, 0x03, 0x76, 0x69, 0x70, 0x12, 0x57, - 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x07, + 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x52, 0x12, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x74, 0x0a, 0x19, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x64, 0x65, 0x73, 0x74, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, + 0x6c, 0x65, 0x73, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x52, + 0x17, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x5a, 0x0a, 0x0c, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, + 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, + 0x6f, 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x4c, 0x61, 0x79, 0x65, + 0x72, 0x34, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x52, 0x0b, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x61, + 0x79, 0x65, 0x72, 0x34, 0x12, 0x5e, 0x0a, 0x0f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x69, 0x5f, + 0x69, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, + 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, + 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x73, 0x49, 0x66, 0x4e, 0x61, 0x6d, + 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x52, 0x0c, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x49, 0x49, 0x66, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x51, 0x0a, 0x09, 0x63, 0x6c, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x73, + 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x4e, 0x66, 0x54, + 0x61, 0x62, 0x6c, 0x65, 0x73, 0x43, 0x6c, 0x61, 0x6d, 0x70, 0x4d, 0x53, 0x53, 0x52, 0x08, 0x63, + 0x6c, 0x61, 0x6d, 0x70, 0x4d, 0x73, 0x73, 0x22, 0x93, 0x01, 0x0a, 0x15, 0x4e, 0x6f, 0x64, 0x65, + 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x53, 0x70, 0x65, + 0x63, 0x12, 0x3c, 0x0a, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, + 0x6e, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, + 0x0e, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x12, + 0x3c, 0x0a, 0x0f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x73, 0x75, 0x62, 0x6e, 0x65, + 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0e, 0x65, + 0x78, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x73, 0x22, 0x44, 0x0a, + 0x0f, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x70, 0x65, 0x63, + 0x12, 0x31, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, + 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x65, 0x73, 0x22, 0xd7, 0x03, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x4d, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x69, 0x6e, 0x6b, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x5f, + 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, + 0x65, 0x55, 0x70, 0x12, 0x4b, 0x0a, 0x05, 0x64, 0x68, 0x63, 0x70, 0x34, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x44, 0x48, 0x43, 0x50, 0x34, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x52, 0x05, 0x64, 0x68, 0x63, 0x70, 0x34, + 0x12, 0x4b, 0x0a, 0x05, 0x64, 0x68, 0x63, 0x70, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, + 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x44, 0x48, 0x43, 0x50, 0x36, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x52, 0x05, 0x64, 0x68, 0x63, 0x70, 0x36, 0x12, 0x45, 0x0a, + 0x03, 0x76, 0x69, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, + 0x56, 0x49, 0x50, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x03, 0x76, 0x69, 0x70, 0x12, 0x57, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, + 0x61, 0x79, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, + 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x2b, 0x0a, + 0x09, 0x50, 0x6f, 0x72, 0x74, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x6c, 0x6f, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x6c, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x68, 0x69, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x07, 0x52, 0x02, 0x68, 0x69, 0x22, 0x90, 0x02, 0x0a, 0x0d, 0x50, + 0x72, 0x6f, 0x62, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x35, 0x0a, 0x08, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x76, 0x61, 0x6c, 0x12, 0x2b, 0x0a, 0x11, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x74, + 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, + 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, + 0x12, 0x42, 0x0a, 0x03, 0x74, 0x63, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, + 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, + 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, + 0x72, 0x6b, 0x2e, 0x54, 0x43, 0x50, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x03, 0x74, 0x63, 0x70, 0x12, 0x57, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, + 0x61, 0x79, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, + 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x4a, 0x0a, + 0x0f, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, + 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x61, + 0x73, 0x74, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x6c, 0x61, 0x73, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x9b, 0x01, 0x0a, 0x10, 0x52, 0x65, + 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, + 0x0a, 0x0b, 0x64, 0x6e, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, + 0x49, 0x50, 0x52, 0x0a, 0x64, 0x6e, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x57, + 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x90, 0x02, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x62, - 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x35, 0x0a, 0x08, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, - 0x12, 0x2b, 0x0a, 0x11, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x74, 0x68, 0x72, 0x65, - 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x66, 0x61, 0x69, - 0x6c, 0x75, 0x72, 0x65, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x42, 0x0a, - 0x03, 0x74, 0x63, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x74, 0x61, 0x6c, - 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, - 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, - 0x54, 0x43, 0x50, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x53, 0x70, 0x65, 0x63, 0x52, 0x03, 0x74, 0x63, - 0x70, 0x12, 0x57, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, - 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, - 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, - 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x4a, 0x0a, 0x0f, 0x50, 0x72, - 0x6f, 0x62, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, 0x18, 0x0a, - 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, - 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x61, 0x73, 0x74, 0x5f, - 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6c, 0x61, 0x73, - 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x9b, 0x01, 0x0a, 0x10, 0x52, 0x65, 0x73, 0x6f, 0x6c, - 0x76, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x0b, 0x64, - 0x6e, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, - 0x0a, 0x64, 0x6e, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x57, 0x0a, 0x0c, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, - 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, - 0x61, 0x79, 0x65, 0x72, 0x22, 0x44, 0x0a, 0x12, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x72, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x0b, 0x64, 0x6e, - 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x0a, - 0x64, 0x6e, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x22, 0xde, 0x05, 0x0a, 0x0d, 0x52, - 0x6f, 0x75, 0x74, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x4a, 0x0a, 0x06, - 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x32, 0x2e, 0x74, - 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, - 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, - 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, - 0x52, 0x06, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x35, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, - 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, - 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, - 0x69, 0x78, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x25, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x06, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x07, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, - 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x07, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x12, - 0x22, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, - 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, - 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x05, 0x74, 0x61, - 0x62, 0x6c, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, - 0x47, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, - 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, - 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, - 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x53, 0x63, 0x6f, 0x70, - 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x49, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, - 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, - 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x55, 0x0a, 0x08, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x74, 0x61, - 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, - 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x50, 0x72, - 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, - 0x12, 0x57, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, - 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, - 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x74, 0x75, - 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6d, 0x74, 0x75, 0x22, 0xad, 0x05, 0x0a, 0x0f, - 0x52, 0x6f, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x44, 0x0a, 0x12, 0x52, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, + 0x0b, 0x64, 0x6e, 0x73, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, + 0x50, 0x52, 0x0a, 0x64, 0x6e, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x22, 0xde, 0x05, + 0x0a, 0x0d, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x4a, 0x0a, 0x06, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x32, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, @@ -3292,140 +3969,186 @@ var file_resource_definitions_network_network_proto_rawDesc = []byte{ 0x50, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x07, 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x07, 0x67, 0x61, 0x74, 0x65, 0x77, - 0x61, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6f, 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6f, 0x75, 0x74, 0x4c, - 0x69, 0x6e, 0x6b, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x5f, - 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0b, 0x6f, 0x75, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x05, - 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x74, 0x61, - 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, - 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, - 0x54, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x1a, 0x0a, 0x08, - 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, - 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x47, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, - 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, + 0x61, 0x79, 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x4c, 0x69, + 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, + 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x52, + 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, + 0x74, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, + 0x74, 0x79, 0x12, 0x47, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, + 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x53, + 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x49, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, + 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, + 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x55, 0x0a, 0x08, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, + 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, + 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, + 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x12, 0x57, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, + 0x79, 0x65, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, + 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, + 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, + 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03, + 0x6d, 0x74, 0x75, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6d, 0x74, 0x75, 0x22, 0xad, + 0x05, 0x0a, 0x0f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, + 0x65, 0x63, 0x12, 0x4a, 0x0a, 0x06, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x32, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, + 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x52, 0x06, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x35, + 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, + 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, + 0x65, 0x74, 0x49, 0x50, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x07, + 0x67, 0x61, 0x74, 0x65, 0x77, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x07, 0x67, 0x61, + 0x74, 0x65, 0x77, 0x61, 0x79, 0x12, 0x24, 0x0a, 0x0e, 0x6f, 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x6e, + 0x6b, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6f, + 0x75, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x6f, + 0x75, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x6b, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x4e, 0x0a, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, + 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, + 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, + 0x69, 0x6e, 0x67, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x05, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x12, + 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x47, 0x0a, 0x05, 0x73, + 0x63, 0x6f, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, + 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, + 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, + 0x63, 0x6f, 0x70, 0x65, 0x12, 0x49, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, + 0x52, 0x6f, 0x75, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, + 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x55, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, + 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, - 0x6c, 0x70, 0x65, 0x72, 0x73, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, - 0x65, 0x12, 0x49, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x35, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, - 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, - 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, - 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x66, 0x6c, 0x61, - 0x67, 0x73, 0x12, 0x55, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x0c, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, + 0x6c, 0x70, 0x65, 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x10, 0x0a, 0x03, + 0x6d, 0x74, 0x75, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6d, 0x74, 0x75, 0x22, 0x23, + 0x0a, 0x07, 0x53, 0x54, 0x50, 0x53, 0x70, 0x65, 0x63, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, + 0x62, 0x6c, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x22, 0xaf, 0x01, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, + 0x65, 0x63, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x72, 0x65, + 0x61, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, + 0x6d, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, + 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x26, 0x0a, + 0x0f, 0x65, 0x74, 0x63, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x65, 0x74, 0x63, 0x46, 0x69, 0x6c, 0x65, 0x73, + 0x52, 0x65, 0x61, 0x64, 0x79, 0x22, 0x5f, 0x0a, 0x0c, 0x54, 0x43, 0x50, 0x50, 0x72, 0x6f, 0x62, + 0x65, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x12, 0x33, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x74, + 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x8e, 0x01, 0x0a, 0x12, 0x54, 0x69, 0x6d, 0x65, 0x53, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1f, 0x0a, + 0x0b, 0x6e, 0x74, 0x70, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x74, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x57, + 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, - 0x72, 0x73, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, - 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x74, 0x75, - 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6d, 0x74, 0x75, 0x22, 0x23, 0x0a, 0x07, 0x53, - 0x54, 0x50, 0x53, 0x70, 0x65, 0x63, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, - 0x22, 0xaf, 0x01, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, - 0x23, 0x0a, 0x0d, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, - 0x65, 0x61, 0x64, 0x79, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, - 0x76, 0x69, 0x74, 0x79, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x52, 0x65, - 0x61, 0x64, 0x79, 0x12, 0x25, 0x0a, 0x0e, 0x68, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x5f, - 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x68, 0x6f, 0x73, - 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x65, 0x74, - 0x63, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0d, 0x65, 0x74, 0x63, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x61, - 0x64, 0x79, 0x22, 0x5f, 0x0a, 0x0c, 0x54, 0x43, 0x50, 0x50, 0x72, 0x6f, 0x62, 0x65, 0x53, 0x70, - 0x65, 0x63, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x33, - 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, - 0x6f, 0x75, 0x74, 0x22, 0x8e, 0x01, 0x0a, 0x12, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x74, - 0x70, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x0a, 0x6e, 0x74, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x12, 0x57, 0x0a, 0x0c, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x34, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, - 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, - 0x61, 0x79, 0x65, 0x72, 0x22, 0x37, 0x0a, 0x14, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1f, 0x0a, 0x0b, - 0x6e, 0x74, 0x70, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x0a, 0x6e, 0x74, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x22, 0x6e, 0x0a, - 0x13, 0x56, 0x49, 0x50, 0x45, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, 0x74, 0x61, 0x6c, - 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, - 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64, - 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x70, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x68, 0x0a, - 0x0d, 0x56, 0x49, 0x50, 0x48, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1b, - 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x08, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, - 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x09, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, - 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, - 0x70, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x81, 0x02, 0x0a, 0x0f, 0x56, 0x49, 0x50, 0x4f, - 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x02, 0x69, - 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x02, 0x69, 0x70, 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x72, - 0x61, 0x74, 0x75, 0x69, 0x74, 0x6f, 0x75, 0x73, 0x5f, 0x61, 0x72, 0x70, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0d, 0x67, 0x72, 0x61, 0x74, 0x75, 0x69, 0x74, 0x6f, 0x75, 0x73, 0x41, 0x72, - 0x70, 0x12, 0x5c, 0x0a, 0x0d, 0x65, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x5f, 0x6d, 0x65, 0x74, - 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, - 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x56, 0x49, - 0x50, 0x45, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x53, 0x70, 0x65, - 0x63, 0x52, 0x0c, 0x65, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, 0x74, 0x61, 0x6c, 0x12, - 0x4a, 0x0a, 0x07, 0x68, 0x5f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x22, 0x37, 0x0a, 0x14, 0x54, 0x69, 0x6d, 0x65, 0x53, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x53, 0x70, 0x65, 0x63, 0x12, + 0x1f, 0x0a, 0x0b, 0x6e, 0x74, 0x70, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6e, 0x74, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, + 0x22, 0x6e, 0x0a, 0x13, 0x56, 0x49, 0x50, 0x45, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, + 0x74, 0x61, 0x6c, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, + 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x70, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x61, 0x70, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x22, 0x68, 0x0a, 0x0d, 0x56, 0x49, 0x50, 0x48, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x53, 0x70, 0x65, + 0x63, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x64, 0x12, 0x1d, + 0x0a, 0x0a, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x64, 0x12, 0x1b, 0x0a, + 0x09, 0x61, 0x70, 0x69, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x61, 0x70, 0x69, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x81, 0x02, 0x0a, 0x0f, 0x56, + 0x49, 0x50, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1d, + 0x0a, 0x02, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x52, 0x02, 0x69, 0x70, 0x12, 0x25, 0x0a, + 0x0e, 0x67, 0x72, 0x61, 0x74, 0x75, 0x69, 0x74, 0x6f, 0x75, 0x73, 0x5f, 0x61, 0x72, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x67, 0x72, 0x61, 0x74, 0x75, 0x69, 0x74, 0x6f, 0x75, + 0x73, 0x41, 0x72, 0x70, 0x12, 0x5c, 0x0a, 0x0d, 0x65, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x5f, + 0x6d, 0x65, 0x74, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x74, 0x61, + 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, + 0x2e, 0x56, 0x49, 0x50, 0x45, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, 0x74, 0x61, 0x6c, + 0x53, 0x70, 0x65, 0x63, 0x52, 0x0c, 0x65, 0x71, 0x75, 0x69, 0x6e, 0x69, 0x78, 0x4d, 0x65, 0x74, + 0x61, 0x6c, 0x12, 0x4a, 0x0a, 0x07, 0x68, 0x5f, 0x63, 0x6c, 0x6f, 0x75, 0x64, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x56, 0x49, 0x50, 0x48, 0x43, 0x6c, 0x6f, + 0x75, 0x64, 0x53, 0x70, 0x65, 0x63, 0x52, 0x06, 0x68, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x22, 0x72, + 0x0a, 0x08, 0x56, 0x4c, 0x41, 0x4e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x76, 0x69, 0x64, 0x12, 0x54, 0x0a, 0x08, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, + 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, + 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, + 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x56, 0x4c, 0x41, 0x4e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x22, 0x84, 0x02, 0x0a, 0x0d, 0x57, 0x69, 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, + 0x50, 0x65, 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x4b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x65, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, + 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x65, 0x73, + 0x68, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x5d, 0x0a, 0x1d, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, + 0x6e, 0x74, 0x5f, 0x6b, 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x76, 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x1b, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, + 0x6e, 0x74, 0x4b, 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x76, 0x61, 0x6c, 0x12, 0x34, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x69, + 0x70, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x4e, 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0a, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x49, 0x70, 0x73, 0x22, 0xde, 0x01, 0x0a, 0x0d, 0x57, 0x69, + 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x70, + 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, + 0x69, 0x73, 0x74, 0x65, 0x6e, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0a, 0x6c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x23, 0x0a, 0x0d, + 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0c, 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x4d, 0x61, 0x72, + 0x6b, 0x12, 0x47, 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, - 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x56, 0x49, 0x50, 0x48, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x53, - 0x70, 0x65, 0x63, 0x52, 0x06, 0x68, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x22, 0x72, 0x0a, 0x08, 0x56, - 0x4c, 0x41, 0x4e, 0x53, 0x70, 0x65, 0x63, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x07, 0x52, 0x03, 0x76, 0x69, 0x64, 0x12, 0x54, 0x0a, 0x08, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x74, 0x61, - 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, 0x65, 0x66, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x65, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, - 0x65, 0x74, 0x68, 0x65, 0x6c, 0x70, 0x65, 0x72, 0x73, 0x56, 0x4c, 0x41, 0x4e, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x22, - 0x84, 0x02, 0x0a, 0x0d, 0x57, 0x69, 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x50, 0x65, 0x65, - 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, - 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x72, 0x65, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x5f, 0x6b, 0x65, - 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x72, 0x65, 0x73, 0x68, 0x61, 0x72, - 0x65, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x12, 0x5d, 0x0a, 0x1d, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x5f, - 0x6b, 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, - 0x61, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x1b, 0x70, 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x74, 0x4b, - 0x65, 0x65, 0x70, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, - 0x12, 0x34, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x5f, 0x69, 0x70, 0x73, 0x18, - 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, - 0x65, 0x74, 0x49, 0x50, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, - 0x77, 0x65, 0x64, 0x49, 0x70, 0x73, 0x22, 0xde, 0x01, 0x0a, 0x0d, 0x57, 0x69, 0x72, 0x65, 0x67, - 0x75, 0x61, 0x72, 0x64, 0x53, 0x70, 0x65, 0x63, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x69, 0x76, - 0x61, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, - 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x75, 0x62, - 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, - 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x69, 0x73, 0x74, - 0x65, 0x6e, 0x5f, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6c, - 0x69, 0x73, 0x74, 0x65, 0x6e, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x69, 0x72, - 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x6b, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0c, 0x66, 0x69, 0x72, 0x65, 0x77, 0x61, 0x6c, 0x6c, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x47, - 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, - 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x64, - 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x6e, 0x65, 0x74, 0x77, 0x6f, - 0x72, 0x6b, 0x2e, 0x57, 0x69, 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x50, 0x65, 0x65, 0x72, - 0x52, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x42, 0x4c, 0x5a, 0x4a, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x69, 0x64, 0x65, 0x72, 0x6f, 0x6c, 0x61, 0x62, 0x73, - 0x2f, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x6d, 0x61, 0x63, 0x68, 0x69, - 0x6e, 0x65, 0x72, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x6e, 0x65, - 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x57, 0x69, 0x72, 0x65, 0x67, 0x75, 0x61, 0x72, 0x64, 0x50, + 0x65, 0x65, 0x72, 0x52, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x42, 0x4c, 0x5a, 0x4a, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x69, 0x64, 0x65, 0x72, 0x6f, 0x6c, + 0x61, 0x62, 0x73, 0x2f, 0x74, 0x61, 0x6c, 0x6f, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x6d, 0x61, + 0x63, 0x68, 0x69, 0x6e, 0x65, 0x72, 0x79, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x2f, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -3440,149 +4163,182 @@ func file_resource_definitions_network_network_proto_rawDescGZIP() []byte { return file_resource_definitions_network_network_proto_rawDescData } -var file_resource_definitions_network_network_proto_msgTypes = make([]protoimpl.MessageInfo, 34) +var file_resource_definitions_network_network_proto_msgTypes = make([]protoimpl.MessageInfo, 43) var file_resource_definitions_network_network_proto_goTypes = []interface{}{ - (*AddressSpecSpec)(nil), // 0: talos.resource.definitions.network.AddressSpecSpec - (*AddressStatusSpec)(nil), // 1: talos.resource.definitions.network.AddressStatusSpec - (*BondMasterSpec)(nil), // 2: talos.resource.definitions.network.BondMasterSpec - (*BondSlave)(nil), // 3: talos.resource.definitions.network.BondSlave - (*BridgeMasterSpec)(nil), // 4: talos.resource.definitions.network.BridgeMasterSpec - (*BridgeSlave)(nil), // 5: talos.resource.definitions.network.BridgeSlave - (*DHCP4OperatorSpec)(nil), // 6: talos.resource.definitions.network.DHCP4OperatorSpec - (*DHCP6OperatorSpec)(nil), // 7: talos.resource.definitions.network.DHCP6OperatorSpec - (*HardwareAddrSpec)(nil), // 8: talos.resource.definitions.network.HardwareAddrSpec - (*HostnameSpecSpec)(nil), // 9: talos.resource.definitions.network.HostnameSpecSpec - (*HostnameStatusSpec)(nil), // 10: talos.resource.definitions.network.HostnameStatusSpec - (*LinkRefreshSpec)(nil), // 11: talos.resource.definitions.network.LinkRefreshSpec - (*LinkSpecSpec)(nil), // 12: talos.resource.definitions.network.LinkSpecSpec - (*LinkStatusSpec)(nil), // 13: talos.resource.definitions.network.LinkStatusSpec - (*NodeAddressFilterSpec)(nil), // 14: talos.resource.definitions.network.NodeAddressFilterSpec - (*NodeAddressSpec)(nil), // 15: talos.resource.definitions.network.NodeAddressSpec - (*OperatorSpecSpec)(nil), // 16: talos.resource.definitions.network.OperatorSpecSpec - (*ProbeSpecSpec)(nil), // 17: talos.resource.definitions.network.ProbeSpecSpec - (*ProbeStatusSpec)(nil), // 18: talos.resource.definitions.network.ProbeStatusSpec - (*ResolverSpecSpec)(nil), // 19: talos.resource.definitions.network.ResolverSpecSpec - (*ResolverStatusSpec)(nil), // 20: talos.resource.definitions.network.ResolverStatusSpec - (*RouteSpecSpec)(nil), // 21: talos.resource.definitions.network.RouteSpecSpec - (*RouteStatusSpec)(nil), // 22: talos.resource.definitions.network.RouteStatusSpec - (*STPSpec)(nil), // 23: talos.resource.definitions.network.STPSpec - (*StatusSpec)(nil), // 24: talos.resource.definitions.network.StatusSpec - (*TCPProbeSpec)(nil), // 25: talos.resource.definitions.network.TCPProbeSpec - (*TimeServerSpecSpec)(nil), // 26: talos.resource.definitions.network.TimeServerSpecSpec - (*TimeServerStatusSpec)(nil), // 27: talos.resource.definitions.network.TimeServerStatusSpec - (*VIPEquinixMetalSpec)(nil), // 28: talos.resource.definitions.network.VIPEquinixMetalSpec - (*VIPHCloudSpec)(nil), // 29: talos.resource.definitions.network.VIPHCloudSpec - (*VIPOperatorSpec)(nil), // 30: talos.resource.definitions.network.VIPOperatorSpec - (*VLANSpec)(nil), // 31: talos.resource.definitions.network.VLANSpec - (*WireguardPeer)(nil), // 32: talos.resource.definitions.network.WireguardPeer - (*WireguardSpec)(nil), // 33: talos.resource.definitions.network.WireguardSpec - (*common.NetIPPrefix)(nil), // 34: common.NetIPPrefix - (enums.NethelpersFamily)(0), // 35: talos.resource.definitions.enums.NethelpersFamily - (enums.NethelpersScope)(0), // 36: talos.resource.definitions.enums.NethelpersScope - (enums.NetworkConfigLayer)(0), // 37: talos.resource.definitions.enums.NetworkConfigLayer - (*common.NetIP)(nil), // 38: common.NetIP - (enums.NethelpersBondMode)(0), // 39: talos.resource.definitions.enums.NethelpersBondMode - (enums.NethelpersBondXmitHashPolicy)(0), // 40: talos.resource.definitions.enums.NethelpersBondXmitHashPolicy - (enums.NethelpersLACPRate)(0), // 41: talos.resource.definitions.enums.NethelpersLACPRate - (enums.NethelpersARPValidate)(0), // 42: talos.resource.definitions.enums.NethelpersARPValidate - (enums.NethelpersARPAllTargets)(0), // 43: talos.resource.definitions.enums.NethelpersARPAllTargets - (enums.NethelpersPrimaryReselect)(0), // 44: talos.resource.definitions.enums.NethelpersPrimaryReselect - (enums.NethelpersFailOverMAC)(0), // 45: talos.resource.definitions.enums.NethelpersFailOverMAC - (enums.NethelpersADSelect)(0), // 46: talos.resource.definitions.enums.NethelpersADSelect - (enums.NethelpersLinkType)(0), // 47: talos.resource.definitions.enums.NethelpersLinkType - (enums.NethelpersOperationalState)(0), // 48: talos.resource.definitions.enums.NethelpersOperationalState - (enums.NethelpersPort)(0), // 49: talos.resource.definitions.enums.NethelpersPort - (enums.NethelpersDuplex)(0), // 50: talos.resource.definitions.enums.NethelpersDuplex - (enums.NetworkOperator)(0), // 51: talos.resource.definitions.enums.NetworkOperator - (*durationpb.Duration)(nil), // 52: google.protobuf.Duration - (enums.NethelpersRoutingTable)(0), // 53: talos.resource.definitions.enums.NethelpersRoutingTable - (enums.NethelpersRouteType)(0), // 54: talos.resource.definitions.enums.NethelpersRouteType - (enums.NethelpersRouteProtocol)(0), // 55: talos.resource.definitions.enums.NethelpersRouteProtocol - (enums.NethelpersVLANProtocol)(0), // 56: talos.resource.definitions.enums.NethelpersVLANProtocol + (*AddressSpecSpec)(nil), // 0: talos.resource.definitions.network.AddressSpecSpec + (*AddressStatusSpec)(nil), // 1: talos.resource.definitions.network.AddressStatusSpec + (*BondMasterSpec)(nil), // 2: talos.resource.definitions.network.BondMasterSpec + (*BondSlave)(nil), // 3: talos.resource.definitions.network.BondSlave + (*BridgeMasterSpec)(nil), // 4: talos.resource.definitions.network.BridgeMasterSpec + (*BridgeSlave)(nil), // 5: talos.resource.definitions.network.BridgeSlave + (*DHCP4OperatorSpec)(nil), // 6: talos.resource.definitions.network.DHCP4OperatorSpec + (*DHCP6OperatorSpec)(nil), // 7: talos.resource.definitions.network.DHCP6OperatorSpec + (*HardwareAddrSpec)(nil), // 8: talos.resource.definitions.network.HardwareAddrSpec + (*HostnameSpecSpec)(nil), // 9: talos.resource.definitions.network.HostnameSpecSpec + (*HostnameStatusSpec)(nil), // 10: talos.resource.definitions.network.HostnameStatusSpec + (*LinkRefreshSpec)(nil), // 11: talos.resource.definitions.network.LinkRefreshSpec + (*LinkSpecSpec)(nil), // 12: talos.resource.definitions.network.LinkSpecSpec + (*LinkStatusSpec)(nil), // 13: talos.resource.definitions.network.LinkStatusSpec + (*NfTablesAddressMatch)(nil), // 14: talos.resource.definitions.network.NfTablesAddressMatch + (*NfTablesChainSpec)(nil), // 15: talos.resource.definitions.network.NfTablesChainSpec + (*NfTablesClampMSS)(nil), // 16: talos.resource.definitions.network.NfTablesClampMSS + (*NfTablesIfNameMatch)(nil), // 17: talos.resource.definitions.network.NfTablesIfNameMatch + (*NfTablesLayer4Match)(nil), // 18: talos.resource.definitions.network.NfTablesLayer4Match + (*NfTablesMark)(nil), // 19: talos.resource.definitions.network.NfTablesMark + (*NfTablesPortMatch)(nil), // 20: talos.resource.definitions.network.NfTablesPortMatch + (*NfTablesRule)(nil), // 21: talos.resource.definitions.network.NfTablesRule + (*NodeAddressFilterSpec)(nil), // 22: talos.resource.definitions.network.NodeAddressFilterSpec + (*NodeAddressSpec)(nil), // 23: talos.resource.definitions.network.NodeAddressSpec + (*OperatorSpecSpec)(nil), // 24: talos.resource.definitions.network.OperatorSpecSpec + (*PortRange)(nil), // 25: talos.resource.definitions.network.PortRange + (*ProbeSpecSpec)(nil), // 26: talos.resource.definitions.network.ProbeSpecSpec + (*ProbeStatusSpec)(nil), // 27: talos.resource.definitions.network.ProbeStatusSpec + (*ResolverSpecSpec)(nil), // 28: talos.resource.definitions.network.ResolverSpecSpec + (*ResolverStatusSpec)(nil), // 29: talos.resource.definitions.network.ResolverStatusSpec + (*RouteSpecSpec)(nil), // 30: talos.resource.definitions.network.RouteSpecSpec + (*RouteStatusSpec)(nil), // 31: talos.resource.definitions.network.RouteStatusSpec + (*STPSpec)(nil), // 32: talos.resource.definitions.network.STPSpec + (*StatusSpec)(nil), // 33: talos.resource.definitions.network.StatusSpec + (*TCPProbeSpec)(nil), // 34: talos.resource.definitions.network.TCPProbeSpec + (*TimeServerSpecSpec)(nil), // 35: talos.resource.definitions.network.TimeServerSpecSpec + (*TimeServerStatusSpec)(nil), // 36: talos.resource.definitions.network.TimeServerStatusSpec + (*VIPEquinixMetalSpec)(nil), // 37: talos.resource.definitions.network.VIPEquinixMetalSpec + (*VIPHCloudSpec)(nil), // 38: talos.resource.definitions.network.VIPHCloudSpec + (*VIPOperatorSpec)(nil), // 39: talos.resource.definitions.network.VIPOperatorSpec + (*VLANSpec)(nil), // 40: talos.resource.definitions.network.VLANSpec + (*WireguardPeer)(nil), // 41: talos.resource.definitions.network.WireguardPeer + (*WireguardSpec)(nil), // 42: talos.resource.definitions.network.WireguardSpec + (*common.NetIPPrefix)(nil), // 43: common.NetIPPrefix + (enums.NethelpersFamily)(0), // 44: talos.resource.definitions.enums.NethelpersFamily + (enums.NethelpersScope)(0), // 45: talos.resource.definitions.enums.NethelpersScope + (enums.NetworkConfigLayer)(0), // 46: talos.resource.definitions.enums.NetworkConfigLayer + (*common.NetIP)(nil), // 47: common.NetIP + (enums.NethelpersBondMode)(0), // 48: talos.resource.definitions.enums.NethelpersBondMode + (enums.NethelpersBondXmitHashPolicy)(0), // 49: talos.resource.definitions.enums.NethelpersBondXmitHashPolicy + (enums.NethelpersLACPRate)(0), // 50: talos.resource.definitions.enums.NethelpersLACPRate + (enums.NethelpersARPValidate)(0), // 51: talos.resource.definitions.enums.NethelpersARPValidate + (enums.NethelpersARPAllTargets)(0), // 52: talos.resource.definitions.enums.NethelpersARPAllTargets + (enums.NethelpersPrimaryReselect)(0), // 53: talos.resource.definitions.enums.NethelpersPrimaryReselect + (enums.NethelpersFailOverMAC)(0), // 54: talos.resource.definitions.enums.NethelpersFailOverMAC + (enums.NethelpersADSelect)(0), // 55: talos.resource.definitions.enums.NethelpersADSelect + (enums.NethelpersLinkType)(0), // 56: talos.resource.definitions.enums.NethelpersLinkType + (enums.NethelpersOperationalState)(0), // 57: talos.resource.definitions.enums.NethelpersOperationalState + (enums.NethelpersPort)(0), // 58: talos.resource.definitions.enums.NethelpersPort + (enums.NethelpersDuplex)(0), // 59: talos.resource.definitions.enums.NethelpersDuplex + (enums.NethelpersNfTablesChainHook)(0), // 60: talos.resource.definitions.enums.NethelpersNfTablesChainHook + (enums.NethelpersNfTablesChainPriority)(0), // 61: talos.resource.definitions.enums.NethelpersNfTablesChainPriority + (enums.NethelpersMatchOperator)(0), // 62: talos.resource.definitions.enums.NethelpersMatchOperator + (enums.NethelpersProtocol)(0), // 63: talos.resource.definitions.enums.NethelpersProtocol + (enums.NethelpersNfTablesVerdict)(0), // 64: talos.resource.definitions.enums.NethelpersNfTablesVerdict + (enums.NetworkOperator)(0), // 65: talos.resource.definitions.enums.NetworkOperator + (*durationpb.Duration)(nil), // 66: google.protobuf.Duration + (enums.NethelpersRoutingTable)(0), // 67: talos.resource.definitions.enums.NethelpersRoutingTable + (enums.NethelpersRouteType)(0), // 68: talos.resource.definitions.enums.NethelpersRouteType + (enums.NethelpersRouteProtocol)(0), // 69: talos.resource.definitions.enums.NethelpersRouteProtocol + (enums.NethelpersVLANProtocol)(0), // 70: talos.resource.definitions.enums.NethelpersVLANProtocol } var file_resource_definitions_network_network_proto_depIdxs = []int32{ - 34, // 0: talos.resource.definitions.network.AddressSpecSpec.address:type_name -> common.NetIPPrefix - 35, // 1: talos.resource.definitions.network.AddressSpecSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily - 36, // 2: talos.resource.definitions.network.AddressSpecSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope - 37, // 3: talos.resource.definitions.network.AddressSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 34, // 4: talos.resource.definitions.network.AddressStatusSpec.address:type_name -> common.NetIPPrefix - 38, // 5: talos.resource.definitions.network.AddressStatusSpec.local:type_name -> common.NetIP - 38, // 6: talos.resource.definitions.network.AddressStatusSpec.broadcast:type_name -> common.NetIP - 38, // 7: talos.resource.definitions.network.AddressStatusSpec.anycast:type_name -> common.NetIP - 38, // 8: talos.resource.definitions.network.AddressStatusSpec.multicast:type_name -> common.NetIP - 35, // 9: talos.resource.definitions.network.AddressStatusSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily - 36, // 10: talos.resource.definitions.network.AddressStatusSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope - 39, // 11: talos.resource.definitions.network.BondMasterSpec.mode:type_name -> talos.resource.definitions.enums.NethelpersBondMode - 40, // 12: talos.resource.definitions.network.BondMasterSpec.hash_policy:type_name -> talos.resource.definitions.enums.NethelpersBondXmitHashPolicy - 41, // 13: talos.resource.definitions.network.BondMasterSpec.lacp_rate:type_name -> talos.resource.definitions.enums.NethelpersLACPRate - 42, // 14: talos.resource.definitions.network.BondMasterSpec.arp_validate:type_name -> talos.resource.definitions.enums.NethelpersARPValidate - 43, // 15: talos.resource.definitions.network.BondMasterSpec.arp_all_targets:type_name -> talos.resource.definitions.enums.NethelpersARPAllTargets - 44, // 16: talos.resource.definitions.network.BondMasterSpec.primary_reselect:type_name -> talos.resource.definitions.enums.NethelpersPrimaryReselect - 45, // 17: talos.resource.definitions.network.BondMasterSpec.fail_over_mac:type_name -> talos.resource.definitions.enums.NethelpersFailOverMAC - 46, // 18: talos.resource.definitions.network.BondMasterSpec.ad_select:type_name -> talos.resource.definitions.enums.NethelpersADSelect - 23, // 19: talos.resource.definitions.network.BridgeMasterSpec.stp:type_name -> talos.resource.definitions.network.STPSpec - 37, // 20: talos.resource.definitions.network.HostnameSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 47, // 21: talos.resource.definitions.network.LinkSpecSpec.type:type_name -> talos.resource.definitions.enums.NethelpersLinkType + 43, // 0: talos.resource.definitions.network.AddressSpecSpec.address:type_name -> common.NetIPPrefix + 44, // 1: talos.resource.definitions.network.AddressSpecSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily + 45, // 2: talos.resource.definitions.network.AddressSpecSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope + 46, // 3: talos.resource.definitions.network.AddressSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 43, // 4: talos.resource.definitions.network.AddressStatusSpec.address:type_name -> common.NetIPPrefix + 47, // 5: talos.resource.definitions.network.AddressStatusSpec.local:type_name -> common.NetIP + 47, // 6: talos.resource.definitions.network.AddressStatusSpec.broadcast:type_name -> common.NetIP + 47, // 7: talos.resource.definitions.network.AddressStatusSpec.anycast:type_name -> common.NetIP + 47, // 8: talos.resource.definitions.network.AddressStatusSpec.multicast:type_name -> common.NetIP + 44, // 9: talos.resource.definitions.network.AddressStatusSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily + 45, // 10: talos.resource.definitions.network.AddressStatusSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope + 48, // 11: talos.resource.definitions.network.BondMasterSpec.mode:type_name -> talos.resource.definitions.enums.NethelpersBondMode + 49, // 12: talos.resource.definitions.network.BondMasterSpec.hash_policy:type_name -> talos.resource.definitions.enums.NethelpersBondXmitHashPolicy + 50, // 13: talos.resource.definitions.network.BondMasterSpec.lacp_rate:type_name -> talos.resource.definitions.enums.NethelpersLACPRate + 51, // 14: talos.resource.definitions.network.BondMasterSpec.arp_validate:type_name -> talos.resource.definitions.enums.NethelpersARPValidate + 52, // 15: talos.resource.definitions.network.BondMasterSpec.arp_all_targets:type_name -> talos.resource.definitions.enums.NethelpersARPAllTargets + 53, // 16: talos.resource.definitions.network.BondMasterSpec.primary_reselect:type_name -> talos.resource.definitions.enums.NethelpersPrimaryReselect + 54, // 17: talos.resource.definitions.network.BondMasterSpec.fail_over_mac:type_name -> talos.resource.definitions.enums.NethelpersFailOverMAC + 55, // 18: talos.resource.definitions.network.BondMasterSpec.ad_select:type_name -> talos.resource.definitions.enums.NethelpersADSelect + 32, // 19: talos.resource.definitions.network.BridgeMasterSpec.stp:type_name -> talos.resource.definitions.network.STPSpec + 46, // 20: talos.resource.definitions.network.HostnameSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 56, // 21: talos.resource.definitions.network.LinkSpecSpec.type:type_name -> talos.resource.definitions.enums.NethelpersLinkType 3, // 22: talos.resource.definitions.network.LinkSpecSpec.bond_slave:type_name -> talos.resource.definitions.network.BondSlave 5, // 23: talos.resource.definitions.network.LinkSpecSpec.bridge_slave:type_name -> talos.resource.definitions.network.BridgeSlave - 31, // 24: talos.resource.definitions.network.LinkSpecSpec.vlan:type_name -> talos.resource.definitions.network.VLANSpec + 40, // 24: talos.resource.definitions.network.LinkSpecSpec.vlan:type_name -> talos.resource.definitions.network.VLANSpec 2, // 25: talos.resource.definitions.network.LinkSpecSpec.bond_master:type_name -> talos.resource.definitions.network.BondMasterSpec 4, // 26: talos.resource.definitions.network.LinkSpecSpec.bridge_master:type_name -> talos.resource.definitions.network.BridgeMasterSpec - 33, // 27: talos.resource.definitions.network.LinkSpecSpec.wireguard:type_name -> talos.resource.definitions.network.WireguardSpec - 37, // 28: talos.resource.definitions.network.LinkSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 47, // 29: talos.resource.definitions.network.LinkStatusSpec.type:type_name -> talos.resource.definitions.enums.NethelpersLinkType - 48, // 30: talos.resource.definitions.network.LinkStatusSpec.operational_state:type_name -> talos.resource.definitions.enums.NethelpersOperationalState - 49, // 31: talos.resource.definitions.network.LinkStatusSpec.port:type_name -> talos.resource.definitions.enums.NethelpersPort - 50, // 32: talos.resource.definitions.network.LinkStatusSpec.duplex:type_name -> talos.resource.definitions.enums.NethelpersDuplex - 31, // 33: talos.resource.definitions.network.LinkStatusSpec.vlan:type_name -> talos.resource.definitions.network.VLANSpec + 42, // 27: talos.resource.definitions.network.LinkSpecSpec.wireguard:type_name -> talos.resource.definitions.network.WireguardSpec + 46, // 28: talos.resource.definitions.network.LinkSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 56, // 29: talos.resource.definitions.network.LinkStatusSpec.type:type_name -> talos.resource.definitions.enums.NethelpersLinkType + 57, // 30: talos.resource.definitions.network.LinkStatusSpec.operational_state:type_name -> talos.resource.definitions.enums.NethelpersOperationalState + 58, // 31: talos.resource.definitions.network.LinkStatusSpec.port:type_name -> talos.resource.definitions.enums.NethelpersPort + 59, // 32: talos.resource.definitions.network.LinkStatusSpec.duplex:type_name -> talos.resource.definitions.enums.NethelpersDuplex + 40, // 33: talos.resource.definitions.network.LinkStatusSpec.vlan:type_name -> talos.resource.definitions.network.VLANSpec 4, // 34: talos.resource.definitions.network.LinkStatusSpec.bridge_master:type_name -> talos.resource.definitions.network.BridgeMasterSpec 2, // 35: talos.resource.definitions.network.LinkStatusSpec.bond_master:type_name -> talos.resource.definitions.network.BondMasterSpec - 33, // 36: talos.resource.definitions.network.LinkStatusSpec.wireguard:type_name -> talos.resource.definitions.network.WireguardSpec - 34, // 37: talos.resource.definitions.network.NodeAddressFilterSpec.include_subnets:type_name -> common.NetIPPrefix - 34, // 38: talos.resource.definitions.network.NodeAddressFilterSpec.exclude_subnets:type_name -> common.NetIPPrefix - 34, // 39: talos.resource.definitions.network.NodeAddressSpec.addresses:type_name -> common.NetIPPrefix - 51, // 40: talos.resource.definitions.network.OperatorSpecSpec.operator:type_name -> talos.resource.definitions.enums.NetworkOperator - 6, // 41: talos.resource.definitions.network.OperatorSpecSpec.dhcp4:type_name -> talos.resource.definitions.network.DHCP4OperatorSpec - 7, // 42: talos.resource.definitions.network.OperatorSpecSpec.dhcp6:type_name -> talos.resource.definitions.network.DHCP6OperatorSpec - 30, // 43: talos.resource.definitions.network.OperatorSpecSpec.vip:type_name -> talos.resource.definitions.network.VIPOperatorSpec - 37, // 44: talos.resource.definitions.network.OperatorSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 52, // 45: talos.resource.definitions.network.ProbeSpecSpec.interval:type_name -> google.protobuf.Duration - 25, // 46: talos.resource.definitions.network.ProbeSpecSpec.tcp:type_name -> talos.resource.definitions.network.TCPProbeSpec - 37, // 47: talos.resource.definitions.network.ProbeSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 38, // 48: talos.resource.definitions.network.ResolverSpecSpec.dns_servers:type_name -> common.NetIP - 37, // 49: talos.resource.definitions.network.ResolverSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 38, // 50: talos.resource.definitions.network.ResolverStatusSpec.dns_servers:type_name -> common.NetIP - 35, // 51: talos.resource.definitions.network.RouteSpecSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily - 34, // 52: talos.resource.definitions.network.RouteSpecSpec.destination:type_name -> common.NetIPPrefix - 38, // 53: talos.resource.definitions.network.RouteSpecSpec.source:type_name -> common.NetIP - 38, // 54: talos.resource.definitions.network.RouteSpecSpec.gateway:type_name -> common.NetIP - 53, // 55: talos.resource.definitions.network.RouteSpecSpec.table:type_name -> talos.resource.definitions.enums.NethelpersRoutingTable - 36, // 56: talos.resource.definitions.network.RouteSpecSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope - 54, // 57: talos.resource.definitions.network.RouteSpecSpec.type:type_name -> talos.resource.definitions.enums.NethelpersRouteType - 55, // 58: talos.resource.definitions.network.RouteSpecSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersRouteProtocol - 37, // 59: talos.resource.definitions.network.RouteSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 35, // 60: talos.resource.definitions.network.RouteStatusSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily - 34, // 61: talos.resource.definitions.network.RouteStatusSpec.destination:type_name -> common.NetIPPrefix - 38, // 62: talos.resource.definitions.network.RouteStatusSpec.source:type_name -> common.NetIP - 38, // 63: talos.resource.definitions.network.RouteStatusSpec.gateway:type_name -> common.NetIP - 53, // 64: talos.resource.definitions.network.RouteStatusSpec.table:type_name -> talos.resource.definitions.enums.NethelpersRoutingTable - 36, // 65: talos.resource.definitions.network.RouteStatusSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope - 54, // 66: talos.resource.definitions.network.RouteStatusSpec.type:type_name -> talos.resource.definitions.enums.NethelpersRouteType - 55, // 67: talos.resource.definitions.network.RouteStatusSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersRouteProtocol - 52, // 68: talos.resource.definitions.network.TCPProbeSpec.timeout:type_name -> google.protobuf.Duration - 37, // 69: talos.resource.definitions.network.TimeServerSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer - 38, // 70: talos.resource.definitions.network.VIPOperatorSpec.ip:type_name -> common.NetIP - 28, // 71: talos.resource.definitions.network.VIPOperatorSpec.equinix_metal:type_name -> talos.resource.definitions.network.VIPEquinixMetalSpec - 29, // 72: talos.resource.definitions.network.VIPOperatorSpec.h_cloud:type_name -> talos.resource.definitions.network.VIPHCloudSpec - 56, // 73: talos.resource.definitions.network.VLANSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersVLANProtocol - 52, // 74: talos.resource.definitions.network.WireguardPeer.persistent_keepalive_interval:type_name -> google.protobuf.Duration - 34, // 75: talos.resource.definitions.network.WireguardPeer.allowed_ips:type_name -> common.NetIPPrefix - 32, // 76: talos.resource.definitions.network.WireguardSpec.peers:type_name -> talos.resource.definitions.network.WireguardPeer - 77, // [77:77] is the sub-list for method output_type - 77, // [77:77] is the sub-list for method input_type - 77, // [77:77] is the sub-list for extension type_name - 77, // [77:77] is the sub-list for extension extendee - 0, // [0:77] is the sub-list for field type_name + 42, // 36: talos.resource.definitions.network.LinkStatusSpec.wireguard:type_name -> talos.resource.definitions.network.WireguardSpec + 43, // 37: talos.resource.definitions.network.NfTablesAddressMatch.include_subnets:type_name -> common.NetIPPrefix + 43, // 38: talos.resource.definitions.network.NfTablesAddressMatch.exclude_subnets:type_name -> common.NetIPPrefix + 60, // 39: talos.resource.definitions.network.NfTablesChainSpec.hook:type_name -> talos.resource.definitions.enums.NethelpersNfTablesChainHook + 61, // 40: talos.resource.definitions.network.NfTablesChainSpec.priority:type_name -> talos.resource.definitions.enums.NethelpersNfTablesChainPriority + 21, // 41: talos.resource.definitions.network.NfTablesChainSpec.rules:type_name -> talos.resource.definitions.network.NfTablesRule + 62, // 42: talos.resource.definitions.network.NfTablesIfNameMatch.operator:type_name -> talos.resource.definitions.enums.NethelpersMatchOperator + 63, // 43: talos.resource.definitions.network.NfTablesLayer4Match.protocol:type_name -> talos.resource.definitions.enums.NethelpersProtocol + 20, // 44: talos.resource.definitions.network.NfTablesLayer4Match.match_source_port:type_name -> talos.resource.definitions.network.NfTablesPortMatch + 20, // 45: talos.resource.definitions.network.NfTablesLayer4Match.match_destination_port:type_name -> talos.resource.definitions.network.NfTablesPortMatch + 25, // 46: talos.resource.definitions.network.NfTablesPortMatch.ranges:type_name -> talos.resource.definitions.network.PortRange + 17, // 47: talos.resource.definitions.network.NfTablesRule.match_o_if_name:type_name -> talos.resource.definitions.network.NfTablesIfNameMatch + 64, // 48: talos.resource.definitions.network.NfTablesRule.verdict:type_name -> talos.resource.definitions.enums.NethelpersNfTablesVerdict + 19, // 49: talos.resource.definitions.network.NfTablesRule.match_mark:type_name -> talos.resource.definitions.network.NfTablesMark + 19, // 50: talos.resource.definitions.network.NfTablesRule.set_mark:type_name -> talos.resource.definitions.network.NfTablesMark + 14, // 51: talos.resource.definitions.network.NfTablesRule.match_source_address:type_name -> talos.resource.definitions.network.NfTablesAddressMatch + 14, // 52: talos.resource.definitions.network.NfTablesRule.match_destination_address:type_name -> talos.resource.definitions.network.NfTablesAddressMatch + 18, // 53: talos.resource.definitions.network.NfTablesRule.match_layer4:type_name -> talos.resource.definitions.network.NfTablesLayer4Match + 17, // 54: talos.resource.definitions.network.NfTablesRule.match_i_if_name:type_name -> talos.resource.definitions.network.NfTablesIfNameMatch + 16, // 55: talos.resource.definitions.network.NfTablesRule.clamp_mss:type_name -> talos.resource.definitions.network.NfTablesClampMSS + 43, // 56: talos.resource.definitions.network.NodeAddressFilterSpec.include_subnets:type_name -> common.NetIPPrefix + 43, // 57: talos.resource.definitions.network.NodeAddressFilterSpec.exclude_subnets:type_name -> common.NetIPPrefix + 43, // 58: talos.resource.definitions.network.NodeAddressSpec.addresses:type_name -> common.NetIPPrefix + 65, // 59: talos.resource.definitions.network.OperatorSpecSpec.operator:type_name -> talos.resource.definitions.enums.NetworkOperator + 6, // 60: talos.resource.definitions.network.OperatorSpecSpec.dhcp4:type_name -> talos.resource.definitions.network.DHCP4OperatorSpec + 7, // 61: talos.resource.definitions.network.OperatorSpecSpec.dhcp6:type_name -> talos.resource.definitions.network.DHCP6OperatorSpec + 39, // 62: talos.resource.definitions.network.OperatorSpecSpec.vip:type_name -> talos.resource.definitions.network.VIPOperatorSpec + 46, // 63: talos.resource.definitions.network.OperatorSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 66, // 64: talos.resource.definitions.network.ProbeSpecSpec.interval:type_name -> google.protobuf.Duration + 34, // 65: talos.resource.definitions.network.ProbeSpecSpec.tcp:type_name -> talos.resource.definitions.network.TCPProbeSpec + 46, // 66: talos.resource.definitions.network.ProbeSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 47, // 67: talos.resource.definitions.network.ResolverSpecSpec.dns_servers:type_name -> common.NetIP + 46, // 68: talos.resource.definitions.network.ResolverSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 47, // 69: talos.resource.definitions.network.ResolverStatusSpec.dns_servers:type_name -> common.NetIP + 44, // 70: talos.resource.definitions.network.RouteSpecSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily + 43, // 71: talos.resource.definitions.network.RouteSpecSpec.destination:type_name -> common.NetIPPrefix + 47, // 72: talos.resource.definitions.network.RouteSpecSpec.source:type_name -> common.NetIP + 47, // 73: talos.resource.definitions.network.RouteSpecSpec.gateway:type_name -> common.NetIP + 67, // 74: talos.resource.definitions.network.RouteSpecSpec.table:type_name -> talos.resource.definitions.enums.NethelpersRoutingTable + 45, // 75: talos.resource.definitions.network.RouteSpecSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope + 68, // 76: talos.resource.definitions.network.RouteSpecSpec.type:type_name -> talos.resource.definitions.enums.NethelpersRouteType + 69, // 77: talos.resource.definitions.network.RouteSpecSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersRouteProtocol + 46, // 78: talos.resource.definitions.network.RouteSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 44, // 79: talos.resource.definitions.network.RouteStatusSpec.family:type_name -> talos.resource.definitions.enums.NethelpersFamily + 43, // 80: talos.resource.definitions.network.RouteStatusSpec.destination:type_name -> common.NetIPPrefix + 47, // 81: talos.resource.definitions.network.RouteStatusSpec.source:type_name -> common.NetIP + 47, // 82: talos.resource.definitions.network.RouteStatusSpec.gateway:type_name -> common.NetIP + 67, // 83: talos.resource.definitions.network.RouteStatusSpec.table:type_name -> talos.resource.definitions.enums.NethelpersRoutingTable + 45, // 84: talos.resource.definitions.network.RouteStatusSpec.scope:type_name -> talos.resource.definitions.enums.NethelpersScope + 68, // 85: talos.resource.definitions.network.RouteStatusSpec.type:type_name -> talos.resource.definitions.enums.NethelpersRouteType + 69, // 86: talos.resource.definitions.network.RouteStatusSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersRouteProtocol + 66, // 87: talos.resource.definitions.network.TCPProbeSpec.timeout:type_name -> google.protobuf.Duration + 46, // 88: talos.resource.definitions.network.TimeServerSpecSpec.config_layer:type_name -> talos.resource.definitions.enums.NetworkConfigLayer + 47, // 89: talos.resource.definitions.network.VIPOperatorSpec.ip:type_name -> common.NetIP + 37, // 90: talos.resource.definitions.network.VIPOperatorSpec.equinix_metal:type_name -> talos.resource.definitions.network.VIPEquinixMetalSpec + 38, // 91: talos.resource.definitions.network.VIPOperatorSpec.h_cloud:type_name -> talos.resource.definitions.network.VIPHCloudSpec + 70, // 92: talos.resource.definitions.network.VLANSpec.protocol:type_name -> talos.resource.definitions.enums.NethelpersVLANProtocol + 66, // 93: talos.resource.definitions.network.WireguardPeer.persistent_keepalive_interval:type_name -> google.protobuf.Duration + 43, // 94: talos.resource.definitions.network.WireguardPeer.allowed_ips:type_name -> common.NetIPPrefix + 41, // 95: talos.resource.definitions.network.WireguardSpec.peers:type_name -> talos.resource.definitions.network.WireguardPeer + 96, // [96:96] is the sub-list for method output_type + 96, // [96:96] is the sub-list for method input_type + 96, // [96:96] is the sub-list for extension type_name + 96, // [96:96] is the sub-list for extension extendee + 0, // [0:96] is the sub-list for field type_name } func init() { file_resource_definitions_network_network_proto_init() } @@ -3760,7 +4516,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NodeAddressFilterSpec); i { + switch v := v.(*NfTablesAddressMatch); i { case 0: return &v.state case 1: @@ -3772,7 +4528,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NodeAddressSpec); i { + switch v := v.(*NfTablesChainSpec); i { case 0: return &v.state case 1: @@ -3784,7 +4540,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*OperatorSpecSpec); i { + switch v := v.(*NfTablesClampMSS); i { case 0: return &v.state case 1: @@ -3796,7 +4552,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ProbeSpecSpec); i { + switch v := v.(*NfTablesIfNameMatch); i { case 0: return &v.state case 1: @@ -3808,7 +4564,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ProbeStatusSpec); i { + switch v := v.(*NfTablesLayer4Match); i { case 0: return &v.state case 1: @@ -3820,7 +4576,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResolverSpecSpec); i { + switch v := v.(*NfTablesMark); i { case 0: return &v.state case 1: @@ -3832,7 +4588,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResolverStatusSpec); i { + switch v := v.(*NfTablesPortMatch); i { case 0: return &v.state case 1: @@ -3844,7 +4600,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RouteSpecSpec); i { + switch v := v.(*NfTablesRule); i { case 0: return &v.state case 1: @@ -3856,7 +4612,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RouteStatusSpec); i { + switch v := v.(*NodeAddressFilterSpec); i { case 0: return &v.state case 1: @@ -3868,7 +4624,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*STPSpec); i { + switch v := v.(*NodeAddressSpec); i { case 0: return &v.state case 1: @@ -3880,7 +4636,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StatusSpec); i { + switch v := v.(*OperatorSpecSpec); i { case 0: return &v.state case 1: @@ -3892,7 +4648,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TCPProbeSpec); i { + switch v := v.(*PortRange); i { case 0: return &v.state case 1: @@ -3904,7 +4660,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TimeServerSpecSpec); i { + switch v := v.(*ProbeSpecSpec); i { case 0: return &v.state case 1: @@ -3916,7 +4672,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TimeServerStatusSpec); i { + switch v := v.(*ProbeStatusSpec); i { case 0: return &v.state case 1: @@ -3928,7 +4684,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VIPEquinixMetalSpec); i { + switch v := v.(*ResolverSpecSpec); i { case 0: return &v.state case 1: @@ -3940,7 +4696,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VIPHCloudSpec); i { + switch v := v.(*ResolverStatusSpec); i { case 0: return &v.state case 1: @@ -3952,7 +4708,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VIPOperatorSpec); i { + switch v := v.(*RouteSpecSpec); i { case 0: return &v.state case 1: @@ -3964,7 +4720,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*VLANSpec); i { + switch v := v.(*RouteStatusSpec); i { case 0: return &v.state case 1: @@ -3976,7 +4732,7 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*WireguardPeer); i { + switch v := v.(*STPSpec); i { case 0: return &v.state case 1: @@ -3988,6 +4744,114 @@ func file_resource_definitions_network_network_proto_init() { } } file_resource_definitions_network_network_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StatusSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TCPProbeSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimeServerSpecSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimeServerStatusSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VIPEquinixMetalSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VIPHCloudSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VIPOperatorSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VLANSpec); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WireguardPeer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_resource_definitions_network_network_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WireguardSpec); i { case 0: return &v.state @@ -4006,7 +4870,7 @@ func file_resource_definitions_network_network_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_resource_definitions_network_network_proto_rawDesc, NumEnums: 0, - NumMessages: 34, + NumMessages: 43, NumExtensions: 0, NumServices: 0, }, diff --git a/pkg/machinery/api/resource/definitions/network/network_vtproto.pb.go b/pkg/machinery/api/resource/definitions/network/network_vtproto.pb.go index 1b925fd944..ef8c40de85 100644 --- a/pkg/machinery/api/resource/definitions/network/network_vtproto.pb.go +++ b/pkg/machinery/api/resource/definitions/network/network_vtproto.pb.go @@ -1300,7 +1300,7 @@ func (m *LinkStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *NodeAddressFilterSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesAddressMatch) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1313,12 +1313,12 @@ func (m *NodeAddressFilterSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *NodeAddressFilterSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesAddressMatch) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *NodeAddressFilterSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesAddressMatch) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1330,6 +1330,16 @@ func (m *NodeAddressFilterSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.Invert { + i-- + if m.Invert { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } if len(m.ExcludeSubnets) > 0 { for iNdEx := len(m.ExcludeSubnets) - 1; iNdEx >= 0; iNdEx-- { if vtmsg, ok := interface{}(m.ExcludeSubnets[iNdEx]).(interface { @@ -1381,7 +1391,7 @@ func (m *NodeAddressFilterSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *NodeAddressSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesChainSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1394,12 +1404,12 @@ func (m *NodeAddressSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *NodeAddressSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesChainSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *NodeAddressSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesChainSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1411,34 +1421,39 @@ func (m *NodeAddressSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.Addresses) > 0 { - for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { - if vtmsg, ok := interface{}(m.Addresses[iNdEx]).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Addresses[iNdEx]) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) + if len(m.Rules) > 0 { + for iNdEx := len(m.Rules) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Rules[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x22 } } + if m.Priority != 0 { + i = encodeVarint(dAtA, i, uint64(m.Priority)) + i-- + dAtA[i] = 0x18 + } + if m.Hook != 0 { + i = encodeVarint(dAtA, i, uint64(m.Hook)) + i-- + dAtA[i] = 0x10 + } + if len(m.Type) > 0 { + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarint(dAtA, i, uint64(len(m.Type))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } -func (m *OperatorSpecSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesClampMSS) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1451,12 +1466,12 @@ func (m *OperatorSpecSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *OperatorSpecSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesClampMSS) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *OperatorSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesClampMSS) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1468,67 +1483,16 @@ func (m *OperatorSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.ConfigLayer != 0 { - i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) - i-- - dAtA[i] = 0x38 - } - if m.Vip != nil { - size, err := m.Vip.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x32 - } - if m.Dhcp6 != nil { - size, err := m.Dhcp6.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x2a - } - if m.Dhcp4 != nil { - size, err := m.Dhcp4.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x22 - } - if m.RequireUp { - i-- - if m.RequireUp { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if len(m.LinkName) > 0 { - i -= len(m.LinkName) - copy(dAtA[i:], m.LinkName) - i = encodeVarint(dAtA, i, uint64(len(m.LinkName))) - i-- - dAtA[i] = 0x12 - } - if m.Operator != 0 { - i = encodeVarint(dAtA, i, uint64(m.Operator)) + if m.Mtu != 0 { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Mtu)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xd } return len(dAtA) - i, nil } -func (m *ProbeSpecSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesIfNameMatch) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1541,12 +1505,12 @@ func (m *ProbeSpecSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ProbeSpecSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesIfNameMatch) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *ProbeSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesIfNameMatch) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1558,52 +1522,22 @@ func (m *ProbeSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.ConfigLayer != 0 { - i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) - i-- - dAtA[i] = 0x20 - } - if m.Tcp != nil { - size, err := m.Tcp.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x1a - } - if m.FailureThreshold != 0 { - i = encodeVarint(dAtA, i, uint64(m.FailureThreshold)) + if m.Operator != 0 { + i = encodeVarint(dAtA, i, uint64(m.Operator)) i-- dAtA[i] = 0x10 } - if m.Interval != nil { - if vtmsg, ok := interface{}(m.Interval).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Interval) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } + if len(m.InterfaceName) > 0 { + i -= len(m.InterfaceName) + copy(dAtA[i:], m.InterfaceName) + i = encodeVarint(dAtA, i, uint64(len(m.InterfaceName))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ProbeStatusSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesLayer4Match) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1616,12 +1550,12 @@ func (m *ProbeStatusSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ProbeStatusSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesLayer4Match) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *ProbeStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesLayer4Match) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1633,27 +1567,35 @@ func (m *ProbeStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.LastError) > 0 { - i -= len(m.LastError) - copy(dAtA[i:], m.LastError) - i = encodeVarint(dAtA, i, uint64(len(m.LastError))) + if m.MatchDestinationPort != nil { + size, err := m.MatchDestinationPort.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x1a } - if m.Success { - i-- - if m.Success { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.MatchSourcePort != nil { + size, err := m.MatchSourcePort.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + if m.Protocol != 0 { + i = encodeVarint(dAtA, i, uint64(m.Protocol)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *ResolverSpecSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesMark) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1666,12 +1608,12 @@ func (m *ResolverSpecSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ResolverSpecSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesMark) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *ResolverSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesMark) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1683,39 +1625,25 @@ func (m *ResolverSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.ConfigLayer != 0 { - i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + if m.Value != 0 { + i = encodeVarint(dAtA, i, uint64(m.Value)) + i-- + dAtA[i] = 0x18 + } + if m.Xor != 0 { + i = encodeVarint(dAtA, i, uint64(m.Xor)) i-- dAtA[i] = 0x10 } - if len(m.DnsServers) > 0 { - for iNdEx := len(m.DnsServers) - 1; iNdEx >= 0; iNdEx-- { - if vtmsg, ok := interface{}(m.DnsServers[iNdEx]).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.DnsServers[iNdEx]) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } - i-- - dAtA[i] = 0xa - } + if m.Mask != 0 { + i = encodeVarint(dAtA, i, uint64(m.Mask)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *ResolverStatusSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesPortMatch) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1728,12 +1656,12 @@ func (m *ResolverStatusSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ResolverStatusSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesPortMatch) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *ResolverStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesPortMatch) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1745,26 +1673,14 @@ func (m *ResolverStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.DnsServers) > 0 { - for iNdEx := len(m.DnsServers) - 1; iNdEx >= 0; iNdEx-- { - if vtmsg, ok := interface{}(m.DnsServers[iNdEx]).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.DnsServers[iNdEx]) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) + if len(m.Ranges) > 0 { + for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Ranges[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0xa } @@ -1772,7 +1688,7 @@ func (m *ResolverStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *RouteSpecSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NfTablesRule) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1785,12 +1701,12 @@ func (m *RouteSpecSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RouteSpecSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NfTablesRule) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *RouteSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NfTablesRule) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1802,128 +1718,95 @@ func (m *RouteSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Mtu != 0 { - i = encodeVarint(dAtA, i, uint64(m.Mtu)) - i-- - dAtA[i] = 0x68 - } - if m.ConfigLayer != 0 { - i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + if m.ClampMss != nil { + size, err := m.ClampMss.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x60 + dAtA[i] = 0x4a } - if m.Protocol != 0 { - i = encodeVarint(dAtA, i, uint64(m.Protocol)) - i-- - dAtA[i] = 0x58 - } - if m.Flags != 0 { - i = encodeVarint(dAtA, i, uint64(m.Flags)) - i-- - dAtA[i] = 0x50 - } - if m.Type != 0 { - i = encodeVarint(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x48 - } - if m.Scope != 0 { - i = encodeVarint(dAtA, i, uint64(m.Scope)) + if m.MatchIIfName != nil { + size, err := m.MatchIIfName.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x40 + dAtA[i] = 0x42 } - if m.Priority != 0 { - i = encodeVarint(dAtA, i, uint64(m.Priority)) + if m.MatchLayer4 != nil { + size, err := m.MatchLayer4.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x38 + dAtA[i] = 0x3a } - if m.Table != 0 { - i = encodeVarint(dAtA, i, uint64(m.Table)) + if m.MatchDestinationAddress != nil { + size, err := m.MatchDestinationAddress.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x30 + dAtA[i] = 0x32 } - if len(m.OutLinkName) > 0 { - i -= len(m.OutLinkName) - copy(dAtA[i:], m.OutLinkName) - i = encodeVarint(dAtA, i, uint64(len(m.OutLinkName))) + if m.MatchSourceAddress != nil { + size, err := m.MatchSourceAddress.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x2a } - if m.Gateway != nil { - if vtmsg, ok := interface{}(m.Gateway).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Gateway) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) + if m.SetMark != nil { + size, err := m.SetMark.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x22 } - if m.Source != nil { - if vtmsg, ok := interface{}(m.Source).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Source) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) + if m.MatchMark != nil { + size, err := m.MatchMark.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x1a } - if m.Destination != nil { - if vtmsg, ok := interface{}(m.Destination).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Destination) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } + if m.Verdict != 0 { + i = encodeVarint(dAtA, i, uint64(m.Verdict)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x10 } - if m.Family != 0 { - i = encodeVarint(dAtA, i, uint64(m.Family)) + if m.MatchOIfName != nil { + size, err := m.MatchOIfName.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *RouteStatusSpec) MarshalVT() (dAtA []byte, err error) { +func (m *NodeAddressFilterSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -1936,12 +1819,12 @@ func (m *RouteStatusSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *RouteStatusSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *NodeAddressFilterSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *RouteStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NodeAddressFilterSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -1953,128 +1836,115 @@ func (m *RouteStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Mtu != 0 { - i = encodeVarint(dAtA, i, uint64(m.Mtu)) - i-- - dAtA[i] = 0x68 - } - if m.Protocol != 0 { - i = encodeVarint(dAtA, i, uint64(m.Protocol)) - i-- - dAtA[i] = 0x60 - } - if m.Flags != 0 { - i = encodeVarint(dAtA, i, uint64(m.Flags)) - i-- - dAtA[i] = 0x58 - } - if m.Type != 0 { - i = encodeVarint(dAtA, i, uint64(m.Type)) - i-- - dAtA[i] = 0x50 + if len(m.ExcludeSubnets) > 0 { + for iNdEx := len(m.ExcludeSubnets) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.ExcludeSubnets[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.ExcludeSubnets[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0x12 + } } - if m.Scope != 0 { - i = encodeVarint(dAtA, i, uint64(m.Scope)) - i-- - dAtA[i] = 0x48 + if len(m.IncludeSubnets) > 0 { + for iNdEx := len(m.IncludeSubnets) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.IncludeSubnets[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.IncludeSubnets[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0xa + } } - if m.Priority != 0 { - i = encodeVarint(dAtA, i, uint64(m.Priority)) - i-- - dAtA[i] = 0x40 + return len(dAtA) - i, nil +} + +func (m *NodeAddressSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if m.Table != 0 { - i = encodeVarint(dAtA, i, uint64(m.Table)) - i-- - dAtA[i] = 0x38 + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - if len(m.OutLinkName) > 0 { - i -= len(m.OutLinkName) - copy(dAtA[i:], m.OutLinkName) - i = encodeVarint(dAtA, i, uint64(len(m.OutLinkName))) - i-- - dAtA[i] = 0x32 + return dAtA[:n], nil +} + +func (m *NodeAddressSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *NodeAddressSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil } - if m.OutLinkIndex != 0 { - i = encodeVarint(dAtA, i, uint64(m.OutLinkIndex)) - i-- - dAtA[i] = 0x28 + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.Gateway != nil { - if vtmsg, ok := interface{}(m.Gateway).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Gateway) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } - i-- - dAtA[i] = 0x22 - } - if m.Source != nil { - if vtmsg, ok := interface{}(m.Source).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Source) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } - i-- - dAtA[i] = 0x1a - } - if m.Destination != nil { - if vtmsg, ok := interface{}(m.Destination).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.Destination) - if err != nil { - return 0, err + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.Addresses[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.Addresses[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa } - i-- - dAtA[i] = 0x12 - } - if m.Family != 0 { - i = encodeVarint(dAtA, i, uint64(m.Family)) - i-- - dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *STPSpec) MarshalVT() (dAtA []byte, err error) { +func (m *OperatorSpecSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2087,12 +1957,12 @@ func (m *STPSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *STPSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *OperatorSpecSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *STPSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *OperatorSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2104,20 +1974,67 @@ func (m *STPSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Enabled { + if m.ConfigLayer != 0 { + i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) i-- - if m.Enabled { + dAtA[i] = 0x38 + } + if m.Vip != nil { + size, err := m.Vip.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x32 + } + if m.Dhcp6 != nil { + size, err := m.Dhcp6.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } + if m.Dhcp4 != nil { + size, err := m.Dhcp4.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.RequireUp { + i-- + if m.RequireUp { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- + dAtA[i] = 0x18 + } + if len(m.LinkName) > 0 { + i -= len(m.LinkName) + copy(dAtA[i:], m.LinkName) + i = encodeVarint(dAtA, i, uint64(len(m.LinkName))) + i-- + dAtA[i] = 0x12 + } + if m.Operator != 0 { + i = encodeVarint(dAtA, i, uint64(m.Operator)) + i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *StatusSpec) MarshalVT() (dAtA []byte, err error) { +func (m *PortRange) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2130,12 +2047,12 @@ func (m *StatusSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *StatusSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *PortRange) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *StatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *PortRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2147,50 +2064,22 @@ func (m *StatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.EtcFilesReady { - i-- - if m.EtcFilesReady { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x20 - } - if m.HostnameReady { - i-- - if m.HostnameReady { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x18 - } - if m.ConnectivityReady { - i-- - if m.ConnectivityReady { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } + if m.Hi != 0 { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Hi)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x15 } - if m.AddressReady { - i-- - if m.AddressReady { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } + if m.Lo != 0 { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Lo)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xd } return len(dAtA) - i, nil } -func (m *TCPProbeSpec) MarshalVT() (dAtA []byte, err error) { +func (m *ProbeSpecSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2203,12 +2092,12 @@ func (m *TCPProbeSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TCPProbeSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *ProbeSpecSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *TCPProbeSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ProbeSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2220,8 +2109,28 @@ func (m *TCPProbeSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Timeout != nil { - if vtmsg, ok := interface{}(m.Timeout).(interface { + if m.ConfigLayer != 0 { + i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + i-- + dAtA[i] = 0x20 + } + if m.Tcp != nil { + size, err := m.Tcp.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.FailureThreshold != 0 { + i = encodeVarint(dAtA, i, uint64(m.FailureThreshold)) + i-- + dAtA[i] = 0x10 + } + if m.Interval != nil { + if vtmsg, ok := interface{}(m.Interval).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) @@ -2231,7 +2140,7 @@ func (m *TCPProbeSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = encodeVarint(dAtA, i, uint64(size)) } else { - encoded, err := proto.Marshal(m.Timeout) + encoded, err := proto.Marshal(m.Interval) if err != nil { return 0, err } @@ -2240,19 +2149,12 @@ func (m *TCPProbeSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i = encodeVarint(dAtA, i, uint64(len(encoded))) } i-- - dAtA[i] = 0x12 - } - if len(m.Endpoint) > 0 { - i -= len(m.Endpoint) - copy(dAtA[i:], m.Endpoint) - i = encodeVarint(dAtA, i, uint64(len(m.Endpoint))) - i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *TimeServerSpecSpec) MarshalVT() (dAtA []byte, err error) { +func (m *ProbeStatusSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2265,12 +2167,12 @@ func (m *TimeServerSpecSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TimeServerSpecSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *ProbeStatusSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *TimeServerSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ProbeStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2282,24 +2184,27 @@ func (m *TimeServerSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.ConfigLayer != 0 { - i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + if len(m.LastError) > 0 { + i -= len(m.LastError) + copy(dAtA[i:], m.LastError) + i = encodeVarint(dAtA, i, uint64(len(m.LastError))) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x12 } - if len(m.NtpServers) > 0 { - for iNdEx := len(m.NtpServers) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.NtpServers[iNdEx]) - copy(dAtA[i:], m.NtpServers[iNdEx]) - i = encodeVarint(dAtA, i, uint64(len(m.NtpServers[iNdEx]))) - i-- - dAtA[i] = 0xa + if m.Success { + i-- + if m.Success { + dAtA[i] = 1 + } else { + dAtA[i] = 0 } + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *TimeServerStatusSpec) MarshalVT() (dAtA []byte, err error) { +func (m *ResolverSpecSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2312,12 +2217,12 @@ func (m *TimeServerStatusSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *TimeServerStatusSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *ResolverSpecSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *TimeServerStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ResolverSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2329,11 +2234,31 @@ func (m *TimeServerStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.NtpServers) > 0 { - for iNdEx := len(m.NtpServers) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.NtpServers[iNdEx]) - copy(dAtA[i:], m.NtpServers[iNdEx]) - i = encodeVarint(dAtA, i, uint64(len(m.NtpServers[iNdEx]))) + if m.ConfigLayer != 0 { + i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + i-- + dAtA[i] = 0x10 + } + if len(m.DnsServers) > 0 { + for iNdEx := len(m.DnsServers) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.DnsServers[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.DnsServers[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } i-- dAtA[i] = 0xa } @@ -2341,7 +2266,7 @@ func (m *TimeServerStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *VIPEquinixMetalSpec) MarshalVT() (dAtA []byte, err error) { +func (m *ResolverStatusSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2354,12 +2279,12 @@ func (m *VIPEquinixMetalSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *VIPEquinixMetalSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *ResolverStatusSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *VIPEquinixMetalSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ResolverStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2371,31 +2296,34 @@ func (m *VIPEquinixMetalSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.ApiToken) > 0 { - i -= len(m.ApiToken) - copy(dAtA[i:], m.ApiToken) - i = encodeVarint(dAtA, i, uint64(len(m.ApiToken))) - i-- - dAtA[i] = 0x1a - } - if len(m.DeviceId) > 0 { - i -= len(m.DeviceId) - copy(dAtA[i:], m.DeviceId) - i = encodeVarint(dAtA, i, uint64(len(m.DeviceId))) - i-- - dAtA[i] = 0x12 - } - if len(m.ProjectId) > 0 { - i -= len(m.ProjectId) - copy(dAtA[i:], m.ProjectId) - i = encodeVarint(dAtA, i, uint64(len(m.ProjectId))) - i-- - dAtA[i] = 0xa + if len(m.DnsServers) > 0 { + for iNdEx := len(m.DnsServers) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.DnsServers[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.DnsServers[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0xa + } } return len(dAtA) - i, nil } -func (m *VIPHCloudSpec) MarshalVT() (dAtA []byte, err error) { +func (m *RouteSpecSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2408,12 +2336,12 @@ func (m *VIPHCloudSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *VIPHCloudSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *RouteSpecSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *VIPHCloudSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *RouteSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2425,88 +2353,99 @@ func (m *VIPHCloudSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.ApiToken) > 0 { - i -= len(m.ApiToken) - copy(dAtA[i:], m.ApiToken) - i = encodeVarint(dAtA, i, uint64(len(m.ApiToken))) + if m.Mtu != 0 { + i = encodeVarint(dAtA, i, uint64(m.Mtu)) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x68 } - if m.NetworkId != 0 { - i = encodeVarint(dAtA, i, uint64(m.NetworkId)) + if m.ConfigLayer != 0 { + i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x60 } - if m.DeviceId != 0 { - i = encodeVarint(dAtA, i, uint64(m.DeviceId)) + if m.Protocol != 0 { + i = encodeVarint(dAtA, i, uint64(m.Protocol)) i-- - dAtA[i] = 0x8 + dAtA[i] = 0x58 } - return len(dAtA) - i, nil -} - -func (m *VIPOperatorSpec) MarshalVT() (dAtA []byte, err error) { - if m == nil { - return nil, nil + if m.Flags != 0 { + i = encodeVarint(dAtA, i, uint64(m.Flags)) + i-- + dAtA[i] = 0x50 } - size := m.SizeVT() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) - if err != nil { - return nil, err + if m.Type != 0 { + i = encodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x48 } - return dAtA[:n], nil -} - -func (m *VIPOperatorSpec) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *VIPOperatorSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - if m == nil { - return 0, nil + if m.Scope != 0 { + i = encodeVarint(dAtA, i, uint64(m.Scope)) + i-- + dAtA[i] = 0x40 } - i := len(dAtA) - _ = i - var l int - _ = l - if m.unknownFields != nil { - i -= len(m.unknownFields) - copy(dAtA[i:], m.unknownFields) + if m.Priority != 0 { + i = encodeVarint(dAtA, i, uint64(m.Priority)) + i-- + dAtA[i] = 0x38 } - if m.HCloud != nil { - size, err := m.HCloud.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) + if m.Table != 0 { + i = encodeVarint(dAtA, i, uint64(m.Table)) i-- - dAtA[i] = 0x22 + dAtA[i] = 0x30 } - if m.EquinixMetal != nil { - size, err := m.EquinixMetal.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) + if len(m.OutLinkName) > 0 { + i -= len(m.OutLinkName) + copy(dAtA[i:], m.OutLinkName) + i = encodeVarint(dAtA, i, uint64(len(m.OutLinkName))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x2a } - if m.GratuitousArp { + if m.Gateway != nil { + if vtmsg, ok := interface{}(m.Gateway).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.Gateway) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } i-- - if m.GratuitousArp { - dAtA[i] = 1 + dAtA[i] = 0x22 + } + if m.Source != nil { + if vtmsg, ok := interface{}(m.Source).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) } else { - dAtA[i] = 0 + encoded, err := proto.Marshal(m.Source) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) } i-- - dAtA[i] = 0x10 + dAtA[i] = 0x1a } - if m.Ip != nil { - if vtmsg, ok := interface{}(m.Ip).(interface { + if m.Destination != nil { + if vtmsg, ok := interface{}(m.Destination).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) @@ -2516,7 +2455,7 @@ func (m *VIPOperatorSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = encodeVarint(dAtA, i, uint64(size)) } else { - encoded, err := proto.Marshal(m.Ip) + encoded, err := proto.Marshal(m.Destination) if err != nil { return 0, err } @@ -2525,12 +2464,17 @@ func (m *VIPOperatorSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i = encodeVarint(dAtA, i, uint64(len(encoded))) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 + } + if m.Family != 0 { + i = encodeVarint(dAtA, i, uint64(m.Family)) + i-- + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *VLANSpec) MarshalVT() (dAtA []byte, err error) { +func (m *RouteStatusSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2543,12 +2487,12 @@ func (m *VLANSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *VLANSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *RouteStatusSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *VLANSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *RouteStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2560,76 +2504,55 @@ func (m *VLANSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.Mtu != 0 { + i = encodeVarint(dAtA, i, uint64(m.Mtu)) + i-- + dAtA[i] = 0x68 + } if m.Protocol != 0 { i = encodeVarint(dAtA, i, uint64(m.Protocol)) i-- - dAtA[i] = 0x10 + dAtA[i] = 0x60 } - if m.Vid != 0 { - i -= 4 - binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Vid)) + if m.Flags != 0 { + i = encodeVarint(dAtA, i, uint64(m.Flags)) i-- - dAtA[i] = 0xd - } - return len(dAtA) - i, nil -} - -func (m *WireguardPeer) MarshalVT() (dAtA []byte, err error) { - if m == nil { - return nil, nil + dAtA[i] = 0x58 } - size := m.SizeVT() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) - if err != nil { - return nil, err + if m.Type != 0 { + i = encodeVarint(dAtA, i, uint64(m.Type)) + i-- + dAtA[i] = 0x50 } - return dAtA[:n], nil -} - -func (m *WireguardPeer) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *WireguardPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - if m == nil { - return 0, nil + if m.Scope != 0 { + i = encodeVarint(dAtA, i, uint64(m.Scope)) + i-- + dAtA[i] = 0x48 } - i := len(dAtA) - _ = i - var l int - _ = l - if m.unknownFields != nil { - i -= len(m.unknownFields) - copy(dAtA[i:], m.unknownFields) + if m.Priority != 0 { + i = encodeVarint(dAtA, i, uint64(m.Priority)) + i-- + dAtA[i] = 0x40 } - if len(m.AllowedIps) > 0 { - for iNdEx := len(m.AllowedIps) - 1; iNdEx >= 0; iNdEx-- { - if vtmsg, ok := interface{}(m.AllowedIps[iNdEx]).(interface { - MarshalToSizedBufferVT([]byte) (int, error) - }); ok { - size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - } else { - encoded, err := proto.Marshal(m.AllowedIps[iNdEx]) - if err != nil { - return 0, err - } - i -= len(encoded) - copy(dAtA[i:], encoded) - i = encodeVarint(dAtA, i, uint64(len(encoded))) - } - i-- - dAtA[i] = 0x2a - } + if m.Table != 0 { + i = encodeVarint(dAtA, i, uint64(m.Table)) + i-- + dAtA[i] = 0x38 } - if m.PersistentKeepaliveInterval != nil { - if vtmsg, ok := interface{}(m.PersistentKeepaliveInterval).(interface { + if len(m.OutLinkName) > 0 { + i -= len(m.OutLinkName) + copy(dAtA[i:], m.OutLinkName) + i = encodeVarint(dAtA, i, uint64(len(m.OutLinkName))) + i-- + dAtA[i] = 0x32 + } + if m.OutLinkIndex != 0 { + i = encodeVarint(dAtA, i, uint64(m.OutLinkIndex)) + i-- + dAtA[i] = 0x28 + } + if m.Gateway != nil { + if vtmsg, ok := interface{}(m.Gateway).(interface { MarshalToSizedBufferVT([]byte) (int, error) }); ok { size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) @@ -2639,7 +2562,7 @@ func (m *WireguardPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= size i = encodeVarint(dAtA, i, uint64(size)) } else { - encoded, err := proto.Marshal(m.PersistentKeepaliveInterval) + encoded, err := proto.Marshal(m.Gateway) if err != nil { return 0, err } @@ -2650,31 +2573,59 @@ func (m *WireguardPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i-- dAtA[i] = 0x22 } - if len(m.Endpoint) > 0 { - i -= len(m.Endpoint) - copy(dAtA[i:], m.Endpoint) - i = encodeVarint(dAtA, i, uint64(len(m.Endpoint))) + if m.Source != nil { + if vtmsg, ok := interface{}(m.Source).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.Source) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } i-- dAtA[i] = 0x1a } - if len(m.PresharedKey) > 0 { - i -= len(m.PresharedKey) - copy(dAtA[i:], m.PresharedKey) - i = encodeVarint(dAtA, i, uint64(len(m.PresharedKey))) + if m.Destination != nil { + if vtmsg, ok := interface{}(m.Destination).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.Destination) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } i-- dAtA[i] = 0x12 } - if len(m.PublicKey) > 0 { - i -= len(m.PublicKey) - copy(dAtA[i:], m.PublicKey) - i = encodeVarint(dAtA, i, uint64(len(m.PublicKey))) + if m.Family != 0 { + i = encodeVarint(dAtA, i, uint64(m.Family)) i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func (m *WireguardSpec) MarshalVT() (dAtA []byte, err error) { +func (m *STPSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -2687,12 +2638,12 @@ func (m *WireguardSpec) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *WireguardSpec) MarshalToVT(dAtA []byte) (int, error) { +func (m *STPSpec) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *WireguardSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *STPSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -2704,457 +2655,687 @@ func (m *WireguardSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.Peers) > 0 { - for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { - size, err := m.Peers[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x2a - } - } - if m.FirewallMark != 0 { - i = encodeVarint(dAtA, i, uint64(m.FirewallMark)) - i-- - dAtA[i] = 0x20 - } - if m.ListenPort != 0 { - i = encodeVarint(dAtA, i, uint64(m.ListenPort)) - i-- - dAtA[i] = 0x18 - } - if len(m.PublicKey) > 0 { - i -= len(m.PublicKey) - copy(dAtA[i:], m.PublicKey) - i = encodeVarint(dAtA, i, uint64(len(m.PublicKey))) + if m.Enabled { i-- - dAtA[i] = 0x12 - } - if len(m.PrivateKey) > 0 { - i -= len(m.PrivateKey) - copy(dAtA[i:], m.PrivateKey) - i = encodeVarint(dAtA, i, uint64(len(m.PrivateKey))) + if m.Enabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } i-- - dAtA[i] = 0xa + dAtA[i] = 0x8 } return len(dAtA) - i, nil } -func encodeVarint(dAtA []byte, offset int, v uint64) int { - offset -= sov(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *StatusSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - dAtA[offset] = uint8(v) - return base + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil } -func (m *AddressSpecSpec) SizeVT() (n int) { + +func (m *StatusSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *StatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - if m.Address != nil { - if size, ok := interface{}(m.Address).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if m.EtcFilesReady { + i-- + if m.EtcFilesReady { + dAtA[i] = 1 } else { - l = proto.Size(m.Address) + dAtA[i] = 0 } - n += 1 + l + sov(uint64(l)) - } - l = len(m.LinkName) - if l > 0 { - n += 1 + l + sov(uint64(l)) + i-- + dAtA[i] = 0x20 } - if m.Family != 0 { - n += 1 + sov(uint64(m.Family)) + if m.HostnameReady { + i-- + if m.HostnameReady { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 } - if m.Scope != 0 { - n += 1 + sov(uint64(m.Scope)) + if m.ConnectivityReady { + i-- + if m.ConnectivityReady { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 } - if m.Flags != 0 { - n += 1 + sov(uint64(m.Flags)) + if m.AddressReady { + i-- + if m.AddressReady { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 } - if m.AnnounceWithArp { - n += 2 + return len(dAtA) - i, nil +} + +func (m *TCPProbeSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if m.ConfigLayer != 0 { - n += 1 + sov(uint64(m.ConfigLayer)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *AddressStatusSpec) SizeVT() (n int) { +func (m *TCPProbeSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *TCPProbeSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - if m.Address != nil { - if size, ok := interface{}(m.Address).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Address) - } - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.Local != nil { - if size, ok := interface{}(m.Local).(interface { - SizeVT() int + if m.Timeout != nil { + if vtmsg, ok := interface{}(m.Timeout).(interface { + MarshalToSizedBufferVT([]byte) (int, error) }); ok { - l = size.SizeVT() + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) } else { - l = proto.Size(m.Local) + encoded, err := proto.Marshal(m.Timeout) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) } - n += 1 + l + sov(uint64(l)) + i-- + dAtA[i] = 0x12 } - if m.Broadcast != nil { - if size, ok := interface{}(m.Broadcast).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Broadcast) - } - n += 1 + l + sov(uint64(l)) + if len(m.Endpoint) > 0 { + i -= len(m.Endpoint) + copy(dAtA[i:], m.Endpoint) + i = encodeVarint(dAtA, i, uint64(len(m.Endpoint))) + i-- + dAtA[i] = 0xa } - if m.Anycast != nil { - if size, ok := interface{}(m.Anycast).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Anycast) - } - n += 1 + l + sov(uint64(l)) + return len(dAtA) - i, nil +} + +func (m *TimeServerSpecSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if m.Multicast != nil { - if size, ok := interface{}(m.Multicast).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Multicast) - } - n += 1 + l + sov(uint64(l)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - if m.LinkIndex != 0 { - n += 1 + sov(uint64(m.LinkIndex)) + return dAtA[:n], nil +} + +func (m *TimeServerSpecSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *TimeServerSpecSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil } - l = len(m.LinkName) - if l > 0 { - n += 1 + l + sov(uint64(l)) + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.Family != 0 { - n += 1 + sov(uint64(m.Family)) + if m.ConfigLayer != 0 { + i = encodeVarint(dAtA, i, uint64(m.ConfigLayer)) + i-- + dAtA[i] = 0x10 } - if m.Scope != 0 { - n += 1 + sov(uint64(m.Scope)) + if len(m.NtpServers) > 0 { + for iNdEx := len(m.NtpServers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NtpServers[iNdEx]) + copy(dAtA[i:], m.NtpServers[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.NtpServers[iNdEx]))) + i-- + dAtA[i] = 0xa + } } - if m.Flags != 0 { - n += 1 + sov(uint64(m.Flags)) + return len(dAtA) - i, nil +} + +func (m *TimeServerStatusSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - n += len(m.unknownFields) - return n + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil } -func (m *BondMasterSpec) SizeVT() (n int) { +func (m *TimeServerStatusSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *TimeServerStatusSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - if m.Mode != 0 { - n += 1 + sov(uint64(m.Mode)) - } - if m.HashPolicy != 0 { - n += 1 + sov(uint64(m.HashPolicy)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.LacpRate != 0 { - n += 1 + sov(uint64(m.LacpRate)) + if len(m.NtpServers) > 0 { + for iNdEx := len(m.NtpServers) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.NtpServers[iNdEx]) + copy(dAtA[i:], m.NtpServers[iNdEx]) + i = encodeVarint(dAtA, i, uint64(len(m.NtpServers[iNdEx]))) + i-- + dAtA[i] = 0xa + } } - if m.ArpValidate != 0 { - n += 1 + sov(uint64(m.ArpValidate)) + return len(dAtA) - i, nil +} + +func (m *VIPEquinixMetalSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if m.ArpAllTargets != 0 { - n += 1 + sov(uint64(m.ArpAllTargets)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - if m.PrimaryIndex != 0 { - n += 1 + sov(uint64(m.PrimaryIndex)) + return dAtA[:n], nil +} + +func (m *VIPEquinixMetalSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VIPEquinixMetalSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil } - if m.PrimaryReselect != 0 { - n += 1 + sov(uint64(m.PrimaryReselect)) + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.FailOverMac != 0 { - n += 1 + sov(uint64(m.FailOverMac)) + if len(m.ApiToken) > 0 { + i -= len(m.ApiToken) + copy(dAtA[i:], m.ApiToken) + i = encodeVarint(dAtA, i, uint64(len(m.ApiToken))) + i-- + dAtA[i] = 0x1a } - if m.AdSelect != 0 { - n += 1 + sov(uint64(m.AdSelect)) + if len(m.DeviceId) > 0 { + i -= len(m.DeviceId) + copy(dAtA[i:], m.DeviceId) + i = encodeVarint(dAtA, i, uint64(len(m.DeviceId))) + i-- + dAtA[i] = 0x12 } - if m.MiiMon != 0 { - n += 1 + sov(uint64(m.MiiMon)) - } - if m.UpDelay != 0 { - n += 1 + sov(uint64(m.UpDelay)) - } - if m.DownDelay != 0 { - n += 1 + sov(uint64(m.DownDelay)) - } - if m.ArpInterval != 0 { - n += 1 + sov(uint64(m.ArpInterval)) - } - if m.ResendIgmp != 0 { - n += 1 + sov(uint64(m.ResendIgmp)) - } - if m.MinLinks != 0 { - n += 1 + sov(uint64(m.MinLinks)) - } - if m.LpInterval != 0 { - n += 2 + sov(uint64(m.LpInterval)) - } - if m.PacketsPerSlave != 0 { - n += 2 + sov(uint64(m.PacketsPerSlave)) - } - if m.NumPeerNotif != 0 { - n += 6 - } - if m.TlbDynamicLb != 0 { - n += 6 - } - if m.AllSlavesActive != 0 { - n += 6 - } - if m.UseCarrier { - n += 3 - } - if m.AdActorSysPrio != 0 { - n += 6 + if len(m.ProjectId) > 0 { + i -= len(m.ProjectId) + copy(dAtA[i:], m.ProjectId) + i = encodeVarint(dAtA, i, uint64(len(m.ProjectId))) + i-- + dAtA[i] = 0xa } - if m.AdUserPortKey != 0 { - n += 6 + return len(dAtA) - i, nil +} + +func (m *VIPHCloudSpec) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil } - if m.PeerNotifyDelay != 0 { - n += 2 + sov(uint64(m.PeerNotifyDelay)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *BondSlave) SizeVT() (n int) { +func (m *VIPHCloudSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VIPHCloudSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - l = len(m.MasterName) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.SlaveIndex != 0 { - n += 1 + sov(uint64(m.SlaveIndex)) + if len(m.ApiToken) > 0 { + i -= len(m.ApiToken) + copy(dAtA[i:], m.ApiToken) + i = encodeVarint(dAtA, i, uint64(len(m.ApiToken))) + i-- + dAtA[i] = 0x1a } - n += len(m.unknownFields) - return n + if m.NetworkId != 0 { + i = encodeVarint(dAtA, i, uint64(m.NetworkId)) + i-- + dAtA[i] = 0x10 + } + if m.DeviceId != 0 { + i = encodeVarint(dAtA, i, uint64(m.DeviceId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil } -func (m *BridgeMasterSpec) SizeVT() (n int) { +func (m *VIPOperatorSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { - return 0 + return nil, nil } - var l int - _ = l - if m.Stp != nil { - l = m.Stp.SizeVT() - n += 1 + l + sov(uint64(l)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *BridgeSlave) SizeVT() (n int) { +func (m *VIPOperatorSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VIPOperatorSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - l = len(m.MasterName) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - n += len(m.unknownFields) - return n + if m.HCloud != nil { + size, err := m.HCloud.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } + if m.EquinixMetal != nil { + size, err := m.EquinixMetal.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a + } + if m.GratuitousArp { + i-- + if m.GratuitousArp { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.Ip != nil { + if vtmsg, ok := interface{}(m.Ip).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.Ip) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil } -func (m *DHCP4OperatorSpec) SizeVT() (n int) { +func (m *VLANSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { - return 0 - } - var l int - _ = l - if m.RouteMetric != 0 { - n += 1 + sov(uint64(m.RouteMetric)) + return nil, nil } - if m.SkipHostnameRequest { - n += 2 + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *DHCP6OperatorSpec) SizeVT() (n int) { +func (m *VLANSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *VLANSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Duid) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.RouteMetric != 0 { - n += 1 + sov(uint64(m.RouteMetric)) + if m.Protocol != 0 { + i = encodeVarint(dAtA, i, uint64(m.Protocol)) + i-- + dAtA[i] = 0x10 } - if m.SkipHostnameRequest { - n += 2 + if m.Vid != 0 { + i -= 4 + binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Vid)) + i-- + dAtA[i] = 0xd } - n += len(m.unknownFields) - return n + return len(dAtA) - i, nil } -func (m *HardwareAddrSpec) SizeVT() (n int) { +func (m *WireguardPeer) MarshalVT() (dAtA []byte, err error) { if m == nil { - return 0 + return nil, nil } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sov(uint64(l)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.HardwareAddr) - if l > 0 { - n += 1 + l + sov(uint64(l)) - } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *HostnameSpecSpec) SizeVT() (n int) { +func (m *WireguardPeer) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *WireguardPeer) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Hostname) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - l = len(m.Domainname) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if len(m.AllowedIps) > 0 { + for iNdEx := len(m.AllowedIps) - 1; iNdEx >= 0; iNdEx-- { + if vtmsg, ok := interface{}(m.AllowedIps[iNdEx]).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.AllowedIps[iNdEx]) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0x2a + } } - if m.ConfigLayer != 0 { - n += 1 + sov(uint64(m.ConfigLayer)) + if m.PersistentKeepaliveInterval != nil { + if vtmsg, ok := interface{}(m.PersistentKeepaliveInterval).(interface { + MarshalToSizedBufferVT([]byte) (int, error) + }); ok { + size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + } else { + encoded, err := proto.Marshal(m.PersistentKeepaliveInterval) + if err != nil { + return 0, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = encodeVarint(dAtA, i, uint64(len(encoded))) + } + i-- + dAtA[i] = 0x22 } - n += len(m.unknownFields) - return n -} - -func (m *HostnameStatusSpec) SizeVT() (n int) { - if m == nil { - return 0 + if len(m.Endpoint) > 0 { + i -= len(m.Endpoint) + copy(dAtA[i:], m.Endpoint) + i = encodeVarint(dAtA, i, uint64(len(m.Endpoint))) + i-- + dAtA[i] = 0x1a } - var l int - _ = l - l = len(m.Hostname) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if len(m.PresharedKey) > 0 { + i -= len(m.PresharedKey) + copy(dAtA[i:], m.PresharedKey) + i = encodeVarint(dAtA, i, uint64(len(m.PresharedKey))) + i-- + dAtA[i] = 0x12 } - l = len(m.Domainname) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if len(m.PublicKey) > 0 { + i -= len(m.PublicKey) + copy(dAtA[i:], m.PublicKey) + i = encodeVarint(dAtA, i, uint64(len(m.PublicKey))) + i-- + dAtA[i] = 0xa } - n += len(m.unknownFields) - return n + return len(dAtA) - i, nil } -func (m *LinkRefreshSpec) SizeVT() (n int) { +func (m *WireguardSpec) MarshalVT() (dAtA []byte, err error) { if m == nil { - return 0 + return nil, nil } - var l int - _ = l - if m.Generation != 0 { - n += 1 + sov(uint64(m.Generation)) + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err } - n += len(m.unknownFields) - return n + return dAtA[:n], nil } -func (m *LinkSpecSpec) SizeVT() (n int) { +func (m *WireguardSpec) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *WireguardSpec) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { - return 0 + return 0, nil } + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) } - if m.Logical { - n += 2 + if len(m.Peers) > 0 { + for iNdEx := len(m.Peers) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Peers[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x2a + } } - if m.Up { - n += 2 + if m.FirewallMark != 0 { + i = encodeVarint(dAtA, i, uint64(m.FirewallMark)) + i-- + dAtA[i] = 0x20 } - if m.Mtu != 0 { - n += 1 + sov(uint64(m.Mtu)) + if m.ListenPort != 0 { + i = encodeVarint(dAtA, i, uint64(m.ListenPort)) + i-- + dAtA[i] = 0x18 } - l = len(m.Kind) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if len(m.PublicKey) > 0 { + i -= len(m.PublicKey) + copy(dAtA[i:], m.PublicKey) + i = encodeVarint(dAtA, i, uint64(len(m.PublicKey))) + i-- + dAtA[i] = 0x12 } - if m.Type != 0 { - n += 1 + sov(uint64(m.Type)) + if len(m.PrivateKey) > 0 { + i -= len(m.PrivateKey) + copy(dAtA[i:], m.PrivateKey) + i = encodeVarint(dAtA, i, uint64(len(m.PrivateKey))) + i-- + dAtA[i] = 0xa } - l = len(m.ParentName) - if l > 0 { - n += 1 + l + sov(uint64(l)) + return len(dAtA) - i, nil +} + +func encodeVarint(dAtA []byte, offset int, v uint64) int { + offset -= sov(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ } - if m.BondSlave != nil { - l = m.BondSlave.SizeVT() - n += 1 + l + sov(uint64(l)) + dAtA[offset] = uint8(v) + return base +} +func (m *AddressSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 } - if m.BridgeSlave != nil { - l = m.BridgeSlave.SizeVT() + var l int + _ = l + if m.Address != nil { + if size, ok := interface{}(m.Address).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Address) + } n += 1 + l + sov(uint64(l)) } - if m.Vlan != nil { - l = m.Vlan.SizeVT() + l = len(m.LinkName) + if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.BondMaster != nil { - l = m.BondMaster.SizeVT() - n += 1 + l + sov(uint64(l)) + if m.Family != 0 { + n += 1 + sov(uint64(m.Family)) } - if m.BridgeMaster != nil { - l = m.BridgeMaster.SizeVT() - n += 1 + l + sov(uint64(l)) + if m.Scope != 0 { + n += 1 + sov(uint64(m.Scope)) } - if m.Wireguard != nil { - l = m.Wireguard.SizeVT() - n += 1 + l + sov(uint64(l)) + if m.Flags != 0 { + n += 1 + sov(uint64(m.Flags)) + } + if m.AnnounceWithArp { + n += 2 } if m.ConfigLayer != 0 { n += 1 + sov(uint64(m.ConfigLayer)) @@ -3163,256 +3344,256 @@ func (m *LinkSpecSpec) SizeVT() (n int) { return n } -func (m *LinkStatusSpec) SizeVT() (n int) { +func (m *AddressStatusSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Index != 0 { - n += 1 + sov(uint64(m.Index)) - } - if m.Type != 0 { - n += 1 + sov(uint64(m.Type)) + if m.Address != nil { + if size, ok := interface{}(m.Address).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Address) + } + n += 1 + l + sov(uint64(l)) } - if m.LinkIndex != 0 { - n += 1 + sov(uint64(m.LinkIndex)) + if m.Local != nil { + if size, ok := interface{}(m.Local).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Local) + } + n += 1 + l + sov(uint64(l)) } - if m.Flags != 0 { - n += 1 + sov(uint64(m.Flags)) + if m.Broadcast != nil { + if size, ok := interface{}(m.Broadcast).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Broadcast) + } + n += 1 + l + sov(uint64(l)) } - l = len(m.HardwareAddr) - if l > 0 { + if m.Anycast != nil { + if size, ok := interface{}(m.Anycast).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Anycast) + } n += 1 + l + sov(uint64(l)) } - l = len(m.BroadcastAddr) - if l > 0 { + if m.Multicast != nil { + if size, ok := interface{}(m.Multicast).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Multicast) + } n += 1 + l + sov(uint64(l)) } - if m.Mtu != 0 { - n += 1 + sov(uint64(m.Mtu)) + if m.LinkIndex != 0 { + n += 1 + sov(uint64(m.LinkIndex)) } - l = len(m.QueueDisc) + l = len(m.LinkName) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.MasterIndex != 0 { - n += 1 + sov(uint64(m.MasterIndex)) + if m.Family != 0 { + n += 1 + sov(uint64(m.Family)) } - if m.OperationalState != 0 { - n += 1 + sov(uint64(m.OperationalState)) + if m.Scope != 0 { + n += 1 + sov(uint64(m.Scope)) } - l = len(m.Kind) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.Flags != 0 { + n += 1 + sov(uint64(m.Flags)) } - l = len(m.SlaveKind) - if l > 0 { - n += 1 + l + sov(uint64(l)) + n += len(m.unknownFields) + return n +} + +func (m *BondMasterSpec) SizeVT() (n int) { + if m == nil { + return 0 } - l = len(m.BusPath) - if l > 0 { - n += 1 + l + sov(uint64(l)) + var l int + _ = l + if m.Mode != 0 { + n += 1 + sov(uint64(m.Mode)) } - l = len(m.Pciid) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.HashPolicy != 0 { + n += 1 + sov(uint64(m.HashPolicy)) } - l = len(m.Driver) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.LacpRate != 0 { + n += 1 + sov(uint64(m.LacpRate)) } - l = len(m.DriverVersion) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.ArpValidate != 0 { + n += 1 + sov(uint64(m.ArpValidate)) } - l = len(m.FirmwareVersion) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.ArpAllTargets != 0 { + n += 1 + sov(uint64(m.ArpAllTargets)) } - l = len(m.ProductId) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.PrimaryIndex != 0 { + n += 1 + sov(uint64(m.PrimaryIndex)) } - l = len(m.VendorId) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.PrimaryReselect != 0 { + n += 1 + sov(uint64(m.PrimaryReselect)) } - l = len(m.Product) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.FailOverMac != 0 { + n += 1 + sov(uint64(m.FailOverMac)) } - l = len(m.Vendor) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.AdSelect != 0 { + n += 1 + sov(uint64(m.AdSelect)) } - if m.LinkState { - n += 3 + if m.MiiMon != 0 { + n += 1 + sov(uint64(m.MiiMon)) } - if m.SpeedMegabits != 0 { - n += 2 + sov(uint64(m.SpeedMegabits)) + if m.UpDelay != 0 { + n += 1 + sov(uint64(m.UpDelay)) } - if m.Port != 0 { - n += 2 + sov(uint64(m.Port)) + if m.DownDelay != 0 { + n += 1 + sov(uint64(m.DownDelay)) } - if m.Duplex != 0 { - n += 2 + sov(uint64(m.Duplex)) + if m.ArpInterval != 0 { + n += 1 + sov(uint64(m.ArpInterval)) } - if m.Vlan != nil { - l = m.Vlan.SizeVT() - n += 2 + l + sov(uint64(l)) + if m.ResendIgmp != 0 { + n += 1 + sov(uint64(m.ResendIgmp)) } - if m.BridgeMaster != nil { - l = m.BridgeMaster.SizeVT() - n += 2 + l + sov(uint64(l)) + if m.MinLinks != 0 { + n += 1 + sov(uint64(m.MinLinks)) } - if m.BondMaster != nil { - l = m.BondMaster.SizeVT() - n += 2 + l + sov(uint64(l)) + if m.LpInterval != 0 { + n += 2 + sov(uint64(m.LpInterval)) } - if m.Wireguard != nil { - l = m.Wireguard.SizeVT() - n += 2 + l + sov(uint64(l)) + if m.PacketsPerSlave != 0 { + n += 2 + sov(uint64(m.PacketsPerSlave)) } - l = len(m.PermanentAddr) - if l > 0 { - n += 2 + l + sov(uint64(l)) + if m.NumPeerNotif != 0 { + n += 6 + } + if m.TlbDynamicLb != 0 { + n += 6 + } + if m.AllSlavesActive != 0 { + n += 6 + } + if m.UseCarrier { + n += 3 + } + if m.AdActorSysPrio != 0 { + n += 6 + } + if m.AdUserPortKey != 0 { + n += 6 + } + if m.PeerNotifyDelay != 0 { + n += 2 + sov(uint64(m.PeerNotifyDelay)) } n += len(m.unknownFields) return n } -func (m *NodeAddressFilterSpec) SizeVT() (n int) { +func (m *BondSlave) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.IncludeSubnets) > 0 { - for _, e := range m.IncludeSubnets { - if size, ok := interface{}(e).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(e) - } - n += 1 + l + sov(uint64(l)) - } + l = len(m.MasterName) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - if len(m.ExcludeSubnets) > 0 { - for _, e := range m.ExcludeSubnets { - if size, ok := interface{}(e).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(e) - } - n += 1 + l + sov(uint64(l)) - } + if m.SlaveIndex != 0 { + n += 1 + sov(uint64(m.SlaveIndex)) } n += len(m.unknownFields) return n } -func (m *NodeAddressSpec) SizeVT() (n int) { +func (m *BridgeMasterSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.Addresses) > 0 { - for _, e := range m.Addresses { - if size, ok := interface{}(e).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(e) - } - n += 1 + l + sov(uint64(l)) - } + if m.Stp != nil { + l = m.Stp.SizeVT() + n += 1 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *OperatorSpecSpec) SizeVT() (n int) { +func (m *BridgeSlave) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Operator != 0 { - n += 1 + sov(uint64(m.Operator)) - } - l = len(m.LinkName) + l = len(m.MasterName) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.RequireUp { - n += 2 - } - if m.Dhcp4 != nil { - l = m.Dhcp4.SizeVT() - n += 1 + l + sov(uint64(l)) - } - if m.Dhcp6 != nil { - l = m.Dhcp6.SizeVT() - n += 1 + l + sov(uint64(l)) - } - if m.Vip != nil { - l = m.Vip.SizeVT() - n += 1 + l + sov(uint64(l)) - } - if m.ConfigLayer != 0 { - n += 1 + sov(uint64(m.ConfigLayer)) - } n += len(m.unknownFields) return n } -func (m *ProbeSpecSpec) SizeVT() (n int) { +func (m *DHCP4OperatorSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Interval != nil { - if size, ok := interface{}(m.Interval).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Interval) - } - n += 1 + l + sov(uint64(l)) + if m.RouteMetric != 0 { + n += 1 + sov(uint64(m.RouteMetric)) } - if m.FailureThreshold != 0 { - n += 1 + sov(uint64(m.FailureThreshold)) + if m.SkipHostnameRequest { + n += 2 } - if m.Tcp != nil { - l = m.Tcp.SizeVT() + n += len(m.unknownFields) + return n +} + +func (m *DHCP6OperatorSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Duid) + if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.ConfigLayer != 0 { - n += 1 + sov(uint64(m.ConfigLayer)) + if m.RouteMetric != 0 { + n += 1 + sov(uint64(m.RouteMetric)) + } + if m.SkipHostnameRequest { + n += 2 } n += len(m.unknownFields) return n } -func (m *ProbeStatusSpec) SizeVT() (n int) { +func (m *HardwareAddrSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Success { - n += 2 + l = len(m.Name) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - l = len(m.LastError) + l = len(m.HardwareAddr) if l > 0 { n += 1 + l + sov(uint64(l)) } @@ -3420,23 +3601,19 @@ func (m *ProbeStatusSpec) SizeVT() (n int) { return n } -func (m *ResolverSpecSpec) SizeVT() (n int) { +func (m *HostnameSpecSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.DnsServers) > 0 { - for _, e := range m.DnsServers { - if size, ok := interface{}(e).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(e) - } - n += 1 + l + sov(uint64(l)) - } + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.Domainname) + if l > 0 { + n += 1 + l + sov(uint64(l)) } if m.ConfigLayer != 0 { n += 1 + sov(uint64(m.ConfigLayer)) @@ -3445,383 +3622,598 @@ func (m *ResolverSpecSpec) SizeVT() (n int) { return n } -func (m *ResolverStatusSpec) SizeVT() (n int) { +func (m *HostnameStatusSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.DnsServers) > 0 { - for _, e := range m.DnsServers { - if size, ok := interface{}(e).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(e) - } - n += 1 + l + sov(uint64(l)) - } + l = len(m.Hostname) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.Domainname) + if l > 0 { + n += 1 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *RouteSpecSpec) SizeVT() (n int) { +func (m *LinkRefreshSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Family != 0 { - n += 1 + sov(uint64(m.Family)) + if m.Generation != 0 { + n += 1 + sov(uint64(m.Generation)) } - if m.Destination != nil { - if size, ok := interface{}(m.Destination).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Destination) - } - n += 1 + l + sov(uint64(l)) + n += len(m.unknownFields) + return n +} + +func (m *LinkSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 } - if m.Source != nil { - if size, ok := interface{}(m.Source).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Source) - } + var l int + _ = l + l = len(m.Name) + if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.Gateway != nil { - if size, ok := interface{}(m.Gateway).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Gateway) - } + if m.Logical { + n += 2 + } + if m.Up { + n += 2 + } + if m.Mtu != 0 { + n += 1 + sov(uint64(m.Mtu)) + } + l = len(m.Kind) + if l > 0 { n += 1 + l + sov(uint64(l)) } - l = len(m.OutLinkName) + if m.Type != 0 { + n += 1 + sov(uint64(m.Type)) + } + l = len(m.ParentName) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.Table != 0 { - n += 1 + sov(uint64(m.Table)) + if m.BondSlave != nil { + l = m.BondSlave.SizeVT() + n += 1 + l + sov(uint64(l)) } - if m.Priority != 0 { - n += 1 + sov(uint64(m.Priority)) + if m.BridgeSlave != nil { + l = m.BridgeSlave.SizeVT() + n += 1 + l + sov(uint64(l)) } - if m.Scope != 0 { - n += 1 + sov(uint64(m.Scope)) + if m.Vlan != nil { + l = m.Vlan.SizeVT() + n += 1 + l + sov(uint64(l)) } - if m.Type != 0 { - n += 1 + sov(uint64(m.Type)) + if m.BondMaster != nil { + l = m.BondMaster.SizeVT() + n += 1 + l + sov(uint64(l)) } - if m.Flags != 0 { - n += 1 + sov(uint64(m.Flags)) + if m.BridgeMaster != nil { + l = m.BridgeMaster.SizeVT() + n += 1 + l + sov(uint64(l)) } - if m.Protocol != 0 { - n += 1 + sov(uint64(m.Protocol)) + if m.Wireguard != nil { + l = m.Wireguard.SizeVT() + n += 1 + l + sov(uint64(l)) } if m.ConfigLayer != 0 { n += 1 + sov(uint64(m.ConfigLayer)) } - if m.Mtu != 0 { - n += 1 + sov(uint64(m.Mtu)) - } n += len(m.unknownFields) return n } -func (m *RouteStatusSpec) SizeVT() (n int) { +func (m *LinkStatusSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Family != 0 { - n += 1 + sov(uint64(m.Family)) + if m.Index != 0 { + n += 1 + sov(uint64(m.Index)) } - if m.Destination != nil { - if size, ok := interface{}(m.Destination).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Destination) - } - n += 1 + l + sov(uint64(l)) + if m.Type != 0 { + n += 1 + sov(uint64(m.Type)) } - if m.Source != nil { - if size, ok := interface{}(m.Source).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Source) - } + if m.LinkIndex != 0 { + n += 1 + sov(uint64(m.LinkIndex)) + } + if m.Flags != 0 { + n += 1 + sov(uint64(m.Flags)) + } + l = len(m.HardwareAddr) + if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.Gateway != nil { - if size, ok := interface{}(m.Gateway).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Gateway) - } + l = len(m.BroadcastAddr) + if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.OutLinkIndex != 0 { - n += 1 + sov(uint64(m.OutLinkIndex)) + if m.Mtu != 0 { + n += 1 + sov(uint64(m.Mtu)) } - l = len(m.OutLinkName) + l = len(m.QueueDisc) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.Table != 0 { - n += 1 + sov(uint64(m.Table)) + if m.MasterIndex != 0 { + n += 1 + sov(uint64(m.MasterIndex)) } - if m.Priority != 0 { - n += 1 + sov(uint64(m.Priority)) + if m.OperationalState != 0 { + n += 1 + sov(uint64(m.OperationalState)) } - if m.Scope != 0 { - n += 1 + sov(uint64(m.Scope)) + l = len(m.Kind) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - if m.Type != 0 { - n += 1 + sov(uint64(m.Type)) + l = len(m.SlaveKind) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - if m.Flags != 0 { - n += 1 + sov(uint64(m.Flags)) + l = len(m.BusPath) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - if m.Protocol != 0 { - n += 1 + sov(uint64(m.Protocol)) + l = len(m.Pciid) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - if m.Mtu != 0 { - n += 1 + sov(uint64(m.Mtu)) + l = len(m.Driver) + if l > 0 { + n += 1 + l + sov(uint64(l)) } - n += len(m.unknownFields) - return n -} - -func (m *STPSpec) SizeVT() (n int) { - if m == nil { - return 0 + l = len(m.DriverVersion) + if l > 0 { + n += 2 + l + sov(uint64(l)) } - var l int - _ = l - if m.Enabled { - n += 2 + l = len(m.FirmwareVersion) + if l > 0 { + n += 2 + l + sov(uint64(l)) + } + l = len(m.ProductId) + if l > 0 { + n += 2 + l + sov(uint64(l)) + } + l = len(m.VendorId) + if l > 0 { + n += 2 + l + sov(uint64(l)) + } + l = len(m.Product) + if l > 0 { + n += 2 + l + sov(uint64(l)) + } + l = len(m.Vendor) + if l > 0 { + n += 2 + l + sov(uint64(l)) + } + if m.LinkState { + n += 3 + } + if m.SpeedMegabits != 0 { + n += 2 + sov(uint64(m.SpeedMegabits)) + } + if m.Port != 0 { + n += 2 + sov(uint64(m.Port)) + } + if m.Duplex != 0 { + n += 2 + sov(uint64(m.Duplex)) + } + if m.Vlan != nil { + l = m.Vlan.SizeVT() + n += 2 + l + sov(uint64(l)) + } + if m.BridgeMaster != nil { + l = m.BridgeMaster.SizeVT() + n += 2 + l + sov(uint64(l)) + } + if m.BondMaster != nil { + l = m.BondMaster.SizeVT() + n += 2 + l + sov(uint64(l)) + } + if m.Wireguard != nil { + l = m.Wireguard.SizeVT() + n += 2 + l + sov(uint64(l)) + } + l = len(m.PermanentAddr) + if l > 0 { + n += 2 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *StatusSpec) SizeVT() (n int) { +func (m *NfTablesAddressMatch) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.AddressReady { - n += 2 - } - if m.ConnectivityReady { - n += 2 + if len(m.IncludeSubnets) > 0 { + for _, e := range m.IncludeSubnets { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } } - if m.HostnameReady { - n += 2 + if len(m.ExcludeSubnets) > 0 { + for _, e := range m.ExcludeSubnets { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } } - if m.EtcFilesReady { + if m.Invert { n += 2 } n += len(m.unknownFields) return n } -func (m *TCPProbeSpec) SizeVT() (n int) { +func (m *NfTablesChainSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Endpoint) + l = len(m.Type) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.Timeout != nil { - if size, ok := interface{}(m.Timeout).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Timeout) + if m.Hook != 0 { + n += 1 + sov(uint64(m.Hook)) + } + if m.Priority != 0 { + n += 1 + sov(uint64(m.Priority)) + } + if len(m.Rules) > 0 { + for _, e := range m.Rules { + l = e.SizeVT() + n += 1 + l + sov(uint64(l)) } - n += 1 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *TimeServerSpecSpec) SizeVT() (n int) { +func (m *NfTablesClampMSS) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.NtpServers) > 0 { - for _, s := range m.NtpServers { - l = len(s) - n += 1 + l + sov(uint64(l)) - } - } - if m.ConfigLayer != 0 { - n += 1 + sov(uint64(m.ConfigLayer)) + if m.Mtu != 0 { + n += 5 } n += len(m.unknownFields) return n } -func (m *TimeServerStatusSpec) SizeVT() (n int) { +func (m *NfTablesIfNameMatch) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.NtpServers) > 0 { - for _, s := range m.NtpServers { - l = len(s) - n += 1 + l + sov(uint64(l)) - } + l = len(m.InterfaceName) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.Operator != 0 { + n += 1 + sov(uint64(m.Operator)) } n += len(m.unknownFields) return n } -func (m *VIPEquinixMetalSpec) SizeVT() (n int) { +func (m *NfTablesLayer4Match) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.ProjectId) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.Protocol != 0 { + n += 1 + sov(uint64(m.Protocol)) } - l = len(m.DeviceId) - if l > 0 { + if m.MatchSourcePort != nil { + l = m.MatchSourcePort.SizeVT() n += 1 + l + sov(uint64(l)) } - l = len(m.ApiToken) - if l > 0 { + if m.MatchDestinationPort != nil { + l = m.MatchDestinationPort.SizeVT() n += 1 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *VIPHCloudSpec) SizeVT() (n int) { +func (m *NfTablesMark) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.DeviceId != 0 { - n += 1 + sov(uint64(m.DeviceId)) + if m.Mask != 0 { + n += 1 + sov(uint64(m.Mask)) } - if m.NetworkId != 0 { - n += 1 + sov(uint64(m.NetworkId)) + if m.Xor != 0 { + n += 1 + sov(uint64(m.Xor)) } - l = len(m.ApiToken) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if m.Value != 0 { + n += 1 + sov(uint64(m.Value)) } n += len(m.unknownFields) return n } -func (m *VIPOperatorSpec) SizeVT() (n int) { +func (m *NfTablesPortMatch) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Ip != nil { - if size, ok := interface{}(m.Ip).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.Ip) + if len(m.Ranges) > 0 { + for _, e := range m.Ranges { + l = e.SizeVT() + n += 1 + l + sov(uint64(l)) } + } + n += len(m.unknownFields) + return n +} + +func (m *NfTablesRule) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.MatchOIfName != nil { + l = m.MatchOIfName.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.GratuitousArp { - n += 2 + if m.Verdict != 0 { + n += 1 + sov(uint64(m.Verdict)) } - if m.EquinixMetal != nil { - l = m.EquinixMetal.SizeVT() + if m.MatchMark != nil { + l = m.MatchMark.SizeVT() n += 1 + l + sov(uint64(l)) } - if m.HCloud != nil { - l = m.HCloud.SizeVT() + if m.SetMark != nil { + l = m.SetMark.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.MatchSourceAddress != nil { + l = m.MatchSourceAddress.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.MatchDestinationAddress != nil { + l = m.MatchDestinationAddress.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.MatchLayer4 != nil { + l = m.MatchLayer4.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.MatchIIfName != nil { + l = m.MatchIIfName.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.ClampMss != nil { + l = m.ClampMss.SizeVT() n += 1 + l + sov(uint64(l)) } n += len(m.unknownFields) return n } -func (m *VLANSpec) SizeVT() (n int) { +func (m *NodeAddressFilterSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - if m.Vid != 0 { - n += 5 + if len(m.IncludeSubnets) > 0 { + for _, e := range m.IncludeSubnets { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } } - if m.Protocol != 0 { - n += 1 + sov(uint64(m.Protocol)) + if len(m.ExcludeSubnets) > 0 { + for _, e := range m.ExcludeSubnets { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } } n += len(m.unknownFields) return n } -func (m *WireguardPeer) SizeVT() (n int) { +func (m *NodeAddressSpec) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.PublicKey) - if l > 0 { - n += 1 + l + sov(uint64(l)) + if len(m.Addresses) > 0 { + for _, e := range m.Addresses { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } } - l = len(m.PresharedKey) - if l > 0 { - n += 1 + l + sov(uint64(l)) + n += len(m.unknownFields) + return n +} + +func (m *OperatorSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 } - l = len(m.Endpoint) + var l int + _ = l + if m.Operator != 0 { + n += 1 + sov(uint64(m.Operator)) + } + l = len(m.LinkName) if l > 0 { n += 1 + l + sov(uint64(l)) } - if m.PersistentKeepaliveInterval != nil { - if size, ok := interface{}(m.PersistentKeepaliveInterval).(interface { - SizeVT() int - }); ok { - l = size.SizeVT() - } else { - l = proto.Size(m.PersistentKeepaliveInterval) - } + if m.RequireUp { + n += 2 + } + if m.Dhcp4 != nil { + l = m.Dhcp4.SizeVT() n += 1 + l + sov(uint64(l)) } - if len(m.AllowedIps) > 0 { - for _, e := range m.AllowedIps { + if m.Dhcp6 != nil { + l = m.Dhcp6.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.Vip != nil { + l = m.Vip.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.ConfigLayer != 0 { + n += 1 + sov(uint64(m.ConfigLayer)) + } + n += len(m.unknownFields) + return n +} + +func (m *PortRange) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Lo != 0 { + n += 5 + } + if m.Hi != 0 { + n += 5 + } + n += len(m.unknownFields) + return n +} + +func (m *ProbeSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Interval != nil { + if size, ok := interface{}(m.Interval).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Interval) + } + n += 1 + l + sov(uint64(l)) + } + if m.FailureThreshold != 0 { + n += 1 + sov(uint64(m.FailureThreshold)) + } + if m.Tcp != nil { + l = m.Tcp.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.ConfigLayer != 0 { + n += 1 + sov(uint64(m.ConfigLayer)) + } + n += len(m.unknownFields) + return n +} + +func (m *ProbeStatusSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Success { + n += 2 + } + l = len(m.LastError) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *ResolverSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.DnsServers) > 0 { + for _, e := range m.DnsServers { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } + } + if m.ConfigLayer != 0 { + n += 1 + sov(uint64(m.ConfigLayer)) + } + n += len(m.unknownFields) + return n +} + +func (m *ResolverStatusSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.DnsServers) > 0 { + for _, e := range m.DnsServers { if size, ok := interface{}(e).(interface { SizeVT() int }); ok { @@ -3829,50 +4221,1021 @@ func (m *WireguardPeer) SizeVT() (n int) { } else { l = proto.Size(e) } - n += 1 + l + sov(uint64(l)) + n += 1 + l + sov(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *RouteSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Family != 0 { + n += 1 + sov(uint64(m.Family)) + } + if m.Destination != nil { + if size, ok := interface{}(m.Destination).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Destination) + } + n += 1 + l + sov(uint64(l)) + } + if m.Source != nil { + if size, ok := interface{}(m.Source).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Source) + } + n += 1 + l + sov(uint64(l)) + } + if m.Gateway != nil { + if size, ok := interface{}(m.Gateway).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Gateway) + } + n += 1 + l + sov(uint64(l)) + } + l = len(m.OutLinkName) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.Table != 0 { + n += 1 + sov(uint64(m.Table)) + } + if m.Priority != 0 { + n += 1 + sov(uint64(m.Priority)) + } + if m.Scope != 0 { + n += 1 + sov(uint64(m.Scope)) + } + if m.Type != 0 { + n += 1 + sov(uint64(m.Type)) + } + if m.Flags != 0 { + n += 1 + sov(uint64(m.Flags)) + } + if m.Protocol != 0 { + n += 1 + sov(uint64(m.Protocol)) + } + if m.ConfigLayer != 0 { + n += 1 + sov(uint64(m.ConfigLayer)) + } + if m.Mtu != 0 { + n += 1 + sov(uint64(m.Mtu)) + } + n += len(m.unknownFields) + return n +} + +func (m *RouteStatusSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Family != 0 { + n += 1 + sov(uint64(m.Family)) + } + if m.Destination != nil { + if size, ok := interface{}(m.Destination).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Destination) + } + n += 1 + l + sov(uint64(l)) + } + if m.Source != nil { + if size, ok := interface{}(m.Source).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Source) + } + n += 1 + l + sov(uint64(l)) + } + if m.Gateway != nil { + if size, ok := interface{}(m.Gateway).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Gateway) + } + n += 1 + l + sov(uint64(l)) + } + if m.OutLinkIndex != 0 { + n += 1 + sov(uint64(m.OutLinkIndex)) + } + l = len(m.OutLinkName) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.Table != 0 { + n += 1 + sov(uint64(m.Table)) + } + if m.Priority != 0 { + n += 1 + sov(uint64(m.Priority)) + } + if m.Scope != 0 { + n += 1 + sov(uint64(m.Scope)) + } + if m.Type != 0 { + n += 1 + sov(uint64(m.Type)) + } + if m.Flags != 0 { + n += 1 + sov(uint64(m.Flags)) + } + if m.Protocol != 0 { + n += 1 + sov(uint64(m.Protocol)) + } + if m.Mtu != 0 { + n += 1 + sov(uint64(m.Mtu)) + } + n += len(m.unknownFields) + return n +} + +func (m *STPSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Enabled { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *StatusSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AddressReady { + n += 2 + } + if m.ConnectivityReady { + n += 2 + } + if m.HostnameReady { + n += 2 + } + if m.EtcFilesReady { + n += 2 + } + n += len(m.unknownFields) + return n +} + +func (m *TCPProbeSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Endpoint) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.Timeout != nil { + if size, ok := interface{}(m.Timeout).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Timeout) + } + n += 1 + l + sov(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *TimeServerSpecSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NtpServers) > 0 { + for _, s := range m.NtpServers { + l = len(s) + n += 1 + l + sov(uint64(l)) + } + } + if m.ConfigLayer != 0 { + n += 1 + sov(uint64(m.ConfigLayer)) + } + n += len(m.unknownFields) + return n +} + +func (m *TimeServerStatusSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.NtpServers) > 0 { + for _, s := range m.NtpServers { + l = len(s) + n += 1 + l + sov(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *VIPEquinixMetalSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ProjectId) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.DeviceId) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.ApiToken) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *VIPHCloudSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DeviceId != 0 { + n += 1 + sov(uint64(m.DeviceId)) + } + if m.NetworkId != 0 { + n += 1 + sov(uint64(m.NetworkId)) + } + l = len(m.ApiToken) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *VIPOperatorSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Ip != nil { + if size, ok := interface{}(m.Ip).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.Ip) + } + n += 1 + l + sov(uint64(l)) + } + if m.GratuitousArp { + n += 2 + } + if m.EquinixMetal != nil { + l = m.EquinixMetal.SizeVT() + n += 1 + l + sov(uint64(l)) + } + if m.HCloud != nil { + l = m.HCloud.SizeVT() + n += 1 + l + sov(uint64(l)) + } + n += len(m.unknownFields) + return n +} + +func (m *VLANSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Vid != 0 { + n += 5 + } + if m.Protocol != 0 { + n += 1 + sov(uint64(m.Protocol)) + } + n += len(m.unknownFields) + return n +} + +func (m *WireguardPeer) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PublicKey) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.PresharedKey) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.Endpoint) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.PersistentKeepaliveInterval != nil { + if size, ok := interface{}(m.PersistentKeepaliveInterval).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(m.PersistentKeepaliveInterval) + } + n += 1 + l + sov(uint64(l)) + } + if len(m.AllowedIps) > 0 { + for _, e := range m.AllowedIps { + if size, ok := interface{}(e).(interface { + SizeVT() int + }); ok { + l = size.SizeVT() + } else { + l = proto.Size(e) + } + n += 1 + l + sov(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func (m *WireguardSpec) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PrivateKey) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + l = len(m.PublicKey) + if l > 0 { + n += 1 + l + sov(uint64(l)) + } + if m.ListenPort != 0 { + n += 1 + sov(uint64(m.ListenPort)) + } + if m.FirewallMark != 0 { + n += 1 + sov(uint64(m.FirewallMark)) + } + if len(m.Peers) > 0 { + for _, e := range m.Peers { + l = e.SizeVT() + n += 1 + l + sov(uint64(l)) + } + } + n += len(m.unknownFields) + return n +} + +func sov(x uint64) (n int) { + return (bits.Len64(x|1) + 6) / 7 +} +func soz(x uint64) (n int) { + return sov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *AddressSpecSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: AddressSpecSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddressSpecSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &common.NetIPPrefix{} + } + if unmarshal, ok := interface{}(m.Address).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Address); err != nil { + return err + } + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LinkName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Family", wireType) + } + m.Family = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Family |= enums.NethelpersFamily(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + } + m.Scope = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Scope |= enums.NethelpersScope(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + } + m.Flags = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Flags |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AnnounceWithArp", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AnnounceWithArp = bool(v != 0) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) + } + m.ConfigLayer = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddressStatusSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: AddressStatusSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddressStatusSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Address == nil { + m.Address = &common.NetIPPrefix{} + } + if unmarshal, ok := interface{}(m.Address).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Address); err != nil { + return err + } + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Local == nil { + m.Local = &common.NetIP{} + } + if unmarshal, ok := interface{}(m.Local).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Local); err != nil { + return err + } + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Broadcast", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Broadcast == nil { + m.Broadcast = &common.NetIP{} + } + if unmarshal, ok := interface{}(m.Broadcast).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Broadcast); err != nil { + return err + } + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Anycast", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Anycast == nil { + m.Anycast = &common.NetIP{} + } + if unmarshal, ok := interface{}(m.Anycast).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Anycast); err != nil { + return err + } + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Multicast", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Multicast == nil { + m.Multicast = &common.NetIP{} + } + if unmarshal, ok := interface{}(m.Multicast).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Multicast); err != nil { + return err + } + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LinkIndex", wireType) + } + m.LinkIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LinkIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LinkName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Family", wireType) + } + m.Family = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Family |= enums.NethelpersFamily(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + } + m.Scope = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Scope |= enums.NethelpersScope(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + } + m.Flags = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Flags |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy } } - n += len(m.unknownFields) - return n -} -func (m *WireguardSpec) SizeVT() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.PrivateKey) - if l > 0 { - n += 1 + l + sov(uint64(l)) - } - l = len(m.PublicKey) - if l > 0 { - n += 1 + l + sov(uint64(l)) - } - if m.ListenPort != 0 { - n += 1 + sov(uint64(m.ListenPort)) - } - if m.FirewallMark != 0 { - n += 1 + sov(uint64(m.FirewallMark)) - } - if len(m.Peers) > 0 { - for _, e := range m.Peers { - l = e.SizeVT() - n += 1 + l + sov(uint64(l)) - } + if iNdEx > l { + return io.ErrUnexpectedEOF } - n += len(m.unknownFields) - return n -} - -func sov(x uint64) (n int) { - return (bits.Len64(x|1) + 6) / 7 -} -func soz(x uint64) (n int) { - return sov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { +func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -3895,17 +5258,17 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AddressSpecSpec: wiretype end group for non-group") + return fmt.Errorf("proto: BondMasterSpec: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AddressSpecSpec: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BondMasterSpec: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) } - var msglen int + m.Mode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -3915,41 +5278,73 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Mode |= enums.NethelpersBondMode(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field HashPolicy", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength + m.HashPolicy = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.HashPolicy |= enums.NethelpersBondXmitHashPolicy(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LacpRate", wireType) } - if m.Address == nil { - m.Address = &common.NetIPPrefix{} + m.LacpRate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LacpRate |= enums.NethelpersLACPRate(b&0x7F) << shift + if b < 0x80 { + break + } } - if unmarshal, ok := interface{}(m.Address).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ArpValidate", wireType) + } + m.ArpValidate = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Address); err != nil { - return err + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ArpValidate |= enums.NethelpersARPValidate(b&0x7F) << shift + if b < 0x80 { + break } } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ArpAllTargets", wireType) } - var stringLen uint64 + m.ArpAllTargets = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -3959,29 +5354,73 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.ArpAllTargets |= enums.NethelpersARPAllTargets(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrimaryIndex", wireType) } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLength + m.PrimaryIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PrimaryIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PrimaryReselect", wireType) } - m.LinkName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: + m.PrimaryReselect = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PrimaryReselect |= enums.NethelpersPrimaryReselect(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field FailOverMac", wireType) + } + m.FailOverMac = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.FailOverMac |= enums.NethelpersFailOverMAC(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Family", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AdSelect", wireType) } - m.Family = 0 + m.AdSelect = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -3991,16 +5430,16 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Family |= enums.NethelpersFamily(b&0x7F) << shift + m.AdSelect |= enums.NethelpersADSelect(b&0x7F) << shift if b < 0x80 { break } } - case 4: + case 10: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MiiMon", wireType) } - m.Scope = 0 + m.MiiMon = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4010,16 +5449,16 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Scope |= enums.NethelpersScope(b&0x7F) << shift + m.MiiMon |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 5: + case 11: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UpDelay", wireType) } - m.Flags = 0 + m.UpDelay = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4029,16 +5468,16 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Flags |= uint32(b&0x7F) << shift + m.UpDelay |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 6: + case 12: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AnnounceWithArp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DownDelay", wireType) } - var v int + m.DownDelay = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4048,17 +5487,16 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.DownDelay |= uint32(b&0x7F) << shift if b < 0x80 { break } } - m.AnnounceWithArp = bool(v != 0) - case 7: + case 13: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ArpInterval", wireType) } - m.ConfigLayer = 0 + m.ArpInterval = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4068,67 +5506,16 @@ func (m *AddressSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift + m.ArpInterval |= uint32(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AddressStatusSpec) UnmarshalVT(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 ErrIntOverflow - } - 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: AddressStatusSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AddressStatusSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ResendIgmp", wireType) } - var msglen int + m.ResendIgmp = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4138,41 +5525,16 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ResendIgmp |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Address == nil { - m.Address = &common.NetIPPrefix{} - } - if unmarshal, ok := interface{}(m.Address).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Address); err != nil { - return err - } - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Local", wireType) + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinLinks", wireType) } - var msglen int + m.MinLinks = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4182,41 +5544,16 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.MinLinks |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Local == nil { - m.Local = &common.NetIP{} - } - if unmarshal, ok := interface{}(m.Local).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Local); err != nil { - return err - } - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Broadcast", wireType) + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LpInterval", wireType) } - var msglen int + m.LpInterval = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4226,41 +5563,16 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.LpInterval |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Broadcast == nil { - m.Broadcast = &common.NetIP{} - } - if unmarshal, ok := interface{}(m.Broadcast).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Broadcast); err != nil { - return err - } - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Anycast", wireType) + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PacketsPerSlave", wireType) } - var msglen int + m.PacketsPerSlave = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4270,41 +5582,46 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.PacketsPerSlave |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength + case 18: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field NumPeerNotif", wireType) } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength + m.NumPeerNotif = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF } - if postIndex > l { + m.NumPeerNotif = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 19: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field TlbDynamicLb", wireType) + } + m.TlbDynamicLb = 0 + if (iNdEx + 4) > l { return io.ErrUnexpectedEOF } - if m.Anycast == nil { - m.Anycast = &common.NetIP{} + m.TlbDynamicLb = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 20: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field AllSlavesActive", wireType) } - if unmarshal, ok := interface{}(m.Anycast).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Anycast); err != nil { - return err - } + m.AllSlavesActive = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Multicast", wireType) + m.AllSlavesActive = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field UseCarrier", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4314,41 +5631,37 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength + m.UseCarrier = bool(v != 0) + case 22: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field AdActorSysPrio", wireType) } - if postIndex > l { + m.AdActorSysPrio = 0 + if (iNdEx + 4) > l { return io.ErrUnexpectedEOF } - if m.Multicast == nil { - m.Multicast = &common.NetIP{} + m.AdActorSysPrio = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 23: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field AdUserPortKey", wireType) } - if unmarshal, ok := interface{}(m.Multicast).(interface { - UnmarshalVT([]byte) error - }); ok { - if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Multicast); err != nil { - return err - } + m.AdUserPortKey = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 6: + m.AdUserPortKey = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 24: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LinkIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PeerNotifyDelay", wireType) } - m.LinkIndex = 0 + m.PeerNotifyDelay = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4358,14 +5671,65 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LinkIndex |= uint32(b&0x7F) << shift + m.PeerNotifyDelay |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 7: + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BondSlave) UnmarshalVT(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 ErrIntOverflow + } + 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: BondSlave: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BondSlave: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LinkName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MasterName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4393,13 +5757,13 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.LinkName = string(dAtA[iNdEx:postIndex]) + m.MasterName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Family", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SlaveIndex", wireType) } - m.Family = 0 + m.SlaveIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4409,16 +5773,67 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Family |= enums.NethelpersFamily(b&0x7F) << shift + m.SlaveIndex |= int64(b&0x7F) << shift if b < 0x80 { break } } - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Scope", wireType) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - m.Scope = 0 + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BridgeMasterSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: BridgeMasterSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BridgeMasterSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Stp", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4428,16 +5843,84 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Scope |= enums.NethelpersScope(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + if msglen < 0 { + return ErrInvalidLength } - m.Flags = 0 + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Stp == nil { + m.Stp = &STPSpec{} + } + if err := m.Stp.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BridgeSlave) UnmarshalVT(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 ErrIntOverflow + } + 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: BridgeSlave: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BridgeSlave: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MasterName", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4447,11 +5930,24 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Flags |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MasterName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skip(dAtA[iNdEx:]) @@ -4474,7 +5970,7 @@ func (m *AddressStatusSpec) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { +func (m *DHCP4OperatorSpec) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4497,17 +5993,17 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BondMasterSpec: wiretype end group for non-group") + return fmt.Errorf("proto: DHCP4OperatorSpec: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BondMasterSpec: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: DHCP4OperatorSpec: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RouteMetric", wireType) } - m.Mode = 0 + m.RouteMetric = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4517,16 +6013,16 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mode |= enums.NethelpersBondMode(b&0x7F) << shift + m.RouteMetric |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HashPolicy", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SkipHostnameRequest", wireType) } - m.HashPolicy = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4536,73 +6032,68 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.HashPolicy |= enums.NethelpersBondXmitHashPolicy(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LacpRate", wireType) + m.SkipHostnameRequest = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - m.LacpRate = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LacpRate |= enums.NethelpersLACPRate(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ArpValidate", wireType) + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - m.ArpValidate = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ArpValidate |= enums.NethelpersARPValidate(b&0x7F) << shift - if b < 0x80 { - break - } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DHCP6OperatorSpec) UnmarshalVT(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 ErrIntOverflow } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ArpAllTargets", wireType) + if iNdEx >= l { + return io.ErrUnexpectedEOF } - m.ArpAllTargets = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ArpAllTargets |= enums.NethelpersARPAllTargets(b&0x7F) << shift - if b < 0x80 { - break - } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PrimaryIndex", wireType) + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DHCP6OperatorSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DHCP6OperatorSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Duid", wireType) } - m.PrimaryIndex = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4612,35 +6103,29 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PrimaryIndex |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PrimaryReselect", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.PrimaryReselect = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PrimaryReselect |= enums.NethelpersPrimaryReselect(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength } - case 8: + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Duid = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field FailOverMac", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RouteMetric", wireType) } - m.FailOverMac = 0 + m.RouteMetric = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4650,16 +6135,16 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.FailOverMac |= enums.NethelpersFailOverMAC(b&0x7F) << shift + m.RouteMetric |= uint32(b&0x7F) << shift if b < 0x80 { break } } - case 9: + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AdSelect", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SkipHostnameRequest", wireType) } - m.AdSelect = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4669,54 +6154,68 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.AdSelect |= enums.NethelpersADSelect(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MiiMon", wireType) + m.SkipHostnameRequest = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - m.MiiMon = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MiiMon |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength } - case 11: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UpDelay", wireType) + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF } - m.UpDelay = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.UpDelay |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HardwareAddrSpec) UnmarshalVT(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 ErrIntOverflow } - case 12: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DownDelay", wireType) + 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: HardwareAddrSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HardwareAddrSpec: 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) } - m.DownDelay = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4726,16 +6225,29 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DownDelay |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 13: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ArpInterval", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.ArpInterval = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + 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 HardwareAddr", wireType) + } + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4745,16 +6257,82 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ArpInterval |= uint32(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ResendIgmp", wireType) + if byteLen < 0 { + return ErrInvalidLength } - m.ResendIgmp = 0 + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.HardwareAddr = append(m.HardwareAddr[:0], dAtA[iNdEx:postIndex]...) + if m.HardwareAddr == nil { + m.HardwareAddr = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostnameSpecSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: HostnameSpecSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostnameSpecSpec: 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 ErrIntOverflow @@ -4764,16 +6342,29 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ResendIgmp |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 15: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinLinks", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.MinLinks = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + 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 Domainname", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4783,16 +6374,29 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MinLinks |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 16: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Domainname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LpInterval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) } - m.LpInterval = 0 + m.ConfigLayer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4802,16 +6406,67 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LpInterval |= uint32(b&0x7F) << shift + m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift if b < 0x80 { break } } - case 17: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PacketsPerSlave", wireType) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - m.PacketsPerSlave = 0 + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HostnameStatusSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: HostnameStatusSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HostnameStatusSpec: 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 ErrIntOverflow @@ -4821,46 +6476,29 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PacketsPerSlave |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 18: - if wireType != 5 { - return fmt.Errorf("proto: wrong wireType = %d for field NumPeerNotif", wireType) - } - m.NumPeerNotif = 0 - if (iNdEx + 4) > l { - return io.ErrUnexpectedEOF - } - m.NumPeerNotif = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) - iNdEx += 4 - case 19: - if wireType != 5 { - return fmt.Errorf("proto: wrong wireType = %d for field TlbDynamicLb", wireType) - } - m.TlbDynamicLb = 0 - if (iNdEx + 4) > l { - return io.ErrUnexpectedEOF - } - m.TlbDynamicLb = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) - iNdEx += 4 - case 20: - if wireType != 5 { - return fmt.Errorf("proto: wrong wireType = %d for field AllSlavesActive", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.AllSlavesActive = 0 - if (iNdEx + 4) > l { - return io.ErrUnexpectedEOF + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength } - m.AllSlavesActive = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) - iNdEx += 4 - case 21: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field UseCarrier", wireType) + if postIndex > l { + return io.ErrUnexpectedEOF } - var v int + m.Hostname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Domainname", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4870,37 +6508,80 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.UseCarrier = bool(v != 0) - case 22: - if wireType != 5 { - return fmt.Errorf("proto: wrong wireType = %d for field AdActorSysPrio", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.AdActorSysPrio = 0 - if (iNdEx + 4) > l { + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { return io.ErrUnexpectedEOF } - m.AdActorSysPrio = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) - iNdEx += 4 - case 23: - if wireType != 5 { - return fmt.Errorf("proto: wrong wireType = %d for field AdUserPortKey", wireType) + m.Domainname = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - m.AdUserPortKey = 0 - if (iNdEx + 4) > l { + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.AdUserPortKey = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) - iNdEx += 4 - case 24: + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LinkRefreshSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: LinkRefreshSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LinkRefreshSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PeerNotifyDelay", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType) } - m.PeerNotifyDelay = 0 + m.Generation = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -4910,7 +6591,7 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.PeerNotifyDelay |= uint32(b&0x7F) << shift + m.Generation |= int64(b&0x7F) << shift if b < 0x80 { break } @@ -4937,7 +6618,7 @@ func (m *BondMasterSpec) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *BondSlave) UnmarshalVT(dAtA []byte) error { +func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -4960,15 +6641,15 @@ func (m *BondSlave) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: BondSlave: wiretype end group for non-group") + return fmt.Errorf("proto: LinkSpecSpec: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: BondSlave: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LinkSpecSpec: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MasterName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -4996,13 +6677,13 @@ func (m *BondSlave) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.MasterName = string(dAtA[iNdEx:postIndex]) + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SlaveIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType) } - m.SlaveIndex = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5012,65 +6693,137 @@ func (m *BondSlave) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SlaveIndex |= int64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err + m.Logical = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Up", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Up = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mtu", wireType) + } + m.Mtu = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mtu |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength } - if (iNdEx + skippy) > l { + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { return io.ErrUnexpectedEOF } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BridgeMasterSpec) UnmarshalVT(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 ErrIntOverflow + m.Kind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - if iNdEx >= l { - return io.ErrUnexpectedEOF + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= enums.NethelpersLinkType(b&0x7F) << shift + if b < 0x80 { + break + } } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ParentName", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: BridgeMasterSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BridgeMasterSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + 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 ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ParentName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Stp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BondSlave", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -5097,69 +6850,18 @@ func (m *BridgeMasterSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Stp == nil { - m.Stp = &STPSpec{} + if m.BondSlave == nil { + m.BondSlave = &BondSlave{} } - if err := m.Stp.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.BondSlave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BridgeSlave) UnmarshalVT(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 ErrIntOverflow - } - 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: BridgeSlave: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: BridgeSlave: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MasterName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BridgeSlave", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5169,80 +6871,33 @@ func (m *BridgeSlave) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.MasterName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DHCP4OperatorSpec) UnmarshalVT(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 ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.BridgeSlave == nil { + m.BridgeSlave = &BridgeSlave{} } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := m.BridgeSlave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: DHCP4OperatorSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DHCP4OperatorSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RouteMetric", wireType) + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vlan", wireType) } - m.RouteMetric = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5252,16 +6907,33 @@ func (m *DHCP4OperatorSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RouteMetric |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SkipHostnameRequest", wireType) + if msglen < 0 { + return ErrInvalidLength } - var v int + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Vlan == nil { + m.Vlan = &VLANSpec{} + } + if err := m.Vlan.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BondMaster", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5271,68 +6943,33 @@ func (m *DHCP4OperatorSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - m.SkipHostnameRequest = bool(v != 0) - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err + if msglen < 0 { + return ErrInvalidLength } - if (skippy < 0) || (iNdEx+skippy) < 0 { + postIndex := iNdEx + msglen + if postIndex < 0 { return ErrInvalidLength } - if (iNdEx + skippy) > l { + if postIndex > l { return io.ErrUnexpectedEOF } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DHCP6OperatorSpec) UnmarshalVT(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 ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if m.BondMaster == nil { + m.BondMaster = &BondMasterSpec{} } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := m.BondMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: DHCP6OperatorSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DHCP6OperatorSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Duid", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BridgeMaster", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5342,29 +6979,33 @@ func (m *DHCP6OperatorSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Duid = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RouteMetric", wireType) + if m.BridgeMaster == nil { + m.BridgeMaster = &BridgeMasterSpec{} + } + if err := m.BridgeMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Wireguard", wireType) } - m.RouteMetric = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5374,16 +7015,33 @@ func (m *DHCP6OperatorSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.RouteMetric |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Wireguard == nil { + m.Wireguard = &WireguardSpec{} + } + if err := m.Wireguard.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 14: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SkipHostnameRequest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) } - var v int + m.ConfigLayer = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5393,12 +7051,11 @@ func (m *DHCP6OperatorSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift if b < 0x80 { break } } - m.SkipHostnameRequest = bool(v != 0) default: iNdEx = preIndex skippy, err := skip(dAtA[iNdEx:]) @@ -5421,7 +7078,7 @@ func (m *DHCP6OperatorSpec) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *HardwareAddrSpec) UnmarshalVT(dAtA []byte) error { +func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5444,17 +7101,17 @@ func (m *HardwareAddrSpec) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: HardwareAddrSpec: wiretype end group for non-group") + return fmt.Errorf("proto: LinkStatusSpec: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: HardwareAddrSpec: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LinkStatusSpec: 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) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) } - var stringLen uint64 + m.Index = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5464,25 +7121,69 @@ func (m *HardwareAddrSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Index |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLength + m.Type = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Type |= enums.NethelpersLinkType(b&0x7F) << shift + if b < 0x80 { + break + } } - if postIndex > l { - return io.ErrUnexpectedEOF + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LinkIndex", wireType) } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: + m.LinkIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LinkIndex |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) + } + m.Flags = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Flags |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HardwareAddr", wireType) } @@ -5516,62 +7217,11 @@ func (m *HardwareAddrSpec) UnmarshalVT(dAtA []byte) error { m.HardwareAddr = []byte{} } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *HostnameSpecSpec) UnmarshalVT(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 ErrIntOverflow - } - 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: HostnameSpecSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: HostnameSpecSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BroadcastAddr", wireType) } - var stringLen uint64 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5581,27 +7231,48 @@ func (m *HostnameSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if byteLen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Hostname = string(dAtA[iNdEx:postIndex]) + m.BroadcastAddr = append(m.BroadcastAddr[:0], dAtA[iNdEx:postIndex]...) + if m.BroadcastAddr == nil { + m.BroadcastAddr = []byte{} + } iNdEx = postIndex - case 2: + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mtu", wireType) + } + m.Mtu = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mtu |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Domainname", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field QueueDisc", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -5629,13 +7300,13 @@ func (m *HostnameSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Domainname = string(dAtA[iNdEx:postIndex]) + m.QueueDisc = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 9: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MasterIndex", wireType) } - m.ConfigLayer = 0 + m.MasterIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5645,65 +7316,33 @@ func (m *HostnameSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift + m.MasterIndex |= uint32(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *HostnameStatusSpec) UnmarshalVT(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 ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OperationalState", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: HostnameStatusSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: HostnameStatusSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.OperationalState = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OperationalState |= enums.NethelpersOperationalState(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -5731,11 +7370,11 @@ func (m *HostnameStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Hostname = string(dAtA[iNdEx:postIndex]) + m.Kind = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Domainname", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SlaveKind", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -5763,64 +7402,45 @@ func (m *HostnameStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Domainname = string(dAtA[iNdEx:postIndex]) + m.SlaveKind = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BusPath", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLength + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LinkRefreshSpec) UnmarshalVT(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 ErrIntOverflow + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength } - if iNdEx >= l { + if postIndex > 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: LinkRefreshSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LinkRefreshSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType) + m.BusPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pciid", wireType) } - m.Generation = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5830,65 +7450,27 @@ func (m *LinkRefreshSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Generation |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - default: - iNdEx = preIndex - skippy, err := skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLength } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LinkSpecSpec) UnmarshalVT(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 ErrIntOverflow + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength } - if iNdEx >= l { + if postIndex > 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: LinkSpecSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LinkSpecSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.Pciid = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -5916,13 +7498,13 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Driver = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Logical", wireType) + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DriverVersion", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5932,17 +7514,29 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.Logical = bool(v != 0) - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Up", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - var v int + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DriverVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FirmwareVersion", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5952,17 +7546,29 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.Up = bool(v != 0) - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mtu", wireType) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength } - m.Mtu = 0 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FirmwareVersion = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProductId", wireType) + } + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -5972,14 +7578,27 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mtu |= uint32(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 5: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProductId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field VendorId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -6007,13 +7626,13 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Kind = string(dAtA[iNdEx:postIndex]) + m.VendorId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + case 20: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Product", wireType) } - m.Type = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6023,14 +7642,27 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Type |= enums.NethelpersLinkType(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 7: + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Product = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 21: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ParentName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Vendor", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -6058,13 +7690,13 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ParentName = string(dAtA[iNdEx:postIndex]) + m.Vendor = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BondSlave", wireType) + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LinkState", wireType) } - var msglen int + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6074,33 +7706,17 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.BondSlave == nil { - m.BondSlave = &BondSlave{} - } - if err := m.BondSlave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BridgeSlave", wireType) + m.LinkState = bool(v != 0) + case 23: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SpeedMegabits", wireType) } - var msglen int + m.SpeedMegabits = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6110,29 +7726,50 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.SpeedMegabits |= int64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLength + case 24: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) } - if postIndex > l { - return io.ErrUnexpectedEOF + m.Port = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Port |= enums.NethelpersPort(b&0x7F) << shift + if b < 0x80 { + break + } } - if m.BridgeSlave == nil { - m.BridgeSlave = &BridgeSlave{} + case 25: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Duplex", wireType) } - if err := m.BridgeSlave.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err + m.Duplex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Duplex |= enums.NethelpersDuplex(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex - case 10: + case 26: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Vlan", wireType) } @@ -6168,9 +7805,9 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex - case 11: + case 27: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BondMaster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BridgeMaster", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -6197,16 +7834,16 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BondMaster == nil { - m.BondMaster = &BondMasterSpec{} + if m.BridgeMaster == nil { + m.BridgeMaster = &BridgeMasterSpec{} } - if err := m.BondMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.BridgeMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 12: + case 28: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BridgeMaster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BondMaster", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -6233,14 +7870,14 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BridgeMaster == nil { - m.BridgeMaster = &BridgeMasterSpec{} + if m.BondMaster == nil { + m.BondMaster = &BondMasterSpec{} } - if err := m.BridgeMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.BondMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 13: + case 29: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Wireguard", wireType) } @@ -6276,11 +7913,11 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { return err } iNdEx = postIndex - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ConfigLayer", wireType) + case 30: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PermanentAddr", wireType) } - m.ConfigLayer = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6290,11 +7927,26 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ConfigLayer |= enums.NetworkConfigLayer(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PermanentAddr = append(m.PermanentAddr[:0], dAtA[iNdEx:postIndex]...) + if m.PermanentAddr == nil { + m.PermanentAddr = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skip(dAtA[iNdEx:]) @@ -6317,7 +7969,7 @@ func (m *LinkSpecSpec) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { +func (m *NfTablesAddressMatch) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6331,102 +7983,26 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { 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: LinkStatusSpec: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LinkStatusSpec: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) - } - m.Index = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Index |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - 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 ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Type |= enums.NethelpersLinkType(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LinkIndex", wireType) - } - m.LinkIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LinkIndex |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType) - } - m.Flags = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Flags |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - case 5: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NfTablesAddressMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesAddressMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field HardwareAddr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IncludeSubnets", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6436,31 +8012,39 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.HardwareAddr = append(m.HardwareAddr[:0], dAtA[iNdEx:postIndex]...) - if m.HardwareAddr == nil { - m.HardwareAddr = []byte{} + m.IncludeSubnets = append(m.IncludeSubnets, &common.NetIPPrefix{}) + if unmarshal, ok := interface{}(m.IncludeSubnets[len(m.IncludeSubnets)-1]).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.IncludeSubnets[len(m.IncludeSubnets)-1]); err != nil { + return err + } } iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BroadcastAddr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ExcludeSubnets", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6470,31 +8054,39 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.BroadcastAddr = append(m.BroadcastAddr[:0], dAtA[iNdEx:postIndex]...) - if m.BroadcastAddr == nil { - m.BroadcastAddr = []byte{} + m.ExcludeSubnets = append(m.ExcludeSubnets, &common.NetIPPrefix{}) + if unmarshal, ok := interface{}(m.ExcludeSubnets[len(m.ExcludeSubnets)-1]).(interface { + UnmarshalVT([]byte) error + }); ok { + if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + } else { + if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.ExcludeSubnets[len(m.ExcludeSubnets)-1]); err != nil { + return err + } } iNdEx = postIndex - case 7: + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mtu", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Invert", wireType) } - m.Mtu = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6504,14 +8096,66 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mtu |= uint32(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 8: + m.Invert = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesChainSpec) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesChainSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesChainSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field QueueDisc", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -6539,13 +8183,13 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.QueueDisc = string(dAtA[iNdEx:postIndex]) + m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 9: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MasterIndex", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Hook", wireType) } - m.MasterIndex = 0 + m.Hook = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6555,16 +8199,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.MasterIndex |= uint32(b&0x7F) << shift + m.Hook |= enums.NethelpersNfTablesChainHook(b&0x7F) << shift if b < 0x80 { break } } - case 10: + case 3: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field OperationalState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType) } - m.OperationalState = 0 + m.Priority = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6574,16 +8218,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.OperationalState |= enums.NethelpersOperationalState(b&0x7F) << shift + m.Priority |= enums.NethelpersNfTablesChainPriority(b&0x7F) << shift if b < 0x80 { break } } - case 11: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Rules", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6593,27 +8237,141 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Kind = string(dAtA[iNdEx:postIndex]) + m.Rules = append(m.Rules, &NfTablesRule{}) + if err := m.Rules[len(m.Rules)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 12: + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesClampMSS) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesClampMSS: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesClampMSS: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Mtu", wireType) + } + m.Mtu = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + m.Mtu = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesIfNameMatch) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesIfNameMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesIfNameMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SlaveKind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field InterfaceName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -6641,13 +8399,13 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SlaveKind = string(dAtA[iNdEx:postIndex]) + m.InterfaceName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 13: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BusPath", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } - var stringLen uint64 + m.Operator = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6657,29 +8415,67 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Operator |= enums.NethelpersMatchOperator(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLength } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.BusPath = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 14: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Pciid", wireType) + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesLayer4Match) UnmarshalVT(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 ErrIntOverflow } - var stringLen uint64 + 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: NfTablesLayer4Match: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesLayer4Match: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) + } + m.Protocol = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6689,29 +8485,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Protocol |= enums.NethelpersProtocol(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Pciid = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 15: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Driver", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchSourcePort", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6721,29 +8504,33 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Driver = string(dAtA[iNdEx:postIndex]) + if m.MatchSourcePort == nil { + m.MatchSourcePort = &NfTablesPortMatch{} + } + if err := m.MatchSourcePort.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 16: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DriverVersion", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchDestinationPort", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6753,29 +8540,84 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.DriverVersion = string(dAtA[iNdEx:postIndex]) + if m.MatchDestinationPort == nil { + m.MatchDestinationPort = &NfTablesPortMatch{} + } + if err := m.MatchDestinationPort.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FirmwareVersion", wireType) + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - var stringLen uint64 + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesMark) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesMark: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesMark: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mask", wireType) + } + m.Mask = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6785,29 +8627,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Mask |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.FirmwareVersion = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 18: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProductId", wireType) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Xor", wireType) } - var stringLen uint64 + m.Xor = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6817,29 +8646,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Xor |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ProductId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 19: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field VendorId", wireType) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } - var stringLen uint64 + m.Value = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6849,29 +8665,67 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.Value |= uint32(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLength + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + intStringLen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLength } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - m.VendorId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 20: + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesPortMatch) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesPortMatch: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesPortMatch: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Product", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6881,29 +8735,82 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Product = string(dAtA[iNdEx:postIndex]) + m.Ranges = append(m.Ranges, &PortRange{}) + if err := m.Ranges[len(m.Ranges)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 21: + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NfTablesRule) UnmarshalVT(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 ErrIntOverflow + } + 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: NfTablesRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: NfTablesRule: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Vendor", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchOIfName", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6913,29 +8820,33 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Vendor = string(dAtA[iNdEx:postIndex]) + if m.MatchOIfName == nil { + m.MatchOIfName = &NfTablesIfNameMatch{} + } + if err := m.MatchOIfName.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 22: + case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LinkState", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Verdict", wireType) } - var v int + m.Verdict = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6945,17 +8856,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + m.Verdict |= enums.NethelpersNfTablesVerdict(b&0x7F) << shift if b < 0x80 { break } } - m.LinkState = bool(v != 0) - case 23: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field SpeedMegabits", wireType) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MatchMark", wireType) } - m.SpeedMegabits = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -6965,35 +8875,33 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.SpeedMegabits |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 24: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) + if msglen < 0 { + return ErrInvalidLength } - m.Port = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Port |= enums.NethelpersPort(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength } - case 25: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Duplex", wireType) + if postIndex > l { + return io.ErrUnexpectedEOF } - m.Duplex = 0 + if m.MatchMark == nil { + m.MatchMark = &NfTablesMark{} + } + if err := m.MatchMark.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetMark", wireType) + } + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -7003,14 +8911,31 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Duplex |= enums.NethelpersDuplex(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 26: + if msglen < 0 { + return ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SetMark == nil { + m.SetMark = &NfTablesMark{} + } + if err := m.SetMark.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Vlan", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchSourceAddress", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -7037,16 +8962,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Vlan == nil { - m.Vlan = &VLANSpec{} + if m.MatchSourceAddress == nil { + m.MatchSourceAddress = &NfTablesAddressMatch{} } - if err := m.Vlan.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.MatchSourceAddress.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 27: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BridgeMaster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchDestinationAddress", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -7073,16 +8998,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BridgeMaster == nil { - m.BridgeMaster = &BridgeMasterSpec{} + if m.MatchDestinationAddress == nil { + m.MatchDestinationAddress = &NfTablesAddressMatch{} } - if err := m.BridgeMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.MatchDestinationAddress.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 28: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BondMaster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchLayer4", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -7109,16 +9034,16 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.BondMaster == nil { - m.BondMaster = &BondMasterSpec{} + if m.MatchLayer4 == nil { + m.MatchLayer4 = &NfTablesLayer4Match{} } - if err := m.BondMaster.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.MatchLayer4.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 29: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Wireguard", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchIIfName", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -7145,18 +9070,18 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Wireguard == nil { - m.Wireguard = &WireguardSpec{} + if m.MatchIIfName == nil { + m.MatchIIfName = &NfTablesIfNameMatch{} } - if err := m.Wireguard.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + if err := m.MatchIIfName.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 30: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PermanentAddr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClampMss", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflow @@ -7166,24 +9091,26 @@ func (m *LinkStatusSpec) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLength } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.PermanentAddr = append(m.PermanentAddr[:0], dAtA[iNdEx:postIndex]...) - if m.PermanentAddr == nil { - m.PermanentAddr = []byte{} + if m.ClampMss == nil { + m.ClampMss = &NfTablesClampMSS{} + } + if err := m.ClampMss.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err } iNdEx = postIndex default: @@ -7685,6 +9612,77 @@ func (m *OperatorSpecSpec) UnmarshalVT(dAtA []byte) error { } return nil } +func (m *PortRange) UnmarshalVT(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 ErrIntOverflow + } + 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 != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Lo", wireType) + } + m.Lo = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + m.Lo = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + case 2: + if wireType != 5 { + return fmt.Errorf("proto: wrong wireType = %d for field Hi", wireType) + } + m.Hi = 0 + if (iNdEx + 4) > l { + return io.ErrUnexpectedEOF + } + m.Hi = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:])) + iNdEx += 4 + default: + iNdEx = preIndex + skippy, err := skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *ProbeSpecSpec) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/pkg/machinery/constants/constants.go b/pkg/machinery/constants/constants.go index 42c472bcde..9dd2167db2 100644 --- a/pkg/machinery/constants/constants.go +++ b/pkg/machinery/constants/constants.go @@ -962,6 +962,9 @@ const ( // TalosAPIDefaultCertificateValidityDuration specifies default certificate duration for Talos API generated client certificates. TalosAPIDefaultCertificateValidityDuration = time.Hour * 24 * 365 + + // DefaultNfTablesTableName is the default name of the nftables table created by Talos. + DefaultNfTablesTableName = "talos" ) // See https://linux.die.net/man/3/klogctl diff --git a/pkg/machinery/nethelpers/match_operator.go b/pkg/machinery/nethelpers/match_operator.go new file mode 100644 index 0000000000..0651f816c4 --- /dev/null +++ b/pkg/machinery/nethelpers/match_operator.go @@ -0,0 +1,18 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +//go:generate enumer -type=MatchOperator -linecomment -text + +// MatchOperator is a netfilter match operator. +type MatchOperator int + +// MatchOperator constants. +// +//structprotogen:gen_enum +const ( + OperatorEqual MatchOperator = 0 // == + OperatorNotEqual MatchOperator = 1 // != +) diff --git a/pkg/machinery/nethelpers/matchoperator_enumer.go b/pkg/machinery/nethelpers/matchoperator_enumer.go new file mode 100644 index 0000000000..4f65d1c565 --- /dev/null +++ b/pkg/machinery/nethelpers/matchoperator_enumer.go @@ -0,0 +1,61 @@ +// Code generated by "enumer -type=MatchOperator -linecomment -text"; DO NOT EDIT. + +package nethelpers + +import ( + "fmt" +) + +const _MatchOperatorName = "==!=" + +var _MatchOperatorIndex = [...]uint8{0, 2, 4} + +func (i MatchOperator) String() string { + if i < 0 || i >= MatchOperator(len(_MatchOperatorIndex)-1) { + return fmt.Sprintf("MatchOperator(%d)", i) + } + return _MatchOperatorName[_MatchOperatorIndex[i]:_MatchOperatorIndex[i+1]] +} + +var _MatchOperatorValues = []MatchOperator{0, 1} + +var _MatchOperatorNameToValueMap = map[string]MatchOperator{ + _MatchOperatorName[0:2]: 0, + _MatchOperatorName[2:4]: 1, +} + +// MatchOperatorString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func MatchOperatorString(s string) (MatchOperator, error) { + if val, ok := _MatchOperatorNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to MatchOperator values", s) +} + +// MatchOperatorValues returns all values of the enum +func MatchOperatorValues() []MatchOperator { + return _MatchOperatorValues +} + +// IsAMatchOperator returns "true" if the value is listed in the enum definition. "false" otherwise +func (i MatchOperator) IsAMatchOperator() bool { + for _, v := range _MatchOperatorValues { + if i == v { + return true + } + } + return false +} + +// MarshalText implements the encoding.TextMarshaler interface for MatchOperator +func (i MatchOperator) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for MatchOperator +func (i *MatchOperator) UnmarshalText(text []byte) error { + var err error + *i, err = MatchOperatorString(string(text)) + return err +} diff --git a/pkg/machinery/nethelpers/nftables_chain_hook.go b/pkg/machinery/nethelpers/nftables_chain_hook.go new file mode 100644 index 0000000000..dd435179a4 --- /dev/null +++ b/pkg/machinery/nethelpers/nftables_chain_hook.go @@ -0,0 +1,21 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +//go:generate enumer -type=NfTablesChainHook -linecomment -text + +// NfTablesChainHook wraps nftables.ChainHook for YAML marshaling. +type NfTablesChainHook uint32 + +// Constants copied from nftables to provide Stringer interface. +// +//structprotogen:gen_enum +const ( + ChainHookPrerouting NfTablesChainHook = 0 // prerouting + ChainHookInput NfTablesChainHook = 1 // input + ChainHookForward NfTablesChainHook = 2 // forward + ChainHookOutput NfTablesChainHook = 3 // output + ChainHookPostrouting NfTablesChainHook = 4 // postrouting +) diff --git a/pkg/machinery/nethelpers/nftables_chain_priority.go b/pkg/machinery/nethelpers/nftables_chain_priority.go new file mode 100644 index 0000000000..db1f9e3a57 --- /dev/null +++ b/pkg/machinery/nethelpers/nftables_chain_priority.go @@ -0,0 +1,31 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +import "math" + +//go:generate enumer -type=NfTablesChainPriority -linecomment -text + +// NfTablesChainPriority wraps nftables.ChainPriority for YAML marshaling. +type NfTablesChainPriority int32 + +// Constants copied from nftables to provide Stringer interface. +// +//structprotogen:gen_enum +const ( + ChainPriorityFirst NfTablesChainPriority = math.MinInt32 // first + ChainPriorityConntrackDefrag NfTablesChainPriority = -400 // conntrack-defrag + ChainPriorityRaw NfTablesChainPriority = -300 // raw + ChainPrioritySELinuxFirst NfTablesChainPriority = -225 // selinux-first + ChainPriorityConntrack NfTablesChainPriority = -200 // conntrack + ChainPriorityMangle NfTablesChainPriority = -150 // mangle + ChainPriorityNATDest NfTablesChainPriority = -100 // nat-dest + ChainPriorityFilter NfTablesChainPriority = 0 // filter + ChainPrioritySecurity NfTablesChainPriority = 50 // security + ChainPriorityNATSource NfTablesChainPriority = 100 // nat-source + ChainPrioritySELinuxLast NfTablesChainPriority = 225 // selinux-last + ChainPriorityConntrackHelper NfTablesChainPriority = 300 // conntrack-helper + ChainPriorityLast NfTablesChainPriority = math.MaxInt32 // last +) diff --git a/pkg/machinery/nethelpers/nftables_chain_type.go b/pkg/machinery/nethelpers/nftables_chain_type.go new file mode 100644 index 0000000000..5c1d488636 --- /dev/null +++ b/pkg/machinery/nethelpers/nftables_chain_type.go @@ -0,0 +1,16 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +// NfTablesChainType defines what this chain will be used for. See also +// https://wiki.nftables.org/wiki-nftables/index.php/Configuring_chains#Base_chain_types +type NfTablesChainType = string + +// Possible ChainType values. +const ( + ChainTypeFilter NfTablesChainType = "filter" + ChainTypeRoute NfTablesChainType = "route" + ChainTypeNAT NfTablesChainType = "nat" +) diff --git a/pkg/machinery/nethelpers/nftables_verdict.go b/pkg/machinery/nethelpers/nftables_verdict.go new file mode 100644 index 0000000000..eaacedcd59 --- /dev/null +++ b/pkg/machinery/nethelpers/nftables_verdict.go @@ -0,0 +1,18 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +//go:generate enumer -type=NfTablesVerdict -linecomment -text + +// NfTablesVerdict wraps nftables.Verdict for YAML marshaling. +type NfTablesVerdict int64 + +// Constants copied from nftables to provide Stringer interface. +// +//structprotogen:gen_enum +const ( + VerdictDrop NfTablesVerdict = 0 // drop + VerdictAccept NfTablesVerdict = 1 // accept +) diff --git a/pkg/machinery/nethelpers/nftableschainhook_enumer.go b/pkg/machinery/nethelpers/nftableschainhook_enumer.go new file mode 100644 index 0000000000..9f3f5d7e6f --- /dev/null +++ b/pkg/machinery/nethelpers/nftableschainhook_enumer.go @@ -0,0 +1,64 @@ +// Code generated by "enumer -type=NfTablesChainHook -linecomment -text"; DO NOT EDIT. + +package nethelpers + +import ( + "fmt" +) + +const _NfTablesChainHookName = "preroutinginputforwardoutputpostrouting" + +var _NfTablesChainHookIndex = [...]uint8{0, 10, 15, 22, 28, 39} + +func (i NfTablesChainHook) String() string { + if i >= NfTablesChainHook(len(_NfTablesChainHookIndex)-1) { + return fmt.Sprintf("NfTablesChainHook(%d)", i) + } + return _NfTablesChainHookName[_NfTablesChainHookIndex[i]:_NfTablesChainHookIndex[i+1]] +} + +var _NfTablesChainHookValues = []NfTablesChainHook{0, 1, 2, 3, 4} + +var _NfTablesChainHookNameToValueMap = map[string]NfTablesChainHook{ + _NfTablesChainHookName[0:10]: 0, + _NfTablesChainHookName[10:15]: 1, + _NfTablesChainHookName[15:22]: 2, + _NfTablesChainHookName[22:28]: 3, + _NfTablesChainHookName[28:39]: 4, +} + +// NfTablesChainHookString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func NfTablesChainHookString(s string) (NfTablesChainHook, error) { + if val, ok := _NfTablesChainHookNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to NfTablesChainHook values", s) +} + +// NfTablesChainHookValues returns all values of the enum +func NfTablesChainHookValues() []NfTablesChainHook { + return _NfTablesChainHookValues +} + +// IsANfTablesChainHook returns "true" if the value is listed in the enum definition. "false" otherwise +func (i NfTablesChainHook) IsANfTablesChainHook() bool { + for _, v := range _NfTablesChainHookValues { + if i == v { + return true + } + } + return false +} + +// MarshalText implements the encoding.TextMarshaler interface for NfTablesChainHook +func (i NfTablesChainHook) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesChainHook +func (i *NfTablesChainHook) UnmarshalText(text []byte) error { + var err error + *i, err = NfTablesChainHookString(string(text)) + return err +} diff --git a/pkg/machinery/nethelpers/nftableschainpriority_enumer.go b/pkg/machinery/nethelpers/nftableschainpriority_enumer.go new file mode 100644 index 0000000000..445ef3d5dc --- /dev/null +++ b/pkg/machinery/nethelpers/nftableschainpriority_enumer.go @@ -0,0 +1,82 @@ +// Code generated by "enumer -type=NfTablesChainPriority -linecomment -text"; DO NOT EDIT. + +package nethelpers + +import ( + "fmt" +) + +const _NfTablesChainPriorityName = "firstconntrack-defragrawselinux-firstconntrackmanglenat-destfiltersecuritynat-sourceselinux-lastconntrack-helperlast" + +var _NfTablesChainPriorityMap = map[NfTablesChainPriority]string{ + -2147483648: _NfTablesChainPriorityName[0:5], + -400: _NfTablesChainPriorityName[5:21], + -300: _NfTablesChainPriorityName[21:24], + -225: _NfTablesChainPriorityName[24:37], + -200: _NfTablesChainPriorityName[37:46], + -150: _NfTablesChainPriorityName[46:52], + -100: _NfTablesChainPriorityName[52:60], + 0: _NfTablesChainPriorityName[60:66], + 50: _NfTablesChainPriorityName[66:74], + 100: _NfTablesChainPriorityName[74:84], + 225: _NfTablesChainPriorityName[84:96], + 300: _NfTablesChainPriorityName[96:112], + 2147483647: _NfTablesChainPriorityName[112:116], +} + +func (i NfTablesChainPriority) String() string { + if str, ok := _NfTablesChainPriorityMap[i]; ok { + return str + } + return fmt.Sprintf("NfTablesChainPriority(%d)", i) +} + +var _NfTablesChainPriorityValues = []NfTablesChainPriority{-2147483648, -400, -300, -225, -200, -150, -100, 0, 50, 100, 225, 300, 2147483647} + +var _NfTablesChainPriorityNameToValueMap = map[string]NfTablesChainPriority{ + _NfTablesChainPriorityName[0:5]: -2147483648, + _NfTablesChainPriorityName[5:21]: -400, + _NfTablesChainPriorityName[21:24]: -300, + _NfTablesChainPriorityName[24:37]: -225, + _NfTablesChainPriorityName[37:46]: -200, + _NfTablesChainPriorityName[46:52]: -150, + _NfTablesChainPriorityName[52:60]: -100, + _NfTablesChainPriorityName[60:66]: 0, + _NfTablesChainPriorityName[66:74]: 50, + _NfTablesChainPriorityName[74:84]: 100, + _NfTablesChainPriorityName[84:96]: 225, + _NfTablesChainPriorityName[96:112]: 300, + _NfTablesChainPriorityName[112:116]: 2147483647, +} + +// NfTablesChainPriorityString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func NfTablesChainPriorityString(s string) (NfTablesChainPriority, error) { + if val, ok := _NfTablesChainPriorityNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to NfTablesChainPriority values", s) +} + +// NfTablesChainPriorityValues returns all values of the enum +func NfTablesChainPriorityValues() []NfTablesChainPriority { + return _NfTablesChainPriorityValues +} + +// IsANfTablesChainPriority returns "true" if the value is listed in the enum definition. "false" otherwise +func (i NfTablesChainPriority) IsANfTablesChainPriority() bool { + _, ok := _NfTablesChainPriorityMap[i] + return ok +} + +// MarshalText implements the encoding.TextMarshaler interface for NfTablesChainPriority +func (i NfTablesChainPriority) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesChainPriority +func (i *NfTablesChainPriority) UnmarshalText(text []byte) error { + var err error + *i, err = NfTablesChainPriorityString(string(text)) + return err +} diff --git a/pkg/machinery/nethelpers/nftablesverdict_enumer.go b/pkg/machinery/nethelpers/nftablesverdict_enumer.go new file mode 100644 index 0000000000..bd69af0df5 --- /dev/null +++ b/pkg/machinery/nethelpers/nftablesverdict_enumer.go @@ -0,0 +1,61 @@ +// Code generated by "enumer -type=NfTablesVerdict -linecomment -text"; DO NOT EDIT. + +package nethelpers + +import ( + "fmt" +) + +const _NfTablesVerdictName = "dropaccept" + +var _NfTablesVerdictIndex = [...]uint8{0, 4, 10} + +func (i NfTablesVerdict) String() string { + if i < 0 || i >= NfTablesVerdict(len(_NfTablesVerdictIndex)-1) { + return fmt.Sprintf("NfTablesVerdict(%d)", i) + } + return _NfTablesVerdictName[_NfTablesVerdictIndex[i]:_NfTablesVerdictIndex[i+1]] +} + +var _NfTablesVerdictValues = []NfTablesVerdict{0, 1} + +var _NfTablesVerdictNameToValueMap = map[string]NfTablesVerdict{ + _NfTablesVerdictName[0:4]: 0, + _NfTablesVerdictName[4:10]: 1, +} + +// NfTablesVerdictString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func NfTablesVerdictString(s string) (NfTablesVerdict, error) { + if val, ok := _NfTablesVerdictNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to NfTablesVerdict values", s) +} + +// NfTablesVerdictValues returns all values of the enum +func NfTablesVerdictValues() []NfTablesVerdict { + return _NfTablesVerdictValues +} + +// IsANfTablesVerdict returns "true" if the value is listed in the enum definition. "false" otherwise +func (i NfTablesVerdict) IsANfTablesVerdict() bool { + for _, v := range _NfTablesVerdictValues { + if i == v { + return true + } + } + return false +} + +// MarshalText implements the encoding.TextMarshaler interface for NfTablesVerdict +func (i NfTablesVerdict) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesVerdict +func (i *NfTablesVerdict) UnmarshalText(text []byte) error { + var err error + *i, err = NfTablesVerdictString(string(text)) + return err +} diff --git a/pkg/machinery/nethelpers/protocol.go b/pkg/machinery/nethelpers/protocol.go new file mode 100644 index 0000000000..b183159088 --- /dev/null +++ b/pkg/machinery/nethelpers/protocol.go @@ -0,0 +1,18 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package nethelpers + +//go:generate enumer -type=Protocol -linecomment -text + +// Protocol is a inet protocol. +type Protocol uint8 + +// Protocol constants. +// +//structprotogen:gen_enum +const ( + ProtocolTCP Protocol = 0x6 // tcp + ProtocolUDP Protocol = 0x11 // udp +) diff --git a/pkg/machinery/nethelpers/protocol_enumer.go b/pkg/machinery/nethelpers/protocol_enumer.go new file mode 100644 index 0000000000..e2c5587e2d --- /dev/null +++ b/pkg/machinery/nethelpers/protocol_enumer.go @@ -0,0 +1,71 @@ +// Code generated by "enumer -type=Protocol -linecomment -text"; DO NOT EDIT. + +package nethelpers + +import ( + "fmt" +) + +const ( + _ProtocolName_0 = "tcp" + _ProtocolName_1 = "udp" +) + +var ( + _ProtocolIndex_0 = [...]uint8{0, 3} + _ProtocolIndex_1 = [...]uint8{0, 3} +) + +func (i Protocol) String() string { + switch { + case i == 6: + return _ProtocolName_0 + case i == 17: + return _ProtocolName_1 + default: + return fmt.Sprintf("Protocol(%d)", i) + } +} + +var _ProtocolValues = []Protocol{6, 17} + +var _ProtocolNameToValueMap = map[string]Protocol{ + _ProtocolName_0[0:3]: 6, + _ProtocolName_1[0:3]: 17, +} + +// ProtocolString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func ProtocolString(s string) (Protocol, error) { + if val, ok := _ProtocolNameToValueMap[s]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to Protocol values", s) +} + +// ProtocolValues returns all values of the enum +func ProtocolValues() []Protocol { + return _ProtocolValues +} + +// IsAProtocol returns "true" if the value is listed in the enum definition. "false" otherwise +func (i Protocol) IsAProtocol() bool { + for _, v := range _ProtocolValues { + if i == v { + return true + } + } + return false +} + +// MarshalText implements the encoding.TextMarshaler interface for Protocol +func (i Protocol) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for Protocol +func (i *Protocol) UnmarshalText(text []byte) error { + var err error + *i, err = ProtocolString(string(text)) + return err +} diff --git a/pkg/machinery/resources/network/address_spec.go b/pkg/machinery/resources/network/address_spec.go index 1639db5669..b45a96a47a 100644 --- a/pkg/machinery/resources/network/address_spec.go +++ b/pkg/machinery/resources/network/address_spec.go @@ -16,7 +16,7 @@ import ( "github.com/siderolabs/talos/pkg/machinery/proto" ) -//go:generate deep-copy -type AddressSpecSpec -type AddressStatusSpec -type HardwareAddrSpec -type HostnameSpecSpec -type HostnameStatusSpec -type LinkRefreshSpec -type LinkSpecSpec -type LinkStatusSpec -type NodeAddressSpec -type NodeAddressFilterSpec -type OperatorSpecSpec -type ProbeSpecSpec -type ProbeStatusSpec -type ResolverSpecSpec -type ResolverStatusSpec -type RouteSpecSpec -type RouteStatusSpec -type StatusSpec -type TimeServerSpecSpec -type TimeServerStatusSpec -header-file ../../../../hack/boilerplate.txt -o deep_copy.generated.go . +//go:generate deep-copy -type AddressSpecSpec -type AddressStatusSpec -type HardwareAddrSpec -type HostnameSpecSpec -type HostnameStatusSpec -type LinkRefreshSpec -type LinkSpecSpec -type LinkStatusSpec -type NfTablesChainSpec -type NodeAddressSpec -type NodeAddressFilterSpec -type OperatorSpecSpec -type ProbeSpecSpec -type ProbeStatusSpec -type ResolverSpecSpec -type ResolverStatusSpec -type RouteSpecSpec -type RouteStatusSpec -type StatusSpec -type TimeServerSpecSpec -type TimeServerStatusSpec -header-file ../../../../hack/boilerplate.txt -o deep_copy.generated.go . // AddressSpecType is type of AddressSpec resource. const AddressSpecType = resource.Type("AddressSpecs.net.talos.dev") diff --git a/pkg/machinery/resources/network/deep_copy.generated.go b/pkg/machinery/resources/network/deep_copy.generated.go index 89b13fb516..415f6947f3 100644 --- a/pkg/machinery/resources/network/deep_copy.generated.go +++ b/pkg/machinery/resources/network/deep_copy.generated.go @@ -2,12 +2,14 @@ // License, v. 2.0. If a copy of the MPL was not distributed with this // file, You can obtain one at http://mozilla.org/MPL/2.0/. -// Code generated by "deep-copy -type AddressSpecSpec -type AddressStatusSpec -type HardwareAddrSpec -type HostnameSpecSpec -type HostnameStatusSpec -type LinkRefreshSpec -type LinkSpecSpec -type LinkStatusSpec -type NodeAddressSpec -type NodeAddressFilterSpec -type OperatorSpecSpec -type ProbeSpecSpec -type ProbeStatusSpec -type ResolverSpecSpec -type ResolverStatusSpec -type RouteSpecSpec -type RouteStatusSpec -type StatusSpec -type TimeServerSpecSpec -type TimeServerStatusSpec -header-file ../../../../hack/boilerplate.txt -o deep_copy.generated.go ."; DO NOT EDIT. +// Code generated by "deep-copy -type AddressSpecSpec -type AddressStatusSpec -type HardwareAddrSpec -type HostnameSpecSpec -type HostnameStatusSpec -type LinkRefreshSpec -type LinkSpecSpec -type LinkStatusSpec -type NfTablesChainSpec -type NodeAddressSpec -type NodeAddressFilterSpec -type OperatorSpecSpec -type ProbeSpecSpec -type ProbeStatusSpec -type ResolverSpecSpec -type ResolverStatusSpec -type RouteSpecSpec -type RouteStatusSpec -type StatusSpec -type TimeServerSpecSpec -type TimeServerStatusSpec -header-file ../../../../hack/boilerplate.txt -o deep_copy.generated.go ."; DO NOT EDIT. package network import ( "net/netip" + + "github.com/siderolabs/talos/pkg/machinery/nethelpers" ) // DeepCopy generates a deep copy of AddressSpecSpec. @@ -94,6 +96,86 @@ func (o LinkStatusSpec) DeepCopy() LinkStatusSpec { return cp } +// DeepCopy generates a deep copy of NfTablesChainSpec. +func (o NfTablesChainSpec) DeepCopy() NfTablesChainSpec { + var cp NfTablesChainSpec = o + if o.Rules != nil { + cp.Rules = make([]NfTablesRule, len(o.Rules)) + copy(cp.Rules, o.Rules) + for i2 := range o.Rules { + if o.Rules[i2].MatchIIfName != nil { + cp.Rules[i2].MatchIIfName = new(NfTablesIfNameMatch) + *cp.Rules[i2].MatchIIfName = *o.Rules[i2].MatchIIfName + } + if o.Rules[i2].MatchOIfName != nil { + cp.Rules[i2].MatchOIfName = new(NfTablesIfNameMatch) + *cp.Rules[i2].MatchOIfName = *o.Rules[i2].MatchOIfName + } + if o.Rules[i2].MatchMark != nil { + cp.Rules[i2].MatchMark = new(NfTablesMark) + *cp.Rules[i2].MatchMark = *o.Rules[i2].MatchMark + } + if o.Rules[i2].MatchSourceAddress != nil { + cp.Rules[i2].MatchSourceAddress = new(NfTablesAddressMatch) + *cp.Rules[i2].MatchSourceAddress = *o.Rules[i2].MatchSourceAddress + if o.Rules[i2].MatchSourceAddress.IncludeSubnets != nil { + cp.Rules[i2].MatchSourceAddress.IncludeSubnets = make([]netip.Prefix, len(o.Rules[i2].MatchSourceAddress.IncludeSubnets)) + copy(cp.Rules[i2].MatchSourceAddress.IncludeSubnets, o.Rules[i2].MatchSourceAddress.IncludeSubnets) + } + if o.Rules[i2].MatchSourceAddress.ExcludeSubnets != nil { + cp.Rules[i2].MatchSourceAddress.ExcludeSubnets = make([]netip.Prefix, len(o.Rules[i2].MatchSourceAddress.ExcludeSubnets)) + copy(cp.Rules[i2].MatchSourceAddress.ExcludeSubnets, o.Rules[i2].MatchSourceAddress.ExcludeSubnets) + } + } + if o.Rules[i2].MatchDestinationAddress != nil { + cp.Rules[i2].MatchDestinationAddress = new(NfTablesAddressMatch) + *cp.Rules[i2].MatchDestinationAddress = *o.Rules[i2].MatchDestinationAddress + if o.Rules[i2].MatchDestinationAddress.IncludeSubnets != nil { + cp.Rules[i2].MatchDestinationAddress.IncludeSubnets = make([]netip.Prefix, len(o.Rules[i2].MatchDestinationAddress.IncludeSubnets)) + copy(cp.Rules[i2].MatchDestinationAddress.IncludeSubnets, o.Rules[i2].MatchDestinationAddress.IncludeSubnets) + } + if o.Rules[i2].MatchDestinationAddress.ExcludeSubnets != nil { + cp.Rules[i2].MatchDestinationAddress.ExcludeSubnets = make([]netip.Prefix, len(o.Rules[i2].MatchDestinationAddress.ExcludeSubnets)) + copy(cp.Rules[i2].MatchDestinationAddress.ExcludeSubnets, o.Rules[i2].MatchDestinationAddress.ExcludeSubnets) + } + } + if o.Rules[i2].MatchLayer4 != nil { + cp.Rules[i2].MatchLayer4 = new(NfTablesLayer4Match) + *cp.Rules[i2].MatchLayer4 = *o.Rules[i2].MatchLayer4 + if o.Rules[i2].MatchLayer4.MatchSourcePort != nil { + cp.Rules[i2].MatchLayer4.MatchSourcePort = new(NfTablesPortMatch) + *cp.Rules[i2].MatchLayer4.MatchSourcePort = *o.Rules[i2].MatchLayer4.MatchSourcePort + if o.Rules[i2].MatchLayer4.MatchSourcePort.Ranges != nil { + cp.Rules[i2].MatchLayer4.MatchSourcePort.Ranges = make([]PortRange, len(o.Rules[i2].MatchLayer4.MatchSourcePort.Ranges)) + copy(cp.Rules[i2].MatchLayer4.MatchSourcePort.Ranges, o.Rules[i2].MatchLayer4.MatchSourcePort.Ranges) + } + } + if o.Rules[i2].MatchLayer4.MatchDestinationPort != nil { + cp.Rules[i2].MatchLayer4.MatchDestinationPort = new(NfTablesPortMatch) + *cp.Rules[i2].MatchLayer4.MatchDestinationPort = *o.Rules[i2].MatchLayer4.MatchDestinationPort + if o.Rules[i2].MatchLayer4.MatchDestinationPort.Ranges != nil { + cp.Rules[i2].MatchLayer4.MatchDestinationPort.Ranges = make([]PortRange, len(o.Rules[i2].MatchLayer4.MatchDestinationPort.Ranges)) + copy(cp.Rules[i2].MatchLayer4.MatchDestinationPort.Ranges, o.Rules[i2].MatchLayer4.MatchDestinationPort.Ranges) + } + } + } + if o.Rules[i2].ClampMSS != nil { + cp.Rules[i2].ClampMSS = new(NfTablesClampMSS) + *cp.Rules[i2].ClampMSS = *o.Rules[i2].ClampMSS + } + if o.Rules[i2].SetMark != nil { + cp.Rules[i2].SetMark = new(NfTablesMark) + *cp.Rules[i2].SetMark = *o.Rules[i2].SetMark + } + if o.Rules[i2].Verdict != nil { + cp.Rules[i2].Verdict = new(nethelpers.NfTablesVerdict) + *cp.Rules[i2].Verdict = *o.Rules[i2].Verdict + } + } + } + return cp +} + // DeepCopy generates a deep copy of NodeAddressSpec. func (o NodeAddressSpec) DeepCopy() NodeAddressSpec { var cp NodeAddressSpec = o diff --git a/pkg/machinery/resources/network/network_test.go b/pkg/machinery/resources/network/network_test.go index 0e25c47c10..d1c09d4f62 100644 --- a/pkg/machinery/resources/network/network_test.go +++ b/pkg/machinery/resources/network/network_test.go @@ -33,6 +33,7 @@ func TestRegisterResource(t *testing.T) { &network.LinkRefresh{}, &network.LinkStatus{}, &network.LinkSpec{}, + &network.NfTablesChain{}, &network.NodeAddress{}, &network.NodeAddressFilter{}, &network.OperatorSpec{}, diff --git a/pkg/machinery/resources/network/nftables_chain.go b/pkg/machinery/resources/network/nftables_chain.go new file mode 100644 index 0000000000..e10a930ba2 --- /dev/null +++ b/pkg/machinery/resources/network/nftables_chain.go @@ -0,0 +1,150 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package network + +import ( + "net/netip" + + "github.com/cosi-project/runtime/pkg/resource" + "github.com/cosi-project/runtime/pkg/resource/meta" + "github.com/cosi-project/runtime/pkg/resource/protobuf" + "github.com/cosi-project/runtime/pkg/resource/typed" + + "github.com/siderolabs/talos/pkg/machinery/nethelpers" + "github.com/siderolabs/talos/pkg/machinery/proto" +) + +// NfTablesChainType is type of NfTablesChain resource. +const NfTablesChainType = resource.Type("NfTablesChains.net.talos.dev") + +// NfTablesChain resource holds definition of the nftables chain. +type NfTablesChain = typed.Resource[NfTablesChainSpec, NfTablesChainExtension] + +// NfTablesChainSpec describes status of rendered secrets. +// +//gotagsrewrite:gen +type NfTablesChainSpec struct { + Type nethelpers.NfTablesChainType `yaml:"type" protobuf:"1"` + Hook nethelpers.NfTablesChainHook `yaml:"hook" protobuf:"2"` + Priority nethelpers.NfTablesChainPriority `yaml:"priority" protobuf:"3"` + + Rules []NfTablesRule `yaml:"rules" protobuf:"4"` +} + +// NfTablesRule describes a single rule in the nftables chain. +// +//gotagsrewrite:gen +type NfTablesRule struct { + MatchIIfName *NfTablesIfNameMatch `yaml:"matchIIfName,omitempty" protobuf:"8"` + MatchOIfName *NfTablesIfNameMatch `yaml:"matchOIfName,omitempty" protobuf:"1"` + MatchMark *NfTablesMark `yaml:"matchMark,omitempty" protobuf:"3"` + MatchSourceAddress *NfTablesAddressMatch `yaml:"matchSourceAddress,omitempty" protobuf:"5"` + MatchDestinationAddress *NfTablesAddressMatch `yaml:"matchDestinationAddress,omitempty" protobuf:"6"` + MatchLayer4 *NfTablesLayer4Match `yaml:"matchLayer4,omitempty" protobuf:"7"` + + ClampMSS *NfTablesClampMSS `yaml:"clampMSS,omitempty" protobuf:"9"` + SetMark *NfTablesMark `yaml:"setMark,omitempty" protobuf:"4"` + Verdict *nethelpers.NfTablesVerdict `yaml:"verdict,omitempty" protobuf:"2"` +} + +// NfTablesIfNameMatch describes the match on the interface name. +// +//gotagsrewrite:gen +type NfTablesIfNameMatch struct { + InterfaceName string `yaml:"interfaceName" protobuf:"1"` + Operator nethelpers.MatchOperator `yaml:"operator" protobuf:"2"` +} + +// NfTablesMark encodes packet mark match/update operation. +// +// When used as a match computes the following condition: +// (mark & mask) ^ xor == value +// +// When used as an update computes the following operation: +// mark = (mark & mask) ^ xor. +// +//gotagsrewrite:gen +type NfTablesMark struct { + Mask uint32 `yaml:"mask,omitempty" protobuf:"1"` + Xor uint32 `yaml:"xor,omitempty" protobuf:"2"` + Value uint32 `yaml:"value,omitempty" protobuf:"3"` +} + +// NfTablesAddressMatch describes the match on the IP address. +// +//gotagsrewrite:gen +type NfTablesAddressMatch struct { + IncludeSubnets []netip.Prefix `yaml:"includeSubnets,omitempty" protobuf:"1"` + ExcludeSubnets []netip.Prefix `yaml:"excludeSubnets,omitempty" protobuf:"2"` + Invert bool `yaml:"invert,omitempty" protobuf:"3"` +} + +// NfTablesLayer4Match describes the match on the transport layer protocol. +// +//gotagsrewrite:gen +type NfTablesLayer4Match struct { + Protocol nethelpers.Protocol `yaml:"protocol" protobuf:"1"` + MatchSourcePort *NfTablesPortMatch `yaml:"matchSourcePort,omitempty" protobuf:"2"` + MatchDestinationPort *NfTablesPortMatch `yaml:"matchDestinationPort,omitempty" protobuf:"3"` +} + +// NfTablesPortMatch describes the match on the transport layer port. +// +//gotagsrewrite:gen +type NfTablesPortMatch struct { + Ranges []PortRange `yaml:"ranges,omitempty" protobuf:"1"` +} + +// PortRange describes a range of ports. +// +// Range is [lo, hi]. +// +//gotagsrewrite:gen +type PortRange struct { + Lo uint16 `yaml:"lo" protobuf:"1"` + Hi uint16 `yaml:"hi" protobuf:"2"` +} + +// NfTablesClampMSS describes the TCP MSS clamping operation. +// +// MSS is limited by the `MaxMTU` so that: +// - IPv4: MSS = MaxMTU - 40 +// - IPv6: MSS = MaxMTU - 60. +// +//gotagsrewrite:gen +type NfTablesClampMSS struct { + MTU uint16 `yaml:"mtu" protobuf:"1"` +} + +// NewNfTablesChain initializes a NfTablesChain resource. +func NewNfTablesChain(namespace resource.Namespace, id resource.ID) *NfTablesChain { + return typed.NewResource[NfTablesChainSpec, NfTablesChainExtension]( + resource.NewMetadata(namespace, NfTablesChainType, id, resource.VersionUndefined), + NfTablesChainSpec{}, + ) +} + +// NfTablesChainExtension provides auxiliary methods for NfTablesChain. +type NfTablesChainExtension struct{} + +// ResourceDefinition implements [typed.Extension] interface. +func (NfTablesChainExtension) ResourceDefinition() meta.ResourceDefinitionSpec { + return meta.ResourceDefinitionSpec{ + Type: NfTablesChainType, + Aliases: []resource.Type{"chain", "chains"}, + DefaultNamespace: NamespaceName, + PrintColumns: []meta.PrintColumn{}, + Sensitivity: meta.NonSensitive, + } +} + +func init() { + proto.RegisterDefaultTypes() + + err := protobuf.RegisterDynamic[NfTablesChainSpec](NfTablesChainType, &NfTablesChain{}) + if err != nil { + panic(err) + } +} diff --git a/website/content/v1.6/reference/api.md b/website/content/v1.6/reference/api.md index 03e131f42c..08e98a99b6 100644 --- a/website/content/v1.6/reference/api.md +++ b/website/content/v1.6/reference/api.md @@ -51,9 +51,14 @@ description: Talos gRPC API reference. - [NethelpersFamily](#talos.resource.definitions.enums.NethelpersFamily) - [NethelpersLACPRate](#talos.resource.definitions.enums.NethelpersLACPRate) - [NethelpersLinkType](#talos.resource.definitions.enums.NethelpersLinkType) + - [NethelpersMatchOperator](#talos.resource.definitions.enums.NethelpersMatchOperator) + - [NethelpersNfTablesChainHook](#talos.resource.definitions.enums.NethelpersNfTablesChainHook) + - [NethelpersNfTablesChainPriority](#talos.resource.definitions.enums.NethelpersNfTablesChainPriority) + - [NethelpersNfTablesVerdict](#talos.resource.definitions.enums.NethelpersNfTablesVerdict) - [NethelpersOperationalState](#talos.resource.definitions.enums.NethelpersOperationalState) - [NethelpersPort](#talos.resource.definitions.enums.NethelpersPort) - [NethelpersPrimaryReselect](#talos.resource.definitions.enums.NethelpersPrimaryReselect) + - [NethelpersProtocol](#talos.resource.definitions.enums.NethelpersProtocol) - [NethelpersRouteFlag](#talos.resource.definitions.enums.NethelpersRouteFlag) - [NethelpersRouteProtocol](#talos.resource.definitions.enums.NethelpersRouteProtocol) - [NethelpersRouteType](#talos.resource.definitions.enums.NethelpersRouteType) @@ -158,9 +163,18 @@ description: Talos gRPC API reference. - [LinkRefreshSpec](#talos.resource.definitions.network.LinkRefreshSpec) - [LinkSpecSpec](#talos.resource.definitions.network.LinkSpecSpec) - [LinkStatusSpec](#talos.resource.definitions.network.LinkStatusSpec) + - [NfTablesAddressMatch](#talos.resource.definitions.network.NfTablesAddressMatch) + - [NfTablesChainSpec](#talos.resource.definitions.network.NfTablesChainSpec) + - [NfTablesClampMSS](#talos.resource.definitions.network.NfTablesClampMSS) + - [NfTablesIfNameMatch](#talos.resource.definitions.network.NfTablesIfNameMatch) + - [NfTablesLayer4Match](#talos.resource.definitions.network.NfTablesLayer4Match) + - [NfTablesMark](#talos.resource.definitions.network.NfTablesMark) + - [NfTablesPortMatch](#talos.resource.definitions.network.NfTablesPortMatch) + - [NfTablesRule](#talos.resource.definitions.network.NfTablesRule) - [NodeAddressFilterSpec](#talos.resource.definitions.network.NodeAddressFilterSpec) - [NodeAddressSpec](#talos.resource.definitions.network.NodeAddressSpec) - [OperatorSpecSpec](#talos.resource.definitions.network.OperatorSpecSpec) + - [PortRange](#talos.resource.definitions.network.PortRange) - [ProbeSpecSpec](#talos.resource.definitions.network.ProbeSpecSpec) - [ProbeStatusSpec](#talos.resource.definitions.network.ProbeStatusSpec) - [ResolverSpecSpec](#talos.resource.definitions.network.ResolverSpecSpec) @@ -1152,6 +1166,69 @@ NethelpersLinkType is a link type. + + +### NethelpersMatchOperator +NethelpersMatchOperator is a netfilter match operator. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| OPERATOR_EQUAL | 0 | | +| OPERATOR_NOT_EQUAL | 1 | | + + + + + +### NethelpersNfTablesChainHook +NethelpersNfTablesChainHook wraps nftables.ChainHook for YAML marshaling. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| CHAIN_HOOK_PREROUTING | 0 | | +| CHAIN_HOOK_INPUT | 1 | | +| CHAIN_HOOK_FORWARD | 2 | | +| CHAIN_HOOK_OUTPUT | 3 | | +| CHAIN_HOOK_POSTROUTING | 4 | | + + + + + +### NethelpersNfTablesChainPriority +NethelpersNfTablesChainPriority wraps nftables.ChainPriority for YAML marshaling. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| NETHELPERS_NFTABLESCHAINPRIORITY_UNSPECIFIED | 0 | | +| CHAIN_PRIORITY_FIRST | -2147483648 | | +| CHAIN_PRIORITY_CONNTRACK_DEFRAG | -400 | | +| CHAIN_PRIORITY_RAW | -300 | | +| CHAIN_PRIORITY_SE_LINUX_FIRST | -225 | | +| CHAIN_PRIORITY_CONNTRACK | -200 | | +| CHAIN_PRIORITY_MANGLE | -150 | | +| CHAIN_PRIORITY_NAT_DEST | -100 | | +| CHAIN_PRIORITY_FILTER | 0 | | +| CHAIN_PRIORITY_SECURITY | 50 | | +| CHAIN_PRIORITY_NAT_SOURCE | 100 | | +| CHAIN_PRIORITY_SE_LINUX_LAST | 225 | | +| CHAIN_PRIORITY_CONNTRACK_HELPER | 300 | | +| CHAIN_PRIORITY_LAST | 2147483647 | | + + + + + +### NethelpersNfTablesVerdict +NethelpersNfTablesVerdict wraps nftables.Verdict for YAML marshaling. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| VERDICT_DROP | 0 | | +| VERDICT_ACCEPT | 1 | | + + + ### NethelpersOperationalState @@ -1200,6 +1277,19 @@ NethelpersPrimaryReselect is an ARP targets mode. + + +### NethelpersProtocol +NethelpersProtocol is a inet protocol. + +| Name | Number | Description | +| ---- | ------ | ----------- | +| NETHELPERS_PROTOCOL_UNSPECIFIED | 0 | | +| PROTOCOL_TCP | 6 | | +| PROTOCOL_UDP | 17 | | + + + ### NethelpersRouteFlag @@ -2922,6 +3012,154 @@ LinkStatusSpec describes status of rendered secrets. + + +### NfTablesAddressMatch +NfTablesAddressMatch describes the match on the IP address. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| include_subnets | [common.NetIPPrefix](#common.NetIPPrefix) | repeated | | +| exclude_subnets | [common.NetIPPrefix](#common.NetIPPrefix) | repeated | | +| invert | [bool](#bool) | | | + + + + + + + + +### NfTablesChainSpec +NfTablesChainSpec describes status of rendered secrets. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| type | [string](#string) | | | +| hook | [talos.resource.definitions.enums.NethelpersNfTablesChainHook](#talos.resource.definitions.enums.NethelpersNfTablesChainHook) | | | +| priority | [talos.resource.definitions.enums.NethelpersNfTablesChainPriority](#talos.resource.definitions.enums.NethelpersNfTablesChainPriority) | | | +| rules | [NfTablesRule](#talos.resource.definitions.network.NfTablesRule) | repeated | | + + + + + + + + +### NfTablesClampMSS +NfTablesClampMSS describes the TCP MSS clamping operation. + +MSS is limited by the `MaxMTU` so that: +- IPv4: MSS = MaxMTU - 40 +- IPv6: MSS = MaxMTU - 60. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| mtu | [fixed32](#fixed32) | | | + + + + + + + + +### NfTablesIfNameMatch +NfTablesIfNameMatch describes the match on the interface name. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| interface_name | [string](#string) | | | +| operator | [talos.resource.definitions.enums.NethelpersMatchOperator](#talos.resource.definitions.enums.NethelpersMatchOperator) | | | + + + + + + + + +### NfTablesLayer4Match +NfTablesLayer4Match describes the match on the transport layer protocol. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| protocol | [talos.resource.definitions.enums.NethelpersProtocol](#talos.resource.definitions.enums.NethelpersProtocol) | | | +| match_source_port | [NfTablesPortMatch](#talos.resource.definitions.network.NfTablesPortMatch) | | | +| match_destination_port | [NfTablesPortMatch](#talos.resource.definitions.network.NfTablesPortMatch) | | | + + + + + + + + +### NfTablesMark +NfTablesMark encodes packet mark match/update operation. + +When used as a match computes the following condition: +(mark & mask) ^ xor == value + +When used as an update computes the following operation: +mark = (mark & mask) ^ xor. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| mask | [uint32](#uint32) | | | +| xor | [uint32](#uint32) | | | +| value | [uint32](#uint32) | | | + + + + + + + + +### NfTablesPortMatch +NfTablesPortMatch describes the match on the transport layer port. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| ranges | [PortRange](#talos.resource.definitions.network.PortRange) | repeated | | + + + + + + + + +### NfTablesRule +NfTablesRule describes a single rule in the nftables chain. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| match_o_if_name | [NfTablesIfNameMatch](#talos.resource.definitions.network.NfTablesIfNameMatch) | | | +| verdict | [talos.resource.definitions.enums.NethelpersNfTablesVerdict](#talos.resource.definitions.enums.NethelpersNfTablesVerdict) | | | +| match_mark | [NfTablesMark](#talos.resource.definitions.network.NfTablesMark) | | | +| set_mark | [NfTablesMark](#talos.resource.definitions.network.NfTablesMark) | | | +| match_source_address | [NfTablesAddressMatch](#talos.resource.definitions.network.NfTablesAddressMatch) | | | +| match_destination_address | [NfTablesAddressMatch](#talos.resource.definitions.network.NfTablesAddressMatch) | | | +| match_layer4 | [NfTablesLayer4Match](#talos.resource.definitions.network.NfTablesLayer4Match) | | | +| match_i_if_name | [NfTablesIfNameMatch](#talos.resource.definitions.network.NfTablesIfNameMatch) | | | +| clamp_mss | [NfTablesClampMSS](#talos.resource.definitions.network.NfTablesClampMSS) | | | + + + + + + ### NodeAddressFilterSpec @@ -2974,6 +3212,24 @@ OperatorSpecSpec describes DNS resolvers. + + +### PortRange +PortRange describes a range of ports. + +Range is [lo, hi]. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| lo | [fixed32](#fixed32) | | | +| hi | [fixed32](#fixed32) | | | + + + + + + ### ProbeSpecSpec