14895667988

Committed 07 May 2025 08:57PM UTC coverage: 72.225% (-0.007%) from 72.232%

Build # 14895667988

Build Type

push

github

Committed by

yuwata

Commit Message

network: log_link_message_debug_errno() automatically append %m if necessary

Follow-up for d28746ef5.
Fixes CID#1609753.

Coverage Stats

0 of 1 new or added line in 1 file covered. (0.0%)

20297 existing lines in 338 files now uncovered.

297407 of 411780 relevant lines covered (72.22%)

695716.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.68

/src/systemctl/systemctl-set-environment.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "alloc-util.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "env-util.h"
#include "escape.h"
#include "systemctl.h"
#include "systemctl-set-environment.h"
#include "systemctl-util.h"

static int json_transform_message(sd_bus_message *m, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        const char *text;
        int r;

        assert(m);
        assert(ret);

        while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &text)) > 0) {
                _cleanup_free_ char *n = NULL;
                const char *sep;

                sep = strchr(text, '=');
                if (!sep)
                        return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN),
                                               "Invalid environment block");

                n = strndup(text, sep - text);
                if (!n)
                        return log_oom();

                sep++;

                r = sd_json_variant_set_field_string(&v, n, sep);
                if (r < 0)
                        return log_error_errno(r, "Failed to set JSON field '%s' to '%s': %m", n, sep);
        }
        if (r < 0)
                return bus_log_parse_error(r);

        *ret = TAKE_PTR(v);
        return 0;
}

static int print_variable(const char *s) {
        const char *sep;
        _cleanup_free_ char *esc = NULL;

        sep = strchr(s, '=');
        if (!sep)
                return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN),
                                       "Invalid environment block");

        esc = shell_maybe_quote(sep + 1, SHELL_ESCAPE_POSIX);
        if (!esc)
                return log_oom();

        printf("%.*s=%s\n", (int)(sep-s), s, esc);
        return 0;
}

int verb_show_environment(int argc, char *argv[], void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        const char *text;
        sd_bus *bus;
        int r;

        r = acquire_bus(BUS_MANAGER, &bus);
        if (r < 0)
                return r;

        pager_open(arg_pager_flags);

        r = bus_get_property(bus, bus_systemd_mgr, "Environment", &error, &reply, "as");
        if (r < 0)
                return log_error_errno(r, "Failed to get environment: %s", bus_error_message(&error, r));

        r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "s");
        if (r < 0)
                return bus_log_parse_error(r);

        if (OUTPUT_MODE_IS_JSON(arg_output)) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;

                r = json_transform_message(reply, &v);
                if (r < 0)
                        return r;

                sd_json_variant_dump(v, output_mode_to_json_format_flags(arg_output), stdout, NULL);
        } else {
                while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0) {
                        r = print_variable(text);
                        if (r < 0)
                                return r;
                }
                if (r < 0)
                        return bus_log_parse_error(r);
        }

        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                return bus_log_parse_error(r);

        return 0;
}

static void invalid_callback(const char *p, void *userdata) {
        _cleanup_free_ char *t = cescape(p);

        log_debug("Ignoring invalid environment assignment \"%s\".", strnull(t));
}

int verb_set_environment(int argc, char *argv[], void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        const char *method;
        sd_bus *bus;
        int r;

        assert(argc > 1);
        assert(argv);

        r = acquire_bus(BUS_MANAGER, &bus);
        if (r < 0)
                return r;

        polkit_agent_open_maybe();

        method = streq(argv[0], "set-environment")
                ? "SetEnvironment"
                : "UnsetEnvironment";

        r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, method);
        if (r < 0)
                return bus_log_create_error(r);

        r = sd_bus_message_append_strv(m, strv_skip(argv, 1));
        if (r < 0)
                return bus_log_create_error(r);

        r = sd_bus_call(bus, m, 0, &error, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to set environment: %s", bus_error_message(&error, r));

        return 0;
}

