chiark / gitweb /
0444cf44561360d20f0589e17283c5517fc77ee2
[elogind.git] / src / shared / util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <stdlib.h>
27 #include <signal.h>
28 #include <stdio.h>
29 #include <syslog.h>
30 #include <sched.h>
31 #include <sys/resource.h>
32 #include <linux/sched.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <fcntl.h>
36 #include <dirent.h>
37 #include <sys/ioctl.h>
38 #include <linux/vt.h>
39 #include <linux/tiocl.h>
40 #include <termios.h>
41 #include <stdarg.h>
42 #include <sys/inotify.h>
43 #include <sys/poll.h>
44 #include <libgen.h>
45 #include <ctype.h>
46 #include <sys/prctl.h>
47 #include <sys/utsname.h>
48 #include <pwd.h>
49 #include <netinet/ip.h>
50 #include <linux/kd.h>
51 #include <dlfcn.h>
52 #include <sys/wait.h>
53 #include <sys/time.h>
54 #include <glob.h>
55 #include <grp.h>
56 #include <sys/mman.h>
57 #include <sys/vfs.h>
58 #include <linux/magic.h>
59 #include <limits.h>
60 #include <langinfo.h>
61 #include <locale.h>
62
63 #include "macro.h"
64 #include "util.h"
65 #include "ioprio.h"
66 #include "missing.h"
67 #include "log.h"
68 #include "strv.h"
69 #include "label.h"
70 #include "path-util.h"
71 #include "exit-status.h"
72 #include "hashmap.h"
73 #include "env-util.h"
74 #include "fileio.h"
75
76 int saved_argc = 0;
77 char **saved_argv = NULL;
78
79 static volatile unsigned cached_columns = 0;
80 static volatile unsigned cached_lines = 0;
81
82 size_t page_size(void) {
83         static __thread size_t pgsz = 0;
84         long r;
85
86         if (_likely_(pgsz > 0))
87                 return pgsz;
88
89         r = sysconf(_SC_PAGESIZE);
90         assert(r > 0);
91
92         pgsz = (size_t) r;
93         return pgsz;
94 }
95
96 bool streq_ptr(const char *a, const char *b) {
97
98         /* Like streq(), but tries to make sense of NULL pointers */
99
100         if (a && b)
101                 return streq(a, b);
102
103         if (!a && !b)
104                 return true;
105
106         return false;
107 }
108
109 char* endswith(const char *s, const char *postfix) {
110         size_t sl, pl;
111
112         assert(s);
113         assert(postfix);
114
115         sl = strlen(s);
116         pl = strlen(postfix);
117
118         if (pl == 0)
119                 return (char*) s + sl;
120
121         if (sl < pl)
122                 return NULL;
123
124         if (memcmp(s + sl - pl, postfix, pl) != 0)
125                 return NULL;
126
127         return (char*) s + sl - pl;
128 }
129
130 char* startswith(const char *s, const char *prefix) {
131         const char *a, *b;
132
133         assert(s);
134         assert(prefix);
135
136         a = s, b = prefix;
137         for (;;) {
138                 if (*b == 0)
139                         return (char*) a;
140                 if (*a != *b)
141                         return NULL;
142
143                 a++, b++;
144         }
145 }
146
147 char* startswith_no_case(const char *s, const char *prefix) {
148         const char *a, *b;
149
150         assert(s);
151         assert(prefix);
152
153         a = s, b = prefix;
154         for (;;) {
155                 if (*b == 0)
156                         return (char*) a;
157                 if (tolower(*a) != tolower(*b))
158                         return NULL;
159
160                 a++, b++;
161         }
162 }
163
164 bool first_word(const char *s, const char *word) {
165         size_t sl, wl;
166
167         assert(s);
168         assert(word);
169
170         sl = strlen(s);
171         wl = strlen(word);
172
173         if (sl < wl)
174                 return false;
175
176         if (wl == 0)
177                 return true;
178
179         if (memcmp(s, word, wl) != 0)
180                 return false;
181
182         return s[wl] == 0 ||
183                 strchr(WHITESPACE, s[wl]);
184 }
185
186 int close_nointr(int fd) {
187         int r;
188
189         assert(fd >= 0);
190         r = close(fd);
191
192         /* Just ignore EINTR; a retry loop is the wrong
193          * thing to do on Linux.
194          *
195          * http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html
196          * https://bugzilla.gnome.org/show_bug.cgi?id=682819
197          * http://utcc.utoronto.ca/~cks/space/blog/unix/CloseEINTR
198          * https://sites.google.com/site/michaelsafyan/software-engineering/checkforeintrwheninvokingclosethinkagain
199          */
200         if (_unlikely_(r < 0 && errno == EINTR))
201                 return 0;
202         else if (r >= 0)
203                 return r;
204         else
205                 return -errno;
206 }
207
208 void close_nointr_nofail(int fd) {
209         int saved_errno = errno;
210
211         /* like close_nointr() but cannot fail, and guarantees errno
212          * is unchanged */
213
214         assert_se(close_nointr(fd) == 0);
215
216         errno = saved_errno;
217 }
218
219 void close_many(const int fds[], unsigned n_fd) {
220         unsigned i;
221
222         assert(fds || n_fd <= 0);
223
224         for (i = 0; i < n_fd; i++)
225                 close_nointr_nofail(fds[i]);
226 }
227
228 int parse_boolean(const char *v) {
229         assert(v);
230
231         if (streq(v, "1") || v[0] == 'y' || v[0] == 'Y' || v[0] == 't' || v[0] == 'T' || strcaseeq(v, "on"))
232                 return 1;
233         else if (streq(v, "0") || v[0] == 'n' || v[0] == 'N' || v[0] == 'f' || v[0] == 'F' || strcaseeq(v, "off"))
234                 return 0;
235
236         return -EINVAL;
237 }
238
239 int parse_pid(const char *s, pid_t* ret_pid) {
240         unsigned long ul = 0;
241         pid_t pid;
242         int r;
243
244         assert(s);
245         assert(ret_pid);
246
247         r = safe_atolu(s, &ul);
248         if (r < 0)
249                 return r;
250
251         pid = (pid_t) ul;
252
253         if ((unsigned long) pid != ul)
254                 return -ERANGE;
255
256         if (pid <= 0)
257                 return -ERANGE;
258
259         *ret_pid = pid;
260         return 0;
261 }
262
263 int parse_uid(const char *s, uid_t* ret_uid) {
264         unsigned long ul = 0;
265         uid_t uid;
266         int r;
267
268         assert(s);
269         assert(ret_uid);
270
271         r = safe_atolu(s, &ul);
272         if (r < 0)
273                 return r;
274
275         uid = (uid_t) ul;
276
277         if ((unsigned long) uid != ul)
278                 return -ERANGE;
279
280         *ret_uid = uid;
281         return 0;
282 }
283
284 int safe_atou(const char *s, unsigned *ret_u) {
285         char *x = NULL;
286         unsigned long l;
287
288         assert(s);
289         assert(ret_u);
290
291         errno = 0;
292         l = strtoul(s, &x, 0);
293
294         if (!x || x == s || *x || errno)
295                 return errno > 0 ? -errno : -EINVAL;
296
297         if ((unsigned long) (unsigned) l != l)
298                 return -ERANGE;
299
300         *ret_u = (unsigned) l;
301         return 0;
302 }
303
304 int safe_atoi(const char *s, int *ret_i) {
305         char *x = NULL;
306         long l;
307
308         assert(s);
309         assert(ret_i);
310
311         errno = 0;
312         l = strtol(s, &x, 0);
313
314         if (!x || x == s || *x || errno)
315                 return errno > 0 ? -errno : -EINVAL;
316
317         if ((long) (int) l != l)
318                 return -ERANGE;
319
320         *ret_i = (int) l;
321         return 0;
322 }
323
324 int safe_atollu(const char *s, long long unsigned *ret_llu) {
325         char *x = NULL;
326         unsigned long long l;
327
328         assert(s);
329         assert(ret_llu);
330
331         errno = 0;
332         l = strtoull(s, &x, 0);
333
334         if (!x || x == s || *x || errno)
335                 return errno ? -errno : -EINVAL;
336
337         *ret_llu = l;
338         return 0;
339 }
340
341 int safe_atolli(const char *s, long long int *ret_lli) {
342         char *x = NULL;
343         long long l;
344
345         assert(s);
346         assert(ret_lli);
347
348         errno = 0;
349         l = strtoll(s, &x, 0);
350
351         if (!x || x == s || *x || errno)
352                 return errno ? -errno : -EINVAL;
353
354         *ret_lli = l;
355         return 0;
356 }
357
358 int safe_atod(const char *s, double *ret_d) {
359         char *x = NULL;
360         double d;
361
362         assert(s);
363         assert(ret_d);
364
365         errno = 0;
366         d = strtod(s, &x);
367
368         if (!x || x == s || *x || errno)
369                 return errno ? -errno : -EINVAL;
370
371         *ret_d = (double) d;
372         return 0;
373 }
374
375 /* Split a string into words. */
376 char *split(const char *c, size_t *l, const char *separator, char **state) {
377         char *current;
378
379         current = *state ? *state : (char*) c;
380
381         if (!*current || *c == 0)
382                 return NULL;
383
384         current += strspn(current, separator);
385         *l = strcspn(current, separator);
386         *state = current+*l;
387
388         return (char*) current;
389 }
390
391 /* Split a string into words, but consider strings enclosed in '' and
392  * "" as words even if they include spaces. */
393 char *split_quoted(const char *c, size_t *l, char **state) {
394         char *current, *e;
395         bool escaped = false;
396
397         current = *state ? *state : (char*) c;
398
399         if (!*current || *c == 0)
400                 return NULL;
401
402         current += strspn(current, WHITESPACE);
403
404         if (*current == '\'') {
405                 current ++;
406
407                 for (e = current; *e; e++) {
408                         if (escaped)
409                                 escaped = false;
410                         else if (*e == '\\')
411                                 escaped = true;
412                         else if (*e == '\'')
413                                 break;
414                 }
415
416                 *l = e-current;
417                 *state = *e == 0 ? e : e+1;
418         } else if (*current == '\"') {
419                 current ++;
420
421                 for (e = current; *e; e++) {
422                         if (escaped)
423                                 escaped = false;
424                         else if (*e == '\\')
425                                 escaped = true;
426                         else if (*e == '\"')
427                                 break;
428                 }
429
430                 *l = e-current;
431                 *state = *e == 0 ? e : e+1;
432         } else {
433                 for (e = current; *e; e++) {
434                         if (escaped)
435                                 escaped = false;
436                         else if (*e == '\\')
437                                 escaped = true;
438                         else if (strchr(WHITESPACE, *e))
439                                 break;
440                 }
441                 *l = e-current;
442                 *state = e;
443         }
444
445         return (char*) current;
446 }
447
448 int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
449         int r;
450         _cleanup_fclose_ FILE *f = NULL;
451         char fn[PATH_MAX], line[LINE_MAX], *p;
452         long unsigned ppid;
453
454         assert(pid > 0);
455         assert(_ppid);
456
457         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
458         char_array_0(fn);
459
460         f = fopen(fn, "re");
461         if (!f)
462                 return -errno;
463
464         if (!fgets(line, sizeof(line), f)) {
465                 r = feof(f) ? -EIO : -errno;
466                 return r;
467         }
468
469         /* Let's skip the pid and comm fields. The latter is enclosed
470          * in () but does not escape any () in its value, so let's
471          * skip over it manually */
472
473         p = strrchr(line, ')');
474         if (!p)
475                 return -EIO;
476
477         p++;
478
479         if (sscanf(p, " "
480                    "%*c "  /* state */
481                    "%lu ", /* ppid */
482                    &ppid) != 1)
483                 return -EIO;
484
485         if ((long unsigned) (pid_t) ppid != ppid)
486                 return -ERANGE;
487
488         *_ppid = (pid_t) ppid;
489
490         return 0;
491 }
492
493 int get_starttime_of_pid(pid_t pid, unsigned long long *st) {
494         _cleanup_fclose_ FILE *f = NULL;
495         char fn[PATH_MAX], line[LINE_MAX], *p;
496
497         assert(pid > 0);
498         assert(st);
499
500         assert_se(snprintf(fn, sizeof(fn)-1, "/proc/%lu/stat", (unsigned long) pid) < (int) (sizeof(fn)-1));
501         char_array_0(fn);
502
503         f = fopen(fn, "re");
504         if (!f)
505                 return -errno;
506
507         if (!fgets(line, sizeof(line), f)) {
508                 if (ferror(f))
509                         return -errno;
510
511                 return -EIO;
512         }
513
514         /* Let's skip the pid and comm fields. The latter is enclosed
515          * in () but does not escape any () in its value, so let's
516          * skip over it manually */
517
518         p = strrchr(line, ')');
519         if (!p)
520                 return -EIO;
521
522         p++;
523
524         if (sscanf(p, " "
525                    "%*c "  /* state */
526                    "%*d "  /* ppid */
527                    "%*d "  /* pgrp */
528                    "%*d "  /* session */
529                    "%*d "  /* tty_nr */
530                    "%*d "  /* tpgid */
531                    "%*u "  /* flags */
532                    "%*u "  /* minflt */
533                    "%*u "  /* cminflt */
534                    "%*u "  /* majflt */
535                    "%*u "  /* cmajflt */
536                    "%*u "  /* utime */
537                    "%*u "  /* stime */
538                    "%*d "  /* cutime */
539                    "%*d "  /* cstime */
540                    "%*d "  /* priority */
541                    "%*d "  /* nice */
542                    "%*d "  /* num_threads */
543                    "%*d "  /* itrealvalue */
544                    "%llu "  /* starttime */,
545                    st) != 1)
546                 return -EIO;
547
548         return 0;
549 }
550
551 int fchmod_umask(int fd, mode_t m) {
552         mode_t u;
553         int r;
554
555         u = umask(0777);
556         r = fchmod(fd, m & (~u)) < 0 ? -errno : 0;
557         umask(u);
558
559         return r;
560 }
561
562 char *truncate_nl(char *s) {
563         assert(s);
564
565         s[strcspn(s, NEWLINE)] = 0;
566         return s;
567 }
568
569 int get_process_comm(pid_t pid, char **name) {
570         int r;
571
572         assert(name);
573
574         if (pid == 0)
575                 r = read_one_line_file("/proc/self/comm", name);
576         else {
577                 char *p;
578                 if (asprintf(&p, "/proc/%lu/comm", (unsigned long) pid) < 0)
579                         return -ENOMEM;
580
581                 r = read_one_line_file(p, name);
582                 free(p);
583         }
584
585         return r;
586 }
587
588 int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
589         char *r = NULL, *k;
590         int c;
591         FILE *f;
592
593         assert(line);
594
595         if (pid == 0)
596                 f = fopen("/proc/self/cmdline", "re");
597         else {
598                 char *p;
599                 if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
600                         return -ENOMEM;
601
602                 f = fopen(p, "re");
603                 free(p);
604         }
605
606         if (!f)
607                 return -errno;
608         if (max_length == 0) {
609                 size_t len = 1;
610                 while ((c = getc(f)) != EOF) {
611                         k = realloc(r, len+1);
612                         if (k == NULL) {
613                                 free(r);
614                                 fclose(f);
615                                 return -ENOMEM;
616                         }
617                         r = k;
618                         r[len-1] = isprint(c) ? c : ' ';
619                         r[len] = 0;
620                         len++;
621                 }
622         } else {
623                 bool space = false;
624                 size_t left;
625                 r = new(char, max_length);
626                 if (!r) {
627                         fclose(f);
628                         return -ENOMEM;
629                 }
630
631                 k = r;
632                 left = max_length;
633                 while ((c = getc(f)) != EOF) {
634
635                         if (isprint(c)) {
636                                 if (space) {
637                                         if (left <= 4)
638                                                 break;
639
640                                         *(k++) = ' ';
641                                         left--;
642                                         space = false;
643                                 }
644
645                                 if (left <= 4)
646                                         break;
647
648                                 *(k++) = (char) c;
649                                 left--;
650                         }  else
651                                 space = true;
652                 }
653
654                 if (left <= 4) {
655                         size_t n = MIN(left-1, 3U);
656                         memcpy(k, "...", n);
657                         k[n] = 0;
658                 } else
659                         *k = 0;
660         }
661
662         fclose(f);
663
664         /* Kernel threads have no argv[] */
665         if (r == NULL || r[0] == 0) {
666                 char *t;
667                 int h;
668
669                 free(r);
670
671                 if (!comm_fallback)
672                         return -ENOENT;
673
674                 h = get_process_comm(pid, &t);
675                 if (h < 0)
676                         return h;
677
678                 r = strjoin("[", t, "]", NULL);
679                 free(t);
680
681                 if (!r)
682                         return -ENOMEM;
683         }
684
685         *line = r;
686         return 0;
687 }
688
689 int is_kernel_thread(pid_t pid) {
690         char *p;
691         size_t count;
692         char c;
693         bool eof;
694         FILE *f;
695
696         if (pid == 0)
697                 return 0;
698
699         if (asprintf(&p, "/proc/%lu/cmdline", (unsigned long) pid) < 0)
700                 return -ENOMEM;
701
702         f = fopen(p, "re");
703         free(p);
704
705         if (!f)
706                 return -errno;
707
708         count = fread(&c, 1, 1, f);
709         eof = feof(f);
710         fclose(f);
711
712         /* Kernel threads have an empty cmdline */
713
714         if (count <= 0)
715                 return eof ? 1 : -errno;
716
717         return 0;
718 }
719
720 int get_process_exe(pid_t pid, char **name) {
721         int r;
722
723         assert(name);
724
725         if (pid == 0)
726                 r = readlink_malloc("/proc/self/exe", name);
727         else {
728                 char *p;
729                 if (asprintf(&p, "/proc/%lu/exe", (unsigned long) pid) < 0)
730                         return -ENOMEM;
731
732                 r = readlink_malloc(p, name);
733                 free(p);
734         }
735
736         return r;
737 }
738
739 static int get_process_id(pid_t pid, const char *field, uid_t *uid) {
740         _cleanup_fclose_ FILE *f = NULL;
741         _cleanup_free_ char *p = NULL;
742         char line[LINE_MAX];
743
744         assert(field);
745         assert(uid);
746
747         if (pid == 0)
748                 return getuid();
749
750         if (asprintf(&p, "/proc/%lu/status", (unsigned long) pid) < 0)
751                 return -ENOMEM;
752
753         f = fopen(p, "re");
754         if (!f)
755                 return -errno;
756
757         FOREACH_LINE(line, f, return -errno) {
758                 char *l;
759
760                 l = strstrip(line);
761
762                 if (startswith(l, field)) {
763                         l += strlen(field);
764                         l += strspn(l, WHITESPACE);
765
766                         l[strcspn(l, WHITESPACE)] = 0;
767
768                         return parse_uid(l, uid);
769                 }
770         }
771
772         return -EIO;
773 }
774
775 int get_process_uid(pid_t pid, uid_t *uid) {
776         return get_process_id(pid, "Uid:", uid);
777 }
778
779 int get_process_gid(pid_t pid, gid_t *gid) {
780         return get_process_id(pid, "Gid:", gid);
781 }
782
783 char *strnappend(const char *s, const char *suffix, size_t b) {
784         size_t a;
785         char *r;
786
787         if (!s && !suffix)
788                 return strdup("");
789
790         if (!s)
791                 return strndup(suffix, b);
792
793         if (!suffix)
794                 return strdup(s);
795
796         assert(s);
797         assert(suffix);
798
799         a = strlen(s);
800         if (b > ((size_t) -1) - a)
801                 return NULL;
802
803         r = new(char, a+b+1);
804         if (!r)
805                 return NULL;
806
807         memcpy(r, s, a);
808         memcpy(r+a, suffix, b);
809         r[a+b] = 0;
810
811         return r;
812 }
813
814 char *strappend(const char *s, const char *suffix) {
815         return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
816 }
817
818 int readlink_malloc(const char *p, char **r) {
819         size_t l = 100;
820
821         assert(p);
822         assert(r);
823
824         for (;;) {
825                 char *c;
826                 ssize_t n;
827
828                 if (!(c = new(char, l)))
829                         return -ENOMEM;
830
831                 if ((n = readlink(p, c, l-1)) < 0) {
832                         int ret = -errno;
833                         free(c);
834                         return ret;
835                 }
836
837                 if ((size_t) n < l-1) {
838                         c[n] = 0;
839                         *r = c;
840                         return 0;
841                 }
842
843                 free(c);
844                 l *= 2;
845         }
846 }
847
848 int readlink_and_make_absolute(const char *p, char **r) {
849         char *target, *k;
850         int j;
851
852         assert(p);
853         assert(r);
854
855         if ((j = readlink_malloc(p, &target)) < 0)
856                 return j;
857
858         k = file_in_same_dir(p, target);
859         free(target);
860
861         if (!k)
862                 return -ENOMEM;
863
864         *r = k;
865         return 0;
866 }
867
868 int readlink_and_canonicalize(const char *p, char **r) {
869         char *t, *s;
870         int j;
871
872         assert(p);
873         assert(r);
874
875         j = readlink_and_make_absolute(p, &t);
876         if (j < 0)
877                 return j;
878
879         s = canonicalize_file_name(t);
880         if (s) {
881                 free(t);
882                 *r = s;
883         } else
884                 *r = t;
885
886         path_kill_slashes(*r);
887
888         return 0;
889 }
890
891 int reset_all_signal_handlers(void) {
892         int sig;
893
894         for (sig = 1; sig < _NSIG; sig++) {
895                 struct sigaction sa;
896
897                 if (sig == SIGKILL || sig == SIGSTOP)
898                         continue;
899
900                 zero(sa);
901                 sa.sa_handler = SIG_DFL;
902                 sa.sa_flags = SA_RESTART;
903
904                 /* On Linux the first two RT signals are reserved by
905                  * glibc, and sigaction() will return EINVAL for them. */
906                 if ((sigaction(sig, &sa, NULL) < 0))
907                         if (errno != EINVAL)
908                                 return -errno;
909         }
910
911         return 0;
912 }
913
914 char *strstrip(char *s) {
915         char *e;
916
917         /* Drops trailing whitespace. Modifies the string in
918          * place. Returns pointer to first non-space character */
919
920         s += strspn(s, WHITESPACE);
921
922         for (e = strchr(s, 0); e > s; e --)
923                 if (!strchr(WHITESPACE, e[-1]))
924                         break;
925
926         *e = 0;
927
928         return s;
929 }
930
931 char *delete_chars(char *s, const char *bad) {
932         char *f, *t;
933
934         /* Drops all whitespace, regardless where in the string */
935
936         for (f = s, t = s; *f; f++) {
937                 if (strchr(bad, *f))
938                         continue;
939
940                 *(t++) = *f;
941         }
942
943         *t = 0;
944
945         return s;
946 }
947
948 bool in_charset(const char *s, const char* charset) {
949         const char *i;
950
951         assert(s);
952         assert(charset);
953
954         for (i = s; *i; i++)
955                 if (!strchr(charset, *i))
956                         return false;
957
958         return true;
959 }
960
961 char *file_in_same_dir(const char *path, const char *filename) {
962         char *e, *r;
963         size_t k;
964
965         assert(path);
966         assert(filename);
967
968         /* This removes the last component of path and appends
969          * filename, unless the latter is absolute anyway or the
970          * former isn't */
971
972         if (path_is_absolute(filename))
973                 return strdup(filename);
974
975         if (!(e = strrchr(path, '/')))
976                 return strdup(filename);
977
978         k = strlen(filename);
979         if (!(r = new(char, e-path+1+k+1)))
980                 return NULL;
981
982         memcpy(r, path, e-path+1);
983         memcpy(r+(e-path)+1, filename, k+1);
984
985         return r;
986 }
987
988 int rmdir_parents(const char *path, const char *stop) {
989         size_t l;
990         int r = 0;
991
992         assert(path);
993         assert(stop);
994
995         l = strlen(path);
996
997         /* Skip trailing slashes */
998         while (l > 0 && path[l-1] == '/')
999                 l--;
1000
1001         while (l > 0) {
1002                 char *t;
1003
1004                 /* Skip last component */
1005                 while (l > 0 && path[l-1] != '/')
1006                         l--;
1007
1008                 /* Skip trailing slashes */
1009                 while (l > 0 && path[l-1] == '/')
1010                         l--;
1011
1012                 if (l <= 0)
1013                         break;
1014
1015                 if (!(t = strndup(path, l)))
1016                         return -ENOMEM;
1017
1018                 if (path_startswith(stop, t)) {
1019                         free(t);
1020                         return 0;
1021                 }
1022
1023                 r = rmdir(t);
1024                 free(t);
1025
1026                 if (r < 0)
1027                         if (errno != ENOENT)
1028                                 return -errno;
1029         }
1030
1031         return 0;
1032 }
1033
1034 char hexchar(int x) {
1035         static const char table[16] = "0123456789abcdef";
1036
1037         return table[x & 15];
1038 }
1039
1040 int unhexchar(char c) {
1041
1042         if (c >= '0' && c <= '9')
1043                 return c - '0';
1044
1045         if (c >= 'a' && c <= 'f')
1046                 return c - 'a' + 10;
1047
1048         if (c >= 'A' && c <= 'F')
1049                 return c - 'A' + 10;
1050
1051         return -1;
1052 }
1053
1054 char *hexmem(const void *p, size_t l) {
1055         char *r, *z;
1056         const uint8_t *x;
1057
1058         z = r = malloc(l * 2 + 1);
1059         if (!r)
1060                 return NULL;
1061
1062         for (x = p; x < (const uint8_t*) p + l; x++) {
1063                 *(z++) = hexchar(*x >> 4);
1064                 *(z++) = hexchar(*x & 15);
1065         }
1066
1067         *z = 0;
1068         return r;
1069 }
1070
1071 char octchar(int x) {
1072         return '0' + (x & 7);
1073 }
1074
1075 int unoctchar(char c) {
1076
1077         if (c >= '0' && c <= '7')
1078                 return c - '0';
1079
1080         return -1;
1081 }
1082
1083 char decchar(int x) {
1084         return '0' + (x % 10);
1085 }
1086
1087 int undecchar(char c) {
1088
1089         if (c >= '0' && c <= '9')
1090                 return c - '0';
1091
1092         return -1;
1093 }
1094
1095 char *cescape(const char *s) {
1096         char *r, *t;
1097         const char *f;
1098
1099         assert(s);
1100
1101         /* Does C style string escaping. */
1102
1103         r = new(char, strlen(s)*4 + 1);
1104         if (!r)
1105                 return NULL;
1106
1107         for (f = s, t = r; *f; f++)
1108
1109                 switch (*f) {
1110
1111                 case '\a':
1112                         *(t++) = '\\';
1113                         *(t++) = 'a';
1114                         break;
1115                 case '\b':
1116                         *(t++) = '\\';
1117                         *(t++) = 'b';
1118                         break;
1119                 case '\f':
1120                         *(t++) = '\\';
1121                         *(t++) = 'f';
1122                         break;
1123                 case '\n':
1124                         *(t++) = '\\';
1125                         *(t++) = 'n';
1126                         break;
1127                 case '\r':
1128                         *(t++) = '\\';
1129                         *(t++) = 'r';
1130                         break;
1131                 case '\t':
1132                         *(t++) = '\\';
1133                         *(t++) = 't';
1134                         break;
1135                 case '\v':
1136                         *(t++) = '\\';
1137                         *(t++) = 'v';
1138                         break;
1139                 case '\\':
1140                         *(t++) = '\\';
1141                         *(t++) = '\\';
1142                         break;
1143                 case '"':
1144                         *(t++) = '\\';
1145                         *(t++) = '"';
1146                         break;
1147                 case '\'':
1148                         *(t++) = '\\';
1149                         *(t++) = '\'';
1150                         break;
1151
1152                 default:
1153                         /* For special chars we prefer octal over
1154                          * hexadecimal encoding, simply because glib's
1155                          * g_strescape() does the same */
1156                         if ((*f < ' ') || (*f >= 127)) {
1157                                 *(t++) = '\\';
1158                                 *(t++) = octchar((unsigned char) *f >> 6);
1159                                 *(t++) = octchar((unsigned char) *f >> 3);
1160                                 *(t++) = octchar((unsigned char) *f);
1161                         } else
1162                                 *(t++) = *f;
1163                         break;
1164                 }
1165
1166         *t = 0;
1167
1168         return r;
1169 }
1170
1171 char *cunescape_length_with_prefix(const char *s, size_t length, const char *prefix) {
1172         char *r, *t;
1173         const char *f;
1174         size_t pl;
1175
1176         assert(s);
1177
1178         /* Undoes C style string escaping, and optionally prefixes it. */
1179
1180         pl = prefix ? strlen(prefix) : 0;
1181
1182         r = new(char, pl+length+1);
1183         if (!r)
1184                 return r;
1185
1186         if (prefix)
1187                 memcpy(r, prefix, pl);
1188
1189         for (f = s, t = r + pl; f < s + length; f++) {
1190
1191                 if (*f != '\\') {
1192                         *(t++) = *f;
1193                         continue;
1194                 }
1195
1196                 f++;
1197
1198                 switch (*f) {
1199
1200                 case 'a':
1201                         *(t++) = '\a';
1202                         break;
1203                 case 'b':
1204                         *(t++) = '\b';
1205                         break;
1206                 case 'f':
1207                         *(t++) = '\f';
1208                         break;
1209                 case 'n':
1210                         *(t++) = '\n';
1211                         break;
1212                 case 'r':
1213                         *(t++) = '\r';
1214                         break;
1215                 case 't':
1216                         *(t++) = '\t';
1217                         break;
1218                 case 'v':
1219                         *(t++) = '\v';
1220                         break;
1221                 case '\\':
1222                         *(t++) = '\\';
1223                         break;
1224                 case '"':
1225                         *(t++) = '"';
1226                         break;
1227                 case '\'':
1228                         *(t++) = '\'';
1229                         break;
1230
1231                 case 's':
1232                         /* This is an extension of the XDG syntax files */
1233                         *(t++) = ' ';
1234                         break;
1235
1236                 case 'x': {
1237                         /* hexadecimal encoding */
1238                         int a, b;
1239
1240                         a = unhexchar(f[1]);
1241                         b = unhexchar(f[2]);
1242
1243                         if (a < 0 || b < 0) {
1244                                 /* Invalid escape code, let's take it literal then */
1245                                 *(t++) = '\\';
1246                                 *(t++) = 'x';
1247                         } else {
1248                                 *(t++) = (char) ((a << 4) | b);
1249                                 f += 2;
1250                         }
1251
1252                         break;
1253                 }
1254
1255                 case '0':
1256                 case '1':
1257                 case '2':
1258                 case '3':
1259                 case '4':
1260                 case '5':
1261                 case '6':
1262                 case '7': {
1263                         /* octal encoding */
1264                         int a, b, c;
1265
1266                         a = unoctchar(f[0]);
1267                         b = unoctchar(f[1]);
1268                         c = unoctchar(f[2]);
1269
1270                         if (a < 0 || b < 0 || c < 0) {
1271                                 /* Invalid escape code, let's take it literal then */
1272                                 *(t++) = '\\';
1273                                 *(t++) = f[0];
1274                         } else {
1275                                 *(t++) = (char) ((a << 6) | (b << 3) | c);
1276                                 f += 2;
1277                         }
1278
1279                         break;
1280                 }
1281
1282                 case 0:
1283                         /* premature end of string.*/
1284                         *(t++) = '\\';
1285                         goto finish;
1286
1287                 default:
1288                         /* Invalid escape code, let's take it literal then */
1289                         *(t++) = '\\';
1290                         *(t++) = *f;
1291                         break;
1292                 }
1293         }
1294
1295 finish:
1296         *t = 0;
1297         return r;
1298 }
1299
1300 char *cunescape_length(const char *s, size_t length) {
1301         return cunescape_length_with_prefix(s, length, NULL);
1302 }
1303
1304 char *cunescape(const char *s) {
1305         assert(s);
1306
1307         return cunescape_length(s, strlen(s));
1308 }
1309
1310 char *xescape(const char *s, const char *bad) {
1311         char *r, *t;
1312         const char *f;
1313
1314         /* Escapes all chars in bad, in addition to \ and all special
1315          * chars, in \xFF style escaping. May be reversed with
1316          * cunescape. */
1317
1318         r = new(char, strlen(s) * 4 + 1);
1319         if (!r)
1320                 return NULL;
1321
1322         for (f = s, t = r; *f; f++) {
1323
1324                 if ((*f < ' ') || (*f >= 127) ||
1325                     (*f == '\\') || strchr(bad, *f)) {
1326                         *(t++) = '\\';
1327                         *(t++) = 'x';
1328                         *(t++) = hexchar(*f >> 4);
1329                         *(t++) = hexchar(*f);
1330                 } else
1331                         *(t++) = *f;
1332         }
1333
1334         *t = 0;
1335
1336         return r;
1337 }
1338
1339 char *bus_path_escape(const char *s) {
1340         char *r, *t;
1341         const char *f;
1342
1343         assert(s);
1344
1345         /* Escapes all chars that D-Bus' object path cannot deal
1346          * with. Can be reverse with bus_path_unescape(). We special
1347          * case the empty string. */
1348
1349         if (*s == 0)
1350                 return strdup("_");
1351
1352         r = new(char, strlen(s)*3 + 1);
1353         if (!r)
1354                 return NULL;
1355
1356         for (f = s, t = r; *f; f++) {
1357
1358                 /* Escape everything that is not a-zA-Z0-9. We also
1359                  * escape 0-9 if it's the first character */
1360
1361                 if (!(*f >= 'A' && *f <= 'Z') &&
1362                     !(*f >= 'a' && *f <= 'z') &&
1363                     !(f > s && *f >= '0' && *f <= '9')) {
1364                         *(t++) = '_';
1365                         *(t++) = hexchar(*f >> 4);
1366                         *(t++) = hexchar(*f);
1367                 } else
1368                         *(t++) = *f;
1369         }
1370
1371         *t = 0;
1372
1373         return r;
1374 }
1375
1376 char *bus_path_unescape(const char *f) {
1377         char *r, *t;
1378
1379         assert(f);
1380
1381         /* Special case for the empty string */
1382         if (streq(f, "_"))
1383                 return strdup("");
1384
1385         r = new(char, strlen(f) + 1);
1386         if (!r)
1387                 return NULL;
1388
1389         for (t = r; *f; f++) {
1390
1391                 if (*f == '_') {
1392                         int a, b;
1393
1394                         if ((a = unhexchar(f[1])) < 0 ||
1395                             (b = unhexchar(f[2])) < 0) {
1396                                 /* Invalid escape code, let's take it literal then */
1397                                 *(t++) = '_';
1398                         } else {
1399                                 *(t++) = (char) ((a << 4) | b);
1400                                 f += 2;
1401                         }
1402                 } else
1403                         *(t++) = *f;
1404         }
1405
1406         *t = 0;
1407
1408         return r;
1409 }
1410
1411 char *ascii_strlower(char *t) {
1412         char *p;
1413
1414         assert(t);
1415
1416         for (p = t; *p; p++)
1417                 if (*p >= 'A' && *p <= 'Z')
1418                         *p = *p - 'A' + 'a';
1419
1420         return t;
1421 }
1422
1423 static bool ignore_file_allow_backup(const char *filename) {
1424         assert(filename);
1425
1426         return
1427                 filename[0] == '.' ||
1428                 streq(filename, "lost+found") ||
1429                 streq(filename, "aquota.user") ||
1430                 streq(filename, "aquota.group") ||
1431                 endswith(filename, ".rpmnew") ||
1432                 endswith(filename, ".rpmsave") ||
1433                 endswith(filename, ".rpmorig") ||
1434                 endswith(filename, ".dpkg-old") ||
1435                 endswith(filename, ".dpkg-new") ||
1436                 endswith(filename, ".swp");
1437 }
1438
1439 bool ignore_file(const char *filename) {
1440         assert(filename);
1441
1442         if (endswith(filename, "~"))
1443                 return false;
1444
1445         return ignore_file_allow_backup(filename);
1446 }
1447
1448 int fd_nonblock(int fd, bool nonblock) {
1449         int flags;
1450
1451         assert(fd >= 0);
1452
1453         if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
1454                 return -errno;
1455
1456         if (nonblock)
1457                 flags |= O_NONBLOCK;
1458         else
1459                 flags &= ~O_NONBLOCK;
1460
1461         if (fcntl(fd, F_SETFL, flags) < 0)
1462                 return -errno;
1463
1464         return 0;
1465 }
1466
1467 int fd_cloexec(int fd, bool cloexec) {
1468         int flags;
1469
1470         assert(fd >= 0);
1471
1472         if ((flags = fcntl(fd, F_GETFD, 0)) < 0)
1473                 return -errno;
1474
1475         if (cloexec)
1476                 flags |= FD_CLOEXEC;
1477         else
1478                 flags &= ~FD_CLOEXEC;
1479
1480         if (fcntl(fd, F_SETFD, flags) < 0)
1481                 return -errno;
1482
1483         return 0;
1484 }
1485
1486 static bool fd_in_set(int fd, const int fdset[], unsigned n_fdset) {
1487         unsigned i;
1488
1489         assert(n_fdset == 0 || fdset);
1490
1491         for (i = 0; i < n_fdset; i++)
1492                 if (fdset[i] == fd)
1493                         return true;
1494
1495         return false;
1496 }
1497
1498 int close_all_fds(const int except[], unsigned n_except) {
1499         DIR *d;
1500         struct dirent *de;
1501         int r = 0;
1502
1503         assert(n_except == 0 || except);
1504
1505         d = opendir("/proc/self/fd");
1506         if (!d) {
1507                 int fd;
1508                 struct rlimit rl;
1509
1510                 /* When /proc isn't available (for example in chroots)
1511                  * the fallback is brute forcing through the fd
1512                  * table */
1513
1514                 assert_se(getrlimit(RLIMIT_NOFILE, &rl) >= 0);
1515                 for (fd = 3; fd < (int) rl.rlim_max; fd ++) {
1516
1517                         if (fd_in_set(fd, except, n_except))
1518                                 continue;
1519
1520                         if (close_nointr(fd) < 0)
1521                                 if (errno != EBADF && r == 0)
1522                                         r = -errno;
1523                 }
1524
1525                 return r;
1526         }
1527
1528         while ((de = readdir(d))) {
1529                 int fd = -1;
1530
1531                 if (ignore_file(de->d_name))
1532                         continue;
1533
1534                 if (safe_atoi(de->d_name, &fd) < 0)
1535                         /* Let's better ignore this, just in case */
1536                         continue;
1537
1538                 if (fd < 3)
1539                         continue;
1540
1541                 if (fd == dirfd(d))
1542                         continue;
1543
1544                 if (fd_in_set(fd, except, n_except))
1545                         continue;
1546
1547                 if (close_nointr(fd) < 0) {
1548                         /* Valgrind has its own FD and doesn't want to have it closed */
1549                         if (errno != EBADF && r == 0)
1550                                 r = -errno;
1551                 }
1552         }
1553
1554         closedir(d);
1555         return r;
1556 }
1557
1558 bool chars_intersect(const char *a, const char *b) {
1559         const char *p;
1560
1561         /* Returns true if any of the chars in a are in b. */
1562         for (p = a; *p; p++)
1563                 if (strchr(b, *p))
1564                         return true;
1565
1566         return false;
1567 }
1568
1569 bool fstype_is_network(const char *fstype) {
1570         static const char table[] =
1571                 "cifs\0"
1572                 "smbfs\0"
1573                 "ncpfs\0"
1574                 "nfs\0"
1575                 "nfs4\0"
1576                 "gfs\0"
1577                 "gfs2\0";
1578
1579         return nulstr_contains(table, fstype);
1580 }
1581
1582 int chvt(int vt) {
1583         _cleanup_close_ int fd;
1584
1585         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
1586         if (fd < 0)
1587                 return -errno;
1588
1589         if (vt < 0) {
1590                 int tiocl[2] = {
1591                         TIOCL_GETKMSGREDIRECT,
1592                         0
1593                 };
1594
1595                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
1596                         return -errno;
1597
1598                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
1599         }
1600
1601         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
1602                 return -errno;
1603
1604         return 0;
1605 }
1606
1607 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
1608         struct termios old_termios, new_termios;
1609         char c;
1610         char line[LINE_MAX];
1611
1612         assert(f);
1613         assert(ret);
1614
1615         if (tcgetattr(fileno(f), &old_termios) >= 0) {
1616                 new_termios = old_termios;
1617
1618                 new_termios.c_lflag &= ~ICANON;
1619                 new_termios.c_cc[VMIN] = 1;
1620                 new_termios.c_cc[VTIME] = 0;
1621
1622                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
1623                         size_t k;
1624
1625                         if (t != (usec_t) -1) {
1626                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
1627                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1628                                         return -ETIMEDOUT;
1629                                 }
1630                         }
1631
1632                         k = fread(&c, 1, 1, f);
1633
1634                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
1635
1636                         if (k <= 0)
1637                                 return -EIO;
1638
1639                         if (need_nl)
1640                                 *need_nl = c != '\n';
1641
1642                         *ret = c;
1643                         return 0;
1644                 }
1645         }
1646
1647         if (t != (usec_t) -1)
1648                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
1649                         return -ETIMEDOUT;
1650
1651         if (!fgets(line, sizeof(line), f))
1652                 return -EIO;
1653
1654         truncate_nl(line);
1655
1656         if (strlen(line) != 1)
1657                 return -EBADMSG;
1658
1659         if (need_nl)
1660                 *need_nl = false;
1661
1662         *ret = line[0];
1663         return 0;
1664 }
1665
1666 int ask(char *ret, const char *replies, const char *text, ...) {
1667
1668         assert(ret);
1669         assert(replies);
1670         assert(text);
1671
1672         for (;;) {
1673                 va_list ap;
1674                 char c;
1675                 int r;
1676                 bool need_nl = true;
1677
1678                 if (on_tty())
1679                         fputs(ANSI_HIGHLIGHT_ON, stdout);
1680
1681                 va_start(ap, text);
1682                 vprintf(text, ap);
1683                 va_end(ap);
1684
1685                 if (on_tty())
1686                         fputs(ANSI_HIGHLIGHT_OFF, stdout);
1687
1688                 fflush(stdout);
1689
1690                 r = read_one_char(stdin, &c, (usec_t) -1, &need_nl);
1691                 if (r < 0) {
1692
1693                         if (r == -EBADMSG) {
1694                                 puts("Bad input, please try again.");
1695                                 continue;
1696                         }
1697
1698                         putchar('\n');
1699                         return r;
1700                 }
1701
1702                 if (need_nl)
1703                         putchar('\n');
1704
1705                 if (strchr(replies, c)) {
1706                         *ret = c;
1707                         return 0;
1708                 }
1709
1710                 puts("Read unexpected character, please try again.");
1711         }
1712 }
1713
1714 int reset_terminal_fd(int fd, bool switch_to_text) {
1715         struct termios termios;
1716         int r = 0;
1717
1718         /* Set terminal to some sane defaults */
1719
1720         assert(fd >= 0);
1721
1722         /* We leave locked terminal attributes untouched, so that
1723          * Plymouth may set whatever it wants to set, and we don't
1724          * interfere with that. */
1725
1726         /* Disable exclusive mode, just in case */
1727         ioctl(fd, TIOCNXCL);
1728
1729         /* Switch to text mode */
1730         if (switch_to_text)
1731                 ioctl(fd, KDSETMODE, KD_TEXT);
1732
1733         /* Enable console unicode mode */
1734         ioctl(fd, KDSKBMODE, K_UNICODE);
1735
1736         if (tcgetattr(fd, &termios) < 0) {
1737                 r = -errno;
1738                 goto finish;
1739         }
1740
1741         /* We only reset the stuff that matters to the software. How
1742          * hardware is set up we don't touch assuming that somebody
1743          * else will do that for us */
1744
1745         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
1746         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
1747         termios.c_oflag |= ONLCR;
1748         termios.c_cflag |= CREAD;
1749         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
1750
1751         termios.c_cc[VINTR]    =   03;  /* ^C */
1752         termios.c_cc[VQUIT]    =  034;  /* ^\ */
1753         termios.c_cc[VERASE]   = 0177;
1754         termios.c_cc[VKILL]    =  025;  /* ^X */
1755         termios.c_cc[VEOF]     =   04;  /* ^D */
1756         termios.c_cc[VSTART]   =  021;  /* ^Q */
1757         termios.c_cc[VSTOP]    =  023;  /* ^S */
1758         termios.c_cc[VSUSP]    =  032;  /* ^Z */
1759         termios.c_cc[VLNEXT]   =  026;  /* ^V */
1760         termios.c_cc[VWERASE]  =  027;  /* ^W */
1761         termios.c_cc[VREPRINT] =  022;  /* ^R */
1762         termios.c_cc[VEOL]     =    0;
1763         termios.c_cc[VEOL2]    =    0;
1764
1765         termios.c_cc[VTIME]  = 0;
1766         termios.c_cc[VMIN]   = 1;
1767
1768         if (tcsetattr(fd, TCSANOW, &termios) < 0)
1769                 r = -errno;
1770
1771 finish:
1772         /* Just in case, flush all crap out */
1773         tcflush(fd, TCIOFLUSH);
1774
1775         return r;
1776 }
1777
1778 int reset_terminal(const char *name) {
1779         int fd, r;
1780
1781         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1782         if (fd < 0)
1783                 return fd;
1784
1785         r = reset_terminal_fd(fd, true);
1786         close_nointr_nofail(fd);
1787
1788         return r;
1789 }
1790
1791 int open_terminal(const char *name, int mode) {
1792         int fd, r;
1793         unsigned c = 0;
1794
1795         /*
1796          * If a TTY is in the process of being closed opening it might
1797          * cause EIO. This is horribly awful, but unlikely to be
1798          * changed in the kernel. Hence we work around this problem by
1799          * retrying a couple of times.
1800          *
1801          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
1802          */
1803
1804         for (;;) {
1805                 fd = open(name, mode);
1806                 if (fd >= 0)
1807                         break;
1808
1809                 if (errno != EIO)
1810                         return -errno;
1811
1812                 /* Max 1s in total */
1813                 if (c >= 20)
1814                         return -errno;
1815
1816                 usleep(50 * USEC_PER_MSEC);
1817                 c++;
1818         }
1819
1820         if (fd < 0)
1821                 return -errno;
1822
1823         r = isatty(fd);
1824         if (r < 0) {
1825                 close_nointr_nofail(fd);
1826                 return -errno;
1827         }
1828
1829         if (!r) {
1830                 close_nointr_nofail(fd);
1831                 return -ENOTTY;
1832         }
1833
1834         return fd;
1835 }
1836
1837 int flush_fd(int fd) {
1838         struct pollfd pollfd;
1839
1840         zero(pollfd);
1841         pollfd.fd = fd;
1842         pollfd.events = POLLIN;
1843
1844         for (;;) {
1845                 char buf[LINE_MAX];
1846                 ssize_t l;
1847                 int r;
1848
1849                 if ((r = poll(&pollfd, 1, 0)) < 0) {
1850
1851                         if (errno == EINTR)
1852                                 continue;
1853
1854                         return -errno;
1855                 }
1856
1857                 if (r == 0)
1858                         return 0;
1859
1860                 if ((l = read(fd, buf, sizeof(buf))) < 0) {
1861
1862                         if (errno == EINTR)
1863                                 continue;
1864
1865                         if (errno == EAGAIN)
1866                                 return 0;
1867
1868                         return -errno;
1869                 }
1870
1871                 if (l <= 0)
1872                         return 0;
1873         }
1874 }
1875
1876 int acquire_terminal(
1877                 const char *name,
1878                 bool fail,
1879                 bool force,
1880                 bool ignore_tiocstty_eperm,
1881                 usec_t timeout) {
1882
1883         int fd = -1, notify = -1, r = 0, wd = -1;
1884         usec_t ts = 0;
1885         struct sigaction sa_old, sa_new;
1886
1887         assert(name);
1888
1889         /* We use inotify to be notified when the tty is closed. We
1890          * create the watch before checking if we can actually acquire
1891          * it, so that we don't lose any event.
1892          *
1893          * Note: strictly speaking this actually watches for the
1894          * device being closed, it does *not* really watch whether a
1895          * tty loses its controlling process. However, unless some
1896          * rogue process uses TIOCNOTTY on /dev/tty *after* closing
1897          * its tty otherwise this will not become a problem. As long
1898          * as the administrator makes sure not configure any service
1899          * on the same tty as an untrusted user this should not be a
1900          * problem. (Which he probably should not do anyway.) */
1901
1902         if (timeout != (usec_t) -1)
1903                 ts = now(CLOCK_MONOTONIC);
1904
1905         if (!fail && !force) {
1906                 notify = inotify_init1(IN_CLOEXEC | (timeout != (usec_t) -1 ? IN_NONBLOCK : 0));
1907                 if (notify < 0) {
1908                         r = -errno;
1909                         goto fail;
1910                 }
1911
1912                 wd = inotify_add_watch(notify, name, IN_CLOSE);
1913                 if (wd < 0) {
1914                         r = -errno;
1915                         goto fail;
1916                 }
1917         }
1918
1919         for (;;) {
1920                 if (notify >= 0) {
1921                         r = flush_fd(notify);
1922                         if (r < 0)
1923                                 goto fail;
1924                 }
1925
1926                 /* We pass here O_NOCTTY only so that we can check the return
1927                  * value TIOCSCTTY and have a reliable way to figure out if we
1928                  * successfully became the controlling process of the tty */
1929                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
1930                 if (fd < 0)
1931                         return fd;
1932
1933                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
1934                  * if we already own the tty. */
1935                 zero(sa_new);
1936                 sa_new.sa_handler = SIG_IGN;
1937                 sa_new.sa_flags = SA_RESTART;
1938                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
1939
1940                 /* First, try to get the tty */
1941                 if (ioctl(fd, TIOCSCTTY, force) < 0)
1942                         r = -errno;
1943
1944                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
1945
1946                 /* Sometimes it makes sense to ignore TIOCSCTTY
1947                  * returning EPERM, i.e. when very likely we already
1948                  * are have this controlling terminal. */
1949                 if (r < 0 && r == -EPERM && ignore_tiocstty_eperm)
1950                         r = 0;
1951
1952                 if (r < 0 && (force || fail || r != -EPERM)) {
1953                         goto fail;
1954                 }
1955
1956                 if (r >= 0)
1957                         break;
1958
1959                 assert(!fail);
1960                 assert(!force);
1961                 assert(notify >= 0);
1962
1963                 for (;;) {
1964                         uint8_t inotify_buffer[sizeof(struct inotify_event) + FILENAME_MAX];
1965                         ssize_t l;
1966                         struct inotify_event *e;
1967
1968                         if (timeout != (usec_t) -1) {
1969                                 usec_t n;
1970
1971                                 n = now(CLOCK_MONOTONIC);
1972                                 if (ts + timeout < n) {
1973                                         r = -ETIMEDOUT;
1974                                         goto fail;
1975                                 }
1976
1977                                 r = fd_wait_for_event(fd, POLLIN, ts + timeout - n);
1978                                 if (r < 0)
1979                                         goto fail;
1980
1981                                 if (r == 0) {
1982                                         r = -ETIMEDOUT;
1983                                         goto fail;
1984                                 }
1985                         }
1986
1987                         l = read(notify, inotify_buffer, sizeof(inotify_buffer));
1988                         if (l < 0) {
1989
1990                                 if (errno == EINTR || errno == EAGAIN)
1991                                         continue;
1992
1993                                 r = -errno;
1994                                 goto fail;
1995                         }
1996
1997                         e = (struct inotify_event*) inotify_buffer;
1998
1999                         while (l > 0) {
2000                                 size_t step;
2001
2002                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) {
2003                                         r = -EIO;
2004                                         goto fail;
2005                                 }
2006
2007                                 step = sizeof(struct inotify_event) + e->len;
2008                                 assert(step <= (size_t) l);
2009
2010                                 e = (struct inotify_event*) ((uint8_t*) e + step);
2011                                 l -= step;
2012                         }
2013
2014                         break;
2015                 }
2016
2017                 /* We close the tty fd here since if the old session
2018                  * ended our handle will be dead. It's important that
2019                  * we do this after sleeping, so that we don't enter
2020                  * an endless loop. */
2021                 close_nointr_nofail(fd);
2022         }
2023
2024         if (notify >= 0)
2025                 close_nointr_nofail(notify);
2026
2027         r = reset_terminal_fd(fd, true);
2028         if (r < 0)
2029                 log_warning("Failed to reset terminal: %s", strerror(-r));
2030
2031         return fd;
2032
2033 fail:
2034         if (fd >= 0)
2035                 close_nointr_nofail(fd);
2036
2037         if (notify >= 0)
2038                 close_nointr_nofail(notify);
2039
2040         return r;
2041 }
2042
2043 int release_terminal(void) {
2044         int r = 0, fd;
2045         struct sigaction sa_old, sa_new;
2046
2047         if ((fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_NDELAY|O_CLOEXEC)) < 0)
2048                 return -errno;
2049
2050         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
2051          * by our own TIOCNOTTY */
2052
2053         zero(sa_new);
2054         sa_new.sa_handler = SIG_IGN;
2055         sa_new.sa_flags = SA_RESTART;
2056         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
2057
2058         if (ioctl(fd, TIOCNOTTY) < 0)
2059                 r = -errno;
2060
2061         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
2062
2063         close_nointr_nofail(fd);
2064         return r;
2065 }
2066
2067 int sigaction_many(const struct sigaction *sa, ...) {
2068         va_list ap;
2069         int r = 0, sig;
2070
2071         va_start(ap, sa);
2072         while ((sig = va_arg(ap, int)) > 0)
2073                 if (sigaction(sig, sa, NULL) < 0)
2074                         r = -errno;
2075         va_end(ap);
2076
2077         return r;
2078 }
2079
2080 int ignore_signals(int sig, ...) {
2081         struct sigaction sa;
2082         va_list ap;
2083         int r = 0;
2084
2085         zero(sa);
2086         sa.sa_handler = SIG_IGN;
2087         sa.sa_flags = SA_RESTART;
2088
2089         if (sigaction(sig, &sa, NULL) < 0)
2090                 r = -errno;
2091
2092         va_start(ap, sig);
2093         while ((sig = va_arg(ap, int)) > 0)
2094                 if (sigaction(sig, &sa, NULL) < 0)
2095                         r = -errno;
2096         va_end(ap);
2097
2098         return r;
2099 }
2100
2101 int default_signals(int sig, ...) {
2102         struct sigaction sa;
2103         va_list ap;
2104         int r = 0;
2105
2106         zero(sa);
2107         sa.sa_handler = SIG_DFL;
2108         sa.sa_flags = SA_RESTART;
2109
2110         if (sigaction(sig, &sa, NULL) < 0)
2111                 r = -errno;
2112
2113         va_start(ap, sig);
2114         while ((sig = va_arg(ap, int)) > 0)
2115                 if (sigaction(sig, &sa, NULL) < 0)
2116                         r = -errno;
2117         va_end(ap);
2118
2119         return r;
2120 }
2121
2122 int close_pipe(int p[]) {
2123         int a = 0, b = 0;
2124
2125         assert(p);
2126
2127         if (p[0] >= 0) {
2128                 a = close_nointr(p[0]);
2129                 p[0] = -1;
2130         }
2131
2132         if (p[1] >= 0) {
2133                 b = close_nointr(p[1]);
2134                 p[1] = -1;
2135         }
2136
2137         return a < 0 ? a : b;
2138 }
2139
2140 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
2141         uint8_t *p;
2142         ssize_t n = 0;
2143
2144         assert(fd >= 0);
2145         assert(buf);
2146
2147         p = buf;
2148
2149         while (nbytes > 0) {
2150                 ssize_t k;
2151
2152                 if ((k = read(fd, p, nbytes)) <= 0) {
2153
2154                         if (k < 0 && errno == EINTR)
2155                                 continue;
2156
2157                         if (k < 0 && errno == EAGAIN && do_poll) {
2158                                 struct pollfd pollfd;
2159
2160                                 zero(pollfd);
2161                                 pollfd.fd = fd;
2162                                 pollfd.events = POLLIN;
2163
2164                                 if (poll(&pollfd, 1, -1) < 0) {
2165                                         if (errno == EINTR)
2166                                                 continue;
2167
2168                                         return n > 0 ? n : -errno;
2169                                 }
2170
2171                                 if (pollfd.revents != POLLIN)
2172                                         return n > 0 ? n : -EIO;
2173
2174                                 continue;
2175                         }
2176
2177                         return n > 0 ? n : (k < 0 ? -errno : 0);
2178                 }
2179
2180                 p += k;
2181                 nbytes -= k;
2182                 n += k;
2183         }
2184
2185         return n;
2186 }
2187
2188 ssize_t loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
2189         const uint8_t *p;
2190         ssize_t n = 0;
2191
2192         assert(fd >= 0);
2193         assert(buf);
2194
2195         p = buf;
2196
2197         while (nbytes > 0) {
2198                 ssize_t k;
2199
2200                 k = write(fd, p, nbytes);
2201                 if (k <= 0) {
2202
2203                         if (k < 0 && errno == EINTR)
2204                                 continue;
2205
2206                         if (k < 0 && errno == EAGAIN && do_poll) {
2207                                 struct pollfd pollfd;
2208
2209                                 zero(pollfd);
2210                                 pollfd.fd = fd;
2211                                 pollfd.events = POLLOUT;
2212
2213                                 if (poll(&pollfd, 1, -1) < 0) {
2214                                         if (errno == EINTR)
2215                                                 continue;
2216
2217                                         return n > 0 ? n : -errno;
2218                                 }
2219
2220                                 if (pollfd.revents != POLLOUT)
2221                                         return n > 0 ? n : -EIO;
2222
2223                                 continue;
2224                         }
2225
2226                         return n > 0 ? n : (k < 0 ? -errno : 0);
2227                 }
2228
2229                 p += k;
2230                 nbytes -= k;
2231                 n += k;
2232         }
2233
2234         return n;
2235 }
2236
2237 int parse_bytes(const char *t, off_t *bytes) {
2238         static const struct {
2239                 const char *suffix;
2240                 off_t factor;
2241         } table[] = {
2242                 { "B", 1 },
2243                 { "K", 1024ULL },
2244                 { "M", 1024ULL*1024ULL },
2245                 { "G", 1024ULL*1024ULL*1024ULL },
2246                 { "T", 1024ULL*1024ULL*1024ULL*1024ULL },
2247                 { "P", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2248                 { "E", 1024ULL*1024ULL*1024ULL*1024ULL*1024ULL*1024ULL },
2249                 { "", 1 },
2250         };
2251
2252         const char *p;
2253         off_t r = 0;
2254
2255         assert(t);
2256         assert(bytes);
2257
2258         p = t;
2259         do {
2260                 long long l;
2261                 char *e;
2262                 unsigned i;
2263
2264                 errno = 0;
2265                 l = strtoll(p, &e, 10);
2266
2267                 if (errno != 0)
2268                         return -errno;
2269
2270                 if (l < 0)
2271                         return -ERANGE;
2272
2273                 if (e == p)
2274                         return -EINVAL;
2275
2276                 e += strspn(e, WHITESPACE);
2277
2278                 for (i = 0; i < ELEMENTSOF(table); i++)
2279                         if (startswith(e, table[i].suffix)) {
2280                                 r += (off_t) l * table[i].factor;
2281                                 p = e + strlen(table[i].suffix);
2282                                 break;
2283                         }
2284
2285                 if (i >= ELEMENTSOF(table))
2286                         return -EINVAL;
2287
2288         } while (*p != 0);
2289
2290         *bytes = r;
2291
2292         return 0;
2293 }
2294
2295 int make_stdio(int fd) {
2296         int r, s, t;
2297
2298         assert(fd >= 0);
2299
2300         r = dup3(fd, STDIN_FILENO, 0);
2301         s = dup3(fd, STDOUT_FILENO, 0);
2302         t = dup3(fd, STDERR_FILENO, 0);
2303
2304         if (fd >= 3)
2305                 close_nointr_nofail(fd);
2306
2307         if (r < 0 || s < 0 || t < 0)
2308                 return -errno;
2309
2310         /* We rely here that the new fd has O_CLOEXEC not set */
2311
2312         return 0;
2313 }
2314
2315 int make_null_stdio(void) {
2316         int null_fd;
2317
2318         null_fd = open("/dev/null", O_RDWR|O_NOCTTY);
2319         if (null_fd < 0)
2320                 return -errno;
2321
2322         return make_stdio(null_fd);
2323 }
2324
2325 bool is_device_path(const char *path) {
2326
2327         /* Returns true on paths that refer to a device, either in
2328          * sysfs or in /dev */
2329
2330         return
2331                 path_startswith(path, "/dev/") ||
2332                 path_startswith(path, "/sys/");
2333 }
2334
2335 int dir_is_empty(const char *path) {
2336         _cleanup_closedir_ DIR *d;
2337         int r;
2338
2339         d = opendir(path);
2340         if (!d)
2341                 return -errno;
2342
2343         for (;;) {
2344                 struct dirent *de;
2345                 union dirent_storage buf;
2346
2347                 r = readdir_r(d, &buf.de, &de);
2348                 if (r > 0)
2349                         return -r;
2350
2351                 if (!de)
2352                         return 1;
2353
2354                 if (!ignore_file(de->d_name))
2355                         return 0;
2356         }
2357 }
2358
2359 unsigned long long random_ull(void) {
2360         _cleanup_close_ int fd;
2361         uint64_t ull;
2362         ssize_t r;
2363
2364         fd = open("/dev/urandom", O_RDONLY|O_CLOEXEC|O_NOCTTY);
2365         if (fd < 0)
2366                 goto fallback;
2367
2368         r = loop_read(fd, &ull, sizeof(ull), true);
2369         if (r != sizeof(ull))
2370                 goto fallback;
2371
2372         return ull;
2373
2374 fallback:
2375         return random() * RAND_MAX + random();
2376 }
2377
2378 void rename_process(const char name[8]) {
2379         assert(name);
2380
2381         /* This is a like a poor man's setproctitle(). It changes the
2382          * comm field, argv[0], and also the glibc's internally used
2383          * name of the process. For the first one a limit of 16 chars
2384          * applies, to the second one usually one of 10 (i.e. length
2385          * of "/sbin/init"), to the third one one of 7 (i.e. length of
2386          * "systemd"). If you pass a longer string it will be
2387          * truncated */
2388
2389         prctl(PR_SET_NAME, name);
2390
2391         if (program_invocation_name)
2392                 strncpy(program_invocation_name, name, strlen(program_invocation_name));
2393
2394         if (saved_argc > 0) {
2395                 int i;
2396
2397                 if (saved_argv[0])
2398                         strncpy(saved_argv[0], name, strlen(saved_argv[0]));
2399
2400                 for (i = 1; i < saved_argc; i++) {
2401                         if (!saved_argv[i])
2402                                 break;
2403
2404                         memset(saved_argv[i], 0, strlen(saved_argv[i]));
2405                 }
2406         }
2407 }
2408
2409 void sigset_add_many(sigset_t *ss, ...) {
2410         va_list ap;
2411         int sig;
2412
2413         assert(ss);
2414
2415         va_start(ap, ss);
2416         while ((sig = va_arg(ap, int)) > 0)
2417                 assert_se(sigaddset(ss, sig) == 0);
2418         va_end(ap);
2419 }
2420
2421 char* gethostname_malloc(void) {
2422         struct utsname u;
2423
2424         assert_se(uname(&u) >= 0);
2425
2426         if (!isempty(u.nodename) && !streq(u.nodename, "(none)"))
2427                 return strdup(u.nodename);
2428
2429         return strdup(u.sysname);
2430 }
2431
2432 bool hostname_is_set(void) {
2433         struct utsname u;
2434
2435         assert_se(uname(&u) >= 0);
2436
2437         return !isempty(u.nodename) && !streq(u.nodename, "(none)");
2438 }
2439
2440 static char *lookup_uid(uid_t uid) {
2441         long bufsize;
2442         char *name;
2443         _cleanup_free_ char *buf = NULL;
2444         struct passwd pwbuf, *pw = NULL;
2445
2446         /* Shortcut things to avoid NSS lookups */
2447         if (uid == 0)
2448                 return strdup("root");
2449
2450         bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
2451         if (bufsize <= 0)
2452                 bufsize = 4096;
2453
2454         buf = malloc(bufsize);
2455         if (!buf)
2456                 return NULL;
2457
2458         if (getpwuid_r(uid, &pwbuf, buf, bufsize, &pw) == 0 && pw)
2459                 return strdup(pw->pw_name);
2460
2461         if (asprintf(&name, "%lu", (unsigned long) uid) < 0)
2462                 return NULL;
2463
2464         return name;
2465 }
2466
2467 char* getlogname_malloc(void) {
2468         uid_t uid;
2469         struct stat st;
2470
2471         if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
2472                 uid = st.st_uid;
2473         else
2474                 uid = getuid();
2475
2476         return lookup_uid(uid);
2477 }
2478
2479 char *getusername_malloc(void) {
2480         const char *e;
2481
2482         e = getenv("USER");
2483         if (e)
2484                 return strdup(e);
2485
2486         return lookup_uid(getuid());
2487 }
2488
2489 int getttyname_malloc(int fd, char **r) {
2490         char path[PATH_MAX], *c;
2491         int k;
2492
2493         assert(r);
2494
2495         k = ttyname_r(fd, path, sizeof(path));
2496         if (k != 0)
2497                 return -k;
2498
2499         char_array_0(path);
2500
2501         c = strdup(startswith(path, "/dev/") ? path + 5 : path);
2502         if (!c)
2503                 return -ENOMEM;
2504
2505         *r = c;
2506         return 0;
2507 }
2508
2509 int getttyname_harder(int fd, char **r) {
2510         int k;
2511         char *s;
2512
2513         k = getttyname_malloc(fd, &s);
2514         if (k < 0)
2515                 return k;
2516
2517         if (streq(s, "tty")) {
2518                 free(s);
2519                 return get_ctty(0, NULL, r);
2520         }
2521
2522         *r = s;
2523         return 0;
2524 }
2525
2526 int get_ctty_devnr(pid_t pid, dev_t *d) {
2527         int k;
2528         char line[LINE_MAX], *p, *fn;
2529         unsigned long ttynr;
2530         FILE *f;
2531
2532         if (asprintf(&fn, "/proc/%lu/stat", (unsigned long) (pid <= 0 ? getpid() : pid)) < 0)
2533                 return -ENOMEM;
2534
2535         f = fopen(fn, "re");
2536         free(fn);
2537         if (!f)
2538                 return -errno;
2539
2540         if (!fgets(line, sizeof(line), f)) {
2541                 k = feof(f) ? -EIO : -errno;
2542                 fclose(f);
2543                 return k;
2544         }
2545
2546         fclose(f);
2547
2548         p = strrchr(line, ')');
2549         if (!p)
2550                 return -EIO;
2551
2552         p++;
2553
2554         if (sscanf(p, " "
2555                    "%*c "  /* state */
2556                    "%*d "  /* ppid */
2557                    "%*d "  /* pgrp */
2558                    "%*d "  /* session */
2559                    "%lu ", /* ttynr */
2560                    &ttynr) != 1)
2561                 return -EIO;
2562
2563         if (major(ttynr) == 0 && minor(ttynr) == 0)
2564                 return -ENOENT;
2565
2566         *d = (dev_t) ttynr;
2567         return 0;
2568 }
2569
2570 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
2571         int k;
2572         char fn[PATH_MAX], *s, *b, *p;
2573         dev_t devnr;
2574
2575         assert(r);
2576
2577         k = get_ctty_devnr(pid, &devnr);
2578         if (k < 0)
2579                 return k;
2580
2581         snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
2582         char_array_0(fn);
2583
2584         k = readlink_malloc(fn, &s);
2585         if (k < 0) {
2586
2587                 if (k != -ENOENT)
2588                         return k;
2589
2590                 /* This is an ugly hack */
2591                 if (major(devnr) == 136) {
2592                         if (asprintf(&b, "pts/%lu", (unsigned long) minor(devnr)) < 0)
2593                                 return -ENOMEM;
2594
2595                         *r = b;
2596                         if (_devnr)
2597                                 *_devnr = devnr;
2598
2599                         return 0;
2600                 }
2601
2602                 /* Probably something like the ptys which have no
2603                  * symlink in /dev/char. Let's return something
2604                  * vaguely useful. */
2605
2606                 b = strdup(fn + 5);
2607                 if (!b)
2608                         return -ENOMEM;
2609
2610                 *r = b;
2611                 if (_devnr)
2612                         *_devnr = devnr;
2613
2614                 return 0;
2615         }
2616
2617         if (startswith(s, "/dev/"))
2618                 p = s + 5;
2619         else if (startswith(s, "../"))
2620                 p = s + 3;
2621         else
2622                 p = s;
2623
2624         b = strdup(p);
2625         free(s);
2626
2627         if (!b)
2628                 return -ENOMEM;
2629
2630         *r = b;
2631         if (_devnr)
2632                 *_devnr = devnr;
2633
2634         return 0;
2635 }
2636
2637 int rm_rf_children_dangerous(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2638         DIR *d;
2639         int ret = 0;
2640
2641         assert(fd >= 0);
2642
2643         /* This returns the first error we run into, but nevertheless
2644          * tries to go on. This closes the passed fd. */
2645
2646         d = fdopendir(fd);
2647         if (!d) {
2648                 close_nointr_nofail(fd);
2649
2650                 return errno == ENOENT ? 0 : -errno;
2651         }
2652
2653         for (;;) {
2654                 struct dirent *de;
2655                 union dirent_storage buf;
2656                 bool is_dir, keep_around;
2657                 struct stat st;
2658                 int r;
2659
2660                 r = readdir_r(d, &buf.de, &de);
2661                 if (r != 0 && ret == 0) {
2662                         ret = -r;
2663                         break;
2664                 }
2665
2666                 if (!de)
2667                         break;
2668
2669                 if (streq(de->d_name, ".") || streq(de->d_name, ".."))
2670                         continue;
2671
2672                 if (de->d_type == DT_UNKNOWN ||
2673                     honour_sticky ||
2674                     (de->d_type == DT_DIR && root_dev)) {
2675                         if (fstatat(fd, de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
2676                                 if (ret == 0 && errno != ENOENT)
2677                                         ret = -errno;
2678                                 continue;
2679                         }
2680
2681                         is_dir = S_ISDIR(st.st_mode);
2682                         keep_around =
2683                                 honour_sticky &&
2684                                 (st.st_uid == 0 || st.st_uid == getuid()) &&
2685                                 (st.st_mode & S_ISVTX);
2686                 } else {
2687                         is_dir = de->d_type == DT_DIR;
2688                         keep_around = false;
2689                 }
2690
2691                 if (is_dir) {
2692                         int subdir_fd;
2693
2694                         /* if root_dev is set, remove subdirectories only, if device is same as dir */
2695                         if (root_dev && st.st_dev != root_dev->st_dev)
2696                                 continue;
2697
2698                         subdir_fd = openat(fd, de->d_name,
2699                                            O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2700                         if (subdir_fd < 0) {
2701                                 if (ret == 0 && errno != ENOENT)
2702                                         ret = -errno;
2703                                 continue;
2704                         }
2705
2706                         r = rm_rf_children_dangerous(subdir_fd, only_dirs, honour_sticky, root_dev);
2707                         if (r < 0 && ret == 0)
2708                                 ret = r;
2709
2710                         if (!keep_around)
2711                                 if (unlinkat(fd, de->d_name, AT_REMOVEDIR) < 0) {
2712                                         if (ret == 0 && errno != ENOENT)
2713                                                 ret = -errno;
2714                                 }
2715
2716                 } else if (!only_dirs && !keep_around) {
2717
2718                         if (unlinkat(fd, de->d_name, 0) < 0) {
2719                                 if (ret == 0 && errno != ENOENT)
2720                                         ret = -errno;
2721                         }
2722                 }
2723         }
2724
2725         closedir(d);
2726
2727         return ret;
2728 }
2729
2730 static int is_temporary_fs(struct statfs *s) {
2731         assert(s);
2732         return s->f_type == TMPFS_MAGIC ||
2733                 (long)s->f_type == (long)RAMFS_MAGIC;
2734 }
2735
2736 int rm_rf_children(int fd, bool only_dirs, bool honour_sticky, struct stat *root_dev) {
2737         struct statfs s;
2738
2739         assert(fd >= 0);
2740
2741         if (fstatfs(fd, &s) < 0) {
2742                 close_nointr_nofail(fd);
2743                 return -errno;
2744         }
2745
2746         /* We refuse to clean disk file systems with this call. This
2747          * is extra paranoia just to be sure we never ever remove
2748          * non-state data */
2749         if (!is_temporary_fs(&s)) {
2750                 log_error("Attempted to remove disk file system, and we can't allow that.");
2751                 close_nointr_nofail(fd);
2752                 return -EPERM;
2753         }
2754
2755         return rm_rf_children_dangerous(fd, only_dirs, honour_sticky, root_dev);
2756 }
2757
2758 static int rm_rf_internal(const char *path, bool only_dirs, bool delete_root, bool honour_sticky, bool dangerous) {
2759         int fd, r;
2760         struct statfs s;
2761
2762         assert(path);
2763
2764         /* We refuse to clean the root file system with this
2765          * call. This is extra paranoia to never cause a really
2766          * seriously broken system. */
2767         if (path_equal(path, "/")) {
2768                 log_error("Attempted to remove entire root file system, and we can't allow that.");
2769                 return -EPERM;
2770         }
2771
2772         fd = open(path, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|O_NOFOLLOW|O_NOATIME);
2773         if (fd < 0) {
2774
2775                 if (errno != ENOTDIR)
2776                         return -errno;
2777
2778                 if (!dangerous) {
2779                         if (statfs(path, &s) < 0)
2780                                 return -errno;
2781
2782                         if (!is_temporary_fs(&s)) {
2783                                 log_error("Attempted to remove disk file system, and we can't allow that.");
2784                                 return -EPERM;
2785                         }
2786                 }
2787
2788                 if (delete_root && !only_dirs)
2789                         if (unlink(path) < 0 && errno != ENOENT)
2790                                 return -errno;
2791
2792                 return 0;
2793         }
2794
2795         if (!dangerous) {
2796                 if (fstatfs(fd, &s) < 0) {
2797                         close_nointr_nofail(fd);
2798                         return -errno;
2799                 }
2800
2801                 if (!is_temporary_fs(&s)) {
2802                         log_error("Attempted to remove disk file system, and we can't allow that.");
2803                         close_nointr_nofail(fd);
2804                         return -EPERM;
2805                 }
2806         }
2807
2808         r = rm_rf_children_dangerous(fd, only_dirs, honour_sticky, NULL);
2809         if (delete_root) {
2810
2811                 if (honour_sticky && file_is_priv_sticky(path) > 0)
2812                         return r;
2813
2814                 if (rmdir(path) < 0 && errno != ENOENT) {
2815                         if (r == 0)
2816                                 r = -errno;
2817                 }
2818         }
2819
2820         return r;
2821 }
2822
2823 int rm_rf(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2824         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, false);
2825 }
2826
2827 int rm_rf_dangerous(const char *path, bool only_dirs, bool delete_root, bool honour_sticky) {
2828         return rm_rf_internal(path, only_dirs, delete_root, honour_sticky, true);
2829 }
2830
2831 int chmod_and_chown(const char *path, mode_t mode, uid_t uid, gid_t gid) {
2832         assert(path);
2833
2834         /* Under the assumption that we are running privileged we
2835          * first change the access mode and only then hand out
2836          * ownership to avoid a window where access is too open. */
2837
2838         if (mode != (mode_t) -1)
2839                 if (chmod(path, mode) < 0)
2840                         return -errno;
2841
2842         if (uid != (uid_t) -1 || gid != (gid_t) -1)
2843                 if (chown(path, uid, gid) < 0)
2844                         return -errno;
2845
2846         return 0;
2847 }
2848
2849 int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) {
2850         assert(fd >= 0);
2851
2852         /* Under the assumption that we are running privileged we
2853          * first change the access mode and only then hand out
2854          * ownership to avoid a window where access is too open. */
2855
2856         if (fchmod(fd, mode) < 0)
2857                 return -errno;
2858
2859         if (fchown(fd, uid, gid) < 0)
2860                 return -errno;
2861
2862         return 0;
2863 }
2864
2865 cpu_set_t* cpu_set_malloc(unsigned *ncpus) {
2866         cpu_set_t *r;
2867         unsigned n = 1024;
2868
2869         /* Allocates the cpuset in the right size */
2870
2871         for (;;) {
2872                 if (!(r = CPU_ALLOC(n)))
2873                         return NULL;
2874
2875                 if (sched_getaffinity(0, CPU_ALLOC_SIZE(n), r) >= 0) {
2876                         CPU_ZERO_S(CPU_ALLOC_SIZE(n), r);
2877
2878                         if (ncpus)
2879                                 *ncpus = n;
2880
2881                         return r;
2882                 }
2883
2884                 CPU_FREE(r);
2885
2886                 if (errno != EINVAL)
2887                         return NULL;
2888
2889                 n *= 2;
2890         }
2891 }
2892
2893 int status_vprintf(const char *status, bool ellipse, bool ephemeral, const char *format, va_list ap) {
2894         static const char status_indent[] = "         "; /* "[" STATUS "] " */
2895         _cleanup_free_ char *s = NULL;
2896         _cleanup_close_ int fd = -1;
2897         struct iovec iovec[6];
2898         int n = 0;
2899         static bool prev_ephemeral;
2900
2901         assert(format);
2902
2903         /* This is independent of logging, as status messages are
2904          * optional and go exclusively to the console. */
2905
2906         if (vasprintf(&s, format, ap) < 0)
2907                 return log_oom();
2908
2909         fd = open_terminal("/dev/console", O_WRONLY|O_NOCTTY|O_CLOEXEC);
2910         if (fd < 0)
2911                 return fd;
2912
2913         if (ellipse) {
2914                 char *e;
2915                 size_t emax, sl;
2916                 int c;
2917
2918                 c = fd_columns(fd);
2919                 if (c <= 0)
2920                         c = 80;
2921
2922                 sl = status ? sizeof(status_indent)-1 : 0;
2923
2924                 emax = c - sl - 1;
2925                 if (emax < 3)
2926                         emax = 3;
2927
2928                 e = ellipsize(s, emax, 75);
2929                 if (e) {
2930                         free(s);
2931                         s = e;
2932                 }
2933         }
2934
2935         zero(iovec);
2936
2937         if (prev_ephemeral)
2938                 IOVEC_SET_STRING(iovec[n++], "\r" ANSI_ERASE_TO_END_OF_LINE);
2939         prev_ephemeral = ephemeral;
2940
2941         if (status) {
2942                 if (!isempty(status)) {
2943                         IOVEC_SET_STRING(iovec[n++], "[");
2944                         IOVEC_SET_STRING(iovec[n++], status);
2945                         IOVEC_SET_STRING(iovec[n++], "] ");
2946                 } else
2947                         IOVEC_SET_STRING(iovec[n++], status_indent);
2948         }
2949
2950         IOVEC_SET_STRING(iovec[n++], s);
2951         if (!ephemeral)
2952                 IOVEC_SET_STRING(iovec[n++], "\n");
2953
2954         if (writev(fd, iovec, n) < 0)
2955                 return -errno;
2956
2957         return 0;
2958 }
2959
2960 int status_printf(const char *status, bool ellipse, bool ephemeral, const char *format, ...) {
2961         va_list ap;
2962         int r;
2963
2964         assert(format);
2965
2966         va_start(ap, format);
2967         r = status_vprintf(status, ellipse, ephemeral, format, ap);
2968         va_end(ap);
2969
2970         return r;
2971 }
2972
2973 int status_welcome(void) {
2974         int r;
2975         _cleanup_free_ char *pretty_name = NULL, *ansi_color = NULL;
2976
2977         r = parse_env_file("/etc/os-release", NEWLINE,
2978                            "PRETTY_NAME", &pretty_name,
2979                            "ANSI_COLOR", &ansi_color,
2980                            NULL);
2981         if (r < 0 && r != -ENOENT)
2982                 log_warning("Failed to read /etc/os-release: %s", strerror(-r));
2983
2984         return status_printf(NULL, false, false,
2985                              "\nWelcome to \x1B[%sm%s\x1B[0m!\n",
2986                              isempty(ansi_color) ? "1" : ansi_color,
2987                              isempty(pretty_name) ? "Linux" : pretty_name);
2988 }
2989
2990 char *replace_env(const char *format, char **env) {
2991         enum {
2992                 WORD,
2993                 CURLY,
2994                 VARIABLE
2995         } state = WORD;
2996
2997         const char *e, *word = format;
2998         char *r = NULL, *k;
2999
3000         assert(format);
3001
3002         for (e = format; *e; e ++) {
3003
3004                 switch (state) {
3005
3006                 case WORD:
3007                         if (*e == '$')
3008                                 state = CURLY;
3009                         break;
3010
3011                 case CURLY:
3012                         if (*e == '{') {
3013                                 if (!(k = strnappend(r, word, e-word-1)))
3014                                         goto fail;
3015
3016                                 free(r);
3017                                 r = k;
3018
3019                                 word = e-1;
3020                                 state = VARIABLE;
3021
3022                         } else if (*e == '$') {
3023                                 if (!(k = strnappend(r, word, e-word)))
3024                                         goto fail;
3025
3026                                 free(r);
3027                                 r = k;
3028
3029                                 word = e+1;
3030                                 state = WORD;
3031                         } else
3032                                 state = WORD;
3033                         break;
3034
3035                 case VARIABLE:
3036                         if (*e == '}') {
3037                                 const char *t;
3038
3039                                 t = strempty(strv_env_get_n(env, word+2, e-word-2));
3040
3041                                 k = strappend(r, t);
3042                                 if (!k)
3043                                         goto fail;
3044
3045                                 free(r);
3046                                 r = k;
3047
3048                                 word = e+1;
3049                                 state = WORD;
3050                         }
3051                         break;
3052                 }
3053         }
3054
3055         if (!(k = strnappend(r, word, e-word)))
3056                 goto fail;
3057
3058         free(r);
3059         return k;
3060
3061 fail:
3062         free(r);
3063         return NULL;
3064 }
3065
3066 char **replace_env_argv(char **argv, char **env) {
3067         char **r, **i;
3068         unsigned k = 0, l = 0;
3069
3070         l = strv_length(argv);
3071
3072         if (!(r = new(char*, l+1)))
3073                 return NULL;
3074
3075         STRV_FOREACH(i, argv) {
3076
3077                 /* If $FOO appears as single word, replace it by the split up variable */
3078                 if ((*i)[0] == '$' && (*i)[1] != '{') {
3079                         char *e;
3080                         char **w, **m;
3081                         unsigned q;
3082
3083                         e = strv_env_get(env, *i+1);
3084                         if (e) {
3085
3086                                 if (!(m = strv_split_quoted(e))) {
3087                                         r[k] = NULL;
3088                                         strv_free(r);
3089                                         return NULL;
3090                                 }
3091                         } else
3092                                 m = NULL;
3093
3094                         q = strv_length(m);
3095                         l = l + q - 1;
3096
3097                         if (!(w = realloc(r, sizeof(char*) * (l+1)))) {
3098                                 r[k] = NULL;
3099                                 strv_free(r);
3100                                 strv_free(m);
3101                                 return NULL;
3102                         }
3103
3104                         r = w;
3105                         if (m) {
3106                                 memcpy(r + k, m, q * sizeof(char*));
3107                                 free(m);
3108                         }
3109
3110                         k += q;
3111                         continue;
3112                 }
3113
3114                 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
3115                 if (!(r[k++] = replace_env(*i, env))) {
3116                         strv_free(r);
3117                         return NULL;
3118                 }
3119         }
3120
3121         r[k] = NULL;
3122         return r;
3123 }
3124
3125 int fd_columns(int fd) {
3126         struct winsize ws;
3127         zero(ws);
3128
3129         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3130                 return -errno;
3131
3132         if (ws.ws_col <= 0)
3133                 return -EIO;
3134
3135         return ws.ws_col;
3136 }
3137
3138 unsigned columns(void) {
3139         const char *e;
3140         int c;
3141
3142         if (_likely_(cached_columns > 0))
3143                 return cached_columns;
3144
3145         c = 0;
3146         e = getenv("COLUMNS");
3147         if (e)
3148                 safe_atoi(e, &c);
3149
3150         if (c <= 0)
3151                 c = fd_columns(STDOUT_FILENO);
3152
3153         if (c <= 0)
3154                 c = 80;
3155
3156         cached_columns = c;
3157         return c;
3158 }
3159
3160 int fd_lines(int fd) {
3161         struct winsize ws;
3162         zero(ws);
3163
3164         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
3165                 return -errno;
3166
3167         if (ws.ws_row <= 0)
3168                 return -EIO;
3169
3170         return ws.ws_row;
3171 }
3172
3173 unsigned lines(void) {
3174         const char *e;
3175         unsigned l;
3176
3177         if (_likely_(cached_lines > 0))
3178                 return cached_lines;
3179
3180         l = 0;
3181         e = getenv("LINES");
3182         if (e)
3183                 safe_atou(e, &l);
3184
3185         if (l <= 0)
3186                 l = fd_lines(STDOUT_FILENO);
3187
3188         if (l <= 0)
3189                 l = 24;
3190
3191         cached_lines = l;
3192         return cached_lines;
3193 }
3194
3195 /* intended to be used as a SIGWINCH sighandler */
3196 void columns_lines_cache_reset(int signum) {
3197         cached_columns = 0;
3198         cached_lines = 0;
3199 }
3200
3201 bool on_tty(void) {
3202         static int cached_on_tty = -1;
3203
3204         if (_unlikely_(cached_on_tty < 0))
3205                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
3206
3207         return cached_on_tty;
3208 }
3209
3210 int running_in_chroot(void) {
3211         struct stat a, b;
3212
3213         zero(a);
3214         zero(b);
3215
3216         /* Only works as root */
3217
3218         if (stat("/proc/1/root", &a) < 0)
3219                 return -errno;
3220
3221         if (stat("/", &b) < 0)
3222                 return -errno;
3223
3224         return
3225                 a.st_dev != b.st_dev ||
3226                 a.st_ino != b.st_ino;
3227 }
3228
3229 char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, unsigned percent) {
3230         size_t x;
3231         char *r;
3232
3233         assert(s);
3234         assert(percent <= 100);
3235         assert(new_length >= 3);
3236
3237         if (old_length <= 3 || old_length <= new_length)
3238                 return strndup(s, old_length);
3239
3240         r = new0(char, new_length+1);
3241         if (!r)
3242                 return r;
3243
3244         x = (new_length * percent) / 100;
3245
3246         if (x > new_length - 3)
3247                 x = new_length - 3;
3248
3249         memcpy(r, s, x);
3250         r[x] = '.';
3251         r[x+1] = '.';
3252         r[x+2] = '.';
3253         memcpy(r + x + 3,
3254                s + old_length - (new_length - x - 3),
3255                new_length - x - 3);
3256
3257         return r;
3258 }
3259
3260 char *ellipsize(const char *s, size_t length, unsigned percent) {
3261         return ellipsize_mem(s, strlen(s), length, percent);
3262 }
3263
3264 int touch(const char *path) {
3265         int fd;
3266
3267         assert(path);
3268
3269         /* This just opens the file for writing, ensuring it
3270          * exists. It doesn't call utimensat() the way /usr/bin/touch
3271          * does it. */
3272
3273         fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
3274         if (fd < 0)
3275                 return -errno;
3276
3277         close_nointr_nofail(fd);
3278         return 0;
3279 }
3280
3281 char *unquote(const char *s, const char* quotes) {
3282         size_t l;
3283         assert(s);
3284
3285         /* This is rather stupid, simply removes the heading and
3286          * trailing quotes if there is one. Doesn't care about
3287          * escaping or anything. We should make this smarter one
3288          * day...*/
3289
3290         l = strlen(s);
3291         if (l < 2)
3292                 return strdup(s);
3293
3294         if (strchr(quotes, s[0]) && s[l-1] == s[0])
3295                 return strndup(s+1, l-2);
3296
3297         return strdup(s);
3298 }
3299
3300 char *normalize_env_assignment(const char *s) {
3301         _cleanup_free_ char *name = NULL, *value = NULL, *p = NULL;
3302         char *eq, *r;
3303
3304         eq = strchr(s, '=');
3305         if (!eq) {
3306                 char *t;
3307
3308                 r = strdup(s);
3309                 if (!r)
3310                         return NULL;
3311
3312                 t = strstrip(r);
3313                 if (t == r)
3314                         return r;
3315
3316                 memmove(r, t, strlen(t) + 1);
3317                 return r;
3318         }
3319
3320         name = strndup(s, eq - s);
3321         if (!name)
3322                 return NULL;
3323
3324         p = strdup(eq + 1);
3325         if (!p)
3326                 return NULL;
3327
3328         value = unquote(strstrip(p), QUOTES);
3329         if (!value)
3330                 return NULL;
3331
3332         if (asprintf(&r, "%s=%s", strstrip(name), value) < 0)
3333                 r = NULL;
3334
3335         return r;
3336 }
3337
3338 int wait_for_terminate(pid_t pid, siginfo_t *status) {
3339         siginfo_t dummy;
3340
3341         assert(pid >= 1);
3342
3343         if (!status)
3344                 status = &dummy;
3345
3346         for (;;) {
3347                 zero(*status);
3348
3349                 if (waitid(P_PID, pid, status, WEXITED) < 0) {
3350
3351                         if (errno == EINTR)
3352                                 continue;
3353
3354                         return -errno;
3355                 }
3356
3357                 return 0;
3358         }
3359 }
3360
3361 int wait_for_terminate_and_warn(const char *name, pid_t pid) {
3362         int r;
3363         siginfo_t status;
3364
3365         assert(name);
3366         assert(pid > 1);
3367
3368         r = wait_for_terminate(pid, &status);
3369         if (r < 0) {
3370                 log_warning("Failed to wait for %s: %s", name, strerror(-r));
3371                 return r;
3372         }
3373
3374         if (status.si_code == CLD_EXITED) {
3375                 if (status.si_status != 0) {
3376                         log_warning("%s failed with error code %i.", name, status.si_status);
3377                         return status.si_status;
3378                 }
3379
3380                 log_debug("%s succeeded.", name);
3381                 return 0;
3382
3383         } else if (status.si_code == CLD_KILLED ||
3384                    status.si_code == CLD_DUMPED) {
3385
3386                 log_warning("%s terminated by signal %s.", name, signal_to_string(status.si_status));
3387                 return -EPROTO;
3388         }
3389
3390         log_warning("%s failed due to unknown reason.", name);
3391         return -EPROTO;
3392 }
3393
3394 _noreturn_ void freeze(void) {
3395
3396         /* Make sure nobody waits for us on a socket anymore */
3397         close_all_fds(NULL, 0);
3398
3399         sync();
3400
3401         for (;;)
3402                 pause();
3403 }
3404
3405 bool null_or_empty(struct stat *st) {
3406         assert(st);
3407
3408         if (S_ISREG(st->st_mode) && st->st_size <= 0)
3409                 return true;
3410
3411         if (S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode))
3412                 return true;
3413
3414         return false;
3415 }
3416
3417 int null_or_empty_path(const char *fn) {
3418         struct stat st;
3419
3420         assert(fn);
3421
3422         if (stat(fn, &st) < 0)
3423                 return -errno;
3424
3425         return null_or_empty(&st);
3426 }
3427
3428 DIR *xopendirat(int fd, const char *name, int flags) {
3429         int nfd;
3430         DIR *d;
3431
3432         nfd = openat(fd, name, O_RDONLY|O_NONBLOCK|O_DIRECTORY|O_CLOEXEC|flags);
3433         if (nfd < 0)
3434                 return NULL;
3435
3436         d = fdopendir(nfd);
3437         if (!d) {
3438                 close_nointr_nofail(nfd);
3439                 return NULL;
3440         }
3441
3442         return d;
3443 }
3444
3445 int signal_from_string_try_harder(const char *s) {
3446         int signo;
3447         assert(s);
3448
3449         signo = signal_from_string(s);
3450         if (signo <= 0)
3451                 if (startswith(s, "SIG"))
3452                         return signal_from_string(s+3);
3453
3454         return signo;
3455 }
3456
3457 static char *tag_to_udev_node(const char *tagvalue, const char *by) {
3458         char *dn, *t, *u;
3459         int r;
3460
3461         /* FIXME: to follow udev's logic 100% we need to leave valid
3462          * UTF8 chars unescaped */
3463
3464         u = unquote(tagvalue, "\"\'");
3465         if (u == NULL)
3466                 return NULL;
3467
3468         t = xescape(u, "/ ");
3469         free(u);
3470
3471         if (t == NULL)
3472                 return NULL;
3473
3474         r = asprintf(&dn, "/dev/disk/by-%s/%s", by, t);
3475         free(t);
3476
3477         if (r < 0)
3478                 return NULL;
3479
3480         return dn;
3481 }
3482
3483 char *fstab_node_to_udev_node(const char *p) {
3484         assert(p);
3485
3486         if (startswith(p, "LABEL="))
3487                 return tag_to_udev_node(p+6, "label");
3488
3489         if (startswith(p, "UUID="))
3490                 return tag_to_udev_node(p+5, "uuid");
3491
3492         if (startswith(p, "PARTUUID="))
3493                 return tag_to_udev_node(p+9, "partuuid");
3494
3495         if (startswith(p, "PARTLABEL="))
3496                 return tag_to_udev_node(p+10, "partlabel");
3497
3498         return strdup(p);
3499 }
3500
3501 bool tty_is_vc(const char *tty) {
3502         assert(tty);
3503
3504         if (startswith(tty, "/dev/"))
3505                 tty += 5;
3506
3507         return vtnr_from_tty(tty) >= 0;
3508 }
3509
3510 bool tty_is_console(const char *tty) {
3511         assert(tty);
3512
3513         if (startswith(tty, "/dev/"))
3514                 tty += 5;
3515
3516         return streq(tty, "console");
3517 }
3518
3519 int vtnr_from_tty(const char *tty) {
3520         int i, r;
3521
3522         assert(tty);
3523
3524         if (startswith(tty, "/dev/"))
3525                 tty += 5;
3526
3527         if (!startswith(tty, "tty") )
3528                 return -EINVAL;
3529
3530         if (tty[3] < '0' || tty[3] > '9')
3531                 return -EINVAL;
3532
3533         r = safe_atoi(tty+3, &i);
3534         if (r < 0)
3535                 return r;
3536
3537         if (i < 0 || i > 63)
3538                 return -EINVAL;
3539
3540         return i;
3541 }
3542
3543 char *resolve_dev_console(char **active) {
3544         char *tty;
3545
3546         /* Resolve where /dev/console is pointing to, if /sys is actually ours
3547          * (i.e. not read-only-mounted which is a sign for container setups) */
3548
3549         if (path_is_read_only_fs("/sys") > 0)
3550                 return NULL;
3551
3552         if (read_one_line_file("/sys/class/tty/console/active", active) < 0)
3553                 return NULL;
3554
3555         /* If multiple log outputs are configured the last one is what
3556          * /dev/console points to */
3557         tty = strrchr(*active, ' ');
3558         if (tty)
3559                 tty++;
3560         else
3561                 tty = *active;
3562
3563         return tty;
3564 }
3565
3566 bool tty_is_vc_resolve(const char *tty) {
3567         char *active = NULL;
3568         bool b;
3569
3570         assert(tty);
3571
3572         if (startswith(tty, "/dev/"))
3573                 tty += 5;
3574
3575         if (streq(tty, "console")) {
3576                 tty = resolve_dev_console(&active);
3577                 if (!tty)
3578                         return false;
3579         }
3580
3581         b = tty_is_vc(tty);
3582         free(active);
3583
3584         return b;
3585 }
3586
3587 const char *default_term_for_tty(const char *tty) {
3588         assert(tty);
3589
3590         return tty_is_vc_resolve(tty) ? "TERM=linux" : "TERM=vt102";
3591 }
3592
3593 bool dirent_is_file(const struct dirent *de) {
3594         assert(de);
3595
3596         if (ignore_file(de->d_name))
3597                 return false;
3598
3599         if (de->d_type != DT_REG &&
3600             de->d_type != DT_LNK &&
3601             de->d_type != DT_UNKNOWN)
3602                 return false;
3603
3604         return true;
3605 }
3606
3607 bool dirent_is_file_with_suffix(const struct dirent *de, const char *suffix) {
3608         assert(de);
3609
3610         if (de->d_type != DT_REG &&
3611             de->d_type != DT_LNK &&
3612             de->d_type != DT_UNKNOWN)
3613                 return false;
3614
3615         if (ignore_file_allow_backup(de->d_name))
3616                 return false;
3617
3618         return endswith(de->d_name, suffix);
3619 }
3620
3621 void execute_directory(const char *directory, DIR *d, char *argv[]) {
3622         DIR *_d = NULL;
3623         struct dirent *de;
3624         Hashmap *pids = NULL;
3625
3626         assert(directory);
3627
3628         /* Executes all binaries in a directory in parallel and
3629          * waits for them to finish. */
3630
3631         if (!d) {
3632                 if (!(_d = opendir(directory))) {
3633
3634                         if (errno == ENOENT)
3635                                 return;
3636
3637                         log_error("Failed to enumerate directory %s: %m", directory);
3638                         return;
3639                 }
3640
3641                 d = _d;
3642         }
3643
3644         if (!(pids = hashmap_new(trivial_hash_func, trivial_compare_func))) {
3645                 log_error("Failed to allocate set.");
3646                 goto finish;
3647         }
3648
3649         while ((de = readdir(d))) {
3650                 char *path;
3651                 pid_t pid;
3652                 int k;
3653
3654                 if (!dirent_is_file(de))
3655                         continue;
3656
3657                 if (asprintf(&path, "%s/%s", directory, de->d_name) < 0) {
3658                         log_oom();
3659                         continue;
3660                 }
3661
3662                 if ((pid = fork()) < 0) {
3663                         log_error("Failed to fork: %m");
3664                         free(path);
3665                         continue;
3666                 }
3667
3668                 if (pid == 0) {
3669                         char *_argv[2];
3670                         /* Child */
3671
3672                         if (!argv) {
3673                                 _argv[0] = path;
3674                                 _argv[1] = NULL;
3675                                 argv = _argv;
3676                         } else
3677                                 argv[0] = path;
3678
3679                         execv(path, argv);
3680
3681                         log_error("Failed to execute %s: %m", path);
3682                         _exit(EXIT_FAILURE);
3683                 }
3684
3685                 log_debug("Spawned %s as %lu", path, (unsigned long) pid);
3686
3687                 if ((k = hashmap_put(pids, UINT_TO_PTR(pid), path)) < 0) {
3688                         log_error("Failed to add PID to set: %s", strerror(-k));
3689                         free(path);
3690                 }
3691         }
3692
3693         while (!hashmap_isempty(pids)) {
3694                 pid_t pid = PTR_TO_UINT(hashmap_first_key(pids));
3695                 siginfo_t si;
3696                 char *path;
3697
3698                 zero(si);
3699                 if (waitid(P_PID, pid, &si, WEXITED) < 0) {
3700
3701                         if (errno == EINTR)
3702                                 continue;
3703
3704                         log_error("waitid() failed: %m");
3705                         goto finish;
3706                 }
3707
3708                 if ((path = hashmap_remove(pids, UINT_TO_PTR(si.si_pid)))) {
3709                         if (!is_clean_exit(si.si_code, si.si_status, NULL)) {
3710                                 if (si.si_code == CLD_EXITED)
3711                                         log_error("%s exited with exit status %i.", path, si.si_status);
3712                                 else
3713                                         log_error("%s terminated by signal %s.", path, signal_to_string(si.si_status));
3714                         } else
3715                                 log_debug("%s exited successfully.", path);
3716
3717                         free(path);
3718                 }
3719         }
3720
3721 finish:
3722         if (_d)
3723                 closedir(_d);
3724
3725         if (pids)
3726                 hashmap_free_free(pids);
3727 }
3728
3729 int kill_and_sigcont(pid_t pid, int sig) {
3730         int r;
3731
3732         r = kill(pid, sig) < 0 ? -errno : 0;
3733
3734         if (r >= 0)
3735                 kill(pid, SIGCONT);
3736
3737         return r;
3738 }
3739
3740 bool nulstr_contains(const char*nulstr, const char *needle) {
3741         const char *i;
3742
3743         if (!nulstr)
3744                 return false;
3745
3746         NULSTR_FOREACH(i, nulstr)
3747                 if (streq(i, needle))
3748                         return true;
3749
3750         return false;
3751 }
3752
3753 bool plymouth_running(void) {
3754         return access("/run/plymouth/pid", F_OK) >= 0;
3755 }
3756
3757 char* strshorten(char *s, size_t l) {
3758         assert(s);
3759
3760         if (l < strlen(s))
3761                 s[l] = 0;
3762
3763         return s;
3764 }
3765
3766 static bool hostname_valid_char(char c) {
3767         return
3768                 (c >= 'a' && c <= 'z') ||
3769                 (c >= 'A' && c <= 'Z') ||
3770                 (c >= '0' && c <= '9') ||
3771                 c == '-' ||
3772                 c == '_' ||
3773                 c == '.';
3774 }
3775
3776 bool hostname_is_valid(const char *s) {
3777         const char *p;
3778         bool dot;
3779
3780         if (isempty(s))
3781                 return false;
3782
3783         for (p = s, dot = true; *p; p++) {
3784                 if (*p == '.') {
3785                         if (dot)
3786                                 return false;
3787
3788                         dot = true;
3789                 } else {
3790                         if (!hostname_valid_char(*p))
3791                                 return false;
3792
3793                         dot = false;
3794                 }
3795         }
3796
3797         if (dot)
3798                 return false;
3799
3800         if (p-s > HOST_NAME_MAX)
3801                 return false;
3802
3803         return true;
3804 }
3805
3806 char* hostname_cleanup(char *s) {
3807         char *p, *d;
3808
3809         for (p = s, d = s; *p; p++)
3810                 if ((*p >= 'a' && *p <= 'z') ||
3811                     (*p >= 'A' && *p <= 'Z') ||
3812                     (*p >= '0' && *p <= '9') ||
3813                     *p == '-' ||
3814                     *p == '_' ||
3815                     *p == '.')
3816                         *(d++) = *p;
3817
3818         *d = 0;
3819
3820         strshorten(s, HOST_NAME_MAX);
3821         return s;
3822 }
3823
3824 int pipe_eof(int fd) {
3825         struct pollfd pollfd;
3826         int r;
3827
3828         zero(pollfd);
3829         pollfd.fd = fd;
3830         pollfd.events = POLLIN|POLLHUP;
3831
3832         r = poll(&pollfd, 1, 0);
3833         if (r < 0)
3834                 return -errno;
3835
3836         if (r == 0)
3837                 return 0;
3838
3839         return pollfd.revents & POLLHUP;
3840 }
3841
3842 int fd_wait_for_event(int fd, int event, usec_t t) {
3843         struct pollfd pollfd;
3844         int r;
3845
3846         zero(pollfd);
3847         pollfd.fd = fd;
3848         pollfd.events = event;
3849
3850         r = poll(&pollfd, 1, t == (usec_t) -1 ? -1 : (int) (t / USEC_PER_MSEC));
3851         if (r < 0)
3852                 return -errno;
3853
3854         if (r == 0)
3855                 return 0;
3856
3857         return pollfd.revents;
3858 }
3859
3860 int fopen_temporary(const char *path, FILE **_f, char **_temp_path) {
3861         FILE *f;
3862         char *t;
3863         const char *fn;
3864         size_t k;
3865         int fd;
3866
3867         assert(path);
3868         assert(_f);
3869         assert(_temp_path);
3870
3871         t = new(char, strlen(path) + 1 + 6 + 1);
3872         if (!t)
3873                 return -ENOMEM;
3874
3875         fn = path_get_file_name(path);
3876         k = fn-path;
3877         memcpy(t, path, k);
3878         t[k] = '.';
3879         stpcpy(stpcpy(t+k+1, fn), "XXXXXX");
3880
3881         fd = mkostemp(t, O_WRONLY|O_CLOEXEC);
3882         if (fd < 0) {
3883                 free(t);
3884                 return -errno;
3885         }
3886
3887         f = fdopen(fd, "we");
3888         if (!f) {
3889                 unlink(t);
3890                 free(t);
3891                 return -errno;
3892         }
3893
3894         *_f = f;
3895         *_temp_path = t;
3896
3897         return 0;
3898 }
3899
3900 int terminal_vhangup_fd(int fd) {
3901         assert(fd >= 0);
3902
3903         if (ioctl(fd, TIOCVHANGUP) < 0)
3904                 return -errno;
3905
3906         return 0;
3907 }
3908
3909 int terminal_vhangup(const char *name) {
3910         int fd, r;
3911
3912         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3913         if (fd < 0)
3914                 return fd;
3915
3916         r = terminal_vhangup_fd(fd);
3917         close_nointr_nofail(fd);
3918
3919         return r;
3920 }
3921
3922 int vt_disallocate(const char *name) {
3923         int fd, r;
3924         unsigned u;
3925
3926         /* Deallocate the VT if possible. If not possible
3927          * (i.e. because it is the active one), at least clear it
3928          * entirely (including the scrollback buffer) */
3929
3930         if (!startswith(name, "/dev/"))
3931                 return -EINVAL;
3932
3933         if (!tty_is_vc(name)) {
3934                 /* So this is not a VT. I guess we cannot deallocate
3935                  * it then. But let's at least clear the screen */
3936
3937                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3938                 if (fd < 0)
3939                         return fd;
3940
3941                 loop_write(fd,
3942                            "\033[r"    /* clear scrolling region */
3943                            "\033[H"    /* move home */
3944                            "\033[2J",  /* clear screen */
3945                            10, false);
3946                 close_nointr_nofail(fd);
3947
3948                 return 0;
3949         }
3950
3951         if (!startswith(name, "/dev/tty"))
3952                 return -EINVAL;
3953
3954         r = safe_atou(name+8, &u);
3955         if (r < 0)
3956                 return r;
3957
3958         if (u <= 0)
3959                 return -EINVAL;
3960
3961         /* Try to deallocate */
3962         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
3963         if (fd < 0)
3964                 return fd;
3965
3966         r = ioctl(fd, VT_DISALLOCATE, u);
3967         close_nointr_nofail(fd);
3968
3969         if (r >= 0)
3970                 return 0;
3971
3972         if (errno != EBUSY)
3973                 return -errno;
3974
3975         /* Couldn't deallocate, so let's clear it fully with
3976          * scrollback */
3977         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
3978         if (fd < 0)
3979                 return fd;
3980
3981         loop_write(fd,
3982                    "\033[r"   /* clear scrolling region */
3983                    "\033[H"   /* move home */
3984                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
3985                    10, false);
3986         close_nointr_nofail(fd);
3987
3988         return 0;
3989 }
3990
3991 int copy_file(const char *from, const char *to) {
3992         int r, fdf, fdt;
3993
3994         asser