include/net/netlink.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __NET_NETLINK_H
   3 #define __NET_NETLINK_H
   4
   5 #include <linux/types.h>
   6 #include <linux/netlink.h>
   7 #include <linux/jiffies.h>
   8 #include <linux/in6.h>
   9
  10 /* ========================================================================
  11  *         Netlink Messages and Attributes Interface (As Seen On TV)
  12  * ------------------------------------------------------------------------
  13  *                          Messages Interface
  14  * ------------------------------------------------------------------------
  15  *
  16  * Message Format:
  17  *    <--- nlmsg_total_size(payload)  --->
  18  *    <-- nlmsg_msg_size(payload) ->
  19  *   +----------+- - -+-------------+- - -+-------- - -
  20  *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
  21  *   +----------+- - -+-------------+- - -+-------- - -
  22  *   nlmsg_data(nlh)---^                   ^
  23  *   nlmsg_next(nlh)-----------------------+
  24  *
  25  * Payload Format:
  26  *    <---------------------- nlmsg_len(nlh) --------------------->
  27  *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
  28  *   +----------------------+- - -+--------------------------------+
  29  *   |     Family Header    | Pad |           Attributes           |
  30  *   +----------------------+- - -+--------------------------------+
  31  *   nlmsg_attrdata(nlh, hdrlen)---^
  32  *
  33  * Data Structures:
  34  *   struct nlmsghdr                    netlink message header
  35  *
  36  * Message Construction:
  37  *   nlmsg_new()                        create a new netlink message
  38  *   nlmsg_put()                        add a netlink message to an skb
  39  *   nlmsg_put_answer()                 callback based nlmsg_put()
  40  *   nlmsg_end()                        finalize netlink message
  41  *   nlmsg_get_pos()                    return current position in message
  42  *   nlmsg_trim()                       trim part of message
  43  *   nlmsg_cancel()                     cancel message construction
  44  *   nlmsg_consume()                    free a netlink message (expected)
  45  *   nlmsg_free()                       free a netlink message (drop)
  46  *
  47  * Message Sending:
  48  *   nlmsg_multicast()                  multicast message to several groups
  49  *   nlmsg_unicast()                    unicast a message to a single socket
  50  *   nlmsg_notify()                     send notification message
  51  *
  52  * Message Length Calculations:
  53  *   nlmsg_msg_size(payload)            length of message w/o padding
  54  *   nlmsg_total_size(payload)          length of message w/ padding
  55  *   nlmsg_padlen(payload)              length of padding at tail
  56  *
  57  * Message Payload Access:
  58  *   nlmsg_data(nlh)                    head of message payload
  59  *   nlmsg_len(nlh)                     length of message payload
  60  *   nlmsg_attrdata(nlh, hdrlen)        head of attributes data
  61  *   nlmsg_attrlen(nlh, hdrlen)         length of attributes data
  62  *
  63  * Message Parsing:
  64  *   nlmsg_ok(nlh, remaining)           does nlh fit into remaining bytes?
  65  *   nlmsg_next(nlh, remaining)         get next netlink message
  66  *   nlmsg_parse()                      parse attributes of a message
  67  *   nlmsg_find_attr()                  find an attribute in a message
  68  *   nlmsg_for_each_msg()               loop over all messages
  69  *   nlmsg_validate()                   validate netlink message incl. attrs
  70  *   nlmsg_for_each_attr()              loop over all attributes
  71  *
  72  * Misc:
  73  *   nlmsg_report()                     report back to application?
  74  *
  75  * ------------------------------------------------------------------------
  76  *                          Attributes Interface
  77  * ------------------------------------------------------------------------
  78  *
  79  * Attribute Format:
  80  *    <------- nla_total_size(payload) ------->
  81  *    <---- nla_attr_size(payload) ----->
  82  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
  83  *   |  Header  | Pad |     Payload      | Pad |  Header
  84  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
  85  *                     <- nla_len(nla) ->      ^
  86  *   nla_data(nla)----^                        |
  87  *   nla_next(nla)-----------------------------'
  88  *
  89  * Data Structures:
  90  *   struct nlattr                      netlink attribute header
  91  *
  92  * Attribute Construction:
  93  *   nla_reserve(skb, type, len)        reserve room for an attribute
  94  *   nla_reserve_nohdr(skb, len)        reserve room for an attribute w/o hdr
  95  *   nla_put(skb, type, len, data)      add attribute to skb
  96  *   nla_put_nohdr(skb, len, data)      add attribute w/o hdr
  97  *   nla_append(skb, len, data)         append data to skb
  98  *
  99  * Attribute Construction for Basic Types:
 100  *   nla_put_u8(skb, type, value)       add u8 attribute to skb
 101  *   nla_put_u16(skb, type, value)      add u16 attribute to skb
 102  *   nla_put_u32(skb, type, value)      add u32 attribute to skb
 103  *   nla_put_u64_64bit(skb, type,
 104  *                     value, padattr)  add u64 attribute to skb
 105  *   nla_put_s8(skb, type, value)       add s8 attribute to skb
 106  *   nla_put_s16(skb, type, value)      add s16 attribute to skb
 107  *   nla_put_s32(skb, type, value)      add s32 attribute to skb
 108  *   nla_put_s64(skb, type, value,
 109  *               padattr)               add s64 attribute to skb
 110  *   nla_put_string(skb, type, str)     add string attribute to skb
 111  *   nla_put_flag(skb, type)            add flag attribute to skb
 112  *   nla_put_msecs(skb, type, jiffies,
 113  *                 padattr)             add msecs attribute to skb
 114  *   nla_put_in_addr(skb, type, addr)   add IPv4 address attribute to skb
 115  *   nla_put_in6_addr(skb, type, addr)  add IPv6 address attribute to skb
 116  *
 117  * Nested Attributes Construction:
 118  *   nla_nest_start(skb, type)          start a nested attribute
 119  *   nla_nest_end(skb, nla)             finalize a nested attribute
 120  *   nla_nest_cancel(skb, nla)          cancel nested attribute construction
 121  *
 122  * Attribute Length Calculations:
 123  *   nla_attr_size(payload)             length of attribute w/o padding
 124  *   nla_total_size(payload)            length of attribute w/ padding
 125  *   nla_padlen(payload)                length of padding
 126  *
 127  * Attribute Payload Access:
 128  *   nla_data(nla)                      head of attribute payload
 129  *   nla_len(nla)                       length of attribute payload
 130  *
 131  * Attribute Payload Access for Basic Types:
 132  *   nla_get_uint(nla)                  get payload for a uint attribute
 133  *   nla_get_sint(nla)                  get payload for a sint attribute
 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_s8(nla)                    get payload for a s8 attribute
 139  *   nla_get_s16(nla)                   get payload for a s16 attribute
 140  *   nla_get_s32(nla)                   get payload for a s32 attribute
 141  *   nla_get_s64(nla)                   get payload for a s64 attribute
 142  *   nla_get_flag(nla)                  return 1 if flag is true
 143  *   nla_get_msecs(nla)                 get payload for a msecs attribute
 144  *
 145  *   The same functions also exist with _default().
 146  *
 147  * Attribute Misc:
 148  *   nla_memcpy(dest, nla, count)       copy attribute into memory
 149  *   nla_memcmp(nla, data, size)        compare attribute with memory area
 150  *   nla_strscpy(dst, nla, size)        copy attribute to a sized string
 151  *   nla_strcmp(nla, str)               compare attribute with string
 152  *
 153  * Attribute Parsing:
 154  *   nla_ok(nla, remaining)             does nla fit into remaining bytes?
 155  *   nla_next(nla, remaining)           get next netlink attribute
 156  *   nla_validate()                     validate a stream of attributes
 157  *   nla_validate_nested()              validate a stream of nested attributes
 158  *   nla_find()                         find attribute in stream of attributes
 159  *   nla_find_nested()                  find attribute in nested attributes
 160  *   nla_parse()                        parse and validate stream of attrs
 161  *   nla_parse_nested()                 parse nested attributes
 162  *   nla_for_each_attr()                loop over all attributes
 163  *   nla_for_each_attr_type()           loop over all attributes with the
 164  *                                      given type
 165  *   nla_for_each_nested()              loop over the nested attributes
 166  *   nla_for_each_nested_type()         loop over the nested attributes with
 167  *                                      the given type
 168  *=========================================================================
 169  */
 170
 171  /**
 172   * Standard attribute types to specify validation policy
 173   */
 174 enum {
 175         NLA_UNSPEC,
 176         NLA_U8,
 177         NLA_U16,
 178         NLA_U32,
 179         NLA_U64,
 180         NLA_STRING,
 181         NLA_FLAG,
 182         NLA_MSECS,
 183         NLA_NESTED,
 184         NLA_NESTED_ARRAY,
 185         NLA_NUL_STRING,
 186         NLA_BINARY,
 187         NLA_S8,
 188         NLA_S16,
 189         NLA_S32,
 190         NLA_S64,
 191         NLA_BITFIELD32,
 192         NLA_REJECT,
 193         NLA_BE16,
 194         NLA_BE32,
 195         NLA_SINT,
 196         NLA_UINT,
 197         __NLA_TYPE_MAX,
 198 };
 199
 200 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
 201
 202 struct netlink_range_validation {
 203         u64 min, max;
 204 };
 205
 206 struct netlink_range_validation_signed {
 207         s64 min, max;
 208 };
 209
 210 enum nla_policy_validation {
 211         NLA_VALIDATE_NONE,
 212         NLA_VALIDATE_RANGE,
 213         NLA_VALIDATE_RANGE_WARN_TOO_LONG,
 214         NLA_VALIDATE_MIN,
 215         NLA_VALIDATE_MAX,
 216         NLA_VALIDATE_MASK,
 217         NLA_VALIDATE_RANGE_PTR,
 218         NLA_VALIDATE_FUNCTION,
 219 };
 220
 221 /**
 222  * struct nla_policy - attribute validation policy
 223  * @type: Type of attribute or NLA_UNSPEC
 224  * @validation_type: type of attribute validation done in addition to
 225  *      type-specific validation (e.g. range, function call), see
 226  *      &enum nla_policy_validation
 227  * @len: Type specific length of payload
 228  *
 229  * Policies are defined as arrays of this struct, the array must be
 230  * accessible by attribute type up to the highest identifier to be expected.
 231  *
 232  * Meaning of `len' field:
 233  *    NLA_STRING           Maximum length of string
 234  *    NLA_NUL_STRING       Maximum length of string (excluding NUL)
 235  *    NLA_FLAG             Unused
 236  *    NLA_BINARY           Maximum length of attribute payload
 237  *                         (but see also below with the validation type)
 238  *    NLA_NESTED,
 239  *    NLA_NESTED_ARRAY     Length verification is done by checking len of
 240  *                         nested header (or empty); len field is used if
 241  *                         nested_policy is also used, for the max attr
 242  *                         number in the nested policy.
 243  *    NLA_SINT, NLA_UINT,
 244  *    NLA_U8, NLA_U16,
 245  *    NLA_U32, NLA_U64,
 246  *    NLA_S8, NLA_S16,
 247  *    NLA_S32, NLA_S64,
 248  *    NLA_BE16, NLA_BE32,
 249  *    NLA_MSECS            Leaving the length field zero will verify the
 250  *                         given type fits, using it verifies minimum length
 251  *                         just like "All other"
 252  *    NLA_BITFIELD32       Unused
 253  *    NLA_REJECT           Unused
 254  *    All other            Minimum length of attribute payload
 255  *
 256  * Meaning of validation union:
 257  *    NLA_BITFIELD32       This is a 32-bit bitmap/bitselector attribute and
 258  *                         `bitfield32_valid' is the u32 value of valid flags
 259  *    NLA_REJECT           This attribute is always rejected and `reject_message'
 260  *                         may point to a string to report as the error instead
 261  *                         of the generic one in extended ACK.
 262  *    NLA_NESTED           `nested_policy' to a nested policy to validate, must
 263  *                         also set `len' to the max attribute number. Use the
 264  *                         provided NLA_POLICY_NESTED() macro.
 265  *                         Note that nla_parse() will validate, but of course not
 266  *                         parse, the nested sub-policies.
 267  *    NLA_NESTED_ARRAY     `nested_policy' points to a nested policy to validate,
 268  *                         must also set `len' to the max attribute number. Use
 269  *                         the provided NLA_POLICY_NESTED_ARRAY() macro.
 270  *                         The difference to NLA_NESTED is the structure:
 271  *                         NLA_NESTED has the nested attributes directly inside
 272  *                         while an array has the nested attributes at another
 273  *                         level down and the attribute types directly in the
 274  *                         nesting don't matter.
 275  *    NLA_UINT,
 276  *    NLA_U8,
 277  *    NLA_U16,
 278  *    NLA_U32,
 279  *    NLA_U64,
 280  *    NLA_BE16,
 281  *    NLA_BE32,
 282  *    NLA_SINT,
 283  *    NLA_S8,
 284  *    NLA_S16,
 285  *    NLA_S32,
 286  *    NLA_S64              The `min' and `max' fields are used depending on the
 287  *                         validation_type field, if that is min/max/range then
 288  *                         the min, max or both are used (respectively) to check
 289  *                         the value of the integer attribute.
 290  *                         Note that in the interest of code simplicity and
 291  *                         struct size both limits are s16, so you cannot
 292  *                         enforce a range that doesn't fall within the range
 293  *                         of s16 - do that using the NLA_POLICY_FULL_RANGE()
 294  *                         or NLA_POLICY_FULL_RANGE_SIGNED() macros instead.
 295  *                         Use the NLA_POLICY_MIN(), NLA_POLICY_MAX() and
 296  *                         NLA_POLICY_RANGE() macros.
 297  *    NLA_UINT,
 298  *    NLA_U8,
 299  *    NLA_U16,
 300  *    NLA_U32,
 301  *    NLA_U64              If the validation_type field instead is set to
 302  *                         NLA_VALIDATE_RANGE_PTR, `range' must be a pointer
 303  *                         to a struct netlink_range_validation that indicates
 304  *                         the min/max values.
 305  *                         Use NLA_POLICY_FULL_RANGE().
 306  *    NLA_SINT,
 307  *    NLA_S8,
 308  *    NLA_S16,
 309  *    NLA_S32,
 310  *    NLA_S64              If the validation_type field instead is set to
 311  *                         NLA_VALIDATE_RANGE_PTR, `range_signed' must be a
 312  *                         pointer to a struct netlink_range_validation_signed
 313  *                         that indicates the min/max values.
 314  *                         Use NLA_POLICY_FULL_RANGE_SIGNED().
 315  *
 316  *    NLA_BINARY           If the validation type is like the ones for integers
 317  *                         above, then the min/max length (not value like for
 318  *                         integers) of the attribute is enforced.
 319  *
 320  *    All other            Unused - but note that it's a union
 321  *
 322  * Meaning of `validate' field, use via NLA_POLICY_VALIDATE_FN:
 323  *    NLA_BINARY           Validation function called for the attribute.
 324  *    All other            Unused - but note that it's a union
 325  *
 326  * Example:
 327  *
 328  * static const u32 myvalidflags = 0xff231023;
 329  *
 330  * static const struct nla_policy my_policy[ATTR_MAX+1] = {
 331  *      [ATTR_FOO] = { .type = NLA_U16 },
 332  *      [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
 333  *      [ATTR_BAZ] = NLA_POLICY_EXACT_LEN(sizeof(struct mystruct)),
 334  *      [ATTR_GOO] = NLA_POLICY_BITFIELD32(myvalidflags),
 335  * };
 336  */
 337 struct nla_policy {
 338         u8              type;
 339         u8              validation_type;
 340         u16             len;
 341         union {
 342                 /**
 343                  * @strict_start_type: first attribute to validate strictly
 344                  *
 345                  * This entry is special, and used for the attribute at index 0
 346                  * only, and specifies special data about the policy, namely it
 347                  * specifies the "boundary type" where strict length validation
 348                  * starts for any attribute types >= this value, also, strict
 349                  * nesting validation starts here.
 350                  *
 351                  * Additionally, it means that NLA_UNSPEC is actually NLA_REJECT
 352                  * for any types >= this, so need to use NLA_POLICY_MIN_LEN() to
 353                  * get the previous pure { .len = xyz } behaviour. The advantage
 354                  * of this is that types not specified in the policy will be
 355                  * rejected.
 356                  *
 357                  * For completely new families it should be set to 1 so that the
 358                  * validation is enforced for all attributes. For existing ones
 359                  * it should be set at least when new attributes are added to
 360                  * the enum used by the policy, and be set to the new value that
 361                  * was added to enforce strict validation from thereon.
 362                  */
 363                 u16 strict_start_type;
 364
 365                 /* private: use NLA_POLICY_*() to set */
 366                 const u32 bitfield32_valid;
 367                 const u32 mask;
 368                 const char *reject_message;
 369                 const struct nla_policy *nested_policy;
 370                 const struct netlink_range_validation *range;
 371                 const struct netlink_range_validation_signed *range_signed;
 372                 struct {
 373                         s16 min, max;
 374                 };
 375                 int (*validate)(const struct nlattr *attr,
 376                                 struct netlink_ext_ack *extack);
 377         };
 378 };
 379
 380 #define NLA_POLICY_ETH_ADDR             NLA_POLICY_EXACT_LEN(ETH_ALEN)
 381 #define NLA_POLICY_ETH_ADDR_COMPAT      NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN)
 382
 383 #define _NLA_POLICY_NESTED(maxattr, policy) \
 384         { .type = NLA_NESTED, .nested_policy = policy, .len = maxattr }
 385 #define _NLA_POLICY_NESTED_ARRAY(maxattr, policy) \
 386         { .type = NLA_NESTED_ARRAY, .nested_policy = policy, .len = maxattr }
 387 #define NLA_POLICY_NESTED(policy) \
 388         _NLA_POLICY_NESTED(ARRAY_SIZE(policy) - 1, policy)
 389 #define NLA_POLICY_NESTED_ARRAY(policy) \
 390         _NLA_POLICY_NESTED_ARRAY(ARRAY_SIZE(policy) - 1, policy)
 391 #define NLA_POLICY_BITFIELD32(valid) \
 392         { .type = NLA_BITFIELD32, .bitfield32_valid = valid }
 393
 394 #define __NLA_IS_UINT_TYPE(tp)                                  \
 395         (tp == NLA_U8 || tp == NLA_U16 || tp == NLA_U32 ||      \
 396          tp == NLA_U64 || tp == NLA_UINT ||                     \
 397          tp == NLA_BE16 || tp == NLA_BE32)
 398 #define __NLA_IS_SINT_TYPE(tp)                                          \
 399         (tp == NLA_S8 || tp == NLA_S16 || tp == NLA_S32 || tp == NLA_S64 || \
 400          tp == NLA_SINT)
 401
 402 #define __NLA_ENSURE(condition) BUILD_BUG_ON_ZERO(!(condition))
 403 #define NLA_ENSURE_UINT_TYPE(tp)                        \
 404         (__NLA_ENSURE(__NLA_IS_UINT_TYPE(tp)) + tp)
 405 #define NLA_ENSURE_UINT_OR_BINARY_TYPE(tp)              \
 406         (__NLA_ENSURE(__NLA_IS_UINT_TYPE(tp) || \
 407                       tp == NLA_MSECS ||                \
 408                       tp == NLA_BINARY) + tp)
 409 #define NLA_ENSURE_SINT_TYPE(tp)                        \
 410         (__NLA_ENSURE(__NLA_IS_SINT_TYPE(tp)) + tp)
 411 #define NLA_ENSURE_INT_OR_BINARY_TYPE(tp)               \
 412         (__NLA_ENSURE(__NLA_IS_UINT_TYPE(tp) ||         \
 413                       __NLA_IS_SINT_TYPE(tp) ||         \
 414                       tp == NLA_MSECS ||                \
 415                       tp == NLA_BINARY) + tp)
 416 #define NLA_ENSURE_NO_VALIDATION_PTR(tp)                \
 417         (__NLA_ENSURE(tp != NLA_BITFIELD32 &&           \
 418                       tp != NLA_REJECT &&               \
 419                       tp != NLA_NESTED &&               \
 420                       tp != NLA_NESTED_ARRAY) + tp)
 421
 422 #define NLA_POLICY_RANGE(tp, _min, _max) {              \
 423         .type = NLA_ENSURE_INT_OR_BINARY_TYPE(tp),      \
 424         .validation_type = NLA_VALIDATE_RANGE,          \
 425         .min = _min,                                    \
 426         .max = _max                                     \
 427 }
 428
 429 #define NLA_POLICY_FULL_RANGE(tp, _range) {             \
 430         .type = NLA_ENSURE_UINT_OR_BINARY_TYPE(tp),     \
 431         .validation_type = NLA_VALIDATE_RANGE_PTR,      \
 432         .range = _range,                                \
 433 }
 434
 435 #define NLA_POLICY_FULL_RANGE_SIGNED(tp, _range) {      \
 436         .type = NLA_ENSURE_SINT_TYPE(tp),               \
 437         .validation_type = NLA_VALIDATE_RANGE_PTR,      \
 438         .range_signed = _range,                         \
 439 }
 440
 441 #define NLA_POLICY_MIN(tp, _min) {                      \
 442         .type = NLA_ENSURE_INT_OR_BINARY_TYPE(tp),      \
 443         .validation_type = NLA_VALIDATE_MIN,            \
 444         .min = _min,                                    \
 445 }
 446
 447 #define NLA_POLICY_MAX(tp, _max) {                      \
 448         .type = NLA_ENSURE_INT_OR_BINARY_TYPE(tp),      \
 449         .validation_type = NLA_VALIDATE_MAX,            \
 450         .max = _max,                                    \
 451 }
 452
 453 #define NLA_POLICY_MASK(tp, _mask) {                    \
 454         .type = NLA_ENSURE_UINT_TYPE(tp),               \
 455         .validation_type = NLA_VALIDATE_MASK,           \
 456         .mask = _mask,                                  \
 457 }
 458
 459 #define NLA_POLICY_VALIDATE_FN(tp, fn, ...) {           \
 460         .type = NLA_ENSURE_NO_VALIDATION_PTR(tp),       \
 461         .validation_type = NLA_VALIDATE_FUNCTION,       \
 462         .validate = fn,                                 \
 463         .len = __VA_ARGS__ + 0,                         \
 464 }
 465
 466 #define NLA_POLICY_EXACT_LEN(_len)      NLA_POLICY_RANGE(NLA_BINARY, _len, _len)
 467 #define NLA_POLICY_EXACT_LEN_WARN(_len) {                       \
 468         .type = NLA_BINARY,                                     \
 469         .validation_type = NLA_VALIDATE_RANGE_WARN_TOO_LONG,    \
 470         .min = _len,                                            \
 471         .max = _len                                             \
 472 }
 473 #define NLA_POLICY_MIN_LEN(_len)        NLA_POLICY_MIN(NLA_BINARY, _len)
 474 #define NLA_POLICY_MAX_LEN(_len)        NLA_POLICY_MAX(NLA_BINARY, _len)
 475
 476 /**
 477  * struct nl_info - netlink source information
 478  * @nlh: Netlink message header of original request
 479  * @nl_net: Network namespace
 480  * @portid: Netlink PORTID of requesting application
 481  * @skip_notify: Skip netlink notifications to user space
 482  * @skip_notify_kernel: Skip selected in-kernel notifications
 483  */
 484 struct nl_info {
 485         struct nlmsghdr         *nlh;
 486         struct net              *nl_net;
 487         u32                     portid;
 488         u8                      skip_notify:1,
 489                                 skip_notify_kernel:1;
 490 };
 491
 492 /**
 493  * enum netlink_validation - netlink message/attribute validation levels
 494  * @NL_VALIDATE_LIBERAL: Old-style "be liberal" validation, not caring about
 495  *      extra data at the end of the message, attributes being longer than
 496  *      they should be, or unknown attributes being present.
 497  * @NL_VALIDATE_TRAILING: Reject junk data encountered after attribute parsing.
 498  * @NL_VALIDATE_MAXTYPE: Reject attributes > max type; Together with _TRAILING
 499  *      this is equivalent to the old nla_parse_strict()/nlmsg_parse_strict().
 500  * @NL_VALIDATE_UNSPEC: Reject attributes with NLA_UNSPEC in the policy.
 501  *      This can safely be set by the kernel when the given policy has no
 502  *      NLA_UNSPEC anymore, and can thus be used to ensure policy entries
 503  *      are enforced going forward.
 504  * @NL_VALIDATE_STRICT_ATTRS: strict attribute policy parsing (e.g.
 505  *      U8, U16, U32 must have exact size, etc.)
 506  * @NL_VALIDATE_NESTED: Check that NLA_F_NESTED is set for NLA_NESTED(_ARRAY)
 507  *      and unset for other policies.
 508  */
 509 enum netlink_validation {
 510         NL_VALIDATE_LIBERAL = 0,
 511         NL_VALIDATE_TRAILING = BIT(0),
 512         NL_VALIDATE_MAXTYPE = BIT(1),
 513         NL_VALIDATE_UNSPEC = BIT(2),
 514         NL_VALIDATE_STRICT_ATTRS = BIT(3),
 515         NL_VALIDATE_NESTED = BIT(4),
 516 };
 517
 518 #define NL_VALIDATE_DEPRECATED_STRICT (NL_VALIDATE_TRAILING |\
 519                                        NL_VALIDATE_MAXTYPE)
 520 #define NL_VALIDATE_STRICT (NL_VALIDATE_TRAILING |\
 521                             NL_VALIDATE_MAXTYPE |\
 522                             NL_VALIDATE_UNSPEC |\
 523                             NL_VALIDATE_STRICT_ATTRS |\
 524                             NL_VALIDATE_NESTED)
 525
 526 int netlink_rcv_skb(struct sk_buff *skb,
 527                     int (*cb)(struct sk_buff *, struct nlmsghdr *,
 528                               struct netlink_ext_ack *));
 529 int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
 530                  unsigned int group, int report, gfp_t flags);
 531
 532 int __nla_validate(const struct nlattr *head, int len, int maxtype,
 533                    const struct nla_policy *policy, unsigned int validate,
 534                    struct netlink_ext_ack *extack);
 535 int __nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
 536                 int len, const struct nla_policy *policy, unsigned int validate,
 537                 struct netlink_ext_ack *extack);
 538 int nla_policy_len(const struct nla_policy *, int);
 539 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
 540 ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize);
 541 char *nla_strdup(const struct nlattr *nla, gfp_t flags);
 542 int nla_memcpy(void *dest, const struct nlattr *src, int count);
 543 int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
 544 int nla_strcmp(const struct nlattr *nla, const char *str);
 545 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
 546 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
 547                                    int attrlen, int padattr);
 548 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
 549 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
 550 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
 551                                  int attrlen, int padattr);
 552 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
 553 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
 554                const void *data);
 555 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
 556                      const void *data, int padattr);
 557 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
 558 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
 559 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
 560                   const void *data, int padattr);
 561 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
 562 int nla_append(struct sk_buff *skb, int attrlen, const void *data);
 563
 564 /**************************************************************************
 565  * Netlink Messages
 566  **************************************************************************/
 567
 568 /**
 569  * nlmsg_msg_size - length of netlink message not including padding
 570  * @payload: length of message payload
 571  */
 572 static inline int nlmsg_msg_size(int payload)
 573 {
 574         return NLMSG_HDRLEN + payload;
 575 }
 576
 577 /**
 578  * nlmsg_total_size - length of netlink message including padding
 579  * @payload: length of message payload
 580  */
 581 static inline int nlmsg_total_size(int payload)
 582 {
 583         return NLMSG_ALIGN(nlmsg_msg_size(payload));
 584 }
 585
 586 /**
 587  * nlmsg_padlen - length of padding at the message's tail
 588  * @payload: length of message payload
 589  */
 590 static inline int nlmsg_padlen(int payload)
 591 {
 592         return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
 593 }
 594
 595 /**
 596  * nlmsg_data - head of message payload
 597  * @nlh: netlink message header
 598  */
 599 static inline void *nlmsg_data(const struct nlmsghdr *nlh)
 600 {
 601         return (unsigned char *) nlh + NLMSG_HDRLEN;
 602 }
 603
 604 /**
 605  * nlmsg_len - length of message payload
 606  * @nlh: netlink message header
 607  */
 608 static inline int nlmsg_len(const struct nlmsghdr *nlh)
 609 {
 610         return nlh->nlmsg_len - NLMSG_HDRLEN;
 611 }
 612
 613 /**
 614  * nlmsg_attrdata - head of attributes data
 615  * @nlh: netlink message header
 616  * @hdrlen: length of family specific header
 617  */
 618 static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
 619                                             int hdrlen)
 620 {
 621         unsigned char *data = nlmsg_data(nlh);
 622         return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
 623 }
 624
 625 /**
 626  * nlmsg_attrlen - length of attributes data
 627  * @nlh: netlink message header
 628  * @hdrlen: length of family specific header
 629  */
 630 static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
 631 {
 632         return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
 633 }
 634
 635 /**
 636  * nlmsg_ok - check if the netlink message fits into the remaining bytes
 637  * @nlh: netlink message header
 638  * @remaining: number of bytes remaining in message stream
 639  */
 640 static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
 641 {
 642         return (remaining >= (int) sizeof(struct nlmsghdr) &&
 643                 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
 644                 nlh->nlmsg_len <= remaining);
 645 }
 646
 647 /**
 648  * nlmsg_next - next netlink message in message stream
 649  * @nlh: netlink message header
 650  * @remaining: number of bytes remaining in message stream
 651  *
 652  * Returns the next netlink message in the message stream and
 653  * decrements remaining by the size of the current message.
 654  */
 655 static inline struct nlmsghdr *
 656 nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
 657 {
 658         int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
 659
 660         *remaining -= totlen;
 661
 662         return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
 663 }
 664
 665 /**
 666  * nla_parse - Parse a stream of attributes into a tb buffer
 667  * @tb: destination array with maxtype+1 elements
 668  * @maxtype: maximum attribute type to be expected
 669  * @head: head of attribute stream
 670  * @len: length of attribute stream
 671  * @policy: validation policy
 672  * @extack: extended ACK pointer
 673  *
 674  * Parses a stream of attributes and stores a pointer to each attribute in
 675  * the tb array accessible via the attribute type. Attributes with a type
 676  * exceeding maxtype will be rejected, policy must be specified, attributes
 677  * will be validated in the strictest way possible.
 678  *
 679  * Returns 0 on success or a negative error code.
 680  */
 681 static inline int nla_parse(struct nlattr **tb, int maxtype,
 682                             const struct nlattr *head, int len,
 683                             const struct nla_policy *policy,
 684                             struct netlink_ext_ack *extack)
 685 {
 686         return __nla_parse(tb, maxtype, head, len, policy,
 687                            NL_VALIDATE_STRICT, extack);
 688 }
 689
 690 /**
 691  * nla_parse_deprecated - Parse a stream of attributes into a tb buffer
 692  * @tb: destination array with maxtype+1 elements
 693  * @maxtype: maximum attribute type to be expected
 694  * @head: head of attribute stream
 695  * @len: length of attribute stream
 696  * @policy: validation policy
 697  * @extack: extended ACK pointer
 698  *
 699  * Parses a stream of attributes and stores a pointer to each attribute in
 700  * the tb array accessible via the attribute type. Attributes with a type
 701  * exceeding maxtype will be ignored and attributes from the policy are not
 702  * always strictly validated (only for new attributes).
 703  *
 704  * Returns 0 on success or a negative error code.
 705  */
 706 static inline int nla_parse_deprecated(struct nlattr **tb, int maxtype,
 707                                        const struct nlattr *head, int len,
 708                                        const struct nla_policy *policy,
 709                                        struct netlink_ext_ack *extack)
 710 {
 711         return __nla_parse(tb, maxtype, head, len, policy,
 712                            NL_VALIDATE_LIBERAL, extack);
 713 }
 714
 715 /**
 716  * nla_parse_deprecated_strict - Parse a stream of attributes into a tb buffer
 717  * @tb: destination array with maxtype+1 elements
 718  * @maxtype: maximum attribute type to be expected
 719  * @head: head of attribute stream
 720  * @len: length of attribute stream
 721  * @policy: validation policy
 722  * @extack: extended ACK pointer
 723  *
 724  * Parses a stream of attributes and stores a pointer to each attribute in
 725  * the tb array accessible via the attribute type. Attributes with a type
 726  * exceeding maxtype will be rejected as well as trailing data, but the
 727  * policy is not completely strictly validated (only for new attributes).
 728  *
 729  * Returns 0 on success or a negative error code.
 730  */
 731 static inline int nla_parse_deprecated_strict(struct nlattr **tb, int maxtype,
 732                                               const struct nlattr *head,
 733                                               int len,
 734                                               const struct nla_policy *policy,
 735                                               struct netlink_ext_ack *extack)
 736 {
 737         return __nla_parse(tb, maxtype, head, len, policy,
 738                            NL_VALIDATE_DEPRECATED_STRICT, extack);
 739 }
 740
 741 /**
 742  * __nlmsg_parse - parse attributes of a netlink message
 743  * @nlh: netlink message header
 744  * @hdrlen: length of family specific header
 745  * @tb: destination array with maxtype+1 elements
 746  * @maxtype: maximum attribute type to be expected
 747  * @policy: validation policy
 748  * @validate: validation strictness
 749  * @extack: extended ACK report struct
 750  *
 751  * See nla_parse()
 752  */
 753 static inline int __nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
 754                                 struct nlattr *tb[], int maxtype,
 755                                 const struct nla_policy *policy,
 756                                 unsigned int validate,
 757                                 struct netlink_ext_ack *extack)
 758 {
 759         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) {
 760                 NL_SET_ERR_MSG(extack, "Invalid header length");
 761                 return -EINVAL;
 762         }
 763
 764         return __nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
 765                            nlmsg_attrlen(nlh, hdrlen), policy, validate,
 766                            extack);
 767 }
 768
 769 /**
 770  * nlmsg_parse - parse attributes of a netlink message
 771  * @nlh: netlink message header
 772  * @hdrlen: length of family specific header
 773  * @tb: destination array with maxtype+1 elements
 774  * @maxtype: maximum attribute type to be expected
 775  * @policy: validation policy
 776  * @extack: extended ACK report struct
 777  *
 778  * See nla_parse()
 779  */
 780 static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
 781                               struct nlattr *tb[], int maxtype,
 782                               const struct nla_policy *policy,
 783                               struct netlink_ext_ack *extack)
 784 {
 785         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
 786                              NL_VALIDATE_STRICT, extack);
 787 }
 788
 789 /**
 790  * nlmsg_parse_deprecated - parse attributes of a netlink message
 791  * @nlh: netlink message header
 792  * @hdrlen: length of family specific header
 793  * @tb: destination array with maxtype+1 elements
 794  * @maxtype: maximum attribute type to be expected
 795  * @policy: validation policy
 796  * @extack: extended ACK report struct
 797  *
 798  * See nla_parse_deprecated()
 799  */
 800 static inline int nlmsg_parse_deprecated(const struct nlmsghdr *nlh, int hdrlen,
 801                                          struct nlattr *tb[], int maxtype,
 802                                          const struct nla_policy *policy,
 803                                          struct netlink_ext_ack *extack)
 804 {
 805         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
 806                              NL_VALIDATE_LIBERAL, extack);
 807 }
 808
 809 /**
 810  * nlmsg_parse_deprecated_strict - parse attributes of a netlink message
 811  * @nlh: netlink message header
 812  * @hdrlen: length of family specific header
 813  * @tb: destination array with maxtype+1 elements
 814  * @maxtype: maximum attribute type to be expected
 815  * @policy: validation policy
 816  * @extack: extended ACK report struct
 817  *
 818  * See nla_parse_deprecated_strict()
 819  */
 820 static inline int
 821 nlmsg_parse_deprecated_strict(const struct nlmsghdr *nlh, int hdrlen,
 822                               struct nlattr *tb[], int maxtype,
 823                               const struct nla_policy *policy,
 824                               struct netlink_ext_ack *extack)
 825 {
 826         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
 827                              NL_VALIDATE_DEPRECATED_STRICT, extack);
 828 }
 829
 830 /**
 831  * nlmsg_find_attr - find a specific attribute in a netlink message
 832  * @nlh: netlink message header
 833  * @hdrlen: length of family specific header
 834  * @attrtype: type of attribute to look for
 835  *
 836  * Returns the first attribute which matches the specified type.
 837  */
 838 static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
 839                                              int hdrlen, int attrtype)
 840 {
 841         return nla_find(nlmsg_attrdata(nlh, hdrlen),
 842                         nlmsg_attrlen(nlh, hdrlen), attrtype);
 843 }
 844
 845 /**
 846  * nla_validate_deprecated - Validate a stream of attributes
 847  * @head: head of attribute stream
 848  * @len: length of attribute stream
 849  * @maxtype: maximum attribute type to be expected
 850  * @policy: validation policy
 851  * @extack: extended ACK report struct
 852  *
 853  * Validates all attributes in the specified attribute stream against the
 854  * specified policy. Validation is done in liberal mode.
 855  * See documentation of struct nla_policy for more details.
 856  *
 857  * Returns 0 on success or a negative error code.
 858  */
 859 static inline int nla_validate_deprecated(const struct nlattr *head, int len,
 860                                           int maxtype,
 861                                           const struct nla_policy *policy,
 862                                           struct netlink_ext_ack *extack)
 863 {
 864         return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_LIBERAL,
 865                               extack);
 866 }
 867
 868 /**
 869  * nla_validate - Validate a stream of attributes
 870  * @head: head of attribute stream
 871  * @len: length of attribute stream
 872  * @maxtype: maximum attribute type to be expected
 873  * @policy: validation policy
 874  * @extack: extended ACK report struct
 875  *
 876  * Validates all attributes in the specified attribute stream against the
 877  * specified policy. Validation is done in strict mode.
 878  * See documentation of struct nla_policy for more details.
 879  *
 880  * Returns 0 on success or a negative error code.
 881  */
 882 static inline int nla_validate(const struct nlattr *head, int len, int maxtype,
 883                                const struct nla_policy *policy,
 884                                struct netlink_ext_ack *extack)
 885 {
 886         return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_STRICT,
 887                               extack);
 888 }
 889
 890 /**
 891  * nlmsg_validate_deprecated - validate a netlink message including attributes
 892  * @nlh: netlinket message header
 893  * @hdrlen: length of family specific header
 894  * @maxtype: maximum attribute type to be expected
 895  * @policy: validation policy
 896  * @extack: extended ACK report struct
 897  */
 898 static inline int nlmsg_validate_deprecated(const struct nlmsghdr *nlh,
 899                                             int hdrlen, int maxtype,
 900                                             const struct nla_policy *policy,
 901                                             struct netlink_ext_ack *extack)
 902 {
 903         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
 904                 return -EINVAL;
 905
 906         return __nla_validate(nlmsg_attrdata(nlh, hdrlen),
 907                               nlmsg_attrlen(nlh, hdrlen), maxtype,
 908                               policy, NL_VALIDATE_LIBERAL, extack);
 909 }
 910
 911
 912
 913 /**
 914  * nlmsg_report - need to report back to application?
 915  * @nlh: netlink message header
 916  *
 917  * Returns 1 if a report back to the application is requested.
 918  */
 919 static inline int nlmsg_report(const struct nlmsghdr *nlh)
 920 {
 921         return nlh ? !!(nlh->nlmsg_flags & NLM_F_ECHO) : 0;
 922 }
 923
 924 /**
 925  * nlmsg_seq - return the seq number of netlink message
 926  * @nlh: netlink message header
 927  *
 928  * Returns 0 if netlink message is NULL
 929  */
 930 static inline u32 nlmsg_seq(const struct nlmsghdr *nlh)
 931 {
 932         return nlh ? nlh->nlmsg_seq : 0;
 933 }
 934
 935 /**
 936  * nlmsg_for_each_attr - iterate over a stream of attributes
 937  * @pos: loop counter, set to current attribute
 938  * @nlh: netlink message header
 939  * @hdrlen: length of family specific header
 940  * @rem: initialized to len, holds bytes currently remaining in stream
 941  */
 942 #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
 943         nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
 944                           nlmsg_attrlen(nlh, hdrlen), rem)
 945
 946 /**
 947  * nlmsg_put - Add a new netlink message to an skb
 948  * @skb: socket buffer to store message in
 949  * @portid: netlink PORTID of requesting application
 950  * @seq: sequence number of message
 951  * @type: message type
 952  * @payload: length of message payload
 953  * @flags: message flags
 954  *
 955  * Returns NULL if the tailroom of the skb is insufficient to store
 956  * the message header and payload.
 957  */
 958 static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
 959                                          int type, int payload, int flags)
 960 {
 961         if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
 962                 return NULL;
 963
 964         return __nlmsg_put(skb, portid, seq, type, payload, flags);
 965 }
 966
 967 /**
 968  * nlmsg_append - Add more data to a nlmsg in a skb
 969  * @skb: socket buffer to store message in
 970  * @size: length of message payload
 971  *
 972  * Append data to an existing nlmsg, used when constructing a message
 973  * with multiple fixed-format headers (which is rare).
 974  * Returns NULL if the tailroom of the skb is insufficient to store
 975  * the extra payload.
 976  */
 977 static inline void *nlmsg_append(struct sk_buff *skb, u32 size)
 978 {
 979         if (unlikely(skb_tailroom(skb) < NLMSG_ALIGN(size)))
 980                 return NULL;
 981
 982         if (NLMSG_ALIGN(size) - size)
 983                 memset(skb_tail_pointer(skb) + size, 0,
 984                        NLMSG_ALIGN(size) - size);
 985         return __skb_put(skb, NLMSG_ALIGN(size));
 986 }
 987
 988 /**
 989  * nlmsg_put_answer - Add a new callback based netlink message to an skb
 990  * @skb: socket buffer to store message in
 991  * @cb: netlink callback
 992  * @type: message type
 993  * @payload: length of message payload
 994  * @flags: message flags
 995  *
 996  * Returns NULL if the tailroom of the skb is insufficient to store
 997  * the message header and payload.
 998  */
 999 static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
