X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-bus%2Fbus-internal.h;h=673f30eb912e379ece4a4d597350a59441a3d102;hp=b6975c54a2221d439be6d6082f6a44064949fd58;hb=8a0e0ed9ddfa208e414355881acb886270039268;hpb=d5a2b9a6f455468a0f29483303657ab4fd7013d8 diff --git a/src/libsystemd-bus/bus-internal.h b/src/libsystemd-bus/bus-internal.h index b6975c54a..673f30eb9 100644 --- a/src/libsystemd-bus/bus-internal.h +++ b/src/libsystemd-bus/bus-internal.h @@ -24,6 +24,7 @@ #include #include #include +#include #include "hashmap.h" #include "prioq.h" @@ -35,6 +36,7 @@ #include "bus-error.h" #include "bus-match.h" #include "bus-kernel.h" +#include "kdbus.h" struct reply_callback { sd_bus_message_handler_t callback; @@ -53,14 +55,63 @@ struct filter_callback { LIST_FIELDS(struct filter_callback, callbacks); }; -struct object_callback { +struct node { + char *path; + struct node *parent; + LIST_HEAD(struct node, child); + LIST_FIELDS(struct node, siblings); + + LIST_HEAD(struct node_callback, callbacks); + LIST_HEAD(struct node_vtable, vtables); + LIST_HEAD(struct node_enumerator, enumerators); + + bool object_manager; +}; + +struct node_callback { + struct node *node; + + bool is_fallback; sd_bus_message_handler_t callback; void *userdata; - char *path; + unsigned last_iteration; + + LIST_FIELDS(struct node_callback, callbacks); +}; + +struct node_enumerator { + struct node *node; + + sd_bus_node_enumerator_t callback; + void *userdata; + + unsigned last_iteration; + + LIST_FIELDS(struct node_enumerator, enumerators); +}; + +struct node_vtable { + struct node *node; + + char *interface; bool is_fallback; + const sd_bus_vtable *vtable; + void *userdata; + sd_bus_object_find_t find; unsigned last_iteration; + + LIST_FIELDS(struct node_vtable, vtables); +}; + +struct vtable_member { + const char *path; + const char *interface; + const char *member; + struct node_vtable *parent; + unsigned last_iteration; + const sd_bus_vtable *vtable; }; enum bus_state { @@ -69,11 +120,12 @@ enum bus_state { BUS_AUTHENTICATING, BUS_HELLO, BUS_RUNNING, + BUS_CLOSING, BUS_CLOSED }; static inline bool BUS_IS_OPEN(enum bus_state state) { - return state > BUS_UNSET && state < BUS_CLOSED; + return state > BUS_UNSET && state < BUS_CLOSING; } enum bus_auth { @@ -96,9 +148,9 @@ struct sd_bus { enum bus_state state; int input_fd, output_fd; int message_version; + int message_endian; bool is_kernel:1; - bool negotiate_fds:1; bool can_fds:1; bool bus_client:1; bool ucred_valid:1; @@ -106,30 +158,39 @@ struct sd_bus { bool anonymous_auth:1; bool prefer_readv:1; bool prefer_writev:1; - bool processing:1; bool match_callbacks_modified:1; bool filter_callbacks_modified:1; - bool object_callbacks_modified:1; + bool nodes_modified:1; + bool trusted:1; + bool fake_creds_valid:1; + + int use_memfd; void *rbuffer; size_t rbuffer_size; sd_bus_message **rqueue; unsigned rqueue_size; + size_t rqueue_allocated; sd_bus_message **wqueue; unsigned wqueue_size; size_t windex; + size_t wqueue_allocated; uint64_t serial; char *unique_name; + uint64_t unique_id; struct bus_match_node match_callbacks; Prioq *reply_callbacks_prioq; Hashmap *reply_callbacks; LIST_HEAD(struct filter_callback, filter_callbacks); - Hashmap *object_callbacks; + + Hashmap *nodes; + Hashmap *vtable_methods; + Hashmap *vtable_properties; union { struct sockaddr sa; @@ -140,6 +201,7 @@ struct sd_bus { socklen_t sockaddr_size; char *kernel; + char *machine; sd_id128_t server_id; @@ -158,6 +220,8 @@ struct sd_bus { struct ucred ucred; char label[NAME_MAX]; + uint64_t creds_mask; + int *fds; unsigned n_fds; @@ -169,23 +233,43 @@ struct sd_bus { void *kdbus_buffer; + /* We do locking around the memfd cache, since we want to + * allow people to process a sd_bus_message in a different + * thread then it was generated on and free it there. Since + * adding something to the memfd cache might happen when a + * message is released, we hence need to protect this bit with + * a mutex. */ + pthread_mutex_t memfd_cache_mutex; struct memfd_cache memfd_cache[MEMFD_CACHE_MAX]; unsigned n_memfd_cache; pid_t original_pid; -}; -static inline void bus_unrefp(sd_bus **b) { - sd_bus_unref(*b); -} + uint64_t hello_flags; + uint64_t attach_flags; + + uint64_t match_cookie; + + sd_event_source *input_io_event_source; + sd_event_source *output_io_event_source; + sd_event_source *time_event_source; + sd_event_source *quit_event_source; + sd_event *event; + int event_priority; -#define _cleanup_bus_unref_ __attribute__((cleanup(bus_unrefp))) -#define _cleanup_bus_error_free_ __attribute__((cleanup(sd_bus_error_free))) + sd_bus_message *current; + + sd_bus **default_bus_ptr; + pid_t tid; + + struct kdbus_creds fake_creds; + char *fake_label; +}; #define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC)) -#define BUS_WQUEUE_MAX 128 -#define BUS_RQUEUE_MAX 128 +#define BUS_WQUEUE_MAX 1024 +#define BUS_RQUEUE_MAX 64*1024 #define BUS_MESSAGE_SIZE_MAX (64*1024*1024) #define BUS_AUTH_SIZE_MAX (64*1024) @@ -200,10 +284,11 @@ static inline void bus_unrefp(sd_bus **b) { #define BUS_EXEC_ARGV_MAX 256 -bool object_path_is_valid(const char *p); bool interface_name_is_valid(const char *p); bool service_name_is_valid(const char *p); bool member_name_is_valid(const char *p); +bool object_path_is_valid(const char *p); +char *object_path_startswith(const char *a, const char *b); bool namespace_complex_pattern(const char *pattern, const char *value); bool path_complex_pattern(const char *pattern, const char *value); @@ -220,4 +305,21 @@ int bus_ensure_running(sd_bus *bus); int bus_start_running(sd_bus *bus); int bus_next_address(sd_bus *bus); +int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m); + +int bus_rqueue_make_room(sd_bus *bus); + bool bus_pid_changed(sd_bus *bus); + +char *bus_address_escape(const char *v); + +#define OBJECT_PATH_FOREACH_PREFIX(prefix, path) \ + for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \ + _slash && !(_slash[(_slash) == (prefix)] = 0); \ + _slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/')) + +/* If we are invoking callbacks of a bus object, ensure unreffing the + * bus from the callback doesn't destroy the object we are working + * on */ +#define BUS_DONT_DESTROY(bus) \ + _cleanup_bus_unref_ _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)