chiark / gitweb /
Prep v220: Apply "Fixes to user and session saving"
[elogind.git] / src / basic / 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 2010 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 <string.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <stdlib.h>
26 #include <signal.h>
27 #include <libintl.h>
28 #include <stdio.h>
29 #include <syslog.h>
30 #include <sched.h>
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <fcntl.h>
36 #include <dirent.h>
37 #include <sys/ioctl.h>
38 #include <stdarg.h>
39 #include <poll.h>
40 #include <ctype.h>
41 #include <sys/prctl.h>
42 #include <sys/utsname.h>
43 #include <pwd.h>
44 #include <netinet/ip.h>
45 #include <sys/wait.h>
46 #include <sys/time.h>
47 #include <glob.h>
48 #include <grp.h>
49 #include <sys/mman.h>
50 #include <sys/vfs.h>
51 #include <sys/mount.h>
52 #include <linux/magic.h>
53 #include <limits.h>
54 #include <langinfo.h>
55 #include <locale.h>
56 #include <sys/personality.h>
57 #include <sys/xattr.h>
58 #include <sys/statvfs.h>
59 #include <sys/file.h>
60 #include <linux/fs.h>
61
62 /* When we include libgen.h because we need dirname() we immediately
63  * undefine basename() since libgen.h defines it as a macro to the POSIX
64  * version which is really broken. We prefer GNU basename(). */
65 #include <libgen.h>
66 #undef basename
67
68 #ifdef HAVE_SYS_AUXV_H
69 #include <sys/auxv.h>
70 #endif
71
72 #include "config.h"
73 #include "macro.h"
74 #include "util.h"
75 #include "ioprio.h"
76 #include "missing.h"
77 #include "log.h"
78 #include "strv.h"
79 #include "mkdir.h"
80 #include "path-util.h"
81 #include "exit-status.h"
82 #include "hashmap.h"
83 #include "env-util.h"
84 #include "fileio.h"
85 #include "device-nodes.h"
86 #include "utf8.h"
87 #include "gunicode.h"
88 #include "virt.h"
89 #include "def.h"
90 #include "sparse-endian.h"
91 #include "formats-util.h"
92 #include "process-util.h"
93 #include "random-util.h"
94 #include "terminal-util.h"
95 #include "hostname-util.h"
96 #include "signal-util.h"
97
98 /* Put this test here for a lack of better place */
99 assert_cc(EAGAIN == EWOULDBLOCK);
100
101 int saved_argc = 0;
102 char **saved_argv = NULL;
103
104 size_t page_size(void) {
105         static thread_local size_t pgsz = 0;
106         long r;
107
108         if (_likely_(pgsz > 0))
109                 return pgsz;
110
111         r = sysconf(_SC_PAGESIZE);
112         assert(r > 0);
113
114         pgsz = (size_t) r;
115         return pgsz;
116 }
117
118 bool streq_ptr(const char *a, const char *b) {
119
120         /* Like streq(), but tries to make sense of NULL pointers */
121
122         if (a && b)
123                 return streq(a, b);
124
125         if (!a && !b)
126                 return true;
127
128         return false;
129 }
130
131 char* endswith(const char *s, const char *postfix) {
132         size_t sl, pl;
133
134         assert(s);
135         assert(postfix);
136
137         sl = strlen(s);
138         pl = strlen(postfix);
139
140         if (pl == 0)
141                 return (char*) s + sl;
142
143         if (sl < pl)
144                 return NULL;
145
146         if (memcmp(s + sl - pl, postfix, pl) != 0)
147                 return NULL;
148
149         return (char*) s + sl - pl;
150 }
151
152 char* endswith_no_case(const char *s, const char *postfix) {
153         size_t sl, pl;
154
155         assert(s);
156         assert(postfix);
157
158         sl = strlen(s);
159         pl = strlen(postfix);
160
161         if (pl == 0)
162                 return (char*) s + sl;
163
164         if (sl < pl)
165                 return NULL;
166
167         if (strcasecmp(s + sl - pl, postfix) != 0)
168                 return NULL;
169
170         return (char*) s + sl - pl;
171 }
172
173 char* first_word(const char *s, const char *word) {
174         size_t sl, wl;
175         const char *p;
176
177         assert(s);
178         assert(word);
179
180         /* Checks if the string starts with the specified word, either
181          * followed by NUL or by whitespace. Returns a pointer to the
182          * NUL or the first character after the whitespace. */
183
184         sl = strlen(s);
185         wl = strlen(word);
186
187         if (sl < wl)
188                 return NULL;
189
190         if (wl == 0)
191                 return (char*) s;
192
193         if (memcmp(s, word, wl) != 0)
194                 return NULL;
195
196         p = s + wl;
197         if (*p == 0)
198                 return (char*) p;
199
200         if (!strchr(WHITESPACE, *p))
201                 return NULL;
202
203         p += strspn(p, WHITESPACE);
204         return (char*) p;
205 }
206
207 size_t cescape_char(char c, char *buf) {
208         char * buf_old = buf;
209
210         switch (c) {
211
212                 case '\a':
213                         *(buf++) = '\\';
214                         *(buf++) = 'a';
215                         break;
216                 case '\b':
217                         *(buf++) = '\\';
218                         *(buf++) = 'b';
219                         break;
220                 case '\f':
221                         *(buf++) = '\\';
222                         *(buf++) = 'f';
223                         break;
224                 case '\n':
225                         *(buf++) = '\\';
226                         *(buf++) = 'n';
227                         break;
228                 case '\r':
229                         *(buf++) = '\\';
230                         *(buf++) = 'r';
231                         break;
232                 case '\t':
233                         *(buf++) = '\\';
234                         *(buf++) = 't';
235                         break;
236                 case '\v':
237                         *(buf++) = '\\';
238                         *(buf++) = 'v';
239                         break;
240                 case '\\':
241                         *(buf++) = '\\';
242                         *(buf++) = '\\';
243                         break;
244                 case '"':
245                         *(buf++) = '\\';
246                         *(buf++) = '"';
247                         break;
248                 case '\'':
249                         *(buf++) = '\\';
250                         *(buf++) = '\'';
251                         break;
252
253                 default:
254                         /* For special chars we prefer octal over
255                          * hexadecimal encoding, simply because glib's
256                          * g_strescape() does the same */
257                         if ((c < ' ') || (c >= 127)) {
258                                 *(buf++) = '\\';
259                                 *(buf++) = octchar((unsigned char) c >> 6);
260                                 *(buf++) = octchar((unsigned char) c >> 3);
261                                 *(buf++) = octchar((unsigned char) c);
262                         } else
263                                 *(buf++) = c;
264                         break;
265         }
266
267         return buf - buf_old;
268 }
269
270 int close_nointr(int fd) {
271         assert(fd >= 0);
272
273         if (close(fd) >= 0)
274                 return 0;
275
276         /*
277          * Just ignore EINTR; a retry loop is the wrong thing to do on
278          * Linux.
279          *
280          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
281          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
282          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
283          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
284          */
285         if (errno == EINTR)
286                 return 0;
287
288         return -errno;
289 }
290
291 int safe_close(int fd) {
292
293         /*
294          * Like close_nointr() but cannot fail. Guarantees errno is
295          * unchanged. Is a NOP with negative fds passed, and returns
296          * -1, so that it can be used in this syntax:
297          *
298          * fd = safe_close(fd);
299          */
300
301         if (fd >= 0) {
302                 PROTECT_ERRNO;
303
304                 /* The kernel might return pretty much any error code
305                  * via close(), but the fd will be closed anyway. The
306                  * only condition we want to check for here is whether
307                  * the fd was invalid at all... */
308
309                 assert_se(close_nointr(fd) != -EBADF);
310         }
311
312         return -1;
313 }
314
315 void close_many(const int fds[], unsigned n_fd) {
316         unsigned i;
317
318         assert(fds || n_fd <= 0);
319
320         for (i = 0; i < n_fd; i++)
321                 safe_close(fds[i]);
322 }
323
324 int unlink_noerrno(const char *path) {
325         PROTECT_ERRNO;
326         int r;
327
328         r = unlink(path);
329         if (r < 0)
330                 return -errno;
331
332         return 0;
333 }
334
335 int parse_boolean(const char *v) {
336         assert(v);
337
338         if (streq(v, "1") || strcaseeq(v, "yes") || strcaseeq(v, "y") || strcaseeq(v, "true") || strcaseeq(v, "t") || strcaseeq(v, "on"))
339                 return 1;
340         else if (streq(v, "0") || strcaseeq(v, "no") || strcaseeq(v, "n") || strcaseeq(v, "false") || strcaseeq(v, "f") || strcaseeq(v, "off"))
341                 return 0;
342
343         return -EINVAL;
344 }
345
346 int parse_pid(const char *s, pid_t* ret_pid) {
347         unsigned long ul = 0;
348         pid_t pid;
349         int r;
350
351         assert(s);
352         assert(ret_pid);
353
354         r = safe_atolu(s, &ul);
355         if (r < 0)
356                 return r;
357
358         pid = (pid_t) ul;
359
360         if ((unsigned long) pid != ul)
361                 return -ERANGE;
362
363         if (pid <= 0)
364                 return -ERANGE;
365
366         *ret_pid = pid;
367         return 0;
368 }
369
370 int parse_uid(const char *s, uid_t* ret_uid) {
371         unsigned long ul = 0;
372         uid_t uid;
373         int r;
374
375         assert(s);
376
377         r = safe_atolu(s, &ul);
378         if (r < 0)
379                 return r;
380
381         uid = (uid_t) ul;
382
383         if ((unsigned long) uid != ul)
384                 return -ERANGE;
385
386         /* Some libc APIs use UID_INVALID as special placeholder */
387         if (uid == (uid_t) 0xFFFFFFFF)
388                 return -ENXIO;
389
390         /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
391         if (uid == (uid_t) 0xFFFF)
392                 return -ENXIO;
393
394         if (ret_uid)
395                 *ret_uid = uid;
396
397         return 0;
398 }
399
400 int safe_atou(const char *s, unsigned *ret_u) {
401         char *x = NULL;
402         unsigned long l;
403
404         assert(s);
405         assert(ret_u);
406
407         errno = 0;
408         l = strtoul(s, &x, 0);
409
410         if (!x || x == s || *x || errno)
411                 return errno > 0 ? -errno : -EINVAL;
412
413         if ((unsigned long) (unsigned) l != l)
414                 return -ERANGE;
415
416         *ret_u = (unsigned) l;
417         return 0;
418 }
419
420 int safe_atoi(const char *s, int *ret_i) {
421         char *x = NULL;
422         long l;
423
424         assert(s);
425         assert(ret_i);
426
427         errno = 0;
428         l = strtol(s, &x, 0);
429
430         if (!x || x == s || *x || errno)
431                 return errno > 0 ? -errno : -EINVAL;
432
433         if ((long) (int) l != l)
434                 return -ERANGE;
435
436         *ret_i = (int) l;
437         return 0;
438 }
439
440 int safe_atou8(const char *s, uint8_t *ret) {
441         char *x = NULL;
442         unsigned long l;
443
444         assert(s);
445         assert(ret);
446
447         errno = 0;
448         l = strtoul(s, &x, 0);
449
450         if (!x || x == s || *x || errno)
451                 return errno > 0 ? -errno : -EINVAL;
452
453         if ((unsigned long) (uint8_t) l != l)
454                 return -ERANGE;
455
456         *ret = (uint8_t) l;
457         return 0;
458 }
459
460 int safe_atou16(const char *s, uint16_t *ret) {
461         char *x = NULL;
462         unsigned long l;
463
464         assert(s);
465         assert(ret);
466
467         errno = 0;
468         l = strtoul(s, &x, 0);
469
470         if (!x || x == s || *x || errno)
471                 return errno > 0 ? -errno : -EINVAL;
472
473         if ((unsigned long) (uint16_t) l != l)
474                 return -ERANGE;
475
476         *ret = (uint16_t) l;
477         return 0;
478 }
479
480 int safe_atoi16(const char *s, int16_t *ret) {
481         char *x = NULL;
482         long l;
483
484         assert(s);
485         assert(ret);
486
487         errno = 0;
488         l = strtol(s, &x, 0);
489
490         if (!x || x == s || *x || errno)
491                 return errno > 0 ? -errno : -EINVAL;
492
493         if ((long) (int16_t) l != l)
494                 return -ERANGE;
495
496         *ret = (int16_t) l;
497         return 0;
498 }
499
500 int safe_atollu(const char *s, long long unsigned *ret_llu) {
501         char *x = NULL;
502         unsigned long long l;
503
504         assert(s);
505         assert(ret_llu);
506
507         errno = 0;
508         l = strtoull(s, &x, 0);
509
510         if (!x || x == s || *x || errno)
511                 return errno ? -errno : -EINVAL;
512
513         *ret_llu = l;
514         return 0;
515 }
516
517 int safe_atolli(const char *s, long long int *ret_lli) {
518         char *x = NULL;
519         long long l;
520
521         assert(s);
522         assert(ret_lli);
523
524         errno = 0;
525         l = strtoll(s, &x, 0);
526
527         if (!x || x == s || *x || errno)
528                 return errno ? -errno : -EINVAL;
529
530         *ret_lli = l;
531         return 0;
532 }
533
534 int safe_atod(const char *s, double *ret_d) {
535         char *x = NULL;
536         double d = 0;
537         locale_t loc;
538
539         assert(s);
540         assert(ret_d);
541
542         loc = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
543         if (loc == (locale_t) 0)
544                 return -errno;
545
546         errno = 0;
547         d = strtod_l(s, &x, loc);
548
549         if (!x || x == s || *x || errno) {
550                 freelocale(loc);
551                 return errno ? -errno : -EINVAL;
552         }
553
554         freelocale(loc);
555         *ret_d = (double) d;
556         return 0;
557 }
558
559 static size_t strcspn_escaped(const char *s, const char *reject) {
560         bool escaped = false;
561         int n;
562
563         for (n=0; s[n]; n++) {
564                 if (escaped)
565                         escaped = false;
566                 else if (s[n] == '\\')
567                         escaped = true;
568                 else if (strchr(reject, s[n]))
569                         break;
570         }
571
572         /* if s ends in \, return index of previous char */
573         return n - escaped;
574 }
575
576 /* Split a string into words. */
577 const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
578         const char *current;
579
580         current = *state;
581
582         if (!*current) {
583                 assert(**state == '\0');
584                 return NULL;
585         }
586
587         current += strspn(current, separator);
588         if (!*current) {
589                 *state = current;
590                 return NULL;
591         }
592
593         if (quoted && strchr("\'\"", *current)) {
594                 char quotechars[2] = {*current, '\0'};
595
596                 *l = strcspn_escaped(current + 1, quotechars);
597                 if (current[*l + 1] == '\0' || current[*l + 1] != quotechars[0] ||
598                     (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
599                         /* right quote missing or garbage at the end */
600                         *state = current;
601                         return NULL;
602                 }
603                 *state = current++ + *l + 2;
604         } else if (quoted) {
605                 *l = strcspn_escaped(current, separator);
606                 if (current[*l] && !strchr(separator, current[*l])) {
607                         /* unfinished escape */
608                         *state = current;
609                         return NULL;
610                 }
611                 *state = current + *l;
612         } else {
613                 *l = strcspn(current, separator);
614                 *state = current + *l;
615         }
616
617         return current;
618 }
619
620 int fchmod_umask(int fd, mode_t m) {
621         mode_t u;
622         int r;
623
624         u = umask(0777);
625         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
626         umask(u);
627
628         return r;
629 }
630
631 char *truncate_nl(char *s) {
632         assert(s);
633
634         s[strcspn(s, NEWLINE)] = 0;
635         return s;
636 }
637
638 char *strnappend(const char *s, const char *suffix, size_t b) {
639         size_t a;
640         char *r;
641
642         if (!s && !suffix)
643                 return strdup("");
644
645         if (!s)
646                 return strndup(suffix, b);
647
648         if (!suffix)
649                 return strdup(s);
650
651         assert(s);
652         assert(suffix);
653
654         a = strlen(s);
655         if (b > ((size_t) -1) - a)
656                 return NULL;
657
658         r = new(char, a+b+1);
659         if (!r)
660                 return NULL;
661
662         memcpy(r, s, a);
663         memcpy(r+a, suffix, b);
664         r[a+b] = 0;
665
666         return r;
667 }
668
669 char *strappend(const char *s, const char *suffix) {
670         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
671 }
672
673 int readlinkat_malloc(int fd, const char *p, char **ret) {
674         size_t l = 100;
675         int r;
676
677         assert(p);
678         assert(ret);
679
680         for (;;) {
681                 char *c;
682                 ssize_t n;
683
684                 c = new(char, l);
685                 if (!c)
686                         return -ENOMEM;
687
688                 n = readlinkat(fd, p, c, l-1);
689                 if (n < 0) {
690                         r = -errno;
691                         free(c);
692                         return r;
693                 }
694
695                 if ((size_t) n < l-1) {
696                         c[n] = 0;
697                         *ret = c;
698                         return 0;
699                 }
700
701                 free(c);
702                 l *= 2;
703         }
704 }
705
706 int readlink_malloc(const char *p, char **ret) {
707         return readlinkat_malloc(AT_FDCWD, p, ret);
708 }
709
710 int readlink_value(const char *p, char **ret) {
711         _cleanup_free_ char *link = NULL;
712         char *value;
713         int r;
714
715         r = readlink_malloc(p, &link);
716         if (r < 0)
717                 return r;
718
719         value = basename(link);
720         if (!value)
721                 return -ENOENT;
722
723         value = strdup(value);
724         if (!value)
725                 return -ENOMEM;
726
727         *ret = value;
728
729         return 0;
730 }
731
732 int readlink_and_make_absolute(const char *p, char **r) {
733         _cleanup_free_ char *target = NULL;
734         char *k;
735         int j;
736
737         assert(p);
738         assert(r);
739
740         j = readlink_malloc(p, &target);
741         if (j < 0)
742                 return j;
743
744         k = file_in_same_dir(p, target);
745         if (!k)
746                 return -ENOMEM;
747
748         *r = k;
749         return 0;
750 }
751
752 int readlink_and_canonicalize(const char *p, char **r) {
753         char *t, *s;
754         int j;
755
756         assert(p);
757         assert(r);
758
759         j = readlink_and_make_absolute(p, &t);
760         if (j < 0)
761                 return j;
762
763         s = canonicalize_file_name(t);
764         if (s) {
765                 free(t);
766                 *r = s;
767         } else
768                 *r = t;
769
770         path_kill_slashes(*r);
771
772         return 0;
773 }
774
775 char *strstrip(char *s) {
776         char *e;
777
778         /* Drops trailing whitespace. Modifies the string in
779          * place. Returns pointer to first non-space character */
780
781         s += strspn(s, WHITESPACE);
782
783         for (e = strchr(s, 0); e > s; e --)
784                 if (!strchr(WHITESPACE, e[-1]))
785                         break;
786
787         *e = 0;
788
789         return s;
790 }
791
792 /// UNNEEDED by elogind
793 #if 0
794 char *delete_chars(char *s, const char *bad) {
795         char *f, *t;
796
797         /* Drops all whitespace, regardless where in the string */
798
799         for (f = s, t = s; *f; f++) {
800                 if (strchr(bad, *f))
801                         continue;
802
803                 *(t++) = *f;
804         }
805
806         *t = 0;
807
808         return s;
809 }
810 #endif // 0
811
812 char *file_in_same_dir(const char *path, const char *filename) {
813         char *e, *ret;
814         size_t k;
815
816         assert(path);
817         assert(filename);
818
819         /* This removes the last component of path and appends
820          * filename, unless the latter is absolute anyway or the
821          * former isn't */
822
823         if (path_is_absolute(filename))
824                 return strdup(filename);
825
826         e = strrchr(path, '/');
827         if (!e)
828                 return strdup(filename);
829
830         k = strlen(filename);
831         ret = new(char, (e + 1 - path) + k + 1);
832         if (!ret)
833                 return NULL;
834
835         memcpy(mempcpy(ret, path, e + 1 - path), filename, k + 1);
836         return ret;
837 }
838
839 int rmdir_parents(const char *path, const char *stop) {
840         size_t l;
841         int r = 0;
842
843         assert(path);
844         assert(stop);
845
846         l = strlen(path);
847
848         /* Skip trailing slashes */
849         while (l > 0 && path[l-1] == '/')
850                 l--;
851
852         while (l > 0) {
853                 char *t;
854
855                 /* Skip last component */
856                 while (l > 0 && path[l-1] != '/')
857                         l--;
858
859                 /* Skip trailing slashes */
860                 while (l > 0 && path[l-1] == '/')
861                         l--;
862
863                 if (l <= 0)
864                         break;
865
866                 if (!(t = strndup(path, l)))
867                         return -ENOMEM;
868
869                 if (path_startswith(stop, t)) {
870                         free(t);
871                         return 0;
872                 }
873
874                 r = rmdir(t);
875                 free(t);
876
877                 if (r < 0)
878                         if (errno != ENOENT)
879                                 return -errno;
880         }
881
882         return 0;
883 }
884
885 char hexchar(int x) {
886         static const char table[16] = "0123456789abcdef";
887
888         return table[x & 15];
889 }
890
891 int unhexchar(char c) {
892
893         if (c >= '0' && c <= '9')
894                 return c - '0';
895
896         if (c >= 'a' && c <= 'f')
897                 return c - 'a' + 10;
898
899         if (c >= 'A' && c <= 'F')
900                 return c - 'A' + 10;
901
902         return -EINVAL;
903 }
904
905 char *hexmem(const void *p, size_t l) {
906         char *r, *z;
907         const uint8_t *x;
908
909         z = r = malloc(l * 2 + 1);
910         if (!r)
911                 return NULL;
912
913         for (x = p; x < (const uint8_t*) p + l; x++) {
914                 *(z++) = hexchar(*x >> 4);
915                 *(z++) = hexchar(*x & 15);
916         }
917
918         *z = 0;
919         return r;
920 }
921
922 void *unhexmem(const char *p, size_t l) {
923         uint8_t *r, *z;
924         const char *x;
925
926         assert(p);
927
928         z = r = malloc((l + 1) / 2 + 1);
929         if (!r)
930                 return NULL;
931
932         for (x = p; x < p + l; x += 2) {
933                 int a, b;
934
935                 a = unhexchar(x[0]);
936                 if (x+1 < p + l)
937                         b = unhexchar(x[1]);
938                 else
939                         b = 0;
940
941                 *(z++) = (uint8_t) a << 4 | (uint8_t) b;
942         }
943
944         *z = 0;
945         return r;
946 }
947
948 char octchar(int x) {
949         return '0' + (x & 7);
950 }
951
952 int unoctchar(char c) {
953
954         if (c >= '0' && c <= '7')
955                 return c - '0';
956
957         return -EINVAL;
958 }
959
960 char decchar(int x) {
961         return '0' + (x % 10);
962 }
963
964 int undecchar(char c) {
965
966         if (c >= '0' && c <= '9')
967                 return c - '0';
968
969         return -EINVAL;
970 }
971
972 char *cescape(const char *s) {
973         char *r, *t;
974         const char *f;
975
976         assert(s);
977
978         /* Does C style string escaping. May be reversed with
979          * cunescape(). */
980
981         r = new(char, strlen(s)*4 + 1);
982         if (!r)
983                 return NULL;
984
985         for (f = s, t = r; *f; f++)
986                 t += cescape_char(*f, t);
987
988         *t = 0;
989
990         return r;
991 }
992
993 static int cunescape_one(const char *p, size_t length, char *ret, uint32_t *ret_unicode) {
994         int r = 1;
995
996         assert(p);
997         assert(*p);
998         assert(ret);
999
1000         /* Unescapes C style. Returns the unescaped character in ret,
1001          * unless we encountered a \u sequence in which case the full
1002          * unicode character is returned in ret_unicode, instead. */
1003
1004         if (length != (size_t) -1 && length < 1)
1005                 return -EINVAL;
1006
1007         switch (p[0]) {
1008
1009         case 'a':
1010                 *ret = '\a';
1011                 break;
1012         case 'b':
1013                 *ret = '\b';
1014                 break;
1015         case 'f':
1016                 *ret = '\f';
1017                 break;
1018         case 'n':
1019                 *ret = '\n';
1020                 break;
1021         case 'r':
1022                 *ret = '\r';
1023                 break;
1024         case 't':
1025                 *ret = '\t';
1026                 break;
1027         case 'v':
1028                 *ret = '\v';
1029                 break;
1030         case '\\':
1031                 *ret = '\\';
1032                 break;
1033         case '"':
1034                 *ret = '"';
1035                 break;
1036         case '\'':
1037                 *ret = '\'';
1038                 break;
1039
1040         case 's':
1041                 /* This is an extension of the XDG syntax files */
1042                 *ret = ' ';
1043                 break;
1044
1045         case 'x': {
1046                 /* hexadecimal encoding */
1047                 int a, b;
1048
1049                 if (length != (size_t) -1 && length < 3)
1050                         return -EINVAL;
1051
1052                 a = unhexchar(p[1]);
1053                 if (a < 0)
1054                         return -EINVAL;
1055
1056                 b = unhexchar(p[2]);
1057                 if (b < 0)
1058                         return -EINVAL;
1059
1060                 /* Don't allow NUL bytes */
1061                 if (a == 0 && b == 0)
1062                         return -EINVAL;
1063
1064                 *ret = (char) ((a << 4U) | b);
1065                 r = 3;
1066                 break;
1067         }
1068
1069         case 'u': {
1070                 /* C++11 style 16bit unicode */
1071
1072                 int a[4];
1073                 unsigned i;
1074                 uint32_t c;
1075
1076                 if (length != (size_t) -1 && length < 5)
1077                         return -EINVAL;
1078
1079                 for (i = 0; i < 4; i++) {
1080                         a[i] = unhexchar(p[1 + i]);
1081                         if (a[i] < 0)
1082                                 return a[i];
1083                 }
1084
1085                 c = ((uint32_t) a[0] << 12U) | ((uint32_t) a[1] << 8U) | ((uint32_t) a[2] << 4U) | (uint32_t) a[3];
1086
1087                 /* Don't allow 0 chars */
1088                 if (c == 0)
1089                         return -EINVAL;
1090
1091                 if (c < 128)
1092                         *ret = c;
1093                 else {
1094                         if (!ret_unicode)
1095                                 return -EINVAL;
1096
1097                         *ret = 0;
1098                         *ret_unicode = c;
1099                 }
1100
1101                 r = 5;
1102                 break;
1103         }
1104
1105         case 'U': {
1106                 /* C++11 style 32bit unicode */
1107
1108                 int a[8];
1109                 unsigned i;
1110                 uint32_t c;
1111
1112                 if (length != (size_t) -1 && length < 9)
1113                         return -EINVAL;
1114
1115                 for (i = 0; i < 8; i++) {
1116                         a[i] = unhexchar(p[1 + i]);
1117                         if (a[i] < 0)
1118                                 return a[i];
1119                 }
1120
1121                 c = ((uint32_t) a[0] << 28U) | ((uint32_t) a[1] << 24U) | ((uint32_t) a[2] << 20U) | ((uint32_t) a[3] << 16U) |
1122                     ((uint32_t) a[4] << 12U) | ((uint32_t) a[5] <<  8U) | ((uint32_t) a[6] <<  4U) |  (uint32_t) a[7];
1123
1124                 /* Don't allow 0 chars */
1125                 if (c == 0)
1126                         return -EINVAL;
1127
1128                 /* Don't allow invalid code points */
1129                 if (!unichar_is_valid(c))
1130                         return -EINVAL;
1131
1132                 if (c < 128)
1133                         *ret = c;
1134                 else {
1135                         if (!ret_unicode)
1136                                 return -EINVAL;
1137
1138                         *ret = 0;
1139                         *ret_unicode = c;
1140                 }
1141
1142                 r = 9;
1143                 break;
1144         }
1145
1146         case '0':
1147         case '1':
1148         case '2':
1149         case '3':
1150         case '4':
1151         case '5':
1152         case '6':
1153         case '7': {
1154                 /* octal encoding */
1155                 int a, b, c;
1156                 uint32_t m;
1157
1158                 if (length != (size_t) -1 && length < 3)
1159                         return -EINVAL;
1160
1161                 a = unoctchar(p[0]);
1162                 if (a < 0)
1163                         return -EINVAL;
1164
1165                 b = unoctchar(p[1]);
1166                 if (b < 0)
1167                         return -EINVAL;
1168
1169                 c = unoctchar(p[2]);
1170                 if (c < 0)
1171                         return -EINVAL;
1172
1173                 /* don't allow NUL bytes */
1174                 if (a == 0 && b == 0 && c == 0)
1175                         return -EINVAL;
1176
1177                 /* Don't allow bytes above 255 */
1178                 m = ((uint32_t) a << 6U) | ((uint32_t) b << 3U) | (uint32_t) c;
1179                 if (m > 255)
1180                         return -EINVAL;
1181
1182                 *ret = m;
1183                 r = 3;
1184                 break;
1185         }
1186
1187         default:
1188                 return -EINVAL;
1189         }
1190
1191         return r;
1192 }
1193
1194 int cunescape_length_with_prefix(const char *s, size_t length, const char *prefix, UnescapeFlags flags, char **ret) {
1195         char *r, *t;
1196         const char *f;
1197         size_t pl;
1198
1199         assert(s);
1200         assert(ret);
1201
1202         /* Undoes C style string escaping, and optionally prefixes it. */
1203
1204         pl = prefix ? strlen(prefix) : 0;
1205
1206         r = new(char, pl+length+1);
1207         if (!r)
1208                 return -ENOMEM;
1209
1210         if (prefix)
1211                 memcpy(r, prefix, pl);
1212
1213         for (f = s, t = r + pl; f < s + length; f++) {
1214                 size_t remaining;
1215                 uint32_t u;
1216                 char c;
1217                 int k;
1218
1219                 remaining = s + length - f;
1220                 assert(remaining > 0);
1221
1222                 if (*f != '\\') {
1223                         /* A literal literal, copy verbatim */
1224                         *(t++) = *f;
1225                         continue;
1226                 }
1227
1228                 if (remaining == 1) {
1229                         if (flags & UNESCAPE_RELAX) {
1230                                 /* A trailing backslash, copy verbatim */
1231                                 *(t++) = *f;
1232                                 continue;
1233                         }
1234
1235                         free(r);
1236                         return -EINVAL;
1237                 }
1238
1239                 k = cunescape_one(f + 1, remaining - 1, &c, &u);
1240                 if (k < 0) {
1241                         if (flags & UNESCAPE_RELAX) {
1242                                 /* Invalid escape code, let's take it literal then */
1243                                 *(t++) = '\\';
1244                                 continue;
1245                         }
1246
1247                         free(r);
1248                         return k;
1249                 }
1250
1251                 if (c != 0)
1252                         /* Non-Unicode? Let's encode this directly */
1253                         *(t++) = c;
1254                 else
1255                         /* Unicode? Then let's encode this in UTF-8 */
1256                         t += utf8_encode_unichar(t, u);
1257
1258                 f += k;
1259         }
1260
1261         *t = 0;
1262
1263         *ret = r;
1264         return t - r;
1265 }
1266
1267 int cunescape_length(const char *s, size_t length, UnescapeFlags flags, char **ret) {
1268         return cunescape_length_with_prefix(s, length, NULL, flags, ret);
1269 }
1270
1271 int cunescape(const char *s, UnescapeFlags flags, char **ret) {
1272         return cunescape_length(s, strlen(s), flags, ret);
1273 }
1274
1275 char *xescape(const char *s, const char *bad) {
1276         char *r, *t;
1277         const char *f;
1278
1279         /* Escapes all chars in bad, in addition to \ and all special
1280          * chars, in \xFF style escaping. May be reversed with
1281          * cunescape(). */
1282
1283         r = new(char, strlen(s) * 4 + 1);
1284         if (!r)
1285                 return NULL;
1286
1287         for (f = s, t = r; *f; f++) {
1288
1289                 if ((*f < ' ') || (*f >= 127) ||
1290                     (*f == '\\') || strchr(bad, *f)) {
1291                         *(t++) = '\\';
1292                         *(t++) = 'x';
1293                         *(t++) = hexchar(*f >> 4);
1294                         *(t++) = hexchar(*f);
1295                 } else
1296                         *(t++) = *f;
1297         }
1298
1299         *t = 0;
1300
1301         return r;
1302 }
1303
1304 char *ascii_strlower(char *t) {
1305         char *p;
1306
1307         assert(t);
1308
1309         for (p = t; *p; p++)
1310                 if (*p >= 'A' && *p <= 'Z')
1311                         *p = *p - 'A' + 'a';
1312
1313         return t;
1314 }
1315
1316 _pure_ static bool hidden_file_allow_backup(const char *filename) {
1317         assert(filename);
1318
1319         return
1320                 filename[0] == '.' ||
1321                 streq(filename, "lost+found") ||
1322                 streq(filename, "aquota.user") ||
1323                 streq(filename, "aquota.group") ||
1324                 endswith(filename, ".rpmnew") ||
1325                 endswith(filename, ".rpmsave") ||
1326                 endswith(filename, ".rpmorig") ||
1327                 endswith(filename, ".dpkg-old") ||
1328                 endswith(filename, ".dpkg-new") ||
1329                 endswith(filename, ".dpkg-tmp") ||
1330                 endswith(filename, ".dpkg-dist") ||
1331                 endswith(filename, ".dpkg-bak") ||
1332                 endswith(filename, ".dpkg-backup") ||
1333                 endswith(filename, ".dpkg-remove") ||
1334                 endswith(filename, ".swp");
1335 }
1336
1337 bool hidden_file(const char *filename) {
1338         assert(filename);
1339
1340         if (endswith(filename, "~"))
1341                 return true;
1342
1343         return hidden_file_allow_backup(filename);
1344 }
1345
1346 int fd_nonblock(int fd, bool nonblock) {
1347         int flags, nflags;
1348
1349         assert(fd >= 0);
1350
1351         flags = fcntl(fd, F_GETFL, 0);
1352         if (flags < 0)
1353                 return -errno;
1354
1355         if (nonblock)
1356                 nflags = flags | O_NONBLOCK;
1357         else
1358                 nflags = flags & ~O_NONBLOCK;
1359
1360         if (nflags == flags)
1361                 return 0;
1362
1363         if (fcntl(fd, F_SETFL, nflags) < 0)
1364                 return -errno;
1365
1366         return 0;
1367 }
1368
1369 int fd_cloexec(int fd, bool cloexec) {
1370         int flags, nflags;
1371
1372         assert(fd >= 0);
1373
1374         flags = fcntl(fd, F_GETFD, 0);
1375         if (flags < 0)
1376                 return -errno;
1377
1378         if (cloexec)
1379                 nflags = flags | FD_CLOEXEC;
1380         else
1381                 nflags = flags & ~FD_CLOEXEC;
1382
1383         if (nflags == flags)
1384                 return 0;
1385
1386         if (fcntl(fd, F_SETFD, nflags) < 0)
1387                 return -errno;
1388
1389         return 0;
1390 }
1391
1392 _pure_ static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1393         unsigned i;
1394
1395         assert(n_fdset == 0 || fdset);
1396
1397         for (i = 0; i < n_fdset; i++)
1398                 if (fdset[i] == fd)
1399                         return true;
1400
1401         return false;
1402 }
1403
1404 int close_all_fds(const int except[], unsigned n_except) {
1405         _cleanup_closedir_ DIR *d = NULL;
1406         struct dirent *de;
1407         int r = 0;
1408
1409         assert(n_except == 0 || except);
1410
1411         d = opendir("/proc/self/fd");
1412         if (!d) {
1413                 int fd;
1414                 struct rlimit rl;
1415
1416                 /* When /proc isn't available (for example in chroots)
1417                  * the fallback is brute forcing through the fd
1418                  * table */
1419
1420                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1421                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1422
1423                         if (fd_in_set(fd, except, n_except))
1424                                 continue;
1425
1426                         if (close_nointr(fd) < 0)
1427                                 if (errno != EBADF && r == 0)
1428                                         r = -errno;
1429                 }
1430
1431                 return r;
1432         }
1433
1434         while ((de = readdir(d))) {
1435                 int fd = -1;
1436
1437                 if (hidden_file(de->d_name))
1438                         continue;
1439
1440                 if (safe_atoi(de->d_name, &fd) < 0)
1441                         /* Let's better ignore this, just in case */
1442                         continue;
1443
1444                 if (fd < 3)
1445                         continue;
1446
1447                 if (fd == dirfd(d))
1448                         continue;
1449
1450                 if (fd_in_set(fd, except, n_except))
1451                         continue;
1452
1453                 if (close_nointr(fd) < 0) {
1454                         /* Valgrind has its own FD and doesn't want to have it closed */
1455                         if (errno != EBADF && r == 0)
1456                                 r = -errno;
1457                 }
1458         }
1459
1460         return r;
1461 }
1462
1463 bool chars_intersect(const char *a, const char *b) {
1464         const char *p;
1465
1466         /* Returns true if any of the chars in a are in b. */
1467         for (p = a; *p; p++)
1468                 if (strchr(b, *p))
1469                         return true;
1470
1471         return false;
1472 }
1473
1474 bool fstype_is_network(const char *fstype) {
1475         static const char table[] =
1476                 "afs\0"
1477                 "cifs\0"
1478                 "smbfs\0"
1479                 "sshfs\0"
1480                 "ncpfs\0"
1481                 "ncp\0"
1482                 "nfs\0"
1483                 "nfs4\0"
1484                 "gfs\0"
1485                 "gfs2\0"
1486                 "glusterfs\0";
1487
1488         const char *x;
1489
1490         x = startswith(fstype, "fuse.");
1491         if (x)
1492                 fstype = x;
1493
1494         return nulstr_contains(table, fstype);
1495 }
1496
1497 int flush_fd(int fd) {
1498         struct pollfd pollfd = {
1499                 .fd = fd,
1500                 .events = POLLIN,
1501         };
1502
1503         for (;;) {
1504                 char buf[LINE_MAX];
1505                 ssize_t l;
1506                 int r;
1507
1508                 r = poll(&pollfd, 1, 0);
1509                 if (r < 0) {
1510                         if (errno == EINTR)
1511                                 continue;
1512
1513                         return -errno;
1514
1515                 } else if (r == 0)
1516                         return 0;
1517
1518                 l = read(fd, buf, sizeof(buf));
1519                 if (l < 0) {
1520
1521                         if (errno == EINTR)
1522                                 continue;
1523
1524                         if (errno == EAGAIN)
1525                                 return 0;
1526
1527                         return -errno;
1528                 } else if (l == 0)
1529                         return 0;
1530         }
1531 }
1532
1533 void safe_close_pair(int p[]) {
1534         assert(p);
1535
1536         if (p[0] == p[1]) {
1537                 /* Special case pairs which use the same fd in both
1538                  * directions... */
1539                 p[0] = p[1] = safe_close(p[0]);
1540                 return;
1541         }
1542
1543         p[0] = safe_close(p[0]);
1544         p[1] = safe_close(p[1]);
1545 }
1546
1547 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
1548         uint8_t *p = buf;
1549         ssize_t n = 0;
1550
1551         assert(fd >= 0);
1552         assert(buf);
1553
1554         while (nbytes > 0) {
1555                 ssize_t k;
1556
1557                 k = read(fd, p, nbytes);
1558                 if (k < 0) {
1559                         if (errno == EINTR)
1560                                 continue;
1561
1562                         if (errno == EAGAIN && do_poll) {
1563
1564                                 /* We knowingly ignore any return value here,
1565                                  * and expect that any error/EOF is reported
1566                                  * via read() */
1567
1568                                 fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
1569                                 continue;
1570                         }
1571
1572                         return n > 0 ? n : -errno;
1573                 }
1574
1575                 if (k == 0)
1576                         return n;
1577
1578                 p += k;
1579                 nbytes -= k;
1580                 n += k;
1581         }
1582
1583         return n;
1584 }
1585
1586 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
1587         ssize_t n;
1588
1589         n = loop_read(fd, buf, nbytes, do_poll);
1590         if (n < 0)
1591                 return n;
1592         if ((size_t) n != nbytes)
1593                 return -EIO;
1594         return 0;
1595 }
1596
1597 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
1598         const uint8_t *p = buf;
1599
1600         assert(fd >= 0);
1601         assert(buf);
1602
1603         errno = 0;
1604
1605         do {
1606                 ssize_t k;
1607
1608                 k = write(fd, p, nbytes);
1609                 if (k < 0) {
1610                         if (errno == EINTR)
1611                                 continue;
1612
1613                         if (errno == EAGAIN && do_poll) {
1614                                 /* We knowingly ignore any return value here,
1615                                  * and expect that any error/EOF is reported
1616                                  * via write() */
1617
1618                                 fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
1619                                 continue;
1620                         }
1621
1622                         return -errno;
1623                 }
1624
1625                 if (nbytes > 0 && k == 0) /* Can't really happen */
1626                         return -EIO;
1627
1628                 p += k;
1629                 nbytes -= k;
1630         } while (nbytes > 0);
1631
1632         return 0;
1633 }
1634
1635 int parse_size(const char *t, off_t base, off_t *size) {
1636
1637         /* Soo, sometimes we want to parse IEC binary suffixes, and
1638          * sometimes SI decimal suffixes. This function can parse
1639          * both. Which one is the right way depends on the
1640          * context. Wikipedia suggests that SI is customary for
1641          * hardware metrics and network speeds, while IEC is
1642          * customary for most data sizes used by software and volatile
1643          * (RAM) memory. Hence be careful which one you pick!
1644          *
1645          * In either case we use just K, M, G as suffix, and not Ki,
1646          * Mi, Gi or so (as IEC would suggest). That's because that's
1647          * frickin' ugly. But this means you really need to make sure
1648          * to document which base you are parsing when you use this
1649          * call. */
1650
1651         struct table {
1652                 const char *suffix;
1653                 unsigned long long factor;
1654         };
1655
1656         static const struct table iec[] = {
1657                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1658                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
1659                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
1660                 { "G", 1024ULL*1024ULL*1024ULL },
1661                 { "M", 1024ULL*1024ULL },
1662                 { "K", 1024ULL },
1663                 { "B", 1 },
1664                 { "", 1 },
1665         };
1666
1667         static const struct table si[] = {
1668                 { "E", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1669                 { "P", 1000ULL*1000ULL*1000ULL*1000ULL*1000ULL },
1670                 { "T", 1000ULL*1000ULL*1000ULL*1000ULL },
1671                 { "G", 1000ULL*1000ULL*1000ULL },
1672                 { "M", 1000ULL*1000ULL },
1673                 { "K", 1000ULL },
1674                 { "B", 1 },
1675                 { "", 1 },
1676         };
1677
1678         const struct table *table;
1679         const char *p;
1680         unsigned long long r = 0;
1681         unsigned n_entries, start_pos = 0;
1682
1683         assert(t);
1684         assert(base == 1000 || base == 1024);
1685         assert(size);
1686
1687         if (base == 1000) {
1688                 table = si;
1689                 n_entries = ELEMENTSOF(si);
1690         } else {
1691                 table = iec;
1692                 n_entries = ELEMENTSOF(iec);
1693         }
1694
1695         p = t;
1696         do {
1697                 long long l;
1698                 unsigned long long l2;
1699                 double frac = 0;
1700                 char *e;
1701                 unsigned i;
1702
1703                 errno = 0;
1704                 l = strtoll(p, &e, 10);
1705
1706                 if (errno > 0)
1707                         return -errno;
1708
1709                 if (l < 0)
1710                         return -ERANGE;
1711
1712                 if (e == p)
1713                         return -EINVAL;
1714
1715                 if (*e == '.') {
1716                         e++;
1717                         if (*e >= '0' && *e <= '9') {
1718                                 char *e2;
1719
1720                                 /* strotoull itself would accept space/+/- */
1721                                 l2 = strtoull(e, &e2, 10);
1722
1723                                 if (errno == ERANGE)
1724                                         return -errno;
1725
1726                                 /* Ignore failure. E.g. 10.M is valid */
1727                                 frac = l2;
1728                                 for (; e < e2; e++)
1729                                         frac /= 10;
1730                         }
1731                 }
1732
1733                 e += strspn(e, WHITESPACE);
1734
1735                 for (i = start_pos; i < n_entries; i++)
1736                         if (startswith(e, table[i].suffix)) {
1737                                 unsigned long long tmp;
1738                                 if ((unsigned long long) l + (frac > 0) > ULLONG_MAX / table[i].factor)
1739                                         return -ERANGE;
1740                                 tmp = l * table[i].factor + (unsigned long long) (frac * table[i].factor);
1741                                 if (tmp > ULLONG_MAX - r)
1742                                         return -ERANGE;
1743
1744                                 r += tmp;
1745                                 if ((unsigned long long) (off_t) r != r)
1746                                         return -ERANGE;
1747
1748                                 p = e + strlen(table[i].suffix);
1749
1750                                 start_pos = i + 1;
1751                                 break;
1752                         }
1753
1754                 if (i >= n_entries)
1755                         return -EINVAL;
1756
1757         } while (*p);
1758
1759         *size = r;
1760
1761         return 0;
1762 }
1763
1764 bool is_device_path(const char *path) {
1765
1766         /* Returns true on paths that refer to a device, either in
1767          * sysfs or in /dev */
1768
1769         return
1770                 path_startswith(path, "/dev/") ||
1771                 path_startswith(path, "/sys/");
1772 }
1773
1774 int dir_is_empty(const char *path) {
1775         _cleanup_closedir_ DIR *d;
1776
1777         d = opendir(path);
1778         if (!d)
1779                 return -errno;
1780
1781         for (;;) {
1782                 struct dirent *de;
1783
1784                 errno = 0;
1785                 de = readdir(d);
1786                 if (!de && errno != 0)
1787                         return -errno;
1788
1789                 if (!de)
1790                         return 1;
1791
1792                 if (!hidden_file(de->d_name))
1793                         return 0;
1794         }
1795 }
1796
1797 char* dirname_malloc(const char *path) {
1798         char *d, *dir, *dir2;
1799
1800         d = strdup(path);
1801         if (!d)
1802                 return NULL;
1803         dir = dirname(d);
1804         assert(dir);
1805
1806         if (dir != d) {
1807                 dir2 = strdup(dir);
1808                 free(d);
1809                 return dir2;
1810         }
1811
1812         return dir;
1813 }
1814
1815 void rename_process(const char name[8]) {
1816         assert(name);
1817
1818         /* This is a like a poor man's setproctitle(). It changes the
1819          * comm field, argv[0], and also the glibc's internally used
1820          * name of the process. For the first one a limit of 16 chars
1821          * applies, to the second one usually one of 10 (i.e. length
1822          * of "/sbin/init"), to the third one one of 7 (i.e. length of
1823          * "systemd"). If you pass a longer string it will be
1824          * truncated */
1825
1826         prctl(PR_SET_NAME, name);
1827
1828         if (program_invocation_name)
1829                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
1830
1831         if (saved_argc > 0) {
1832                 int i;
1833
1834                 if (saved_argv[0])
1835                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
1836
1837                 for (i = 1; i < saved_argc; i++) {
1838                         if (!saved_argv[i])
1839                                 break;
1840
1841                         memzero(saved_argv[i], strlen(saved_argv[i]));
1842                 }
1843         }
1844 }
1845
1846 char *lookup_uid(uid_t uid) {
1847         long bufsize;
1848         char *name;
1849         _cleanup_free_ char *buf = NULL;
1850         struct passwd pwbuf, *pw = NULL;
1851
1852         /* Shortcut things to avoid NSS lookups */
1853         if (uid == 0)
1854                 return strdup("root");
1855
1856         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
1857         if (bufsize <= 0)
1858                 bufsize = 4096;
1859
1860         buf = malloc(bufsize);
1861         if (!buf)
1862                 return NULL;
1863
1864         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
1865                 return strdup(pw->pw_name);
1866
1867         if (asprintf(&name, UID_FMT, uid) < 0)
1868                 return NULL;
1869
1870         return name;
1871 }
1872
1873 char* getlogname_malloc(void) {
1874         uid_t uid;
1875         struct stat st;
1876
1877         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
1878                 uid = st.st_uid;
1879         else
1880                 uid = getuid();
1881
1882         return lookup_uid(uid);
1883 }
1884
1885 char *getusername_malloc(void) {
1886         const char *e;
1887
1888         e = getenv("USER");
1889         if (e)
1890                 return strdup(e);
1891
1892         return lookup_uid(getuid());
1893 }
1894
1895 bool is_temporary_fs(const struct statfs *s) {
1896         assert(s);
1897
1898         return F_TYPE_EQUAL(s->f_type, TMPFS_MAGIC) ||
1899                F_TYPE_EQUAL(s->f_type, RAMFS_MAGIC);
1900 }
1901
1902 int fd_is_temporary_fs(int fd) {
1903         struct statfs s;
1904
1905         if (fstatfs(fd, &s) < 0)
1906                 return -errno;
1907
1908         return is_temporary_fs(&s);
1909 }
1910
1911 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
1912         assert(path);
1913
1914         /* Under the assumption that we are running privileged we
1915          * first change the access mode and only then hand out
1916          * ownership to avoid a window where access is too open. */
1917
1918         if (mode != MODE_INVALID)
1919                 if (chmod(path, mode) < 0)
1920                         return -errno;
1921
1922         if (uid != UID_INVALID || gid != GID_INVALID)
1923                 if (chown(path, uid, gid) < 0)
1924                         return -errno;
1925
1926         return 0;
1927 }
1928
1929 /// UNNEEDED by elogind
1930 #if 0
1931 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
1932         assert(fd >= 0);
1933
1934         /* Under the assumption that we are running privileged we
1935          * first change the access mode and only then hand out
1936          * ownership to avoid a window where access is too open. */
1937
1938         if (mode != MODE_INVALID)
1939                 if (fchmod(fd, mode) < 0)
1940                         return -errno;
1941
1942         if (uid != UID_INVALID || gid != GID_INVALID)
1943                 if (fchown(fd, uid, gid) < 0)
1944                         return -errno;
1945
1946         return 0;
1947 }
1948 #endif // 0
1949
1950 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
1951         cpu_set_t *r;
1952         unsigned n = 1024;
1953
1954         /* Allocates the cpuset in the right size */
1955
1956         for (;;) {
1957                 if (!(r = CPU_ALLOC(n)))
1958                         return NULL;
1959
1960                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
1961                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
1962
1963                         if (ncpus)
1964                                 *ncpus = n;
1965
1966                         return r;
1967                 }
1968
1969                 CPU_FREE(r);
1970
1971                 if (errno != EINVAL)
1972                         return NULL;
1973
1974                 n *= 2;
1975         }
1976 }
1977
1978 int files_same(const char *filea, const char *fileb) {
1979         struct stat a, b;
1980
1981         if (stat(filea, &a) < 0)
1982                 return -errno;
1983
1984         if (stat(fileb, &b) < 0)
1985                 return -errno;
1986
1987         return a.st_dev == b.st_dev &&
1988                a.st_ino == b.st_ino;
1989 }
1990
1991 int running_in_chroot(void) {
1992         int ret;
1993
1994         ret = files_same("/proc/1/root", "/");
1995         if (ret < 0)
1996                 return ret;
1997
1998         return ret == 0;
1999 }
2000
2001 static char *ascii_ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2002         size_t x;
2003         char *r;
2004
2005         assert(s);
2006         assert(percent <= 100);
2007         assert(new_length >= 3);
2008
2009         if (old_length <= 3 || old_length <= new_length)
2010                 return strndup(s, old_length);
2011
2012         r = new0(char, new_length+1);
2013         if (!r)
2014                 return NULL;
2015
2016         x = (new_length * percent) / 100;
2017
2018         if (x > new_length - 3)
2019                 x = new_length - 3;
2020
2021         memcpy(r, s, x);
2022         r[x] = '.';
2023         r[x+1] = '.';
2024         r[x+2] = '.';
2025         memcpy(r + x + 3,
2026                s + old_length - (new_length - x - 3),
2027                new_length - x - 3);
2028
2029         return r;
2030 }
2031
2032 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
2033         size_t x;
2034         char *e;
2035         const char *i, *j;
2036         unsigned k, len, len2;
2037
2038         assert(s);
2039         assert(percent <= 100);
2040         assert(new_length >= 3);
2041
2042         /* if no multibyte characters use ascii_ellipsize_mem for speed */
2043         if (ascii_is_valid(s))
2044                 return ascii_ellipsize_mem(s, old_length, new_length, percent);
2045
2046         if (old_length <= 3 || old_length <= new_length)
2047                 return strndup(s, old_length);
2048
2049         x = (new_length * percent) / 100;
2050
2051         if (x > new_length - 3)
2052                 x = new_length - 3;
2053
2054         k = 0;
2055         for (i = s; k < x && i < s + old_length; i = utf8_next_char(i)) {
2056                 int c;
2057
2058                 c = utf8_encoded_to_unichar(i);
2059                 if (c < 0)
2060                         return NULL;
2061                 k += unichar_iswide(c) ? 2 : 1;
2062         }
2063
2064         if (k > x) /* last character was wide and went over quota */
2065                 x ++;
2066
2067         for (j = s + old_length; k < new_length && j > i; ) {
2068                 int c;
2069
2070                 j = utf8_prev_char(j);
2071                 c = utf8_encoded_to_unichar(j);
2072                 if (c < 0)
2073                         return NULL;
2074                 k += unichar_iswide(c) ? 2 : 1;
2075         }
2076         assert(i <= j);
2077
2078         /* we don't actually need to ellipsize */
2079         if (i == j)
2080                 return memdup(s, old_length + 1);
2081
2082         /* make space for ellipsis */
2083         j = utf8_next_char(j);
2084
2085         len = i - s;
2086         len2 = s + old_length - j;
2087         e = new(char, len + 3 + len2 + 1);
2088         if (!e)
2089                 return NULL;
2090
2091         /*
2092         printf("old_length=%zu new_length=%zu x=%zu len=%u len2=%u k=%u\n",
2093                old_length, new_length, x, len, len2, k);
2094         */
2095
2096         memcpy(e, s, len);
2097         e[len]   = 0xe2; /* tri-dot ellipsis: … */
2098         e[len + 1] = 0x80;
2099         e[len + 2] = 0xa6;
2100
2101         memcpy(e + len + 3, j, len2 + 1);
2102
2103         return e;
2104 }
2105
2106 char *ellipsize(const char *s, size_t length, unsigned percent) {
2107         return ellipsize_mem(s, strlen(s), length, percent);
2108 }
2109
2110 int touch_file(const char *path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) {
2111         _cleanup_close_ int fd;
2112         int r;
2113
2114         assert(path);
2115
2116         if (parents)
2117                 mkdir_parents(path, 0755);
2118
2119         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, mode > 0 ? mode : 0644);
2120         if (fd < 0)
2121                 return -errno;
2122
2123         if (mode > 0) {
2124                 r = fchmod(fd, mode);
2125                 if (r < 0)
2126                         return -errno;
2127         }
2128
2129         if (uid != UID_INVALID || gid != GID_INVALID) {
2130                 r = fchown(fd, uid, gid);
2131                 if (r < 0)
2132                         return -errno;
2133         }
2134
2135         if (stamp != USEC_INFINITY) {
2136                 struct timespec ts[2];
2137
2138                 timespec_store(&ts[0], stamp);
2139                 ts[1] = ts[0];
2140                 r = futimens(fd, ts);
2141         } else
2142                 r = futimens(fd, NULL);
2143         if (r < 0)
2144                 return -errno;
2145
2146         return 0;
2147 }
2148
2149 int touch(const char *path) {
2150         return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, 0);
2151 }
2152
2153 /// UNNEEDED by elogind
2154 #if 0
2155 static char *unquote(const char *s, const char* quotes) {
2156         size_t l;
2157         assert(s);
2158
2159         /* This is rather stupid, simply removes the heading and
2160          * trailing quotes if there is one. Doesn't care about
2161          * escaping or anything.
2162          *
2163          * DON'T USE THIS FOR NEW CODE ANYMORE!*/
2164
2165         l = strlen(s);
2166         if (l < 2)
2167                 return strdup(s);
2168
2169         if (strchr(quotes, s[0]) && s[l-1] == s[0])
2170                 return strndup(s+1, l-2);
2171
2172         return strdup(s);
2173 }
2174 #endif // 0
2175
2176 noreturn void freeze(void) {
2177
2178         /* Make sure nobody waits for us on a socket anymore */
2179         close_all_fds(NULL, 0);
2180
2181         sync();
2182
2183         for (;;)
2184                 pause();
2185 }
2186
2187 bool null_or_empty(struct stat *st) {
2188         assert(st);
2189
2190         if (S_ISREG(st->st_mode) && st->st_size <= 0)
2191                 return true;
2192
2193         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
2194                 return true;
2195
2196         return false;
2197 }
2198
2199 int null_or_empty_path(const char *fn) {
2200         struct stat st;
2201
2202         assert(fn);
2203
2204         if (stat(fn, &st) < 0)
2205                 return -errno;
2206
2207         return null_or_empty(&st);
2208 }
2209
2210 /// UNNEEDED by elogind
2211 #if 0
2212 int null_or_empty_fd(int fd) {
2213         struct stat st;
2214
2215         assert(fd >= 0);
2216
2217         if (fstat(fd, &st) < 0)
2218                 return -errno;
2219
2220         return null_or_empty(&st);
2221 }
2222 #endif // 0
2223
2224 DIR *xopendirat(int fd, const char *name, int flags) {
2225         int nfd;
2226         DIR *d;
2227
2228         assert(!(flags & O_CREAT));
2229
2230         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags, 0);
2231         if (nfd < 0)
2232                 return NULL;
2233
2234         d = fdopendir(nfd);
2235         if (!d) {
2236                 safe_close(nfd);
2237                 return NULL;
2238         }
2239
2240         return d;
2241 }
2242
2243 /// UNNEEDED by elogind
2244 #if 0
2245 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
2246         _cleanup_free_ char *t = NULL, *u = NULL;
2247         size_t enc_len;
2248
2249         u = unquote(tagvalue, QUOTES);
2250         if (!u)
2251                 return NULL;
2252
2253         enc_len = strlen(u) * 4 + 1;
2254         t = new(char, enc_len);
2255         if (!t)
2256                 return NULL;
2257
2258         if (encode_devnode_name(u, t, enc_len) < 0)
2259                 return NULL;
2260
2261         return strjoin("/dev/disk/by-", by, "/", t, NULL);
2262 }
2263
2264 char *fstab_node_to_udev_node(const char *p) {
2265         assert(p);
2266
2267         if (startswith(p, "LABEL="))
2268                 return tag_to_udev_node(p+6, "label");
2269
2270         if (startswith(p, "UUID="))
2271                 return tag_to_udev_node(p+5, "uuid");
2272
2273         if (startswith(p, "PARTUUID="))
2274                 return tag_to_udev_node(p+9, "partuuid");
2275
2276         if (startswith(p, "PARTLABEL="))
2277                 return tag_to_udev_node(p+10, "partlabel");
2278
2279         return strdup(p);
2280 }
2281 #endif // 0
2282
2283 bool dirent_is_file(const struct dirent *de) {
2284         assert(de);
2285
2286         if (hidden_file(de->d_name))
2287                 return false;
2288
2289         if (de->d_type != DT_REG &&
2290             de->d_type != DT_LNK &&
2291             de->d_type != DT_UNKNOWN)
2292                 return false;
2293
2294         return true;
2295 }
2296
2297 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
2298         assert(de);
2299
2300         if (de->d_type != DT_REG &&
2301             de->d_type != DT_LNK &&
2302             de->d_type != DT_UNKNOWN)
2303                 return false;
2304
2305         if (hidden_file_allow_backup(de->d_name))
2306                 return false;
2307
2308         return endswith(de->d_name, suffix);
2309 }
2310
2311 /// UNNEEDED by elogind
2312 #if 0
2313 static int do_execute(char **directories, usec_t timeout, char *argv[]) {
2314         _cleanup_hashmap_free_free_ Hashmap *pids = NULL;
2315         _cleanup_set_free_free_ Set *seen = NULL;
2316         char **directory;
2317
2318         /* We fork this all off from a child process so that we can
2319          * somewhat cleanly make use of SIGALRM to set a time limit */
2320
2321         (void) reset_all_signal_handlers();
2322         (void) reset_signal_mask();
2323
2324         assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2325
2326         pids = hashmap_new(NULL);
2327         if (!pids)
2328                 return log_oom();
2329
2330         seen = set_new(&string_hash_ops);
2331         if (!seen)
2332                 return log_oom();
2333
2334         STRV_FOREACH(directory, directories) {
2335                 _cleanup_closedir_ DIR *d;
2336                 struct dirent *de;
2337
2338                 d = opendir(*directory);
2339                 if (!d) {
2340                         if (errno == ENOENT)
2341                                 continue;
2342
2343                         return log_error_errno(errno, "Failed to open directory %s: %m", *directory);
2344                 }
2345
2346                 FOREACH_DIRENT(de, d, break) {
2347                         _cleanup_free_ char *path = NULL;
2348                         pid_t pid;
2349                         int r;
2350
2351                         if (!dirent_is_file(de))
2352                                 continue;
2353
2354                         if (set_contains(seen, de->d_name)) {
2355                                 log_debug("%1$s/%2$s skipped (%2$s was already seen).", *directory, de->d_name);
2356                                 continue;
2357                         }
2358
2359                         r = set_put_strdup(seen, de->d_name);
2360                         if (r < 0)
2361                                 return log_oom();
2362
2363                         path = strjoin(*directory, "/", de->d_name, NULL);
2364                         if (!path)
2365                                 return log_oom();
2366
2367                         if (null_or_empty_path(path)) {
2368                                 log_debug("%s is empty (a mask).", path);
2369                                 continue;
2370                         }
2371
2372                         pid = fork();
2373                         if (pid < 0) {
2374                                 log_error_errno(errno, "Failed to fork: %m");
2375                                 continue;
2376                         } else if (pid == 0) {
2377                                 char *_argv[2];
2378
2379                                 assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
2380
2381                                 if (!argv) {
2382                                         _argv[0] = path;
2383                                         _argv[1] = NULL;
2384                                         argv = _argv;
2385                                 } else
2386                                         argv[0] = path;
2387
2388                                 execv(path, argv);
2389                                 return log_error_errno(errno, "Failed to execute %s: %m", path);
2390                         }
2391
2392                         log_debug("Spawned %s as " PID_FMT ".", path, pid);
2393
2394                         r = hashmap_put(pids, UINT_TO_PTR(pid), path);
2395                         if (r < 0)
2396                                 return log_oom();
2397                         path = NULL;
2398                 }
2399         }
2400
2401         /* Abort execution of this process after the timout. We simply
2402          * rely on SIGALRM as default action terminating the process,
2403          * and turn on alarm(). */
2404
2405         if (timeout != USEC_INFINITY)
2406                 alarm((timeout + USEC_PER_SEC - 1) / USEC_PER_SEC);
2407
2408         while (!hashmap_isempty(pids)) {
2409                 _cleanup_free_ char *path = NULL;
2410                 pid_t pid;
2411
2412                 pid = PTR_TO_UINT(hashmap_first_key(pids));
2413                 assert(pid > 0);
2414
2415                 path = hashmap_remove(pids, UINT_TO_PTR(pid));
2416                 assert(path);
2417
2418                 wait_for_terminate_and_warn(path, pid, true);
2419         }
2420
2421         return 0;
2422 }
2423
2424 void execute_directories(const char* const* directories, usec_t timeout, char *argv[]) {
2425         pid_t executor_pid;
2426         int r;
2427         char *name;
2428         char **dirs = (char**) directories;
2429
2430         assert(!strv_isempty(dirs));
2431
2432         name = basename(dirs[0]);
2433         assert(!isempty(name));
2434
2435         /* Executes all binaries in the directories in parallel and waits
2436          * for them to finish. Optionally a timeout is applied. If a file
2437          * with the same name exists in more than one directory, the
2438          * earliest one wins. */
2439
2440         executor_pid = fork();
2441         if (executor_pid < 0) {
2442                 log_error_errno(errno, "Failed to fork: %m");
2443                 return;
2444
2445         } else if (executor_pid == 0) {
2446                 r = do_execute(dirs, timeout, argv);
2447                 _exit(r < 0 ? EXIT_FAILURE : EXIT_SUCCESS);
2448         }
2449
2450         wait_for_terminate_and_warn(name, executor_pid, true);
2451 }
2452 #endif // 0
2453
2454 bool nulstr_contains(const char*nulstr, const char *needle) {
2455         const char *i;
2456
2457         if (!nulstr)
2458                 return false;
2459
2460         NULSTR_FOREACH(i, nulstr)
2461                 if (streq(i, needle))
2462                         return true;
2463
2464         return false;
2465 }
2466
2467 /// UNNEEDED by elogind
2468 #if 0
2469 bool plymouth_running(void) {
2470         return access("/run/plymouth/pid", F_OK) >= 0;
2471 }
2472 #endif // 0
2473
2474 char* strshorten(char *s, size_t l) {
2475         assert(s);
2476
2477         if (l < strlen(s))
2478                 s[l] = 0;
2479
2480         return s;
2481 }
2482
2483 bool machine_name_is_valid(const char *s) {
2484
2485         if (!hostname_is_valid(s))
2486                 return false;
2487
2488         /* Machine names should be useful hostnames, but also be
2489          * useful in unit names, hence we enforce a stricter length
2490          * limitation. */
2491
2492         if (strlen(s) > 64)
2493                 return false;
2494
2495         return true;
2496 }
2497
2498 int pipe_eof(int fd) {
2499         struct pollfd pollfd = {
2500                 .fd = fd,
2501                 .events = POLLIN|POLLHUP,
2502         };
2503
2504         int r;
2505
2506         r = poll(&pollfd, 1, 0);
2507         if (r < 0)
2508                 return -errno;
2509
2510         if (r == 0)
2511                 return 0;
2512
2513         return pollfd.revents & POLLHUP;
2514 }
2515
2516 int fd_wait_for_event(int fd, int event, usec_t t) {
2517
2518         struct pollfd pollfd = {
2519                 .fd = fd,
2520                 .events = event,
2521         };
2522
2523         struct timespec ts;
2524         int r;
2525
2526         r = ppoll(&pollfd, 1, t == USEC_INFINITY ? NULL : timespec_store(&ts, t), NULL);
2527         if (r < 0)
2528                 return -errno;
2529
2530         if (r == 0)
2531                 return 0;
2532
2533         return pollfd.revents;
2534 }
2535
2536 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
2537         FILE *f;
2538         char *t;
2539         int r, fd;
2540
2541         assert(path);
2542         assert(_f);
2543         assert(_temp_path);
2544
2545         r = tempfn_xxxxxx(path, NULL, &t);
2546         if (r < 0)
2547                 return r;
2548
2549         fd = mkostemp_safe(t, O_WRONLY|O_CLOEXEC);
2550         if (fd < 0) {
2551                 free(t);
2552                 return -errno;
2553         }
2554
2555         f = fdopen(fd, "we");
2556         if (!f) {
2557                 unlink(t);
2558                 free(t);
2559                 return -errno;
2560         }
2561
2562         *_f = f;
2563         *_temp_path = t;
2564
2565         return 0;
2566 }
2567
2568 int symlink_atomic(const char *from, const char *to) {
2569         _cleanup_free_ char *t = NULL;
2570         int r;
2571
2572         assert(from);
2573         assert(to);
2574
2575         r = tempfn_random(to, NULL, &t);
2576         if (r < 0)
2577                 return r;
2578
2579         if (symlink(from, t) < 0)
2580                 return -errno;
2581
2582         if (rename(t, to) < 0) {
2583                 unlink_noerrno(t);
2584                 return -errno;
2585         }
2586
2587         return 0;
2588 }
2589
2590 /// UNNEEDED by elogind
2591 #if 0
2592 int symlink_idempotent(const char *from, const char *to) {
2593         _cleanup_free_ char *p = NULL;
2594         int r;
2595
2596         assert(from);
2597         assert(to);
2598
2599         if (symlink(from, to) < 0) {
2600                 if (errno != EEXIST)
2601                         return -errno;
2602
2603                 r = readlink_malloc(to, &p);
2604                 if (r < 0)
2605                         return r;
2606
2607                 if (!streq(p, from))
2608                         return -EINVAL;
2609         }
2610
2611         return 0;
2612 }
2613
2614 int mknod_atomic(const char *path, mode_t mode, dev_t dev) {
2615         _cleanup_free_ char *t = NULL;
2616         int r;
2617
2618         assert(path);
2619
2620         r = tempfn_random(path, NULL, &t);
2621         if (r < 0)
2622                 return r;
2623
2624         if (mknod(t, mode, dev) < 0)
2625                 return -errno;
2626
2627         if (rename(t, path) < 0) {
2628                 unlink_noerrno(t);
2629                 return -errno;
2630         }
2631
2632         return 0;
2633 }
2634
2635 int mkfifo_atomic(const char *path, mode_t mode) {
2636         _cleanup_free_ char *t = NULL;
2637         int r;
2638
2639         assert(path);
2640
2641         r = tempfn_random(path, NULL, &t);
2642         if (r < 0)
2643                 return r;
2644
2645         if (mkfifo(t, mode) < 0)
2646                 return -errno;
2647
2648         if (rename(t, path) < 0) {
2649                 unlink_noerrno(t);
2650                 return -errno;
2651         }
2652
2653         return 0;
2654 }
2655 #endif // 0
2656
2657 bool display_is_local(const char *display) {
2658         assert(display);
2659
2660         return
2661                 display[0] == ':' &&
2662                 display[1] >= '0' &&
2663                 display[1] <= '9';
2664 }
2665
2666 int socket_from_display(const char *display, char **path) {
2667         size_t k;
2668         char *f, *c;
2669
2670         assert(display);
2671         assert(path);
2672
2673         if (!display_is_local(display))
2674                 return -EINVAL;
2675
2676         k = strspn(display+1, "0123456789");
2677
2678         f = new(char, strlen("/tmp/.X11-unix/X") + k + 1);
2679         if (!f)
2680                 return -ENOMEM;
2681
2682         c = stpcpy(f, "/tmp/.X11-unix/X");
2683         memcpy(c, display+1, k);
2684         c[k] = 0;
2685
2686         *path = f;
2687
2688         return 0;
2689 }
2690
2691 int get_user_creds(
2692                 const char **username,
2693                 uid_t *uid, gid_t *gid,
2694                 const char **home,
2695                 const char **shell) {
2696
2697         struct passwd *p;
2698         uid_t u;
2699
2700         assert(username);
2701         assert(*username);
2702
2703         /* We enforce some special rules for uid=0: in order to avoid
2704          * NSS lookups for root we hardcode its data. */
2705
2706         if (streq(*username, "root") || streq(*username, "0")) {
2707                 *username = "root";
2708
2709                 if (uid)
2710                         *uid = 0;
2711
2712                 if (gid)
2713                         *gid = 0;
2714
2715                 if (home)
2716                         *home = "/root";
2717
2718                 if (shell)
2719                         *shell = "/bin/sh";
2720
2721                 return 0;
2722         }
2723
2724         if (parse_uid(*username, &u) >= 0) {
2725                 errno = 0;
2726                 p = getpwuid(u);
2727
2728                 /* If there are multiple users with the same id, make
2729                  * sure to leave $USER to the configured value instead
2730                  * of the first occurrence in the database. However if
2731                  * the uid was configured by a numeric uid, then let's
2732                  * pick the real username from /etc/passwd. */
2733                 if (p)
2734                         *username = p->pw_name;
2735         } else {
2736                 errno = 0;
2737                 p = getpwnam(*username);
2738         }
2739
2740         if (!p)
2741                 return errno > 0 ? -errno : -ESRCH;
2742
2743         if (uid)
2744                 *uid = p->pw_uid;
2745
2746         if (gid)
2747                 *gid = p->pw_gid;
2748
2749         if (home)
2750                 *home = p->pw_dir;
2751
2752         if (shell)
2753                 *shell = p->pw_shell;
2754
2755         return 0;
2756 }
2757
2758 char* uid_to_name(uid_t uid) {
2759         struct passwd *p;
2760         char *r;
2761
2762         if (uid == 0)
2763                 return strdup("root");
2764
2765         p = getpwuid(uid);
2766         if (p)
2767                 return strdup(p->pw_name);
2768
2769         if (asprintf(&r, UID_FMT, uid) < 0)
2770                 return NULL;
2771
2772         return r;
2773 }
2774
2775 char* gid_to_name(gid_t gid) {
2776         struct group *p;
2777         char *r;
2778
2779         if (gid == 0)
2780                 return strdup("root");
2781
2782         p = getgrgid(gid);
2783         if (p)
2784                 return strdup(p->gr_name);
2785
2786         if (asprintf(&r, GID_FMT, gid) < 0)
2787                 return NULL;
2788
2789         return r;
2790 }
2791
2792 int get_group_creds(const char **groupname, gid_t *gid) {
2793         struct group *g;
2794         gid_t id;
2795
2796         assert(groupname);
2797
2798         /* We enforce some special rules for gid=0: in order to avoid
2799          * NSS lookups for root we hardcode its data. */
2800
2801         if (streq(*groupname, "root") || streq(*groupname, "0")) {
2802                 *groupname = "root";
2803
2804                 if (gid)
2805                         *gid = 0;
2806
2807                 return 0;
2808         }
2809
2810         if (parse_gid(*groupname, &id) >= 0) {
2811                 errno = 0;
2812                 g = getgrgid(id);
2813
2814                 if (g)
2815                         *groupname = g->gr_name;
2816         } else {
2817                 errno = 0;
2818                 g = getgrnam(*groupname);
2819         }
2820
2821         if (!g)
2822                 return errno > 0 ? -errno : -ESRCH;
2823
2824         if (gid)
2825                 *gid = g->gr_gid;
2826
2827         return 0;
2828 }
2829
2830 int in_gid(gid_t gid) {
2831         gid_t *gids;
2832         int ngroups_max, r, i;
2833
2834         if (getgid() == gid)
2835                 return 1;
2836
2837         if (getegid() == gid)
2838                 return 1;
2839
2840         ngroups_max = sysconf(_SC_NGROUPS_MAX);
2841         assert(ngroups_max > 0);
2842
2843         gids = alloca(sizeof(gid_t) * ngroups_max);
2844
2845         r = getgroups(ngroups_max, gids);
2846         if (r < 0)
2847                 return -errno;
2848
2849         for (i = 0; i < r; i++)
2850                 if (gids[i] == gid)
2851                         return 1;
2852
2853         return 0;
2854 }
2855
2856 /// UNNEEDED by elogind
2857 #if 0
2858 int in_group(const char *name) {
2859         int r;
2860         gid_t gid;
2861
2862         r = get_group_creds(&name, &gid);
2863         if (r < 0)
2864                 return r;
2865
2866         return in_gid(gid);
2867 }
2868 #endif // 0
2869
2870 int glob_exists(const char *path) {
2871         _cleanup_globfree_ glob_t g = {};
2872         int k;
2873
2874         assert(path);
2875
2876         errno = 0;
2877         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2878
2879         if (k == GLOB_NOMATCH)
2880                 return 0;
2881         else if (k == GLOB_NOSPACE)
2882                 return -ENOMEM;
2883         else if (k == 0)
2884                 return !strv_isempty(g.gl_pathv);
2885         else
2886                 return errno ? -errno : -EIO;
2887 }
2888
2889 /// UNNEEDED by elogind
2890 #if 0
2891 int glob_extend(char ***strv, const char *path) {
2892         _cleanup_globfree_ glob_t g = {};
2893         int k;
2894         char **p;
2895
2896         errno = 0;
2897         k = glob(path, GLOB_NOSORT|GLOB_BRACE, NULL, &g);
2898
2899         if (k == GLOB_NOMATCH)
2900                 return -ENOENT;
2901         else if (k == GLOB_NOSPACE)
2902                 return -ENOMEM;
2903         else if (k != 0 || strv_isempty(g.gl_pathv))
2904                 return errno ? -errno : -EIO;
2905
2906         STRV_FOREACH(p, g.gl_pathv) {
2907                 k = strv_extend(strv, *p);
2908                 if (k < 0)
2909                         break;
2910         }
2911
2912         return k;
2913 }
2914 #endif // 0
2915
2916 int dirent_ensure_type(DIR *d, struct dirent *de) {
2917         struct stat st;
2918
2919         assert(d);
2920         assert(de);
2921
2922         if (de->d_type != DT_UNKNOWN)
2923                 return 0;
2924
2925         if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
2926                 return -errno;
2927
2928         de->d_type =
2929                 S_ISREG(st.st_mode)  ? DT_REG  :
2930                 S_ISDIR(st.st_mode)  ? DT_DIR  :
2931                 S_ISLNK(st.st_mode)  ? DT_LNK  :
2932                 S_ISFIFO(st.st_mode) ? DT_FIFO :
2933                 S_ISSOCK(st.st_mode) ? DT_SOCK :
2934                 S_ISCHR(st.st_mode)  ? DT_CHR  :
2935                 S_ISBLK(st.st_mode)  ? DT_BLK  :
2936                                        DT_UNKNOWN;
2937
2938         return 0;
2939 }
2940
2941 int get_files_in_directory(const char *path, char ***list) {
2942         _cleanup_closedir_ DIR *d = NULL;
2943         size_t bufsize = 0, n = 0;
2944         _cleanup_strv_free_ char **l = NULL;
2945
2946         assert(path);
2947
2948         /* Returns all files in a directory in *list, and the number
2949          * of files as return value. If list is NULL returns only the
2950          * number. */
2951
2952         d = opendir(path);
2953         if (!d)
2954                 return -errno;
2955
2956         for (;;) {
2957                 struct dirent *de;
2958
2959                 errno = 0;
2960                 de = readdir(d);
2961                 if (!de && errno != 0)
2962                         return -errno;
2963                 if (!de)
2964                         break;
2965
2966                 dirent_ensure_type(d, de);
2967
2968                 if (!dirent_is_file(de))
2969                         continue;
2970
2971                 if (list) {
2972                         /* one extra slot is needed for the terminating NULL */
2973                         if (!GREEDY_REALLOC(l, bufsize, n + 2))
2974                                 return -ENOMEM;
2975
2976                         l[n] = strdup(de->d_name);
2977                         if (!l[n])
2978                                 return -ENOMEM;
2979
2980                         l[++n] = NULL;
2981                 } else
2982                         n++;
2983         }
2984
2985         if (list) {
2986                 *list = l;
2987                 l = NULL; /* avoid freeing */
2988         }
2989
2990         return n;
2991 }
2992
2993 char *strjoin(const char *x, ...) {
2994         va_list ap;
2995         size_t l;
2996         char *r, *p;
2997
2998         va_start(ap, x);
2999
3000         if (x) {
3001                 l = strlen(x);
3002
3003                 for (;;) {
3004                         const char *t;
3005                         size_t n;
3006
3007                         t = va_arg(ap, const char *);
3008                         if (!t)
3009                                 break;
3010
3011                         n = strlen(t);
3012                         if (n > ((size_t) -1) - l) {
3013                                 va_end(ap);
3014                                 return NULL;
3015                         }
3016
3017                         l += n;
3018                 }
3019         } else
3020                 l = 0;
3021
3022         va_end(ap);
3023
3024         r = new(char, l+1);
3025         if (!r)
3026                 return NULL;
3027
3028         if (x) {
3029                 p = stpcpy(r, x);
3030
3031                 va_start(ap, x);
3032
3033                 for (;;) {
3034                         const char *t;
3035
3036                         t = va_arg(ap, const char *);
3037                         if (!t)
3038                                 break;
3039
3040                         p = stpcpy(p, t);
3041                 }
3042
3043                 va_end(ap);
3044         } else
3045                 r[0] = 0;
3046
3047         return r;
3048 }
3049
3050 bool is_main_thread(void) {
3051         static thread_local int cached = 0;
3052
3053         if (_unlikely_(cached == 0))
3054                 cached = getpid() == gettid() ? 1 : -1;
3055
3056         return cached > 0;
3057 }
3058
3059 int block_get_whole_disk(dev_t d, dev_t *ret) {
3060         char *p, *s;
3061         int r;
3062         unsigned n, m;
3063
3064         assert(ret);
3065
3066         /* If it has a queue this is good enough for us */
3067         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", major(d), minor(d)) < 0)
3068                 return -ENOMEM;
3069
3070         r = access(p, F_OK);
3071         free(p);
3072
3073         if (r >= 0) {
3074                 *ret = d;
3075                 return 0;
3076         }
3077
3078         /* If it is a partition find the originating device */
3079         if (asprintf(&p, "/sys/dev/block/%u:%u/partition", major(d), minor(d)) < 0)
3080                 return -ENOMEM;
3081
3082         r = access(p, F_OK);
3083         free(p);
3084
3085         if (r < 0)
3086                 return -ENOENT;
3087
3088         /* Get parent dev_t */
3089         if (asprintf(&p, "/sys/dev/block/%u:%u/../dev", major(d), minor(d)) < 0)
3090                 return -ENOMEM;
3091
3092         r = read_one_line_file(p, &s);
3093         free(p);
3094
3095         if (r < 0)
3096                 return r;
3097
3098         r = sscanf(s, "%u:%u", &m, &n);
3099         free(s);
3100
3101         if (r != 2)
3102                 return -EINVAL;
3103
3104         /* Only return this if it is really good enough for us. */
3105         if (asprintf(&p, "/sys/dev/block/%u:%u/queue", m, n) < 0)
3106                 return -ENOMEM;
3107
3108         r = access(p, F_OK);
3109         free(p);
3110
3111         if (r >= 0) {
3112                 *ret = makedev(m, n);
3113                 return 0;
3114         }
3115
3116         return -ENOENT;
3117 }
3118
3119 static const char *const ioprio_class_table[] = {
3120         [IOPRIO_CLASS_NONE] = "none",
3121         [IOPRIO_CLASS_RT] = "realtime",
3122         [IOPRIO_CLASS_BE] = "best-effort",
3123         [IOPRIO_CLASS_IDLE] = "idle"
3124 };
3125
3126 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ioprio_class, int, INT_MAX);
3127
3128 static const char *const sigchld_code_table[] = {
3129         [CLD_EXITED] = "exited",
3130         [CLD_KILLED] = "killed",
3131         [CLD_DUMPED] = "dumped",
3132         [CLD_TRAPPED] = "trapped",
3133         [CLD_STOPPED] = "stopped",
3134         [CLD_CONTINUED] = "continued",
3135 };
3136
3137 DEFINE_STRING_TABLE_LOOKUP(sigchld_code, int);
3138
3139 static const char *const log_facility_unshifted_table[LOG_NFACILITIES] = {
3140         [LOG_FAC(LOG_KERN)] = "kern",
3141         [LOG_FAC(LOG_USER)] = "user",
3142         [LOG_FAC(LOG_MAIL)] = "mail",
3143         [LOG_FAC(LOG_DAEMON)] = "daemon",
3144         [LOG_FAC(LOG_AUTH)] = "auth",
3145         [LOG_FAC(LOG_SYSLOG)] = "syslog",
3146         [LOG_FAC(LOG_LPR)] = "lpr",
3147         [LOG_FAC(LOG_NEWS)] = "news",
3148         [LOG_FAC(LOG_UUCP)] = "uucp",
3149         [LOG_FAC(LOG_CRON)] = "cron",
3150         [LOG_FAC(LOG_AUTHPRIV)] = "authpriv",
3151         [LOG_FAC(LOG_FTP)] = "ftp",
3152         [LOG_FAC(LOG_LOCAL0)] = "local0",
3153         [LOG_FAC(LOG_LOCAL1)] = "local1",
3154         [LOG_FAC(LOG_LOCAL2)] = "local2",
3155         [LOG_FAC(LOG_LOCAL3)] = "local3",
3156         [LOG_FAC(LOG_LOCAL4)] = "local4",
3157         [LOG_FAC(LOG_LOCAL5)] = "local5",
3158         [LOG_FAC(LOG_LOCAL6)] = "local6",
3159         [LOG_FAC(LOG_LOCAL7)] = "local7"
3160 };
3161
3162 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_facility_unshifted, int, LOG_FAC(~0));
3163
3164 static const char *const log_level_table[] = {
3165         [LOG_EMERG] = "emerg",
3166         [LOG_ALERT] = "alert",
3167         [LOG_CRIT] = "crit",
3168         [LOG_ERR] = "err",
3169         [LOG_WARNING] = "warning",
3170         [LOG_NOTICE] = "notice",
3171         [LOG_INFO] = "info",
3172         [LOG_DEBUG] = "debug"
3173 };
3174
3175 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(log_level, int, LOG_DEBUG);
3176
3177 static const char* const sched_policy_table[] = {
3178         [SCHED_OTHER] = "other",
3179         [SCHED_BATCH] = "batch",
3180         [SCHED_IDLE] = "idle",
3181         [SCHED_FIFO] = "fifo",
3182         [SCHED_RR] = "rr"
3183 };
3184
3185 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sched_policy, int, INT_MAX);
3186
3187 static const char* const rlimit_table[_RLIMIT_MAX] = {
3188         [RLIMIT_CPU] = "LimitCPU",
3189         [RLIMIT_FSIZE] = "LimitFSIZE",
3190         [RLIMIT_DATA] = "LimitDATA",
3191         [RLIMIT_STACK] = "LimitSTACK",
3192         [RLIMIT_CORE] = "LimitCORE",
3193         [RLIMIT_RSS] = "LimitRSS",
3194         [RLIMIT_NOFILE] = "LimitNOFILE",
3195         [RLIMIT_AS] = "LimitAS",
3196         [RLIMIT_NPROC] = "LimitNPROC",
3197         [RLIMIT_MEMLOCK] = "LimitMEMLOCK",
3198         [RLIMIT_LOCKS] = "LimitLOCKS",
3199         [RLIMIT_SIGPENDING] = "LimitSIGPENDING",
3200         [RLIMIT_MSGQUEUE] = "LimitMSGQUEUE",
3201         [RLIMIT_NICE] = "LimitNICE",
3202         [RLIMIT_RTPRIO] = "LimitRTPRIO",
3203         [RLIMIT_RTTIME] = "LimitRTTIME"
3204 };
3205
3206 DEFINE_STRING_TABLE_LOOKUP(rlimit, int);
3207
3208 static const char* const ip_tos_table[] = {
3209         [IPTOS_LOWDELAY] = "low-delay",
3210         [IPTOS_THROUGHPUT] = "throughput",
3211         [IPTOS_RELIABILITY] = "reliability",
3212         [IPTOS_LOWCOST] = "low-cost",
3213 };
3214
3215 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(ip_tos, int, 0xff);
3216
3217 bool kexec_loaded(void) {
3218        bool loaded = false;
3219        char *s;
3220
3221        if (read_one_line_file("/sys/kernel/kexec_loaded", &s) >= 0) {
3222                if (s[0] == '1')
3223                        loaded = true;
3224                free(s);
3225        }
3226        return loaded;
3227 }
3228
3229 /// UNNEEDED by elogind
3230 #if 0
3231 int prot_from_flags(int flags) {
3232
3233         switch (flags & O_ACCMODE) {
3234
3235         case O_RDONLY:
3236                 return PROT_READ;
3237
3238         case O_WRONLY:
3239                 return PROT_WRITE;
3240
3241         case O_RDWR:
3242                 return PROT_READ|PROT_WRITE;
3243
3244         default:
3245                 return -EINVAL;
3246         }
3247 }
3248 #endif // 0
3249 char *format_bytes(char *buf, size_t l, off_t t) {
3250         unsigned i;
3251
3252         static const struct {
3253                 const char *suffix;
3254                 off_t factor;
3255         } table[] = {
3256                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3257                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
3258                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
3259                 { "G", 1024ULL*1024ULL*1024ULL },
3260                 { "M", 1024ULL*1024ULL },
3261                 { "K", 1024ULL },
3262         };
3263
3264         if (t == (off_t) -1)
3265                 return NULL;
3266
3267         for (i = 0; i < ELEMENTSOF(table); i++) {
3268
3269                 if (t >= table[i].factor) {
3270                         snprintf(buf, l,
3271                                  "%llu.%llu%s",
3272                                  (unsigned long long) (t / table[i].factor),
3273                                  (unsigned long long) (((t*10ULL) / table[i].factor) % 10ULL),
3274                                  table[i].suffix);
3275
3276                         goto finish;
3277                 }
3278         }
3279
3280         snprintf(buf, l, "%lluB", (unsigned long long) t);
3281
3282 finish:
3283         buf[l-1] = 0;
3284         return buf;
3285
3286 }
3287
3288 void* memdup(const void *p, size_t l) {
3289         void *r;
3290
3291         assert(p);
3292
3293         r = malloc(l);
3294         if (!r)
3295                 return NULL;
3296
3297         memcpy(r, p, l);
3298         return r;
3299 }
3300
3301 int fd_inc_sndbuf(int fd, size_t n) {
3302         int r, value;
3303         socklen_t l = sizeof(value);
3304
3305         r = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, &l);
3306         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3307                 return 0;
3308
3309         /* If we have the privileges we will ignore the kernel limit. */
3310
3311         value = (int) n;
3312         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
3313                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
3314                         return -errno;
3315
3316         return 1;
3317 }
3318
3319 int fd_inc_rcvbuf(int fd, size_t n) {
3320         int r, value;
3321         socklen_t l = sizeof(value);
3322
3323         r = getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, &l);
3324         if (r >= 0 && l == sizeof(value) && (size_t) value >= n*2)
3325                 return 0;
3326
3327         /* If we have the privileges we will ignore the kernel limit. */
3328
3329         value = (int) n;
3330         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
3331                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
3332                         return -errno;
3333         return 1;
3334 }
3335
3336 int fork_agent(pid_t *pid, const int except[], unsigned n_except, const char *path, ...) {
3337         bool stdout_is_tty, stderr_is_tty;
3338         pid_t parent_pid, agent_pid;
3339         sigset_t ss, saved_ss;
3340         unsigned n, i;
3341         va_list ap;
3342         char **l;
3343
3344         assert(pid);
3345         assert(path);
3346
3347         /* Spawns a temporary TTY agent, making sure it goes away when
3348          * we go away */
3349
3350         parent_pid = getpid();
3351
3352         /* First we temporarily block all signals, so that the new
3353          * child has them blocked initially. This way, we can be sure
3354          * that SIGTERMs are not lost we might send to the agent. */
3355         assert_se(sigfillset(&ss) >= 0);
3356         assert_se(sigprocmask(SIG_SETMASK, &ss, &saved_ss) >= 0);
3357
3358         agent_pid = fork();
3359         if (agent_pid < 0) {
3360                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3361                 return -errno;
3362         }
3363
3364         if (agent_pid != 0) {
3365                 assert_se(sigprocmask(SIG_SETMASK, &saved_ss, NULL) >= 0);
3366                 *pid = agent_pid;
3367                 return 0;
3368         }
3369
3370         /* In the child:
3371          *
3372          * Make sure the agent goes away when the parent dies */
3373         if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
3374                 _exit(EXIT_FAILURE);
3375
3376         /* Make sure we actually can kill the agent, if we need to, in
3377          * case somebody invoked us from a shell script that trapped
3378          * SIGTERM or so... */
3379         (void) reset_all_signal_handlers();
3380         (void) reset_signal_mask();
3381
3382         /* Check whether our parent died before we were able
3383          * to set the death signal and unblock the signals */
3384         if (getppid() != parent_pid)
3385                 _exit(EXIT_SUCCESS);
3386
3387         /* Don't leak fds to the agent */
3388         close_all_fds(except, n_except);
3389
3390         stdout_is_tty = isatty(STDOUT_FILENO);
3391         stderr_is_tty = isatty(STDERR_FILENO);
3392
3393         if (!stdout_is_tty || !stderr_is_tty) {
3394                 int fd;
3395
3396                 /* Detach from stdout/stderr. and reopen
3397                  * /dev/tty for them. This is important to
3398                  * ensure that when systemctl is started via
3399                  * popen() or a similar call that expects to
3400                  * read EOF we actually do generate EOF and
3401                  * not delay this indefinitely by because we
3402                  * keep an unused copy of stdin around. */
3403                 fd = open("/dev/tty", O_WRONLY);
3404                 if (fd < 0) {
3405                         log_error_errno(errno, "Failed to open /dev/tty: %m");
3406                         _exit(EXIT_FAILURE);
3407                 }
3408
3409                 if (!stdout_is_tty)
3410                         dup2(fd, STDOUT_FILENO);
3411
3412                 if (!stderr_is_tty)
3413                         dup2(fd, STDERR_FILENO);
3414
3415                 if (fd > 2)
3416                         close(fd);
3417         }
3418
3419         /* Count arguments */
3420         va_start(ap, path);
3421         for (n = 0; va_arg(ap, char*); n++)
3422                 ;
3423         va_end(ap);
3424
3425         /* Allocate strv */
3426         l = alloca(sizeof(char *) * (n + 1));
3427
3428         /* Fill in arguments */
3429         va_start(ap, path);
3430         for (i = 0; i <= n; i++)
3431                 l[i] = va_arg(ap, char*);
3432         va_end(ap);
3433
3434         execv(path, l);
3435         _exit(EXIT_FAILURE);
3436 }
3437
3438 int setrlimit_closest(int resource, const struct rlimit *rlim) {
3439         struct rlimit highest, fixed;
3440
3441         assert(rlim);
3442
3443         if (setrlimit(resource, rlim) >= 0)
3444                 return 0;
3445
3446         if (errno != EPERM)
3447                 return -errno;
3448
3449         /* So we failed to set the desired setrlimit, then let's try
3450          * to get as close as we can */
3451         assert_se(getrlimit(resource, &highest) == 0);
3452
3453         fixed.rlim_cur = MIN(rlim->rlim_cur, highest.rlim_max);
3454         fixed.rlim_max = MIN(rlim->rlim_max, highest.rlim_max);
3455
3456         if (setrlimit(resource, &fixed) < 0)
3457                 return -errno;
3458
3459         return 0;
3460 }
3461
3462 /// UNNEEDED by elogind
3463 #if 0
3464 bool http_etag_is_valid(const char *etag) {
3465         if (isempty(etag))
3466                 return false;
3467
3468         if (!endswith(etag, "\""))
3469                 return false;
3470
3471         if (!startswith(etag, "\"") && !startswith(etag, "W/\""))
3472                 return false;
3473
3474         return true;
3475 }
3476 #endif // 0
3477
3478 bool http_url_is_valid(const char *url) {
3479         const char *p;
3480
3481         if (isempty(url))
3482                 return false;
3483
3484         p = startswith(url, "http://");
3485         if (!p)
3486                 p = startswith(url, "https://");
3487         if (!p)
3488                 return false;
3489
3490         if (isempty(p))
3491                 return false;
3492