shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-15 07:24:00 +03:00
Code
380d7cc5b7
systemd/src/core/dbus-manager.c

1682 lines
74 KiB
C
Raw Normal View History

emacs: make sure nobody accidently adds tabs to our sources
2010-08-14 21:59:25 +04:00
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
license: add GPLv2+ license blurbs everwhere
2010-02-03 15:03:47 +03:00
/***
This file is part of systemd.
Copyright 2010 Lennart Poettering
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
license: add GPLv2+ license blurbs everwhere
2010-02-03 15:03:47 +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.
license: add GPLv2+ license blurbs everwhere
2010-02-03 15:03:47 +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
license: add GPLv2+ license blurbs everwhere
2010-02-03 15:03:47 +03:00
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
#include <errno.h>
taint: add missing cgroups taint flag
2011-03-30 04:12:46 +04:00
#include <unistd.h>
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
#include "dbus.h"
#include "log.h"
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
#include "dbus-manager.h"
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
#include "strv.h"
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
#include "bus-errors.h"
dbus: expose distribution name and features on manager object as properties
2011-03-04 20:34:56 +03:00
#include "build.h"
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
#include "dbus-common.h"
bus: expose installer functions
2011-07-23 05:44:47 +04:00
#include "install.h"
selinux: add bus service access control -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 This patch adds the ability to look at the calling process that is trying to do dbus calls into systemd, then it checks with the SELinux policy to see if the calling process is allowed to do the activity. The basic idea is we want to allow NetworkManager_t to be able to start and stop ntpd.service, but not necessarly mysqld.service. Similarly we want to allow a root admin webadm_t that can only manage the apache environment. systemctl enable httpd.service, systemctl disable iptables.service bad. To make this code cleaner, we really need to refactor the dbus-manager.c code. This has just become a huge if-then-else blob, which makes doing the correct check difficult. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://www.enigmail.net/ iEYEARECAAYFAlBJBi8ACgkQrlYvE4MpobOzTwCdEUikbvRWUCwOb83KlVF0Nuy5 lRAAnjZZNuc19Z+aNxm3k3nwD4p/JYco =yops -----END PGP SIGNATURE-----
2012-09-07 00:23:11 +04:00
#include "selinux-access.h"
watchdog: make watchdog dbus properties writable
2012-04-13 23:33:28 +04:00
#include "watchdog.h"
util: split-out hwclock.[ch]
2012-05-07 23:06:55 +04:00
#include "hwclock.h"
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
#include "path-util.h"
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
#include "dbus-unit.h"
dbus: expose Virtualization ID on PID1's bus interface This allows unprivileged clients to check for the used virtualization even when lacking the privileges that some of the virtualization tests require. https://bugzilla.gnome.org/show_bug.cgi?id=684801
2012-10-04 22:08:17 +04:00
#include "virt.h"
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
#define BUS_MANAGER_INTERFACE_BEGIN \
" <interface name=\"org.freedesktop.systemd1.Manager\">\n"
#define BUS_MANAGER_INTERFACE_METHODS \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"GetUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
" <method name=\"GetUnitByPID\">\n" \
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
" <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n" \
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"LoadUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
" <method name=\"StartUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
" <method name=\"StartUnitReplace\">\n" \
" <arg name=\"old_unit\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"new_unit\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
" <method name=\"StopUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"ReloadUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"RestartUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
install: implement --start option
2010-07-06 07:06:40 +04:00
" <method name=\"TryRestartUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
systemctl: introduce try-restart and reload-or-restart commands
2010-07-13 22:20:36 +04:00
" <method name=\"ReloadOrRestartUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"ReloadOrTryRestartUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
" <method name=\"KillUnit\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"signal\" type=\"i\" direction=\"in\"/>\n" \
" </method>\n" \
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
" <method name=\"ResetFailedUnit\">\n" \
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
" </method>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"GetJob\">\n" \
" <arg name=\"id\" type=\"u\" direction=\"in\"/>\n" \
" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"ClearJobs\"/>\n" \
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
" <method name=\"ResetFailed\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"ListUnits\">\n" \
device: do not merge devices Don't try to merge devices that have been created via dependencies when they appear in the system and can be recognized as the same. Instead, simply continue to maintain them independently of each other, however with the same state cycle. Why? Because otherwise we'd have a hard time to seperate the dependencies after the devices are unplugged again and we hence cannot be sure anymore that next time the device is plugged in it will carry the same names. Example: if one depndency refers to dev-sda.device and another one to dev-by-id-xxxyyy.device we only learn at time of plug in of the device that it is actually the same device that was ment. In the moment the device is unplugged again we won't know anymore their relation to each other and the next time the harddisk is plugged it might even appear as dev-by-id-xxxyyy.device and dev-sdb.service. To ensure the dependencies continue to have the meaning they were intended to have let's hence keep the .device objects seperate all the time, even when they are plugged in. This patch also introduces a new Following= property which points from the various .device units of a specific device to the main .device unit for it. This can be used by the client side to figure out the relation of the .device units to each other and even filter units from display.
2010-07-20 22:33:19 +04:00
" <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" </method>\n" \
" <method name=\"ListJobs\">\n" \
" <arg name=\"jobs\" type=\"a(usssoo)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"Subscribe\"/>\n" \
" <method name=\"Unsubscribe\"/>\n" \
remount-fs: also remount /usr according to fstab
2012-06-29 18:14:01 +04:00
" <method name=\"Dump\">\n" \
" <arg name=\"dump\" type=\"s\" direction=\"out\"/>\n" \
" </method>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"CreateSnapshot\">\n" \
" <arg name=\"name\" type=\"s\" direction=\"in\"/>\n" \
dbus: small typo in introspection data Hey, here is a patch to fix a small typo in the systemd dbus introspection data. I found this while trying to explore the systemd dbus API via bash completion with gdbus. You should try this, it is really fun, and, evidently, helps to find some bugs... Matthias
2010-08-19 00:27:58 +04:00
" <arg name=\"cleanup\" type=\"b\" direction=\"in\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <arg name=\"unit\" type=\"o\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"Reload\"/>\n" \
" <method name=\"Reexecute\"/>\n" \
" <method name=\"Exit\"/>\n" \
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
" <method name=\"Reboot\"/>\n" \
" <method name=\"PowerOff\"/>\n" \
" <method name=\"Halt\"/>\n" \
" <method name=\"KExec\"/>\n" \
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
" <method name=\"SwitchRoot\">\n" \
" <arg name=\"new_root\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"init\" type=\"s\" direction=\"in\"/>\n" \
" </method>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <method name=\"SetEnvironment\">\n" \
" <arg name=\"names\" type=\"as\" direction=\"in\"/>\n" \
" </method>\n" \
" <method name=\"UnsetEnvironment\">\n" \
" <arg name=\"names\" type=\"as\" direction=\"in\"/>\n" \
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
" </method>\n" \
" <method name=\"UnsetAndSetEnvironment\">\n" \
" <arg name=\"unset\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"set\" type=\"as\" direction=\"in\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" </method>\n" \
" <method name=\"ListUnitFiles\">\n" \
core: fix name of dbus call parameter
2012-07-16 21:11:27 +04:00
" <arg name=\"files\" type=\"a(ss)\" direction=\"out\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" </method>\n" \
" <method name=\"GetUnitFileState\">\n" \
" <arg name=\"file\" type=\"s\" direction=\"in\"/>\n" \
" <arg name=\"state\" type=\"s\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"EnableUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"force\" type=\"b\" direction=\"in\"/>\n" \
dbus: 'directrion' is not a valid attribute $ gdbus introspect --system --dest org.freedesktop.systemd1 --object-path /org/freedesktop/systemd1 Error parsing introspection XML: 115:64: attribute 'directrion' invalid for element 'arg'
2011-08-24 14:10:06 +04:00
" <arg name=\"carries_install_info\" type=\"b\" direction=\"out\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"DisableUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"ReenableUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"force\" type=\"b\" direction=\"in\"/>\n" \
dbus: 'directrion' is not a valid attribute $ gdbus introspect --system --dest org.freedesktop.systemd1 --object-path /org/freedesktop/systemd1 Error parsing introspection XML: 115:64: attribute 'directrion' invalid for element 'arg'
2011-08-24 14:10:06 +04:00
" <arg name=\"carries_install_info\" type=\"b\" direction=\"out\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"LinkUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"force\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"PresetUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"force\" type=\"b\" direction=\"in\"/>\n" \
dbus: 'directrion' is not a valid attribute $ gdbus introspect --system --dest org.freedesktop.systemd1 --object-path /org/freedesktop/systemd1 Error parsing introspection XML: 115:64: attribute 'directrion' invalid for element 'arg'
2011-08-24 14:10:06 +04:00
" <arg name=\"carries_install_info\" type=\"b\" direction=\"out\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"MaskUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"force\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
" </method>\n" \
" <method name=\"UnmaskUnitFiles\">\n" \
" <arg name=\"files\" type=\"as\" direction=\"in\"/>\n" \
" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
" <arg name=\"changes\" type=\"a(sss)\" direction=\"out\"/>\n" \
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
" </method>\n"
#define BUS_MANAGER_INTERFACE_SIGNALS \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <signal name=\"UnitNew\">\n" \
" <arg name=\"id\" type=\"s\"/>\n" \
" <arg name=\"unit\" type=\"o\"/>\n" \
" </signal>\n" \
" <signal name=\"UnitRemoved\">\n" \
" <arg name=\"id\" type=\"s\"/>\n" \
" <arg name=\"unit\" type=\"o\"/>\n" \
" </signal>\n" \
" <signal name=\"JobNew\">\n" \
" <arg name=\"id\" type=\"u\"/>\n" \
" <arg name=\"job\" type=\"o\"/>\n" \
dbus: include unit name in JobNew/JobRemoved signals This breaks D-Bus interface slightly, but since the D-Bus API isn't covered by the interface stability promise this should be OK.
2012-05-04 00:53:25 +04:00
" <arg name=\"unit\" type=\"s\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" </signal>\n" \
" <signal name=\"JobRemoved\">\n" \
" <arg name=\"id\" type=\"u\"/>\n" \
" <arg name=\"job\" type=\"o\"/>\n" \
dbus: include unit name in JobNew/JobRemoved signals This breaks D-Bus interface slightly, but since the D-Bus API isn't covered by the interface stability promise this should be OK.
2012-05-04 00:53:25 +04:00
" <arg name=\"unit\" type=\"s\"/>\n" \
dbus: pass along information why a job failed when it failed (dbus api change!)
2011-02-24 04:36:34 +03:00
" <arg name=\"result\" type=\"s\"/>\n" \
dbus: send our finished signal when we are finished booting
2011-06-27 15:47:03 +04:00
" </signal>" \
" <signal name=\"StartupFinished\">\n" \
manager: extend performance measurement interface to include firmware/loader times This only adds the fields to the D-Bus interfaces but doesn't fill them in with anything useful yet. Gummiboot exposes the necessary bits of information to use however and as soon as I get my fingers on a proper UEFI laptop I'll hook up the remaining bits. Since we want to stabilize the D-Bus interface soon and include it in the stability promise we should get the last fixes in, hence this change now.
2012-09-13 20:54:32 +04:00
" <arg name=\"firmware\" type=\"t\"/>\n" \
" <arg name=\"loader\" type=\"t\"/>\n" \
dbus: send our finished signal when we are finished booting
2011-06-27 15:47:03 +04:00
" <arg name=\"kernel\" type=\"t\"/>\n" \
" <arg name=\"initrd\" type=\"t\"/>\n" \
" <arg name=\"userspace\" type=\"t\"/>\n" \
" <arg name=\"total\" type=\"t\"/>\n" \
bus: expose installer functions
2011-07-23 05:44:47 +04:00
" </signal>" \
" <signal name=\"UnitFilesChanged\"/>\n"
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
#define BUS_MANAGER_INTERFACE_PROPERTIES_GENERAL \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <property name=\"Version\" type=\"s\" access=\"read\"/>\n" \
dbus: expose distribution name and features on manager object as properties
2011-03-04 20:34:56 +03:00
" <property name=\"Distribution\" type=\"s\" access=\"read\"/>\n" \
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
" <property name=\"Features\" type=\"s\" access=\"read\"/>\n" \
" <property name=\"Tainted\" type=\"s\" access=\"read\"/>\n" \
manager: extend performance measurement interface to include firmware/loader times This only adds the fields to the D-Bus interfaces but doesn't fill them in with anything useful yet. Gummiboot exposes the necessary bits of information to use however and as soon as I get my fingers on a proper UEFI laptop I'll hook up the remaining bits. Since we want to stabilize the D-Bus interface soon and include it in the stability promise we should get the last fixes in, hence this change now.
2012-09-13 20:54:32 +04:00
" <property name=\"FirmwareTimestamp\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"FirmwareTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"LoaderTimestamp\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"LoaderTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"KernelTimestamp\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"KernelTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
manager: parse RD_TIMESTAMP passed from initrd
2010-11-08 08:31:09 +03:00
" <property name=\"InitRDTimestamp\" type=\"t\" access=\"read\"/>\n" \
dbus: expose monotonic timestamps on the bus
2011-04-07 23:35:37 +04:00
" <property name=\"InitRDTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
manager: extend performance measurement interface to include firmware/loader times This only adds the fields to the D-Bus interfaces but doesn't fill them in with anything useful yet. Gummiboot exposes the necessary bits of information to use however and as soon as I get my fingers on a proper UEFI laptop I'll hook up the remaining bits. Since we want to stabilize the D-Bus interface soon and include it in the stability promise we should get the last fixes in, hence this change now.
2012-09-13 20:54:32 +04:00
" <property name=\"UserspaceTimestamp\" type=\"t\" access=\"read\"/>\n" \
" <property name=\"UserspaceTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
manager: parse RD_TIMESTAMP passed from initrd
2010-11-08 08:31:09 +03:00
" <property name=\"FinishTimestamp\" type=\"t\" access=\"read\"/>\n" \
dbus: expose monotonic timestamps on the bus
2011-04-07 23:35:37 +04:00
" <property name=\"FinishTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
add org.freedesktop.DBus.Properies.Set method The patch adds framework for processing Set requests on properties and as first consumers allows setting of LogTarget and LogLevel on interface org.freedesktop.systemd1.Manager of org.freedesktop.systemd1. The code should be generic enough to allow processing of any property on other objects and interfaces as well. No systemctl visible interface is added so far. The LogTarget and LogLevel are meant for debugging in the first place; user interface can be added if other usage emerge. Set on systemwide systemd is restricted to root; I am not sure how session level access is controlled.
2011-03-06 19:17:02 +03:00
" <property name=\"LogLevel\" type=\"s\" access=\"readwrite\"/>\n" \
" <property name=\"LogTarget\" type=\"s\" access=\"readwrite\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <property name=\"NNames\" type=\"u\" access=\"read\"/>\n" \
" <property name=\"NJobs\" type=\"u\" access=\"read\"/>\n" \
manager: count how many jobs we executed
2010-09-21 05:51:31 +04:00
" <property name=\"NInstalledJobs\" type=\"u\" access=\"read\"/>\n" \
dbus: export number of total failed jobs on D-Bus interface
2010-09-23 17:38:42 +04:00
" <property name=\"NFailedJobs\" type=\"u\" access=\"read\"/>\n" \
dbus: add Progress property to introspection
2010-09-21 18:55:35 +04:00
" <property name=\"Progress\" type=\"d\" access=\"read\"/>\n" \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" <property name=\"Environment\" type=\"as\" access=\"read\"/>\n" \
dbus: complete coverage of manager interface
2010-07-04 06:47:19 +04:00
" <property name=\"ConfirmSpawn\" type=\"b\" access=\"read\"/>\n" \
manager: optionally print status updates to console on boot
2010-07-07 02:00:59 +04:00
" <property name=\"ShowStatus\" type=\"b\" access=\"read\"/>\n" \
dbus: complete coverage of manager interface
2010-07-04 06:47:19 +04:00
" <property name=\"UnitPath\" type=\"as\" access=\"read\"/>\n" \
cgroup: kill processes, not tasks and other cgroup changes
2010-07-11 02:50:49 +04:00
" <property name=\"ControlGroupHierarchy\" type=\"s\" access=\"read\"/>\n" \
exec: introduce global defaults for the standard output of services
2011-02-15 13:52:29 +03:00
" <property name=\"DefaultControllers\" type=\"as\" access=\"read\"/>\n" \
" <property name=\"DefaultStandardOutput\" type=\"s\" access=\"read\"/>\n" \
systemd: add hardware watchdog support This adds minimal hardware watchdog support to PID 1. The idea is that PID 1 supervises and watchdogs system services, while the hardware watchdog is used to supervise PID 1. This adds two hardware watchdog configuration options, for the runtime watchdog and for a shutdown watchdog. The former is active during normal operation, the latter only at reboots to ensure that if a clean reboot times out we reboot nonetheless. If the runtime watchdog is enabled PID 1 will automatically wake up at half the configured interval and write to the watchdog daemon. By default we enable the shutdown watchdog, but leave the runtime watchdog disabled in order not to break independent hardware watchdog daemons people might be using. This is only the most basic hookup. If necessary we can later on hook up the watchdog ping more closely with services deemed crucial.
2012-04-06 00:08:10 +04:00
" <property name=\"DefaultStandardError\" type=\"s\" access=\"read\"/>\n" \
watchdog: make watchdog dbus properties writable
2012-04-13 23:33:28 +04:00
" <property name=\"RuntimeWatchdogUSec\" type=\"s\" access=\"readwrite\"/>\n" \
dbus: expose Virtualization ID on PID1's bus interface This allows unprivileged clients to check for the used virtualization even when lacking the privileges that some of the virtualization tests require. https://bugzilla.gnome.org/show_bug.cgi?id=684801
2012-10-04 22:08:17 +04:00
" <property name=\"ShutdownWatchdogUSec\" type=\"s\" access=\"readwrite\"/>\n" \
" <property name=\"Virtualization\" type=\"s\" access=\"read\"/>\n"
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
#define BUS_MANAGER_INTERFACE_END \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
" </interface>\n"
sysv: optionally disable of SysV init/rcN.d support at compile time This patch adds a cpp definition HAVE_SYSV_COMPAT that is used to isolate code dealing with /etc/init.d and /etc/rcN.d for systems where it does not make sense (one that does not use sysv or one that is fully systemd native). The patch tries to be as little intrusive as possible, however in order to minimize the number of #ifdef'ed regions I've reordered some code in path-lookup.c:lookup_paths_init() where all code dealing with sysv is now isolated under running_as == MANAGER_SYSTEM as well. Moreover, In struct Service, some fields were rearranged to reduce the number of ifdefs. Lennart's suggestions were fixed and squashed with the original patch, that was sent by Gustavo Sverzut Barbieri (barbieri@profusion.mobi).
2010-09-21 07:23:12 +04:00
#define BUS_MANAGER_INTERFACE \
BUS_MANAGER_INTERFACE_BEGIN \
BUS_MANAGER_INTERFACE_METHODS \
BUS_MANAGER_INTERFACE_SIGNALS \
BUS_MANAGER_INTERFACE_PROPERTIES_GENERAL \
BUS_MANAGER_INTERFACE_END
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
#define INTROSPECTION_BEGIN \
DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
"<node>\n" \
BUS_MANAGER_INTERFACE \
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
BUS_PROPERTIES_INTERFACE \
dbus: follow standardized fdo PropertiesChanged signal spec
2010-08-20 04:26:05 +04:00
BUS_PEER_INTERFACE \
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
BUS_INTROSPECTABLE_INTERFACE
#define INTROSPECTION_END \
dbus: automatically generate and install introspection files
2010-05-23 05:45:33 +04:00
"</node>\n"
dbus: properly generate UnknownInterface, UnknownProperty and PropertyReadOnly errors
2011-03-09 22:01:53 +03:00
#define INTERFACES_LIST \
BUS_GENERIC_INTERFACES_LIST \
"org.freedesktop.systemd1.Manager\0"
build-sys: allow cross-compilation When cross-compiling systemd, the introspection XML files fail to be generated because the systemd host binary is not executable. This patch works around this by putting the introspection XML data into separate ELF sections and extracting them from the binary when generating the XML files. The extracted XML data is passed through the strings utility in order to strip the trailing NUL character. A small AWK script is used to prepend the doctype and add the opening and closing node tags respectively. Finally, the C preprocessor is used to substitute the correct doctype information from the D-Bus header files.
2010-11-23 23:12:11 +03:00
const char bus_manager_interface[] _introspect_("Manager") = BUS_MANAGER_INTERFACE;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
exec: introduce global defaults for the standard output of services
2011-02-15 13:52:29 +03:00
static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_exec_output, exec_output, ExecOutput);
dbus: add a couple of properties to the dbus manager interface
2010-04-10 19:40:18 +04:00
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_tainted(DBusMessageIter *i, const char *property, void *data) {
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
const char *t;
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
Manager *m = data;
don't make up buffer sizes, use standard LINE_MAX instead
2011-04-07 20:48:50 +04:00
char buf[LINE_MAX] = "", *e = buf, *p = NULL;
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
assert(i);
assert(property);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
assert(m);
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
manager: fix taint check for /usr
2011-03-30 02:47:50 +04:00
if (m->taint_usr)
hwclock: add taint flag for non-local hwclock
2012-05-03 17:46:04 +04:00
e = stpcpy(e, "split-usr:");
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
taint: add missing cgroups taint flag
2011-03-30 04:12:46 +04:00
if (readlink_malloc("/etc/mtab", &p) < 0)
hwclock: add taint flag for non-local hwclock
2012-05-03 17:46:04 +04:00
e = stpcpy(e, "mtab-not-symlink:");
taint: add missing cgroups taint flag
2011-03-30 04:12:46 +04:00
else
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
free(p);
taint: add missing cgroups taint flag
2011-03-30 04:12:46 +04:00
if (access("/proc/cgroups", F_OK) < 0)
dbus-manager: fix tainted string The pointer to the end of the string was not advanced after adding the "cgroups-missing" taint. If "local-hwclock" was detected too, it would overwrite the previous string. With 'e' always pointing to the end of the string, removing the last delimiter is easier.
2012-05-09 23:42:56 +04:00
e = stpcpy(e, "cgroups-missing:");
taint: add missing cgroups taint flag
2011-03-30 04:12:46 +04:00
hwclock: add taint flag for non-local hwclock
2012-05-03 17:46:04 +04:00
if (hwclock_is_localtime() > 0)
dbus-manager: fix tainted string The pointer to the end of the string was not advanced after adding the "cgroups-missing" taint. If "local-hwclock" was detected too, it would overwrite the previous string. With 'e' always pointing to the end of the string, removing the last delimiter is easier.
2012-05-09 23:42:56 +04:00
e = stpcpy(e, "local-hwclock:");
hwclock: add taint flag for non-local hwclock
2012-05-03 17:46:04 +04:00
dbus-manager: fix tainted string The pointer to the end of the string was not advanced after adding the "cgroups-missing" taint. If "local-hwclock" was detected too, it would overwrite the previous string. With 'e' always pointing to the end of the string, removing the last delimiter is easier.
2012-05-09 23:42:56 +04:00
/* remove the last ':' */
if (e != buf)
e[-1] = 0;
hwclock: add taint flag for non-local hwclock
2012-05-03 17:46:04 +04:00
t = buf;
dbus: add 'Tainted' property to Manager object
2011-03-04 21:47:43 +03:00
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
return -ENOMEM;
return 0;
}
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_log_target(DBusMessageIter *i, const char *property, void *data) {
dbus: add a couple of properties to the dbus manager interface
2010-04-10 19:40:18 +04:00
const char *t;
assert(i);
assert(property);
t = log_target_to_string(log_get_target());
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
return -ENOMEM;
return 0;
}
dbus: add data argument to BusPropertySetCallback BusPropertyCallback already has the argument. It is necesary for the callback to know what data to access.
2012-04-06 23:38:00 +04:00
static int bus_manager_set_log_target(DBusMessageIter *i, const char *property, void *data) {
add org.freedesktop.DBus.Properies.Set method The patch adds framework for processing Set requests on properties and as first consumers allows setting of LogTarget and LogLevel on interface org.freedesktop.systemd1.Manager of org.freedesktop.systemd1. The code should be generic enough to allow processing of any property on other objects and interfaces as well. No systemctl visible interface is added so far. The LogTarget and LogLevel are meant for debugging in the first place; user interface can be added if other usage emerge. Set on systemwide systemd is restricted to root; I am not sure how session level access is controlled.
2011-03-06 19:17:02 +03:00
const char *t;
assert(i);
assert(property);
dbus_message_iter_get_basic(i, &t);
return log_set_target_from_string(t);
}
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_log_level(DBusMessageIter *i, const char *property, void *data) {
dbus: add a couple of properties to the dbus manager interface
2010-04-10 19:40:18 +04:00
const char *t;
assert(i);
assert(property);
t = log_level_to_string(log_get_max_level());
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &t))
return -ENOMEM;
return 0;
}
dbus: add data argument to BusPropertySetCallback BusPropertyCallback already has the argument. It is necesary for the callback to know what data to access.
2012-04-06 23:38:00 +04:00
static int bus_manager_set_log_level(DBusMessageIter *i, const char *property, void *data) {
add org.freedesktop.DBus.Properies.Set method The patch adds framework for processing Set requests on properties and as first consumers allows setting of LogTarget and LogLevel on interface org.freedesktop.systemd1.Manager of org.freedesktop.systemd1. The code should be generic enough to allow processing of any property on other objects and interfaces as well. No systemctl visible interface is added so far. The LogTarget and LogLevel are meant for debugging in the first place; user interface can be added if other usage emerge. Set on systemwide systemd is restricted to root; I am not sure how session level access is controlled.
2011-03-06 19:17:02 +03:00
const char *t;
assert(i);
assert(property);
dbus_message_iter_get_basic(i, &t);
return log_set_max_level_from_string(t);
}
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_n_names(DBusMessageIter *i, const char *property, void *data) {
Manager *m = data;
manager: enforce limit on accepted number of names
2010-04-22 04:56:42 +04:00
uint32_t u;
assert(i);
assert(property);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
assert(m);
manager: enforce limit on accepted number of names
2010-04-22 04:56:42 +04:00
u = hashmap_size(m->units);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT32, &u))
return -ENOMEM;
return 0;
}
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_n_jobs(DBusMessageIter *i, const char *property, void *data) {
Manager *m = data;
manager: enforce limit on accepted number of names
2010-04-22 04:56:42 +04:00
uint32_t u;
assert(i);
assert(property);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
assert(m);
manager: enforce limit on accepted number of names
2010-04-22 04:56:42 +04:00
u = hashmap_size(m->jobs);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT32, &u))
return -ENOMEM;
return 0;
}
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
static int bus_manager_append_progress(DBusMessageIter *i, const char *property, void *data) {
manager: calculate progress value while booting
2010-09-21 06:25:48 +04:00
double d;
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
Manager *m = data;
manager: calculate progress value while booting
2010-09-21 06:25:48 +04:00
assert(i);
assert(property);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
assert(m);
manager: calculate progress value while booting
2010-09-21 06:25:48 +04:00
if (dual_timestamp_is_set(&m->finish_timestamp))
d = 1.0;
else
d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_DOUBLE, &d))
return -ENOMEM;
return 0;
}
dbus: expose Virtualization ID on PID1's bus interface This allows unprivileged clients to check for the used virtualization even when lacking the privileges that some of the virtualization tests require. https://bugzilla.gnome.org/show_bug.cgi?id=684801
2012-10-04 22:08:17 +04:00
static int bus_manager_append_virt(DBusMessageIter *i, const char *property, void *data) {
Manager *m = data;
const char *id = "";
assert(i);
assert(property);
assert(m);
detect_virtualization(&id);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &id))
return -ENOMEM;
return 0;
}
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
static DBusMessage *message_from_file_changes(
DBusMessage *m,
UnitFileChange *changes,
unsigned n_changes,
int carries_install_info) {
bus: expose installer functions
2011-07-23 05:44:47 +04:00
DBusMessageIter iter, sub, sub2;
DBusMessage *reply;
unsigned i;
reply = dbus_message_new_method_return(m);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
if (carries_install_info >= 0) {
dbus_bool_t b;
convert int to boolean for dbus_bool_t
2011-08-17 21:38:07 +04:00
b = !!carries_install_info;
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b))
goto oom;
}
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sss)", &sub))
goto oom;
for (i = 0; i < n_changes; i++) {
const char *type, *path, *source;
type = unit_file_change_type_to_string(changes[i].type);
path = strempty(changes[i].path);
source = strempty(changes[i].source);
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &type) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &source) ||
bus: expose installer functions
2011-07-23 05:44:47 +04:00
!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
return reply;
oom:
dbus_message_unref(reply);
return NULL;
}
static int bus_manager_send_unit_files_changed(Manager *m) {
DBusMessage *s;
int r;
s = dbus_message_new_signal("/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
if (!s)
return -ENOMEM;
r = bus_broadcast(m, s);
dbus_message_unref(s);
return r;
}
watchdog: make watchdog dbus properties writable
2012-04-13 23:33:28 +04:00
static int bus_manager_set_runtime_watchdog_usec(DBusMessageIter *i, const char *property, void *data) {
uint64_t *t = data;
assert(i);
assert(property);
dbus_message_iter_get_basic(i, t);
return watchdog_set_timeout(t);
}
systemd: add hardware watchdog support This adds minimal hardware watchdog support to PID 1. The idea is that PID 1 supervises and watchdogs system services, while the hardware watchdog is used to supervise PID 1. This adds two hardware watchdog configuration options, for the runtime watchdog and for a shutdown watchdog. The former is active during normal operation, the latter only at reboots to ensure that if a clean reboot times out we reboot nonetheless. If the runtime watchdog is enabled PID 1 will automatically wake up at half the configured interval and write to the watchdog daemon. By default we enable the shutdown watchdog, but leave the runtime watchdog disabled in order not to break independent hardware watchdog daemons people might be using. This is only the most basic hookup. If necessary we can later on hook up the watchdog ping more closely with services deemed crucial.
2012-04-06 00:08:10 +04:00
static const char systemd_property_string[] =
PACKAGE_STRING "\0"
DISTRIBUTION "\0"
SYSTEMD_FEATURES;
dbus: more efficient implementation of properties The way the various properties[] arrays are initialized is inefficient: - only the .data members change at runtime, yet the whole arrays of properties with all the fields are constructed on the stack one by one by the code. - there's duplication, eg. the properties of "org.freedesktop.systemd1.Unit" are repeated in several unit types. Fix it by moving the information about properties into static const sections. Instead of storing the .data directly in the property, store a constant offset from a run-time base. The small arrays of struct BusBoundProperties bind together the constant information with the right runtime information (the base pointer). On my system the code shrinks by 60 KB, data increases by 10 KB.
2012-01-16 03:23:59 +04:00
static const BusProperty bus_systemd_properties[] = {
{ "Version", bus_property_append_string, "s", 0 },
{ "Distribution", bus_property_append_string, "s", sizeof(PACKAGE_STRING) },
{ "Features", bus_property_append_string, "s", sizeof(PACKAGE_STRING) + sizeof(DISTRIBUTION) },
{ NULL, }
};
static const BusProperty bus_manager_properties[] = {
dbus: expose Virtualization ID on PID1's bus interface This allows unprivileged clients to check for the used virtualization even when lacking the privileges that some of the virtualization tests require. https://bugzilla.gnome.org/show_bug.cgi?id=684801
2012-10-04 22:08:17 +04:00
{ "Tainted", bus_manager_append_tainted, "s", 0 },
{ "FirmwareTimestamp", bus_property_append_uint64, "t", offsetof(Manager, firmware_timestamp.realtime) },
{ "FirmwareTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, firmware_timestamp.monotonic) },
{ "LoaderTimestamp", bus_property_append_uint64, "t", offsetof(Manager, loader_timestamp.realtime) },
{ "LoaderTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, loader_timestamp.monotonic) },
{ "KernelTimestamp", bus_property_append_uint64, "t", offsetof(Manager, kernel_timestamp.realtime) },
{ "KernelTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, kernel_timestamp.monotonic) },
{ "InitRDTimestamp", bus_property_append_uint64, "t", offsetof(Manager, initrd_timestamp.realtime) },
{ "InitRDTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, initrd_timestamp.monotonic) },
{ "UserspaceTimestamp", bus_property_append_uint64, "t", offsetof(Manager, userspace_timestamp.realtime) },
{ "UserspaceTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, userspace_timestamp.monotonic) },
{ "FinishTimestamp", bus_property_append_uint64, "t", offsetof(Manager, finish_timestamp.realtime) },
{ "FinishTimestampMonotonic", bus_property_append_uint64, "t", offsetof(Manager, finish_timestamp.monotonic) },
{ "LogLevel", bus_manager_append_log_level, "s", 0, false, bus_manager_set_log_level },
{ "LogTarget", bus_manager_append_log_target, "s", 0, false, bus_manager_set_log_target },
{ "NNames", bus_manager_append_n_names, "u", 0 },
{ "NJobs", bus_manager_append_n_jobs, "u", 0 },
{ "NInstalledJobs", bus_property_append_uint32, "u", offsetof(Manager, n_installed_jobs) },
{ "NFailedJobs", bus_property_append_uint32, "u", offsetof(Manager, n_failed_jobs) },
{ "Progress", bus_manager_append_progress, "d", 0 },
{ "Environment", bus_property_append_strv, "as", offsetof(Manager, environment), true },
{ "ConfirmSpawn", bus_property_append_bool, "b", offsetof(Manager, confirm_spawn) },
{ "ShowStatus", bus_property_append_bool, "b", offsetof(Manager, show_status) },
{ "UnitPath", bus_property_append_strv, "as", offsetof(Manager, lookup_paths.unit_path), true },
{ "ControlGroupHierarchy", bus_property_append_string, "s", offsetof(Manager, cgroup_hierarchy), true },
{ "DefaultControllers", bus_property_append_strv, "as", offsetof(Manager, default_controllers), true },
{ "DefaultStandardOutput", bus_manager_append_exec_output, "s", offsetof(Manager, default_std_output) },
{ "DefaultStandardError", bus_manager_append_exec_output, "s", offsetof(Manager, default_std_error) },
{ "RuntimeWatchdogUSec", bus_property_append_usec, "t", offsetof(Manager, runtime_watchdog), false, bus_manager_set_runtime_watchdog_usec },
{ "ShutdownWatchdogUSec", bus_property_append_usec, "t", offsetof(Manager, shutdown_watchdog), false, bus_property_set_usec },
{ "Virtualization", bus_manager_append_virt, "s", 0, },
dbus: more efficient implementation of properties The way the various properties[] arrays are initialized is inefficient: - only the .data members change at runtime, yet the whole arrays of properties with all the fields are constructed on the stack one by one by the code. - there's duplication, eg. the properties of "org.freedesktop.systemd1.Unit" are repeated in several unit types. Fix it by moving the information about properties into static const sections. Instead of storing the .data directly in the property, store a constant offset from a run-time base. The small arrays of struct BusBoundProperties bind together the constant information with the right runtime information (the base pointer). On my system the code shrinks by 60 KB, data increases by 10 KB.
2012-01-16 03:23:59 +04:00
{ NULL, }
};
static DBusHandlerResult bus_manager_message_handler(DBusConnection *connection, DBusMessage *message, void *data) {
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
_cleanup_free_ char * path = NULL;
dbus: more efficient implementation of properties The way the various properties[] arrays are initialized is inefficient: - only the .data members change at runtime, yet the whole arrays of properties with all the fields are constructed on the stack one by one by the code. - there's duplication, eg. the properties of "org.freedesktop.systemd1.Unit" are repeated in several unit types. Fix it by moving the information about properties into static const sections. Instead of storing the .data directly in the property, store a constant offset from a run-time base. The small arrays of struct BusBoundProperties bind together the constant information with the right runtime information (the base pointer). On my system the code shrinks by 60 KB, data increases by 10 KB.
2012-01-16 03:23:59 +04:00
Manager *m = data;
dbus: add a couple of properties to the dbus manager interface
2010-04-10 19:40:18 +04:00
int r;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
DBusError error;
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
JobType job_type = _JOB_TYPE_INVALID;
systemctl: introduce try-restart and reload-or-restart commands
2010-07-13 22:20:36 +04:00
bool reload_if_possible = false;
bus: expose installer functions
2011-07-23 05:44:47 +04:00
const char *member;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
assert(connection);
assert(message);
assert(m);
dbus_error_init(&error);
bus: expose installer functions
2011-07-23 05:44:47 +04:00
member = dbus_message_get_member(message);
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "GetUnit")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
const char *name;
Unit *u;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
u = manager_get_unit(m, name);
if (!u) {
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
}
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(u, connection, message, "status");
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
path = unit_dbus_path(u);
if (!path)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "GetUnitByPID")) {
Unit *u;
uint32_t pid;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_UINT32, &pid,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
u = cgroup_unit_by_pid(m, (pid_t) pid);
if (!u) {
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_UNIT, "No unit for PID %lu is loaded.", (unsigned long) pid);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(u, connection, message, "status");
reply = dbus_message_new_method_return(message);
if (!reply)
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
path = unit_dbus_path(u);
if (!reply)
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
goto oom;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
systemctl: when calling 'status' accept a PID
2010-08-13 04:07:22 +04:00
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "LoadUnit")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
const char *name;
Unit *u;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = manager_load_unit(m, name, NULL, &error, &u);
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, r);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(u, connection, message, "status");
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
path = unit_dbus_path(u);
if (!path)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "StartUnit"))
job_type = JOB_START;
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "StartUnitReplace"))
job_type = JOB_START;
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "StopUnit"))
job_type = JOB_STOP;
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ReloadUnit"))
job_type = JOB_RELOAD;
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "RestartUnit"))
job_type = JOB_RESTART;
install: implement --start option
2010-07-06 07:06:40 +04:00
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "TryRestartUnit"))
job_type = JOB_TRY_RESTART;
systemctl: introduce try-restart and reload-or-restart commands
2010-07-13 22:20:36 +04:00
else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ReloadOrRestartUnit")) {
reload_if_possible = true;
job_type = JOB_RESTART;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ReloadOrTryRestartUnit")) {
reload_if_possible = true;
job_type = JOB_TRY_RESTART;
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "KillUnit")) {
core: drop KillMode parameter from KillUnit() bus call It made no sense, and since we are documenting the bus calls now and want to include them in our stability promise we really should get it cleaned up sooner, not later.
2012-07-20 02:00:04 +04:00
const char *name, *swho;
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
int32_t signo;
Unit *u;
KillWho who;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &swho,
DBUS_TYPE_INT32, &signo,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
unit: accept empty defaults for kill who/mode args
2011-07-13 21:56:40 +04:00
if (isempty(swho))
who = KILL_ALL;
else {
who = kill_who_from_string(swho);
if (who < 0)
return bus_send_error_reply(connection, message, &error, -EINVAL);
}
if (signo <= 0 || signo >= _NSIG)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
core: drop KillMode parameter from KillUnit() bus call It made no sense, and since we are documenting the bus calls now and want to include them in our stability promise we really should get it cleaned up sooner, not later.
2012-07-20 02:00:04 +04:00
u = manager_get_unit(m, name);
if (!u) {
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(u, connection, message, "stop");
core: drop KillMode parameter from KillUnit() bus call It made no sense, and since we are documenting the bus calls now and want to include them in our stability promise we really should get it cleaned up sooner, not later.
2012-07-20 02:00:04 +04:00
r = unit_kill(u, who, signo, &error);
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, r);
systemctl: introduce systemctl kill
2010-10-22 18:11:50 +04:00
if (!(reply = dbus_message_new_method_return(message)))
goto oom;
systemctl: introduce try-restart and reload-or-restart commands
2010-07-13 22:20:36 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "GetJob")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
uint32_t id;
Job *j;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_UINT32, &id,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
j = manager_get_job(m, id);
if (!j) {
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
}
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(j->unit, connection, message, "status");
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
path = job_dbus_path(j);
if (!path)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ClearJobs")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
manager_clear_jobs(m);
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ResetFailed")) {
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reload");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
manager_reset_failed(m);
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
goto oom;
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ResetFailedUnit")) {
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
const char *name;
Unit *u;
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
u = manager_get_unit(m, name);
if (!u) {
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
SELINUX_UNIT_ACCESS_CHECK(u, connection, message, "reload");
manager: add missing second part of s/maintenance/failed/
2010-08-31 02:23:34 +04:00
unit_reset_failed(u);
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
systemctl: introduce reset-maintenance command
2010-07-18 06:58:01 +04:00
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ListUnits")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
DBusMessageIter iter, sub;
Iterator i;
Unit *u;
const char *k;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
dbus_message_iter_init_append(reply, &iter);
device: do not merge devices Don't try to merge devices that have been created via dependencies when they appear in the system and can be recognized as the same. Instead, simply continue to maintain them independently of each other, however with the same state cycle. Why? Because otherwise we'd have a hard time to seperate the dependencies after the devices are unplugged again and we hence cannot be sure anymore that next time the device is plugged in it will carry the same names. Example: if one depndency refers to dev-sda.device and another one to dev-by-id-xxxyyy.device we only learn at time of plug in of the device that it is actually the same device that was ment. In the moment the device is unplugged again we won't know anymore their relation to each other and the next time the harddisk is plugged it might even appear as dev-by-id-xxxyyy.device and dev-sdb.service. To ensure the dependencies continue to have the meaning they were intended to have let's hence keep the .device objects seperate all the time, even when they are plugged in. This patch also introduces a new Following= property which points from the various .device units of a specific device to the main .device unit for it. This can be used by the client side to figure out the relation of the .device units to each other and even filter units from display.
2010-07-20 22:33:19 +04:00
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssssouso)", &sub))
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
build: basic autoconfization
2010-02-03 16:21:48 +03:00
char *u_path, *j_path;
device: do not merge devices Don't try to merge devices that have been created via dependencies when they appear in the system and can be recognized as the same. Instead, simply continue to maintain them independently of each other, however with the same state cycle. Why? Because otherwise we'd have a hard time to seperate the dependencies after the devices are unplugged again and we hence cannot be sure anymore that next time the device is plugged in it will carry the same names. Example: if one depndency refers to dev-sda.device and another one to dev-by-id-xxxyyy.device we only learn at time of plug in of the device that it is actually the same device that was ment. In the moment the device is unplugged again we won't know anymore their relation to each other and the next time the harddisk is plugged it might even appear as dev-by-id-xxxyyy.device and dev-sdb.service. To ensure the dependencies continue to have the meaning they were intended to have let's hence keep the .device objects seperate all the time, even when they are plugged in. This patch also introduces a new Following= property which points from the various .device units of a specific device to the main .device unit for it. This can be used by the client side to figure out the relation of the .device units to each other and even filter units from display.
2010-07-20 22:33:19 +04:00
const char *description, *load_state, *active_state, *sub_state, *sjob_type, *following;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
DBusMessageIter sub2;
uint32_t job_id;
unit: deduce following unit value dynamically instead of statically, to avoid dangling pointers
2010-07-21 07:00:29 +04:00
Unit *f;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (k != u->id)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
continue;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
goto oom;
description = unit_description(u);
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
load_state = unit_load_state_to_string(u->load_state);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
active_state = unit_active_state_to_string(unit_active_state(u));
systemctl: show sub state along active state
2010-04-13 22:59:01 +04:00
sub_state = unit_sub_state_to_string(u);
unit: deduce following unit value dynamically instead of statically, to avoid dangling pointers
2010-07-21 07:00:29 +04:00
f = unit_following(u);
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
following = f ? f->id : "";
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
u_path = unit_dbus_path(u);
if (!u_path)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (u->job) {
job_id = (uint32_t) u->job->id;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (!(j_path = job_dbus_path(u->job))) {
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(u_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
}
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
sjob_type = job_type_to_string(u->job->type);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
} else {
job_id = 0;
build: basic autoconfization
2010-02-03 16:21:48 +03:00
j_path = u_path;
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
sjob_type = "";
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
}
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &u->id) ||
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &description) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &load_state) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &active_state) ||
systemctl: show sub state along active state
2010-04-13 22:59:01 +04:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &sub_state) ||
device: do not merge devices Don't try to merge devices that have been created via dependencies when they appear in the system and can be recognized as the same. Instead, simply continue to maintain them independently of each other, however with the same state cycle. Why? Because otherwise we'd have a hard time to seperate the dependencies after the devices are unplugged again and we hence cannot be sure anymore that next time the device is plugged in it will carry the same names. Example: if one depndency refers to dev-sda.device and another one to dev-by-id-xxxyyy.device we only learn at time of plug in of the device that it is actually the same device that was ment. In the moment the device is unplugged again we won't know anymore their relation to each other and the next time the harddisk is plugged it might even appear as dev-by-id-xxxyyy.device and dev-sdb.service. To ensure the dependencies continue to have the meaning they were intended to have let's hence keep the .device objects seperate all the time, even when they are plugged in. This patch also introduces a new Following= property which points from the various .device units of a specific device to the main .device unit for it. This can be used by the client side to figure out the relation of the .device units to each other and even filter units from display.
2010-07-20 22:33:19 +04:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &following) ||
build: basic autoconfization
2010-02-03 16:21:48 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &u_path) ||
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &job_id) ||
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &sjob_type) ||
build: basic autoconfization
2010-02-03 16:21:48 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &j_path)) {
free(u_path);
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (u->job)
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(j_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
}
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(u_path);
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (u->job)
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(j_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ListJobs")) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
DBusMessageIter iter, sub;
Iterator i;
Job *j;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(usssoo)", &sub))
goto oom;
HASHMAP_FOREACH(j, m->jobs, i) {
build: basic autoconfization
2010-02-03 16:21:48 +03:00
char *u_path, *j_path;
core: add minimal templating system
2010-04-15 05:11:11 +04:00
const char *state, *type;
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
uint32_t id;
DBusMessageIter sub2;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
goto oom;
id = (uint32_t) j->id;
state = job_state_to_string(j->state);
dbus: properly encode job type
2010-02-03 14:39:44 +03:00
type = job_type_to_string(j->type);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
j_path = job_dbus_path(j);
if (!j_path)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
u_path = unit_dbus_path(j->unit);
if (!u_path) {
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(j_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
}
if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &id) ||
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &j->unit->id) ||
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &type) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &state) ||
build: basic autoconfization
2010-02-03 16:21:48 +03:00
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &j_path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &u_path)) {
free(j_path);
free(u_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
}
build: basic autoconfization
2010-02-03 16:21:48 +03:00
free(j_path);
free(u_path);
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
if (!dbus_message_iter_close_container(&sub, &sub2))
goto oom;
}
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Subscribe")) {
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
char *client;
dbus: send signals about jobs to the clients having created them unconditionally, and thus get rid of broadcast signals in most cases
2010-07-05 02:58:07 +04:00
Set *s;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
s = BUS_CONNECTION_SUBSCRIBED(m, connection);
if (!s) {
s = set_new(string_hash_func, string_compare_func);
if (!s)
dbus: send signals about jobs to the clients having created them unconditionally, and thus get rid of broadcast signals in most cases
2010-07-05 02:58:07 +04:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
if (!dbus_connection_set_data(connection, m->subscribed_data_slot, s, NULL)) {
dbus: send signals about jobs to the clients having created them unconditionally, and thus get rid of broadcast signals in most cases
2010-07-05 02:58:07 +04:00
set_free(s);
goto oom;
}
}
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
client = strdup(bus_message_get_sender_with_fallback(message));
if (!client)
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = set_put(s, client);
if (r < 0) {
dbus: send signals about jobs to the clients having created them unconditionally, and thus get rid of broadcast signals in most cases
2010-07-05 02:58:07 +04:00
free(client);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, NULL, r);
dbus: send signals about jobs to the clients having created them unconditionally, and thus get rid of broadcast signals in most cases
2010-07-05 02:58:07 +04:00
}
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Unsubscribe")) {
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
char *client;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
client = set_remove(BUS_CONNECTION_SUBSCRIBED(m, connection), (char*) bus_message_get_sender_with_fallback(message));
if (!client) {
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
}
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
free(client);
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: send out signals when units/jobs come, go and change
2010-02-05 02:38:41 +03:00
goto oom;
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Dump")) {
dbus: add Dump() D-Bus call
2010-04-10 19:37:56 +04:00
FILE *f;
char *dump = NULL;
size_t size;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: add Dump() D-Bus call
2010-04-10 19:37:56 +04:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
f = open_memstream(&dump, &size);
if (!f)
dbus: add Dump() D-Bus call
2010-04-10 19:37:56 +04:00
goto oom;
manager_dump_units(m, f, NULL);
manager_dump_jobs(m, f, NULL);
if (ferror(f)) {
fclose(f);
free(dump);
goto oom;
}
fclose(f);
if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &dump, DBUS_TYPE_INVALID)) {
free(dump);
goto oom;
}
free(dump);
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "CreateSnapshot")) {
const char *name;
dbus_bool_t cleanup;
Snapshot *s;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "start");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_BOOLEAN, &cleanup,
DBUS_TYPE_INVALID))
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
if (isempty(name))
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
name = NULL;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = snapshot_create(m, name, cleanup, &error, &s);
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, r);
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
path = unit_dbus_path(UNIT(s));
if (!path)
dbus: greatly extend dbus coverage
2010-04-18 05:08:16 +04:00
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID))
goto oom;
dbus: add Dump() D-Bus call
2010-04-10 19:37:56 +04:00
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
char *introspection = NULL;
FILE *f;
Iterator i;
Unit *u;
Job *j;
const char *k;
size_t size;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
/* We roll our own introspection code here, instead of
* relying on bus_default_message_handler() because we
* need to generate our introspection string
* dynamically. */
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
f = open_memstream(&introspection, &size);
if (!f)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
goto oom;
fputs(INTROSPECTION_BEGIN, f);
HASHMAP_FOREACH_KEY(u, k, m->units, i) {
char *p;
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 15:04:08 +04:00
if (k != u->id)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
continue;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
p = bus_path_escape(k);
if (!p) {
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
fclose(f);
free(introspection);
goto oom;
}
fprintf(f, "<node name=\"unit/%s\"/>", p);
free(p);
}
HASHMAP_FOREACH(j, m->jobs, i)
fprintf(f, "<node name=\"job/%lu\"/>", (unsigned long) j->id);
fputs(INTROSPECTION_END, f);
if (ferror(f)) {
fclose(f);
free(introspection);
goto oom;
}
fclose(f);
if (!introspection)
goto oom;
if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
free(introspection);
goto oom;
}
free(introspection);
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Reload")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reload");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
assert(!m->queued_message);
/* Instead of sending the reply back right away, we
* just remember that we need to and then send it
* after the reload is finished. That way the caller
* knows when the reload finished. */
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
m->queued_message = dbus_message_new_method_return(message);
if (!m->queued_message)
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
goto oom;
dbus: send reload completion message on right connection
2010-07-07 04:21:16 +04:00
m->queued_message_connection = connection;
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
m->exit_code = MANAGER_RELOAD;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Reexecute")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reload");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
dbus: make daemon reexecution synchronous We simply keep open copies of the dbus connections across the reexecution and close them as last step of it. A client can thus simply wait until its connection is dropped to know when the reexecution is finished. https://bugzilla.redhat.com/show_bug.cgi?id=698198
2011-04-29 00:07:01 +04:00
/* We don't send a reply back here, the client should
* just wait for us disconnecting. */
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
m->exit_code = MANAGER_REEXECUTE;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Exit")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "halt");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as == SYSTEMD_SYSTEM) {
drop support for MANAGER_SESSION, introduce MANAGER_USER instead
2010-11-16 00:12:41 +03:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "Exit is only supported for user service managers.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
}
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
reload: implement reload/reexec logic
2010-04-21 05:27:44 +04:00
goto oom;
m->exit_code = MANAGER_EXIT;
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Reboot")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as != SYSTEMD_SYSTEM) {
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
goto oom;
m->exit_code = MANAGER_REBOOT;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "PowerOff")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "halt");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as != SYSTEMD_SYSTEM) {
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
goto oom;
m->exit_code = MANAGER_POWEROFF;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "Halt")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "halt");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as != SYSTEMD_SYSTEM) {
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "Halting is only supported for system managers.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
goto oom;
m->exit_code = MANAGER_HALT;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "KExec")) {
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as != SYSTEMD_SYSTEM) {
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "kexec is only supported for system managers.");
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
dbus: expose shutdown helper via D-Bus
2010-10-14 02:53:51 +04:00
goto oom;
m->exit_code = MANAGER_KEXEC;
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "SwitchRoot")) {
const char *switch_root, *switch_root_init;
char *u, *v;
core: add extra safety check before switching root
2012-05-11 19:17:57 +04:00
int k;
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &switch_root,
DBUS_TYPE_STRING, &switch_root_init,
DBUS_TYPE_INVALID))
return bus_send_error_reply(connection, message, &error, -EINVAL);
switch-root: check for absolute paths
2012-05-16 05:23:54 +04:00
if (path_equal(switch_root, "/") || !path_is_absolute(switch_root))
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
return bus_send_error_reply(connection, message, NULL, -EINVAL);
switch-root: check for absolute paths
2012-05-16 05:23:54 +04:00
if (!isempty(switch_root_init) && !path_is_absolute(switch_root_init))
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
return bus_send_error_reply(connection, message, NULL, -EINVAL);
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
if (m->running_as != SYSTEMD_SYSTEM) {
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
dbus_set_error(&error, BUS_ERROR_NOT_SUPPORTED, "Switching root is only supported for system managers.");
return bus_send_error_reply(connection, message, &error, -ENOTSUP);
}
core: add extra safety check before switching root
2012-05-11 19:17:57 +04:00
/* Safety check */
if (isempty(switch_root_init))
k = access(switch_root, F_OK);
else {
char *p;
util: rename join() to strjoin() This is to match strappend() and the other string related functions.
2012-07-13 15:41:01 +04:00
p = strjoin(switch_root, "/", switch_root_init, NULL);
core: add extra safety check before switching root
2012-05-11 19:17:57 +04:00
if (!p)
goto oom;
k = access(p, X_OK);
free(p);
}
if (k < 0)
return bus_send_error_reply(connection, message, NULL, -errno);
manager: introduce SwitchRoot bus call for initrd/main transition
2012-05-09 03:24:50 +04:00
u = strdup(switch_root);
if (!u)
goto oom;
if (!isempty(switch_root_init)) {
v = strdup(switch_root_init);
if (!v) {
free(u);
goto oom;
}
} else
v = NULL;
free(m->switch_root);
free(m->switch_root_init);
m->switch_root = u;
m->switch_root_init = v;
reply = dbus_message_new_method_return(message);
if (!reply)
goto oom;
m->exit_code = MANAGER_SWITCH_ROOT;
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "SetEnvironment")) {
char **l = NULL, **e = NULL;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = bus_parse_strv(message, &l);
if (r == -ENOMEM)
goto oom;
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, NULL, r);
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
service: optionally call into PAM when dropping priviliges
2010-06-16 23:54:17 +04:00
e = strv_env_merge(2, m->environment, l);
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
strv_free(l);
if (!e)
goto oom;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
reply = dbus_message_new_method_return(message);
if (!reply) {
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
strv_free(e);
goto oom;
}
strv_free(m->environment);
m->environment = e;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "UnsetEnvironment")) {
char **l = NULL, **e = NULL;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = bus_parse_strv(message, &l);
if (r == -ENOMEM)
goto oom;
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, NULL, r);
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
service: optionally call into PAM when dropping priviliges
2010-06-16 23:54:17 +04:00
e = strv_env_delete(m->environment, 1, l);
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
strv_free(l);
if (!e)
goto oom;
src: our lord is coverity
2011-03-31 17:35:40 +04:00
if (!(reply = dbus_message_new_method_return(message))) {
strv_free(e);
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
goto oom;
src: our lord is coverity
2011-03-31 17:35:40 +04:00
}
environment: allow control of the environment block via D-Bus
2010-05-10 01:53:52 +04:00
strv_free(m->environment);
m->environment = e;
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "UnsetAndSetEnvironment")) {
char **l_set = NULL, **l_unset = NULL, **e = NULL, **f = NULL;
DBusMessageIter iter;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "reboot");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
if (!dbus_message_iter_init(message, &iter))
bus: expose installer functions
2011-07-23 05:44:47 +04:00
goto oom;
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
r = bus_parse_strv_iter(&iter, &l_unset);
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
if (r == -ENOMEM)
goto oom;
if (r < 0)
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
return bus_send_error_reply(connection, message, NULL, r);
if (!dbus_message_iter_next(&iter)) {
strv_free(l_unset);
return bus_send_error_reply(connection, message, NULL, -EINVAL);
}
r = bus_parse_strv_iter(&iter, &l_set);
if (r < 0) {
strv_free(l_unset);
if (r == -ENOMEM)
goto oom;
return bus_send_error_reply(connection, message, NULL, r);
}
e = strv_env_delete(m->environment, 1, l_unset);
strv_free(l_unset);
if (!e) {
strv_free(l_set);
goto oom;
}
f = strv_env_merge(2, e, l_set);
strv_free(l_set);
strv_free(e);
if (!f)
goto oom;
if (!(reply = dbus_message_new_method_return(message))) {
strv_free(f);
goto oom;
}
strv_free(m->environment);
m->environment = f;
bus: expose installer functions
2011-07-23 05:44:47 +04:00
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ListUnitFiles")) {
DBusMessageIter iter, sub, sub2;
Hashmap *h;
Iterator i;
UnitFileList *item;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
bus: expose installer functions
2011-07-23 05:44:47 +04:00
reply = dbus_message_new_method_return(message);
if (!reply)
goto oom;
h = hashmap_new(string_hash_func, string_compare_func);
if (!h)
goto oom;
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
r = unit_file_get_list(m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, h);
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (r < 0) {
unit_file_list_free(h);
dbus_message_unref(reply);
return bus_send_error_reply(connection, message, NULL, r);
}
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ss)", &sub)) {
unit_file_list_free(h);
goto oom;
}
HASHMAP_FOREACH(item, h, i) {
const char *state;
state = unit_file_state_to_string(item->state);
assert(state);
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &item->path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &state) ||
!dbus_message_iter_close_container(&sub, &sub2)) {
unit_file_list_free(h);
goto oom;
}
}
unit_file_list_free(h);
if (!dbus_message_iter_close_container(&iter, &sub))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "GetUnitFileState")) {
const char *name;
UnitFileState state;
const char *s;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (!dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
return bus_send_error_reply(connection, message, &error, -EINVAL);
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
state = unit_file_get_state(m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, name);
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (state < 0)
return bus_send_error_reply(connection, message, NULL, state);
s = unit_file_state_to_string(state);
assert(s);
reply = dbus_message_new_method_return(message);
if (!reply)
goto oom;
if (!dbus_message_append_args(
reply,
DBUS_TYPE_STRING, &s,
DBUS_TYPE_INVALID))
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "EnableUnitFiles") ||
dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "ReenableUnitFiles") ||
dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "LinkUnitFiles") ||
dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "PresetUnitFiles") ||
dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "MaskUnitFiles")) {
char **l = NULL;
DBusMessageIter iter;
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
UnitFileScope scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
bus: expose installer functions
2011-07-23 05:44:47 +04:00
UnitFileChange *changes = NULL;
unsigned n_changes = 0;
dbus_bool_t runtime, force;
dbus: fix MaskUnitFiles bus call
2011-08-02 02:10:40 +04:00
int carries_install_info = -1;
bus: expose installer functions
2011-07-23 05:44:47 +04:00
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, streq(member, "MaskUnitFiles") ? "disable" : "enable");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (!dbus_message_iter_init(message, &iter))
goto oom;
r = bus_parse_strv_iter(&iter, &l);
if (r < 0) {
if (r == -ENOMEM)
goto oom;
return bus_send_error_reply(connection, message, NULL, r);
}
if (!dbus_message_iter_next(&iter) ||
bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &runtime, true) < 0 ||
bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &force, false) < 0) {
strv_free(l);
return bus_send_error_reply(connection, message, NULL, -EIO);
}
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
if (streq(member, "EnableUnitFiles")) {
bus: expose installer functions
2011-07-23 05:44:47 +04:00
r = unit_file_enable(scope, runtime, NULL, l, force, &changes, &n_changes);
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
carries_install_info = r;
} else if (streq(member, "ReenableUnitFiles")) {
bus: expose installer functions
2011-07-23 05:44:47 +04:00
r = unit_file_reenable(scope, runtime, NULL, l, force, &changes, &n_changes);
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
carries_install_info = r;
} else if (streq(member, "LinkUnitFiles"))
bus: expose installer functions
2011-07-23 05:44:47 +04:00
r = unit_file_link(scope, runtime, NULL, l, force, &changes, &n_changes);
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
else if (streq(member, "PresetUnitFiles")) {
bus: expose installer functions
2011-07-23 05:44:47 +04:00
r = unit_file_preset(scope, runtime, NULL, l, force, &changes, &n_changes);
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
carries_install_info = r;
} else if (streq(member, "MaskUnitFiles"))
bus: expose installer functions
2011-07-23 05:44:47 +04:00
r = unit_file_mask(scope, runtime, NULL, l, force, &changes, &n_changes);
else
assert_not_reached("Uh? Wrong method");
strv_free(l);
bus_manager_send_unit_files_changed(m);
if (r < 0) {
unit_file_changes_free(changes, n_changes);
return bus_send_error_reply(connection, message, NULL, r);
}
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
reply = message_from_file_changes(message, changes, n_changes, carries_install_info);
bus: expose installer functions
2011-07-23 05:44:47 +04:00
unit_file_changes_free(changes, n_changes);
if (!reply)
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "DisableUnitFiles") ||
dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "UnmaskUnitFiles")) {
char **l = NULL;
DBusMessageIter iter;
core: move ManagerRunningAs to shared Note: I did s/MANAGER/SYSTEMD/ everywhere, even though it makes the patch quite verbose. Nevertheless, keeping MANAGER prefix in some places, and SYSTEMD prefix in others would just lead to confusion down the road. Better to rip off the band-aid now.
2012-09-18 19:11:12 +04:00
UnitFileScope scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
bus: expose installer functions
2011-07-23 05:44:47 +04:00
UnitFileChange *changes = NULL;
unsigned n_changes = 0;
dbus_bool_t runtime;
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, streq(member, "UnmaskUnitFiles") ? "enable" : "disable");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
bus: expose installer functions
2011-07-23 05:44:47 +04:00
if (!dbus_message_iter_init(message, &iter))
goto oom;
r = bus_parse_strv_iter(&iter, &l);
if (r < 0) {
if (r == -ENOMEM)
goto oom;
return bus_send_error_reply(connection, message, NULL, r);
}
if (!dbus_message_iter_next(&iter) ||
bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &runtime, false) < 0) {
strv_free(l);
return bus_send_error_reply(connection, message, NULL, -EIO);
}
if (streq(member, "DisableUnitFiles"))
r = unit_file_disable(scope, runtime, NULL, l, &changes, &n_changes);
else if (streq(member, "UnmaskUnitFiles"))
r = unit_file_unmask(scope, runtime, NULL, l, &changes, &n_changes);
else
assert_not_reached("Uh? Wrong method");
strv_free(l);
bus_manager_send_unit_files_changed(m);
if (r < 0) {
unit_file_changes_free(changes, n_changes);
return bus_send_error_reply(connection, message, NULL, r);
}
systemctl: hook up new install logic This adds a number of new options to systemctl, for presets, reenabling, masking/unmask, and runtime operations.
2011-07-25 06:58:02 +04:00
reply = message_from_file_changes(message, changes, n_changes, -1);
bus: expose installer functions
2011-07-23 05:44:47 +04:00
unit_file_changes_free(changes, n_changes);
if (!reply)
goto oom;
dbus: introduce UnsetAndSetEnvironment()
2011-06-15 17:31:54 +04:00
dbus: more efficient implementation of properties The way the various properties[] arrays are initialized is inefficient: - only the .data members change at runtime, yet the whole arrays of properties with all the fields are constructed on the stack one by one by the code. - there's duplication, eg. the properties of "org.freedesktop.systemd1.Unit" are repeated in several unit types. Fix it by moving the information about properties into static const sections. Instead of storing the .data directly in the property, store a constant offset from a run-time base. The small arrays of struct BusBoundProperties bind together the constant information with the right runtime information (the base pointer). On my system the code shrinks by 60 KB, data increases by 10 KB.
2012-01-16 03:23:59 +04:00
} else {
const BusBoundProperties bps[] = {
{ "org.freedesktop.systemd1.Manager", bus_systemd_properties, systemd_property_string },
{ "org.freedesktop.systemd1.Manager", bus_manager_properties, m },
{ NULL, }
};
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
selinux: remove anything PID1-specific from selinux-access.[ch] so that we can reuse it in logind
2012-10-03 01:56:54 +04:00
SELINUX_ACCESS_CHECK(connection, message, "status");
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
dbus: more efficient implementation of properties The way the various properties[] arrays are initialized is inefficient: - only the .data members change at runtime, yet the whole arrays of properties with all the fields are constructed on the stack one by one by the code. - there's duplication, eg. the properties of "org.freedesktop.systemd1.Unit" are repeated in several unit types. Fix it by moving the information about properties into static const sections. Instead of storing the .data directly in the property, store a constant offset from a run-time base. The small arrays of struct BusBoundProperties bind together the constant information with the right runtime information (the base pointer). On my system the code shrinks by 60 KB, data increases by 10 KB.
2012-01-16 03:23:59 +04:00
return bus_default_message_handler(connection, message, NULL, INTERFACES_LIST, bps);
}
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
if (job_type != _JOB_TYPE_INVALID) {
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
const char *name, *smode, *old_name = NULL;
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
JobMode mode;
Unit *u;
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
dbus_bool_t b;
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
if (dbus_message_is_method_call(message, "org.freedesktop.systemd1.Manager", "StartUnitReplace"))
b = dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &old_name,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &smode,
DBUS_TYPE_INVALID);
else
b = dbus_message_get_args(
message,
&error,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &smode,
DBUS_TYPE_INVALID);
if (!b)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
if (old_name) {
u = manager_get_unit(m, old_name);
if (!u || !u->job || u->job->type != JOB_START) {
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
dbus_set_error(&error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -ENOENT);
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
}
fsck: atomically replace base.target by rescue.target/reboot.target when fsck fails
2010-10-19 23:53:19 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
mode = job_mode_from_string(smode);
if (mode < 0) {
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
dbus_set_error(&error, BUS_ERROR_INVALID_JOB_MODE, "Job mode %s is invalid.", smode);
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, -EINVAL);
dbus: make errors reported via D-Bus more useful
2010-07-08 04:43:18 +04:00
}
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
r = manager_load_unit(m, name, NULL, &error, &u);
if (r < 0)
dbus: split out object management code into dbus-common, and simplify it
2011-04-16 03:54:49 +04:00
return bus_send_error_reply(connection, message, &error, r);
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
return bus_unit_queue_job(connection, message, u, job_type, mode, reload_if_possible);
dbus: add simplified way to start an arbitrary unit in a single method call
2010-06-01 21:47:46 +04:00
}
selinux: rework selinux access check logic a) Instead of parsing the bus messages inside of selinux-access.c simply pass everything pre-parsed in the functions b) implement the access checking with a macro that resolves to nothing on non-selinux builds c) split out the selinux checks into their own sources selinux-util.[ch] d) this unifies the job creation code behind the D-Bus calls Manager.StartUnit() and Unit.Start().
2012-10-03 01:07:00 +04:00
if (reply)
add basic (and not very useful) D-Bus support
2010-02-01 05:33:24 +03:00
if (!dbus_connection_send(connection, reply, NULL))
goto oom;
return DBUS_HANDLER_RESULT_HANDLED;
oom:
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
const DBusObjectPathVTable bus_manager_vtable = {
.message_function = bus_manager_message_handler
};
Copy Permalink