--- /dev/null
+@@
+expression list args;
+@@
+- strjoin(args, NULL);
++ strjoin(args);
+@@
+expression t;
+expression list args;
+@@
+- t = strjoin(args, NULL);
++ t = strjoin(args);
+@@
+expression list args;
+@@
+- return strjoin(args, NULL);
++ return strjoin(args);
return EXIT_FAILURE;
}
- saved = strjoin("/var/lib/systemd/backlight/", escaped_path_id, ":", escaped_ss, ":", escaped_sysname, NULL);
+ saved = strjoin("/var/lib/systemd/backlight/", escaped_path_id, ":", escaped_ss, ":", escaped_sysname);
} else
- saved = strjoin("/var/lib/systemd/backlight/", escaped_ss, ":", escaped_sysname, NULL);
+ saved = strjoin("/var/lib/systemd/backlight/", escaped_ss, ":", escaped_sysname);
if (!saved) {
log_oom();
if (old_child_fd < 0)
return -errno;
- np = strjoin(subvolume, "/", ino_args.name, NULL);
+ np = strjoin(subvolume, "/", ino_args.name);
if (!np)
return -ENOMEM;
while ((r = cg_read_subgroup(d, &fn)) > 0) {
_cleanup_free_ char *p = NULL;
- p = strjoin(path, "/", fn, NULL);
+ p = strjoin(path, "/", fn);
free(fn);
if (!p)
return -ENOMEM;
while ((r = cg_read_subgroup(d, &fn)) > 0) {
_cleanup_free_ char *p = NULL;
- p = strjoin(pfrom, "/", fn, NULL);
+ p = strjoin(pfrom, "/", fn);
free(fn);
if (!p)
return -ENOMEM;
if (isempty(path) && isempty(suffix))
t = strappend("/sys/fs/cgroup/", dn);
else if (isempty(path))
- t = strjoin("/sys/fs/cgroup/", dn, "/", suffix, NULL);
+ t = strjoin("/sys/fs/cgroup/", dn, "/", suffix);
else if (isempty(suffix))
- t = strjoin("/sys/fs/cgroup/", dn, "/", path, NULL);
+ t = strjoin("/sys/fs/cgroup/", dn, "/", path);
else
- t = strjoin("/sys/fs/cgroup/", dn, "/", path, "/", suffix, NULL);
+ t = strjoin("/sys/fs/cgroup/", dn, "/", path, "/", suffix);
if (!t)
return -ENOMEM;
else if (isempty(suffix))
t = strappend("/sys/fs/cgroup/", path);
else
- t = strjoin("/sys/fs/cgroup/", path, "/", suffix, NULL);
+ t = strjoin("/sys/fs/cgroup/", path, "/", suffix);
if (!t)
return -ENOMEM;
else if (!path)
t = strdup(suffix);
else
- t = strjoin(path, "/", suffix, NULL);
+ t = strjoin(path, "/", suffix);
if (!t)
return -ENOMEM;
while ((r = cg_read_subgroup(d, &fn)) > 0) {
_cleanup_free_ char *p = NULL;
- p = strjoin(path, "/", fn, NULL);
+ p = strjoin(path, "/", fn);
free(fn);
if (!p)
return -ENOMEM;
if (!dirent_is_file_with_suffix(de, suffix))
continue;
- p = strjoin(dirpath, "/", de->d_name, NULL);
+ p = strjoin(dirpath, "/", de->d_name);
if (!p)
return -ENOMEM;
return -EINVAL;
}
- p = strjoin(key, "=", strempty(value), NULL);
+ p = strjoin(key, "=", strempty(value));
if (!p)
return -ENOMEM;
FILE *f;
if (root)
- p = strjoin(root, *i, "/", path, NULL);
+ p = strjoin(root, *i, "/", path);
else
- p = strjoin(*i, "/", path, NULL);
+ p = strjoin(*i, "/", path);
if (!p)
return -ENOMEM;
/* A relative destination. If so, this is what we'll prefix what's left to do with what
* we just read, and start the loop again, but remain in the current directory. */
- joined = strjoin("/", destination, todo, NULL);
+ joined = strjoin("/", destination, todo);
if (!joined)
return -ENOMEM;
FLAG(MS_I_VERSION),
FLAG(MS_STRICTATIME),
FLAG(MS_LAZYTIME),
- y, NULL);
+ y);
if (!x)
return NULL;
if (!y)
if (path_is_absolute(p) || !prefix)
return strdup(p);
- return strjoin(prefix, "/", p, NULL);
+ return strjoin(prefix, "/", p);
}
int path_make_absolute_cwd(const char *p, char **ret) {
if (!cwd)
return negative_errno();
- c = strjoin(cwd, "/", p, NULL);
+ c = strjoin(cwd, "/", p);
}
if (!c)
return -ENOMEM;
return strjoin(root, endswith(root, "/") ? "" : "/",
path[0] == '/' ? path+1 : path,
rest ? (endswith(path, "/") ? "" : "/") : NULL,
- rest && rest[0] == '/' ? rest+1 : rest,
- NULL);
+ rest && rest[0] == '/' ? rest+1 : rest);
else
return strjoin(path,
rest ? (endswith(path, "/") ? "" : "/") : NULL,
- rest && rest[0] == '/' ? rest+1 : rest,
- NULL);
+ rest && rest[0] == '/' ? rest+1 : rest);
}
int find_binary(const char *name, char **ret) {
if (!path_is_absolute(element))
continue;
- j = strjoin(element, "/", name, NULL);
+ j = strjoin(element, "/", name);
if (!j)
return -ENOMEM;
return h;
if (max_length == 0)
- r = strjoin("[", t, "]", NULL);
+ r = strjoin("[", t, "]");
else {
size_t l;
l = strlen(t);
if (l + 3 <= max_length)
- r = strjoin("[", t, "]", NULL);
+ r = strjoin("[", t, "]");
else if (max_length <= 6) {
r = new(char, max_length);
e--;
*e = 0;
- r = strjoin("[", t, "...]", NULL);
+ r = strjoin("[", t, "...]");
}
}
if (!r)
return strnappend(s, suffix, suffix ? strlen(suffix) : 0);
}
-char *strjoin(const char *x, ...) {
+char *strjoin_real(const char *x, ...) {
va_list ap;
size_t l;
char *r, *p;
char *strappend(const char *s, const char *suffix);
char *strnappend(const char *s, const char *suffix, size_t length);
-char *strjoin(const char *x, ...) _sentinel_;
+char *strjoin_real(const char *x, ...) _sentinel_;
+#define strjoin(a, ...) strjoin_real((a), __VA_ARGS__, NULL)
#define strjoina(a, ...) \
({ \
if (!instance)
s = strappend(prefix, suffix);
else
- s = strjoin(prefix, "@", instance, suffix, NULL);
+ s = strjoin(prefix, "@", instance, suffix);
if (!s)
return -ENOMEM;
if (r < 0)
return r;
- s = strjoin(prefix, "@", p, suffix, NULL);
+ s = strjoin(prefix, "@", p, suffix);
if (!s)
return -ENOMEM;
if (r < 0)
return log_oom();
- path = strjoin(*directory, "/", de->d_name, NULL);
+ path = strjoin(*directory, "/", de->d_name);
if (!path)
return log_oom();
controller = c ?: SYSTEMD_CGROUP_CONTROLLER;
if (p) {
- j = strjoin(root, "/", p, NULL);
+ j = strjoin(root, "/", p);
if (!j) {
r = log_oom();
goto finish;
if (r == 0)
break;
- p = strjoin(path, "/", fn, NULL);
+ p = strjoin(path, "/", fn);
if (!p)
return -ENOMEM;
return NULL;
if (slice)
- return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
+ return strjoin(u->manager->cgroup_root, "/", slice, "/",
+ escaped);
else
- return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
+ return strjoin(u->manager->cgroup_root, "/", escaped);
}
int unit_set_cgroup_path(Unit *u, const char *path) {
while ((r = cg_read_subgroup(d, &fn)) > 0) {
_cleanup_free_ char *p = NULL;
- p = strjoin(path, "/", fn, NULL);
+ p = strjoin(path, "/", fn);
free(fn);
if (!p)
if (mode != UNIT_CHECK) {
char *buf = NULL;
- buf = strjoin(b ? "-" : "", path, NULL);
+ buf = strjoin(b ? "-" : "", path);
if (!buf)
return -ENOMEM;
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s invalid", smode);
if (reload_if_possible)
- verb = strjoin("reload-or-", job_type_to_string(job_type), NULL);
+ verb = strjoin("reload-or-", job_type_to_string(job_type));
else
verb = strdup(job_type_to_string(job_type));
if (!verb)
if (r == 0)
break;
- j = strjoin(p, "/", g, NULL);
+ j = strjoin(p, "/", g);
if (!j)
return -ENOMEM;
if (r < 0)
return r;
- label = strjoin(name, "-", other, NULL);
+ label = strjoin(name, "-", other);
if (!label)
return -ENOMEM;
if (label) {
_cleanup_free_ char *j;
- j = strjoin(model, " ", label, NULL);
+ j = strjoin(model, " ", label);
if (j)
r = unit_set_description(u, j);
else
if (!joined)
return -ENOMEM;
- x = strjoin("LISTEN_FDNAMES=", joined, NULL);
+ x = strjoin("LISTEN_FDNAMES=", joined);
if (!x)
return -ENOMEM;
our_env[n_env++] = x;
v = getenv(*i);
if (!v)
continue;
- x = strjoin(*i, "=", v, NULL);
+ x = strjoin(*i, "=", v);
if (!x)
return -ENOMEM;
if (!GREEDY_REALLOC(pass_env, n_bufsize, n_env + 2))
STRV_FOREACH(rt, context->runtime_directory) {
_cleanup_free_ char *p;
- p = strjoin(params->runtime_prefix, "/", *rt, NULL);
+ p = strjoin(params->runtime_prefix, "/", *rt);
if (!p)
return -ENOMEM;
STRV_FOREACH(rt, context->runtime_directory) {
char *s;
- s = strjoin(params->runtime_prefix, "/", *rt, NULL);
+ s = strjoin(params->runtime_prefix, "/", *rt);
if (!s)
return -ENOMEM;
STRV_FOREACH(i, c->runtime_directory) {
_cleanup_free_ char *p;
- p = strjoin(runtime_prefix, "/", *i, NULL);
+ p = strjoin(runtime_prefix, "/", *i);
if (!p)
return -ENOMEM;
if (!variables[i])
continue;
- s = strjoin(locale_variable_to_string(i), "=", variables[i], NULL);
+ s = strjoin(locale_variable_to_string(i), "=", variables[i]);
if (!s) {
r = -ENOMEM;
goto finish;
FOREACH_DIRENT(de, d, r = -errno; goto fail) {
char *p;
- p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name, NULL);
+ p = strjoin(streq(*i, "/") ? "" : *i, "/", de->d_name);
if (!p) {
r = -ENOMEM;
goto fail;
if (r < 0)
return r;
- x = strjoin(prefix, "/systemd-private-", sd_id128_to_string(boot_id, bid), "-", id, "-XXXXXX", NULL);
+ x = strjoin(prefix, "/systemd-private-", sd_id128_to_string(boot_id, bid), "-", id, "-XXXXXX");
if (!x)
return -ENOMEM;
if (UNIT(s)->description) {
_cleanup_free_ char *a;
- a = strjoin(UNIT(s)->description, " (", peer, ")", NULL);
+ a = strjoin(UNIT(s)->description, " (", peer, ")");
if (!a)
return -ENOMEM;
e = getenv("XDG_DATA_HOME");
if (e)
- t->stamp_path = strjoin(e, "/systemd/timers/stamp-", UNIT(t)->id, NULL);
+ t->stamp_path = strjoin(e, "/systemd/timers/stamp-", UNIT(t)->id);
else {
_cleanup_free_ char *h = NULL;
if (r < 0)
return log_unit_error_errno(UNIT(t), r, "Failed to determine home directory: %m");
- t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id, NULL);
+ t->stamp_path = strjoin(h, "/.local/share/systemd/timers/stamp-", UNIT(t)->id);
}
}
return -ENOMEM;
if (MANAGER_IS_SYSTEM(u->manager))
- b = strjoin("system-", escaped, ".slice", NULL);
+ b = strjoin("system-", escaped, ".slice");
else
b = strappend(escaped, ".slice");
if (!b)
if (!UNIT_VTABLE(u)->can_transient)
return -EOPNOTSUPP;
- path = strjoin(u->manager->lookup_paths.transient, "/", u->id, NULL);
+ path = strjoin(u->manager->lookup_paths.transient, "/", u->id);
if (!path)
return -ENOMEM;
r = coredump_make_stack_trace(coredump_fd, context[CONTEXT_EXE], &stacktrace);
if (r >= 0)
- core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID], " (", context[CONTEXT_COMM], ") of user ", context[CONTEXT_UID], " dumped core.\n\n", stacktrace, NULL);
+ core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID],
+ " (", context[CONTEXT_COMM], ") of user ",
+ context[CONTEXT_UID], " dumped core.\n\n",
+ stacktrace);
else if (r == -EINVAL)
log_warning("Failed to generate stack trace: %s", dwfl_errmsg(dwfl_errno()));
else
if (!core_message)
#endif
log:
- core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID], " (", context[CONTEXT_COMM], ") of user ", context[CONTEXT_UID], " dumped core.", NULL);
+ core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID], " (",
+ context[CONTEXT_COMM], ") of user ",
+ context[CONTEXT_UID], " dumped core.");
if (core_message)
IOVEC_SET_STRING(iovec[n_iovec++], core_message);
else
prefix = "COREDUMP_COMM=";
- pattern = strjoin(prefix, match, NULL);
+ pattern = strjoin(prefix, match);
if (!pattern) {
r = -ENOMEM;
goto fail;
if (r < 0)
return log_error_errno(r, "Failed to acquire temporary directory path: %m");
- temp = strjoin(vt, "/coredump-XXXXXX", NULL);
+ temp = strjoin(vt, "/coredump-XXXXXX");
if (!temp)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- p = strjoin(arg_dest, "/", n, NULL);
+ p = strjoin(arg_dest, "/", n);
if (!p)
return log_oom();
if (!noauto) {
- to = strjoin(arg_dest, "/", d, ".wants/", n, NULL);
+ to = strjoin(arg_dest, "/", d, ".wants/", n);
if (!to)
return log_oom();
free(to);
if (!nofail)
- to = strjoin(arg_dest, "/cryptsetup.target.requires/", n, NULL);
+ to = strjoin(arg_dest, "/cryptsetup.target.requires/", n);
else
- to = strjoin(arg_dest, "/cryptsetup.target.wants/", n, NULL);
+ to = strjoin(arg_dest, "/cryptsetup.target.wants/", n);
if (!to)
return log_oom();
}
free(to);
- to = strjoin(arg_dest, "/dev-mapper-", e, ".device.requires/", n, NULL);
+ to = strjoin(arg_dest, "/dev-mapper-", e, ".device.requires/", n);
if (!to)
return log_oom();
if (!noauto && !nofail) {
_cleanup_free_ char *dmname;
- dmname = strjoin("dev-mapper-", e, ".device", NULL);
+ dmname = strjoin("dev-mapper-", e, ".device");
if (!dmname)
return log_oom();
STRV_FOREACH(u, arg_mask) {
_cleanup_free_ char *p = NULL;
- p = strjoin(arg_dest, "/", *u, NULL);
+ p = strjoin(arg_dest, "/", *u);
if (!p)
return log_oom();
STRV_FOREACH(u, arg_wants) {
_cleanup_free_ char *p = NULL, *f = NULL;
- p = strjoin(arg_dest, "/", arg_default_unit, ".wants/", *u, NULL);
+ p = strjoin(arg_dest, "/", arg_default_unit, ".wants/", *u);
if (!p)
return log_oom();
assert(!endswith(drop, "/"));
- path = strjoin(toppath, "/", drop, NULL);
+ path = strjoin(toppath, "/", drop);
if (!path)
return -ENOMEM;
if (!endswith(*file, ".conf"))
continue;
- p = strjoin(path, "/", *file, NULL);
+ p = strjoin(path, "/", *file);
if (!p)
return -ENOMEM;
d = p + strlen(toppath) + 1;
if (!dirent_is_file(de))
continue;
- p = strjoin(path, "/", de->d_name, NULL);
+ p = strjoin(path, "/", de->d_name);
if (!p)
return -ENOMEM;
NULSTR_FOREACH(p, prefixes) {
_cleanup_free_ char *t = NULL;
- t = strjoin(p, "/", suffix, NULL);
+ t = strjoin(p, "/", suffix);
if (!t) {
r = -ENOMEM;
goto finish;
} else if (arg_suffix) {
char *x;
- x = strjoin(e, ".", arg_suffix, NULL);
+ x = strjoin(e, ".", arg_suffix);
if (!x) {
r = log_oom();
goto finish;
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- unit = strjoin(arg_dest, "/", name, NULL);
+ unit = strjoin(arg_dest, "/", name);
if (!unit)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- unit = strjoin(arg_dest, "/", name, NULL);
+ unit = strjoin(arg_dest, "/", name);
if (!unit)
return log_oom();
return log_error_errno(r, "Failed to write unit file %s: %m", unit);
if (!noauto && !automount) {
- lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", name, NULL);
+ lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", name);
if (!lnk)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
+ automount_unit = strjoin(arg_dest, "/", automount_name);
if (!automount_unit)
return log_oom();
return log_error_errno(r, "Failed to write unit file %s: %m", automount_unit);
free(lnk);
- lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
+ lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name);
if (!lnk)
return log_oom();
char *o;
o = arg_root_options ?
- strjoin(arg_root_options, ",", value, NULL) :
+ strjoin(arg_root_options, ",", value) :
strdup(value);
if (!o)
return log_oom();
char *o;
o = arg_usr_options ?
- strjoin(arg_usr_options, ",", value, NULL) :
+ strjoin(arg_usr_options, ",", value) :
strdup(value);
if (!o)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- p = strjoin(arg_dest, "/", n, NULL);
+ p = strjoin(arg_dest, "/", n);
if (!p)
return log_oom();
from = strjoina("../", n);
- to = strjoin(arg_dest, "/", d, ".wants/", n, NULL);
+ to = strjoin(arg_dest, "/", d, ".wants/", n);
if (!to)
return log_oom();
return log_error_errno(errno, "Failed to create symlink %s: %m", to);
free(to);
- to = strjoin(arg_dest, "/cryptsetup.target.requires/", n, NULL);
+ to = strjoin(arg_dest, "/cryptsetup.target.requires/", n);
if (!to)
return log_oom();
return log_error_errno(errno, "Failed to create symlink %s: %m", to);
free(to);
- to = strjoin(arg_dest, "/dev-mapper-", e, ".device.requires/", n, NULL);
+ to = strjoin(arg_dest, "/dev-mapper-", e, ".device.requires/", n);
if (!to)
return log_oom();
return log_error_errno(errno, "Failed to create symlink %s: %m", to);
free(p);
- p = strjoin(arg_dest, "/dev-mapper-", e, ".device.d/50-job-timeout-sec-0.conf", NULL);
+ p = strjoin(arg_dest, "/dev-mapper-", e, ".device.d/50-job-timeout-sec-0.conf");
if (!p)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- p = strjoin(arg_dest, "/", unit, NULL);
+ p = strjoin(arg_dest, "/", unit);
if (!p)
return log_oom();
return log_error_errno(r, "Failed to write unit file %s: %m", p);
if (post) {
- lnk = strjoin(arg_dest, "/", post, ".requires/", unit, NULL);
+ lnk = strjoin(arg_dest, "/", post, ".requires/", unit);
if (!lnk)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- unit = strjoin(arg_dest, "/", name, NULL);
+ unit = strjoin(arg_dest, "/", name);
if (!unit)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to write unit file %s: %m", unit);
- lnk = strjoin(arg_dest, "/" SPECIAL_SWAP_TARGET ".wants/", name, NULL);
+ lnk = strjoin(arg_dest, "/" SPECIAL_SWAP_TARGET ".wants/", name);
if (!lnk)
return log_oom();
assert(description);
if (options)
- opt = strjoin(options, ",noauto", NULL);
+ opt = strjoin(options, ",noauto");
else
opt = strdup("noauto");
if (!opt)
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- p = strjoin(arg_dest, "/", unit, NULL);
+ p = strjoin(arg_dest, "/", unit);
if (!p)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to write unit file %s: %m", p);
- lnk = strjoin(arg_dest, "/" SPECIAL_LOCAL_FS_TARGET ".wants/", unit, NULL);
+ lnk = strjoin(arg_dest, "/" SPECIAL_LOCAL_FS_TARGET ".wants/", unit);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (r < 0)
return log_error_errno(r, "Failed to generate unit name: %m");
- lnk = strjoin(arg_dest, "/" SPECIAL_SYSINIT_TARGET ".wants/", name, NULL);
+ lnk = strjoin(arg_dest, "/" SPECIAL_SYSINIT_TARGET ".wants/", name);
if (!lnk)
return log_oom();
continue;
}
- t = strjoin(name[p], "=", c->data[p], NULL);
+ t = strjoin(name[p], "=", c->data[p]);
if (!t)
return -ENOMEM;
log_debug("strings dedup'ed: %8zu bytes (%8zu)",
trie->strings->dedup_len, trie->strings->dedup_count);
- hwdb_bin = strjoin(arg_root, "/", arg_hwdb_bin_dir, "/hwdb.bin", NULL);
+ hwdb_bin = strjoin(arg_root, "/", arg_hwdb_bin_dir, "/hwdb.bin");
if (!hwdb_bin)
return -ENOMEM;
assert(!i->temp_path);
assert(i->output_fd < 0);
- i->final_path = strjoin(i->image_root, "/", i->local, ".raw", NULL);
+ i->final_path = strjoin(i->image_root, "/", i->local, ".raw");
if (!i->final_path)
return log_oom();
assert(!i->temp_path);
assert(i->tar_fd < 0);
- i->final_path = strjoin(i->image_root, "/", i->local, NULL);
+ i->final_path = strjoin(i->image_root, "/", i->local);
if (!i->final_path)
return log_oom();
return MHD_YES;
}
- p = strjoin(key, "=", strempty(value), NULL);
+ p = strjoin(key, "=", strempty(value));
if (!p) {
m->argument_parse_error = log_oom();
return MHD_NO;
}
if (strchr(host, ':'))
- u->url = strjoin(proto, url, "/upload", NULL);
+ u->url = strjoin(proto, url, "/upload");
else {
char *t;
size_t x;
while (x > 0 && t[x - 1] == '/')
t[x - 1] = '\0';
- u->url = strjoin(proto, t, ":" STRINGIFY(DEFAULT_PORT), "/upload", NULL);
+ u->url = strjoin(proto, t, ":" STRINGIFY(DEFAULT_PORT), "/upload");
}
if (!u->url)
return log_oom();
continue;
}
- match = strjoin("_KERNEL_DEVICE=+", subsys, ":", sysname, NULL);
+ match = strjoin("_KERNEL_DEVICE=+", subsys, ":", sysname);
if (!match)
return log_oom();
if (!escaped)
return -ENOMEM;
- p = strjoin(cgroup_root, "/", slice_path, "/", escaped, NULL);
+ p = strjoin(cgroup_root, "/", slice_path, "/", escaped);
if (!p)
return -ENOMEM;
s->runtime_storage.name = "Runtime journal";
s->system_storage.name = "System journal";
- s->runtime_storage.path = strjoin("/run/log/journal/", SERVER_MACHINE_ID(s), NULL);
- s->system_storage.path = strjoin("/var/log/journal/", SERVER_MACHINE_ID(s), NULL);
+ s->runtime_storage.path = strjoin("/run/log/journal/", SERVER_MACHINE_ID(s));
+ s->system_storage.path = strjoin("/var/log/journal/", SERVER_MACHINE_ID(s));
if (!s->runtime_storage.path || !s->system_storage.path)
return -ENOMEM;
} else if (identifier) {
- l = l_buf = strjoin(identifier, ": ", message, NULL);
+ l = l_buf = strjoin(identifier, ": ", message);
if (!l_buf) {
log_oom();
return;
return mfree(p);
if (p) {
- k = strjoin(p, m->type == MATCH_OR_TERM ? " OR " : " AND ", t, NULL);
+ k = strjoin(p, m->type == MATCH_OR_TERM ? " OR " : " AND ", t);
free(p);
free(t);
}
if (enclose) {
- r = strjoin("(", p, ")", NULL);
+ r = strjoin("(", p, ")");
free(p);
return r;
}
* and reenumerates directory contents */
if (dirname)
- path = strjoin(prefix, "/", dirname, NULL);
+ path = strjoin(prefix, "/", dirname);
else
path = strdup(prefix);
if (!path) {
if (s) {
char *p;
- p = strjoin("/sys/fs/kdbus/", n->str, "/bus", NULL);
+ p = strjoin("/sys/fs/kdbus/", n->str, "/bus");
if (!p) {
safe_close(fd);
return -ENOMEM;
if (endswith(prefix, "/"))
node_path = strappend(prefix, name);
else
- node_path = strjoin(prefix, "/", name, NULL);
+ node_path = strjoin(prefix, "/", name);
if (!node_path)
return log_oom();
}
return -EINVAL;
}
- m = strjoin("sender='", *i, "'", NULL);
+ m = strjoin("sender='", *i, "'");
if (!m)
return log_oom();
return bus_log_create_error(r);
free(m);
- m = strjoin("destination='", *i, "'", NULL);
+ m = strjoin("destination='", *i, "'");
if (!m)
return log_oom();
return -ENOMEM;
}
- b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL);
+ b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c);
if (!b->address)
return -ENOMEM;
if (!e)
return -ENOMEM;
- b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);
+ b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e);
if (!b->address)
return -ENOMEM;
if (!e)
return -ENOMEM;
- ret = strjoin(prefix, "/", e, NULL);
+ ret = strjoin(prefix, "/", e);
if (!ret)
return -ENOMEM;
r = sd_bus_message_read(m, "s", &s);
assert_se(r > 0);
- n = strjoin("<<<", s, ">>>", NULL);
+ n = strjoin("<<<", s, ">>>");
assert_se(n);
free(c->something);
if (dent->d_type != DT_DIR)
continue;
- child = strjoin(path, "/", dent->d_name, NULL);
+ child = strjoin(path, "/", dent->d_name);
if (!child)
return -ENOMEM;
if (endswith(h, "/"))
cc = strappend(h, suffix);
else
- cc = strjoin(h, "/", suffix, NULL);
+ cc = strjoin(h, "/", suffix);
if (!cc)
return -ENOMEM;
if (endswith(ret, "/"))
cc = strappend(ret, suffix);
else
- cc = strjoin(ret, "/", suffix, NULL);
+ cc = strjoin(ret, "/", suffix);
free(buffer);
if (endswith(e, "/"))
h = strappend(e, home_suffix);
else
- h = strjoin(e, "/", home_suffix, NULL);
+ h = strjoin(e, "/", home_suffix);
if (!h) {
strv_free(l);
if (endswith(*i, "/"))
*j = strappend(*i, suffix);
else
- *j = strjoin(*i, "/", suffix, NULL);
+ *j = strjoin(*i, "/", suffix);
if (!*j) {
strv_free(l);
_cleanup_free_ char *n;
if (x11_variant)
- n = strjoin(x11_layout, "-", x11_variant, NULL);
+ n = strjoin(x11_layout, "-", x11_variant);
else
n = strdup(x11_layout);
if (!n)
_cleanup_free_ char *p = NULL, *pz = NULL;
bool uncompressed;
- p = strjoin(dir, "xkb/", n, ".map", NULL);
- pz = strjoin(dir, "xkb/", n, ".map.gz", NULL);
+ p = strjoin(dir, "xkb/", n, ".map");
+ pz = strjoin(dir, "xkb/", n, ".map.gz");
if (!p || !pz)
return -ENOMEM;
if (r < 0)
return r;
- i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref", NULL);
+ i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref");
if (!i->fifo_path)
return -ENOMEM;
char *scope, *job = NULL;
const char *description;
- scope = strjoin("session-", s->id, ".scope", NULL);
+ scope = strjoin("session-", s->id, ".scope");
if (!scope)
return log_oom();
* daemons that spawn dbus-daemon, instead of forcing
* DBUS_SESSION_BUS_ADDRESS= here. */
- s = strjoin(runtime, "/bus", NULL);
+ s = strjoin(runtime, "/bus");
if (!s)
goto error;
if (!escaped)
return log_oom();
- scope = strjoin("machine-", escaped, ".scope", NULL);
+ scope = strjoin("machine-", escaped, ".scope");
if (!scope)
return log_oom();
if (!filename_is_valid(escaped))
return 0;
- arg_mount_where = strjoin("/run/media/system/", escaped, NULL);
+ arg_mount_where = strjoin("/run/media/system/", escaped);
} else
arg_mount_where = strdup(v);
label = udev_device_get_property_value(d, "ID_PART_ENTRY_NUMBER");
if (model && label)
- arg_description = strjoin(model, " ", label, NULL);
+ arg_description = strjoin(model, " ", label);
else if (label)
arg_description = strdup(label);
else if (model)
char *t;
if (options)
- t = strjoin(options, ",context=\"", selinux_apifs_context, "\"", NULL);
+ t = strjoin(options, ",context=\"", selinux_apifs_context, "\"");
else
- t = strjoin("context=\"", selinux_apifs_context, "\"", NULL);
+ t = strjoin("context=\"", selinux_apifs_context, "\"");
if (!t) {
free(buf);
return -ENOMEM;
* search for a machine, but instead create a new one
* in /var/lib/machine. */
- arg_directory = strjoin("/var/lib/machines/", arg_machine, NULL);
+ arg_directory = strjoin("/var/lib/machines/", arg_machine);
if (!arg_directory)
return log_oom();
}
FOREACH_STRING(i, "/etc/systemd/nspawn", "/run/systemd/nspawn") {
_cleanup_free_ char *j = NULL;
- j = strjoin(i, "/", fn, NULL);
+ j = strjoin(i, "/", fn);
if (!j)
return log_oom();
assert(service);
assert(where);
- from = strjoin(SYSTEM_DATA_UNIT_PATH, "/", service, NULL);
+ from = strjoin(SYSTEM_DATA_UNIT_PATH, "/", service);
if (!from)
return log_oom();
- to = strjoin(arg_dest, "/", where, ".wants/", service, NULL);
+ to = strjoin(arg_dest, "/", where, ".wants/", service);
if (!to)
return log_oom();
if (!l)
return -ENOMEM;
- j = strjoin(l, ".", zone, NULL);
+ j = strjoin(l, ".", zone);
if (!j)
return -ENOMEM;
if (!str)
return NULL;
- return strjoin("( ", str, " )", NULL);
+ return strjoin("( ", str, " )");
}
static char *format_txt(DnsTxtItem *first) {
case DNS_TYPE_NS:
case DNS_TYPE_CNAME:
case DNS_TYPE_DNAME:
- s = strjoin(k, " ", rr->ptr.name, NULL);
+ s = strjoin(k, " ", rr->ptr.name);
if (!s)
return NULL;
break;
case DNS_TYPE_HINFO:
- s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os, NULL);
+ s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os);
if (!s)
return NULL;
break;
if (!t)
return NULL;
- s = strjoin(k, " ", t, NULL);
+ s = strjoin(k, " ", t);
if (!s)
return NULL;
break;
if (r < 0)
return NULL;
- s = strjoin(k, " ", x, NULL);
+ s = strjoin(k, " ", x);
if (!s)
return NULL;
break;
if (r < 0)
return NULL;
- s = strjoin(k, " ", t, NULL);
+ s = strjoin(k, " ", t);
if (!s)
return NULL;
break;
if (!t)
return NULL;
- s = strjoin(k, " ", t, NULL);
+ s = strjoin(k, " ", t);
if (!s)
return NULL;
break;
char *x;
assert_se(asprintf(&b, "x%" PRIu64 "x", random_u64()));
- x = strjoin(b, ".", name, NULL);
+ x = strjoin(b, ".", name);
assert_se(x);
free(m);
if (!escaped_path_id)
return log_oom();
- state_file = strjoin("/var/lib/systemd/rfkill/", escaped_path_id, ":", type, NULL);
+ state_file = strjoin("/var/lib/systemd/rfkill/", escaped_path_id, ":", type);
} else
- state_file = strjoin("/var/lib/systemd/rfkill/", type, NULL);
+ state_file = strjoin("/var/lib/systemd/rfkill/", type);
if (!state_file)
return log_oom();
return -EINVAL;
}
- p = strjoin("run-u", id, ".", unit_type_to_string(t), NULL);
+ p = strjoin("run-u", id, ".", unit_type_to_string(t));
if (!p)
return log_oom();
if (table[i].exists) {
_cleanup_free_ char *p = NULL;
- p = strjoin(s, "/", table[i].exists, NULL);
+ p = strjoin(s, "/", table[i].exists);
if (!p)
return log_oom();
if (r < 0)
return r;
- bus->address = strjoin("unix:path=", ee, "/systemd/private", NULL);
+ bus->address = strjoin("unix:path=", ee, "/systemd/private");
if (!bus->address)
return -ENOMEM;
if (!external_label)
return -ENOMEM;
- p = strjoin(prefix, "/", sender_label, "/", external_label, NULL);
+ p = strjoin(prefix, "/", sender_label, "/", external_label);
if (!p)
return -ENOMEM;
while ((r = cg_read_subgroup(d, &gn)) > 0) {
_cleanup_free_ char *k = NULL;
- k = strjoin(fn, "/", gn, NULL);
+ k = strjoin(fn, "/", gn);
free(gn);
if (!k)
return -ENOMEM;
else {
char *key;
- key = strjoin(section, ".", lvalue, NULL);
+ key = strjoin(section, ".", lvalue);
if (!key)
return -ENOMEM;
if (!name)
return -ENOMEM;
- type = strjoin(b, ".", c, NULL);
+ type = strjoin(b, ".", c);
if (!type)
return -ENOMEM;
name = NULL;
- type = strjoin(a, ".", b, NULL);
+ type = strjoin(a, ".", b);
if (!type)
return -ENOMEM;
if (!filename_is_valid(b))
return -EINVAL;
- p = strjoin(dir, "/", unit, ".d", NULL);
+ p = strjoin(dir, "/", unit, ".d");
if (!p)
return -ENOMEM;
- q = strjoin(p, "/", prefix, "-", b, ".conf", NULL);
+ q = strjoin(p, "/", prefix, "-", b, ".conf");
if (!q) {
free(p);
return -ENOMEM;
if (hidden_or_backup_file(de->d_name))
continue;
- f = strjoin(path, "/", de->d_name, NULL);
+ f = strjoin(path, "/", de->d_name);
if (!f)
return log_oom();
assert(name);
assert(suffix);
- path = strjoin(unit_path, "/", name, suffix, NULL);
+ path = strjoin(unit_path, "/", name, suffix);
if (!path)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to generate template from unit name: %m");
- p = strjoin(unit_path, "/", template, suffix, NULL);
+ p = strjoin(unit_path, "/", template, suffix);
if (!p)
return log_oom();
if (encode_devnode_name(u, t, enc_len) < 0)
return NULL;
- return strjoin("/dev/disk/by-", by, "/", t, NULL);
+ return strjoin("/dev/disk/by-", by, "/", t);
}
char *fstab_node_to_udev_node(const char *p) {
if (endswith(prefix, "@") && i->default_instance) {
char *ans;
- ans = strjoin(prefix, i->default_instance, NULL);
+ ans = strjoin(prefix, i->default_instance);
if (!ans)
return -ENOMEM;
*ret = ans;
STRV_FOREACH(p, paths->search_path) {
_cleanup_free_ char *path = NULL;
- path = strjoin(*p, "/", info->name, NULL);
+ path = strjoin(*p, "/", info->name);
if (!path)
return -ENOMEM;
STRV_FOREACH(p, paths->search_path) {
_cleanup_free_ char *path = NULL;
- path = strjoin(*p, "/", template, NULL);
+ path = strjoin(*p, "/", template);
if (!path)
return -ENOMEM;
continue;
}
- path = strjoin(config_path, "/", dst, suffix, n, NULL);
+ path = strjoin(config_path, "/", dst, suffix, n);
if (!path)
return -ENOMEM;
if (r > 0)
return 0;
- path = strjoin(config_path, "/", i->name, NULL);
+ path = strjoin(config_path, "/", i->name);
if (!path)
return -ENOMEM;
STRV_FOREACH(j, fs) {
_cleanup_free_ char *t = NULL;
- t = strjoin(*i, "/", *j, NULL);
+ t = strjoin(*i, "/", *j);
if (!t)
return -ENOMEM;
return -ENOMEM;
if (path)
- i->path = strjoin(path, "/", filename, NULL);
+ i->path = strjoin(path, "/", filename);
else
i->path = strdup(filename);
if (!home)
return -ENXIO;
- j = strjoin(home, "/.config", suffix, NULL);
+ j = strjoin(home, "/.config", suffix);
}
if (!j)
return -ENXIO;
- j = strjoin(home, "/.local/share", suffix, NULL);
+ j = strjoin(home, "/.local/share", suffix);
}
if (!j)
return -ENOMEM;
}
if (u->machine) {
- j = strjoin(u->machine, ":", u->id, NULL);
+ j = strjoin(u->machine, ":", u->id);
if (!j)
return log_oom();
char **a;
if (s->machine) {
- j = strjoin(s->machine, ":", s->path, NULL);
+ j = strjoin(s->machine, ":", s->path);
if (!j)
return log_oom();
path = j;
format_timestamp_relative(trel2, sizeof(trel2), t->last_trigger);
if (t->machine) {
- j = strjoin(t->machine, ":", t->id, NULL);
+ j = strjoin(t->machine, ":", t->id);
if (!j)
return log_oom();
unit = j;
assert(name);
assert(ret_path);
- path = strjoin(paths->persistent_config, "/", name, NULL);
+ path = strjoin(paths->persistent_config, "/", name);
if (!path)
return log_oom();
if (arg_runtime) {
- run = strjoin(paths->runtime_config, "/", name, NULL);
+ run = strjoin(paths->runtime_config, "/", name);
if (!run)
return log_oom();
}
char *d = NULL;
if (chkconfig_description)
- d = strjoin(chkconfig_description, " ", j, NULL);
+ d = strjoin(chkconfig_description, " ", j);
else
d = strdup(j);
if (!d)
char *d = NULL;
if (long_description)
- d = strjoin(long_description, " ", t, NULL);
+ d = strjoin(long_description, " ", t);
else
d = strdup(j);
if (!d)
continue;
}
- fpath = strjoin(*path, "/", de->d_name, NULL);
+ fpath = strjoin(*path, "/", de->d_name);
if (!fpath)
return log_oom();
_cleanup_free_ char *path = NULL;
struct dirent *de;
- path = strjoin(*p, "/", rcnd_table[i].path, NULL);
+ path = strjoin(*p, "/", rcnd_table[i].path);
if (!path) {
r = log_oom();
goto finish;
if (a < 0 || b < 0)
continue;
- fpath = strjoin(*p, "/", de->d_name, NULL);
+ fpath = strjoin(*p, "/", de->d_name);
if (!fpath) {
r = log_oom();
goto finish;
STRV_FOREACH_PAIR(link, p, links) {
_cleanup_free_ char *target = NULL, *f, *l;
- assert_se(f = strjoin(original_dir, *p, NULL));
- assert_se(l = strjoin(copy_dir, *link, NULL));
+ assert_se(f = strjoin(original_dir, *p));
+ assert_se(l = strjoin(copy_dir, *link));
assert_se(readlink_and_canonicalize(l, &target) == 0);
assert_se(path_equal(f, target));
_cleanup_free_ char *with_utc;
log_info("Test: %s", p);
- with_utc = strjoin(p, " UTC", NULL);
+ with_utc = strjoin(p, " UTC");
test_should_pass(p);
test_should_pass(with_utc);
}
_cleanup_free_ char *with_utc;
log_info("Test: %s", p);
- with_utc = strjoin(p, " UTC", NULL);
+ with_utc = strjoin(p, " UTC");
test_should_pass(p);
test_should_fail(with_utc);
}
int r;
assert_se(read_one_line_file("/proc/cmdline", &buf) >= 0);
- assert_se((buf2 = strjoin(buf, "\n", NULL)));
+ assert_se((buf2 = strjoin(buf, "\n")));
r = write_string_file("/proc/cmdline", buf, 0);
assert_se(r == -EACCES || r == -EIO);
assert_se(sd_id128_get_boot(&bid) >= 0);
sd_id128_to_string(bid, boot_id);
- x = strjoin("/tmp/systemd-private-", boot_id, "-abcd.service-", NULL);
- y = strjoin("/var/tmp/systemd-private-", boot_id, "-abcd.service-", NULL);
+ x = strjoin("/tmp/systemd-private-", boot_id, "-abcd.service-");
+ y = strjoin("/var/tmp/systemd-private-", boot_id, "-abcd.service-");
assert_se(x && y);
test_tmpdir("abcd.service", x, y);
- z = strjoin("/tmp/systemd-private-", boot_id, "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-", NULL);
- zz = strjoin("/var/tmp/systemd-private-", boot_id, "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-", NULL);
+ z = strjoin("/tmp/systemd-private-", boot_id, "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-");
+ zz = strjoin("/var/tmp/systemd-private-", boot_id, "-sys-devices-pci0000:00-0000:00:1a.0-usb3-3\\x2d1-3\\x2d1:1.0-bluetooth-hci0.device-");
assert_se(z && zz);
STRV_FOREACH(test_path, tests_path) {
_cleanup_free_ char *p = NULL;
- p = strjoin("/tmp/test-path_", *test_path, NULL);
+ p = strjoin("/tmp/test-path_", *test_path);
assert_se(p);
(void) rm_rf(p, REMOVE_ROOT|REMOVE_PHYSICAL);
#include "util.h"
static char *lookup(const char *variable, void *userdata) {
- return strjoin("<<<", variable, ">>>", NULL);
+ return strjoin("<<<", variable, ">>>");
}
int main(int argc, char *argv[]) {
continue;
}
- sub_path = strjoin(p, "/", dent->d_name, NULL);
+ sub_path = strjoin(p, "/", dent->d_name);
if (!sub_path) {
r = log_oom();
goto finish;
if (STR_IN_SET(de->d_name, ".", ".."))
continue;
- p = strjoin(path, "/", de->d_name, NULL);
+ p = strjoin(path, "/", de->d_name);
if (!p)
return -ENOMEM;
return -ENOENT;
if (prefix) {
- lookup = strjoin(prefix, modalias, NULL);
+ lookup = strjoin(prefix, modalias);
if (!lookup)
return -ENOMEM;
modalias = lookup;
log_debug("strings dedup'ed: %8zu bytes (%8zu)",
trie->strings->dedup_len, trie->strings->dedup_count);
- hwdb_bin = strjoin(root, "/", hwdb_bin_dir, "/hwdb.bin", NULL);
+ hwdb_bin = strjoin(root, "/", hwdb_bin_dir, "/hwdb.bin");
if (!hwdb_bin) {
rc = EXIT_FAILURE;
goto out;