Debian Codegraph @

src/shared/bus-map-properties.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-bus.h"
4
5 #include "bus-map-properties.h"
6 #include "bus-message-util.h"
7 #include "bus-util.h"
8 #include "string-util.h"
9 #include "strv.h"
10
11 int bus_map_id128(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
12 sd_id128_t *p = userdata;
13 int r;
14
15 assert(m);
16
17 r = bus_message_read_id128(m, p);
18 if (r < 0)
19 return bus_log_parse_error_debug(r);
20
21 return 0;
22 }
23
24 int bus_map_strv_sort(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
25 char ***p = ASSERT_PTR(userdata);
26 int r;
27
28 assert(m);
29
30 r = sd_bus_message_read_strv_extend(m, p);
31 if (r < 0)
32 return bus_log_parse_error_debug(r);
33
34 strv_sort(*p);
35 return 0;
36 }
37
38 int bus_map_job_id(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *reterr_error, void *userdata) {
39 uint32_t *p = ASSERT_PTR(userdata);
40
41 assert(m);
42
43 return sd_bus_message_read(m, "(uo)", p, /* path= */ NULL);
44 }
45
46 static int map_basic(sd_bus_message *m, unsigned flags, void *userdata) {
47 char type;
48 int r;
49
50 assert(m);
51 assert(userdata);
52
53 r = sd_bus_message_peek_type(m, &type, NULL);
54 if (r < 0)
55 return bus_log_parse_error_debug(r);
56
57 switch (type) {
58
59 case SD_BUS_TYPE_STRING:
60 case SD_BUS_TYPE_OBJECT_PATH: {
61 const char **p = userdata, *s;
62
63 r = sd_bus_message_read_basic(m, type, &s);
64 if (r < 0)
65 return bus_log_parse_error_debug(r);
66
67 s = empty_to_null(s);
68
69 if (FLAGS_SET(flags, BUS_MAP_STRDUP))
70 return free_and_strdup((char**) p, s);
71
72 *p = s;
73 return 0;
74 }
75
76 case SD_BUS_TYPE_ARRAY: {
77 char ***p = userdata;
78
79 r = sd_bus_message_read_strv_extend(m, p);
80 if (r < 0)
81 return bus_log_parse_error_debug(r);
82
83 return 0;
84 }
85
86 case SD_BUS_TYPE_BOOLEAN: {
87 int b;
88
89 r = sd_bus_message_read_basic(m, type, &b);
90 if (r < 0)
91 return bus_log_parse_error_debug(r);
92
93 if (flags & BUS_MAP_BOOLEAN_AS_BOOL)
94 *(bool*) userdata = b;
95 else
96 *(int*) userdata = b;
97
98 return 0;
99 }
100
101 case SD_BUS_TYPE_INT32:
102 case SD_BUS_TYPE_UINT32: {
103 uint32_t *p = userdata;
104
105 r = sd_bus_message_read_basic(m, type, p);
106 if (r < 0)
107 return bus_log_parse_error_debug(r);
108
109 return 0;
110 }
111
112 case SD_BUS_TYPE_INT64:
113 case SD_BUS_TYPE_UINT64: {
114 uint64_t *p = userdata;
115
116 r = sd_bus_message_read_basic(m, type, p);
117 if (r < 0)
118 return bus_log_parse_error_debug(r);
119
120 return 0;
121 }
122
123 case SD_BUS_TYPE_DOUBLE: {
124 double *p = userdata;
125
126 r = sd_bus_message_read_basic(m, type, p);
127 if (r < 0)
128 return bus_log_parse_error_debug(r);
129
130 return 0;
131 }
132
133 default:
134 return -EOPNOTSUPP;
135 }
136 }
137
138 int bus_message_map_all_properties(
139 sd_bus_message *m,
140 const struct bus_properties_map *map,
141 unsigned flags,
142 sd_bus_error *reterr_error,
143 void *userdata) {
144
145 int r;
146
147 assert(m);
148 assert(map);
149
150 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{sv}");
151 if (r < 0)
152 return bus_log_parse_error_debug(r);
153
154 while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
155 const struct bus_properties_map *prop;
156 const char *member;
157 const char *contents;
158 void *v;
159 unsigned i;
160
161 r = sd_bus_message_read_basic(m, SD_BUS_TYPE_STRING, &member);
162 if (r < 0)
163 return bus_log_parse_error_debug(r);
164
165 for (i = 0, prop = NULL; map[i].member; i++)
166 if (streq(map[i].member, member)) {
167 prop = &map[i];
168 break;
169 }
170
171 if (prop) {
172 r = sd_bus_message_peek_type(m, NULL, &contents);
173 if (r < 0)
174 return bus_log_parse_error_debug(r);
175
176 if (prop->signature && !streq(contents, prop->signature)) {
177 log_debug("Unexpected type for property '%s': expected '%s', got '%s', ignoring.",
178 member, prop->signature, contents);
179 r = sd_bus_message_skip(m, "v");
180 if (r < 0)
181 return bus_log_parse_error_debug(r);
182 } else {
183 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_VARIANT, contents);
184 if (r < 0)
185 return bus_log_parse_error_debug(r);
186
187 v = (uint8_t*) userdata + prop->offset;
188 if (prop->set)
189 r = prop->set(sd_bus_message_get_bus(m), member, m, reterr_error, v);
190 else
191 r = map_basic(m, flags, v);
192 if (r < 0)
193 return bus_log_parse_error_debug(r);
194
195 r = sd_bus_message_exit_container(m);
196 if (r < 0)
197 return bus_log_parse_error_debug(r);
198 }
199 } else {
200 r = sd_bus_message_skip(m, "v");
201 if (r < 0)
202 return bus_log_parse_error_debug(r);
203 }
204
205 r = sd_bus_message_exit_container(m);
206 if (r < 0)
207 return bus_log_parse_error_debug(r);
208 }
209 if (r < 0)
210 return bus_log_parse_error_debug(r);
211
212 r = sd_bus_message_exit_container(m);
213 if (r < 0)
214 return bus_log_parse_error_debug(r);
215
216 return r;
217 }
218
219 int bus_map_all_properties(
220 sd_bus *bus,
221 const char *destination,
222 const char *path,
223 const struct bus_properties_map *map,
224 unsigned flags,
225 sd_bus_error *reterr_error,
226 sd_bus_message **ret_reply,
227 void *userdata) {
228
229 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
230 int r;
231
232 assert(bus);
233 assert(destination);
234 assert(path);
235 assert(map);
236 assert(ret_reply || (flags & BUS_MAP_STRDUP));
237
238 r = sd_bus_call_method(
239 bus,
240 destination,
241 path,
242 "org.freedesktop.DBus.Properties",
243 "GetAll",
244 reterr_error,
245 &reply,
246 "s", "");
247 if (r < 0)
248 return r;
249
250 r = bus_message_map_all_properties(reply, map, flags, reterr_error, userdata);
251 if (r < 0)
252 return r;
253
254 if (ret_reply)
255 *ret_reply = TAKE_PTR(reply);
256
257 return r;
258 }