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