xref: /openbmc/linux/lib/nlattr.c (revision 3ddc8b84)
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 
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 
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 
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 
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 
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 
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 
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 
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 	case NLA_BE16:
359 		value = ntohs(nla_get_be16(nla));
360 		break;
361 	case NLA_BE32:
362 		value = ntohl(nla_get_be32(nla));
363 		break;
364 	default:
365 		return -EINVAL;
366 	}
367 
368 	if (value & ~(u64)pt->mask) {
369 		NL_SET_ERR_MSG_ATTR(extack, nla, "reserved bit set");
370 		return -EINVAL;
371 	}
372 
373 	return 0;
374 }
375 
376 static int validate_nla(const struct nlattr *nla, int maxtype,
377 			const struct nla_policy *policy, unsigned int validate,
378 			struct netlink_ext_ack *extack, unsigned int depth)
379 {
380 	u16 strict_start_type = policy[0].strict_start_type;
381 	const struct nla_policy *pt;
382 	int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
383 	int err = -ERANGE;
384 
385 	if (strict_start_type && type >= strict_start_type)
386 		validate |= NL_VALIDATE_STRICT;
387 
388 	if (type <= 0 || type > maxtype)
389 		return 0;
390 
391 	type = array_index_nospec(type, maxtype + 1);
392 	pt = &policy[type];
393 
394 	BUG_ON(pt->type > NLA_TYPE_MAX);
395 
396 	if (nla_attr_len[pt->type] && attrlen != nla_attr_len[pt->type]) {
397 		pr_warn_ratelimited("netlink: '%s': attribute type %d has an invalid length.\n",
398 				    current->comm, type);
399 		if (validate & NL_VALIDATE_STRICT_ATTRS) {
400 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
401 						"invalid attribute length");
402 			return -EINVAL;
403 		}
404 	}
405 
406 	if (validate & NL_VALIDATE_NESTED) {
407 		if ((pt->type == NLA_NESTED || pt->type == NLA_NESTED_ARRAY) &&
408 		    !(nla->nla_type & NLA_F_NESTED)) {
409 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
410 						"NLA_F_NESTED is missing");
411 			return -EINVAL;
412 		}
413 		if (pt->type != NLA_NESTED && pt->type != NLA_NESTED_ARRAY &&
414 		    pt->type != NLA_UNSPEC && (nla->nla_type & NLA_F_NESTED)) {
415 			NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
416 						"NLA_F_NESTED not expected");
417 			return -EINVAL;
418 		}
419 	}
420 
421 	switch (pt->type) {
422 	case NLA_REJECT:
423 		if (extack && pt->reject_message) {
424 			NL_SET_BAD_ATTR(extack, nla);
425 			extack->_msg = pt->reject_message;
426 			return -EINVAL;
427 		}
428 		err = -EINVAL;
429 		goto out_err;
430 
431 	case NLA_FLAG:
432 		if (attrlen > 0)
433 			goto out_err;
434 		break;
435 
436 	case NLA_BITFIELD32:
437 		if (attrlen != sizeof(struct nla_bitfield32))
438 			goto out_err;
439 
440 		err = validate_nla_bitfield32(nla, pt->bitfield32_valid);
441 		if (err)
442 			goto out_err;
443 		break;
444 
445 	case NLA_NUL_STRING:
446 		if (pt->len)
447 			minlen = min_t(int, attrlen, pt->len + 1);
448 		else
449 			minlen = attrlen;
450 
451 		if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL) {
452 			err = -EINVAL;
453 			goto out_err;
454 		}
455 		fallthrough;
456 
457 	case NLA_STRING:
458 		if (attrlen < 1)
459 			goto out_err;
460 
461 		if (pt->len) {
462 			char *buf = nla_data(nla);
463 
464 			if (buf[attrlen - 1] == '\0')
465 				attrlen--;
466 
467 			if (attrlen > pt->len)
468 				goto out_err;
469 		}
470 		break;
471 
472 	case NLA_BINARY:
473 		if (pt->len && attrlen > pt->len)
474 			goto out_err;
475 		break;
476 
477 	case NLA_NESTED:
478 		/* a nested attributes is allowed to be empty; if its not,
479 		 * it must have a size of at least NLA_HDRLEN.
480 		 */
481 		if (attrlen == 0)
482 			break;
483 		if (attrlen < NLA_HDRLEN)
484 			goto out_err;
485 		if (pt->nested_policy) {
486 			err = __nla_validate_parse(nla_data(nla), nla_len(nla),
487 						   pt->len, pt->nested_policy,
488 						   validate, extack, NULL,
489 						   depth + 1);
490 			if (err < 0) {
491 				/*
492 				 * return directly to preserve the inner
493 				 * error message/attribute pointer
494 				 */
495 				return err;
496 			}
497 		}
498 		break;
499 	case NLA_NESTED_ARRAY:
500 		/* a nested array attribute is allowed to be empty; if its not,
501 		 * it must have a size of at least NLA_HDRLEN.
502 		 */
503 		if (attrlen == 0)
504 			break;
505 		if (attrlen < NLA_HDRLEN)
506 			goto out_err;
507 		if (pt->nested_policy) {
508 			int err;
509 
510 			err = nla_validate_array(nla_data(nla), nla_len(nla),
511 						 pt->len, pt->nested_policy,
512 						 extack, validate, depth);
513 			if (err < 0) {
514 				/*
515 				 * return directly to preserve the inner
516 				 * error message/attribute pointer
517 				 */
518 				return err;
519 			}
520 		}
521 		break;
522 
523 	case NLA_UNSPEC:
524 		if (validate & NL_VALIDATE_UNSPEC) {
525 			NL_SET_ERR_MSG_ATTR(extack, nla,
526 					    "Unsupported attribute");
527 			return -EINVAL;
528 		}
529 		if (attrlen < pt->len)
530 			goto out_err;
531 		break;
532 
533 	default:
534 		if (pt->len)
535 			minlen = pt->len;
536 		else
537 			minlen = nla_attr_minlen[pt->type];
538 
539 		if (attrlen < minlen)
540 			goto out_err;
541 	}
542 
543 	/* further validation */
544 	switch (pt->validation_type) {
545 	case NLA_VALIDATE_NONE:
546 		/* nothing to do */
547 		break;
548 	case NLA_VALIDATE_RANGE_PTR:
549 	case NLA_VALIDATE_RANGE:
550 	case NLA_VALIDATE_RANGE_WARN_TOO_LONG:
551 	case NLA_VALIDATE_MIN:
552 	case NLA_VALIDATE_MAX:
553 		err = nla_validate_int_range(pt, nla, extack, validate);
554 		if (err)
555 			return err;
556 		break;
557 	case NLA_VALIDATE_MASK:
558 		err = nla_validate_mask(pt, nla, extack);
559 		if (err)
560 			return err;
561 		break;
562 	case NLA_VALIDATE_FUNCTION:
563 		if (pt->validate) {
564 			err = pt->validate(nla, extack);
565 			if (err)
566 				return err;
567 		}
568 		break;
569 	}
570 
571 	return 0;
572 out_err:
573 	NL_SET_ERR_MSG_ATTR_POL(extack, nla, pt,
574 				"Attribute failed policy validation");
575 	return err;
576 }
577 
578 static int __nla_validate_parse(const struct nlattr *head, int len, int maxtype,
579 				const struct nla_policy *policy,
580 				unsigned int validate,
581 				struct netlink_ext_ack *extack,
582 				struct nlattr **tb, unsigned int depth)
583 {
584 	const struct nlattr *nla;
585 	int rem;
586 
587 	if (depth >= MAX_POLICY_RECURSION_DEPTH) {
588 		NL_SET_ERR_MSG(extack,
589 			       "allowed policy recursion depth exceeded");
590 		return -EINVAL;
591 	}
592 
593 	if (tb)
594 		memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
595 
596 	nla_for_each_attr(nla, head, len, rem) {
597 		u16 type = nla_type(nla);
598 
599 		if (type == 0 || type > maxtype) {
600 			if (validate & NL_VALIDATE_MAXTYPE) {
601 				NL_SET_ERR_MSG_ATTR(extack, nla,
602 						    "Unknown attribute type");
603 				return -EINVAL;
604 			}
605 			continue;
606 		}
607 		type = array_index_nospec(type, maxtype + 1);
608 		if (policy) {
609 			int err = validate_nla(nla, maxtype, policy,
610 					       validate, extack, depth);
611 
612 			if (err < 0)
613 				return err;
614 		}
615 
616 		if (tb)
617 			tb[type] = (struct nlattr *)nla;
618 	}
619 
620 	if (unlikely(rem > 0)) {
621 		pr_warn_ratelimited("netlink: %d bytes leftover after parsing attributes in process `%s'.\n",
622 				    rem, current->comm);
623 		NL_SET_ERR_MSG(extack, "bytes leftover after parsing attributes");
624 		if (validate & NL_VALIDATE_TRAILING)
625 			return -EINVAL;
626 	}
627 
628 	return 0;
629 }
630 
631 /**
632  * __nla_validate - Validate a stream of attributes
633  * @head: head of attribute stream
634  * @len: length of attribute stream
635  * @maxtype: maximum attribute type to be expected
636  * @policy: validation policy
637  * @validate: validation strictness
638  * @extack: extended ACK report struct
639  *
640  * Validates all attributes in the specified attribute stream against the
641  * specified policy. Validation depends on the validate flags passed, see
642  * &enum netlink_validation for more details on that.
643  * See documentation of struct nla_policy for more details.
644  *
645  * Returns 0 on success or a negative error code.
646  */
647 int __nla_validate(const struct nlattr *head, int len, int maxtype,
648 		   const struct nla_policy *policy, unsigned int validate,
649 		   struct netlink_ext_ack *extack)
650 {
651 	return __nla_validate_parse(head, len, maxtype, policy, validate,
652 				    extack, NULL, 0);
653 }
654 EXPORT_SYMBOL(__nla_validate);
655 
656 /**
657  * nla_policy_len - Determine the max. length of a policy
658  * @p: policy to use
659  * @n: number of policies
660  *
661  * Determines the max. length of the policy.  It is currently used
662  * to allocated Netlink buffers roughly the size of the actual
663  * message.
664  *
665  * Returns 0 on success or a negative error code.
666  */
667 int
668 nla_policy_len(const struct nla_policy *p, int n)
669 {
670 	int i, len = 0;
671 
672 	for (i = 0; i < n; i++, p++) {
673 		if (p->len)
674 			len += nla_total_size(p->len);
675 		else if (nla_attr_len[p->type])
676 			len += nla_total_size(nla_attr_len[p->type]);
677 		else if (nla_attr_minlen[p->type])
678 			len += nla_total_size(nla_attr_minlen[p->type]);
679 	}
680 
681 	return len;
682 }
683 EXPORT_SYMBOL(nla_policy_len);
684 
685 /**
686  * __nla_parse - Parse a stream of attributes into a tb buffer
687  * @tb: destination array with maxtype+1 elements
688  * @maxtype: maximum attribute type to be expected
689  * @head: head of attribute stream
690  * @len: length of attribute stream
691  * @policy: validation policy
692  * @validate: validation strictness
693  * @extack: extended ACK pointer
694  *
695  * Parses a stream of attributes and stores a pointer to each attribute in
696  * the tb array accessible via the attribute type.
697  * Validation is controlled by the @validate parameter.
698  *
699  * Returns 0 on success or a negative error code.
700  */
701 int __nla_parse(struct nlattr **tb, int maxtype,
702 		const struct nlattr *head, int len,
703 		const struct nla_policy *policy, unsigned int validate,
704 		struct netlink_ext_ack *extack)
705 {
706 	return __nla_validate_parse(head, len, maxtype, policy, validate,
707 				    extack, tb, 0);
708 }
709 EXPORT_SYMBOL(__nla_parse);
710 
711 /**
712  * nla_find - Find a specific attribute in a stream of attributes
713  * @head: head of attribute stream
714  * @len: length of attribute stream
715  * @attrtype: type of attribute to look for
716  *
717  * Returns the first attribute in the stream matching the specified type.
718  */
719 struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype)
720 {
721 	const struct nlattr *nla;
722 	int rem;
723 
724 	nla_for_each_attr(nla, head, len, rem)
725 		if (nla_type(nla) == attrtype)
726 			return (struct nlattr *)nla;
727 
728 	return NULL;
729 }
730 EXPORT_SYMBOL(nla_find);
731 
732 /**
733  * nla_strscpy - Copy string attribute payload into a sized buffer
734  * @dst: Where to copy the string to.
735  * @nla: Attribute to copy the string from.
736  * @dstsize: Size of destination buffer.
737  *
738  * Copies at most dstsize - 1 bytes into the destination buffer.
739  * Unlike strlcpy the destination buffer is always padded out.
740  *
741  * Return:
742  * * srclen - Returns @nla length (not including the trailing %NUL).
743  * * -E2BIG - If @dstsize is 0 or greater than U16_MAX or @nla length greater
744  *            than @dstsize.
745  */
746 ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize)
747 {
748 	size_t srclen = nla_len(nla);
749 	char *src = nla_data(nla);
750 	ssize_t ret;
751 	size_t len;
752 
753 	if (dstsize == 0 || WARN_ON_ONCE(dstsize > U16_MAX))
754 		return -E2BIG;
755 
756 	if (srclen > 0 && src[srclen - 1] == '\0')
757 		srclen--;
758 
759 	if (srclen >= dstsize) {
760 		len = dstsize - 1;
761 		ret = -E2BIG;
762 	} else {
763 		len = srclen;
764 		ret = len;
765 	}
766 
767 	memcpy(dst, src, len);
768 	/* Zero pad end of dst. */
769 	memset(dst + len, 0, dstsize - len);
770 
771 	return ret;
772 }
773 EXPORT_SYMBOL(nla_strscpy);
774 
775 /**
776  * nla_strdup - Copy string attribute payload into a newly allocated buffer
777  * @nla: attribute to copy the string from
778  * @flags: the type of memory to allocate (see kmalloc).
779  *
780  * Returns a pointer to the allocated buffer or NULL on error.
781  */
782 char *nla_strdup(const struct nlattr *nla, gfp_t flags)
783 {
784 	size_t srclen = nla_len(nla);
785 	char *src = nla_data(nla), *dst;
786 
787 	if (srclen > 0 && src[srclen - 1] == '\0')
788 		srclen--;
789 
790 	dst = kmalloc(srclen + 1, flags);
791 	if (dst != NULL) {
792 		memcpy(dst, src, srclen);
793 		dst[srclen] = '\0';
794 	}
795 	return dst;
796 }
797 EXPORT_SYMBOL(nla_strdup);
798 
799 /**
800  * nla_memcpy - Copy a netlink attribute into another memory area
801  * @dest: where to copy to memcpy
802  * @src: netlink attribute to copy from
803  * @count: size of the destination area
804  *
805  * Note: The number of bytes copied is limited by the length of
806  *       attribute's payload. memcpy
807  *
808  * Returns the number of bytes copied.
809  */
810 int nla_memcpy(void *dest, const struct nlattr *src, int count)
811 {
812 	int minlen = min_t(int, count, nla_len(src));
813 
814 	memcpy(dest, nla_data(src), minlen);
815 	if (count > minlen)
816 		memset(dest + minlen, 0, count - minlen);
817 
818 	return minlen;
819 }
820 EXPORT_SYMBOL(nla_memcpy);
821 
822 /**
823  * nla_memcmp - Compare an attribute with sized memory area
824  * @nla: netlink attribute
825  * @data: memory area
826  * @size: size of memory area
827  */
828 int nla_memcmp(const struct nlattr *nla, const void *data,
829 			     size_t size)
830 {
831 	int d = nla_len(nla) - size;
832 
833 	if (d == 0)
834 		d = memcmp(nla_data(nla), data, size);
835 
836 	return d;
837 }
838 EXPORT_SYMBOL(nla_memcmp);
839 
840 /**
841  * nla_strcmp - Compare a string attribute against a string
842  * @nla: netlink string attribute
843  * @str: another string
844  */
845 int nla_strcmp(const struct nlattr *nla, const char *str)
846 {
847 	int len = strlen(str);
848 	char *buf = nla_data(nla);
849 	int attrlen = nla_len(nla);
850 	int d;
851 
852 	while (attrlen > 0 && buf[attrlen - 1] == '\0')
853 		attrlen--;
854 
855 	d = attrlen - len;
856 	if (d == 0)
857 		d = memcmp(nla_data(nla), str, len);
858 
859 	return d;
860 }
861 EXPORT_SYMBOL(nla_strcmp);
862 
863 #ifdef CONFIG_NET
864 /**
865  * __nla_reserve - reserve room for attribute on the skb
866  * @skb: socket buffer to reserve room on
867  * @attrtype: attribute type
868  * @attrlen: length of attribute payload
869  *
870  * Adds a netlink attribute header to a socket buffer and reserves
871  * room for the payload but does not copy it.
872  *
873  * The caller is responsible to ensure that the skb provides enough
874  * tailroom for the attribute header and payload.
875  */
876 struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
877 {
878 	struct nlattr *nla;
879 
880 	nla = skb_put(skb, nla_total_size(attrlen));
881 	nla->nla_type = attrtype;
882 	nla->nla_len = nla_attr_size(attrlen);
883 
884 	memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
885 
886 	return nla;
887 }
888 EXPORT_SYMBOL(__nla_reserve);
889 
890 /**
891  * __nla_reserve_64bit - reserve room for attribute on the skb and align it
892  * @skb: socket buffer to reserve room on
893  * @attrtype: attribute type
894  * @attrlen: length of attribute payload
895  * @padattr: attribute type for the padding
896  *
897  * Adds a netlink attribute header to a socket buffer and reserves
898  * room for the payload but does not copy it. It also ensure that this
899  * attribute will have a 64-bit aligned nla_data() area.
900  *
901  * The caller is responsible to ensure that the skb provides enough
902  * tailroom for the attribute header and payload.
903  */
904 struct nlattr *__nla_reserve_64bit(struct sk_buff *skb, int attrtype,
905 				   int attrlen, int padattr)
906 {
907 	nla_align_64bit(skb, padattr);
908 
909 	return __nla_reserve(skb, attrtype, attrlen);
910 }
911 EXPORT_SYMBOL(__nla_reserve_64bit);
912 
913 /**
914  * __nla_reserve_nohdr - reserve room for attribute without header
915  * @skb: socket buffer to reserve room on
916  * @attrlen: length of attribute payload
917  *
918  * Reserves room for attribute payload without a header.
919  *
920  * The caller is responsible to ensure that the skb provides enough
921  * tailroom for the payload.
922  */
923 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
924 {
925 	return skb_put_zero(skb, NLA_ALIGN(attrlen));
926 }
927 EXPORT_SYMBOL(__nla_reserve_nohdr);
928 
929 /**
930  * nla_reserve - reserve room for attribute on the skb
931  * @skb: socket buffer to reserve room on
932  * @attrtype: attribute type
933  * @attrlen: length of attribute payload
934  *
935  * Adds a netlink attribute header to a socket buffer and reserves
936  * room for the payload but does not copy it.
937  *
938  * Returns NULL if the tailroom of the skb is insufficient to store
939  * the attribute header and payload.
940  */
941 struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
942 {
943 	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
944 		return NULL;
945 
946 	return __nla_reserve(skb, attrtype, attrlen);
947 }
948 EXPORT_SYMBOL(nla_reserve);
949 
950 /**
951  * nla_reserve_64bit - reserve room for attribute on the skb and align it
952  * @skb: socket buffer to reserve room on
953  * @attrtype: attribute type
954  * @attrlen: length of attribute payload
955  * @padattr: attribute type for the padding
956  *
957  * Adds a netlink attribute header to a socket buffer and reserves
958  * room for the payload but does not copy it. It also ensure that this
959  * attribute will have a 64-bit aligned nla_data() area.
960  *
961  * Returns NULL if the tailroom of the skb is insufficient to store
962  * the attribute header and payload.
963  */
964 struct nlattr *nla_reserve_64bit(struct sk_buff *skb, int attrtype, int attrlen,
965 				 int padattr)
966 {
967 	size_t len;
968 
969 	if (nla_need_padding_for_64bit(skb))
970 		len = nla_total_size_64bit(attrlen);
971 	else
972 		len = nla_total_size(attrlen);
973 	if (unlikely(skb_tailroom(skb) < len))
974 		return NULL;
975 
976 	return __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
977 }
978 EXPORT_SYMBOL(nla_reserve_64bit);
979 
980 /**
981  * nla_reserve_nohdr - reserve room for attribute without header
982  * @skb: socket buffer to reserve room on
983  * @attrlen: length of attribute payload
984  *
985  * Reserves room for attribute payload without a header.
986  *
987  * Returns NULL if the tailroom of the skb is insufficient to store
988  * the attribute payload.
989  */
990 void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
991 {
992 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
993 		return NULL;
994 
995 	return __nla_reserve_nohdr(skb, attrlen);
996 }
997 EXPORT_SYMBOL(nla_reserve_nohdr);
998 
999 /**
1000  * __nla_put - Add a netlink attribute to a socket buffer
1001  * @skb: socket buffer to add attribute to
1002  * @attrtype: attribute type
1003  * @attrlen: length of attribute payload
1004  * @data: head of attribute payload
1005  *
1006  * The caller is responsible to ensure that the skb provides enough
1007  * tailroom for the attribute header and payload.
1008  */
1009 void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
1010 			     const void *data)
1011 {
1012 	struct nlattr *nla;
1013 
1014 	nla = __nla_reserve(skb, attrtype, attrlen);
1015 	memcpy(nla_data(nla), data, attrlen);
1016 }
1017 EXPORT_SYMBOL(__nla_put);
1018 
1019 /**
1020  * __nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1021  * @skb: socket buffer to add attribute to
1022  * @attrtype: attribute type
1023  * @attrlen: length of attribute payload
1024  * @data: head of attribute payload
1025  * @padattr: attribute type for the padding
1026  *
1027  * The caller is responsible to ensure that the skb provides enough
1028  * tailroom for the attribute header and payload.
1029  */
1030 void __nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1031 		     const void *data, int padattr)
1032 {
1033 	struct nlattr *nla;
1034 
1035 	nla = __nla_reserve_64bit(skb, attrtype, attrlen, padattr);
1036 	memcpy(nla_data(nla), data, attrlen);
1037 }
1038 EXPORT_SYMBOL(__nla_put_64bit);
1039 
1040 /**
1041  * __nla_put_nohdr - Add a netlink attribute without header
1042  * @skb: socket buffer to add attribute to
1043  * @attrlen: length of attribute payload
1044  * @data: head of attribute payload
1045  *
1046  * The caller is responsible to ensure that the skb provides enough
1047  * tailroom for the attribute payload.
1048  */
1049 void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1050 {
1051 	void *start;
1052 
1053 	start = __nla_reserve_nohdr(skb, attrlen);
1054 	memcpy(start, data, attrlen);
1055 }
1056 EXPORT_SYMBOL(__nla_put_nohdr);
1057 
1058 /**
1059  * nla_put - Add a netlink attribute to a socket buffer
1060  * @skb: socket buffer to add attribute to
1061  * @attrtype: attribute type
1062  * @attrlen: length of attribute payload
1063  * @data: head of attribute payload
1064  *
1065  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1066  * the attribute header and payload.
1067  */
1068 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
1069 {
1070 	if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
1071 		return -EMSGSIZE;
1072 
1073 	__nla_put(skb, attrtype, attrlen, data);
1074 	return 0;
1075 }
1076 EXPORT_SYMBOL(nla_put);
1077 
1078 /**
1079  * nla_put_64bit - Add a netlink attribute to a socket buffer and align it
1080  * @skb: socket buffer to add attribute to
1081  * @attrtype: attribute type
1082  * @attrlen: length of attribute payload
1083  * @data: head of attribute payload
1084  * @padattr: attribute type for the padding
1085  *
1086  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1087  * the attribute header and payload.
1088  */
1089 int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen,
1090 		  const void *data, int padattr)
1091 {
1092 	size_t len;
1093 
1094 	if (nla_need_padding_for_64bit(skb))
1095 		len = nla_total_size_64bit(attrlen);
1096 	else
1097 		len = nla_total_size(attrlen);
1098 	if (unlikely(skb_tailroom(skb) < len))
1099 		return -EMSGSIZE;
1100 
1101 	__nla_put_64bit(skb, attrtype, attrlen, data, padattr);
1102 	return 0;
1103 }
1104 EXPORT_SYMBOL(nla_put_64bit);
1105 
1106 /**
1107  * nla_put_nohdr - Add a netlink attribute without header
1108  * @skb: socket buffer to add attribute to
1109  * @attrlen: length of attribute payload
1110  * @data: head of attribute payload
1111  *
1112  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1113  * the attribute payload.
1114  */
1115 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
1116 {
1117 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1118 		return -EMSGSIZE;
1119 
1120 	__nla_put_nohdr(skb, attrlen, data);
1121 	return 0;
1122 }
1123 EXPORT_SYMBOL(nla_put_nohdr);
1124 
1125 /**
1126  * nla_append - Add a netlink attribute without header or padding
1127  * @skb: socket buffer to add attribute to
1128  * @attrlen: length of attribute payload
1129  * @data: head of attribute payload
1130  *
1131  * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
1132  * the attribute payload.
1133  */
1134 int nla_append(struct sk_buff *skb, int attrlen, const void *data)
1135 {
1136 	if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
1137 		return -EMSGSIZE;
1138 
1139 	skb_put_data(skb, data, attrlen);
1140 	return 0;
1141 }
1142 EXPORT_SYMBOL(nla_append);
1143 #endif
1144