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