/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ /*** 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 . ***/ #include #include #include #include #include #include #include "alloc-util.h" #include "escape.h" #include "extract-word.h" #include "string-util.h" #include "strv.h" #include "util.h" char *strv_find(char **l, const char *name) { char **i; assert(name); STRV_FOREACH(i, l) if (streq(*i, name)) return *i; return NULL; } char *strv_find_prefix(char **l, const char *name) { char **i; assert(name); STRV_FOREACH(i, l) if (startswith(*i, name)) return *i; return NULL; } char *strv_find_startswith(char **l, const char *name) { char **i, *e; assert(name); /* Like strv_find_prefix, but actually returns only the * suffix, not the whole item */ STRV_FOREACH(i, l) { e = startswith(*i, name); if (e) return e; } return NULL; } void strv_clear(char **l) { char **k; if (!l) return; for (k = l; *k; k++) free(*k); *l = NULL; } char **strv_free(char **l) { strv_clear(l); free(l); return NULL; } char **strv_free_erase(char **l) { char **i; STRV_FOREACH(i, l) string_erase(*i); return strv_free(l); } char **strv_copy(char * const *l) { char **r, **k; k = r = new(char*, strv_length(l) + 1); if (!r) return NULL; if (l) for (; *l; k++, l++) { *k = strdup(*l); if (!*k) { strv_free(r); return NULL; } } *k = NULL; return r; } unsigned strv_length(char * const *l) { unsigned n = 0; if (!l) return 0; for (; *l; l++) n++; return n; } char **strv_new_ap(const char *x, va_list ap) { const char *s; char **a; unsigned n = 0, i = 0; va_list aq; /* As a special trick we ignore all listed strings that equal * (const char*) -1. This is supposed to be used with the * STRV_IFNOTNULL() macro to include possibly NULL strings in * the string list. */ if (x) { n = x == (const char*) -1 ? 0 : 1; va_copy(aq, ap); while ((s = va_arg(aq, const char*))) { if (s == (const char*) -1) continue; n++; } va_end(aq); } a = new(char*, n+1); if (!a) return NULL; if (x) { if (x != (const char*) -1) { a[i] = strdup(x); if (!a[i]) goto fail; i++; } while ((s = va_arg(ap, const char*))) { if (s == (const char*) -1) continue; a[i] = strdup(s); if (!a[i]) goto fail; i++; } } a[i] = NULL; return a; fail: strv_free(a); return NULL; } char **strv_new(const char *x, ...) { char **r; va_list ap; va_start(ap, x); r = strv_new_ap(x, ap); va_end(ap); return r; } int strv_extend_strv(char ***a, char **b, bool filter_duplicates) { char **s, **t; size_t p, q, i = 0, j; assert(a); if (strv_isempty(b)) return 0; p = strv_length(*a); q = strv_length(b); t = realloc(*a, sizeof(char*) * (p + q + 1)); if (!t) return -ENOMEM; t[p] = NULL; *a = t; STRV_FOREACH(s, b) { if (filter_duplicates && strv_contains(t, *s)) continue; t[p+i] = strdup(*s); if (!t[p+i]) goto rollback; i++; t[p+i] = NULL; } assert(i <= q); return (int) i; rollback: for (j = 0; j < i; j++) free(t[p + j]); t[p] = NULL; return -ENOMEM; } int strv_extend_strv_concat(char ***a, char **b, const char *suffix) { int r; char **s; STRV_FOREACH(s, b) { char *v; v = strappend(*s, suffix); if (!v) return -ENOMEM; r = strv_push(a, v); if (r < 0) { free(v); return r; } } return 0; } char **strv_split(const char *s, const char *separator) { const char *word, *state; size_t l; unsigned n, i; char **r; assert(s); n = 0; FOREACH_WORD_SEPARATOR(word, l, s, separator, state) n++; r = new(char*, n+1); if (!r) return NULL; i = 0; FOREACH_WORD_SEPARATOR(word, l, s, separator, state) { r[i] = strndup(word, l); if (!r[i]) { strv_free(r); return NULL; } i++; } r[i] = NULL; return r; } char **strv_split_newlines(const char *s) { char **l; unsigned n; assert(s); /* Special version of strv_split() that splits on newlines and * suppresses an empty string at the end */ l = strv_split(s, NEWLINE); if (!l) return NULL; n = strv_length(l); if (n <= 0) return l; if (isempty(l[n - 1])) l[n - 1] = mfree(l[n - 1]); return l; } int strv_split_extract(char ***t, const char *s, const char *separators, ExtractFlags flags) { _cleanup_strv_free_ char **l = NULL; size_t n = 0, allocated = 0; int r; assert(t); assert(s); for (;;) { _cleanup_free_ char *word = NULL; r = extract_first_word(&s, &word, separators, flags); if (r < 0) return r; if (r == 0) break; if (!GREEDY_REALLOC(l, allocated, n + 2)) return -ENOMEM; l[n++] = word; word = NULL; l[n] = NULL; } if (!l) { l = new0(char*, 1); if (!l) return -ENOMEM; } *t = l; l = NULL; return (int) n; } char *strv_join(char **l, const char *separator) { char *r, *e; char **s; size_t n, k; if (!separator) separator = " "; k = strlen(separator); n = 0; STRV_FOREACH(s, l) { if (n != 0) n += k; n += strlen(*s); } r = new(char, n+1); if (!r) return NULL; e = r; STRV_FOREACH(s, l) { if (e != r) e = stpcpy(e, separator); e = stpcpy(e, *s); } *e = 0; return r; } char *strv_join_quoted(char **l) { char *buf = NULL; char **s; size_t allocated = 0, len = 0; STRV_FOREACH(s, l) { /* assuming here that escaped string cannot be more * than twice as long, and reserving space for the * separator and quotes. */ _cleanup_free_ char *esc = NULL; size_t needed; if (!GREEDY_REALLOC(buf, allocated, len + strlen(*s) * 2 + 3)) goto oom; esc = cescape(*s); if (!esc) goto oom; needed = snprintf(buf + len, allocated - len, "%s\"%s\"", len > 0 ? " " : "", esc); assert(needed < allocated - len); len += needed; } if (!buf) buf = malloc0(1); return buf; oom: free(buf); return NULL; } int strv_push(char ***l, char *value) { char **c; unsigned n, m; if (!value) return 0; n = strv_length(*l); /* Increase and check for overflow */ m = n + 2; if (m < n) return -ENOMEM; c = realloc_multiply(*l, sizeof(char*), m); if (!c) return -ENOMEM; c[n] = value; c[n+1] = NULL; *l = c; return 0; } int strv_push_pair(char ***l, char *a, char *b) { char **c; unsigned n, m; if (!a && !b) return 0; n = strv_length(*l); /* increase and check for overflow */ m = n + !!a + !!b + 1; if (m < n) return -ENOMEM; c = realloc_multiply(*l, sizeof(char*), m); if (!c) return -ENOMEM; if (a) c[n++] = a; if (b) c[n++] = b; c[n] = NULL; *l = c; return 0; } int strv_push_prepend(char ***l, char *value) { char **c; unsigned n, m, i; if (!value) return 0; n = strv_length(*l); /* increase and check for overflow */ m = n + 2; if (m < n) return -ENOMEM; c = new(char*, m); if (!c) return -ENOMEM; for (i = 0; i < n; i++) c[i+1] = (*l)[i]; c[0] = value; c[n+1] = NULL; free(*l); *l = c; return 0; } int strv_consume(char ***l, char *value) { int r; r = strv_push(l, value); if (r < 0) free(value); return r; } int strv_consume_pair(char ***l, char *a, char *b) { int r; r = strv_push_pair(l, a, b); if (r < 0) { free(a); free(b); } return r; } int strv_consume_prepend(char ***l, char *value) { int r; r = strv_push_prepend(l, value); if (r < 0) free(value); return r; } int strv_extend(char ***l, const char *value) { char *v; if (!value) return 0; v = strdup(value); if (!v) return -ENOMEM; return strv_consume(l, v); } char **strv_uniq(char **l) { char **i; /* Drops duplicate entries. The first identical string will be * kept, the others dropped */ STRV_FOREACH(i, l) strv_remove(i+1, *i); return l; } bool strv_is_uniq(char **l) { char **i; STRV_FOREACH(i, l) if (strv_find(i+1, *i)) return false; return true; } char **strv_remove(char **l, const char *s) { char **f, **t; if (!l) return NULL; assert(s); /* Drops every occurrence of s in the string list, edits * in-place. */ for (f = t = l; *f; f++) if (streq(*f, s)) free(*f); else *(t++) = *f; *t = NULL; return l; } char **strv_parse_nulstr(const char *s, size_t l) { const char *p; unsigned c = 0, i = 0; char **v; assert(s || l <= 0); if (l <= 0) return new0(char*, 1); for (p = s; p < s + l; p++) if (*p == 0) c++; if (s[l-1] != 0) c++; v = new0(char*, c+1); if (!v) return NULL; p = s; while (p < s + l) { const char *e; e = memchr(p, 0, s + l - p); v[i] = strndup(p, e ? e - p : s + l - p); if (!v[i]) { strv_free(v); return NULL; } i++; if (!e) break; p = e + 1; } assert(i == c); return v; } char **strv_split_nulstr(const char *s) { const char *i; char **r = NULL; NULSTR_FOREACH(i, s) if (strv_extend(&r, i) < 0) { strv_free(r); return NULL; } if (!r) return strv_new(NULL, NULL); return r; } int strv_make_nulstr(char **l, char **p, size_t *q) { size_t n_allocated = 0, n = 0; _cleanup_free_ char *m = NULL; char **i; assert(p); assert(q); STRV_FOREACH(i, l) { size_t z; z = strlen(*i); if (!GREEDY_REALLOC(m, n_allocated, n + z + 1)) return -ENOMEM; memcpy(m + n, *i, z + 1); n += z + 1; } if (!m) { m = new0(char, 1); if (!m) return -ENOMEM; n = 0; } *p = m; *q = n; m = NULL; return 0; } bool strv_overlap(char **a, char **b) { char **i; STRV_FOREACH(i, a) if (strv_contains(b, *i)) return true; return false; } static int str_compare(const void *_a, const void *_b) { const char **a = (const char**) _a, **b = (const char**) _b; return strcmp(*a, *b); } char **strv_sort(char **l) { if (strv_isempty(l)) return l; qsort(l, strv_length(l), sizeof(char*), str_compare); return l; } bool strv_equal(char **a, char **b) { if (strv_isempty(a)) return strv_isempty(b); if (strv_isempty(b)) return false; for ( ; *a || *b; ++a, ++b) if (!streq_ptr(*a, *b)) return false; return true; } void strv_print(char **l) { char **s; STRV_FOREACH(s, l) puts(*s); } int strv_extendf(char ***l, const char *format, ...) { va_list ap; char *x; int r; va_start(ap, format); r = vasprintf(&x, format, ap); va_end(ap); if (r < 0) return -ENOMEM; return strv_consume(l, x); } char **strv_reverse(char **l) { unsigned n, i; n = strv_length(l); if (n <= 1) return l; for (i = 0; i < n / 2; i++) { char *t; t = l[i]; l[i] = l[n-1-i]; l[n-1-i] = t; } return l; } char **strv_shell_escape(char **l, const char *bad) { char **s; /* Escapes every character in every string in l that is in bad, * edits in-place, does not roll-back on error. */ STRV_FOREACH(s, l) { char *v; v = shell_escape(*s, bad); if (!v) return NULL; free(*s); *s = v; } return l; } bool strv_fnmatch(char* const* patterns, const char *s, int flags) { char* const* p; STRV_FOREACH(p, patterns) if (fnmatch(*p, s, 0) == 0) return true; return false; } char ***strv_free_free(char ***l) { char ***i; if (!l) return NULL; for (i = l; *i; i++) strv_free(*i); free(l); return NULL; } char **strv_skip(char **l, size_t n) { while (n > 0) { if (strv_isempty(l)) return l; l++, n--; } return l; } int strv_extend_n(char ***l, const char *value, size_t n) { size_t i, j, k; char **nl; assert(l); if (!value) return 0; if (n == 0) return 0; /* Adds the value value n times to l */ k = strv_length(*l); nl = realloc(*l, sizeof(char*) * (k + n + 1)); if (!nl) return -ENOMEM; *l = nl; for (i = k; i < k + n; i++) { nl[i] = strdup(value); if (!nl[i]) goto rollback; } nl[i] = NULL; return 0; rollback: for (j = k; j < i; j++) free(nl[j]); nl[k] = NULL; return -ENOMEM; } int fputstrv(FILE *f, char **l, const char *separator, bool *space) { bool b = false; char **s; int r; /* Like fputs(), but for strv, and with a less stupid argument order */ if (!f) f = stdout; if (!separator) separator = " "; if (!space) space = &b; STRV_FOREACH(s, l) { if (*space) { r = fputs(separator, f); if (r < 0) return r; } r = fputs(*s, f); if (r < 0) return r; *space = true; } return 0; }