~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/lib/nlattr.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  */
 23 static 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 
 34 static 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 
 55 static 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 
 61 static 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 
 84 static 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 
114 void 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 
160 static 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 
196 void 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 
240 static 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 
275 static 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 
297 static 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;
498 out_err:
499         NL_SET_ERR_MSG_ATTR(extack, nla, "Attribute failed policy validation");
500         return err;
501 }
502 
503 static 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  */
571 int __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 }
578 EXPORT_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  */
591 int
592 nla_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 }
607 EXPORT_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  */
625 int __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 }
633 EXPORT_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  */
643 struct 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 }
654 EXPORT_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  */
668 size_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 }
685 EXPORT_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  */
694 char *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 }
709 EXPORT_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  */
722 int 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 }
732 EXPORT_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  */
740 int 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 }
750 EXPORT_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  */
757 int 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 }
773 EXPORT_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  */
788 struct 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 }
800 EXPORT_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  */
816 struct 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 }
824 EXPORT_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  */
836 void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
837 {
838         return skb_put_zero(skb, NLA_ALIGN(attrlen));
839 }
840 EXPORT_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  */
854 struct 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 }
861 EXPORT_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  */
877 struct 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 }
891 EXPORT_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  */
903 void *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 }
910 EXPORT_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  */
922 void __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 }
930 EXPORT_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  */
943 void __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 }
951 EXPORT_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  */
962 void __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 }
969 EXPORT_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  */
981 int 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 }
989 EXPORT_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  */
1002 int 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 }
1017 EXPORT_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  */
1028 int 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 }
1036 EXPORT_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  */
1047 int 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 }
1055 EXPORT_SYMBOL(nla_append);
1056 #endif
1057 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp