tree-wide: remove Emacs lines from all files This should be handled fine now by .dir-locals.el, so need to carry that stuff in every file.

bus-kernel: reword assignment of dst_id in bus_message_setup_kmsg Setting of dst_id was based on interplay of two booleans, making the logic hard to follow (for humans and compilers alike). gcc was confused and emmitted a warning about an uninitialized variable. Rework the code to make it obvious that dst_id is set properly.

tree-wide: use xsprintf() where applicable Also add a coccinelle receipt to help with such transitions.

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.

util-lib: split out allocation calls into alloc-util.[ch]

user-util: move UID/GID related macros from macro.h to user-util.h

src/basic: rename audit.[ch] → audit-util.[ch] and capability.[ch] → capability-util.[ch] The files are named too generically, so that they might conflict with the upstream project headers. Hence, let's add a "-util" suffix, to clarify that this are just our utility headers and not any official upstream headers.

util-lib: split string parsing related calls from util.[ch] into parse-util.[ch]

util-lib: split out fd-related operations into fd-util.[ch] There are more than enough to deserve their own .c file, hence move them over.

util-lib: split our string related calls from util.[ch] into its own file string-util.[ch] There are more than enough calls doing string manipulations to deserve its own files, hence do something about it. This patch also sorts the #include blocks of all files that needed to be updated, according to the sorting suggestions from CODING_STYLE. Since pretty much every file needs our string manipulation functions this effectively means that most files have sorted #include blocks now. Also touches a few unrelated include files.

sd-bus: fix error handling of pthread API calls pthread APIs (unlike the rest of libc) return their errors as positive error codes directly from the functions, rather than using errno. Let's make sure we always handle things that way.

Revert "sd-bus: do not connect to dbus-1 socket when kdbus is available" This reverts commit d4d00020d6ad855d65d31020fefa5003e1bb477f. The idea of the commit is broken and needs to be reworked. We really cannot reduce the bus-addresses to a single address. We always will have systemd with native clients and legacy clients at the same time, so we also need both addresses at the same time.

sd-bus: rename bloom-tag to arg0-has We use dashes in our bloom-tags. Make sure the newly introduced arg0has tag uses the same style. Note that the external dbus-tags don't use dashes, though. They are defined in the spec and we need to keep compatibility there.

sd-bus: introduce new match type "arg0has=" for matching arrays of strings Previously, sd-bus inofficially already supported bus matches that tested a string against an array of strings ("as"). This was done via an enhanced way to interpret "arg0=" matches. This is problematic however, since clients have no way to determine if their respective implementation understood strv matches or not, thus allowing invalid matches to be installed without a way to detect that. This patch changes the logic to only allow such matches with a new "arg0has=" syntax. This has the benefit that non-conforming implementations will return a parse error and a client application may thus efficiently detect support for the match type. Matches of this type are useful for "udev"-like systems that "tag" objects with a number of strings, and clients need to be able to match against any of these "tags". The name "has" takes inspiration from Python's ".has_key()" construct.

sd-bus: do not connect to dbus-1 socket when kdbus is available We should not fall back to dbus-1 and connect to the proxy when kdbus returns an error that indicates that kdbus is running but just does not accept new connections because of quota limits or something similar. Using is_kdbus_available() in libsystemd/ requires it to move from shared/ to libsystemd/. Based on a patch from David Herrmann: https://github.com/systemd/systemd/pull/886

sd-bus: ignore BLOOM_FILTER kdbus items The kernel nowadays sends these along, and that's OK, hence don't even debug log about it, but completely ignore it.

tree-wide: fix indentation

sd-bus: don't treat KDBUS_ITEM_TIMESTAMP as unknown item In bus_kernel_translate_message(), we print a DEBUG message on unknown items. But right now, we also print this message for KDBUS_ITEM_TIMESTAMP despite parsing it properly. Fix this!

