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