a2a5291b3f
String which ended in an unfinished quote were accepted, potentially with bad memory accesses. Reject anything which ends in a unfished quote, or contains non-whitespace characters right after the closing quote. _FOREACH_WORD now returns the invalid character in *state. But this return value is not checked anywhere yet. Also, make 'word' and 'state' variables const pointers, and rename 'w' to 'word' in various places. Things are easier to read if the same name is used consistently. mbiebl_> am I correct that something like this doesn't work mbiebl_> ExecStart=/usr/bin/encfs --extpass='/bin/systemd-ask-passwd "Unlock EncFS"' mbiebl_> systemd seems to strip of the quotes mbiebl_> systemctl status shows mbiebl_> ExecStart=/usr/bin/encfs --extpass='/bin/systemd-ask-password Unlock EncFS $RootDir $MountPoint mbiebl_> which is pretty weird
265 lines
8.4 KiB
C
265 lines
8.4 KiB
C
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2013 Zbigniew Jędrzejewski-Szmek
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "conf-parser.h"
|
|
#include "sleep-config.h"
|
|
#include "fileio.h"
|
|
#include "log.h"
|
|
#include "strv.h"
|
|
#include "util.h"
|
|
|
|
#define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
|
|
|
|
int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
|
|
|
|
_cleanup_strv_free_ char
|
|
**suspend_mode = NULL, **suspend_state = NULL,
|
|
**hibernate_mode = NULL, **hibernate_state = NULL,
|
|
**hybrid_mode = NULL, **hybrid_state = NULL;
|
|
char **modes, **states;
|
|
|
|
const ConfigTableItem items[] = {
|
|
{ "Sleep", "SuspendMode", config_parse_strv, 0, &suspend_mode },
|
|
{ "Sleep", "SuspendState", config_parse_strv, 0, &suspend_state },
|
|
{ "Sleep", "HibernateMode", config_parse_strv, 0, &hibernate_mode },
|
|
{ "Sleep", "HibernateState", config_parse_strv, 0, &hibernate_state },
|
|
{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &hybrid_mode },
|
|
{ "Sleep", "HybridSleepState", config_parse_strv, 0, &hybrid_state },
|
|
{}
|
|
};
|
|
|
|
config_parse(NULL, PKGSYSCONFDIR "/sleep.conf", NULL,
|
|
"Sleep\0",
|
|
config_item_table_lookup, items, false, false, true, NULL);
|
|
|
|
if (streq(verb, "suspend")) {
|
|
/* empty by default */
|
|
USE(modes, suspend_mode);
|
|
|
|
if (suspend_state)
|
|
USE(states, suspend_state);
|
|
else
|
|
states = strv_new("mem", "standby", "freeze", NULL);
|
|
|
|
} else if (streq(verb, "hibernate")) {
|
|
if (hibernate_mode)
|
|
USE(modes, hibernate_mode);
|
|
else
|
|
modes = strv_new("platform", "shutdown", NULL);
|
|
|
|
if (hibernate_state)
|
|
USE(states, hibernate_state);
|
|
else
|
|
states = strv_new("disk", NULL);
|
|
|
|
} else if (streq(verb, "hybrid-sleep")) {
|
|
if (hybrid_mode)
|
|
USE(modes, hybrid_mode);
|
|
else
|
|
modes = strv_new("suspend", "platform", "shutdown", NULL);
|
|
|
|
if (hybrid_state)
|
|
USE(states, hybrid_state);
|
|
else
|
|
states = strv_new("disk", NULL);
|
|
|
|
} else
|
|
assert_not_reached("what verb");
|
|
|
|
if ((!modes && !streq(verb, "suspend")) || !states) {
|
|
strv_free(modes);
|
|
strv_free(states);
|
|
return log_oom();
|
|
}
|
|
|
|
*_modes = modes;
|
|
*_states = states;
|
|
return 0;
|
|
}
|
|
|
|
int can_sleep_state(char **types) {
|
|
char **type;
|
|
int r;
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
if (strv_isempty(types))
|
|
return true;
|
|
|
|
/* 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 false;
|
|
|
|
STRV_FOREACH(type, types) {
|
|
const char *word, *state;
|
|
size_t l, k;
|
|
|
|
k = strlen(*type);
|
|
FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state)
|
|
if (l == k && memcmp(word, *type, l) == 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int can_sleep_disk(char **types) {
|
|
char **type;
|
|
int r;
|
|
_cleanup_free_ char *p = NULL;
|
|
|
|
if (strv_isempty(types))
|
|
return true;
|
|
|
|
/* If /sys is read-only we cannot sleep */
|
|
if (access("/sys/power/disk", W_OK) < 0)
|
|
return false;
|
|
|
|
r = read_one_line_file("/sys/power/disk", &p);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
STRV_FOREACH(type, types) {
|
|
const char *word, *state;
|
|
size_t l, k;
|
|
|
|
k = strlen(*type);
|
|
FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state) {
|
|
if (l == k && memcmp(word, *type, l) == 0)
|
|
return true;
|
|
|
|
if (l == k + 2 &&
|
|
word[0] == '[' &&
|
|
memcmp(word + 1, *type, l - 2) == 0 &&
|
|
word[l-1] == ']')
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#define HIBERNATION_SWAP_THRESHOLD 0.98
|
|
|
|
static int hibernation_partition_size(size_t *size, size_t *used) {
|
|
_cleanup_fclose_ FILE *f;
|
|
int i;
|
|
|
|
assert(size);
|
|
assert(used);
|
|
|
|
f = fopen("/proc/swaps", "re");
|
|
if (!f) {
|
|
log_full(errno == ENOENT ? LOG_DEBUG : LOG_WARNING,
|
|
"Failed to retrieve open /proc/swaps: %m");
|
|
assert(errno > 0);
|
|
return -errno;
|
|
}
|
|
|
|
(void) fscanf(f, "%*s %*s %*s %*s %*s\n");
|
|
|
|
for (i = 1;; i++) {
|
|
_cleanup_free_ char *dev = NULL, *type = NULL;
|
|
size_t size_field, used_field;
|
|
int k;
|
|
|
|
k = fscanf(f,
|
|
"%ms " /* device/file */
|
|
"%ms " /* type of swap */
|
|
"%zd " /* swap size */
|
|
"%zd " /* used */
|
|
"%*i\n", /* priority */
|
|
&dev, &type, &size_field, &used_field);
|
|
if (k != 4) {
|
|
if (k == EOF)
|
|
break;
|
|
|
|
log_warning("Failed to parse /proc/swaps:%u", i);
|
|
continue;
|
|
}
|
|
|
|
if (streq(type, "partition") && endswith(dev, "\\040(deleted)")) {
|
|
log_warning("Ignoring deleted swapfile '%s'.", dev);
|
|
continue;
|
|
}
|
|
|
|
*size = size_field;
|
|
*used = used_field;
|
|
return 0;
|
|
}
|
|
|
|
log_debug("No swap partitions were found.");
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static bool enough_memory_for_hibernation(void) {
|
|
_cleanup_free_ char *active = NULL;
|
|
unsigned long long act = 0;
|
|
size_t size = 0, used = 0;
|
|
int r;
|
|
|
|
r = hibernation_partition_size(&size, &used);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
r = get_status_field("/proc/meminfo", "\nActive(anon):", &active);
|
|
if (r < 0) {
|
|
log_error("Failed to retrieve Active(anon) from /proc/meminfo: %s", strerror(-r));
|
|
return false;
|
|
}
|
|
|
|
r = safe_atollu(active, &act);
|
|
if (r < 0) {
|
|
log_error("Failed to parse Active(anon) from /proc/meminfo: %s: %s",
|
|
active, strerror(-r));
|
|
return false;
|
|
}
|
|
|
|
r = act <= (size - used) * HIBERNATION_SWAP_THRESHOLD;
|
|
log_debug("Hibernation is %spossible, Active(anon)=%llu kB, size=%zu kB, used=%zu kB, threshold=%.2g%%",
|
|
r ? "" : "im", act, size, used, 100*HIBERNATION_SWAP_THRESHOLD);
|
|
|
|
return r;
|
|
}
|
|
|
|
int can_sleep(const char *verb) {
|
|
_cleanup_strv_free_ char **modes = NULL, **states = NULL;
|
|
int r;
|
|
|
|
assert(streq(verb, "suspend") ||
|
|
streq(verb, "hibernate") ||
|
|
streq(verb, "hybrid-sleep"));
|
|
|
|
r = parse_sleep_config(verb, &modes, &states);
|
|
if (r < 0)
|
|
return false;
|
|
|
|
if (!can_sleep_state(states) || !can_sleep_disk(modes))
|
|
return false;
|
|
|
|
return streq(verb, "suspend") || enough_memory_for_hibernation();
|
|
}
|