]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/libsystemd/sd-bus/bus-internal.h
shared: split out in_addr related calls from socket-util.[ch] into its private in...
[thirdparty/systemd.git] / src / libsystemd / sd-bus / bus-internal.h
CommitLineData
de1c301e
LP
1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3#pragma once
4
5/***
6 This file is part of systemd.
7
8 Copyright 2013 Lennart Poettering
9
10 systemd is free software; you can redistribute it and/or modify it
11 under the terms of the GNU Lesser General Public License as published by
12 the Free Software Foundation; either version 2.1 of the License, or
13 (at your option) any later version.
14
15 systemd is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public License
21 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22***/
23
24#include <sys/socket.h>
25#include <sys/un.h>
26#include <netinet/in.h>
45fbe937 27#include <pthread.h>
de1c301e
LP
28
29#include "hashmap.h"
e3017af9 30#include "prioq.h"
de1c301e
LP
31#include "list.h"
32#include "util.h"
e4ee6e5c 33#include "refcnt.h"
de1c301e
LP
34
35#include "sd-bus.h"
36#include "bus-error.h"
392d5b37 37#include "bus-match.h"
bc7fd8cd 38#include "bus-kernel.h"
8a0e0ed9 39#include "kdbus.h"
de1c301e
LP
40
41struct reply_callback {
52f3ba91 42 sd_bus_message_handler_t callback;
de1c301e 43 usec_t timeout;
693eb9a2 44 uint64_t cookie;
e3017af9 45 unsigned prioq_idx;
de1c301e
LP
46};
47
48struct filter_callback {
52f3ba91 49 sd_bus_message_handler_t callback;
de1c301e 50
7286037f
LP
51 unsigned last_iteration;
52
de1c301e
LP
53 LIST_FIELDS(struct filter_callback, callbacks);
54};
55
19befb2d
LP
56struct match_callback {
57 sd_bus_message_handler_t callback;
58
59 uint64_t cookie;
60 unsigned last_iteration;
61
62 char *match_string;
63
64 struct bus_match_node *match_node;
65};
66
29ddb38f
LP
67struct node {
68 char *path;
69 struct node *parent;
70 LIST_HEAD(struct node, child);
71 LIST_FIELDS(struct node, siblings);
72
73 LIST_HEAD(struct node_callback, callbacks);
74 LIST_HEAD(struct node_vtable, vtables);
75 LIST_HEAD(struct node_enumerator, enumerators);
19befb2d 76 LIST_HEAD(struct node_object_manager, object_managers);
29ddb38f
LP
77};
78
79struct node_callback {
80 struct node *node;
81
82 bool is_fallback;
52f3ba91 83 sd_bus_message_handler_t callback;
a652755d 84
29ddb38f
LP
85 unsigned last_iteration;
86
87 LIST_FIELDS(struct node_callback, callbacks);
88};
89
90struct node_enumerator {
91 struct node *node;
92
93 sd_bus_node_enumerator_t callback;
29ddb38f
LP
94
95 unsigned last_iteration;
96
97 LIST_FIELDS(struct node_enumerator, enumerators);
98};
99
19befb2d
LP
100struct node_object_manager {
101 struct node *node;
102
103 LIST_FIELDS(struct node_object_manager, object_managers);
104};
105
29ddb38f
LP
106struct node_vtable {
107 struct node *node;
108
109 char *interface;
a652755d 110 bool is_fallback;
29ddb38f 111 const sd_bus_vtable *vtable;
29ddb38f 112 sd_bus_object_find_t find;
7286037f
LP
113
114 unsigned last_iteration;
29ddb38f
LP
115
116 LIST_FIELDS(struct node_vtable, vtables);
117};
118
119struct vtable_member {
120 const char *path;
121 const char *interface;
122 const char *member;
123 struct node_vtable *parent;
124 unsigned last_iteration;
125 const sd_bus_vtable *vtable;
a652755d
LP
126};
127
19befb2d 128typedef enum BusSlotType {
19befb2d
LP
129 BUS_REPLY_CALLBACK,
130 BUS_FILTER_CALLBACK,
131 BUS_MATCH_CALLBACK,
132 BUS_NODE_CALLBACK,
133 BUS_NODE_ENUMERATOR,
134 BUS_NODE_VTABLE,
135 BUS_NODE_OBJECT_MANAGER,
a71fe8b8 136 _BUS_SLOT_INVALID = -1,
19befb2d
LP
137} BusSlotType;
138
139struct sd_bus_slot {
140 unsigned n_ref;
141 sd_bus *bus;
142 void *userdata;
a71fe8b8
LP
143 BusSlotType type:5;
144 bool floating:1;
19befb2d
LP
145
146 LIST_FIELDS(sd_bus_slot, slots);
147
148 union {
149 struct reply_callback reply_callback;
150 struct filter_callback filter_callback;
151 struct match_callback match_callback;
152 struct node_callback node_callback;
153 struct node_enumerator node_enumerator;
154 struct node_object_manager node_object_manager;
155 struct node_vtable node_vtable;
156 };
157};
158
de1c301e 159enum bus_state {
021a1e78 160 BUS_UNSET,
de1c301e
LP
161 BUS_OPENING,
162 BUS_AUTHENTICATING,
163 BUS_HELLO,
f54514f3 164 BUS_RUNNING,
718db961 165 BUS_CLOSING,
f54514f3 166 BUS_CLOSED
de1c301e
LP
167};
168
f54514f3 169static inline bool BUS_IS_OPEN(enum bus_state state) {
718db961 170 return state > BUS_UNSET && state < BUS_CLOSING;
f54514f3
LP
171}
172
2181a7f5
LP
173enum bus_auth {
174 _BUS_AUTH_INVALID,
175 BUS_AUTH_EXTERNAL,
176 BUS_AUTH_ANONYMOUS
177};
178
de1c301e 179struct sd_bus {
e4ee6e5c
LP
180 /* We use atomic ref counting here since sd_bus_message
181 objects retain references to their originating sd_bus but
182 we want to allow them to be processed in a different
183 thread. We won't provide full thread safety, but only the
184 bare minimum that makes it possible to use sd_bus and
185 sd_bus_message objects independently and on different
186 threads as long as each object is used only once at the
187 same time. */
188 RefCount n_ref;
189
de1c301e 190 enum bus_state state;
e82c9509 191 int input_fd, output_fd;
de1c301e 192 int message_version;
0f437184 193 int message_endian;
021a1e78 194
6629161f 195 bool is_kernel:1;
de1c301e 196 bool can_fds:1;
94bbf1ba 197 bool bus_client:1;
2571ead1 198 bool ucred_valid:1;
2181a7f5
LP
199 bool is_server:1;
200 bool anonymous_auth:1;
15d5af81
LP
201 bool prefer_readv:1;
202 bool prefer_writev:1;
7286037f
LP
203 bool match_callbacks_modified:1;
204 bool filter_callbacks_modified:1;
29ddb38f 205 bool nodes_modified:1;
adacb957 206 bool trusted:1;
8a0e0ed9 207 bool fake_creds_valid:1;
758bf0c7 208 bool manual_peer_interface:1;
5972fe95
LP
209 bool is_system:1;
210 bool is_user:1;
de1c301e 211
8f155917
LP
212 int use_memfd;
213
de1c301e
LP
214 void *rbuffer;
215 size_t rbuffer_size;
216
217 sd_bus_message **rqueue;
821e0756
LP
218 unsigned rqueue_size;
219 size_t rqueue_allocated;
de1c301e
LP
220
221 sd_bus_message **wqueue;
222 unsigned wqueue_size;
223 size_t windex;
821e0756 224 size_t wqueue_allocated;
de1c301e 225
693eb9a2 226 uint64_t cookie;
de1c301e
LP
227
228 char *unique_name;
219728b3 229 uint64_t unique_id;
de1c301e 230
392d5b37 231 struct bus_match_node match_callbacks;
e3017af9 232 Prioq *reply_callbacks_prioq;
de1c301e
LP
233 Hashmap *reply_callbacks;
234 LIST_HEAD(struct filter_callback, filter_callbacks);
29ddb38f
LP
235
236 Hashmap *nodes;
29ddb38f
LP
237 Hashmap *vtable_methods;
238 Hashmap *vtable_properties;
de1c301e
LP
239
240 union {
241 struct sockaddr sa;
242 struct sockaddr_un un;
243 struct sockaddr_in in;
244 struct sockaddr_in6 in6;
245 } sockaddr;
246 socklen_t sockaddr_size;
247
6629161f 248 char *kernel;
a7893c6b 249 char *machine;
6629161f 250
98178d39 251 sd_id128_t server_id;
de1c301e
LP
252
253 char *address;
254 unsigned address_index;
255
256 int last_connect_error;
257
2181a7f5
LP
258 enum bus_auth auth;
259 size_t auth_rbegin;
de1c301e
LP
260 struct iovec auth_iovec[3];
261 unsigned auth_index;
2181a7f5 262 char *auth_buffer;
e3017af9 263 usec_t auth_timeout;
2571ead1
LP
264
265 struct ucred ucred;
266 char label[NAME_MAX];
2c93b4ef 267
5b12334d
LP
268 uint64_t creds_mask;
269
2c93b4ef
LP
270 int *fds;
271 unsigned n_fds;
2fd9ae2e
LP
272
273 char *exec_path;
274 char **exec_argv;
9d373862 275
7286037f 276 unsigned iteration_counter;
fd8d62d9
LP
277
278 void *kdbus_buffer;
bc7fd8cd 279
45fbe937
LP
280 /* We do locking around the memfd cache, since we want to
281 * allow people to process a sd_bus_message in a different
282 * thread then it was generated on and free it there. Since
283 * adding something to the memfd cache might happen when a
284 * message is released, we hence need to protect this bit with
285 * a mutex. */
286 pthread_mutex_t memfd_cache_mutex;
bc7fd8cd
LP
287 struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
288 unsigned n_memfd_cache;
d5a2b9a6
LP
289
290 pid_t original_pid;
264ad849
LP
291
292 uint64_t hello_flags;
d21a7bb1 293 uint64_t attach_flags;
c7819669
LP
294
295 uint64_t match_cookie;
89ffcd2a 296
40ca29a1
LP
297 sd_event_source *input_io_event_source;
298 sd_event_source *output_io_event_source;
299 sd_event_source *time_event_source;
abc5fe72 300 sd_event_source *quit_event_source;
40ca29a1 301 sd_event *event;
1e05d493 302 int event_priority;
affff0b6 303
19befb2d
LP
304 sd_bus_message *current_message;
305 sd_bus_slot *current_slot;
76b54375
LP
306
307 sd_bus **default_bus_ptr;
308 pid_t tid;
8a0e0ed9
LP
309
310 struct kdbus_creds fake_creds;
311 char *fake_label;
751bc6ac
LP
312
313 char *cgroup_root;
5972fe95
LP
314
315 char *connection_name;
b28ff39f
LP
316
317 size_t bloom_size;
318 unsigned bloom_n_hash;
8f8f05a9
LP
319
320 sd_bus_track *track_queue;
19befb2d
LP
321
322 LIST_HEAD(sd_bus_slot, slots);
40ca29a1 323};
e3017af9
LP
324
325#define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
25220239 326
7a4a2105
LP
327#define BUS_WQUEUE_MAX 1024
328#define BUS_RQUEUE_MAX 64*1024
25220239
LP
329
330#define BUS_MESSAGE_SIZE_MAX (64*1024*1024)
331#define BUS_AUTH_SIZE_MAX (64*1024)
ac89bf1d 332
ed205a6b
LP
333#define BUS_CONTAINER_DEPTH 128
334
ac89bf1d
LP
335/* Defined by the specification as maximum size of an array in
336 * bytes */
337#define BUS_ARRAY_MAX_SIZE 67108864
338
2c93b4ef
LP
339#define BUS_FDS_MAX 1024
340
2fd9ae2e
LP
341#define BUS_EXEC_ARGV_MAX 256
342
0ce036ce
LP
343bool interface_name_is_valid(const char *p) _pure_;
344bool service_name_is_valid(const char *p) _pure_;
345bool member_name_is_valid(const char *p) _pure_;
346bool object_path_is_valid(const char *p) _pure_;
347char *object_path_startswith(const char *a, const char *b) _pure_;
6693860f 348
0ce036ce
LP
349bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
350bool path_complex_pattern(const char *pattern, const char *value) _pure_;
392d5b37 351
0ce036ce
LP
352bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
353bool path_simple_pattern(const char *pattern, const char *value) _pure_;
392d5b37 354
0ce036ce
LP
355int bus_message_type_from_string(const char *s, uint8_t *u) _pure_;
356const char *bus_message_type_to_string(uint8_t u) _pure_;
392d5b37 357
6693860f 358#define error_name_is_valid interface_name_is_valid
20902f3e
LP
359
360int bus_ensure_running(sd_bus *bus);
a7e3212d
LP
361int bus_start_running(sd_bus *bus);
362int bus_next_address(sd_bus *bus);
d5a2b9a6 363
7adc46fc 364int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
777d7a61 365
7adc46fc 366int bus_rqueue_make_room(sd_bus *bus);
7d22c717 367
d5a2b9a6 368bool bus_pid_changed(sd_bus *bus);
92e189e5 369
0f8bd8de
LP
370char *bus_address_escape(const char *v);
371
92e189e5
LP
372#define OBJECT_PATH_FOREACH_PREFIX(prefix, path) \
373 for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
374 _slash && !(_slash[(_slash) == (prefix)] = 0); \
375 _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
8ce2afd6
LP
376
377/* If we are invoking callbacks of a bus object, ensure unreffing the
378 * bus from the callback doesn't destroy the object we are working
379 * on */
380#define BUS_DONT_DESTROY(bus) \
d7726e57 381 _cleanup_bus_unref_ _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)
09365592
LP
382
383int bus_set_address_system(sd_bus *bus);
384int bus_set_address_user(sd_bus *bus);
385int bus_set_address_system_remote(sd_bus *b, const char *host);
386int bus_set_address_system_container(sd_bus *b, const char *machine);
19befb2d
LP
387
388int bus_remove_match_by_string(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata);