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