int verb_import_environment(int argc, char *argv[], void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        sd_bus *bus;
        int r;

        r = acquire_bus(BUS_MANAGER, &bus);
        if (r < 0)
                return r;

        polkit_agent_open_maybe();

        r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "SetEnvironment");
        if (r < 0)
                return bus_log_create_error(r);

        if (argc < 2) {
                log_warning("Calling import-environment without a list of variable names is deprecated.");

                _cleanup_strv_free_ char **copy = strv_copy(environ);
                if (!copy)
                        return log_oom();

                strv_env_clean_with_callback(copy, invalid_callback, NULL);

                STRV_FOREACH(e, copy)
                        if (string_has_cc(*e, NULL))
                                log_notice("Environment variable $%.*s contains control characters, importing anyway.",
                                           (int) strcspn(*e, "="), *e);

                r = sd_bus_message_append_strv(m, copy);

        } else {
                r = sd_bus_message_open_container(m, 'a', "s");
                if (r < 0)
                        return bus_log_create_error(r);

                STRV_FOREACH(a, strv_skip(argv, 1)) {

                        if (!env_name_is_valid(*a))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Not a valid environment variable name: %s", *a);

                        bool found = false;
                        STRV_FOREACH(b, environ) {
                                const char *eq;

                                eq = startswith(*b, *a);
                                if (eq && *eq == '=') {
                                        if (string_has_cc(eq + 1, NULL))
                                                log_notice("Environment variable $%.*s contains control characters, importing anyway.",
                                                           (int) (eq - *b), *b);

                                        r = sd_bus_message_append(m, "s", *b);
                                        if (r < 0)
                                                return bus_log_create_error(r);

                                        found = true;
                                        break;
                                }
                        }

                        if (!found)
                                log_notice("Environment variable $%s not set, ignoring.", *a);
                }

                r = sd_bus_message_close_container(m);
        }
        if (r < 0)
                return bus_log_create_error(r);

        r = sd_bus_call(bus, m, 0, &error, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to import environment: %s", bus_error_message(&error, r));

        return 0;
}

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include "alloc-util.h"
4	#include "bus-error.h"
5	#include "bus-locator.h"
6	#include "env-util.h"
7	#include "escape.h"
8	#include "systemctl.h"
9	#include "systemctl-set-environment.h"
10	#include "systemctl-util.h"
11
12	static int json_transform_message(sd_bus_message m, sd_json_variant *ret) {	1✔
13	_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;	1✔
14	const char *text;	1✔
15	int r;	1✔
16
17	assert(m);	1✔
18	assert(ret);	1✔
19
20	while ((r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &text)) > 0) {	5✔
21	_cleanup_free_ char *n = NULL;	4✔
22	const char *sep;	4✔
23
24	sep = strchr(text, '=');	4✔
25	if (!sep)	4✔
UNCOV 26	return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN),	×
27	"Invalid environment block");
28
29	n = strndup(text, sep - text);	4✔
30	if (!n)	4✔
UNCOV 31	return log_oom();	×
32
33	sep++;	4✔
34
35	r = sd_json_variant_set_field_string(&v, n, sep);	4✔
36	if (r < 0)	4✔
UNCOV 37	return log_error_errno(r, "Failed to set JSON field '%s' to '%s': %m", n, sep);	×
38	}
39	if (r < 0)	1✔
UNCOV 40	return bus_log_parse_error(r);	×
41
42	*ret = TAKE_PTR(v);	1✔
43	return 0;	1✔
44	}
45
46	static int print_variable(const char *s) {	115✔
47	const char *sep;	115✔
48	_cleanup_free_ char *esc = NULL;	115✔
49
50	sep = strchr(s, '=');	115✔
51	if (!sep)	115✔
UNCOV 52	return log_error_errno(SYNTHETIC_ERRNO(EUCLEAN),	×
53	"Invalid environment block");
54
55	esc = shell_maybe_quote(sep + 1, SHELL_ESCAPE_POSIX);	115✔
56	if (!esc)	115✔
UNCOV 57	return log_oom();	×
58
59	printf("%.*s=%s\n", (int)(sep-s), s, esc);	115✔
60	return 0;
61	}
62
63	int verb_show_environment(int argc, char argv[], void userdata) {	26✔
UNCOV 64	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;	×
65	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;	26✔
66	const char *text;	26✔
67	sd_bus *bus;	26✔
68	int r;	26✔
69
70	r = acquire_bus(BUS_MANAGER, &bus);	26✔
71	if (r < 0)	26✔
72	return r;
73
74	pager_open(arg_pager_flags);	26✔
75
76	r = bus_get_property(bus, bus_systemd_mgr, "Environment", &error, &reply, "as");	26✔
77	if (r < 0)	26✔
UNCOV 78	return log_error_errno(r, "Failed to get environment: %s", bus_error_message(&error, r));	×
79
80	r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "s");	26✔
81	if (r < 0)	26✔
UNCOV 82	return bus_log_parse_error(r);	×
83
84	if (OUTPUT_MODE_IS_JSON(arg_output)) {	26✔
85	_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;	1✔
86
87	r = json_transform_message(reply, &v);	1✔
88	if (r < 0)	1✔
UNCOV 89	return r;	×
90
91	sd_json_variant_dump(v, output_mode_to_json_format_flags(arg_output), stdout, NULL);	1✔
92	} else {
93	while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0) {	140✔
94	r = print_variable(text);	115✔
95	if (r < 0)	115✔
96	return r;
97	}
98	if (r < 0)	25✔
UNCOV 99	return bus_log_parse_error(r);	×
100	}
101
102	r = sd_bus_message_exit_container(reply);	26✔
103	if (r < 0)	26✔
UNCOV 104	return bus_log_parse_error(r);	×
105
106	return 0;
107	}
108
109	static void invalid_callback(const char p, void userdata) {	×
UNCOV 110	_cleanup_free_ char *t = cescape(p);	×
111
112	log_debug("Ignoring invalid environment assignment \"%s\".", strnull(t));	×
UNCOV 113	}	×
114
115	int verb_set_environment(int argc, char argv[], void userdata) {	177✔
UNCOV 116	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;	×
117	_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;	177✔
118	const char *method;	177✔
119	sd_bus *bus;	177✔
120	int r;	177✔
121
122	assert(argc > 1);	177✔
123	assert(argv);	177✔
124
125	r = acquire_bus(BUS_MANAGER, &bus);	177✔
126	if (r < 0)	177✔
127	return r;
128
129	polkit_agent_open_maybe();	177✔
130
131	method = streq(argv[0], "set-environment")	3✔
132	? "SetEnvironment"
133	: "UnsetEnvironment";	177✔
134
135	r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, method);	177✔
136	if (r < 0)	177✔
UNCOV 137	return bus_log_create_error(r);	×
138
139	r = sd_bus_message_append_strv(m, strv_skip(argv, 1));	177✔
140	if (r < 0)	177✔
UNCOV 141	return bus_log_create_error(r);	×
142
143	r = sd_bus_call(bus, m, 0, &error, NULL);	177✔
144	if (r < 0)	177✔
UNCOV 145	return log_error_errno(r, "Failed to set environment: %s", bus_error_message(&error, r));	×
146
147	return 0;
148	}
149
150	int verb_import_environment(int argc, char argv[], void userdata) {	1✔
UNCOV 151	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;	×
152	_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;	1✔
153	sd_bus *bus;	1✔
154	int r;	1✔
155
156	r = acquire_bus(BUS_MANAGER, &bus);	1✔
157	if (r < 0)	1✔
158	return r;
159
160	polkit_agent_open_maybe();	1✔
161
162	r = bus_message_new_method_call(bus, &m, bus_systemd_mgr, "SetEnvironment");	1✔
163	if (r < 0)	1✔
UNCOV 164	return bus_log_create_error(r);	×
165
166	if (argc < 2) {	1✔
UNCOV 167	log_warning("Calling import-environment without a list of variable names is deprecated.");	×
168
169	_cleanup_strv_free_ char **copy = strv_copy(environ);	×
170	if (!copy)	×
UNCOV 171	return log_oom();	×
172
UNCOV 173	strv_env_clean_with_callback(copy, invalid_callback, NULL);	×
174
175	STRV_FOREACH(e, copy)	×
176	if (string_has_cc(*e, NULL))	×
UNCOV 177	log_notice("Environment variable $%.*s contains control characters, importing anyway.",	×
178	(int) strcspn(e, "="), e);
179
UNCOV 180	r = sd_bus_message_append_strv(m, copy);	×
181
182	} else {
183	r = sd_bus_message_open_container(m, 'a', "s");	1✔
184	if (r < 0)	1✔
UNCOV 185	return bus_log_create_error(r);	×
186
187	STRV_FOREACH(a, strv_skip(argv, 1)) {	3✔
188
189	if (!env_name_is_valid(*a))	2✔
UNCOV 190	return log_error_errno(SYNTHETIC_ERRNO(EINVAL),	×
191	"Not a valid environment variable name: %s", *a);
192
193	bool found = false;	2✔
194	STRV_FOREACH(b, environ) {	10✔
195	const char *eq;	10✔
196
197	eq = startswith(b, a);	10✔
198	if (eq && *eq == '=') {	10✔
199	if (string_has_cc(eq + 1, NULL))	2✔
UNCOV 200	log_notice("Environment variable $%.*s contains control characters, importing anyway.",	×
201	(int) (eq - b), b);
202
203	r = sd_bus_message_append(m, "s", *b);	2✔
204	if (r < 0)	2✔
UNCOV 205	return bus_log_create_error(r);	×
206
207	found = true;
208	break;
209	}
210	}
211
212	if (!found)	×
UNCOV 213	log_notice("Environment variable $%s not set, ignoring.", *a);	×
214	}
215
216	r = sd_bus_message_close_container(m);	1✔
217	}
218	if (r < 0)	1✔
UNCOV 219	return bus_log_create_error(r);	×
220
221	r = sd_bus_call(bus, m, 0, &error, NULL);	1✔
222	if (r < 0)	1✔
UNCOV 223	return log_error_errno(r, "Failed to import environment: %s", bus_error_message(&error, r));	×
224
225	return 0;
226	}

systemd / systemd / 14895667988

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous