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