static int device_add_udev_wants(Unit *u, struct udev_device *dev) {
const char *wants;
- char *state, *w;
+ const char *word, *state;
size_t l;
int r;
if (!wants)
return 0;
- FOREACH_WORD_QUOTED(w, l, wants, state) {
+ FOREACH_WORD_QUOTED(word, l, wants, state) {
_cleanup_free_ char *n = NULL;
char e[l+1];
- memcpy(e, w, l);
+ memcpy(e, word, l);
e[l] = 0;
n = unit_name_mangle(e, MANGLE_NOGLOB);
* aliases */
alias = udev_device_get_property_value(dev, "SYSTEMD_ALIAS");
if (alias) {
- char *state, *w;
+ const char *word, *state;
size_t l;
- FOREACH_WORD_QUOTED(w, l, alias, state) {
+ FOREACH_WORD_QUOTED(word, l, alias, state) {
char e[l+1];
- memcpy(e, w, l);
+ memcpy(e, word, l);
e[l] = 0;
if (path_is_absolute(e))
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();
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();
void *data,
void *userdata) {
- char *w;
+ const char *word, *state;
size_t l;
- char *state;
cpu_set_t *c = NULL;
unsigned ncpus = 0;
assert(lvalue);
assert(rvalue);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
char *t;
int r;
unsigned cpu;
- if (!(t = strndup(w, l)))
+ if (!(t = strndup(word, l)))
return log_oom();
r = safe_atou(t, &cpu);
void *userdata) {
unsigned n = 0;
- char *state, *w;
+ const char *word, *state;
size_t length;
assert(filename);
free_join_controllers();
- FOREACH_WORD_QUOTED(w, length, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, length, rvalue, state) {
char *s, **l;
- s = strndup(w, length);
+ s = strndup(word, length);
if (!s)
return log_oom();
}
static int parse_options(const char *options) {
- char *state, *w;
+ const char *word, *state;
size_t l;
int r;
assert(options);
- FOREACH_WORD_SEPARATOR(w, l, options, ",", state) {
+ FOREACH_WORD_SEPARATOR(word, l, options, ",", state) {
_cleanup_free_ char *o;
- o = strndup(w, l);
+ o = strndup(word, l);
if (!o)
return -ENOMEM;
r = parse_one_option(o);
}
static int parse_flags(const char *flag_str, int flags) {
- char *w, *state;
+ const char *word, *state;
size_t l;
- FOREACH_WORD(w, l, flag_str, state) {
- if (strneq("masked", w, l))
+ FOREACH_WORD(word, l, flag_str, state) {
+ if (strneq("masked", word, l))
flags |= SHOW_MASKED;
- else if (strneq ("equivalent", w, l))
+ else if (strneq ("equivalent", word, l))
flags |= SHOW_EQUIVALENT;
- else if (strneq("redirected", w, l))
+ else if (strneq("redirected", word, l))
flags |= SHOW_REDIRECTED;
- else if (strneq("overridden", w, l))
+ else if (strneq("overridden", word, l))
flags |= SHOW_OVERRIDDEN;
- else if (strneq("unchanged", w, l))
+ else if (strneq("unchanged", word, l))
flags |= SHOW_UNCHANGED;
- else if (strneq("extended", w, l))
+ else if (strneq("extended", word, l))
flags |= SHOW_EXTENDED;
- else if (strneq("default", w, l))
+ else if (strneq("default", word, l))
flags |= SHOW_DEFAULTS;
else
return -EINVAL;
r = getenv_for_pid(1, "container_ttys", &container_ttys);
if (r > 0) {
- char *w, *state;
+ const char *word, *state;
size_t l;
- FOREACH_WORD(w, l, container_ttys, state) {
+ FOREACH_WORD(word, l, container_ttys, state) {
const char *t;
char tty[l + 1];
- memcpy(tty, w, l);
+ memcpy(tty, word, l);
tty[l] = 0;
/* First strip off /dev/ if it is specified */
}
if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
- char *w, *state;
+ const char *word, *state;
size_t l;
/* Automatically add in a serial getty on all active
* kernel consoles */
- FOREACH_WORD(w, l, active, state) {
+ FOREACH_WORD(word, l, active, state) {
_cleanup_free_ char *tty = NULL;
- tty = strndup(w, l);
+ tty = strndup(word, l);
if (!tty) {
log_oom();
return EXIT_FAILURE;
case ARG_GNUTLS_LOG: {
#ifdef HAVE_GNUTLS
- char *word, *state;
+ const char *word, *state;
size_t size;
FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
static int server_parse_proc_cmdline(Server *s) {
_cleanup_free_ char *line = NULL;
- char *w, *state;
+ const char *w, *state;
size_t l;
int r;
}
_public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) {
- char *w, *state;
+ const char *word, *state;
size_t l;
unsigned long long seqnum, monotonic, realtime, xor_hash;
bool
assert_return(!journal_pid_changed(j), -ECHILD);
assert_return(!isempty(cursor), -EINVAL);
- FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
+ FOREACH_WORD_SEPARATOR(word, l, cursor, ";", state) {
char *item;
int k = 0;
- if (l < 2 || w[1] != '=')
+ if (l < 2 || word[1] != '=')
return -EINVAL;
- item = strndup(w, l);
+ item = strndup(word, l);
if (!item)
return -ENOMEM;
- switch (w[0]) {
+ switch (word[0]) {
case 's':
seqnum_id_set = true;
_public_ int sd_journal_test_cursor(sd_journal *j, const char *cursor) {
int r;
- char *w, *state;
+ const char *word, *state;
size_t l;
Object *o;
if (r < 0)
return r;
- FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
+ FOREACH_WORD_SEPARATOR(word, l, cursor, ";", state) {
_cleanup_free_ char *item = NULL;
sd_id128_t id;
unsigned long long ll;
int k = 0;
- if (l < 2 || w[1] != '=')
+ if (l < 2 || word[1] != '=')
return -EINVAL;
- item = strndup(w, l);
+ item = strndup(word, l);
if (!item)
return -ENOMEM;
- switch (w[0]) {
+ switch (word[0]) {
case 's':
k = sd_id128_from_string(item+2, &id);
int deserialize_in_addrs(struct in_addr **ret, const char *string) {
_cleanup_free_ struct in_addr *addresses = NULL;
int size = 0;
- char *word, *state;
+ const char *word, *state;
size_t len;
assert(ret);
int deserialize_in6_addrs(struct in6_addr **ret, const char *string) {
_cleanup_free_ struct in6_addr *addresses = NULL;
int size = 0;
- char *word, *state;
+ const char *word, *state;
size_t len;
assert(ret);
int deserialize_dhcp_routes(struct sd_dhcp_route **ret, size_t *ret_size, size_t *ret_allocated, const char *string) {
_cleanup_free_ struct sd_dhcp_route *routes = NULL;
size_t size = 0, allocated = 0;
- char *word, *state;
+ const char *word, *state;
size_t len;
assert(ret);
}
_public_ int sd_uid_is_on_seat(uid_t uid, int require_active, const char *seat) {
- char *w, *state;
_cleanup_free_ char *t = NULL, *s = NULL, *p = NULL;
size_t l;
int r;
- const char *variable;
+ const char *word, *variable, *state;
assert_return(seat, -EINVAL);
if (asprintf(&t, UID_FMT, uid) < 0)
return -ENOMEM;
- FOREACH_WORD(w, l, s, state) {
- if (strneq(t, w, l))
+ FOREACH_WORD(word, l, s, state) {
+ if (strneq(t, word, l))
return 1;
}
}
if (uids && t) {
- char *w, *state;
+ const char *word, *state;
size_t l;
- FOREACH_WORD(w, l, t, state)
+ FOREACH_WORD(word, l, t, state)
n++;
if (n > 0) {
if (!b)
return -ENOMEM;
- FOREACH_WORD(w, l, t, state) {
+ FOREACH_WORD(word, l, t, state) {
_cleanup_free_ char *k = NULL;
- k = strndup(w, l);
+ k = strndup(word, l);
if (!k)
return -ENOMEM;
_public_ int sd_machine_get_ifindices(const char *machine, int **ifindices) {
_cleanup_free_ char *netif = NULL;
size_t l, allocated = 0, nr = 0;
- char *w, *state;
int *ni = NULL;
- const char *p;
+ const char *p, *word, *state;
int r;
assert_return(machine_name_is_valid(machine), -EINVAL);
return 0;
}
- FOREACH_WORD(w, l, netif, state) {
+ FOREACH_WORD(word, l, netif, state) {
char buf[l+1];
int ifi;
- *(char*) (mempcpy(buf, w, l)) = 0;
+ *(char*) (mempcpy(buf, word, l)) = 0;
if (safe_atoi(buf, &ifi) < 0)
continue;
InhibitWhat inhibit_what_from_string(const char *s) {
InhibitWhat what = 0;
- char *w, *state;
+ const char *word, *state;
size_t l;
- FOREACH_WORD_SEPARATOR(w, l, s, ":", state) {
- if (l == 8 && strneq(w, "shutdown", l))
+ FOREACH_WORD_SEPARATOR(word, l, s, ":", state) {
+ if (l == 8 && strneq(word, "shutdown", l))
what |= INHIBIT_SHUTDOWN;
- else if (l == 5 && strneq(w, "sleep", l))
+ else if (l == 5 && strneq(word, "sleep", l))
what |= INHIBIT_SLEEP;
- else if (l == 4 && strneq(w, "idle", l))
+ else if (l == 4 && strneq(word, "idle", l))
what |= INHIBIT_IDLE;
- else if (l == 16 && strneq(w, "handle-power-key", l))
+ else if (l == 16 && strneq(word, "handle-power-key", l))
what |= INHIBIT_HANDLE_POWER_KEY;
- else if (l == 18 && strneq(w, "handle-suspend-key", l))
+ else if (l == 18 && strneq(word, "handle-suspend-key", l))
what |= INHIBIT_HANDLE_SUSPEND_KEY;
- else if (l == 20 && strneq(w, "handle-hibernate-key", l))
+ else if (l == 20 && strneq(word, "handle-hibernate-key", l))
what |= INHIBIT_HANDLE_HIBERNATE_KEY;
- else if (l == 17 && strneq(w, "handle-lid-switch", l))
+ else if (l == 17 && strneq(word, "handle-lid-switch", l))
what |= INHIBIT_HANDLE_LID_SWITCH;
else
return _INHIBIT_WHAT_INVALID;
if (netif) {
size_t l, allocated = 0, nr = 0;
- char *w, *state;
+ const char *word, *state;
int *ni = NULL;
- FOREACH_WORD(w, l, netif, state) {
+ FOREACH_WORD(word, l, netif, state) {
char buf[l+1];
int ifi;
- *(char*) (mempcpy(buf, w, l)) = 0;
+ *(char*) (mempcpy(buf, word, l)) = 0;
if (safe_atoi(buf, &ifi) < 0)
continue;
case ARG_CAPABILITY:
case ARG_DROP_CAPABILITY: {
- char *state, *word;
+ const char *state, *word;
size_t length;
FOREACH_WORD_SEPARATOR(word, length, optarg, ",", state) {
}
static int change_uid_gid(char **_home) {
- char line[LINE_MAX], *w, *x, *state, *u, *g, *h;
+ char line[LINE_MAX], *x, *u, *g, *h;
+ const char *word, *state;
_cleanup_free_ uid_t *uids = NULL;
_cleanup_free_ char *home = NULL;
_cleanup_fclose_ FILE *f = NULL;
x += strcspn(x, WHITESPACE);
x += strspn(x, WHITESPACE);
- FOREACH_WORD(w, l, x, state) {
+ FOREACH_WORD(word, l, x, state) {
char c[l+1];
- memcpy(c, w, l);
+ memcpy(c, word, l);
c[l] = 0;
if (!GREEDY_REALLOC(uids, sz, n_uids+1))
}
static int parse_dns_server_string(Manager *m, const char *string) {
- char *word, *state;
+ const char *word, *state;
size_t length;
int r;
cs = strlen(controller);
FOREACH_LINE(line, f, return -errno) {
- char *l, *p, *w, *e;
+ char *l, *p, *e;
size_t k;
- char *state;
+ const char *word, *state;
bool found = false;
truncate_nl(line);
*e = 0;
- FOREACH_WORD_SEPARATOR(w, k, l, ",", state) {
+ FOREACH_WORD_SEPARATOR(word, k, l, ",", state) {
- if (k == cs && memcmp(w, controller, cs) == 0) {
+ if (k == cs && memcmp(word, controller, cs) == 0) {
found = true;
break;
}
if (k == 5 + cs &&
- memcmp(w, "name=", 5) == 0 &&
- memcmp(w+5, controller, cs) == 0) {
+ memcmp(word, "name=", 5) == 0 &&
+ memcmp(word+5, controller, cs) == 0) {
found = true;
break;
}
}
bool condition_test_kernel_command_line(Condition *c) {
- char *line, *w, *state, *word = NULL;
+ char *line, *word = NULL;
+ const char *w, *state;
bool equal;
int r;
size_t l, pl;
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) {
char *n;
- n = strndup(w, l);
+ n = strndup(word, l);
if (!n)
return log_oom();
void *userdata) { \
\
type **enums = data, *xs, x, *ys; \
- char *w, *state; \
+ const char *word, *state; \
size_t l, i = 0; \
\
assert(filename); \
xs = new0(type, 1); \
*xs = invalid; \
\
- FOREACH_WORD(w, l, rvalue, state) { \
+ FOREACH_WORD(word, l, rvalue, state) { \
_cleanup_free_ char *en = NULL; \
\
- en = strndup(w, l); \
+ en = strndup(word, l); \
if (!en) \
return -ENOMEM; \
\
void *data,
void *userdata) {
- char *w;
size_t l;
- char *state;
+ const char *word, *state;
InstallContext *c = data;
assert(filename);
assert(lvalue);
assert(rvalue);
- FOREACH_WORD_QUOTED(w, l, rvalue, state) {
+ FOREACH_WORD_QUOTED(word, l, rvalue, state) {
_cleanup_free_ char *n;
int r;
- n = strndup(w, l);
+ n = strndup(word, l);
if (!n)
return -ENOMEM;
if (r < 0)
log_warning("Failed to read /proc/cmdline. Ignoring: %s", strerror(-r));
else if (r > 0) {
- char *w, *state;
+ const char *word, *state;
size_t l;
- FOREACH_WORD_QUOTED(w, l, line, state) {
- if (l == 5 && startswith(w, "debug")) {
+ FOREACH_WORD_QUOTED(word, l, line, state) {
+ if (l == 5 && startswith(word, "debug")) {
log_set_max_level(LOG_DEBUG);
break;
}
return 0;
} else {
const char *path;
- char *state, *w;
+ const char *word, *state;
size_t l;
/**
if (!path)
path = DEFAULT_PATH;
- FOREACH_WORD_SEPARATOR(w, l, path, ":", state) {
+ FOREACH_WORD_SEPARATOR(word, l, path, ":", state) {
_cleanup_free_ char *p = NULL;
- if (asprintf(&p, "%.*s/%s", (int) l, w, name) < 0)
+ if (asprintf(&p, "%.*s/%s", (int) l, word, name) < 0)
return -ENOMEM;
if (access(p, X_OK) < 0)
}
int can_sleep_state(char **types) {
- char *w, *state, **type;
+ char **type;
int r;
_cleanup_free_ char *p = NULL;
return false;
STRV_FOREACH(type, types) {
+ const char *word, *state;
size_t l, k;
k = strlen(*type);
- FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state)
- if (l == k && memcmp(w, *type, l) == 0)
+ FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state)
+ if (l == k && memcmp(word, *type, l) == 0)
return true;
}
}
int can_sleep_disk(char **types) {
- char *w, *state, **type;
+ char **type;
int r;
_cleanup_free_ char *p = NULL;
return false;
STRV_FOREACH(type, types) {
+ const char *word, *state;
size_t l, k;
k = strlen(*type);
- FOREACH_WORD_SEPARATOR(w, l, p, WHITESPACE, state) {
- if (l == k && memcmp(w, *type, l) == 0)
+ FOREACH_WORD_SEPARATOR(word, l, p, WHITESPACE, state) {
+ if (l == k && memcmp(word, *type, l) == 0)
return true;
- if (l == k + 2 && w[0] == '[' && memcmp(w + 1, *type, l - 2) == 0 && w[l-1] == ']')
+ if (l == k + 2 &&
+ word[0] == '[' &&
+ memcmp(word + 1, *type, l - 2) == 0 &&
+ word[l-1] == ']')
return true;
}
}
}
char **strv_split(const char *s, const char *separator) {
- char *state;
- char *w;
+ const char *word, *state;
size_t l;
unsigned n, i;
char **r;
assert(s);
n = 0;
- FOREACH_WORD_SEPARATOR(w, l, s, separator, state)
+ FOREACH_WORD_SEPARATOR(word, l, s, separator, state)
n++;
r = new(char*, n+1);
return NULL;
i = 0;
- FOREACH_WORD_SEPARATOR(w, l, s, separator, state) {
- r[i] = strndup(w, l);
+ FOREACH_WORD_SEPARATOR(word, l, s, separator, state) {
+ r[i] = strndup(word, l);
if (!r[i]) {
strv_free(r);
return NULL;
}
char **strv_split_quoted(const char *s) {
- char *state;
- char *w;
+ const char *word, *state;
size_t l;
unsigned n, i;
char **r;
assert(s);
n = 0;
- FOREACH_WORD_QUOTED(w, l, s, state)
+ FOREACH_WORD_QUOTED(word, l, s, state)
n++;
+ if (*state)
+ /* bad syntax */
+ return NULL;
r = new(char*, n+1);
if (!r)
return NULL;
i = 0;
- FOREACH_WORD_QUOTED(w, l, s, state) {
- r[i] = cunescape_length(w, l);
+ FOREACH_WORD_QUOTED(word, l, s, state) {
+ r[i] = cunescape_length(word, l);
if (!r[i]) {
strv_free(r);
return NULL;
else if (s[n] == '\\')
escaped = true;
else if (strchr(reject, s[n]))
- return n;
+ break;
}
- return n;
+ /* if s ends in \, return index of previous char */
+ return n - escaped;
}
/* Split a string into words. */
-char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state) {
- char *current;
+const char* split(const char **state, size_t *l, const char *separator, bool quoted) {
+ const char *current;
- current = *state ? *state : (char*) c;
+ current = *state;
- if (!*current || *c == 0)
+ if (!*current) {
+ assert(**state == '\0');
return NULL;
+ }
current += strspn(current, separator);
- if (!*current)
+ if (!*current) {
+ *state = current;
return NULL;
+ }
if (quoted && strchr("\'\"", *current)) {
- char quotechar = *(current++);
- *l = strcspn_escaped(current, (char[]){quotechar, '\0'});
- *state = current+*l+1;
+ char quotechars[2] = {*current, '\0'};
+
+ *l = strcspn_escaped(current + 1, quotechars);
+ if (current[*l + 1] == '\0' ||
+ (current[*l + 2] && !strchr(separator, current[*l + 2]))) {
+ /* right quote missing or garbage at the end*/
+ *state = current;
+ return NULL;
+ }
+ assert(current[*l + 1] == quotechars[0]);
+ *state = current++ + *l + 2;
} else if (quoted) {
*l = strcspn_escaped(current, separator);
- *state = current+*l;
+ *state = current + *l;
} else {
*l = strcspn(current, separator);
- *state = current+*l;
+ *state = current + *l;
}
- return (char*) current;
+ return current;
}
int get_parent_of_pid(pid_t pid, pid_t *_ppid) {
int shall_restore_state(void) {
_cleanup_free_ char *line = NULL;
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
r = 1;
- FOREACH_WORD_QUOTED(w, l, line, state) {
+ FOREACH_WORD_QUOTED(word, l, line, state) {
const char *e;
char n[l+1];
int k;
- memcpy(n, w, l);
+ memcpy(n, word, l);
n[l] = 0;
e = startswith(n, "systemd.restore_state=");
int parse_proc_cmdline(int (*parse_item)(const char *key, const char *value)) {
_cleanup_free_ char *line = NULL;
- char *w, *state;
+ const char *w, *state;
size_t l;
int r;
return safe_atolli(s, (long long int*) ret_i);
}
-char *split(const char *c, size_t *l, const char *separator, bool quoted, char **state);
+const char* split(const char **state, size_t *l, const char *separator, bool quoted);
#define FOREACH_WORD(word, length, s, state) \
_FOREACH_WORD(word, length, s, WHITESPACE, false, state)
_FOREACH_WORD(word, length, s, separator, true, state)
#define _FOREACH_WORD(word, length, s, separator, quoted, state) \
- for ((state) = NULL, (word) = split((s), &(length), (separator), (quoted), &(state)); (word); (word) = split((s), &(length), (separator), (quoted), &(state)))
+ for ((state) = (s), (word) = split(&(state), &(length), (separator), (quoted)); (word); (word) = split(&(state), &(length), (separator), (quoted)))
pid_t get_parent_of_pid(pid_t pid, pid_t *ppid);
int get_starttime_of_pid(pid_t pid, unsigned long long *st);
return 0;
case 't': {
- char *word, *state;
+ const char *word, *state;
size_t size;
FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
if (!arg_properties)
return log_oom();
} else {
- char *word, *state;
+ const char *word, *state;
size_t size;
FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
break;
case ARG_STATE: {
- char *word, *state;
+ const char *word, *state;
size_t size;
FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
} else if (state == LSB || state == LSB_DESCRIPTION) {
if (startswith_no_case(t, "Provides:")) {
- char *i, *w;
+ const char *word, *state_;
size_t z;
state = LSB;
- FOREACH_WORD_QUOTED(w, z, t+9, i) {
+ FOREACH_WORD_QUOTED(word, z, t+9, state_) {
_cleanup_free_ char *n = NULL, *m = NULL;
- n = strndup(w, z);
+ n = strndup(word, z);
if (!n)
return -ENOMEM;
startswith_no_case(t, "Should-Start:") ||
startswith_no_case(t, "X-Start-Before:") ||
startswith_no_case(t, "X-Start-After:")) {
- char *i, *w;
+ const char *word, *state_;
size_t z;
state = LSB;
- FOREACH_WORD_QUOTED(w, z, strchr(t, ':')+1, i) {
+ FOREACH_WORD_QUOTED(word, z, strchr(t, ':')+1, state_) {
_cleanup_free_ char *n = NULL, *m = NULL;
bool is_before;
- n = strndup(w, z);
+ n = strndup(word, z);
if (!n)
return -ENOMEM;
static void test_strv_unquote(const char *quoted, const char **list) {
_cleanup_strv_free_ char **s;
+ _cleanup_free_ char *j;
unsigned i = 0;
char **t;
s = strv_split_quoted(quoted);
assert_se(s);
- strv_print(s);
+ j = strv_join(s, " | ");
+ assert(j);
+ puts(j);
STRV_FOREACH(t, s)
assert_se(streq(list[i++], *t));
assert_se(list[i] == NULL);
}
+static void test_invalid_unquote(const char *quoted) {
+ char **s;
+
+ s = strv_split_quoted(quoted);
+ assert(s == NULL);
+}
+
static void test_strv_split(void) {
char **s;
unsigned i = 0;
test_strv_unquote(" \"x'\" ", (const char*[]) { "x'", NULL });
test_strv_unquote("a '--b=c \"d e\"'", (const char*[]) { "a", "--b=c \"d e\"", NULL });
- test_strv_unquote("a --b='c \"d e\"'", (const char*[]) { "a", "--b='c", "\"d", "e\"'", NULL });
+ test_invalid_unquote("a --b='c \"d e\"'");
+ test_invalid_unquote("a --b='c \"d e\" '");
+ test_invalid_unquote("a --b='c \"d e\"garbage");
test_strv_split();
test_strv_split_newlines();
}
static void test_foreach_word(void) {
- char *w, *state;
+ const char *word, *state;
size_t l;
int i = 0;
const char test[] = "test abc d\te f ";
NULL
};
- FOREACH_WORD(w, l, test, state) {
- assert_se(strneq(expected[i++], w, l));
- }
+ FOREACH_WORD(word, l, test, state)
+ assert_se(strneq(expected[i++], word, l));
}
static void test_foreach_word_quoted(void) {
- char *w, *state;
+ const char *word, *state;
size_t l;
int i = 0;
const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
};
printf("<%s>\n", test);
- FOREACH_WORD_QUOTED(w, l, test, state) {
+ FOREACH_WORD_QUOTED(word, l, test, state) {
_cleanup_free_ char *t = NULL;
- assert_se(t = strndup(w, l));
- assert_se(strneq(expected[i++], w, l));
+ assert_se(t = strndup(word, l));
+ assert_se(strneq(expected[i++], word, l));
printf("<%s>\n", t);
}
}
}
static int manager_add_server_string(Manager *m, const char *string) {
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
assert(m);
assert(string);
- FOREACH_WORD_QUOTED(w, l, string, state) {
+ FOREACH_WORD_QUOTED(word, l, string, state) {
char t[l+1];
- memcpy(t, w, l);
+ memcpy(t, word, l);
t[l] = 0;
r = manager_add_server(m, t);
static bool enable_name_policy(void) {
_cleanup_free_ char *line = NULL;
- char *w, *state;
+ const char *word, *state;
int r;
size_t l;
if (r <= 0)
return true;
- FOREACH_WORD_QUOTED(w, l, line, state)
- if (strneq(w, "net.ifnames=0", l))
+ FOREACH_WORD_QUOTED(word, l, line, state)
+ if (strneq(word, "net.ifnames=0", l))
return false;
return true;
*/
static void kernel_cmdline_options(struct udev *udev) {
_cleanup_free_ char *line = NULL;
- char *w, *state;
+ const char *word, *state;
size_t l;
int r;
if (r <= 0)
return;
- FOREACH_WORD_QUOTED(w, l, line, state) {
+ FOREACH_WORD_QUOTED(word, l, line, state) {
char *s, *opt;
- s = strndup(w, l);
+ s = strndup(word, l);
if (!s)
break;