sd-bus: don't leak kdbus notifications When we get notifications from the kernel, we always turn them into synthetic dbus1 messages. This means, we do *not* consume the kdbus message, and as such have to free the offset. Right now, the translation-helpers told the caller that they consumed the message, which is wrong. Fix this by explicitly releasing all kernel messages that are translated.

Stop talking about the "XDG" version of basename() XDG refers to X Desktop Group, a former name for freedesktop.org. This group is responsible for specifications like basedirs, .desktop files and icon naming, but as far as I know, it has never tried to redefine basename(). I think these references were meant to say XPG (X/Open Portability Guide), a precursor of POSIX. POSIX is better-known and less easily confused with XDG, and is how the basename(3) man page describes the libgen.h version of basename(). The other version of basename() is glibc-specific and is described in basename(3) as "the GNU version"; specifically mention that version, to disambiguate.

sd-bus: remove ucred parameter from bus_message_from_header() since we don't use it anymore

bus: don't force send-masks on kdbus buses Right now we always pass KDBUS_ITEM_ATTACH_FLAGS_RECV to KDBUS_CMD_BUS_MAKE, effectively forcing every bus connection to do the same during KDBUS_CMD_HELLO. This used to be a workaround to make sure all metadata is always present. However, we refrained from that approach and intend to make all metadata collection solely rely on /proc access restrictions. Therefore, there is no need to force the send-flags mask on newly created buses.

kdbus: remove attach_flags_mask module parameter setting

treewide: Correct typos and spell plural of bus consistent

sd-bus: when we get ENOTTY on the HELLO ioctl assume incompatible API version As perparation for future incompatible kdbus kernel API changes.

sd-bus: properly handle creds that are known but undefined for a process A number of fields do not apply to all processes, including: there a processes without a controlling tty, without parent process, without service, user services or session. To distuingish these cases from the case where we simply don't have the data, always return ENXIO for them, while returning ENODATA for the case where we really lack the information. Also update the credentials dumping code to show this properly. Fields that are known but do not apply are now shown as "n/a". Note that this also changes some of the calls in process-util.c and cgroup-util.c to return ENXIO for these cases.

sd-bus: expose ppid field kdbus has been passing us the ppid file for a while, actually make use of it.

shared: add formats-util.h

tree-wide: there is no ENOTSUP on linux Replace ENOTSUP by EOPNOTSUPP as this is what linux actually uses.

sd-bus: sync kdbus.h (ABI break) After some reconsideration, we decided to move the binary protocol back to 64-bit wide UIDs and GIDs. After all, it should be possible to redefine [gu]id_t to uint64_t and things should continue to work. As we want to avoid such data types in kdbus.h, let's move back to 64-bit values and be safe. In sd-bus, we have to do a translation between uint64_t and gid_t now for supplementary gids. Some inline comments have also been updated in kdbus upstream.

sd-bus: sync kdbus.h Follow two small changes in the kdbus API: * Flags are now returned in cmd->return_flags by KDBUS_CMD_NAME_ACQUIRE * struct kdbus_item_list has been dropped. The information stored in this struct was redundant since awhile already, as all commands report their returned slice size anyway.

remove unused includes This patch removes includes that are not used. The removals were found with include-what-you-use which checks if any of the symbols from a header is in use.

bus: sync with kdbus Pull in new kdbus changes, namely: - EOVERFLOW is replaces by KDBUS_RECV_RETURN_DROPPED_MSGS - ENOMSG is merged with EAGAIN for consistency

sd-bus: make sure we always serialize the reply cookie as 64bit on dbus2, and 32bit on dbus1

Revert "Revert "sd-bus: change serialization of kdbus messages to qualify in their entirety as gvariant objects"" This reverts commit 954871d8ba15911d014f76ed2c7a9492953cf39d.

sd-bus: sync kdbus.h (ABI break) Another slice logic rework in kdbus made KDBUS_ITEM_PAYLOAD_OFF items relative to the message header again. Catch up with that in sd-bus.

