Impressum string.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include "string2.h"
#include <linux/kernel.h>
#include <linux/string.h>
#include <stdlib.h>

#include <linux/ctype.h>

const char *graph_dotted_line =
 "---------------------------------------------------------------------"
 "---------------------------------------------------------------------"
 "---------------------------------------------------------------------";
const char *dots =
 "....................................................................."
 "....................................................................."
 ".....................................................................";

/*
 * perf_atoll()
 * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB")
 * and return its numeric value
 */
s64 perf_atoll(const char *str)
{
 s64 length;
 char *p;
 char c;

 if (!isdigit(str[0]))
  goto out_err;

 length = strtoll(str, &p, 10);
 switch (c = *p++) {
  case 'b': case 'B':
   if (*p)
    goto out_err;

   fallthrough;
  case '\0':
   return length;
  default:
   goto out_err;
  /* two-letter suffices */
  case 'k': case 'K':
   length <<= 10;
   break;
  case 'm': case 'M':
   length <<= 20;
   break;
  case 'g': case 'G':
   length <<= 30;
   break;
  case 't': case 'T':
   length <<= 40;
   break;
 }
 /* we want the cases to match */
 if (islower(c)) {
  if (strcmp(p, "b") != 0)
   goto out_err;
 } else {
  if (strcmp(p, "B") != 0)
   goto out_err;
 }
 return length;

out_err:
 return -1;
}

/* Character class matching */
static bool __match_charclass(const char *pat, char c, const char **npat)
{
 bool complement = false, ret = true;

 if (*pat == '!') {
  complement = true;
  pat++;
 }
 if (*pat++ == c) /* First character is special */
  goto end;

 while (*pat && *pat != ']') { /* Matching */
  if (*pat == '-' && *(pat + 1) != ']') { /* Range */
   if (*(pat - 1) <= c && c <= *(pat + 1))
    goto end;
   if (*(pat - 1) > *(pat + 1))
    goto error;
   pat += 2;
  } else if (*pat++ == c)
   goto end;
 }
 if (!*pat)
  goto error;
 ret = false;

end:
 while (*pat && *pat != ']') /* Searching closing */
  pat++;
 if (!*pat)
  goto error;
 *npat = pat + 1;
 return complement ? !ret : ret;

error:
 return false;
}

/* Glob/lazy pattern matching */
static bool __match_glob(const char *str, const char *pat, bool ignore_space,
   bool case_ins)
{
 while (*str && *pat && *pat != '*') {
  if (ignore_space) {
   /* Ignore spaces for lazy matching */
   if (isspace(*str)) {
    str++;
    continue;
   }
   if (isspace(*pat)) {
    pat++;
    continue;
   }
  }
  if (*pat == '?') { /* Matches any single character */
   str++;
   pat++;
   continue;
  } else if (*pat == '[') /* Character classes/Ranges */
   if (__match_charclass(pat + 1, *str, &pat)) {
    str++;
    continue;
   } else
    return false;
  else if (*pat == '\\') /* Escaped char match as normal char */
   pat++;
  if (case_ins) {
   if (tolower(*str) != tolower(*pat))
    return false;
  } else if (*str != *pat)
   return false;
  str++;
  pat++;
 }
 /* Check wild card */
 if (*pat == '*') {
  while (*pat == '*')
   pat++;
  if (!*pat) /* Tail wild card matches all */
   return true;
  while (*str)
   if (__match_glob(str++, pat, ignore_space, case_ins))
    return true;
 }
 return !*str && !*pat;
}

/**
 * strglobmatch - glob expression pattern matching
 * @str: the target string to match
 * @pat: the pattern string to match
 *
 * This returns true if the @str matches @pat. @pat can includes wildcards
 * ('*','?') and character classes ([CHARS], complementation and ranges are
 * also supported). Also, this supports escape character ('\') to use special
 * characters as normal character.
 *
 * Note: if @pat syntax is broken, this always returns false.
 */
bool strglobmatch(const char *str, const char *pat)
{
 return __match_glob(str, pat, false, false);
}

bool strglobmatch_nocase(const char *str, const char *pat)
{
 return __match_glob(str, pat, false, true);
}

/**
 * strlazymatch - matching pattern strings lazily with glob pattern
 * @str: the target string to match
 * @pat: the pattern string to match
 *
 * This is similar to strglobmatch, except this ignores spaces in
 * the target string.
 */
bool strlazymatch(const char *str, const char *pat)
{
 return __match_glob(str, pat, true, false);
}

/**
 * strtailcmp - Compare the tail of two strings
 * @s1: 1st string to be compared
 * @s2: 2nd string to be compared
 *
 * Return 0 if whole of either string is same as another's tail part.
 */
int strtailcmp(const char *s1, const char *s2)
{
 int i1 = strlen(s1);
 int i2 = strlen(s2);
 while (--i1 >= 0 && --i2 >= 0) {
  if (s1[i1] != s2[i2])
   return s1[i1] - s2[i2];
 }
 return 0;
}

char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints)
{
 /*
  * FIXME: replace this with an expression using log10() when we
  * find a suitable implementation, maybe the one in the dvb drivers...
  *
  * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators
 */
 size_t size = nints * 28 + 1; /* \0 */
 size_t i, printed = 0;
 char *expr = malloc(size);

 if (expr) {
  const char *or_and = "||", *eq_neq = "==";
  char *e = expr;

  if (!in) {
   or_and = "&&";
   eq_neq = "!=";
  }

  for (i = 0; i < nints; ++i) {
   if (printed == size)
    goto out_err_overflow;

   if (i > 0)
    printed += scnprintf(e + printed, size - printed, " %s ", or_and);
   printed += scnprintf(e + printed, size - printed,
          "%s %s %d", var, eq_neq, ints[i]);
  }
 }

 return expr;

out_err_overflow:
 free(expr);
 return NULL;
}

