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