18958539692

Committed 30 Oct 2025 09:15PM UTC coverage: 72.046% (-0.2%) from 72.245%

Build # 18958539692

Build Type

push

github

Committed by

web-flow

Commit Message

importd: port export-tar code to use the one systemd-dissect already uses (#39405)

Split out of #38728.

(Testcase is part of that PR)

Run Details

92 of 135 new or added lines in 5 files covered. (68.15%)

4530 existing lines in 57 files now uncovered.

304067 of 422048 relevant lines covered (72.05%)

1172093.27 hits per line

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

83.66

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

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

#include <unistd.h>

#include "sd-bus.h"

#include "alloc-util.h"
#include "bus-message-util.h"
#include "bus-util.h"
#include "copy.h"
#include "in-addr-util.h"
#include "resolve-util.h"
#include "set.h"
#include "socket-netlink.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 *reterr_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(reterr_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 *reterr_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(reterr_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 *reterr_error, int *ret_family, union in_addr_union *ret_addr) {
        int family, r;
        const void *d;
        size_t sz;

        assert(message);

        r = bus_message_read_family(message, reterr_error, &family);
        if (r < 0)
                return r;

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

        if (sz != FAMILY_ADDRESS_SIZE(family))
                return sd_bus_error_set(reterr_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 *reterr_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, reterr_error, &family, &a);
        if (r < 0)
                return r;

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

systemd / systemd / 18958539692

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