picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Systemd/src/systemd/sd-bus.h

534 lines
29 KiB
C
Raw Normal View History

license: LGPL-2.1+ -> LGPL-2.1-or-later
2020-11-09 05:23:58 +01:00
/* SPDX-License-Identifier: LGPL-2.1-or-later */
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
#ifndef foosdbushfoo
#define foosdbushfoo
/***
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 <inttypes.h>
sd-bus: export sd_bus_error_set_errnofv()
2015-02-13 15:34:54 +01:00
#include <stdarg.h>
sd-bus: export sd_bus_message_dump Fixes #14640.
2020-01-23 18:42:54 +01:00
#include <stdio.h>
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
#include <sys/types.h>
bus: add APIs for adding iovecs to messages as string or arrays
2013-11-11 16:26:12 +01:00
#include <sys/uio.h>
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
#include "sd-event.h"
tree-wide: sort includes in *.h This is a continuation of the previous include sort patch, which only sorted for .c files.
2015-11-18 22:46:33 +01:00
#include "sd-id128.h"
api: unify some common bits used by public systemd APIs
2013-10-16 17:00:13 +02:00
#include "_sd-common.h"
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
api: replace manual C++ guards by macros
2013-11-07 16:44:48 +01:00
_SD_BEGIN_DECLARATIONS;
bus: add C++ wrappers to public header files
2013-03-29 23:20:32 +01:00
Add support for SD_BUS_DEFAULT* Currently, sd-bus supports the ability to have thread-local default busses. However, this is less useful than it can be since all functions which require an sd_bus* as input require the caller to pass it. This patch adds a new macro which allows the developer to pass a constant SD_BUS_DEFAULT, SD_BUS_DEFAULT_USER or SD_BUS_DEFAULT_SYSTEM instead. This reduces work for the caller. For example: r = sd_bus_default(&bus); r = sd_bus_call_method(bus, ...); sd_bus_unref(bus); Becomes: r = sd_bus_call_method(SD_BUS_DEFAULT, ...); If the specified thread-local default bus does not exist, the function calls will return -ENOPKG. No bus will ever be implicitly created.
2018-01-22 22:26:44 +01:00
#define SD_BUS_DEFAULT ((sd_bus *) 1)
#define SD_BUS_DEFAULT_USER ((sd_bus *) 2)
#define SD_BUS_DEFAULT_SYSTEM ((sd_bus *) 3)
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
/* Types */
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
typedef struct sd_bus sd_bus;
typedef struct sd_bus_message sd_bus_message;
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
typedef struct sd_bus_slot sd_bus_slot;
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
typedef struct sd_bus_creds sd_bus_creds;
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
typedef struct sd_bus_track sd_bus_track;
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
typedef struct {
const char *name;
const char *message;
bus: support temporarily const errors that don't need to be freed but require deep copies This should fix issues with incorrectly copying bus error messages out of sd_bus_message objects. Original bug found by: Djalal Harouni
2013-11-30 19:45:32 +01:00
int _need_free;
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
} sd_bus_error;
sd-bus: rework ELF error mapping table magic The ELF magic cannot work for consumers of our shard library, since they are in a different module. Hence make all the ELF magic private, and instead introduce a public function to register additional static mapping table.
2014-12-06 02:39:15 +01:00
typedef struct {
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
const char *name;
sd-bus: rework ELF error mapping table magic The ELF magic cannot work for consumers of our shard library, since they are in a different module. Hence make all the ELF magic private, and instead introduce a public function to register additional static mapping table.
2014-12-06 02:39:15 +01:00
int code;
} sd_bus_error_map;
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
/* Flags */
enum {
sd-bus: add supplementary groups list to creds object
2014-11-25 13:21:23 +01:00
SD_BUS_CREDS_PID = 1ULL << 0,
sd-bus: get rid of PID starttime concept As kdbus no longer exports this, remove all traces from sd-bus too
2014-12-09 18:16:54 +01:00
SD_BUS_CREDS_TID = 1ULL << 1,
sd-bus: expose ppid field kdbus has been passing us the ppid file for a while, actually make use of it.
2015-04-21 20:58:09 +02:00
SD_BUS_CREDS_PPID = 1ULL << 2,
SD_BUS_CREDS_UID = 1ULL << 3,
SD_BUS_CREDS_EUID = 1ULL << 4,
SD_BUS_CREDS_SUID = 1ULL << 5,
SD_BUS_CREDS_FSUID = 1ULL << 6,
SD_BUS_CREDS_GID = 1ULL << 7,
SD_BUS_CREDS_EGID = 1ULL << 8,
SD_BUS_CREDS_SGID = 1ULL << 9,
SD_BUS_CREDS_FSGID = 1ULL << 10,
SD_BUS_CREDS_SUPPLEMENTARY_GIDS = 1ULL << 11,
SD_BUS_CREDS_COMM = 1ULL << 12,
SD_BUS_CREDS_TID_COMM = 1ULL << 13,
SD_BUS_CREDS_EXE = 1ULL << 14,
SD_BUS_CREDS_CMDLINE = 1ULL << 15,
SD_BUS_CREDS_CGROUP = 1ULL << 16,
SD_BUS_CREDS_UNIT = 1ULL << 17,
sd-bus,sd-login: add api for querying the slice within the the user systemd instance of a process units are organized in slice trees, not only for the system instance, but also for user systemd instances, expose this properly.
2015-04-30 11:58:06 +02:00
SD_BUS_CREDS_SLICE = 1ULL << 18,
SD_BUS_CREDS_USER_UNIT = 1ULL << 19,
SD_BUS_CREDS_USER_SLICE = 1ULL << 20,
SD_BUS_CREDS_SESSION = 1ULL << 21,
SD_BUS_CREDS_OWNER_UID = 1ULL << 22,
SD_BUS_CREDS_EFFECTIVE_CAPS = 1ULL << 23,
SD_BUS_CREDS_PERMITTED_CAPS = 1ULL << 24,
SD_BUS_CREDS_INHERITABLE_CAPS = 1ULL << 25,
SD_BUS_CREDS_BOUNDING_CAPS = 1ULL << 26,
SD_BUS_CREDS_SELINUX_CONTEXT = 1ULL << 27,
SD_BUS_CREDS_AUDIT_SESSION_ID = 1ULL << 28,
SD_BUS_CREDS_AUDIT_LOGIN_UID = 1ULL << 29,
SD_BUS_CREDS_TTY = 1ULL << 30,
SD_BUS_CREDS_UNIQUE_NAME = 1ULL << 31,
SD_BUS_CREDS_WELL_KNOWN_NAMES = 1ULL << 32,
SD_BUS_CREDS_DESCRIPTION = 1ULL << 33,
sd-bus: add supplementary groups list to creds object
2014-11-25 13:21:23 +01:00
SD_BUS_CREDS_AUGMENT = 1ULL << 63, /* special flag, if on sd-bus will augment creds struct, in a potentially race-full way. */
headers: remove commas at end of enum lists src/systemd/sd-journal.h:75:51: warning: commas at the end of enumerator lists are a C99-specific feature [-Wc99-extensions]
2016-03-11 19:50:56 +01:00
_SD_BUS_CREDS_ALL = (1ULL << 34) -1
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
};
bus: instead of exposing the dbus1 flags when acquiring a name use our own that are closer to kdbus This turns around DO_NOT_QUEUE into QUEUE which implies a more useful default. (And negative options are awful anyway.)
2013-12-12 05:55:58 +01:00
enum {
SD_BUS_NAME_REPLACE_EXISTING = 1ULL << 0,
SD_BUS_NAME_ALLOW_REPLACEMENT = 1ULL << 1,
headers: remove commas at end of enum lists src/systemd/sd-journal.h:75:51: warning: commas at the end of enumerator lists are a C99-specific feature [-Wc99-extensions]
2016-03-11 19:50:56 +01:00
SD_BUS_NAME_QUEUE = 1ULL << 2
bus: instead of exposing the dbus1 flags when acquiring a name use our own that are closer to kdbus This turns around DO_NOT_QUEUE into QUEUE which implies a more useful default. (And negative options are awful anyway.)
2013-12-12 05:55:58 +01:00
};
sd-bus: make dump flags public
2020-01-23 12:36:55 +01:00
enum {
SD_BUS_MESSAGE_DUMP_WITH_HEADER = 1ULL << 0,
SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY = 1ULL << 1,
};
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
/* Callbacks */
sd-bus: drop bus parameter from message callback prototype This should simplify the prototype a bit. The bus parameter is redundant in most cases, and in the few where it matters it can be derived from the message via sd_bus_message_get_bus().
2015-04-29 18:35:10 +02:00
typedef int (*sd_bus_message_handler_t)(sd_bus_message *m, void *userdata, sd_bus_error *ret_error);
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
typedef int (*sd_bus_property_get_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *ret_error);
typedef int (*sd_bus_property_set_t) (sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *ret_error);
bus: also add error parameter to object find and enumerator callbacks Just in order to bring things inline with the method and property callbacks.
2013-11-22 01:14:57 +01:00
typedef int (*sd_bus_object_find_t) (sd_bus *bus, const char *path, const char *interface, void *userdata, void **ret_found, sd_bus_error *ret_error);
sd-bus: drop bus parameter from message callback prototype This should simplify the prototype a bit. The bus parameter is redundant in most cases, and in the few where it matters it can be derived from the message via sd_bus_message_get_bus().
2015-04-29 18:35:10 +02:00
typedef int (*sd_bus_node_enumerator_t) (sd_bus *bus, const char *prefix, void *userdata, char ***ret_nodes, sd_bus_error *ret_error);
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
typedef int (*sd_bus_track_handler_t) (sd_bus_track *track, void *userdata);
libsystemd: introduce _sd_destroy_t
2018-11-28 16:28:53 +01:00
typedef _sd_destroy_t sd_bus_destroy_t;
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
#include "sd-bus-protocol.h"
#include "sd-bus-vtable.h"
sd-bus: make name validation functions public Those are fairly trivial to reimplement, but any non-trivial user of sd-bus is likely to need them. So let's expose them to save everyone the trouble. I'm keeping the internal functions and making the public ones thin wrappers, because for the internal uses we don't need the additional asserts, and also we can't expose _pure_ annotation easily, and dropping it would likely make the compiled code a bit less efficient.
2020-05-24 12:51:51 +02:00
/* Naming */
int sd_bus_interface_name_is_valid(const char *p);
int sd_bus_service_name_is_valid(const char *p);
int sd_bus_member_name_is_valid(const char *p);
int sd_bus_object_path_is_valid(const char *p);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
/* Connections */
bus: reorder a few things
2014-01-28 12:33:32 +01:00
int sd_bus_default(sd_bus **ret);
bus: introduce concept of a default bus for each thread and make use of it everywhere We want to emphasize bus connections as per-thread communication primitives, hence introduce a concept of a per-thread default bus, and make use of it everywhere.
2013-11-11 22:00:48 +01:00
int sd_bus_default_user(sd_bus **ret);
int sd_bus_default_system(sd_bus **ret);
bus: add API calls for connecting to starter bus Add new calls sd_bus_open() and sd_bus_default() for connecting to the starter bus a service was invoked for, or -- if the process is not a bus-activated service -- the appropriate bus for the scope the process has been started in.
2014-01-27 21:34:54 +01:00
int sd_bus_open(sd_bus **ret);
sd-bus: allow description to be set for system/user busses (#8594) sd_bus_open/sd_bus_open_system/sd_bus_open_user are convenient, but don't allow the description to be set. After they return, the bus is is already started, and sd_bus_set_description() fails with -EBUSY. It would be possible to allow sd_bus_set_description() to update the description "live", but messages are already emitted from sd_bus_open functions, so it's better to allow the description to be set in sd_bus_open/sd_bus_open_system/sd_bus_open_user. Fixes message like: Bus n/a: changing state UNSET → OPENING
2018-03-29 16:14:11 +02:00
int sd_bus_open_with_description(sd_bus **ret, const char *description);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_open_user(sd_bus **ret);
sd-bus: allow description to be set for system/user busses (#8594) sd_bus_open/sd_bus_open_system/sd_bus_open_user are convenient, but don't allow the description to be set. After they return, the bus is is already started, and sd_bus_set_description() fails with -EBUSY. It would be possible to allow sd_bus_set_description() to update the description "live", but messages are already emitted from sd_bus_open functions, so it's better to allow the description to be set in sd_bus_open/sd_bus_open_system/sd_bus_open_user. Fixes message like: Bus n/a: changing state UNSET → OPENING
2018-03-29 16:14:11 +02:00
int sd_bus_open_user_with_description(sd_bus **ret, const char *description);
sd-bus: add API for connecting to a specific user's user bus of a specific container This is unfortunately harder to implement than it sounds. The user's bus is bound a to the user's lifecycle after all (i.e. only exists as long as the user has at least one PAM session), and the path dynamically (at least theoretically, in practice it's going to be the same always) generated via $XDG_RUNTIME_DIR in /run/. To fix this properly, we'll thus go through PAM before connecting to a user bus. Which is hard since we cannot just link against libpam in the container, since the container might have been compiled entirely differently. So our way out is to use systemd-run from outside, which invokes a transient unit that does PAM from outside, doing so via D-Bus. Inside the transient unit we then invoke systemd-stdio-bridge which forwards D-Bus from the user bus to us. The systemd-stdio-bridge makes up the PAM session and thus we can sure tht the bus exists at least as long as the bus connection is kept. Or so say this differently: if you use "systemctl -M lennart@foobar" now, the bus connection works like this: 1. sd-bus on the host forks off: systemd-run -M foobar -PGq --wait -pUser=lennart -pPAMName=login systemd-stdio-bridge 2. systemd-run gets a connection to the "foobar" container's system bus, and invokes the "systemd-stdio-bridge" binary as transient service inside a PAM session for the user "lennart" 3. The systemd-stdio-bridge then proxies our D-Bus traffic to the user bus. sd-bus (on host) → systemd-run (on host) → systemd-stdio-bridge (in container) Complicated? Well, to some point yes, but otoh it's actually nice in various other ways, primarily as it makes the -H and -M codepaths more alike. In the -H case (i.e. connect to remote host via SSH) a very similar three steps are used. The only difference is that instead of "systemd-run" the "ssh" binary is used to invoke the stdio bridge in a PAM session of some other system. Thus we get similar implementation and isolation for similar operations. Fixes: #14580
2020-12-14 13:21:58 +01:00
int sd_bus_open_user_machine(sd_bus **ret, const char *machine);
bus: move ssh support into public API of libsystem-bus
2013-10-30 13:52:40 +01:00
int sd_bus_open_system(sd_bus **ret);
sd-bus: allow description to be set for system/user busses (#8594) sd_bus_open/sd_bus_open_system/sd_bus_open_user are convenient, but don't allow the description to be set. After they return, the bus is is already started, and sd_bus_set_description() fails with -EBUSY. It would be possible to allow sd_bus_set_description() to update the description "live", but messages are already emitted from sd_bus_open functions, so it's better to allow the description to be set in sd_bus_open/sd_bus_open_system/sd_bus_open_user. Fixes message like: Bus n/a: changing state UNSET → OPENING
2018-03-29 16:14:11 +02:00
int sd_bus_open_system_with_description(sd_bus **ret, const char *description);
sd-bus: the bus returned should be the first arg This matches the API of previous headers, such as sd-journal.h.
2014-02-18 19:11:08 +01:00
int sd_bus_open_system_remote(sd_bus **ret, const char *host);
sd-bus: rename sd_bus_open_system_container() to sd_bus_open_system_machine() Pretty much everywhere else we use the generic term "machine" when referring to containers in API, so let's do though in sd-bus too. In particular, since the concept of a "container" exists in sd-bus too, but as part of the marshalling system.
2014-12-23 23:38:13 +01:00
int sd_bus_open_system_machine(sd_bus **ret, const char *machine);
bus: make optional whether unix socket passing is negotiated and whether hello is sent This alos gets rid of explicit sd_open_fd() and sd_open_address() constructors in favour of sd_new() + sd_new_start() where the negotiation parameters may be set it in between.
2013-03-24 23:55:03 +01:00
int sd_bus_new(sd_bus **ret);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
bus: make optional whether unix socket passing is negotiated and whether hello is sent This alos gets rid of explicit sd_open_fd() and sd_open_address() constructors in favour of sd_new() + sd_new_start() where the negotiation parameters may be set it in between.
2013-03-24 23:55:03 +01:00
int sd_bus_set_address(sd_bus *bus, const char *address);
bus: fall back to readv/writev if recvmsg/sendmsg don't work
2013-03-31 20:19:18 +02:00
int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd);
sd-bus: Use pointer syntax for sd_bus_set_exec argv parameter
2020-04-11 21:57:28 +02:00
int sd_bus_set_exec(sd_bus *bus, const char *path, char *const *argv);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_get_address(sd_bus *bus, const char **address);
bus: rename send_hello flag to bus_cient This way we can hide more than just the hello logic behind this flag, for example, later on automatic match management.
2013-03-26 00:36:43 +01:00
int sd_bus_set_bus_client(sd_bus *bus, int b);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_is_bus_client(sd_bus *bus);
sd-bus: add new sd_bus_get_address() for querying the current bus address Also, update "busctl" to show this in its output.
2014-11-28 16:51:45 +01:00
int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t bus_id);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_is_server(sd_bus *bus);
bus: implement server mode, and anonymous authentication
2013-03-30 15:21:06 +01:00
int sd_bus_set_anonymous(sd_bus *bus, int b);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_is_anonymous(sd_bus *bus);
bus: introduce "trusted" bus concept and encode access control in object vtables Introduces a new concept of "trusted" vs. "untrusted" busses. For the latter libsystemd-bus will automatically do per-method access control, for the former all access is automatically granted. Per-method access control is encoded in the vtables: by default all methods are only accessible to privileged clients. If the SD_BUS_VTABLE_UNPRIVILEGED flag is set for a method it is accessible to unprivileged clients too. By default whether a client is privileged is determined via checking for its CAP_SYS_ADMIN capability, but this can be altered via the SD_BUS_VTABLE_CAPABILITY() macro that can be ORed into the flags field of the method. Writable properties are also subject to SD_BUS_VTABLE_UNPRIVILEGED and SD_BUS_VTABLE_CAPABILITY() for controlling write access to them. Note however that read access is unrestricted, as PropertiesChanged messages might send out the values anyway as an unrestricted broadcast. By default the system bus is set to "untrusted" and the user bus is "trusted" since per-method access control on the latter is unnecessary. On dbus1 busses we check the UID of the caller rather than the configured capability since the capability cannot be determined without race. On kdbus the capability is checked if possible from the attached meta-data of a message and otherwise queried from the sending peer. This also decorates the vtables of the various daemons we ship with these flags.
2013-12-10 17:41:39 +01:00
int sd_bus_set_trusted(sd_bus *bus, int b);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_is_trusted(sd_bus *bus);
sd-bus: add proper monitoring API
2014-03-19 04:17:00 +01:00
int sd_bus_set_monitor(sd_bus *bus, int b);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_is_monitor(sd_bus *bus);
int sd_bus_set_description(sd_bus *bus, const char *description);
int sd_bus_get_description(sd_bus *bus, const char **description);
sd-bus,sd-event: make public APIs With the v221 release these APIs should be public, stable APIs, hence let's install their headers by default now, and add their symbols to the .sym file.
2015-05-22 14:32:51 +02:00
int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t creds_mask);
int sd_bus_negotiate_timestamp(sd_bus *bus, int b);
bus: add APIs for negotiating what is attached to messages
2013-05-17 04:25:56 +02:00
int sd_bus_negotiate_fds(sd_bus *bus, int b);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_can_send(sd_bus *bus, char type);
int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *creds_mask);
sd-bus: allow setting a per-connection default value for the "allow-interactive-authentication" message flag Most of our client tools want to set this bit for all their method calls, even though it defaults to off in sd-bus, and rightfully so. Hence, to simplify thing, introduce a per sd_bus-object flag that sets the default value for all messages created on the connection.
2015-02-17 20:30:33 +01:00
int sd_bus_set_allow_interactive_authorization(sd_bus *bus, int b);
int sd_bus_get_allow_interactive_authorization(sd_bus *bus);
sd-bus: optionally, exit process or event loop on disconnect Old libdbus has a feature that the process is terminated whenever the the bus connection receives a disconnect. This is pretty useful on desktop apps (where a disconnect indicates session termination), as well as on command line apps (where we really shouldn't stay hanging in most cases if dbus daemon goes down). Add a similar feature to sd-bus, but make it opt-in rather than opt-out, like it is on libdbus. Also, if the bus is attached to an event loop just exit the event loop rather than the the whole process.
2016-08-22 17:19:12 +02:00
int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b);
int sd_bus_get_exit_on_disconnect(sd_bus *bus);
sd-bus: make "close+flush-on-exit" optional when using sd-event with sd-bus This adds a new pair of API calls sd_bus_set_close_on_exit() and sd_bus_get_close_on_exit(). They control whether an sd_bus object attached to a an sd-event loop shall automatically be flushed/closed when the event loop goes down. Usually that's a good thing, except for very few cases where the bus connection is longer living than the event loop it is attached on. Specifically, this is the case for nspawn, where we run the event loop only while the container is up, but afterwards still want to be able to use the bus connection.
2018-10-06 18:43:28 +02:00
int sd_bus_set_close_on_exit(sd_bus *bus, int b);
int sd_bus_get_close_on_exit(sd_bus *bus);
sd-bus: optionally, use inotify to wait for bus sockets to appear This adds a "watch-bind" feature to sd-bus connections. If set and the AF_UNIX socket we are connecting to doesn't exist yet, we'll establish an inotify watch instead, and wait for the socket to appear. In other words, a missing AF_UNIX just makes connecting slower. This is useful for daemons such as networkd or resolved that shall be able to run during early-boot, before dbus-daemon is up, and want to connect to dbus-daemon as soon as it becomes ready.
2017-12-15 22:24:52 +01:00
int sd_bus_set_watch_bind(sd_bus *bus, int b);
int sd_bus_get_watch_bind(sd_bus *bus);
networkd,resolved: make use of watch_bind feature to connect to the bus The changes both networkd and resolved to make use of the watch_bind feature of sd-bus to connect to the system bus. This way, both daemons can be started during early boot, and automatically and instantly connect to the system bus as it becomes available. This replaces prior code that used a time-based retry logic to connect to the bus.
2017-12-19 15:54:30 +01:00
int sd_bus_set_connected_signal(sd_bus *bus, int b);
int sd_bus_get_connected_signal(sd_bus *bus);
sd-bus: add API to optionally set a sender field on all outgoing messages This is useful on direct connections to generate messages with valid sender fields. This is particularly useful for services that are accessible both through direct connections and the broker, as it allows clients to install matches on the sender service name, and they work the same in both cases.
2017-12-20 19:41:06 +01:00
int sd_bus_set_sender(sd_bus *bus, const char *sender);
int sd_bus_get_sender(sd_bus *bus, const char **ret);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
sd-bus: optionally, use inotify to wait for bus sockets to appear This adds a "watch-bind" feature to sd-bus connections. If set and the AF_UNIX socket we are connecting to doesn't exist yet, we'll establish an inotify watch instead, and wait for the socket to appear. In other words, a missing AF_UNIX just makes connecting slower. This is useful for daemons such as networkd or resolved that shall be able to run during early-boot, before dbus-daemon is up, and want to connect to dbus-daemon as soon as it becomes ready.
2017-12-15 22:24:52 +01:00
int sd_bus_start(sd_bus *bus);
bus: make optional whether unix socket passing is negotiated and whether hello is sent This alos gets rid of explicit sd_open_fd() and sd_open_address() constructors in favour of sd_new() + sd_new_start() where the negotiation parameters may be set it in between.
2013-03-24 23:55:03 +01:00
headers: get rid of pointless /* deprecated */ comment The _sd_deprecated_ annotation gives it all away, and the comment adds no additional value.
2020-04-17 14:01:07 +02:00
int sd_bus_try_close(sd_bus *bus) _sd_deprecated_;
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
void sd_bus_close(sd_bus *bus);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
sd_bus* sd_bus_ref(sd_bus *bus);
sd_bus* sd_bus_unref(sd_bus *bus);
sd_bus* sd_bus_close_unref(sd_bus *bus);
sd_bus* sd_bus_flush_close_unref(sd_bus *bus);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd-bus: introduce new sd_bus_default_flush_close() call If code enqueues a message on one of the default busses, but doesn't sync on it, and immediately drops the reference to the bus again, it will stay queued and consume memory. Intrdouce a new call sd_bus_default_flush_close() that can be invoked at the end of programs (or threads) and flushes out all unsent messages on any of the default busses.
2015-09-22 14:13:10 +02:00
void sd_bus_default_flush_close(void);
bus: implement full method call timeout logic
2013-03-21 22:50:25 +01:00
int sd_bus_is_open(sd_bus *bus);
sd-bus: add new sd_bus_is_ready() API This new call is much light sd_bus_is_open(), but returns true only if the connection is fully set up, i.e. after we finished with the authentication and Hello() phase. This API is useful for clients in particular when using the "watch_bind" feature, as that way it can be determined in advance whether it makes sense to sync on some operation.
2017-12-19 15:47:09 +01:00
int sd_bus_is_ready(sd_bus *bus);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
sd-bus: rename sd_bus_get_owner_id() → sd_bus_get_bus_id() The ID returned really doesn't identify the owner, but the bus instance, hence fix this misnaming. Also, update "busctl status" to show the ID in its output.
2014-11-28 16:38:47 +01:00
int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id);
sd-bus: add new call sd_bus_get_scope() for querying whether one is connected to a system or a user bus
2014-11-28 15:59:05 +01:00
int sd_bus_get_scope(sd_bus *bus, const char **scope);
bus: reorder a few things
2014-01-28 12:33:32 +01:00
int sd_bus_get_tid(sd_bus *bus, pid_t *tid);
sd-bus: make more connection properties readable
2014-11-28 17:03:35 +01:00
int sd_bus_get_owner_creds(sd_bus *bus, uint64_t creds_mask, sd_bus_creds **ret);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
bus: rename message "serial" to "cookie" Even if the lower-leveld dbus1 protocol calls it "serial", let's expose the word "cookie" for this instead, as this is what kdbus uses and since it doesn't imply monotonicity the same way "serial" does.
2013-12-25 17:46:45 +01:00
int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie);
int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destination, uint64_t *cookie);
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply);
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
int sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_get_fd(sd_bus *bus);
int sd_bus_get_events(sd_bus *bus);
bus: implement full method call timeout logic
2013-03-21 22:50:25 +01:00
int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_process(sd_bus *bus, sd_bus_message **r);
headers: get rid of pointless /* deprecated */ comment The _sd_deprecated_ annotation gives it all away, and the comment adds no additional value.
2020-04-17 14:01:07 +02:00
int sd_bus_process_priority(sd_bus *bus, int64_t max_priority, sd_bus_message **r) _sd_deprecated_;
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec);
int sd_bus_flush(sd_bus *bus);
Fix typo in function name
2020-02-04 18:39:04 +01:00
int sd_bus_enqueue_for_read(sd_bus *bus, sd_bus_message *m);
sd-bus: rename sd_bus_get_server_id() to sd_bus_get_owner_id() In kdbus a "server id" is mostly a misnomer, as there isn't any "server" involved anymore. Let's rename this to "owner" id hence, since it is an ID that is picked by the owner of a bus or direct connection. This matches nicely the sd_bus_get_owner_creds() call we already have.
2014-11-04 17:24:30 +01:00
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus);
sd-bus: add API to query which handler/callback is currently being dispatched
2014-08-18 17:41:56 +02:00
sd_bus_message* sd_bus_get_current_message(sd_bus *bus);
sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus);
void* sd_bus_get_current_userdata(sd_bus *bus);
bus: add sd_bus_get_current() bus call to determine message that is currently being dispatched
2013-11-05 20:51:49 +01:00
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
int sd_bus_attach_event(sd_bus *bus, sd_event *e, int priority);
int sd_bus_detach_event(sd_bus *bus);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
sd_event* sd_bus_get_event(sd_bus *bus);
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
core: don't process dbus unit and job queue when there are already too many messages pending We maintain a queue of units and jobs that we are supposed to generate change/new notifications for because they were either just created or some of their property has changed. Let's throttle processing of this queue a bit: as soon as > 1K of bus messages are queued for writing let's skip processing the queue, and then recheck on the next iteration again. Moreover, never process more than 100 units in one go, return to the event loop after that. Both limits together should put effective limits on both space and time usage of the function, delaying further operations until a later moment, when the queue is empty or the the event loop is sufficiently idle again. This should keep the number of generated messages much lower than before on busy systems or where some client is hanging. Note that this also means a bad client can slow down message dispatching substantially for up to 90s if it likes to, for all clients. But that should be acceptable as we only allow trusted bus clients, anyway. Fixes: #8166
2018-02-13 18:30:34 +01:00
int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret);
int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret);
sd-bus: make BUS_DEFAULT_TIMEOUT configurable This adds sd_bus_{get,set}_method_call_timeout(). If the timeout is not set or set to 0, then the timeout value is parsed from $SYSTEMD_BUS_TIMEOUT= environment variable. If the environment variable is not set, then built-in timeout is used.
2018-07-13 10:38:47 +02:00
int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec);
int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret);
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
int sd_bus_add_filter(sd_bus *bus, sd_bus_slot **slot, sd_bus_message_handler_t callback, void *userdata);
int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata);
sd-bus: add asynchronous version of sd_bus_match() We usually enqueue a number of these calls on each service initialization. Let's do this asynchronously, and thus remove synchronization points. This improves both performance behaviour and reduces the chances to deadlock.
2017-12-18 21:37:03 +01:00
int sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata);
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
int sd_bus_add_object(sd_bus *bus, sd_bus_slot **slot, const char *path, sd_bus_message_handler_t callback, void *userdata);
int sd_bus_add_fallback(sd_bus *bus, sd_bus_slot **slot, const char *prefix, sd_bus_message_handler_t callback, void *userdata);
int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata);
int sd_bus_add_fallback_vtable(sd_bus *bus, sd_bus_slot **slot, const char *prefix, const char *interface, const sd_bus_vtable *vtable, sd_bus_object_find_t find, void *userdata);
int sd_bus_add_node_enumerator(sd_bus *bus, sd_bus_slot **slot, const char *path, sd_bus_node_enumerator_t callback, void *userdata);
int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
/* Slot object */
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
sd_bus_slot* sd_bus_slot_ref(sd_bus_slot *slot);
sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot);
bus: implement object handler registry
2013-03-22 05:58:47 +01:00
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
sd_bus* sd_bus_slot_get_bus(sd_bus_slot *slot);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
void* sd_bus_slot_get_userdata(sd_bus_slot *slot);
void* sd_bus_slot_set_userdata(sd_bus_slot *slot, void *userdata);
sd-bus: also allow setting descriptions on bus slots
2014-11-04 16:57:38 +01:00
int sd_bus_slot_set_description(sd_bus_slot *slot, const char *description);
sd-bus: sd_bus_slot_get_description() should return const strings All other *_get_description() functions use 'const char**', so make sure sd_bus_slot_get_description() does the same. This changes API, but ABI stays stable. I think this is fine, but I wouldn't mind bumping SONAME. Reported in #528.
2015-07-09 10:40:41 +02:00
int sd_bus_slot_get_description(sd_bus_slot *slot, const char **description);
sd-bus: add new sd_bus_slot_set_floating() call This new call allows explicit control of the "floating" state of a bus slot object. This is useful for creating a bus slot object first, retaining a reference to it, using it for making changes to the slot object (for example, set a description) and then handing it over to sd-bus for lifecycle management. It's also useful to fix #8551.
2018-05-30 16:29:33 +02:00
int sd_bus_slot_get_floating(sd_bus_slot *slot);
int sd_bus_slot_set_floating(sd_bus_slot *slot, int b);
bus: optionally call a callbacks for cleanup This adds a function sd_bus_slot_set_destroy_callback() to set a function which can free userdata or perform other cleanups. sd_bus_slot_get_destory_callback() queries the callback, and is included for completeness. Without something like this, for floating asynchronous callbacks, which might be called or not, depending on the sequence of events, it's hard to perform resource cleanup. The alternative would be to always perform the cleanup from the caller too, but that requires more coordination and keeping of some shared state. It's nicer to keep the cleanup contained between the callback and the function that requests the callback.
2018-06-06 11:07:02 +02:00
int sd_bus_slot_set_destroy_callback(sd_bus_slot *s, sd_bus_destroy_t callback);
int sd_bus_slot_get_destroy_callback(sd_bus_slot *s, sd_bus_destroy_t *callback);
sd-bus: also allow setting descriptions on bus slots
2014-11-04 16:57:38 +01:00
sd-bus: introduce sd_bus_slot objects encapsulating callbacks or vtables attached to a bus connection This makes callback behaviour more like sd-event or sd-resolve, and creates proper object for unregistering callbacks. Taking the refernce to the slot is optional. If not taken life time of the slot will be bound to the underlying bus object (or in the case of an async call until the reply has been recieved).
2014-05-15 01:15:30 +02:00
sd_bus_message* sd_bus_slot_get_current_message(sd_bus_slot *slot);
sd-bus: rename argument
2018-10-15 02:27:53 +02:00
sd_bus_message_handler_t sd_bus_slot_get_current_handler(sd_bus_slot *slot);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
void* sd_bus_slot_get_current_userdata(sd_bus_slot *slot);
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
/* Message object */
bus: merge sd_bus_get_owner() and sd_bus_get_owner_creds() into one call Since the backing ioctl for this on kdbus is the same we retain atomicity this way.
2013-11-28 20:41:55 +01:00
Add sd_bus_message_new and sd_bus_message_seal as public functions (#6609)
2017-10-30 16:08:46 +01:00
int sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type);
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member);
int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member);
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
int sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m);
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_message_new_method_errorf(sd_bus_message *call, sd_bus_message **m, const char *name, const char *format, ...) _sd_printf_(4, 5);
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
int sd_bus_message_new_method_errno(sd_bus_message *call, sd_bus_message **m, int error, const sd_bus_error *e);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_message_new_method_errnof(sd_bus_message *call, sd_bus_message **m, int error, const char *format, ...) _sd_printf_(4, 5);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd_bus_message* sd_bus_message_ref(sd_bus_message *m);
sd_bus_message* sd_bus_message_unref(sd_bus_message *m);
Add sd_bus_message_new and sd_bus_message_seal as public functions (#6609)
2017-10-30 16:08:46 +01:00
int sd_bus_message_seal(sd_bus_message *m, uint64_t cookie, uint64_t timeout_usec);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_get_type(sd_bus_message *m, uint8_t *type);
bus: rename message "serial" to "cookie" Even if the lower-leveld dbus1 protocol calls it "serial", let's expose the word "cookie" for this instead, as this is what kdbus uses and since it doesn't imply monotonicity the same way "serial" does.
2013-12-25 17:46:45 +01:00
int sd_bus_message_get_cookie(sd_bus_message *m, uint64_t *cookie);
int sd_bus_message_get_reply_cookie(sd_bus_message *m, uint64_t *cookie);
headers: get rid of pointless /* deprecated */ comment The _sd_deprecated_ annotation gives it all away, and the comment adds no additional value.
2020-04-17 14:01:07 +02:00
int sd_bus_message_get_priority(sd_bus_message *m, int64_t *priority) _sd_deprecated_;
sd-bus: add support for new allow-interactive-authorization message header flag
2014-10-13 17:16:56 +02:00
bus: change API to expose "inverted" no_reply and no_auto_start message flags non-inverted
2014-01-22 20:45:05 +01:00
int sd_bus_message_get_expect_reply(sd_bus_message *m);
int sd_bus_message_get_auto_start(sd_bus_message *m);
sd-bus: add support for new allow-interactive-authorization message header flag
2014-10-13 17:16:56 +02:00
int sd_bus_message_get_allow_interactive_authorization(sd_bus_message *m);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
const char* sd_bus_message_get_signature(sd_bus_message *m, int complete);
const char* sd_bus_message_get_path(sd_bus_message *m);
const char* sd_bus_message_get_interface(sd_bus_message *m);
const char* sd_bus_message_get_member(sd_bus_message *m);
const char* sd_bus_message_get_destination(sd_bus_message *m);
const char* sd_bus_message_get_sender(sd_bus_message *m);
const sd_bus_error* sd_bus_message_get_error(sd_bus_message *m);
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
int sd_bus_message_get_errno(sd_bus_message *m);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
bus: rename sd_bus_get_realtime_timestamp() to sd_bus_get_realtime_usec() This brings the calls into similar style as the respective functions in libsystemd-journal, and also is a bi shorter and more descriptive since it clarifies the time unit used.
2014-01-22 11:25:39 +01:00
int sd_bus_message_get_monotonic_usec(sd_bus_message *m, uint64_t *usec);
int sd_bus_message_get_realtime_usec(sd_bus_message *m, uint64_t *usec);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
int sd_bus_message_get_seqnum(sd_bus_message *m, uint64_t *seqnum);
bus: add API for querying the kdbus message sequence number
2014-01-22 10:57:12 +01:00
bus: reorder a few things
2014-01-28 12:33:32 +01:00
sd_bus* sd_bus_message_get_bus(sd_bus_message *m);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
sd_bus_creds* sd_bus_message_get_creds(sd_bus_message *m); /* do not unref the result */
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_is_signal(sd_bus_message *m, const char *interface, const char *member);
int sd_bus_message_is_method_call(sd_bus_message *m, const char *interface, const char *member);
int sd_bus_message_is_method_error(sd_bus_message *m, const char *name);
sd-bus: add sd_bus_message_is_empty() for checking whether a message carries any body
2014-11-14 13:05:01 +01:00
int sd_bus_message_is_empty(sd_bus_message *m);
bus-proxy: check passed parameter signature of all driver method calls
2014-11-26 22:52:10 +01:00
int sd_bus_message_has_signature(sd_bus_message *m, const char *signature);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
bus: change API to expose "inverted" no_reply and no_auto_start message flags non-inverted
2014-01-22 20:45:05 +01:00
int sd_bus_message_set_expect_reply(sd_bus_message *m, int b);
int sd_bus_message_set_auto_start(sd_bus_message *m, int b);
sd-bus: add support for new allow-interactive-authorization message header flag
2014-10-13 17:16:56 +02:00
int sd_bus_message_set_allow_interactive_authorization(sd_bus_message *m, int b);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_set_destination(sd_bus_message *m, const char *destination);
sd-bus: add API to optionally set a sender field on all outgoing messages This is useful on direct connections to generate messages with valid sender fields. This is particularly useful for services that are accessible both through direct connections and the broker, as it allows clients to install matches on the sender service name, and they work the same in both cases.
2017-12-20 19:41:06 +01:00
int sd_bus_message_set_sender(sd_bus_message *m, const char *sender);
headers: get rid of pointless /* deprecated */ comment The _sd_deprecated_ annotation gives it all away, and the comment adds no additional value.
2020-04-17 14:01:07 +02:00
int sd_bus_message_set_priority(sd_bus_message *m, int64_t priority) _sd_deprecated_;
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_append(sd_bus_message *m, const char *types, ...);
Export sd_bus_message_append_ap. It is renamed to sd_bus_message_appendv to follow systemd naming conventions. (#5753) Moreover, man page for sd_bus_message_append is updated with reference to new exposed function. Makefile-man is updated too, to reflect new alias.
2017-04-25 09:32:24 +02:00
int sd_bus_message_appendv(sd_bus_message *m, const char *types, va_list ap);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_append_basic(sd_bus_message *m, char type, const void *p);
bus: add sd_bus_message_append_string_space() for zero-copy string appending
2013-05-10 01:12:15 +02:00
int sd_bus_message_append_array(sd_bus_message *m, char type, const void *ptr, size_t size);
int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t size, void **ptr);
bus: add APIs for adding iovecs to messages as string or arrays
2013-11-11 16:26:12 +01:00
int sd_bus_message_append_array_iovec(sd_bus_message *m, char type, const struct iovec *iov, unsigned n);
sd-bus: properly support passing memfds around with offset/size parameters
2014-12-09 18:07:46 +01:00
int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, int memfd, uint64_t offset, uint64_t size);
bus: add sd_bus_message_append_string_space() for zero-copy string appending
2013-05-10 01:12:15 +02:00
int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char **s);
bus: add APIs for adding iovecs to messages as string or arrays
2013-11-11 16:26:12 +01:00
int sd_bus_message_append_string_iovec(sd_bus_message *m, const struct iovec *iov, unsigned n);
sd-bus: properly support passing memfds around with offset/size parameters
2014-12-09 18:07:46 +01:00
int sd_bus_message_append_string_memfd(sd_bus_message *m, int memfd, uint64_t offset, uint64_t size);
bus: add sd_bus_message_append_strv() to easily add a NULL terminated string array to a message
2013-10-11 23:02:47 +02:00
int sd_bus_message_append_strv(sd_bus_message *m, char **l);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_open_container(sd_bus_message *m, char type, const char *contents);
int sd_bus_message_close_container(sd_bus_message *m);
bus: add new sd_bus_message_verify_type() and sd_bus_message_copy() API calls
2013-10-29 19:30:55 +01:00
int sd_bus_message_copy(sd_bus_message *m, sd_bus_message *source, int all);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_message_read(sd_bus_message *m, const char *types, ...);
sd-bus: publicize sd_bus_message_readv() The D-Bus library supplies a va_list variant of `sd_bus_message_append()` called `sd_bus_message_appendv()`, but failed to provide a va_list variant of its opposite, `sd_bus_message_read()`. This commit publicizes a previously static function as `sd_bus_message_readv()`.
2018-06-15 10:18:07 +02:00
int sd_bus_message_readv(sd_bus_message *m, const char *types, va_list ap);
bus: implement demarshaller
2013-03-20 03:15:03 +01:00
int sd_bus_message_read_basic(sd_bus_message *m, char type, void *p);
bus: add sd_bus_message_append_string_space() for zero-copy string appending
2013-05-10 01:12:15 +02:00
int sd_bus_message_read_array(sd_bus_message *m, char type, const void **ptr, size_t *size);
bus: add APIs to easily query string and strv properties
2013-11-07 19:28:54 +01:00
int sd_bus_message_read_strv(sd_bus_message *m, char ***l); /* free the result! */
bus: add sd_bus_message_skip() to skip over multiple fields
2013-11-05 02:25:24 +01:00
int sd_bus_message_skip(sd_bus_message *m, const char *types);
bus: implement demarshaller
2013-03-20 03:15:03 +01:00
int sd_bus_message_enter_container(sd_bus_message *m, char type, const char *contents);
int sd_bus_message_exit_container(sd_bus_message *m);
int sd_bus_message_peek_type(sd_bus_message *m, char *type, const char **contents);
bus: add new sd_bus_message_verify_type() and sd_bus_message_copy() API calls
2013-10-29 19:30:55 +01:00
int sd_bus_message_verify_type(sd_bus_message *m, char type, const char *contents);
bus: add new bus API call sd_bus_message_at_end() This may be used to determine whether we are at the end of a container ot the entire message.
2013-11-05 19:36:05 +01:00
int sd_bus_message_at_end(sd_bus_message *m, int complete);
bus: hook up client with socket communication
2013-03-20 22:56:25 +01:00
int sd_bus_message_rewind(sd_bus_message *m, int complete);
sd-bus: add new call sd_bus_message_sensitive() and SD_BUS_VTABLE_SENSITIVE This allows marking messages that contain "sensitive" data with a flag. If it's set then the messages are erased from memory when the message is freed. Similar, a flag may be set on vtable entries: incoming/outgoing message matching the entry will then automatically be flagged this way. This is supposed to be an easy method to mark messages containing potentially sensitive data (such as passwords) for proper destruction. (Note that this of course is only is as safe as the broker in between is doing something similar. But let's at least not be the ones at fault here.)
2019-08-19 20:28:34 +02:00
int sd_bus_message_sensitive(sd_bus_message *m);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd-bus: export sd_bus_message_dump Fixes #14640.
2020-01-23 18:42:54 +01:00
int sd_bus_message_dump(sd_bus_message *m, FILE *f, uint64_t flags);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
/* Bus management */
int sd_bus_get_unique_name(sd_bus *bus, const char **unique);
bus: instead of exposing the dbus1 flags when acquiring a name use our own that are closer to kdbus This turns around DO_NOT_QUEUE into QUEUE which implies a more useful default. (And negative options are awful anyway.)
2013-12-12 05:55:58 +01:00
int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags);
sd-bus: add APIs to request/release names asynchronously They do the same thing as their synchronous counterparts, but only enqueue the operation, thus removing synchronization points during service initialization. If the callback function is passed as NULL we'll fallback to generic implementations of the reply handlers, that terminate the connection if the requested name cannot be acquired, under the assumption that not being able to acquire the name is a technical problem.
2017-12-18 20:10:13 +01:00
int sd_bus_request_name_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *name, uint64_t flags, sd_bus_message_handler_t callback, void *userdata);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_release_name(sd_bus *bus, const char *name);
sd-bus: add APIs to request/release names asynchronously They do the same thing as their synchronous counterparts, but only enqueue the operation, thus removing synchronization points during service initialization. If the callback function is passed as NULL we'll fallback to generic implementations of the reply handlers, that terminate the connection if the requested name cannot be acquired, under the assumption that not being able to acquire the name is a technical problem.
2017-12-18 20:10:13 +01:00
int sd_bus_release_name_async(sd_bus *bus, sd_bus_slot **ret_slot, const char *name, sd_bus_message_handler_t callback, void *userdata);
bus: rework sd_bus_list_names() to return two lists for acquired and activatable names
2013-12-03 18:42:51 +01:00
int sd_bus_list_names(sd_bus *bus, char ***acquired, char ***activatable); /* free the results */
sd-bus: rename sd_bus_get_owner_uid(), sd_bus_get_owner_machine_id() and sd_bus_get_peer_creds() Clean up the function namespace by renaming the following: sd_bus_get_owner_uid() → sd_bus_get_name_creds_uid() sd_bus_get_owner_machine_id() → sd_bus_get_name_machine_id() sd_bus_get_peer_creds() → sd_bus_get_owner_creds()
2014-10-22 19:17:24 +02:00
int sd_bus_get_name_creds(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **creds); /* unref the result! */
int sd_bus_get_name_machine_id(sd_bus *bus, const char *name, sd_id128_t *machine);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
bus: add convenience functions for constructing and sending method calls/signals in one call
2013-04-05 04:15:39 +02:00
/* Convenience calls */
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_call_methodv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *types, va_list ap);
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int sd_bus_call_method(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *types, ...);
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_call_method_asyncv(sd_bus *bus, sd_bus_slot **slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, va_list ap);
sd-bus: add async convenience method call API
2015-06-08 10:00:17 +02:00
int sd_bus_call_method_async(sd_bus *bus, sd_bus_slot **slot, const char *destination, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata, const char *types, ...);
bus: rework message handlers to always take an error argument Message handler callbacks can be simplified drastically if the dispatcher automatically replies to method calls if errors are returned. Thus: add an sd_bus_error argument to all message handlers. When we dispatch a message handler and it returns negative or a set sd_bus_error we send this as message error back to the client. This means errors returned by handlers by default are given back to clients instead of rippling all the way up to the event loop, which is desirable to make things robust. As a side-effect we can now easily turn the SELinux checks into normal function calls, since the method call dispatcher will generate the right error replies automatically now. Also, make sure we always pass the error structure to all property and method handlers as last argument to follow the usual style of passing variables for return values as last argument.
2013-11-21 19:34:37 +01:00
int sd_bus_get_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, sd_bus_message **reply, const char *type);
int sd_bus_get_property_trivial(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char type, void *ret_ptr);
int sd_bus_get_property_string(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char **ret); /* free the result! */
int sd_bus_get_property_strv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, char ***ret); /* free the result! */
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_set_propertyv(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, const char *type, va_list ap);
sd-bus,sd-event: make public APIs With the v221 release these APIs should be public, stable APIs, hence let's install their headers by default now, and add their symbols to the .sym file.
2015-05-22 14:32:51 +02:00
int sd_bus_set_property(sd_bus *bus, const char *destination, const char *path, const char *interface, const char *member, sd_bus_error *ret_error, const char *type, ...);
bus: add sd_bus_send_to() API call
2013-11-19 01:23:08 +01:00
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_reply_method_returnv(sd_bus_message *call, const char *types, va_list ap);
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
int sd_bus_reply_method_return(sd_bus_message *call, const char *types, ...);
int sd_bus_reply_method_error(sd_bus_message *call, const sd_bus_error *e);
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_reply_method_errorfv(sd_bus_message *call, const char *name, const char *format, va_list ap) _sd_printf_(3, 0);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_reply_method_errorf(sd_bus_message *call, const char *name, const char *format, ...) _sd_printf_(3, 4);
bus: let's simplify things by getting rid of unnecessary bus parameters
2013-11-21 01:51:16 +01:00
int sd_bus_reply_method_errno(sd_bus_message *call, int error, const sd_bus_error *e);
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_reply_method_errnofv(sd_bus_message *call, int error, const char *format, va_list ap) _sd_printf_(3, 0);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_reply_method_errnof(sd_bus_message *call, int error, const char *format, ...) _sd_printf_(3, 4);
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
sd-bus: add va_list variants of variadic convenience functions Consumers of the sd-bus convenience API can't make convenience helpers of their own without va_list variants. This commit is a mechanical change splitting out the existing function bodies into bare va_list variants having a 'v' suffixed to the names. The original functions now simply create the va_list before forwarding the call on to the va_list variant, and the va_list variants dispense with those steps.
2020-03-31 16:28:01 +02:00
int sd_bus_emit_signalv(sd_bus *bus, const char *path, const char *interface, const char *member, const char *types, va_list ap);
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
int sd_bus_emit_signal(sd_bus *bus, const char *path, const char *interface, const char *member, const char *types, ...);
int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names);
api: unify some common bits used by public systemd APIs
2013-10-16 17:00:13 +02:00
int sd_bus_emit_properties_changed(sd_bus *bus, const char *path, const char *interface, const char *name, ...) _sd_sentinel_;
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
bus: add sd_bus_emit_object_{added/removed}() This implements two new helpers, discussed on systemd-devel about 1 year ago: sd_bus_emit_object_added() sd_bus_emit_object_removed() Both calls are equivalent to their respective counterpart sd_bus_emit_interfaces_{added/removed}(), but can figure out the list of interfaces themselves, instead of requiring the caller to provide them. Furthermore, both calls properly deal with builtin interfaces provided via org.freedesktop.DBus.* and alike. Both calls simply traverse a node and all its parent nodes to figure out a list of all interfaces registered as vtable or fallback. It then appends each of them, similar to the interfaces_{added/removed}() helpers. Note that interfaces_{added/removed}() runs a parent traversal for *each* passed interface. Therefore, it can simply bail out, once it found a parent node that implements a given interface. With object_{added/removed}() we cannot know the registered interfaces in advance, thus, we cannot run one traversal per node. Instead, we run a single traversal and remember all interfaces that we added. Therefore, a child-interface overrides all conflicting parent-interfaces. We keep a "Set *s" context to track those while climbing up the tree.
2014-12-30 11:37:35 +01:00
int sd_bus_emit_object_added(sd_bus *bus, const char *path);
int sd_bus_emit_object_removed(sd_bus *bus, const char *path);
bus: properly implement logic for generating InterfacesAdded/InterfacesRemoved signals of ObjectManager
2013-10-11 23:22:29 +02:00
int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces);
api: unify some common bits used by public systemd APIs
2013-10-16 17:00:13 +02:00
int sd_bus_emit_interfaces_added(sd_bus *bus, const char *path, const char *interface, ...) _sd_sentinel_;
bus: properly implement logic for generating InterfacesAdded/InterfacesRemoved signals of ObjectManager
2013-10-11 23:22:29 +02:00
int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces);
api: unify some common bits used by public systemd APIs
2013-10-16 17:00:13 +02:00
int sd_bus_emit_interfaces_removed(sd_bus *bus, const char *path, const char *interface, ...) _sd_sentinel_;
bus: add convenience functions for constructing and sending method calls/signals in one call
2013-04-05 04:15:39 +02:00
sd-bus: Add sd_bus_query_sender_creds/privilege docs
2020-04-28 19:29:46 +02:00
int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **creds);
int sd_bus_query_sender_privilege(sd_bus_message *m, int capability);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
sd-bus: add new API sd_bus_match_signal() + sd_bus_match_signal_asnyc() These are convenience helpers that hide the match string logic (which we probably should never have exposed), and instead just takes regular C arguments.
2017-12-18 21:52:50 +01:00
int sd_bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata);
int sd_bus_match_signal_async(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t match_callback, sd_bus_message_handler_t add_callback, void *userdata);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
/* Credential handling */
api: in constructor function calls, always put the returned object pointer first (or second) Previously the returned object of constructor functions where sometimes returned as last, sometimes as first and sometimes as second parameter. Let's clean this up a bit. Here are the new rules: 1. The object the new object is derived from is put first, if there is any 2. The object we are creating will be returned in the next arguments 3. This is followed by any additional arguments Rationale: For functions that operate on an object we always put that object first. Constructors should probably not be too different in this regard. Also, if the additional parameters might want to use varargs which suggests to put them last. Note that this new scheme only applies to constructor functions, not to all other functions. We do give a lot of freedom for those. Note that this commit only changes the order of the new functions we added, for old ones we accept the wrong order and leave it like that.
2014-02-19 23:54:58 +01:00
int sd_bus_creds_new_from_pid(sd_bus_creds **ret, pid_t pid, uint64_t creds_mask);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
sd_bus_creds* sd_bus_creds_ref(sd_bus_creds *c);
sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c);
man: document some more bus functions
2014-01-05 01:28:52 +01:00
uint64_t sd_bus_creds_get_mask(const sd_bus_creds *c);
sd-bus: when augmenting creds, remember which ones were augmented Also, when we do permissions checks using creds, verify that we don't do so based on augmented creds, as extra safety check.
2015-04-21 00:58:08 +02:00
uint64_t sd_bus_creds_get_augmented_mask(const sd_bus_creds *c);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid);
sd-bus: expose ppid field kdbus has been passing us the ppid file for a while, actually make use of it.
2015-04-21 20:58:09 +02:00
int sd_bus_creds_get_ppid(sd_bus_creds *c, pid_t *ppid);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_tid(sd_bus_creds *c, pid_t *tid);
bus: include unique and well known names in credentials object
2013-11-30 04:14:10 +01:00
int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid);
sd-bus: update to current kernel version, by splitting off the extended KDBUS_ITEM_PIDS structure from KDBUS_ITEM_CREDS Also: - adds support for euid, suid, fsuid, egid, sgid, fsgid fields. - makes augmentation of creds with data from /proc explicitly controllable to give apps better control over this, given that this is racy. - enables augmentation for kdbus connections (previously we only did it for dbus1). This is useful since with recent kdbus versions it is possible for clients to control the metadata they want to send. - changes sd_bus_query_sender_privilege() to take the euid of the client into consideration, if known - when we don't have permissions to read augmentation data from /proc, don't fail, just don't add the data in
2014-11-24 21:41:40 +01:00
int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid);
int sd_bus_creds_get_suid(sd_bus_creds *c, uid_t *suid);
int sd_bus_creds_get_fsuid(sd_bus_creds *c, uid_t *fsuid);
bus: include unique and well known names in credentials object
2013-11-30 04:14:10 +01:00
int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid);
sd-bus: update to current kernel version, by splitting off the extended KDBUS_ITEM_PIDS structure from KDBUS_ITEM_CREDS Also: - adds support for euid, suid, fsuid, egid, sgid, fsgid fields. - makes augmentation of creds with data from /proc explicitly controllable to give apps better control over this, given that this is racy. - enables augmentation for kdbus connections (previously we only did it for dbus1). This is useful since with recent kdbus versions it is possible for clients to control the metadata they want to send. - changes sd_bus_query_sender_privilege() to take the euid of the client into consideration, if known - when we don't have permissions to read augmentation data from /proc, don't fail, just don't add the data in
2014-11-24 21:41:40 +01:00
int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid);
int sd_bus_creds_get_sgid(sd_bus_creds *c, gid_t *sgid);
int sd_bus_creds_get_fsgid(sd_bus_creds *c, gid_t *fsgid);
sd-bus: add supplementary groups list to creds object
2014-11-25 13:21:23 +01:00
int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids);
man: document a batch of bus functions
2014-01-04 06:08:50 +01:00
int sd_bus_creds_get_comm(sd_bus_creds *c, const char **comm);
int sd_bus_creds_get_tid_comm(sd_bus_creds *c, const char **comm);
int sd_bus_creds_get_exe(sd_bus_creds *c, const char **exe);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_cmdline(sd_bus_creds *c, char ***cmdline);
man: document a batch of bus functions
2014-01-04 06:08:50 +01:00
int sd_bus_creds_get_cgroup(sd_bus_creds *c, const char **cgroup);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_unit(sd_bus_creds *c, const char **unit);
int sd_bus_creds_get_slice(sd_bus_creds *c, const char **slice);
sd-bus,sd-login: add api for querying the slice within the the user systemd instance of a process units are organized in slice trees, not only for the system instance, but also for user systemd instances, expose this properly.
2015-04-30 11:58:06 +02:00
int sd_bus_creds_get_user_unit(sd_bus_creds *c, const char **unit);
int sd_bus_creds_get_user_slice(sd_bus_creds *c, const char **slice);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_session(sd_bus_creds *c, const char **session);
int sd_bus_creds_get_owner_uid(sd_bus_creds *c, uid_t *uid);
int sd_bus_creds_has_effective_cap(sd_bus_creds *c, int capability);
int sd_bus_creds_has_permitted_cap(sd_bus_creds *c, int capability);
int sd_bus_creds_has_inheritable_cap(sd_bus_creds *c, int capability);
int sd_bus_creds_has_bounding_cap(sd_bus_creds *c, int capability);
man: document a batch of bus functions
2014-01-04 06:08:50 +01:00
int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **context);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
int sd_bus_creds_get_audit_session_id(sd_bus_creds *c, uint32_t *sessionid);
int sd_bus_creds_get_audit_login_uid(sd_bus_creds *c, uid_t *loginuid);
sd-bus: add controlling tty field to sd_creds object This is useful to print wall messages from logind with the right client tty. (to be added in a later patch)
2015-04-23 19:43:40 +02:00
int sd_bus_creds_get_tty(sd_bus_creds *c, const char **tty);
bus: include unique and well known names in credentials object
2013-11-30 04:14:10 +01:00
int sd_bus_creds_get_unique_name(sd_bus_creds *c, const char **name);
int sd_bus_creds_get_well_known_names(sd_bus_creds *c, char ***names);
sd-bus: rename "connection name" to "description" for the sd-bus API too kdbus recently renamed this concept, and so should we in what we expose in userspace.
2014-11-04 16:13:49 +01:00
int sd_bus_creds_get_description(sd_bus_creds *c, const char **name);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
bus: introduce bus_error_is_dirty() independently of sd_bus_error_is_set()
2013-03-20 13:10:12 +01:00
/* Error structures */
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
journalctl: make sure -b --foobar cannot be misunderstood as --boot=--foobar
2013-12-26 01:52:01 +01:00
#define SD_BUS_ERROR_MAKE_CONST(name, message) ((const sd_bus_error) {(name), (message), 0})
bus: rename SD_BUS_ERROR_MAKE to SD_BUS_ERROR_MAKE_CONST to indicate it only works for const strings
2013-11-21 02:11:06 +01:00
#define SD_BUS_ERROR_NULL SD_BUS_ERROR_MAKE_CONST(NULL, NULL)
Make bus errno mappings non-static __attribute__((used)) is not enough to force static variables to be carried over to a compiled program from a library. Mappings defined in libsystemd-shared.a were not visible in the compiled binaries. To ensure that the mappings are present in the final binary, the tables are made non-static and are given a real unique name by which they can be referenced. To use a mapping defined not in the local compilation unit (e.g. in a library) a reference to the mapping table is added. This is done by including a declaration in the header file. Expected values in test-engine are fixed to reflect the new mappings.
2014-10-31 15:07:54 +01:00
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
void sd_bus_error_free(sd_bus_error *e);
libsystemd-bus: add lightweight object vtable implementation for exposing objects on the bus This adds a lightweight scheme how to define interfaces in static fixed arrays which then can be easily registered on a bus connection. This makes it much easier to write bus services. This automatically handles implementation of the Properties, ObjectManager, and Introspection bus interfaces.
2013-10-09 02:37:10 +02:00
int sd_bus_error_set(sd_bus_error *e, const char *name, const char *message);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_error_setf(sd_bus_error *e, const char *name, const char *format, ...) _sd_printf_(3, 4);
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
int sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *message);
int sd_bus_error_set_errno(sd_bus_error *e, int error);
bus: correct a number of gcc format string attribute usages
2013-12-28 14:39:12 +01:00
int sd_bus_error_set_errnof(sd_bus_error *e, int error, const char *format, ...) _sd_printf_(3, 4);
sd-bus: add missing format attribute
2015-02-16 05:09:55 +01:00
int sd_bus_error_set_errnofv(sd_bus_error *e, int error, const char *format, va_list ap) _sd_printf_(3,0);
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
int sd_bus_error_get_errno(const sd_bus_error *e);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_error_copy(sd_bus_error *dest, const sd_bus_error *e);
sd-bus: add new API call sd_bus_error_move() This new call move an sd_bus_error into another one.
2018-08-06 18:54:03 +02:00
int sd_bus_error_move(sd_bus_error *dest, sd_bus_error *e);
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
int sd_bus_error_is_set(const sd_bus_error *e);
int sd_bus_error_has_name(const sd_bus_error *e, const char *name);
sd-bus: add a variant of sd_bus_error_has_name() that takes multiple names
2020-08-22 18:24:43 +02:00
int sd_bus_error_has_names_sentinel(const sd_bus_error *e, ...) _sd_sentinel_;
#define sd_bus_error_has_names(e, ...) sd_bus_error_has_names_sentinel(e, __VA_ARGS__, NULL)
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
sd-bus: rework ELF error mapping table magic The ELF magic cannot work for consumers of our shard library, since they are in a different module. Hence make all the ELF magic private, and instead introduce a public function to register additional static mapping table.
2014-12-06 02:39:15 +01:00
#define SD_BUS_ERROR_MAP(_name, _code) \
{ \
.name = _name, \
.code = _code, \
}
#define SD_BUS_ERROR_MAP_END \
{ \
.name = NULL, \
.code = - 'x', \
}
int sd_bus_error_add_map(const sd_bus_error_map *map);
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
/* Auxiliary macros */
timedated: use libsystemd-bus instead of libdbus for bus communication Among other things this also adds a few things necessary for the change: - Considerably more powerful error returning APIs in libsystemd-bus - Adapter for connecting an sd_bus to an sd_event - As I reworked the PolicyKit logic to the new library I also made it asynchronous, so that PolicyKit requests of one user cannot block out another user anymore. - We always use the macro names for common bus error. That way it is harder to mistype them since the compiler will notice
2013-10-16 06:10:04 +02:00
#define SD_BUS_MESSAGE_APPEND_ID128(x) 16, \
(x).bytes[0], (x).bytes[1], (x).bytes[2], (x).bytes[3], \
(x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], \
logind: add infrastructure to keep track of machines, and move to slices - This changes all logind cgroup objects to use slice objects rather than fixed croup locations. - logind can now collect minimal information about running VMs/containers. As fixed cgroup locations can no longer be used we need an entity that keeps track of machine cgroups in whatever slice they might be located. Since logind already keeps track of users, sessions and seats this is a trivial addition. - nspawn will now register with logind and pass various bits of metadata along. A new option "--slice=" has been added to place the container in a specific slice. - loginctl gained commands to list, introspect and terminate machines. - user.slice and machine.slice will now be pulled in by logind.service, since only logind.service requires this slice.
2013-06-20 03:45:08 +02:00
(x).bytes[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], \
(x).bytes[12], (x).bytes[13], (x).bytes[14], (x).bytes[15]
bus: add a macro to simplify reading of UUIDs
2013-10-29 19:31:25 +01:00
#define SD_BUS_MESSAGE_READ_ID128(x) 16, \
&(x).bytes[0], &(x).bytes[1], &(x).bytes[2], &(x).bytes[3], \
&(x).bytes[4], &(x).bytes[5], &(x).bytes[6], &(x).bytes[7], \
&(x).bytes[8], &(x).bytes[9], &(x).bytes[10], &(x).bytes[11], \
&(x).bytes[12], &(x).bytes[13], &(x).bytes[14], &(x).bytes[15]
bus: add new sd_bus_creds object to encapsulate process credentials This way we can unify handling of credentials that are attached to messages, or can be queried for bus name owners or connection peers. This also adds the ability to extend incomplete credential information with data from /proc, Also, provide a convenience call that will automatically determine the most appropriate credential object for an incoming message, by using the the attached information if possible, the sending name information if available and otherwise the peer's credentials.
2013-11-28 17:50:02 +01:00
/* Label escaping */
bus: replace sd_bus_label_{escape,unescape}() by new sd_bus_path_{encode,decode}() The new calls work similarly, but enforce a that a common, fixed bus path prefix is used. This follows discussions with Simon McVittie on IRC that it should be a good idea to make sure that people don't use the escaping applied here too wildly as anything other than the last label of a bus path.
2014-03-11 19:03:50 +01:00
int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path);
sd-bus: add sd_bus_path_{encode,decode}_many() This introduces two new helpers alongside sd_bus_path_{encode,decode}(), which work similarly to their counterparts, but accept a format-string as input. This allows encoding and decoding multiple labels of a format string at the same time.
2015-09-25 19:05:23 +02:00
int sd_bus_path_encode_many(char **out, const char *path_template, ...);
bus: replace sd_bus_label_{escape,unescape}() by new sd_bus_path_{encode,decode}() The new calls work similarly, but enforce a that a common, fixed bus path prefix is used. This follows discussions with Simon McVittie on IRC that it should be a good idea to make sure that people don't use the escaping applied here too wildly as anything other than the last label of a bus path.
2014-03-11 19:03:50 +01:00
int sd_bus_path_decode(const char *path, const char *prefix, char **ret_external_id);
sd-bus: add sd_bus_path_{encode,decode}_many() This introduces two new helpers alongside sd_bus_path_{encode,decode}(), which work similarly to their counterparts, but accept a format-string as input. This allows encoding and decoding multiple labels of a format string at the same time.
2015-09-25 19:05:23 +02:00
int sd_bus_path_decode_many(const char *path, const char *path_template, ...);
bus: add API calls to escape string components of objects paths
2013-11-21 01:03:26 +01:00
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
/* Tracking peers */
int sd_bus_track_new(sd_bus *bus, sd_bus_track **track, sd_bus_track_handler_t handler, void *userdata);
sd_bus_track* sd_bus_track_ref(sd_bus_track *track);
sd_bus_track* sd_bus_track_unref(sd_bus_track *track);
bus: add userdata API for bus name tracker objects
2014-05-06 19:15:36 +02:00
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
sd_bus* sd_bus_track_get_bus(sd_bus_track *track);
sd-bus: Fix pointer alignment
2020-03-29 21:42:50 +02:00
void* sd_bus_track_get_userdata(sd_bus_track *track);
void* sd_bus_track_set_userdata(sd_bus_track *track, void *userdata);
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
int sd_bus_track_add_sender(sd_bus_track *track, sd_bus_message *m);
int sd_bus_track_remove_sender(sd_bus_track *track, sd_bus_message *m);
int sd_bus_track_add_name(sd_bus_track *track, const char *name);
int sd_bus_track_remove_name(sd_bus_track *track, const char *name);
sd-bus: add a "recursive" mode to sd_bus_track This adds an optional "recursive" counting mode to sd_bus_track. If enabled adding the same name multiple times to an sd_bus_track object is counted individually, so that it also has to be removed the same number of times before it is gone again from the tracking object. This functionality is useful for implementing local ref counted objects that peers make take references on.
2016-08-15 14:58:09 +02:00
int sd_bus_track_set_recursive(sd_bus_track *track, int b);
int sd_bus_track_get_recursive(sd_bus_track *track);
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
unsigned sd_bus_track_count(sd_bus_track *track);
sd-bus: add a "recursive" mode to sd_bus_track This adds an optional "recursive" counting mode to sd_bus_track. If enabled adding the same name multiple times to an sd_bus_track object is counted individually, so that it also has to be removed the same number of times before it is gone again from the tracking object. This functionality is useful for implementing local ref counted objects that peers make take references on.
2016-08-15 14:58:09 +02:00
int sd_bus_track_count_sender(sd_bus_track *track, sd_bus_message *m);
int sd_bus_track_count_name(sd_bus_track *track, const char *name);
const char* sd_bus_track_contains(sd_bus_track *track, const char *name);
bus: add sd_bus_track object for tracking peers, and port core over to it This is primarily useful for services that need to track clients which reference certain objects they maintain, or which explicitly want to subscribe to certain events. Something like this is done in a large number of services, and not trivial to do. Hence, let's unify this at one place. This also ports over PID 1 to use this to ensure that subscriptions to job and manager events are correctly tracked. As a side-effect this makes sure we properly serialize and restore the track list across daemon reexec/reload, which didn't work correctly before. This also simplifies how we distribute messages to broadcast to the direct busses: we only track subscriptions for the API bus and implicitly assume that all direct busses are subscribed. This should be a pretty OK simplification since clients connected via direct bus connections are shortlived anyway.
2014-03-03 01:33:45 +01:00
const char* sd_bus_track_first(sd_bus_track *track);
const char* sd_bus_track_next(sd_bus_track *track);
sd-bus: also add destroy callbacks to sd_bus_track objects This augments previous work for this for sd_bus_slot objects, and adds the same concept to sd_bus_track objects, too.
2018-06-07 12:29:52 +02:00
int sd_bus_track_set_destroy_callback(sd_bus_track *s, sd_bus_destroy_t callback);
int sd_bus_track_get_destroy_callback(sd_bus_track *s, sd_bus_destroy_t *ret);
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy GLIB has recently started to officially support the gcc cleanup attribute in its public API, hence let's do the same for our APIs. With this patch we'll define an xyz_unrefp() call for each public xyz_unref() call, to make it easy to use inside a __attribute__((cleanup())) expression. Then, all code is ported over to make use of this. The new calls are also documented in the man pages, with examples how to use them (well, I only added docs where the _unref() call itself already had docs, and the examples, only cover sd_bus_unrefp() and sd_event_unrefp()). This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we tend to call our destructors these days. Note that this defines no public macro that wraps gcc's attribute and makes it easier to use. While I think it's our duty in the library to make our stuff easy to use, I figure it's not our duty to make gcc's own features easy to use on its own. Most likely, client code which wants to make use of this should define its own: #define _cleanup_(function) __attribute__((cleanup(function))) Or similar, to make the gcc feature easier to use. Making this logic public has the benefit that we can remove three header files whose only purpose was to define these functions internally. See #2008.
2015-11-27 19:13:45 +01:00
/* Define helpers so that __attribute__((cleanup(sd_bus_unrefp))) and similar may be used. */
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus, sd_bus_unref);
sd-bus: add sd_bus_close_unref() helper It's similar to sd_bus_flush_close_unref() but doesn't do the flushing. This is useful since this will still discnnect the connection properly but not synchronously wait for the peer to take our messages. Primary usecase is within _cleanup_() expressions where synchronously waiting on the peer is not OK.
2019-01-17 15:51:08 +01:00
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus, sd_bus_close_unref);
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy GLIB has recently started to officially support the gcc cleanup attribute in its public API, hence let's do the same for our APIs. With this patch we'll define an xyz_unrefp() call for each public xyz_unref() call, to make it easy to use inside a __attribute__((cleanup())) expression. Then, all code is ported over to make use of this. The new calls are also documented in the man pages, with examples how to use them (well, I only added docs where the _unref() call itself already had docs, and the examples, only cover sd_bus_unrefp() and sd_event_unrefp()). This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we tend to call our destructors these days. Note that this defines no public macro that wraps gcc's attribute and makes it easier to use. While I think it's our duty in the library to make our stuff easy to use, I figure it's not our duty to make gcc's own features easy to use on its own. Most likely, client code which wants to make use of this should define its own: #define _cleanup_(function) __attribute__((cleanup(function))) Or similar, to make the gcc feature easier to use. Making this logic public has the benefit that we can remove three header files whose only purpose was to define these functions internally. See #2008.
2015-11-27 19:13:45 +01:00
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus, sd_bus_flush_close_unref);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus_slot, sd_bus_slot_unref);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus_message, sd_bus_message_unref);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus_creds, sd_bus_creds_unref);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_bus_track, sd_bus_track_unref);
api: replace manual C++ guards by macros
2013-11-07 16:44:48 +01:00
_SD_END_DECLARATIONS;
bus: add C++ wrappers to public header files
2013-03-29 23:20:32 +01:00
bus: add basic implementation of a native bus client library
2013-03-19 20:03:16 +01:00
#endif
Reference in a new issue Copy permalink