src/libsystemd/sd-bus/bus-internal.h

   1 #pragma once
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <pthread.h>
  23 #include <sys/socket.h>
  24
  25 #include "sd-bus.h"
  26
  27 #include "bus-error.h"
  28 #include "bus-kernel.h"
  29 #include "bus-match.h"
  30 #include "def.h"
  31 #include "hashmap.h"
  32 #include "list.h"
  33 #include "prioq.h"
  34 #include "refcnt.h"
  35 #include "socket-util.h"
  36 #include "util.h"
  37
  38 struct reply_callback {
  39         sd_bus_message_handler_t callback;
  40         usec_t timeout;
  41         uint64_t cookie;
  42         unsigned prioq_idx;
  43 };
  44
  45 struct filter_callback {
  46         sd_bus_message_handler_t callback;
  47
  48         unsigned last_iteration;
  49
  50         LIST_FIELDS(struct filter_callback, callbacks);
  51 };
  52
  53 struct match_callback {
  54         sd_bus_message_handler_t callback;
  55
  56         unsigned last_iteration;
  57
  58         char *match_string;
  59
  60         struct bus_match_node *match_node;
  61 };
  62
  63 struct node {
  64         char *path;
  65         struct node *parent;
  66         LIST_HEAD(struct node, child);
  67         LIST_FIELDS(struct node, siblings);
  68
  69         LIST_HEAD(struct node_callback, callbacks);
  70         LIST_HEAD(struct node_vtable, vtables);
  71         LIST_HEAD(struct node_enumerator, enumerators);
  72         LIST_HEAD(struct node_object_manager, object_managers);
  73 };
  74
  75 struct node_callback {
  76         struct node *node;
  77
  78         bool is_fallback;
  79         sd_bus_message_handler_t callback;
  80
  81         unsigned last_iteration;
  82
  83         LIST_FIELDS(struct node_callback, callbacks);
  84 };
  85
  86 struct node_enumerator {
  87         struct node *node;
  88
  89         sd_bus_node_enumerator_t callback;
  90
  91         unsigned last_iteration;
  92
  93         LIST_FIELDS(struct node_enumerator, enumerators);
  94 };
  95
  96 struct node_object_manager {
  97         struct node *node;
  98
  99         LIST_FIELDS(struct node_object_manager, object_managers);
 100 };
 101
 102 struct node_vtable {
 103         struct node *node;
 104
 105         char *interface;
 106         bool is_fallback;
 107         const sd_bus_vtable *vtable;
 108         sd_bus_object_find_t find;
 109
 110         unsigned last_iteration;
 111
 112         LIST_FIELDS(struct node_vtable, vtables);
 113 };
 114
 115 struct vtable_member {
 116         const char *path;
 117         const char *interface;
 118         const char *member;
 119         struct node_vtable *parent;
 120         unsigned last_iteration;
 121         const sd_bus_vtable *vtable;
 122 };
 123
 124 typedef enum BusSlotType {
 125         BUS_REPLY_CALLBACK,
 126         BUS_FILTER_CALLBACK,
 127         BUS_MATCH_CALLBACK,
 128         BUS_NODE_CALLBACK,
 129         BUS_NODE_ENUMERATOR,
 130         BUS_NODE_VTABLE,
 131         BUS_NODE_OBJECT_MANAGER,
 132         _BUS_SLOT_INVALID = -1,
 133 } BusSlotType;
 134
 135 struct sd_bus_slot {
 136         unsigned n_ref;
 137         sd_bus *bus;
 138         void *userdata;
 139         BusSlotType type:5;
 140         bool floating:1;
 141         bool match_added:1;
 142         char *description;
 143
 144         LIST_FIELDS(sd_bus_slot, slots);
 145
 146         union {
 147                 struct reply_callback reply_callback;
 148                 struct filter_callback filter_callback;
 149                 struct match_callback match_callback;
 150                 struct node_callback node_callback;
 151                 struct node_enumerator node_enumerator;
 152                 struct node_object_manager node_object_manager;
 153                 struct node_vtable node_vtable;
 154         };
 155 };
 156
 157 enum bus_state {
 158         BUS_UNSET,
 159         BUS_OPENING,
 160         BUS_AUTHENTICATING,
 161         BUS_HELLO,
 162         BUS_RUNNING,
 163         BUS_CLOSING,
 164         BUS_CLOSED
 165 };
 166
 167 static inline bool BUS_IS_OPEN(enum bus_state state) {
 168         return state > BUS_UNSET && state < BUS_CLOSING;
 169 }
 170
 171 enum bus_auth {
 172         _BUS_AUTH_INVALID,
 173         BUS_AUTH_EXTERNAL,
 174         BUS_AUTH_ANONYMOUS
 175 };
 176
 177 struct sd_bus {
 178         /* We use atomic ref counting here since sd_bus_message
 179            objects retain references to their originating sd_bus but
 180            we want to allow them to be processed in a different
 181            thread. We won't provide full thread safety, but only the
 182            bare minimum that makes it possible to use sd_bus and
 183            sd_bus_message objects independently and on different
 184            threads as long as each object is used only once at the
 185            same time. */
 186         RefCount n_ref;
 187
 188         enum bus_state state;
 189         int input_fd, output_fd;
 190         int message_version;
 191         int message_endian;
 192
 193         bool can_fds:1;
 194         bool bus_client:1;
 195         bool ucred_valid:1;
 196         bool is_server:1;
 197         bool anonymous_auth:1;
 198         bool prefer_readv:1;
 199         bool prefer_writev:1;
 200         bool match_callbacks_modified:1;
 201         bool filter_callbacks_modified:1;
 202         bool nodes_modified:1;
 203         bool trusted:1;
 204         bool manual_peer_interface:1;
 205         bool is_system:1;
 206         bool is_user:1;
 207         bool allow_interactive_authorization:1;
 208         bool exit_on_disconnect:1;
 209         bool exited:1;
 210         bool exit_triggered:1;
 211         bool is_local:1;
 212
 213         int use_memfd;
 214
 215         void *rbuffer;
 216         size_t rbuffer_size;
 217
 218         sd_bus_message **rqueue;
 219         unsigned rqueue_size;
 220         size_t rqueue_allocated;
 221
 222         sd_bus_message **wqueue;
 223         unsigned wqueue_size;
 224         size_t windex;
 225         size_t wqueue_allocated;
 226
 227         uint64_t cookie;
 228
 229         char *unique_name;
 230         uint64_t unique_id;
 231
 232         struct bus_match_node match_callbacks;
 233         Prioq *reply_callbacks_prioq;
 234         OrderedHashmap *reply_callbacks;
 235         LIST_HEAD(struct filter_callback, filter_callbacks);
 236
 237         Hashmap *nodes;
 238         Hashmap *vtable_methods;
 239         Hashmap *vtable_properties;
 240
 241         union sockaddr_union sockaddr;
 242         socklen_t sockaddr_size;
 243
 244         char *machine;
 245         pid_t nspid;
 246
 247         sd_id128_t server_id;
 248
 249         char *address;
 250         unsigned address_index;
 251
 252         int last_connect_error;
 253
 254         enum bus_auth auth;
 255         size_t auth_rbegin;
 256         struct iovec auth_iovec[3];
 257         unsigned auth_index;
 258         char *auth_buffer;
 259         usec_t auth_timeout;
 260
 261         struct ucred ucred;
 262         char *label;
 263
 264         uint64_t creds_mask;
 265
 266         int *fds;
 267         unsigned n_fds;
 268
 269         char *exec_path;
 270         char **exec_argv;
 271
 272         unsigned iteration_counter;
 273
 274         /* We do locking around the memfd cache, since we want to
 275          * allow people to process a sd_bus_message in a different
 276          * thread then it was generated on and free it there. Since
 277          * adding something to the memfd cache might happen when a
 278          * message is released, we hence need to protect this bit with
 279          * a mutex. */
 280         pthread_mutex_t memfd_cache_mutex;
 281         struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
 282         unsigned n_memfd_cache;
 283
 284         pid_t original_pid;
 285
 286         uint64_t hello_flags;
 287         uint64_t attach_flags;
 288
 289         sd_event_source *input_io_event_source;
 290         sd_event_source *output_io_event_source;
 291         sd_event_source *time_event_source;
 292         sd_event_source *quit_event_source;
 293         sd_event *event;
 294         int event_priority;
 295
 296         sd_bus_message *current_message;
 297         sd_bus_slot *current_slot;
 298         sd_bus_message_handler_t current_handler;
 299         void *current_userdata;
 300
 301         sd_bus **default_bus_ptr;
 302         pid_t tid;
 303
 304         char *cgroup_root;
 305
 306         char *description;
 307
 308         sd_bus_track *track_queue;
 309
 310         LIST_HEAD(sd_bus_slot, slots);
 311         LIST_HEAD(sd_bus_track, tracks);
 312 };
 313
 314 /* For method calls we time-out at 25s, like in the D-Bus reference implementation */
 315 #define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
 316
 317 /* For the authentication phase we grant 90s, to provide extra room during boot, when RNGs and such are not filled up
 318  * with enough entropy yet and might delay the boot */
 319 #define BUS_AUTH_TIMEOUT ((usec_t) DEFAULT_TIMEOUT_USEC)
 320
 321 #define BUS_WQUEUE_MAX (192*1024)
 322 #define BUS_RQUEUE_MAX (192*1024)
 323
 324 #define BUS_MESSAGE_SIZE_MAX (64*1024*1024)
 325 #define BUS_AUTH_SIZE_MAX (64*1024)
 326
 327 #define BUS_CONTAINER_DEPTH 128
 328
 329 /* Defined by the specification as maximum size of an array in
 330  * bytes */
 331 #define BUS_ARRAY_MAX_SIZE 67108864
 332
 333 #define BUS_FDS_MAX 1024
 334
 335 #define BUS_EXEC_ARGV_MAX 256
 336
 337 bool interface_name_is_valid(const char *p) _pure_;
 338 bool service_name_is_valid(const char *p) _pure_;
 339 char* service_name_startswith(const char *a, const char *b);
 340 bool member_name_is_valid(const char *p) _pure_;
 341 bool object_path_is_valid(const char *p) _pure_;
 342 char *object_path_startswith(const char *a, const char *b) _pure_;
 343
 344 bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
 345 bool path_complex_pattern(const char *pattern, const char *value) _pure_;
 346
 347 bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
 348 bool path_simple_pattern(const char *pattern, const char *value) _pure_;
 349
 350 int bus_message_type_from_string(const char *s, uint8_t *u) _pure_;
 351 const char *bus_message_type_to_string(uint8_t u) _pure_;
 352
 353 #define error_name_is_valid interface_name_is_valid
 354
 355 int bus_ensure_running(sd_bus *bus);
 356 int bus_start_running(sd_bus *bus);
 357 int bus_next_address(sd_bus *bus);
 358
 359 int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
 360
 361 int bus_rqueue_make_room(sd_bus *bus);
 362
 363 bool bus_pid_changed(sd_bus *bus);
 364
 365 char *bus_address_escape(const char *v);
 366
 367 #define OBJECT_PATH_FOREACH_PREFIX(prefix, path)                        \
 368         for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
 369              _slash && !(_slash[(_slash) == (prefix)] = 0);             \
 370              _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
 371
 372 /* If we are invoking callbacks of a bus object, ensure unreffing the
 373  * bus from the callback doesn't destroy the object we are working
 374  * on */
 375 #define BUS_DONT_DESTROY(bus) \
 376         _cleanup_(sd_bus_unrefp) _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)
 377
 378 int bus_set_address_system(sd_bus *bus);
 379 int bus_set_address_user(sd_bus *bus);
 380 int bus_set_address_system_remote(sd_bus *b, const char *host);
 381 int bus_set_address_system_machine(sd_bus *b, const char *machine);
 382
 383 int bus_remove_match_by_string(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata);
 384
 385 int bus_get_root_path(sd_bus *bus);
 386
 387 int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error);
 388
 389 #define bus_assert_return(expr, r, error)                               \
 390         do {                                                            \
 391                 if (!assert_log(expr, #expr))                           \
 392                         return sd_bus_error_set_errno(error, r);        \
 393         } while (false)
 394
 395 /**
 396  * enum kdbus_attach_flags - flags for metadata attachments
 397  * @KDBUS_ATTACH_TIMESTAMP:             Timestamp
 398  * @KDBUS_ATTACH_CREDS:                 Credentials
 399  * @KDBUS_ATTACH_PIDS:                  PIDs
 400  * @KDBUS_ATTACH_AUXGROUPS:             Auxiliary groups
 401  * @KDBUS_ATTACH_NAMES:                 Well-known names
 402  * @KDBUS_ATTACH_TID_COMM:              The "comm" process identifier of the TID
 403  * @KDBUS_ATTACH_PID_COMM:              The "comm" process identifier of the PID
 404  * @KDBUS_ATTACH_EXE:                   The path of the executable
 405  * @KDBUS_ATTACH_CMDLINE:               The process command line
 406  * @KDBUS_ATTACH_CGROUP:                The croup membership
 407  * @KDBUS_ATTACH_CAPS:                  The process capabilities
 408  * @KDBUS_ATTACH_SECLABEL:              The security label
 409  * @KDBUS_ATTACH_AUDIT:                 The audit IDs
 410  * @KDBUS_ATTACH_CONN_DESCRIPTION:      The human-readable connection name
 411  * @_KDBUS_ATTACH_ALL:                  All of the above
 412  * @_KDBUS_ATTACH_ANY:                  Wildcard match to enable any kind of
 413  *                                      metatdata.
 414  */
 415 enum kdbus_attach_flags {
 416         KDBUS_ATTACH_TIMESTAMP          =  1ULL <<  0,
 417         KDBUS_ATTACH_CREDS              =  1ULL <<  1,
 418         KDBUS_ATTACH_PIDS               =  1ULL <<  2,
 419         KDBUS_ATTACH_AUXGROUPS          =  1ULL <<  3,
 420         KDBUS_ATTACH_NAMES              =  1ULL <<  4,
 421         KDBUS_ATTACH_TID_COMM           =  1ULL <<  5,
 422         KDBUS_ATTACH_PID_COMM           =  1ULL <<  6,
 423         KDBUS_ATTACH_EXE                =  1ULL <<  7,
 424         KDBUS_ATTACH_CMDLINE            =  1ULL <<  8,
 425         KDBUS_ATTACH_CGROUP             =  1ULL <<  9,
 426         KDBUS_ATTACH_CAPS               =  1ULL << 10,
 427         KDBUS_ATTACH_SECLABEL           =  1ULL << 11,
 428         KDBUS_ATTACH_AUDIT              =  1ULL << 12,
 429         KDBUS_ATTACH_CONN_DESCRIPTION   =  1ULL << 13,
 430         _KDBUS_ATTACH_ALL               =  (1ULL << 14) - 1,
 431         _KDBUS_ATTACH_ANY               =  ~0ULL
 432 };
 433
 434 /**
 435  * enum kdbus_hello_flags - flags for struct kdbus_cmd_hello
 436  * @KDBUS_HELLO_ACCEPT_FD:      The connection allows the reception of
 437  *                              any passed file descriptors
 438  * @KDBUS_HELLO_ACTIVATOR:      Special-purpose connection which registers
 439  *                              a well-know name for a process to be started
 440  *                              when traffic arrives
 441  * @KDBUS_HELLO_POLICY_HOLDER:  Special-purpose connection which registers
 442  *                              policy entries for a name. The provided name
 443  *                              is not activated and not registered with the
 444  *                              name database, it only allows unprivileged
 445  *                              connections to acquire a name, talk or discover
 446  *                              a service
 447  * @KDBUS_HELLO_MONITOR:        Special-purpose connection to monitor
 448  *                              bus traffic
 449  */
 450 enum kdbus_hello_flags {
 451         KDBUS_HELLO_ACCEPT_FD           =  1ULL <<  0,
 452         KDBUS_HELLO_ACTIVATOR           =  1ULL <<  1,
 453         KDBUS_HELLO_POLICY_HOLDER       =  1ULL <<  2,
 454         KDBUS_HELLO_MONITOR             =  1ULL <<  3,
 455 };