tree-wide: whenever we include libgen.h, immediately undefine basename() Also, document in adjacent comments and in CODING_STYLE why we do that.

bus: sync with kdbus (ABI break)

Revert "sd-bus: change serialization of kdbus messages to qualify in their entirety as gvariant objects" This breaks booting with kdbus. This reverts commit b381de4197157748ed96e469fcc372c23f842ae1.

sd-bus: change serialization of kdbus messages to qualify in their entirety as gvariant objects Previously, we only minimally altered the dbus1 framing for kdbus, and while the header and its fields where compliant Gvariant objects, and so was the body, the entire message together was not. As result of discussions with Ryan Lortie this is now changed, so that the messages in there entirely are fully compliant GVariants. This follows the framing description described here: https://wiki.gnome.org/Projects/GLib/GDBus/Version2 Note that this change changes the framing of *all* messages sent via kdbus, this means you have to reboot your kdbus system, after compiling and installing this new version.

sd-bus: reuse the KDBUS_CMD_FREE wrapper wherever appropriate

bus: drop systemd.kdbus_attach_flags_mask= cmdline There is no reason to provide our own attach_flags_mask. We can simply rely on kdbus.attach_flags_mask= which is read by the kernel *and* kmod. If it's set, we assume the user wants to override our setting, so we simply skip setting it.

sd-bus: sync kdbus.h (API break) Just a simple variable rename, and a dropped flag that sd-bus didn't make use of.

bus: append bloom-filter to all signals Make sure to append bloom-filters to all signal-messages, not only broadcasts.

sd-bus: unify how we set the sender of synthetic messages

sd-bus: make use of the newly added timestamps on kdbus kernel messages

sd-bus: sync kdbus.h Catch up with latest changes in kdbus.ko: * Signals can be sent as unicast now, hence they need to be marked as such with the KDBUS_MSG_SIGNAL in the message flags. * Follow ioctl number change for KDBUS_CMD_FREE

bus: fix capabilities on big-endian The kernel provides capabilities as a u32 array, sd-bus uses an u8 array. This works fine on little-endian as both are encoded the same way. However, this fails on big-endian if we do not perform sufficient byte-swapping on each u32 entry. This patch makes sd-bus use u32, too. We avoid changing any kernel provided data so we can keep pointing into kdbus pool buffers which contain u32 arrays.

bus: drop creds->capability_size The number of available caps can be read from /proc/sys/kernel/cap_last_cap during runtime. Our helper cap_last_cap() does that, so there's no reason to remember the size of any capability cache. We can just pre-allocate arrays with a suitable size for all available caps and reject any higher caps. The kernel capability API uses u32 as base so make sure we do the same. Note that this is specified by POSIX, so it's unlikely to change.

bus: fix typo Drop spurious 'we'.

core: rearrange code so that libsystemd/sd-bus/ does not include header files from core Stuff in src/shared or src/libsystemd should *never* include code from src/core or any of the tools, so don't do that here either. It's not OK!

sd-bus: ignore KDBUS_ITEM_TIMESTAMP in kernel messages Kernel notifications carry a timestamp now, so make sure bus_kernel_translate_message() doesn't complain when it stumbles across them.

bus: send attach flags on BUS_MAKE Make sure to set send-attach-flags on BUS_MAKE. These control which information is revealed about the bus-owner.

bus: fix assert() on HELLO error-path Make sure we don't call into any bus_kernel_*() functions before b->is_kernel is set to true. Hard-code the CMD_FREE just like the other helpers do.

bus: sync with kdbus.git Changes: * bloom parameters are returned in an offset via HELLO * FREE now takes items just like any other ioctl

bus: sync with kdbus.git Sync up with recent kdbus changed: * several ioctls gained .size and .items members (but still unused) * CMD_SEND gained its own ioctl structure * several members of kdbus_msg were dropped as they were only used during SEND, not during RECV etc. * CMD_RECV and CMD_SEND now share a kdbus_reply member which contains the offset and size of the returned message.

