Discussion:
proper use of /run/{user/<uid>, }/systemd/private sockets
(too old to reply)
Simon McVittie
2017-11-14 12:18:40 UTC
Permalink
That being said, the system socket location is hardcoded not just in systemd,
but in the dbus specification itself.
The D-Bus Specification does not say anything about the
.../systemd/private sockets. That would be inappropriate: those sockets
are private (not API), and are part of systemd (not D-Bus).

The socket path that is hard-coded in the D-Bus specification is the
well-known system bus socket, /var/run/dbus/system_bus_socket, used by
`dbus-daemon --system` and all D-Bus client implementations (dbus, GDBus,
sd-bus and others). This is present in the D-Bus Specification because
every D-Bus implementation needs to agree on it: otherwise they cannot
interoperate.

If you have dbus-daemon installed and available, then you can
communicate with the system instance of systemd (pid 1) via the D-Bus
system bus. This is a public API that offers the same functionality as
/run/systemd/private, except that it does not work without the system
dbus-daemon.

Similarly, if you have dbus-daemon installed and available and dbus was
configured with the --enable-user-session option (or on Debian derivatives
and similar, if the dbus-user-session package is installed), then you
can communicate with the per-user instance of systemd (systemd --user)
via the D-Bus session bus (which is a "user bus" in this configuration),
$XDG_RUNTIME_DIR/bus. This is a public API that offers the same
functionality as $XDG_RUNTIME_DIR/systemd/private, except that it does
not work without the per-user dbus-daemon.

(Or strictly speaking, you don't *need* dbus-daemon; you could be using
a compatible reimplementation instead.)

Regards,
smcv
Lennart Poettering
2017-11-14 14:52:25 UTC
Permalink
hope you guys are doing great!. So i have a few questions, hope this is the
best place for them.
I've been doing a lot of work with `sd-bus.h` (basically i've been trying
to bind it to other languages to then interact with systemd natively).
I've been reading the man pages/blog post/general docs, but mostly the src
code. and i stumble across
https://github.com/systemd/systemd/blob/master/src/shared/bus-util.c#L598-L605
and saw that you can connect to systemd using the sockets, for root would
be `/run/systemd/private`, and for users something like
`/run/user/<uid>/systemd/private` and this trigger lots of questions, that
Note that these sockets aren't really the official way to talk to
systemd, they are called "private" for the reason that they, well, are
"private" to systemd...
Question 1)
what would be the advantage of connecting through dbus instead of directly
through the socket?
They are available unconditionally as long as systemd is running, from
earliest boot to final shutdown. They are available in emergency mode,
and normal boot and really always. This is different for dbus-daemon,
which is available only during later boot, and is likely to be missing
in emergency mode, the initrd, and during shutdown.

Since systemd must take client requests at any time we thus bind to
this socket, and systemctl has some code to optionally connect to
that.
the way i connect to systemd is with `sd_bus_open_system` but i can also do
```
sd_bus_new(&bus);
sd_bus_set_address(bus, "unix:path=/run/systemd/private");
sd_bus_start(bus);
```
why (or when) would one be better than the other?
Generally the bus is the official way, and the private socket is only
for systemctl and very few other cases which must be able to deal with
dbus-daemon, i.e. the official bus being absent.

Note that the private socket is accessible to root only.
question 2);
i also look that you can do the same with the user connections (and this is
mostly true when the --user flag is given, at least on systemd-run), and
you can connect to something like `/run/user/<uid>/systemd/private`, where
`/run/user/<uid>` is $XDG_RUNTIME_DIR, and i guess this is really the best
form to connect to systemd as a user, but is there any difference between
using that socket or doing `sd_bus_open_user`. ?
systemd sucks as a bus replacement. Use the proper bus, and leave the
private sockets be, please. Unless you have a very good reason to
prefer the private socket: it's not for normal users.
question 3)
systemd source code is pretty clear, really easy to learn from, also
sd-bus.h is incredible helpful and easy to use.
But the docs is good, don't get me wrong, but it could definitely use more
love. for instance the usage of the sockets
`/run/{user/uid,}/systemd/private`, is not documented anywhere that i could
find. is this intentional?,
Yes, it is intentional. The name "private" is also intentional: it's a
private, internal API of systemd, and should not be considered
something people should use outside of very specific environments.
is this because this is a implementation detail
that may change in the future?. if so, what would be the correct way to
connect to systemd's socket?
Don't connect directly to it. Use the official bus instead. Forget
that you know about the private connection at all...

Lennart
--
Lennart Poettering, Red Hat
aleivag
2017-11-14 15:39:40 UTC
Permalink
Post by Lennart Poettering
Don't connect directly to it. Use the official bus instead. Forget
that you know about the private connection at all...
Lennart
got it, "this aren't the sockets you're looking for" :), will use then
propper `sd_bus_open_*`

Thanks Guys!
Alvaro

Loading...