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