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 #define K 1024LL
19 /*
20 * perf_atoll()
21 * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB")
22 * and return its numeric value
23 */
perf_atoll(const char * str)24 s64 perf_atoll(const char *str)
25 {
26 s64 length;
27 char *p;
28 char c;
29
30 if (!isdigit(str[0]))
31 goto out_err;
32
33 length = strtoll(str, &p, 10);
34 switch (c = *p++) {
35 case 'b': case 'B':
36 if (*p)
37 goto out_err;
38
39 __fallthrough;
40 case '\0':
41 return length;
42 default:
43 goto out_err;
44 /* two-letter suffices */
45 case 'k': case 'K':
46 length <<= 10;
47 break;
48 case 'm': case 'M':
49 length <<= 20;
50 break;
51 case 'g': case 'G':
52 length <<= 30;
53 break;
54 case 't': case 'T':
55 length <<= 40;
56 break;
57 }
58 /* we want the cases to match */
59 if (islower(c)) {
60 if (strcmp(p, "b") != 0)
61 goto out_err;
62 } else {
63 if (strcmp(p, "B") != 0)
64 goto out_err;
65 }
66 return length;
67
68 out_err:
69 return -1;
70 }
71
72 /* Character class matching */
__match_charclass(const char * pat,char c,const char ** npat)73 static bool __match_charclass(const char *pat, char c, const char **npat)
74 {
75 bool complement = false, ret = true;
76
77 if (*pat == '!') {
78 complement = true;
79 pat++;
80 }
81 if (*pat++ == c) /* First character is special */
82 goto end;
83
84 while (*pat && *pat != ']') { /* Matching */
85 if (*pat == '-' && *(pat + 1) != ']') { /* Range */
86 if (*(pat - 1) <= c && c <= *(pat + 1))
87 goto end;
88 if (*(pat - 1) > *(pat + 1))
89 goto error;
90 pat += 2;
91 } else if (*pat++ == c)
92 goto end;
93 }
94 if (!*pat)
95 goto error;
96 ret = false;
97
98 end:
99 while (*pat && *pat != ']') /* Searching closing */
100 pat++;
101 if (!*pat)
102 goto error;
103 *npat = pat + 1;
104 return complement ? !ret : ret;
105
106 error:
107 return false;
108 }
109
110 /* Glob/lazy pattern matching */
__match_glob(const char * str,const char * pat,bool ignore_space,bool case_ins)111 static bool __match_glob(const char *str, const char *pat, bool ignore_space,
112 bool case_ins)
113 {
114 while (*str && *pat && *pat != '*') {
115 if (ignore_space) {
116 /* Ignore spaces for lazy matching */
117 if (isspace(*str)) {
118 str++;
119 continue;
120 }
121 if (isspace(*pat)) {
122 pat++;
123 continue;
124 }
125 }
126 if (*pat == '?') { /* Matches any single character */
127 str++;
128 pat++;
129 continue;
130 } else if (*pat == '[') /* Character classes/Ranges */
131 if (__match_charclass(pat + 1, *str, &pat)) {
132 str++;
133 continue;
134 } else
135 return false;
136 else if (*pat == '\\') /* Escaped char match as normal char */
137 pat++;
138 if (case_ins) {
139 if (tolower(*str) != tolower(*pat))
140 return false;
141 } else if (*str != *pat)
142 return false;
143 str++;
144 pat++;
145 }
146 /* Check wild card */
147 if (*pat == '*') {
148 while (*pat == '*')
149 pat++;
150 if (!*pat) /* Tail wild card matches all */
151 return true;
152 while (*str)
153 if (__match_glob(str++, pat, ignore_space, case_ins))
154 return true;
155 }
156 return !*str && !*pat;
157 }
158
159 /**
160 * strglobmatch - glob expression pattern matching
161 * @str: the target string to match
162 * @pat: the pattern string to match
163 *
164 * This returns true if the @str matches @pat. @pat can includes wildcards
165 * ('*','?') and character classes ([CHARS], complementation and ranges are
166 * also supported). Also, this supports escape character ('\') to use special
167 * characters as normal character.
168 *
169 * Note: if @pat syntax is broken, this always returns false.
170 */
strglobmatch(const char * str,const char * pat)171 bool strglobmatch(const char *str, const char *pat)
172 {
173 return __match_glob(str, pat, false, false);
174 }
175
strglobmatch_nocase(const char * str,const char * pat)176 bool strglobmatch_nocase(const char *str, const char *pat)
177 {
178 return __match_glob(str, pat, false, true);
179 }
180
181 /**
182 * strlazymatch - matching pattern strings lazily with glob pattern
183 * @str: the target string to match
184 * @pat: the pattern string to match
185 *
186 * This is similar to strglobmatch, except this ignores spaces in
187 * the target string.
188 */
strlazymatch(const char * str,const char * pat)189 bool strlazymatch(const char *str, const char *pat)
190 {
191 return __match_glob(str, pat, true, false);
192 }
193
194 /**
195 * strtailcmp - Compare the tail of two strings
196 * @s1: 1st string to be compared
197 * @s2: 2nd string to be compared
198 *
199 * Return 0 if whole of either string is same as another's tail part.
200 */
strtailcmp(const char * s1,const char * s2)201 int strtailcmp(const char *s1, const char *s2)
202 {
203 int i1 = strlen(s1);
204 int i2 = strlen(s2);
205 while (--i1 >= 0 && --i2 >= 0) {
206 if (s1[i1] != s2[i2])
207 return s1[i1] - s2[i2];
208 }
209 return 0;
210 }
211
asprintf_expr_inout_ints(const char * var,bool in,size_t nints,int * ints)212 char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints)
213 {
214 /*
215 * FIXME: replace this with an expression using log10() when we
216 * find a suitable implementation, maybe the one in the dvb drivers...
217 *
218 * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators
219 */
220 size_t size = nints * 28 + 1; /* \0 */
221 size_t i, printed = 0;
222 char *expr = malloc(size);
223
224 if (expr) {
225 const char *or_and = "||", *eq_neq = "==";
226 char *e = expr;
227
228 if (!in) {
229 or_and = "&&";
230 eq_neq = "!=";
231 }
232
233 for (i = 0; i < nints; ++i) {
234 if (printed == size)
235 goto out_err_overflow;
236
237 if (i > 0)
238 printed += scnprintf(e + printed, size - printed, " %s ", or_and);
239 printed += scnprintf(e + printed, size - printed,
240 "%s %s %d", var, eq_neq, ints[i]);
241 }
242 }
243
244 return expr;
245
246 out_err_overflow:
247 free(expr);
248 return NULL;
249 }
250
251 /* Like strpbrk(), but not break if it is right after a backslash (escaped) */
strpbrk_esc(char * str,const char * stopset)252 char *strpbrk_esc(char *str, const char *stopset)
253 {
254 char *ptr;
255
256 do {
257 ptr = strpbrk(str, stopset);
258 if (ptr == str ||
259 (ptr == str + 1 && *(ptr - 1) != '\\'))
260 break;
261 str = ptr + 1;
262 } while (ptr && *(ptr - 1) == '\\' && *(ptr - 2) != '\\');
263
264 return ptr;
265 }
266
267 /* Like strdup, but do not copy a single backslash */
strdup_esc(const char * str)268 char *strdup_esc(const char *str)
269 {
270 char *s, *d, *p, *ret = strdup(str);
271
272 if (!ret)
273 return NULL;
274
275 d = strchr(ret, '\\');
276 if (!d)
277 return ret;
278
279 s = d + 1;
280 do {
281 if (*s == '\0') {
282 *d = '\0';
283 break;
284 }
285 p = strchr(s + 1, '\\');
286 if (p) {
287 memmove(d, s, p - s);
288 d += p - s;
289 s = p + 1;
290 } else
291 memmove(d, s, strlen(s) + 1);
292 } while (p);
293
294 return ret;
295 }
296
