Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/strnlen_user.c

  1 #include <linux/kernel.h>
  2 #include <linux/export.h>
  3 #include <linux/uaccess.h>
  4 
  5 #include <asm/word-at-a-time.h>
  6 
  7 /* Set bits in the first 'n' bytes when loaded from memory */
  8 #ifdef __LITTLE_ENDIAN
  9 #  define aligned_byte_mask(n) ((1ul << 8*(n))-1)
 10 #else
 11 #  define aligned_byte_mask(n) (~0xfful << (BITS_PER_LONG - 8 - 8*(n)))
 12 #endif
 13 
 14 /*
 15  * Do a strnlen, return length of string *with* final '\0'.
 16  * 'count' is the user-supplied count, while 'max' is the
 17  * address space maximum.
 18  *
 19  * Return 0 for exceptions (which includes hitting the address
 20  * space maximum), or 'count+1' if hitting the user-supplied
 21  * maximum count.
 22  *
 23  * NOTE! We can sometimes overshoot the user-supplied maximum
 24  * if it fits in a aligned 'long'. The caller needs to check
 25  * the return value against "> max".
 26  */
 27 static inline long do_strnlen_user(const char __user *src, unsigned long count, unsigned long max)
 28 {
 29         const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS;
 30         long align, res = 0;
 31         unsigned long c;
 32 
 33         /*
 34          * Truncate 'max' to the user-specified limit, so that
 35          * we only have one limit we need to check in the loop
 36          */
 37         if (max > count)
 38                 max = count;
 39 
 40         /*
 41          * Do everything aligned. But that means that we
 42          * need to also expand the maximum..
 43          */
 44         align = (sizeof(long) - 1) & (unsigned long)src;
 45         src -= align;
 46         max += align;
 47 
 48         unsafe_get_user(c, (unsigned long __user *)src, efault);
 49         c |= aligned_byte_mask(align);
 50 
 51         for (;;) {
 52                 unsigned long data;
 53                 if (has_zero(c, &data, &constants)) {
 54                         data = prep_zero_mask(c, data, &constants);
 55                         data = create_zero_mask(data);
 56                         return res + find_zero(data) + 1 - align;
 57                 }
 58                 res += sizeof(unsigned long);
 59                 /* We already handled 'unsigned long' bytes. Did we do it all ? */
 60                 if (unlikely(max <= sizeof(unsigned long)))
 61                         break;
 62                 max -= sizeof(unsigned long);
 63                 unsafe_get_user(c, (unsigned long __user *)(src+res), efault);
 64         }
 65         res -= align;
 66 
 67         /*
 68          * Uhhuh. We hit 'max'. But was that the user-specified maximum
 69          * too? If so, return the marker for "too long".
 70          */
 71         if (res >= count)
 72                 return count+1;
 73 
 74         /*
 75          * Nope: we hit the address space limit, and we still had more
 76          * characters the caller would have wanted. That's 0.
 77          */
 78 efault:
 79         return 0;
 80 }
 81 
 82 /**
 83  * strnlen_user: - Get the size of a user string INCLUDING final NUL.
 84  * @str: The string to measure.
 85  * @count: Maximum count (including NUL character)
 86  *
 87  * Context: User context only. This function may sleep if pagefaults are
 88  *          enabled.
 89  *
 90  * Get the size of a NUL-terminated string in user space.
 91  *
 92  * Returns the size of the string INCLUDING the terminating NUL.
 93  * If the string is too long, returns a number larger than @count. User
 94  * has to check the return value against "> count".
 95  * On exception (or invalid count), returns 0.
 96  *
 97  * NOTE! You should basically never use this function. There is
 98  * almost never any valid case for using the length of a user space
 99  * string, since the string can be changed at any time by other
100  * threads. Use "strncpy_from_user()" instead to get a stable copy
101  * of the string.
102  */
103 long strnlen_user(const char __user *str, long count)
104 {
105         unsigned long max_addr, src_addr;
106 
107         if (unlikely(count <= 0))
108                 return 0;
109 
110         max_addr = user_addr_max();
111         src_addr = (unsigned long)str;
112         if (likely(src_addr < max_addr)) {
113                 unsigned long max = max_addr - src_addr;
114                 long retval;
115 
116                 user_access_begin();
117                 retval = do_strnlen_user(str, count, max);
118                 user_access_end();
119                 return retval;
120         }
121         return 0;
122 }
123 EXPORT_SYMBOL(strnlen_user);
124 
125 /**
126  * strlen_user: - Get the size of a user string INCLUDING final NUL.
127  * @str: The string to measure.
128  *
129  * Context: User context only. This function may sleep if pagefaults are
130  *          enabled.
131  *
132  * Get the size of a NUL-terminated string in user space.
133  *
134  * Returns the size of the string INCLUDING the terminating NUL.
135  * On exception, returns 0.
136  *
137  * If there is a limit on the length of a valid string, you may wish to
138  * consider using strnlen_user() instead.
139  */
140 long strlen_user(const char __user *str)
141 {
142         unsigned long max_addr, src_addr;
143 
144         max_addr = user_addr_max();
145         src_addr = (unsigned long)str;
146         if (likely(src_addr < max_addr)) {
147                 unsigned long max = max_addr - src_addr;
148                 long retval;
149 
150                 user_access_begin();
151                 retval = do_strnlen_user(str, ~0ul, max);
152                 user_access_end();
153                 return retval;
154         }
155         return 0;
156 }
157 EXPORT_SYMBOL(strlen_user);
158 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us