bb8ad9eaca
This adds a new flavour of strextend(), called strextend_with_separator(), which takes an optional separator string. If specified, the separator is inserted between each appended string, as well as before the first one, but only if the original string was non-empty. This new call is particularly useful when appending new options to mount option strings and suchlike, which need to be comma-separated, and initially start out from an empty string.
927 lines
21 KiB
C
927 lines
21 KiB
C
/* SPDX-License-Identifier: LGPL-2.1+ */
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <errno.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "alloc-util.h"
|
|
#include "gunicode.h"
|
|
#include "macro.h"
|
|
#include "string-util.h"
|
|
#include "utf8.h"
|
|
#include "util.h"
|
|
|
|
int strcmp_ptr(const char *a, const char *b) {
|
|
|
|
/* Like strcmp(), but tries to make sense of NULL pointers */
|
|
if (a && b)
|
|
return strcmp(a, b);
|
|
|
|
if (!a && b)
|
|
return -1;
|
|
|
|
if (a && !b)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
char* endswith(const char *s, const char *postfix) {
|
|
size_t sl, pl;
|
|
|
|
assert(s);
|
|
assert(postfix);
|
|
|
|
sl = strlen(s);
|
|
pl = strlen(postfix);
|
|
|
|
if (pl == 0)
|
|
return (char*) s + sl;
|
|
|
|
if (sl < pl)
|
|
return NULL;
|
|
|
|
if (memcmp(s + sl - pl, postfix, pl) != 0)
|
|
return NULL;
|
|
|
|
return (char*) s + sl - pl;
|
|
}
|
|
|
|
char* endswith_no_case(const char *s, const char *postfix) {
|
|
size_t sl, pl;
|
|
|
|
assert(s);
|
|
assert(postfix);
|
|
|
|
sl = strlen(s);
|
|
pl = strlen(postfix);
|
|
|
|
if (pl == 0)
|
|
return (char*) s + sl;
|
|
|
|
if (sl < pl)
|
|
return NULL;
|
|
|
|
if (strcasecmp(s + sl - pl, postfix) != 0)
|
|
return NULL;
|
|
|
|
return (char*) s + sl - pl;
|
|
}
|
|
|
|
char* first_word(const char *s, const char *word) {
|
|
size_t sl, wl;
|
|
const char *p;
|
|
|
|
assert(s);
|
|
assert(word);
|
|
|
|
/* Checks if the string starts with the specified word, either
|
|
* followed by NUL or by whitespace. Returns a pointer to the
|
|
* NUL or the first character after the whitespace. */
|
|
|
|
sl = strlen(s);
|
|
wl = strlen(word);
|
|
|
|
if (sl < wl)
|
|
return NULL;
|
|
|
|
if (wl == 0)
|
|
return (char*) s;
|
|
|
|
if (memcmp(s, word, wl) != 0)
|
|
return NULL;
|
|
|
|
p = s + wl;
|
|
if (*p == 0)
|
|
return (char*) p;
|
|
|
|
if (!strchr(WHITESPACE, *p))
|
|
return NULL;
|
|
|
|
p += strspn(p, WHITESPACE);
|
|
return (char*) p;
|
|
}
|
|
|
|
static size_t strcspn_escaped(const char *s, const char *reject) {
|
|
bool escaped = false;
|
|
int n;
|
|
|
|
for (n=0; s[n]; n++) {
|
|
if (escaped)
|
|
escaped = false;
|
|
else if (s[n] == '\\')
|
|
escaped = true;
|
|
else if (strchr(reject, s[n]))
|
|
break;
|
|
}
|
|
|
|
/* if s ends in \, return index of previous char */
|
|
return n - escaped;
|
|
}
|
|
|
|
/* Split a string into words. */
|
|
const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
|
|
const char *current;
|
|
|
|
current = *state;
|
|
|
|
if (!*current) {
|
|
assert(**state == '\0');
|
|
return NULL;
|
|
}
|
|
|
|
current += strspn(current, separator);
|
|
if (!*current) {
|
|
*state = current;
|
|
return NULL;
|
|
}
|
|
|
|
if (quoted && strchr("\'\"", *current)) {
|
|
char quotechars[2] = {*current, '\0'};
|
|
|
|
*l = strcspn_escaped(current + 1, quotechars);
|
|
if (current[*l + 1] == '\0' || current[*l + 1] != quotechars[0] ||
|
|
(current[*l + 2] && !strchr(separator, current[*l + 2]))) {
|
|
/* right quote missing or garbage at the end */
|
|
*state = current;
|
|
return NULL;
|
|
}
|
|
*state = current++ + *l + 2;
|
|
} else if (quoted) {
|
|
*l = strcspn_escaped(current, separator);
|
|
if (current[*l] && !strchr(separator, current[*l])) {
|
|
/* unfinished escape */
|
|
*state = current;
|
|
return NULL;
|
|
}
|
|
*state = current + *l;
|
|
} else {
|
|
*l = strcspn(current, separator);
|
|
*state = current + *l;
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
char *strnappend(const char *s, const char *suffix, size_t b) {
|
|
size_t a;
|
|
char *r;
|
|
|
|
if (!s && !suffix)
|
|
return strdup("");
|
|
|
|
if (!s)
|
|
return strndup(suffix, b);
|
|
|
|
if (!suffix)
|
|
return strdup(s);
|
|
|
|
assert(s);
|
|
assert(suffix);
|
|
|
|
a = strlen(s);
|
|
if (b > ((size_t) -1) - a)
|
|
return NULL;
|
|
|
|
r = new(char, a+b+1);
|
|
if (!r)
|
|
return NULL;
|
|
|
|
memcpy(r, s, a);
|
|
memcpy(r+a, suffix, b);
|
|
r[a+b] = 0;
|
|
|
|
return r;
|
|
}
|
|
|
|
char *strappend(const char *s, const char *suffix) {
|
|
return strnappend(s, suffix, strlen_ptr(suffix));
|
|
}
|
|
|
|
char *strjoin_real(const char *x, ...) {
|
|
va_list ap;
|
|
size_t l;
|
|
char *r, *p;
|
|
|
|
va_start(ap, x);
|
|
|
|
if (x) {
|
|
l = strlen(x);
|
|
|
|
for (;;) {
|
|
const char *t;
|
|
size_t n;
|
|
|
|
t = va_arg(ap, const char *);
|
|
if (!t)
|
|
break;
|
|
|
|
n = strlen(t);
|
|
if (n > ((size_t) -1) - l) {
|
|
va_end(ap);
|
|
return NULL;
|
|
}
|
|
|
|
l += n;
|
|
}
|
|
} else
|
|
l = 0;
|
|
|
|
va_end(ap);
|
|
|
|
r = new(char, l+1);
|
|
if (!r)
|
|
return NULL;
|
|
|
|
if (x) {
|
|
p = stpcpy(r, x);
|
|
|
|
va_start(ap, x);
|
|
|
|
for (;;) {
|
|
const char *t;
|
|
|
|
t = va_arg(ap, const char *);
|
|
if (!t)
|
|
break;
|
|
|
|
p = stpcpy(p, t);
|
|
}
|
|
|
|
va_end(ap);
|
|
} else
|
|
r[0] = 0;
|
|
|
|
return r;
|
|
}
|
|
|
|
char *strstrip(char *s) {
|
|
char *e;
|
|
|
|
if (!s)
|
|
return NULL;
|
|
|
|
/* Drops trailing whitespace. Modifies the string in
|
|
* place. Returns pointer to first non-space character */
|
|
|
|
s += strspn(s, WHITESPACE);
|
|
|
|
for (e = strchr(s, 0); e > s; e --)
|
|
if (!strchr(WHITESPACE, e[-1]))
|
|
break;
|
|
|
|
*e = 0;
|
|
|
|
return s;
|
|
}
|
|
|
|
char *delete_chars(char *s, const char *bad) {
|
|
char *f, *t;
|
|
|
|
/* Drops all specified bad characters, regardless where in the string */
|
|
|
|
if (!s)
|
|
return NULL;
|
|
|
|
if (!bad)
|
|
bad = WHITESPACE;
|
|
|
|
for (f = s, t = s; *f; f++) {
|
|
if (strchr(bad, *f))
|
|
continue;
|
|
|
|
*(t++) = *f;
|
|
}
|
|
|
|
*t = 0;
|
|
|
|
return s;
|
|
}
|
|
|
|
char *delete_trailing_chars(char *s, const char *bad) {
|
|
char *p, *c = s;
|
|
|
|
/* Drops all specified bad characters, at the end of the string */
|
|
|
|
if (!s)
|
|
return NULL;
|
|
|
|
if (!bad)
|
|
bad = WHITESPACE;
|
|
|
|
for (p = s; *p; p++)
|
|
if (!strchr(bad, *p))
|
|
c = p + 1;
|
|
|
|
*c = 0;
|
|
|
|
return s;
|
|
}
|
|
|
|
char *truncate_nl(char *s) {
|
|
assert(s);
|
|
|
|
s[strcspn(s, NEWLINE)] = 0;
|
|
return s;
|
|
}
|
|
|
|
char ascii_tolower(char x) {
|
|
|
|
if (x >= 'A' && x <= 'Z')
|
|
return x - 'A' + 'a';
|
|
|
|
return x;
|
|
}
|
|
|
|
char ascii_toupper(char x) {
|
|
|
|
if (x >= 'a' && x <= 'z')
|
|
return x - 'a' + 'A';
|
|
|
|
return x;
|
|
}
|
|
|
|
char *ascii_strlower(char *t) {
|
|
char *p;
|
|
|
|
assert(t);
|
|
|
|
for (p = t; *p; p++)
|
|
*p = ascii_tolower(*p);
|
|
|
|
return t;
|
|
}
|
|
|
|
char *ascii_strupper(char *t) {
|
|
char *p;
|
|
|
|
assert(t);
|
|
|
|
for (p = t; *p; p++)
|
|
*p = ascii_toupper(*p);
|
|
|
|
return t;
|
|
}
|
|
|
|
char *ascii_strlower_n(char *t, size_t n) {
|
|
size_t i;
|
|
|
|
if (n <= 0)
|
|
return t;
|
|
|
|
for (i = 0; i < n; i++)
|
|
t[i] = ascii_tolower(t[i]);
|
|
|
|
return t;
|
|
}
|
|
|
|
int ascii_strcasecmp_n(const char *a, const char *b, size_t n) {
|
|
|
|
for (; n > 0; a++, b++, n--) {
|
|
int x, y;
|
|
|
|
x = (int) (uint8_t) ascii_tolower(*a);
|
|
y = (int) (uint8_t) ascii_tolower(*b);
|
|
|
|
if (x != y)
|
|
return x - y;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ascii_strcasecmp_nn(const char *a, size_t n, const char *b, size_t m) {
|
|
int r;
|
|
|
|
r = ascii_strcasecmp_n(a, b, MIN(n, m));
|
|
if (r != 0)
|
|
return r;
|
|
|
|
if (n < m)
|
|
return -1;
|
|
else if (n > m)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
bool chars_intersect(const char *a, const char *b) {
|
|
const char *p;
|
|
|
|
/* Returns true if any of the chars in a are in b. */
|
|
for (p = a; *p; p++)
|
|
if (strchr(b, *p))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool string_has_cc(const char *p, const char *ok) {
|
|
const char *t;
|
|
|
|
assert(p);
|
|
|
|
/*
|
|
* Check if a string contains control characters. If 'ok' is
|
|
* non-NULL it may be a string containing additional CCs to be
|
|
* considered OK.
|
|
*/
|
|
|
|
for (t = p; *t; t++) {
|
|
if (ok && strchr(ok, *t))
|
|
continue;
|
|
|
|
if (*t > 0 && *t < ' ')
|
|
return true;
|
|
|
|
if (*t == 127)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
|
|
size_t x;
|
|
char *r;
|
|
|
|
assert(s);
|
|
assert(percent <= 100);
|
|
assert(new_length >= 3);
|
|
|
|
if (old_length <= 3 || old_length <= new_length)
|
|
return strndup(s, old_length);
|
|
|
|
r = new0(char, new_length+3);
|
|
if (!r)
|
|
return NULL;
|
|
|
|
x = (new_length * percent) / 100;
|
|
|
|
if (x > new_length - 3)
|
|
x = new_length - 3;
|
|
|
|
memcpy(r, s, x);
|
|
r[x] = 0xe2; /* tri-dot ellipsis: … */
|
|
r[x+1] = 0x80;
|
|
r[x+2] = 0xa6;
|
|
memcpy(r + x + 3,
|
|
s + old_length - (new_length - x - 1),
|
|
new_length - x - 1);
|
|
|
|
return r;
|
|
}
|
|
|
|
char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
|
|
size_t x;
|
|
char *e;
|
|
const char *i, *j;
|
|
unsigned k, len, len2;
|
|
int r;
|
|
|
|
assert(s);
|
|
assert(percent <= 100);
|
|
|
|
if (new_length == (size_t) -1)
|
|
return strndup(s, old_length);
|
|
|
|
assert(new_length >= 3);
|
|
|
|
/* if no multibyte characters use ascii_ellipsize_mem for speed */
|
|
if (ascii_is_valid(s))
|
|
return ascii_ellipsize_mem(s, old_length, new_length, percent);
|
|
|
|
if (old_length <= 3 || old_length <= new_length)
|
|
return strndup(s, old_length);
|
|
|
|
x = (new_length * percent) / 100;
|
|
|
|
if (x > new_length - 3)
|
|
x = new_length - 3;
|
|
|
|
k = 0;
|
|
for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
|
|
char32_t c;
|
|
|
|
r = utf8_encoded_to_unichar(i, &c);
|
|
if (r < 0)
|
|
return NULL;
|
|
k += unichar_iswide(c) ? 2 : 1;
|
|
}
|
|
|
|
if (k > x) /* last character was wide and went over quota */
|
|
x++;
|
|
|
|
for (j = s + old_length; k < new_length && j > i; ) {
|
|
char32_t c;
|
|
|
|
j = utf8_prev_char(j);
|
|
r = utf8_encoded_to_unichar(j, &c);
|
|
if (r < 0)
|
|
return NULL;
|
|
k += unichar_iswide(c) ? 2 : 1;
|
|
}
|
|
assert(i <= j);
|
|
|
|
/* we don't actually need to ellipsize */
|
|
if (i == j)
|
|
return memdup(s, old_length + 1);
|
|
|
|
/* make space for ellipsis */
|
|
j = utf8_next_char(j);
|
|
|
|
len = i - s;
|
|
len2 = s + old_length - j;
|
|
e = new(char, len + 3 + len2 + 1);
|
|
if (!e)
|
|
return NULL;
|
|
|
|
/*
|
|
printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
|
|
old_length, new_length, x, len, len2, k);
|
|
*/
|
|
|
|
memcpy(e, s, len);
|
|
e[len] = 0xe2; /* tri-dot ellipsis: … */
|
|
e[len + 1] = 0x80;
|
|
e[len + 2] = 0xa6;
|
|
|
|
memcpy(e + len + 3, j, len2 + 1);
|
|
|
|
return e;
|
|
}
|
|
|
|
char *ellipsize(const char *s, size_t length, unsigned percent) {
|
|
|
|
if (length == (size_t) -1)
|
|
return strdup(s);
|
|
|
|
return ellipsize_mem(s, strlen(s), length, percent);
|
|
}
|
|
|
|
bool nulstr_contains(const char *nulstr, const char *needle) {
|
|
const char *i;
|
|
|
|
if (!nulstr)
|
|
return false;
|
|
|
|
NULSTR_FOREACH(i, nulstr)
|
|
if (streq(i, needle))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
char* strshorten(char *s, size_t l) {
|
|
assert(s);
|
|
|
|
if (strnlen(s, l+1) > l)
|
|
s[l] = 0;
|
|
|
|
return s;
|
|
}
|
|
|
|
char *strreplace(const char *text, const char *old_string, const char *new_string) {
|
|
size_t l, old_len, new_len, allocated = 0;
|
|
char *t, *ret = NULL;
|
|
const char *f;
|
|
|
|
assert(old_string);
|
|
assert(new_string);
|
|
|
|
if (!text)
|
|
return NULL;
|
|
|
|
old_len = strlen(old_string);
|
|
new_len = strlen(new_string);
|
|
|
|
l = strlen(text);
|
|
if (!GREEDY_REALLOC(ret, allocated, l+1))
|
|
return NULL;
|
|
|
|
f = text;
|
|
t = ret;
|
|
while (*f) {
|
|
size_t d, nl;
|
|
|
|
if (!startswith(f, old_string)) {
|
|
*(t++) = *(f++);
|
|
continue;
|
|
}
|
|
|
|
d = t - ret;
|
|
nl = l - old_len + new_len;
|
|
|
|
if (!GREEDY_REALLOC(ret, allocated, nl + 1))
|
|
return mfree(ret);
|
|
|
|
l = nl;
|
|
t = ret + d;
|
|
|
|
t = stpcpy(t, new_string);
|
|
f += old_len;
|
|
}
|
|
|
|
*t = 0;
|
|
return ret;
|
|
}
|
|
|
|
char *strip_tab_ansi(char **ibuf, size_t *_isz) {
|
|
const char *i, *begin = NULL;
|
|
enum {
|
|
STATE_OTHER,
|
|
STATE_ESCAPE,
|
|
STATE_BRACKET
|
|
} state = STATE_OTHER;
|
|
char *obuf = NULL;
|
|
size_t osz = 0, isz;
|
|
FILE *f;
|
|
|
|
assert(ibuf);
|
|
assert(*ibuf);
|
|
|
|
/* Strips ANSI color and replaces TABs by 8 spaces */
|
|
|
|
isz = _isz ? *_isz : strlen(*ibuf);
|
|
|
|
f = open_memstream(&obuf, &osz);
|
|
if (!f)
|
|
return NULL;
|
|
|
|
/* Note we use the _unlocked() stdio variants on f for performance
|
|
* reasons. It's safe to do so since we created f here and it
|
|
* doesn't leave our scope.
|
|
*/
|
|
|
|
for (i = *ibuf; i < *ibuf + isz + 1; i++) {
|
|
|
|
switch (state) {
|
|
|
|
case STATE_OTHER:
|
|
if (i >= *ibuf + isz) /* EOT */
|
|
break;
|
|
else if (*i == '\x1B')
|
|
state = STATE_ESCAPE;
|
|
else if (*i == '\t')
|
|
fputs_unlocked(" ", f);
|
|
else
|
|
fputc_unlocked(*i, f);
|
|
break;
|
|
|
|
case STATE_ESCAPE:
|
|
if (i >= *ibuf + isz) { /* EOT */
|
|
fputc_unlocked('\x1B', f);
|
|
break;
|
|
} else if (*i == '[') {
|
|
state = STATE_BRACKET;
|
|
begin = i + 1;
|
|
} else {
|
|
fputc_unlocked('\x1B', f);
|
|
fputc_unlocked(*i, f);
|
|
state = STATE_OTHER;
|
|
}
|
|
|
|
break;
|
|
|
|
case STATE_BRACKET:
|
|
|
|
if (i >= *ibuf + isz || /* EOT */
|
|
(!(*i >= '0' && *i <= '9') && !IN_SET(*i, ';', 'm'))) {
|
|
fputc_unlocked('\x1B', f);
|
|
fputc_unlocked('[', f);
|
|
state = STATE_OTHER;
|
|
i = begin-1;
|
|
} else if (*i == 'm')
|
|
state = STATE_OTHER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ferror(f)) {
|
|
fclose(f);
|
|
return mfree(obuf);
|
|
}
|
|
|
|
fclose(f);
|
|
|
|
free(*ibuf);
|
|
*ibuf = obuf;
|
|
|
|
if (_isz)
|
|
*_isz = osz;
|
|
|
|
return obuf;
|
|
}
|
|
|
|
char *strextend_with_separator(char **x, const char *separator, ...) {
|
|
bool need_separator;
|
|
size_t f, l, l_separator;
|
|
char *r, *p;
|
|
va_list ap;
|
|
|
|
assert(x);
|
|
|
|
l = f = strlen_ptr(*x);
|
|
|
|
need_separator = !isempty(*x);
|
|
l_separator = strlen_ptr(separator);
|
|
|
|
va_start(ap, separator);
|
|
for (;;) {
|
|
const char *t;
|
|
size_t n;
|
|
|
|
t = va_arg(ap, const char *);
|
|
if (!t)
|
|
break;
|
|
|
|
n = strlen(t);
|
|
|
|
if (need_separator)
|
|
n += l_separator;
|
|
|
|
if (n > ((size_t) -1) - l) {
|
|
va_end(ap);
|
|
return NULL;
|
|
}
|
|
|
|
l += n;
|
|
need_separator = true;
|
|
}
|
|
va_end(ap);
|
|
|
|
need_separator = !isempty(*x);
|
|
|
|
r = realloc(*x, l+1);
|
|
if (!r)
|
|
return NULL;
|
|
|
|
p = r + f;
|
|
|
|
va_start(ap, separator);
|
|
for (;;) {
|
|
const char *t;
|
|
|
|
t = va_arg(ap, const char *);
|
|
if (!t)
|
|
break;
|
|
|
|
if (need_separator && separator)
|
|
p = stpcpy(p, separator);
|
|
|
|
p = stpcpy(p, t);
|
|
|
|
need_separator = true;
|
|
}
|
|
va_end(ap);
|
|
|
|
assert(p == r + l);
|
|
|
|
*p = 0;
|
|
*x = r;
|
|
|
|
return r + l;
|
|
}
|
|
|
|
char *strrep(const char *s, unsigned n) {
|
|
size_t l;
|
|
char *r, *p;
|
|
unsigned i;
|
|
|
|
assert(s);
|
|
|
|
l = strlen(s);
|
|
p = r = malloc(l * n + 1);
|
|
if (!r)
|
|
return NULL;
|
|
|
|
for (i = 0; i < n; i++)
|
|
p = stpcpy(p, s);
|
|
|
|
*p = 0;
|
|
return r;
|
|
}
|
|
|
|
int split_pair(const char *s, const char *sep, char **l, char **r) {
|
|
char *x, *a, *b;
|
|
|
|
assert(s);
|
|
assert(sep);
|
|
assert(l);
|
|
assert(r);
|
|
|
|
if (isempty(sep))
|
|
return -EINVAL;
|
|
|
|
x = strstr(s, sep);
|
|
if (!x)
|
|
return -EINVAL;
|
|
|
|
a = strndup(s, x - s);
|
|
if (!a)
|
|
return -ENOMEM;
|
|
|
|
b = strdup(x + strlen(sep));
|
|
if (!b) {
|
|
free(a);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
*l = a;
|
|
*r = b;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int free_and_strdup(char **p, const char *s) {
|
|
char *t;
|
|
|
|
assert(p);
|
|
|
|
/* Replaces a string pointer with an strdup()ed new string,
|
|
* possibly freeing the old one. */
|
|
|
|
if (streq_ptr(*p, s))
|
|
return 0;
|
|
|
|
if (s) {
|
|
t = strdup(s);
|
|
if (!t)
|
|
return -ENOMEM;
|
|
} else
|
|
t = NULL;
|
|
|
|
free(*p);
|
|
*p = t;
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if !HAVE_EXPLICIT_BZERO
|
|
/*
|
|
* Pointer to memset is volatile so that compiler must de-reference
|
|
* the pointer and can't assume that it points to any function in
|
|
* particular (such as memset, which it then might further "optimize")
|
|
* This approach is inspired by openssl's crypto/mem_clr.c.
|
|
*/
|
|
typedef void *(*memset_t)(void *,int,size_t);
|
|
|
|
static volatile memset_t memset_func = memset;
|
|
|
|
void explicit_bzero(void *p, size_t l) {
|
|
memset_func(p, '\0', l);
|
|
}
|
|
#endif
|
|
|
|
char* string_erase(char *x) {
|
|
if (!x)
|
|
return NULL;
|
|
|
|
/* A delicious drop of snake-oil! To be called on memory where
|
|
* we stored passphrases or so, after we used them. */
|
|
explicit_bzero(x, strlen(x));
|
|
return x;
|
|
}
|
|
|
|
char *string_free_erase(char *s) {
|
|
return mfree(string_erase(s));
|
|
}
|
|
|
|
bool string_is_safe(const char *p) {
|
|
const char *t;
|
|
|
|
if (!p)
|
|
return false;
|
|
|
|
for (t = p; *t; t++) {
|
|
if (*t > 0 && *t < ' ') /* no control characters */
|
|
return false;
|
|
|
|
if (strchr(QUOTES "\\\x7f", *t))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|