1 /* 2 * netlink/attr.h Netlink Attributes 3 * 4 * This library is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation version 2.1 7 * of the License. 8 * 9 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch> 10 */ 11 12 #ifndef NETLINK_ATTR_H_ 13 #define NETLINK_ATTR_H_ 14 15 #include <netlink/netlink.h> 16 #include <netlink/object.h> 17 #include <netlink/addr.h> 18 #include <netlink/data.h> 19 #include <netlink/msg.h> 20 21 #ifdef __cplusplus 22 extern "C" { 23 #endif 24 25 struct nl_msg; 26 27 /** 28 * @name Basic Attribute Data Types 29 * @{ 30 */ 31 32 /** 33 * @ingroup attr 34 * Basic attribute data types 35 * 36 * See \ref attr_datatypes for more details. 37 */ 38 enum { 39 NLA_UNSPEC, /**< Unspecified type, binary data chunk */ 40 NLA_U8, /**< 8 bit integer */ 41 NLA_U16, /**< 16 bit integer */ 42 NLA_U32, /**< 32 bit integer */ 43 NLA_U64, /**< 64 bit integer */ 44 NLA_STRING, /**< NUL terminated character string */ 45 NLA_FLAG, /**< Flag */ 46 NLA_MSECS, /**< Micro seconds (64bit) */ 47 NLA_NESTED, /**< Nested attributes */ 48 NLA_NESTED_ARRAY, 49 NLA_NUL_STRING, 50 NLA_BINARY, 51 NLA_S8, 52 NLA_S16, 53 NLA_S32, 54 NLA_S64, 55 __NLA_TYPE_MAX, 56 }; 57 58 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1) 59 60 /** @} */ 61 62 /** 63 * @ingroup attr 64 * Attribute validation policy. 65 * 66 * See \ref attr_datatypes for more details. 67 */ 68 struct nla_policy { 69 /** Type of attribute or NLA_UNSPEC */ 70 uint16_t type; 71 72 /** Minimal length of payload required */ 73 uint16_t minlen; 74 75 /** Maximal length of payload allowed */ 76 uint16_t maxlen; 77 }; 78 79 /* Attribute parsing */ 80 extern int nla_ok(const struct nlattr *, int); 81 extern struct nlattr * nla_next(const struct nlattr *, int *); 82 extern int nla_parse(struct nlattr **, int, struct nlattr *, 83 int, const struct nla_policy *); 84 extern int nla_validate(const struct nlattr *, int, int, 85 const struct nla_policy *); 86 extern struct nlattr * nla_find(struct nlattr *, int, int); 87 88 /* Unspecific attribute */ 89 extern struct nlattr * nla_reserve(struct nl_msg *, int, int); 90 extern int nla_put(struct nl_msg *, int, int, const void *); 91 92 /** 93 * nlmsg_find_attr - find a specific attribute in a netlink message 94 * @arg nlh netlink message header 95 * @arg hdrlen length of familiy specific header 96 * @arg attrtype type of attribute to look for 97 * 98 * Returns the first attribute which matches the specified type. 99 */ 100 static inline struct nlattr *nlmsg_find_attr(struct nlmsghdr *nlh, int hdrlen, int attrtype) 101 { 102 return nla_find(nlmsg_attrdata(nlh, hdrlen), 103 nlmsg_attrlen(nlh, hdrlen), attrtype); 104 } 105 106 107 /** 108 * Return size of attribute whithout padding. 109 * @arg payload Payload length of attribute. 110 * 111 * @code 112 * <-------- nla_attr_size(payload) ---------> 113 * +------------------+- - -+- - - - - - - - - +- - -+ 114 * | Attribute Header | Pad | Payload | Pad | 115 * +------------------+- - -+- - - - - - - - - +- - -+ 116 * @endcode 117 * 118 * @return Size of attribute in bytes without padding. 119 */ 120 static inline int nla_attr_size(int payload) 121 { 122 return NLA_HDRLEN + payload; 123 } 124 125 /** 126 * Return size of attribute including padding. 127 * @arg payload Payload length of attribute. 128 * 129 * @code 130 * <----------- nla_total_size(payload) -----------> 131 * +------------------+- - -+- - - - - - - - - +- - -+ 132 * | Attribute Header | Pad | Payload | Pad | 133 * +------------------+- - -+- - - - - - - - - +- - -+ 134 * @endcode 135 * 136 * @return Size of attribute in bytes. 137 */ 138 static inline int nla_total_size(int payload) 139 { 140 return NLA_ALIGN(nla_attr_size(payload)); 141 } 142 143 /** 144 * Return length of padding at the tail of the attribute. 145 * @arg payload Payload length of attribute. 146 * 147 * @code 148 * +------------------+- - -+- - - - - - - - - +- - -+ 149 * | Attribute Header | Pad | Payload | Pad | 150 * +------------------+- - -+- - - - - - - - - +- - -+ 151 * <---> 152 * @endcode 153 * 154 * @return Length of padding in bytes. 155 */ 156 static inline int nla_padlen(int payload) 157 { 158 return nla_total_size(payload) - nla_attr_size(payload); 159 } 160 161 /** 162 * Return type of the attribute. 163 * @arg nla Attribute. 164 * 165 * @return Type of attribute. 166 */ 167 static inline int nla_type(const struct nlattr *nla) 168 { 169 return nla->nla_type & NLA_TYPE_MASK; 170 } 171 172 /** 173 * Return pointer to the payload section. 174 * @arg nla Attribute. 175 * 176 * @return Pointer to start of payload section. 177 */ 178 static inline void *nla_data(const struct nlattr *nla) 179 { 180 return (char *) nla + NLA_HDRLEN; 181 } 182 183 /** 184 * Return length of the payload . 185 * @arg nla Attribute 186 * 187 * @return Length of payload in bytes. 188 */ 189 static inline int nla_len(const struct nlattr *nla) 190 { 191 return nla->nla_len - NLA_HDRLEN; 192 } 193 194 /** 195 * Copy attribute payload to another memory area. 196 * @arg dest Pointer to destination memory area. 197 * @arg src Attribute 198 * @arg count Number of bytes to copy at most. 199 * 200 * Note: The number of bytes copied is limited by the length of 201 * the attribute payload. 202 * 203 * @return The number of bytes copied to dest. 204 */ 205 static inline int nla_memcpy(void *dest, const struct nlattr *src, int count) 206 { 207 int minlen; 208 209 if (!src) 210 return 0; 211 212 minlen = min_t(int, count, nla_len(src)); 213 memcpy(dest, nla_data(src), minlen); 214 215 return minlen; 216 } 217 218 219 /** 220 * Add abstract data as unspecific attribute to netlink message. 221 * @arg msg Netlink message. 222 * @arg attrtype Attribute type. 223 * @arg data Abstract data object. 224 * 225 * Equivalent to nla_put() except that the length of the payload is 226 * derived from the abstract data object. 227 * 228 * @see nla_put 229 * @return 0 on success or a negative error code. 230 */ 231 static inline int nla_put_data(struct nl_msg *msg, int attrtype, struct nl_data *data) 232 { 233 return nla_put(msg, attrtype, nl_data_get_size(data), 234 nl_data_get(data)); 235 } 236 237 /** 238 * Add abstract address as unspecific attribute to netlink message. 239 * @arg msg Netlink message. 240 * @arg attrtype Attribute type. 241 * @arg addr Abstract address object. 242 * 243 * @see nla_put 244 * @return 0 on success or a negative error code. 245 */ 246 static inline int nla_put_addr(struct nl_msg *msg, int attrtype, struct nl_addr *addr) 247 { 248 return nla_put(msg, attrtype, nl_addr_get_len(addr), 249 nl_addr_get_binary_addr(addr)); 250 } 251 252 /** @} */ 253 254 /** 255 * @name Integer Attributes 256 */ 257 258 /** 259 * Add 8 bit signed integer attribute to netlink message. 260 * @arg msg Netlink message. 261 * @arg attrtype Attribute type. 262 * @arg value Numeric value to store as payload. 263 * 264 * @see nla_put 265 * @return 0 on success or a negative error code. 266 */ 267 static inline int nla_put_s8(struct nl_msg *msg, int attrtype, int8_t value) 268 { 269 return nla_put(msg, attrtype, sizeof(int8_t), &value); 270 } 271 272 /** 273 * Return value of 8 bit signed integer attribute. 274 * @arg nla 8 bit integer attribute 275 * 276 * @return Payload as 8 bit integer. 277 */ 278 static inline int8_t nla_get_s8(const struct nlattr *nla) 279 { 280 return *(const int8_t *) nla_data(nla); 281 } 282 283 /** 284 * Add 8 bit integer attribute to netlink message. 285 * @arg msg Netlink message. 286 * @arg attrtype Attribute type. 287 * @arg value Numeric value to store as payload. 288 * 289 * @see nla_put 290 * @return 0 on success or a negative error code. 291 */ 292 static inline int nla_put_u8(struct nl_msg *msg, int attrtype, uint8_t value) 293 { 294 return nla_put(msg, attrtype, sizeof(uint8_t), &value); 295 } 296 297 /** 298 * Return value of 8 bit integer attribute. 299 * @arg nla 8 bit integer attribute 300 * 301 * @return Payload as 8 bit integer. 302 */ 303 static inline uint8_t nla_get_u8(const struct nlattr *nla) 304 { 305 return *(const uint8_t *) nla_data(nla); 306 } 307 308 /** 309 * Add 16 bit signed integer attribute to netlink message. 310 * @arg msg Netlink message. 311 * @arg attrtype Attribute type. 312 * @arg value Numeric value to store as payload. 313 * 314 * @see nla_put 315 * @return 0 on success or a negative error code. 316 */ 317 static inline int nla_put_s16(struct nl_msg *msg, int attrtype, int16_t value) 318 { 319 return nla_put(msg, attrtype, sizeof(int16_t), &value); 320 } 321 322 /** 323 * Return payload of 16 bit signed integer attribute. 324 * @arg nla 16 bit integer attribute 325 * 326 * @return Payload as 16 bit integer. 327 */ 328 static inline int16_t nla_get_s16(const struct nlattr *nla) 329 { 330 return *(const int16_t *) nla_data(nla); 331 } 332 333 /** 334 * Add 16 bit integer attribute to netlink message. 335 * @arg msg Netlink message. 336 * @arg attrtype Attribute type. 337 * @arg value Numeric value to store as payload. 338 * 339 * @see nla_put 340 * @return 0 on success or a negative error code. 341 */ 342 static inline int nla_put_u16(struct nl_msg *msg, int attrtype, uint16_t value) 343 { 344 return nla_put(msg, attrtype, sizeof(uint16_t), &value); 345 } 346 347 /** 348 * Return payload of 16 bit integer attribute. 349 * @arg nla 16 bit integer attribute 350 * 351 * @return Payload as 16 bit integer. 352 */ 353 static inline uint16_t nla_get_u16(const struct nlattr *nla) 354 { 355 return *(const uint16_t *) nla_data(nla); 356 } 357 358 /** 359 * Add 32 bit signed integer attribute to netlink message. 360 * @arg msg Netlink message. 361 * @arg attrtype Attribute type. 362 * @arg value Numeric value to store as payload. 363 * 364 * @see nla_put 365 * @return 0 on success or a negative error code. 366 */ 367 static inline int nla_put_s32(struct nl_msg *msg, int attrtype, int32_t value) 368 { 369 return nla_put(msg, attrtype, sizeof(int32_t), &value); 370 } 371 372 /** 373 * Return payload of 32 bit signed integer attribute. 374 * @arg nla 32 bit integer attribute. 375 * 376 * @return Payload as 32 bit integer. 377 */ 378 static inline int32_t nla_get_s32(const struct nlattr *nla) 379 { 380 return *(const int32_t *) nla_data(nla); 381 } 382 383 /** 384 * Add 32 bit integer attribute to netlink message. 385 * @arg msg Netlink message. 386 * @arg attrtype Attribute type. 387 * @arg value Numeric value to store as payload. 388 * 389 * @see nla_put 390 * @return 0 on success or a negative error code. 391 */ 392 static inline int nla_put_u32(struct nl_msg *msg, int attrtype, uint32_t value) 393 { 394 return nla_put(msg, attrtype, sizeof(uint32_t), &value); 395 } 396 397 /** 398 * Return payload of 32 bit integer attribute. 399 * @arg nla 32 bit integer attribute. 400 * 401 * @return Payload as 32 bit integer. 402 */ 403 static inline uint32_t nla_get_u32(const struct nlattr *nla) 404 { 405 return *(const uint32_t *) nla_data(nla); 406 } 407 408 /** 409 * Add 64 bit signed integer attribute to netlink message. 410 * @arg msg Netlink message. 411 * @arg attrtype Attribute type. 412 * @arg value Numeric value to store as payload. 413 * 414 * @see nla_put 415 * @return 0 on success or a negative error code. 416 */ 417 static inline int nla_put_s64(struct nl_msg *msg, int attrtype, int64_t value) 418 { 419 return nla_put(msg, attrtype, sizeof(int64_t), &value); 420 } 421 422 /** 423 * Return payload of s64 attribute 424 * @arg nla s64 netlink attribute 425 * 426 * @return Payload as 64 bit integer. 427 */ 428 static inline int64_t nla_get_s64(const struct nlattr *nla) 429 { 430 int64_t tmp; 431 432 nla_memcpy(&tmp, nla, sizeof(tmp)); 433 434 return tmp; 435 } 436 437 /** 438 * Add 64 bit integer attribute to netlink message. 439 * @arg msg Netlink message. 440 * @arg attrtype Attribute type. 441 * @arg value Numeric value to store as payload. 442 * 443 * @see nla_put 444 * @return 0 on success or a negative error code. 445 */ 446 static inline int nla_put_u64(struct nl_msg *msg, int attrtype, uint64_t value) 447 { 448 return nla_put(msg, attrtype, sizeof(uint64_t), &value); 449 } 450 451 /** 452 * Return payload of u64 attribute 453 * @arg nla u64 netlink attribute 454 * 455 * @return Payload as 64 bit integer. 456 */ 457 static inline uint64_t nla_get_u64(const struct nlattr *nla) 458 { 459 uint64_t tmp; 460 461 nla_memcpy(&tmp, nla, sizeof(tmp)); 462 463 return tmp; 464 } 465 466 /** 467 * Add string attribute to netlink message. 468 * @arg msg Netlink message. 469 * @arg attrtype Attribute type. 470 * @arg str NUL terminated string. 471 * 472 * @see nla_put 473 * @return 0 on success or a negative error code. 474 */ 475 static inline int nla_put_string(struct nl_msg *msg, int attrtype, const char *str) 476 { 477 return nla_put(msg, attrtype, strlen(str) + 1, str); 478 } 479 480 /** 481 * Return payload of string attribute. 482 * @arg nla String attribute. 483 * 484 * @return Pointer to attribute payload. 485 */ 486 static inline char *nla_get_string(const struct nlattr *nla) 487 { 488 return (char *) nla_data(nla); 489 } 490 491 static inline char *nla_strdup(const struct nlattr *nla) 492 { 493 return strdup(nla_get_string(nla)); 494 } 495 496 /** @} */ 497 498 /** 499 * @name Flag Attribute 500 */ 501 502 /** 503 * Add flag netlink attribute to netlink message. 504 * @arg msg Netlink message. 505 * @arg attrtype Attribute type. 506 * 507 * @see nla_put 508 * @return 0 on success or a negative error code. 509 */ 510 static inline int nla_put_flag(struct nl_msg *msg, int attrtype) 511 { 512 return nla_put(msg, attrtype, 0, NULL); 513 } 514 515 /** 516 * Return true if flag attribute is set. 517 * @arg nla Flag netlink attribute. 518 * 519 * @return True if flag is set, otherwise false. 520 */ 521 static inline int nla_get_flag(const struct nlattr *nla) 522 { 523 return !!nla; 524 } 525 526 /** @} */ 527 528 /** 529 * @name Microseconds Attribute 530 */ 531 532 /** 533 * Add a msecs netlink attribute to a netlink message 534 * @arg n netlink message 535 * @arg attrtype attribute type 536 * @arg msecs number of msecs 537 */ 538 static inline int nla_put_msecs(struct nl_msg *n, int attrtype, unsigned long msecs) 539 { 540 return nla_put_u64(n, attrtype, msecs); 541 } 542 543 /** 544 * Return payload of msecs attribute 545 * @arg nla msecs netlink attribute 546 * 547 * @return the number of milliseconds. 548 */ 549 static inline unsigned long nla_get_msecs(const struct nlattr *nla) 550 { 551 return nla_get_u64(nla); 552 } 553 554 /** 555 * Add nested attributes to netlink message. 556 * @arg msg Netlink message. 557 * @arg attrtype Attribute type. 558 * @arg nested Message containing attributes to be nested. 559 * 560 * Takes the attributes found in the \a nested message and appends them 561 * to the message \a msg nested in a container of the type \a attrtype. 562 * The \a nested message may not have a family specific header. 563 * 564 * @see nla_put 565 * @return 0 on success or a negative error code. 566 */ 567 static inline int nla_put_nested(struct nl_msg *msg, int attrtype, const struct nl_msg *nested) 568 { 569 return nla_put(msg, attrtype, nlmsg_len(nested->nm_nlh), 570 nlmsg_data(nested->nm_nlh)); 571 } 572 573 /** 574 * Start a new level of nested attributes. 575 * @arg msg Netlink message. 576 * @arg attrtype Attribute type of container. 577 * 578 * @return Pointer to container attribute. 579 */ 580 static inline struct nlattr *nla_nest_start(struct nl_msg *msg, int attrtype) 581 { 582 struct nlattr *start = (struct nlattr *) nlmsg_tail(msg->nm_nlh); 583 584 if (nla_put(msg, attrtype | NLA_F_NESTED, 0, NULL) < 0) 585 return NULL; 586 587 return start; 588 } 589 590 /** 591 * Finalize nesting of attributes. 592 * @arg msg Netlink message. 593 * @arg start Container attribute as returned from nla_nest_start(). 594 * 595 * Corrects the container attribute header to include the appeneded attributes. 596 * 597 * @return 0 598 */ 599 static inline int nla_nest_end(struct nl_msg *msg, struct nlattr *start) 600 { 601 start->nla_len = (unsigned char *) nlmsg_tail(msg->nm_nlh) - 602 (unsigned char *) start; 603 return 0; 604 } 605 606 /** 607 * Create attribute index based on nested attribute 608 * @arg tb Index array to be filled (maxtype+1 elements). 609 * @arg maxtype Maximum attribute type expected and accepted. 610 * @arg nla Nested Attribute. 611 * @arg policy Attribute validation policy. 612 * 613 * Feeds the stream of attributes nested into the specified attribute 614 * to nla_parse(). 615 * 616 * @see nla_parse 617 * @return 0 on success or a negative error code. 618 */ 619 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype, struct nlattr *nla, 620 const struct nla_policy *policy) 621 { 622 return nla_parse(tb, maxtype, (struct nlattr *)nla_data(nla), nla_len(nla), policy); 623 } 624 625 /** 626 * Compare attribute payload with memory area. 627 * @arg nla Attribute. 628 * @arg data Memory area to compare to. 629 * @arg size Number of bytes to compare. 630 * 631 * @see memcmp(3) 632 * @return An integer less than, equal to, or greater than zero. 633 */ 634 static inline int nla_memcmp(const struct nlattr *nla, const void *data, size_t size) 635 { 636 int d = nla_len(nla) - size; 637 638 if (d == 0) 639 d = memcmp(nla_data(nla), data, size); 640 641 return d; 642 } 643 644 /** 645 * Compare string attribute payload with string 646 * @arg nla Attribute of type NLA_STRING. 647 * @arg str NUL terminated string. 648 * 649 * @see strcmp(3) 650 * @return An integer less than, equal to, or greater than zero. 651 */ 652 static inline int nla_strcmp(const struct nlattr *nla, const char *str) 653 { 654 int len = strlen(str) + 1; 655 int d = nla_len(nla) - len; 656 657 if (d == 0) 658 d = memcmp(nla_data(nla), str, len); 659 660 return d; 661 } 662 663 /** 664 * Copy string attribute payload to a buffer. 665 * @arg dst Pointer to destination buffer. 666 * @arg nla Attribute of type NLA_STRING. 667 * @arg dstsize Size of destination buffer in bytes. 668 * 669 * Copies at most dstsize - 1 bytes to the destination buffer. 670 * The result is always a valid NUL terminated string. Unlike 671 * strlcpy the destination buffer is always padded out. 672 * 673 * @return The length of string attribute without the terminating NUL. 674 */ 675 static inline size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize) 676 { 677 size_t srclen = (size_t)nla_len(nla); 678 char *src = (char*)nla_data(nla); 679 680 if (srclen > 0 && src[srclen - 1] == '\0') 681 srclen--; 682 683 if (dstsize > 0) { 684 size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen; 685 686 memset(dst, 0, dstsize); 687 memcpy(dst, src, len); 688 } 689 690 return srclen; 691 } 692 693 694 /** 695 * @name Attribute Construction (Exception Based) 696 * @{ 697 */ 698 699 /** 700 * @ingroup attr 701 * Add unspecific attribute to netlink message. 702 * @arg msg Netlink message. 703 * @arg attrtype Attribute type. 704 * @arg attrlen Length of attribute payload. 705 * @arg data Head of attribute payload. 706 */ 707 #define NLA_PUT(msg, attrtype, attrlen, data) \ 708 do { \ 709 if (nla_put(msg, attrtype, attrlen, data) < 0) \ 710 goto nla_put_failure; \ 711 } while(0) 712 713 /** 714 * @ingroup attr 715 * Add atomic type attribute to netlink message. 716 * @arg msg Netlink message. 717 * @arg type Atomic type. 718 * @arg attrtype Attribute type. 719 * @arg value Head of attribute payload. 720 */ 721 #define NLA_PUT_TYPE(msg, type, attrtype, value) \ 722 do { \ 723 type __tmp = value; \ 724 NLA_PUT(msg, attrtype, sizeof(type), &__tmp); \ 725 } while(0) 726 727 /** 728 * Add 8 bit signed integer attribute to netlink message. 729 * @arg msg Netlink message. 730 * @arg attrtype Attribute type. 731 * @arg value Numeric value. 732 */ 733 #define NLA_PUT_S8(msg, attrtype, value) \ 734 NLA_PUT_TYPE(msg, int8_t, attrtype, value) 735 736 /** 737 * Add 8 bit signed integer attribute to netlink message. 738 * @arg msg Netlink message. 739 * @arg attrtype Attribute type. 740 * @arg value Numeric value. 741 */ 742 #define NLA_PUT_S8(msg, attrtype, value) \ 743 NLA_PUT_TYPE(msg, int8_t, attrtype, value) 744 745 /** 746 * Add 8 bit integer attribute to netlink message. 747 * @arg msg Netlink message. 748 * @arg attrtype Attribute type. 749 * @arg value Numeric value. 750 */ 751 #define NLA_PUT_U8(msg, attrtype, value) \ 752 NLA_PUT_TYPE(msg, uint8_t, attrtype, value) 753 754 /** 755 * Add 16 bit signed integer attribute to netlink message. 756 * @arg msg Netlink message. 757 * @arg attrtype Attribute type. 758 * @arg value Numeric value. 759 */ 760 #define NLA_PUT_S16(msg, attrtype, value) \ 761 NLA_PUT_TYPE(msg, int16_t, attrtype, value) 762 763 /** 764 * Add 16 bit integer attribute to netlink message. 765 * @arg msg Netlink message. 766 * @arg attrtype Attribute type. 767 * @arg value Numeric value. 768 */ 769 #define NLA_PUT_U16(msg, attrtype, value) \ 770 NLA_PUT_TYPE(msg, uint16_t, attrtype, value) 771 772 /** 773 * Add 32 bit signed integer attribute to netlink message. 774 * @arg msg Netlink message. 775 * @arg attrtype Attribute type. 776 * @arg value Numeric value. 777 */ 778 #define NLA_PUT_S32(msg, attrtype, value) \ 779 NLA_PUT_TYPE(msg, int32_t, attrtype, value) 780 781 /** 782 * Add 32 bit integer attribute to netlink message. 783 * @arg msg Netlink message. 784 * @arg attrtype Attribute type. 785 * @arg value Numeric value. 786 */ 787 #define NLA_PUT_U32(msg, attrtype, value) \ 788 NLA_PUT_TYPE(msg, uint32_t, attrtype, value) 789 790 /** 791 * Add 64 bit signed integer attribute to netlink message. 792 * @arg msg Netlink message. 793 * @arg attrtype Attribute type. 794 * @arg value Numeric value. 795 */ 796 #define NLA_PUT_S64(msg, attrtype, value) \ 797 NLA_PUT_TYPE(msg, int64_t, attrtype, value) 798 799 /** 800 * Add 64 bit integer attribute to netlink message. 801 * @arg msg Netlink message. 802 * @arg attrtype Attribute type. 803 * @arg value Numeric value. 804 */ 805 #define NLA_PUT_U64(msg, attrtype, value) \ 806 NLA_PUT_TYPE(msg, uint64_t, attrtype, value) 807 808 /** 809 * Add string attribute to netlink message. 810 * @arg msg Netlink message. 811 * @arg attrtype Attribute type. 812 * @arg value NUL terminated character string. 813 */ 814 #define NLA_PUT_STRING(msg, attrtype, value) \ 815 NLA_PUT(msg, attrtype, strlen(value) + 1, value) 816 817 /** 818 * Add flag attribute to netlink message. 819 * @arg msg Netlink message. 820 * @arg attrtype Attribute type. 821 */ 822 #define NLA_PUT_FLAG(msg, attrtype) \ 823 NLA_PUT(msg, attrtype, 0, NULL) 824 825 /** 826 * Add msecs attribute to netlink message. 827 * @arg msg Netlink message. 828 * @arg attrtype Attribute type. 829 * @arg msecs Numeric value in micro seconds. 830 */ 831 #define NLA_PUT_MSECS(msg, attrtype, msecs) \ 832 NLA_PUT_U64(msg, attrtype, msecs) 833 834 /** 835 * Add address attribute to netlink message. 836 * @arg msg Netlink message. 837 * @arg attrtype Attribute type. 838 * @arg addr Abstract address object. 839 */ 840 #define NLA_PUT_ADDR(msg, attrtype, addr) \ 841 NLA_PUT(msg, attrtype, nl_addr_get_len(addr), \ 842 nl_addr_get_binary_addr(addr)) 843 844 /** @} */ 845 846 /** 847 * @name Iterators 848 * @{ 849 */ 850 851 /** 852 * @ingroup attr 853 * Iterate over a stream of attributes 854 * @arg pos loop counter, set to current attribute 855 * @arg head head of attribute stream 856 * @arg len length of attribute stream 857 * @arg rem initialized to len, holds bytes currently remaining in stream 858 */ 859 #define nla_for_each_attr(pos, head, len, rem) \ 860 for (pos = head, rem = len; \ 861 nla_ok(pos, rem); \ 862 pos = nla_next(pos, &(rem))) 863 864 /** 865 * @ingroup attr 866 * Iterate over a stream of nested attributes 867 * @arg pos loop counter, set to current attribute 868 * @arg nla attribute containing the nested attributes 869 * @arg rem initialized to len, holds bytes currently remaining in stream 870 */ 871 #define nla_for_each_nested(pos, nla, rem) \ 872 for (pos = (struct nlattr *)nla_data(nla), rem = nla_len(nla); \ 873 nla_ok(pos, rem); \ 874 pos = nla_next(pos, &(rem))) 875 876 /** @} */ 877 878 #ifdef __cplusplus 879 } 880 #endif 881 882 #endif 883
This page was automatically generated by LXR 0.3.1. • OpenWrt