kdbus: downgrade warning if we cannot patch kdbus attach mask to DEBUG if kdbus is not available

sd-bus: get rid of PID starttime concept As kdbus no longer exports this, remove all traces from sd-bus too

bus: sync with kdbus-git (ABI break) kdbus-git gained two new features: * memfd offsets: This allows to specify a 'start' offset in kdbus_memfd so you can send partial memfd hunks instead of always the full memfd * KDBUS_HELLO_UNPRIVILEGED: If passed during HELLO, the client will be treated as unprivileged.

sd-bus: follow kdbus changes (ABI break) Implement a recent change in the kdbus pool logic: PAYLOAD_VEC_OFF items are now referencing offsets relative to the connection's pool, not to the item itself. Follow this change in sd-bus.

treewide: introduce UID_INVALID (and friends) as macro for (uid_t) -1

sd-bus: add arrays of strings in the bloom filter Let's do this right from the beginning, to prepare ground for udev messages that most likely want to store list of strings (for device tags) in messages, and filter on them.

sd-bus: add new call sd_bus_get_scope() for querying whether one is connected to a system or a user bus

sd-bus: rework credential query logic Also, make the call to free kdbus slices generic and use it everywhere

treewide: no need to negate errno for log_*_errno() It corrrectly handles both positive and negative errno values.

treewide: auto-convert the simple cases to log_*_errno() As a followup to 086891e5c1 "log: add an "error" parameter to all low-level logging calls and intrdouce log_error_errno() as log calls that take error numbers", use sed to convert the simple cases to use the new macros: find . -name '*.[ch]' | xargs sed -r -i -e \ 's/log_(debug|info|notice|warning|error|emergency)\("(.*)%s"(.*), strerror\(-([a-zA-Z_]+)\)\);/log_\1_errno(-\4, "\2%m"\3);/' Multi-line log_*() invocations are not covered. And we also should add log_unit_*_errno().

kdbus: when running in a container, don't complain that we cannot write to /sys

sd-bus: the attach_mask kernel module parameter is 64bit now, hence initialize it as such

kdbus: set kernel attach mask before creating the first bus

sd-bus: when we get the list of well-known names back from kdbus we shouldn't confuse the empty list with unknown information

sd-bus: unify logic how we patch the message source of driver messages

sd-bus: fake valid well-known-names metadata for faked bus messages

sd-bus: optimize how we generate the well-known-names lists in messages from kdbus

sd-bus: be stricter with mismatches between dbus1 and kdbus message headers

bus: prefix custom endpoints with "$UID-" The kdbus module will later get a policy that endpoint-names are restricted to "<uid>-<name>" just like bus-names. Make sure that systemd is already compatible to that.

sd-bus: given that the kernel now passes the auxgroups list as 32bit array to us, no need to convert to uid_t manually This way, we can save one allocation and avoid copying the array unnecesarily.

bus: update kdbus.h (ABI break) We changed creds to u32, so fix systemd sd-bus to acknowledge that.

bus-kernel: when installing an activator, ask for any kind of metadata to be attached to incoming messages We don't know what the activated service might want in the end, hence enable everything current and future, just to be sure.

sd-bus: don't clobber return values on failure in bus_kernel_open_bus_fd()

sd-bus: set per-bus attach flag requirement mask to ANY On the system and user busses we create it's the receiver that chooses which metadata is attched, not the sender, hence set the requirement mask to ANY, to allow any current of future credential bit to be attached.

sd-bus: add suppot for renegotiating message credential attach flags

sd-bus: react properly to EOVERFLOW by generating a log message about dropped broadcast messages and proceeding

kdbus: minor simplification

sd-bus: fix error handling when receiving invalid service name Also, properly keep track of incoming additional service names.

