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
 276 #define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
 277
 278 #define BUS_WQUEUE_MAX 1024
 279 #define BUS_RQUEUE_MAX 64*1024
 280
 281 #define BUS_MESSAGE_SIZE_MAX (64*1024*1024)
 282 #define BUS_AUTH_SIZE_MAX (64*1024)
 283
 284 #define BUS_CONTAINER_DEPTH 128
 285
 286 /* Defined by the specification as maximum size of an array in
 287  * bytes */
 288 #define BUS_ARRAY_MAX_SIZE 67108864
 289
 290 #define BUS_FDS_MAX 1024
 291
 292 #define BUS_EXEC_ARGV_MAX 256
 293
 294 bool interface_name_is_valid(const char *p) _pure_;
 295 bool service_name_is_valid(const char *p) _pure_;
 296 bool member_name_is_valid(const char *p) _pure_;
 297 bool object_path_is_valid(const char *p) _pure_;
 298 char *object_path_startswith(const char *a, const char *b) _pure_;
 299
 300 bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
 301 bool path_complex_pattern(const char *pattern, const char *value) _pure_;
 302
 303 bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
 304 bool path_simple_pattern(const char *pattern, const char *value) _pure_;
 305
 306 int bus_message_type_from_string(const char *s, uint8_t *u) _pure_;
 307 const char *bus_message_type_to_string(uint8_t u) _pure_;
 308
 309 #define error_name_is_valid interface_name_is_valid
 310
 311 int bus_ensure_running(sd_bus *bus);
 312 int bus_start_running(sd_bus *bus);
 313 int bus_next_address(sd_bus *bus);
 314
 315 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
 316
 317 int bus_rqueue_make_room(sd_bus *bus);
 318
 319 bool bus_pid_changed(sd_bus *bus);
 320
 321 char *bus_address_escape(const char *v);
 322
 323 #define OBJECT_PATH_FOREACH_PREFIX(prefix, path)                        \
 324         for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
 325              _slash && !(_slash[(_slash) == (prefix)] = 0);             \
 326              _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
 327
 328 /* If we are invoking callbacks of a bus object, ensure unreffing the
 329  * bus from the callback doesn't destroy the object we are working
 330  * on */
 331 #define BUS_DONT_DESTROY(bus) \
 332         _cleanup_bus_unref_ _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)