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