Commit | Line | Data |
---|---|---|
40b0b3f8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * lib/parser.c - simple parser for mount, etc. options. | |
1da177e4 LT |
4 | */ |
5 | ||
6 | #include <linux/ctype.h> | |
8bc3bcc9 PG |
7 | #include <linux/types.h> |
8 | #include <linux/export.h> | |
4c527293 | 9 | #include <linux/kstrtox.h> |
1da177e4 LT |
10 | #include <linux/parser.h> |
11 | #include <linux/slab.h> | |
12 | #include <linux/string.h> | |
13 | ||
67222c4b LL |
14 | /* |
15 | * max size needed by different bases to express U64 | |
16 | * HEX: "0xFFFFFFFFFFFFFFFF" --> 18 | |
17 | * DEC: "18446744073709551615" --> 20 | |
18 | * OCT: "01777777777777777777777" --> 23 | |
19 | * pick the max one to define NUMBER_BUF_LEN | |
20 | */ | |
21 | #define NUMBER_BUF_LEN 24 | |
22 | ||
1da177e4 | 23 | /** |
b9bffa10 | 24 | * match_one - Determines if a string matches a simple pattern |
25985edc | 25 | * @s: the string to examine for presence of the pattern |
1da177e4 LT |
26 | * @p: the string containing the pattern |
27 | * @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match | |
28 | * locations. | |
29 | * | |
30 | * Description: Determines if the pattern @p is present in string @s. Can only | |
31 | * match extremely simple token=arg style patterns. If the pattern is found, | |
32 | * the location(s) of the arguments will be returned in the @args array. | |
33 | */ | |
ef4533f8 | 34 | static int match_one(char *s, const char *p, substring_t args[]) |
1da177e4 LT |
35 | { |
36 | char *meta; | |
37 | int argc = 0; | |
38 | ||
39 | if (!p) | |
40 | return 1; | |
41 | ||
42 | while(1) { | |
43 | int len = -1; | |
44 | meta = strchr(p, '%'); | |
45 | if (!meta) | |
46 | return strcmp(p, s) == 0; | |
47 | ||
48 | if (strncmp(p, s, meta-p)) | |
49 | return 0; | |
50 | ||
51 | s += meta - p; | |
52 | p = meta + 1; | |
53 | ||
54 | if (isdigit(*p)) | |
ef4533f8 | 55 | len = simple_strtoul(p, (char **) &p, 10); |
1da177e4 LT |
56 | else if (*p == '%') { |
57 | if (*s++ != '%') | |
58 | return 0; | |
59 | p++; | |
60 | continue; | |
61 | } | |
62 | ||
63 | if (argc >= MAX_OPT_ARGS) | |
64 | return 0; | |
65 | ||
66 | args[argc].from = s; | |
67 | switch (*p++) { | |
b5f54b07 AGR |
68 | case 's': { |
69 | size_t str_len = strlen(s); | |
70 | ||
71 | if (str_len == 0) | |
1da177e4 | 72 | return 0; |
b5f54b07 AGR |
73 | if (len == -1 || len > str_len) |
74 | len = str_len; | |
1da177e4 LT |
75 | args[argc].to = s + len; |
76 | break; | |
b5f54b07 | 77 | } |
1da177e4 LT |
78 | case 'd': |
79 | simple_strtol(s, &args[argc].to, 0); | |
80 | goto num; | |
81 | case 'u': | |
82 | simple_strtoul(s, &args[argc].to, 0); | |
83 | goto num; | |
84 | case 'o': | |
85 | simple_strtoul(s, &args[argc].to, 8); | |
86 | goto num; | |
87 | case 'x': | |
88 | simple_strtoul(s, &args[argc].to, 16); | |
89 | num: | |
90 | if (args[argc].to == args[argc].from) | |
91 | return 0; | |
92 | break; | |
93 | default: | |
94 | return 0; | |
95 | } | |
96 | s = args[argc].to; | |
97 | argc++; | |
98 | } | |
99 | } | |
100 | ||
101 | /** | |
b9bffa10 | 102 | * match_token - Find a token (and optional args) in a string |
1da177e4 LT |
103 | * @s: the string to examine for token/argument pairs |
104 | * @table: match_table_t describing the set of allowed option tokens and the | |
105 | * arguments that may be associated with them. Must be terminated with a | |
106 | * &struct match_token whose pattern is set to the NULL pointer. | |
107 | * @args: array of %MAX_OPT_ARGS &substring_t elements. Used to return match | |
108 | * locations. | |
109 | * | |
110 | * Description: Detects which if any of a set of token strings has been passed | |
edd9334c | 111 | * to it. Tokens can include up to %MAX_OPT_ARGS instances of basic c-style |
1da177e4 LT |
112 | * format identifiers which will be taken into account when matching the |
113 | * tokens, and whose locations will be returned in the @args array. | |
114 | */ | |
a447c093 | 115 | int match_token(char *s, const match_table_t table, substring_t args[]) |
1da177e4 | 116 | { |
ef4533f8 | 117 | const struct match_token *p; |
1da177e4 LT |
118 | |
119 | for (p = table; !match_one(s, p->pattern, args) ; p++) | |
120 | ; | |
121 | ||
122 | return p->token; | |
123 | } | |
a3d2cca4 | 124 | EXPORT_SYMBOL(match_token); |
1da177e4 LT |
125 | |
126 | /** | |
b9bffa10 | 127 | * match_number - scan a number in the given base from a substring_t |
1da177e4 LT |
128 | * @s: substring to be scanned |
129 | * @result: resulting integer on success | |
130 | * @base: base to use when converting string | |
131 | * | |
132 | * Description: Given a &substring_t and a base, attempts to parse the substring | |
edd9334c RD |
133 | * as a number in that base. |
134 | * | |
135 | * Return: On success, sets @result to the integer represented by the | |
359d6255 | 136 | * string and returns 0. Returns -EINVAL or -ERANGE on failure. |
1da177e4 LT |
137 | */ |
138 | static int match_number(substring_t *s, int *result, int base) | |
139 | { | |
140 | char *endp; | |
67222c4b | 141 | char buf[NUMBER_BUF_LEN]; |
1da177e4 | 142 | int ret; |
77dd3b0b | 143 | long val; |
1da177e4 | 144 | |
67222c4b LL |
145 | if (match_strlcpy(buf, s, NUMBER_BUF_LEN) >= NUMBER_BUF_LEN) |
146 | return -ERANGE; | |
1da177e4 | 147 | ret = 0; |
77dd3b0b | 148 | val = simple_strtol(buf, &endp, base); |
1da177e4 LT |
149 | if (endp == buf) |
150 | ret = -EINVAL; | |
77dd3b0b AE |
151 | else if (val < (long)INT_MIN || val > (long)INT_MAX) |
152 | ret = -ERANGE; | |
153 | else | |
154 | *result = (int) val; | |
1da177e4 LT |
155 | return ret; |
156 | } | |
157 | ||
a317178e | 158 | /** |
b9bffa10 | 159 | * match_u64int - scan a number in the given base from a substring_t |
a317178e JS |
160 | * @s: substring to be scanned |
161 | * @result: resulting u64 on success | |
162 | * @base: base to use when converting string | |
163 | * | |
164 | * Description: Given a &substring_t and a base, attempts to parse the substring | |
edd9334c RD |
165 | * as a number in that base. |
166 | * | |
167 | * Return: On success, sets @result to the integer represented by the | |
359d6255 | 168 | * string and returns 0. Returns -EINVAL or -ERANGE on failure. |
a317178e JS |
169 | */ |
170 | static int match_u64int(substring_t *s, u64 *result, int base) | |
171 | { | |
67222c4b | 172 | char buf[NUMBER_BUF_LEN]; |
a317178e JS |
173 | int ret; |
174 | u64 val; | |
a317178e | 175 | |
67222c4b LL |
176 | if (match_strlcpy(buf, s, NUMBER_BUF_LEN) >= NUMBER_BUF_LEN) |
177 | return -ERANGE; | |
a317178e JS |
178 | ret = kstrtoull(buf, base, &val); |
179 | if (!ret) | |
180 | *result = val; | |
a317178e JS |
181 | return ret; |
182 | } | |
183 | ||
1da177e4 | 184 | /** |
b9bffa10 | 185 | * match_int - scan a decimal representation of an integer from a substring_t |
1da177e4 LT |
186 | * @s: substring_t to be scanned |
187 | * @result: resulting integer on success | |
188 | * | |
edd9334c RD |
189 | * Description: Attempts to parse the &substring_t @s as a decimal integer. |
190 | * | |
191 | * Return: On success, sets @result to the integer represented by the string | |
359d6255 | 192 | * and returns 0. Returns -EINVAL or -ERANGE on failure. |
1da177e4 LT |
193 | */ |
194 | int match_int(substring_t *s, int *result) | |
195 | { | |
196 | return match_number(s, result, 0); | |
197 | } | |
a3d2cca4 | 198 | EXPORT_SYMBOL(match_int); |
1da177e4 | 199 | |
edd9334c | 200 | /** |
01531ac3 BC |
201 | * match_uint - scan a decimal representation of an integer from a substring_t |
202 | * @s: substring_t to be scanned | |
203 | * @result: resulting integer on success | |
204 | * | |
edd9334c RD |
205 | * Description: Attempts to parse the &substring_t @s as a decimal integer. |
206 | * | |
207 | * Return: On success, sets @result to the integer represented by the string | |
359d6255 | 208 | * and returns 0. Returns -EINVAL or -ERANGE on failure. |
01531ac3 BC |
209 | */ |
210 | int match_uint(substring_t *s, unsigned int *result) | |
211 | { | |
67222c4b | 212 | char buf[NUMBER_BUF_LEN]; |
01531ac3 | 213 | |
67222c4b LL |
214 | if (match_strlcpy(buf, s, NUMBER_BUF_LEN) >= NUMBER_BUF_LEN) |
215 | return -ERANGE; | |
216 | ||
217 | return kstrtouint(buf, 10, result); | |
01531ac3 BC |
218 | } |
219 | EXPORT_SYMBOL(match_uint); | |
220 | ||
a317178e | 221 | /** |
b9bffa10 | 222 | * match_u64 - scan a decimal representation of a u64 from |
a317178e JS |
223 | * a substring_t |
224 | * @s: substring_t to be scanned | |
225 | * @result: resulting unsigned long long on success | |
226 | * | |
227 | * Description: Attempts to parse the &substring_t @s as a long decimal | |
edd9334c RD |
228 | * integer. |
229 | * | |
230 | * Return: On success, sets @result to the integer represented by the string | |
359d6255 | 231 | * and returns 0. Returns -EINVAL or -ERANGE on failure. |
a317178e JS |
232 | */ |
233 | int match_u64(substring_t *s, u64 *result) | |
234 | { | |
235 | return match_u64int(s, result, 0); | |
236 | } | |
237 | EXPORT_SYMBOL(match_u64); | |
238 | ||
1da177e4 | 239 | /** |
b9bffa10 | 240 | * match_octal - scan an octal representation of an integer from a substring_t |
1da177e4 LT |
241 | * @s: substring_t to be scanned |
242 | * @result: resulting integer on success | |
243 | * | |
edd9334c RD |
244 | * Description: Attempts to parse the &substring_t @s as an octal integer. |
245 | * | |
246 | * Return: On success, sets @result to the integer represented by the string | |
359d6255 | 247 | * and returns 0. Returns -EINVAL or -ERANGE on failure. |
1da177e4 LT |
248 | */ |
249 | int match_octal(substring_t *s, int *result) | |
250 | { | |
251 | return match_number(s, result, 8); | |
252 | } | |
a3d2cca4 | 253 | EXPORT_SYMBOL(match_octal); |
1da177e4 LT |
254 | |
255 | /** | |
b9bffa10 | 256 | * match_hex - scan a hex representation of an integer from a substring_t |
1da177e4 LT |
257 | * @s: substring_t to be scanned |
258 | * @result: resulting integer on success | |
259 | * | |
260 | * Description: Attempts to parse the &substring_t @s as a hexadecimal integer. | |
edd9334c RD |
261 | * |
262 | * Return: On success, sets @result to the integer represented by the string | |
359d6255 | 263 | * and returns 0. Returns -EINVAL or -ERANGE on failure. |
1da177e4 LT |
264 | */ |
265 | int match_hex(substring_t *s, int *result) | |
266 | { | |
267 | return match_number(s, result, 16); | |
268 | } | |
a3d2cca4 | 269 | EXPORT_SYMBOL(match_hex); |
1da177e4 | 270 | |
aace0509 | 271 | /** |
b9bffa10 | 272 | * match_wildcard - parse if a string matches given wildcard pattern |
aace0509 DC |
273 | * @pattern: wildcard pattern |
274 | * @str: the string to be parsed | |
275 | * | |
276 | * Description: Parse the string @str to check if matches wildcard | |
edd9334c | 277 | * pattern @pattern. The pattern may contain two types of wildcards: |
aace0509 DC |
278 | * '*' - matches zero or more characters |
279 | * '?' - matches one character | |
edd9334c RD |
280 | * |
281 | * Return: If the @str matches the @pattern, return true, else return false. | |
aace0509 DC |
282 | */ |
283 | bool match_wildcard(const char *pattern, const char *str) | |
284 | { | |
285 | const char *s = str; | |
286 | const char *p = pattern; | |
287 | bool star = false; | |
288 | ||
289 | while (*s) { | |
290 | switch (*p) { | |
291 | case '?': | |
292 | s++; | |
293 | p++; | |
294 | break; | |
295 | case '*': | |
296 | star = true; | |
297 | str = s; | |
298 | if (!*++p) | |
299 | return true; | |
300 | pattern = p; | |
301 | break; | |
302 | default: | |
303 | if (*s == *p) { | |
304 | s++; | |
305 | p++; | |
306 | } else { | |
307 | if (!star) | |
308 | return false; | |
309 | str++; | |
310 | s = str; | |
311 | p = pattern; | |
312 | } | |
313 | break; | |
314 | } | |
315 | } | |
316 | ||
317 | if (*p == '*') | |
318 | ++p; | |
319 | return !*p; | |
320 | } | |
a3d2cca4 | 321 | EXPORT_SYMBOL(match_wildcard); |
aace0509 | 322 | |
1da177e4 | 323 | /** |
b9bffa10 | 324 | * match_strlcpy - Copy the characters from a substring_t to a sized buffer |
b32a09db MA |
325 | * @dest: where to copy to |
326 | * @src: &substring_t to copy | |
327 | * @size: size of destination buffer | |
1da177e4 | 328 | * |
b32a09db MA |
329 | * Description: Copy the characters in &substring_t @src to the |
330 | * c-style string @dest. Copy no more than @size - 1 characters, plus | |
edd9334c RD |
331 | * the terminating NUL. |
332 | * | |
333 | * Return: length of @src. | |
1da177e4 | 334 | */ |
b32a09db | 335 | size_t match_strlcpy(char *dest, const substring_t *src, size_t size) |
1da177e4 | 336 | { |
b32a09db MA |
337 | size_t ret = src->to - src->from; |
338 | ||
339 | if (size) { | |
340 | size_t len = ret >= size ? size - 1 : ret; | |
341 | memcpy(dest, src->from, len); | |
342 | dest[len] = '\0'; | |
343 | } | |
344 | return ret; | |
1da177e4 | 345 | } |
a3d2cca4 | 346 | EXPORT_SYMBOL(match_strlcpy); |
1da177e4 LT |
347 | |
348 | /** | |
b9bffa10 | 349 | * match_strdup - allocate a new string with the contents of a substring_t |
1da177e4 LT |
350 | * @s: &substring_t to copy |
351 | * | |
352 | * Description: Allocates and returns a string filled with the contents of | |
353 | * the &substring_t @s. The caller is responsible for freeing the returned | |
354 | * string with kfree(). | |
edd9334c RD |
355 | * |
356 | * Return: the address of the newly allocated NUL-terminated string or | |
357 | * %NULL on error. | |
1da177e4 | 358 | */ |
ef4533f8 | 359 | char *match_strdup(const substring_t *s) |
1da177e4 | 360 | { |
30f7bc99 | 361 | return kmemdup_nul(s->from, s->to - s->from, GFP_KERNEL); |
1da177e4 | 362 | } |
1da177e4 | 363 | EXPORT_SYMBOL(match_strdup); |