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