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