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