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