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