chiark / gitweb /
af975956dbca755091ca60981e5432e37b8328a4
[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 #include <sys/vfs.h>
58 #include <linux/magic.h>
59
60 #include "macro.h"
61 #include "util.h"
62 #include "ioprio.h"
63 #include "missing.h"
64 #include "log.h"
65 #include "strv.h"
66 #include "label.h"
67 #include "path-util.h"
68 #include "exit-status.h"
69 #include "hashmap.h"
70
71 int saved_argc = 0;
72 char **saved_argv = NULL;
73
74 size_t page_size(void) {
75         static __thread size_t pgsz = 0;
76         long r;
77
78         if (_likely_(pgsz > 0))
79                 return pgsz;
80
81         assert_se((r = sysconf(_SC_PAGESIZE)) > 0);
82
83         pgsz = (size_t) r;
84
85         return pgsz;
86 }
87
88 bool streq_ptr(const char *a, const char *b) {
89
90         /* Like streq(), but tries to make sense of NULL pointers */
91
92         if (a && b)
93                 return streq(a, b);
94
95         if (!a && !b)
96                 return true;
97
98         return false;
99 }
100
101 usec_t now(clockid_t clock_id) {
102         struct timespec ts;
103
104         assert_se(clock_gettime(clock_id, &ts) == 0);
105
106         return timespec_load(&ts);
107 }
108
109 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
110         assert(ts);
111
112         ts->realtime = now(CLOCK_REALTIME);
113         ts->monotonic = now(CLOCK_MONOTONIC);
114
115         return ts;
116 }
117
118 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
119         int64_t delta;
120         assert(ts);
121
122         ts->realtime = u;
123
124         if (u == 0)
125                 ts->monotonic = 0;
126         else {
127                 delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
128
129                 ts->monotonic = now(CLOCK_MONOTONIC);
130
131                 if ((int64_t) ts->monotonic > delta)
132                         ts->monotonic -= delta;
133                 else
134                         ts->monotonic = 0;
135         }
136
137         return ts;
138 }
139
140 usec_t timespec_load(const struct timespec *ts) {
141         assert(ts);
142
143         return
144                 (usec_t) ts->tv_sec * USEC_PER_SEC +
145                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
146 }
147
148 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
149         assert(ts);
150
151         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
152         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
153
154         return ts;
155 }
156
157 usec_t timeval_load(const struct timeval *tv) {
158         assert(tv);
159
160         return
161                 (usec_t) tv->tv_sec * USEC_PER_SEC +
162                 (usec_t) tv->tv_usec;
163 }
164
165 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
166         assert(tv);
167
168         tv->tv_sec = (time_t) (u / USEC_PER_SEC);
169         tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
170
171         return tv;
172 }
173
174 bool endswith(const char *s, const char *postfix) {
175         size_t sl, pl;
176
177         assert(s);
178         assert(postfix);
179
180         sl = strlen(s);
181         pl = strlen(postfix);
182
183         if (pl == 0)
184                 return true;
185
186         if (sl < pl)
187                 return false;
188
189         return memcmp(s + sl - pl, postfix, pl) == 0;
190 }
191
192 bool startswith(const char *s, const char *prefix) {
193         size_t sl, pl;
194
195         assert(s);
196         assert(prefix);
197
198         sl = strlen(s);
199         pl = strlen(prefix);
200
201         if (pl == 0)
202                 return true;
203
204         if (sl < pl)
205                 return false;
206
207         return memcmp(s, prefix, pl) == 0;
208 }
209
210 bool startswith_no_case(const char *s, const char *prefix) {
211         size_t sl, pl;
212         unsigned i;
213
214         assert(s);
215         assert(prefix);
216
217         sl = strlen(s);
218         pl = strlen(prefix);
219
220         if (pl == 0)
221                 return true;
222
223         if (sl < pl)
224                 return false;
225
226         for(i = 0; i < pl; ++i) {
227                 if (tolower(s[i]) != tolower(prefix[i]))
228                         return false;
229         }
230
231         return true;
232 }
233
234 bool first_word(const char *s, const char *word) {
235         size_t sl, wl;
236
237         assert(s);
238         assert(word);
239
240         sl = strlen(s);
241         wl = strlen(word);
242
243         if (sl < wl)
244                 return false;
245
246         if (wl == 0)
247                 return true;
248
249         if (memcmp(s, word, wl) != 0)
250                 return false;
251
252         return s[wl] == 0 ||
253                 strchr(WHITESPACE, s[wl]);
254 }
255
256 int close_nointr(int fd) {
257         assert(fd >= 0);
258
259         for (;;) {
260                 int r;
261
262                 r = close(fd);
263                 if (r >= 0)
264                         return r;
265
266                 if (errno != EINTR)
267                         return -errno;
268         }
269 }
270
271 void close_nointr_nofail(int fd) {
272         int saved_errno = errno;
273
274         /* like close_nointr() but cannot fail, and guarantees errno
275          * is unchanged */
276
277         assert_se(close_nointr(fd) == 0);
278
279         errno = saved_errno;
280 }
281
282 void close_many(const int fds[], unsigned n_fd) {
283         unsigned i;
284
285         for (i = 0; i < n_fd; i++)
286                 close_nointr_nofail(fds[i]);
287 }
288
289 int parse_boolean(const char *v) {
290         assert(v);
291
292         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || !strcasecmp(v, "on"))
293                 return 1;
294         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || !strcasecmp(v, "off"))
295                 return 0;
296
297         return -EINVAL;
298 }
299
300 int parse_pid(const char *s, pid_t* ret_pid) {
301         unsigned long ul = 0;
302         pid_t pid;
303         int r;
304
305         assert(s);
306         assert(ret_pid);
307
308         if ((r = safe_atolu(s, &ul)) < 0)
309                 return r;
310
311         pid = (pid_t) ul;
312
313         if ((unsigned long) pid != ul)
314                 return -ERANGE;
315
316         if (pid <= 0)
317                 return -ERANGE;
318
319         *ret_pid = pid;
320         return 0;
321 }
322
323 int parse_uid(const char *s, uid_t* ret_uid) {
324         unsigned long ul = 0;
325         uid_t uid;
326         int r;
327
328         assert(s);
329         assert(ret_uid);
330
331         if ((r = safe_atolu(s, &ul)) < 0)
332                 return r;
333
334         uid = (uid_t) ul;
335
336         if ((unsigned long) uid != ul)
337                 return -ERANGE;
338
339         *ret_uid = uid;
340         return 0;
341 }
342
343 int safe_atou(const char *s, unsigned *ret_u) {
344         char *x = NULL;
345         unsigned long l;
346
347         assert(s);
348         assert(ret_u);
349
350         errno = 0;
351         l = strtoul(s, &x, 0);
352
353         if (!x || *x || errno)
354                 return errno ? -errno : -EINVAL;
355
356         if ((unsigned long) (unsigned) l != l)
357                 return -ERANGE;
358
359         *ret_u = (unsigned) l;
360         return 0;
361 }
362
363 int safe_atoi(const char *s, int *ret_i) {
364         char *x = NULL;
365         long l;
366
367         assert(s);
368         assert(ret_i);
369
370         errno = 0;
371         l = strtol(s, &x, 0);
372
373         if (!x || *x || errno)
374                 return errno ? -errno : -EINVAL;
375
376         if ((long) (int) l != l)
377                 return -ERANGE;
378
379         *ret_i = (int) l;
380         return 0;
381 }
382
383 int safe_atollu(const char *s, long long unsigned *ret_llu) {
384         char *x = NULL;
385         unsigned long long l;
386
387         assert(s);
388         assert(ret_llu);
389
390         errno = 0;
391         l = strtoull(s, &x, 0);
392
393         if (!x || *x || errno)
394                 return errno ? -errno : -EINVAL;
395
396         *ret_llu = l;
397         return 0;
398 }
399
400 int safe_atolli(const char *s, long long int *ret_lli) {
401         char *x = NULL;
402         long long l;
403
404         assert(s);
405         assert(ret_lli);
406
407         errno = 0;
408         l = strtoll(s, &x, 0);
409
410         if (!x || *x || errno)
411                 return errno ? -errno : -EINVAL;
412
413         *ret_lli = l;
414         return 0;
415 }
416
417 /* Split a string into words. */
418 char *split(const char *c, size_t *l, const char *separator, char **state) {
419         char *current;
420
421         current = *state ? *state : (char*) c;
422
423         if (!*current || *c == 0)
424                 return NULL;
425
426         current += strspn(current, separator);
427         *l = strcspn(current, separator);
428         *state = current+*l;
429
430         return (char*) current;
431 }
432
433 /* Split a string into words, but consider strings enclosed in '' and
434  * "" as words even if they include spaces. */
435 char *split_quoted(const char *c, size_t *l, char **state) {
436         char *current, *e;
437         bool escaped = false;
438
439         current = *state ? *state : (char*) c;
440
441         if (!*current || *c == 0)
442                 return NULL;
443
444         current += strspn(current, WHITESPACE);
445
446         if (*current == '\'') {
447                 current ++;
448
449                 for (e = current; *e; e++) {
450                         if (escaped)
451                                 escaped = false;
452                         else if (*e == '\\')
453                                 escaped = true;
454                         else if (*e == '\'')
455                                 break;
456                 }
457
458                 *l = e-current;
459                 *state = *e == 0 ? e : e+1;
460         } else if (*current == '\"') {
461                 current ++;
462
463                 for (e = current; *e; e++) {
464                         if (escaped)
465                                 escaped = false;
466                         else if (*e == '\\')
467                                 escaped = true;
468                         else if (*e == '\"')
469                                 break;
470                 }
471
472                 *l = e-current;
473                 *state = *e == 0 ? e : e+1;
474         } else {
475                 for (e = current; *e; e++) {
476                         if (escaped)
477                                 escaped = false;
478                         else if (*e == '\\')
479                                 escaped = true;
480                         else if (strchr(WHITESPACE, *e))
481                                 break;
482                 }
483                 *l = e-current;
484                 *state = e;
485         }
486
487         return (char*) current;
488 }
489
490 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
491         int r;
492         FILE *f;
493         char fn[PATH_MAX], line[LINE_MAX], *p;
494         long unsigned ppid;
495
496         assert(pid > 0);
497         assert(_ppid);
498
499         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
500         char_array_0(fn);
501
502         if (!(f = fopen(fn, "re")))
503                 return -errno;
504
505         if (!(fgets(line, sizeof(line), f))) {
506                 r = feof(f) ? -EIO : -errno;
507                 fclose(f);
508                 return r;
509         }
510
511         fclose(f);
512
513         /* Let's skip the pid and comm fields. The latter is enclosed
514          * in () but does not escape any () in its value, so let's
515          * skip over it manually */
516
517         if (!(p = strrchr(line, ')')))
518                 return -EIO;
519
520         p++;
521
522         if (sscanf(p, " "
523                    "%*c "  /* state */
524                    "%lu ", /* ppid */
525                    &ppid) != 1)
526                 return -EIO;
527
528         if ((long unsigned) (pid_t) ppid != ppid)
529                 return -ERANGE;
530
531         *_ppid = (pid_t) ppid;
532
533         return 0;
534 }
535
536 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
537         int r;
538         FILE *f;
539         char fn[PATH_MAX], line[LINE_MAX], *p;
540
541         assert(pid > 0);
542         assert(st);
543
544         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
545         char_array_0(fn);
546
547         if (!(f = fopen(fn, "re")))
548                 return -errno;
549
550         if (!(fgets(line, sizeof(line), f))) {
551                 r = feof(f) ? -EIO : -errno;
552                 fclose(f);
553                 return r;
554         }
555
556         fclose(f);
557
558         /* Let's skip the pid and comm fields. The latter is enclosed
559          * in () but does not escape any () in its value, so let's
560          * skip over it manually */
561
562         if (!(p = strrchr(line, ')')))
563                 return -EIO;
564
565         p++;
566
567         if (sscanf(p, " "
568                    "%*c "  /* state */
569                    "%*d "  /* ppid */
570                    "%*d "  /* pgrp */
571                    "%*d "  /* session */
572                    "%*d "  /* tty_nr */
573                    "%*d "  /* tpgid */
574                    "%*u "  /* flags */
575                    "%*u "  /* minflt */
576                    "%*u "  /* cminflt */
577                    "%*u "  /* majflt */
578                    "%*u "  /* cmajflt */
579                    "%*u "  /* utime */
580                    "%*u "  /* stime */
581                    "%*d "  /* cutime */
582                    "%*d "  /* cstime */
583                    "%*d "  /* priority */
584                    "%*d "  /* nice */
585                    "%*d "  /* num_threads */
586                    "%*d "  /* itrealvalue */
587                    "%llu "  /* starttime */,
588                    st) != 1)
589                 return -EIO;
590
591         return 0;
592 }
593
594 int write_one_line_file(const char *fn, const char *line) {
595         FILE *f;
596         int r;
597
598         assert(fn);
599         assert(line);
600
601         f = fopen(fn, "we");
602         if (!f)
603                 return -errno;
604
605         errno = 0;
606         if (fputs(line, f) < 0) {
607                 r = -errno;
608                 goto finish;
609         }
610
611         if (!endswith(line, "\n"))
612                 fputc('\n', f);
613
614         fflush(f);
615
616         if (ferror(f)) {
617                 if (errno != 0)
618                         r = -errno;
619                 else
620                         r = -EIO;
621         } else
622                 r = 0;
623
624 finish:
625         fclose(f);
626         return r;
627 }
628
629 int fchmod_umask(int fd, mode_t m) {
630         mode_t u;
631         int r;
632
633         u = umask(0777);
634         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
635         umask(u);
636
637         return r;
638 }
639
640 int write_one_line_file_atomic(const char *fn, const char *line) {
641         FILE *f;
642         int r;
643         char *p;
644
645         assert(fn);
646         assert(line);
647
648         r = fopen_temporary(fn, &f, &p);
649         if (r < 0)
650                 return r;
651
652         fchmod_umask(fileno(f), 0644);
653
654         errno = 0;
655         if (fputs(line, f) < 0) {
656                 r = -errno;
657                 goto finish;
658         }
659
660         if (!endswith(line, "\n"))
661                 fputc('\n', f);
662
663         fflush(f);
664
665         if (ferror(f)) {
666                 if (errno != 0)
667                         r = -errno;
668                 else
669                         r = -EIO;
670         } else {
671                 if (rename(p, fn) < 0)
672                         r = -errno;
673                 else
674                         r = 0;
675         }
676
677 finish:
678         if (r < 0)
679                 unlink(p);
680
681         fclose(f);
682         free(p);
683
684         return r;
685 }
686
687 int read_one_line_file(const char *fn, char **line) {
688         FILE *f;
689         int r;
690         char t[LINE_MAX], *c;
691
692         assert(fn);
693         assert(line);
694
695         f = fopen(fn, "re");
696         if (!f)
697                 return -errno;
698
699         if (!fgets(t, sizeof(t), f)) {
700
701                 if (ferror(f)) {
702                         r = -errno;
703                         goto finish;
704                 }
705
706                 t[0] = 0;
707         }
708
709         c = strdup(t);
710         if (!c) {
711                 r = -ENOMEM;
712                 goto finish;
713         }
714
715         truncate_nl(c);
716
717         *line = c;
718         r = 0;
719
720 finish:
721         fclose(f);
722         return r;
723 }
724
725 int read_full_file(const char *fn, char **contents, size_t *size) {
726         FILE *f;
727         int r;
728         size_t n, l;
729         char *buf = NULL;
730         struct stat st;
731
732         if (!(f = fopen(fn, "re")))
733                 return -errno;
734
735         if (fstat(fileno(f), &st) < 0) {
736                 r = -errno;
737                 goto finish;
738         }
739
740         /* Safety check */
741         if (st.st_size > 4*1024*1024) {
742                 r = -E2BIG;
743                 goto finish;
744         }
745
746         n = st.st_size > 0 ? st.st_size : LINE_MAX;
747         l = 0;
748
749         for (;;) {
750                 char *t;
751                 size_t k;
752
753                 if (!(t = realloc(buf, n+1))) {
754                         r = -ENOMEM;
755                         goto finish;
756                 }
757
758                 buf = t;
759                 k = fread(buf + l, 1, n - l, f);
760
761                 if (k <= 0) {
762                         if (ferror(f)) {
763                                 r = -errno;
764                                 goto finish;
765                         }
766
767                         break;
768                 }
769
770                 l += k;
771                 n *= 2;
772
773                 /* Safety check */
774                 if (n > 4*1024*1024) {
775                         r = -E2BIG;
776                         goto finish;
777                 }
778         }
779
780         buf[l] = 0;
781         *contents = buf;
782         buf = NULL;
783
784         if (size)
785                 *size = l;
786
787         r = 0;
788
789 finish:
790         fclose(f);
791         free(buf);
792
793         return r;
794 }
795
796 int parse_env_file(
797                 const char *fname,
798                 const char *separator, ...) {
799
800         int r = 0;
801         char *contents = NULL, *p;
802
803         assert(fname);
804         assert(separator);
805
806         if ((r = read_full_file(fname, &contents, NULL)) < 0)
807                 return r;
808
809         p = contents;
810         for (;;) {
811                 const char *key = NULL;
812
813                 p += strspn(p, separator);
814                 p += strspn(p, WHITESPACE);
815
816                 if (!*p)
817                         break;
818
819                 if (!strchr(COMMENTS, *p)) {
820                         va_list ap;
821                         char **value;
822
823                         va_start(ap, separator);
824                         while ((key = va_arg(ap, char *))) {
825                                 size_t n;
826                                 char *v;
827
828                                 value = va_arg(ap, char **);
829
830                                 n = strlen(key);
831                                 if (strncmp(p, key, n) != 0 ||
832                                     p[n] != '=')
833                                         continue;
834
835                                 p += n + 1;
836                                 n = strcspn(p, separator);
837
838                                 if (n >= 2 &&
839                                     strchr(QUOTES, p[0]) &&
840                                     p[n-1] == p[0])
841                                         v = strndup(p+1, n-2);
842                                 else
843                                         v = strndup(p, n);
844
845                                 if (!v) {
846                                         r = -ENOMEM;
847                                         va_end(ap);
848                                         goto fail;
849                                 }
850
851                                 if (v[0] == '\0') {
852                                         /* return empty value strings as NULL */
853                                         free(v);
854                                         v = NULL;
855                                 }
856
857                                 free(*value);
858                                 *value = v;
859
860                                 p += n;
861
862                                 r ++;
863                                 break;
864                         }
865                         va_end(ap);
866                 }
867
868                 if (!key)
869                         p += strcspn(p, separator);
870         }
871
872 fail:
873         free(contents);
874         return r;
875 }
876
877 int load_env_file(
878                 const char *fname,
879                 char ***rl) {
880
881         FILE *f;
882         char **m = NULL;
883         int r;
884
885         assert(fname);
886         assert(rl);
887
888         if (!(f = fopen(fname, "re")))
889                 return -errno;
890
891         while (!feof(f)) {
892                 char l[LINE_MAX], *p, *u;
893                 char **t;
894
895                 if (!fgets(l, sizeof(l), f)) {
896                         if (feof(f))
897                                 break;
898
899                         r = -errno;
900                         goto finish;
901                 }
902
903                 p = strstrip(l);
904
905                 if (!*p)
906                         continue;
907
908                 if (strchr(COMMENTS, *p))
909                         continue;
910
911                 if (!(u = normalize_env_assignment(p))) {
912                         r = log_oom();
913                         goto finish;
914                 }
915
916                 t = strv_append(m, u);
917                 free(u);
918
919                 if (!t) {
920                         r = log_oom();
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 = strjoin("[", 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 = 0, wd = -1;
2387         usec_t ts = 0;
2388         struct sigaction sa_old, sa_new;
2389
2390         assert(name);
2391
2392         /* We use inotify to be notified when the tty is closed. We
2393          * create the watch before checking if we can actually acquire
2394          * it, so that we don't lose any event.
2395          *
2396          * Note: strictly speaking this actually watches for the
2397          * device being closed, it does *not* really watch whether a
2398          * tty loses its controlling process. However, unless some
2399          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
2400          * its tty otherwise this will not become a problem. As long
2401          * as the administrator makes sure not configure any service
2402          * on the same tty as an untrusted user this should not be a
2403          * problem. (Which he probably should not do anyway.) */
2404
2405         if (timeout != (usec_t) -1)
2406                 ts = now(CLOCK_MONOTONIC);
2407
2408         if (!fail && !force) {
2409                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
2410                 if (notify < 0) {
2411                         r = -errno;
2412                         goto fail;
2413                 }
2414
2415                 wd = inotify_add_watch(notify, name, IN_CLOSE);
2416                 if (wd < 0) {
2417                         r = -errno;
2418                         goto fail;
2419                 }
2420         }
2421
2422         for (;;) {
2423                 if (notify >= 0) {
2424                         r = flush_fd(notify);
2425                         if (r < 0)
2426                                 goto fail;
2427                 }
2428
2429                 /* We pass here O_NOCTTY only so that we can check the return
2430                  * value TIOCSCTTY and have a reliable way to figure out if we
2431                  * successfully became the controlling process of the tty */
2432                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
2433                 if (fd < 0)
2434                         return fd;
2435
2436                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2437                  * if we already own the tty. */
2438                 zero(sa_new);
2439                 sa_new.sa_handler = SIG_IGN;
2440                 sa_new.sa_flags = SA_RESTART;
2441                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2442
2443                 /* First, try to get the tty */
2444                 if (ioctl(fd, TIOCSCTTY, force) < 0)
2445                         r = -errno;
2446
2447                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2448
2449                 /* Sometimes it makes sense to ignore TIOCSCTTY
2450                  * returning EPERM, i.e. when very likely we already
2451                  * are have this controlling terminal. */
2452                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
2453                         r = 0;
2454
2455                 if (r < 0 && (force || fail || r != -EPERM)) {
2456                         goto fail;
2457                 }
2458
2459                 if (r >= 0)
2460                         break;
2461
2462                 assert(!fail);
2463                 assert(!force);
2464                 assert(notify >= 0);
2465
2466                 for (;;) {
2467                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
2468                         ssize_t l;
2469                         struct inotify_event *e;
2470
2471                         if (timeout != (usec_t) -1) {
2472                                 usec_t n;
2473
2474                                 n = now(CLOCK_MONOTONIC);
2475                                 if (ts + timeout < n) {
2476                                         r = -ETIMEDOUT;
2477                                         goto fail;
2478                                 }
2479
2480                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
2481                                 if (r < 0)
2482                                         goto fail;
2483
2484                                 if (r == 0) {
2485                                         r = -ETIMEDOUT;
2486                                         goto fail;
2487                                 }
2488                         }
2489
2490                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
2491                         if (l < 0) {
2492
2493                                 if (errno == EINTR || errno == EAGAIN)
2494                                         continue;
2495
2496                                 r = -errno;
2497                                 goto fail;
2498                         }
2499
2500                         e = (struct inotify_event*) inotify_buffer;
2501
2502                         while (l > 0) {
2503                                 size_t step;
2504
2505                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2506                                         r = -EIO;
2507                                         goto fail;
2508                                 }
2509
2510                                 step = sizeof(struct inotify_event) + e->len;
2511                                 assert(step <= (size_t) l);
2512
2513                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2514                                 l -= step;
2515                         }
2516
2517                         break;
2518                 }
2519
2520                 /* We close the tty fd here since if the old session
2521                  * ended our handle will be dead. It's important that
2522                  * we do this after sleeping, so that we don't enter
2523                  * an endless loop. */
2524                 close_nointr_nofail(fd);
2525         }
2526
2527         if (notify >= 0)
2528                 close_nointr_nofail(notify);
2529
2530         r = reset_terminal_fd(fd, true);
2531         if (r < 0)
2532                 log_warning("Failed to reset terminal: %s", strerror(-r));
2533
2534         return fd;
2535
2536 fail:
2537         if (fd >= 0)
2538                 close_nointr_nofail(fd);
2539
2540         if (notify >= 0)
2541                 close_nointr_nofail(notify);
2542
2543         return r;
2544 }
2545
2546 int release_terminal(void) {
2547         int r = 0, fd;
2548         struct sigaction sa_old, sa_new;
2549
2550         if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2551                 return -errno;
2552
2553         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2554          * by our own TIOCNOTTY */
2555
2556         zero(sa_new);
2557         sa_new.sa_handler = SIG_IGN;
2558         sa_new.sa_flags = SA_RESTART;
2559         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2560
2561         if (ioctl(fd, TIOCNOTTY) < 0)
2562                 r = -errno;
2563
2564         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2565
2566         close_nointr_nofail(fd);
2567         return r;
2568 }
2569
2570 int sigaction_many(const struct sigaction *sa, ...) {
2571         va_list ap;
2572         int r = 0, sig;
2573
2574         va_start(ap, sa);
2575         while ((sig = va_arg(ap, int)) > 0)
2576                 if (sigaction(sig, sa, NULL) < 0)
2577                         r = -errno;
2578         va_end(ap);
2579
2580         return r;
2581 }
2582
2583 int ignore_signals(int sig, ...) {
2584         struct sigaction sa;
2585         va_list ap;
2586         int r = 0;
2587
2588         zero(sa);
2589         sa.sa_handler = SIG_IGN;
2590         sa.sa_flags = SA_RESTART;
2591
2592         if (sigaction(sig, &sa, NULL) < 0)
2593                 r = -errno;
2594
2595         va_start(ap, sig);
2596         while ((sig = va_arg(ap, int)) > 0)
2597                 if (sigaction(sig, &sa, NULL) < 0)
2598                         r = -errno;
2599         va_end(ap);
2600
2601         return r;
2602 }
2603
2604 int default_signals(int sig, ...) {
2605         struct sigaction sa;
2606         va_list ap;
2607         int r = 0;
2608
2609         zero(sa);
2610         sa.sa_handler = SIG_DFL;
2611         sa.sa_flags = SA_RESTART;
2612
2613         if (sigaction(sig, &sa, NULL) < 0)
2614                 r = -errno;
2615
2616         va_start(ap, sig);
2617         while ((sig = va_arg(ap, int)) > 0)
2618                 if (sigaction(sig, &sa, NULL) < 0)
2619                         r = -errno;
2620         va_end(ap);
2621
2622         return r;
2623 }
2624
2625 int close_pipe(int p[]) {
2626         int a = 0, b = 0;
2627
2628         assert(p);
2629
2630         if (p[0] >= 0) {
2631                 a = close_nointr(p[0]);
2632                 p[0] = -1;
2633         }
2634
2635         if (p[1] >= 0) {
2636                 b = close_nointr(p[1]);
2637                 p[1] = -1;
2638         }
2639
2640         return a < 0 ? a : b;
2641 }
2642
2643 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2644         uint8_t *p;
2645         ssize_t n = 0;
2646
2647         assert(fd >= 0);
2648         assert(buf);
2649
2650         p = buf;
2651
2652         while (nbytes > 0) {
2653                 ssize_t k;
2654
2655                 if ((k = read(fd, p, nbytes)) <= 0) {
2656
2657                         if (k < 0 && errno == EINTR)
2658                                 continue;
2659
2660                         if (k < 0 && errno == EAGAIN && do_poll) {
2661                                 struct pollfd pollfd;
2662
2663                                 zero(pollfd);
2664                                 pollfd.fd = fd;
2665                                 pollfd.events = POLLIN;
2666
2667                                 if (poll(&pollfd, 1, -1) < 0) {
2668                                         if (errno == EINTR)
2669                                                 continue;
2670
2671                                         return n > 0 ? n : -errno;
2672                                 }
2673
2674                                 if (pollfd.revents != POLLIN)
2675                                         return n > 0 ? n : -EIO;
2676
2677                                 continue;
2678                         }
2679
2680                         return n > 0 ? n : (k < 0 ? -errno : 0);
2681                 }
2682
2683                 p += k;
2684                 nbytes -= k;
2685                 n += k;
2686         }
2687
2688         return n;
2689 }
2690
2691 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2692         const uint8_t *p;
2693         ssize_t n = 0;
2694
2695         assert(fd >= 0);
2696         assert(buf);
2697
2698         p = buf;
2699
2700         while (nbytes > 0) {
2701                 ssize_t k;
2702
2703                 k = write(fd, p, nbytes);
2704                 if (k <= 0) {
2705
2706                         if (k < 0 && errno == EINTR)
2707                                 continue;
2708
2709                         if (k < 0 && errno == EAGAIN && do_poll) {
2710                                 struct pollfd pollfd;
2711
2712                                 zero(pollfd);
2713                                 pollfd.fd = fd;
2714                                 pollfd.events = POLLOUT;
2715
2716                                 if (poll(&pollfd, 1, -1) < 0) {
2717                                         if (errno == EINTR)
2718                                                 continue;
2719
2720                                         return n > 0 ? n : -errno;
2721                                 }
2722
2723                                 if (pollfd.revents != POLLOUT)
2724                                         return n > 0 ? n : -EIO;
2725
2726                                 continue;
2727                         }
2728
2729                         return n > 0 ? n : (k < 0 ? -errno : 0);
2730                 }
2731
2732                 p += k;
2733                 nbytes -= k;
2734                 n += k;
2735         }
2736
2737         return n;
2738 }
2739
2740 int parse_usec(const char *t, usec_t *usec) {
2741         static const struct {
2742                 const char *suffix;
2743                 usec_t usec;
2744         } table[] = {
2745                 { "sec", USEC_PER_SEC },
2746                 { "s", USEC_PER_SEC },
2747                 { "min", USEC_PER_MINUTE },
2748                 { "hr", USEC_PER_HOUR },
2749                 { "h", USEC_PER_HOUR },
2750                 { "d", USEC_PER_DAY },
2751                 { "w", USEC_PER_WEEK },
2752                 { "msec", USEC_PER_MSEC },
2753                 { "ms", USEC_PER_MSEC },
2754                 { "m", USEC_PER_MINUTE },
2755                 { "usec", 1ULL },
2756                 { "us", 1ULL },
2757                 { "", USEC_PER_SEC }, /* default is sec */
2758         };
2759
2760         const char *p;
2761         usec_t r = 0;
2762
2763         assert(t);
2764         assert(usec);
2765
2766         p = t;
2767         do {
2768                 long long l;
2769                 char *e;
2770                 unsigned i;
2771
2772                 errno = 0;
2773                 l = strtoll(p, &e, 10);
2774
2775                 if (errno != 0)
2776                         return -errno;
2777
2778                 if (l < 0)
2779                         return -ERANGE;
2780
2781                 if (e == p)
2782                         return -EINVAL;
2783
2784                 e += strspn(e, WHITESPACE);
2785
2786                 for (i = 0; i < ELEMENTSOF(table); i++)
2787                         if (startswith(e, table[i].suffix)) {
2788                                 r += (usec_t) l * table[i].usec;
2789                                 p = e + strlen(table[i].suffix);
2790                                 break;
2791                         }
2792
2793                 if (i >= ELEMENTSOF(table))
2794                         return -EINVAL;
2795
2796         } while (*p != 0);
2797
2798         *usec = r;
2799
2800         return 0;
2801 }
2802
2803 int parse_nsec(const char *t, nsec_t *nsec) {
2804         static const struct {
2805                 const char *suffix;
2806                 nsec_t nsec;
2807         } table[] = {
2808                 { "sec", NSEC_PER_SEC },
2809                 { "s", NSEC_PER_SEC },
2810                 { "min", NSEC_PER_MINUTE },
2811                 { "hr", NSEC_PER_HOUR },
2812                 { "h", NSEC_PER_HOUR },
2813                 { "d", NSEC_PER_DAY },
2814                 { "w", NSEC_PER_WEEK },
2815                 { "msec", NSEC_PER_MSEC },
2816                 { "ms", NSEC_PER_MSEC },
2817                 { "m", NSEC_PER_MINUTE },
2818                 { "usec", NSEC_PER_USEC },
2819                 { "us", NSEC_PER_USEC },
2820                 { "nsec", 1ULL },
2821                 { "ns", 1ULL },
2822                 { "", 1ULL }, /* default is nsec */
2823         };
2824
2825         const char *p;
2826         nsec_t r = 0;
2827
2828         assert(t);
2829         assert(nsec);
2830
2831         p = t;
2832         do {
2833                 long long l;
2834                 char *e;
2835                 unsigned i;
2836
2837                 errno = 0;
2838                 l = strtoll(p, &e, 10);
2839
2840                 if (errno != 0)
2841                         return -errno;
2842
2843                 if (l < 0)
2844                         return -ERANGE;
2845
2846                 if (e == p)
2847                         return -EINVAL;
2848
2849                 e += strspn(e, WHITESPACE);
2850
2851                 for (i = 0; i < ELEMENTSOF(table); i++)
2852                         if (startswith(e, table[i].suffix)) {
2853                                 r += (nsec_t) l * table[i].nsec;
2854                                 p = e + strlen(table[i].suffix);
2855                                 break;
2856                         }
2857
2858                 if (i >= ELEMENTSOF(table))
2859                         return -EINVAL;
2860
2861         } while (*p != 0);
2862
2863         *nsec = r;
2864
2865         return 0;
2866 }
2867
2868 int parse_bytes(const char *t, off_t *bytes) {
2869         static const struct {
2870                 const char *suffix;
2871                 off_t factor;
2872         } table[] = {
2873                 { "B", 1 },
2874                 { "K", 1024ULL },
2875                 { "M", 1024ULL*1024ULL },
2876                 { "G", 1024ULL*1024ULL*1024ULL },
2877                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2878                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2879                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2880                 { "", 1 },
2881         };
2882
2883         const char *p;
2884         off_t r = 0;
2885
2886         assert(t);
2887         assert(bytes);
2888
2889         p = t;
2890         do {
2891                 long long l;
2892                 char *e;
2893                 unsigned i;
2894
2895                 errno = 0;
2896                 l = strtoll(p, &e, 10);
2897
2898                 if (errno != 0)
2899                         return -errno;
2900
2901                 if (l < 0)
2902                         return -ERANGE;
2903
2904                 if (e == p)
2905                         return -EINVAL;
2906
2907                 e += strspn(e, WHITESPACE);
2908
2909                 for (i = 0; i < ELEMENTSOF(table); i++)
2910                         if (startswith(e, table[i].suffix)) {
2911                                 r += (off_t) l * table[i].factor;
2912                                 p = e + strlen(table[i].suffix);
2913                                 break;
2914                         }
2915
2916                 if (i >= ELEMENTSOF(table))
2917                         return -EINVAL;
2918
2919         } while (*p != 0);
2920
2921         *bytes = r;
2922
2923         return 0;
2924 }
2925
2926 int make_stdio(int fd) {
2927         int r, s, t;
2928
2929         assert(fd >= 0);
2930
2931         r = dup2(fd, STDIN_FILENO);
2932         s = dup2(fd, STDOUT_FILENO);
2933         t = dup2(fd, STDERR_FILENO);
2934
2935         if (fd >= 3)
2936                 close_nointr_nofail(fd);
2937
2938         if (r < 0 || s < 0 || t < 0)
2939                 return -errno;
2940
2941         fd_cloexec(STDIN_FILENO, false);
2942         fd_cloexec(STDOUT_FILENO, false);
2943         fd_cloexec(STDERR_FILENO, false);
2944
2945         return 0;
2946 }
2947
2948 int make_null_stdio(void) {
2949         int null_fd;
2950
2951         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2952         if (null_fd < 0)
2953                 return -errno;
2954
2955         return make_stdio(null_fd);
2956 }
2957
2958 bool is_device_path(const char *path) {
2959
2960         /* Returns true on paths that refer to a device, either in
2961          * sysfs or in /dev */
2962
2963         return
2964                 path_startswith(path, "/dev/") ||
2965                 path_startswith(path, "/sys/");
2966 }
2967
2968 int dir_is_empty(const char *path) {
2969         DIR *d;
2970         int r;
2971         struct dirent buf, *de;
2972
2973         if (!(d = opendir(path)))
2974                 return -errno;
2975
2976         for (;;) {
2977                 if ((r = readdir_r(d, &buf, &de)) > 0) {
2978                         r = -r;
2979                         break;
2980                 }
2981
2982                 if (!de) {
2983                         r = 1;
2984                         break;
2985                 }
2986
2987                 if (!ignore_file(de->d_name)) {
2988                         r = 0;
2989                         break;
2990                 }
2991         }
2992
2993         closedir(d);
2994         return r;
2995 }
2996
2997 unsigned long long random_ull(void) {
2998         int fd;
2999         uint64_t ull;
3000         ssize_t r;
3001
3002         if ((fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY)) < 0)
3003                 goto fallback;
3004
3005         r = loop_read(fd, &ull, sizeof(ull), true);
3006         close_nointr_nofail(fd);
3007
3008         if (r != sizeof(ull))
3009                 goto fallback;
3010
3011         return ull;
3012
3013 fallback:
3014         return random() * RAND_MAX + random();
3015 }
3016
3017 void rename_process(const char name[8]) {
3018         assert(name);
3019
3020         /* This is a like a poor man's setproctitle(). It changes the
3021          * comm field, argv[0], and also the glibc's internally used
3022          * name of the process. For the first one a limit of 16 chars
3023          * applies, to the second one usually one of 10 (i.e. length
3024          * of "/sbin/init"), to the third one one of 7 (i.e. length of
3025          * "systemd"). If you pass a longer string it will be
3026          * truncated */
3027
3028         prctl(PR_SET_NAME, name);
3029
3030         if (program_invocation_name)
3031                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
3032
3033         if (saved_argc > 0) {
3034                 int i;
3035
3036                 if (saved_argv[0])
3037                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
3038
3039                 for (i = 1; i < saved_argc; i++) {
3040                         if (!saved_argv[i])
3041                                 break;
3042
3043                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
3044                 }
3045         }
3046 }
3047
3048 void sigset_add_many(sigset_t *ss, ...) {
3049         va_list ap;
3050         int sig;
3051
3052         assert(ss);
3053
3054         va_start(ap, ss);
3055         while ((sig = va_arg(ap, int)) > 0)
3056                 assert_se(sigaddset(ss, sig) == 0);
3057         va_end(ap);
3058 }
3059
3060 char* gethostname_malloc(void) {
3061         struct utsname u;
3062
3063         assert_se(uname(&u) >= 0);
3064
3065         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
3066                 return strdup(u.nodename);
3067
3068         return strdup(u.sysname);
3069 }
3070
3071 bool hostname_is_set(void) {
3072         struct utsname u;
3073
3074         assert_se(uname(&u) >= 0);
3075
3076         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
3077 }
3078
3079
3080 static char *lookup_uid(uid_t uid) {
3081         long bufsize;
3082         char *buf, *name;
3083         struct passwd pwbuf, *pw = NULL;
3084
3085         /* Shortcut things to avoid NSS lookups */
3086         if (uid == 0)
3087                 return strdup("root");
3088
3089         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
3090         if (bufsize <= 0)
3091                 bufsize = 4096;
3092
3093         buf = malloc(bufsize);
3094         if (!buf)
3095                 return NULL;
3096
3097         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw) {
3098                 name = strdup(pw->pw_name);
3099                 free(buf);
3100                 return name;
3101         }
3102
3103         free(buf);
3104
3105         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
3106                 return NULL;
3107
3108         return name;
3109 }
3110
3111 char* getlogname_malloc(void) {
3112         uid_t uid;
3113         struct stat st;
3114
3115         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
3116                 uid = st.st_uid;
3117         else
3118                 uid = getuid();
3119
3120         return lookup_uid(uid);
3121 }
3122
3123 char *getusername_malloc(void) {
3124         const char *e;
3125
3126         e = getenv("USER");
3127         if (e)
3128                 return strdup(e);
3129
3130         return lookup_uid(getuid());
3131 }
3132
3133 int getttyname_malloc(int fd, char **r) {
3134         char path[PATH_MAX], *c;
3135         int k;
3136
3137         assert(r);
3138
3139         if ((k = ttyname_r(fd, path, sizeof(path))) != 0)
3140                 return -k;
3141
3142         char_array_0(path);
3143
3144         if (!(c = strdup(startswith(path, "/dev/") ? path + 5 : path)))
3145                 return -ENOMEM;
3146
3147         *r = c;
3148         return 0;
3149 }
3150
3151 int getttyname_harder(int fd, char **r) {
3152         int k;
3153         char *s;
3154
3155         if ((k = getttyname_malloc(fd, &s)) < 0)
3156                 return k;
3157
3158         if (streq(s, "tty")) {
3159                 free(s);
3160                 return get_ctty(0, NULL, r);
3161         }
3162
3163         *r = s;
3164         return 0;
3165 }
3166
3167 int get_ctty_devnr(pid_t pid, dev_t *d) {
3168         int k;
3169         char line[LINE_MAX], *p, *fn;
3170         unsigned long ttynr;
3171         FILE *f;
3172
3173         if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
3174                 return -ENOMEM;
3175
3176         f = fopen(fn, "re");
3177         free(fn);
3178         if (!f)
3179                 return -errno;
3180
3181         if (!fgets(line, sizeof(line), f)) {
3182                 k = feof(f) ? -EIO : -errno;
3183                 fclose(f);
3184                 return k;
3185         }
3186
3187         fclose(f);
3188
3189         p = strrchr(line, ')');
3190         if (!p)
3191                 return -EIO;
3192
3193         p++;
3194
3195         if (sscanf(p, " "
3196                    "%*c "  /* state */
3197                    "%*d "  /* ppid */
3198                    "%*d "  /* pgrp */
3199                    "%*d "  /* session */
3200                    "%lu ", /* ttynr */
3201                    &ttynr) != 1)
3202                 return -EIO;
3203
3204         *d = (dev_t) ttynr;
3205         return 0;
3206 }
3207
3208 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
3209         int k;
3210         char fn[PATH_MAX], *s, *b, *p;
3211         dev_t devnr;
3212
3213         assert(r);
3214
3215         k = get_ctty_devnr(pid, &devnr);
3216         if (k < 0)
3217                 return k;
3218
3219         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
3220         char_array_0(fn);
3221
3222         if ((k = readlink_malloc(fn, &s)) < 0) {
3223
3224                 if (k != -ENOENT)
3225                         return k;
3226
3227                 /* This is an ugly hack */
3228                 if (major(devnr) == 136) {
3229                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
3230                                 return -ENOMEM;
3231
3232                         *r = b;
3233                         if (_devnr)
3234                                 *_devnr = devnr;
3235
3236                         return 0;
3237                 }
3238
3239                 /* Probably something like the ptys which have no
3240                  * symlink in /dev/char. Let's return something
3241                  * vaguely useful. */
3242
3243                 if (!(b = strdup(fn + 5)))
3244                         return -ENOMEM;
3245
3246                 *r = b;
3247                 if (_devnr)
3248                         *_devnr = devnr;
3249
3250                 return 0;
3251         }
3252
3253         if (startswith(s, "/dev/"))
3254                 p = s + 5;
3255         else if (startswith(s, "../"))
3256                 p = s + 3;
3257         else
3258                 p = s;
3259
3260         b = strdup(p);
3261         free(s);
3262
3263         if (!b)
3264                 return -ENOMEM;
3265
3266         *r = b;
3267         if (_devnr)
3268                 *_devnr = devnr;
3269
3270         return 0;
3271 }
3272
3273 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3274         DIR *d;
3275         int ret = 0;
3276
3277         assert(fd >= 0);
3278
3279         /* This returns the first error we run into, but nevertheless
3280          * tries to go on. This closes the passed fd. */
3281
3282         d = fdopendir(fd);
3283         if (!d) {
3284                 close_nointr_nofail(fd);
3285
3286                 return errno == ENOENT ? 0 : -errno;
3287         }
3288
3289         for (;;) {
3290                 struct dirent buf, *de;
3291                 bool is_dir, keep_around;
3292                 struct stat st;
3293                 int r;
3294
3295                 r = readdir_r(d, &buf, &de);
3296                 if (r != 0 && ret == 0) {
3297                         ret = -r;
3298                         break;
3299                 }
3300
3301                 if (!de)
3302                         break;
3303
3304                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
3305                         continue;
3306
3307                 if (de->d_type == DT_UNKNOWN ||
3308                     honour_sticky ||
3309                     (de->d_type == DT_DIR && root_dev)) {
3310                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
3311                                 if (ret == 0 && errno != ENOENT)
3312                                         ret = -errno;
3313                                 continue;
3314                         }
3315
3316                         is_dir = S_ISDIR(st.st_mode);
3317                         keep_around =
3318                                 honour_sticky &&
3319                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
3320                                 (st.st_mode & S_ISVTX);
3321                 } else {
3322                         is_dir = de->d_type == DT_DIR;
3323                         keep_around = false;
3324                 }
3325
3326                 if (is_dir) {
3327                         int subdir_fd;
3328
3329                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
3330                         if (root_dev && st.st_dev != root_dev->st_dev)
3331                                 continue;
3332
3333                         subdir_fd = openat(fd, de->d_name,
3334                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3335                         if (subdir_fd < 0) {
3336                                 if (ret == 0 && errno != ENOENT)
3337                                         ret = -errno;
3338                                 continue;
3339                         }
3340
3341                         r = rm_rf_children(subdir_fd, only_dirs, honour_sticky, root_dev);
3342                         if (r < 0 && ret == 0)
3343                                 ret = r;
3344
3345                         if (!keep_around)
3346                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
3347                                         if (ret == 0 && errno != ENOENT)
3348                                                 ret = -errno;
3349                                 }
3350
3351                 } else if (!only_dirs && !keep_around) {
3352
3353                         if (unlinkat(fd, de->d_name, 0) < 0) {
3354                                 if (ret == 0 && errno != ENOENT)
3355                                         ret = -errno;
3356                         }
3357                 }
3358         }
3359
3360         closedir(d);
3361
3362         return ret;
3363 }
3364
3365 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
3366         struct statfs s;
3367
3368         assert(fd >= 0);
3369
3370         if (fstatfs(fd, &s) < 0) {
3371                 close_nointr_nofail(fd);
3372                 return -errno;
3373         }
3374
3375         /* We refuse to clean disk file systems with this call. This
3376          * is extra paranoia just to be sure we never ever remove
3377          * non-state data */
3378
3379         if (s.f_type != TMPFS_MAGIC &&
3380             s.f_type != RAMFS_MAGIC) {
3381                 log_error("Attempted to remove disk file system, and we can't allow that.");
3382                 close_nointr_nofail(fd);
3383                 return -EPERM;
3384         }
3385
3386         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
3387 }
3388
3389 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
3390         int fd, r;
3391         struct statfs s;
3392
3393         assert(path);
3394
3395         /* We refuse to clean the root file system with this
3396          * call. This is extra paranoia to never cause a really
3397          * seriously broken system. */
3398         if (path_equal(path, "/")) {
3399                 log_error("Attempted to remove entire root file system, and we can't allow that.");
3400                 return -EPERM;
3401         }
3402
3403         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
3404         if (fd < 0) {
3405
3406                 if (errno != ENOTDIR)
3407                         return -errno;
3408
3409                 if (!dangerous) {
3410                         if (statfs(path, &s) < 0)
3411                                 return -errno;
3412
3413                         if (s.f_type != TMPFS_MAGIC &&
3414                             s.f_type != RAMFS_MAGIC) {
3415                                 log_error("Attempted to remove disk file system, and we can't allow that.");
3416                                 return -EPERM;
3417                         }
3418                 }
3419
3420                 if (delete_root && !only_dirs)
3421                         if (unlink(path) < 0 && errno != ENOENT)
3422                                 return -errno;
3423
3424                 return 0;
3425         }
3426
3427         if (!dangerous) {
3428                 if (fstatfs(fd, &s) < 0) {
3429                         close_nointr_nofail(fd);
3430                         return -errno;
3431                 }
3432
3433                 if (s.f_type != TMPFS_MAGIC &&
3434                     s.f_type != RAMFS_MAGIC) {
3435                         log_error("Attempted to remove disk file system, and we can't allow that.");
3436                         close_nointr_nofail(fd);
3437                         return -EPERM;
3438                 }
3439         }
3440
3441         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
3442         if (delete_root) {
3443
3444                 if (honour_sticky && file_is_priv_sticky(path) > 0)
3445                         return r;
3446
3447                 if (rmdir(path) < 0 && errno != ENOENT) {
3448                         if (r == 0)
3449                                 r = -errno;
3450                 }
3451         }
3452
3453         return r;
3454 }
3455
3456 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3457         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
3458 }
3459
3460 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
3461         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
3462 }
3463
3464 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
3465         assert(path);
3466
3467         /* Under the assumption that we are running privileged we
3468          * first change the access mode and only then hand out
3469          * ownership to avoid a window where access is too open. */
3470
3471         if (mode != (mode_t) -1)
3472                 if (chmod(path, mode) < 0)
3473                         return -errno;
3474
3475         if (uid != (uid_t) -1 || gid != (gid_t) -1)
3476                 if (chown(path, uid, gid) < 0)
3477                         return -errno;
3478
3479         return 0;
3480 }
3481
3482 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
3483         assert(fd >= 0);
3484
3485         /* Under the assumption that we are running privileged we
3486          * first change the access mode and only then hand out
3487          * ownership to avoid a window where access is too open. */
3488
3489         if (fchmod(fd, mode) < 0)
3490                 return -errno;
3491
3492         if (fchown(fd, uid, gid) < 0)
3493                 return -errno;
3494
3495         return 0;
3496 }
3497
3498 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
3499         cpu_set_t *r;
3500         unsigned n = 1024;
3501
3502         /* Allocates the cpuset in the right size */
3503
3504         for (;;) {
3505                 if (!(r = CPU_ALLOC(n)))
3506                         return NULL;
3507
3508                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
3509                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
3510
3511                         if (ncpus)
3512                                 *ncpus = n;
3513
3514                         return r;
3515                 }
3516
3517                 CPU_FREE(r);
3518
3519                 if (errno != EINVAL)
3520                         return NULL;
3521
3522                 n *= 2;
3523         }
3524 }
3525
3526 void status_vprintf(const char *status, bool ellipse, const char *format, va_list ap) {
3527         char *s = NULL;
3528         static const char status_indent[] = "         "; /* "[" STATUS "] " */
3529         int fd = -1;
3530         struct iovec iovec[5];
3531         int n = 0;
3532
3533         assert(format);
3534
3535         /* This is independent of logging, as status messages are
3536          * optional and go exclusively to the console. */
3537
3538         if (vasprintf(&s, format, ap) < 0)
3539                 goto finish;
3540
3541         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
3542         if (fd < 0)
3543                 goto finish;
3544
3545         if (ellipse) {
3546                 char *e;
3547                 size_t emax, sl;
3548                 int c;
3549
3550                 c = fd_columns(fd);
3551                 if (c <= 0)
3552                         c = 80;
3553
3554                 sl = status ? strlen(status_indent) : 0;
3555
3556                 emax = c - sl - 1;
3557                 if (emax < 3)
3558                         emax = 3;
3559
3560                 e = ellipsize(s, emax, 75);
3561                 if (e) {
3562                         free(s);
3563                         s = e;
3564                 }
3565         }
3566
3567         zero(iovec);
3568
3569         if (status) {
3570                 if (!isempty(status)) {
3571                         IOVEC_SET_STRING(iovec[n++], "[");
3572                         IOVEC_SET_STRING(iovec[n++], status);
3573                         IOVEC_SET_STRING(iovec[n++], "] ");
3574                 } else
3575                         IOVEC_SET_STRING(iovec[n++], status_indent);
3576         }
3577
3578         IOVEC_SET_STRING(iovec[n++], s);
3579         IOVEC_SET_STRING(iovec[n++], "\n");
3580
3581         writev(fd, iovec, n);
3582
3583 finish:
3584         free(s);
3585
3586         if (fd >= 0)
3587                 close_nointr_nofail(fd);
3588 }
3589
3590 void status_printf(const char *status, bool ellipse, const char *format, ...) {
3591         va_list ap;
3592
3593         assert(format);
3594
3595         va_start(ap, format);
3596         status_vprintf(status, ellipse, format, ap);
3597         va_end(ap);
3598 }
3599
3600 void status_welcome(void) {
3601         char *pretty_name = NULL, *ansi_color = NULL;
3602         const char *const_pretty = NULL, *const_color = NULL;
3603         int r;
3604
3605         if ((r = parse_env_file("/etc/os-release", NEWLINE,
3606                                 "PRETTY_NAME", &pretty_name,
3607                                 "ANSI_COLOR", &ansi_color,
3608                                 NULL)) < 0) {
3609
3610                 if (r != -ENOENT)
3611                         log_warning("Failed to read /etc/os-release: %s", strerror(-r));
3612         }
3613
3614         if (!pretty_name && !const_pretty)
3615                 const_pretty = "Linux";
3616
3617         if (!ansi_color && !const_color)
3618                 const_color = "1";
3619
3620         status_printf(NULL,
3621                       false,
3622                       "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
3623                       const_color ? const_color : ansi_color,
3624                       const_pretty ? const_pretty : pretty_name);
3625
3626         free(ansi_color);
3627         free(pretty_name);
3628 }
3629
3630 char *replace_env(const char *format, char **env) {
3631         enum {
3632                 WORD,
3633                 CURLY,
3634                 VARIABLE
3635         } state = WORD;
3636
3637         const char *e, *word = format;
3638         char *r = NULL, *k;
3639
3640         assert(format);
3641
3642         for (e = format; *e; e ++) {
3643
3644                 switch (state) {
3645
3646                 case WORD:
3647                         if (*e == '$')
3648                                 state = CURLY;
3649                         break;
3650
3651                 case CURLY:
3652                         if (*e == '{') {
3653                                 if (!(k = strnappend(r, word, e-word-1)))
3654                                         goto fail;
3655
3656                                 free(r);
3657                                 r = k;
3658
3659                                 word = e-1;
3660                                 state = VARIABLE;
3661
3662                         } else if (*e == '$') {
3663                                 if (!(k = strnappend(r, word, e-word)))
3664                                         goto fail;
3665
3666                                 free(r);
3667                                 r = k;
3668
3669                                 word = e+1;
3670                                 state = WORD;
3671                         } else
3672                                 state = WORD;
3673                         break;
3674
3675                 case VARIABLE:
3676                         if (*e == '}') {
3677                                 const char *t;
3678
3679                                 if (!(t = strv_env_get_with_length(env, word+2, e-word-2)))
3680                                         t = "";
3681
3682                                 if (!(k = strappend(r, t)))
3683                                         goto fail;
3684
3685                                 free(r);
3686                                 r = k;
3687
3688                                 word = e+1;
3689                                 state = WORD;
3690                         }
3691                         break;
3692                 }
3693         }
3694
3695         if (!(k = strnappend(r, word, e-word)))
3696                 goto fail;
3697
3698         free(r);
3699         return k;
3700
3701 fail:
3702         free(r);
3703         return NULL;
3704 }
3705
3706 char **replace_env_argv(char **argv, char **env) {
3707         char **r, **i;
3708         unsigned k = 0, l = 0;
3709
3710         l = strv_length(argv);
3711
3712         if (!(r = new(char*, l+1)))
3713                 return NULL;
3714
3715         STRV_FOREACH(i, argv) {
3716
3717                 /* If $FOO appears as single word, replace it by the split up variable */
3718                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3719                         char *e;
3720                         char **w, **m;
3721                         unsigned q;
3722
3723                         if ((e = strv_env_get(env, *i+1))) {
3724
3725                                 if (!(m = strv_split_quoted(e))) {
3726                                         r[k] = NULL;
3727                                         strv_free(r);
3728                                         return NULL;
3729                                 }
3730                         } else
3731                                 m = NULL;
3732
3733                         q = strv_length(m);
3734                         l = l + q - 1;
3735
3736                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3737                                 r[k] = NULL;
3738                                 strv_free(r);
3739                                 strv_free(m);
3740                                 return NULL;
3741                         }
3742
3743                         r = w;
3744                         if (m) {
3745                                 memcpy(r + k, m, q * sizeof(char*));
3746                                 free(m);
3747                         }
3748
3749                         k += q;
3750                         continue;
3751                 }
3752
3753                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3754                 if (!(r[k++] = replace_env(*i, env))) {
3755                         strv_free(r);
3756                         return NULL;
3757                 }
3758         }
3759
3760         r[k] = NULL;
3761         return r;
3762 }
3763
3764 int fd_columns(int fd) {
3765         struct winsize ws;
3766         zero(ws);
3767
3768         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3769                 return -errno;
3770
3771         if (ws.ws_col <= 0)
3772                 return -EIO;
3773
3774         return ws.ws_col;
3775 }
3776
3777 static unsigned columns_cached(bool cached) {
3778         static __thread int parsed_columns = 0, env_columns = -1;
3779         const char *e;
3780
3781         if (_likely_(parsed_columns > 0 && cached))
3782                 return parsed_columns;
3783
3784         if (_unlikely_(env_columns == -1)) {
3785                 e = getenv("COLUMNS");
3786                 if (e)
3787                         env_columns = atoi(e);
3788                 else
3789                         env_columns = 0;
3790         }
3791
3792         if (env_columns > 0) {
3793                 parsed_columns = env_columns;
3794                 return parsed_columns;
3795         }
3796
3797         if (parsed_columns <= 0 || !cached)
3798                 parsed_columns = fd_columns(STDOUT_FILENO);
3799
3800         if (parsed_columns <= 0)
3801                 parsed_columns = 80;
3802
3803         return parsed_columns;
3804 }
3805
3806 unsigned columns(void) {
3807         return columns_cached(true);
3808 }
3809
3810 unsigned columns_uncached(void) {
3811         return columns_cached(false);
3812 }
3813
3814 int fd_lines(int fd) {
3815         struct winsize ws;
3816         zero(ws);
3817
3818         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3819                 return -errno;
3820
3821         if (ws.ws_row <= 0)
3822                 return -EIO;
3823
3824         return ws.ws_row;
3825 }
3826
3827 unsigned lines(void) {
3828         static __thread int parsed_lines = 0;
3829         const char *e;
3830
3831         if (_likely_(parsed_lines > 0))
3832                 return parsed_lines;
3833
3834         e = getenv("LINES");
3835         if (e)
3836                 parsed_lines = atoi(e);
3837
3838         if (parsed_lines <= 0)
3839                 parsed_lines = fd_lines(STDOUT_FILENO);
3840
3841         if (parsed_lines <= 0)
3842                 parsed_lines = 25;
3843
3844         return parsed_lines;
3845 }
3846
3847 int running_in_chroot(void) {
3848         struct stat a, b;
3849
3850         zero(a);
3851         zero(b);
3852
3853         /* Only works as root */
3854
3855         if (stat("/proc/1/root", &a) < 0)
3856                 return -errno;
3857
3858         if (stat("/", &b) < 0)
3859                 return -errno;
3860
3861         return
3862                 a.st_dev != b.st_dev ||
3863                 a.st_ino != b.st_ino;
3864 }
3865
3866 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3867         size_t x;
3868         char *r;
3869
3870         assert(s);
3871         assert(percent <= 100);
3872         assert(new_length >= 3);
3873
3874         if (old_length <= 3 || old_length <= new_length)
3875                 return strndup(s, old_length);
3876
3877         r = new0(char, new_length+1);
3878         if (!r)
3879                 return r;
3880
3881         x = (new_length * percent) / 100;
3882
3883         if (x > new_length - 3)
3884                 x = new_length - 3;
3885
3886         memcpy(r, s, x);
3887         r[x] = '.';
3888         r[x+1] = '.';
3889         r[x+2] = '.';
3890         memcpy(r + x + 3,
3891                s + old_length - (new_length - x - 3),
3892                new_length - x - 3);
3893
3894         return r;
3895 }
3896
3897 char *ellipsize(const char *s, size_t length, unsigned percent) {
3898         return ellipsize_mem(s, strlen(s), length, percent);
3899 }
3900
3901 int touch(const char *path) {
3902         int fd;
3903
3904         assert(path);
3905
3906         if ((fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644)) < 0)
3907                 return -errno;
3908
3909         close_nointr_nofail(fd);
3910         return 0;
3911 }
3912
3913 char *unquote(const char *s, const char* quotes) {
3914         size_t l;
3915         assert(s);
3916
3917         l = strlen(s);
3918         if (l < 2)
3919                 return strdup(s);
3920
3921         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3922                 return strndup(s+1, l-2);
3923
3924         return strdup(s);
3925 }
3926
3927 char *normalize_env_assignment(const char *s) {
3928         char *name, *value, *p, *r;
3929
3930         p = strchr(s, '=');
3931
3932         if (!p) {
3933                 if (!(r = strdup(s)))
3934                         return NULL;
3935
3936                 return strstrip(r);
3937         }
3938
3939         if (!(name = strndup(s, p - s)))
3940                 return NULL;
3941
3942         if (!(p = strdup(p+1))) {
3943                 free(name);
3944                 return NULL;
3945         }
3946
3947         value = unquote(strstrip(p), QUOTES);
3948         free(p);
3949
3950         if (!value) {
3951                 free(name);
3952                 return NULL;
3953         }
3954
3955         if (asprintf(&r, "%s=%s", name, value) < 0)
3956                 r = NULL;
3957
3958         free(value);
3959         free(name);
3960
3961         return r;
3962 }
3963
3964 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3965         siginfo_t dummy;
3966
3967         assert(pid >= 1);
3968
3969         if (!status)
3970                 status = &dummy;