sd-bus: properly handle non-initialized audit records attached to incoming kernel messages

sd-bus: add supplementary groups list to creds object

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

sd-bus: sync with kdbus upstream (ABI break) kdbus has seen a larger update than expected lately, most notably with kdbusfs, a file system to expose the kdbus control files: * Each time a file system of this type is mounted, a new kdbus domain is created. * The layout inside each mount point is the same as before, except that domains are not hierarchically nested anymore. * Domains are therefore also unnamed now. * Unmounting a kdbusfs will automatically also detroy the associated domain. * Hence, the action of creating a kdbus domain is now as privileged as mounting a filesystem. * This way, we can get around creating dev nodes for everything, which is last but not least something that is not limited by 20-bit minor numbers. The kdbus specific bits in nspawn have all been dropped now, as nspawn can rely on the container OS to set up its own kdbus domain, simply by mounting a new instance. A new set of mounts has been added to mount things *after* the kernel modules have been loaded. For now, only kdbus is in this set, which is invoked with mount_setup_late().

sd-bus: add sd_bus_message.verify_destination_id and .destination_ptr kdbus learned to accept both a numerical destination ID as well as a well-known-name. In that case, kdbus makes sure that the numerical ID is in fact the owner of the provided name and fails otherwise. This allows for race-free assertion of a bus name owner while sending a message, which is a requirement for bus-proxyd. Add two new fields to sd_bus_message, and set the numerical ID to verify_destination_id if bus_message_setup_kmsg() is called for a message with a well-known name. Also, set the destination's name in the kdbus item to .destination_ptr if it is non-NULL. Normal users should not touch these fields, and they're not publicy accessible.

sd-bus: by default allow all creds to be passed along

sd-bus: sync up with new kdbus metadata attachment logic (ABI break) The metadata logic in kdbus has seen a rework, and the only mandatory change we have to follow for now is that attach_flags in kdbus_cmd_hello is now split into two parts, attach_flags_send and attach_flags_recv.

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.

sd-bus: sync kdbus.h (ABI break) Catch up with some changes in kdbus.h: * KDBUS_{ITEM,ATTACH}_CONN_NAME were renamed to KDBUS_{ITEM,ATTACH}_CONN_DESCRIPTION, so the term 'name' is not overloaded as much. * The item types were re-ordered a little so they are lined up to the order of the corresponding KDBUS_ATTACH flags * A new item type KDBUS_ITEM_OWNED_NAME was introduced, designated to store a struct kdbus_name in item->name. KDBUS_ITEM_NAME soley stores data in item->str now * Some kerneldoc fixes

sd-bus: add missing include

memfd: always use our internal utility functions where we have them

memfd: always create our memfds with CLOEXEC set We really shouldn't create fds ever that have the flag unset.

sd-bus: sync kdbus.h (ABI break) Some comment fixes and header cleanups in kdbus.h, and the task capability meta information has been factored out to its own struct.

sd-bus: assert clock_gettime()'s return value Don't handle clock_gettime() errors gracefully but use assert_se().

sd-bus: sync kdbus.h (API change: switch to absolute timeouts) kdbus_msg.timeout_ns now takes an absolute value, based on CLOCK_MONOTONIC, in order to eventually support automatically restarted syscalls. Signed-off-by: Daniel Mack <daniel@zonque.org>

sd-bus: sync kdbus.h (ABI break) In kdbus.h, the following details changed: * All commands gained a 'kernel_flags' field to report the flags supported by the driver. Before, this was done in the 'flags' field in a bidirectional way, which turned out to be a problem for the code in sd-bus, as many parts of it reuse the same ioctl struct more than once and consider them to be owned by userspace. * Name listings are now returned by a new struct instead of reusing struct kdbus_cmd_name for that matter. This way, we don't add more unneeded fields to it and make the API cleaner. * 'conn_flags' was renamed to 'flags' in struct kdbus_cmd_hello to make the API a bit more unified.

