chiark / gitweb /
shared: add formats-util.h
[elogind.git] / src / shared / env-util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2012 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <limits.h>
23 #include <unistd.h>
24
25 #include "strv.h"
26 #include "utf8.h"
27 #include "util.h"
28 #include "env-util.h"
29 #include "def.h"
30
31 #define VALID_CHARS_ENV_NAME                    \
32         DIGITS LETTERS                          \
33         "_"
34
35 #ifndef ARG_MAX
36 #define ARG_MAX ((size_t) sysconf(_SC_ARG_MAX))
37 #endif
38
39 static bool env_name_is_valid_n(const char *e, size_t n) {
40         const char *p;
41
42         if (!e)
43                 return false;
44
45         if (n <= 0)
46                 return false;
47
48         if (e[0] >= '0' && e[0] <= '9')
49                 return false;
50
51         /* POSIX says the overall size of the environment block cannot
52          * be > ARG_MAX, an individual assignment hence cannot be
53          * either. Discounting the equal sign and trailing NUL this
54          * hence leaves ARG_MAX-2 as longest possible variable
55          * name. */
56         if (n > ARG_MAX - 2)
57                 return false;
58
59         for (p = e; p < e + n; p++)
60                 if (!strchr(VALID_CHARS_ENV_NAME, *p))
61                         return false;
62
63         return true;
64 }
65
66 bool env_name_is_valid(const char *e) {
67         if (!e)
68                 return false;
69
70         return env_name_is_valid_n(e, strlen(e));
71 }
72
73 bool env_value_is_valid(const char *e) {
74         if (!e)
75                 return false;
76
77         if (!utf8_is_valid(e))
78                 return false;
79
80         /* bash allows tabs in environment variables, and so should
81          * we */
82         if (string_has_cc(e, "\t"))
83                 return false;
84
85         /* POSIX says the overall size of the environment block cannot
86          * be > ARG_MAX, an individual assignment hence cannot be
87          * either. Discounting the shortest possible variable name of
88          * length 1, the equal sign and trailing NUL this hence leaves
89          * ARG_MAX-3 as longest possible variable value. */
90         if (strlen(e) > ARG_MAX - 3)
91                 return false;
92
93         return true;
94 }
95
96 bool env_assignment_is_valid(const char *e) {
97         const char *eq;
98
99         eq = strchr(e, '=');
100         if (!eq)
101                 return false;
102
103         if (!env_name_is_valid_n(e, eq - e))
104                 return false;
105
106         if (!env_value_is_valid(eq + 1))
107                 return false;
108
109         /* POSIX says the overall size of the environment block cannot
110          * be > ARG_MAX, hence the individual variable assignments
111          * cannot be either, but let's leave room for one trailing NUL
112          * byte. */
113         if (strlen(e) > ARG_MAX - 1)
114                 return false;
115
116         return true;
117 }
118
119 bool strv_env_is_valid(char **e) {
120         char **p, **q;
121
122         STRV_FOREACH(p, e) {
123                 size_t k;
124
125                 if (!env_assignment_is_valid(*p))
126                         return false;
127
128                 /* Check if there are duplicate assginments */
129                 k = strcspn(*p, "=");
130                 STRV_FOREACH(q, p + 1)
131                         if (strneq(*p, *q, k) && (*q)[k] == '=')
132                                 return false;
133         }
134
135         return true;
136 }
137
138 bool strv_env_name_or_assignment_is_valid(char **l) {
139         char **p, **q;
140
141         STRV_FOREACH(p, l) {
142                 if (!env_assignment_is_valid(*p) && !env_name_is_valid(*p))
143                         return false;
144
145                 STRV_FOREACH(q, p + 1)
146                         if (streq(*p, *q))
147                                 return false;
148         }
149
150         return true;
151 }
152
153 static int env_append(char **r, char ***k, char **a) {
154         assert(r);
155         assert(k);
156
157         if (!a)
158                 return 0;
159
160         /* Add the entries of a to *k unless they already exist in *r
161          * in which case they are overridden instead. This assumes
162          * there is enough space in the r array. */
163
164         for (; *a; a++) {
165                 char **j;
166                 size_t n;
167
168                 n = strcspn(*a, "=");
169
170                 if ((*a)[n] == '=')
171                         n++;
172
173                 for (j = r; j < *k; j++)
174                         if (strneq(*j, *a, n))
175                                 break;
176
177                 if (j >= *k)
178                         (*k)++;
179                 else
180                         free(*j);
181
182                 *j = strdup(*a);
183                 if (!*j)
184                         return -ENOMEM;
185         }
186
187         return 0;
188 }
189
190 char **strv_env_merge(unsigned n_lists, ...) {
191         size_t n = 0;
192         char **l, **k, **r;
193         va_list ap;
194         unsigned i;
195
196         /* Merges an arbitrary number of environment sets */
197
198         va_start(ap, n_lists);
199         for (i = 0; i < n_lists; i++) {
200                 l = va_arg(ap, char**);
201                 n += strv_length(l);
202         }
203         va_end(ap);
204
205         r = new(char*, n+1);
206         if (!r)
207                 return NULL;
208
209         k = r;
210
211         va_start(ap, n_lists);
212         for (i = 0; i < n_lists; i++) {
213                 l = va_arg(ap, char**);
214                 if (env_append(r, &k, l) < 0)
215                         goto fail;
216         }
217         va_end(ap);
218
219         *k = NULL;
220
221         return r;
222
223 fail:
224         va_end(ap);
225         strv_free(r);
226
227         return NULL;
228 }
229
230 _pure_ static bool env_match(const char *t, const char *pattern) {
231         assert(t);
232         assert(pattern);
233
234         /* pattern a matches string a
235          *         a matches a=
236          *         a matches a=b
237          *         a= matches a=
238          *         a=b matches a=b
239          *         a= does not match a
240          *         a=b does not match a=
241          *         a=b does not match a
242          *         a=b does not match a=c */
243
244         if (streq(t, pattern))
245                 return true;
246
247         if (!strchr(pattern, '=')) {
248                 size_t l = strlen(pattern);
249
250                 return strneq(t, pattern, l) && t[l] == '=';
251         }
252
253         return false;
254 }
255
256 char **strv_env_delete(char **x, unsigned n_lists, ...) {
257         size_t n, i = 0;
258         char **k, **r;
259         va_list ap;
260
261         /* Deletes every entry from x that is mentioned in the other
262          * string lists */
263
264         n = strv_length(x);
265
266         r = new(char*, n+1);
267         if (!r)
268                 return NULL;
269
270         STRV_FOREACH(k, x) {
271                 unsigned v;
272
273                 va_start(ap, n_lists);
274                 for (v = 0; v < n_lists; v++) {
275                         char **l, **j;
276
277                         l = va_arg(ap, char**);
278                         STRV_FOREACH(j, l)
279                                 if (env_match(*k, *j))
280                                         goto skip;
281                 }
282                 va_end(ap);
283
284                 r[i] = strdup(*k);
285                 if (!r[i]) {
286                         strv_free(r);
287                         return NULL;
288                 }
289
290                 i++;
291                 continue;
292
293         skip:
294                 va_end(ap);
295         }
296
297         r[i] = NULL;
298
299         assert(i <= n);
300
301         return r;
302 }
303
304 char **strv_env_unset(char **l, const char *p) {
305
306         char **f, **t;
307
308         if (!l)
309                 return NULL;
310
311         assert(p);
312
313         /* Drops every occurrence of the env var setting p in the
314          * string list. Edits in-place. */
315
316         for (f = t = l; *f; f++) {
317
318                 if (env_match(*f, p)) {
319                         free(*f);
320                         continue;
321                 }
322
323                 *(t++) = *f;
324         }
325
326         *t = NULL;
327         return l;
328 }
329
330 char **strv_env_unset_many(char **l, ...) {
331
332         char **f, **t;
333
334         if (!l)
335                 return NULL;
336
337         /* Like strv_env_unset() but applies many at once. Edits in-place. */
338
339         for (f = t = l; *f; f++) {
340                 bool found = false;
341                 const char *p;
342                 va_list ap;
343
344                 va_start(ap, l);
345
346                 while ((p = va_arg(ap, const char*))) {
347                         if (env_match(*f, p)) {
348                                 found = true;
349                                 break;
350                         }
351                 }
352
353                 va_end(ap);
354
355                 if (found) {
356                         free(*f);
357                         continue;
358                 }
359
360                 *(t++) = *f;
361         }
362
363         *t = NULL;
364         return l;
365 }
366
367 char **strv_env_set(char **x, const char *p) {
368
369         char **k, **r;
370         char* m[2] = { (char*) p, NULL };
371
372         /* Overrides the env var setting of p, returns a new copy */
373
374         r = new(char*, strv_length(x)+2);
375         if (!r)
376                 return NULL;
377
378         k = r;
379         if (env_append(r, &k, x) < 0)
380                 goto fail;
381
382         if (env_append(r, &k, m) < 0)
383                 goto fail;
384
385         *k = NULL;
386
387         return r;
388
389 fail:
390         strv_free(r);
391         return NULL;
392 }
393
394 char *strv_env_get_n(char **l, const char *name, size_t k) {
395         char **i;
396
397         assert(name);
398
399         if (k <= 0)
400                 return NULL;
401
402         STRV_FOREACH(i, l)
403                 if (strneq(*i, name, k) &&
404                     (*i)[k] == '=')
405                         return *i + k + 1;
406
407         return NULL;
408 }
409
410 char *strv_env_get(char **l, const char *name) {
411         assert(name);
412
413         return strv_env_get_n(l, name, strlen(name));
414 }
415
416 char **strv_env_clean_with_callback(char **e, void (*invalid_callback)(const char *p, void *userdata), void *userdata) {
417         char **p, **q;
418         int k = 0;
419
420         STRV_FOREACH(p, e) {
421                 size_t n;
422                 bool duplicate = false;
423
424                 if (!env_assignment_is_valid(*p)) {
425                         if (invalid_callback)
426                                 invalid_callback(*p, userdata);
427                         free(*p);
428                         continue;
429                 }
430
431                 n = strcspn(*p, "=");
432                 STRV_FOREACH(q, p + 1)
433                         if (strneq(*p, *q, n) && (*q)[n] == '=') {
434                                 duplicate = true;
435                                 break;
436                         }
437
438                 if (duplicate) {
439                         free(*p);
440                         continue;
441                 }
442
443                 e[k++] = *p;
444         }
445
446         if (e)
447                 e[k] = NULL;
448
449         return e;
450 }