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 */ 10 s64 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 52 out_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 */ 60 static const char *skip_sep(const char *cp) 61 { 62 while (*cp && isspace(*cp)) 63 cp++; 64 65 return cp; 66 } 67 68 static const char *skip_arg(const char *cp) 69 { 70 while (*cp && !isspace(*cp)) 71 cp++; 72 73 return cp; 74 } 75 76 static 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 */ 97 void 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 */ 118 char **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 149 out: 150 return argv; 151 152 fail: 153 argv_free(argv); 154 return NULL; 155 } 156 157 /* Character class matching */ 158 static 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 183 end: 184 while (*pat && *pat != ']') /* Searching closing */ 185 pat++; 186 if (!*pat) 187 goto error; 188 *npat = pat + 1; 189 return complement ? !ret : ret; 190 191 error: 192 return false; 193 } 194 195 /* Glob/lazy pattern matching */ 196 static 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 */ 256 bool strglobmatch(const char *str, const char *pat) 257 { 258 return __match_glob(str, pat, false, false); 259 } 260 261 bool 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 */ 274 bool 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 */ 286 int 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 */ 305 char *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 */ 321 char *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 */ 340 char *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 356 char *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 390 out_err_overflow: 391 free(expr); 392 return NULL; 393 } 394