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