chiark / gitweb /
core: make systemd.confirm_spawn=1 actually work
[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 <assert.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <stdlib.h>
27 #include <signal.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 <linux/vt.h>
39 #include <linux/tiocl.h>
40 #include <termios.h>
41 #include <stdarg.h>
42 #include <sys/inotify.h>
43 #include <sys/poll.h>
44 #include <libgen.h>
45 #include <ctype.h>
46 #include <sys/prctl.h>
47 #include <sys/utsname.h>
48 #include <pwd.h>
49 #include <netinet/ip.h>
50 #include <linux/kd.h>
51 #include <dlfcn.h>
52 #include <sys/wait.h>
53 #include <sys/time.h>
54 #include <glob.h>
55 #include <grp.h>
56 #include <sys/mman.h>
57
58 #include "macro.h"
59 #include "util.h"
60 #include "ioprio.h"
61 #include "missing.h"
62 #include "log.h"
63 #include "strv.h"
64 #include "label.h"
65 #include "path-util.h"
66 #include "exit-status.h"
67 #include "hashmap.h"
68
69 int saved_argc = 0;
70 char **saved_argv = NULL;
71
72 size_t page_size(void) {
73         static __thread size_t pgsz = 0;
74         long r;
75
76         if (_likely_(pgsz > 0))
77                 return pgsz;
78
79         assert_se((r = sysconf(_SC_PAGESIZE)) > 0);
80
81         pgsz = (size_t) r;
82
83         return pgsz;
84 }
85
86 bool streq_ptr(const char *a, const char *b) {
87
88         /* Like streq(), but tries to make sense of NULL pointers */
89
90         if (a && b)
91                 return streq(a, b);
92
93         if (!a && !b)
94                 return true;
95
96         return false;
97 }
98
99 usec_t now(clockid_t clock_id) {
100         struct timespec ts;
101
102         assert_se(clock_gettime(clock_id, &ts) == 0);
103
104         return timespec_load(&ts);
105 }
106
107 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
108         assert(ts);
109
110         ts->realtime = now(CLOCK_REALTIME);
111         ts->monotonic = now(CLOCK_MONOTONIC);
112
113         return ts;
114 }
115
116 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
117         int64_t delta;
118         assert(ts);
119
120         ts->realtime = u;
121
122         if (u == 0)
123                 ts->monotonic = 0;
124         else {
125                 delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
126
127                 ts->monotonic = now(CLOCK_MONOTONIC);
128
129                 if ((int64_t) ts->monotonic > delta)
130                         ts->monotonic -= delta;
131                 else
132                         ts->monotonic = 0;
133         }
134
135         return ts;
136 }
137
138 usec_t timespec_load(const struct timespec *ts) {
139         assert(ts);
140
141         return
142                 (usec_t) ts->tv_sec * USEC_PER_SEC +
143                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
144 }
145
146 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
147         assert(ts);
148
149         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
150         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
151
152         return ts;
153 }
154
155 usec_t timeval_load(const struct timeval *tv) {
156         assert(tv);
157
158         return
159                 (usec_t) tv->tv_sec * USEC_PER_SEC +
160                 (usec_t) tv->tv_usec;
161 }
162
163 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
164         assert(tv);
165
166         tv->tv_sec = (time_t) (u / USEC_PER_SEC);
167         tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
168
169         return tv;
170 }
171
172 bool endswith(const char *s, const char *postfix) {
173         size_t sl, pl;
174
175         assert(s);
176         assert(postfix);
177
178         sl = strlen(s);
179         pl = strlen(postfix);
180
181         if (pl == 0)
182                 return true;
183
184         if (sl < pl)
185                 return false;
186
187         return memcmp(s + sl - pl, postfix, pl) == 0;
188 }
189
190 bool startswith(const char *s, const char *prefix) {
191         size_t sl, pl;
192
193         assert(s);
194         assert(prefix);
195
196         sl = strlen(s);
197         pl = strlen(prefix);
198
199         if (pl == 0)
200                 return true;
201
202         if (sl < pl)
203                 return false;
204
205         return memcmp(s, prefix, pl) == 0;
206 }
207
208 bool startswith_no_case(const char *s, const char *prefix) {
209         size_t sl, pl;
210         unsigned i;
211
212         assert(s);
213         assert(prefix);
214
215         sl = strlen(s);
216         pl = strlen(prefix);
217
218         if (pl == 0)
219                 return true;
220
221         if (sl < pl)
222                 return false;
223
224         for(i = 0; i < pl; ++i) {
225                 if (tolower(s[i]) != tolower(prefix[i]))
226                         return false;
227         }
228
229         return true;
230 }
231
232 bool first_word(const char *s, const char *word) {
233         size_t sl, wl;
234
235         assert(s);
236         assert(word);
237
238         sl = strlen(s);
239         wl = strlen(word);
240
241         if (sl < wl)
242                 return false;
243
244         if (wl == 0)
245                 return true;
246
247         if (memcmp(s, word, wl) != 0)
248                 return false;
249
250         return s[wl] == 0 ||
251                 strchr(WHITESPACE, s[wl]);
252 }
253
254 int close_nointr(int fd) {
255         assert(fd >= 0);
256
257         for (;;) {
258                 int r;
259
260                 r = close(fd);
261                 if (r >= 0)
262                         return r;
263
264                 if (errno != EINTR)
265                         return -errno;
266         }
267 }
268
269 void close_nointr_nofail(int fd) {
270         int saved_errno = errno;
271
272         /* like close_nointr() but cannot fail, and guarantees errno
273          * is unchanged */
274
275         assert_se(close_nointr(fd) == 0);
276
277         errno = saved_errno;
278 }
279
280 void close_many(const int fds[], unsigned n_fd) {
281         unsigned i;
282
283         for (i = 0; i < n_fd; i++)
284                 close_nointr_nofail(fds[i]);
285 }
286
287 int parse_boolean(const char *v) {
288         assert(v);
289
290         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
291                 return 1;
292         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
293                 return 0;
294
295         return -EINVAL;
296 }
297
298 int parse_pid(const char *s, pid_t* ret_pid) {
299         unsigned long ul = 0;
300         pid_t pid;
301         int r;
302
303         assert(s);
304         assert(ret_pid);
305
306         if ((r = safe_atolu(s, &ul)) < 0)
307                 return r;
308
309         pid = (pid_t) ul;
310
311         if ((unsigned long) pid != ul)
312                 return -ERANGE;
313
314         if (pid <= 0)
315                 return -ERANGE;
316
317         *ret_pid = pid;
318         return 0;
319 }
320
321 int parse_uid(const char *s, uid_t* ret_uid) {
322         unsigned long ul = 0;
323         uid_t uid;
324         int r;
325
326         assert(s);
327         assert(ret_uid);
328
329         if ((r = safe_atolu(s, &ul)) < 0)
330                 return r;
331
332         uid = (uid_t) ul;
333
334         if ((unsigned long) uid != ul)
335                 return -ERANGE;
336
337         *ret_uid = uid;
338         return 0;
339 }
340
341 int safe_atou(const char *s, unsigned *ret_u) {
342         char *x = NULL;
343         unsigned long l;
344
345         assert(s);
346         assert(ret_u);
347
348         errno = 0;
349         l = strtoul(s, &x, 0);
350
351         if (!x || *x || errno)
352                 return errno ? -errno : -EINVAL;
353
354         if ((unsigned long) (unsigned) l != l)
355                 return -ERANGE;
356
357         *ret_u = (unsigned) l;
358         return 0;
359 }
360
361 int safe_atoi(const char *s, int *ret_i) {
362         char *x = NULL;
363         long l;
364
365         assert(s);
366         assert(ret_i);
367
368         errno = 0;
369         l = strtol(s, &x, 0);
370
371         if (!x || *x || errno)
372                 return errno ? -errno : -EINVAL;
373
374         if ((long) (int) l != l)
375                 return -ERANGE;
376
377         *ret_i = (int) l;
378         return 0;
379 }
380
381 int safe_atollu(const char *s, long long unsigned *ret_llu) {
382         char *x = NULL;
383         unsigned long long l;
384
385         assert(s);
386         assert(ret_llu);
387
388         errno = 0;
389         l = strtoull(s, &x, 0);
390
391         if (!x || *x || errno)
392                 return errno ? -errno : -EINVAL;
393
394         *ret_llu = l;
395         return 0;
396 }
397
398 int safe_atolli(const char *s, long long int *ret_lli) {
399         char *x = NULL;
400         long long l;
401
402         assert(s);
403         assert(ret_lli);
404
405         errno = 0;
406         l = strtoll(s, &x, 0);
407
408         if (!x || *x || errno)
409                 return errno ? -errno : -EINVAL;
410
411         *ret_lli = l;
412         return 0;
413 }
414
415 /* Split a string into words. */
416 char *split(const char *c, size_t *l, const char *separator, char **state) {
417         char *current;
418
419         current = *state ? *state : (char*) c;
420
421         if (!*current || *c == 0)
422                 return NULL;
423
424         current += strspn(current, separator);
425         *l = strcspn(current, separator);
426         *state = current+*l;
427
428         return (char*) current;
429 }
430
431 /* Split a string into words, but consider strings enclosed in '' and
432  * "" as words even if they include spaces. */
433 char *split_quoted(const char *c, size_t *l, char **state) {
434         char *current, *e;
435         bool escaped = false;
436
437         current = *state ? *state : (char*) c;
438
439         if (!*current || *c == 0)
440                 return NULL;
441
442         current += strspn(current, WHITESPACE);
443
444         if (*current == '\'') {
445                 current ++;
446
447                 for (e = current; *e; e++) {
448                         if (escaped)
449                                 escaped = false;
450                         else if (*e == '\\')
451                                 escaped = true;
452                         else if (*e == '\'')
453                                 break;
454                 }
455
456                 *l = e-current;
457                 *state = *e == 0 ? e : e+1;
458         } else if (*current == '\"') {
459                 current ++;
460
461                 for (e = current; *e; e++) {
462                         if (escaped)
463                                 escaped = false;
464                         else if (*e == '\\')
465                                 escaped = true;
466                         else if (*e == '\"')
467                                 break;
468                 }
469
470                 *l = e-current;
471                 *state = *e == 0 ? e : e+1;
472         } else {
473                 for (e = current; *e; e++) {
474                         if (escaped)
475                                 escaped = false;
476                         else if (*e == '\\')
477                                 escaped = true;
478                         else if (strchr(WHITESPACE, *e))
479                                 break;
480                 }
481                 *l = e-current;
482                 *state = e;
483         }
484
485         return (char*) current;
486 }
487
488 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
489         int r;
490         FILE *f;
491         char fn[PATH_MAX], line[LINE_MAX], *p;
492         long unsigned ppid;
493
494         assert(pid > 0);
495         assert(_ppid);
496
497         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
498         char_array_0(fn);
499
500         if (!(f = fopen(fn, "re")))
501                 return -errno;
502
503         if (!(fgets(line, sizeof(line), f))) {
504                 r = feof(f) ? -EIO : -errno;
505                 fclose(f);
506                 return r;
507         }
508
509         fclose(f);
510
511         /* Let's skip the pid and comm fields. The latter is enclosed
512          * in () but does not escape any () in its value, so let's
513          * skip over it manually */
514
515         if (!(p = strrchr(line, ')')))
516                 return -EIO;
517
518         p++;
519
520         if (sscanf(p, " "
521                    "%*c "  /* state */
522                    "%lu ", /* ppid */
523                    &ppid) != 1)
524                 return -EIO;
525
526         if ((long unsigned) (pid_t) ppid != ppid)
527                 return -ERANGE;
528
529         *_ppid = (pid_t) ppid;
530
531         return 0;
532 }
533
534 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
535         int r;
536         FILE *f;
537         char fn[PATH_MAX], line[LINE_MAX], *p;
538
539         assert(pid > 0);
540         assert(st);
541
542         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
543         char_array_0(fn);
544
545         if (!(f = fopen(fn, "re")))
546                 return -errno;
547
548         if (!(fgets(line, sizeof(line), f))) {
549                 r = feof(f) ? -EIO : -errno;
550                 fclose(f);
551                 return r;
552         }
553
554         fclose(f);
555
556         /* Let's skip the pid and comm fields. The latter is enclosed
557          * in () but does not escape any () in its value, so let's
558          * skip over it manually */
559
560         if (!(p = strrchr(line, ')')))
561                 return -EIO;
562
563         p++;
564
565         if (sscanf(p, " "
566                    "%*c "  /* state */
567                    "%*d "  /* ppid */
568                    "%*d "  /* pgrp */
569                    "%*d "  /* session */
570                    "%*d "  /* tty_nr */
571                    "%*d "  /* tpgid */
572                    "%*u "  /* flags */
573                    "%*u "  /* minflt */
574                    "%*u "  /* cminflt */
575                    "%*u "  /* majflt */
576                    "%*u "  /* cmajflt */
577                    "%*u "  /* utime */
578                    "%*u "  /* stime */
579                    "%*d "  /* cutime */
580                    "%*d "  /* cstime */
581                    "%*d "  /* priority */
582                    "%*d "  /* nice */
583                    "%*d "  /* num_threads */
584                    "%*d "  /* itrealvalue */
585                    "%llu "  /* starttime */,
586                    st) != 1)
587                 return -EIO;
588
589         return 0;
590 }
591
592 int write_one_line_file(const char *fn, const char *line) {
593         FILE *f;
594         int r;
595
596         assert(fn);
597         assert(line);
598
599         f = fopen(fn, "we");
600         if (!f)
601                 return -errno;
602
603         errno = 0;
604         if (fputs(line, f) < 0) {
605                 r = -errno;
606                 goto finish;
607         }
608
609         if (!endswith(line, "\n"))
610                 fputc('\n', f);
611
612         fflush(f);
613
614         if (ferror(f)) {
615                 if (errno != 0)
616                         r = -errno;
617                 else
618                         r = -EIO;
619         } else
620                 r = 0;
621
622 finish:
623         fclose(f);
624         return r;
625 }
626
627 int fchmod_umask(int fd, mode_t m) {
628         mode_t u;
629         int r;
630
631         u = umask(0777);
632         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
633         umask(u);
634
635         return r;
636 }
637
638 int write_one_line_file_atomic(const char *fn, const char *line) {
639         FILE *f;
640         int r;
641         char *p;
642
643         assert(fn);
644         assert(line);
645
646         r = fopen_temporary(fn, &f, &p);
647         if (r < 0)
648                 return r;
649
650         fchmod_umask(fileno(f), 0644);
651
652         errno = 0;
653         if (fputs(line, f) < 0) {
654                 r = -errno;
655                 goto finish;
656         }
657
658         if (!endswith(line, "\n"))
659                 fputc('\n', f);
660
661         fflush(f);
662
663         if (ferror(f)) {
664                 if (errno != 0)
665                         r = -errno;
666                 else
667                         r = -EIO;
668         } else {
669                 if (rename(p, fn) < 0)
670                         r = -errno;
671                 else
672                         r = 0;
673         }
674
675 finish:
676         if (r < 0)
677                 unlink(p);
678
679         fclose(f);
680         free(p);
681
682         return r;
683 }
684
685 int read_one_line_file(const char *fn, char **line) {
686         FILE *f;
687         int r;
688         char t[LINE_MAX], *c;
689
690         assert(fn);
691         assert(line);
692
693         f = fopen(fn, "re");
694         if (!f)
695                 return -errno;
696
697         if (!fgets(t, sizeof(t), f)) {
698
699                 if (ferror(f)) {
700                         r = -errno;
701                         goto finish;
702                 }
703
704                 t[0] = 0;
705         }
706
707         c = strdup(t);
708         if (!c) {
709                 r = -ENOMEM;
710                 goto finish;
711         }
712
713         truncate_nl(c);
714
715         *line = c;
716         r = 0;
717
718 finish:
719         fclose(f);
720         return r;
721 }
722
723 int read_full_file(const char *fn, char **contents, size_t *size) {
724         FILE *f;
725         int r;
726         size_t n, l;
727         char *buf = NULL;
728         struct stat st;
729
730         if (!(f = fopen(fn, "re")))
731                 return -errno;
732
733         if (fstat(fileno(f), &st) < 0) {
734                 r = -errno;
735                 goto finish;
736         }
737
738         /* Safety check */
739         if (st.st_size > 4*1024*1024) {
740                 r = -E2BIG;
741                 goto finish;
742         }
743
744         n = st.st_size > 0 ? st.st_size : LINE_MAX;
745         l = 0;
746
747         for (;;) {
748                 char *t;
749                 size_t k;
750
751                 if (!(t = realloc(buf, n+1))) {
752                         r = -ENOMEM;
753                         goto finish;
754                 }
755
756                 buf = t;
757                 k = fread(buf + l, 1, n - l, f);
758
759                 if (k <= 0) {
760                         if (ferror(f)) {
761                                 r = -errno;
762                                 goto finish;
763                         }
764
765                         break;
766                 }
767
768                 l += k;
769                 n *= 2;
770
771                 /* Safety check */
772                 if (n > 4*1024*1024) {
773                         r = -E2BIG;
774                         goto finish;
775                 }
776         }
777
778         buf[l] = 0;
779         *contents = buf;
780         buf = NULL;
781
782         if (size)
783                 *size = l;
784
785         r = 0;
786
787 finish:
788         fclose(f);
789         free(buf);
790
791         return r;
792 }
793
794 int parse_env_file(
795                 const char *fname,
796                 const char *separator, ...) {
797
798         int r = 0;
799         char *contents = NULL, *p;
800
801         assert(fname);
802         assert(separator);
803
804         if ((r = read_full_file(fname, &contents, NULL)) < 0)
805                 return r;
806
807         p = contents;
808         for (;;) {
809                 const char *key = NULL;
810
811                 p += strspn(p, separator);
812                 p += strspn(p, WHITESPACE);
813
814                 if (!*p)
815                         break;
816
817                 if (!strchr(COMMENTS, *p)) {
818                         va_list ap;
819                         char **value;
820
821                         va_start(ap, separator);
822                         while ((key = va_arg(ap, char *))) {
823                                 size_t n;
824                                 char *v;
825
826                                 value = va_arg(ap, char **);
827
828                                 n = strlen(key);
829                                 if (strncmp(p, key, n) != 0 ||
830                                     p[n] != '=')
831                                         continue;
832
833                                 p += n + 1;
834                                 n = strcspn(p, separator);
835
836                                 if (n >= 2 &&
837                                     strchr(QUOTES, p[0]) &&
838                                     p[n-1] == p[0])
839                                         v = strndup(p+1, n-2);
840                                 else
841                                         v = strndup(p, n);
842
843                                 if (!v) {
844                                         r = -ENOMEM;
845                                         va_end(ap);
846                                         goto fail;
847                                 }
848
849                                 if (v[0] == '\0') {
850                                         /* return empty value strings as NULL */
851                                         free(v);
852                                         v = NULL;
853                                 }
854
855                                 free(*value);
856                                 *value = v;
857
858                                 p += n;
859
860                                 r ++;
861                                 break;
862                         }
863                         va_end(ap);
864                 }
865
866                 if (!key)
867                         p += strcspn(p, separator);
868         }
869
870 fail:
871         free(contents);
872         return r;
873 }
874
875 int load_env_file(
876                 const char *fname,
877                 char ***rl) {
878
879         FILE *f;
880         char **m = NULL;
881         int r;
882
883         assert(fname);
884         assert(rl);
885
886         if (!(f = fopen(fname, "re")))
887                 return -errno;
888
889         while (!feof(f)) {
890                 char l[LINE_MAX], *p, *u;
891                 char **t;
892
893                 if (!fgets(l, sizeof(l), f)) {
894                         if (feof(f))
895                                 break;
896
897                         r = -errno;
898                         goto finish;
899                 }
900
901                 p = strstrip(l);
902
903                 if (!*p)
904                         continue;
905
906                 if (strchr(COMMENTS, *p))
907                         continue;
908
909                 if (!(u = normalize_env_assignment(p))) {
910                         log_error("Out of memory");
911                         r = -ENOMEM;
912                         goto finish;
913                 }
914
915                 t = strv_append(m, u);
916                 free(u);
917
918                 if (!t) {
919                         log_error("Out of memory");
920                         r = -ENOMEM;
921                         goto finish;
922                 }
923
924                 strv_free(m);
925                 m = t;
926         }
927
928         r = 0;
929
930         *rl = m;
931         m = NULL;
932
933 finish:
934         if (f)
935                 fclose(f);
936
937         strv_free(m);
938
939         return r;
940 }
941
942 int write_env_file(const char *fname, char **l) {
943         char **i, *p;
944         FILE *f;
945         int r;
946
947         r = fopen_temporary(fname, &f, &p);
948         if (r < 0)
949                 return r;
950
951         fchmod_umask(fileno(f), 0644);
952
953         errno = 0;
954         STRV_FOREACH(i, l) {
955                 fputs(*i, f);
956                 fputc('\n', f);
957         }
958
959         fflush(f);
960
961         if (ferror(f)) {
962                 if (errno != 0)
963                         r = -errno;
964                 else
965                         r = -EIO;
966         } else {
967                 if (rename(p, fname) < 0)
968                         r = -errno;
969                 else
970                         r = 0;
971         }
972
973         if (r < 0)
974                 unlink(p);
975
976         fclose(f);
977         free(p);
978
979         return r;
980 }
981
982 char *truncate_nl(char *s) {
983         assert(s);
984
985         s[strcspn(s, NEWLINE)] = 0;
986         return s;
987 }
988
989 int get_process_comm(pid_t pid, char **name) {
990         int r;
991
992         assert(name);
993
994         if (pid == 0)
995                 r = read_one_line_file("/proc/self/comm", name);
996         else {
997                 char *p;
998                 if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
999                         return -ENOMEM;
1000
1001                 r = read_one_line_file(p, name);
1002                 free(p);
1003         }
1004
1005         return r;
1006 }
1007
1008 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
1009         char *r, *k;
1010         int c;
1011         bool space = false;
1012         size_t left;
1013         FILE *f;
1014
1015         assert(max_length > 0);
1016         assert(line);
1017
1018         if (pid == 0)
1019                 f = fopen("/proc/self/cmdline", "re");
1020         else {
1021                 char *p;
1022                 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1023                         return -ENOMEM;
1024
1025                 f = fopen(p, "re");
1026                 free(p);
1027         }
1028
1029         if (!f)
1030                 return -errno;
1031
1032         r = new(char, max_length);
1033         if (!r) {
1034                 fclose(f);
1035                 return -ENOMEM;
1036         }
1037
1038         k = r;
1039         left = max_length;
1040         while ((c = getc(f)) != EOF) {
1041
1042                 if (isprint(c)) {
1043                         if (space) {
1044                                 if (left <= 4)
1045                                         break;
1046
1047                                 *(k++) = ' ';
1048                                 left--;
1049                                 space = false;
1050                         }
1051
1052                         if (left <= 4)
1053                                 break;
1054
1055                         *(k++) = (char) c;
1056                         left--;
1057                 }  else
1058                         space = true;
1059         }
1060
1061         if (left <= 4) {
1062                 size_t n = MIN(left-1, 3U);
1063                 memcpy(k, "...", n);
1064                 k[n] = 0;
1065         } else
1066                 *k = 0;
1067
1068         fclose(f);
1069
1070         /* Kernel threads have no argv[] */
1071         if (r[0] == 0) {
1072                 char *t;
1073                 int h;
1074
1075                 free(r);
1076
1077                 if (!comm_fallback)
1078                         return -ENOENT;
1079
1080                 h = get_process_comm(pid, &t);
1081                 if (h < 0)
1082                         return h;
1083
1084                 r = join("[", t, "]", NULL);
1085                 free(t);
1086
1087                 if (!r)
1088                         return -ENOMEM;
1089         }
1090
1091         *line = r;
1092         return 0;
1093 }
1094
1095 int is_kernel_thread(pid_t pid) {
1096         char *p;
1097         size_t count;
1098         char c;
1099         bool eof;
1100         FILE *f;
1101
1102         if (pid == 0)
1103                 return 0;
1104
1105         if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
1106                 return -ENOMEM;
1107
1108         f = fopen(p, "re");
1109         free(p);
1110
1111         if (!f)
1112                 return -errno;
1113
1114         count = fread(&c, 1, 1, f);
1115         eof = feof(f);
1116         fclose(f);
1117
1118         /* Kernel threads have an empty cmdline */
1119
1120         if (count <= 0)
1121                 return eof ? 1 : -errno;
1122
1123         return 0;
1124 }
1125
1126 int get_process_exe(pid_t pid, char **name) {
1127         int r;
1128
1129         assert(name);
1130
1131         if (pid == 0)
1132                 r = readlink_malloc("/proc/self/exe", name);
1133         else {
1134                 char *p;
1135                 if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)
1136                         return -ENOMEM;
1137
1138                 r = readlink_malloc(p, name);
1139                 free(p);
1140         }
1141
1142         return r;
1143 }
1144
1145 int get_process_uid(pid_t pid, uid_t *uid) {
1146         char *p;
1147         FILE *f;
1148         int r;
1149
1150         assert(uid);
1151
1152         if (pid == 0)
1153                 return getuid();
1154
1155         if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)
1156                 return -ENOMEM;
1157
1158         f = fopen(p, "re");
1159         free(p);
1160
1161         if (!f)
1162                 return -errno;
1163
1164         while (!feof(f)) {
1165                 char line[LINE_MAX], *l;
1166
1167                 if (!fgets(line, sizeof(line), f)) {
1168                         if (feof(f))
1169                                 break;
1170
1171                         r = -errno;
1172                         goto finish;
1173                 }
1174
1175                 l = strstrip(line);
1176
1177                 if (startswith(l, "Uid:")) {
1178                         l += 4;
1179                         l += strspn(l, WHITESPACE);
1180
1181                         l[strcspn(l, WHITESPACE)] = 0;
1182
1183                         r = parse_uid(l, uid);
1184                         goto finish;
1185                 }
1186         }
1187
1188         r = -EIO;
1189
1190 finish:
1191         fclose(f);
1192
1193         return r;
1194 }
1195
1196 char *strnappend(const char *s, const char *suffix, size_t b) {
1197         size_t a;
1198         char *r;
1199
1200         if (!s && !suffix)
1201                 return strdup("");
1202
1203         if (!s)
1204                 return strndup(suffix, b);
1205
1206         if (!suffix)
1207                 return strdup(s);
1208
1209         assert(s);
1210         assert(suffix);
1211
1212         a = strlen(s);
1213
1214         if (!(r = new(char, a+b+1)))
1215                 return NULL;
1216
1217         memcpy(r, s, a);
1218         memcpy(r+a, suffix, b);
1219         r[a+b] = 0;
1220
1221         return r;
1222 }
1223
1224 char *strappend(const char *s, const char *suffix) {
1225         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
1226 }
1227
1228 int readlink_malloc(const char *p, char **r) {
1229         size_t l = 100;
1230
1231         assert(p);
1232         assert(r);
1233
1234         for (;;) {
1235                 char *c;
1236                 ssize_t n;
1237
1238                 if (!(c = new(char, l)))
1239                         return -ENOMEM;
1240
1241                 if ((n = readlink(p, c, l-1)) < 0) {
1242                         int ret = -errno;
1243                         free(c);
1244                         return ret;
1245                 }
1246
1247                 if ((size_t) n < l-1) {
1248                         c[n] = 0;
1249                         *r = c;
1250                         return 0;
1251                 }
1252
1253                 free(c);
1254                 l *= 2;
1255         }
1256 }
1257
1258 int readlink_and_make_absolute(const char *p, char **r) {
1259         char *target, *k;
1260         int j;
1261
1262         assert(p);
1263         assert(r);
1264
1265         if ((j = readlink_malloc(p, &target)) < 0)
1266                 return j;
1267
1268         k = file_in_same_dir(p, target);
1269         free(target);
1270
1271         if (!k)
1272                 return -ENOMEM;
1273
1274         *r = k;
1275         return 0;
1276 }
1277
1278 int readlink_and_canonicalize(const char *p, char **r) {
1279         char *t, *s;
1280         int j;
1281
1282         assert(p);
1283         assert(r);
1284
1285         j = readlink_and_make_absolute(p, &t);
1286         if (j < 0)
1287                 return j;
1288
1289         s = canonicalize_file_name(t);
1290         if (s) {
1291                 free(t);
1292                 *r = s;
1293         } else
1294                 *r = t;
1295
1296         path_kill_slashes(*r);
1297
1298         return 0;
1299 }
1300
1301 int reset_all_signal_handlers(void) {
1302         int sig;
1303
1304         for (sig = 1; sig < _NSIG; sig++) {
1305                 struct sigaction sa;
1306
1307                 if (sig == SIGKILL || sig == SIGSTOP)
1308                         continue;
1309
1310                 zero(sa);
1311                 sa.sa_handler = SIG_DFL;
1312                 sa.sa_flags = SA_RESTART;
1313
1314                 /* On Linux the first two RT signals are reserved by
1315                  * glibc, and sigaction() will return EINVAL for them. */
1316                 if ((sigaction(sig, &sa, NULL) < 0))
1317                         if (errno != EINVAL)
1318                                 return -errno;
1319         }
1320
1321         return 0;
1322 }
1323
1324 char *strstrip(char *s) {
1325         char *e;
1326
1327         /* Drops trailing whitespace. Modifies the string in
1328          * place. Returns pointer to first non-space character */
1329
1330         s += strspn(s, WHITESPACE);
1331
1332         for (e = strchr(s, 0); e > s; e --)
1333                 if (!strchr(WHITESPACE, e[-1]))
1334                         break;
1335
1336         *e = 0;
1337
1338         return s;
1339 }
1340
1341 char *delete_chars(char *s, const char *bad) {
1342         char *f, *t;
1343
1344         /* Drops all whitespace, regardless where in the string */
1345
1346         for (f = s, t = s; *f; f++) {
1347                 if (strchr(bad, *f))
1348                         continue;
1349
1350                 *(t++) = *f;
1351         }
1352
1353         *t = 0;
1354
1355         return s;
1356 }
1357
1358 bool in_charset(const char *s, const char* charset) {
1359         const char *i;
1360
1361         assert(s);
1362         assert(charset);
1363
1364         for (i = s; *i; i++)
1365                 if (!strchr(charset, *i))
1366                         return false;
1367
1368         return true;
1369 }
1370
1371 char *file_in_same_dir(const char *path, const char *filename) {
1372         char *e, *r;
1373         size_t k;
1374
1375         assert(path);
1376         assert(filename);
1377
1378         /* This removes the last component of path and appends
1379          * filename, unless the latter is absolute anyway or the
1380          * former isn't */
1381
1382         if (path_is_absolute(filename))
1383                 return strdup(filename);
1384
1385         if (!(e = strrchr(path, '/')))
1386                 return strdup(filename);
1387
1388         k = strlen(filename);
1389         if (!(r = new(char, e-path+1+k+1)))
1390                 return NULL;
1391
1392         memcpy(r, path, e-path+1);
1393         memcpy(r+(e-path)+1, filename, k+1);
1394
1395         return r;
1396 }
1397
1398 int rmdir_parents(const char *path, const char *stop) {
1399         size_t l;
1400         int r = 0;
1401
1402         assert(path);
1403         assert(stop);
1404
1405         l = strlen(path);
1406
1407         /* Skip trailing slashes */
1408         while (l > 0 && path[l-1] == '/')
1409                 l--;
1410
1411         while (l > 0) {
1412                 char *t;
1413
1414                 /* Skip last component */
1415                 while (l > 0 && path[l-1] != '/')
1416                         l--;
1417
1418                 /* Skip trailing slashes */
1419                 while (l > 0 && path[l-1] == '/')
1420                         l--;
1421
1422                 if (l <= 0)
1423                         break;
1424
1425                 if (!(t = strndup(path, l)))
1426                         return -ENOMEM;
1427
1428                 if (path_startswith(stop, t)) {
1429                         free(t);
1430                         return 0;
1431                 }
1432
1433                 r = rmdir(t);
1434                 free(t);
1435
1436                 if (r < 0)
1437                         if (errno != ENOENT)
1438                                 return -errno;
1439         }
1440
1441         return 0;
1442 }
1443
1444
1445 char hexchar(int x) {
1446         static const char table[16] = "0123456789abcdef";
1447
1448         return table[x & 15];
1449 }
1450
1451 int unhexchar(char c) {
1452
1453         if (c >= '0' && c <= '9')
1454                 return c - '0';
1455
1456         if (c >= 'a' && c <= 'f')
1457                 return c - 'a' + 10;
1458
1459         if (c >= 'A' && c <= 'F')
1460                 return c - 'A' + 10;
1461
1462         return -1;
1463 }
1464
1465 char octchar(int x) {
1466         return '0' + (x & 7);
1467 }
1468
1469 int unoctchar(char c) {
1470
1471         if (c >= '0' && c <= '7')
1472                 return c - '0';
1473
1474         return -1;
1475 }
1476
1477 char decchar(int x) {
1478         return '0' + (x % 10);
1479 }
1480
1481 int undecchar(char c) {
1482
1483         if (c >= '0' && c <= '9')
1484                 return c - '0';
1485
1486         return -1;
1487 }
1488
1489 char *cescape(const char *s) {
1490         char *r, *t;
1491         const char *f;
1492
1493         assert(s);
1494
1495         /* Does C style string escaping. */
1496
1497         r = new(char, strlen(s)*4 + 1);
1498         if (!r)
1499                 return NULL;
1500
1501         for (f = s, t = r; *f; f++)
1502
1503                 switch (*f) {
1504
1505                 case '\a':
1506                         *(t++) = '\\';
1507                         *(t++) = 'a';
1508                         break;
1509                 case '\b':
1510                         *(t++) = '\\';
1511                         *(t++) = 'b';
1512                         break;
1513                 case '\f':
1514                         *(t++) = '\\';
1515                         *(t++) = 'f';
1516                         break;
1517                 case '\n':
1518                         *(t++) = '\\';
1519                         *(t++) = 'n';
1520                         break;
1521                 case '\r':
1522                         *(t++) = '\\';
1523                         *(t++) = 'r';
1524                         break;
1525                 case '\t':
1526                         *(t++) = '\\';
1527                         *(t++) = 't';
1528                         break;
1529                 case '\v':
1530                         *(t++) = '\\';
1531                         *(t++) = 'v';
1532                         break;
1533                 case '\\':
1534                         *(t++) = '\\';
1535                         *(t++) = '\\';
1536                         break;
1537                 case '"':
1538                         *(t++) = '\\';
1539                         *(t++) = '"';
1540                         break;
1541                 case '\'':
1542                         *(t++) = '\\';
1543                         *(t++) = '\'';
1544                         break;
1545
1546                 default:
1547                         /* For special chars we prefer octal over
1548                          * hexadecimal encoding, simply because glib's
1549                          * g_strescape() does the same */
1550                         if ((*f < ' ') || (*f >= 127)) {
1551                                 *(t++) = '\\';
1552                                 *(t++) = octchar((unsigned char) *f >> 6);
1553                                 *(t++) = octchar((unsigned char) *f >> 3);
1554                                 *(t++) = octchar((unsigned char) *f);
1555                         } else
1556                                 *(t++) = *f;
1557                         break;
1558                 }
1559
1560         *t = 0;
1561
1562         return r;
1563 }
1564
1565 char *cunescape_length(const char *s, size_t length) {
1566         char *r, *t;
1567         const char *f;
1568
1569         assert(s);
1570
1571         /* Undoes C style string escaping */
1572
1573         r = new(char, length+1);
1574         if (!r)
1575                 return r;
1576
1577         for (f = s, t = r; f < s + length; f++) {
1578
1579                 if (*f != '\\') {
1580                         *(t++) = *f;
1581                         continue;
1582                 }
1583
1584                 f++;
1585
1586                 switch (*f) {
1587
1588                 case 'a':
1589                         *(t++) = '\a';
1590                         break;
1591                 case 'b':
1592                         *(t++) = '\b';
1593                         break;
1594                 case 'f':
1595                         *(t++) = '\f';
1596                         break;
1597                 case 'n':
1598                         *(t++) = '\n';
1599                         break;
1600                 case 'r':
1601                         *(t++) = '\r';
1602                         break;
1603                 case 't':
1604                         *(t++) = '\t';
1605                         break;
1606                 case 'v':
1607                         *(t++) = '\v';
1608                         break;
1609                 case '\\':
1610                         *(t++) = '\\';
1611                         break;
1612                 case '"':
1613                         *(t++) = '"';
1614                         break;
1615                 case '\'':
1616                         *(t++) = '\'';
1617                         break;
1618
1619                 case 's':
1620                         /* This is an extension of the XDG syntax files */
1621                         *(t++) = ' ';
1622                         break;
1623
1624                 case 'x': {
1625                         /* hexadecimal encoding */
1626                         int a, b;
1627
1628                         a = unhexchar(f[1]);
1629                         b = unhexchar(f[2]);
1630
1631                         if (a < 0 || b < 0) {
1632                                 /* Invalid escape code, let's take it literal then */
1633                                 *(t++) = '\\';
1634                                 *(t++) = 'x';
1635                         } else {
1636                                 *(t++) = (char) ((a << 4) | b);
1637                                 f += 2;
1638                         }
1639
1640                         break;
1641                 }
1642
1643                 case '0':
1644                 case '1':
1645                 case '2':
1646                 case '3':
1647                 case '4':
1648                 case '5':
1649                 case '6':
1650                 case '7': {
1651                         /* octal encoding */
1652                         int a, b, c;
1653
1654                         a = unoctchar(f[0]);
1655                         b = unoctchar(f[1]);
1656                         c = unoctchar(f[2]);
1657
1658                         if (a < 0 || b < 0 || c < 0) {
1659                                 /* Invalid escape code, let's take it literal then */
1660                                 *(t++) = '\\';
1661                                 *(t++) = f[0];
1662                         } else {
1663                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1664                                 f += 2;
1665                         }
1666
1667                         break;
1668                 }
1669
1670                 case 0:
1671                         /* premature end of string.*/
1672                         *(t++) = '\\';
1673                         goto finish;
1674
1675                 default:
1676                         /* Invalid escape code, let's take it literal then */
1677                         *(t++) = '\\';
1678                         *(t++) = *f;
1679                         break;
1680                 }
1681         }
1682
1683 finish:
1684         *t = 0;
1685         return r;
1686 }
1687
1688 char *cunescape(const char *s) {
1689         return cunescape_length(s, strlen(s));
1690 }
1691
1692 char *xescape(const char *s, const char *bad) {
1693         char *r, *t;
1694         const char *f;
1695
1696         /* Escapes all chars in bad, in addition to \ and all special
1697          * chars, in \xFF style escaping. May be reversed with
1698          * cunescape. */
1699
1700         if (!(r = new(char, strlen(s)*4+1)))
1701                 return NULL;
1702
1703         for (f = s, t = r; *f; f++) {
1704
1705                 if ((*f < ' ') || (*f >= 127) ||
1706                     (*f == '\\') || strchr(bad, *f)) {
1707                         *(t++) = '\\';
1708                         *(t++) = 'x';
1709                         *(t++) = hexchar(*f >> 4);
1710                         *(t++) = hexchar(*f);
1711                 } else
1712                         *(t++) = *f;
1713         }
1714
1715         *t = 0;
1716
1717         return r;
1718 }
1719
1720 char *bus_path_escape(const char *s) {
1721         char *r, *t;
1722         const char *f;
1723
1724         assert(s);
1725
1726         /* Escapes all chars that D-Bus' object path cannot deal
1727          * with. Can be reverse with bus_path_unescape() */
1728
1729         if (!(r = new(char, strlen(s)*3+1)))
1730                 return NULL;
1731
1732         for (f = s, t = r; *f; f++) {
1733
1734                 if (!(*f >= 'A' && *f <= 'Z') &&
1735                     !(*f >= 'a' && *f <= 'z') &&
1736                     !(*f >= '0' && *f <= '9')) {
1737                         *(t++) = '_';
1738                         *(t++) = hexchar(*f >> 4);
1739                         *(t++) = hexchar(*f);
1740                 } else
1741                         *(t++) = *f;
1742         }
1743
1744         *t = 0;
1745
1746         return r;
1747 }
1748
1749 char *bus_path_unescape(const char *f) {
1750         char *r, *t;
1751
1752         assert(f);
1753
1754         if (!(r = strdup(f)))
1755                 return NULL;
1756
1757         for (t = r; *f; f++) {
1758
1759                 if (*f == '_') {
1760                         int a, b;
1761
1762                         if ((a = unhexchar(f[1])) < 0 ||
1763                             (b = unhexchar(f[2])) < 0) {
1764                                 /* Invalid escape code, let's take it literal then */
1765                                 *(t++) = '_';
1766                         } else {
1767                                 *(t++) = (char) ((a << 4) | b);
1768                                 f += 2;
1769                         }
1770                 } else
1771                         *(t++) = *f;
1772         }
1773
1774         *t = 0;
1775
1776         return r;
1777 }
1778
1779 char *ascii_strlower(char *t) {
1780         char *p;
1781
1782         assert(t);
1783
1784         for (p = t; *p; p++)
1785                 if (*p >= 'A' && *p <= 'Z')
1786                         *p = *p - 'A' + 'a';
1787
1788         return t;
1789 }
1790
1791 bool ignore_file(const char *filename) {
1792         assert(filename);
1793
1794         return
1795                 filename[0] == '.' ||
1796                 streq(filename, "lost+found") ||
1797                 streq(filename, "aquota.user") ||
1798                 streq(filename, "aquota.group") ||
1799                 endswith(filename, "~") ||
1800                 endswith(filename, ".rpmnew") ||
1801                 endswith(filename, ".rpmsave") ||
1802                 endswith(filename, ".rpmorig") ||
1803                 endswith(filename, ".dpkg-old") ||
1804                 endswith(filename, ".dpkg-new") ||
1805                 endswith(filename, ".swp");
1806 }
1807
1808 int fd_nonblock(int fd, bool nonblock) {
1809         int flags;
1810
1811         assert(fd >= 0);
1812
1813         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1814                 return -errno;
1815
1816         if (nonblock)
1817                 flags |= O_NONBLOCK;
1818         else
1819                 flags &= ~O_NONBLOCK;
1820
1821         if (fcntl(fd, F_SETFL, flags) < 0)
1822                 return -errno;
1823
1824         return 0;
1825 }
1826
1827 int fd_cloexec(int fd, bool cloexec) {
1828         int flags;
1829
1830         assert(fd >= 0);
1831
1832         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1833                 return -errno;
1834
1835         if (cloexec)
1836                 flags |= FD_CLOEXEC;
1837         else
1838                 flags &= ~FD_CLOEXEC;
1839
1840         if (fcntl(fd, F_SETFD, flags) < 0)
1841                 return -errno;
1842
1843         return 0;
1844 }
1845
1846 static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1847         unsigned i;
1848
1849         assert(n_fdset == 0 || fdset);
1850
1851         for (i = 0; i < n_fdset; i++)
1852                 if (fdset[i] == fd)
1853                         return true;
1854
1855         return false;
1856 }
1857
1858 int close_all_fds(const int except[], unsigned n_except) {
1859         DIR *d;
1860         struct dirent *de;
1861         int r = 0;
1862
1863         assert(n_except == 0 || except);
1864
1865         d = opendir("/proc/self/fd");
1866         if (!d) {
1867                 int fd;
1868                 struct rlimit rl;
1869
1870                 /* When /proc isn't available (for example in chroots)
1871                  * the fallback is brute forcing through the fd
1872                  * table */
1873
1874                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1875                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1876
1877                         if (fd_in_set(fd, except, n_except))
1878                                 continue;
1879
1880                         if (close_nointr(fd) < 0)
1881                                 if (errno != EBADF && r == 0)
1882                                         r = -errno;
1883                 }
1884
1885                 return r;
1886         }
1887
1888         while ((de = readdir(d))) {
1889                 int fd = -1;
1890
1891                 if (ignore_file(de->d_name))
1892                         continue;
1893
1894                 if (safe_atoi(de->d_name, &fd) < 0)
1895                         /* Let's better ignore this, just in case */
1896                         continue;
1897
1898                 if (fd < 3)
1899                         continue;
1900
1901                 if (fd == dirfd(d))
1902                         continue;
1903
1904                 if (fd_in_set(fd, except, n_except))
1905                         continue;
1906
1907                 if (close_nointr(fd) < 0) {
1908                         /* Valgrind has its own FD and doesn't want to have it closed */
1909                         if (errno != EBADF && r == 0)
1910                                 r = -errno;
1911                 }
1912         }
1913
1914         closedir(d);
1915         return r;
1916 }
1917
1918 bool chars_intersect(const char *a, const char *b) {
1919         const char *p;
1920
1921         /* Returns true if any of the chars in a are in b. */
1922         for (p = a; *p; p++)
1923                 if (strchr(b, *p))
1924                         return true;
1925
1926         return false;
1927 }
1928
1929 char *format_timestamp(char *buf, size_t l, usec_t t) {
1930         struct tm tm;
1931         time_t sec;
1932
1933         assert(buf);
1934         assert(l > 0);
1935
1936         if (t <= 0)
1937                 return NULL;
1938
1939         sec = (time_t) (t / USEC_PER_SEC);
1940
1941         if (strftime(buf, l, "%a, %d %b %Y %H:%M:%S %z", localtime_r(&sec, &tm)) <= 0)
1942                 return NULL;
1943
1944         return buf;
1945 }
1946
1947 char *format_timestamp_pretty(char *buf, size_t l, usec_t t) {
1948         usec_t n, d;
1949
1950         n = now(CLOCK_REALTIME);
1951
1952         if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
1953                 return NULL;
1954
1955         d = n - t;
1956
1957         if (d >= USEC_PER_YEAR)
1958                 snprintf(buf, l, "%llu years and %llu months ago",
1959                          (unsigned long long) (d / USEC_PER_YEAR),
1960                          (unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
1961         else if (d >= USEC_PER_MONTH)
1962                 snprintf(buf, l, "%llu months and %llu days ago",
1963                          (unsigned long long) (d / USEC_PER_MONTH),
1964                          (unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
1965         else if (d >= USEC_PER_WEEK)
1966                 snprintf(buf, l, "%llu weeks and %llu days ago",
1967                          (unsigned long long) (d / USEC_PER_WEEK),
1968                          (unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
1969         else if (d >= 2*USEC_PER_DAY)
1970                 snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
1971         else if (d >= 25*USEC_PER_HOUR)
1972                 snprintf(buf, l, "1 day and %lluh ago",
1973                          (unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
1974         else if (d >= 6*USEC_PER_HOUR)
1975                 snprintf(buf, l, "%lluh ago",
1976                          (unsigned long long) (d / USEC_PER_HOUR));
1977         else if (d >= USEC_PER_HOUR)
1978                 snprintf(buf, l, "%lluh %llumin ago",
1979                          (unsigned long long) (d / USEC_PER_HOUR),
1980                          (unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
1981         else if (d >= 5*USEC_PER_MINUTE)
1982                 snprintf(buf, l, "%llumin ago",
1983                          (unsigned long long) (d / USEC_PER_MINUTE));
1984         else if (d >= USEC_PER_MINUTE)
1985                 snprintf(buf, l, "%llumin %llus ago",
1986                          (unsigned long long) (d / USEC_PER_MINUTE),
1987                          (unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
1988         else if (d >= USEC_PER_SEC)
1989                 snprintf(buf, l, "%llus ago",
1990                          (unsigned long long) (d / USEC_PER_SEC));
1991         else if (d >= USEC_PER_MSEC)
1992                 snprintf(buf, l, "%llums ago",
1993                          (unsigned long long) (d / USEC_PER_MSEC));
1994         else if (d > 0)
1995                 snprintf(buf, l, "%lluus ago",
1996                          (unsigned long long) d);
1997         else
1998                 snprintf(buf, l, "now");
1999
2000         buf[l-1] = 0;
2001         return buf;
2002 }
2003
2004 char *format_timespan(char *buf, size_t l, usec_t t) {
2005         static const struct {
2006                 const char *suffix;
2007                 usec_t usec;
2008         } table[] = {
2009                 { "w", USEC_PER_WEEK },
2010                 { "d", USEC_PER_DAY },
2011                 { "h", USEC_PER_HOUR },
2012                 { "min", USEC_PER_MINUTE },
2013                 { "s", USEC_PER_SEC },
2014                 { "ms", USEC_PER_MSEC },
2015                 { "us", 1 },
2016         };
2017
2018         unsigned i;
2019         char *p = buf;
2020
2021         assert(buf);
2022         assert(l > 0);
2023
2024         if (t == (usec_t) -1)
2025                 return NULL;
2026
2027         if (t == 0) {
2028                 snprintf(p, l, "0");
2029                 p[l-1] = 0;
2030                 return p;
2031         }
2032
2033         /* The result of this function can be parsed with parse_usec */
2034
2035         for (i = 0; i < ELEMENTSOF(table); i++) {
2036                 int k;
2037                 size_t n;
2038
2039                 if (t < table[i].usec)
2040                         continue;
2041
2042                 if (l <= 1)
2043                         break;
2044
2045                 k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
2046                 n = MIN((size_t) k, l);
2047
2048                 l -= n;
2049                 p += n;
2050
2051                 t %= table[i].usec;
2052         }
2053
2054         *p = 0;
2055
2056         return buf;
2057 }
2058
2059 bool fstype_is_network(const char *fstype) {
2060         static const char * const table[] = {
2061                 "cifs",
2062                 "smbfs",
2063                 "ncpfs",
2064                 "nfs",
2065                 "nfs4",
2066                 "gfs",
2067                 "gfs2"
2068         };
2069
2070         unsigned i;
2071
2072         for (i = 0; i < ELEMENTSOF(table); i++)
2073                 if (streq(table[i], fstype))
2074                         return true;
2075
2076         return false;
2077 }
2078
2079 int chvt(int vt) {
2080         int fd, r = 0;
2081
2082         if ((fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC)) < 0)
2083                 return -errno;
2084
2085         if (vt < 0) {
2086                 int tiocl[2] = {
2087                         TIOCL_GETKMSGREDIRECT,
2088                         0
2089                 };
2090
2091                 if (ioctl(fd, TIOCLINUX, tiocl) < 0) {
2092                         r = -errno;
2093                         goto fail;
2094                 }
2095
2096                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
2097         }
2098
2099         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
2100                 r = -errno;
2101
2102 fail:
2103         close_nointr_nofail(fd);
2104         return r;
2105 }
2106
2107 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
2108         struct termios old_termios, new_termios;
2109         char c;
2110         char line[LINE_MAX];
2111
2112         assert(f);
2113         assert(ret);
2114
2115         if (tcgetattr(fileno(f), &old_termios) >= 0) {
2116                 new_termios = old_termios;
2117
2118                 new_termios.c_lflag &= ~ICANON;
2119                 new_termios.c_cc[VMIN] = 1;
2120                 new_termios.c_cc[VTIME] = 0;
2121
2122                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
2123                         size_t k;
2124
2125                         if (t != (usec_t) -1) {
2126                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
2127                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2128                                         return -ETIMEDOUT;
2129                                 }
2130                         }
2131
2132                         k = fread(&c, 1, 1, f);
2133
2134                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
2135
2136                         if (k <= 0)
2137                                 return -EIO;
2138
2139                         if (need_nl)
2140                                 *need_nl = c != '\n';
2141
2142                         *ret = c;
2143                         return 0;
2144                 }
2145         }
2146
2147         if (t != (usec_t) -1)
2148                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
2149                         return -ETIMEDOUT;
2150
2151         if (!fgets(line, sizeof(line), f))
2152                 return -EIO;
2153
2154         truncate_nl(line);
2155
2156         if (strlen(line) != 1)
2157                 return -EBADMSG;
2158
2159         if (need_nl)
2160                 *need_nl = false;
2161
2162         *ret = line[0];
2163         return 0;
2164 }
2165
2166 int ask(char *ret, const char *replies, const char *text, ...) {
2167         bool on_tty;
2168
2169         assert(ret);
2170         assert(replies);
2171         assert(text);
2172
2173         on_tty = isatty(STDOUT_FILENO);
2174
2175         for (;;) {
2176                 va_list ap;
2177                 char c;
2178                 int r;
2179                 bool need_nl = true;
2180
2181                 if (on_tty)
2182                         fputs(ANSI_HIGHLIGHT_ON, stdout);
2183
2184                 va_start(ap, text);
2185                 vprintf(text, ap);
2186                 va_end(ap);
2187
2188                 if (on_tty)
2189                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
2190
2191                 fflush(stdout);
2192
2193                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
2194                 if (r < 0) {
2195
2196                         if (r == -EBADMSG) {
2197                                 puts("Bad input, please try again.");
2198                                 continue;
2199                         }
2200
2201                         putchar('\n');
2202                         return r;
2203                 }
2204
2205                 if (need_nl)
2206                         putchar('\n');
2207
2208                 if (strchr(replies, c)) {
2209                         *ret = c;
2210                         return 0;
2211                 }
2212
2213                 puts("Read unexpected character, please try again.");
2214         }
2215 }
2216
2217 int reset_terminal_fd(int fd, bool switch_to_text) {
2218         struct termios termios;
2219         int r = 0;
2220
2221         /* Set terminal to some sane defaults */
2222
2223         assert(fd >= 0);
2224
2225         /* We leave locked terminal attributes untouched, so that
2226          * Plymouth may set whatever it wants to set, and we don't
2227          * interfere with that. */
2228
2229         /* Disable exclusive mode, just in case */
2230         ioctl(fd, TIOCNXCL);
2231
2232         /* Switch to text mode */
2233         if (switch_to_text)
2234                 ioctl(fd, KDSETMODE, KD_TEXT);
2235
2236         /* Enable console unicode mode */
2237         ioctl(fd, KDSKBMODE, K_UNICODE);
2238
2239         if (tcgetattr(fd, &termios) < 0) {
2240                 r = -errno;
2241                 goto finish;
2242         }
2243
2244         /* We only reset the stuff that matters to the software. How
2245          * hardware is set up we don't touch assuming that somebody
2246          * else will do that for us */
2247
2248         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
2249         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
2250         termios.c_oflag |= ONLCR;
2251         termios.c_cflag |= CREAD;
2252         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
2253
2254         termios.c_cc[VINTR]    =   03;  /* ^C */
2255         termios.c_cc[VQUIT]    =  034;  /* ^\ */
2256         termios.c_cc[VERASE]   = 0177;
2257         termios.c_cc[VKILL]    =  025;  /* ^X */
2258         termios.c_cc[VEOF]     =   04;  /* ^D */
2259         termios.c_cc[VSTART]   =  021;  /* ^Q */
2260         termios.c_cc[VSTOP]    =  023;  /* ^S */
2261         termios.c_cc[VSUSP]    =  032;  /* ^Z */
2262         termios.c_cc[VLNEXT]   =  026;  /* ^V */
2263         termios.c_cc[VWERASE]  =  027;  /* ^W */
2264         termios.c_cc[VREPRINT] =  022;  /* ^R */
2265         termios.c_cc[VEOL]     =    0;
2266         termios.c_cc[VEOL2]    =    0;
2267
2268         termios.c_cc[VTIME]  = 0;
2269         termios.c_cc[VMIN]   = 1;
2270
2271         if (tcsetattr(fd, TCSANOW, &termios) < 0)
2272                 r = -errno;
2273
2274 finish:
2275         /* Just in case, flush all crap out */
2276         tcflush(fd, TCIOFLUSH);
2277
2278         return r;
2279 }
2280
2281 int reset_terminal(const char *name) {
2282         int fd, r;
2283
2284         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2285         if (fd < 0)
2286                 return fd;
2287
2288         r = reset_terminal_fd(fd, true);
2289         close_nointr_nofail(fd);
2290
2291         return r;
2292 }
2293
2294 int open_terminal(const char *name, int mode) {
2295         int fd, r;
2296         unsigned c = 0;
2297
2298         /*
2299          * If a TTY is in the process of being closed opening it might
2300          * cause EIO. This is horribly awful, but unlikely to be
2301          * changed in the kernel. Hence we work around this problem by
2302          * retrying a couple of times.
2303          *
2304          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
2305          */
2306
2307         for (;;) {
2308                 fd = open(name, mode);
2309                 if (fd >= 0)
2310                         break;
2311
2312                 if (errno != EIO)
2313                         return -errno;
2314
2315                 /* Max 1s in total */
2316                 if (c >= 20)
2317                         return -errno;
2318
2319                 usleep(50 * USEC_PER_MSEC);
2320                 c++;
2321         }
2322
2323         if (fd < 0)
2324                 return -errno;
2325
2326         r = isatty(fd);
2327         if (r < 0) {
2328                 close_nointr_nofail(fd);
2329                 return -errno;
2330         }
2331
2332         if (!r) {
2333                 close_nointr_nofail(fd);
2334                 return -ENOTTY;
2335         }
2336
2337         return fd;
2338 }
2339
2340 int flush_fd(int fd) {
2341         struct pollfd pollfd;
2342
2343         zero(pollfd);
2344         pollfd.fd = fd;
2345         pollfd.events = POLLIN;
2346
2347         for (;;) {
2348                 char buf[LINE_MAX];
2349                 ssize_t l;
2350                 int r;
2351
2352                 if ((r = poll(&pollfd, 1, 0)) < 0) {
2353
2354                         if (errno == EINTR)
2355                                 continue;
2356
2357                         return -errno;
2358                 }
2359
2360                 if (r == 0)
2361                         return 0;
2362
2363                 if ((l = read(fd, buf, sizeof(buf))) < 0) {
2364
2365                         if (errno == EINTR)
2366                                 continue;
2367
2368                         if (errno == EAGAIN)
2369                                 return 0;
2370
2371                         return -errno;
2372                 }
2373
2374                 if (l <= 0)
2375                         return 0;
2376         }
2377 }
2378
2379 int acquire_terminal(
2380                 const char *name,
2381                 bool fail,
2382                 bool force,
2383                 bool ignore_tiocstty_eperm,
2384                 usec_t timeout) {
2385
2386         int fd = -1, notify = -1, r, wd = -1;
2387         usec_t ts = 0;
2388
2389         assert(name);
2390
2391         /* We use inotify to be notified when the tty is closed. We
2392          * create the watch before checking if we can actually acquire
2393          * it, so that we don't lose any event.
2394          *
2395          * Note: strictly speaking this actually watches for the
2396          * device being closed, it does *not* really watch whether a
2397          * tty loses its controlling process. However, unless some
2398          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2399          * its tty otherwise this will not become a problem. As long
2400          * as the administrator makes sure not configure any service
2401          * on the same tty as an untrusted user this should not be a
2402          * problem. (Which he probably should not do anyway.) */
2403
2404         if (timeout != (usec_t) -1)
2405                 ts = now(CLOCK_MONOTONIC);
2406
2407         if (!fail && !force) {
2408                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
2409                 if (notify < 0) {
2410                         r = -errno;
2411                         goto fail;
2412                 }
2413
2414                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2415                 if (wd < 0) {
2416                         r = -errno;
2417                         goto fail;
2418                 }
2419         }
2420
2421         for (;;) {
2422                 if (notify >= 0) {
2423                         r = flush_fd(notify);
2424                         if (r < 0)
2425                                 goto fail;
2426                 }
2427
2428                 /* We pass here O_NOCTTY only so that we can check the return
2429                  * value TIOCSCTTY and have a reliable way to figure out if we
2430                  * successfully became the controlling process of the tty */
2431                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2432                 if (fd < 0)
2433                         return fd;
2434
2435                 /* First, try to get the tty */
2436                 r = ioctl(fd, TIOCSCTTY, force);
2437
2438                 /* Sometimes it makes sense to ignore TIOCSCTTY
2439                  * returning EPERM, i.e. when very likely we already
2440                  * are have this controlling terminal. */
2441                 if (r < 0 && errno == EPERM && ignore_tiocstty_eperm)
2442                         r = 0;
2443
2444                 if (r < 0 && (force || fail || errno != EPERM)) {
2445                         r = -errno;
2446                         goto fail;
2447                 }
2448
2449                 if (r >= 0)
2450                         break;
2451
2452                 assert(!fail);
2453                 assert(!force);
2454                 assert(notify >= 0);
2455
2456                 for (;;) {
2457                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2458                         ssize_t l;
2459                         struct inotify_event *e;
2460
2461                         if (timeout != (usec_t) -1) {
2462                                 usec_t n;
2463
2464                                 n = now(CLOCK_MONOTONIC);
2465                                 if (ts + timeout < n) {
2466                                         r = -ETIMEDOUT;
2467                                         goto fail;
2468                                 }
2469
2470                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2471                                 if (r < 0)
2472                                         goto fail;
2473
2474                                 if (r == 0) {
2475                                         r = -ETIMEDOUT;
2476                                         goto fail;
2477                                 }
2478                         }
2479
2480                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2481                         if (l < 0) {
2482
2483                                 if (errno == EINTR || errno == EAGAIN)
2484                                         continue;
2485
2486                                 r = -errno;
2487                                 goto fail;
2488                         }
2489
2490                         e = (struct inotify_event*) inotify_buffer;
2491
2492                         while (l > 0) {
2493                                 size_t step;
2494
2495                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2496                                         r = -EIO;
2497                                         goto fail;
2498                                 }
2499
2500                                 step = sizeof(struct inotify_event) + e->len;
2501                                 assert(step <= (size_t) l);
2502
2503                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2504                                 l -= step;
2505                         }
2506
2507                         break;
2508                 }
2509
2510                 /* We close the tty fd here since if the old session
2511                  * ended our handle will be dead. It's important that
2512                  * we do this after sleeping, so that we don't enter
2513                  * an endless loop. */
2514                 close_nointr_nofail(fd);
2515         }
2516
2517         if (notify >= 0)
2518                 close_nointr_nofail(notify);
2519
2520         r = reset_terminal_fd(fd, true);
2521         if (r < 0)
2522                 log_warning("Failed to reset terminal: %s", strerror(-r));
2523
2524         return fd;
2525
2526 fail:
2527         if (fd >= 0)
2528                 close_nointr_nofail(fd);
2529
2530         if (notify >= 0)
2531                 close_nointr_nofail(notify);
2532
2533         return r;
2534 }
2535
2536 int release_terminal(void) {
2537         int r = 0, fd;
2538         struct sigaction sa_old, sa_new;
2539
2540         if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2541                 return -errno;
2542
2543         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2544          * by our own TIOCNOTTY */
2545
2546         zero(sa_new);
2547         sa_new.sa_handler = SIG_IGN;
2548         sa_new.sa_flags = SA_RESTART;
2549         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2550
2551         if (ioctl(fd, TIOCNOTTY) < 0)
2552                 r = -errno;
2553
2554         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2555
2556         close_nointr_nofail(fd);
2557         return r;
2558 }
2559
2560 int sigaction_many(const struct sigaction *sa, ...) {
2561         va_list ap;
2562         int r = 0, sig;
2563
2564         va_start(ap, sa);
2565         while ((sig = va_arg(ap, int)) > 0)
2566                 if (sigaction(sig, sa, NULL) < 0)
2567                         r = -errno;
2568         va_end(ap);
2569
2570         return r;
2571 }
2572
2573 int ignore_signals(int sig, ...) {
2574         struct sigaction sa;
2575         va_list ap;
2576         int r = 0;
2577
2578         zero(sa);
2579         sa.sa_handler = SIG_IGN;
2580         sa.sa_flags = SA_RESTART;
2581
2582         if (sigaction(sig, &sa, NULL) < 0)
2583                 r = -errno;
2584
2585         va_start(ap, sig);
2586         while ((sig = va_arg(ap, int)) > 0)
2587                 if (sigaction(sig, &sa, NULL) < 0)
2588                         r = -errno;
2589         va_end(ap);
2590
2591         return r;
2592 }
2593
2594 int default_signals(int sig, ...) {
2595         struct sigaction sa;
2596         va_list ap;
2597         int r = 0;
2598
2599         zero(sa);
2600         sa.sa_handler = SIG_DFL;
2601         sa.sa_flags = SA_RESTART;
2602
2603         if (sigaction(sig, &sa, NULL) < 0)
2604                 r = -errno;
2605
2606         va_start(ap, sig);
2607         while ((sig = va_arg(ap, int)) > 0)
2608                 if (sigaction(sig, &sa, NULL) < 0)
2609                         r = -errno;
2610         va_end(ap);
2611
2612         return r;
2613 }
2614
2615 int close_pipe(int p[]) {
2616         int a = 0, b = 0;
2617
2618         assert(p);
2619
2620         if (p[0] >= 0) {
2621                 a = close_nointr(p[0]);
2622                 p[0] = -1;
2623         }
2624
2625         if (p[1] >= 0) {
2626                 b = close_nointr(p[1]);
2627                 p[1] = -1;
2628         }
2629
2630         return a < 0 ? a : b;
2631 }
2632
2633 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2634         uint8_t *p;
2635         ssize_t n = 0;
2636
2637         assert(fd >= 0);
2638         assert(buf);
2639
2640         p = buf;
2641
2642         while (nbytes > 0) {
2643                 ssize_t k;
2644
2645                 if ((k = read(fd, p, nbytes)) <= 0) {
2646
2647                         if (k < 0 && errno == EINTR)
2648                                 continue;
2649
2650                         if (k < 0 && errno == EAGAIN && do_poll) {
2651                                 struct pollfd pollfd;
2652
2653                                 zero(pollfd);
2654                                 pollfd.fd = fd;
2655                                 pollfd.events = POLLIN;
2656
2657                                 if (poll(&pollfd, 1, -1) < 0) {
2658                                         if (errno == EINTR)
2659                                                 continue;
2660
2661                                         return n > 0 ? n : -errno;
2662                                 }
2663
2664                                 if (pollfd.revents != POLLIN)
2665                                         return n > 0 ? n : -EIO;
2666
2667                                 continue;
2668                         }
2669
2670                         return n > 0 ? n : (k < 0 ? -errno : 0);
2671                 }
2672
2673                 p += k;
2674                 nbytes -= k;
2675                 n += k;
2676         }
2677
2678         return n;
2679 }
2680
2681 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2682         const uint8_t *p;
2683         ssize_t n = 0;
2684
2685         assert(fd >= 0);
2686         assert(buf);
2687
2688         p = buf;
2689
2690         while (nbytes > 0) {
2691                 ssize_t k;
2692
2693                 k = write(fd, p, nbytes);
2694                 if (k <= 0) {
2695
2696                         if (k < 0 && errno == EINTR)
2697                                 continue;
2698
2699                         if (k < 0 && errno == EAGAIN && do_poll) {
2700                                 struct pollfd pollfd;
2701
2702                                 zero(pollfd);
2703                                 pollfd.fd = fd;
2704                                 pollfd.events = POLLOUT;
2705
2706                                 if (poll(&pollfd, 1, -1) < 0) {
2707                                         if (errno == EINTR)
2708                                                 continue;
2709
2710                                         return n > 0 ? n : -errno;
2711                                 }
2712
2713                                 if (pollfd.revents != POLLOUT)
2714                                         return n > 0 ? n : -EIO;
2715
2716                                 continue;
2717                         }
2718
2719                         return n > 0 ? n : (k < 0 ? -errno : 0);
2720                 }
2721
2722                 p += k;
2723                 nbytes -= k;
2724                 n += k;
2725         }
2726
2727         return n;
2728 }
2729
2730 int parse_usec(const char *t, usec_t *usec) {
2731         static const struct {
2732                 const char *suffix;
2733                 usec_t usec;
2734         } table[] = {
2735                 { "sec", USEC_PER_SEC },
2736                 { "s", USEC_PER_SEC },
2737                 { "min", USEC_PER_MINUTE },
2738                 { "hr", USEC_PER_HOUR },
2739                 { "h", USEC_PER_HOUR },
2740                 { "d", USEC_PER_DAY },
2741                 { "w", USEC_PER_WEEK },
2742                 { "msec", USEC_PER_MSEC },
2743                 { "ms", USEC_PER_MSEC },
2744                 { "m", USEC_PER_MINUTE },
2745                 { "usec", 1ULL },
2746                 { "us", 1ULL },
2747                 { "", USEC_PER_SEC }, /* default is sec */
2748         };
2749
2750         const char *p;
2751         usec_t r = 0;
2752
2753         assert(t);
2754         assert(usec);
2755
2756         p = t;
2757         do {
2758                 long long l;
2759                 char *e;
2760                 unsigned i;
2761
2762                 errno = 0;
2763                 l = strtoll(p, &e, 10);
2764
2765                 if (errno != 0)
2766                         return -errno;
2767
2768                 if (l < 0)
2769                         return -ERANGE;
2770
2771                 if (e == p)
2772                         return -EINVAL;
2773
2774                 e += strspn(e, WHITESPACE);
2775
2776                 for (i = 0; i < ELEMENTSOF(table); i++)
2777                         if (startswith(e, table[i].suffix)) {
2778                                 r += (usec_t) l * table[i].usec;
2779                                 p = e + strlen(table[i].suffix);
2780                                 break;
2781                         }
2782
2783                 if (i >= ELEMENTSOF(table))
2784                         return -EINVAL;
2785
2786         } while (*p != 0);
2787
2788         *usec = r;
2789
2790         return 0;
2791 }
2792
2793 int parse_nsec(const char *t, nsec_t *nsec) {
2794         static const struct {
2795                 const char *suffix;
2796                 nsec_t nsec;
2797         } table[] = {
2798                 { "sec", NSEC_PER_SEC },
2799                 { "s", NSEC_PER_SEC },
2800                 { "min", NSEC_PER_MINUTE },
2801                 { "hr", NSEC_PER_HOUR },
2802                 { "h", NSEC_PER_HOUR },
2803                 { "d", NSEC_PER_DAY },
2804                 { "w", NSEC_PER_WEEK },
2805                 { "msec", NSEC_PER_MSEC },
2806                 { "ms", NSEC_PER_MSEC },
2807                 { "m", NSEC_PER_MINUTE },
2808                 { "usec", NSEC_PER_USEC },
2809                 { "us", NSEC_PER_USEC },
2810                 { "nsec", 1ULL },
2811                 { "ns", 1ULL },
2812                 { "", 1ULL }, /* default is nsec */
2813         };
2814
2815         const char *p;
2816         nsec_t r = 0;
2817
2818         assert(t);
2819         assert(nsec);
2820
2821         p = t;
2822         do {
2823                 long long l;
2824                 char *e;
2825                 unsigned i;
2826
2827                 errno = 0;
2828                 l = strtoll(p, &e, 10);
2829
2830                 if (errno != 0)
2831                         return -errno;
2832
2833                 if (l < 0)
2834                         return -ERANGE;
2835
2836                 if (e == p)
2837                         return -EINVAL;
2838
2839                 e += strspn(e, WHITESPACE);
2840
2841                 for (i = 0; i < ELEMENTSOF(table); i++)
2842                         if (startswith(e, table[i].suffix)) {
2843                                 r += (nsec_t) l * table[i].nsec;
2844                                 p = e + strlen(table[i].suffix);
2845                                 break;
2846                         }
2847
2848                 if (i >= ELEMENTSOF(table))
2849                         return -EINVAL;
2850
2851         } while (*p != 0);
2852
2853         *nsec = r;
2854
2855         return 0;
2856 }
2857
2858 int parse_bytes(const char *t, off_t *bytes) {
2859         static const struct {
2860                 const char *suffix;
2861                 off_t factor;
2862         } table[] = {
2863                 { "B", 1 },
2864                 { "K", 1024ULL },
2865                 { "M", 1024ULL*1024ULL },
2866                 { "G", 1024ULL*1024ULL*1024ULL },
2867                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2868                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2869                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2870                 { "", 1 },
2871         };
2872
2873         const char *p;
2874         off_t r = 0;
2875
2876         assert(t);
2877         assert(bytes);
2878
2879         p = t;
2880         do {
2881                 long long l;
2882                 char *e;
2883                 unsigned i;
2884
2885                 errno = 0;
2886                 l = strtoll(p, &e, 10);
2887
2888                 if (errno != 0)
2889                         return -errno;
2890
2891                 if (l < 0)
2892                         return -ERANGE;
2893
2894                 if (e == p)
2895                         return -EINVAL;
2896
2897                 e += strspn(e, WHITESPACE);
2898
2899                 for (i = 0; i < ELEMENTSOF(table); i++)
2900                         if (startswith(e, table[i].suffix)) {
2901                                 r += (off_t) l * table[i].factor;
2902                                 p = e + strlen(table[i].suffix);
2903                                 break;
2904                         }
2905
2906                 if (i >= ELEMENTSOF(table))
2907                         return -EINVAL;
2908
2909         } while (*p != 0);
2910
2911         *bytes = r;
2912
2913         return 0;
2914 }
2915
2916 int make_stdio(int fd) {
2917         int r, s, t;
2918
2919         assert(fd >= 0);
2920
2921         r = dup2(fd, STDIN_FILENO);
2922         s = dup2(fd, STDOUT_FILENO);
2923         t = dup2(fd, STDERR_FILENO);
2924
2925         if (fd >= 3)
2926                 close_nointr_nofail(fd);
2927
2928         if (r < 0 || s < 0 || t < 0)
2929                 return -errno;
2930
2931         fd_cloexec(STDIN_FILENO, false);
2932         fd_cloexec(STDOUT_FILENO, false);
2933         fd_cloexec(STDERR_FILENO, false);
2934
2935         return 0;
2936 }
2937
2938 int make_null_stdio(void) {
2939         int null_fd;
2940
2941         if ((null_fd = open("/dev/null", O_RDWR|O_NOCTTY)) < 0)
2942                 return -errno;
2943
2944         return make_stdio(null_fd);
2945 }
2946
2947 bool is_device_path(const char *path) {
2948
2949         /* Returns true on paths that refer to a device, either in
2950          * sysfs or in /dev */
2951
2952         return
2953                 path_startswith(path, "/dev/") ||
2954                 path_startswith(path, "/sys/");
2955 }
2956
2957 int dir_is_empty(const char *path) {
2958         DIR *d;
2959         int r;
2960         struct dirent buf, *de;
2961
2962         if (!(d = opendir(path)))
2963                 return -errno;
2964
2965         for (;;) {
2966                 if ((r = readdir_r(d, &buf, &de)) > 0) {
2967                         r = -r;
2968                         break;
2969                 }
2970
2971                 if (!de) {
2972                         r = 1;
2973                         break;
2974                 }
2975
2976                 if (!ignore_file(de->d_name)) {
2977                         r = 0;
2978                         break;
2979                 }
2980         }
2981
2982         closedir(d);
2983         return r;
2984 }
2985
2986 unsigned long long random_ull(void) {
2987         int fd;
2988         uint64_t ull;
2989         ssize_t r;
2990
2991         if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0)
2992                 goto fallback;
2993
2994         r = loop_read(fd, &ull, sizeof(ull), true);
2995         close_nointr_nofail(fd);
2996
2997         if (r != sizeof(ull))
2998                 goto fallback;
2999
3000         return ull;
3001
3002 fallback:
3003         return random() * RAND_MAX + random();
3004 }
3005
3006 void rename_process(const char name[8]) {
3007         assert(name);
3008
3009         /* This is a like a poor man's setproctitle(). It changes the
3010          * comm field, argv[0], and also the glibc's internally used
3011          * name of the process. For the first one a limit of 16 chars
3012          * applies, to the second one usually one of 10 (i.e. length
3013          * of "/sbin/init"), to the third one one of 7 (i.e. length of
3014          * "systemd"). If you pass a longer string it will be
3015          * truncated */
3016
3017         prctl(PR_SET_NAME, name);
3018
3019         if (program_invocation_name)
3020                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
3021
3022         if (saved_argc > 0) {
3023                 int i;
3024
3025                 if (saved_argv[0])
3026                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
3027
3028                 for (i = 1; i < saved_argc; i++) {
3029                         if (!saved_argv[i])
3030                                 break;
3031
3032                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
3033                 }
3034         }
3035 }
3036
3037 void sigset_add_many(sigset_t *ss, ...) {
3038         va_list ap;
3039         int sig;
3040
3041         assert(ss);
3042
3043         va_start(ap, ss);
3044         while ((sig = va_arg(ap, int)) > 0)
3045                 assert_se(sigaddset(ss, sig) == 0);
3046         va_end(ap);
3047 }
3048
3049 char* gethostname_malloc(void) {
3050         struct utsname u;
3051
3052         assert_se(uname(&u) >= 0);
3053
3054         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
3055                 return strdup(u.nodename);
3056
3057         return strdup(u.sysname);
3058 }
3059
3060 bool hostname_is_set(void) {
3061         struct utsname u;
3062
3063         assert_se(uname(&u) >= 0);
3064
3065         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
3066 }
3067
3068 char* getlogname_malloc(void) {
3069         uid_t uid;
3070         long bufsize;
3071         char *buf, *name;
3072         struct passwd pwbuf, *pw = NULL;
3073         struct stat st;
3074
3075         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
3076                 uid = st.st_uid;
3077         else
3078                 uid = getuid();
3079
3080         /* Shortcut things to avoid NSS lookups */
3081         if (uid == 0)
3082                 return strdup("root");
3083
3084         if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) <= 0)
3085                 bufsize = 4096;
3086
3087         if (!(buf = malloc(bufsize)))
3088                 return NULL;
3089
3090         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw) {
3091                 name = strdup(pw->pw_name);
3092                 free(buf);
3093                 return name;
3094         }
3095
3096         free(buf);
3097
3098         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
3099                 return NULL;
3100
3101         return name;
3102 }
3103
3104 int getttyname_malloc(int fd, char **r) {
3105         char path[PATH_MAX], *c;
3106         int k;
3107
3108         assert(r);
3109
3110         if ((k = ttyname_r(fd, path, sizeof(path))) != 0)
3111                 return -k;
3112
3113         char_array_0(path);
3114
3115         if (!(c = strdup(startswith(path, "/dev/") ? path + 5 : path)))
3116                 return -ENOMEM;
3117
3118         *r = c;
3119         return 0;
3120 }
3121
3122 int getttyname_harder(int fd, char **r) {
3123         int k;
3124         char *s;
3125
3126         if ((k = getttyname_malloc(fd, &s)) < 0)
3127                 return k;
3128
3129         if (streq(s, "tty")) {
3130                 free(s);
3131                 return get_ctty(0, NULL, r);
3132         }
3133
3134         *r = s;
3135         return 0;
3136 }
3137
3138 int get_ctty_devnr(pid_t pid, dev_t *d) {
3139         int k;
3140         char line[LINE_MAX], *p, *fn;
3141         unsigned long ttynr;
3142         FILE *f;
3143
3144         if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
3145                 return -ENOMEM;
3146
3147         f = fopen(fn, "re");
3148         free(fn);
3149         if (!f)
3150                 return -errno;
3151
3152         if (!fgets(line, sizeof(line), f)) {
3153                 k = feof(f) ? -EIO : -errno;
3154                 fclose(f);
3155                 return k;
3156         }
3157
3158         fclose(f);
3159
3160         p = strrchr(line, ')');
3161         if (!p)
3162                 return -EIO;
3163
3164         p++;
3165
3166         if (sscanf(p, " "
3167                    "%*c "  /* state */
3168                    "%*d "  /* ppid */
3169                    "%*d "  /* pgrp */
3170                    "%*d "  /* session */
3171                    "%lu ", /* ttynr */
3172                    &ttynr) != 1)
3173                 return -EIO;
3174
3175         *d = (dev_t) ttynr;
3176         return 0;
3177 }
3178
3179 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3180         int k;
3181         char fn[PATH_MAX], *s, *b, *p;
3182         dev_t devnr;
3183
3184         assert(r);
3185
3186         k = get_ctty_devnr(pid, &devnr);
3187         if (k < 0)
3188                 return k;
3189
3190         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
3191         char_array_0(fn);
3192
3193         if ((k = readlink_malloc(fn, &s)) < 0) {
3194
3195                 if (k != -ENOENT)
3196                         return k;
3197
3198                 /* This is an ugly hack */
3199                 if (major(devnr) == 136) {
3200                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
3201                                 return -ENOMEM;
3202
3203                         *r = b;
3204                         if (_devnr)
3205                                 *_devnr = devnr;
3206
3207                         return 0;
3208                 }
3209
3210                 /* Probably something like the ptys which have no
3211                  * symlink in /dev/char. Let's return something
3212                  * vaguely useful. */
3213
3214                 if (!(b = strdup(fn + 5)))
3215                         return -ENOMEM;
3216
3217                 *r = b;
3218                 if (_devnr)
3219                         *_devnr = devnr;
3220
3221                 return 0;
3222         }
3223
3224         if (startswith(s, "/dev/"))
3225                 p = s + 5;
3226         else if (startswith(s, "../"))
3227                 p = s + 3;
3228         else
3229                 p = s;
3230
3231         b = strdup(p);
3232         free(s);
3233
3234         if (!b)
3235                 return -ENOMEM;
3236
3237         *r = b;
3238         if (_devnr)
3239                 *_devnr = devnr;
3240
3241         return 0;
3242 }
3243
3244 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3245         DIR *d;
3246         int ret = 0;
3247
3248         assert(fd >= 0);
3249
3250         /* This returns the first error we run into, but nevertheless
3251          * tries to go on. This closes the passed fd. */
3252
3253         d = fdopendir(fd);
3254         if (!d) {
3255                 close_nointr_nofail(fd);
3256
3257                 return errno == ENOENT ? 0 : -errno;
3258         }
3259
3260         for (;;) {
3261                 struct dirent buf, *de;
3262                 bool is_dir, keep_around;
3263                 struct stat st;
3264                 int r;
3265
3266                 r = readdir_r(d, &buf, &de);
3267                 if (r != 0 && ret == 0) {
3268                         ret = -r;
3269                         break;
3270                 }
3271
3272                 if (!de)
3273                         break;
3274
3275                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3276                         continue;
3277
3278                 if (de->d_type == DT_UNKNOWN ||
3279                     honour_sticky ||
3280                     (de->d_type == DT_DIR && root_dev)) {
3281                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3282                                 if (ret == 0 && errno != ENOENT)
3283                                         ret = -errno;
3284                                 continue;
3285                         }
3286
3287                         is_dir = S_ISDIR(st.st_mode);
3288                         keep_around =
3289                                 honour_sticky &&
3290                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3291                                 (st.st_mode & S_ISVTX);
3292                 } else {
3293                         is_dir = de->d_type == DT_DIR;
3294                         keep_around = false;
3295                 }
3296
3297                 if (is_dir) {
3298                         int subdir_fd;
3299
3300                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
3301                         if (root_dev && st.st_dev != root_dev->st_dev)
3302                                 continue;
3303
3304                         subdir_fd = openat(fd, de->d_name,
3305                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3306                         if (subdir_fd < 0) {
3307                                 if (ret == 0 && errno != ENOENT)
3308                                         ret = -errno;
3309                                 continue;
3310                         }
3311
3312                         r = rm_rf_children(subdir_fd, only_dirs, honour_sticky, root_dev);
3313                         if (r < 0 && ret == 0)
3314                                 ret = r;
3315
3316                         if (!keep_around)
3317                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3318                                         if (ret == 0 && errno != ENOENT)
3319                                                 ret = -errno;
3320                                 }
3321
3322                 } else if (!only_dirs && !keep_around) {
3323
3324                         if (unlinkat(fd, de->d_name, 0) < 0) {
3325                                 if (ret == 0 && errno != ENOENT)
3326                                         ret = -errno;
3327                         }
3328                 }
3329         }
3330
3331         closedir(d);
3332
3333         return ret;
3334 }
3335
3336 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3337         int fd;
3338         int r;
3339
3340         assert(path);
3341
3342         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3343         if (fd < 0) {
3344
3345                 if (errno != ENOTDIR)
3346                         return -errno;
3347
3348                 if (delete_root && !only_dirs)
3349                         if (unlink(path) < 0 && errno != ENOENT)
3350                                 return -errno;
3351
3352                 return 0;
3353         }
3354
3355         r = rm_rf_children(fd, only_dirs, honour_sticky, NULL);
3356
3357         if (delete_root) {
3358
3359                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3360                         return r;
3361
3362                 if (rmdir(path) < 0 && errno != ENOENT) {
3363                         if (r == 0)
3364                                 r = -errno;
3365                 }
3366         }
3367
3368         return r;
3369 }
3370
3371 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3372         assert(path);
3373
3374         /* Under the assumption that we are running privileged we
3375          * first change the access mode and only then hand out
3376          * ownership to avoid a window where access is too open. */
3377
3378         if (mode != (mode_t) -1)
3379                 if (chmod(path, mode) < 0)
3380                         return -errno;
3381
3382         if (uid != (uid_t) -1 || gid != (gid_t) -1)
3383                 if (chown(path, uid, gid) < 0)
3384                         return -errno;
3385
3386         return 0;
3387 }
3388
3389 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3390         assert(fd >= 0);
3391
3392         /* Under the assumption that we are running privileged we
3393          * first change the access mode and only then hand out
3394          * ownership to avoid a window where access is too open. */
3395
3396         if (fchmod(fd, mode) < 0)
3397                 return -errno;
3398
3399         if (fchown(fd, uid, gid) < 0)