/* Like strpbrk(), but not break if it is right after a backslash (escaped) */
char *strpbrk_esc(char *str, const char *stopset)
{
 char *ptr;

 do {
  ptr = strpbrk(str, stopset);
  if (!ptr) {
   /* stopset not in str. */
   break;
  }
  if (ptr == str) {
   /* stopset character is first in str. */
   break;
  }
  if (ptr == str + 1 && str[0] != '\\') {
   /* stopset chacter is second and wasn't preceded by a '\'. */
   break;
  }
  str = ptr + 1;
 } while (ptr[-1] == '\\' && ptr[-2] != '\\');

 return ptr;
}

/* Like strpbrk_esc(), but not break if it is quoted with single/double quotes */
char *strpbrk_esq(char *str, const char *stopset)
{
 char *_stopset = NULL;
 char *ptr;
 const char *squote = "'";
 const char *dquote = "\"";

 if (asprintf(&_stopset, "%s%c%c", stopset, *squote, *dquote) < 0)
  return NULL;

 do {
  ptr = strpbrk_esc(str, _stopset);
  if (!ptr)
   break;
  if (*ptr == *squote)
   ptr = strpbrk_esc(ptr + 1, squote);
  else if (*ptr == *dquote)
   ptr = strpbrk_esc(ptr + 1, dquote);
  else
   break;
  str = ptr + 1;
 } while (ptr);

 free(_stopset);
 return ptr;
}

/* Like strdup, but do not copy a single backslash */
char *strdup_esc(const char *str)
{
 char *s, *d, *p, *ret = strdup(str);

 if (!ret)
  return NULL;

 d = strchr(ret, '\\');
 if (!d)
  return ret;

 s = d + 1;
 do {
  if (*s == '\0') {
   *d = '\0';
   break;
  }
  p = strchr(s + 1, '\\');
  if (p) {
   memmove(d, s, p - s);
   d += p - s;
   s = p + 1;
  } else
   memmove(d, s, strlen(s) + 1);
 } while (p);

 return ret;
}

/* Remove backslash right before quote and return next quote address. */
static char *remove_consumed_esc(char *str, int len, int quote)
{
 char *ptr = str, *end = str + len;

 while (*ptr != quote && ptr < end) {
  if (*ptr == '\\' && *(ptr + 1) == quote) {
   memmove(ptr, ptr + 1, end - (ptr + 1));
   /* now *ptr is `quote`. */
   end--;
  }
  ptr++;
 }

 return *ptr == quote ? ptr : NULL;
}

/*
 * Like strdup_esc, but keep quoted string as it is (and single backslash
 * before quote is removed). If there is no closed quote, return NULL.
 */
char *strdup_esq(const char *str)
{
 char *d, *ret;

 /* If there is no quote, return normal strdup_esc() */
 d = strpbrk_esc((char *)str, "\"'");
 if (!d)
  return strdup_esc(str);

 ret = strdup(str);
 if (!ret)
  return NULL;

 d = ret;
 do {
  d = strpbrk(d, "\\\"\'");
  if (!d)
   break;

  if (*d == '"' || *d == '\'') {
   /* This is non-escaped quote */
   int quote = *d;
   int len = strlen(d + 1) + 1;

   /*
    * Remove the start quote and remove consumed escape (backslash
    * before quote) and remove the end quote. If there is no end
    * quote, it is the input error.
 */
   memmove(d, d + 1, len);
   d = remove_consumed_esc(d, len, quote);
   if (!d)
    goto error;
   memmove(d, d + 1, strlen(d + 1) + 1);
  }
  if (*d == '\\') {
   memmove(d, d + 1, strlen(d + 1) + 1);
   if (*d == '\\') {
    /* double backslash -- keep the second one. */
    d++;
   }
  }
 } while (*d != '\0');

 return ret;

error:
 free(ret);
 return NULL;
}

unsigned int hex(char c)
{
 if (c >= '0' && c <= '9')
  return c - '0';
 if (c >= 'a' && c <= 'f')
  return c - 'a' + 10;
 return c - 'A' + 10;
}

/*
 * Replace all occurrences of character 'needle' in string 'haystack' with
 * string 'replace'
 *
 * The new string could be longer so a new string is returned which must be
 * freed.
 */
char *strreplace_chars(char needle, const char *haystack, const char *replace)
{
 int replace_len = strlen(replace);
 char *new_s, *to;
 const char *loc = strchr(haystack, needle);
 const char *from = haystack;
 int num = 0;

 /* Count occurrences */
 while (loc) {
  loc = strchr(loc + 1, needle);
  num++;
 }

 /* Allocate enough space for replacements and reset first location */
 new_s = malloc(strlen(haystack) + (num * (replace_len - 1) + 1));
 if (!new_s)
  return NULL;
 loc = strchr(haystack, needle);
 to = new_s;

 while (loc) {
  /* Copy original string up to found char and update positions */
  memcpy(to, from, 1 + loc - from);
  to += loc - from;
  from = loc + 1;

  /* Copy replacement string and update positions */
  memcpy(to, replace, replace_len);
  to += replace_len;

  /* needle next occurrence or end of string */
  loc = strchr(from, needle);
 }

 /* Copy any remaining chars + null */
 strcpy(to, from);

 return new_s;
}