nl 0.4.1 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +28 -0
- data/lib/nl/async/dispatcher.rb +2 -2
- data/lib/nl/attribute_set.rb +19 -153
- data/lib/nl/attributes.rb +193 -0
- data/lib/nl/blocking_transport.rb +5 -5
- data/lib/nl/datagram.rb +4 -4
- data/lib/nl/datatypes/checked.rb +66 -0
- data/lib/nl/datatypes/defaults.rb +13 -0
- data/lib/nl/datatypes/scalar.rb +28 -0
- data/lib/nl/datatypes.rb +97 -125
- data/lib/nl/decoder.rb +79 -25
- data/lib/nl/encoder.rb +4 -6
- data/lib/nl/endian.rb +5 -4
- data/lib/nl/exchange.rb +18 -17
- data/lib/nl/family.rb +33 -15
- data/lib/nl/genl/client.rb +1 -0
- data/lib/nl/genl/protocol.rb +16 -3
- data/lib/nl/genl/wire.rb +10 -3
- data/lib/nl/genl.rb +0 -20
- data/lib/nl/message.rb +21 -0
- data/lib/nl/notification_router.rb +2 -5
- data/lib/nl/raw/client.rb +1 -1
- data/lib/nl/raw/protocol.rb +27 -21
- data/lib/nl/raw/wire.rb +21 -50
- data/lib/nl/raw.rb +1 -51
- data/lib/nl/{sub_message.rb → selector.rb} +13 -23
- data/lib/nl/socket.rb +21 -5
- data/lib/nl/version.rb +1 -1
- data/lib/nl.rb +2 -2
- data/sig/generated/nl/attribute_set.rbs +21 -29
- data/sig/generated/nl/attributes.rbs +51 -0
- data/sig/generated/nl/datagram.rbs +4 -4
- data/sig/generated/nl/datatypes/checked.rbs +31 -0
- data/sig/generated/nl/datatypes/defaults.rbs +11 -0
- data/sig/generated/nl/datatypes/scalar.rbs +11 -0
- data/sig/generated/nl/datatypes.rbs +38 -34
- data/sig/generated/nl/decoder.rbs +12 -4
- data/sig/generated/nl/encoder.rbs +1 -1
- data/sig/generated/nl/endian.rbs +1 -0
- data/sig/generated/nl/exchange.rbs +2 -2
- data/sig/generated/nl/family.rbs +40 -22
- data/sig/generated/nl/genl/protocol.rbs +3 -1
- data/sig/generated/nl/genl.rbs +0 -15
- data/sig/generated/nl/message.rbs +14 -0
- data/sig/generated/nl/raw/client.rbs +0 -1
- data/sig/generated/nl/raw/protocol.rbs +29 -43
- data/sig/generated/nl/raw/wire.rbs +0 -36
- data/sig/generated/nl/raw.rbs +0 -35
- data/sig/generated/nl/{sub_message.rbs → selector.rbs} +8 -19
- data/sig/generated/nl/socket.rbs +29 -10
- metadata +14 -6
- data/lib/nl/structured_payload.rb +0 -61
- data/sig/generated/nl/structured_payload.rbs +0 -25
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 9c0ecd3660cf3b5d786831a8439617b6709fde4953f7e424c2ce923c27628b39
|
|
4
|
+
data.tar.gz: 740a452ad27ea59a3e19c58338d4c6d4d95c0ed07e69c20ff5cf3cc560000302
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 5287fae38e7c67fec82015d7896b78a01464f725497c1291c460d9fe1474d981b424aea4204175ae274ee659284c8c2e90f302f7ae597a69f965e7dd268ad04c
|
|
7
|
+
data.tar.gz: 0c884c46badc79b8d79cccc975bf085ef498eb9299eed772a7bb637d519e65f8078b57995a377061501435f16cc37d45e4654fbe7651ed506458118fa4835bf8
|
data/CHANGELOG.md
CHANGED
|
@@ -2,6 +2,34 @@
|
|
|
2
2
|
|
|
3
3
|
## Unreleased
|
|
4
4
|
|
|
5
|
+
## v0.5.0 (2026-11-18)
|
|
6
|
+
|
|
7
|
+
Optimized performance with API changes.
|
|
8
|
+
|
|
9
|
+
- Remove `Raw::NlAttr`; attribute sets and array codecs write their headers
|
|
10
|
+
directly without allocating a header object.
|
|
11
|
+
- Unify `Raw::Message` and `Genl::Message` as `Nl::Message`.
|
|
12
|
+
- Use `Nl::Message` for decoded selector-specific messages too; remove
|
|
13
|
+
`Nl::SubMessage`. Unrecognized payloads remain standalone `RawAttributeValue`
|
|
14
|
+
objects.
|
|
15
|
+
- Avoid validation overhead for datatypes without checks by moving validation
|
|
16
|
+
into opt-in wrappers. Replace datatype constructor `check:` arguments with
|
|
17
|
+
`DataTypes::Checked.new(datatype, check:)`, or `CheckedPayload` for checks on
|
|
18
|
+
encoded structs and packed arrays.
|
|
19
|
+
- Return decoded values directly from `AttributeSet#[]` instead of attribute
|
|
20
|
+
wrapper objects. Replace `attributes[:name].value` with `attributes[:name]`.
|
|
21
|
+
- Replace `AttributeSet#<<` with `append_attribute(name_or_id, value)`.
|
|
22
|
+
Construct empty sets with `AttributeSet.new`, and use
|
|
23
|
+
`from_params(params)` instead of passing an array of attribute wrappers
|
|
24
|
+
to the constructor.
|
|
25
|
+
- Change `Message#append_attribute` to accept an attribute name or numeric
|
|
26
|
+
ID and its value: `message.append_attribute(:mtu, 1500)`.
|
|
27
|
+
- Replace `AttributeSet::Attribute` and per-attribute classes with immutable
|
|
28
|
+
`AttributeSet::Definition` records. `by_name` and `by_type` return definitions
|
|
29
|
+
exposing `id`, `name`, `datatype`, `multi`, `order`, and `selector_slot`.
|
|
30
|
+
|
|
31
|
+
## v0.4.2 (2026-09-09)
|
|
32
|
+
|
|
5
33
|
## v0.4.1 (2026-09-08)
|
|
6
34
|
|
|
7
35
|
## v0.4.0 (2026-09-08)
|
data/lib/nl/async/dispatcher.rb
CHANGED
|
@@ -129,13 +129,13 @@ module Nl
|
|
|
129
129
|
key = [header.seq, header.pid]
|
|
130
130
|
pending = @mutex.synchronize { @pending[key] }
|
|
131
131
|
unless pending
|
|
132
|
-
@notifications.route(header, payload) if header.seq
|
|
132
|
+
@notifications.route(header, payload) if header.seq == 0
|
|
133
133
|
next
|
|
134
134
|
end
|
|
135
135
|
|
|
136
136
|
begin
|
|
137
137
|
message = @protocol.decode_frame(pending.endpoint, header, payload, pending.reply_class)
|
|
138
|
-
dispatch_outcome(key, pending, pending.exchange.accept(message))
|
|
138
|
+
dispatch_outcome(key, pending, pending.exchange.accept(header, message))
|
|
139
139
|
rescue Exception => error
|
|
140
140
|
fail_pending(key, error) if pending
|
|
141
141
|
end
|
data/lib/nl/attribute_set.rb
CHANGED
|
@@ -1,173 +1,39 @@
|
|
|
1
|
-
require_relative '
|
|
1
|
+
require_relative 'attributes'
|
|
2
2
|
|
|
3
3
|
module Nl
|
|
4
|
+
# A standalone nested attribute set. Messages share the same operations
|
|
5
|
+
# without allocating this wrapper.
|
|
4
6
|
class AttributeSet
|
|
5
|
-
|
|
6
|
-
class Attribute
|
|
7
|
-
MULTI = false
|
|
8
|
-
ORDER = nil
|
|
9
|
-
SELECTOR_SLOT = nil
|
|
7
|
+
include Attributes
|
|
10
8
|
|
|
11
|
-
|
|
12
|
-
|
|
9
|
+
Definition = Data.define(:id, :name, :datatype, :multi, :order, :selector_slot) do
|
|
10
|
+
def initialize(id:, name:, datatype:, multi: false, order: 0, selector_slot: nil)
|
|
11
|
+
super(id:, name:, datatype:, multi:, order:, selector_slot:)
|
|
13
12
|
end
|
|
14
|
-
|
|
15
|
-
def self.decode(decoder, context: nil, nlattr_type_flags: 0)
|
|
16
|
-
new(self::DATATYPE.decode(decoder, context:, nlattr_type_flags:))
|
|
17
|
-
end
|
|
18
|
-
|
|
19
|
-
def encode(encoder, context: nil)
|
|
20
|
-
self.class::DATATYPE.encode(encoder, self.value, context:)
|
|
21
|
-
end
|
|
22
|
-
end
|
|
23
|
-
|
|
24
|
-
def initialize(attributes)
|
|
25
|
-
attr_class = self.class::Attribute
|
|
26
|
-
|
|
27
|
-
attributes.each do |attr|
|
|
28
|
-
unless attr.kind_of?(attr_class)
|
|
29
|
-
raise TypeError, "attribute must be an instance of #{attr_class}"
|
|
30
|
-
end
|
|
31
|
-
end
|
|
32
|
-
|
|
33
|
-
@attributes = Array(attributes)
|
|
34
13
|
end
|
|
35
14
|
|
|
36
|
-
def []
|
|
37
|
-
|
|
38
|
-
when Symbol
|
|
39
|
-
attr_class = self.class.by_name(type)
|
|
40
|
-
when Integer
|
|
41
|
-
attr_class = self.class.by_type(type)
|
|
42
|
-
else
|
|
43
|
-
raise TypeError, "attribute type must be a Symbol or an Integer"
|
|
44
|
-
end
|
|
45
|
-
|
|
46
|
-
attributes = @attributes.select { it.kind_of?(attr_class) }
|
|
47
|
-
attr_class.multi? ? attributes : attributes.first
|
|
15
|
+
def initialize(attributes = [])
|
|
16
|
+
@attributes = attributes
|
|
48
17
|
end
|
|
49
18
|
|
|
50
|
-
def
|
|
51
|
-
|
|
52
|
-
unless attr.kind_of?(attr_class)
|
|
53
|
-
raise TypeError, "attribute must be an instance of #{attr_class}"
|
|
54
|
-
end
|
|
55
|
-
|
|
56
|
-
@attributes << attr
|
|
57
|
-
end
|
|
58
|
-
|
|
59
|
-
SELECTOR_NAMES = {local: [].freeze, external: [].freeze}.freeze
|
|
60
|
-
|
|
61
|
-
private def encode1(encoder, attr, context)
|
|
62
|
-
datatype = attr.class::DATATYPE
|
|
63
|
-
flags = datatype.nlattr_type_flags(attr.value, context:)
|
|
64
|
-
type = attr.class::TYPE | flags
|
|
65
|
-
nlattr = Raw::NlAttr.new(0, type)
|
|
66
|
-
encoder.measure(Endian::Host::U16) do
|
|
67
|
-
nlattr.encode(encoder)
|
|
68
|
-
attr.encode(encoder, context:)
|
|
69
|
-
end
|
|
70
|
-
encoder.align_to(Raw::NLA_ALIGNTO)
|
|
71
|
-
end
|
|
72
|
-
|
|
73
|
-
def encode(encoder, external_selectors: [])
|
|
74
|
-
context = Selector::State.new(self.class::SELECTOR_NAMES.fetch(:local).length, external_selectors)
|
|
75
|
-
@attributes.each do |attr|
|
|
76
|
-
if slot = attr.class::SELECTOR_SLOT
|
|
77
|
-
context.set_local(slot, attr.value)
|
|
78
|
-
end
|
|
79
|
-
end
|
|
80
|
-
|
|
81
|
-
attributes = @attributes.sort_by { it.class::ORDER }
|
|
82
|
-
attributes.each do |attr|
|
|
83
|
-
encode1(encoder, attr, context)
|
|
84
|
-
end
|
|
85
|
-
rescue Selector::MissingSelectorValueError => error
|
|
86
|
-
raise ArgumentError, "selector #{selector_name(error).inspect} is required by a dependent attribute"
|
|
87
|
-
rescue Selector::UnknownSelectorValueError => error
|
|
88
|
-
raise ArgumentError, "unknown sub-message selector value: #{error.value.inspect}"
|
|
89
|
-
end
|
|
90
|
-
|
|
91
|
-
private def selector_name(error)
|
|
92
|
-
self.class::SELECTOR_NAMES.fetch(error.scope).fetch(error.index)
|
|
19
|
+
def encode(encoder, external_selectors: Selector::EMPTY_VALUES)
|
|
20
|
+
encode_attributes(encoder, external_selectors:)
|
|
93
21
|
end
|
|
94
22
|
|
|
95
23
|
class << self
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
if attr_class = self::BY_TYPE[nlattr.type & Raw::NLA_TYPE_MASK]
|
|
101
|
-
attr_class.decode(decoder, context:, nlattr_type_flags: flags)
|
|
102
|
-
else
|
|
103
|
-
decoder.skip
|
|
104
|
-
nil
|
|
105
|
-
end
|
|
106
|
-
end
|
|
107
|
-
decoder.align_to(Raw::NLA_ALIGNTO)
|
|
108
|
-
if attr && (slot = attr.class::SELECTOR_SLOT)
|
|
109
|
-
context.set_local(slot, attr.value)
|
|
110
|
-
end
|
|
111
|
-
attr
|
|
24
|
+
# Builds an attribute set from attribute names and values.
|
|
25
|
+
# @rbs (?Hash[Symbol, untyped] params) -> instance
|
|
26
|
+
def from_params(params = {})
|
|
27
|
+
build_instance(params)
|
|
112
28
|
end
|
|
113
29
|
|
|
114
|
-
def decode(decoder, external_selectors
|
|
115
|
-
|
|
116
|
-
attrs = []
|
|
117
|
-
while decoder.available?
|
|
118
|
-
attr = decode1(decoder, context)
|
|
119
|
-
attrs << attr
|
|
120
|
-
end
|
|
121
|
-
new(attrs.compact)
|
|
122
|
-
rescue Selector::MissingSelectorValueError => error
|
|
123
|
-
raise Decoder::Error,
|
|
124
|
-
"selector #{selector_name(error).inspect} must precede the dependent attribute"
|
|
125
|
-
rescue Selector::UnknownSelectorValueError => error
|
|
126
|
-
raise Decoder::Error, "unknown sub-message selector value: #{error.value.inspect}"
|
|
30
|
+
def decode(decoder, definitions, local_selector_count, external_selectors)
|
|
31
|
+
new(decode_attributes(decoder, definitions, local_selector_count, external_selectors:))
|
|
127
32
|
end
|
|
128
33
|
|
|
129
|
-
def
|
|
130
|
-
|
|
131
|
-
unknown = params.keys - self::BY_NAME.keys
|
|
132
|
-
raise ArgumentError, "unknown attributes: #{unknown.join(', ')}" unless unknown.empty?
|
|
133
|
-
|
|
134
|
-
context = Selector::State.new(self::SELECTOR_NAMES.fetch(:local).length, external_selectors)
|
|
135
|
-
coerced_selectors = {}
|
|
136
|
-
self::SELECTOR_NAMES.fetch(:local).each_with_index do |name, slot|
|
|
137
|
-
next unless params.key?(name)
|
|
138
|
-
attr_class = self::BY_NAME.fetch(name)
|
|
139
|
-
value = attr_class::DATATYPE.coerce(params.fetch(name))
|
|
140
|
-
coerced_selectors[name] = value
|
|
141
|
-
context.set_local(slot, value)
|
|
142
|
-
end
|
|
143
|
-
|
|
144
|
-
attrs = params.sort_by { |name, _| self::BY_NAME.fetch(name)::ORDER }.flat_map do |name, value|
|
|
145
|
-
attr_class = self::BY_NAME[name] or raise "Unknown attribute #{name}"
|
|
146
|
-
if attr_class.multi?
|
|
147
|
-
unless value.is_a?(Array)
|
|
148
|
-
raise TypeError, "value for multi-attribute #{name} must be an Array"
|
|
149
|
-
end
|
|
150
|
-
value.map { attr_class.new(coerce(attr_class::DATATYPE, it, context)) }
|
|
151
|
-
else
|
|
152
|
-
value = coerced_selectors.fetch(name) { coerce(attr_class::DATATYPE, value, context) }
|
|
153
|
-
attr_class.new(value)
|
|
154
|
-
end
|
|
155
|
-
end
|
|
156
|
-
new(attrs)
|
|
157
|
-
rescue Selector::MissingSelectorValueError => error
|
|
158
|
-
raise ArgumentError, "selector #{selector_name(error).inspect} is required by a dependent attribute"
|
|
159
|
-
rescue Selector::UnknownSelectorValueError => error
|
|
160
|
-
raise ArgumentError, "unknown sub-message selector value: #{error.value.inspect}"
|
|
161
|
-
end
|
|
162
|
-
|
|
163
|
-
private def coerce(datatype, value, context)
|
|
164
|
-
datatype.coerce(value, context:)
|
|
34
|
+
def build_instance(params, external_selectors: Selector::EMPTY_VALUES)
|
|
35
|
+
new(build_attributes(params, external_selectors:))
|
|
165
36
|
end
|
|
166
|
-
|
|
167
|
-
private def selector_name(error)
|
|
168
|
-
self::SELECTOR_NAMES.fetch(error.scope).fetch(error.index)
|
|
169
|
-
end
|
|
170
|
-
|
|
171
37
|
end
|
|
172
38
|
end
|
|
173
39
|
end
|
|
@@ -0,0 +1,193 @@
|
|
|
1
|
+
require_relative 'datatypes'
|
|
2
|
+
|
|
3
|
+
module Nl
|
|
4
|
+
# An opaque attribute payload with the flags needed to re-encode it.
|
|
5
|
+
class RawAttributeValue
|
|
6
|
+
attr_reader :payload, :nlattr_type_flags
|
|
7
|
+
|
|
8
|
+
def initialize(payload, nlattr_type_flags:)
|
|
9
|
+
@payload = payload
|
|
10
|
+
@nlattr_type_flags = nlattr_type_flags
|
|
11
|
+
end
|
|
12
|
+
|
|
13
|
+
def encode(encoder, external_selectors: Selector::EMPTY_VALUES)
|
|
14
|
+
encoder.put_string(payload)
|
|
15
|
+
end
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
# Ordered attribute operations shared by nested sets and generated payloads.
|
|
19
|
+
module Attributes
|
|
20
|
+
def self.included(base)
|
|
21
|
+
base.extend(ClassMethods)
|
|
22
|
+
end
|
|
23
|
+
|
|
24
|
+
def [](type)
|
|
25
|
+
definition = definition_for(type)
|
|
26
|
+
id = definition.id
|
|
27
|
+
values = [] if definition.multi
|
|
28
|
+
i = 0
|
|
29
|
+
while i < @attributes.length
|
|
30
|
+
if @attributes[i] == id
|
|
31
|
+
return @attributes[i + 1] unless values
|
|
32
|
+
values << @attributes[i + 1]
|
|
33
|
+
end
|
|
34
|
+
i += 2
|
|
35
|
+
end
|
|
36
|
+
values
|
|
37
|
+
end
|
|
38
|
+
|
|
39
|
+
def append_attribute(type, value)
|
|
40
|
+
@attributes.push(definition_for(type).id, value)
|
|
41
|
+
self
|
|
42
|
+
end
|
|
43
|
+
|
|
44
|
+
LOCAL_SELECTOR_NAMES = [].freeze
|
|
45
|
+
EXTERNAL_SELECTOR_NAMES = [].freeze
|
|
46
|
+
|
|
47
|
+
private def definition_for(type)
|
|
48
|
+
case type
|
|
49
|
+
when Symbol then self.class.by_name(type)
|
|
50
|
+
when Integer then self.class.by_type(type)
|
|
51
|
+
else raise TypeError, 'attribute type must be a Symbol or an Integer'
|
|
52
|
+
end
|
|
53
|
+
end
|
|
54
|
+
|
|
55
|
+
private def encode1(encoder, definition, value, context)
|
|
56
|
+
datatype = definition.datatype
|
|
57
|
+
flags = datatype.nlattr_type_flags(value, context:)
|
|
58
|
+
type = definition.id | flags
|
|
59
|
+
encoder.measure(Endian::Host::U16) do
|
|
60
|
+
encoder.put_value(Endian::Host::U16, 0) # nla_len
|
|
61
|
+
encoder.put_value(Endian::Host::U16, type) # nla_type
|
|
62
|
+
datatype.encode(encoder, value, context:)
|
|
63
|
+
end
|
|
64
|
+
encoder.align_to_4 # NLA_ALIGNTO
|
|
65
|
+
end
|
|
66
|
+
|
|
67
|
+
private def encode_attributes(encoder, external_selectors: Selector::EMPTY_VALUES)
|
|
68
|
+
definitions = self.class::BY_TYPE
|
|
69
|
+
local_selector_count = self.class::LOCAL_SELECTOR_NAMES.length
|
|
70
|
+
context = Selector::State.for(local_selector_count, external_selectors)
|
|
71
|
+
unless local_selector_count == 0
|
|
72
|
+
i = 0
|
|
73
|
+
while i < @attributes.length
|
|
74
|
+
if slot = definitions.fetch(@attributes[i]).selector_slot
|
|
75
|
+
context.set_local(slot, @attributes[i + 1])
|
|
76
|
+
end
|
|
77
|
+
i += 2
|
|
78
|
+
end
|
|
79
|
+
end
|
|
80
|
+
|
|
81
|
+
indices = (0...@attributes.length).step(2).sort_by { definitions.fetch(@attributes[it]).order }
|
|
82
|
+
indices.each do |i|
|
|
83
|
+
encode1(encoder, definitions.fetch(@attributes[i]), @attributes[i + 1], context)
|
|
84
|
+
end
|
|
85
|
+
rescue Selector::MissingSelectorValueError => error
|
|
86
|
+
raise ArgumentError, "selector #{selector_name(error).inspect} is required by a dependent attribute"
|
|
87
|
+
rescue Selector::UnknownSelectorValueError => error
|
|
88
|
+
raise ArgumentError, "unknown sub-message selector value: #{error.value.inspect}"
|
|
89
|
+
end
|
|
90
|
+
|
|
91
|
+
private def selector_name(error)
|
|
92
|
+
names = error.scope == :local ? self.class::LOCAL_SELECTOR_NAMES : self.class::EXTERNAL_SELECTOR_NAMES
|
|
93
|
+
names.fetch(error.index)
|
|
94
|
+
end
|
|
95
|
+
|
|
96
|
+
module ClassMethods
|
|
97
|
+
def by_name(name) = self::BY_NAME.fetch(name)
|
|
98
|
+
|
|
99
|
+
def by_type(type)
|
|
100
|
+
(type >= 0 && self::BY_TYPE[type]) || raise(KeyError, "unknown attribute type: #{type}")
|
|
101
|
+
end
|
|
102
|
+
|
|
103
|
+
private def decode1(decoder, context, attributes, definitions)
|
|
104
|
+
header = decoder.get_host_u32
|
|
105
|
+
if IO::Buffer::HOST_ENDIAN == IO::Buffer::LITTLE_ENDIAN
|
|
106
|
+
length = header & 0xffff
|
|
107
|
+
type = header >> 16
|
|
108
|
+
else
|
|
109
|
+
length = header >> 16
|
|
110
|
+
type = header & 0xffff
|
|
111
|
+
end
|
|
112
|
+
if length < Raw::NLA_HDRLEN
|
|
113
|
+
raise Decoder::Error,
|
|
114
|
+
"attribute length must be at least #{Raw::NLA_HDRLEN} bytes, got #{length}"
|
|
115
|
+
end
|
|
116
|
+
flags = type & (Raw::NLA_F_NESTED | Raw::NLA_F_NET_BYTEORDER)
|
|
117
|
+
id = type & Raw::NLA_TYPE_MASK
|
|
118
|
+
if definition = definitions[id]
|
|
119
|
+
value = decoder.limit(length - Raw::NLA_HDRLEN) do
|
|
120
|
+
definition.datatype.decode(decoder, context:, nlattr_type_flags: flags)
|
|
121
|
+
end
|
|
122
|
+
attributes.push(id, value)
|
|
123
|
+
if slot = definition.selector_slot
|
|
124
|
+
context.set_local(slot, value)
|
|
125
|
+
end
|
|
126
|
+
else
|
|
127
|
+
decoder.skip(length - Raw::NLA_HDRLEN)
|
|
128
|
+
end
|
|
129
|
+
decoder.align_to_4 # NLA_ALIGNTO
|
|
130
|
+
end
|
|
131
|
+
|
|
132
|
+
private def decode_attributes(decoder, definitions, local_selector_count, external_selectors: Selector::EMPTY_VALUES)
|
|
133
|
+
context = Selector::State.for(local_selector_count, external_selectors)
|
|
134
|
+
attributes = []
|
|
135
|
+
decode1(decoder, context, attributes, definitions) while decoder.available?
|
|
136
|
+
attributes
|
|
137
|
+
rescue Selector::MissingSelectorValueError => error
|
|
138
|
+
raise Decoder::Error,
|
|
139
|
+
"selector #{selector_name(error).inspect} must precede the dependent attribute"
|
|
140
|
+
rescue Selector::UnknownSelectorValueError => error
|
|
141
|
+
raise Decoder::Error, "unknown sub-message selector value: #{error.value.inspect}"
|
|
142
|
+
end
|
|
143
|
+
|
|
144
|
+
private def build_attributes(params, external_selectors: Selector::EMPTY_VALUES)
|
|
145
|
+
unknown = params.keys - self::BY_NAME.keys
|
|
146
|
+
raise ArgumentError, "unknown attributes: #{unknown.join(', ')}" unless unknown.empty?
|
|
147
|
+
|
|
148
|
+
context = Selector::State.for(
|
|
149
|
+
self::LOCAL_SELECTOR_NAMES.length,
|
|
150
|
+
external_selectors,
|
|
151
|
+
)
|
|
152
|
+
coerced_selectors = {}
|
|
153
|
+
self::LOCAL_SELECTOR_NAMES.each_with_index do |name, slot|
|
|
154
|
+
next unless params.key?(name)
|
|
155
|
+
definition = self::BY_NAME.fetch(name)
|
|
156
|
+
value = definition.datatype.coerce(params.fetch(name))
|
|
157
|
+
coerced_selectors[name] = value
|
|
158
|
+
context.set_local(slot, value)
|
|
159
|
+
end
|
|
160
|
+
|
|
161
|
+
attributes = []
|
|
162
|
+
params.sort_by { |name, _| self::BY_NAME.fetch(name).order }.each do |name, value|
|
|
163
|
+
definition = self::BY_NAME.fetch(name)
|
|
164
|
+
if definition.multi
|
|
165
|
+
unless value.is_a?(Array)
|
|
166
|
+
raise TypeError, "value for multi-attribute #{name} must be an Array"
|
|
167
|
+
end
|
|
168
|
+
value.each do |entry|
|
|
169
|
+
attributes.push(definition.id, coerce(definition.datatype, entry, context))
|
|
170
|
+
end
|
|
171
|
+
else
|
|
172
|
+
value = coerced_selectors.fetch(name) { coerce(definition.datatype, value, context) }
|
|
173
|
+
attributes.push(definition.id, value)
|
|
174
|
+
end
|
|
175
|
+
end
|
|
176
|
+
attributes
|
|
177
|
+
rescue Selector::MissingSelectorValueError => error
|
|
178
|
+
raise ArgumentError, "selector #{selector_name(error).inspect} is required by a dependent attribute"
|
|
179
|
+
rescue Selector::UnknownSelectorValueError => error
|
|
180
|
+
raise ArgumentError, "unknown sub-message selector value: #{error.value.inspect}"
|
|
181
|
+
end
|
|
182
|
+
|
|
183
|
+
private def coerce(datatype, value, context)
|
|
184
|
+
datatype.coerce(value, context:)
|
|
185
|
+
end
|
|
186
|
+
|
|
187
|
+
private def selector_name(error)
|
|
188
|
+
names = error.scope == :local ? self::LOCAL_SELECTOR_NAMES : self::EXTERNAL_SELECTOR_NAMES
|
|
189
|
+
names.fetch(error.index)
|
|
190
|
+
end
|
|
191
|
+
end
|
|
192
|
+
end
|
|
193
|
+
end
|
|
@@ -41,8 +41,8 @@ module Nl
|
|
|
41
41
|
result = [] unless block_given?
|
|
42
42
|
|
|
43
43
|
until exchange.complete?
|
|
44
|
-
receive(endpoint, key, reply_class) do |message|
|
|
45
|
-
case outcome = exchange.accept(message)
|
|
44
|
+
receive(endpoint, key, reply_class) do |header, message|
|
|
45
|
+
case outcome = exchange.accept(header, message)
|
|
46
46
|
when Exchange::Item
|
|
47
47
|
block_given? ? yield(outcome.value) : result << outcome.value
|
|
48
48
|
when Exchange::Failure
|
|
@@ -99,8 +99,8 @@ module Nl
|
|
|
99
99
|
Datagram.each_frame(receive_datagram) do |header, payload|
|
|
100
100
|
actual_key = [header.seq, header.pid]
|
|
101
101
|
if actual_key == expected_key
|
|
102
|
-
yield @protocol.decode_frame(endpoint, header, payload, reply_class)
|
|
103
|
-
elsif header.seq
|
|
102
|
+
yield header, @protocol.decode_frame(endpoint, header, payload, reply_class)
|
|
103
|
+
elsif header.seq == 0
|
|
104
104
|
@notifications.route(header, payload)
|
|
105
105
|
else
|
|
106
106
|
raise UnexpectedSequenceError.new(expected_key, actual_key)
|
|
@@ -113,7 +113,7 @@ module Nl
|
|
|
113
113
|
|
|
114
114
|
private def receive_notifications
|
|
115
115
|
Datagram.each_frame(receive_datagram) do |header, payload|
|
|
116
|
-
if header.seq
|
|
116
|
+
if header.seq == 0
|
|
117
117
|
@notifications.route(header, payload)
|
|
118
118
|
else
|
|
119
119
|
raise UnexpectedSequenceError.new(nil, [header.seq, header.pid])
|
data/lib/nl/datagram.rb
CHANGED
|
@@ -4,8 +4,8 @@ require_relative 'decoder'
|
|
|
4
4
|
module Nl
|
|
5
5
|
# Splits Netlink datagrams into aligned header/payload frames.
|
|
6
6
|
module Datagram
|
|
7
|
-
# @rbs (IO::Buffer buffer) { (Raw::NlMsgHdr,
|
|
8
|
-
# | (IO::Buffer buffer) -> Enumerator[[Raw::NlMsgHdr,
|
|
7
|
+
# @rbs (IO::Buffer buffer) { (Raw::NlMsgHdr, Decoder) -> void } -> nil
|
|
8
|
+
# | (IO::Buffer buffer) -> Enumerator[[Raw::NlMsgHdr, Decoder], nil]
|
|
9
9
|
def self.each_frame(buffer)
|
|
10
10
|
return enum_for(__method__, buffer) unless block_given?
|
|
11
11
|
|
|
@@ -13,8 +13,8 @@ module Nl
|
|
|
13
13
|
while decoder.available?(Raw::NLMSG_HDRLEN)
|
|
14
14
|
header = Raw::NlMsgHdr.decode(decoder)
|
|
15
15
|
payload_size = header.len - Raw::NLMSG_HDRLEN
|
|
16
|
-
payload = decoder.
|
|
17
|
-
decoder.
|
|
16
|
+
payload = decoder.slice(payload_size)
|
|
17
|
+
decoder.align_to_4 # NLMSG_ALIGNTO
|
|
18
18
|
yield header, payload
|
|
19
19
|
end
|
|
20
20
|
end
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
require_relative '../decoder'
|
|
2
|
+
require_relative '../encoder'
|
|
3
|
+
|
|
4
|
+
module Nl
|
|
5
|
+
module DataTypes
|
|
6
|
+
# Validation applies to the decoded value, or the value being encoded.
|
|
7
|
+
class Checked
|
|
8
|
+
def initialize(datatype, check:)
|
|
9
|
+
@datatype = datatype
|
|
10
|
+
@check = check
|
|
11
|
+
end
|
|
12
|
+
|
|
13
|
+
def nlattr_type_flags(value = nil, context: nil)
|
|
14
|
+
@datatype.nlattr_type_flags(value, context:)
|
|
15
|
+
end
|
|
16
|
+
|
|
17
|
+
def coerce(value, context: nil)
|
|
18
|
+
@datatype.coerce(value, context:)
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
def encode(encoder, value, context: nil)
|
|
22
|
+
@check.call(value)
|
|
23
|
+
@datatype.encode(encoder, value, context:)
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
def decode(decoder, context: nil, nlattr_type_flags: 0)
|
|
27
|
+
value = @datatype.decode(decoder, context:, nlattr_type_flags:)
|
|
28
|
+
@check.call(value)
|
|
29
|
+
value
|
|
30
|
+
end
|
|
31
|
+
end
|
|
32
|
+
|
|
33
|
+
# Structured binary and packed arrays validate their encoded bytes.
|
|
34
|
+
class CheckedPayload
|
|
35
|
+
def initialize(datatype, check:)
|
|
36
|
+
@datatype = datatype
|
|
37
|
+
@check = check
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
def nlattr_type_flags(value = nil, context: nil)
|
|
41
|
+
@datatype.nlattr_type_flags(value, context:)
|
|
42
|
+
end
|
|
43
|
+
|
|
44
|
+
def coerce(value, context: nil)
|
|
45
|
+
@datatype.coerce(value, context:)
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
def encode(encoder, value, context: nil)
|
|
49
|
+
temporary = Encoder.new
|
|
50
|
+
@datatype.encode(temporary, value, context:)
|
|
51
|
+
payload = temporary.buffer.get_string
|
|
52
|
+
@check.call(payload)
|
|
53
|
+
encoder.put_string(payload)
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
def decode(decoder, context: nil, nlattr_type_flags: 0)
|
|
57
|
+
payload = decoder.get_string
|
|
58
|
+
@check.call(payload)
|
|
59
|
+
nested = Decoder.new(IO::Buffer.for(payload))
|
|
60
|
+
nested.limit(payload.bytesize) do
|
|
61
|
+
@datatype.decode(nested, context:, nlattr_type_flags:)
|
|
62
|
+
end
|
|
63
|
+
end
|
|
64
|
+
end
|
|
65
|
+
end
|
|
66
|
+
end
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
require_relative 'defaults'
|
|
2
|
+
require_relative '../decoder'
|
|
3
|
+
|
|
4
|
+
module Nl
|
|
5
|
+
module DataTypes
|
|
6
|
+
module Scalar
|
|
7
|
+
def self.[](type)
|
|
8
|
+
SPECIALIZATIONS.fetch(type)
|
|
9
|
+
end
|
|
10
|
+
|
|
11
|
+
SPECIALIZATIONS = Decoder::VALUE_READERS.to_h do |type, reader|
|
|
12
|
+
specialization = Class.new { include Defaults }
|
|
13
|
+
const_set("Type_#{type}", specialization)
|
|
14
|
+
specialization.class_eval <<~RUBY, __FILE__, __LINE__ + 1
|
|
15
|
+
def encode(encoder, value, context: nil)
|
|
16
|
+
encoder.put_value(#{type.inspect}, value)
|
|
17
|
+
end
|
|
18
|
+
|
|
19
|
+
def decode(decoder, context: nil, nlattr_type_flags: 0)
|
|
20
|
+
decoder.#{reader}
|
|
21
|
+
end
|
|
22
|
+
RUBY
|
|
23
|
+
[type, specialization]
|
|
24
|
+
end.freeze
|
|
25
|
+
private_constant :SPECIALIZATIONS
|
|
26
|
+
end
|
|
27
|
+
end
|
|
28
|
+
end
|