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 */ 15 s64 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 59 out_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 */ 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; 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 */ 127 char **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 158 out: 159 return argv; 160 161 fail: 162 argv_free(argv); 163 return NULL; 164 } 165 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 204 /* Glob/lazy pattern matching */ 205 static 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 */ 265 bool strglobmatch(const char *str, const char *pat) 266 { 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); 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 { 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 */ 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 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 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 { 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 */ 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 } 360 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) 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 395 out_err_overflow: 396 free(expr); 397 return NULL; 398 } 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 } 445