src/basic/strv.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <fnmatch.h>
   4 #include <stdio.h>
   5
   6 #include "alloc-util.h"
   7 #include "env-util.h"
   8 #include "escape.h"
   9 #include "extract-word.h"
  10 #include "fileio.h"
  11 #include "gunicode.h"
  12 #include "hashmap.h"
  13 #include "log.h"
  14 #include "memory-util.h"
  15 #include "sort-util.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18 #include "utf8.h"
  19
  20 char* strv_find(char * const *l, const char *name) {
  21         assert(name);
  22
  23         STRV_FOREACH(i, l)
  24                 if (streq(*i, name))
  25                         return *i;
  26
  27         return NULL;
  28 }
  29
  30 char* strv_find_case(char * const *l, const char *name) {
  31         assert(name);
  32
  33         STRV_FOREACH(i, l)
  34                 if (strcaseeq(*i, name))
  35                         return *i;
  36
  37         return NULL;
  38 }
  39
  40 char* strv_find_prefix(char * const *l, const char *name) {
  41         assert(name);
  42
  43         STRV_FOREACH(i, l)
  44                 if (startswith(*i, name))
  45                         return *i;
  46
  47         return NULL;
  48 }
  49
  50 char* strv_find_startswith(char * const *l, const char *name) {
  51         assert(name);
  52
  53         /* Like strv_find_prefix, but actually returns only the
  54          * suffix, not the whole item */
  55
  56         STRV_FOREACH(i, l) {
  57                 char *e;
  58
  59                 e = startswith(*i, name);
  60                 if (e)
  61                         return e;
  62         }
  63
  64         return NULL;
  65 }
  66
  67 static char* strv_find_closest_prefix(char * const *l, const char *name) {
  68         size_t best_distance = SIZE_MAX;
  69         char *best = NULL;
  70
  71         assert(name);
  72
  73         STRV_FOREACH(s, l) {
  74                 char *e = startswith(*s, name);
  75                 if (!e)
  76                         continue;
  77
  78                 size_t n = strlen(e);
  79                 if (n < best_distance) {
  80                         best_distance = n;
  81                         best = *s;
  82                 }
  83         }
  84
  85         return best;
  86 }
  87
  88 static char* strv_find_closest_by_levenshtein(char * const *l, const char *name) {
  89         ssize_t best_distance = SSIZE_MAX;
  90         char *best = NULL;
  91
  92         assert(name);
  93
  94         STRV_FOREACH(i, l) {
  95                 ssize_t distance;
  96
  97                 distance = strlevenshtein(*i, name);
  98                 if (distance < 0) {
  99                         log_debug_errno(distance, "Failed to determine Levenshtein distance between %s and %s: %m", *i, name);
 100                         return NULL;
 101                 }
 102
 103                 if (distance > 5) /* If the distance is just too far off, don't make a bad suggestion */
 104                         continue;
 105
 106                 if (distance < best_distance) {
 107                         best_distance = distance;
 108                         best = *i;
 109                 }
 110         }
 111
 112         return best;
 113 }
 114
 115 char* strv_find_closest(char * const *l, const char *name) {
 116         assert(name);
 117
 118         /* Be more helpful to the user, and give a hint what the user might have wanted to type. We search
 119          * with two mechanisms: a simple prefix match and – if that didn't yield results –, a Levenshtein
 120          * word distance based match. */
 121
 122         char *found = strv_find_closest_prefix(l, name);
 123         if (found)
 124                 return found;
 125
 126         return strv_find_closest_by_levenshtein(l, name);
 127 }
 128
 129 char* strv_find_first_field(char * const *needles, char * const *haystack) {
 130         STRV_FOREACH(k, needles) {
 131                 char *value = strv_env_pairs_get((char **)haystack, *k);
 132                 if (value)
 133                         return value;
 134         }
 135
 136         return NULL;
 137 }
 138
 139 char** strv_free(char **l) {
 140         STRV_FOREACH(k, l)
 141                 free(*k);
 142
 143         return mfree(l);
 144 }
 145
 146 char** strv_free_erase(char **l) {
 147         STRV_FOREACH(i, l)
 148                 erase_and_freep(i);
 149
 150         return mfree(l);
 151 }
 152
 153 void strv_free_many(char ***strvs, size_t n) {
 154         assert(strvs || n == 0);
 155
 156         FOREACH_ARRAY (i, strvs, n)
 157                 strv_free(*i);
 158
 159         free(strvs);
 160 }
 161
 162 char** strv_copy_n(char * const *l, size_t m) {
 163         _cleanup_strv_free_ char **result = NULL;
 164         char **k;
 165
 166         result = new(char*, MIN(strv_length(l), m) + 1);
 167         if (!result)
 168                 return NULL;
 169
 170         k = result;
 171         STRV_FOREACH(i, l) {
 172                 if (m == 0)
 173                         break;
 174
 175                 *k = strdup(*i);
 176                 if (!*k)
 177                         return NULL;
 178                 k++;
 179
 180                 if (m != SIZE_MAX)
 181                         m--;
 182         }
 183
 184         *k = NULL;
 185         return TAKE_PTR(result);
 186 }
 187
 188 int strv_copy_unless_empty(char * const *l, char ***ret) {
 189         assert(ret);
 190
 191         if (strv_isempty(l)) {
 192                 *ret = NULL;
 193                 return 0;
 194         }
 195
 196         char **copy = strv_copy(l);
 197         if (!copy)
 198                 return -ENOMEM;
 199
 200         *ret = TAKE_PTR(copy);
 201         return 1;
 202 }
 203
 204 size_t strv_length(char * const *l) {
 205         size_t n = 0;
 206
 207         STRV_FOREACH(i, l)
 208                 n++;
 209
 210         return n;
 211 }
 212
 213 char** strv_new_ap(const char *x, va_list ap) {
 214         _cleanup_strv_free_ char **a = NULL;
 215         size_t n = 0, i = 0;
 216         va_list aq;
 217
 218         /* As a special trick we ignore all listed strings that equal
 219          * STRV_IGNORE. This is supposed to be used with the
 220          * STRV_IFNOTNULL() macro to include possibly NULL strings in
 221          * the string list. */
 222
 223         va_copy(aq, ap);
 224         for (const char *s = x; s; s = va_arg(aq, const char*)) {
 225                 if (s == STRV_IGNORE)
 226                         continue;
 227
 228                 n++;
 229         }
 230         va_end(aq);
 231
 232         a = new(char*, n+1);
 233         if (!a)
 234                 return NULL;
 235
 236         for (const char *s = x; s; s = va_arg(ap, const char*)) {
 237                 if (s == STRV_IGNORE)
 238                         continue;
 239
 240                 a[i] = strdup(s);
 241                 if (!a[i])
 242                         return NULL;
 243
 244                 i++;
 245         }
 246
 247         a[i] = NULL;
 248
 249         return TAKE_PTR(a);
 250 }
 251
 252 char** strv_new_internal(const char *x, ...) {
 253         char **r;
 254         va_list ap;
 255
 256         va_start(ap, x);
 257         r = strv_new_ap(x, ap);
 258         va_end(ap);
 259
 260         return r;
 261 }
 262
 263 int strv_extend_strv(char ***a, char * const *b, bool filter_duplicates) {
 264         size_t p, q, i = 0;
 265
 266         assert(a);
 267
 268         q = strv_length(b);
 269         if (q == 0)
 270                 return 0;
 271
 272         p = strv_length(*a);
 273         if (p >= SIZE_MAX - q)
 274                 return -ENOMEM;
 275
 276         char **t = reallocarray(*a, GREEDY_ALLOC_ROUND_UP(p + q + 1), sizeof(char *));
 277         if (!t)
 278                 return -ENOMEM;
 279
 280         t[p] = NULL;
 281         *a = t;
 282
 283         STRV_FOREACH(s, b) {
 284                 if (filter_duplicates && strv_contains(t, *s))
 285                         continue;
 286
 287                 t[p+i] = strdup(*s);
 288                 if (!t[p+i])
 289                         goto rollback;
 290
 291                 i++;
 292                 t[p+i] = NULL;
 293         }
 294
 295         assert(i <= q);
 296
 297         return (int) i;
 298
 299 rollback:
 300         free_many_charp(t + p, i);
 301         t[p] = NULL;
 302         return -ENOMEM;
 303 }
 304
 305 int strv_extend_strv_consume(char ***a, char **b, bool filter_duplicates) {
 306         _cleanup_strv_free_ char **b_consume = b;
 307         size_t p, q, i;
 308
 309         assert(a);
 310
 311         q = strv_length(b);
 312         if (q == 0)
 313                 return 0;
 314
 315         p = strv_length(*a);
 316         if (p == 0) {
 317                 strv_free_and_replace(*a, b_consume);
 318
 319                 if (filter_duplicates)
 320                         strv_uniq(*a);
 321
 322                 return strv_length(*a);
 323         }
 324
 325         if (p >= SIZE_MAX - q)
 326                 return -ENOMEM;
 327
 328         char **t = reallocarray(*a, GREEDY_ALLOC_ROUND_UP(p + q + 1), sizeof(char *));
 329         if (!t)
 330                 return -ENOMEM;
 331
 332         t[p] = NULL;
 333         *a = t;
 334
 335         if (!filter_duplicates) {
 336                 *mempcpy_typesafe(t + p, b, q) = NULL;
 337                 i = q;
 338         } else {
 339                 i = 0;
 340
 341                 STRV_FOREACH(s, b) {
 342                         if (strv_contains(t, *s)) {
 343                                 free(*s);
 344                                 continue;
 345                         }
 346
 347                         t[p+i] = *s;
 348
 349                         i++;
 350                         t[p+i] = NULL;
 351                 }
 352         }
 353
 354         assert(i <= q);
 355
 356         b_consume = mfree(b_consume);
 357
 358         return (int) i;
 359 }
 360
 361 int strv_extend_strv_biconcat(char ***a, const char *prefix, const char* const *b, const char *suffix) {
 362         int r;
 363
 364         assert(a);
 365
 366         STRV_FOREACH(s, b) {
 367                 char *v;
 368
 369                 v = strjoin(strempty(prefix), *s, suffix);
 370                 if (!v)
 371                         return -ENOMEM;
 372
 373                 r = strv_consume(a, v);
 374                 if (r < 0)
 375                         return r;
 376         }
 377
 378         return 0;
 379 }
 380
 381 int strv_split_newlines_full(char ***ret, const char *s, ExtractFlags flags) {
 382         _cleanup_strv_free_ char **l = NULL;
 383         size_t n;
 384         int r;
 385
 386         assert(s);
 387
 388         /* Special version of strv_split_full() that splits on newlines and
 389          * suppresses an empty string at the end. */
 390
 391         r = strv_split_full(&l, s, NEWLINE, flags);
 392         if (r < 0)
 393                 return r;
 394
 395         n = strv_length(l);
 396         if (n > 0 && isempty(l[n - 1])) {
 397                 l[n - 1] = mfree(l[n - 1]);
 398                 n--;
 399         }
 400
 401         *ret = TAKE_PTR(l);
 402         return n;
 403 }
 404
 405 char** strv_split_newlines(const char *s) {
 406         char **ret;
 407
 408         if (strv_split_newlines_full(&ret, s, 0) < 0)
 409                 return NULL;
 410
 411         return ret;
 412 }
 413
 414 int strv_split_full(char ***t, const char *s, const char *separators, ExtractFlags flags) {
 415         _cleanup_strv_free_ char **l = NULL;
 416         size_t n = 0;
 417         int r;
 418
 419         assert(t);
 420         assert(s);
 421
 422         for (;;) {
 423                 _cleanup_free_ char *word = NULL;
 424
 425                 r = extract_first_word(&s, &word, separators, flags);
 426                 if (r < 0)
 427                         return r;
 428                 if (r == 0)
 429                         break;
 430
 431                 if (!GREEDY_REALLOC(l, n + 2))
 432                         return -ENOMEM;
 433
 434                 l[n++] = TAKE_PTR(word);
 435                 l[n] = NULL;
 436         }
 437
 438         if (!l) {
 439                 l = new0(char*, 1);
 440                 if (!l)
 441                         return -ENOMEM;
 442         }
 443
 444         *t = TAKE_PTR(l);
 445
 446         return (int) n;
 447 }
 448
 449 char** strv_split(const char *s, const char *separators) {
 450         char **ret;
 451
 452         if (strv_split_full(&ret, s, separators, EXTRACT_RETAIN_ESCAPE) < 0)
 453                 return NULL;
 454
 455         return ret;
 456 }
 457
 458 int strv_split_and_extend_full(char ***t, const char *s, const char *separators, bool filter_duplicates, ExtractFlags flags) {
 459         char **l;
 460         int r;
 461
 462         assert(t);
 463         assert(s);
 464
 465         r = strv_split_full(&l, s, separators, flags);
 466         if (r < 0)
 467                 return r;
 468
 469         r = strv_extend_strv_consume(t, l, filter_duplicates);
 470         if (r < 0)
 471                 return r;
 472
 473         return (int) strv_length(*t);
 474 }
 475
 476 int strv_split_and_extend(char ***t, const char *s, const char *separators, bool filter_duplicates) {
 477         return strv_split_and_extend_full(t, s, separators, filter_duplicates, 0);
 478 }
 479
 480 int strv_split_colon_pairs(char ***t, const char *s) {
 481         _cleanup_strv_free_ char **l = NULL;
 482         size_t n = 0;
 483         int r;
 484
 485         assert(t);
 486         assert(s);
 487
 488         for (;;) {
 489                 _cleanup_free_ char *first = NULL, *second = NULL, *tuple = NULL, *second_or_empty = NULL;
 490
 491                 r = extract_first_word(&s, &tuple, NULL, EXTRACT_UNQUOTE|EXTRACT_RETAIN_ESCAPE);
 492                 if (r < 0)
 493                         return r;
 494                 if (r == 0)
 495                         break;
 496
 497                 const char *p = tuple;
 498                 r = extract_many_words(&p, ":", EXTRACT_CUNESCAPE|EXTRACT_UNESCAPE_SEPARATORS,
 499                                        &first, &second);
 500                 if (r < 0)
 501                         return r;
 502                 if (r == 0)
 503                         continue;
 504                 /* Enforce that at most 2 colon-separated words are contained in each group */
 505                 if (!isempty(p))
 506                         return -EINVAL;
 507
 508                 second_or_empty = strdup(strempty(second));
 509                 if (!second_or_empty)
 510                         return -ENOMEM;
 511
 512                 if (!GREEDY_REALLOC(l, n + 3))
 513                         return -ENOMEM;
 514
 515                 l[n++] = TAKE_PTR(first);
 516                 l[n++] = TAKE_PTR(second_or_empty);
 517
 518                 l[n] = NULL;
 519         }
 520
 521         if (!l) {
 522                 l = new0(char*, 1);
 523                 if (!l)
 524                         return -ENOMEM;
 525         }
 526
 527         *t = TAKE_PTR(l);
 528
 529         return (int) n;
 530 }
 531
 532 char* strv_join_full(char * const *l, const char *separator, const char *prefix, bool escape_separator) {
 533         char *r, *e;
 534         size_t n, k, m;
 535
 536         if (!separator)
 537                 separator = " ";
 538
 539         k = strlen(separator);
 540         m = strlen_ptr(prefix);
 541
 542         if (escape_separator) /* If the separator was multi-char, we wouldn't know how to escape it. */
 543                 assert(k == 1);
 544
 545         n = 0;
 546         STRV_FOREACH(s, l) {
 547                 if (s != l)
 548                         n += k;
 549
 550                 bool needs_escaping = escape_separator && strchr(*s, *separator);
 551
 552                 n += m + strlen(*s) * (1 + needs_escaping);
 553         }
 554
 555         r = new(char, n+1);
 556         if (!r)
 557                 return NULL;
 558
 559         e = r;
 560         STRV_FOREACH(s, l) {
 561                 if (s != l)
 562                         e = stpcpy(e, separator);
 563
 564                 if (prefix)
 565                         e = stpcpy(e, prefix);
 566
 567                 bool needs_escaping = escape_separator && strchr(*s, *separator);
 568
 569                 if (needs_escaping)
 570                         for (size_t i = 0; (*s)[i]; i++) {
 571                                 if ((*s)[i] == *separator)
 572                                         *(e++) = '\\';
 573                                 *(e++) = (*s)[i];
 574                         }
 575                 else
 576                         e = stpcpy(e, *s);
 577         }
 578
 579         *e = 0;
 580
 581         return r;
 582 }
 583
 584 int strv_push_with_size(char ***l, size_t *n, char *value) {
 585         /* n is a pointer to a variable to store the size of l.
 586          * If not given (i.e. n is NULL or *n is SIZE_MAX), size will be calculated using strv_length().
 587          * If n is not NULL, the size after the push will be returned.
 588          * If value is empty, no action is taken and *n is not set. */
 589
 590         if (!value)
 591                 return 0;
 592
 593         size_t size = n ? *n : SIZE_MAX;
 594         if (size == SIZE_MAX)
 595                 size = strv_length(*l);
 596
 597         /* Check for overflow */
 598         if (size > SIZE_MAX-2)
 599                 return -ENOMEM;
 600
 601         char **c = reallocarray(*l, GREEDY_ALLOC_ROUND_UP(size + 2), sizeof(char*));
 602         if (!c)
 603                 return -ENOMEM;
 604
 605         c[size] = value;
 606         c[size+1] = NULL;
 607
 608         *l = c;
 609         if (n)
 610                 *n = size + 1;
 611         return 0;
 612 }
 613
 614 int strv_push_pair(char ***l, char *a, char *b) {
 615         char **c;
 616         size_t n;
 617
 618         if (!a && !b)
 619                 return 0;
 620
 621         n = strv_length(*l);
 622
 623         /* Check for overflow */
 624         if (n > SIZE_MAX-3)
 625                 return -ENOMEM;
 626
 627         /* increase and check for overflow */
 628         c = reallocarray(*l, GREEDY_ALLOC_ROUND_UP(n + !!a + !!b + 1), sizeof(char*));
 629         if (!c)
 630                 return -ENOMEM;
 631
 632         if (a)
 633                 c[n++] = a;
 634         if (b)
 635                 c[n++] = b;
 636         c[n] = NULL;
 637
 638         *l = c;
 639         return 0;
 640 }
 641
 642 int strv_insert(char ***l, size_t position, char *value) {
 643         char **c;
 644         size_t n, m;
 645
 646         assert(l);
 647
 648         if (!value)
 649                 return 0;
 650
 651         n = strv_length(*l);
 652         position = MIN(position, n);
 653
 654         /* check for overflow and increase */
 655         if (n > SIZE_MAX - 2)
 656                 return -ENOMEM;
 657         m = n + 2;
 658
 659         c = reallocarray(*l, GREEDY_ALLOC_ROUND_UP(m), sizeof(char*));
 660         if (!c)
 661                 return -ENOMEM;
 662
 663         if (n > position)
 664                 memmove(c + position + 1, c + position, (n - position) * sizeof(char*));
 665
 666         c[position] = value;
 667         c[n + 1] = NULL;
 668
 669         *l = c;
 670         return 0;
 671 }
 672
 673 int strv_consume_with_size(char ***l, size_t *n, char *value) {
 674         int r;
 675
 676         r = strv_push_with_size(l, n, value);
 677         if (r < 0)
 678                 free(value);
 679
 680         return r;
 681 }
 682
 683 int strv_consume_pair(char ***l, char *a, char *b) {
 684         int r;
 685
 686         r = strv_push_pair(l, a, b);
 687         if (r < 0) {
 688                 free(a);
 689                 free(b);
 690         }
 691
 692         return r;
 693 }
 694
 695 int strv_consume_prepend(char ***l, char *value) {
 696         int r;
 697
 698         r = strv_push_prepend(l, value);
 699         if (r < 0)
 700                 free(value);
 701
 702         return r;
 703 }
 704
 705 int strv_prepend(char ***l, const char *value) {
 706         char *v;
 707
 708         if (!value)
 709                 return 0;
 710
 711         v = strdup(value);
 712         if (!v)
 713                 return -ENOMEM;
 714
 715         return strv_consume_prepend(l, v);
 716 }
 717
 718 int strv_extend_with_size(char ***l, size_t *n, const char *value) {
 719         char *v;
 720
 721         if (!value)
 722                 return 0;
 723
 724         v = strdup(value);
 725         if (!v)
 726                 return -ENOMEM;
 727
 728         return strv_consume_with_size(l, n, v);
 729 }
 730
 731 int strv_extend_many_internal(char ***l, const char *value, ...) {
 732         va_list ap;
 733         size_t n, m;
 734         int r;
 735
 736         assert(l);
 737
 738         m = n = strv_length(*l);
 739
 740         r = 0;
 741         va_start(ap, value);
 742         for (const char *s = value; s != POINTER_MAX; s = va_arg(ap, const char*)) {
 743                 if (!s)
 744                         continue;
 745
 746                 if (m > SIZE_MAX-1) { /* overflow */
 747                         r = -ENOMEM;
 748                         break;
 749                 }
 750                 m++;
 751         }
 752         va_end(ap);
 753
 754         if (r < 0)
 755                 return r;
 756         if (m > SIZE_MAX-1)
 757                 return -ENOMEM;
 758
 759         char **c = reallocarray(*l, GREEDY_ALLOC_ROUND_UP(m+1), sizeof(char*));
 760         if (!c)
 761                 return -ENOMEM;
 762         *l = c;
 763
 764         r = 0;
 765         size_t i = n;
 766         va_start(ap, value);
 767         for (const char *s = value; s != POINTER_MAX; s = va_arg(ap, const char*)) {
 768                 if (!s)
 769                         continue;
 770
 771                 c[i] = strdup(s);
 772                 if (!c[i]) {
 773                         r = -ENOMEM;
 774                         break;
 775                 }
 776                 i++;
 777         }
 778         va_end(ap);
 779
 780         if (r < 0) {
 781                 /* rollback on error */
 782                 for (size_t j = n; j < i; j++)
 783                         c[j] = mfree(c[j]);
 784                 return r;
 785         }
 786
 787         c[i] = NULL;
 788         return 0;
 789 }
 790
 791 char** strv_uniq(char **l) {
 792         /* Drops duplicate entries. The first identical string will be
 793          * kept, the others dropped */
 794
 795         STRV_FOREACH(i, l)
 796                 strv_remove(i+1, *i);
 797
 798         return l;
 799 }
 800
 801 bool strv_is_uniq(char * const *l) {
 802         STRV_FOREACH(i, l)
 803                 if (strv_contains(i+1, *i))
 804                         return false;
 805
 806         return true;
 807 }
 808
 809 char** strv_remove(char **l, const char *s) {
 810         char **f, **t;
 811
 812         if (!l)
 813                 return NULL;
 814
 815         assert(s);
 816
 817         /* Drops every occurrence of s in the string list, edits
 818          * in-place. */
 819
 820         for (f = t = l; *f; f++)
 821                 if (streq(*f, s))
 822                         free(*f);
 823                 else
 824                         *(t++) = *f;
 825
 826         *t = NULL;
 827         return l;
 828 }
 829
 830 bool strv_overlap(char * const *a, char * const *b) {
 831         STRV_FOREACH(i, a)
 832                 if (strv_contains(b, *i))
 833                         return true;
 834
 835         return false;
 836 }
 837
 838 static int str_compare(char * const *a, char * const *b) {
 839         return strcmp(*a, *b);
 840 }
 841
 842 char** strv_sort(char **l) {
 843         typesafe_qsort(l, strv_length(l), str_compare);
 844         return l;
 845 }
 846
 847 char** strv_sort_uniq(char **l) {
 848         if (strv_isempty(l))
 849                 return l;
 850
 851         char **tail = strv_sort(l), *prev = NULL;
 852         STRV_FOREACH(i, l)
 853                 if (streq_ptr(*i, prev))
 854                         free(*i);
 855                 else
 856                         *(tail++) = prev = *i;
 857
 858         *tail = NULL;
 859         return l;
 860 }
 861
 862 int strv_compare(char * const *a, char * const *b) {
 863         int r;
 864
 865         if (strv_isempty(a)) {
 866                 if (strv_isempty(b))
 867                         return 0;
 868                 else
 869                         return -1;
 870         }
 871
 872         if (strv_isempty(b))
 873                 return 1;
 874
 875         for ( ; *a || *b; ++a, ++b) {
 876                 r = strcmp_ptr(*a, *b);
 877                 if (r != 0)
 878                         return r;
 879         }
 880
 881         return 0;
 882 }
 883
 884 bool strv_equal_ignore_order(char * const *a, char * const *b) {
 885
 886         /* Just like strv_equal(), but doesn't care about the order of elements or about redundant entries
 887          * (i.e. it's even ok if the number of entries in the array differ, as long as the difference just
 888          * consists of repetitions). */
 889
 890         if (a == b)
 891                 return true;
 892
 893         STRV_FOREACH(i, a)
 894                 if (!strv_contains(b, *i))
 895                         return false;
 896
 897         STRV_FOREACH(i, b)
 898                 if (!strv_contains(a, *i))
 899                         return false;
 900
 901         return true;
 902 }
 903
 904 void strv_print_full(char * const *l, const char *prefix) {
 905         STRV_FOREACH(s, l)
 906                 printf("%s%s\n", strempty(prefix), *s);
 907 }
 908
 909 int strv_extendf(char ***l, const char *format, ...) {
 910         va_list ap;
 911         char *x;
 912         int r;
 913
 914         va_start(ap, format);
 915         r = vasprintf(&x, format, ap);
 916         va_end(ap);
 917
 918         if (r < 0)
 919                 return -ENOMEM;
 920
 921         return strv_consume(l, x);
 922 }
 923
 924 char* startswith_strv(const char *s, char * const *l) {
 925         STRV_FOREACH(i, l) {
 926                 char *found = startswith(s, *i);
 927                 if (found)
 928                         return found;
 929         }
 930
 931         return NULL;
 932 }
 933
 934 char* endswith_strv(const char *s, char * const *l) {
 935         STRV_FOREACH(i, l) {
 936                 char *found = endswith(s, *i);
 937                 if (found)
 938                         return found;
 939         }
 940
 941         return NULL;
 942 }
 943
 944 char** strv_reverse(char **l) {
 945         size_t n;
 946
 947         n = strv_length(l);
 948         if (n <= 1)
 949                 return l;
 950
 951         for (size_t i = 0; i < n / 2; i++)
 952                 SWAP_TWO(l[i], l[n-1-i]);
 953
 954         return l;
 955 }
 956
 957 char** strv_shell_escape(char **l, const char *bad) {
 958         /* Escapes every character in every string in l that is in bad,
 959          * edits in-place, does not roll-back on error. */
 960
 961         STRV_FOREACH(s, l) {
 962                 char *v;
 963
 964                 v = shell_escape(*s, bad);
 965                 if (!v)
 966                         return NULL;
 967
 968                 free_and_replace(*s, v);
 969         }
 970
 971         return l;
 972 }
 973
 974 bool strv_fnmatch_full(
 975                 char* const* patterns,
 976                 const char *s,
 977                 int flags,
 978                 size_t *ret_matched_pos) {
 979
 980         assert(s);
 981
 982         if (patterns)
 983                 for (size_t i = 0; patterns[i]; i++)
 984                         /* NB: We treat all fnmatch() errors as equivalent to FNM_NOMATCH, i.e. if fnmatch() fails to
 985                          * process the pattern for some reason we'll consider this equivalent to non-matching. */
 986                         if (fnmatch(patterns[i], s, flags) == 0) {
 987                                 if (ret_matched_pos)
 988                                         *ret_matched_pos = i;
 989                                 return true;
 990                         }
 991
 992         if (ret_matched_pos)
 993                 *ret_matched_pos = SIZE_MAX;
 994
 995         return false;
 996 }
 997
 998 char** strv_skip(char **l, size_t n) {
 999         while (n > 0) {
1000                 if (strv_isempty(l))
1001                         return NULL;
1002
1003                 l++, n--;
1004         }
1005
1006         /* To simplify callers, always return NULL instead of a zero-item array. */
1007         if (strv_isempty(l))
1008                 return NULL;
1009         return l;
1010 }
1011
1012 int strv_extend_n(char ***l, const char *value, size_t n) {
1013         size_t i, k;
1014         char **nl;
1015
1016         assert(l);
1017
1018         if (!value)
1019                 return 0;
1020         if (n == 0)
1021                 return 0;
1022
1023         /* Adds the value n times to l */
1024
1025         k = strv_length(*l);
1026         if (n >= SIZE_MAX - k)
1027                 return -ENOMEM;
1028
1029         nl = reallocarray(*l, GREEDY_ALLOC_ROUND_UP(k + n + 1), sizeof(char *));
1030         if (!nl)
1031                 return -ENOMEM;
1032
1033         *l = nl;
1034
1035         for (i = k; i < k + n; i++) {
1036                 nl[i] = strdup(value);
1037                 if (!nl[i])
1038                         goto rollback;
1039         }
1040         nl[i] = NULL;
1041
1042         return 0;
1043
1044 rollback:
1045         for (size_t j = k; j < i; j++)
1046                 free(nl[j]);
1047         nl[k] = NULL;
1048
1049         return -ENOMEM;
1050 }
1051
1052 int strv_extend_assignment(char ***l, const char *lhs, const char *rhs) {
1053         char *j;
1054
1055         assert(l);
1056         assert(lhs);
1057
1058         if (!rhs) /* value is optional, in which case we suppress the field */
1059                 return 0;
1060
1061         j = strjoin(lhs, "=", rhs);
1062         if (!j)
1063                 return -ENOMEM;
1064
1065         return strv_consume(l, j);
1066 }
1067
1068 int fputstrv(FILE *f, char * const *l, const char *separator, bool *space) {
1069         bool b = false;
1070         int r;
1071
1072         assert(f);
1073
1074         /* Like fputs(), but for strv, and with a less stupid argument order */
1075
1076         if (!space)
1077                 space = &b;
1078
1079         STRV_FOREACH(s, l) {
1080                 r = fputs_with_separator(f, *s, separator, space);
1081                 if (r < 0)
1082                         return r;
1083         }
1084
1085         return 0;
1086 }
1087
1088 void string_strv_hashmap_remove(Hashmap *h, const char *key, const char *value) {
1089         assert(key);
1090
1091         if (value) {
1092                 char **l = hashmap_get(h, key);
1093                 if (!l)
1094                         return;
1095
1096                 strv_remove(l, value);
1097                 if (!strv_isempty(l))
1098                         return;
1099         }
1100
1101         _unused_ _cleanup_free_ char *key_free = NULL;
1102         strv_free(hashmap_remove2(h, key, (void**) &key_free));
1103 }
1104
1105 void string_strv_ordered_hashmap_remove(OrderedHashmap *h, const char *key, const char *value) {
1106         string_strv_hashmap_remove(PLAIN_HASHMAP(h), key, value);
1107 }
1108
1109 static int string_strv_hashmap_put_internal(Hashmap *h, const char *key, const char *value) {
1110         char **l;
1111         int r;
1112
1113         assert(h);
1114         assert(key);
1115         assert(value);
1116
1117         l = hashmap_get(h, key);
1118         if (l) {
1119                 /* A list for this key already exists, let's append to it if it is not listed yet */
1120                 if (strv_contains(l, value))
1121                         return 0;
1122
1123                 r = strv_extend(&l, value);
1124                 if (r < 0)
1125                         return r;
1126
1127                 assert_se(hashmap_update(h, key, l) >= 0);
1128         } else {
1129                 /* No list for this key exists yet, create one */
1130                 _cleanup_strv_free_ char **l2 = NULL;
1131                 _cleanup_free_ char *t = NULL;
1132
1133                 t = strdup(key);
1134                 if (!t)
1135                         return -ENOMEM;
1136
1137                 r = strv_extend(&l2, value);
1138                 if (r < 0)
1139                         return r;
1140
1141                 r = hashmap_put(h, t, l2);
1142                 if (r < 0)
1143                         return r;
1144
1145                 TAKE_PTR(t);
1146                 TAKE_PTR(l2);
1147         }
1148
1149         return 1;
1150 }
1151
1152 int string_strv_hashmap_put(Hashmap **h, const char *key, const char *value) {
1153         int r;
1154
1155         assert(h);
1156         assert(key);
1157         assert(value);
1158
1159         r = hashmap_ensure_allocated(h, &string_hash_ops_free_strv_free);
1160         if (r < 0)
1161                 return r;
1162
1163         return string_strv_hashmap_put_internal(*h, key, value);
1164 }
1165
1166 int string_strv_ordered_hashmap_put(OrderedHashmap **h, const char *key, const char *value) {
1167         int r;
1168
1169         assert(h);
1170         assert(key);
1171         assert(value);
1172
1173         r = ordered_hashmap_ensure_allocated(h, &string_hash_ops_free_strv_free);
1174         if (r < 0)
1175                 return r;
1176
1177         return string_strv_hashmap_put_internal(PLAIN_HASHMAP(*h), key, value);
1178 }
1179
1180 int strv_rebreak_lines(char **l, size_t width, char ***ret) {
1181         _cleanup_strv_free_ char **broken = NULL;
1182         int r;
1183
1184         assert(ret);
1185
1186         /* Implements a simple UTF-8 line breaking algorithm
1187          *
1188          * Goes through all entries in *l, and line-breaks each line that is longer than the specified
1189          * character width. Breaks at the end of words/beginning of whitespace. Lines that do not contain whitespace are not
1190          * broken. Retains whitespace at beginning of lines, removes it at end of lines. */
1191
1192         if (width == SIZE_MAX) { /* NOP? */
1193                 broken = strv_copy(l);
1194                 if (!broken)
1195                         return -ENOMEM;
1196
1197                 *ret = TAKE_PTR(broken);
1198                 return 0;
1199         }
1200
1201         STRV_FOREACH(i, l) {
1202                 const char *start = *i, *whitespace_begin = NULL, *whitespace_end = NULL;
1203                 bool in_prefix = true; /* still in the whitespace in the beginning of the line? */
1204                 size_t w = 0;
1205
1206                 for (const char *p = start; *p != 0; p = utf8_next_char(p)) {
1207                         if (strchr(NEWLINE, *p)) {
1208                                 in_prefix = true;
1209                                 whitespace_begin = whitespace_end = NULL;
1210                                 w = 0;
1211                         } else if (strchr(WHITESPACE, *p)) {
1212                                 if (!in_prefix && (!whitespace_begin || whitespace_end)) {
1213                                         whitespace_begin = p;
1214                                         whitespace_end = NULL;
1215                                 }
1216                         } else {
1217                                 if (whitespace_begin && !whitespace_end)
1218                                         whitespace_end = p;
1219
1220                                 in_prefix = false;
1221                         }
1222
1223                         int cw = utf8_char_console_width(p);
1224                         if (cw < 0) {
1225                                 log_debug_errno(cw, "Comment to line break contains invalid UTF-8, ignoring.");
1226                                 cw = 1;
1227                         }
1228
1229                         w += cw;
1230
1231                         if (w > width && whitespace_begin && whitespace_end) {
1232                                 _cleanup_free_ char *truncated = NULL;
1233
1234                                 truncated = strndup(start, whitespace_begin - start);
1235                                 if (!truncated)
1236                                         return -ENOMEM;
1237
1238                                 r = strv_consume(&broken, TAKE_PTR(truncated));
1239                                 if (r < 0)
1240                                         return r;
1241
1242                                 p = start = whitespace_end;
1243                                 whitespace_begin = whitespace_end = NULL;
1244                                 w = cw;
1245                         }
1246                 }
1247
1248                 /* Process rest of the line */
1249                 assert(start);
1250                 if (in_prefix) /* Never seen anything non-whitespace? Generate empty line! */
1251                         r = strv_extend(&broken, "");
1252                 else if (whitespace_begin && !whitespace_end) { /* Ends in whitespace? Chop it off! */
1253                         _cleanup_free_ char *truncated = strndup(start, whitespace_begin - start);
1254                         if (!truncated)
1255                                 return -ENOMEM;
1256
1257                         r = strv_consume(&broken, TAKE_PTR(truncated));
1258                 } else /* Otherwise use line as is */
1259                         r = strv_extend(&broken, start);
1260                 if (r < 0)
1261                         return r;
1262         }
1263
1264         *ret = TAKE_PTR(broken);
1265         return 0;
1266 }
1267
1268 char** strv_filter_prefix(char * const *l, const char *prefix) {
1269
1270         /* Allocates a copy of 'l', but only copies over entries starting with 'prefix' */
1271
1272         if (isempty(prefix))
1273                 return strv_copy(l);
1274
1275         _cleanup_strv_free_ char **f = NULL;
1276         size_t sz = 0;
1277
1278         STRV_FOREACH(i, l) {
1279                 if (!startswith(*i, prefix))
1280                         continue;
1281
1282                 if (strv_extend_with_size(&f, &sz, *i) < 0)
1283                         return NULL;
1284         }
1285
1286         return TAKE_PTR(f);
1287 }