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