14583755890

Committed 21 Apr 2025 11:58PM UTC coverage: 72.043% (-0.06%) from 72.107%

Build # 14583755890

Build Type

push

github

Committed by

web-flow

Commit Message

cgroup-util: drop cg_freezer_supported() and cg_ns_supported() (#37201)

Coverage Stats

10 of 12 new or added lines in 7 files covered. (83.33%)

704 existing lines in 44 files now uncovered.

296622 of 411727 relevant lines covered (72.04%)

687023.56 hits per line

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

76.13

/src/shared/bus-message-util.c

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

#include <unistd.h>

#include "bus-message-util.h"
#include "bus-util.h"
#include "copy.h"
#include "resolve-util.h"

int bus_message_read_id128(sd_bus_message *m, sd_id128_t *ret) {
        const void *a;
        size_t sz;
        int r;

        assert(m);

        r = sd_bus_message_read_array(m, 'y', &a, &sz);
        if (r < 0)
                return r;

        switch (sz) {

        case 0:
                if (ret)
                        *ret = SD_ID128_NULL;
                return 0;

        case sizeof(sd_id128_t):
                if (ret)
                        memcpy(ret, a, sz);
                return !memeqzero(a, sz); /* This mimics sd_id128_is_null(), but ret may be NULL,
                                           * and a may be misaligned, so use memeqzero() here. */

        default:
                return -EINVAL;
        }
}

int bus_message_read_ifindex(sd_bus_message *message, sd_bus_error *error, int *ret) {
        int ifindex, r;

        assert(message);
        assert(ret);

        assert_cc(sizeof(int) == sizeof(int32_t));

        r = sd_bus_message_read(message, "i", &ifindex);
        if (r < 0)
                return r;

        if (ifindex <= 0)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");

        *ret = ifindex;

        return 0;
}

int bus_message_read_family(sd_bus_message *message, sd_bus_error *error, int *ret) {
        int family, r;

        assert(message);
        assert(ret);

        assert_cc(sizeof(int) == sizeof(int32_t));

        r = sd_bus_message_read(message, "i", &family);
        if (r < 0)
                return r;

        if (!IN_SET(family, AF_INET, AF_INET6))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);

        *ret = family;
        return 0;
}

int bus_message_read_in_addr_auto(sd_bus_message *message, sd_bus_error *error, int *ret_family, union in_addr_union *ret_addr) {
        int family, r;
        const void *d;
        size_t sz;

        assert(message);

        r = sd_bus_message_read(message, "i", &family);
        if (r < 0)
                return r;

        r = sd_bus_message_read_array(message, 'y', &d, &sz);
        if (r < 0)
                return r;

        if (!IN_SET(family, AF_INET, AF_INET6))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);

        if (sz != FAMILY_ADDRESS_SIZE(family))
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");

        if (ret_family)
                *ret_family = family;
        if (ret_addr)
                memcpy(ret_addr, d, sz);
        return 0;
}

static int bus_message_read_dns_one(
                        sd_bus_message *message,
                        sd_bus_error *error,
                        bool extended,
                        int *ret_family,
                        union in_addr_union *ret_address,
                        uint16_t *ret_port,
                        const char **ret_server_name) {
        const char *server_name = NULL;
        union in_addr_union a;
        uint16_t port = 0;
        int family, r;

        assert(message);
        assert(ret_family);
        assert(ret_address);
        assert(ret_port);
        assert(ret_server_name);

        r = sd_bus_message_enter_container(message, 'r', extended ? "iayqs" : "iay");
        if (r <= 0)
                return r;

        r = bus_message_read_in_addr_auto(message, error, &family, &a);
        if (r < 0)
                return r;

        if (!dns_server_address_valid(family, &a)) {
                r = sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");
                assert(r < 0);
                return r;
        }

        if (extended) {
                r = sd_bus_message_read(message, "q", &port);
                if (r < 0)
                        return r;

                if (IN_SET(port, 53, 853))
                        port = 0;

                r = sd_bus_message_read(message, "s", &server_name);
                if (r < 0)
                        return r;
        }

        r = sd_bus_message_exit_container(message);
        if (r < 0)
                return r;

        *ret_family = family;
        *ret_address = a;
        *ret_port = port;
        *ret_server_name = server_name;

        return 1;
}

int bus_message_read_dns_servers(
                        sd_bus_message *message,
                        sd_bus_error *error,
                        bool extended,
                        struct in_addr_full ***ret_dns,
                        size_t *ret_n_dns) {

        struct in_addr_full **dns = NULL;
        size_t n = 0;
        int r;

        assert(message);
        assert(ret_dns);
        assert(ret_n_dns);

        r = sd_bus_message_enter_container(message, 'a', extended ? "(iayqs)" : "(iay)");
        if (r < 0)
                return r;

        for (;;) {
                const char *server_name;
                union in_addr_union a;
                uint16_t port;
                int family;

                r = bus_message_read_dns_one(message, error, extended, &family, &a, &port, &server_name);
                if (r < 0)
                        goto clear;
                if (r == 0)
                        break;

                if (!GREEDY_REALLOC(dns, n+1)) {
                        r = -ENOMEM;
                        goto clear;
                }

                r = in_addr_full_new(family, &a, port, 0, server_name, dns + n);
                if (r < 0)
                        goto clear;

                n++;
        }

        *ret_dns = TAKE_PTR(dns);
        *ret_n_dns = n;
        return 0;

clear:
        for (size_t i = 0; i < n; i++)
                in_addr_full_free(dns[i]);
        free(dns);

        return r;
}

