~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/net/netlink.h

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp