tools/perf/util/string.c

   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 }