int bus_message_append_string_set(sd_bus_message *m, const Set *set) {
        int r;

        assert(m);

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

        const char *s;
        SET_FOREACH(s, set) {
                r = sd_bus_message_append(m, "s", s);
                if (r < 0)
                        return r;
        }

        return sd_bus_message_close_container(m);
}

int bus_message_dump_string(sd_bus_message *message) {
        const char *s;
        int r;

        assert(message);

        r = sd_bus_message_read(message, "s", &s);
        if (r < 0)
                return bus_log_parse_error(r);

        fputs(s, stdout);
        return 0;
}

int bus_message_dump_fd(sd_bus_message *message) {
        int fd, r;

        assert(message);

        r = sd_bus_message_read(message, "h", &fd);
        if (r < 0)
                return bus_log_parse_error(r);

        fflush(stdout);
        r = copy_bytes(fd, STDOUT_FILENO, UINT64_MAX, 0);
        if (r < 0)
                return log_error_errno(r, "Failed to dump contents in received file descriptor: %m");

        return 0;
}

DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(bus_message_hash_ops,
                                      void, trivial_hash_func, trivial_compare_func,
                                      sd_bus_message, sd_bus_message_unref);

1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3	#include <unistd.h>
4
5	#include "bus-message-util.h"
6	#include "bus-util.h"
7	#include "copy.h"
8	#include "resolve-util.h"
9
10	int bus_message_read_id128(sd_bus_message m, sd_id128_t ret) {	1,230✔
11	const void *a;	1,230✔
12	size_t sz;	1,230✔
13	int r;	1,230✔
14
15	assert(m);	1,230✔
16
17	r = sd_bus_message_read_array(m, 'y', &a, &sz);	1,230✔
18	if (r < 0)	1,230✔
19	return r;	1,230✔
20
21	switch (sz) {	1,230✔
22
23	case 0:	256✔
24	if (ret)	256✔
25	*ret = SD_ID128_NULL;	256✔
26	return 0;
27
28	case sizeof(sd_id128_t):	974✔
29	if (ret)	974✔
30	memcpy(ret, a, sz);	974✔
31	return !memeqzero(a, sz); /* This mimics sd_id128_is_null(), but ret may be NULL,	974✔
32	* and a may be misaligned, so use memeqzero() here. */
33
34	default:
35	return -EINVAL;
36	}
37	}
38
39	int bus_message_read_ifindex(sd_bus_message message, sd_bus_error error, int *ret) {	142✔
40	int ifindex, r;	142✔
41
42	assert(message);	142✔
43	assert(ret);	142✔
44
45	assert_cc(sizeof(int) == sizeof(int32_t));	142✔
46
47	r = sd_bus_message_read(message, "i", &ifindex);	142✔
48	if (r < 0)	142✔
49	return r;	142✔
50
51	if (ifindex <= 0)	142✔
52	return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");	×
53
54	*ret = ifindex;	142✔
55
56	return 0;	142✔
57	}
58
59	int bus_message_read_family(sd_bus_message message, sd_bus_error error, int *ret) {	×
60	int family, r;	×
61
62	assert(message);	×
63	assert(ret);	×
64
65	assert_cc(sizeof(int) == sizeof(int32_t));	×
66
67	r = sd_bus_message_read(message, "i", &family);	×
68	if (r < 0)	×
69	return r;	×
70
71	if (!IN_SET(family, AF_INET, AF_INET6))	×
72	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);	×
73
74	*ret = family;	×
75	return 0;	×
76	}
77
78	int bus_message_read_in_addr_auto(sd_bus_message message, sd_bus_error error, int ret_family, union in_addr_union ret_addr) {	416✔
79	int family, r;	416✔
80	const void *d;	416✔
81	size_t sz;	416✔
82
83	assert(message);	416✔
84
85	r = sd_bus_message_read(message, "i", &family);	416✔
86	if (r < 0)	416✔
87	return r;	416✔
88
89	r = sd_bus_message_read_array(message, 'y', &d, &sz);	416✔
90	if (r < 0)	416✔
91	return r;
92
93	if (!IN_SET(family, AF_INET, AF_INET6))	416✔
94	return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);	152✔
95
96	if (sz != FAMILY_ADDRESS_SIZE(family))	264✔
97	return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");	×
98
99	if (ret_family)	264✔
100	*ret_family = family;	264✔
101	if (ret_addr)	264✔
102	memcpy(ret_addr, d, sz);	264✔
103	return 0;
104	}
105
106	static int bus_message_read_dns_one(	50✔
107	sd_bus_message *message,
108	sd_bus_error *error,
109	bool extended,
110	int *ret_family,
111	union in_addr_union *ret_address,
112	uint16_t *ret_port,
113	const char **ret_server_name) {
114	const char *server_name = NULL;	50✔
115	union in_addr_union a;	50✔
116	uint16_t port = 0;	50✔
117	int family, r;	50✔
118
119	assert(message);	50✔
120	assert(ret_family);	50✔
121	assert(ret_address);	50✔
122	assert(ret_port);	50✔
123	assert(ret_server_name);	50✔
124
125	r = sd_bus_message_enter_container(message, 'r', extended ? "iayqs" : "iay");	50✔
126	if (r <= 0)	50✔
127	return r;	50✔
128
129	r = bus_message_read_in_addr_auto(message, error, &family, &a);	32✔
130	if (r < 0)	32✔
131	return r;
132
133	if (!dns_server_address_valid(family, &a)) {	32✔
134	r = sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid DNS server address");	×
135	assert(r < 0);	×
136	return r;
137	}
138
139	if (extended) {	32✔
140	r = sd_bus_message_read(message, "q", &port);	32✔
141	if (r < 0)	32✔
142	return r;
143
144	if (IN_SET(port, 53, 853))	32✔
145	port = 0;	×
146
147	r = sd_bus_message_read(message, "s", &server_name);	32✔
148	if (r < 0)	32✔
149	return r;
150	}
151
152	r = sd_bus_message_exit_container(message);	32✔
153	if (r < 0)	32✔
154	return r;
155
156	*ret_family = family;	32✔
157	*ret_address = a;	32✔
158	*ret_port = port;	32✔
159	*ret_server_name = server_name;	32✔
160
161	return 1;	32✔
162	}
163
164	int bus_message_read_dns_servers(	18✔
165	sd_bus_message *message,
166	sd_bus_error *error,
167	bool extended,
168	struct in_addr_full ***ret_dns,
169	size_t *ret_n_dns) {
170
171	struct in_addr_full **dns = NULL;	18✔
172	size_t n = 0;	18✔
173	int r;	18✔
174
175	assert(message);	18✔
176	assert(ret_dns);	18✔
177	assert(ret_n_dns);	18✔
178
179	r = sd_bus_message_enter_container(message, 'a', extended ? "(iayqs)" : "(iay)");	18✔
180	if (r < 0)	18✔
181	return r;	18✔
182
183	for (;;) {	82✔
184	const char *server_name;	50✔
185	union in_addr_union a;	50✔
186	uint16_t port;	50✔
187	int family;	50✔
188
189	r = bus_message_read_dns_one(message, error, extended, &family, &a, &port, &server_name);	50✔
190	if (r < 0)	50✔
191	goto clear;	×
192	if (r == 0)	50✔
193	break;
194
195	if (!GREEDY_REALLOC(dns, n+1)) {	32✔
196	r = -ENOMEM;	×
197	goto clear;	×
198	}
199
200	r = in_addr_full_new(family, &a, port, 0, server_name, dns + n);	32✔
201	if (r < 0)	32✔
202	goto clear;	×
203
204	n++;	32✔
205	}
206
207	*ret_dns = TAKE_PTR(dns);	18✔
208	*ret_n_dns = n;	18✔
209	return 0;	18✔
210
211	clear:	×
212	for (size_t i = 0; i < n; i++)	×
213	in_addr_full_free(dns[i]);	×
214	free(dns);	×
215
216	return r;	×
217	}
218
219	int bus_message_append_string_set(sd_bus_message m, const Set set) {	1,393✔
220	int r;	1,393✔
221
222	assert(m);	1,393✔
223
224	r = sd_bus_message_open_container(m, 'a', "s");	1,393✔
225	if (r < 0)	1,393✔
226	return r;	1,393✔
227
228	const char *s;	1,393✔
229	SET_FOREACH(s, set) {	1,396✔
230	r = sd_bus_message_append(m, "s", s);	3✔
231	if (r < 0)	3✔
232	return r;	×
233	}
234
235	return sd_bus_message_close_container(m);	1,393✔
236	}
237
238	int bus_message_dump_string(sd_bus_message *message) {	×
239	const char *s;	×
240	int r;	×
241
242	assert(message);	×
243
244	r = sd_bus_message_read(message, "s", &s);	×
245	if (r < 0)	×
246	return bus_log_parse_error(r);	×
247
248	fputs(s, stdout);	×
249	return 0;
250	}
251
252	int bus_message_dump_fd(sd_bus_message *message) {	65✔
253	int fd, r;	65✔
254
255	assert(message);	65✔
256
257	r = sd_bus_message_read(message, "h", &fd);	65✔
258	if (r < 0)	65✔
259	return bus_log_parse_error(r);	×
260
261	fflush(stdout);	65✔
262	r = copy_bytes(fd, STDOUT_FILENO, UINT64_MAX, 0);	65✔
263	if (r < 0)	65✔
UNCOV 264	return log_error_errno(r, "Failed to dump contents in received file descriptor: %m");	×
265
266	return 0;
267	}
268
269	DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(bus_message_hash_ops,	74✔
270	void, trivial_hash_func, trivial_compare_func,
271	sd_bus_message, sd_bus_message_unref);

systemd / systemd / 14583755890

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