16791678039

Committed 06 Aug 2025 11:10PM UTC coverage: 72.181% (-0.04%) from 72.223%

Build # 16791678039

Build Type

push

github

Committed by

yuwata

Commit Message

logging: Improve logging messages related to NFTSet.

The 'NFTSet' directive in various units adds and removes entries in nftables
sets, it does not add or remove entire sets. The logging messages should
indicate that an entry was added or removed, not that a set was added or
removed.

Run Details

2 of 6 new or added lines in 3 files covered. (33.33%)

496 existing lines in 52 files now uncovered.

302228 of 418708 relevant lines covered (72.18%)

647735.83 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,388✔
17	const void *a;	1,388✔
18	size_t sz;	1,388✔
19	int r;	1,388✔
20
21	assert(m);	1,388✔
22
23	r = sd_bus_message_read_array(m, 'y', &a, &sz);	1,388✔
24	if (r < 0)	1,388✔
25	return r;	1,388✔
26
27	switch (sz) {	1,388✔
28
29	case 0:	287✔
30	if (ret)	287✔
31	*ret = SD_ID128_NULL;	287✔
32	return 0;
33
34	case sizeof(sd_id128_t):	1,101✔
35	if (ret)	1,101✔
36	memcpy(ret, a, sz);	1,101✔
37	return !memeqzero(a, sz); /* This mimics sd_id128_is_null(), but ret may be NULL,	1,101✔
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) {	153✔
46	int ifindex, r;	153✔
47
48	assert(message);	153✔
49	assert(ret);	153✔
50
51	assert_cc(sizeof(int) == sizeof(int32_t));	153✔
52
53	r = sd_bus_message_read(message, "i", &ifindex);	153✔
54	if (r < 0)	153✔
55	return r;	153✔
56
57	if (ifindex <= 0)	153✔
58	return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid interface index");	×
59
60	*ret = ifindex;	153✔
61
62	return 0;	153✔
63	}
64
65	int bus_message_read_family(sd_bus_message message, sd_bus_error reterr_error, int *ret) {	491✔
66	int family, r;	491✔
67
68	assert(message);	491✔
69	assert(ret);	491✔
70
71	assert_cc(sizeof(int) == sizeof(int32_t));	491✔
72
73	r = sd_bus_message_read(message, "i", &family);	491✔
74	if (r < 0)	491✔
75	return r;	491✔
76
77	if (!IN_SET(family, AF_INET, AF_INET6))	491✔
78	return sd_bus_error_setf(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Unknown address family %i", family);	179✔
79
80	*ret = family;	312✔
81	return 0;	312✔
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) {	491✔
85	int family, r;	491✔
86	const void *d;	491✔
87	size_t sz;	491✔
88
89	assert(message);	491✔
90
91	r = bus_message_read_family(message, reterr_error, &family);	491✔
92	if (r < 0)	491✔
93	return r;	491✔
94
95	r = sd_bus_message_read_array(message, 'y', &d, &sz);	312✔
96	if (r < 0)	312✔
97	return r;
98
99	if (sz != FAMILY_ADDRESS_SIZE(family))	312✔
100	return sd_bus_error_set(reterr_error, SD_BUS_ERROR_INVALID_ARGS, "Invalid address size");	×
101
102	if (ret_family)	312✔
103	*ret_family = family;	312✔
104	if (ret_addr)	312✔
105	memcpy(ret_addr, d, sz);	312✔
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,282✔
223	int r;	1,282✔
224
225	assert(m);	1,282✔
226
227	r = sd_bus_message_open_container(m, 'a', "s");	1,282✔
228	if (r < 0)	1,282✔
229	return r;	1,282✔
230
231	const char *s;	1,282✔
232	SET_FOREACH(s, set) {	1,320✔
233	r = sd_bus_message_append(m, "s", s);	38✔
234	if (r < 0)	38✔
235	return r;	×
236	}
237
238	return sd_bus_message_close_container(m);	1,282✔
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,	75✔
273	void, trivial_hash_func, trivial_compare_func,
274	sd_bus_message, sd_bus_message_unref);

systemd / systemd / 16791678039

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