src/test/test-env-util.c

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