src/test/test-env-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <string.h>
   4
   5 #include "env-util.h"
   6 #include "fd-util.h"
   7 #include "fileio.h"
   8 #include "fs-util.h"
   9 #include "serialize.h"
  10 #include "string-util.h"
  11 #include "strv.h"
  12 #include "util.h"
  13
  14 static void test_strv_env_delete(void) {
  15         _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
  16
  17         a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
  18         assert_se(a);
  19
  20         b = strv_new("PIEP", "FOO");
  21         assert_se(b);
  22
  23         c = strv_new("SCHLUMPF");
  24         assert_se(c);
  25
  26         d = strv_env_delete(a, 2, b, c);
  27         assert_se(d);
  28
  29         assert_se(streq(d[0], "WALDO=WALDO"));
  30         assert_se(streq(d[1], "WALDO="));
  31         assert_se(strv_length(d) == 2);
  32 }
  33
  34 static void test_strv_env_get(void) {
  35         char **l;
  36
  37         l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");
  38
  39         assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
  40         assert_se(streq(strv_env_get(l, "THREE"), "3"));
  41         assert_se(streq(strv_env_get(l, "FOUR"), "4"));
  42 }
  43
  44 static void test_strv_env_unset(void) {
  45         _cleanup_strv_free_ char **l = NULL;
  46
  47         l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
  48         assert_se(l);
  49
  50         assert_se(strv_env_unset(l, "SCHLUMPF") == l);
  51
  52         assert_se(streq(l[0], "PIEP"));
  53         assert_se(streq(l[1], "NANANANA=YES"));
  54         assert_se(strv_length(l) == 2);
  55 }
  56
  57 static void test_strv_env_set(void) {
  58         _cleanup_strv_free_ char **l = NULL, **r = NULL;
  59
  60         l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
  61         assert_se(l);
  62
  63         r = strv_env_set(l, "WALDO=WALDO");
  64         assert_se(r);
  65
  66         assert_se(streq(r[0], "PIEP"));
  67         assert_se(streq(r[1], "SCHLUMPF=SMURFF"));
  68         assert_se(streq(r[2], "NANANANA=YES"));
  69         assert_se(streq(r[3], "WALDO=WALDO"));
  70         assert_se(strv_length(r) == 4);
  71 }
  72
  73 static void test_strv_env_merge(void) {
  74         _cleanup_strv_free_ char **a = NULL, **b = NULL, **r = NULL;
  75
  76         a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
  77         assert_se(a);
  78
  79         b = strv_new("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
  80         assert_se(b);
  81
  82         r = strv_env_merge(2, a, b);
  83         assert_se(r);
  84         assert_se(streq(r[0], "FOO="));
  85         assert_se(streq(r[1], "WALDO="));
  86         assert_se(streq(r[2], "PIEP"));
  87         assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
  88         assert_se(streq(r[4], "PIEP="));
  89         assert_se(streq(r[5], "NANANANA=YES"));
  90         assert_se(strv_length(r) == 6);
  91
  92         assert_se(strv_env_clean(r) == r);
  93         assert_se(streq(r[0], "FOO="));
  94         assert_se(streq(r[1], "WALDO="));
  95         assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
  96         assert_se(streq(r[3], "PIEP="));
  97         assert_se(streq(r[4], "NANANANA=YES"));
  98         assert_se(strv_length(r) == 5);
  99 }
 100
 101 static void test_env_strv_get_n(void) {
 102         const char *_env[] = {
 103                 "FOO=NO NO NO",
 104                 "FOO=BAR BAR",
 105                 "BAR=waldo",
 106                 "PATH=unset",
 107                 NULL
 108         };
 109         char **env = (char**) _env;
 110
 111         assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
 112         assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
 113         assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
 114         assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
 115
 116         assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
 117         assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
 118         assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
 119         assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
 120
 121         env[3] = NULL; /* kill our $PATH */
 122
 123         assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
 124         assert_se(!strv_env_get_n(env, "PATH", 4, 0));
 125         assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
 126                         getenv("PATH")));
 127         assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
 128                         getenv("PATH")));
 129 }
 130
 131 static void test_replace_env(bool braceless) {
 132         const char *env[] = {
 133                 "FOO=BAR BAR",
 134                 "BAR=waldo",
 135                 NULL
 136         };
 137         _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL;
 138         unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;
 139
 140         t = replace_env("FOO=$FOO=${FOO}", (char**) env, flags);
 141         assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
 142
 143         s = replace_env("BAR=$BAR=${BAR}", (char**) env, flags);
 144         assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
 145
 146         q = replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags);
 147         assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
 148
 149         r = replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags);
 150         assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
 151
 152         p = replace_env("${BAR}$BAR$BAR", (char**) env, flags);
 153         assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
 154 }
 155
 156 static void test_replace_env2(bool extended) {
 157         const char *env[] = {
 158                 "FOO=foo",
 159                 "BAR=bar",
 160                 NULL
 161         };
 162         _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = NULL;
 163         unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
 164
 165         t = replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags);
 166         assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
 167
 168         s = replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags);
 169         assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
 170
 171         q = replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags);
 172         assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
 173
 174         r = replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags);
 175         assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
 176
 177         p = replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags);
 178         assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
 179
 180         x = replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags);
 181         assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
 182 }
 183
 184 static void test_replace_env_argv(void) {
 185         const char *env[] = {
 186                 "FOO=BAR BAR",
 187                 "BAR=waldo",
 188                 NULL
 189         };
 190         const char *line[] = {
 191                 "FOO$FOO",
 192                 "FOO$FOOFOO",
 193                 "FOO${FOO}$FOO",
 194                 "FOO${FOO}",
 195                 "${FOO}",
 196                 "$FOO",
 197                 "$FOO$FOO",
 198                 "${FOO}${BAR}",
 199                 "${FOO",
 200                 "FOO$$${FOO}",
 201                 "$$FOO${FOO}",
 202                 "${FOO:-${BAR}}",
 203                 "${QUUX:-${FOO}}",
 204                 "${FOO:+${BAR}}",
 205                 "${QUUX:+${BAR}}",
 206                 "${FOO:+|${BAR}|}}",
 207                 "${FOO:+|${BAR}{|}",
 208                 NULL
 209         };
 210         _cleanup_strv_free_ char **r = NULL;
 211
 212         r = replace_env_argv((char**) line, (char**) env);
 213         assert_se(r);
 214         assert_se(streq(r[0], "FOO$FOO"));
 215         assert_se(streq(r[1], "FOO$FOOFOO"));
 216         assert_se(streq(r[2], "FOOBAR BAR$FOO"));
 217         assert_se(streq(r[3], "FOOBAR BAR"));
 218         assert_se(streq(r[4], "BAR BAR"));
 219         assert_se(streq(r[5], "BAR"));
 220         assert_se(streq(r[6], "BAR"));
 221         assert_se(streq(r[7], "BAR BARwaldo"));
 222         assert_se(streq(r[8], "${FOO"));
 223         assert_se(streq(r[9], "FOO$BAR BAR"));
 224         assert_se(streq(r[10], "$FOOBAR BAR"));
 225         assert_se(streq(r[11], "${FOO:-waldo}"));
 226         assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
 227         assert_se(streq(r[13], "${FOO:+waldo}"));
 228         assert_se(streq(r[14], "${QUUX:+waldo}"));
 229         assert_se(streq(r[15], "${FOO:+|waldo|}}"));
 230         assert_se(streq(r[16], "${FOO:+|waldo{|}"));
 231         assert_se(strv_length(r) == 17);
 232 }
 233
 234 static void test_env_clean(void) {
 235         _cleanup_strv_free_ char **e;
 236
 237         e = strv_new("FOOBAR=WALDO",
 238                      "FOOBAR=WALDO",
 239                      "FOOBAR",
 240                      "F",
 241                      "X=",
 242                      "F=F",
 243                      "=",
 244                      "=F",
 245                      "",
 246                      "0000=000",
 247                      "äöüß=abcd",
 248                      "abcd=äöüß",
 249                      "xyz\n=xyz",
 250                      "xyz=xyz\n",
 251                      "another=one",
 252                      "another=final one");
 253         assert_se(e);
 254         assert_se(!strv_env_is_valid(e));
 255         assert_se(strv_env_clean(e) == e);
 256         assert_se(strv_env_is_valid(e));
 257
 258         assert_se(streq(e[0], "FOOBAR=WALDO"));
 259         assert_se(streq(e[1], "X="));
 260         assert_se(streq(e[2], "F=F"));
 261         assert_se(streq(e[3], "abcd=äöüß"));
 262         assert_se(streq(e[4], "xyz=xyz\n"));
 263         assert_se(streq(e[5], "another=final one"));
 264         assert_se(e[6] == NULL);
 265 }
 266
 267 static void test_env_name_is_valid(void) {
 268         assert_se(env_name_is_valid("test"));
 269
 270         assert_se(!env_name_is_valid(NULL));
 271         assert_se(!env_name_is_valid(""));
 272         assert_se(!env_name_is_valid("xxx\a"));
 273         assert_se(!env_name_is_valid("xxx\007b"));
 274         assert_se(!env_name_is_valid("\007\009"));
 275         assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
 276         assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
 277 }
 278
 279 static void test_env_value_is_valid(void) {
 280         assert_se(env_value_is_valid(""));
 281         assert_se(env_value_is_valid("głąb kapuściany"));
 282         assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
 283         assert_se(env_value_is_valid("tab\tcharacter"));
 284         assert_se(env_value_is_valid("new\nline"));
 285 }
 286
 287 static void test_env_assignment_is_valid(void) {
 288         assert_se(env_assignment_is_valid("a="));
 289         assert_se(env_assignment_is_valid("b=głąb kapuściany"));
 290         assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
 291         assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
 292         assert_se(env_assignment_is_valid("f=tab\tcharacter"));
 293         assert_se(env_assignment_is_valid("g=new\nline"));
 294
 295         assert_se(!env_assignment_is_valid("="));
 296         assert_se(!env_assignment_is_valid("a b="));
 297         assert_se(!env_assignment_is_valid("a ="));
 298         assert_se(!env_assignment_is_valid(" b="));
 299         /* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
 300         assert_se(!env_assignment_is_valid("a.b="));
 301         assert_se(!env_assignment_is_valid("a-b="));
 302         assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
 303         assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
 304         assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
 305 }
 306
 307 int main(int argc, char *argv[]) {
 308         test_strv_env_delete();
 309         test_strv_env_get();
 310         test_strv_env_unset();
 311         test_strv_env_set();
 312         test_strv_env_merge();
 313         test_env_strv_get_n();
 314         test_replace_env(false);
 315         test_replace_env(true);
 316         test_replace_env2(false);
 317         test_replace_env2(true);
 318         test_replace_env_argv();
 319         test_env_clean();
 320         test_env_name_is_valid();
 321         test_env_value_is_valid();
 322         test_env_assignment_is_valid();
 323
 324         return 0;
 325 }