// * read customization data provided by customization package
void Timed::init_customization()
{
iodata::storage *storage = new iodata::storage ;
storage->set_primary_path(customization_path()) ;
storage->set_validator(customization_data_validator(), "customization_t") ;
iodata::record *c = storage->load() ;
log_assert(c, "loading customization settings failed") ;
if(storage->source()==0)
log_info("customization loaded from '%s'", customization_path()) ;
else
log_warning("customization file '%s' corrupted or non-existing, using default values", customization_path()) ;
format24_by_default = parse_boolean(c->get("format24")->str()) ;
nitz_supported = parse_boolean(c->get("useNitz")->str()) ;
auto_time_by_default = parse_boolean(c->get("autoTime")->str()) ;
guess_tz_by_default = parse_boolean(c->get("guessTz")->str()) ;
tz_by_default = c->get("tz")->str() ;
if (not nitz_supported and auto_time_by_default)
{
log_warning("automatic time update disabled because nitz is not supported in the device") ;
auto_time_by_default = false ;
}
delete c ;
delete storage ;
}
static cairo_bool_t
resource_parse_line (char *name, cairo_xcb_resources_t *resources)
{
char *value;
value = strchr (name, ':');
if (value == NULL)
return FALSE;
*value++ = 0;
name = skip_spaces (name);
value = skip_spaces (value);
if (strcmp (name, "Xft.antialias") == 0)
parse_boolean (value, &(resources->xft_antialias));
else if (strcmp (name, "Xft.lcdfilter") == 0)
parse_integer (value, &(resources->xft_lcdfilter));
else if (strcmp (name, "Xft.rgba") == 0)
parse_integer (value, &(resources->xft_rgba));
else if (strcmp (name, "Xft.hinting") == 0)
parse_boolean (value, &(resources->xft_hinting));
else if (strcmp (name, "Xft.hintstyle") == 0)
parse_integer (value, &(resources->xft_hintstyle));
return TRUE;
}
//!
//!
//!
//! @param[in] key
//! @param[in] val
//!
//! @pre
//!
//! @post
//!
static void set_global_parameter(char *key, char *val)
{
if (strcmp(key, "debug") == 0) {
print_debug = parse_boolean(val);
set_debug(print_debug);
} else if (strcmp(key, "argv") == 0) {
print_argv = parse_boolean(val);
} else if (strcmp(key, "work") == 0) {
set_work_dir(val);
} else if (strcmp(key, "work_size") == 0) {
set_work_limit(parse_bytes(val));
} else if (strcmp(key, "cache") == 0) {
set_cache_dir(val);
} else if (strcmp(key, "cache_size") == 0) {
set_cache_limit(parse_bytes(val));
} else if (strcmp(key, "purge_cache") == 0) {
purge_cache = parse_boolean(val);
} else if (strcmp(key, "cloud_cert") == 0) {
euca_strncpy(cloud_cert_path, val, sizeof(cloud_cert_path));
} else if (strcmp(key, "service_key") == 0) {
euca_strncpy(service_key_path, val, sizeof(service_key_path));
} else {
err("unknown global parameter '%s'", key);
}
LOGINFO("GLOBAL: %s=%s\n", key, val);
}
struct rmonitor_file_watch_info *initialize_watch(const char *fname, struct jx *watch_spec) {
struct rmonitor_file_watch_info *f;
f = calloc(1, sizeof(*f));
f->delete_if_found = parse_boolean(fname, watch_spec, "delete-if-found", 0 /* default false */);
f->from_start = parse_boolean(fname, watch_spec, "from-start", 0 /* default false */);
f->from_start_if_truncated = parse_boolean(fname, watch_spec, "from-start-if-truncated", 1 /* default true */);
f->filename = fname;
f->exists = 0;
f->position = 0;
f->last_size = 0;
f->last_mtime = 0;
f->last_ino = 0;
f->event_with_pattern = 0;
initialize_watch_events(f, watch_spec);
struct stat s;
if(stat(fname, &s) == 0) {
f->exists = 1;
f->last_ino = s.st_ino;
if(!f->from_start) {
f->position = s.st_size;
f->last_size = s.st_size;
f->last_mtime = s.st_mtime;
}
}
return f;
}
struct rmonitor_file_watch_event *parse_event(const char *fname, struct jx *spec) {
struct rmonitor_file_watch_event *e = calloc(1, sizeof(*e));
//defaults:
e->on_creation = 0;
e->on_truncate = 0;
e->max_count = -1;
e->total_count = 0;
e->cycle_count = 0;
e->on_pattern = NULL;
e->label = NULL;
e->label = parse_str(fname, spec, "label", NULL);
e->max_count = parse_int(fname, spec, "count", -1);
e->on_pattern = parse_str(fname, spec, "on-pattern", e->on_pattern);
e->on_creation = parse_boolean(fname, spec, "on-create", e->on_creation);
e->on_truncate = parse_boolean(fname, spec, "on-truncate", e->on_truncate);
int error = 0;
if(!e->label) {
error = 1;
warn(D_RMON | D_NOTICE, "A label for '%s' was not given.", fname);
} else if(string_match_regex(e->label, "[^A-Za-z0-9_-]")) {
error = 1;
warn(D_RMON | D_NOTICE, "Label for '%s' has characters not in [A-Za-z0-9_-]", fname);
} else {
int defined = 0;
if(e->on_creation) {
defined++;
}
if(e->on_truncate) {
defined++;
}
if(e->on_pattern) {
defined++;
}
if(defined != 1) {
error = 1;
warn(D_RMON | D_NOTICE, "Exactly one of on-create, on-truncate, or on-pattern should be specified for '%s'", fname);
}
}
if(error) {
free(e->label);
free(e->on_pattern);
free(e);
return NULL;
}
return e;
}
static int parse_proc_cmdline(void) {
char *line, *w, *state;
int r;
size_t l;
if (detect_container(NULL) > 0)
return 0;
r = read_one_line_file("/proc/cmdline", &line);
if (r < 0) {
log_warning("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
return 0;
}
FOREACH_WORD_QUOTED(w, l, line, state) {
char *word;
word = strndup(w, l);
if (!word) {
r = log_oom();
goto finish;
}
if (startswith(word, "fstab=")) {
r = parse_boolean(word + 6);
if (r < 0)
log_warning("Failed to parse fstab switch %s. Ignoring.", word + 6);
else
arg_enabled = r;
} else if (startswith(word, "rd.fstab=")) {
if (in_initrd()) {
r = parse_boolean(word + 6);
if (r < 0)
log_warning("Failed to parse fstab switch %s. Ignoring.", word + 6);
else
arg_enabled = r;
}
} else if (startswith(word, "fstab.") ||
(in_initrd() && startswith(word, "rd.fstab."))) {
log_warning("Unknown kernel switch %s. Ignoring.", word);
}
free(word);
}
static int condition_test_virtualization(Condition *c) {
int b, v;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_VIRTUALIZATION);
v = detect_virtualization();
if (v < 0)
return v;
/* First, compare with yes/no */
b = parse_boolean(c->parameter);
if (v > 0 && b > 0)
return true;
if (v == 0 && b == 0)
return true;
/* Then, compare categorization */
if (VIRTUALIZATION_IS_VM(v) && streq(c->parameter, "vm"))
return true;
if (VIRTUALIZATION_IS_CONTAINER(v) && streq(c->parameter, "container"))
return true;
/* Finally compare id */
return v != VIRTUALIZATION_NONE && streq(c->parameter, virtualization_to_string(v));
}
static int condition_test_virtualization(Condition *c) {
int b, v;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_VIRTUALIZATION);
if (streq(c->parameter, "private-users"))
return running_in_userns();
v = detect_virtualization();
if (v < 0)
return v;
/* First, compare with yes/no */
b = parse_boolean(c->parameter);
if (b >= 0)
return b == !!v;
/* Then, compare categorization */
if (streq(c->parameter, "vm"))
return VIRTUALIZATION_IS_VM(v);
if (streq(c->parameter, "container"))
return VIRTUALIZATION_IS_CONTAINER(v);
/* Finally compare id */
return v != VIRTUALIZATION_NONE && streq(c->parameter, virtualization_to_string(v));
}
void parse_module(struct context *ctx, const char *cmd, const char *arg)
{
/* Label and description can be internationalized */
if (G_strcasecmp(cmd, "label") == 0) {
ctx->module->label = translate(xstrdup(arg));
return;
}
if (G_strcasecmp(cmd, "description") == 0) {
ctx->module->description = translate(xstrdup(arg));
return;
}
if (G_strcasecmp(cmd, "keywords") == 0) {
G_add_keyword(translate(xstrdup(arg)));
return;
}
if (G_strcasecmp(cmd, "overwrite") == 0) {
ctx->module->overwrite = parse_boolean(ctx, arg);
return;
}
if (G_strcasecmp(cmd, "end") == 0) {
ctx->state = S_TOPLEVEL;
return;
}
fprintf(stderr, _("Unknown module parameter \"%s\" at line %d\n"),
cmd, ctx->line);
}
static int link_update_llmnr_support(Link *l) {
_cleanup_free_ char *b = NULL;
int r;
assert(l);
r = sd_network_link_get_llmnr(l->ifindex, &b);
if (r < 0)
goto clear;
r = parse_boolean(b);
if (r < 0) {
if (streq(b, "resolve"))
l->llmnr_support = SUPPORT_RESOLVE;
else
goto clear;
} else if (r > 0)
l->llmnr_support = SUPPORT_YES;
else
l->llmnr_support = SUPPORT_NO;
return 0;
clear:
l->llmnr_support = SUPPORT_YES;
return r;
}
static int set_local_rtc(sd_bus *bus, char **args, unsigned n) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r, b;
assert(args);
assert(n == 2);
polkit_agent_open_if_enabled();
b = parse_boolean(args[1]);
if (b < 0) {
log_error("Failed to parse local RTC setting: %s", args[1]);
return b;
}
r = sd_bus_call_method(bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
"org.freedesktop.timedate1",
"SetLocalRTC",
&error,
NULL,
"bbb", b, arg_adjust_system_clock, arg_ask_password);
if (r < 0)
log_error("Failed to set local RTC: %s", bus_error_message(&error, -r));
return r;
}
int config_parse_bool(const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
int k;
bool *b = data;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
k = parse_boolean(rvalue);
if (k < 0) {
log_syntax(unit, LOG_ERR, filename, line, -k,
"Failed to parse boolean value, ignoring: %s", rvalue);
return 0;
}
*b = !!k;
return 0;
}
static int set_ntp(sd_bus *bus, char **args, unsigned n) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int b, r;
assert(args);
assert(n == 2);
polkit_agent_open_if_enabled();
b = parse_boolean(args[1]);
if (b < 0) {
log_error("Failed to parse NTP setting: %s", args[1]);
return b;
}
r = sd_bus_call_method(bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
"org.freedesktop.timedate1",
"SetNTP",
&error,
NULL,
"bb", b, arg_ask_password);
if (r < 0)
log_error("Failed to set ntp: %s", bus_error_message(&error, -r));
return r;
}
static int condition_test_virtualization(Condition *c) {
int b, v;
const char *id;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_VIRTUALIZATION);
v = detect_virtualization(&id);
if (v < 0)
return v;
/* First, compare with yes/no */
b = parse_boolean(c->parameter);
if (v > 0 && b > 0)
return true;
if (v == 0 && b == 0)
return true;
/* Then, compare categorization */
if (v == VIRTUALIZATION_VM && streq(c->parameter, "vm"))
return true;
if (v == VIRTUALIZATION_CONTAINER && streq(c->parameter, "container"))
return true;
/* Finally compare id */
return v > 0 && streq(c->parameter, id);
}
static int read_only_image(int argc, char *argv[], void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
int b = true, r;
if (argc > 2) {
b = parse_boolean(argv[2]);
if (b < 0)
return log_error_errno(b, "Failed to parse boolean argument: %s", argv[2]);
}
r = acquire_bus(&bus);
if (r < 0)
return r;
(void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
r = sd_bus_call_method(
bus,
"org.freedesktop.portable1",
"/org/freedesktop/portable1",
"org.freedesktop.portable1.Manager",
"MarkImageReadOnly",
&error,
NULL,
"sb", argv[1], b);
if (r < 0)
return log_error_errno(r, "Could not mark image read-only: %s", bus_error_message(&error, r));
return 0;
}
int config_parse_bool(
const char *filename,
unsigned line,
const char *section,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
int k;
bool *b = data;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if ((k = parse_boolean(rvalue)) < 0) {
log_error("[%s:%u] Failed to parse boolean value, ignoring: %s", filename, line, rvalue);
return 0;
}
*b = !!k;
return 0;
}
int config_parse_tristate(
const char *filename,
unsigned line,
const char *section,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
int k;
int *b = data;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
/* Tristates are like booleans, but can also take the 'default' value, i.e. "-1" */
k = parse_boolean(rvalue);
if (k < 0) {
log_error("[%s:%u] Failed to parse boolean value, ignoring: %s", filename, line, rvalue);
return 0;
}
*b = !!k;
return 0;
}
static int set_ntp(DBusConnection *bus, char **args, unsigned n) {
_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
dbus_bool_t interactive = true, b;
int r;
assert(args);
assert(n == 2);
polkit_agent_open_if_enabled();
r = parse_boolean(args[1]);
if (r < 0) {
log_error("Failed to parse NTP setting: %s", args[1]);
return r;
}
b = r;
return bus_method_call_with_reply(
bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
"org.freedesktop.timedate1",
"SetNTP",
&reply,
NULL,
DBUS_TYPE_BOOLEAN, &b,
DBUS_TYPE_BOOLEAN, &interactive,
DBUS_TYPE_INVALID);
}
static int scope_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
Scope *s = SCOPE(u);
assert(u);
assert(key);
assert(value);
assert(fds);
if (streq(key, "state")) {
ScopeState state;
state = scope_state_from_string(value);
if (state < 0)
log_unit_debug(u, "Failed to parse state value: %s", value);
else
s->deserialized_state = state;
} else if (streq(key, "was-abandoned")) {
int k;
k = parse_boolean(value);
if (k < 0)
log_unit_debug(u, "Failed to parse boolean value: %s", value);
else
s->was_abandoned = k;
} else
log_unit_debug(u, "Unknown serialization key: %s", key);
return 0;
}
int config_parse_quickack(const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_route_free_ Route *n = NULL;
Network *network = userdata;
int k, r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = route_new_static(network, filename, section_line, &n);
if (r < 0)
return r;
k = parse_boolean(rvalue);
if (k < 0) {
log_syntax(unit, LOG_ERR, filename, line, k, "Failed to parse TCP quickack, ignoring: %s", rvalue);
return 0;
}
n->quickack = !!k;
n = NULL;
return 0;
}
struct cmd_results *cmd_tiling_drag(int argc, char **argv) {
struct cmd_results *error = NULL;
if ((error = checkarg(argc, "tiling_drag", EXPECTED_EQUAL_TO, 1))) {
return error;
}
config->tiling_drag = parse_boolean(argv[0], config->tiling_drag);
return cmd_results_new(CMD_SUCCESS, NULL);
}
void compatibility_sysv_utmp_clean() {
char utmp_cfg = parse_boolean (cfg_getstring ("configuration-compatibility-sysv/utmp", NULL));
if (utmp_cfg) {
notice (4, "cleaning utmp");
updateutmp_f (utmp_clean, NULL);
}
/* don't worry if it's not OK, as utmp is pretty much useless to eINIT, so no reason
to bitch about it... */
}
//!
//!
//!
//! @param[in] key
//! @param[in] val
//!
//! @pre
//!
//! @post
//!
static void set_global_parameter(char *key, char *val)
{
if (strcmp(key, "debug") == 0) {
print_debug = parse_boolean(val);
set_debug(print_debug);
} else if (strcmp(key, "argv") == 0) {
print_argv = parse_boolean(val);
} else if (strcmp(key, "work") == 0) {
set_work_dir(val);
} else if (strcmp(key, "work_size") == 0) {
set_work_limit(parse_bytes(val));
} else if (strcmp(key, "cache") == 0) {
set_cache_dir(val);
} else if (strcmp(key, "cache_size") == 0) {
set_cache_limit(parse_bytes(val));
} else {
err("unknown global parameter '%s'", key);
}
LOGINFO("GLOBAL: %s=%s\n", key, val);
}
static VALUE typecast(VALUE r_value, const VALUE type) {
VALUE r_data;
if (type == rb_cInteger) {
return TYPE(r_value) == T_FIXNUM || TYPE(r_value) == T_BIGNUM ? r_value : rb_funcall(r_value, DO_ID_TO_I, 0);
} else if (type == rb_cString) {
if (TYPE(r_value) == T_STRING)
return r_value;
else if (rb_obj_class(r_value) == cOCI8_CLOB)
return rb_funcall(r_value, DO_ID_READ, 0);
else
return rb_funcall(r_value, DO_ID_TO_S, 0);
} else if (type == rb_cFloat) {
return TYPE(r_value) == T_FLOAT ? r_value : rb_funcall(r_value, DO_ID_TO_F, 0);
} else if (type == rb_cBigDecimal) {
VALUE r_string = TYPE(r_value) == T_STRING ? r_value : rb_funcall(r_value, DO_ID_TO_S, 0);
return rb_funcall(rb_cBigDecimal, DO_ID_NEW, 1, r_string);
} else if (type == rb_cDate) {
return parse_date(r_value);
} else if (type == rb_cDateTime) {
return parse_date_time(r_value);
} else if (type == rb_cTime) {
return parse_time(r_value);
} else if (type == rb_cTrueClass) {
return parse_boolean(r_value);
} else if (type == rb_cByteArray) {
if (rb_obj_class(r_value) == cOCI8_BLOB)
r_data = rb_funcall(r_value, DO_ID_READ, 0);
else
r_data = r_value;
return rb_funcall(rb_cByteArray, DO_ID_NEW, 1, r_data);
} else if (type == rb_cClass) {
return rb_funcall(mDO, DO_ID_FULL_CONST_GET, 1, r_value);
} else if (type == rb_cNilClass) {
return Qnil;
} else {
if (rb_obj_class(r_value) == cOCI8_CLOB)
return rb_funcall(r_value, DO_ID_READ, 0);
else
return r_value;
}
}
static int parse_proc_cmdline_item(const char *key, const char *value) {
int r;
if (STR_IN_SET(key, "luks", "rd.luks") && value) {
r = parse_boolean(value);
if (r < 0)
log_warning("Failed to parse luks switch %s. Ignoring.", value);
else
arg_enabled = r;
} else if (STR_IN_SET(key, "luks.crypttab", "rd.luks.crypttab") && value) {
r = parse_boolean(value);
if (r < 0)
log_warning("Failed to parse luks crypttab switch %s. Ignoring.", value);
else
arg_read_crypttab = r;
} else if (STR_IN_SET(key, "luks.uuid", "rd.luks.uuid") && value) {
if (strv_extend(&arg_disks, value) < 0)
return log_oom();
} else if (STR_IN_SET(key, "luks.options", "rd.luks.options") && value) {
if (strv_extend(&arg_options, value) < 0)
return log_oom();
} else if (STR_IN_SET(key, "luks.key", "rd.luks.key") && value) {
free(arg_keyfile);
arg_keyfile = strdup(value);
if (!arg_keyfile)
return log_oom();
} else if (startswith(key, "luks.") || startswith(key, "rd.luks."))
log_warning("Unknown kernel switch %s. Ignoring.", key);
return 0;
}
int shall_restore_state(void) {
_cleanup_free_ char *value = NULL;
int r;
r = get_proc_cmdline_key("systemd.restore_state=", &value);
if (r < 0)
return r;
if (r == 0)
return true;
return parse_boolean(value);
}
initialize_env (void)
{
unsigned long stacksize;
/* Do a compile time check that mkomp_h.pl did good job. */
omp_check_defines ();
parse_schedule ();
parse_boolean ("OMP_DYNAMIC", &gomp_dyn_var);
parse_boolean ("OMP_NESTED", &gomp_nest_var);
if (!parse_unsigned_long ("OMP_NUM_THREADS", &gomp_nthreads_var))
gomp_init_num_threads ();
/* Not strictly environment related, but ordering constructors is tricky. */
pthread_attr_init (&gomp_thread_attr);
pthread_attr_setdetachstate (&gomp_thread_attr, PTHREAD_CREATE_DETACHED);
if (parse_unsigned_long ("GOMP_STACKSIZE", &stacksize))
{
int err;
stacksize *= 1024;
err = pthread_attr_setstacksize (&gomp_thread_attr, stacksize);
#ifdef PTHREAD_STACK_MIN
if (err == EINVAL)
{
if (stacksize < PTHREAD_STACK_MIN)
gomp_error ("Stack size less than minimum of %luk",
PTHREAD_STACK_MIN / 1024ul
+ (PTHREAD_STACK_MIN % 1024 != 0));
else
gomp_error ("Stack size larger than system limit");
}
else
#endif
if (err != 0)
gomp_error ("Stack size change failed: %s", strerror (err));
}
}
static int condition_test_ac_power(Condition *c) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_AC_POWER);
r = parse_boolean(c->parameter);
if (r < 0)
return r;
return (on_ac_power() != 0) == !!r;
}
static int condition_test_first_boot(Condition *c) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_FIRST_BOOT);
r = parse_boolean(c->parameter);
if (r < 0)
return r;
return (access("/run/systemd/first-boot", F_OK) >= 0) == !!r;
}
void
change_c::parse_value() {
switch (m_property.m_type) {
case property_element_c::EBMLT_STRING: parse_ascii_string(); break;
case property_element_c::EBMLT_USTRING: parse_unicode_string(); break;
case property_element_c::EBMLT_UINT: parse_unsigned_integer(); break;
case property_element_c::EBMLT_INT: parse_signed_integer(); break;
case property_element_c::EBMLT_BOOL: parse_boolean(); break;
case property_element_c::EBMLT_BINARY: parse_binary(); break;
case property_element_c::EBMLT_FLOAT: parse_floating_point_number(); break;
default: assert(false);
}
}