1000                                                 struct netlink_callback *cb,
1001                                                 int type, int payload,
1002                                                 int flags)
1003 {
1004         return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
1005                          type, payload, flags);
1006 }
1007
1008 /**
1009  * nlmsg_new - Allocate a new netlink message
1010  * @payload: size of the message payload
1011  * @flags: the type of memory to allocate.
1012  *
1013  * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
1014  * and a good default is needed.
1015  */
1016 static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
1017 {
1018         return alloc_skb(nlmsg_total_size(payload), flags);
1019 }
1020
1021 /**
1022  * nlmsg_new_large - Allocate a new netlink message with non-contiguous
1023  * physical memory
1024  * @payload: size of the message payload
1025  *
1026  * The allocated skb is unable to have frag page for shinfo->frags*,
1027  * as the NULL setting for skb->head in netlink_skb_destructor() will
1028  * bypass most of the handling in skb_release_data()
1029  */
1030 static inline struct sk_buff *nlmsg_new_large(size_t payload)
1031 {
1032         return netlink_alloc_large_skb(nlmsg_total_size(payload), 0);
1033 }
1034
1035 /**
1036  * nlmsg_end - Finalize a netlink message
1037  * @skb: socket buffer the message is stored in
1038  * @nlh: netlink message header
1039  *
1040  * Corrects the netlink message header to include the appended
1041  * attributes. Only necessary if attributes have been added to
1042  * the message.
1043  */
1044 static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
1045 {
1046         nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
1047 }
1048
1049 /**
1050  * nlmsg_get_pos - return current position in netlink message
1051  * @skb: socket buffer the message is stored in
1052  *
1053  * Returns a pointer to the current tail of the message.
1054  */
1055 static inline void *nlmsg_get_pos(struct sk_buff *skb)
1056 {
1057         return skb_tail_pointer(skb);
1058 }
1059
1060 /**
1061  * nlmsg_trim - Trim message to a mark
1062  * @skb: socket buffer the message is stored in
1063  * @mark: mark to trim to
1064  *
1065  * Trims the message to the provided mark.
1066  */
1067 static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
1068 {
1069         if (mark) {
1070                 WARN_ON((unsigned char *) mark < skb->data);
1071                 skb_trim(skb, (unsigned char *) mark - skb->data);
1072         }
1073 }
1074
1075 /**
1076  * nlmsg_cancel - Cancel construction of a netlink message
1077  * @skb: socket buffer the message is stored in
1078  * @nlh: netlink message header
1079  *
1080  * Removes the complete netlink message including all
1081  * attributes from the socket buffer again.
1082  */
1083 static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
1084 {
1085         nlmsg_trim(skb, nlh);
1086 }
1087
1088 /**
1089  * nlmsg_free - drop a netlink message
1090  * @skb: socket buffer of netlink message
1091  */
1092 static inline void nlmsg_free(struct sk_buff *skb)
1093 {
1094         kfree_skb(skb);
1095 }
1096
1097 /**
1098  * nlmsg_consume - free a netlink message
1099  * @skb: socket buffer of netlink message
1100  */
1101 static inline void nlmsg_consume(struct sk_buff *skb)
1102 {
1103         consume_skb(skb);
1104 }
1105
1106 /**
1107  * nlmsg_multicast_filtered - multicast a netlink message with filter function
1108  * @sk: netlink socket to spread messages to
1109  * @skb: netlink message as socket buffer
1110  * @portid: own netlink portid to avoid sending to yourself
1111  * @group: multicast group id
1112  * @flags: allocation flags
1113  * @filter: filter function
1114  * @filter_data: filter function private data
1115  *
1116  * Return: 0 on success, negative error code for failure.
1117  */
1118 static inline int nlmsg_multicast_filtered(struct sock *sk, struct sk_buff *skb,
1119                                            u32 portid, unsigned int group,
1120                                            gfp_t flags,
1121                                            netlink_filter_fn filter,
1122                                            void *filter_data)
1123 {
1124         int err;
1125
1126         NETLINK_CB(skb).dst_group = group;
1127
1128         err = netlink_broadcast_filtered(sk, skb, portid, group, flags,
1129                                          filter, filter_data);
1130         if (err > 0)
1131                 err = 0;
1132
1133         return err;
1134 }
1135
1136 /**
1137  * nlmsg_multicast - multicast a netlink message
1138  * @sk: netlink socket to spread messages to
1139  * @skb: netlink message as socket buffer
1140  * @portid: own netlink portid to avoid sending to yourself
1141  * @group: multicast group id
1142  * @flags: allocation flags
1143  */
1144 static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
1145                                   u32 portid, unsigned int group, gfp_t flags)
1146 {
1147         return nlmsg_multicast_filtered(sk, skb, portid, group, flags,
1148                                         NULL, NULL);
1149 }
1150
1151 /**
1152  * nlmsg_unicast - unicast a netlink message
1153  * @sk: netlink socket to spread message to
1154  * @skb: netlink message as socket buffer
1155  * @portid: netlink portid of the destination socket
1156  */
1157 static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
1158 {
1159         int err;
1160
1161         err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
1162         if (err > 0)
1163                 err = 0;
1164
1165         return err;
1166 }
1167
1168 /**
1169  * nlmsg_for_each_msg - iterate over a stream of messages
1170  * @pos: loop counter, set to current message
1171  * @head: head of message stream
1172  * @len: length of message stream
1173  * @rem: initialized to len, holds bytes currently remaining in stream
1174  */
1175 #define nlmsg_for_each_msg(pos, head, len, rem) \
1176         for (pos = head, rem = len; \
1177              nlmsg_ok(pos, rem); \
1178              pos = nlmsg_next(pos, &(rem)))
1179
1180 /**
1181  * nl_dump_check_consistent - check if sequence is consistent and advertise if not
1182  * @cb: netlink callback structure that stores the sequence number
1183  * @nlh: netlink message header to write the flag to
1184  *
1185  * This function checks if the sequence (generation) number changed during dump
1186  * and if it did, advertises it in the netlink message header.
1187  *
1188  * The correct way to use it is to set cb->seq to the generation counter when
1189  * all locks for dumping have been acquired, and then call this function for
1190  * each message that is generated.
1191  *
1192  * Note that due to initialisation concerns, 0 is an invalid sequence number
1193  * and must not be used by code that uses this functionality.
1194  */
1195 static inline void
1196 nl_dump_check_consistent(struct netlink_callback *cb,
1197                          struct nlmsghdr *nlh)
1198 {
1199         if (cb->prev_seq && cb->seq != cb->prev_seq)
1200                 nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
1201         cb->prev_seq = cb->seq;
1202 }
1203
1204 /**************************************************************************
1205  * Netlink Attributes
1206  **************************************************************************/
1207
1208 /**
1209  * nla_attr_size - length of attribute not including padding
1210  * @payload: length of payload
1211  */
1212 static inline int nla_attr_size(int payload)
1213 {
1214         return NLA_HDRLEN + payload;
1215 }
1216
1217 /**
1218  * nla_total_size - total length of attribute including padding
1219  * @payload: length of payload
1220  */
1221 static inline int nla_total_size(int payload)
1222 {
1223         return NLA_ALIGN(nla_attr_size(payload));
1224 }
1225
1226 /**
1227  * nla_padlen - length of padding at the tail of attribute
1228  * @payload: length of payload
1229  */
1230 static inline int nla_padlen(int payload)
1231 {
1232         return nla_total_size(payload) - nla_attr_size(payload);
1233 }
1234
1235 /**
1236  * nla_type - attribute type
1237  * @nla: netlink attribute
1238  */
1239 static inline int nla_type(const struct nlattr *nla)
1240 {
1241         return nla->nla_type & NLA_TYPE_MASK;
1242 }
1243
1244 /**
1245  * nla_data - head of payload
1246  * @nla: netlink attribute
1247  */
1248 static inline void *nla_data(const struct nlattr *nla)
1249 {
1250         return (char *) nla + NLA_HDRLEN;
1251 }
1252
1253 /**
1254  * nla_len - length of payload
1255  * @nla: netlink attribute
1256  */
1257 static inline u16 nla_len(const struct nlattr *nla)
1258 {
1259         return nla->nla_len - NLA_HDRLEN;
1260 }
1261
1262 /**
1263  * nla_ok - check if the netlink attribute fits into the remaining bytes
1264  * @nla: netlink attribute
1265  * @remaining: number of bytes remaining in attribute stream
1266  */
1267 static inline int nla_ok(const struct nlattr *nla, int remaining)
1268 {
1269         return remaining >= (int) sizeof(*nla) &&
1270                nla->nla_len >= sizeof(*nla) &&
1271                nla->nla_len <= remaining;
1272 }
1273
1274 /**
1275  * nla_next - next netlink attribute in attribute stream
1276  * @nla: netlink attribute
1277  * @remaining: number of bytes remaining in attribute stream
1278  *
1279  * Returns the next netlink attribute in the attribute stream and
1280  * decrements remaining by the size of the current attribute.
1281  */
1282 static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
1283 {
1284         unsigned int totlen = NLA_ALIGN(nla->nla_len);
1285
1286         *remaining -= totlen;
1287         return (struct nlattr *) ((char *) nla + totlen);
1288 }
1289
1290 /**
1291  * nla_find_nested - find attribute in a set of nested attributes
1292  * @nla: attribute containing the nested attributes
1293  * @attrtype: type of attribute to look for
1294  *
1295  * Returns the first attribute which matches the specified type.
1296  */
1297 static inline struct nlattr *
1298 nla_find_nested(const struct nlattr *nla, int attrtype)
1299 {
1300         return nla_find(nla_data(nla), nla_len(nla), attrtype);
1301 }
1302
1303 /**
1304  * nla_parse_nested - parse nested attributes
1305  * @tb: destination array with maxtype+1 elements
1306  * @maxtype: maximum attribute type to be expected
1307  * @nla: attribute containing the nested attributes
1308  * @policy: validation policy
1309  * @extack: extended ACK report struct
1310  *
1311  * See nla_parse()
1312  */
1313 static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
1314                                    const struct nlattr *nla,
1315                                    const struct nla_policy *policy,
1316                                    struct netlink_ext_ack *extack)
1317 {
1318         if (!(nla->nla_type & NLA_F_NESTED)) {
1319                 NL_SET_ERR_MSG_ATTR(extack, nla, "NLA_F_NESTED is missing");
1320                 return -EINVAL;
1321         }
1322
1323         return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1324                            NL_VALIDATE_STRICT, extack);
1325 }
1326
1327 /**
1328  * nla_parse_nested_deprecated - parse nested attributes
1329  * @tb: destination array with maxtype+1 elements
1330  * @maxtype: maximum attribute type to be expected
1331  * @nla: attribute containing the nested attributes
1332  * @policy: validation policy
1333  * @extack: extended ACK report struct
1334  *
1335  * See nla_parse_deprecated()
1336  */
1337 static inline int nla_parse_nested_deprecated(struct nlattr *tb[], int maxtype,
1338                                               const struct nlattr *nla,
1339                                               const struct nla_policy *policy,
1340                                               struct netlink_ext_ack *extack)
1341 {
1342         return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
1343                            NL_VALIDATE_LIBERAL, extack);
1344 }
1345
1346 /**
1347  * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
1348  * @skb: socket buffer to add attribute to
1349  * @attrtype: attribute type
1350  * @value: numeric value
1351  */
1352 static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
1353 {
1354         /* temporary variables to work around GCC PR81715 with asan-stack=1 */
1355         u8 tmp = value;
1356
1357         return nla_put(skb, attrtype, sizeof(u8), &tmp);
1358 }
1359
1360 /**
1361  * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
1362  * @skb: socket buffer to add attribute to
1363  * @attrtype: attribute type
1364  * @value: numeric value
1365  */
1366 static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
1367 {
1368         u16 tmp = value;
1369
1370         return nla_put(skb, attrtype, sizeof(u16), &tmp);
1371 }
1372
1373 /**
1374  * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
1375  * @skb: socket buffer to add attribute to
1376  * @attrtype: attribute type
1377  * @value: numeric value
1378  */
1379 static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
1380 {
1381         __be16 tmp = value;
1382
1383         return nla_put(skb, attrtype, sizeof(__be16), &tmp);
1384 }
1385
1386 /**
1387  * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
1388  * @skb: socket buffer to add attribute to
1389  * @attrtype: attribute type
1390  * @value: numeric value
1391  */
1392 static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
1393 {
1394         __be16 tmp = value;
1395
1396         return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
1397 }
1398
1399 /**
1400  * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
1401  * @skb: socket buffer to add attribute to
1402  * @attrtype: attribute type
1403  * @value: numeric value
1404  */
1405 static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
1406 {
1407         __le16 tmp = value;
1408
1409         return nla_put(skb, attrtype, sizeof(__le16), &tmp);
1410 }
1411
1412 /**
1413  * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
1414  * @skb: socket buffer to add attribute to
1415  * @attrtype: attribute type
1416  * @value: numeric value
1417  */
1418 static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
1419 {
1420         u32 tmp = value;
1421
1422         return nla_put(skb, attrtype, sizeof(u32), &tmp);
1423 }
1424
1425 /**
1426  * nla_put_uint - Add a variable-size unsigned int to a socket buffer
1427  * @skb: socket buffer to add attribute to
1428  * @attrtype: attribute type
1429  * @value: numeric value
1430  */
1431 static inline int nla_put_uint(struct sk_buff *skb, int attrtype, u64 value)
1432 {
1433         u64 tmp64 = value;
1434         u32 tmp32 = value;
1435
1436         if (tmp64 == tmp32)
1437                 return nla_put_u32(skb, attrtype, tmp32);
1438         return nla_put(skb, attrtype, sizeof(u64), &tmp64);
1439 }
1440
1441 /**
1442  * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
1443  * @skb: socket buffer to add attribute to
1444  * @attrtype: attribute type
1445  * @value: numeric value
1446  */
1447 static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
1448 {
1449         __be32 tmp = value;
1450
1451         return nla_put(skb, attrtype, sizeof(__be32), &tmp);
1452 }
1453
1454 /**
1455  * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
1456  * @skb: socket buffer to add attribute to
1457  * @attrtype: attribute type
1458  * @value: numeric value
1459  */
1460 static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
1461 {
1462         __be32 tmp = value;
1463
1464         return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
1465 }
1466
1467 /**
1468  * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
1469  * @skb: socket buffer to add attribute to
1470  * @attrtype: attribute type
1471  * @value: numeric value
1472  */
1473 static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
1474 {
1475         __le32 tmp = value;
1476
1477         return nla_put(skb, attrtype, sizeof(__le32), &tmp);
1478 }
1479
1480 /**
1481  * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
1482  * @skb: socket buffer to add attribute to
1483  * @attrtype: attribute type
1484  * @value: numeric value
1485  * @padattr: attribute type for the padding
1486  */
1487 static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
1488                                     u64 value, int padattr)
1489 {
1490         u64 tmp = value;
1491
1492         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1493 }
1494
1495 /**
1496  * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
1497  * @skb: socket buffer to add attribute to
1498  * @attrtype: attribute type
1499  * @value: numeric value
1500  * @padattr: attribute type for the padding
1501  */
1502 static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
1503                                int padattr)
1504 {
1505         __be64 tmp = value;
1506
1507         return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
1508 }
1509
1510 /**
1511  * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
1512  * @skb: socket buffer to add attribute to
1513  * @attrtype: attribute type
1514  * @value: numeric value
1515  * @padattr: attribute type for the padding
1516  */
1517 static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
1518                                 int padattr)
1519 {
1520         __be64 tmp = value;
1521
1522         return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
1523                             padattr);
1524 }
1525
1526 /**
1527  * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
1528  * @skb: socket buffer to add attribute to
1529  * @attrtype: attribute type
1530  * @value: numeric value
1531  * @padattr: attribute type for the padding
1532  */
1533 static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
1534                                int padattr)
1535 {
1536         __le64 tmp = value;
1537
1538         return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
1539 }
1540
1541 /**
1542  * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
1543  * @skb: socket buffer to add attribute to
1544  * @attrtype: attribute type
1545  * @value: numeric value
1546  */
1547 static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
1548 {
1549         s8 tmp = value;
1550
1551         return nla_put(skb, attrtype, sizeof(s8), &tmp);
1552 }
1553
1554 /**
1555  * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
1556  * @skb: socket buffer to add attribute to
1557  * @attrtype: attribute type
1558  * @value: numeric value
1559  */
1560 static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
1561 {
1562         s16 tmp = value;
1563
1564         return nla_put(skb, attrtype, sizeof(s16), &tmp);
1565 }
1566
1567 /**
1568  * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
1569  * @skb: socket buffer to add attribute to
1570  * @attrtype: attribute type
1571  * @value: numeric value
1572  */
1573 static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
1574 {
1575         s32 tmp = value;
1576
1577         return nla_put(skb, attrtype, sizeof(s32), &tmp);
1578 }
1579
1580 /**
1581  * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
1582  * @skb: socket buffer to add attribute to
1583  * @attrtype: attribute type
1584  * @value: numeric value
1585  * @padattr: attribute type for the padding
1586  */
1587 static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
1588                               int padattr)
1589 {
1590         s64 tmp = value;
1591
1592         return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
1593 }
1594
1595 /**
1596  * nla_put_sint - Add a variable-size signed int to a socket buffer
1597  * @skb: socket buffer to add attribute to
1598  * @attrtype: attribute type
1599  * @value: numeric value
1600  */
1601 static inline int nla_put_sint(struct sk_buff *skb, int attrtype, s64 value)
1602 {
1603         s64 tmp64 = value;
1604         s32 tmp32 = value;
1605
1606         if (tmp64 == tmp32)
1607                 return nla_put_s32(skb, attrtype, tmp32);
1608         return nla_put(skb, attrtype, sizeof(s64), &tmp64);
1609 }
1610
1611 /**
1612  * nla_put_string - Add a string netlink attribute to a socket buffer
1613  * @skb: socket buffer to add attribute to
1614  * @attrtype: attribute type
1615  * @str: NUL terminated string
1616  */
1617 static inline int nla_put_string(struct sk_buff *skb, int attrtype,
1618                                  const char *str)
1619 {
1620         return nla_put(skb, attrtype, strlen(str) + 1, str);
1621 }
1622
1623 /**
1624  * nla_put_flag - Add a flag netlink attribute to a socket buffer
1625  * @skb: socket buffer to add attribute to
1626  * @attrtype: attribute type
1627  */
1628 static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
1629 {
1630         return nla_put(skb, attrtype, 0, NULL);
1631 }
1632
1633 /**
1634  * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
1635  * @skb: socket buffer to add attribute to
1636  * @attrtype: attribute type
1637  * @njiffies: number of jiffies to convert to msecs
1638  * @padattr: attribute type for the padding
1639  */
1640 static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
1641                                 unsigned long njiffies, int padattr)
1642 {
1643         u64 tmp = jiffies_to_msecs(njiffies);
1644
1645         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
1646 }
1647
1648 /**
1649  * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
1650  * buffer
1651  * @skb: socket buffer to add attribute to
1652  * @attrtype: attribute type
1653  * @addr: IPv4 address
1654  */
1655 static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
1656                                   __be32 addr)
1657 {
1658         __be32 tmp = addr;
1659
1660         return nla_put_be32(skb, attrtype, tmp);
1661 }
1662
1663 /**
1664  * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
1665  * buffer
1666  * @skb: socket buffer to add attribute to
1667  * @attrtype: attribute type
1668  * @addr: IPv6 address
1669  */
1670 static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
1671                                    const struct in6_addr *addr)
1672 {
1673         return nla_put(skb, attrtype, sizeof(*addr), addr);
1674 }
1675
1676 /**
1677  * nla_put_bitfield32 - Add a bitfield32 netlink attribute to a socket buffer
1678  * @skb: socket buffer to add attribute to
1679  * @attrtype: attribute type
1680  * @value: value carrying bits
1681  * @selector: selector of valid bits
1682  */
1683 static inline int nla_put_bitfield32(struct sk_buff *skb, int attrtype,
1684                                      __u32 value, __u32 selector)
1685 {
1686         struct nla_bitfield32 tmp = { value, selector, };
1687
1688         return nla_put(skb, attrtype, sizeof(tmp), &tmp);
1689 }
1690
1691 /**
1692  * nla_get_u32 - return payload of u32 attribute
1693  * @nla: u32 netlink attribute
1694  */
1695 static inline u32 nla_get_u32(const struct nlattr *nla)
1696 {
1697         return *(u32 *) nla_data(nla);
1698 }
1699
1700 /**
1701  * nla_get_u32_default - return payload of u32 attribute or default
1702  * @nla: u32 netlink attribute, may be %NULL
1703  * @defvalue: default value to use if @nla is %NULL
1704  *
1705  * Return: the value of the attribute, or the default value if not present
1706  */
1707 static inline u32 nla_get_u32_default(const struct nlattr *nla, u32 defvalue)
1708 {
1709         if (!nla)
1710                 return defvalue;
1711         return nla_get_u32(nla);
1712 }
1713
1714 /**
1715  * nla_get_be32 - return payload of __be32 attribute
1716  * @nla: __be32 netlink attribute
1717  */
1718 static inline __be32 nla_get_be32(const struct nlattr *nla)
1719 {
1720         return *(__be32 *) nla_data(nla);
1721 }
1722
1723 /**
1724  * nla_get_be32_default - return payload of be32 attribute or default
1725  * @nla: __be32 netlink attribute, may be %NULL
1726  * @defvalue: default value to use if @nla is %NULL
1727  *
1728  * Return: the value of the attribute, or the default value if not present
1729  */
1730 static inline __be32 nla_get_be32_default(const struct nlattr *nla,
1731                                           __be32 defvalue)
1732 {
1733         if (!nla)
1734                 return defvalue;
1735         return nla_get_be32(nla);
1736 }
1737
1738 /**
1739  * nla_get_le32 - return payload of __le32 attribute
1740  * @nla: __le32 netlink attribute
1741  */
1742 static inline __le32 nla_get_le32(const struct nlattr *nla)
1743 {
1744         return *(__le32 *) nla_data(nla);
1745 }
1746
1747 /**
1748  * nla_get_le32_default - return payload of le32 attribute or default
1749  * @nla: __le32 netlink attribute, may be %NULL
1750  * @defvalue: default value to use if @nla is %NULL
1751  *
1752  * Return: the value of the attribute, or the default value if not present
1753  */
1754 static inline __le32 nla_get_le32_default(const struct nlattr *nla,
1755                                           __le32 defvalue)
1756 {
1757         if (!nla)
1758                 return defvalue;
1759         return nla_get_le32(nla);
1760 }
1761
1762 /**
1763  * nla_get_u16 - return payload of u16 attribute
1764  * @nla: u16 netlink attribute
1765  */
1766 static inline u16 nla_get_u16(const struct nlattr *nla)
1767 {
1768         return *(u16 *) nla_data(nla);
1769 }
1770
1771 /**
1772  * nla_get_u16_default - return payload of u16 attribute or default
1773  * @nla: u16 netlink attribute, may be %NULL
1774  * @defvalue: default value to use if @nla is %NULL
1775  *
1776  * Return: the value of the attribute, or the default value if not present
1777  */
1778 static inline u16 nla_get_u16_default(const struct nlattr *nla, u16 defvalue)
1779 {
1780         if (!nla)
1781                 return defvalue;
1782         return nla_get_u16(nla);
1783 }
1784
1785 /**
1786  * nla_get_be16 - return payload of __be16 attribute
1787  * @nla: __be16 netlink attribute
1788  */
1789 static inline __be16 nla_get_be16(const struct nlattr *nla)
1790 {
1791         return *(__be16 *) nla_data(nla);
1792 }
1793
1794 /**
1795  * nla_get_be16_default - return payload of be16 attribute or default
1796  * @nla: __be16 netlink attribute, may be %NULL
1797  * @defvalue: default value to use if @nla is %NULL
1798  *
1799  * Return: the value of the attribute, or the default value if not present
1800  */
1801 static inline __be16 nla_get_be16_default(const struct nlattr *nla,
1802                                           __be16 defvalue)
1803 {
1804         if (!nla)
1805                 return defvalue;
1806         return nla_get_be16(nla);
1807 }
1808
1809 /**
1810  * nla_get_le16 - return payload of __le16 attribute
1811  * @nla: __le16 netlink attribute
1812  */
1813 static inline __le16 nla_get_le16(const struct nlattr *nla)
1814 {
1815         return *(__le16 *) nla_data(nla);
1816 }
1817
1818 /**
1819  * nla_get_le16_default - return payload of le16 attribute or default
1820  * @nla: __le16 netlink attribute, may be %NULL
1821  * @defvalue: default value to use if @nla is %NULL
1822  *
1823  * Return: the value of the attribute, or the default value if not present
1824  */
1825 static inline __le16 nla_get_le16_default(const struct nlattr *nla,
1826                                           __le16 defvalue)
1827 {
1828         if (!nla)
1829                 return defvalue;
1830         return nla_get_le16(nla);
1831 }
1832
1833 /**
1834  * nla_get_u8 - return payload of u8 attribute
1835  * @nla: u8 netlink attribute
1836  */
1837 static inline u8 nla_get_u8(const struct nlattr *nla)
1838 {
1839         return *(u8 *) nla_data(nla);
1840 }
1841
1842 /**
1843  * nla_get_u8_default - return payload of u8 attribute or default
1844  * @nla: u8 netlink attribute, may be %NULL
1845  * @defvalue: default value to use if @nla is %NULL
1846  *
1847  * Return: the value of the attribute, or the default value if not present
1848  */
1849 static inline u8 nla_get_u8_default(const struct nlattr *nla, u8 defvalue)
1850 {
1851         if (!nla)
1852                 return defvalue;
1853         return nla_get_u8(nla);
1854 }
1855
1856 /**
1857  * nla_get_u64 - return payload of u64 attribute
1858  * @nla: u64 netlink attribute
1859  */
1860 static inline u64 nla_get_u64(const struct nlattr *nla)
1861 {
1862         u64 tmp;
1863
1864         nla_memcpy(&tmp, nla, sizeof(tmp));
1865
1866         return tmp;
1867 }
1868
1869 /**
1870  * nla_get_u64_default - return payload of u64 attribute or default
1871  * @nla: u64 netlink attribute, may be %NULL
1872  * @defvalue: default value to use if @nla is %NULL
1873  *
1874  * Return: the value of the attribute, or the default value if not present
1875  */
1876 static inline u64 nla_get_u64_default(const struct nlattr *nla, u64 defvalue)
1877 {
1878         if (!nla)
1879                 return defvalue;
1880         return nla_get_u64(nla);
1881 }
1882
1883 /**
1884  * nla_get_uint - return payload of uint attribute
1885  * @nla: uint netlink attribute
1886  */
1887 static inline u64 nla_get_uint(const struct nlattr *nla)
1888 {
1889         if (nla_len(nla) == sizeof(u32))
1890                 return nla_get_u32(nla);
1891         return nla_get_u64(nla);
1892 }
1893
1894 /**
1895  * nla_get_uint_default - return payload of uint attribute or default
1896  * @nla: uint netlink attribute, may be %NULL
1897  * @defvalue: default value to use if @nla is %NULL
1898  *
1899  * Return: the value of the attribute, or the default value if not present
1900  */
1901 static inline u64 nla_get_uint_default(const struct nlattr *nla, u64 defvalue)
1902 {
1903         if (!nla)
1904                 return defvalue;
1905         return nla_get_uint(nla);
1906 }
1907
1908 /**
1909  * nla_get_be64 - return payload of __be64 attribute
1910  * @nla: __be64 netlink attribute
1911  */
1912 static inline __be64 nla_get_be64(const struct nlattr *nla)
1913 {
1914         __be64 tmp;
1915
1916         nla_memcpy(&tmp, nla, sizeof(tmp));
1917
1918         return tmp;
1919 }
1920
1921 /**
1922  * nla_get_be64_default - return payload of be64 attribute or default
1923  * @nla: __be64 netlink attribute, may be %NULL
1924  * @defvalue: default value to use if @nla is %NULL
1925  *
1926  * Return: the value of the attribute, or the default value if not present
1927  */
1928 static inline __be64 nla_get_be64_default(const struct nlattr *nla,
1929                                           __be64 defvalue)
1930 {
1931         if (!nla)
1932                 return defvalue;
1933         return nla_get_be64(nla);
1934 }
1935
1936 /**
1937  * nla_get_le64 - return payload of __le64 attribute
1938  * @nla: __le64 netlink attribute
1939  */
1940 static inline __le64 nla_get_le64(const struct nlattr *nla)
1941 {
1942         return *(__le64 *) nla_data(nla);
1943 }
1944
1945 /**
1946  * nla_get_le64_default - return payload of le64 attribute or default
1947  * @nla: __le64 netlink attribute, may be %NULL
1948  * @defvalue: default value to use if @nla is %NULL
1949  *
1950  * Return: the value of the attribute, or the default value if not present
1951  */
1952 static inline __le64 nla_get_le64_default(const struct nlattr *nla,
1953                                           __le64 defvalue)
1954 {
1955         if (!nla)
1956                 return defvalue;
1957         return nla_get_le64(nla);
1958 }
1959
1960 /**
1961  * nla_get_s32 - return payload of s32 attribute
1962  * @nla: s32 netlink attribute
1963  */
1964 static inline s32 nla_get_s32(const struct nlattr *nla)
1965 {
1966         return *(s32 *) nla_data(nla);
1967 }
1968
1969 /**
1970  * nla_get_s32_default - return payload of s32 attribute or default
1971  * @nla: s32 netlink attribute, may be %NULL
1972  * @defvalue: default value to use if @nla is %NULL
1973  *
1974  * Return: the value of the attribute, or the default value if not present
1975  */
1976 static inline s32 nla_get_s32_default(const struct nlattr *nla, s32 defvalue)
1977 {
1978         if (!nla)
1979                 return defvalue;
1980         return nla_get_s32(nla);
1981 }
1982
1983 /**
1984  * nla_get_s16 - return payload of s16 attribute
1985  * @nla: s16 netlink attribute
1986  */
1987 static inline s16 nla_get_s16(const struct nlattr *nla)
1988 {
1989         return *(s16 *) nla_data(nla);
1990 }
1991
1992 /**
1993  * nla_get_s16_default - return payload of s16 attribute or default
1994  * @nla: s16 netlink attribute, may be %NULL
1995  * @defvalue: default value to use if @nla is %NULL
1996  *
1997  * Return: the value of the attribute, or the default value if not present
1998  */
1999 static inline s16 nla_get_s16_default(const struct nlattr *nla, s16 defvalue)
2000 {
2001         if (!nla)
2002                 return defvalue;
2003         return nla_get_s16(nla);
2004 }
2005
2006 /**
2007  * nla_get_s8 - return payload of s8 attribute
2008  * @nla: s8 netlink attribute
2009  */
2010 static inline s8 nla_get_s8(const struct nlattr *nla)
2011 {
2012         return *(s8 *) nla_data(nla);
2013 }
2014
2015 /**
2016  * nla_get_s8_default - return payload of s8 attribute or default
2017  * @nla: s8 netlink attribute, may be %NULL
2018  * @defvalue: default value to use if @nla is %NULL
2019  *
2020  * Return: the value of the attribute, or the default value if not present
2021  */
2022 static inline s8 nla_get_s8_default(const struct nlattr *nla, s8 defvalue)
2023 {
2024         if (!nla)
2025                 return defvalue;
2026         return nla_get_s8(nla);
2027 }
2028
2029 /**
2030  * nla_get_s64 - return payload of s64 attribute
2031  * @nla: s64 netlink attribute
2032  */
2033 static inline s64 nla_get_s64(const struct nlattr *nla)
2034 {
2035         s64 tmp;
2036
2037         nla_memcpy(&tmp, nla, sizeof(tmp));
2038
2039         return tmp;
2040 }
2041
2042 /**
2043  * nla_get_s64_default - return payload of s64 attribute or default
2044  * @nla: s64 netlink attribute, may be %NULL
2045  * @defvalue: default value to use if @nla is %NULL
2046  *
2047  * Return: the value of the attribute, or the default value if not present
2048  */
2049 static inline s64 nla_get_s64_default(const struct nlattr *nla, s64 defvalue)
2050 {
2051         if (!nla)
2052                 return defvalue;
2053         return nla_get_s64(nla);
2054 }
2055
2056 /**
2057  * nla_get_sint - return payload of uint attribute
2058  * @nla: uint netlink attribute
2059  */
2060 static inline s64 nla_get_sint(const struct nlattr *nla)
2061 {
2062         if (nla_len(nla) == sizeof(s32))
2063                 return nla_get_s32(nla);
2064         return nla_get_s64(nla);
2065 }
2066
2067 /**
2068  * nla_get_sint_default - return payload of sint attribute or default
2069  * @nla: sint netlink attribute, may be %NULL
2070  * @defvalue: default value to use if @nla is %NULL
2071  *
2072  * Return: the value of the attribute, or the default value if not present
2073  */
2074 static inline s64 nla_get_sint_default(const struct nlattr *nla, s64 defvalue)
2075 {
2076         if (!nla)
2077                 return defvalue;
2078         return nla_get_sint(nla);
2079 }
2080
2081 /**
2082  * nla_get_flag - return payload of flag attribute
2083  * @nla: flag netlink attribute
2084  */
2085 static inline int nla_get_flag(const struct nlattr *nla)
2086 {
2087         return !!nla;
2088 }
2089
2090 /**
2091  * nla_get_msecs - return payload of msecs attribute
2092  * @nla: msecs netlink attribute
2093  *
2094  * Returns the number of milliseconds in jiffies.
2095  */
2096 static inline unsigned long nla_get_msecs(const struct nlattr *nla)
2097 {
2098         u64 msecs = nla_get_u64(nla);
2099
2100         return msecs_to_jiffies((unsigned long) msecs);
2101 }
2102
2103 /**
2104  * nla_get_msecs_default - return payload of msecs attribute or default
2105  * @nla: msecs netlink attribute, may be %NULL
2106  * @defvalue: default value to use if @nla is %NULL
2107  *
2108  * Return: the value of the attribute, or the default value if not present
2109  */
2110 static inline unsigned long nla_get_msecs_default(const struct nlattr *nla,
2111                                                   unsigned long defvalue)
2112 {
2113         if (!nla)
2114                 return defvalue;
2115         return nla_get_msecs(nla);
2116 }
2117
2118 /**
2119  * nla_get_in_addr - return payload of IPv4 address attribute
2120  * @nla: IPv4 address netlink attribute
2121  */
2122 static inline __be32 nla_get_in_addr(const struct nlattr *nla)
2123 {
2124         return *(__be32 *) nla_data(nla);
2125 }
2126
2127 /**
2128  * nla_get_in_addr_default - return payload of be32 attribute or default
2129  * @nla: IPv4 address netlink attribute, may be %NULL
2130  * @defvalue: default value to use if @nla is %NULL
2131  *
2132  * Return: the value of the attribute, or the default value if not present
2133  */
2134 static inline __be32 nla_get_in_addr_default(const struct nlattr *nla,
2135                                              __be32 defvalue)
2136 {
2137         if (!nla)
2138                 return defvalue;
2139         return nla_get_in_addr(nla);
2140 }
2141
2142 /**
2143  * nla_get_in6_addr - return payload of IPv6 address attribute
2144  * @nla: IPv6 address netlink attribute
2145  */
2146 static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
2147 {
2148         struct in6_addr tmp;
2149
2150         nla_memcpy(&tmp, nla, sizeof(tmp));
2151         return tmp;
2152 }
2153
2154 /**
2155  * nla_get_bitfield32 - return payload of 32 bitfield attribute
2156  * @nla: nla_bitfield32 attribute
2157  */
2158 static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
2159 {
2160         struct nla_bitfield32 tmp;
2161
2162         nla_memcpy(&tmp, nla, sizeof(tmp));
2163         return tmp;
2164 }
2165
2166 /**
2167  * nla_memdup - duplicate attribute memory (kmemdup)
2168  * @src: netlink attribute to duplicate from
2169  * @gfp: GFP mask
2170  */
2171 static inline void *nla_memdup_noprof(const struct nlattr *src, gfp_t gfp)
2172 {
2173         return kmemdup_noprof(nla_data(src), nla_len(src), gfp);
2174 }
2175 #define nla_memdup(...) alloc_hooks(nla_memdup_noprof(__VA_ARGS__))
2176
2177 /**
2178  * nla_nest_start_noflag - Start a new level of nested attributes
2179  * @skb: socket buffer to add attributes to
2180  * @attrtype: attribute type of container
2181  *
2182  * This function exists for backward compatibility to use in APIs which never
2183  * marked their nest attributes with NLA_F_NESTED flag. New APIs should use
2184  * nla_nest_start() which sets the flag.
2185  *
2186  * Returns the container attribute or NULL on error
2187  */
2188 static inline struct nlattr *nla_nest_start_noflag(struct sk_buff *skb,
2189                                                    int attrtype)
2190 {
2191         struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
2192
2193         if (nla_put(skb, attrtype, 0, NULL) < 0)
2194                 return NULL;
2195
2196         return start;
2197 }
2198
2199 /**
2200  * nla_nest_start - Start a new level of nested attributes, with NLA_F_NESTED
2201  * @skb: socket buffer to add attributes to
2202  * @attrtype: attribute type of container
2203  *
2204  * Unlike nla_nest_start_noflag(), mark the nest attribute with NLA_F_NESTED
2205  * flag. This is the preferred function to use in new code.
2206  *
2207  * Returns the container attribute or NULL on error
2208  */
2209 static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
2210 {
2211         return nla_nest_start_noflag(skb, attrtype | NLA_F_NESTED);
2212 }
2213
2214 /**
2215  * nla_nest_end - Finalize nesting of attributes
2216  * @skb: socket buffer the attributes are stored in
2217  * @start: container attribute
2218  *
2219  * Corrects the container attribute header to include the all
2220  * appended attributes.
2221  *
2222  * Returns the total data length of the skb.
2223  */
2224 static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
2225 {
2226         start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
2227         return skb->len;
2228 }
2229
2230 /**
2231  * nla_nest_cancel - Cancel nesting of attributes
2232  * @skb: socket buffer the message is stored in
2233  * @start: container attribute
2234  *
2235  * Removes the container attribute and including all nested
2236  * attributes. Returns -EMSGSIZE
2237  */
2238 static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
2239 {
2240         nlmsg_trim(skb, start);
2241 }
2242
2243 /**
2244  * __nla_validate_nested - Validate a stream of nested attributes
2245  * @start: container attribute
2246  * @maxtype: maximum attribute type to be expected
2247  * @policy: validation policy
2248  * @validate: validation strictness
2249  * @extack: extended ACK report struct
2250  *
2251  * Validates all attributes in the nested attribute stream against the
2252  * specified policy. Attributes with a type exceeding maxtype will be
2253  * ignored. See documentation of struct nla_policy for more details.
2254  *
2255  * Returns 0 on success or a negative error code.
2256  */
2257 static inline int __nla_validate_nested(const struct nlattr *start, int maxtype,
2258                                         const struct nla_policy *policy,
2259                                         unsigned int validate,
2260                                         struct netlink_ext_ack *extack)
2261 {
2262         return __nla_validate(nla_data(start), nla_len(start), maxtype, policy,
2263                               validate, extack);
2264 }
2265
2266 static inline int
2267 nla_validate_nested(const struct nlattr *start, int maxtype,
2268                     const struct nla_policy *policy,
2269                     struct netlink_ext_ack *extack)
2270 {
2271         return __nla_validate_nested(start, maxtype, policy,
2272                                      NL_VALIDATE_STRICT, extack);
2273 }
2274
2275 static inline int
2276 nla_validate_nested_deprecated(const struct nlattr *start, int maxtype,
2277                                const struct nla_policy *policy,
2278                                struct netlink_ext_ack *extack)
2279 {
2280         return __nla_validate_nested(start, maxtype, policy,
2281                                      NL_VALIDATE_LIBERAL, extack);
2282 }
2283
2284 /**
2285  * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
2286  * @skb: socket buffer the message is stored in
2287  *
2288  * Return true if padding is needed to align the next attribute (nla_data()) to
2289  * a 64-bit aligned area.
2290  */
2291 static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
2292 {
2293 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
2294         /* The nlattr header is 4 bytes in size, that's why we test
2295          * if the skb->data _is_ aligned.  A NOP attribute, plus
2296          * nlattr header for next attribute, will make nla_data()
2297          * 8-byte aligned.
2298          */
2299         if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
2300                 return true;
2301 #endif
2302         return false;
2303 }
2304
2305 /**
2306  * nla_align_64bit - 64-bit align the nla_data() of next attribute
2307  * @skb: socket buffer the message is stored in
2308  * @padattr: attribute type for the padding
2309  *
2310  * Conditionally emit a padding netlink attribute in order to make
2311  * the next attribute we emit have a 64-bit aligned nla_data() area.
2312  * This will only be done in architectures which do not have
2313  * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
2314  *
2315  * Returns zero on success or a negative error code.
2316  */
2317 static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
2318 {
2319         if (nla_need_padding_for_64bit(skb) &&
2320             !nla_reserve(skb, padattr, 0))
2321                 return -EMSGSIZE;
2322
2323         return 0;
2324 }
2325
2326 /**
2327  * nla_total_size_64bit - total length of attribute including padding
2328  * @payload: length of payload
2329  */
2330 static inline int nla_total_size_64bit(int payload)
2331 {
2332         return NLA_ALIGN(nla_attr_size(payload))
2333 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
2334                 + NLA_ALIGN(nla_attr_size(0))
2335 #endif
2336                 ;
2337 }
2338
2339 /**
2340  * nla_for_each_attr - iterate over a stream of attributes
2341  * @pos: loop counter, set to current attribute
2342  * @head: head of attribute stream
2343  * @len: length of attribute stream
2344  * @rem: initialized to len, holds bytes currently remaining in stream
2345  */
2346 #define nla_for_each_attr(pos, head, len, rem) \
2347         for (pos = head, rem = len; \
2348              nla_ok(pos, rem); \
2349              pos = nla_next(pos, &(rem)))
2350
2351 /**
2352  * nla_for_each_attr_type - iterate over a stream of attributes
2353  * @pos: loop counter, set to current attribute
2354  * @type: required attribute type for @pos
2355  * @head: head of attribute stream
2356  * @len: length of attribute stream
2357  * @rem: initialized to len, holds bytes currently remaining in stream
2358  */
2359 #define nla_for_each_attr_type(pos, type, head, len, rem) \
2360         nla_for_each_attr(pos, head, len, rem) \
2361                 if (nla_type(pos) == type)
2362
2363 /**
2364  * nla_for_each_nested - iterate over nested attributes
2365  * @pos: loop counter, set to current attribute
2366  * @nla: attribute containing the nested attributes
2367  * @rem: initialized to len, holds bytes currently remaining in stream
2368  */
2369 #define nla_for_each_nested(pos, nla, rem) \
2370         nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
2371
2372 /**
2373  * nla_for_each_nested_type - iterate over nested attributes
2374  * @pos: loop counter, set to current attribute
2375  * @type: required attribute type for @pos
2376  * @nla: attribute containing the nested attributes
2377  * @rem: initialized to len, holds bytes currently remaining in stream
2378  */
2379 #define nla_for_each_nested_type(pos, type, nla, rem) \
2380         nla_for_each_nested(pos, nla, rem) \
2381                 if (nla_type(pos) == type)
2382
2383 /**
2384  * nla_is_last - Test if attribute is last in stream
2385  * @nla: attribute to test
2386  * @rem: bytes remaining in stream
2387  */
2388 static inline bool nla_is_last(const struct nlattr *nla, int rem)
2389 {
2390         return nla->nla_len == rem;
2391 }
2392
2393 void nla_get_range_unsigned(const struct nla_policy *pt,
2394                             struct netlink_range_validation *range);
2395 void nla_get_range_signed(const struct nla_policy *pt,
2396                           struct netlink_range_validation_signed *range);
2397
2398 struct netlink_policy_dump_state;
2399
2400 int netlink_policy_dump_add_policy(struct netlink_policy_dump_state **pstate,
2401                                    const struct nla_policy *policy,
2402                                    unsigned int maxtype);
2403 int netlink_policy_dump_get_policy_idx(struct netlink_policy_dump_state *state,
2404                                        const struct nla_policy *policy,
2405                                        unsigned int maxtype);
2406 bool netlink_policy_dump_loop(struct netlink_policy_dump_state *state);
2407 int netlink_policy_dump_write(struct sk_buff *skb,
2408                               struct netlink_policy_dump_state *state);
2409 int netlink_policy_dump_attr_size_estimate(const struct nla_policy *pt);
2410 int netlink_policy_dump_write_attr(struct sk_buff *skb,
2411                                    const struct nla_policy *pt,
2412                                    int nestattr);
2413 void netlink_policy_dump_free(struct netlink_policy_dump_state *state);
2414
2415 #endif