shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-15 07:24:00 +03:00
Code
827bf3c5dd
systemd/src/bus-proxyd/bus-proxyd.c

1419 lines
50 KiB
C
Raw Normal View History

systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
Copyright 2013 Daniel Mack
Copyright 2014 Kay Sievers
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
systemd is free software; you can redistribute it and/or modify it
relicense to LGPLv2.1 (with exceptions) We finally got the OK from all contributors with non-trivial commits to relicense systemd from GPL2+ to LGPL2.1+. Some udev bits continue to be GPL2+ for now, but we are looking into relicensing them too, to allow free copy/paste of all code within systemd. The bits that used to be MIT continue to be MIT. The big benefit of the relicensing is that closed source code may now link against libsystemd-login.so and friends.
2012-04-12 02:20:58 +04:00
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
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
(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
relicense to LGPLv2.1 (with exceptions) We finally got the OK from all contributors with non-trivial commits to relicense systemd from GPL2+ to LGPL2.1+. Some udev bits continue to be GPL2+ for now, but we are looking into relicensing them too, to allow free copy/paste of all code within systemd. The bits that used to be MIT continue to be MIT. The big benefit of the relicensing is that closed source code may now link against libsystemd-login.so and friends.
2012-04-12 02:20:58 +04:00
Lesser General Public License for more details.
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
relicense to LGPLv2.1 (with exceptions) We finally got the OK from all contributors with non-trivial commits to relicense systemd from GPL2+ to LGPL2.1+. Some udev bits continue to be GPL2+ for now, but we are looking into relicensing them too, to allow free copy/paste of all code within systemd. The bits that used to be MIT continue to be MIT. The big benefit of the relicensing is that closed source code may now link against libsystemd-login.so and friends.
2012-04-12 02:20:58 +04:00
You should have received a copy of the GNU Lesser General Public License
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
#include <sys/poll.h>
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
#include <stddef.h>
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
#include <getopt.h>
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
#include "log.h"
#include "util.h"
#include "socket-util.h"
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
#include "sd-daemon.h"
#include "sd-bus.h"
#include "bus-internal.h"
#include "bus-message.h"
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 08:10:04 +04:00
#include "bus-util.h"
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 03:15:30 +04:00
#include "bus-internal.h"
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
#include "build.h"
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
#include "strv.h"
Move bus path definitions to def.h
2013-12-31 01:12:46 +04:00
#include "def.h"
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
#include "capability.h"
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
Move bus path definitions to def.h
2013-12-31 01:12:46 +04:00
static const char *arg_address = DEFAULT_SYSTEM_BUS_PATH;
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
static char *arg_command_line_buffer = NULL;
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
static bool arg_drop_privileges = false;
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
static int help(void) {
printf("%s [OPTIONS...]\n\n"
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
"Connect STDIO or a socket to a given bus address.\n\n"
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
" -h --help Show this help\n"
" --version Show package version\n"
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
" --drop-privileges Drop privileges\n"
bus-proxyd: show address nicely in --help
2013-12-21 19:26:55 +04:00
" --address=ADDRESS Connect to the bus specified by ADDRESS\n"
Move bus path definitions to def.h
2013-12-31 01:12:46 +04:00
" (default: " DEFAULT_SYSTEM_BUS_PATH ")\n",
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
program_invocation_short_name);
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
return 0;
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
ARG_ADDRESS,
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
ARG_DROP_PRIVILEGES,
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
};
static const struct option options[] = {
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "address", required_argument, NULL, ARG_ADDRESS },
{ "drop-privileges", no_argument, NULL, ARG_DROP_PRIVILEGES },
{ NULL, 0, NULL, 0 },
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
};
int c;
assert(argc >= 0);
assert(argv);
man: add systemd-dbus-proxy@.service(8) and systemd-dbus.proxy(8)
2013-12-21 22:58:14 +04:00
while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0) {
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
switch (c) {
case 'h':
help();
return 0;
case ARG_VERSION:
puts(PACKAGE_STRING);
puts(SYSTEMD_FEATURES);
return 0;
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
case ARG_ADDRESS:
arg_address = optarg;
break;
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
case ARG_DROP_PRIVILEGES:
arg_drop_privileges = true;
break;
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
case '?':
return -EINVAL;
default:
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
assert_not_reached("Unhandled option");
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
}
}
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
/* If the first command line argument is only "x" characters
* we'll write who we are talking to into it, so that "ps" is
* explanatory */
arg_command_line_buffer = argv[optind];
if (argc > optind + 1 ||
(arg_command_line_buffer && arg_command_line_buffer[strspn(arg_command_line_buffer, "x")] != 0)) {
log_error("Too many arguments");
return -EINVAL;
}
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
return 1;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
static int rename_service(sd_bus *a, sd_bus *b) {
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
_cleanup_free_ char *p = NULL, *name = NULL;
const char *comm;
char **cmdline;
uid_t uid;
pid_t pid;
int r;
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
assert(a);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
assert(b);
r = sd_bus_get_peer_creds(b, SD_BUS_CREDS_UID|SD_BUS_CREDS_PID|SD_BUS_CREDS_CMDLINE|SD_BUS_CREDS_COMM, &creds);
if (r < 0)
return r;
r = sd_bus_creds_get_uid(creds, &uid);
if (r < 0)
return r;
r = sd_bus_creds_get_pid(creds, &pid);
if (r < 0)
return r;
r = sd_bus_creds_get_cmdline(creds, &cmdline);
if (r < 0)
return r;
r = sd_bus_creds_get_comm(creds, &comm);
if (r < 0)
return r;
name = uid_to_name(uid);
if (!name)
return -ENOMEM;
p = strv_join(cmdline, " ");
if (!p)
return -ENOMEM;
/* The status string gets the full command line ... */
sd_notifyf(false,
Use format patterns for usec_t, pid_t, nsec_t, usec_t It is nicer to predefine patterns using configure time check instead of using casts everywhere. Since we do not need to use any flags, include "%" in the format instead of excluding it like PRI* macros.
2013-12-31 02:22:26 +04:00
"STATUS=Processing requests from client PID "PID_FMT" (%s); UID "UID_FMT" (%s)",
pid, p,
uid, name);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
/* ... and the argv line only the short comm */
if (arg_command_line_buffer) {
size_t m, w;
m = strlen(arg_command_line_buffer);
w = snprintf(arg_command_line_buffer, m,
Use format patterns for usec_t, pid_t, nsec_t, usec_t It is nicer to predefine patterns using configure time check instead of using casts everywhere. Since we do not need to use any flags, include "%" in the format instead of excluding it like PRI* macros.
2013-12-31 02:22:26 +04:00
"[PID "PID_FMT"/%s; UID "UID_FMT"/%s]",
pid, comm,
uid, name);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (m > w)
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).
2014-01-31 09:51:32 +04:00
memzero(arg_command_line_buffer + w, m - w);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
}
Use format patterns for usec_t, pid_t, nsec_t, usec_t It is nicer to predefine patterns using configure time check instead of using casts everywhere. Since we do not need to use any flags, include "%" in the format instead of excluding it like PRI* macros.
2013-12-31 02:22:26 +04:00
log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s",
pid, p,
uid, name,
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
a->unique_name);
;
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
return 0;
}
static int synthesize_name_acquired(sd_bus *a, sd_bus *b, sd_bus_message *m) {
_cleanup_bus_message_unref_ sd_bus_message *n = NULL;
const char *name, *old_owner, *new_owner;
int r;
assert(a);
assert(b);
assert(m);
/* If we get NameOwnerChanged for our own name, we need to
* synthesize NameLost/NameAcquired, since socket clients need
* that, even though it is obsoleted on kdbus */
if (!a->is_kernel)
return 0;
if (!sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameOwnerChanged") ||
!streq_ptr(m->path, "/org/freedesktop/DBus") ||
!streq_ptr(m->sender, "org.freedesktop.DBus"))
return 0;
r = sd_bus_message_read(m, "sss", &name, &old_owner, &new_owner);
if (r < 0)
return r;
r = sd_bus_message_rewind(m, true);
if (r < 0)
return r;
if (streq(old_owner, a->unique_name)) {
r = sd_bus_message_new_signal(
b,
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-20 02:54:58 +04:00
&n,
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
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-20 02:54:58 +04:00
"NameLost");
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
} else if (streq(new_owner, a->unique_name)) {
r = sd_bus_message_new_signal(
b,
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-20 02:54:58 +04:00
&n,
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
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-20 02:54:58 +04:00
"NameAcquired");
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
} else
return 0;
if (r < 0)
return r;
r = sd_bus_message_append(n, "s", name);
if (r < 0)
return r;
r = bus_message_append_sender(n, "org.freedesktop.DBus");
if (r < 0)
return r;
r = bus_seal_synthetic_message(b, n);
if (r < 0)
return r;
return sd_bus_send(b, n, NULL);
}
bus: add a temporary hard-coded policy to proxyd to make gdm work gdm relies on the policy to deny its own requests to not deadlock. Given that we currently do not enforce any policy in the dbus1 compat proxy service this means that gdm will necessarily deadlock on our systems. To work around this, enforce a fixed policy teomporarily, until we interpret the legacy XML policy in full. Booh, gdm, booh, for requring this and making me waste two days on tracking this brokenness down.
2013-12-26 19:07:38 +04:00
static int process_policy(sd_bus *a, sd_bus *b, sd_bus_message *m) {
_cleanup_bus_message_unref_ sd_bus_message *n = NULL;
int r;
assert(a);
assert(b);
assert(m);
if (!sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "GetAll"))
return 0;
if (!streq_ptr(m->path, "/org/gnome/DisplayManager/Slave"))
return 0;
r = sd_bus_message_new_method_errorf(m, &n, SD_BUS_ERROR_ACCESS_DENIED, "gdm, you are stupid");
if (r < 0)
return r;
r = bus_message_append_sender(n, "org.freedesktop.DBus");
if (r < 0) {
log_error("Failed to append sender to gdm reply: %s", strerror(-r));
return r;
}
r = bus_seal_synthetic_message(b, n);
if (r < 0) {
log_error("Failed to seal gdm reply: %s", strerror(-r));
return r;
}
r = sd_bus_send(b, n, NULL);
if (r < 0) {
log_error("Failed to send gdm reply: %s", strerror(-r));
return r;
}
return 1;
}
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
static int synthetic_driver_send(sd_bus *b, sd_bus_message *m) {
int r;
assert(b);
assert(m);
r = bus_message_append_sender(m, "org.freedesktop.DBus");
if (r < 0)
return r;
r = bus_seal_synthetic_message(b, m);
if (r < 0)
return r;
return sd_bus_send(b, m, NULL);
}
static int synthetic_reply_method_error(sd_bus_message *call, const sd_bus_error *e) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
int r;
if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
return 0;
r = sd_bus_message_new_method_error(call, &m, e);
if (r < 0)
return r;
return synthetic_driver_send(call->bus, m);
}
static int synthetic_reply_method_errno(sd_bus_message *call, int error, const sd_bus_error *p) {
_cleanup_bus_error_free_ sd_bus_error berror = SD_BUS_ERROR_NULL;
if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
return 0;
if (sd_bus_error_is_set(p))
return synthetic_reply_method_error(call, p);
sd_bus_error_set_errno(&berror, error);
return synthetic_reply_method_error(call, &berror);
}
static int synthetic_reply_method_return(sd_bus_message *call, const char *types, ...) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
int r;
if (call->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED)
return 0;
r = sd_bus_message_new_method_return(call, &m);
if (r < 0)
return r;
if (!isempty(types)) {
va_list ap;
va_start(ap, types);
r = bus_message_append_ap(m, types, ap);
va_end(ap);
if (r < 0)
return r;
}
return synthetic_driver_send(call->bus, m);
}
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
static int synthetic_reply_return_strv(sd_bus_message *call, char **l) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
int r;
r = sd_bus_message_new_method_return(call, &m);
if (r < 0)
return synthetic_reply_method_errno(call, r, NULL);
r = sd_bus_message_append_strv(m, l);
if (r < 0)
return synthetic_reply_method_errno(call, r, NULL);
return synthetic_driver_send(call->bus, m);
}
static int get_creds_by_name(sd_bus *bus, const char *name, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
_cleanup_bus_creds_unref_ sd_bus_creds *c = NULL;
int r;
assert(bus);
assert(name);
assert(_creds);
assert_return(service_name_is_valid(name), -EINVAL);
r = sd_bus_get_owner(bus, name, mask, &c);
if (r == -ESRCH || r == -ENXIO)
return sd_bus_error_setf(error, SD_BUS_ERROR_NAME_HAS_NO_OWNER, "Name %s is currently not owned by anyone.", name);
if (r < 0)
return r;
if ((c->mask & mask) != mask)
return -ENOTSUP;
*_creds = c;
c = NULL;
return 0;
}
static int get_creds_by_message(sd_bus *bus, sd_bus_message *m, uint64_t mask, sd_bus_creds **_creds, sd_bus_error *error) {
const char *name;
int r;
assert(bus);
assert(m);
assert(_creds);
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return r;
return get_creds_by_name(bus, name, mask, _creds, error);
}
static int peer_is_privileged(sd_bus *bus, sd_bus_message *m) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
uid_t uid;
int r;
r = get_creds_by_message(bus, m, SD_BUS_CREDS_UID, &creds, NULL);
if (r < 0)
return r;
r = sd_bus_creds_get_uid(creds, &uid);
if (r < 0)
return r;
r = sd_bus_creds_has_effective_cap(creds, CAP_SYS_ADMIN);
if (r > 0)
return true;
if (uid == getuid())
return true;
return false;
}
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
static int process_driver(sd_bus *a, sd_bus *b, sd_bus_message *m) {
int r;
assert(a);
assert(b);
assert(m);
if (!streq_ptr(sd_bus_message_get_destination(m), "org.freedesktop.DBus"))
return 0;
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
if (0 && !isempty(sd_bus_message_get_signature(m, true))) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_error_setf(&error, SD_BUS_ERROR_INVALID_ARGS, "Expected no parameters");
return synthetic_reply_method_errno(m, r, &error);
}
return synthetic_reply_method_return(m, "s",
"<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
"\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
"<node>\n"
" <interface name=\"org.freedesktop.DBus.Introspectable\">\n"
" <method name=\"Introspect\">\n"
" <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"
" </method>\n"
" </interface>\n"
" <interface name=\"org.freedesktop.DBus\">\n"
" <method name=\"AddMatch\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" </method>\n"
" <method name=\"RemoveMatch\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" </method>\n"
" <method name=\"GetConnectionSELinuxSecurityContext\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"ay\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"GetConnectionUnixProcessID\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"GetConnectionUnixUser\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"GetId\">\n"
" <arg type=\"s\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"GetNameOwner\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"s\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"Hello\">\n"
" <arg type=\"s\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"ListActivatableNames\">\n"
" <arg type=\"as\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"ListNames\">\n"
" <arg type=\"as\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"ListQueuedOwners\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"as\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"NameHasOwner\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"b\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"ReleaseName\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"ReloadConfig\">\n"
" </method>\n"
" <method name=\"RequestName\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"StartServiceByName\">\n"
" <arg type=\"s\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"in\"/>\n"
" <arg type=\"u\" direction=\"out\"/>\n"
" </method>\n"
" <method name=\"UpdateActivationEnvironment\">\n"
" <arg type=\"a{ss}\" direction=\"in\"/>\n"
" </method>\n"
" <signal name=\"NameAcquired\">\n"
" <arg type=\"s\"/>\n"
" </signal>\n"
" <signal name=\"NameLost\">\n"
" <arg type=\"s\"/>\n"
" </signal>\n"
" <signal name=\"NameOwnerChanged\">\n"
" <arg type=\"s\"/>\n"
" <arg type=\"s\"/>\n"
" <arg type=\"s\"/>\n"
" </signal>\n"
" </interface>\n"
"</node>\n");
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "AddMatch")) {
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
const char *match;
r = sd_bus_message_read(m, "s", &match);
if (r < 0)
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_errno(m, r, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04: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 03:15:30 +04:00
r = sd_bus_add_match(a, NULL, match, NULL, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
if (r < 0)
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_errno(m, r, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_return(m, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RemoveMatch")) {
const char *match;
r = sd_bus_message_read(m, "s", &match);
if (r < 0)
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_errno(m, r, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04: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 03:15:30 +04:00
r = bus_remove_match_by_string(a, match, NULL, NULL);
if (r == 0)
return synthetic_reply_method_error(m, &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, "Match rule not found"));
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
if (r < 0)
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_errno(m, r, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
bus-proxy: when replying to bus calls set a synthetic serial number and patch the sender address Otherwise old libdbus1 is confused and will not accept our replies.
2014-04-14 06:43:00 +04:00
return synthetic_reply_method_return(m, NULL);
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext")) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
r = get_creds_by_message(a, m, SD_BUS_CREDS_SELINUX_CONTEXT, &creds, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "y", creds->label, strlen(creds->label));
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixProcessID")) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
r = get_creds_by_message(a, m, SD_BUS_CREDS_PID, &creds, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->pid);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetConnectionUnixUser")) {
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
r = get_creds_by_message(a, m, SD_BUS_CREDS_UID, &creds, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "u", (uint32_t) creds->uid);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetId")) {
sd_id128_t server_id;
char buf[SD_ID128_STRING_MAX];
r = sd_bus_get_server_id(a, &server_id);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "s", sd_id128_to_string(server_id, buf));
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "GetNameOwner")) {
const char *name;
_cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (streq(name, "org.freedesktop.DBus"))
return synthetic_reply_method_return(m, "s", "org.freedesktop.DBus");
r = get_creds_by_name(a, name, SD_BUS_CREDS_UNIQUE_NAME, &creds, &error);
if (r < 0)
return synthetic_reply_method_errno(m, r, &error);
return synthetic_reply_method_return(m, "s", creds->unique_name);
/* "Hello" is handled in process_hello() */
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListActivatableNames")) {
_cleanup_strv_free_ char **names = NULL;
r = sd_bus_list_names(a, NULL, &names);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
/* Let's sort the names list to make it stable */
strv_sort(names);
return synthetic_reply_return_strv(m, names);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListNames")) {
_cleanup_strv_free_ char **names = NULL;
r = sd_bus_list_names(a, &names, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
r = strv_extend(&names, "org.freedesktop.DBus");
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
/* Let's sort the names list to make it stable */
strv_sort(names);
return synthetic_reply_return_strv(m, names);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ListQueuedOwners")) {
struct kdbus_cmd_name_list cmd = {};
struct kdbus_name_list *name_list;
struct kdbus_cmd_name *name;
_cleanup_strv_free_ char **owners = NULL;
char *arg0;
int err = 0;
r = sd_bus_message_read(m, "s", &arg0);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (service_name_is_valid(arg0) < 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
cmd.flags = KDBUS_NAME_LIST_QUEUED;
r = ioctl(a->input_fd, KDBUS_CMD_NAME_LIST, &cmd);
if (r < 0)
return synthetic_reply_method_errno(m, -errno, NULL);
name_list = (struct kdbus_name_list *) ((uint8_t *) a->kdbus_buffer + cmd.offset);
KDBUS_ITEM_FOREACH(name, name_list, names) {
char *n;
if (name->size <= sizeof(*name))
continue;
if (!streq(name->name, arg0))
continue;
if (asprintf(&n, ":1.%llu", (unsigned long long) name->owner_id) < 0) {
err = -ENOMEM;
break;
}
r = strv_consume(&owners, n);
if (r < 0) {
err = r;
break;
}
}
r = ioctl(a->input_fd, KDBUS_CMD_FREE, &cmd.offset);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (err > 0)
return synthetic_reply_method_errno(m, err, NULL);
return synthetic_reply_return_strv(m, owners);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "NameHasOwner")) {
const char *name;
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (service_name_is_valid(name) < 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
if (streq(name, "org.freedesktop.DBus"))
return synthetic_reply_method_return(m, "b", true);
r = sd_bus_get_owner(a, name, 0, NULL);
if (r < 0 && r != -ESRCH && r != -ENXIO)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "b", r >= 0);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReleaseName")) {
const char *name;
r = sd_bus_message_read(m, "s", &name);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (service_name_is_valid(name) < 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
r = sd_bus_release_name(a, name);
if (r < 0) {
if (r == -ESRCH)
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 03:15:30 +04:00
return synthetic_reply_method_return(m, "u", BUS_NAME_NON_EXISTENT);
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
if (r == -EADDRINUSE)
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 03:15:30 +04:00
return synthetic_reply_method_return(m, "u", BUS_NAME_NOT_OWNER);
bus-proxyd: handle org.freedesktob.DBus calls natively
2014-04-21 23:16:26 +04:00
return synthetic_reply_method_errno(m, r, NULL);
}
return synthetic_reply_method_return(m, "u", BUS_NAME_RELEASED);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "ReloadConfig")) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_error_setf(&error, SD_BUS_ERROR_NOT_SUPPORTED, "%s() is not supported", sd_bus_message_get_member(m));
return synthetic_reply_method_errno(m, r, &error);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "RequestName")) {
const char *name;
uint32_t flags;
r = sd_bus_message_read(m, "su", &name, &flags);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (service_name_is_valid(name) < 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
if ((flags & ~(BUS_NAME_ALLOW_REPLACEMENT|BUS_NAME_REPLACE_EXISTING|BUS_NAME_DO_NOT_QUEUE)) != 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
r = sd_bus_request_name(a, name, flags);
if (r < 0) {
if (r == -EEXIST)
return synthetic_reply_method_return(m, "u", BUS_NAME_EXISTS);
if (r == -EALREADY)
return synthetic_reply_method_return(m, "u", BUS_NAME_ALREADY_OWNER);
return synthetic_reply_method_errno(m, r, NULL);
}
if (r == 0)
return synthetic_reply_method_return(m, "u", BUS_NAME_IN_QUEUE);
return synthetic_reply_method_return(m, "u", BUS_NAME_PRIMARY_OWNER);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "StartServiceByName")) {
_cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
const char *name;
uint32_t flags;
r = sd_bus_message_read(m, "su", &name, &flags);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (service_name_is_valid(name) < 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
if (flags != 0)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
r = sd_bus_get_owner(a, name, 0, NULL);
if (r >= 0 || streq(name, "org.freedesktop.DBus"))
return synthetic_reply_method_return(m, "u", BUS_START_REPLY_ALREADY_RUNNING);
if (r != -ESRCH)
return synthetic_reply_method_errno(m, r, NULL);
r = sd_bus_message_new_method_call(
a,
&msg,
name,
"/",
"org.freedesktop.DBus.Peer",
"Ping");
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
r = sd_bus_send(a, msg, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, "u", BUS_START_REPLY_SUCCESS);
} else if (sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "UpdateActivationEnvironment")) {
_cleanup_bus_message_unref_ sd_bus_message *msg = NULL;
_cleanup_strv_free_ char **args = NULL;
if (!peer_is_privileged(a, m))
return synthetic_reply_method_errno(m, -EPERM, NULL);
r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "{ss}");
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
while ((r = sd_bus_message_enter_container(m, SD_BUS_TYPE_DICT_ENTRY, "ss")) > 0) {
_cleanup_free_ char *s = NULL;
const char *key;
const char *value;
r = sd_bus_message_read(m, "ss", &key, &value);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
s = strjoin(key, "=", value, NULL);
if (!s)
return synthetic_reply_method_errno(m, -ENOMEM, NULL);
r = strv_extend(&args, s);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
r = sd_bus_message_exit_container(m);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
}
r = sd_bus_message_exit_container(m);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
if (!args)
return synthetic_reply_method_errno(m, -EINVAL, NULL);
r = sd_bus_message_new_method_call(
a,
&msg,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"SetEnvironment");
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
r = sd_bus_message_append_strv(msg, args);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
r = sd_bus_call(a, msg, 0, NULL, NULL);
if (r < 0)
return synthetic_reply_method_errno(m, r, NULL);
return synthetic_reply_method_return(m, NULL);
} else {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
r = sd_bus_error_setf(&error, SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method '%s'.", m->member);
return synthetic_reply_method_errno(m, r, &error);
}
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
static int process_hello(sd_bus *a, sd_bus *b, sd_bus_message *m, bool *got_hello) {
_cleanup_bus_message_unref_ sd_bus_message *n = NULL;
bool is_hello;
int r;
assert(a);
assert(b);
assert(m);
assert(got_hello);
/* As reaction to hello we need to respond with two messages:
* the callback reply and the NameAcquired for the unique
* name, since hello is otherwise obsolete on kdbus. */
is_hello =
sd_bus_message_is_method_call(m, "org.freedesktop.DBus", "Hello") &&
streq_ptr(m->destination, "org.freedesktop.DBus");
if (!is_hello) {
if (*got_hello)
return 0;
log_error("First packet isn't hello (it's %s.%s), aborting.", m->interface, m->member);
return -EIO;
}
if (*got_hello) {
log_error("Got duplicate hello, aborting.");
return -EIO;
}
*got_hello = true;
if (!a->is_kernel)
return 0;
r = sd_bus_message_new_method_return(m, &n);
if (r < 0) {
log_error("Failed to generate HELLO reply: %s", strerror(-r));
return r;
}
r = sd_bus_message_append(n, "s", a->unique_name);
if (r < 0) {
log_error("Failed to append unique name to HELLO reply: %s", strerror(-r));
return r;
}
r = bus_message_append_sender(n, "org.freedesktop.DBus");
if (r < 0) {
log_error("Failed to append sender to HELLO reply: %s", strerror(-r));
return r;
}
r = bus_seal_synthetic_message(b, n);
if (r < 0) {
log_error("Failed to seal HELLO reply: %s", strerror(-r));
return r;
}
r = sd_bus_send(b, n, NULL);
if (r < 0) {
log_error("Failed to send HELLO reply: %s", strerror(-r));
return r;
}
n = sd_bus_message_unref(n);
r = sd_bus_message_new_signal(
b,
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-20 02:54:58 +04:00
&n,
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
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-20 02:54:58 +04:00
"NameAcquired");
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (r < 0) {
log_error("Failed to allocate initial NameAcquired message: %s", strerror(-r));
return r;
}
r = sd_bus_message_append(n, "s", a->unique_name);
if (r < 0) {
log_error("Failed to append unique name to NameAcquired message: %s", strerror(-r));
return r;
}
r = bus_message_append_sender(n, "org.freedesktop.DBus");
if (r < 0) {
log_error("Failed to append sender to NameAcquired message: %s", strerror(-r));
return r;
}
r = bus_seal_synthetic_message(b, n);
if (r < 0) {
log_error("Failed to seal NameAcquired message: %s", strerror(-r));
return r;
}
r = sd_bus_send(b, n, NULL);
if (r < 0) {
log_error("Failed to send NameAcquired message: %s", strerror(-r));
return r;
}
return 1;
}
bus: when proxying messages from the bus driver patch the driver's well-known name into the sender
2014-01-30 00:23:41 +04:00
static int patch_sender(sd_bus *a, sd_bus_message *m) {
char **well_known = NULL;
sd_bus_creds *c;
int r;
assert(a);
assert(m);
if (!a->is_kernel)
return 0;
/* We will change the sender of messages from the bus driver
* so that they originate from the bus driver. This is a
* speciality originating from dbus1, where the bus driver did
* not have a unique id, but only the well-known name. */
c = sd_bus_message_get_creds(m);
if (!c)
return 0;
r = sd_bus_creds_get_well_known_names(c, &well_known);
if (r < 0)
return r;
if (strv_contains(well_known, "org.freedesktop.DBus"))
m->sender = "org.freedesktop.DBus";
return 0;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
int main(int argc, char *argv[]) {
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
_cleanup_bus_unref_ sd_bus *a = NULL, *b = NULL;
sd_id128_t server_id;
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
int r, in_fd, out_fd;
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
bool got_hello = false;
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
bool is_unix;
bus: fake client side creds in the proxy to the caller's creds
2013-12-24 18:03:32 +04:00
struct ucred ucred = {};
_cleanup_free_ char *peersec = NULL;
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
core: switch all log targets to go directly to the journal, instead via syslog
2012-01-12 08:09:06 +04:00
log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
log_parse_environment();
log_open();
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
r = parse_argv(argc, argv);
if (r <= 0)
goto finish;
r = sd_listen_fds(0);
if (r == 0) {
in_fd = STDIN_FILENO;
out_fd = STDOUT_FILENO;
} else if (r == 1) {
in_fd = SD_LISTEN_FDS_START;
out_fd = SD_LISTEN_FDS_START;
} else {
log: log_error() and friends add a newline after each line anyway, so avoid including it in the log strings
2013-12-24 19:39:37 +04:00
log_error("Illegal number of file descriptors passed");
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
goto finish;
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
is_unix =
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
sd_is_socket(in_fd, AF_UNIX, 0, 0) > 0 &&
sd_is_socket(out_fd, AF_UNIX, 0, 0) > 0;
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
bus: fake client side creds in the proxy to the caller's creds
2013-12-24 18:03:32 +04:00
if (is_unix) {
util: unify SO_PEERCRED/SO_PEERSEC invocations Introduce new call getpeercred() which internally just uses SO_PEERCRED but checks if the returned data is actually useful due to namespace quirks.
2013-12-24 18:53:04 +04:00
getpeercred(in_fd, &ucred);
bus: fake client side creds in the proxy to the caller's creds
2013-12-24 18:03:32 +04:00
getpeersec(in_fd, &peersec);
}
bus-proxy: drop priviliges if we can Either become uid/gid of the client we have been forked for, or become the "systemd-bus-proxy" user if the client was root. We retain CAP_IPC_OWNER so that we can tell kdbus we are actually our own client.
2014-06-04 11:55:40 +04:00
if (arg_drop_privileges) {
const char *user = "systemd-bus-proxy";
uid_t uid;
gid_t gid;
r = get_user_creds(&user, &uid, &gid, NULL, NULL);
if (r < 0) {
log_error("Cannot resolve user name %s: %s", user, strerror(-r));
goto finish;
}
r = drop_privileges(uid, gid, 1ULL << CAP_IPC_OWNER);
if (r < 0)
goto finish;
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_new(&a);
if (r < 0) {
log_error("Failed to allocate bus: %s", strerror(-r));
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
goto finish;
}
bus: set debug name of proxy bus connections
2014-01-22 22:08:22 +04:00
r = sd_bus_set_name(a, "sd-proxy");
if (r < 0) {
log_error("Failed to set bus name: %s", strerror(-r));
goto finish;
}
bus: change bus-proxyd command line parsing to be more similar to other tools
2013-12-21 06:59:07 +04:00
r = sd_bus_set_address(a, arg_address);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (r < 0) {
log_error("Failed to set address to connect to: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: add APIs for negotiating what is attached to messages
2013-05-17 06:25:56 +04:00
r = sd_bus_negotiate_fds(a, is_unix);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (r < 0) {
log_error("Failed to set FD negotiation: %s", strerror(-r));
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
goto finish;
}
bus: fake client side creds in the proxy to the caller's creds
2013-12-24 18:03:32 +04:00
if (ucred.pid > 0) {
a->fake_creds.pid = ucred.pid;
a->fake_creds.uid = ucred.uid;
a->fake_creds.gid = ucred.gid;
a->fake_creds_valid = true;
}
bus: fake security labels again (The kernel module got fixed, so let's reenable this again)
2014-01-29 00:38:14 +04:00
if (peersec) {
a->fake_label = peersec;
peersec = NULL;
}
bus: fake client side creds in the proxy to the caller's creds
2013-12-24 18:03:32 +04:00
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
a->manual_peer_interface = true;
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_start(a);
if (r < 0) {
log_error("Failed to start bus client: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_get_server_id(a, &server_id);
if (r < 0) {
log_error("Failed to get server ID: %s", strerror(-r));
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
goto finish;
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_new(&b);
if (r < 0) {
log_error("Failed to allocate bus: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
systemd-stdio-bridge: make it socket-activatable and usable as kdbus bridge Augment systemd-stdio-bridge a bit to make it a 1:1 bridge from legacy DBus clients to kdbus. In particular, * allow setting the bus path of the upstream bus as command line argument * use sd_listen_fds() for systemd's socket activation * omit calling sd_bus_negotiate_fds() when upstream bus is kdbus * reply to bus send errors with proper dbus error messages * treat -ECONNRESET as expected end-of-connection condition
2013-11-15 21:05:27 +04:00
r = sd_bus_set_fd(b, in_fd, out_fd);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (r < 0) {
log_error("Failed to set fds: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_set_server(b, 1, server_id);
if (r < 0) {
log_error("Failed to set server mode: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: add APIs for negotiating what is attached to messages
2013-05-17 06:25:56 +04:00
r = sd_bus_negotiate_fds(b, is_unix);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (r < 0) {
log_error("Failed to set FD negotiation: %s", strerror(-r));
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
goto finish;
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_set_anonymous(b, true);
if (r < 0) {
log_error("Failed to set anonymous authentication: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
b->manual_peer_interface = true;
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
r = sd_bus_start(b);
if (r < 0) {
log_error("Failed to start bus client: %s", strerror(-r));
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: don't process Peer interface messages in the proxy
2013-12-26 06:08:52 +04:00
r = rename_service(a, b);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (r < 0)
log_debug("Failed to rename process: %s", strerror(-r));
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (a->is_kernel) {
bus-proxyd: init cleanup variable
2013-12-23 22:16:49 +04:00
_cleanup_free_ char *match = NULL;
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
const char *unique;
r = sd_bus_get_unique_name(a, &unique);
if (r < 0) {
log_error("Failed to get unique name: %s", strerror(-r));
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
goto finish;
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
match = strjoin("type='signal',"
"sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus',"
"interface='org.freedesktop.DBus',"
"member='NameOwnerChanged',"
"arg1='",
unique,
"'",
NULL);
if (!match) {
log_oom();
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
goto finish;
}
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 03:15:30 +04:00
r = sd_bus_add_match(a, NULL, match, NULL, NULL);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (r < 0) {
log_error("Failed to add match for NameLost: %s", strerror(-r));
goto finish;
}
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
free(match);
match = strjoin("type='signal',"
"sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus',"
"interface='org.freedesktop.DBus',"
"member='NameOwnerChanged',"
"arg2='",
unique,
"'",
NULL);
if (!match) {
log_oom();
goto finish;
}
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04: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 03:15:30 +04:00
r = sd_bus_add_match(a, NULL, match, NULL, NULL);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (r < 0) {
log_error("Failed to add match for NameAcquired: %s", strerror(-r));
goto finish;
bus: send status message from proxyd to systemd about client we are working for
2013-12-21 07:19:51 +04:00
}
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
for (;;) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
int events_a, events_b, fd;
uint64_t timeout_a, timeout_b, t;
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
struct timespec _ts, *ts;
bus: poll() on the right fds in proxyd
2013-12-21 20:46:35 +04:00
struct pollfd *pollfd;
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
int k;
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (got_hello) {
r = sd_bus_process(a, &m);
if (r < 0) {
/* treat 'connection reset by peer' as clean exit condition */
if (r == -ECONNRESET)
r = 0;
else
log_error("Failed to process bus a: %s", strerror(-r));
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus: properly react to Disconnected messages in bus-proxyd
2013-12-21 07:03:12 +04:00
goto finish;
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (m) {
/* We officially got EOF, let's quit */
if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
r = 0;
goto finish;
}
k = synthesize_name_acquired(a, b, m);
if (k < 0) {
r = k;
log_error("Failed to synthesize message: %s", strerror(-r));
goto finish;
}
bus: when proxying messages from the bus driver patch the driver's well-known name into the sender
2014-01-30 00:23:41 +04:00
patch_sender(a, m);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
k = sd_bus_send(b, m, NULL);
if (k < 0) {
bus: properly handle EOF error conditions in proxyd EOF is not an error so we should not print an error message about it.
2014-01-12 06:56:40 +04:00
if (k == -ECONNRESET)
r = 0;
else {
r = k;
log_error("Failed to send message: %s", strerror(-r));
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
goto finish;
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (r > 0)
continue;
}
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
r = sd_bus_process(b, &m);
if (r < 0) {
/* treat 'connection reset by peer' as clean exit condition */
if (r == -ECONNRESET)
r = 0;
else
log_error("Failed to process bus b: %s", strerror(-r));
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
if (m) {
/* We officially got EOF, let's quit */
if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
r = 0;
bus-proxyd: use a loop instead of c&p
2013-12-21 20:23:08 +04:00
goto finish;
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
k = process_hello(a, b, m, &got_hello);
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
if (k < 0) {
r = k;
bus-proxyd: add some more debugging Make sure we print a message when exiting with an error.
2014-01-11 00:40:19 +04:00
log_error("Failed to process HELLO: %s", strerror(-r));
bus-proxyd: use a loop instead of c&p
2013-12-21 20:23:08 +04:00
goto finish;
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (k > 0)
r = k;
else {
bus: add a temporary hard-coded policy to proxyd to make gdm work gdm relies on the policy to deny its own requests to not deadlock. Given that we currently do not enforce any policy in the dbus1 compat proxy service this means that gdm will necessarily deadlock on our systems. To work around this, enforce a fixed policy teomporarily, until we interpret the legacy XML policy in full. Booh, gdm, booh, for requring this and making me waste two days on tracking this brokenness down.
2013-12-26 19:07:38 +04:00
k = process_policy(a, b, m);
if (k < 0) {
r = k;
bus-proxyd: add some more debugging Make sure we print a message when exiting with an error.
2014-01-11 00:40:19 +04:00
log_error("Failed to process policy: %s", strerror(-r));
bus: add a temporary hard-coded policy to proxyd to make gdm work gdm relies on the policy to deny its own requests to not deadlock. Given that we currently do not enforce any policy in the dbus1 compat proxy service this means that gdm will necessarily deadlock on our systems. To work around this, enforce a fixed policy teomporarily, until we interpret the legacy XML policy in full. Booh, gdm, booh, for requring this and making me waste two days on tracking this brokenness down.
2013-12-26 19:07:38 +04:00
goto finish;
}
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
k = process_driver(a, b, m);
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
if (k < 0) {
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
r = k;
log_error("Failed to process driver calls: %s", strerror(-r));
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
goto finish;
}
bus: process AddMatch/RemoveMatch driver call in proxy Previously, AddMatch/RemoveMatch calls where processed exclusively in the proxy. That's racy however, since subscribing to a signal might not complete before the signal is sent due to some subsequent method call. Hence, in order to expose the same ordering guarantees as dbus1 process the AddMatch/RemoveMatch calls from the proxy, so that they are dispatched synchronously to all following messages, thus fixing the race. Ultimately, we should probabably dissolve the driver entirely into the proxy, as it is purely a compatibility feature anyway...
2014-04-14 05:25:10 +04:00
if (k > 0)
r = k;
else {
k = sd_bus_send(a, m, NULL);
if (k < 0) {
if (r == -ECONNRESET)
r = 0;
else {
r = k;
log_error("Failed to send message: %s", strerror(-r));
}
goto finish;
}
}
bus-proxyd: synthesize NameAcquire/NameLost signals for socket clients
2013-12-23 05:59:03 +04:00
}
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
if (r > 0)
continue;
fd = sd_bus_get_fd(a);
if (fd < 0) {
log_error("Failed to get fd: %s", strerror(-r));
goto finish;
}
events_a = sd_bus_get_events(a);
if (events_a < 0) {
log_error("Failed to get events mask: %s", strerror(-r));
goto finish;
}
r = sd_bus_get_timeout(a, &timeout_a);
if (r < 0) {
log_error("Failed to get timeout: %s", strerror(-r));
goto finish;
}
events_b = sd_bus_get_events(b);
if (events_b < 0) {
log_error("Failed to get events mask: %s", strerror(-r));
goto finish;
}
r = sd_bus_get_timeout(b, &timeout_b);
if (r < 0) {
log_error("Failed to get timeout: %s", strerror(-r));
goto finish;
}
t = timeout_a;
if (t == (uint64_t) -1 || (timeout_b != (uint64_t) -1 && timeout_b < timeout_a))
t = timeout_b;
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (t == (uint64_t) -1)
ts = NULL;
else {
usec_t nw;
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
nw = now(CLOCK_MONOTONIC);
if (t > nw)
t -= nw;
else
t = 0;
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
ts = timespec_store(&_ts, t);
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
}
bus: poll() on the right fds in proxyd
2013-12-21 20:46:35 +04:00
pollfd = (struct pollfd[3]) {
Revert "bus-proxyd: use a loop instead of c&p" This reverts commit 9818fa6d6d32d87a3e1b96934a54523ea6b02879. The proxy does not work anymore with this patch.
2013-12-22 19:41:24 +04:00
{.fd = fd, .events = events_a, },
{.fd = in_fd, .events = events_b & POLLIN, },
{.fd = out_fd, .events = events_b & POLLOUT, }
bus: poll() on the right fds in proxyd
2013-12-21 20:46:35 +04:00
};
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
bus: poll() on the right fds in proxyd
2013-12-21 20:46:35 +04:00
r = ppoll(pollfd, 3, ts, NULL);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
if (r < 0) {
log_error("ppoll() failed: %m");
goto finish;
}
}
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
finish:
bus: properly react to Disconnected messages in bus-proxyd
2013-12-21 07:03:12 +04:00
sd_bus_flush(a);
sd_bus_flush(b);
stdio-bridge: rework stdio bridge to use libsystemd-bus
2013-04-01 05:28:42 +04:00
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
systemctl: support remote and privileged systemctl access via SSH and pkexec This adds support for executing systemctl operations remotely or as privileged user while still running systemctl itself unprivileged and locally. This currently requires a D-Bus patch to work properly. https://bugs.freedesktop.org/show_bug.cgi?id=35230
2011-03-12 03:03:13 +03:00
}
Copy Permalink