if (!fgets(line, sizeof(line), f)) {
r = feof(f) ? -EIO : -errno;
- fclose(f);
return r;
}
}
int write_one_line_file_atomic(const char *fn, const char *line) {
- FILE *f;
+ _cleanup_fclose_ FILE *f = NULL;
+ _cleanup_free_ char *p = NULL;
int r;
- char *p;
assert(fn);
assert(line);
fflush(f);
- if (ferror(f)) {
- if (errno != 0)
- r = -errno;
- else
- r = -EIO;
- } else {
+ if (ferror(f))
+ r = errno ? -errno : -EIO;
+ else {
if (rename(p, fn) < 0)
r = -errno;
else
if (r < 0)
unlink(p);
- fclose(f);
- free(p);
-
return r;
}
_cleanup_free_ char *buf = NULL;
struct stat st;
+ assert(fn);
+ assert(contents);
+
f = fopen(fn, "re");
if (!f)
return -errno;
return r;
}
-int load_env_file(
- const char *fname,
- char ***rl) {
+int load_env_file(const char *fname,
+ char ***rl) {
- FILE *f;
- char **m = NULL;
- int r;
+ FILE _cleanup_fclose_ *f;
+ char *b;
+ char _cleanup_free_ *c = NULL;
+ char _cleanup_strv_free_ **m = NULL;
assert(fname);
assert(rl);
- if (!(f = fopen(fname, "re")))
+ f = fopen(fname, "re");
+ if (!f)
return -errno;
while (!feof(f)) {
- char l[LINE_MAX], *p, *u;
+ char l[LINE_MAX], *p, *u, *cs;
char **t;
if (!fgets(l, sizeof(l), f)) {
- if (feof(f))
+ if (!feof(f))
+ return -errno;
+ else if (!c)
break;
+ }
- r = -errno;
- goto finish;
+ cs = endswith(l, "\\\n");
+ if (cs) {
+ *cs = '\0';
+ b = strappend(c, l);
+ if (!b)
+ return log_oom();
+
+ free(c);
+ c = b;
+ *l = '\0';
+ continue;
}
- p = strstrip(l);
+ if (c) {
+ b = strappend(c, l);
+ if (!b)
+ return log_oom();
+
+ free(c);
+ c = b;
+ }
+
+ p = strstrip(c ? c : l);
if (!*p)
continue;
if (strchr(COMMENTS, *p))
continue;
- if (!(u = normalize_env_assignment(p))) {
- r = log_oom();
- goto finish;
- }
+ u = normalize_env_assignment(p);
+ if (!u)
+ return log_oom();
+
+ free(c);
+ c = NULL;
t = strv_append(m, u);
free(u);
- if (!t) {
- r = log_oom();
- goto finish;
- }
+ if (!t)
+ return log_oom();
strv_free(m);
m = t;
}
- r = 0;
-
*rl = m;
m = NULL;
-finish:
- if (f)
- fclose(f);
-
- strv_free(m);
-
- return r;
+ return 0;
}
int write_env_file(const char *fname, char **l) {
}
int get_process_cmdline(pid_t pid, size_t max_length, bool comm_fallback, char **line) {
- char *r, *k;
+ char *r = NULL, *k;
int c;
- bool space = false;
- size_t left;
FILE *f;
- assert(max_length > 0);
assert(line);
if (pid == 0)
if (!f)
return -errno;
+ if (max_length == 0) {
+ size_t len = 1;
+ while ((c = getc(f)) != EOF) {
+ k = realloc(r, len+1);
+ if (k == NULL) {
+ free(r);
+ fclose(f);
+ return -ENOMEM;
+ }
+ r = k;
+ r[len-1] = isprint(c) ? c : ' ';
+ r[len] = 0;
+ len++;
+ }
+ } else {
+ bool space = false;
+ size_t left;
+ r = new(char, max_length);
+ if (!r) {
+ fclose(f);
+ return -ENOMEM;
+ }
- r = new(char, max_length);
- if (!r) {
- fclose(f);
- return -ENOMEM;
- }
+ k = r;
+ left = max_length;
+ while ((c = getc(f)) != EOF) {
- k = r;
- left = max_length;
- while ((c = getc(f)) != EOF) {
+ if (isprint(c)) {
+ if (space) {
+ if (left <= 4)
+ break;
+
+ *(k++) = ' ';
+ left--;
+ space = false;
+ }
- if (isprint(c)) {
- if (space) {
if (left <= 4)
break;
- *(k++) = ' ';
+ *(k++) = (char) c;
left--;
- space = false;
- }
-
- if (left <= 4)
- break;
+ } else
+ space = true;
+ }
- *(k++) = (char) c;
- left--;
- } else
- space = true;
+ if (left <= 4) {
+ size_t n = MIN(left-1, 3U);
+ memcpy(k, "...", n);
+ k[n] = 0;
+ } else
+ *k = 0;
}
- if (left <= 4) {
- size_t n = MIN(left-1, 3U);
- memcpy(k, "...", n);
- k[n] = 0;
- } else
- *k = 0;
-
fclose(f);
/* Kernel threads have no argv[] */
- if (r[0] == 0) {
+ if (r == NULL || r[0] == 0) {
char *t;
int h;
&ttynr) != 1)
return -EIO;
+ if (major(ttynr) == 0 && minor(ttynr) == 0)
+ return -ENOENT;
+
*d = (dev_t) ttynr;
return 0;
}
snprintf(fn, sizeof(fn), "/dev/char/%u:%u", major(devnr), minor(devnr));
char_array_0(fn);
- if ((k = readlink_malloc(fn, &s)) < 0) {
+ k = readlink_malloc(fn, &s);
+ if (k < 0) {
if (k != -ENOENT)
return k;
* symlink in /dev/char. Let's return something
* vaguely useful. */
- if (!(b = strdup(fn + 5)))
+ b = strdup(fn + 5);
+ if (!b)
return -ENOMEM;
*r = b;
return 0;
}
+char* uid_to_name(uid_t uid) {
+ struct passwd *p;
+ char *r;
+
+ if (uid == 0)
+ return strdup("root");
+
+ p = getpwuid(uid);
+ if (p)
+ return strdup(p->pw_name);
+
+ if (asprintf(&r, "%lu", (unsigned long) uid) < 0)
+ return NULL;
+
+ return r;
+}
+
int get_group_creds(const char **groupname, gid_t *gid) {
struct group *g;
gid_t id;
assert(type);
+ /* If /sys is read-only we cannot sleep */
+ if (access("/sys/power/state", W_OK) < 0)
+ return false;
+
r = read_one_line_file("/sys/power/state", &p);
if (r < 0)
- return r == -ENOENT ? 0 : r;
+ return false;
k = strlen(type);
FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
assert(type);
+ /* If /sys is read-only we cannot sleep */
+ if (access("/sys/power/state", W_OK) < 0 ||
+ access("/sys/power/disk", W_OK) < 0)
+ return false;
+
r = read_one_line_file("/sys/power/disk", &p);
if (r < 0)
- return r == -ENOENT ? 0 : r;
+ return false;
k = strlen(type);
FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
return true;
}
+bool path_is_safe(const char *p) {
+
+ if (isempty(p))
+ return false;
+
+ if (streq(p, "..") || startswith(p, "../") || endswith(p, "/..") || strstr(p, "/../"))
+ return false;
+
+ if (strlen(p) > PATH_MAX)
+ return false;
+
+ /* The following two checks are not really dangerous, but hey, they still are confusing */
+ if (streq(p, ".") || startswith(p, "./") || endswith(p, "/.") || strstr(p, "/./"))
+ return false;
+
+ if (strstr(p, "//"))
+ return false;
+
+ return true;
+}
+
/* hey glibc, APIs with callbacks without a user pointer are so useless */
void *xbsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
int (*compar) (const void *, const void *, void *), void *arg) {
[DRAW_TREE_VERT] = "\342\224\202 ", /* │ */
[DRAW_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
[DRAW_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
+ [DRAW_TREE_SPACE] = " ", /* */
[DRAW_TRIANGULAR_BULLET] = "\342\200\243 ", /* ‣ */
},
/* ASCII fallback */ {
[DRAW_TREE_VERT] = "| ",
[DRAW_TREE_BRANCH] = "|-",
[DRAW_TREE_RIGHT] = "`-",
+ [DRAW_TREE_SPACE] = " ",
[DRAW_TRIANGULAR_BULLET] = "> ",
}
};
free(r);
return NULL;
}
+
+char *strip_tab_ansi(char **ibuf, size_t *_isz) {
+ const char *i, *begin = NULL;
+ enum {
+ STATE_OTHER,
+ STATE_ESCAPE,
+ STATE_BRACKET
+ } state = STATE_OTHER;
+ char *obuf = NULL;
+ size_t osz = 0, isz;
+ FILE *f;
+
+ assert(ibuf);
+ assert(*ibuf);
+
+ /* Strips ANSI color and replaces TABs by 8 spaces */
+
+ isz = _isz ? *_isz : strlen(*ibuf);
+
+ f = open_memstream(&obuf, &osz);
+ if (!f)
+ return NULL;
+
+ for (i = *ibuf; i < *ibuf + isz + 1; i++) {
+
+ switch (state) {
+
+ case STATE_OTHER:
+ if (i >= *ibuf + isz) /* EOT */
+ break;
+ else if (*i == '\x1B')
+ state = STATE_ESCAPE;
+ else if (*i == '\t')
+ fputs(" ", f);
+ else
+ fputc(*i, f);
+ break;
+
+ case STATE_ESCAPE:
+ if (i >= *ibuf + isz) { /* EOT */
+ fputc('\x1B', f);
+ break;
+ } else if (*i == '[') {
+ state = STATE_BRACKET;
+ begin = i + 1;
+ } else {
+ fputc('\x1B', f);
+ fputc(*i, f);
+ state = STATE_OTHER;
+ }
+
+ break;
+
+ case STATE_BRACKET:
+
+ if (i >= *ibuf + isz || /* EOT */
+ (!(*i >= '0' && *i <= '9') && *i != ';' && *i != 'm')) {
+ fputc('\x1B', f);
+ fputc('[', f);
+ state = STATE_OTHER;
+ i = begin-1;
+ } else if (*i == 'm')
+ state = STATE_OTHER;
+ break;
+ }
+ }
+
+ if (ferror(f)) {
+ fclose(f);
+ free(obuf);
+ return NULL;
+ }
+
+ fclose(f);
+
+ free(*ibuf);
+ *ibuf = obuf;
+
+ if (_isz)
+ *_isz = osz;
+
+ return obuf;
+}
+
+int on_ac_power(void) {
+ bool found_offline = false, found_online = false;
+ _cleanup_closedir_ DIR *d = NULL;
+
+ d = opendir("/sys/class/power_supply");
+ if (!d)
+ return -errno;
+
+ for (;;) {
+ struct dirent *de;
+ union dirent_storage buf;
+ _cleanup_free_ char *p = NULL;
+ _cleanup_close_ int fd = -1, device = -1;
+ char contents[6];
+ ssize_t n;
+ int k;
+
+ k = readdir_r(d, &buf.de, &de);
+ if (k != 0)
+ return -k;
+
+ if (!de)
+ break;
+
+ if (ignore_file(de->d_name))
+ continue;
+
+ device = openat(dirfd(d), de->d_name, O_DIRECTORY|O_RDONLY|O_CLOEXEC|O_NOCTTY);
+ if (device < 0) {
+ if (errno == ENOENT || errno == ENOTDIR)
+ continue;
+
+ return -errno;
+ }
+
+ fd = openat(device, "type", O_RDONLY|O_CLOEXEC|O_NOCTTY);
+ if (fd < 0) {
+ if (errno == ENOENT)
+ continue;
+
+ return -errno;
+ }
+
+ n = read(fd, contents, sizeof(contents));
+ if (n < 0)
+ return -errno;
+
+ if (n != 6 || memcmp(contents, "Mains\n", 6))
+ continue;
+
+ close_nointr_nofail(fd);
+ fd = openat(device, "online", O_RDONLY|O_CLOEXEC|O_NOCTTY);
+ if (fd < 0) {
+ if (errno == ENOENT)
+ continue;
+
+ return -errno;
+ }
+
+ n = read(fd, contents, sizeof(contents));
+ if (n < 0)
+ return -errno;
+
+ if (n != 2 || contents[1] != '\n')
+ return -EIO;
+
+ if (contents[0] == '1') {
+ found_online = true;
+ break;
+ } else if (contents[0] == '0')
+ found_offline = true;
+ else
+ return -EIO;
+ }
+
+ return found_online || !found_offline;
+}