Branch data Line data Source code
1 : : #ifndef __NET_NETLINK_H
2 : : #define __NET_NETLINK_H
3 : :
4 : : #include <linux/types.h>
5 : : #include <linux/netlink.h>
6 : : #include <linux/jiffies.h>
7 : :
8 : : /* ========================================================================
9 : : * Netlink Messages and Attributes Interface (As Seen On TV)
10 : : * ------------------------------------------------------------------------
11 : : * Messages Interface
12 : : * ------------------------------------------------------------------------
13 : : *
14 : : * Message Format:
15 : : * <--- nlmsg_total_size(payload) --->
16 : : * <-- nlmsg_msg_size(payload) ->
17 : : * +----------+- - -+-------------+- - -+-------- - -
18 : : * | nlmsghdr | Pad | Payload | Pad | nlmsghdr
19 : : * +----------+- - -+-------------+- - -+-------- - -
20 : : * nlmsg_data(nlh)---^ ^
21 : : * nlmsg_next(nlh)-----------------------+
22 : : *
23 : : * Payload Format:
24 : : * <---------------------- nlmsg_len(nlh) --------------------->
25 : : * <------ hdrlen ------> <- nlmsg_attrlen(nlh, hdrlen) ->
26 : : * +----------------------+- - -+--------------------------------+
27 : : * | Family Header | Pad | Attributes |
28 : : * +----------------------+- - -+--------------------------------+
29 : : * nlmsg_attrdata(nlh, hdrlen)---^
30 : : *
31 : : * Data Structures:
32 : : * struct nlmsghdr netlink message header
33 : : *
34 : : * Message Construction:
35 : : * nlmsg_new() create a new netlink message
36 : : * nlmsg_put() add a netlink message to an skb
37 : : * nlmsg_put_answer() callback based nlmsg_put()
38 : : * nlmsg_end() finalize netlink message
39 : : * nlmsg_get_pos() return current position in message
40 : : * nlmsg_trim() trim part of message
41 : : * nlmsg_cancel() cancel message construction
42 : : * nlmsg_free() free a netlink message
43 : : *
44 : : * Message Sending:
45 : : * nlmsg_multicast() multicast message to several groups
46 : : * nlmsg_unicast() unicast a message to a single socket
47 : : * nlmsg_notify() send notification message
48 : : *
49 : : * Message Length Calculations:
50 : : * nlmsg_msg_size(payload) length of message w/o padding
51 : : * nlmsg_total_size(payload) length of message w/ padding
52 : : * nlmsg_padlen(payload) length of padding at tail
53 : : *
54 : : * Message Payload Access:
55 : : * nlmsg_data(nlh) head of message payload
56 : : * nlmsg_len(nlh) length of message payload
57 : : * nlmsg_attrdata(nlh, hdrlen) head of attributes data
58 : : * nlmsg_attrlen(nlh, hdrlen) length of attributes data
59 : : *
60 : : * Message Parsing:
61 : : * nlmsg_ok(nlh, remaining) does nlh fit into remaining bytes?
62 : : * nlmsg_next(nlh, remaining) get next netlink message
63 : : * nlmsg_parse() parse attributes of a message
64 : : * nlmsg_find_attr() find an attribute in a message
65 : : * nlmsg_for_each_msg() loop over all messages
66 : : * nlmsg_validate() validate netlink message incl. attrs
67 : : * nlmsg_for_each_attr() loop over all attributes
68 : : *
69 : : * Misc:
70 : : * nlmsg_report() report back to application?
71 : : *
72 : : * ------------------------------------------------------------------------
73 : : * Attributes Interface
74 : : * ------------------------------------------------------------------------
75 : : *
76 : : * Attribute Format:
77 : : * <------- nla_total_size(payload) ------->
78 : : * <---- nla_attr_size(payload) ----->
79 : : * +----------+- - -+- - - - - - - - - +- - -+-------- - -
80 : : * | Header | Pad | Payload | Pad | Header
81 : : * +----------+- - -+- - - - - - - - - +- - -+-------- - -
82 : : * <- nla_len(nla) -> ^
83 : : * nla_data(nla)----^ |
84 : : * nla_next(nla)-----------------------------'
85 : : *
86 : : * Data Structures:
87 : : * struct nlattr netlink attribute header
88 : : *
89 : : * Attribute Construction:
90 : : * nla_reserve(skb, type, len) reserve room for an attribute
91 : : * nla_reserve_nohdr(skb, len) reserve room for an attribute w/o hdr
92 : : * nla_put(skb, type, len, data) add attribute to skb
93 : : * nla_put_nohdr(skb, len, data) add attribute w/o hdr
94 : : * nla_append(skb, len, data) append data to skb
95 : : *
96 : : * Attribute Construction for Basic Types:
97 : : * nla_put_u8(skb, type, value) add u8 attribute to skb
98 : : * nla_put_u16(skb, type, value) add u16 attribute to skb
99 : : * nla_put_u32(skb, type, value) add u32 attribute to skb
100 : : * nla_put_u64(skb, type, value) add u64 attribute to skb
101 : : * nla_put_s8(skb, type, value) add s8 attribute to skb
102 : : * nla_put_s16(skb, type, value) add s16 attribute to skb
103 : : * nla_put_s32(skb, type, value) add s32 attribute to skb
104 : : * nla_put_s64(skb, type, value) add s64 attribute to skb
105 : : * nla_put_string(skb, type, str) add string attribute to skb
106 : : * nla_put_flag(skb, type) add flag attribute to skb
107 : : * nla_put_msecs(skb, type, jiffies) add msecs attribute to skb
108 : : *
109 : : * Nested Attributes Construction:
110 : : * nla_nest_start(skb, type) start a nested attribute
111 : : * nla_nest_end(skb, nla) finalize a nested attribute
112 : : * nla_nest_cancel(skb, nla) cancel nested attribute construction
113 : : *
114 : : * Attribute Length Calculations:
115 : : * nla_attr_size(payload) length of attribute w/o padding
116 : : * nla_total_size(payload) length of attribute w/ padding
117 : : * nla_padlen(payload) length of padding
118 : : *
119 : : * Attribute Payload Access:
120 : : * nla_data(nla) head of attribute payload
121 : : * nla_len(nla) length of attribute payload
122 : : *
123 : : * Attribute Payload Access for Basic Types:
124 : : * nla_get_u8(nla) get payload for a u8 attribute
125 : : * nla_get_u16(nla) get payload for a u16 attribute
126 : : * nla_get_u32(nla) get payload for a u32 attribute
127 : : * nla_get_u64(nla) get payload for a u64 attribute
128 : : * nla_get_s8(nla) get payload for a s8 attribute
129 : : * nla_get_s16(nla) get payload for a s16 attribute
130 : : * nla_get_s32(nla) get payload for a s32 attribute
131 : : * nla_get_s64(nla) get payload for a s64 attribute
132 : : * nla_get_flag(nla) return 1 if flag is true
133 : : * nla_get_msecs(nla) get payload for a msecs attribute
134 : : *
135 : : * Attribute Misc:
136 : : * nla_memcpy(dest, nla, count) copy attribute into memory
137 : : * nla_memcmp(nla, data, size) compare attribute with memory area
138 : : * nla_strlcpy(dst, nla, size) copy attribute to a sized string
139 : : * nla_strcmp(nla, str) compare attribute with string
140 : : *
141 : : * Attribute Parsing:
142 : : * nla_ok(nla, remaining) does nla fit into remaining bytes?
143 : : * nla_next(nla, remaining) get next netlink attribute
144 : : * nla_validate() validate a stream of attributes
145 : : * nla_validate_nested() validate a stream of nested attributes
146 : : * nla_find() find attribute in stream of attributes
147 : : * nla_find_nested() find attribute in nested attributes
148 : : * nla_parse() parse and validate stream of attrs
149 : : * nla_parse_nested() parse nested attribuets
150 : : * nla_for_each_attr() loop over all attributes
151 : : * nla_for_each_nested() loop over the nested attributes
152 : : *=========================================================================
153 : : */
154 : :
155 : : /**
156 : : * Standard attribute types to specify validation policy
157 : : */
158 : : enum {
159 : : NLA_UNSPEC,
160 : : NLA_U8,
161 : : NLA_U16,
162 : : NLA_U32,
163 : : NLA_U64,
164 : : NLA_STRING,
165 : : NLA_FLAG,
166 : : NLA_MSECS,
167 : : NLA_NESTED,
168 : : NLA_NESTED_COMPAT,
169 : : NLA_NUL_STRING,
170 : : NLA_BINARY,
171 : : NLA_S8,
172 : : NLA_S16,
173 : : NLA_S32,
174 : : NLA_S64,
175 : : __NLA_TYPE_MAX,
176 : : };
177 : :
178 : : #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
179 : :
180 : : /**
181 : : * struct nla_policy - attribute validation policy
182 : : * @type: Type of attribute or NLA_UNSPEC
183 : : * @len: Type specific length of payload
184 : : *
185 : : * Policies are defined as arrays of this struct, the array must be
186 : : * accessible by attribute type up to the highest identifier to be expected.
187 : : *
188 : : * Meaning of `len' field:
189 : : * NLA_STRING Maximum length of string
190 : : * NLA_NUL_STRING Maximum length of string (excluding NUL)
191 : : * NLA_FLAG Unused
192 : : * NLA_BINARY Maximum length of attribute payload
193 : : * NLA_NESTED Don't use `len' field -- length verification is
194 : : * done by checking len of nested header (or empty)
195 : : * NLA_NESTED_COMPAT Minimum length of structure payload
196 : : * NLA_U8, NLA_U16,
197 : : * NLA_U32, NLA_U64,
198 : : * NLA_S8, NLA_S16,
199 : : * NLA_S32, NLA_S64,
200 : : * NLA_MSECS Leaving the length field zero will verify the
201 : : * given type fits, using it verifies minimum length
202 : : * just like "All other"
203 : : * All other Minimum length of attribute payload
204 : : *
205 : : * Example:
206 : : * static const struct nla_policy my_policy[ATTR_MAX+1] = {
207 : : * [ATTR_FOO] = { .type = NLA_U16 },
208 : : * [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
209 : : * [ATTR_BAZ] = { .len = sizeof(struct mystruct) },
210 : : * };
211 : : */
212 : : struct nla_policy {
213 : : u16 type;
214 : : u16 len;
215 : : };
216 : :
217 : : /**
218 : : * struct nl_info - netlink source information
219 : : * @nlh: Netlink message header of original request
220 : : * @portid: Netlink PORTID of requesting application
221 : : */
222 : : struct nl_info {
223 : : struct nlmsghdr *nlh;
224 : : struct net *nl_net;
225 : : u32 portid;
226 : : };
227 : :
228 : : int netlink_rcv_skb(struct sk_buff *skb,
229 : : int (*cb)(struct sk_buff *, struct nlmsghdr *));
230 : : int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
231 : : unsigned int group, int report, gfp_t flags);
232 : :
233 : : int nla_validate(const struct nlattr *head, int len, int maxtype,
234 : : const struct nla_policy *policy);
235 : : int nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
236 : : int len, const struct nla_policy *policy);
237 : : int nla_policy_len(const struct nla_policy *, int);
238 : : struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
239 : : size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
240 : : int nla_memcpy(void *dest, const struct nlattr *src, int count);
241 : : int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
242 : : int nla_strcmp(const struct nlattr *nla, const char *str);
243 : : struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
244 : : void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
245 : : struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
246 : : void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
247 : : void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
248 : : const void *data);
249 : : void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
250 : : int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
251 : : int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
252 : : int nla_append(struct sk_buff *skb, int attrlen, const void *data);
253 : :
254 : : /**************************************************************************
255 : : * Netlink Messages
256 : : **************************************************************************/
257 : :
258 : : /**
259 : : * nlmsg_msg_size - length of netlink message not including padding
260 : : * @payload: length of message payload
261 : : */
262 : : static inline int nlmsg_msg_size(int payload)
263 : : {
264 : 47 : return NLMSG_HDRLEN + payload;
265 : : }
266 : :
267 : : /**
268 : : * nlmsg_total_size - length of netlink message including padding
269 : : * @payload: length of message payload
270 : : */
271 : : static inline int nlmsg_total_size(int payload)
272 : : {
273 : 47 : return NLMSG_ALIGN(nlmsg_msg_size(payload));
274 : : }
275 : :
276 : : /**
277 : : * nlmsg_padlen - length of padding at the message's tail
278 : : * @payload: length of message payload
279 : : */
280 : : static inline int nlmsg_padlen(int payload)
281 : : {
282 : : return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
283 : : }
284 : :
285 : : /**
286 : : * nlmsg_data - head of message payload
287 : : * @nlh: netlink message header
288 : : */
289 : : static inline void *nlmsg_data(const struct nlmsghdr *nlh)
290 : : {
291 : : return (unsigned char *) nlh + NLMSG_HDRLEN;
292 : : }
293 : :
294 : : /**
295 : : * nlmsg_len - length of message payload
296 : : * @nlh: netlink message header
297 : : */
298 : : static inline int nlmsg_len(const struct nlmsghdr *nlh)
299 : : {
300 : 10 : return nlh->nlmsg_len - NLMSG_HDRLEN;
301 : : }
302 : :
303 : : /**
304 : : * nlmsg_attrdata - head of attributes data
305 : : * @nlh: netlink message header
306 : : * @hdrlen: length of family specific header
307 : : */
308 : : static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
309 : : int hdrlen)
310 : : {
311 : : unsigned char *data = nlmsg_data(nlh);
312 : : return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
313 : : }
314 : :
315 : : /**
316 : : * nlmsg_attrlen - length of attributes data
317 : : * @nlh: netlink message header
318 : : * @hdrlen: length of family specific header
319 : : */
320 : : static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
321 : : {
322 : : return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
323 : : }
324 : :
325 : : /**
326 : : * nlmsg_ok - check if the netlink message fits into the remaining bytes
327 : : * @nlh: netlink message header
328 : : * @remaining: number of bytes remaining in message stream
329 : : */
330 : : static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
331 : : {
332 [ + - ]: 2464 : return (remaining >= (int) sizeof(struct nlmsghdr) &&
333 [ + + ][ - + ]: 7392 : nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
334 : 2464 : nlh->nlmsg_len <= remaining);
335 : : }
336 : :
337 : : /**
338 : : * nlmsg_next - next netlink message in message stream
339 : : * @nlh: netlink message header
340 : : * @remaining: number of bytes remaining in message stream
341 : : *
342 : : * Returns the next netlink message in the message stream and
343 : : * decrements remaining by the size of the current message.
344 : : */
345 : : static inline struct nlmsghdr *
346 : : nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
347 : : {
348 : 2464 : int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
349 : :
350 : 2464 : *remaining -= totlen;
351 : :
352 : 2464 : return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
353 : : }
354 : :
355 : : /**
356 : : * nlmsg_parse - parse attributes of a netlink message
357 : : * @nlh: netlink message header
358 : : * @hdrlen: length of family specific header
359 : : * @tb: destination array with maxtype+1 elements
360 : : * @maxtype: maximum attribute type to be expected
361 : : * @policy: validation policy
362 : : *
363 : : * See nla_parse()
364 : : */
365 : : static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
366 : : struct nlattr *tb[], int maxtype,
367 : : const struct nla_policy *policy)
368 : : {
369 : : if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
370 : : return -EINVAL;
371 : :
372 : : return nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
373 : : nlmsg_attrlen(nlh, hdrlen), policy);
374 : : }
375 : :
376 : : /**
377 : : * nlmsg_find_attr - find a specific attribute in a netlink message
378 : : * @nlh: netlink message header
379 : : * @hdrlen: length of familiy specific header
380 : : * @attrtype: type of attribute to look for
381 : : *
382 : : * Returns the first attribute which matches the specified type.
383 : : */
384 : : static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
385 : : int hdrlen, int attrtype)
386 : : {
387 : : return nla_find(nlmsg_attrdata(nlh, hdrlen),
388 : : nlmsg_attrlen(nlh, hdrlen), attrtype);
389 : : }
390 : :
391 : : /**
392 : : * nlmsg_validate - validate a netlink message including attributes
393 : : * @nlh: netlinket message header
394 : : * @hdrlen: length of familiy specific header
395 : : * @maxtype: maximum attribute type to be expected
396 : : * @policy: validation policy
397 : : */
398 : : static inline int nlmsg_validate(const struct nlmsghdr *nlh,
399 : : int hdrlen, int maxtype,
400 : : const struct nla_policy *policy)
401 : : {
402 : : if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
403 : : return -EINVAL;
404 : :
405 : : return nla_validate(nlmsg_attrdata(nlh, hdrlen),
406 : : nlmsg_attrlen(nlh, hdrlen), maxtype, policy);
407 : : }
408 : :
409 : : /**
410 : : * nlmsg_report - need to report back to application?
411 : : * @nlh: netlink message header
412 : : *
413 : : * Returns 1 if a report back to the application is requested.
414 : : */
415 : : static inline int nlmsg_report(const struct nlmsghdr *nlh)
416 : : {
417 : : return !!(nlh->nlmsg_flags & NLM_F_ECHO);
418 : : }
419 : :
420 : : /**
421 : : * nlmsg_for_each_attr - iterate over a stream of attributes
422 : : * @pos: loop counter, set to current attribute
423 : : * @nlh: netlink message header
424 : : * @hdrlen: length of familiy specific header
425 : : * @rem: initialized to len, holds bytes currently remaining in stream
426 : : */
427 : : #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
428 : : nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
429 : : nlmsg_attrlen(nlh, hdrlen), rem)
430 : :
431 : : /**
432 : : * nlmsg_put - Add a new netlink message to an skb
433 : : * @skb: socket buffer to store message in
434 : : * @portid: netlink process id
435 : : * @seq: sequence number of message
436 : : * @type: message type
437 : : * @payload: length of message payload
438 : : * @flags: message flags
439 : : *
440 : : * Returns NULL if the tailroom of the skb is insufficient to store
441 : : * the message header and payload.
442 : : */
443 : : static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
444 : : int type, int payload, int flags)
445 : : {
446 [ + ][ # # ]: 485 : if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
[ # ]
447 : : return NULL;
448 : :
449 : 485 : return __nlmsg_put(skb, portid, seq, type, payload, flags);
450 : : }
451 : :
452 : : /**
453 : : * nlmsg_put_answer - Add a new callback based netlink message to an skb
454 : : * @skb: socket buffer to store message in
455 : : * @cb: netlink callback
456 : : * @type: message type
457 : : * @payload: length of message payload
458 : : * @flags: message flags
459 : : *
460 : : * Returns NULL if the tailroom of the skb is insufficient to store
461 : : * the message header and payload.
462 : : */
463 : : static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
464 : : struct netlink_callback *cb,
465 : : int type, int payload,
466 : : int flags)
467 : : {
468 : : return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
469 : : type, payload, flags);
470 : : }
471 : :
472 : : /**
473 : : * nlmsg_new - Allocate a new netlink message
474 : : * @payload: size of the message payload
475 : : * @flags: the type of memory to allocate.
476 : : *
477 : : * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
478 : : * and a good default is needed.
479 : : */
480 : : static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
481 : : {
482 : 94 : return alloc_skb(nlmsg_total_size(payload), flags);
483 : : }
484 : :
485 : : /**
486 : : * nlmsg_end - Finalize a netlink message
487 : : * @skb: socket buffer the message is stored in
488 : : * @nlh: netlink message header
489 : : *
490 : : * Corrects the netlink message header to include the appeneded
491 : : * attributes. Only necessary if attributes have been added to
492 : : * the message.
493 : : *
494 : : * Returns the total data length of the skb.
495 : : */
496 : : static inline int nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
497 : : {
498 : : nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
499 : :
500 : : return skb->len;
501 : : }
502 : :
503 : : /**
504 : : * nlmsg_get_pos - return current position in netlink message
505 : : * @skb: socket buffer the message is stored in
506 : : *
507 : : * Returns a pointer to the current tail of the message.
508 : : */
509 : : static inline void *nlmsg_get_pos(struct sk_buff *skb)
510 : : {
511 : : return skb_tail_pointer(skb);
512 : : }
513 : :
514 : : /**
515 : : * nlmsg_trim - Trim message to a mark
516 : : * @skb: socket buffer the message is stored in
517 : : * @mark: mark to trim to
518 : : *
519 : : * Trims the message to the provided mark.
520 : : */
521 : : static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
522 : : {
523 : : if (mark)
524 : : skb_trim(skb, (unsigned char *) mark - skb->data);
525 : : }
526 : :
527 : : /**
528 : : * nlmsg_cancel - Cancel construction of a netlink message
529 : : * @skb: socket buffer the message is stored in
530 : : * @nlh: netlink message header
531 : : *
532 : : * Removes the complete netlink message including all
533 : : * attributes from the socket buffer again.
534 : : */
535 : : static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
536 : : {
537 : : nlmsg_trim(skb, nlh);
538 : : }
539 : :
540 : : /**
541 : : * nlmsg_free - free a netlink message
542 : : * @skb: socket buffer of netlink message
543 : : */
544 : : static inline void nlmsg_free(struct sk_buff *skb)
545 : : {
546 : : kfree_skb(skb);
547 : : }
548 : :
549 : : /**
550 : : * nlmsg_multicast - multicast a netlink message
551 : : * @sk: netlink socket to spread messages to
552 : : * @skb: netlink message as socket buffer
553 : : * @portid: own netlink portid to avoid sending to yourself
554 : : * @group: multicast group id
555 : : * @flags: allocation flags
556 : : */
557 : : static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
558 : : u32 portid, unsigned int group, gfp_t flags)
559 : : {
560 : : int err;
561 : :
562 : : NETLINK_CB(skb).dst_group = group;
563 : :
564 : : err = netlink_broadcast(sk, skb, portid, group, flags);
565 : : if (err > 0)
566 : : err = 0;
567 : :
568 : : return err;
569 : : }
570 : :
571 : : /**
572 : : * nlmsg_unicast - unicast a netlink message
573 : : * @sk: netlink socket to spread message to
574 : : * @skb: netlink message as socket buffer
575 : : * @portid: netlink portid of the destination socket
576 : : */
577 : : static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
578 : : {
579 : : int err;
580 : :
581 : : err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
582 : : if (err > 0)
583 : : err = 0;
584 : :
585 : : return err;
586 : : }
587 : :
588 : : /**
589 : : * nlmsg_for_each_msg - iterate over a stream of messages
590 : : * @pos: loop counter, set to current message
591 : : * @head: head of message stream
592 : : * @len: length of message stream
593 : : * @rem: initialized to len, holds bytes currently remaining in stream
594 : : */
595 : : #define nlmsg_for_each_msg(pos, head, len, rem) \
596 : : for (pos = head, rem = len; \
597 : : nlmsg_ok(pos, rem); \
598 : : pos = nlmsg_next(pos, &(rem)))
599 : :
600 : : /**
601 : : * nl_dump_check_consistent - check if sequence is consistent and advertise if not
602 : : * @cb: netlink callback structure that stores the sequence number
603 : : * @nlh: netlink message header to write the flag to
604 : : *
605 : : * This function checks if the sequence (generation) number changed during dump
606 : : * and if it did, advertises it in the netlink message header.
607 : : *
608 : : * The correct way to use it is to set cb->seq to the generation counter when
609 : : * all locks for dumping have been acquired, and then call this function for
610 : : * each message that is generated.
611 : : *
612 : : * Note that due to initialisation concerns, 0 is an invalid sequence number
613 : : * and must not be used by code that uses this functionality.
614 : : */
615 : : static inline void
616 : : nl_dump_check_consistent(struct netlink_callback *cb,
617 : : struct nlmsghdr *nlh)
618 : : {
619 : : if (cb->prev_seq && cb->seq != cb->prev_seq)
620 : : nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
621 : : cb->prev_seq = cb->seq;
622 : : }
623 : :
624 : : /**************************************************************************
625 : : * Netlink Attributes
626 : : **************************************************************************/
627 : :
628 : : /**
629 : : * nla_attr_size - length of attribute not including padding
630 : : * @payload: length of payload
631 : : */
632 : : static inline int nla_attr_size(int payload)
633 : : {
634 : 57526 : return NLA_HDRLEN + payload;
635 : : }
636 : :
637 : : /**
638 : : * nla_total_size - total length of attribute including padding
639 : : * @payload: length of payload
640 : : */
641 : : static inline int nla_total_size(int payload)
642 : : {
643 : 115052 : return NLA_ALIGN(nla_attr_size(payload));
644 : : }
645 : :
646 : : /**
647 : : * nla_padlen - length of padding at the tail of attribute
648 : : * @payload: length of payload
649 : : */
650 : : static inline int nla_padlen(int payload)
651 : : {
652 : 57526 : return nla_total_size(payload) - nla_attr_size(payload);
653 : : }
654 : :
655 : : /**
656 : : * nla_type - attribute type
657 : : * @nla: netlink attribute
658 : : */
659 : : static inline int nla_type(const struct nlattr *nla)
660 : : {
661 : 2 : return nla->nla_type & NLA_TYPE_MASK;
662 : : }
663 : :
664 : : /**
665 : : * nla_data - head of payload
666 : : * @nla: netlink attribute
667 : : */
668 : : static inline void *nla_data(const struct nlattr *nla)
669 : : {
670 : : return (char *) nla + NLA_HDRLEN;
671 : : }
672 : :
673 : : /**
674 : : * nla_len - length of payload
675 : : * @nla: netlink attribute
676 : : */
677 : : static inline int nla_len(const struct nlattr *nla)
678 : : {
679 : 1 : return nla->nla_len - NLA_HDRLEN;
680 : : }
681 : :
682 : : /**
683 : : * nla_ok - check if the netlink attribute fits into the remaining bytes
684 : : * @nla: netlink attribute
685 : : * @remaining: number of bytes remaining in attribute stream
686 : : */
687 : : static inline int nla_ok(const struct nlattr *nla, int remaining)
688 : : {
689 [ # # ][ + - ]: 1 : return remaining >= (int) sizeof(*nla) &&
[ # # ]
690 [ # # ][ # # ]: 5 : nla->nla_len >= sizeof(*nla) &&
[ + + ][ - + ]
[ # # ][ # # ]
691 : 1 : nla->nla_len <= remaining;
692 : : }
693 : :
694 : : /**
695 : : * nla_next - next netlink attribute in attribute stream
696 : : * @nla: netlink attribute
697 : : * @remaining: number of bytes remaining in attribute stream
698 : : *
699 : : * Returns the next netlink attribute in the attribute stream and
700 : : * decrements remaining by the size of the current attribute.
701 : : */
702 : : static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
703 : : {
704 : 1 : int totlen = NLA_ALIGN(nla->nla_len);
705 : :
706 : 1 : *remaining -= totlen;
707 : 1 : return (struct nlattr *) ((char *) nla + totlen);
708 : : }
709 : :
710 : : /**
711 : : * nla_find_nested - find attribute in a set of nested attributes
712 : : * @nla: attribute containing the nested attributes
713 : : * @attrtype: type of attribute to look for
714 : : *
715 : : * Returns the first attribute which matches the specified type.
716 : : */
717 : : static inline struct nlattr *
718 : : nla_find_nested(const struct nlattr *nla, int attrtype)
719 : : {
720 : : return nla_find(nla_data(nla), nla_len(nla), attrtype);
721 : : }
722 : :
723 : : /**
724 : : * nla_parse_nested - parse nested attributes
725 : : * @tb: destination array with maxtype+1 elements
726 : : * @maxtype: maximum attribute type to be expected
727 : : * @nla: attribute containing the nested attributes
728 : : * @policy: validation policy
729 : : *
730 : : * See nla_parse()
731 : : */
732 : : static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
733 : : const struct nlattr *nla,
734 : : const struct nla_policy *policy)
735 : : {
736 : : return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
737 : : }
738 : :
739 : : /**
740 : : * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
741 : : * @skb: socket buffer to add attribute to
742 : : * @attrtype: attribute type
743 : : * @value: numeric value
744 : : */
745 : : static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
746 : : {
747 : : return nla_put(skb, attrtype, sizeof(u8), &value);
748 : : }
749 : :
750 : : /**
751 : : * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
752 : : * @skb: socket buffer to add attribute to
753 : : * @attrtype: attribute type
754 : : * @value: numeric value
755 : : */
756 : : static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
757 : : {
758 : : return nla_put(skb, attrtype, sizeof(u16), &value);
759 : : }
760 : :
761 : : /**
762 : : * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
763 : : * @skb: socket buffer to add attribute to
764 : : * @attrtype: attribute type
765 : : * @value: numeric value
766 : : */
767 : : static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
768 : : {
769 : : return nla_put(skb, attrtype, sizeof(__be16), &value);
770 : : }
771 : :
772 : : /**
773 : : * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
774 : : * @skb: socket buffer to add attribute to
775 : : * @attrtype: attribute type
776 : : * @value: numeric value
777 : : */
778 : : static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
779 : : {
780 : : return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, value);
781 : : }
782 : :
783 : : /**
784 : : * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
785 : : * @skb: socket buffer to add attribute to
786 : : * @attrtype: attribute type
787 : : * @value: numeric value
788 : : */
789 : : static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
790 : : {
791 : : return nla_put(skb, attrtype, sizeof(__le16), &value);
792 : : }
793 : :
794 : : /**
795 : : * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
796 : : * @skb: socket buffer to add attribute to
797 : : * @attrtype: attribute type
798 : : * @value: numeric value
799 : : */
800 : : static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
801 : : {
802 : : return nla_put(skb, attrtype, sizeof(u32), &value);
803 : : }
804 : :
805 : : /**
806 : : * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
807 : : * @skb: socket buffer to add attribute to
808 : : * @attrtype: attribute type
809 : : * @value: numeric value
810 : : */
811 : : static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
812 : : {
813 : : return nla_put(skb, attrtype, sizeof(__be32), &value);
814 : : }
815 : :
816 : : /**
817 : : * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
818 : : * @skb: socket buffer to add attribute to
819 : : * @attrtype: attribute type
820 : : * @value: numeric value
821 : : */
822 : : static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
823 : : {
824 : : return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, value);
825 : : }
826 : :
827 : : /**
828 : : * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
829 : : * @skb: socket buffer to add attribute to
830 : : * @attrtype: attribute type
831 : : * @value: numeric value
832 : : */
833 : : static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
834 : : {
835 : : return nla_put(skb, attrtype, sizeof(__le32), &value);
836 : : }
837 : :
838 : : /**
839 : : * nla_put_u64 - Add a u64 netlink attribute to a socket buffer
840 : : * @skb: socket buffer to add attribute to
841 : : * @attrtype: attribute type
842 : : * @value: numeric value
843 : : */
844 : : static inline int nla_put_u64(struct sk_buff *skb, int attrtype, u64 value)
845 : : {
846 : : return nla_put(skb, attrtype, sizeof(u64), &value);
847 : : }
848 : :
849 : : /**
850 : : * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer
851 : : * @skb: socket buffer to add attribute to
852 : : * @attrtype: attribute type
853 : : * @value: numeric value
854 : : */
855 : : static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value)
856 : : {
857 : : return nla_put(skb, attrtype, sizeof(__be64), &value);
858 : : }
859 : :
860 : : /**
861 : : * nla_put_net64 - Add 64-bit network byte order netlink attribute to a socket buffer
862 : : * @skb: socket buffer to add attribute to
863 : : * @attrtype: attribute type
864 : : * @value: numeric value
865 : : */
866 : : static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value)
867 : : {
868 : : return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, value);
869 : : }
870 : :
871 : : /**
872 : : * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer
873 : : * @skb: socket buffer to add attribute to
874 : : * @attrtype: attribute type
875 : : * @value: numeric value
876 : : */
877 : : static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value)
878 : : {
879 : : return nla_put(skb, attrtype, sizeof(__le64), &value);
880 : : }
881 : :
882 : : /**
883 : : * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
884 : : * @skb: socket buffer to add attribute to
885 : : * @attrtype: attribute type
886 : : * @value: numeric value
887 : : */
888 : : static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
889 : : {
890 : : return nla_put(skb, attrtype, sizeof(s8), &value);
891 : : }
892 : :
893 : : /**
894 : : * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
895 : : * @skb: socket buffer to add attribute to
896 : : * @attrtype: attribute type
897 : : * @value: numeric value
898 : : */
899 : : static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
900 : : {
901 : : return nla_put(skb, attrtype, sizeof(s16), &value);
902 : : }
903 : :
904 : : /**
905 : : * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
906 : : * @skb: socket buffer to add attribute to
907 : : * @attrtype: attribute type
908 : : * @value: numeric value
909 : : */
910 : : static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
911 : : {
912 : : return nla_put(skb, attrtype, sizeof(s32), &value);
913 : : }
914 : :
915 : : /**
916 : : * nla_put_s64 - Add a s64 netlink attribute to a socket buffer
917 : : * @skb: socket buffer to add attribute to
918 : : * @attrtype: attribute type
919 : : * @value: numeric value
920 : : */
921 : : static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value)
922 : : {
923 : : return nla_put(skb, attrtype, sizeof(s64), &value);
924 : : }
925 : :
926 : : /**
927 : : * nla_put_string - Add a string netlink attribute to a socket buffer
928 : : * @skb: socket buffer to add attribute to
929 : : * @attrtype: attribute type
930 : : * @str: NUL terminated string
931 : : */
932 : : static inline int nla_put_string(struct sk_buff *skb, int attrtype,
933 : : const char *str)
934 : : {
935 : : return nla_put(skb, attrtype, strlen(str) + 1, str);
936 : : }
937 : :
938 : : /**
939 : : * nla_put_flag - Add a flag netlink attribute to a socket buffer
940 : : * @skb: socket buffer to add attribute to
941 : : * @attrtype: attribute type
942 : : */
943 : : static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
944 : : {
945 : : return nla_put(skb, attrtype, 0, NULL);
946 : : }
947 : :
948 : : /**
949 : : * nla_put_msecs - Add a msecs netlink attribute to a socket buffer
950 : : * @skb: socket buffer to add attribute to
951 : : * @attrtype: attribute type
952 : : * @jiffies: number of msecs in jiffies
953 : : */
954 : : static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
955 : : unsigned long jiffies)
956 : : {
957 : : u64 tmp = jiffies_to_msecs(jiffies);
958 : : return nla_put(skb, attrtype, sizeof(u64), &tmp);
959 : : }
960 : :
961 : : /**
962 : : * nla_get_u32 - return payload of u32 attribute
963 : : * @nla: u32 netlink attribute
964 : : */
965 : : static inline u32 nla_get_u32(const struct nlattr *nla)
966 : : {
967 : : return *(u32 *) nla_data(nla);
968 : : }
969 : :
970 : : /**
971 : : * nla_get_be32 - return payload of __be32 attribute
972 : : * @nla: __be32 netlink attribute
973 : : */
974 : : static inline __be32 nla_get_be32(const struct nlattr *nla)
975 : : {
976 : : return *(__be32 *) nla_data(nla);
977 : : }
978 : :
979 : : /**
980 : : * nla_get_u16 - return payload of u16 attribute
981 : : * @nla: u16 netlink attribute
982 : : */
983 : : static inline u16 nla_get_u16(const struct nlattr *nla)
984 : : {
985 : : return *(u16 *) nla_data(nla);
986 : : }
987 : :
988 : : /**
989 : : * nla_get_be16 - return payload of __be16 attribute
990 : : * @nla: __be16 netlink attribute
991 : : */
992 : : static inline __be16 nla_get_be16(const struct nlattr *nla)
993 : : {
994 : : return *(__be16 *) nla_data(nla);
995 : : }
996 : :
997 : : /**
998 : : * nla_get_le16 - return payload of __le16 attribute
999 : : * @nla: __le16 netlink attribute
1000 : : */
1001 : : static inline __le16 nla_get_le16(const struct nlattr *nla)
1002 : : {
1003 : : return *(__le16 *) nla_data(nla);
1004 : : }
1005 : :
1006 : : /**
1007 : : * nla_get_u8 - return payload of u8 attribute
1008 : : * @nla: u8 netlink attribute
1009 : : */
1010 : : static inline u8 nla_get_u8(const struct nlattr *nla)
1011 : : {
1012 : : return *(u8 *) nla_data(nla);
1013 : : }
1014 : :
1015 : : /**
1016 : : * nla_get_u64 - return payload of u64 attribute
1017 : : * @nla: u64 netlink attribute
1018 : : */
1019 : : static inline u64 nla_get_u64(const struct nlattr *nla)
1020 : : {
1021 : : u64 tmp;
1022 : :
1023 : : nla_memcpy(&tmp, nla, sizeof(tmp));
1024 : :
1025 : : return tmp;
1026 : : }
1027 : :
1028 : : /**
1029 : : * nla_get_be64 - return payload of __be64 attribute
1030 : : * @nla: __be64 netlink attribute
1031 : : */
1032 : : static inline __be64 nla_get_be64(const struct nlattr *nla)
1033 : : {
1034 : : __be64 tmp;
1035 : :
1036 : : nla_memcpy(&tmp, nla, sizeof(tmp));
1037 : :
1038 : : return tmp;
1039 : : }
1040 : :
1041 : : /**
1042 : : * nla_get_s32 - return payload of s32 attribute
1043 : : * @nla: s32 netlink attribute
1044 : : */
1045 : : static inline s32 nla_get_s32(const struct nlattr *nla)
1046 : : {
1047 : : return *(s32 *) nla_data(nla);
1048 : : }
1049 : :
1050 : : /**
1051 : : * nla_get_s16 - return payload of s16 attribute
1052 : : * @nla: s16 netlink attribute
1053 : : */
1054 : : static inline s16 nla_get_s16(const struct nlattr *nla)
1055 : : {
1056 : : return *(s16 *) nla_data(nla);
1057 : : }
1058 : :
1059 : : /**
1060 : : * nla_get_s8 - return payload of s8 attribute
1061 : : * @nla: s8 netlink attribute
1062 : : */
1063 : : static inline s8 nla_get_s8(const struct nlattr *nla)
1064 : : {
1065 : : return *(s8 *) nla_data(nla);
1066 : : }
1067 : :
1068 : : /**
1069 : : * nla_get_s64 - return payload of s64 attribute
1070 : : * @nla: s64 netlink attribute
1071 : : */
1072 : : static inline s64 nla_get_s64(const struct nlattr *nla)
1073 : : {
1074 : : s64 tmp;
1075 : :
1076 : : nla_memcpy(&tmp, nla, sizeof(tmp));
1077 : :
1078 : : return tmp;
1079 : : }
1080 : :
1081 : : /**
1082 : : * nla_get_flag - return payload of flag attribute
1083 : : * @nla: flag netlink attribute
1084 : : */
1085 : : static inline int nla_get_flag(const struct nlattr *nla)
1086 : : {
1087 : : return !!nla;
1088 : : }
1089 : :
1090 : : /**
1091 : : * nla_get_msecs - return payload of msecs attribute
1092 : : * @nla: msecs netlink attribute
1093 : : *
1094 : : * Returns the number of milliseconds in jiffies.
1095 : : */
1096 : : static inline unsigned long nla_get_msecs(const struct nlattr *nla)
1097 : : {
1098 : : u64 msecs = nla_get_u64(nla);
1099 : :
1100 : : return msecs_to_jiffies((unsigned long) msecs);
1101 : : }
1102 : :
1103 : : /**
1104 : : * nla_nest_start - Start a new level of nested attributes
1105 : : * @skb: socket buffer to add attributes to
1106 : : * @attrtype: attribute type of container
1107 : : *
1108 : : * Returns the container attribute
1109 : : */
1110 : : static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
1111 : : {
1112 : : struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
1113 : :
1114 : : if (nla_put(skb, attrtype, 0, NULL) < 0)
1115 : : return NULL;
1116 : :
1117 : : return start;
1118 : : }
1119 : :
1120 : : /**
1121 : : * nla_nest_end - Finalize nesting of attributes
1122 : : * @skb: socket buffer the attributes are stored in
1123 : : * @start: container attribute
1124 : : *
1125 : : * Corrects the container attribute header to include the all
1126 : : * appeneded attributes.
1127 : : *
1128 : : * Returns the total data length of the skb.
1129 : : */
1130 : : static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
1131 : : {
1132 : : start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
1133 : : return skb->len;
1134 : : }
1135 : :
1136 : : /**
1137 : : * nla_nest_cancel - Cancel nesting of attributes
1138 : : * @skb: socket buffer the message is stored in
1139 : : * @start: container attribute
1140 : : *
1141 : : * Removes the container attribute and including all nested
1142 : : * attributes. Returns -EMSGSIZE
1143 : : */
1144 : : static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
1145 : : {
1146 : : nlmsg_trim(skb, start);
1147 : : }
1148 : :
1149 : : /**
1150 : : * nla_validate_nested - Validate a stream of nested attributes
1151 : : * @start: container attribute
1152 : : * @maxtype: maximum attribute type to be expected
1153 : : * @policy: validation policy
1154 : : *
1155 : : * Validates all attributes in the nested attribute stream against the
1156 : : * specified policy. Attributes with a type exceeding maxtype will be
1157 : : * ignored. See documenation of struct nla_policy for more details.
1158 : : *
1159 : : * Returns 0 on success or a negative error code.
1160 : : */
1161 : : static inline int nla_validate_nested(const struct nlattr *start, int maxtype,
1162 : : const struct nla_policy *policy)
1163 : : {
1164 : : return nla_validate(nla_data(start), nla_len(start), maxtype, policy);
1165 : : }
1166 : :
1167 : : /**
1168 : : * nla_for_each_attr - iterate over a stream of attributes
1169 : : * @pos: loop counter, set to current attribute
1170 : : * @head: head of attribute stream
1171 : : * @len: length of attribute stream
1172 : : * @rem: initialized to len, holds bytes currently remaining in stream
1173 : : */
1174 : : #define nla_for_each_attr(pos, head, len, rem) \
1175 : : for (pos = head, rem = len; \
1176 : : nla_ok(pos, rem); \
1177 : : pos = nla_next(pos, &(rem)))
1178 : :
1179 : : /**
1180 : : * nla_for_each_nested - iterate over nested attributes
1181 : : * @pos: loop counter, set to current attribute
1182 : : * @nla: attribute containing the nested attributes
1183 : : * @rem: initialized to len, holds bytes currently remaining in stream
1184 : : */
1185 : : #define nla_for_each_nested(pos, nla, rem) \
1186 : : nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
1187 : :
1188 : : #endif
|
