service: add options RestartPreventExitStatus and SuccessExitStatus

[elogind.git] / src / shared / dbus-common.c

diff --git a/src/shared/dbus-common.c b/src/shared/dbus-common.c
index badd037db1dd45f3747e76f3752fc3d5e8a32c68..da2dc2e983a06c734616fc87b614ccef5617f986 100644 (file)
--- a/src/shared/dbus-common.c
+++ b/src/shared/dbus-common.c
@@ -245,7 +245,8 @@ int bus_connect_system_polkit(DBusConnection **_bus, DBusError *error) {
 }
 
 const char *bus_error_message(const DBusError *error) {
-        assert(error);
+        if (!error)
+                return NULL;
 
         /* Sometimes the D-Bus server is a little bit too verbose with
          * its error messages, so let's override them here */
@@ -255,6 +256,14 @@ const char *bus_error_message(const DBusError *error) {
         return error->message;
 }
 
+const char *bus_error_message_or_strerror(const DBusError *error, int err) {
+
+        if (error && dbus_error_is_set(error))
+                return bus_error_message(error);
+
+        return strerror(err);
+}
+
 DBusHandlerResult bus_default_message_handler(
                 DBusConnection *c,
                 DBusMessage *message,
@@ -660,6 +669,16 @@ int bus_property_append_long(DBusMessageIter *i, const char *property, void *dat
         return 0;
 }
 
+int bus_property_set_uint64(DBusMessageIter *i, const char *property, void *data) {
+        uint64_t *t = data;
+
+        assert(i);
+        assert(property);
+
+        dbus_message_iter_get_basic(i, t);
+        return 0;
+}
+
 const char *bus_errno_to_dbus(int error) {
 
         switch(error) {
@@ -1063,6 +1082,29 @@ int generic_print_property(const char *name, DBusMessageIter *iter, bool all) {
                                 puts("");
                         }
 
+                        return 1;
+
+                } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_UINT32) {
+                        DBusMessageIter sub;
+
+                        dbus_message_iter_recurse(iter, &sub);
+                        if (all ||
+                            dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+                                printf("%s=", name);
+
+                                while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
+                                        uint32_t u;
+
+                                        assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32);
+                                        dbus_message_iter_get_basic(&sub, &u);
+                                        printf("%08x", u);
+
+                                        dbus_message_iter_next(&sub);
+                                }
+
+                                puts("");
+                        }
+
                         return 1;
                 }
 
@@ -1119,7 +1161,7 @@ void bus_async_unregister_and_exit(DBusConnection *bus, const char *name) {
         return;
 
 oom:
-        log_error("Out of memory");
+        log_oom();
 
         if (pending) {
                 dbus_pending_call_cancel(pending);
@@ -1137,7 +1179,7 @@ DBusHandlerResult bus_exit_idle_filter(DBusConnection *bus, DBusMessage *m, void
         assert(m);
         assert(remain_until);
 
-        /* Everytime we get a new message we reset out timeout */
+        /* Every time we get a new message we reset out timeout */
         *remain_until = now(CLOCK_MONOTONIC) + DEFAULT_EXIT_USEC;
 
         if (dbus_message_is_signal(m, DBUS_INTERFACE_LOCAL, "Disconnected"))
@@ -1145,3 +1187,127 @@ DBusHandlerResult bus_exit_idle_filter(DBusConnection *bus, DBusMessage *m, void
 
         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
+
+/* This mimics dbus_bus_get_unix_user() */
+pid_t bus_get_unix_process_id(
+                DBusConnection *connection,
+                const char *name,
+                DBusError *error) {
+
+        DBusMessage *m = NULL, *reply = NULL;
+        uint32_t pid = 0;
+
+        m = dbus_message_new_method_call(
+                        DBUS_SERVICE_DBUS,
+                        DBUS_PATH_DBUS,
+                        DBUS_INTERFACE_DBUS,
+                        "GetConnectionUnixProcessID");
+        if (!m) {
+                dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, NULL);
+                goto finish;
+        }
+
+        if (!dbus_message_append_args(
+                            m,
+                            DBUS_TYPE_STRING, &name,
+                            DBUS_TYPE_INVALID)) {
+                dbus_set_error_const(error, DBUS_ERROR_NO_MEMORY, NULL);
+                goto finish;
+        }
+
+        reply = dbus_connection_send_with_reply_and_block(connection, m, -1, error);
+        if (!reply)
+                goto finish;
+
+        if (dbus_set_error_from_message(error, reply))
+                goto finish;
+
+        if (!dbus_message_get_args(
+                            reply, error,
+                            DBUS_TYPE_UINT32, &pid,
+                            DBUS_TYPE_INVALID))
+                goto finish;
+
+finish:
+        if (m)
+                dbus_message_unref(m);
+
+        if (reply)
+                dbus_message_unref(reply);
+
+        return (pid_t) pid;
+}
+
+bool bus_error_is_no_service(const DBusError *error) {
+        assert(error);
+
+        if (!dbus_error_is_set(error))
+                return false;
+
+        if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))
+                return true;
+
+        if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))
+                return true;
+
+        return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");
+}
+
+int bus_method_call_with_reply(DBusConnection *bus,
+                                       const char *destination,
+                                       const char *path,
+                                       const char *interface,
+                                       const char *method,
+                                       DBusMessage **return_reply,
+                                       DBusError *return_error,
+                                       int first_arg_type, ...) {
+        DBusError error;
+        DBusMessage *m, *reply;
+        va_list ap;
+        int r = 0;
+
+        dbus_error_init(&error);
+        assert(bus);
+
+        m = dbus_message_new_method_call(destination, path, interface, method);
+        if (!m) {
+                r = log_oom();
+                goto finish;
+        }
+
+        va_start(ap, first_arg_type);
+        if (!dbus_message_append_args_valist(m, first_arg_type, ap)) {
+                va_end(ap);
+                dbus_message_unref(m);
+                r = log_oom();
+                goto finish;
+        }
+        va_end(ap);
+
+        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
+        dbus_message_unref(m);
+        if (!reply) {
+                if (!return_error)
+                        log_error("Failed to issue method call: %s", bus_error_message(&error));
+                if (bus_error_is_no_service(&error))
+                        r = -ENOENT;
+                else if (dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED))
+                        r = -EACCES;
+                else if (dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY))
+                        r = -ETIMEDOUT;
+                else
+                        r = -EIO;
+                goto finish;
+        }
+        if (return_reply)
+                *return_reply = reply;
+        else
+                dbus_message_unref(reply);
+finish:
+        if(return_error)
+                *return_error=error;
+        else
+                dbus_error_free(&error);
+
+        return r;
+}