sd-bus: sync kdbus.h (ABI break) kdbus.h now has KDBUS_ATTACH_COMM split into KDBUS_ATTACH_TID_COMM and KDBUS_ATTACH_PID_COMM. The items were split already, so the change in systemd is easy.

sd-bus: sync kdbus.h (ABI break) In kdbus.h, the 'features' field has been dropped again. Instead of negotiating features that way, we decided to make the kernel return the set of supported flags in each ioctl struct's .flags field, in both the success and error cases.

Revert "sd-bus: sync kdbus.h (ABI break)" This reverts commit 1a2409e262da65a4b0ca8ab18fcf5eabd2d404ca. Support from the kdbus interface was removed. We require memfds to be supported by all clients.

sd-bus: sync kdbus.h (ABI break) kdbus learned KDBUS_HELLO_ACCEPT_MEMFD as new connection negotiation flag. Set it by default in systemd for now.

sd-bus: sync kdbus.h (ABI break) Sync kdbus.h once again. Two thing have changed: a) KDBUS_CMD_EP_* was renamed to KDBUS_CMD_ENDPOINT_* b) struct kdbus_cmd_hello and struct kdbus_cmd_make gained a 'features' bitfield (which is currently unused)

sd-bus: fix use-after-free in close_kdbus_msg() Walk the items first, then free the memory of the message. Also, while at it, make coverity happy with an explicit (void) prefix. We intentionally ignore the return value here.

sd-bus: remove unused variable It is no longer used after d663f1b1a92a778bcdc68f29b8c08cb49431b4f7

sd-bus: sync kdbus.h (ABI break) The KDBUS_CMD_FREE ioctl now uses a struct rather than a direct pointer to the offset to free. The KDBUS_CMD_MSG_CANCEL ioctl has also changes, but there's no user of it yet in systemd.

sd-bus: split out cleanup into separate function m is always non-null at this point. This function is too long anyway.

kdbus: don't clobber return values, use strjoin() instead of asprintf(), keep function invocations and variable declarations separate

kdbus: make sure we never invoke free() on an uninitialized pointer on OOM

sd-bus: sync kdbus.h (API break) Just a rename of two struct members to make the header file c++ compatible.

bus: align kdbus ioctl parameters to 8byte All kdbus ioctl arguments must be 8byte aligned. Make sure we use alloca_align() and _alignas_(8) in all situations where gcc doesn't guarantee 8-byte alignment. Note that objects on the stack are always 8byte aligned as we put _alignas_(8) into the structure definition in kdbus.h.

Fix resource leak (coverity CID 1237760)

bus: add code to create custom endpoints and set their policy Custom endpoints are alternative connection points to a bus, allowing specific policy to be uploaded. Add two functions to bus-kernel. One to create such endpoints, and another one for setting a policy for them.

bus: factor out bus policy items In order to re-use the policy definitions, factor them out into their own files.

sd-bus: remove unused call bus_kernel_create_monitor() Noticed by Djalal Harouni

bus-control: Fix cgroup handling On systems without properly setup systemd, cg_get_root_path returns -ENOENT. This means that busctl doesn't display much information. busctl monitor also fails whenever it intercepts messages. This fix fakes creates a fake "/" root cgroup which lets busctl work on such systems.

memfd: fix memfd_create() syscall wrapper Unlike earlier versions, the syscall only takes 2 arguments in its final version, not 3.

kdbus: switch over to generic memfd implementation (ABI+API break)

Print kdbus path when opening fails This makes it easier to debug what is going on.

kdbus: when uploading bus name policy, resolve users/groups out-of-process It's not safe invoking NSS from PID 1, hence fork off worker processes that upload the policy into the kernel for busnames.

Remove unnecessary casts in printfs No functional change expected :)

sd-bus: add proper monitoring API

