chiark / gitweb /
a4160ef4a18087d71fb646a04eb6b59cd6d334eb
[elogind.git] / src / libsystemd / sd-bus / bus-internal.h
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>
27 #include <pthread.h>
28
29 #include "hashmap.h"
30 #include "prioq.h"
31 #include "list.h"
32 #include "util.h"
33 #include "refcnt.h"
34
35 #include "sd-bus.h"
36 #include "bus-error.h"
37 #include "bus-match.h"
38 #include "bus-kernel.h"
39 #include "kdbus.h"
40
41 struct reply_callback {
42         sd_bus_message_handler_t callback;
43         void *userdata;
44         usec_t timeout;
45         uint64_t cookie;
46         unsigned prioq_idx;
47 };
48
49 struct filter_callback {
50         sd_bus_message_handler_t callback;
51         void *userdata;
52
53         unsigned last_iteration;
54
55         LIST_FIELDS(struct filter_callback, callbacks);
56 };
57
58 struct node {
59         char *path;
60         struct node *parent;
61         LIST_HEAD(struct node, child);
62         LIST_FIELDS(struct node, siblings);
63
64         LIST_HEAD(struct node_callback, callbacks);
65         LIST_HEAD(struct node_vtable, vtables);
66         LIST_HEAD(struct node_enumerator, enumerators);
67
68         bool object_manager;
69 };
70
71 struct node_callback {
72         struct node *node;
73
74         bool is_fallback;
75         sd_bus_message_handler_t callback;
76         void *userdata;
77
78         unsigned last_iteration;
79
80         LIST_FIELDS(struct node_callback, callbacks);
81 };
82
83 struct node_enumerator {
84         struct node *node;
85
86         sd_bus_node_enumerator_t callback;
87         void *userdata;
88
89         unsigned last_iteration;
90
91         LIST_FIELDS(struct node_enumerator, enumerators);
92 };
93
94 struct node_vtable {
95         struct node *node;
96
97         char *interface;
98         bool is_fallback;
99         const sd_bus_vtable *vtable;
100         void *userdata;
101         sd_bus_object_find_t find;
102
103         unsigned last_iteration;
104
105         LIST_FIELDS(struct node_vtable, vtables);
106 };
107
108 struct vtable_member {
109         const char *path;
110         const char *interface;
111         const char *member;
112         struct node_vtable *parent;
113         unsigned last_iteration;
114         const sd_bus_vtable *vtable;
115 };
116
117 enum bus_state {
118         BUS_UNSET,
119         BUS_OPENING,
120         BUS_AUTHENTICATING,
121         BUS_HELLO,
122         BUS_RUNNING,
123         BUS_CLOSING,
124         BUS_CLOSED
125 };
126
127 static inline bool BUS_IS_OPEN(enum bus_state state) {
128         return state > BUS_UNSET && state < BUS_CLOSING;
129 }
130
131 enum bus_auth {
132         _BUS_AUTH_INVALID,
133         BUS_AUTH_EXTERNAL,
134         BUS_AUTH_ANONYMOUS
135 };
136
137 struct sd_bus {
138         /* We use atomic ref counting here since sd_bus_message
139            objects retain references to their originating sd_bus but
140            we want to allow them to be processed in a different
141            thread. We won't provide full thread safety, but only the
142            bare minimum that makes it possible to use sd_bus and
143            sd_bus_message objects independently and on different
144            threads as long as each object is used only once at the
145            same time. */
146         RefCount n_ref;
147
148         enum bus_state state;
149         int input_fd, output_fd;
150         int message_version;
151         int message_endian;
152
153         bool is_kernel:1;
154         bool can_fds:1;
155         bool bus_client:1;
156         bool ucred_valid:1;
157         bool is_server:1;
158         bool anonymous_auth:1;
159         bool prefer_readv:1;
160         bool prefer_writev:1;
161         bool match_callbacks_modified:1;
162         bool filter_callbacks_modified:1;
163         bool nodes_modified:1;
164         bool trusted:1;
165         bool fake_creds_valid:1;
166         bool manual_peer_interface:1;
167         bool is_system:1;
168         bool is_user:1;
169
170         int use_memfd;
171
172         void *rbuffer;
173         size_t rbuffer_size;
174
175         sd_bus_message **rqueue;
176         unsigned rqueue_size;
177         size_t rqueue_allocated;
178
179         sd_bus_message **wqueue;
180         unsigned wqueue_size;
181         size_t windex;
182         size_t wqueue_allocated;
183
184         uint64_t cookie;
185
186         char *unique_name;
187         uint64_t unique_id;
188
189         struct bus_match_node match_callbacks;
190         Prioq *reply_callbacks_prioq;
191         Hashmap *reply_callbacks;
192         LIST_HEAD(struct filter_callback, filter_callbacks);
193
194         Hashmap *nodes;
195         Hashmap *vtable_methods;
196         Hashmap *vtable_properties;
197
198         union {
199                 struct sockaddr sa;
200                 struct sockaddr_un un;
201                 struct sockaddr_in in;
202                 struct sockaddr_in6 in6;
203         } sockaddr;
204         socklen_t sockaddr_size;
205
206         char *kernel;
207         char *machine;
208
209         sd_id128_t server_id;
210
211         char *address;
212         unsigned address_index;
213
214         int last_connect_error;
215
216         enum bus_auth auth;
217         size_t auth_rbegin;
218         struct iovec auth_iovec[3];
219         unsigned auth_index;
220         char *auth_buffer;
221         usec_t auth_timeout;
222
223         struct ucred ucred;
224         char label[NAME_MAX];
225
226         uint64_t creds_mask;
227
228         int *fds;
229         unsigned n_fds;
230
231         char *exec_path;
232         char **exec_argv;
233
234         uint64_t hello_cookie;
235         unsigned iteration_counter;
236
237         void *kdbus_buffer;
238
239         /* We do locking around the memfd cache, since we want to
240          * allow people to process a sd_bus_message in a different
241          * thread then it was generated on and free it there. Since
242          * adding something to the memfd cache might happen when a
243          * message is released, we hence need to protect this bit with
244          * a mutex. */
245         pthread_mutex_t memfd_cache_mutex;
246         struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
247         unsigned n_memfd_cache;
248
249         pid_t original_pid;
250
251         uint64_t hello_flags;
252         uint64_t attach_flags;
253
254         uint64_t match_cookie;
255
256         sd_event_source *input_io_event_source;
257         sd_event_source *output_io_event_source;
258         sd_event_source *time_event_source;
259         sd_event_source *quit_event_source;
260         sd_event *event;
261         int event_priority;
262
263         sd_bus_message *current;
264
265         sd_bus **default_bus_ptr;
266         pid_t tid;
267
268         struct kdbus_creds fake_creds;
269         char *fake_label;
270
271         char *cgroup_root;
272
273         char *connection_name;
274
275         size_t bloom_size;
276         unsigned bloom_n_hash;
277 };
278
279 #define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
280
281 #define BUS_WQUEUE_MAX 1024
282 #define BUS_RQUEUE_MAX 64*1024
283
284 #define BUS_MESSAGE_SIZE_MAX (64*1024*1024)
285 #define BUS_AUTH_SIZE_MAX (64*1024)
286
287 #define BUS_CONTAINER_DEPTH 128
288
289 /* Defined by the specification as maximum size of an array in
290  * bytes */
291 #define BUS_ARRAY_MAX_SIZE 67108864
292
293 #define BUS_FDS_MAX 1024
294
295 #define BUS_EXEC_ARGV_MAX 256
296
297 bool interface_name_is_valid(const char *p) _pure_;
298 bool service_name_is_valid(const char *p) _pure_;
299 bool member_name_is_valid(const char *p) _pure_;
300 bool object_path_is_valid(const char *p) _pure_;
301 char *object_path_startswith(const char *a, const char *b) _pure_;
302
303 bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
304 bool path_complex_pattern(const char *pattern, const char *value) _pure_;
305
306 bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
307 bool path_simple_pattern(const char *pattern, const char *value) _pure_;
308
309 int bus_message_type_from_string(const char *s, uint8_t *u) _pure_;
310 const char *bus_message_type_to_string(uint8_t u) _pure_;
311
312 #define error_name_is_valid interface_name_is_valid
313
314 int bus_ensure_running(sd_bus *bus);
315 int bus_start_running(sd_bus *bus);
316 int bus_next_address(sd_bus *bus);
317
318 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
319
320 int bus_rqueue_make_room(sd_bus *bus);
321
322 bool bus_pid_changed(sd_bus *bus);
323
324 char *bus_address_escape(const char *v);
325
326 #define OBJECT_PATH_FOREACH_PREFIX(prefix, path)                        \
327         for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
328              _slash && !(_slash[(_slash) == (prefix)] = 0);             \
329              _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
330
331 /* If we are invoking callbacks of a bus object, ensure unreffing the
332  * bus from the callback doesn't destroy the object we are working
333  * on */
334 #define BUS_DONT_DESTROY(bus) \
335         _cleanup_bus_unref_ _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)