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 <linux/ctype.h>
8
9 const char *graph_dotted_line =
10 "---------------------------------------------------------------------"
11 "---------------------------------------------------------------------"
12 "---------------------------------------------------------------------";
13 const char *dots =
14 "....................................................................."
15 "....................................................................."
16 ".....................................................................";
17
18 /*
19 * perf_atoll()
20 * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB")
21 * and return its numeric value
22 */
23 s64 perf_atoll(const char *str)
24 {
25 s64 length;
26 char *p;
27 char c;
28
29 if (!isdigit(str[0]))
30 goto out_err;
31
32 length = strtoll(str, &p, 10);
33 switch (c = *p++) {
34 case 'b': case 'B':
35 if (*p)
36 goto out_err;
37
38 fallthrough;
39 case '\0':
40 return length;
41 default:
42 goto out_err;
43 /* two-letter suffices */
44 case 'k': case 'K':
45 length <<= 10;
46 break;
47 case 'm': case 'M':
48 length <<= 20;
49 break;
50 case 'g': case 'G':
51 length <<= 30;
52 break;
53 case 't': case 'T':
54 length <<= 40;
55 break;
56 }
57 /* we want the cases to match */
58 if (islower(c)) {
59 if (strcmp(p, "b") != 0)
60 goto out_err;
61 } else {
62 if (strcmp(p, "B") != 0)
63 goto out_err;
64 }
65 return length;
66
67 out_err:
68 return -1;
69 }
70
71 /* Character class matching */
72 static bool __match_charclass(const char *pat, char c, const char **npat)
73 {
74 bool complement = false, ret = true;
75
76 if (*pat == '!') {
77 complement = true;
78 pat++;
79 }
80 if (*pat++ == c) /* First character is special */
81 goto end;
82
83 while (*pat && *pat != ']') { /* Matching */
84 if (*pat == '-' && *(pat + 1) != ']') { /* Range */
85 if (*(pat - 1) <= c && c <= *(pat + 1))
86 goto end;
87 if (*(pat - 1) > *(pat + 1))
88 goto error;
89 pat += 2;
90 } else if (*pat++ == c)
91 goto end;
92 }
93 if (!*pat)
94 goto error;
95 ret = false;
96
97 end:
98 while (*pat && *pat != ']') /* Searching closing */
99 pat++;
100 if (!*pat)
101 goto error;
102 *npat = pat + 1;
103 return complement ? !ret : ret;
104
105 error:
106 return false;
107 }
108
109 /* Glob/lazy pattern matching */
110 static bool __match_glob(const char *str, const char *pat, bool ignore_space,
111 bool case_ins)
112 {
113 while (*str && *pat && *pat != '*') {
114 if (ignore_space) {
115 /* Ignore spaces for lazy matching */
116 if (isspace(*str)) {
117 str++;
118 continue;
119 }
120 if (isspace(*pat)) {
121 pat++;
122 continue;
123 }
124 }
125 if (*pat == '?') { /* Matches any single character */
126 str++;
127 pat++;
128 continue;
129 } else if (*pat == '[') /* Character classes/Ranges */
130 if (__match_charclass(pat + 1, *str, &pat)) {
131 str++;
132 continue;
133 } else
134 return false;
135 else if (*pat == '\\') /* Escaped char match as normal char */
136 pat++;
137 if (case_ins) {
138 if (tolower(*str) != tolower(*pat))
139 return false;
140 } else if (*str != *pat)
141 return false;
142 str++;
143 pat++;
144 }
145 /* Check wild card */
146 if (*pat == '*') {
147 while (*pat == '*')
148 pat++;
149 if (!*pat) /* Tail wild card matches all */
150 return true;
151 while (*str)
152 if (__match_glob(str++, pat, ignore_space, case_ins))
153 return true;
154 }
155 return !*str && !*pat;
156 }
157
158 /**
159 * strglobmatch - glob expression pattern matching
160 * @str: the target string to match
161 * @pat: the pattern string to match
162 *
163 * This returns true if the @str matches @pat. @pat can includes wildcards
164 * ('*','?') and character classes ([CHARS], complementation and ranges are
165 * also supported). Also, this supports escape character ('\') to use special
166 * characters as normal character.
167 *
168 * Note: if @pat syntax is broken, this always returns false.
169 */
170 bool strglobmatch(const char *str, const char *pat)
171 {
172 return __match_glob(str, pat, false, false);
173 }
174
175 bool strglobmatch_nocase(const char *str, const char *pat)
176 {
177 return __match_glob(str, pat, false, true);
178 }
179
180 /**
181 * strlazymatch - matching pattern strings lazily with glob pattern
182 * @str: the target string to match
183 * @pat: the pattern string to match
184 *
185 * This is similar to strglobmatch, except this ignores spaces in
186 * the target string.
187 */
188 bool strlazymatch(const char *str, const char *pat)
189 {
190 return __match_glob(str, pat, true, false);
191 }
192
193 /**
194 * strtailcmp - Compare the tail of two strings
195 * @s1: 1st string to be compared
196 * @s2: 2nd string to be compared
197 *
198 * Return 0 if whole of either string is same as another's tail part.
199 */
200 int strtailcmp(const char *s1, const char *s2)
201 {
202 int i1 = strlen(s1);
203 int i2 = strlen(s2);
204 while (--i1 >= 0 && --i2 >= 0) {
205 if (s1[i1] != s2[i2])
206 return s1[i1] - s2[i2];
207 }
208 return 0;
209 }
210
211 char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints)
212 {
213 /*
214 * FIXME: replace this with an expression using log10() when we
215 * find a suitable implementation, maybe the one in the dvb drivers...
216 *
217 * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators
218 */
219 size_t size = nints * 28 + 1; /* \0 */
220 size_t i, printed = 0;
221 char *expr = malloc(size);
222
223 if (expr) {
224 const char *or_and = "||", *eq_neq = "==";
225 char *e = expr;
226
227 if (!in) {
228 or_and = "&&";
229 eq_neq = "!=";
230 }
231
232 for (i = 0; i < nints; ++i) {
233 if (printed == size)
234 goto out_err_overflow;
235
236 if (i > 0)
237 printed += scnprintf(e + printed, size - printed, " %s ", or_and);
238 printed += scnprintf(e + printed, size - printed,
239 "%s %s %d", var, eq_neq, ints[i]);
240 }
241 }
242
243 return expr;
244
245 out_err_overflow:
246 free(expr);
247 return NULL;
248 }
249
250 /* Like strpbrk(), but not break if it is right after a backslash (escaped) */
251 char *strpbrk_esc(char *str, const char *stopset)
252 {
253 char *ptr;
254
255 do {
256 ptr = strpbrk(str, stopset);
257 if (ptr == str ||
258 (ptr == str + 1 && *(ptr - 1) != '\\'))
259 break;
260 str = ptr + 1;
261 } while (ptr && *(ptr - 1) == '\\' && *(ptr - 2) != '\\');
262
263 return ptr;
264 }
265
266 /* Like strdup, but do not copy a single backslash */
267 char *strdup_esc(const char *str)
268 {
269 char *s, *d, *p, *ret = strdup(str);
270
271 if (!ret)
272 return NULL;
273
274 d = strchr(ret, '\\');
275 if (!d)
276 return ret;
277
278 s = d + 1;
279 do {
280 if (*s == '\0') {
281 *d = '\0';
282 break;
283 }
284 p = strchr(s + 1, '\\');
285 if (p) {
286 memmove(d, s, p - s);
287 d += p - s;
288 s = p + 1;
289 } else
290 memmove(d, s, strlen(s) + 1);
291 } while (p);
292
293 return ret;
294 }
295
296 unsigned int hex(char c)
297 {
298 if (c >= '' && c <= '9')
299 return c - '';
300 if (c >= 'a' && c <= 'f')
301 return c - 'a' + 10;
302 return c - 'A' + 10;
303 }
304
305 /*
306 * Replace all occurrences of character 'needle' in string 'haystack' with
307 * string 'replace'
308 *
309 * The new string could be longer so a new string is returned which must be
310 * freed.
311 */
312 char *strreplace_chars(char needle, const char *haystack, const char *replace)
313 {
314 int replace_len = strlen(replace);
315 char *new_s, *to;
316 const char *loc = strchr(haystack, needle);
317 const char *from = haystack;
318 int num = 0;
319
320 /* Count occurrences */
321 while (loc) {
322 loc = strchr(loc + 1, needle);
323 num++;
324 }
325
326 /* Allocate enough space for replacements and reset first location */
327 new_s = malloc(strlen(haystack) + (num * (replace_len - 1) + 1));
328 if (!new_s)
329 return NULL;
330 loc = strchr(haystack, needle);
331 to = new_s;
332
333 while (loc) {
334 /* Copy original string up to found char and update positions */
335 memcpy(to, from, 1 + loc - from);
336 to += loc - from;
337 from = loc + 1;
338
339 /* Copy replacement string and update positions */
340 memcpy(to, replace, replace_len);
341 to += replace_len;
342
343 /* needle next occurrence or end of string */
344 loc = strchr(from, needle);
345 }
346
347 /* Copy any remaining chars + null */
348 strcpy(to, from);
349
350 return new_s;
351 }
352
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.