]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
a067558e ACM |
2 | #include "string2.h" |
3 | #include <linux/kernel.h> | |
4 | #include <linux/string.h> | |
5 | #include <stdlib.h> | |
ea5cc87c | 6 | |
3d689ed6 ACM |
7 | #include "sane_ctype.h" |
8 | ||
d2fb8b41 HM |
9 | #define K 1024LL |
10 | /* | |
11 | * perf_atoll() | |
12 | * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB") | |
13 | * and return its numeric value | |
14 | */ | |
15 | s64 perf_atoll(const char *str) | |
16 | { | |
8ba7f6c2 AV |
17 | s64 length; |
18 | char *p; | |
19 | char c; | |
d2fb8b41 HM |
20 | |
21 | if (!isdigit(str[0])) | |
22 | goto out_err; | |
23 | ||
8ba7f6c2 AV |
24 | length = strtoll(str, &p, 10); |
25 | switch (c = *p++) { | |
26 | case 'b': case 'B': | |
27 | if (*p) | |
d2fb8b41 | 28 | goto out_err; |
94bdd5ed ACM |
29 | |
30 | __fallthrough; | |
8ba7f6c2 AV |
31 | case '\0': |
32 | return length; | |
33 | default: | |
34 | goto out_err; | |
35 | /* two-letter suffices */ | |
36 | case 'k': case 'K': | |
37 | length <<= 10; | |
d2fb8b41 | 38 | break; |
8ba7f6c2 AV |
39 | case 'm': case 'M': |
40 | length <<= 20; | |
d2fb8b41 | 41 | break; |
8ba7f6c2 AV |
42 | case 'g': case 'G': |
43 | length <<= 30; | |
d2fb8b41 | 44 | break; |
8ba7f6c2 AV |
45 | case 't': case 'T': |
46 | length <<= 40; | |
d2fb8b41 | 47 | break; |
d2fb8b41 | 48 | } |
8ba7f6c2 AV |
49 | /* we want the cases to match */ |
50 | if (islower(c)) { | |
51 | if (strcmp(p, "b") != 0) | |
52 | goto out_err; | |
53 | } else { | |
54 | if (strcmp(p, "B") != 0) | |
55 | goto out_err; | |
56 | } | |
57 | return length; | |
d2fb8b41 HM |
58 | |
59 | out_err: | |
8ba7f6c2 | 60 | return -1; |
d2fb8b41 | 61 | } |
e1c01d61 MH |
62 | |
63 | /* | |
64 | * Helper function for splitting a string into an argv-like array. | |
25985edc | 65 | * originally copied from lib/argv_split.c |
e1c01d61 MH |
66 | */ |
67 | static const char *skip_sep(const char *cp) | |
68 | { | |
69 | while (*cp && isspace(*cp)) | |
70 | cp++; | |
71 | ||
72 | return cp; | |
73 | } | |
74 | ||
75 | static const char *skip_arg(const char *cp) | |
76 | { | |
77 | while (*cp && !isspace(*cp)) | |
78 | cp++; | |
79 | ||
80 | return cp; | |
81 | } | |
82 | ||
83 | static int count_argc(const char *str) | |
84 | { | |
85 | int count = 0; | |
86 | ||
87 | while (*str) { | |
88 | str = skip_sep(str); | |
89 | if (*str) { | |
90 | count++; | |
91 | str = skip_arg(str); | |
92 | } | |
93 | } | |
94 | ||
95 | return count; | |
96 | } | |
97 | ||
98 | /** | |
99 | * argv_free - free an argv | |
100 | * @argv - the argument vector to be freed | |
101 | * | |
102 | * Frees an argv and the strings it points to. | |
103 | */ | |
104 | void argv_free(char **argv) | |
105 | { | |
106 | char **p; | |
a067558e ACM |
107 | for (p = argv; *p; p++) { |
108 | free(*p); | |
109 | *p = NULL; | |
110 | } | |
e1c01d61 MH |
111 | |
112 | free(argv); | |
113 | } | |
114 | ||
115 | /** | |
116 | * argv_split - split a string at whitespace, returning an argv | |
117 | * @str: the string to be split | |
118 | * @argcp: returned argument count | |
119 | * | |
120 | * Returns an array of pointers to strings which are split out from | |
121 | * @str. This is performed by strictly splitting on white-space; no | |
122 | * quote processing is performed. Multiple whitespace characters are | |
123 | * considered to be a single argument separator. The returned array | |
124 | * is always NULL-terminated. Returns NULL on memory allocation | |
125 | * failure. | |
126 | */ | |
127 | char **argv_split(const char *str, int *argcp) | |
128 | { | |
129 | int argc = count_argc(str); | |
a067558e | 130 | char **argv = calloc(argc + 1, sizeof(*argv)); |
e1c01d61 MH |
131 | char **argvp; |
132 | ||
133 | if (argv == NULL) | |
134 | goto out; | |
135 | ||
136 | if (argcp) | |
137 | *argcp = argc; | |
138 | ||
139 | argvp = argv; | |
140 | ||
141 | while (*str) { | |
142 | str = skip_sep(str); | |
143 | ||
144 | if (*str) { | |
145 | const char *p = str; | |
146 | char *t; | |
147 | ||
148 | str = skip_arg(str); | |
149 | ||
150 | t = strndup(p, str-p); | |
151 | if (t == NULL) | |
152 | goto fail; | |
153 | *argvp++ = t; | |
154 | } | |
155 | } | |
156 | *argvp = NULL; | |
157 | ||
158 | out: | |
159 | return argv; | |
160 | ||
161 | fail: | |
162 | argv_free(argv); | |
163 | return NULL; | |
164 | } | |
bbbb521b | 165 | |
6964cd2c MH |
166 | /* Character class matching */ |
167 | static bool __match_charclass(const char *pat, char c, const char **npat) | |
168 | { | |
169 | bool complement = false, ret = true; | |
170 | ||
171 | if (*pat == '!') { | |
172 | complement = true; | |
173 | pat++; | |
174 | } | |
175 | if (*pat++ == c) /* First character is special */ | |
176 | goto end; | |
177 | ||
178 | while (*pat && *pat != ']') { /* Matching */ | |
179 | if (*pat == '-' && *(pat + 1) != ']') { /* Range */ | |
180 | if (*(pat - 1) <= c && c <= *(pat + 1)) | |
181 | goto end; | |
182 | if (*(pat - 1) > *(pat + 1)) | |
183 | goto error; | |
184 | pat += 2; | |
185 | } else if (*pat++ == c) | |
186 | goto end; | |
187 | } | |
188 | if (!*pat) | |
189 | goto error; | |
190 | ret = false; | |
191 | ||
192 | end: | |
193 | while (*pat && *pat != ']') /* Searching closing */ | |
194 | pat++; | |
195 | if (!*pat) | |
196 | goto error; | |
197 | *npat = pat + 1; | |
198 | return complement ? !ret : ret; | |
199 | ||
200 | error: | |
201 | return false; | |
202 | } | |
203 | ||
2a9c8c36 | 204 | /* Glob/lazy pattern matching */ |
38d14f0c AK |
205 | static bool __match_glob(const char *str, const char *pat, bool ignore_space, |
206 | bool case_ins) | |
bbbb521b MH |
207 | { |
208 | while (*str && *pat && *pat != '*') { | |
2a9c8c36 MH |
209 | if (ignore_space) { |
210 | /* Ignore spaces for lazy matching */ | |
211 | if (isspace(*str)) { | |
212 | str++; | |
213 | continue; | |
214 | } | |
215 | if (isspace(*pat)) { | |
216 | pat++; | |
217 | continue; | |
218 | } | |
219 | } | |
6964cd2c | 220 | if (*pat == '?') { /* Matches any single character */ |
bbbb521b MH |
221 | str++; |
222 | pat++; | |
6964cd2c MH |
223 | continue; |
224 | } else if (*pat == '[') /* Character classes/Ranges */ | |
225 | if (__match_charclass(pat + 1, *str, &pat)) { | |
226 | str++; | |
227 | continue; | |
228 | } else | |
bbbb521b | 229 | return false; |
6964cd2c MH |
230 | else if (*pat == '\\') /* Escaped char match as normal char */ |
231 | pat++; | |
38d14f0c AK |
232 | if (case_ins) { |
233 | if (tolower(*str) != tolower(*pat)) | |
234 | return false; | |
235 | } else if (*str != *pat) | |
6964cd2c | 236 | return false; |
38d14f0c AK |
237 | str++; |
238 | pat++; | |
bbbb521b MH |
239 | } |
240 | /* Check wild card */ | |
241 | if (*pat == '*') { | |
242 | while (*pat == '*') | |
243 | pat++; | |
244 | if (!*pat) /* Tail wild card matches all */ | |
245 | return true; | |
246 | while (*str) | |
38d14f0c | 247 | if (__match_glob(str++, pat, ignore_space, case_ins)) |
bbbb521b MH |
248 | return true; |
249 | } | |
250 | return !*str && !*pat; | |
251 | } | |
252 | ||
2a9c8c36 MH |
253 | /** |
254 | * strglobmatch - glob expression pattern matching | |
255 | * @str: the target string to match | |
256 | * @pat: the pattern string to match | |
257 | * | |
258 | * This returns true if the @str matches @pat. @pat can includes wildcards | |
259 | * ('*','?') and character classes ([CHARS], complementation and ranges are | |
260 | * also supported). Also, this supports escape character ('\') to use special | |
261 | * characters as normal character. | |
262 | * | |
263 | * Note: if @pat syntax is broken, this always returns false. | |
264 | */ | |
265 | bool strglobmatch(const char *str, const char *pat) | |
266 | { | |
38d14f0c AK |
267 | return __match_glob(str, pat, false, false); |
268 | } | |
269 | ||
270 | bool strglobmatch_nocase(const char *str, const char *pat) | |
271 | { | |
272 | return __match_glob(str, pat, false, true); | |
2a9c8c36 MH |
273 | } |
274 | ||
275 | /** | |
276 | * strlazymatch - matching pattern strings lazily with glob pattern | |
277 | * @str: the target string to match | |
278 | * @pat: the pattern string to match | |
279 | * | |
280 | * This is similar to strglobmatch, except this ignores spaces in | |
281 | * the target string. | |
282 | */ | |
283 | bool strlazymatch(const char *str, const char *pat) | |
284 | { | |
38d14f0c | 285 | return __match_glob(str, pat, true, false); |
2a9c8c36 | 286 | } |
bad03ae4 MH |
287 | |
288 | /** | |
289 | * strtailcmp - Compare the tail of two strings | |
290 | * @s1: 1st string to be compared | |
291 | * @s2: 2nd string to be compared | |
292 | * | |
293 | * Return 0 if whole of either string is same as another's tail part. | |
294 | */ | |
295 | int strtailcmp(const char *s1, const char *s2) | |
296 | { | |
297 | int i1 = strlen(s1); | |
298 | int i2 = strlen(s2); | |
299 | while (--i1 >= 0 && --i2 >= 0) { | |
300 | if (s1[i1] != s2[i2]) | |
301 | return s1[i1] - s2[i2]; | |
302 | } | |
303 | return 0; | |
304 | } | |
305 | ||
ea36c46b JO |
306 | /** |
307 | * strxfrchar - Locate and replace character in @s | |
308 | * @s: The string to be searched/changed. | |
309 | * @from: Source character to be replaced. | |
310 | * @to: Destination character. | |
311 | * | |
312 | * Return pointer to the changed string. | |
313 | */ | |
314 | char *strxfrchar(char *s, char from, char to) | |
315 | { | |
316 | char *p = s; | |
317 | ||
318 | while ((p = strchr(p, from)) != NULL) | |
319 | *p++ = to; | |
320 | ||
321 | return s; | |
322 | } | |
323 | ||
08aa9cce NK |
324 | /** |
325 | * ltrim - Removes leading whitespace from @s. | |
326 | * @s: The string to be stripped. | |
327 | * | |
328 | * Return pointer to the first non-whitespace character in @s. | |
329 | */ | |
330 | char *ltrim(char *s) | |
331 | { | |
ecbe5e10 | 332 | while (isspace(*s)) |
08aa9cce | 333 | s++; |
08aa9cce NK |
334 | |
335 | return s; | |
336 | } | |
337 | ||
cb1a28a0 ACM |
338 | /** |
339 | * rtrim - Removes trailing whitespace from @s. | |
340 | * @s: The string to be stripped. | |
341 | * | |
342 | * Note that the first trailing whitespace is replaced with a %NUL-terminator | |
343 | * in the given string @s. Returns @s. | |
344 | */ | |
345 | char *rtrim(char *s) | |
346 | { | |
347 | size_t size = strlen(s); | |
348 | char *end; | |
349 | ||
350 | if (!size) | |
351 | return s; | |
352 | ||
353 | end = s + size - 1; | |
354 | while (end >= s && isspace(*end)) | |
355 | end--; | |
356 | *(end + 1) = '\0'; | |
357 | ||
358 | return s; | |
359 | } | |
b232e073 | 360 | |
93ec4ce7 ACM |
361 | char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints) |
362 | { | |
363 | /* | |
364 | * FIXME: replace this with an expression using log10() when we | |
365 | * find a suitable implementation, maybe the one in the dvb drivers... | |
366 | * | |
367 | * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators | |
368 | */ | |
369 | size_t size = nints * 28 + 1; /* \0 */ | |
370 | size_t i, printed = 0; | |
371 | char *expr = malloc(size); | |
372 | ||
373 | if (expr) { | |
374 | const char *or_and = "||", *eq_neq = "=="; | |
375 | char *e = expr; | |
376 | ||
377 | if (!in) { | |
378 | or_and = "&&"; | |
379 | eq_neq = "!="; | |
380 | } | |
381 | ||
382 | for (i = 0; i < nints; ++i) { | |
383 | if (printed == size) | |
384 | goto out_err_overflow; | |
385 | ||
386 | if (i > 0) | |
a067558e | 387 | printed += scnprintf(e + printed, size - printed, " %s ", or_and); |
93ec4ce7 ACM |
388 | printed += scnprintf(e + printed, size - printed, |
389 | "%s %s %d", var, eq_neq, ints[i]); | |
390 | } | |
391 | } | |
392 | ||
393 | return expr; | |
394 | ||
395 | out_err_overflow: | |
396 | free(expr); | |
397 | return NULL; | |
398 | } | |
1e9f9e8a MH |
399 | |
400 | /* Like strpbrk(), but not break if it is right after a backslash (escaped) */ | |
401 | char *strpbrk_esc(char *str, const char *stopset) | |
402 | { | |
403 | char *ptr; | |
404 | ||
405 | do { | |
406 | ptr = strpbrk(str, stopset); | |
407 | if (ptr == str || | |
408 | (ptr == str + 1 && *(ptr - 1) != '\\')) | |
409 | break; | |
410 | str = ptr + 1; | |
411 | } while (ptr && *(ptr - 1) == '\\' && *(ptr - 2) != '\\'); | |
412 | ||
413 | return ptr; | |
414 | } | |
415 | ||
416 | /* Like strdup, but do not copy a single backslash */ | |
417 | char *strdup_esc(const char *str) | |
418 | { | |
419 | char *s, *d, *p, *ret = strdup(str); | |
420 | ||
421 | if (!ret) | |
422 | return NULL; | |
423 | ||
424 | d = strchr(ret, '\\'); | |
425 | if (!d) | |
426 | return ret; | |
427 | ||
428 | s = d + 1; | |
429 | do { | |
430 | if (*s == '\0') { | |
431 | *d = '\0'; | |
432 | break; | |
433 | } | |
434 | p = strchr(s + 1, '\\'); | |
435 | if (p) { | |
436 | memmove(d, s, p - s); | |
437 | d += p - s; | |
438 | s = p + 1; | |
439 | } else | |
440 | memmove(d, s, strlen(s) + 1); | |
441 | } while (p); | |
442 | ||
443 | return ret; | |
444 | } |