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=5795f74693e282536abbf72337ba18ff29cddc73;hp=636e998c302e89fe5985d4d191299595d9909a7c;hb=29ddb38fea134c6132e4f2dd608e9da3871eaebe;hpb=b9bf7e2be93fe25e0e96e06ad436d43a1e589ed5 diff --git a/src/libsystemd-bus/bus-internal.h b/src/libsystemd-bus/bus-internal.h index 636e998c3..5795f7469 100644 --- a/src/libsystemd-bus/bus-internal.h +++ b/src/libsystemd-bus/bus-internal.h @@ -24,17 +24,21 @@ #include #include #include +#include #include "hashmap.h" #include "prioq.h" #include "list.h" #include "util.h" +#include "refcnt.h" #include "sd-bus.h" #include "bus-error.h" +#include "bus-match.h" +#include "bus-kernel.h" struct reply_callback { - sd_message_handler_t callback; + sd_bus_message_handler_t callback; void *userdata; usec_t timeout; uint64_t serial; @@ -42,26 +46,121 @@ struct reply_callback { }; struct filter_callback { - sd_message_handler_t callback; + sd_bus_message_handler_t callback; void *userdata; + unsigned last_iteration; + LIST_FIELDS(struct filter_callback, callbacks); }; +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; + + 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 { + BUS_UNSET, BUS_OPENING, BUS_AUTHENTICATING, BUS_HELLO, - BUS_RUNNING + BUS_RUNNING, + BUS_CLOSED +}; + +static inline bool BUS_IS_OPEN(enum bus_state state) { + return state > BUS_UNSET && state < BUS_CLOSED; +} + +enum bus_auth { + _BUS_AUTH_INVALID, + BUS_AUTH_EXTERNAL, + BUS_AUTH_ANONYMOUS }; struct sd_bus { - unsigned n_ref; + /* We use atomic ref counting here since sd_bus_message + objects retain references to their originating sd_bus but + we want to allow them to be processed in a different + thread. We won't provide full thread safety, but only the + bare minimum that makes it possible to use sd_bus and + sd_bus_message objects independently and on different + threads as long as each object is used only once at the + same time. */ + RefCount n_ref; + enum bus_state state; - int fd; + int input_fd, output_fd; int message_version; + + bool is_kernel:1; bool can_fds:1; - bool sent_hello:1; + bool bus_client:1; + bool ucred_valid:1; + bool is_server:1; + 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 nodes_modified:1; + + int use_memfd; void *rbuffer; size_t rbuffer_size; @@ -77,10 +176,17 @@ struct sd_bus { char *unique_name; + struct bus_match_node match_callbacks; Prioq *reply_callbacks_prioq; Hashmap *reply_callbacks; LIST_HEAD(struct filter_callback, filter_callbacks); + Hashmap *nodes; + + + Hashmap *vtable_methods; + Hashmap *vtable_properties; + union { struct sockaddr sa; struct sockaddr_un un; @@ -89,18 +195,51 @@ struct sd_bus { } sockaddr; socklen_t sockaddr_size; - sd_id128_t peer; + char *kernel; + + sd_id128_t server_id; char *address; unsigned address_index; int last_connect_error; + enum bus_auth auth; + size_t auth_rbegin; struct iovec auth_iovec[3]; unsigned auth_index; - size_t auth_size; - char *auth_uid; + char *auth_buffer; usec_t auth_timeout; + + struct ucred ucred; + char label[NAME_MAX]; + + int *fds; + unsigned n_fds; + + char *exec_path; + char **exec_argv; + + uint64_t hello_serial; + unsigned iteration_counter; + + 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; + + uint64_t hello_flags; + + uint64_t match_cookie; }; static inline void bus_unrefp(sd_bus **b) { @@ -117,3 +256,36 @@ static inline void bus_unrefp(sd_bus **b) { #define BUS_MESSAGE_SIZE_MAX (64*1024*1024) #define BUS_AUTH_SIZE_MAX (64*1024) + +#define BUS_CONTAINER_DEPTH 128 + +/* Defined by the specification as maximum size of an array in + * bytes */ +#define BUS_ARRAY_MAX_SIZE 67108864 + +#define BUS_FDS_MAX 1024 + +#define BUS_EXEC_ARGV_MAX 256 + +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); + +bool namespace_simple_pattern(const char *pattern, const char *value); +bool path_simple_pattern(const char *pattern, const char *value); + +int bus_message_type_from_string(const char *s, uint8_t *u); +const char *bus_message_type_to_string(uint8_t u); + +#define error_name_is_valid interface_name_is_valid + +int bus_ensure_running(sd_bus *bus); +int bus_start_running(sd_bus *bus); +int bus_next_address(sd_bus *bus); + +bool bus_pid_changed(sd_bus *bus);