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