1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * NETLINK      Netlink attributes
4  *
5  * 		Authors:	Thomas Graf <tgraf@suug.ch>
6  * 				Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
7  */
8 
9 #include <linux/export.h>
10 #include <linux/kernel.h>
11 #include <linux/errno.h>
12 #include <linux/jiffies.h>
13 #include <linux/nospec.h>
14 #include <linux/skbuff.h>
15 #include <linux/string.h>
16 #include <linux/types.h>
17 #include <net/netlink.h>
18 
19 /* For these data types, attribute length should be exactly the given
20  * size. However, to maintain compatibility with broken commands, if the
21  * attribute length does not match the expected size a warning is emitted
22  * to the user that the command is sending invalid data and needs to be fixed.
23  */
24 static const u8 nla_attr_len[NLA_TYPE_MAX+1] = {
25 	[NLA_U8]	= sizeof(u8),
26 	[NLA_U16]	= sizeof(u16),
27 	[NLA_U32]	= sizeof(u32),
28 	[NLA_U64]	= sizeof(u64),
29 	[NLA_S8]	= sizeof(s8),
30 	[NLA_S16]	= sizeof(s16),
31 	[NLA_S32]	= sizeof(s32),
32 	[NLA_S64]	= sizeof(s64),
33 };
34 
35 static const u8 nla_attr_minlen[NLA_TYPE_MAX+1] = {
36 	[NLA_U8]	= sizeof(u8),
37 	[NLA_U16]	= sizeof(u16),
38 	[NLA_U32]	= sizeof(u32),
39 	[NLA_U64]	= sizeof(u64),
40 	[NLA_MSECS]	= sizeof(u64),
41 	[NLA_NESTED]	= NLA_HDRLEN,
42 	[NLA_S8]	= sizeof(s8),
43 	[NLA_S16]	= sizeof(s16),
44 	[NLA_S32]	= sizeof(s32),
45 	[NLA_S64]	= sizeof(s64),
46 };
47 
48 /*
49  * Nested policies might refer back to the original
50  * policy in some cases, and userspace could try to
51  * abuse that and recurse by nesting in the right
52  * ways. Limit recursion to avoid this problem.
53  */
54 #define MAX_POLICY_RECURSION_DEPTH	10
55 
56 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
57 				const struct nla_policy *policy,
58 				unsigned int validate,
59 				struct netlink_ext_ack *extack,
60 				struct nlattr **tb, unsigned int depth);
61 
validate_nla_bitfield32(const struct nlattr * nla,const u32 valid_flags_mask)62 static int validate_nla_bitfield32(const struct nlattr *nla,
63 				   const u32 valid_flags_mask)
64 {
65 	const struct nla_bitfield32 *bf = nla_data(nla);
66 
67 	if (!valid_flags_mask)
68 		return -EINVAL;
69 
70 	/*disallow invalid bit selector */
71 	if (bf->selector & ~valid_flags_mask)
72 		return -EINVAL;
73 
74 	/*disallow invalid bit values */
75 	if (bf->value & ~valid_flags_mask)
76 		return -EINVAL;
77 
78 	/*disallow valid bit values that are not selected*/
79 	if (bf->value & ~bf->selector)
80 		return -EINVAL;
81 
82 	return 0;
83 }
84 
nla_validate_array(const struct nlattr * head,int len,int maxtype,const struct nla_policy * policy,struct netlink_ext_ack * extack,unsigned int validate,unsigned int depth)85 static int nla_validate_array(const struct nlattr *head, int len, int maxtype,
86 			      const struct nla_policy *policy,
87 			      struct netlink_ext_ack *extack,
88 			      unsigned int validate, unsigned int depth)
89 {
90 	const struct nlattr *entry;
91 	int rem;
92 
93 	nla_for_each_attr(entry, head, len, rem) {
94 		int ret;
95 
96 		if (nla_len(entry) == 0)
97 			continue;
98 
99 		if (nla_len(entry) < NLA_HDRLEN) {
100 			NL_SET_ERR_MSG_ATTR_POL(extack, entry, policy,
101 						"Array element too short");
102 			return -ERANGE;
103 		}
104 
105 		ret = __nla_validate_parse(nla_data(entry), nla_len(entry),
106 					   maxtype, policy, validate, extack,
107 					   NULL, depth + 1);
108 		if (ret < 0)
109 			return ret;
110 	}
111 
112 	return 0;
113 }
114 
nla_get_range_unsigned(const struct nla_policy * pt,struct netlink_range_validation * range)115 void nla_get_range_unsigned(const struct nla_policy *pt,
116 			    struct netlink_range_validation *range)
117 {
118 	WARN_ON_ONCE(pt->validation_type != NLA_VALIDATE_RANGE_PTR &&
119 		     (pt->min < 0 || pt->max < 0));
120 
121 	range->min = 0;
122 
123 	switch (pt->type) {
124 	case NLA_U8:
125 		range->max = U8_MAX;
126 		break;
127 	case NLA_U16:
128 	case NLA_BE16:
129 	case NLA_BINARY:
130 		range->max = U16_MAX;
131 		break;
132 	case NLA_U32:
133 	case NLA_BE32:
134 		range->max = U32_MAX;
135 		break;
136 	case NLA_U64:
137 	case NLA_MSECS:
138 		range->max = U64_MAX;
139 		break;
140 	default:
141 		WARN_ON_ONCE(1);
142 		return;
143 	}
144 
145 	switch (pt->validation_type) {
146 	case NLA_VALIDATE_RANGE:
147 	case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
148 		range->min = pt->min;
149 		range->max = pt->max;
150 		break;
151 	case NLA_VALIDATE_RANGE_PTR:
152 		*range = *pt->range;
153 		break;
154 	case NLA_VALIDATE_MIN:
155 		range->min = pt->min;
156 		break;
157 	case NLA_VALIDATE_MAX:
158 		range->max = pt->max;
159 		break;
160 	default:
161 		break;
162 	}
163 }
164 
nla_validate_range_unsigned(const struct nla_policy * pt,const struct nlattr * nla,struct netlink_ext_ack * extack,unsigned int validate)165 static int nla_validate_range_unsigned(const struct nla_policy *pt,
166 				       const struct nlattr *nla,
167 				       struct netlink_ext_ack *extack,
168 				       unsigned int validate)
169 {
170 	struct netlink_range_validation range;
171 	u64 value;
172 
173 	switch (pt->type) {
174 	case NLA_U8:
175 		value = nla_get_u8(nla);
176 		break;
177 	case NLA_U16:
178 		value = nla_get_u16(nla);
179 		break;
180 	case NLA_U32:
181 		value = nla_get_u32(nla);
182 		break;
183 	case NLA_U64:
184 		value = nla_get_u64(nla);
185 		break;
186 	case NLA_MSECS:
187 		value = nla_get_u64(nla);
188 		break;
189 	case NLA_BINARY:
190 		value = nla_len(nla);
191 		break;
192 	case NLA_BE16:
193 		value = ntohs(nla_get_be16(nla));
194 		break;
195 	case NLA_BE32:
196 		value = ntohl(nla_get_be32(nla));
197 		break;
198 	default:
199 		return -EINVAL;
200 	}
201 
202 	nla_get_range_unsigned(pt, &range);
203 
204 	if (pt->validation_type == NLA_VALIDATE_RANGE_WARN_TOO_LONG &&
205 	    pt->type == NLA_BINARY && value > range.max) {
206 		pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
207 				    current->comm, pt->type);
208 		if (validate & NL_VALIDATE_STRICT_ATTRS) {
209 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
210 						"invalid attribute length");
211 			return -EINVAL;
212 		}
213 
214 		/* this assumes min <= max (don't validate against min) */
215 		return 0;
216 	}
217 
218 	if (value < range.min || value > range.max) {
219 		bool binary = pt->type == NLA_BINARY;
220 
221 		if (binary)
222 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
223 						"binary attribute size out of range");
224 		else
225 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
226 						"integer out of range");
227 
228 		return -ERANGE;
229 	}
230 
231 	return 0;
232 }
233 
nla_get_range_signed(const struct nla_policy * pt,struct netlink_range_validation_signed * range)234 void nla_get_range_signed(const struct nla_policy *pt,
235 			  struct netlink_range_validation_signed *range)
236 {
237 	switch (pt->type) {
238 	case NLA_S8:
239 		range->min = S8_MIN;
240 		range->max = S8_MAX;
241 		break;
242 	case NLA_S16:
243 		range->min = S16_MIN;
244 		range->max = S16_MAX;
245 		break;
246 	case NLA_S32:
247 		range->min = S32_MIN;
248 		range->max = S32_MAX;
249 		break;
250 	case NLA_S64:
251 		range->min = S64_MIN;
252 		range->max = S64_MAX;
253 		break;
254 	default:
255 		WARN_ON_ONCE(1);
256 		return;
257 	}
258 
259 	switch (pt->validation_type) {
260 	case NLA_VALIDATE_RANGE:
261 		range->min = pt->min;
262 		range->max = pt->max;
263 		break;
264 	case NLA_VALIDATE_RANGE_PTR:
265 		*range = *pt->range_signed;
266 		break;
267 	case NLA_VALIDATE_MIN:
268 		range->min = pt->min;
269 		break;
270 	case NLA_VALIDATE_MAX:
271 		range->max = pt->max;
272 		break;
273 	default:
274 		break;
275 	}
276 }
277 
nla_validate_int_range_signed(const struct nla_policy * pt,const struct nlattr * nla,struct netlink_ext_ack * extack)278 static int nla_validate_int_range_signed(const struct nla_policy *pt,
279 					 const struct nlattr *nla,
280 					 struct netlink_ext_ack *extack)
281 {
282 	struct netlink_range_validation_signed range;
283 	s64 value;
284 
285 	switch (pt->type) {
286 	case NLA_S8:
287 		value = nla_get_s8(nla);
288 		break;
289 	case NLA_S16:
290 		value = nla_get_s16(nla);
291 		break;
292 	case NLA_S32:
293 		value = nla_get_s32(nla);
294 		break;
295 	case NLA_S64:
296 		value = nla_get_s64(nla);
297 		break;
298 	default:
299 		return -EINVAL;
300 	}
301 
302 	nla_get_range_signed(pt, &range);
303 
304 	if (value < range.min || value > range.max) {
305 		NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
306 					"integer out of range");
307 		return -ERANGE;
308 	}
309 
310 	return 0;
311 }
312 
nla_validate_int_range(const struct nla_policy * pt,const struct nlattr * nla,struct netlink_ext_ack * extack,unsigned int validate)313 static int nla_validate_int_range(const struct nla_policy *pt,
314 				  const struct nlattr *nla,
315 				  struct netlink_ext_ack *extack,
316 				  unsigned int validate)
317 {
318 	switch (pt->type) {
319 	case NLA_U8:
320 	case NLA_U16:
321 	case NLA_U32:
322 	case NLA_U64:
323 	case NLA_MSECS:
324 	case NLA_BINARY:
325 	case NLA_BE16:
326 	case NLA_BE32:
327 		return nla_validate_range_unsigned(pt, nla, extack, validate);
328 	case NLA_S8:
329 	case NLA_S16:
330 	case NLA_S32:
331 	case NLA_S64:
332 		return nla_validate_int_range_signed(pt, nla, extack);
333 	default:
334 		WARN_ON(1);
335 		return -EINVAL;
336 	}
337 }
338 
nla_validate_mask(const struct nla_policy * pt,const struct nlattr * nla,struct netlink_ext_ack * extack)339 static int nla_validate_mask(const struct nla_policy *pt,
340 			     const struct nlattr *nla,
341 			     struct netlink_ext_ack *extack)
342 {
343 	u64 value;
344 
345 	switch (pt->type) {
346 	case NLA_U8:
347 		value = nla_get_u8(nla);
348 		break;
349 	case NLA_U16:
350 		value = nla_get_u16(nla);
351 		break;
352 	case NLA_U32:
353 		value = nla_get_u32(nla);
354 		break;
355 	case NLA_U64:
356 		value = nla_get_u64(nla);
357 		break;
358 	default:
359 		return -EINVAL;
360 	}
361 
362 	if (value & ~(u64)pt->mask) {
363 		NL_SET_ERR_MSG_ATTR(extack, nla, "reserved bit set");
364 		return -EINVAL;
365 	}
366 
367 	return 0;
368 }
369 
validate_nla(const struct nlattr * nla,int maxtype,const struct nla_policy * policy,unsigned int validate,struct netlink_ext_ack * extack,unsigned int depth)370 static int validate_nla(const struct nlattr *nla, int maxtype,
371 			const struct nla_policy *policy, unsigned int validate,
372 			struct netlink_ext_ack *extack, unsigned int depth)
373 {
374 	u16 strict_start_type = policy[0].strict_start_type;
375 	const struct nla_policy *pt;
376 	int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
377 	int err = -ERANGE;
378 
379 	if (strict_start_type && type >= strict_start_type)
380 		validate |= NL_VALIDATE_STRICT;
381 
382 	if (type <= 0 || type > maxtype)
383 		return 0;
384 
385 	type = array_index_nospec(type, maxtype + 1);
386 	pt = &policy[type];
387 
388 	BUG_ON(pt->type > NLA_TYPE_MAX);
389 
390 	if (nla_attr_len[pt->type] && attrlen != nla_attr_len[pt->type]) {
391 		pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
392 				    current->comm, type);
393 		if (validate & NL_VALIDATE_STRICT_ATTRS) {
394 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
395 						"invalid attribute length");
396 			return -EINVAL;
397 		}
398 	}
399 
400 	if (validate & NL_VALIDATE_NESTED) {
401 		if ((pt->type == NLA_NESTED || pt->type == NLA_NESTED_ARRAY) &&
402 		    !(nla->nla_type & NLA_F_NESTED)) {
403 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
404 						"NLA_F_NESTED is missing");
405 			return -EINVAL;
406 		}
407 		if (pt->type != NLA_NESTED && pt->type != NLA_NESTED_ARRAY &&
408 		    pt->type != NLA_UNSPEC && (nla->nla_type & NLA_F_NESTED)) {
409 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
410 						"NLA_F_NESTED not expected");
411 			return -EINVAL;
412 		}
413 	}
414 
415 	switch (pt->type) {
416 	case NLA_REJECT:
417 		if (extack && pt->reject_message) {
418 			NL_SET_BAD_ATTR(extack, nla);
419 			extack->_msg = pt->reject_message;
420 			return -EINVAL;
421 		}
422 		err = -EINVAL;
423 		goto out_err;
424 
425 	case NLA_FLAG:
426 		if (attrlen > 0)
427 			goto out_err;
428 		break;
429 
430 	case NLA_BITFIELD32:
431 		if (attrlen != sizeof(struct nla_bitfield32))
432 			goto out_err;
433 
434 		err = validate_nla_bitfield32(nla, pt->bitfield32_valid);
435 		if (err)
436 			goto out_err;
437 		break;
438 
439 	case NLA_NUL_STRING:
440 		if (pt->len)
441 			minlen = min_t(int, attrlen, pt->len + 1);
442 		else
443 			minlen = attrlen;
444 
445 		if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL) {
446 			err = -EINVAL;
447 			goto out_err;
448 		}
449 		fallthrough;
450 
451 	case NLA_STRING:
452 		if (attrlen < 1)
453 			goto out_err;
454 
455 		if (pt->len) {
456 			char *buf = nla_data(nla);
457 
458 			if (buf[attrlen - 1] == '\0')
459 				attrlen--;
460 
461 			if (attrlen > pt->len)
462 				goto out_err;
463 		}
464 		break;
465 
466 	case NLA_BINARY:
467 		if (pt->len && attrlen > pt->len)
468 			goto out_err;
469 		break;
470 
471 	case NLA_NESTED:
472 		/* a nested attributes is allowed to be empty; if its not,
473 		 * it must have a size of at least NLA_HDRLEN.
474 		 */
475 		if (attrlen == 0)
476 			break;
477 		if (attrlen < NLA_HDRLEN)
478 			goto out_err;
479 		if (pt->nested_policy) {
480 			err = __nla_validate_parse(nla_data(nla), nla_len(nla),
481 						   pt->len, pt->nested_policy,
482 						   validate, extack, NULL,
483 						   depth + 1);
484 			if (err < 0) {
485 				/*
486 				 * return directly to preserve the inner
487 				 * error message/attribute pointer
488 				 */
489 				return err;
490 			}
491 		}
492 		break;
493 	case NLA_NESTED_ARRAY:
494 		/* a nested array attribute is allowed to be empty; if its not,
495 		 * it must have a size of at least NLA_HDRLEN.
496 		 */
497 		if (attrlen == 0)
498 			break;
499 		if (attrlen < NLA_HDRLEN)
500 			goto out_err;
501 		if (pt->nested_policy) {
502 			int err;
503 
504 			err = nla_validate_array(nla_data(nla), nla_len(nla),
505 						 pt->len, pt->nested_policy,
506 						 extack, validate, depth);
507 			if (err < 0) {
508 				/*
509 				 * return directly to preserve the inner
510 				 * error message/attribute pointer
511 				 */
512 				return err;
513 			}
514 		}
515 		break;
516 
517 	case NLA_UNSPEC:
518 		if (validate & NL_VALIDATE_UNSPEC) {
519 			NL_SET_ERR_MSG_ATTR(extack, nla,
520 					    "Unsupported attribute");
521 			return -EINVAL;
522 		}
523 		if (attrlen < pt->len)
524 			goto out_err;
525 		break;
526 
527 	default:
528 		if (pt->len)
529 			minlen = pt->len;
530 		else
531 			minlen = nla_attr_minlen[pt->type];
532 
533 		if (attrlen < minlen)
534 			goto out_err;
535 	}
536 
537 	/* further validation */
538 	switch (pt->validation_type) {
539 	case NLA_VALIDATE_NONE:
540 		/* nothing to do */
541 		break;
542 	case NLA_VALIDATE_RANGE_PTR:
543 	case NLA_VALIDATE_RANGE:
544 	case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
545 	case NLA_VALIDATE_MIN:
546 	case NLA_VALIDATE_MAX:
547 		err = nla_validate_int_range(pt, nla, extack, validate);
548 		if (err)
549 			return err;
550 		break;
551 	case NLA_VALIDATE_MASK:
552 		err = nla_validate_mask(pt, nla, extack);
553 		if (err)
554 			return err;
555 		break;
556 	case NLA_VALIDATE_FUNCTION:
557 		if (pt->validate) {
558 			err = pt->validate(nla, extack);
559 			if (err)
560 				return err;
561 		}
562 		break;
563 	}
564 
565 	return 0;
566 out_err:
567 	NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
568 				"Attribute failed policy validation");
569 	return err;
570 }
571 
__nla_validate_parse(const struct nlattr * head,int len,int maxtype,const struct nla_policy * policy,unsigned int validate,struct netlink_ext_ack * extack,struct nlattr ** tb,unsigned int depth)572 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
573 				const struct nla_policy *policy,
574 				unsigned int validate,
575 				struct netlink_ext_ack *extack,
576 				struct nlattr **tb, unsigned int depth)
577 {
578 	const struct nlattr *nla;
579 	int rem;
580 
581 	if (depth >= MAX_POLICY_RECURSION_DEPTH) {
582 		NL_SET_ERR_MSG(extack,
583 			       "allowed policy recursion depth exceeded");
584 		return -EINVAL;
585 	}
586 
587 	if (tb)
588 		memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
589 
590 	nla_for_each_attr(nla, head, len, rem) {
591 		u16 type = nla_type(nla);
592 
593 		if (type == 0 || type > maxtype) {
594 			if (validate & NL_VALIDATE_MAXTYPE) {
595 				NL_SET_ERR_MSG_ATTR(extack, nla,
596 						    "Unknown attribute type");
597 				return -EINVAL;
598 			}
599 			continue;
600 		}
601 		type = array_index_nospec(type, maxtype + 1);
602 		if (policy) {
603 			int err = validate_nla(nla, maxtype, policy,
604 					       validate, extack, depth);
605 
606 			if (err < 0)
607 				return err;
608 		}
609 
610 		if (tb)
611 			tb[type] = (struct nlattr *)nla;
612 	}
613 
614 	if (unlikely(rem > 0)) {
615 		pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
616 				    rem, current->comm);
617 		NL_SET_ERR_MSG(extack, "bytes leftover after parsing attributes");
618 		if (validate & NL_VALIDATE_TRAILING)
619 			return -EINVAL;
620 	}
621 
622 	return 0;
623 }
624 
625 /**
626  * __nla_validate - Validate a stream of attributes
627  * @head: head of attribute stream
628  * @len: length of attribute stream
629  * @maxtype: maximum attribute type to be expected
630  * @policy: validation policy
631  * @validate: validation strictness
632  * @extack: extended ACK report struct
633  *
634  * Validates all attributes in the specified attribute stream against the
635  * specified policy. Validation depends on the validate flags passed, see
636  * &enum netlink_validation for more details on that.
637  * See documentation of struct nla_policy for more details.
638  *
639  * Returns 0 on success or a negative error code.
640  */
__nla_validate(const struct nlattr * head,int len,int maxtype,const struct nla_policy * policy,unsigned int validate,struct netlink_ext_ack * extack)641 int __nla_validate(const struct nlattr *head, int len, int maxtype,
642 		   const struct nla_policy *policy, unsigned int validate,
643 		   struct netlink_ext_ack *extack)
644 {
645 	return __nla_validate_parse(head, len, maxtype, policy, validate,
646 				    extack, NULL, 0);
647 }
648 EXPORT_SYMBOL(__nla_validate);
649 
650 /**
651  * nla_policy_len - Determine the max. length of a policy
652  * @p: policy to use
653  * @n: number of policies
654  *
655  * Determines the max. length of the policy.  It is currently used
656  * to allocated Netlink buffers roughly the size of the actual
657  * message.
658  *
659  * Returns 0 on success or a negative error code.
660  */
661 int
nla_policy_len(const struct nla_policy * p,int n)662 nla_policy_len(const struct nla_policy *p, int n)
663 {
664 	int i, len = 0;
665 
666 	for (i = 0; i < n; i++, p++) {
667 		if (p->len)
668 			len += nla_total_size(p->len);
669 		else if (nla_attr_len[p->type])
670 			len += nla_total_size(nla_attr_len[p->type]);
671 		else if (nla_attr_minlen[p->type])
672 			len += nla_total_size(nla_attr_minlen[p->type]);
673 	}
674 
675 	return len;
676 }
677 EXPORT_SYMBOL(nla_policy_len);
678 
679 /**
680  * __nla_parse - Parse a stream of attributes into a tb buffer
681  * @tb: destination array with maxtype+1 elements
682  * @maxtype: maximum attribute type to be expected
683  * @head: head of attribute stream
684  * @len: length of attribute stream
685  * @policy: validation policy
686  * @validate: validation strictness
687  * @extack: extended ACK pointer
688  *
689  * Parses a stream of attributes and stores a pointer to each attribute in
690  * the tb array accessible via the attribute type.
691  * Validation is controlled by the @validate parameter.
692  *
693  * Returns 0 on success or a negative error code.
694  */
__nla_parse(struct nlattr ** tb,int maxtype,const struct nlattr * head,int len,const struct nla_policy * policy,unsigned int validate,struct netlink_ext_ack * extack)695 int __nla_parse(struct nlattr **tb, int maxtype,
696 		const struct nlattr *head, int len,
697 		const struct nla_policy *policy, unsigned int validate,
698 		struct netlink_ext_ack *extack)
699 {
700 	return __nla_validate_parse(head, len, maxtype, policy, validate,
701 				    extack, tb, 0);
702 }
703 EXPORT_SYMBOL(__nla_parse);
704 
705 /**
706  * nla_find - Find a specific attribute in a stream of attributes
707  * @head: head of attribute stream
708  * @len: length of attribute stream
709  * @attrtype: type of attribute to look for
710  *
711  * Returns the first attribute in the stream matching the specified type.
712  */
nla_find(const struct nlattr * head,int len,int attrtype)713 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype)
714 {
715 	const struct nlattr *nla;
716 	int rem;
717 
718 	nla_for_each_attr(nla, head, len, rem)
719 		if (nla_type(nla) == attrtype)
720 			return (struct nlattr *)nla;
721 
722 	return NULL;
723 }
724 EXPORT_SYMBOL(nla_find);
725 
726 /**
727  * nla_strscpy - Copy string attribute payload into a sized buffer
728  * @dst: Where to copy the string to.
729  * @nla: Attribute to copy the string from.
730  * @dstsize: Size of destination buffer.
731  *
732  * Copies at most dstsize - 1 bytes into the destination buffer.
733  * Unlike strlcpy the destination buffer is always padded out.
734  *
735  * Return:
736  * * srclen - Returns @nla length (not including the trailing %NUL).
737  * * -E2BIG - If @dstsize is 0 or greater than U16_MAX or @nla length greater
738  *            than @dstsize.
739  */
nla_strscpy(char * dst,const struct nlattr * nla,size_t dstsize)740 ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize)
741 {
742 	size_t srclen = nla_len(nla);
743 	char *src = nla_data(nla);
744 	ssize_t ret;
745 	size_t len;
746 
747 	if (dstsize == 0 || WARN_ON_ONCE(dstsize > U16_MAX))
748 		return -E2BIG;
749 
750 	if (srclen > 0 && src[srclen - 1] == '\0')
751 		srclen--;
752 
753 	if (srclen >= dstsize) {
754 		len = dstsize - 1;
755 		ret = -E2BIG;
756 	} else {
757 		len = srclen;
758 		ret = len;
759 	}
760 
761 	memcpy(dst, src, len);
762 	/* Zero pad end of dst. */
763 	memset(dst + len, 0, dstsize - len);
764 
765 	return ret;
766 }
767 EXPORT_SYMBOL(nla_strscpy);
768 
769 /**
770  * nla_strdup - Copy string attribute payload into a newly allocated buffer
771  * @nla: attribute to copy the string from
772  * @flags: the type of memory to allocate (see kmalloc).
773  *
774  * Returns a pointer to the allocated buffer or NULL on error.
775  */
nla_strdup(const struct nlattr * nla,gfp_t flags)776 char *nla_strdup(const struct nlattr *nla, gfp_t flags)
777 {
778 	size_t srclen = nla_len(nla);
779 	char *src = nla_data(nla), *dst;
780 
781 	if (srclen > 0 && src[srclen - 1] == '\0')
782 		srclen--;
783 
784 	dst = kmalloc(srclen + 1, flags);
785 	if (dst != NULL) {
786 		memcpy(dst, src, srclen);
787 		dst[srclen] = '\0';
788 	}
789 	return dst;
790 }
791 EXPORT_SYMBOL(nla_strdup);
792 
793 /**
794  * nla_memcpy - Copy a netlink attribute into another memory area
795  * @dest: where to copy to memcpy
796  * @src: netlink attribute to copy from
797  * @count: size of the destination area
798  *
799  * Note: The number of bytes copied is limited by the length of
800  *       attribute's payload. memcpy
801  *
802  * Returns the number of bytes copied.
803  */
nla_memcpy(void * dest,const struct nlattr * src,int count)804 int nla_memcpy(void *dest, const struct nlattr *src, int count)
805 {
806 	int minlen = min_t(int, count, nla_len(src));
807 
808 	memcpy(dest, nla_data(src), minlen);
809 	if (count > minlen)
810 		memset(dest + minlen, 0, count - minlen);
811 
812 	return minlen;
813 }
814 EXPORT_SYMBOL(nla_memcpy);
815 
816 /**
817  * nla_memcmp - Compare an attribute with sized memory area
818  * @nla: netlink attribute
819  * @data: memory area
820  * @size: size of memory area
821  */
nla_memcmp(const struct nlattr * nla,const void * data,size_t size)822 int nla_memcmp(const struct nlattr *nla, const void *data,
823 			     size_t size)
824 {
825 	int d = nla_len(nla) - size;
826 
827 	if (d == 0)
828 		d = memcmp(nla_data(nla), data, size);
829 
830 	return d;
831 }
832 EXPORT_SYMBOL(nla_memcmp);
833 
834 /**
835  * nla_strcmp - Compare a string attribute against a string
836  * @nla: netlink string attribute
837  * @str: another string
838  */
nla_strcmp(const struct nlattr * nla,const char * str)839 int nla_strcmp(const struct nlattr *nla, const char *str)
840 {
841 	int len = strlen(str);
842 	char *buf = nla_data(nla);
843 	int attrlen = nla_len(nla);
844 	int d;
845 
846 	while (attrlen > 0 && buf[attrlen - 1] == '\0')
847 		attrlen--;
848 
849 	d = attrlen - len;
850 	if (d == 0)
851 		d = memcmp(nla_data(nla), str, len);
852 
853 	return d;
854 }
855 EXPORT_SYMBOL(nla_strcmp);
856 
857 #ifdef CONFIG_NET
858 /**
859  * __nla_reserve - reserve room for attribute on the skb
860  * @skb: socket buffer to reserve room on
861  * @attrtype: attribute type
862  * @attrlen: length of attribute payload
863  *
864  * Adds a netlink attribute header to a socket buffer and reserves
865  * room for the payload but does not copy it.
866  *
867  * The caller is responsible to ensure that the skb provides enough
868  * tailroom for the attribute header and payload.
869  */
__nla_reserve(struct sk_buff * skb,int attrtype,int attrlen)870 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
871 {
872 	struct nlattr *nla;
873 
874 	nla = skb_put(skb, nla_total_size(attrlen));
875 	nla->nla_type = attrtype;
876 	nla->nla_len = nla_attr_size(attrlen);
877 
878 	memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
879 
880 	return nla;
881 }
882 EXPORT_SYMBOL(__nla_reserve);
883 
884 /**
885  * __nla_reserve_64bit - reserve room for attribute on the skb and align it
886  * @skb: socket buffer to reserve room on
887  * @attrtype: attribute type
888  * @attrlen: length of attribute payload
889  * @padattr: attribute type for the padding
890  *
891  * Adds a netlink attribute header to a socket buffer and reserves
892  * room for the payload but does not copy it. It also ensure that this
893  * attribute will have a 64-bit aligned nla_data() area.
894  *
895  * The caller is responsible to ensure that the skb provides enough
896  * tailroom for the attribute header and payload.
897  */
__nla_reserve_64bit(struct sk_buff * skb,int attrtype,int attrlen,int padattr)898 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
899 				   int attrlen, int padattr)
900 {
901 	nla_align_64bit(skb, padattr);
902 
903 	return __nla_reserve(skb, attrtype, attrlen);
904 }
905 EXPORT_SYMBOL(__nla_reserve_64bit);
906 
907 /**
908  * __nla_reserve_nohdr - reserve room for attribute without header
909  * @skb: socket buffer to reserve room on
910  * @attrlen: length of attribute payload
911  *
912  * Reserves room for attribute payload without a header.
913  *
914  * The caller is responsible to ensure that the skb provides enough
915  * tailroom for the payload.
916  */
__nla_reserve_nohdr(struct sk_buff * skb,int attrlen)917 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
918 {
919 	return skb_put_zero(skb, NLA_ALIGN(attrlen));
920 }
921 EXPORT_SYMBOL(__nla_reserve_nohdr);
922 
923 /**
924  * nla_reserve - reserve room for attribute on the skb
925  * @skb: socket buffer to reserve room on
926  * @attrtype: attribute type
927  * @attrlen: length of attribute payload
928  *
929  * Adds a netlink attribute header to a socket buffer and reserves
930  * room for the payload but does not copy it.
931  *
932  * Returns NULL if the tailroom of the skb is insufficient to store
933  * the attribute header and payload.
934  */
nla_reserve(struct sk_buff * skb,int attrtype,int attrlen)935 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
936 {
937 	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
938 		return NULL;
939 
940 	return __nla_reserve(skb, attrtype, attrlen);
941 }
942 EXPORT_SYMBOL(nla_reserve);
943 
944 /**
945  * nla_reserve_64bit - reserve room for attribute on the skb and align it
946  * @skb: socket buffer to reserve room on
947  * @attrtype: attribute type
948  * @attrlen: length of attribute payload
949  * @padattr: attribute type for the padding
950  *
951  * Adds a netlink attribute header to a socket buffer and reserves
952  * room for the payload but does not copy it. It also ensure that this
953  * attribute will have a 64-bit aligned nla_data() area.
954  *
955  * Returns NULL if the tailroom of the skb is insufficient to store
956  * the attribute header and payload.
957  */
nla_reserve_64bit(struct sk_buff * skb,int attrtype,int attrlen,int padattr)958 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype, int attrlen,
959 				 int padattr)
960 {
961 	size_t len;
962 
963 	if (nla_need_padding_for_64bit(skb))
964 		len = nla_total_size_64bit(attrlen);
965 	else
966 		len = nla_total_size(attrlen);
967 	if (unlikely(skb_tailroom(skb) < len))
968 		return NULL;
969 
970 	return __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
971 }
972 EXPORT_SYMBOL(nla_reserve_64bit);
973 
974 /**
975  * nla_reserve_nohdr - reserve room for attribute without header
976  * @skb: socket buffer to reserve room on
977  * @attrlen: length of attribute payload
978  *
979  * Reserves room for attribute payload without a header.
980  *
981  * Returns NULL if the tailroom of the skb is insufficient to store
982  * the attribute payload.
983  */
nla_reserve_nohdr(struct sk_buff * skb,int attrlen)984 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
985 {
986 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
987 		return NULL;
988 
989 	return __nla_reserve_nohdr(skb, attrlen);
990 }
991 EXPORT_SYMBOL(nla_reserve_nohdr);
992 
993 /**
994  * __nla_put - Add a netlink attribute to a socket buffer
995  * @skb: socket buffer to add attribute to
996  * @attrtype: attribute type
997  * @attrlen: length of attribute payload
998  * @data: head of attribute payload
999  *
1000  * The caller is responsible to ensure that the skb provides enough
1001  * tailroom for the attribute header and payload.
1002  */
__nla_put(struct sk_buff * skb,int attrtype,int attrlen,const void * data)1003 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
1004 			     const void *data)
1005 {
1006 	struct nlattr *nla;
1007 
1008 	nla = __nla_reserve(skb, attrtype, attrlen);
1009 	memcpy(nla_data(nla), data, attrlen);
1010 }
1011 EXPORT_SYMBOL(__nla_put);
1012 
1013 /**
1014  * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1015  * @skb: socket buffer to add attribute to
1016  * @attrtype: attribute type
1017  * @attrlen: length of attribute payload
1018  * @data: head of attribute payload
1019  * @padattr: attribute type for the padding
1020  *
1021  * The caller is responsible to ensure that the skb provides enough
1022  * tailroom for the attribute header and payload.
1023  */
__nla_put_64bit(struct sk_buff * skb,int attrtype,int attrlen,const void * data,int padattr)1024 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1025 		     const void *data, int padattr)
1026 {
1027 	struct nlattr *nla;
1028 
1029 	nla = __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
1030 	memcpy(nla_data(nla), data, attrlen);
1031 }
1032 EXPORT_SYMBOL(__nla_put_64bit);
1033 
1034 /**
1035  * __nla_put_nohdr - Add a netlink attribute without header
1036  * @skb: socket buffer to add attribute to
1037  * @attrlen: length of attribute payload
1038  * @data: head of attribute payload
1039  *
1040  * The caller is responsible to ensure that the skb provides enough
1041  * tailroom for the attribute payload.
1042  */
__nla_put_nohdr(struct sk_buff * skb,int attrlen,const void * data)1043 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1044 {
1045 	void *start;
1046 
1047 	start = __nla_reserve_nohdr(skb, attrlen);
1048 	memcpy(start, data, attrlen);
1049 }
1050 EXPORT_SYMBOL(__nla_put_nohdr);
1051 
1052 /**
1053  * nla_put - Add a netlink attribute to a socket buffer
1054  * @skb: socket buffer to add attribute to
1055  * @attrtype: attribute type
1056  * @attrlen: length of attribute payload
1057  * @data: head of attribute payload
1058  *
1059  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1060  * the attribute header and payload.
1061  */
nla_put(struct sk_buff * skb,int attrtype,int attrlen,const void * data)1062 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
1063 {
1064 	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
1065 		return -EMSGSIZE;
1066 
1067 	__nla_put(skb, attrtype, attrlen, data);
1068 	return 0;
1069 }
1070 EXPORT_SYMBOL(nla_put);
1071 
1072 /**
1073  * nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1074  * @skb: socket buffer to add attribute to
1075  * @attrtype: attribute type
1076  * @attrlen: length of attribute payload
1077  * @data: head of attribute payload
1078  * @padattr: attribute type for the padding
1079  *
1080  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1081  * the attribute header and payload.
1082  */
nla_put_64bit(struct sk_buff * skb,int attrtype,int attrlen,const void * data,int padattr)1083 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1084 		  const void *data, int padattr)
1085 {
1086 	size_t len;
1087 
1088 	if (nla_need_padding_for_64bit(skb))
1089 		len = nla_total_size_64bit(attrlen);
1090 	else
1091 		len = nla_total_size(attrlen);
1092 	if (unlikely(skb_tailroom(skb) < len))
1093 		return -EMSGSIZE;
1094 
1095 	__nla_put_64bit(skb, attrtype, attrlen, data, padattr);
1096 	return 0;
1097 }
1098 EXPORT_SYMBOL(nla_put_64bit);
1099 
1100 /**
1101  * nla_put_nohdr - Add a netlink attribute without header
1102  * @skb: socket buffer to add attribute to
1103  * @attrlen: length of attribute payload
1104  * @data: head of attribute payload
1105  *
1106  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1107  * the attribute payload.
1108  */
nla_put_nohdr(struct sk_buff * skb,int attrlen,const void * data)1109 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1110 {
1111 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1112 		return -EMSGSIZE;
1113 
1114 	__nla_put_nohdr(skb, attrlen, data);
1115 	return 0;
1116 }
1117 EXPORT_SYMBOL(nla_put_nohdr);
1118 
1119 /**
1120  * nla_append - Add a netlink attribute without header or padding
1121  * @skb: socket buffer to add attribute to
1122  * @attrlen: length of attribute payload
1123  * @data: head of attribute payload
1124  *
1125  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1126  * the attribute payload.
1127  */
nla_append(struct sk_buff * skb,int attrlen,const void * data)1128 int nla_append(struct sk_buff *skb, int attrlen, const void *data)
1129 {
1130 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1131 		return -EMSGSIZE;
1132 
1133 	skb_put_data(skb, data, attrlen);
1134 	return 0;
1135 }
1136 EXPORT_SYMBOL(nla_append);
1137 #endif
1138