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