[systemd.git] / src / libsystemd / sd-bus / bus-internal.h

/* SPDX-License-Identifier: LGPL-2.1+ */
#pragma once

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <pthread.h>
#include <sys/socket.h>

#include "sd-bus.h"

#include "bus-error.h"
#include "bus-kernel.h"
#include "bus-match.h"
#include "def.h"
#include "hashmap.h"
#include "list.h"
#include "prioq.h"
#include "refcnt.h"
#include "socket-util.h"
#include "util.h"

struct reply_callback {
        sd_bus_message_handler_t callback;
        usec_t timeout;
        uint64_t cookie;
        unsigned prioq_idx;
};

struct filter_callback {
        sd_bus_message_handler_t callback;

        unsigned last_iteration;

        LIST_FIELDS(struct filter_callback, callbacks);
};

struct match_callback {
        sd_bus_message_handler_t callback;

        unsigned last_iteration;

        char *match_string;

        struct bus_match_node *match_node;
};

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);
        LIST_HEAD(struct node_object_manager, object_managers);
};

struct node_callback {
        struct node *node;

        bool is_fallback;
        sd_bus_message_handler_t callback;

        unsigned last_iteration;

        LIST_FIELDS(struct node_callback, callbacks);
};

struct node_enumerator {
        struct node *node;

        sd_bus_node_enumerator_t callback;

        unsigned last_iteration;

        LIST_FIELDS(struct node_enumerator, enumerators);
};

struct node_object_manager {
        struct node *node;

        LIST_FIELDS(struct node_object_manager, object_managers);
};

struct node_vtable {
        struct node *node;

        char *interface;
        bool is_fallback;
        const sd_bus_vtable *vtable;
        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;
};

typedef enum BusSlotType {
        BUS_REPLY_CALLBACK,
        BUS_FILTER_CALLBACK,
        BUS_MATCH_CALLBACK,
        BUS_NODE_CALLBACK,
        BUS_NODE_ENUMERATOR,
        BUS_NODE_VTABLE,
        BUS_NODE_OBJECT_MANAGER,
        _BUS_SLOT_INVALID = -1,
} BusSlotType;

struct sd_bus_slot {
        unsigned n_ref;
        sd_bus *bus;
        void *userdata;
        BusSlotType type:5;
        bool floating:1;
        bool match_added:1;
        char *description;

        LIST_FIELDS(sd_bus_slot, slots);

        union {
                struct reply_callback reply_callback;
                struct filter_callback filter_callback;
                struct match_callback match_callback;
                struct node_callback node_callback;
                struct node_enumerator node_enumerator;
                struct node_object_manager node_object_manager;
                struct node_vtable node_vtable;
        };
};

enum bus_state {
        BUS_UNSET,
        BUS_OPENING,
        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_CLOSING;
}

enum bus_auth {
        _BUS_AUTH_INVALID,
        BUS_AUTH_EXTERNAL,
        BUS_AUTH_ANONYMOUS
};

struct sd_bus {
        /* 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 input_fd, output_fd;
        int message_version;
        int message_endian;

        bool can_fds: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 match_callbacks_modified:1;
        bool filter_callbacks_modified:1;
        bool nodes_modified:1;
        bool trusted:1;
        bool manual_peer_interface:1;
        bool is_system:1;
        bool is_user:1;
        bool allow_interactive_authorization:1;
        bool exit_on_disconnect:1;
        bool exited:1;
        bool exit_triggered:1;
        bool is_local: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 cookie;

        char *unique_name;
        uint64_t unique_id;

        struct bus_match_node match_callbacks;
        Prioq *reply_callbacks_prioq;
        OrderedHashmap *reply_callbacks;
        LIST_HEAD(struct filter_callback, filter_callbacks);

        Hashmap *nodes;
        Hashmap *vtable_methods;
        Hashmap *vtable_properties;

        union sockaddr_union sockaddr;
        socklen_t sockaddr_size;

        char *machine;
        pid_t nspid;

        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;
        char *auth_buffer;
        usec_t auth_timeout;

        struct ucred ucred;
        char *label;

        uint64_t creds_mask;

        int *fds;
        unsigned n_fds;

        char *exec_path;
        char **exec_argv;

        unsigned iteration_counter;

        /* 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 attach_flags;

        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;

        sd_bus_message *current_message;
        sd_bus_slot *current_slot;
        sd_bus_message_handler_t current_handler;
        void *current_userdata;

        sd_bus **default_bus_ptr;
        pid_t tid;

        char *cgroup_root;

        char *description;

        sd_bus_track *track_queue;

        LIST_HEAD(sd_bus_slot, slots);
        LIST_HEAD(sd_bus_track, tracks);
};

/* For method calls we time-out at 25s, like in the D-Bus reference implementation */
#define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))

/* For the authentication phase we grant 90s, to provide extra room during boot, when RNGs and such are not filled up
 * with enough entropy yet and might delay the boot */
#define BUS_AUTH_TIMEOUT ((usec_t) DEFAULT_TIMEOUT_USEC)

#define BUS_WQUEUE_MAX (192*1024)
#define BUS_RQUEUE_MAX (192*1024)

#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) _pure_;
bool service_name_is_valid(const char *p) _pure_;
char* service_name_startswith(const char *a, const char *b);
bool member_name_is_valid(const char *p) _pure_;
bool object_path_is_valid(const char *p) _pure_;
char *object_path_startswith(const char *a, const char *b) _pure_;

bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
bool path_complex_pattern(const char *pattern, const char *value) _pure_;

bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
bool path_simple_pattern(const char *pattern, const char *value) _pure_;

int bus_message_type_from_string(const char *s, uint8_t *u) _pure_;
const char *bus_message_type_to_string(uint8_t u) _pure_;

#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);

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_(sd_bus_unrefp) _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)

