UnitDependency d = ltype;
Unit *u = userdata;
- char *w, *state;
+ const char *word, *state;
size_t l;
assert(filename);
assert(lvalue);
assert(rvalue);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL, *k = NULL;
int r;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
void *data,
void *userdata) {
- char *w, *state, ***x = data;
+ char ***x = data;
+ const char *word, *state;
Unit *u = userdata;
size_t l;
int r;
assert(rvalue);
assert(u);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *k = NULL;
char t[l+1];
- memcpy(t, w, l);
+ memcpy(t, word, l);
t[l] = 0;
r = unit_full_printf(u, t, &k);
* overriding of argv[0]. */
for (;;) {
int i;
- char *w;
+ const char *word, *state;
size_t l;
- char *state;
bool honour_argv0 = false, ignore = false;
path = NULL;
}
k = 0;
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
- if (strneq(w, ";", MAX(l, 1U)))
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
+ if (strneq(word, ";", MAX(l, 1U)))
break;
k++;
return log_oom();
k = 0;
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
- if (strneq(w, ";", MAX(l, 1U)))
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
+ if (strneq(word, ";", MAX(l, 1U)))
break;
- else if (strneq(w, "\\;", MAX(l, 1U)))
- w ++;
+ else if (strneq(word, "\\;", MAX(l, 1U)))
+ word ++;
- if (honour_argv0 && w == rvalue) {
+ if (honour_argv0 && word == rvalue) {
assert(!path);
- path = strndup(w, l);
+ path = strndup(word, l);
if (!path) {
r = log_oom();
goto fail;
} else {
char *c;
- c = n[k++] = cunescape_length(w, l);
+ c = n[k++] = cunescape_length(word, l);
if (!c) {
r = log_oom();
goto fail;
void *userdata) {
ExecContext *c = data;
- char *w;
+ const char *word, *state;
size_t l;
- char *state;
assert(filename);
assert(lvalue);
return 0;
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL;
int r;
unsigned cpu;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
void *userdata) {
ExecContext *c = data;
- char *w;
size_t l;
- char *state;
+ const char *word, *state;
assert(filename);
assert(lvalue);
return 0;
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
- if (first_word(w, "keep-caps"))
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
+ if (first_word(word, "keep-caps"))
c->secure_bits |= 1<<SECURE_KEEP_CAPS;
- else if (first_word(w, "keep-caps-locked"))
+ else if (first_word(word, "keep-caps-locked"))
c->secure_bits |= 1<<SECURE_KEEP_CAPS_LOCKED;
- else if (first_word(w, "no-setuid-fixup"))
+ else if (first_word(word, "no-setuid-fixup"))
c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP;
- else if (first_word(w, "no-setuid-fixup-locked"))
+ else if (first_word(word, "no-setuid-fixup-locked"))
c->secure_bits |= 1<<SECURE_NO_SETUID_FIXUP_LOCKED;
- else if (first_word(w, "noroot"))
+ else if (first_word(word, "noroot"))
c->secure_bits |= 1<<SECURE_NOROOT;
- else if (first_word(w, "noroot-locked"))
+ else if (first_word(word, "noroot-locked"))
c->secure_bits |= 1<<SECURE_NOROOT_LOCKED;
else {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
void *userdata) {
uint64_t *capability_bounding_set_drop = data;
- char *w;
+ const char *word, *state;
size_t l;
- char *state;
bool invert = false;
uint64_t sum = 0;
* non-inverted everywhere to have a fully normalized
* interface. */
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL;
int r;
cap_value_t cap;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
void *userdata) {
ExecContext *c = data;
- char *w;
+ const char *word, *state;
size_t l;
- char *state;
unsigned long flags = 0;
assert(filename);
assert(rvalue);
assert(data);
- FOREACH_WORD_SEPARATOR(w, l, rvalue, ", ", state) {
+ FOREACH_WORD_SEPARATOR(word, l, rvalue, ", ", state) {
_cleanup_free_ char *t;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
flags = MS_SHARED;
else if (streq(t, "slave"))
flags = MS_SLAVE;
- else if (streq(w, "private"))
+ else if (streq(word, "private"))
flags = MS_PRIVATE;
else {
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Failed to parse mount flag %s, ignoring: %s", t, rvalue);
Service *s = data;
int r;
- char *state, *w;
+ const char *word, *state;
size_t l;
assert(filename);
assert(rvalue);
assert(data);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL, *k = NULL;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
void *userdata) {
Unit *u = userdata;
- char*** env = data, *w, *state;
+ char*** env = data;
+ const char *word, *state;
size_t l;
_cleanup_free_ char *k = NULL;
int r;
if (!k)
return log_oom();
- FOREACH_WORD_QUOTED(w, l, k, state) {
+ FOREACH_WORD_QUOTED(word, l, k, state) {
_cleanup_free_ char *n;
char **x;
- n = cunescape_length(w, l);
+ n = cunescape_length(word, l);
if (!n)
return log_oom();
void *userdata) {
Unit *u = userdata;
- char *state;
+ const char *word, *state;
size_t l;
- char *w;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
int r;
_cleanup_free_ char *n;
- n = strndup(w, l);
+ n = strndup(word, l);
if (!n)
return log_oom();
ExecContext *c = data;
Unit *u = userdata;
bool invert = false;
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
}
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL;
int id;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
void *userdata) {
Set **archs = data;
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
if (r < 0)
return log_oom();
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL;
uint32_t a;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
ExecContext *c = data;
Unit *u = userdata;
bool invert = false;
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
c->address_families_whitelist = !invert;
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *t = NULL;
int af;
- t = strndup(w, l);
+ t = strndup(word, l);
if (!t)
return log_oom();
assert(rvalue);
if (isempty(rvalue)) {
- c->cpu_quota_per_sec_usec = (usec_t) -1;
+ c->cpu_quota_per_sec_usec = USEC_INFINITY;
return 0;
}
void *data,
void *userdata) {
- char***rt = data, *w, *state;
+ char***rt = data;
+ const char *word, *state;
size_t l;
int r;
return 0;
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *n;
- n = strndup(w, l);
+ n = strndup(word, l);
if (!n)
return log_oom();
void *data,
void *userdata) {
- char *w;
size_t l;
- char *state;
+ const char *word, *state;
int r;
ExitStatusSet *status_set = data;
return 0;
}
- FOREACH_WORD(w, l, rvalue, state) {
+ FOREACH_WORD(word, l, rvalue, state) {
_cleanup_free_ char *temp;
int val;
- temp = strndup(w, l);
+ temp = strndup(word, l);
if (!temp)
return log_oom();
r = set_put(status_set->signal, INT_TO_PTR(val));
if (r < 0) {
- log_syntax(unit, LOG_ERR, filename, line, -r, "Unable to store: %s", w);
+ log_syntax(unit, LOG_ERR, filename, line, -r, "Unable to store: %s", word);
return r;
}
} else {
- log_syntax(unit, LOG_ERR, filename, line, -val, "Failed to parse value, ignoring: %s", w);
+ log_syntax(unit, LOG_ERR, filename, line, -val, "Failed to parse value, ignoring: %s", word);
return 0;
}
} else {
r = set_put(status_set->status, INT_TO_PTR(val));
if (r < 0) {
- log_syntax(unit, LOG_ERR, filename, line, -r, "Unable to store: %s", w);
+ log_syntax(unit, LOG_ERR, filename, line, -r, "Unable to store: %s", word);
return r;
}
}
void *data,
void *userdata) {
- char*** sv = data, *w, *state;
+ char*** sv = data;
+ const char *word, *state;
size_t l;
int r;
return 0;
}
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *n;
int offset;
- n = strndup(w, l);
+ n = strndup(word, l);
if (!n)
return log_oom();
u->load_state = UNIT_LOADED;
/* Now, parse the file contents */
- r = config_parse(u->id, filename, f, UNIT_VTABLE(u)->sections,
- config_item_perf_lookup,
- (void*) load_fragment_gperf_lookup, false, true, u);
+ r = config_parse(u->id, filename, f,
+ UNIT_VTABLE(u)->sections,
+ config_item_perf_lookup, load_fragment_gperf_lookup,
+ false, true, false, u);
if (r < 0)
return r;
}