busname: introduce Activating directive Add a new config 'Activating' directive which denotes whether a busname is actually registered on the bus. It defaults to 'yes'. If set to 'no', the .busname unit only uploads policy, which will remain active as long as the unit is running.

core: when creating an activating busname attach all metadata fields to the messages queued for it This way we can be sure that the service the messages are ultimately intended for finds all fields it might need.

core: add new AcceptFD= setting to .busname units AcceptFD= defaults to true, thus making sure that by default fd passing is enabled for all activatable names. Since for normal bus connections fd passing is enabled too by default this makes sure fd passing works correctly regardless whether a service is already activated or not. Making this configurable on both busname units and in bus connections is messy, but unavoidable since busnames are established and may queue messages before the connection feature negotiation is done by the service eventually activated. Conversely, feature negotiation on bus connections takes place before the connection acquires its names. Of course, this means developers really should make sure to keep the settings in .busname units in sync with what they later intend to negotiate.

test

util: replace close_nointr_nofail() by a more useful safe_close() safe_close() automatically becomes a NOP when a negative fd is passed, and returns -1 unconditionally. This makes it easy to write lines like this: fd = safe_close(fd); Which will close an fd if it is open, and reset the fd variable correctly. By making use of this new scheme we can drop a > 200 lines of code that was required to test for non-negative fds or to reset the closed fd variable afterwards.

Use strlen even for constant strings GCC optimizes strlen("string constant") to a constant, even with -O0. Thus, replace patterns like sizeof("string constant")-1 with strlen("string constant") where possible, for clarity. In particular, for expressions intended to add up the lengths of components going into a string, this often makes it clearer that the expression counts the trailing '\0' exactly once, by putting the +1 for the '\0' at the end of the expression, rather than hidden in a sizeof in the middle of the expression.

sd-bus: don't look for a 64bit value when we only have 32bit value on reply cookie hash table access This broke hashtable lookups for the message cookies on s390x, which is a 64bit BE machine where accessing 32bit values as 64bit and vice versa will explode. Also, while we are at it, be a bit more careful when dealing with the 64bit cookies we expose and the 32bit serial numbers dbus uses in its payload. Problem identified by Fridrich Strba.

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.

sd-bus: add support for policy upload on activator connections Activator connections may upload policy when registering to the bus. This patch contains code to translate between BusNamePolicy objects and the kdbus specific items.

sd-bus: sync kdbus.h (ABI break) Bring kdbus.h in sync with recent policy related changes. Most notably, KDBUS_MAKE_POLICY_OPEN is now gone. The rest doesn't matter for systemd at this point, as the policy functionality was not yet used.

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.

doc: update punctuation Resolve spotted issues related to missing or extraneous commas, dashes.

bus: update kdbus.h (ABI break)

use memzero(foo, length); for all memset(foo, 0, length); calls In trying to track down a stupid linker bug, I noticed a bunch of memset() calls that should be using memzero() to make it more "obvious" that the options are correct (i.e. 0 is not the length, but the data to set). So fix up all current calls to memset(foo, 0, length) to memzero(foo, length).

bus: rework bloom filter logic to operate with variable bloom filter sizes and numbers of hash functions In order to make the bloom filter logic more future proof communicate bloom filter parameters from the original bus creator to the clients, and allow them to be variable within certain ranges.

bus: when we cannot bus activate a service because we go down, drop one message from the queue

bus: update kdbus.h (ABI break)

bus: add sd_bus_process_priority() to support prioq mode of kdbus

bus: expose priority field of messages, in preparation for prioq support

bus: pass timestamp info only to caller if he asked for it

bus: include connection name in credentials structure

bus: when allocating a memfd for usage in a bus connection, name the memfd after the bus connection

bus: add support for attaching name to bus connections for debugging purposes

bus: add API for querying the kdbus message sequence number

bus: implement synchronous message calls via kernel ioctl

libsystemd: split up into subdirs We still only produce on .so, but let's keep the sources separate to make things a bit less messy.