int bus_set_address_system(sd_bus *bus);
int bus_set_address_user(sd_bus *bus);
int bus_set_address_system_remote(sd_bus *b, const char *host);
int bus_set_address_system_machine(sd_bus *b, const char *machine);

int bus_remove_match_by_string(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata);

int bus_get_root_path(sd_bus *bus);

int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error);

#define bus_assert_return(expr, r, error)                               \
        do {                                                            \
                if (!assert_log(expr, #expr))                           \
                        return sd_bus_error_set_errno(error, r);        \
        } while (false)

/**
 * enum kdbus_attach_flags - flags for metadata attachments
 * @KDBUS_ATTACH_TIMESTAMP:             Timestamp
 * @KDBUS_ATTACH_CREDS:                 Credentials
 * @KDBUS_ATTACH_PIDS:                  PIDs
 * @KDBUS_ATTACH_AUXGROUPS:             Auxiliary groups
 * @KDBUS_ATTACH_NAMES:                 Well-known names
 * @KDBUS_ATTACH_TID_COMM:              The "comm" process identifier of the TID
 * @KDBUS_ATTACH_PID_COMM:              The "comm" process identifier of the PID
 * @KDBUS_ATTACH_EXE:                   The path of the executable
 * @KDBUS_ATTACH_CMDLINE:               The process command line
 * @KDBUS_ATTACH_CGROUP:                The croup membership
 * @KDBUS_ATTACH_CAPS:                  The process capabilities
 * @KDBUS_ATTACH_SECLABEL:              The security label
 * @KDBUS_ATTACH_AUDIT:                 The audit IDs
 * @KDBUS_ATTACH_CONN_DESCRIPTION:      The human-readable connection name
 * @_KDBUS_ATTACH_ALL:                  All of the above
 * @_KDBUS_ATTACH_ANY:                  Wildcard match to enable any kind of
 *                                      metatdata.
 */
enum kdbus_attach_flags {
        KDBUS_ATTACH_TIMESTAMP          =  1ULL <<  0,
        KDBUS_ATTACH_CREDS              =  1ULL <<  1,
        KDBUS_ATTACH_PIDS               =  1ULL <<  2,
        KDBUS_ATTACH_AUXGROUPS          =  1ULL <<  3,
        KDBUS_ATTACH_NAMES              =  1ULL <<  4,
        KDBUS_ATTACH_TID_COMM           =  1ULL <<  5,
        KDBUS_ATTACH_PID_COMM           =  1ULL <<  6,
        KDBUS_ATTACH_EXE                =  1ULL <<  7,
        KDBUS_ATTACH_CMDLINE            =  1ULL <<  8,
        KDBUS_ATTACH_CGROUP             =  1ULL <<  9,
        KDBUS_ATTACH_CAPS               =  1ULL << 10,
        KDBUS_ATTACH_SECLABEL           =  1ULL << 11,
        KDBUS_ATTACH_AUDIT              =  1ULL << 12,
        KDBUS_ATTACH_CONN_DESCRIPTION   =  1ULL << 13,
        _KDBUS_ATTACH_ALL               =  (1ULL << 14) - 1,
        _KDBUS_ATTACH_ANY               =  ~0ULL
};

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