src/libsystemd-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
 167         int use_memfd;
 168
 169         void *rbuffer;
 170         size_t rbuffer_size;
 171
 172         sd_bus_message **rqueue;
 173         unsigned rqueue_size;
 174         size_t rqueue_allocated;
 175
 176         sd_bus_message **wqueue;
 177         unsigned wqueue_size;
 178         size_t windex;
 179         size_t wqueue_allocated;
 180
 181         uint64_t cookie;
 182
 183         char *unique_name;
 184         uint64_t unique_id;
 185
 186         struct bus_match_node match_callbacks;
 187         Prioq *reply_callbacks_prioq;
 188         Hashmap *reply_callbacks;
 189         LIST_HEAD(struct filter_callback, filter_callbacks);
 190
 191         Hashmap *nodes;
 192         Hashmap *vtable_methods;
 193         Hashmap *vtable_properties;
 194
 195         union {
 196                 struct sockaddr sa;
 197                 struct sockaddr_un un;
 198                 struct sockaddr_in in;
 199                 struct sockaddr_in6 in6;
 200         } sockaddr;
 201         socklen_t sockaddr_size;
 202
 203         char *kernel;
 204         char *machine;
 205
 206         sd_id128_t server_id;
 207
 208         char *address;
 209         unsigned address_index;
 210
 211         int last_connect_error;
 212
 213         enum bus_auth auth;
 214         size_t auth_rbegin;
 215         struct iovec auth_iovec[3];
 216         unsigned auth_index;
 217         char *auth_buffer;
 218         usec_t auth_timeout;
 219
 220         struct ucred ucred;
 221         char label[NAME_MAX];
 222
 223         uint64_t creds_mask;
 224
 225         int *fds;
 226         unsigned n_fds;
 227
 228         char *exec_path;
 229         char **exec_argv;
 230
 231         uint64_t hello_cookie;
 232         unsigned iteration_counter;
 233
 234         void *kdbus_buffer;
 235
 236         /* We do locking around the memfd cache, since we want to
 237          * allow people to process a sd_bus_message in a different
 238          * thread then it was generated on and free it there. Since
 239          * adding something to the memfd cache might happen when a
 240          * message is released, we hence need to protect this bit with
 241          * a mutex. */
 242         pthread_mutex_t memfd_cache_mutex;
 243         struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
 244         unsigned n_memfd_cache;
 245
 246         pid_t original_pid;
 247
 248         uint64_t hello_flags;
 249         uint64_t attach_flags;
 250
 251         uint64_t match_cookie;
 252
 253         sd_event_source *input_io_event_source;
 254         sd_event_source *output_io_event_source;
 255         sd_event_source *time_event_source;
 256         sd_event_source *quit_event_source;
 257         sd_event *event;
 258         int event_priority;
 259
 260         sd_bus_message *current;
 261
 262         sd_bus **default_bus_ptr;
 263         pid_t tid;
 264
 265         struct kdbus_creds fake_creds;
 266         char *fake_label;
 267
 268         char *cgroup_root;
 269 };
 270
 271 #define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
 272
 273 #define BUS_WQUEUE_MAX 1024
 274 #define BUS_RQUEUE_MAX 64*1024
 275
 276 #define BUS_MESSAGE_SIZE_MAX (64*1024*1024)
 277 #define BUS_AUTH_SIZE_MAX (64*1024)
 278
 279 #define BUS_CONTAINER_DEPTH 128
 280
 281 /* Defined by the specification as maximum size of an array in
 282  * bytes */
 283 #define BUS_ARRAY_MAX_SIZE 67108864
 284
 285 #define BUS_FDS_MAX 1024
 286
 287 #define BUS_EXEC_ARGV_MAX 256
 288
 289 bool interface_name_is_valid(const char *p);
 290 bool service_name_is_valid(const char *p);
 291 bool member_name_is_valid(const char *p);
 292 bool object_path_is_valid(const char *p);
 293 char *object_path_startswith(const char *a, const char *b);
 294
 295 bool namespace_complex_pattern(const char *pattern, const char *value);
 296 bool path_complex_pattern(const char *pattern, const char *value);
 297
 298 bool namespace_simple_pattern(const char *pattern, const char *value);
 299 bool path_simple_pattern(const char *pattern, const char *value);
 300
 301 int bus_message_type_from_string(const char *s, uint8_t *u);
 302 const char *bus_message_type_to_string(uint8_t u);
 303
 304 #define error_name_is_valid interface_name_is_valid
 305
 306 int bus_ensure_running(sd_bus *bus);
 307 int bus_start_running(sd_bus *bus);
 308 int bus_next_address(sd_bus *bus);
 309
 310 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
 311
 312 int bus_rqueue_make_room(sd_bus *bus);
 313
 314 bool bus_pid_changed(sd_bus *bus);
 315
 316 char *bus_address_escape(const char *v);
 317
 318 #define OBJECT_PATH_FOREACH_PREFIX(prefix, path)                        \
 319         for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
 320              _slash && !(_slash[(_slash) == (prefix)] = 0);             \
 321              _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
 322
 323 /* If we are invoking callbacks of a bus object, ensure unreffing the
 324  * bus from the callback doesn't destroy the object we are working
 325  * on */
 326 #define BUS_DONT_DESTROY(bus) \
 327         _cleanup_bus_unref_ _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)