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