src/shared/dbus-common.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #pragma once
   4
   5 /***
   6   This file is part of systemd.
   7
   8   Copyright 2010 Lennart Poettering
   9
  10   systemd is free software; you can redistribute it and/or modify it
  11   under the terms of the GNU Lesser General Public License as published by
  12   the Free Software Foundation; either version 2.1 of the License, or
  13   (at your option) any later version.
  14
  15   systemd is distributed in the hope that it will be useful, but
  16   WITHOUT ANY WARRANTY; without even the implied warranty of
  17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18   Lesser General Public License for more details.
  19
  20   You should have received a copy of the GNU Lesser General Public License
  21   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  22 ***/
  23
  24 #include <dbus/dbus.h>
  25
  26 #ifndef DBUS_ERROR_UNKNOWN_OBJECT
  27 #define DBUS_ERROR_UNKNOWN_OBJECT "org.freedesktop.DBus.Error.UnknownObject"
  28 #endif
  29
  30 #ifndef DBUS_ERROR_UNKNOWN_INTERFACE
  31 #define DBUS_ERROR_UNKNOWN_INTERFACE "org.freedesktop.DBus.Error.UnknownInterface"
  32 #endif
  33
  34 #ifndef DBUS_ERROR_UNKNOWN_PROPERTY
  35 #define DBUS_ERROR_UNKNOWN_PROPERTY "org.freedesktop.DBus.Error.UnknownProperty"
  36 #endif
  37
  38 #ifndef DBUS_ERROR_PROPERTY_READ_ONLY
  39 #define DBUS_ERROR_PROPERTY_READ_ONLY "org.freedesktop.DBus.Error.PropertyReadOnly"
  40 #endif
  41
  42 #define BUS_PROPERTIES_INTERFACE                                        \
  43         " <interface name=\"org.freedesktop.DBus.Properties\">\n"       \
  44         "  <method name=\"Get\">\n"                                     \
  45         "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"    \
  46         "   <arg name=\"property\" direction=\"in\" type=\"s\"/>\n"     \
  47         "   <arg name=\"value\" direction=\"out\" type=\"v\"/>\n"       \
  48         "  </method>\n"                                                 \
  49         "  <method name=\"GetAll\">\n"                                  \
  50         "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"    \
  51         "   <arg name=\"properties\" direction=\"out\" type=\"a{sv}\"/>\n" \
  52         "  </method>\n"                                                 \
  53         "  <method name=\"Set\">\n"                                     \
  54         "   <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n"    \
  55         "   <arg name=\"property\" direction=\"in\" type=\"s\"/>\n"     \
  56         "   <arg name=\"value\" direction=\"in\" type=\"v\"/>\n"        \
  57         "  </method>\n"                                                 \
  58         "  <signal name=\"PropertiesChanged\">\n"                       \
  59         "   <arg type=\"s\" name=\"interface\"/>\n"                     \
  60         "   <arg type=\"a{sv}\" name=\"changed_properties\"/>\n"        \
  61         "   <arg type=\"as\" name=\"invalidated_properties\"/>\n"       \
  62         "  </signal>\n"                                                 \
  63         " </interface>\n"
  64
  65 #define BUS_INTROSPECTABLE_INTERFACE                                    \
  66         " <interface name=\"org.freedesktop.DBus.Introspectable\">\n"   \
  67         "  <method name=\"Introspect\">\n"                              \
  68         "   <arg name=\"data\" type=\"s\" direction=\"out\"/>\n"        \
  69         "  </method>\n"                                                 \
  70         " </interface>\n"
  71
  72 #define BUS_PEER_INTERFACE                                              \
  73         "<interface name=\"org.freedesktop.DBus.Peer\">\n"              \
  74         " <method name=\"Ping\"/>\n"                                    \
  75         " <method name=\"GetMachineId\">\n"                             \
  76         "  <arg type=\"s\" name=\"machine_uuid\" direction=\"out\"/>\n" \
  77         " </method>\n"                                                  \
  78         "</interface>\n"
  79
  80 #define BUS_GENERIC_INTERFACES_LIST             \
  81         "org.freedesktop.DBus.Properties\0"     \
  82         "org.freedesktop.DBus.Introspectable\0" \
  83         "org.freedesktop.DBus.Peer\0"
  84
  85 int bus_check_peercred(DBusConnection *c);
  86
  87 int bus_connect(DBusBusType t, DBusConnection **_bus, bool *private_bus, DBusError *error);
  88
  89 int bus_connect_system_ssh(const char *user, const char *host, DBusConnection **_bus, DBusError *error);
  90 int bus_connect_system_polkit(DBusConnection **_bus, DBusError *error);
  91
  92 const char *bus_error_message(const DBusError *error);
  93 const char *bus_error_message_or_strerror(const DBusError *error, int err);
  94
  95 typedef int (*BusPropertyCallback)(DBusMessageIter *iter, const char *property, void *data);
  96 typedef int (*BusPropertySetCallback)(DBusMessageIter *iter, const char *property, void *data);
  97
  98 typedef struct BusProperty {
  99         const char *property;            /* name of the property */
 100         BusPropertyCallback append;      /* Function that is called to serialize this property */
 101         const char *signature;
 102         const uint16_t offset;           /* Offset from BusBoundProperties::base address to the property data.
 103                                           * uint16_t is sufficient, because we have no structs too big.
 104                                           * -Werror=overflow will catch it if this does not hold. */
 105         bool indirect;                   /* data is indirect, ie. not base+offset, but *(base+offset) */
 106         BusPropertySetCallback set;      /* Optional: Function that is called to set this property */
 107 } BusProperty;
 108
 109 typedef struct BusBoundProperties {
 110         const char *interface;           /* interface of the properties */
 111         const BusProperty *properties;   /* array of properties, ended by a NULL-filled element */
 112         const void *const base;          /* base pointer to which the offset must be added to reach data */
 113 } BusBoundProperties;
 114
 115 DBusHandlerResult bus_send_error_reply(
 116                 DBusConnection *c,
 117                 DBusMessage *message,
 118                 DBusError *bus_error,
 119                 int error);
 120
 121 DBusHandlerResult bus_default_message_handler(
 122                 DBusConnection *c,
 123                 DBusMessage *message,
 124                 const char *introspection,
 125                 const char *interfaces,
 126                 const BusBoundProperties *bound_properties);
 127
 128 int bus_property_append_string(DBusMessageIter *i, const char *property, void *data);
 129 int bus_property_append_strv(DBusMessageIter *i, const char *property, void *data);
 130 int bus_property_append_bool(DBusMessageIter *i, const char *property, void *data);
 131 int bus_property_append_tristate_false(DBusMessageIter *i, const char *property, void *data);
 132 int bus_property_append_int32(DBusMessageIter *i, const char *property, void *data);
 133 int bus_property_append_uint32(DBusMessageIter *i, const char *property, void *data);
 134 int bus_property_append_uint64(DBusMessageIter *i, const char *property, void *data);
 135 int bus_property_append_size(DBusMessageIter *i, const char *property, void *data);
 136 int bus_property_append_ul(DBusMessageIter *i, const char *property, void *data);
 137 int bus_property_append_long(DBusMessageIter *i, const char *property, void *data);
 138
 139 #define bus_property_append_int bus_property_append_int32
 140 #define bus_property_append_pid bus_property_append_uint32
 141 #define bus_property_append_uid bus_property_append_uint32
 142 #define bus_property_append_gid bus_property_append_uint32
 143 #define bus_property_append_mode bus_property_append_uint32
 144 #define bus_property_append_unsigned bus_property_append_uint32
 145 #define bus_property_append_usec bus_property_append_uint64
 146
 147 int bus_property_set_uint64(DBusMessageIter *i, const char *property, void *data);
 148 #define bus_property_set_usec bus_property_set_uint64
 149
 150 #define DEFINE_BUS_PROPERTY_APPEND_ENUM(function,name,type)             \
 151         int function(DBusMessageIter *i, const char *property, void *data) { \
 152                 const char *value;                                      \
 153                 type *field = data;                                     \
 154                                                                         \
 155                 assert(i);                                              \
 156                 assert(property);                                       \
 157                                                                         \
 158                 value = strempty(name##_to_string(*field));             \
 159                                                                         \
 160                 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &value)) \
 161                         return -ENOMEM;                                 \
 162                                                                         \
 163                 return 0;                                               \
 164         }
 165
 166 #define DEFINE_BUS_PROPERTY_SET_ENUM(function,name,type)                \
 167         int function(DBusMessageIter *i, const char *property, void *data) { \
 168                 const char *value;                                      \
 169                 type f, *field = data;                                  \
 170                                                                         \
 171                 assert(i);                                              \
 172                 assert(property);                                       \
 173                                                                         \
 174                 dbus_message_iter_get_basic(i, &value);                 \
 175                                                                         \
 176                 f = name##_from_string(value);                          \
 177                 if (f < 0)                                              \
 178                         return f;                                       \
 179                                                                         \
 180                 *field = f;                                             \
 181                 return 0;                                               \
 182         }
 183
 184 const char *bus_errno_to_dbus(int error);
 185
 186 DBusMessage* bus_properties_changed_new(const char *path, const char *interface, const char *properties);
 187 DBusMessage* bus_properties_changed_one_new(const char *path, const char *interface, const char *property);
 188
 189 uint32_t bus_flags_to_events(DBusWatch *bus_watch);
 190 unsigned bus_events_to_flags(uint32_t events);
 191
 192 int bus_parse_strv(DBusMessage *m, char ***_l);
 193 int bus_parse_strv_iter(DBusMessageIter *iter, char ***_l);
 194
 195 int bus_append_strv_iter(DBusMessageIter *iter, char **l);
 196
 197 int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next);
 198
 199 int generic_print_property(const char *name, DBusMessageIter *iter, bool all);
 200
 201 void bus_async_unregister_and_exit(DBusConnection *bus, const char *name);
 202
 203 DBusHandlerResult bus_exit_idle_filter(DBusConnection *bus, DBusMessage *m, void *userdata);
 204
 205 pid_t bus_get_unix_process_id(DBusConnection *connection, const char *name, DBusError *error);
 206
 207 bool bus_error_is_no_service(const DBusError *error);
 208 int bus_method_call_with_reply(DBusConnection *bus,
 209                                const char *destination,
 210                                const char *path,
 211                                const char *interface,
 212                                const char *method,
 213                                DBusMessage **return_reply,
 214                                DBusError *return_error,
 215                                int first_arg_type, ...);
 216
 217 const char *bus_message_get_sender_with_fallback(DBusMessage *m);
 218
 219 void bus_message_unrefp(DBusMessage **reply);
 220
 221 #define _cleanup_dbus_message_unref_ __attribute__((cleanup(bus_message_unrefp)))