LCOV - code coverage report
Current view: top level - include/net - netlink.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 114 213 53.5 %
Date: 2022-03-28 15:32:58 Functions: 4 8 50.0 %
Branches: 66 883 7.5 %

           Branch data     Line data    Source code
       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_free()                       free a netlink message
      45                 :            :  *
      46                 :            :  * Message Sending:
      47                 :            :  *   nlmsg_multicast()                  multicast message to several groups
      48                 :            :  *   nlmsg_unicast()                    unicast a message to a single socket
      49                 :            :  *   nlmsg_notify()                     send notification message
      50                 :            :  *
      51                 :            :  * Message Length Calculations:
      52                 :            :  *   nlmsg_msg_size(payload)            length of message w/o padding
      53                 :            :  *   nlmsg_total_size(payload)          length of message w/ padding
      54                 :            :  *   nlmsg_padlen(payload)              length of padding at tail
      55                 :            :  *
      56                 :            :  * Message Payload Access:
      57                 :            :  *   nlmsg_data(nlh)                    head of message payload
      58                 :            :  *   nlmsg_len(nlh)                     length of message payload
      59                 :            :  *   nlmsg_attrdata(nlh, hdrlen)        head of attributes data
      60                 :            :  *   nlmsg_attrlen(nlh, hdrlen)         length of attributes data
      61                 :            :  *
      62                 :            :  * Message Parsing:
      63                 :            :  *   nlmsg_ok(nlh, remaining)           does nlh fit into remaining bytes?
      64                 :            :  *   nlmsg_next(nlh, remaining)         get next netlink message
      65                 :            :  *   nlmsg_parse()                      parse attributes of a message
      66                 :            :  *   nlmsg_find_attr()                  find an attribute in a message
      67                 :            :  *   nlmsg_for_each_msg()               loop over all messages
      68                 :            :  *   nlmsg_validate()                   validate netlink message incl. attrs
      69                 :            :  *   nlmsg_for_each_attr()              loop over all attributes
      70                 :            :  *
      71                 :            :  * Misc:
      72                 :            :  *   nlmsg_report()                     report back to application?
      73                 :            :  *
      74                 :            :  * ------------------------------------------------------------------------
      75                 :            :  *                          Attributes Interface
      76                 :            :  * ------------------------------------------------------------------------
      77                 :            :  *
      78                 :            :  * Attribute Format:
      79                 :            :  *    <------- nla_total_size(payload) ------->
      80                 :            :  *    <---- nla_attr_size(payload) ----->
      81                 :            :  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
      82                 :            :  *   |  Header  | Pad |     Payload      | Pad |  Header
      83                 :            :  *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
      84                 :            :  *                     <- nla_len(nla) ->      ^
      85                 :            :  *   nla_data(nla)----^                        |
      86                 :            :  *   nla_next(nla)-----------------------------'
      87                 :            :  *
      88                 :            :  * Data Structures:
      89                 :            :  *   struct nlattr                      netlink attribute header
      90                 :            :  *
      91                 :            :  * Attribute Construction:
      92                 :            :  *   nla_reserve(skb, type, len)        reserve room for an attribute
      93                 :            :  *   nla_reserve_nohdr(skb, len)        reserve room for an attribute w/o hdr
      94                 :            :  *   nla_put(skb, type, len, data)      add attribute to skb
      95                 :            :  *   nla_put_nohdr(skb, len, data)      add attribute w/o hdr
      96                 :            :  *   nla_append(skb, len, data)         append data to skb
      97                 :            :  *
      98                 :            :  * Attribute Construction for Basic Types:
      99                 :            :  *   nla_put_u8(skb, type, value)       add u8 attribute to skb
     100                 :            :  *   nla_put_u16(skb, type, value)      add u16 attribute to skb
     101                 :            :  *   nla_put_u32(skb, type, value)      add u32 attribute to skb
     102                 :            :  *   nla_put_u64_64bit(skb, type,
     103                 :            :  *                     value, padattr)  add u64 attribute to skb
     104                 :            :  *   nla_put_s8(skb, type, value)       add s8 attribute to skb
     105                 :            :  *   nla_put_s16(skb, type, value)      add s16 attribute to skb
     106                 :            :  *   nla_put_s32(skb, type, value)      add s32 attribute to skb
     107                 :            :  *   nla_put_s64(skb, type, value,
     108                 :            :  *               padattr)               add s64 attribute to skb
     109                 :            :  *   nla_put_string(skb, type, str)     add string attribute to skb
     110                 :            :  *   nla_put_flag(skb, type)            add flag attribute to skb
     111                 :            :  *   nla_put_msecs(skb, type, jiffies,
     112                 :            :  *                 padattr)             add msecs attribute to skb
     113                 :            :  *   nla_put_in_addr(skb, type, addr)   add IPv4 address attribute to skb
     114                 :            :  *   nla_put_in6_addr(skb, type, addr)  add IPv6 address attribute to skb
     115                 :            :  *
     116                 :            :  * Nested Attributes Construction:
     117                 :            :  *   nla_nest_start(skb, type)          start a nested attribute
     118                 :            :  *   nla_nest_end(skb, nla)             finalize a nested attribute
     119                 :            :  *   nla_nest_cancel(skb, nla)          cancel nested attribute construction
     120                 :            :  *
     121                 :            :  * Attribute Length Calculations:
     122                 :            :  *   nla_attr_size(payload)             length of attribute w/o padding
     123                 :            :  *   nla_total_size(payload)            length of attribute w/ padding
     124                 :            :  *   nla_padlen(payload)                length of padding
     125                 :            :  *
     126                 :            :  * Attribute Payload Access:
     127                 :            :  *   nla_data(nla)                      head of attribute payload
     128                 :            :  *   nla_len(nla)                       length of attribute payload
     129                 :            :  *
     130                 :            :  * Attribute Payload Access for Basic Types:
     131                 :            :  *   nla_get_u8(nla)                    get payload for a u8 attribute
     132                 :            :  *   nla_get_u16(nla)                   get payload for a u16 attribute
     133                 :            :  *   nla_get_u32(nla)                   get payload for a u32 attribute
     134                 :            :  *   nla_get_u64(nla)                   get payload for a u64 attribute
     135                 :            :  *   nla_get_s8(nla)                    get payload for a s8 attribute
     136                 :            :  *   nla_get_s16(nla)                   get payload for a s16 attribute
     137                 :            :  *   nla_get_s32(nla)                   get payload for a s32 attribute
     138                 :            :  *   nla_get_s64(nla)                   get payload for a s64 attribute
     139                 :            :  *   nla_get_flag(nla)                  return 1 if flag is true
     140                 :            :  *   nla_get_msecs(nla)                 get payload for a msecs attribute
     141                 :            :  *
     142                 :            :  * Attribute Misc:
     143                 :            :  *   nla_memcpy(dest, nla, count)       copy attribute into memory
     144                 :            :  *   nla_memcmp(nla, data, size)        compare attribute with memory area
     145                 :            :  *   nla_strlcpy(dst, nla, size)        copy attribute to a sized string
     146                 :            :  *   nla_strcmp(nla, str)               compare attribute with string
     147                 :            :  *
     148                 :            :  * Attribute Parsing:
     149                 :            :  *   nla_ok(nla, remaining)             does nla fit into remaining bytes?
     150                 :            :  *   nla_next(nla, remaining)           get next netlink attribute
     151                 :            :  *   nla_validate()                     validate a stream of attributes
     152                 :            :  *   nla_validate_nested()              validate a stream of nested attributes
     153                 :            :  *   nla_find()                         find attribute in stream of attributes
     154                 :            :  *   nla_find_nested()                  find attribute in nested attributes
     155                 :            :  *   nla_parse()                        parse and validate stream of attrs
     156                 :            :  *   nla_parse_nested()                 parse nested attributes
     157                 :            :  *   nla_for_each_attr()                loop over all attributes
     158                 :            :  *   nla_for_each_nested()              loop over the nested attributes
     159                 :            :  *=========================================================================
     160                 :            :  */
     161                 :            : 
     162                 :            :  /**
     163                 :            :   * Standard attribute types to specify validation policy
     164                 :            :   */
     165                 :            : enum {
     166                 :            :         NLA_UNSPEC,
     167                 :            :         NLA_U8,
     168                 :            :         NLA_U16,
     169                 :            :         NLA_U32,
     170                 :            :         NLA_U64,
     171                 :            :         NLA_STRING,
     172                 :            :         NLA_FLAG,
     173                 :            :         NLA_MSECS,
     174                 :            :         NLA_NESTED,
     175                 :            :         NLA_NESTED_ARRAY,
     176                 :            :         NLA_NUL_STRING,
     177                 :            :         NLA_BINARY,
     178                 :            :         NLA_S8,
     179                 :            :         NLA_S16,
     180                 :            :         NLA_S32,
     181                 :            :         NLA_S64,
     182                 :            :         NLA_BITFIELD32,
     183                 :            :         NLA_REJECT,
     184                 :            :         NLA_EXACT_LEN,
     185                 :            :         NLA_EXACT_LEN_WARN,
     186                 :            :         NLA_MIN_LEN,
     187                 :            :         __NLA_TYPE_MAX,
     188                 :            : };
     189                 :            : 
     190                 :            : #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)
     191                 :            : 
     192                 :            : enum nla_policy_validation {
     193                 :            :         NLA_VALIDATE_NONE,
     194                 :            :         NLA_VALIDATE_RANGE,
     195                 :            :         NLA_VALIDATE_MIN,
     196                 :            :         NLA_VALIDATE_MAX,
     197                 :            :         NLA_VALIDATE_FUNCTION,
     198                 :            : };
     199                 :            : 
     200                 :            : /**
     201                 :            :  * struct nla_policy - attribute validation policy
     202                 :            :  * @type: Type of attribute or NLA_UNSPEC
     203                 :            :  * @validation_type: type of attribute validation done in addition to
     204                 :            :  *      type-specific validation (e.g. range, function call), see
     205                 :            :  *      &enum nla_policy_validation
     206                 :            :  * @len: Type specific length of payload
     207                 :            :  *
     208                 :            :  * Policies are defined as arrays of this struct, the array must be
     209                 :            :  * accessible by attribute type up to the highest identifier to be expected.
     210                 :            :  *
     211                 :            :  * Meaning of `len' field:
     212                 :            :  *    NLA_STRING           Maximum length of string
     213                 :            :  *    NLA_NUL_STRING       Maximum length of string (excluding NUL)
     214                 :            :  *    NLA_FLAG             Unused
     215                 :            :  *    NLA_BINARY           Maximum length of attribute payload
     216                 :            :  *    NLA_MIN_LEN          Minimum length of attribute payload
     217                 :            :  *    NLA_NESTED,
     218                 :            :  *    NLA_NESTED_ARRAY     Length verification is done by checking len of
     219                 :            :  *                         nested header (or empty); len field is used if
     220                 :            :  *                         validation_data is also used, for the max attr
     221                 :            :  *                         number in the nested policy.
     222                 :            :  *    NLA_U8, NLA_U16,
     223                 :            :  *    NLA_U32, NLA_U64,
     224                 :            :  *    NLA_S8, NLA_S16,
     225                 :            :  *    NLA_S32, NLA_S64,
     226                 :            :  *    NLA_MSECS            Leaving the length field zero will verify the
     227                 :            :  *                         given type fits, using it verifies minimum length
     228                 :            :  *                         just like "All other"
     229                 :            :  *    NLA_BITFIELD32       Unused
     230                 :            :  *    NLA_REJECT           Unused
     231                 :            :  *    NLA_EXACT_LEN        Attribute must have exactly this length, otherwise
     232                 :            :  *                         it is rejected.
     233                 :            :  *    NLA_EXACT_LEN_WARN   Attribute should have exactly this length, a warning
     234                 :            :  *                         is logged if it is longer, shorter is rejected.
     235                 :            :  *    NLA_MIN_LEN          Minimum length of attribute payload
     236                 :            :  *    All other            Minimum length of attribute payload
     237                 :            :  *
     238                 :            :  * Meaning of `validation_data' field:
     239                 :            :  *    NLA_BITFIELD32       This is a 32-bit bitmap/bitselector attribute and
     240                 :            :  *                         validation data must point to a u32 value of valid
     241                 :            :  *                         flags
     242                 :            :  *    NLA_REJECT           This attribute is always rejected and validation data
     243                 :            :  *                         may point to a string to report as the error instead
     244                 :            :  *                         of the generic one in extended ACK.
     245                 :            :  *    NLA_NESTED           Points to a nested policy to validate, must also set
     246                 :            :  *                         `len' to the max attribute number.
     247                 :            :  *                         Note that nla_parse() will validate, but of course not
     248                 :            :  *                         parse, the nested sub-policies.
     249                 :            :  *    NLA_NESTED_ARRAY     Points to a nested policy to validate, must also set
     250                 :            :  *                         `len' to the max attribute number. The difference to
     251                 :            :  *                         NLA_NESTED is the structure - NLA_NESTED has the
     252                 :            :  *                         nested attributes directly inside, while an array has
     253                 :            :  *                         the nested attributes at another level down and the
     254                 :            :  *                         attributes directly in the nesting don't matter.
     255                 :            :  *    All other            Unused - but note that it's a union
     256                 :            :  *
     257                 :            :  * Meaning of `min' and `max' fields, use via NLA_POLICY_MIN, NLA_POLICY_MAX
     258                 :            :  * and NLA_POLICY_RANGE:
     259                 :            :  *    NLA_U8,
     260                 :            :  *    NLA_U16,
     261                 :            :  *    NLA_U32,
     262                 :            :  *    NLA_U64,
     263                 :            :  *    NLA_S8,
     264                 :            :  *    NLA_S16,
     265                 :            :  *    NLA_S32,
     266                 :            :  *    NLA_S64              These are used depending on the validation_type
     267                 :            :  *                         field, if that is min/max/range then the minimum,
     268                 :            :  *                         maximum and both are used (respectively) to check
     269                 :            :  *                         the value of the integer attribute.
     270                 :            :  *                         Note that in the interest of code simplicity and
     271                 :            :  *                         struct size both limits are s16, so you cannot
     272                 :            :  *                         enforce a range that doesn't fall within the range
     273                 :            :  *                         of s16 - do that as usual in the code instead.
     274                 :            :  *    All other            Unused - but note that it's a union
     275                 :            :  *
     276                 :            :  * Meaning of `validate' field, use via NLA_POLICY_VALIDATE_FN:
     277                 :            :  *    NLA_BINARY           Validation function called for the attribute,
     278                 :            :  *                         not compatible with use of the validation_data
     279                 :            :  *                         as in NLA_BITFIELD32, NLA_REJECT, NLA_NESTED and
     280                 :            :  *                         NLA_NESTED_ARRAY.
     281                 :            :  *    All other            Unused - but note that it's a union
     282                 :            :  *
     283                 :            :  * Example:
     284                 :            :  * static const struct nla_policy my_policy[ATTR_MAX+1] = {
     285                 :            :  *      [ATTR_FOO] = { .type = NLA_U16 },
     286                 :            :  *      [ATTR_BAR] = { .type = NLA_STRING, .len = BARSIZ },
     287                 :            :  *      [ATTR_BAZ] = { .type = NLA_EXACT_LEN, .len = sizeof(struct mystruct) },
     288                 :            :  *      [ATTR_GOO] = { .type = NLA_BITFIELD32, .validation_data = &myvalidflags },
     289                 :            :  * };
     290                 :            :  */
     291                 :            : struct nla_policy {
     292                 :            :         u8              type;
     293                 :            :         u8              validation_type;
     294                 :            :         u16             len;
     295                 :            :         union {
     296                 :            :                 const void *validation_data;
     297                 :            :                 struct {
     298                 :            :                         s16 min, max;
     299                 :            :                 };
     300                 :            :                 int (*validate)(const struct nlattr *attr,
     301                 :            :                                 struct netlink_ext_ack *extack);
     302                 :            :                 /* This entry is special, and used for the attribute at index 0
     303                 :            :                  * only, and specifies special data about the policy, namely it
     304                 :            :                  * specifies the "boundary type" where strict length validation
     305                 :            :                  * starts for any attribute types >= this value, also, strict
     306                 :            :                  * nesting validation starts here.
     307                 :            :                  *
     308                 :            :                  * Additionally, it means that NLA_UNSPEC is actually NLA_REJECT
     309                 :            :                  * for any types >= this, so need to use NLA_MIN_LEN to get the
     310                 :            :                  * previous pure { .len = xyz } behaviour. The advantage of this
     311                 :            :                  * is that types not specified in the policy will be rejected.
     312                 :            :                  *
     313                 :            :                  * For completely new families it should be set to 1 so that the
     314                 :            :                  * validation is enforced for all attributes. For existing ones
     315                 :            :                  * it should be set at least when new attributes are added to
     316                 :            :                  * the enum used by the policy, and be set to the new value that
     317                 :            :                  * was added to enforce strict validation from thereon.
     318                 :            :                  */
     319                 :            :                 u16 strict_start_type;
     320                 :            :         };
     321                 :            : };
     322                 :            : 
     323                 :            : #define NLA_POLICY_EXACT_LEN(_len)      { .type = NLA_EXACT_LEN, .len = _len }
     324                 :            : #define NLA_POLICY_EXACT_LEN_WARN(_len) { .type = NLA_EXACT_LEN_WARN, \
     325                 :            :                                           .len = _len }
     326                 :            : #define NLA_POLICY_MIN_LEN(_len)        { .type = NLA_MIN_LEN, .len = _len }
     327                 :            : 
     328                 :            : #define NLA_POLICY_ETH_ADDR             NLA_POLICY_EXACT_LEN(ETH_ALEN)
     329                 :            : #define NLA_POLICY_ETH_ADDR_COMPAT      NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN)
     330                 :            : 
     331                 :            : #define _NLA_POLICY_NESTED(maxattr, policy) \
     332                 :            :         { .type = NLA_NESTED, .validation_data = policy, .len = maxattr }
     333                 :            : #define _NLA_POLICY_NESTED_ARRAY(maxattr, policy) \
     334                 :            :         { .type = NLA_NESTED_ARRAY, .validation_data = policy, .len = maxattr }
     335                 :            : #define NLA_POLICY_NESTED(policy) \
     336                 :            :         _NLA_POLICY_NESTED(ARRAY_SIZE(policy) - 1, policy)
     337                 :            : #define NLA_POLICY_NESTED_ARRAY(policy) \
     338                 :            :         _NLA_POLICY_NESTED_ARRAY(ARRAY_SIZE(policy) - 1, policy)
     339                 :            : 
     340                 :            : #define __NLA_ENSURE(condition) BUILD_BUG_ON_ZERO(!(condition))
     341                 :            : #define NLA_ENSURE_INT_TYPE(tp)                         \
     342                 :            :         (__NLA_ENSURE(tp == NLA_S8 || tp == NLA_U8 ||   \
     343                 :            :                       tp == NLA_S16 || tp == NLA_U16 || \
     344                 :            :                       tp == NLA_S32 || tp == NLA_U32 || \
     345                 :            :                       tp == NLA_S64 || tp == NLA_U64) + tp)
     346                 :            : #define NLA_ENSURE_NO_VALIDATION_PTR(tp)                \
     347                 :            :         (__NLA_ENSURE(tp != NLA_BITFIELD32 &&           \
     348                 :            :                       tp != NLA_REJECT &&               \
     349                 :            :                       tp != NLA_NESTED &&               \
     350                 :            :                       tp != NLA_NESTED_ARRAY) + tp)
     351                 :            : 
     352                 :            : #define NLA_POLICY_RANGE(tp, _min, _max) {              \
     353                 :            :         .type = NLA_ENSURE_INT_TYPE(tp),                \
     354                 :            :         .validation_type = NLA_VALIDATE_RANGE,          \
     355                 :            :         .min = _min,                                    \
     356                 :            :         .max = _max                                     \
     357                 :            : }
     358                 :            : 
     359                 :            : #define NLA_POLICY_MIN(tp, _min) {                      \
     360                 :            :         .type = NLA_ENSURE_INT_TYPE(tp),                \
     361                 :            :         .validation_type = NLA_VALIDATE_MIN,            \
     362                 :            :         .min = _min,                                    \
     363                 :            : }
     364                 :            : 
     365                 :            : #define NLA_POLICY_MAX(tp, _max) {                      \
     366                 :            :         .type = NLA_ENSURE_INT_TYPE(tp),                \
     367                 :            :         .validation_type = NLA_VALIDATE_MAX,            \
     368                 :            :         .max = _max,                                    \
     369                 :            : }
     370                 :            : 
     371                 :            : #define NLA_POLICY_VALIDATE_FN(tp, fn, ...) {           \
     372                 :            :         .type = NLA_ENSURE_NO_VALIDATION_PTR(tp),       \
     373                 :            :         .validation_type = NLA_VALIDATE_FUNCTION,       \
     374                 :            :         .validate = fn,                                 \
     375                 :            :         .len = __VA_ARGS__ + 0,                         \
     376                 :            : }
     377                 :            : 
     378                 :            : /**
     379                 :            :  * struct nl_info - netlink source information
     380                 :            :  * @nlh: Netlink message header of original request
     381                 :            :  * @nl_net: Network namespace
     382                 :            :  * @portid: Netlink PORTID of requesting application
     383                 :            :  * @skip_notify: Skip netlink notifications to user space
     384                 :            :  * @skip_notify_kernel: Skip selected in-kernel notifications
     385                 :            :  */
     386                 :            : struct nl_info {
     387                 :            :         struct nlmsghdr         *nlh;
     388                 :            :         struct net              *nl_net;
     389                 :            :         u32                     portid;
     390                 :            :         u8                      skip_notify:1,
     391                 :            :                                 skip_notify_kernel:1;
     392                 :            : };
     393                 :            : 
     394                 :            : /**
     395                 :            :  * enum netlink_validation - netlink message/attribute validation levels
     396                 :            :  * @NL_VALIDATE_LIBERAL: Old-style "be liberal" validation, not caring about
     397                 :            :  *      extra data at the end of the message, attributes being longer than
     398                 :            :  *      they should be, or unknown attributes being present.
     399                 :            :  * @NL_VALIDATE_TRAILING: Reject junk data encountered after attribute parsing.
     400                 :            :  * @NL_VALIDATE_MAXTYPE: Reject attributes > max type; Together with _TRAILING
     401                 :            :  *      this is equivalent to the old nla_parse_strict()/nlmsg_parse_strict().
     402                 :            :  * @NL_VALIDATE_UNSPEC: Reject attributes with NLA_UNSPEC in the policy.
     403                 :            :  *      This can safely be set by the kernel when the given policy has no
     404                 :            :  *      NLA_UNSPEC anymore, and can thus be used to ensure policy entries
     405                 :            :  *      are enforced going forward.
     406                 :            :  * @NL_VALIDATE_STRICT_ATTRS: strict attribute policy parsing (e.g.
     407                 :            :  *      U8, U16, U32 must have exact size, etc.)
     408                 :            :  * @NL_VALIDATE_NESTED: Check that NLA_F_NESTED is set for NLA_NESTED(_ARRAY)
     409                 :            :  *      and unset for other policies.
     410                 :            :  */
     411                 :            : enum netlink_validation {
     412                 :            :         NL_VALIDATE_LIBERAL = 0,
     413                 :            :         NL_VALIDATE_TRAILING = BIT(0),
     414                 :            :         NL_VALIDATE_MAXTYPE = BIT(1),
     415                 :            :         NL_VALIDATE_UNSPEC = BIT(2),
     416                 :            :         NL_VALIDATE_STRICT_ATTRS = BIT(3),
     417                 :            :         NL_VALIDATE_NESTED = BIT(4),
     418                 :            : };
     419                 :            : 
     420                 :            : #define NL_VALIDATE_DEPRECATED_STRICT (NL_VALIDATE_TRAILING |\
     421                 :            :                                        NL_VALIDATE_MAXTYPE)
     422                 :            : #define NL_VALIDATE_STRICT (NL_VALIDATE_TRAILING |\
     423                 :            :                             NL_VALIDATE_MAXTYPE |\
     424                 :            :                             NL_VALIDATE_UNSPEC |\
     425                 :            :                             NL_VALIDATE_STRICT_ATTRS |\
     426                 :            :                             NL_VALIDATE_NESTED)
     427                 :            : 
     428                 :            : int netlink_rcv_skb(struct sk_buff *skb,
     429                 :            :                     int (*cb)(struct sk_buff *, struct nlmsghdr *,
     430                 :            :                               struct netlink_ext_ack *));
     431                 :            : int nlmsg_notify(struct sock *sk, struct sk_buff *skb, u32 portid,
     432                 :            :                  unsigned int group, int report, gfp_t flags);
     433                 :            : 
     434                 :            : int __nla_validate(const struct nlattr *head, int len, int maxtype,
     435                 :            :                    const struct nla_policy *policy, unsigned int validate,
     436                 :            :                    struct netlink_ext_ack *extack);
     437                 :            : int __nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
     438                 :            :                 int len, const struct nla_policy *policy, unsigned int validate,
     439                 :            :                 struct netlink_ext_ack *extack);
     440                 :            : int nla_policy_len(const struct nla_policy *, int);
     441                 :            : struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
     442                 :            : size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize);
     443                 :            : char *nla_strdup(const struct nlattr *nla, gfp_t flags);
     444                 :            : int nla_memcpy(void *dest, const struct nlattr *src, int count);
     445                 :            : int nla_memcmp(const struct nlattr *nla, const void *data, size_t size);
     446                 :            : int nla_strcmp(const struct nlattr *nla, const char *str);
     447                 :            : struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
     448                 :            : struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
     449                 :            :                                    int attrlen, int padattr);
     450                 :            : void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
     451                 :            : struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
     452                 :            : struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype,
     453                 :            :                                  int attrlen, int padattr);
     454                 :            : void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen);
     455                 :            : void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
     456                 :            :                const void *data);
     457                 :            : void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
     458                 :            :                      const void *data, int padattr);
     459                 :            : void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
     460                 :            : int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
     461                 :            : int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
     462                 :            :                   const void *data, int padattr);
     463                 :            : int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data);
     464                 :            : int nla_append(struct sk_buff *skb, int attrlen, const void *data);
     465                 :            : 
     466                 :            : /**************************************************************************
     467                 :            :  * Netlink Messages
     468                 :            :  **************************************************************************/
     469                 :            : 
     470                 :            : /**
     471                 :            :  * nlmsg_msg_size - length of netlink message not including padding
     472                 :            :  * @payload: length of message payload
     473                 :            :  */
     474                 :      23538 : static inline int nlmsg_msg_size(int payload)
     475                 :            : {
     476   [ #  #  #  #  :       3024 :         return NLMSG_HDRLEN + payload;
          #  #  #  #  #  
                #  #  # ]
     477                 :            : }
     478                 :            : 
     479                 :            : /**
     480                 :            :  * nlmsg_total_size - length of netlink message including padding
     481                 :            :  * @payload: length of message payload
     482                 :            :  */
     483                 :      20234 : static inline int nlmsg_total_size(int payload)
     484                 :            : {
     485   [ +  +  -  +  :      19226 :         return NLMSG_ALIGN(nlmsg_msg_size(payload));
             #  #  #  # ]
     486                 :            : }
     487                 :            : 
     488                 :            : /**
     489                 :            :  * nlmsg_padlen - length of padding at the message's tail
     490                 :            :  * @payload: length of message payload
     491                 :            :  */
     492                 :            : static inline int nlmsg_padlen(int payload)
     493                 :            : {
     494                 :            :         return nlmsg_total_size(payload) - nlmsg_msg_size(payload);
     495                 :            : }
     496                 :            : 
     497                 :            : /**
     498                 :            :  * nlmsg_data - head of message payload
     499                 :            :  * @nlh: netlink message header
     500                 :            :  */
     501                 :       7140 : static inline void *nlmsg_data(const struct nlmsghdr *nlh)
     502                 :            : {
     503   [ +  +  +  +  :       6580 :         return (unsigned char *) nlh + NLMSG_HDRLEN;
          +  -  -  +  -  
          -  -  -  -  +  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  +  +  -  
             -  +  -  -  
                      - ]
     504                 :            : }
     505                 :            : 
     506                 :            : /**
     507                 :            :  * nlmsg_len - length of message payload
     508                 :            :  * @nlh: netlink message header
     509                 :            :  */
     510                 :       1876 : static inline int nlmsg_len(const struct nlmsghdr *nlh)
     511                 :            : {
     512   [ +  -  -  -  :       1372 :         return nlh->nlmsg_len - NLMSG_HDRLEN;
          +  -  -  -  +  
             +  -  -  - ]
     513                 :            : }
     514                 :            : 
     515                 :            : /**
     516                 :            :  * nlmsg_attrdata - head of attributes data
     517                 :            :  * @nlh: netlink message header
     518                 :            :  * @hdrlen: length of family specific header
     519                 :            :  */
     520                 :        560 : static inline struct nlattr *nlmsg_attrdata(const struct nlmsghdr *nlh,
     521                 :            :                                             int hdrlen)
     522                 :            : {
     523                 :        560 :         unsigned char *data = nlmsg_data(nlh);
     524                 :        560 :         return (struct nlattr *) (data + NLMSG_ALIGN(hdrlen));
     525                 :            : }
     526                 :            : 
     527                 :            : /**
     528                 :            :  * nlmsg_attrlen - length of attributes data
     529                 :            :  * @nlh: netlink message header
     530                 :            :  * @hdrlen: length of family specific header
     531                 :            :  */
     532                 :        560 : static inline int nlmsg_attrlen(const struct nlmsghdr *nlh, int hdrlen)
     533                 :            : {
     534   [ #  #  #  # ]:          0 :         return nlmsg_len(nlh) - NLMSG_ALIGN(hdrlen);
     535                 :            : }
     536                 :            : 
     537                 :            : /**
     538                 :            :  * nlmsg_ok - check if the netlink message fits into the remaining bytes
     539                 :            :  * @nlh: netlink message header
     540                 :            :  * @remaining: number of bytes remaining in message stream
     541                 :            :  */
     542                 :       1176 : static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)
     543                 :            : {
     544                 :       1764 :         return (remaining >= (int) sizeof(struct nlmsghdr) &&
     545   [ +  +  +  - ]:       1176 :                 nlh->nlmsg_len >= sizeof(struct nlmsghdr) &&
     546         [ +  - ]:        588 :                 nlh->nlmsg_len <= remaining);
     547                 :            : }
     548                 :            : 
     549                 :            : /**
     550                 :            :  * nlmsg_next - next netlink message in message stream
     551                 :            :  * @nlh: netlink message header
     552                 :            :  * @remaining: number of bytes remaining in message stream
     553                 :            :  *
     554                 :            :  * Returns the next netlink message in the message stream and
     555                 :            :  * decrements remaining by the size of the current message.
     556                 :            :  */
     557                 :            : static inline struct nlmsghdr *
     558                 :        588 : nlmsg_next(const struct nlmsghdr *nlh, int *remaining)
     559                 :            : {
     560                 :        588 :         int totlen = NLMSG_ALIGN(nlh->nlmsg_len);
     561                 :            : 
     562                 :        588 :         *remaining -= totlen;
     563                 :            : 
     564                 :        588 :         return (struct nlmsghdr *) ((unsigned char *) nlh + totlen);
     565                 :            : }
     566                 :            : 
     567                 :            : /**
     568                 :            :  * nla_parse - Parse a stream of attributes into a tb buffer
     569                 :            :  * @tb: destination array with maxtype+1 elements
     570                 :            :  * @maxtype: maximum attribute type to be expected
     571                 :            :  * @head: head of attribute stream
     572                 :            :  * @len: length of attribute stream
     573                 :            :  * @policy: validation policy
     574                 :            :  * @extack: extended ACK pointer
     575                 :            :  *
     576                 :            :  * Parses a stream of attributes and stores a pointer to each attribute in
     577                 :            :  * the tb array accessible via the attribute type. Attributes with a type
     578                 :            :  * exceeding maxtype will be rejected, policy must be specified, attributes
     579                 :            :  * will be validated in the strictest way possible.
     580                 :            :  *
     581                 :            :  * Returns 0 on success or a negative error code.
     582                 :            :  */
     583                 :            : static inline int nla_parse(struct nlattr **tb, int maxtype,
     584                 :            :                             const struct nlattr *head, int len,
     585                 :            :                             const struct nla_policy *policy,
     586                 :            :                             struct netlink_ext_ack *extack)
     587                 :            : {
     588                 :            :         return __nla_parse(tb, maxtype, head, len, policy,
     589                 :            :                            NL_VALIDATE_STRICT, extack);
     590                 :            : }
     591                 :            : 
     592                 :            : /**
     593                 :            :  * nla_parse_deprecated - Parse a stream of attributes into a tb buffer
     594                 :            :  * @tb: destination array with maxtype+1 elements
     595                 :            :  * @maxtype: maximum attribute type to be expected
     596                 :            :  * @head: head of attribute stream
     597                 :            :  * @len: length of attribute stream
     598                 :            :  * @policy: validation policy
     599                 :            :  * @extack: extended ACK pointer
     600                 :            :  *
     601                 :            :  * Parses a stream of attributes and stores a pointer to each attribute in
     602                 :            :  * the tb array accessible via the attribute type. Attributes with a type
     603                 :            :  * exceeding maxtype will be ignored and attributes from the policy are not
     604                 :            :  * always strictly validated (only for new attributes).
     605                 :            :  *
     606                 :            :  * Returns 0 on success or a negative error code.
     607                 :            :  */
     608                 :          0 : static inline int nla_parse_deprecated(struct nlattr **tb, int maxtype,
     609                 :            :                                        const struct nlattr *head, int len,
     610                 :            :                                        const struct nla_policy *policy,
     611                 :            :                                        struct netlink_ext_ack *extack)
     612                 :            : {
     613                 :          0 :         return __nla_parse(tb, maxtype, head, len, policy,
     614                 :            :                            NL_VALIDATE_LIBERAL, extack);
     615                 :            : }
     616                 :            : 
     617                 :            : /**
     618                 :            :  * nla_parse_deprecated_strict - Parse a stream of attributes into a tb buffer
     619                 :            :  * @tb: destination array with maxtype+1 elements
     620                 :            :  * @maxtype: maximum attribute type to be expected
     621                 :            :  * @head: head of attribute stream
     622                 :            :  * @len: length of attribute stream
     623                 :            :  * @policy: validation policy
     624                 :            :  * @extack: extended ACK pointer
     625                 :            :  *
     626                 :            :  * Parses a stream of attributes and stores a pointer to each attribute in
     627                 :            :  * the tb array accessible via the attribute type. Attributes with a type
     628                 :            :  * exceeding maxtype will be rejected as well as trailing data, but the
     629                 :            :  * policy is not completely strictly validated (only for new attributes).
     630                 :            :  *
     631                 :            :  * Returns 0 on success or a negative error code.
     632                 :            :  */
     633                 :            : static inline int nla_parse_deprecated_strict(struct nlattr **tb, int maxtype,
     634                 :            :                                               const struct nlattr *head,
     635                 :            :                                               int len,
     636                 :            :                                               const struct nla_policy *policy,
     637                 :            :                                               struct netlink_ext_ack *extack)
     638                 :            : {
     639                 :            :         return __nla_parse(tb, maxtype, head, len, policy,
     640                 :            :                            NL_VALIDATE_DEPRECATED_STRICT, extack);
     641                 :            : }
     642                 :            : 
     643                 :            : /**
     644                 :            :  * __nlmsg_parse - parse attributes of a netlink message
     645                 :            :  * @nlh: netlink message header
     646                 :            :  * @hdrlen: length of family specific header
     647                 :            :  * @tb: destination array with maxtype+1 elements
     648                 :            :  * @maxtype: maximum attribute type to be expected
     649                 :            :  * @policy: validation policy
     650                 :            :  * @validate: validation strictness
     651                 :            :  * @extack: extended ACK report struct
     652                 :            :  *
     653                 :            :  * See nla_parse()
     654                 :            :  */
     655                 :        560 : static inline int __nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
     656                 :            :                                 struct nlattr *tb[], int maxtype,
     657                 :            :                                 const struct nla_policy *policy,
     658                 :            :                                 unsigned int validate,
     659                 :            :                                 struct netlink_ext_ack *extack)
     660                 :            : {
     661         [ -  + ]:        560 :         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) {
     662         [ #  # ]:          0 :                 NL_SET_ERR_MSG(extack, "Invalid header length");
     663                 :          0 :                 return -EINVAL;
     664                 :            :         }
     665                 :            : 
     666                 :        560 :         return __nla_parse(tb, maxtype, nlmsg_attrdata(nlh, hdrlen),
     667                 :            :                            nlmsg_attrlen(nlh, hdrlen), policy, validate,
     668                 :            :                            extack);
     669                 :            : }
     670                 :            : 
     671                 :            : /**
     672                 :            :  * nlmsg_parse - parse attributes of a netlink message
     673                 :            :  * @nlh: netlink message header
     674                 :            :  * @hdrlen: length of family specific header
     675                 :            :  * @tb: destination array with maxtype+1 elements
     676                 :            :  * @maxtype: maximum attribute type to be expected
     677                 :            :  * @validate: validation strictness
     678                 :            :  * @extack: extended ACK report struct
     679                 :            :  *
     680                 :            :  * See nla_parse()
     681                 :            :  */
     682                 :          0 : static inline int nlmsg_parse(const struct nlmsghdr *nlh, int hdrlen,
     683                 :            :                               struct nlattr *tb[], int maxtype,
     684                 :            :                               const struct nla_policy *policy,
     685                 :            :                               struct netlink_ext_ack *extack)
     686                 :            : {
     687                 :          0 :         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
     688                 :            :                              NL_VALIDATE_STRICT, extack);
     689                 :            : }
     690                 :            : 
     691                 :            : /**
     692                 :            :  * nlmsg_parse_deprecated - parse attributes of a netlink message
     693                 :            :  * @nlh: netlink message header
     694                 :            :  * @hdrlen: length of family specific header
     695                 :            :  * @tb: destination array with maxtype+1 elements
     696                 :            :  * @maxtype: maximum attribute type to be expected
     697                 :            :  * @extack: extended ACK report struct
     698                 :            :  *
     699                 :            :  * See nla_parse_deprecated()
     700                 :            :  */
     701                 :        420 : static inline int nlmsg_parse_deprecated(const struct nlmsghdr *nlh, int hdrlen,
     702                 :            :                                          struct nlattr *tb[], int maxtype,
     703                 :            :                                          const struct nla_policy *policy,
     704                 :            :                                          struct netlink_ext_ack *extack)
     705                 :            : {
     706                 :        420 :         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
     707                 :            :                              NL_VALIDATE_LIBERAL, extack);
     708                 :            : }
     709                 :            : 
     710                 :            : /**
     711                 :            :  * nlmsg_parse_deprecated_strict - parse attributes of a netlink message
     712                 :            :  * @nlh: netlink message header
     713                 :            :  * @hdrlen: length of family specific header
     714                 :            :  * @tb: destination array with maxtype+1 elements
     715                 :            :  * @maxtype: maximum attribute type to be expected
     716                 :            :  * @extack: extended ACK report struct
     717                 :            :  *
     718                 :            :  * See nla_parse_deprecated_strict()
     719                 :            :  */
     720                 :            : static inline int
     721                 :          0 : nlmsg_parse_deprecated_strict(const struct nlmsghdr *nlh, int hdrlen,
     722                 :            :                               struct nlattr *tb[], int maxtype,
     723                 :            :                               const struct nla_policy *policy,
     724                 :            :                               struct netlink_ext_ack *extack)
     725                 :            : {
     726                 :          0 :         return __nlmsg_parse(nlh, hdrlen, tb, maxtype, policy,
     727                 :            :                              NL_VALIDATE_DEPRECATED_STRICT, extack);
     728                 :            : }
     729                 :            : 
     730                 :            : /**
     731                 :            :  * nlmsg_find_attr - find a specific attribute in a netlink message
     732                 :            :  * @nlh: netlink message header
     733                 :            :  * @hdrlen: length of familiy specific header
     734                 :            :  * @attrtype: type of attribute to look for
     735                 :            :  *
     736                 :            :  * Returns the first attribute which matches the specified type.
     737                 :            :  */
     738                 :          0 : static inline struct nlattr *nlmsg_find_attr(const struct nlmsghdr *nlh,
     739                 :            :                                              int hdrlen, int attrtype)
     740                 :            : {
     741                 :          0 :         return nla_find(nlmsg_attrdata(nlh, hdrlen),
     742                 :            :                         nlmsg_attrlen(nlh, hdrlen), attrtype);
     743                 :            : }
     744                 :            : 
     745                 :            : /**
     746                 :            :  * nla_validate_deprecated - Validate a stream of attributes
     747                 :            :  * @head: head of attribute stream
     748                 :            :  * @len: length of attribute stream
     749                 :            :  * @maxtype: maximum attribute type to be expected
     750                 :            :  * @policy: validation policy
     751                 :            :  * @validate: validation strictness
     752                 :            :  * @extack: extended ACK report struct
     753                 :            :  *
     754                 :            :  * Validates all attributes in the specified attribute stream against the
     755                 :            :  * specified policy. Validation is done in liberal mode.
     756                 :            :  * See documenation of struct nla_policy for more details.
     757                 :            :  *
     758                 :            :  * Returns 0 on success or a negative error code.
     759                 :            :  */
     760                 :            : static inline int nla_validate_deprecated(const struct nlattr *head, int len,
     761                 :            :                                           int maxtype,
     762                 :            :                                           const struct nla_policy *policy,
     763                 :            :                                           struct netlink_ext_ack *extack)
     764                 :            : {
     765                 :            :         return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_LIBERAL,
     766                 :            :                               extack);
     767                 :            : }
     768                 :            : 
     769                 :            : /**
     770                 :            :  * nla_validate - Validate a stream of attributes
     771                 :            :  * @head: head of attribute stream
     772                 :            :  * @len: length of attribute stream
     773                 :            :  * @maxtype: maximum attribute type to be expected
     774                 :            :  * @policy: validation policy
     775                 :            :  * @validate: validation strictness
     776                 :            :  * @extack: extended ACK report struct
     777                 :            :  *
     778                 :            :  * Validates all attributes in the specified attribute stream against the
     779                 :            :  * specified policy. Validation is done in strict mode.
     780                 :            :  * See documenation of struct nla_policy for more details.
     781                 :            :  *
     782                 :            :  * Returns 0 on success or a negative error code.
     783                 :            :  */
     784                 :          0 : static inline int nla_validate(const struct nlattr *head, int len, int maxtype,
     785                 :            :                                const struct nla_policy *policy,
     786                 :            :                                struct netlink_ext_ack *extack)
     787                 :            : {
     788                 :          0 :         return __nla_validate(head, len, maxtype, policy, NL_VALIDATE_STRICT,
     789                 :            :                               extack);
     790                 :            : }
     791                 :            : 
     792                 :            : /**
     793                 :            :  * nlmsg_validate_deprecated - validate a netlink message including attributes
     794                 :            :  * @nlh: netlinket message header
     795                 :            :  * @hdrlen: length of familiy specific header
     796                 :            :  * @maxtype: maximum attribute type to be expected
     797                 :            :  * @policy: validation policy
     798                 :            :  * @extack: extended ACK report struct
     799                 :            :  */
     800                 :          0 : static inline int nlmsg_validate_deprecated(const struct nlmsghdr *nlh,
     801                 :            :                                             int hdrlen, int maxtype,
     802                 :            :                                             const struct nla_policy *policy,
     803                 :            :                                             struct netlink_ext_ack *extack)
     804                 :            : {
     805         [ #  # ]:          0 :         if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
     806                 :            :                 return -EINVAL;
     807                 :            : 
     808                 :          0 :         return __nla_validate(nlmsg_attrdata(nlh, hdrlen),
     809                 :            :                               nlmsg_attrlen(nlh, hdrlen), maxtype,
     810                 :            :                               policy, NL_VALIDATE_LIBERAL, extack);
     811                 :            : }
     812                 :            : 
     813                 :            : 
     814                 :            : 
     815                 :            : /**
     816                 :            :  * nlmsg_report - need to report back to application?
     817                 :            :  * @nlh: netlink message header
     818                 :            :  *
     819                 :            :  * Returns 1 if a report back to the application is requested.
     820                 :            :  */
     821                 :         28 : static inline int nlmsg_report(const struct nlmsghdr *nlh)
     822                 :            : {
     823                 :         28 :         return !!(nlh->nlmsg_flags & NLM_F_ECHO);
     824                 :            : }
     825                 :            : 
     826                 :            : /**
     827                 :            :  * nlmsg_for_each_attr - iterate over a stream of attributes
     828                 :            :  * @pos: loop counter, set to current attribute
     829                 :            :  * @nlh: netlink message header
     830                 :            :  * @hdrlen: length of familiy specific header
     831                 :            :  * @rem: initialized to len, holds bytes currently remaining in stream
     832                 :            :  */
     833                 :            : #define nlmsg_for_each_attr(pos, nlh, hdrlen, rem) \
     834                 :            :         nla_for_each_attr(pos, nlmsg_attrdata(nlh, hdrlen), \
     835                 :            :                           nlmsg_attrlen(nlh, hdrlen), rem)
     836                 :            : 
     837                 :            : /**
     838                 :            :  * nlmsg_put - Add a new netlink message to an skb
     839                 :            :  * @skb: socket buffer to store message in
     840                 :            :  * @portid: netlink PORTID of requesting application
     841                 :            :  * @seq: sequence number of message
     842                 :            :  * @type: message type
     843                 :            :  * @payload: length of message payload
     844                 :            :  * @flags: message flags
     845                 :            :  *
     846                 :            :  * Returns NULL if the tailroom of the skb is insufficient to store
     847                 :            :  * the message header and payload.
     848                 :            :  */
     849                 :       1960 : static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
     850                 :            :                                          int type, int payload, int flags)
     851                 :            : {
     852   [ +  -  +  -  :       3920 :         if (unlikely(skb_tailroom(skb) < nlmsg_total_size(payload)))
          +  -  +  -  +  
          -  +  -  +  -  
          +  -  +  -  +  
          -  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     853                 :            :                 return NULL;
     854                 :            : 
     855                 :       1960 :         return __nlmsg_put(skb, portid, seq, type, payload, flags);
     856                 :            : }
     857                 :            : 
     858                 :            : /**
     859                 :            :  * nlmsg_put_answer - Add a new callback based netlink message to an skb
     860                 :            :  * @skb: socket buffer to store message in
     861                 :            :  * @cb: netlink callback
     862                 :            :  * @type: message type
     863                 :            :  * @payload: length of message payload
     864                 :            :  * @flags: message flags
     865                 :            :  *
     866                 :            :  * Returns NULL if the tailroom of the skb is insufficient to store
     867                 :            :  * the message header and payload.
     868                 :            :  */
     869                 :        280 : static inline struct nlmsghdr *nlmsg_put_answer(struct sk_buff *skb,
     870                 :            :                                                 struct netlink_callback *cb,
     871                 :            :                                                 int type, int payload,
     872                 :            :                                                 int flags)
     873                 :            : {
     874                 :        280 :         return nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
     875                 :            :                          type, payload, flags);
     876                 :            : }
     877                 :            : 
     878                 :            : /**
     879                 :            :  * nlmsg_new - Allocate a new netlink message
     880                 :            :  * @payload: size of the message payload
     881                 :            :  * @flags: the type of memory to allocate.
     882                 :            :  *
     883                 :            :  * Use NLMSG_DEFAULT_SIZE if the size of the payload isn't known
     884                 :            :  * and a good default is needed.
     885                 :            :  */
     886                 :       1904 : static inline struct sk_buff *nlmsg_new(size_t payload, gfp_t flags)
     887                 :            : {
     888                 :       1820 :         return alloc_skb(nlmsg_total_size(payload), flags);
     889                 :            : }
     890                 :            : 
     891                 :            : /**
     892                 :            :  * nlmsg_end - Finalize a netlink message
     893                 :            :  * @skb: socket buffer the message is stored in
     894                 :            :  * @nlh: netlink message header
     895                 :            :  *
     896                 :            :  * Corrects the netlink message header to include the appeneded
     897                 :            :  * attributes. Only necessary if attributes have been added to
     898                 :            :  * the message.
     899                 :            :  */
     900                 :       2380 : static inline void nlmsg_end(struct sk_buff *skb, struct nlmsghdr *nlh)
     901                 :            : {
     902   [ #  #  #  #  :       2380 :         nlh->nlmsg_len = skb_tail_pointer(skb) - (unsigned char *)nlh;
                   #  # ]
     903                 :          0 : }
     904                 :            : 
     905                 :            : /**
     906                 :            :  * nlmsg_get_pos - return current position in netlink message
     907                 :            :  * @skb: socket buffer the message is stored in
     908                 :            :  *
     909                 :            :  * Returns a pointer to the current tail of the message.
     910                 :            :  */
     911                 :          0 : static inline void *nlmsg_get_pos(struct sk_buff *skb)
     912                 :            : {
     913                 :          0 :         return skb_tail_pointer(skb);
     914                 :            : }
     915                 :            : 
     916                 :            : /**
     917                 :            :  * nlmsg_trim - Trim message to a mark
     918                 :            :  * @skb: socket buffer the message is stored in
     919                 :            :  * @mark: mark to trim to
     920                 :            :  *
     921                 :            :  * Trims the message to the provided mark.
     922                 :            :  */
     923                 :        364 : static inline void nlmsg_trim(struct sk_buff *skb, const void *mark)
     924                 :            : {
     925         [ +  - ]:        364 :         if (mark) {
     926         [ -  + ]:        364 :                 WARN_ON((unsigned char *) mark < skb->data);
     927                 :        364 :                 skb_trim(skb, (unsigned char *) mark - skb->data);
     928                 :            :         }
     929                 :        364 : }
     930                 :            : 
     931                 :            : /**
     932                 :            :  * nlmsg_cancel - Cancel construction of a netlink message
     933                 :            :  * @skb: socket buffer the message is stored in
     934                 :            :  * @nlh: netlink message header
     935                 :            :  *
     936                 :            :  * Removes the complete netlink message including all
     937                 :            :  * attributes from the socket buffer again.
     938                 :            :  */
     939                 :          0 : static inline void nlmsg_cancel(struct sk_buff *skb, struct nlmsghdr *nlh)
     940                 :            : {
     941                 :          0 :         nlmsg_trim(skb, nlh);
     942                 :          0 : }
     943                 :            : 
     944                 :            : /**
     945                 :            :  * nlmsg_free - free a netlink message
     946                 :            :  * @skb: socket buffer of netlink message
     947                 :            :  */
     948                 :          0 : static inline void nlmsg_free(struct sk_buff *skb)
     949                 :            : {
     950                 :          0 :         kfree_skb(skb);
     951                 :          0 : }
     952                 :            : 
     953                 :            : /**
     954                 :            :  * nlmsg_multicast - multicast a netlink message
     955                 :            :  * @sk: netlink socket to spread messages to
     956                 :            :  * @skb: netlink message as socket buffer
     957                 :            :  * @portid: own netlink portid to avoid sending to yourself
     958                 :            :  * @group: multicast group id
     959                 :            :  * @flags: allocation flags
     960                 :            :  */
     961                 :        896 : static inline int nlmsg_multicast(struct sock *sk, struct sk_buff *skb,
     962                 :            :                                   u32 portid, unsigned int group, gfp_t flags)
     963                 :            : {
     964                 :        896 :         int err;
     965                 :            : 
     966                 :        896 :         NETLINK_CB(skb).dst_group = group;
     967                 :            : 
     968                 :        896 :         err = netlink_broadcast(sk, skb, portid, group, flags);
     969                 :        896 :         if (err > 0)
     970                 :            :                 err = 0;
     971                 :            : 
     972   [ -  -  +  - ]:        896 :         return err;
     973                 :            : }
     974                 :            : 
     975                 :            : /**
     976                 :            :  * nlmsg_unicast - unicast a netlink message
     977                 :            :  * @sk: netlink socket to spread message to
     978                 :            :  * @skb: netlink message as socket buffer
     979                 :            :  * @portid: netlink portid of the destination socket
     980                 :            :  */
     981                 :          0 : static inline int nlmsg_unicast(struct sock *sk, struct sk_buff *skb, u32 portid)
     982                 :            : {
     983                 :          0 :         int err;
     984                 :            : 
     985                 :          0 :         err = netlink_unicast(sk, skb, portid, MSG_DONTWAIT);
     986                 :          0 :         if (err > 0)
     987                 :            :                 err = 0;
     988                 :            : 
     989         [ #  # ]:          0 :         return err;
     990                 :            : }
     991                 :            : 
     992                 :            : /**
     993                 :            :  * nlmsg_for_each_msg - iterate over a stream of messages
     994                 :            :  * @pos: loop counter, set to current message
     995                 :            :  * @head: head of message stream
     996                 :            :  * @len: length of message stream
     997                 :            :  * @rem: initialized to len, holds bytes currently remaining in stream
     998                 :            :  */
     999                 :            : #define nlmsg_for_each_msg(pos, head, len, rem) \
    1000                 :            :         for (pos = head, rem = len; \
    1001                 :            :              nlmsg_ok(pos, rem); \
    1002                 :            :              pos = nlmsg_next(pos, &(rem)))
    1003                 :            : 
    1004                 :            : /**
    1005                 :            :  * nl_dump_check_consistent - check if sequence is consistent and advertise if not
    1006                 :            :  * @cb: netlink callback structure that stores the sequence number
    1007                 :            :  * @nlh: netlink message header to write the flag to
    1008                 :            :  *
    1009                 :            :  * This function checks if the sequence (generation) number changed during dump
    1010                 :            :  * and if it did, advertises it in the netlink message header.
    1011                 :            :  *
    1012                 :            :  * The correct way to use it is to set cb->seq to the generation counter when
    1013                 :            :  * all locks for dumping have been acquired, and then call this function for
    1014                 :            :  * each message that is generated.
    1015                 :            :  *
    1016                 :            :  * Note that due to initialisation concerns, 0 is an invalid sequence number
    1017                 :            :  * and must not be used by code that uses this functionality.
    1018                 :            :  */
    1019                 :            : static inline void
    1020                 :        700 : nl_dump_check_consistent(struct netlink_callback *cb,
    1021                 :            :                          struct nlmsghdr *nlh)
    1022                 :            : {
    1023   [ +  +  -  +  :        700 :         if (cb->prev_seq && cb->seq != cb->prev_seq)
             +  +  -  + ]
    1024                 :          0 :                 nlh->nlmsg_flags |= NLM_F_DUMP_INTR;
    1025         [ -  + ]:        700 :         cb->prev_seq = cb->seq;
    1026                 :        140 : }
    1027                 :            : 
    1028                 :            : /**************************************************************************
    1029                 :            :  * Netlink Attributes
    1030                 :            :  **************************************************************************/
    1031                 :            : 
    1032                 :            : /**
    1033                 :            :  * nla_attr_size - length of attribute not including padding
    1034                 :            :  * @payload: length of payload
    1035                 :            :  */
    1036                 :     132362 : static inline int nla_attr_size(int payload)
    1037                 :            : {
    1038         [ #  # ]:     131074 :         return NLA_HDRLEN + payload;
    1039                 :            : }
    1040                 :            : 
    1041                 :            : /**
    1042                 :            :  * nla_total_size - total length of attribute including padding
    1043                 :            :  * @payload: length of payload
    1044                 :            :  */
    1045                 :     132362 : static inline int nla_total_size(int payload)
    1046                 :            : {
    1047   [ +  +  +  +  :      75992 :         return NLA_ALIGN(nla_attr_size(payload));
             +  -  +  - ]
    1048                 :            : }
    1049                 :            : 
    1050                 :            : /**
    1051                 :            :  * nla_padlen - length of padding at the tail of attribute
    1052                 :            :  * @payload: length of payload
    1053                 :            :  */
    1054                 :      36708 : static inline int nla_padlen(int payload)
    1055                 :            : {
    1056                 :      36708 :         return nla_total_size(payload) - nla_attr_size(payload);
    1057                 :            : }
    1058                 :            : 
    1059                 :            : /**
    1060                 :            :  * nla_type - attribute type
    1061                 :            :  * @nla: netlink attribute
    1062                 :            :  */
    1063                 :        448 : static inline int nla_type(const struct nlattr *nla)
    1064                 :            : {
    1065   [ -  -  +  -  :        224 :         return nla->nla_type & NLA_TYPE_MASK;
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1066                 :            : }
    1067                 :            : 
    1068                 :            : /**
    1069                 :            :  * nla_data - head of payload
    1070                 :            :  * @nla: netlink attribute
    1071                 :            :  */
    1072                 :      47292 : static inline void *nla_data(const struct nlattr *nla)
    1073                 :            : {
    1074   [ -  -  -  -  :      11872 :         return (char *) nla + NLA_HDRLEN;
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1075                 :            : }
    1076                 :            : 
    1077                 :            : /**
    1078                 :            :  * nla_len - length of payload
    1079                 :            :  * @nla: netlink attribute
    1080                 :            :  */
    1081                 :       1680 : static inline int nla_len(const struct nlattr *nla)
    1082                 :            : {
    1083   [ -  -  -  -  :       1680 :         return nla->nla_len - NLA_HDRLEN;
          -  -  -  -  -  
          -  -  +  -  -  
          -  -  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
    1084                 :            : }
    1085                 :            : 
    1086                 :            : /**
    1087                 :            :  * nla_ok - check if the netlink attribute fits into the remaining bytes
    1088                 :            :  * @nla: netlink attribute
    1089                 :            :  * @remaining: number of bytes remaining in attribute stream
    1090                 :            :  */
    1091                 :        784 : static inline int nla_ok(const struct nlattr *nla, int remaining)
    1092                 :            : {
    1093         [ #  # ]:       1008 :         return remaining >= (int) sizeof(*nla) &&
    1094   [ -  -  -  -  :        784 :                nla->nla_len >= sizeof(*nla) &&
          +  +  +  -  -  
          -  -  -  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
    1095   [ -  -  +  -  :        224 :                nla->nla_len <= remaining;
          -  -  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1096                 :            : }
    1097                 :            : 
    1098                 :            : /**
    1099                 :            :  * nla_next - next netlink attribute in attribute stream
    1100                 :            :  * @nla: netlink attribute
    1101                 :            :  * @remaining: number of bytes remaining in attribute stream
    1102                 :            :  *
    1103                 :            :  * Returns the next netlink attribute in the attribute stream and
    1104                 :            :  * decrements remaining by the size of the current attribute.
    1105                 :            :  */
    1106                 :        224 : static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)
    1107                 :            : {
    1108                 :        224 :         unsigned int totlen = NLA_ALIGN(nla->nla_len);
    1109                 :            : 
    1110                 :        224 :         *remaining -= totlen;
    1111                 :        224 :         return (struct nlattr *) ((char *) nla + totlen);
    1112                 :            : }
    1113                 :            : 
    1114                 :            : /**
    1115                 :            :  * nla_find_nested - find attribute in a set of nested attributes
    1116                 :            :  * @nla: attribute containing the nested attributes
    1117                 :            :  * @attrtype: type of attribute to look for
    1118                 :            :  *
    1119                 :            :  * Returns the first attribute which matches the specified type.
    1120                 :            :  */
    1121                 :            : static inline struct nlattr *
    1122                 :          0 : nla_find_nested(const struct nlattr *nla, int attrtype)
    1123                 :            : {
    1124                 :          0 :         return nla_find(nla_data(nla), nla_len(nla), attrtype);
    1125                 :            : }
    1126                 :            : 
    1127                 :            : /**
    1128                 :            :  * nla_parse_nested - parse nested attributes
    1129                 :            :  * @tb: destination array with maxtype+1 elements
    1130                 :            :  * @maxtype: maximum attribute type to be expected
    1131                 :            :  * @nla: attribute containing the nested attributes
    1132                 :            :  * @policy: validation policy
    1133                 :            :  * @extack: extended ACK report struct
    1134                 :            :  *
    1135                 :            :  * See nla_parse()
    1136                 :            :  */
    1137                 :          0 : static inline int nla_parse_nested(struct nlattr *tb[], int maxtype,
    1138                 :            :                                    const struct nlattr *nla,
    1139                 :            :                                    const struct nla_policy *policy,
    1140                 :            :                                    struct netlink_ext_ack *extack)
    1141                 :            : {
    1142   [ #  #  #  # ]:          0 :         if (!(nla->nla_type & NLA_F_NESTED)) {
    1143         [ #  # ]:          0 :                 NL_SET_ERR_MSG_ATTR(extack, nla, "NLA_F_NESTED is missing");
    1144                 :          0 :                 return -EINVAL;
    1145                 :            :         }
    1146                 :            : 
    1147                 :          0 :         return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
    1148                 :            :                            NL_VALIDATE_STRICT, extack);
    1149                 :            : }
    1150                 :            : 
    1151                 :            : /**
    1152                 :            :  * nla_parse_nested_deprecated - parse nested attributes
    1153                 :            :  * @tb: destination array with maxtype+1 elements
    1154                 :            :  * @maxtype: maximum attribute type to be expected
    1155                 :            :  * @nla: attribute containing the nested attributes
    1156                 :            :  * @policy: validation policy
    1157                 :            :  * @extack: extended ACK report struct
    1158                 :            :  *
    1159                 :            :  * See nla_parse_deprecated()
    1160                 :            :  */
    1161                 :          0 : static inline int nla_parse_nested_deprecated(struct nlattr *tb[], int maxtype,
    1162                 :            :                                               const struct nlattr *nla,
    1163                 :            :                                               const struct nla_policy *policy,
    1164                 :            :                                               struct netlink_ext_ack *extack)
    1165                 :            : {
    1166                 :          0 :         return __nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy,
    1167                 :            :                            NL_VALIDATE_LIBERAL, extack);
    1168                 :            : }
    1169                 :            : 
    1170                 :            : /**
    1171                 :            :  * nla_put_u8 - Add a u8 netlink attribute to a socket buffer
    1172                 :            :  * @skb: socket buffer to add attribute to
    1173                 :            :  * @attrtype: attribute type
    1174                 :            :  * @value: numeric value
    1175                 :            :  */
    1176                 :       2884 : static inline int nla_put_u8(struct sk_buff *skb, int attrtype, u8 value)
    1177                 :            : {
    1178                 :            :         /* temporary variables to work around GCC PR81715 with asan-stack=1 */
    1179                 :       2884 :         u8 tmp = value;
    1180                 :            : 
    1181                 :       2884 :         return nla_put(skb, attrtype, sizeof(u8), &tmp);
    1182                 :            : }
    1183                 :            : 
    1184                 :            : /**
    1185                 :            :  * nla_put_u16 - Add a u16 netlink attribute to a socket buffer
    1186                 :            :  * @skb: socket buffer to add attribute to
    1187                 :            :  * @attrtype: attribute type
    1188                 :            :  * @value: numeric value
    1189                 :            :  */
    1190                 :        896 : static inline int nla_put_u16(struct sk_buff *skb, int attrtype, u16 value)
    1191                 :            : {
    1192                 :        896 :         u16 tmp = value;
    1193                 :            : 
    1194                 :        896 :         return nla_put(skb, attrtype, sizeof(u16), &tmp);
    1195                 :            : }
    1196                 :            : 
    1197                 :            : /**
    1198                 :            :  * nla_put_be16 - Add a __be16 netlink attribute to a socket buffer
    1199                 :            :  * @skb: socket buffer to add attribute to
    1200                 :            :  * @attrtype: attribute type
    1201                 :            :  * @value: numeric value
    1202                 :            :  */
    1203                 :        504 : static inline int nla_put_be16(struct sk_buff *skb, int attrtype, __be16 value)
    1204                 :            : {
    1205                 :        504 :         __be16 tmp = value;
    1206                 :            : 
    1207                 :        504 :         return nla_put(skb, attrtype, sizeof(__be16), &tmp);
    1208                 :            : }
    1209                 :            : 
    1210                 :            : /**
    1211                 :            :  * nla_put_net16 - Add 16-bit network byte order netlink attribute to a socket buffer
    1212                 :            :  * @skb: socket buffer to add attribute to
    1213                 :            :  * @attrtype: attribute type
    1214                 :            :  * @value: numeric value
    1215                 :            :  */
    1216                 :            : static inline int nla_put_net16(struct sk_buff *skb, int attrtype, __be16 value)
    1217                 :            : {
    1218                 :            :         __be16 tmp = value;
    1219                 :            : 
    1220                 :            :         return nla_put_be16(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
    1221                 :            : }
    1222                 :            : 
    1223                 :            : /**
    1224                 :            :  * nla_put_le16 - Add a __le16 netlink attribute to a socket buffer
    1225                 :            :  * @skb: socket buffer to add attribute to
    1226                 :            :  * @attrtype: attribute type
    1227                 :            :  * @value: numeric value
    1228                 :            :  */
    1229                 :            : static inline int nla_put_le16(struct sk_buff *skb, int attrtype, __le16 value)
    1230                 :            : {
    1231                 :            :         __le16 tmp = value;
    1232                 :            : 
    1233                 :            :         return nla_put(skb, attrtype, sizeof(__le16), &tmp);
    1234                 :            : }
    1235                 :            : 
    1236                 :            : /**
    1237                 :            :  * nla_put_u32 - Add a u32 netlink attribute to a socket buffer
    1238                 :            :  * @skb: socket buffer to add attribute to
    1239                 :            :  * @attrtype: attribute type
    1240                 :            :  * @value: numeric value
    1241                 :            :  */
    1242                 :      15932 : static inline int nla_put_u32(struct sk_buff *skb, int attrtype, u32 value)
    1243                 :            : {
    1244                 :      15932 :         u32 tmp = value;
    1245                 :            : 
    1246                 :      15932 :         return nla_put(skb, attrtype, sizeof(u32), &tmp);
    1247                 :            : }
    1248                 :            : 
    1249                 :            : /**
    1250                 :            :  * nla_put_be32 - Add a __be32 netlink attribute to a socket buffer
    1251                 :            :  * @skb: socket buffer to add attribute to
    1252                 :            :  * @attrtype: attribute type
    1253                 :            :  * @value: numeric value
    1254                 :            :  */
    1255                 :        896 : static inline int nla_put_be32(struct sk_buff *skb, int attrtype, __be32 value)
    1256                 :            : {
    1257                 :        896 :         __be32 tmp = value;
    1258                 :            : 
    1259                 :        896 :         return nla_put(skb, attrtype, sizeof(__be32), &tmp);
    1260                 :            : }
    1261                 :            : 
    1262                 :            : /**
    1263                 :            :  * nla_put_net32 - Add 32-bit network byte order netlink attribute to a socket buffer
    1264                 :            :  * @skb: socket buffer to add attribute to
    1265                 :            :  * @attrtype: attribute type
    1266                 :            :  * @value: numeric value
    1267                 :            :  */
    1268                 :            : static inline int nla_put_net32(struct sk_buff *skb, int attrtype, __be32 value)
    1269                 :            : {
    1270                 :            :         __be32 tmp = value;
    1271                 :            : 
    1272                 :            :         return nla_put_be32(skb, attrtype | NLA_F_NET_BYTEORDER, tmp);
    1273                 :            : }
    1274                 :            : 
    1275                 :            : /**
    1276                 :            :  * nla_put_le32 - Add a __le32 netlink attribute to a socket buffer
    1277                 :            :  * @skb: socket buffer to add attribute to
    1278                 :            :  * @attrtype: attribute type
    1279                 :            :  * @value: numeric value
    1280                 :            :  */
    1281                 :            : static inline int nla_put_le32(struct sk_buff *skb, int attrtype, __le32 value)
    1282                 :            : {
    1283                 :            :         __le32 tmp = value;
    1284                 :            : 
    1285                 :            :         return nla_put(skb, attrtype, sizeof(__le32), &tmp);
    1286                 :            : }
    1287                 :            : 
    1288                 :            : /**
    1289                 :            :  * nla_put_u64_64bit - Add a u64 netlink attribute to a skb and align it
    1290                 :            :  * @skb: socket buffer to add attribute to
    1291                 :            :  * @attrtype: attribute type
    1292                 :            :  * @value: numeric value
    1293                 :            :  * @padattr: attribute type for the padding
    1294                 :            :  */
    1295                 :          0 : static inline int nla_put_u64_64bit(struct sk_buff *skb, int attrtype,
    1296                 :            :                                     u64 value, int padattr)
    1297                 :            : {
    1298                 :          0 :         u64 tmp = value;
    1299                 :            : 
    1300                 :          0 :         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
    1301                 :            : }
    1302                 :            : 
    1303                 :            : /**
    1304                 :            :  * nla_put_be64 - Add a __be64 netlink attribute to a socket buffer and align it
    1305                 :            :  * @skb: socket buffer to add attribute to
    1306                 :            :  * @attrtype: attribute type
    1307                 :            :  * @value: numeric value
    1308                 :            :  * @padattr: attribute type for the padding
    1309                 :            :  */
    1310                 :          0 : static inline int nla_put_be64(struct sk_buff *skb, int attrtype, __be64 value,
    1311                 :            :                                int padattr)
    1312                 :            : {
    1313                 :          0 :         __be64 tmp = value;
    1314                 :            : 
    1315                 :          0 :         return nla_put_64bit(skb, attrtype, sizeof(__be64), &tmp, padattr);
    1316                 :            : }
    1317                 :            : 
    1318                 :            : /**
    1319                 :            :  * nla_put_net64 - Add 64-bit network byte order nlattr to a skb and align it
    1320                 :            :  * @skb: socket buffer to add attribute to
    1321                 :            :  * @attrtype: attribute type
    1322                 :            :  * @value: numeric value
    1323                 :            :  * @padattr: attribute type for the padding
    1324                 :            :  */
    1325                 :            : static inline int nla_put_net64(struct sk_buff *skb, int attrtype, __be64 value,
    1326                 :            :                                 int padattr)
    1327                 :            : {
    1328                 :            :         __be64 tmp = value;
    1329                 :            : 
    1330                 :            :         return nla_put_be64(skb, attrtype | NLA_F_NET_BYTEORDER, tmp,
    1331                 :            :                             padattr);
    1332                 :            : }
    1333                 :            : 
    1334                 :            : /**
    1335                 :            :  * nla_put_le64 - Add a __le64 netlink attribute to a socket buffer and align it
    1336                 :            :  * @skb: socket buffer to add attribute to
    1337                 :            :  * @attrtype: attribute type
    1338                 :            :  * @value: numeric value
    1339                 :            :  * @padattr: attribute type for the padding
    1340                 :            :  */
    1341                 :            : static inline int nla_put_le64(struct sk_buff *skb, int attrtype, __le64 value,
    1342                 :            :                                int padattr)
    1343                 :            : {
    1344                 :            :         __le64 tmp = value;
    1345                 :            : 
    1346                 :            :         return nla_put_64bit(skb, attrtype, sizeof(__le64), &tmp, padattr);
    1347                 :            : }
    1348                 :            : 
    1349                 :            : /**
    1350                 :            :  * nla_put_s8 - Add a s8 netlink attribute to a socket buffer
    1351                 :            :  * @skb: socket buffer to add attribute to
    1352                 :            :  * @attrtype: attribute type
    1353                 :            :  * @value: numeric value
    1354                 :            :  */
    1355                 :          0 : static inline int nla_put_s8(struct sk_buff *skb, int attrtype, s8 value)
    1356                 :            : {
    1357                 :          0 :         s8 tmp = value;
    1358                 :            : 
    1359                 :          0 :         return nla_put(skb, attrtype, sizeof(s8), &tmp);
    1360                 :            : }
    1361                 :            : 
    1362                 :            : /**
    1363                 :            :  * nla_put_s16 - Add a s16 netlink attribute to a socket buffer
    1364                 :            :  * @skb: socket buffer to add attribute to
    1365                 :            :  * @attrtype: attribute type
    1366                 :            :  * @value: numeric value
    1367                 :            :  */
    1368                 :            : static inline int nla_put_s16(struct sk_buff *skb, int attrtype, s16 value)
    1369                 :            : {
    1370                 :            :         s16 tmp = value;
    1371                 :            : 
    1372                 :            :         return nla_put(skb, attrtype, sizeof(s16), &tmp);
    1373                 :            : }
    1374                 :            : 
    1375                 :            : /**
    1376                 :            :  * nla_put_s32 - Add a s32 netlink attribute to a socket buffer
    1377                 :            :  * @skb: socket buffer to add attribute to
    1378                 :            :  * @attrtype: attribute type
    1379                 :            :  * @value: numeric value
    1380                 :            :  */
    1381                 :       1232 : static inline int nla_put_s32(struct sk_buff *skb, int attrtype, s32 value)
    1382                 :            : {
    1383                 :       1232 :         s32 tmp = value;
    1384                 :            : 
    1385                 :       1232 :         return nla_put(skb, attrtype, sizeof(s32), &tmp);
    1386                 :            : }
    1387                 :            : 
    1388                 :            : /**
    1389                 :            :  * nla_put_s64 - Add a s64 netlink attribute to a socket buffer and align it
    1390                 :            :  * @skb: socket buffer to add attribute to
    1391                 :            :  * @attrtype: attribute type
    1392                 :            :  * @value: numeric value
    1393                 :            :  * @padattr: attribute type for the padding
    1394                 :            :  */
    1395                 :            : static inline int nla_put_s64(struct sk_buff *skb, int attrtype, s64 value,
    1396                 :            :                               int padattr)
    1397                 :            : {
    1398                 :            :         s64 tmp = value;
    1399                 :            : 
    1400                 :            :         return nla_put_64bit(skb, attrtype, sizeof(s64), &tmp, padattr);
    1401                 :            : }
    1402                 :            : 
    1403                 :            : /**
    1404                 :            :  * nla_put_string - Add a string netlink attribute to a socket buffer
    1405                 :            :  * @skb: socket buffer to add attribute to
    1406                 :            :  * @attrtype: attribute type
    1407                 :            :  * @str: NUL terminated string
    1408                 :            :  */
    1409                 :       2156 : static inline int nla_put_string(struct sk_buff *skb, int attrtype,
    1410                 :            :                                  const char *str)
    1411                 :            : {
    1412                 :       2156 :         return nla_put(skb, attrtype, strlen(str) + 1, str);
    1413                 :            : }
    1414                 :            : 
    1415                 :            : /**
    1416                 :            :  * nla_put_flag - Add a flag netlink attribute to a socket buffer
    1417                 :            :  * @skb: socket buffer to add attribute to
    1418                 :            :  * @attrtype: attribute type
    1419                 :            :  */
    1420                 :          0 : static inline int nla_put_flag(struct sk_buff *skb, int attrtype)
    1421                 :            : {
    1422                 :          0 :         return nla_put(skb, attrtype, 0, NULL);
    1423                 :            : }
    1424                 :            : 
    1425                 :            : /**
    1426                 :            :  * nla_put_msecs - Add a msecs netlink attribute to a skb and align it
    1427                 :            :  * @skb: socket buffer to add attribute to
    1428                 :            :  * @attrtype: attribute type
    1429                 :            :  * @njiffies: number of jiffies to convert to msecs
    1430                 :            :  * @padattr: attribute type for the padding
    1431                 :            :  */
    1432                 :          0 : static inline int nla_put_msecs(struct sk_buff *skb, int attrtype,
    1433                 :            :                                 unsigned long njiffies, int padattr)
    1434                 :            : {
    1435                 :          0 :         u64 tmp = jiffies_to_msecs(njiffies);
    1436                 :            : 
    1437                 :          0 :         return nla_put_64bit(skb, attrtype, sizeof(u64), &tmp, padattr);
    1438                 :            : }
    1439                 :            : 
    1440                 :            : /**
    1441                 :            :  * nla_put_in_addr - Add an IPv4 address netlink attribute to a socket
    1442                 :            :  * buffer
    1443                 :            :  * @skb: socket buffer to add attribute to
    1444                 :            :  * @attrtype: attribute type
    1445                 :            :  * @addr: IPv4 address
    1446                 :            :  */
    1447                 :        896 : static inline int nla_put_in_addr(struct sk_buff *skb, int attrtype,
    1448                 :            :                                   __be32 addr)
    1449                 :            : {
    1450                 :        896 :         __be32 tmp = addr;
    1451                 :            : 
    1452                 :        896 :         return nla_put_be32(skb, attrtype, tmp);
    1453                 :            : }
    1454                 :            : 
    1455                 :            : /**
    1456                 :            :  * nla_put_in6_addr - Add an IPv6 address netlink attribute to a socket
    1457                 :            :  * buffer
    1458                 :            :  * @skb: socket buffer to add attribute to
    1459                 :            :  * @attrtype: attribute type
    1460                 :            :  * @addr: IPv6 address
    1461                 :            :  */
    1462                 :        196 : static inline int nla_put_in6_addr(struct sk_buff *skb, int attrtype,
    1463                 :            :                                    const struct in6_addr *addr)
    1464                 :            : {
    1465                 :        196 :         return nla_put(skb, attrtype, sizeof(*addr), addr);
    1466                 :            : }
    1467                 :            : 
    1468                 :            : /**
    1469                 :            :  * nla_get_u32 - return payload of u32 attribute
    1470                 :            :  * @nla: u32 netlink attribute
    1471                 :            :  */
    1472                 :        112 : static inline u32 nla_get_u32(const struct nlattr *nla)
    1473                 :            : {
    1474   [ -  -  -  -  :        112 :         return *(u32 *) nla_data(nla);
          -  -  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1475                 :            : }
    1476                 :            : 
    1477                 :            : /**
    1478                 :            :  * nla_get_be32 - return payload of __be32 attribute
    1479                 :            :  * @nla: __be32 netlink attribute
    1480                 :            :  */
    1481                 :          0 : static inline __be32 nla_get_be32(const struct nlattr *nla)
    1482                 :            : {
    1483   [ #  #  #  #  :          0 :         return *(__be32 *) nla_data(nla);
             #  #  #  # ]
    1484                 :            : }
    1485                 :            : 
    1486                 :            : /**
    1487                 :            :  * nla_get_le32 - return payload of __le32 attribute
    1488                 :            :  * @nla: __le32 netlink attribute
    1489                 :            :  */
    1490                 :            : static inline __le32 nla_get_le32(const struct nlattr *nla)
    1491                 :            : {
    1492                 :            :         return *(__le32 *) nla_data(nla);
    1493                 :            : }
    1494                 :            : 
    1495                 :            : /**
    1496                 :            :  * nla_get_u16 - return payload of u16 attribute
    1497                 :            :  * @nla: u16 netlink attribute
    1498                 :            :  */
    1499                 :          0 : static inline u16 nla_get_u16(const struct nlattr *nla)
    1500                 :            : {
    1501   [ #  #  #  #  :          0 :         return *(u16 *) nla_data(nla);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1502                 :            : }
    1503                 :            : 
    1504                 :            : /**
    1505                 :            :  * nla_get_be16 - return payload of __be16 attribute
    1506                 :            :  * @nla: __be16 netlink attribute
    1507                 :            :  */
    1508                 :          0 : static inline __be16 nla_get_be16(const struct nlattr *nla)
    1509                 :            : {
    1510         [ #  # ]:          0 :         return *(__be16 *) nla_data(nla);
    1511                 :            : }
    1512                 :            : 
    1513                 :            : /**
    1514                 :            :  * nla_get_le16 - return payload of __le16 attribute
    1515                 :            :  * @nla: __le16 netlink attribute
    1516                 :            :  */
    1517                 :            : static inline __le16 nla_get_le16(const struct nlattr *nla)
    1518                 :            : {
    1519                 :            :         return *(__le16 *) nla_data(nla);
    1520                 :            : }
    1521                 :            : 
    1522                 :            : /**
    1523                 :            :  * nla_get_u8 - return payload of u8 attribute
    1524                 :            :  * @nla: u8 netlink attribute
    1525                 :            :  */
    1526                 :          0 : static inline u8 nla_get_u8(const struct nlattr *nla)
    1527                 :            : {
    1528   [ #  #  #  #  :          0 :         return *(u8 *) nla_data(nla);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
    1529                 :            : }
    1530                 :            : 
    1531                 :            : /**
    1532                 :            :  * nla_get_u64 - return payload of u64 attribute
    1533                 :            :  * @nla: u64 netlink attribute
    1534                 :            :  */
    1535                 :          0 : static inline u64 nla_get_u64(const struct nlattr *nla)
    1536                 :            : {
    1537                 :          0 :         u64 tmp;
    1538                 :            : 
    1539                 :          0 :         nla_memcpy(&tmp, nla, sizeof(tmp));
    1540                 :            : 
    1541   [ #  #  #  # ]:          0 :         return tmp;
    1542                 :            : }
    1543                 :            : 
    1544                 :            : /**
    1545                 :            :  * nla_get_be64 - return payload of __be64 attribute
    1546                 :            :  * @nla: __be64 netlink attribute
    1547                 :            :  */
    1548                 :            : static inline __be64 nla_get_be64(const struct nlattr *nla)
    1549                 :            : {
    1550                 :            :         __be64 tmp;
    1551                 :            : 
    1552                 :            :         nla_memcpy(&tmp, nla, sizeof(tmp));
    1553                 :            : 
    1554                 :            :         return tmp;
    1555                 :            : }
    1556                 :            : 
    1557                 :            : /**
    1558                 :            :  * nla_get_le64 - return payload of __le64 attribute
    1559                 :            :  * @nla: __le64 netlink attribute
    1560                 :            :  */
    1561                 :            : static inline __le64 nla_get_le64(const struct nlattr *nla)
    1562                 :            : {
    1563                 :            :         return *(__le64 *) nla_data(nla);
    1564                 :            : }
    1565                 :            : 
    1566                 :            : /**
    1567                 :            :  * nla_get_s32 - return payload of s32 attribute
    1568                 :            :  * @nla: s32 netlink attribute
    1569                 :            :  */
    1570                 :          0 : static inline s32 nla_get_s32(const struct nlattr *nla)
    1571                 :            : {
    1572      [ #  #  # ]:          0 :         return *(s32 *) nla_data(nla);
    1573                 :            : }
    1574                 :            : 
    1575                 :            : /**
    1576                 :            :  * nla_get_s16 - return payload of s16 attribute
    1577                 :            :  * @nla: s16 netlink attribute
    1578                 :            :  */
    1579                 :          0 : static inline s16 nla_get_s16(const struct nlattr *nla)
    1580                 :            : {
    1581                 :          0 :         return *(s16 *) nla_data(nla);
    1582                 :            : }
    1583                 :            : 
    1584                 :            : /**
    1585                 :            :  * nla_get_s8 - return payload of s8 attribute
    1586                 :            :  * @nla: s8 netlink attribute
    1587                 :            :  */
    1588                 :          0 : static inline s8 nla_get_s8(const struct nlattr *nla)
    1589                 :            : {
    1590                 :          0 :         return *(s8 *) nla_data(nla);
    1591                 :            : }
    1592                 :            : 
    1593                 :            : /**
    1594                 :            :  * nla_get_s64 - return payload of s64 attribute
    1595                 :            :  * @nla: s64 netlink attribute
    1596                 :            :  */
    1597                 :          0 : static inline s64 nla_get_s64(const struct nlattr *nla)
    1598                 :            : {
    1599                 :          0 :         s64 tmp;
    1600                 :            : 
    1601                 :          0 :         nla_memcpy(&tmp, nla, sizeof(tmp));
    1602                 :            : 
    1603                 :          0 :         return tmp;
    1604                 :            : }
    1605                 :            : 
    1606                 :            : /**
    1607                 :            :  * nla_get_flag - return payload of flag attribute
    1608                 :            :  * @nla: flag netlink attribute
    1609                 :            :  */
    1610                 :          0 : static inline int nla_get_flag(const struct nlattr *nla)
    1611                 :            : {
    1612   [ #  #  #  #  :          0 :         return !!nla;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
    1613                 :            : }
    1614                 :            : 
    1615                 :            : /**
    1616                 :            :  * nla_get_msecs - return payload of msecs attribute
    1617                 :            :  * @nla: msecs netlink attribute
    1618                 :            :  *
    1619                 :            :  * Returns the number of milliseconds in jiffies.
    1620                 :            :  */
    1621                 :          0 : static inline unsigned long nla_get_msecs(const struct nlattr *nla)
    1622                 :            : {
    1623                 :          0 :         u64 msecs = nla_get_u64(nla);
    1624                 :            : 
    1625         [ #  # ]:          0 :         return msecs_to_jiffies((unsigned long) msecs);
    1626                 :            : }
    1627                 :            : 
    1628                 :            : /**
    1629                 :            :  * nla_get_in_addr - return payload of IPv4 address attribute
    1630                 :            :  * @nla: IPv4 address netlink attribute
    1631                 :            :  */
    1632                 :         28 : static inline __be32 nla_get_in_addr(const struct nlattr *nla)
    1633                 :            : {
    1634   [ -  +  -  -  :         28 :         return *(__be32 *) nla_data(nla);
                   -  - ]
    1635                 :            : }
    1636                 :            : 
    1637                 :            : /**
    1638                 :            :  * nla_get_in6_addr - return payload of IPv6 address attribute
    1639                 :            :  * @nla: IPv6 address netlink attribute
    1640                 :            :  */
    1641                 :          0 : static inline struct in6_addr nla_get_in6_addr(const struct nlattr *nla)
    1642                 :            : {
    1643                 :          0 :         struct in6_addr tmp;
    1644                 :            : 
    1645                 :          0 :         nla_memcpy(&tmp, nla, sizeof(tmp));
    1646                 :          0 :         return tmp;
    1647                 :            : }
    1648                 :            : 
    1649                 :            : /**
    1650                 :            :  * nla_get_bitfield32 - return payload of 32 bitfield attribute
    1651                 :            :  * @nla: nla_bitfield32 attribute
    1652                 :            :  */
    1653                 :          0 : static inline struct nla_bitfield32 nla_get_bitfield32(const struct nlattr *nla)
    1654                 :            : {
    1655                 :          0 :         struct nla_bitfield32 tmp;
    1656                 :            : 
    1657                 :          0 :         nla_memcpy(&tmp, nla, sizeof(tmp));
    1658                 :          0 :         return tmp;
    1659                 :            : }
    1660                 :            : 
    1661                 :            : /**
    1662                 :            :  * nla_memdup - duplicate attribute memory (kmemdup)
    1663                 :            :  * @src: netlink attribute to duplicate from
    1664                 :            :  * @gfp: GFP mask
    1665                 :            :  */
    1666                 :          0 : static inline void *nla_memdup(const struct nlattr *src, gfp_t gfp)
    1667                 :            : {
    1668                 :          0 :         return kmemdup(nla_data(src), nla_len(src), gfp);
    1669                 :            : }
    1670                 :            : 
    1671                 :            : /**
    1672                 :            :  * nla_nest_start_noflag - Start a new level of nested attributes
    1673                 :            :  * @skb: socket buffer to add attributes to
    1674                 :            :  * @attrtype: attribute type of container
    1675                 :            :  *
    1676                 :            :  * This function exists for backward compatibility to use in APIs which never
    1677                 :            :  * marked their nest attributes with NLA_F_NESTED flag. New APIs should use
    1678                 :            :  * nla_nest_start() which sets the flag.
    1679                 :            :  *
    1680                 :            :  * Returns the container attribute or NULL on error
    1681                 :            :  */
    1682                 :       7364 : static inline struct nlattr *nla_nest_start_noflag(struct sk_buff *skb,
    1683                 :            :                                                    int attrtype)
    1684                 :            : {
    1685                 :       7000 :         struct nlattr *start = (struct nlattr *)skb_tail_pointer(skb);
    1686                 :            : 
    1687   [ +  -  +  -  :       7364 :         if (nla_put(skb, attrtype, 0, NULL) < 0)
          +  -  +  -  +  
          -  +  -  -  -  
          -  -  -  -  -  
          -  -  -  -  -  
          -  -  -  -  +  
          -  +  -  -  -  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
    1688                 :          0 :                 return NULL;
    1689                 :            : 
    1690                 :            :         return start;
    1691                 :            : }
    1692                 :            : 
    1693                 :            : /**
    1694                 :            :  * nla_nest_start - Start a new level of nested attributes, with NLA_F_NESTED
    1695                 :            :  * @skb: socket buffer to add attributes to
    1696                 :            :  * @attrtype: attribute type of container
    1697                 :            :  *
    1698                 :            :  * Unlike nla_nest_start_noflag(), mark the nest attribute with NLA_F_NESTED
    1699                 :            :  * flag. This is the preferred function to use in new code.
    1700                 :            :  *
    1701                 :            :  * Returns the container attribute or NULL on error
    1702                 :            :  */
    1703                 :        364 : static inline struct nlattr *nla_nest_start(struct sk_buff *skb, int attrtype)
    1704                 :            : {
    1705                 :        364 :         return nla_nest_start_noflag(skb, attrtype | NLA_F_NESTED);
    1706                 :            : }
    1707                 :            : 
    1708                 :            : /**
    1709                 :            :  * nla_nest_end - Finalize nesting of attributes
    1710                 :            :  * @skb: socket buffer the attributes are stored in
    1711                 :            :  * @start: container attribute
    1712                 :            :  *
    1713                 :            :  * Corrects the container attribute header to include the all
    1714                 :            :  * appeneded attributes.
    1715                 :            :  *
    1716                 :            :  * Returns the total data length of the skb.
    1717                 :            :  */
    1718                 :       6748 : static inline int nla_nest_end(struct sk_buff *skb, struct nlattr *start)
    1719                 :            : {
    1720   [ -  -  #  #  :       6748 :         start->nla_len = skb_tail_pointer(skb) - (unsigned char *)start;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1721   [ -  -  #  #  :       6748 :         return skb->len;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1722                 :            : }
    1723                 :            : 
    1724                 :            : /**
    1725                 :            :  * nla_nest_cancel - Cancel nesting of attributes
    1726                 :            :  * @skb: socket buffer the message is stored in
    1727                 :            :  * @start: container attribute
    1728                 :            :  *
    1729                 :            :  * Removes the container attribute and including all nested
    1730                 :            :  * attributes. Returns -EMSGSIZE
    1731                 :            :  */
    1732                 :        364 : static inline void nla_nest_cancel(struct sk_buff *skb, struct nlattr *start)
    1733                 :            : {
    1734                 :        364 :         nlmsg_trim(skb, start);
    1735                 :          0 : }
    1736                 :            : 
    1737                 :            : /**
    1738                 :            :  * __nla_validate_nested - Validate a stream of nested attributes
    1739                 :            :  * @start: container attribute
    1740                 :            :  * @maxtype: maximum attribute type to be expected
    1741                 :            :  * @policy: validation policy
    1742                 :            :  * @validate: validation strictness
    1743                 :            :  * @extack: extended ACK report struct
    1744                 :            :  *
    1745                 :            :  * Validates all attributes in the nested attribute stream against the
    1746                 :            :  * specified policy. Attributes with a type exceeding maxtype will be
    1747                 :            :  * ignored. See documenation of struct nla_policy for more details.
    1748                 :            :  *
    1749                 :            :  * Returns 0 on success or a negative error code.
    1750                 :            :  */
    1751                 :          0 : static inline int __nla_validate_nested(const struct nlattr *start, int maxtype,
    1752                 :            :                                         const struct nla_policy *policy,
    1753                 :            :                                         unsigned int validate,
    1754                 :            :                                         struct netlink_ext_ack *extack)
    1755                 :            : {
    1756                 :          0 :         return __nla_validate(nla_data(start), nla_len(start), maxtype, policy,
    1757                 :            :                               validate, extack);
    1758                 :            : }
    1759                 :            : 
    1760                 :            : static inline int
    1761                 :          0 : nla_validate_nested(const struct nlattr *start, int maxtype,
    1762                 :            :                     const struct nla_policy *policy,
    1763                 :            :                     struct netlink_ext_ack *extack)
    1764                 :            : {
    1765                 :          0 :         return __nla_validate_nested(start, maxtype, policy,
    1766                 :            :                                      NL_VALIDATE_STRICT, extack);
    1767                 :            : }
    1768                 :            : 
    1769                 :            : static inline int
    1770                 :          0 : nla_validate_nested_deprecated(const struct nlattr *start, int maxtype,
    1771                 :            :                                const struct nla_policy *policy,
    1772                 :            :                                struct netlink_ext_ack *extack)
    1773                 :            : {
    1774                 :          0 :         return __nla_validate_nested(start, maxtype, policy,
    1775                 :            :                                      NL_VALIDATE_LIBERAL, extack);
    1776                 :            : }
    1777                 :            : 
    1778                 :            : /**
    1779                 :            :  * nla_need_padding_for_64bit - test 64-bit alignment of the next attribute
    1780                 :            :  * @skb: socket buffer the message is stored in
    1781                 :            :  *
    1782                 :            :  * Return true if padding is needed to align the next attribute (nla_data()) to
    1783                 :            :  * a 64-bit aligned area.
    1784                 :            :  */
    1785                 :       1456 : static inline bool nla_need_padding_for_64bit(struct sk_buff *skb)
    1786                 :            : {
    1787                 :            : #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
    1788                 :            :         /* The nlattr header is 4 bytes in size, that's why we test
    1789                 :            :          * if the skb->data _is_ aligned.  A NOP attribute, plus
    1790                 :            :          * nlattr header for next attribute, will make nla_data()
    1791                 :            :          * 8-byte aligned.
    1792                 :            :          */
    1793                 :            :         if (IS_ALIGNED((unsigned long)skb_tail_pointer(skb), 8))
    1794                 :            :                 return true;
    1795                 :            : #endif
    1796   [ +  -  +  - ]:       1456 :         return false;
    1797                 :            : }
    1798                 :            : 
    1799                 :            : /**
    1800                 :            :  * nla_align_64bit - 64-bit align the nla_data() of next attribute
    1801                 :            :  * @skb: socket buffer the message is stored in
    1802                 :            :  * @padattr: attribute type for the padding
    1803                 :            :  *
    1804                 :            :  * Conditionally emit a padding netlink attribute in order to make
    1805                 :            :  * the next attribute we emit have a 64-bit aligned nla_data() area.
    1806                 :            :  * This will only be done in architectures which do not have
    1807                 :            :  * CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS defined.
    1808                 :            :  *
    1809                 :            :  * Returns zero on success or a negative error code.
    1810                 :            :  */
    1811                 :            : static inline int nla_align_64bit(struct sk_buff *skb, int padattr)
    1812                 :            : {
    1813                 :            :         if (nla_need_padding_for_64bit(skb) &&
    1814                 :            :             !nla_reserve(skb, padattr, 0))
    1815                 :            :                 return -EMSGSIZE;
    1816                 :            : 
    1817                 :            :         return 0;
    1818                 :            : }
    1819                 :            : 
    1820                 :            : /**
    1821                 :            :  * nla_total_size_64bit - total length of attribute including padding
    1822                 :            :  * @payload: length of payload
    1823                 :            :  */
    1824                 :      19382 : static inline int nla_total_size_64bit(int payload)
    1825                 :            : {
    1826         [ -  + ]:      19382 :         return NLA_ALIGN(nla_attr_size(payload))
    1827                 :            : #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
    1828                 :            :                 + NLA_ALIGN(nla_attr_size(0))
    1829                 :            : #endif
    1830                 :            :                 ;
    1831                 :            : }
    1832                 :            : 
    1833                 :            : /**
    1834                 :            :  * nla_for_each_attr - iterate over a stream of attributes
    1835                 :            :  * @pos: loop counter, set to current attribute
    1836                 :            :  * @head: head of attribute stream
    1837                 :            :  * @len: length of attribute stream
    1838                 :            :  * @rem: initialized to len, holds bytes currently remaining in stream
    1839                 :            :  */
    1840                 :            : #define nla_for_each_attr(pos, head, len, rem) \
    1841                 :            :         for (pos = head, rem = len; \
    1842                 :            :              nla_ok(pos, rem); \
    1843                 :            :              pos = nla_next(pos, &(rem)))
    1844                 :            : 
    1845                 :            : /**
    1846                 :            :  * nla_for_each_nested - iterate over nested attributes
    1847                 :            :  * @pos: loop counter, set to current attribute
    1848                 :            :  * @nla: attribute containing the nested attributes
    1849                 :            :  * @rem: initialized to len, holds bytes currently remaining in stream
    1850                 :            :  */
    1851                 :            : #define nla_for_each_nested(pos, nla, rem) \
    1852                 :            :         nla_for_each_attr(pos, nla_data(nla), nla_len(nla), rem)
    1853                 :            : 
    1854                 :            : /**
    1855                 :            :  * nla_is_last - Test if attribute is last in stream
    1856                 :            :  * @nla: attribute to test
    1857                 :            :  * @rem: bytes remaining in stream
    1858                 :            :  */
    1859                 :            : static inline bool nla_is_last(const struct nlattr *nla, int rem)
    1860                 :            : {
    1861                 :            :         return nla->nla_len == rem;
    1862                 :            : }
    1863                 :            : 
    1864                 :            : #endif

Generated by: LCOV version 1.14