| /* |
| * Copyright (C) 2014-2016 Andrew Beekhof <andrew@beekhof.net> |
| * |
| * This source code is licensed under the GNU Lesser General Public License |
| * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY. |
| */ |
| |
| #include <crm_internal.h> |
| #include <crm/crm.h> |
| #include <crm/services.h> |
| #include <dbus/dbus.h> |
| #include <pcmk-dbus.h> |
| |
| #define BUS_PROPERTY_IFACE "org.freedesktop.DBus.Properties" |
| |
| static GList *conn_dispatches = NULL; |
| |
| struct db_getall_data { |
| char *name; |
| char *target; |
| char *object; |
| void *userdata; |
| void (*callback)(const char *name, const char *value, void *userdata); |
| }; |
| |
| static void |
| free_db_getall_data(struct db_getall_data *data) |
| { |
| free(data->target); |
| free(data->object); |
| free(data->name); |
| free(data); |
| } |
| |
| DBusConnection * |
| pcmk_dbus_connect(void) |
| { |
| DBusError err; |
| DBusConnection *connection; |
| |
| dbus_error_init(&err); |
| connection = dbus_bus_get(DBUS_BUS_SYSTEM, &err); |
| if (dbus_error_is_set(&err)) { |
| crm_err("Could not connect to System DBus: %s", err.message); |
| dbus_error_free(&err); |
| return NULL; |
| } |
| if(connection) { |
| pcmk_dbus_connection_setup_with_select(connection); |
| } |
| return connection; |
| } |
| |
| void |
| pcmk_dbus_disconnect(DBusConnection *connection) |
| { |
| return; |
| } |
| |
| /*! |
| * \internal |
| * \brief Check whether a DBus reply indicates an error occurred |
| * |
| * \param[in] pending If non-NULL, indicates that a DBus request was sent |
| * \param[in] reply Reply received from DBus |
| * \param[out] ret If non-NULL, will be set to DBus error, if any |
| * |
| * \return TRUE if an error was found, FALSE otherwise |
| * |
| * \note Following the DBus API convention, a TRUE return is exactly equivalent |
| * to ret being set. If ret is provided and this function returns TRUE, |
| * the caller is responsible for calling dbus_error_free() on ret when |
| * done using it. |
| */ |
| bool |
| pcmk_dbus_find_error(DBusPendingCall *pending, DBusMessage *reply, |
| DBusError *ret) |
| { |
| DBusError error; |
| |
| dbus_error_init(&error); |
| |
| if(pending == NULL) { |
| dbus_set_error_const(&error, "org.clusterlabs.pacemaker.NoRequest", |
| "No request sent"); |
| |
| } else if(reply == NULL) { |
| dbus_set_error_const(&error, "org.clusterlabs.pacemaker.NoReply", |
| "No reply"); |
| |
| } else { |
| DBusMessageIter args; |
| int dtype = dbus_message_get_type(reply); |
| char *sig; |
| |
| switch(dtype) { |
| case DBUS_MESSAGE_TYPE_METHOD_RETURN: |
| dbus_message_iter_init(reply, &args); |
| sig = dbus_message_iter_get_signature(&args); |
| crm_trace("DBus call returned output args '%s'", sig); |
| dbus_free(sig); |
| break; |
| case DBUS_MESSAGE_TYPE_INVALID: |
| dbus_set_error_const(&error, |
| "org.clusterlabs.pacemaker.InvalidReply", |
| "Invalid reply"); |
| break; |
| case DBUS_MESSAGE_TYPE_METHOD_CALL: |
| dbus_set_error_const(&error, |
| "org.clusterlabs.pacemaker.InvalidReply.Method", |
| "Invalid reply (method call)"); |
| break; |
| case DBUS_MESSAGE_TYPE_SIGNAL: |
| dbus_set_error_const(&error, |
| "org.clusterlabs.pacemaker.InvalidReply.Signal", |
| "Invalid reply (signal)"); |
| break; |
| case DBUS_MESSAGE_TYPE_ERROR: |
| dbus_set_error_from_message(&error, reply); |
| break; |
| default: |
| dbus_set_error(&error, |
| "org.clusterlabs.pacemaker.InvalidReply.Type", |
| "Unknown reply type %d", dtype); |
| } |
| } |
| |
| if (dbus_error_is_set(&error)) { |
| crm_trace("DBus reply indicated error '%s' (%s)", |
| error.name, error.message); |
| if (ret) { |
| dbus_error_init(ret); |
| dbus_move_error(&error, ret); |
| } else { |
| dbus_error_free(&error); |
| } |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| /*! |
| * \internal |
| * \brief Send a DBus request and wait for the reply |
| * |
| * \param[in] msg DBus request to send |
| * \param[in] connection DBus connection to use |
| * \param[out] error If non-NULL, will be set to error, if any |
| * \param[in] timeout Timeout to use for request |
| * |
| * \return DBus reply |
| * |
| * \note If error is non-NULL, it is initialized, so the caller may always use |
| * dbus_error_is_set() to determine whether an error occurred; the caller |
| * is responsible for calling dbus_error_free() in this case. |
| */ |
| DBusMessage * |
| pcmk_dbus_send_recv(DBusMessage *msg, DBusConnection *connection, |
| DBusError *error, int timeout) |
| { |
| const char *method = NULL; |
| DBusMessage *reply = NULL; |
| DBusPendingCall* pending = NULL; |
| |
| CRM_ASSERT(dbus_message_get_type (msg) == DBUS_MESSAGE_TYPE_METHOD_CALL); |
| method = dbus_message_get_member (msg); |
| |
| /* Ensure caller can reliably check whether error is set */ |
| if (error) { |
| dbus_error_init(error); |
| } |
| |
| if (timeout <= 0) { |
| /* DBUS_TIMEOUT_USE_DEFAULT (-1) tells DBus to use a sane default */ |
| timeout = DBUS_TIMEOUT_USE_DEFAULT; |
| } |
| |
| // send message and get a handle for a reply |
| if (!dbus_connection_send_with_reply(connection, msg, &pending, timeout)) { |
| if(error) { |
| dbus_set_error(error, "org.clusterlabs.pacemaker.SendFailed", |
| "Could not queue DBus '%s' request", method); |
| } |
| return NULL; |
| } |
| |
| dbus_connection_flush(connection); |
| |
| if(pending) { |
| /* block until we receive a reply */ |
| dbus_pending_call_block(pending); |
| |
| /* get the reply message */ |
| reply = dbus_pending_call_steal_reply(pending); |
| } |
| |
| (void)pcmk_dbus_find_error(pending, reply, error); |
| |
| if(pending) { |
| /* free the pending message handle */ |
| dbus_pending_call_unref(pending); |
| } |
| |
| return reply; |
| } |
| |
| /*! |
| * \internal |
| * \brief Send a DBus message with a callback for the reply |
| * |
| * \param[in] msg DBus message to send |
| * \param[in,out] connection DBus connection to send on |
| * \param[in] done Function to call when pending call completes |
| * \param[in] user_data Data to pass to done callback |
| * |
| * \return Handle for reply on success, NULL on error |
| * \note The caller can assume that the done callback is called always and |
| * only when the return value is non-NULL. (This allows the caller to |
| * know where it should free dynamically allocated user_data.) |
| */ |
| DBusPendingCall * |
| pcmk_dbus_send(DBusMessage *msg, DBusConnection *connection, |
| void(*done)(DBusPendingCall *pending, void *user_data), |
| void *user_data, int timeout) |
| { |
| const char *method = NULL; |
| DBusPendingCall* pending = NULL; |
| |
| CRM_ASSERT(done); |
| CRM_ASSERT(dbus_message_get_type (msg) == DBUS_MESSAGE_TYPE_METHOD_CALL); |
| method = dbus_message_get_member (msg); |
| |
| |
| if (timeout <= 0) { |
| /* DBUS_TIMEOUT_USE_DEFAULT (-1) tells DBus to use a sane default */ |
| timeout = DBUS_TIMEOUT_USE_DEFAULT; |
| } |
| |
| // send message and get a handle for a reply |
| if (!dbus_connection_send_with_reply(connection, msg, &pending, timeout)) { |
| crm_err("Send with reply failed for %s", method); |
| return NULL; |
| |
| } else if (pending == NULL) { |
| crm_err("No pending call found for %s: Connection to System DBus may be closed", method); |
| return NULL; |
| } |
| |
| crm_trace("DBus %s call sent", method); |
| if (dbus_pending_call_get_completed(pending)) { |
| crm_info("DBus %s call completed too soon", method); |
| if(done) { |
| #if 0 |
| /* This sounds like a good idea, but allegedly it breaks things */ |
| done(pending, user_data); |
| pending = NULL; |
| #else |
| CRM_ASSERT(dbus_pending_call_set_notify(pending, done, user_data, NULL)); |
| #endif |
| } |
| |
| } else if(done) { |
| CRM_ASSERT(dbus_pending_call_set_notify(pending, done, user_data, NULL)); |
| } |
| return pending; |
| } |
| |
| bool |
| pcmk_dbus_type_check(DBusMessage *msg, DBusMessageIter *field, int expected, |
| const char *function, int line) |
| { |
| int dtype = 0; |
| DBusMessageIter lfield; |
| |
| if(field == NULL) { |
| if(dbus_message_iter_init(msg, &lfield)) { |
| field = &lfield; |
| } |
| } |
| |
| if(field == NULL) { |
| do_crm_log_alias(LOG_ERR, __FILE__, function, line, |
| "Empty parameter list in reply expecting '%c'", expected); |
| return FALSE; |
| } |
| |
| dtype = dbus_message_iter_get_arg_type(field); |
| |
| if(dtype != expected) { |
| DBusMessageIter args; |
| char *sig; |
| |
| dbus_message_iter_init(msg, &args); |
| sig = dbus_message_iter_get_signature(&args); |
| do_crm_log_alias(LOG_ERR, __FILE__, function, line, |
| "Unexpected DBus type, expected %c in '%s' instead of %c", |
| expected, sig, dtype); |
| dbus_free(sig); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static char * |
| pcmk_dbus_lookup_result(DBusMessage *reply, struct db_getall_data *data) |
| { |
| DBusError error; |
| char *output = NULL; |
| DBusMessageIter dict; |
| DBusMessageIter args; |
| |
| if (pcmk_dbus_find_error((void*)&error, reply, &error)) { |
| crm_err("Cannot get properties from %s for %s: %s", |
| data->target, data->object, error.message); |
| dbus_error_free(&error); |
| goto cleanup; |
| } |
| |
| dbus_message_iter_init(reply, &args); |
| if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) { |
| crm_err("Invalid reply from %s for %s", data->target, data->object); |
| goto cleanup; |
| } |
| |
| dbus_message_iter_recurse(&args, &dict); |
| while (dbus_message_iter_get_arg_type (&dict) != DBUS_TYPE_INVALID) { |
| DBusMessageIter sv; |
| DBusMessageIter v; |
| DBusBasicValue name; |
| DBusBasicValue value; |
| |
| if(!pcmk_dbus_type_check(reply, &dict, DBUS_TYPE_DICT_ENTRY, __FUNCTION__, __LINE__)) { |
| dbus_message_iter_next (&dict); |
| continue; |
| } |
| |
| dbus_message_iter_recurse(&dict, &sv); |
| while (dbus_message_iter_get_arg_type (&sv) != DBUS_TYPE_INVALID) { |
| int dtype = dbus_message_iter_get_arg_type(&sv); |
| |
| switch(dtype) { |
| case DBUS_TYPE_STRING: |
| dbus_message_iter_get_basic(&sv, &name); |
| |
| if(data->name && strcmp(name.str, data->name) != 0) { |
| dbus_message_iter_next (&sv); /* Skip the value */ |
| } |
| break; |
| case DBUS_TYPE_VARIANT: |
| dbus_message_iter_recurse(&sv, &v); |
| if(pcmk_dbus_type_check(reply, &v, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) { |
| dbus_message_iter_get_basic(&v, &value); |
| |
| crm_trace("Property %s[%s] is '%s'", data->object, name.str, value.str); |
| if(data->callback) { |
| data->callback(name.str, value.str, data->userdata); |
| |
| } else { |
| free(output); |
| output = strdup(value.str); |
| } |
| |
| if(data->name) { |
| goto cleanup; |
| } |
| } |
| break; |
| default: |
| pcmk_dbus_type_check(reply, &sv, DBUS_TYPE_STRING, __FUNCTION__, __LINE__); |
| } |
| dbus_message_iter_next (&sv); |
| } |
| |
| dbus_message_iter_next (&dict); |
| } |
| |
| if(data->name && data->callback) { |
| crm_trace("No value for property %s[%s]", data->object, data->name); |
| data->callback(data->name, NULL, data->userdata); |
| } |
| |
| cleanup: |
| free_db_getall_data(data); |
| return output; |
| } |
| |
| static void |
| pcmk_dbus_lookup_cb(DBusPendingCall *pending, void *user_data) |
| { |
| DBusMessage *reply = NULL; |
| char *value = NULL; |
| |
| if(pending) { |
| reply = dbus_pending_call_steal_reply(pending); |
| } |
| |
| value = pcmk_dbus_lookup_result(reply, user_data); |
| free(value); |
| |
| if(reply) { |
| dbus_message_unref(reply); |
| } |
| } |
| |
| char * |
| pcmk_dbus_get_property(DBusConnection *connection, const char *target, |
| const char *obj, const gchar * iface, const char *name, |
| void (*callback)(const char *name, const char *value, void *userdata), |
| void *userdata, DBusPendingCall **pending, int timeout) |
| { |
| DBusMessage *msg; |
| const char *method = "GetAll"; |
| char *output = NULL; |
| struct db_getall_data *query_data = NULL; |
| |
| crm_debug("Calling: %s on %s", method, target); |
| msg = dbus_message_new_method_call(target, // target for the method call |
| obj, // object to call on |
| BUS_PROPERTY_IFACE, // interface to call on |
| method); // method name |
| if (NULL == msg) { |
| crm_err("Call to %s failed: No message", method); |
| return NULL; |
| } |
| |
| CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_STRING, &iface, DBUS_TYPE_INVALID)); |
| |
| query_data = malloc(sizeof(struct db_getall_data)); |
| if(query_data == NULL) { |
| crm_err("Call to %s failed: malloc failed", method); |
| return NULL; |
| } |
| |
| query_data->target = strdup(target); |
| query_data->object = strdup(obj); |
| query_data->callback = callback; |
| query_data->userdata = userdata; |
| query_data->name = NULL; |
| |
| if(name) { |
| query_data->name = strdup(name); |
| } |
| |
| if (query_data->callback) { |
| DBusPendingCall *local_pending; |
| |
| local_pending = pcmk_dbus_send(msg, connection, pcmk_dbus_lookup_cb, |
| query_data, timeout); |
| if (local_pending == NULL) { |
| // pcmk_dbus_lookup_cb() was not called in this case |
| free_db_getall_data(query_data); |
| query_data = NULL; |
| } |
| |
| if (pending) { |
| *pending = local_pending; |
| } |
| |
| } else { |
| DBusMessage *reply = pcmk_dbus_send_recv(msg, connection, NULL, timeout); |
| |
| output = pcmk_dbus_lookup_result(reply, query_data); |
| |
| if(reply) { |
| dbus_message_unref(reply); |
| } |
| } |
| |
| dbus_message_unref(msg); |
| |
| return output; |
| } |
| |
| static void |
| pcmk_dbus_connection_dispatch_status(DBusConnection *connection, |
| DBusDispatchStatus new_status, void *data) |
| { |
| crm_trace("New status %d for connection %p", new_status, connection); |
| if (new_status == DBUS_DISPATCH_DATA_REMAINS){ |
| conn_dispatches = g_list_prepend(conn_dispatches, connection); |
| } |
| } |
| |
| static void |
| pcmk_dbus_connections_dispatch() |
| { |
| GList *gIter = NULL; |
| |
| for (gIter = conn_dispatches; gIter != NULL; gIter = gIter->next) { |
| DBusConnection *connection = gIter->data; |
| |
| while (dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS) { |
| crm_trace("Dispatching for connection %p", connection); |
| dbus_connection_dispatch(connection); |
| } |
| } |
| |
| g_list_free(conn_dispatches); |
| conn_dispatches = NULL; |
| } |
| |
| /* Copied from dbus-watch.c */ |
| |
| static const char* |
| dbus_watch_flags_to_string(int flags) |
| { |
| const char *watch_type; |
| |
| if ((flags & DBUS_WATCH_READABLE) && (flags & DBUS_WATCH_WRITABLE)) { |
| watch_type = "readwrite"; |
| } else if (flags & DBUS_WATCH_READABLE) { |
| watch_type = "read"; |
| } else if (flags & DBUS_WATCH_WRITABLE) { |
| watch_type = "write"; |
| } else { |
| watch_type = "not read or write"; |
| } |
| return watch_type; |
| } |
| |
| static int |
| pcmk_dbus_watch_dispatch(gpointer userdata) |
| { |
| bool oom = FALSE; |
| DBusWatch *watch = userdata; |
| int flags = dbus_watch_get_flags(watch); |
| bool enabled = dbus_watch_get_enabled (watch); |
| mainloop_io_t *client = dbus_watch_get_data(watch); |
| |
| crm_trace("Dispatching client %p: %s", client, dbus_watch_flags_to_string(flags)); |
| if (enabled && (flags & (DBUS_WATCH_READABLE|DBUS_WATCH_WRITABLE))) { |
| oom = !dbus_watch_handle(watch, flags); |
| |
| } else if(enabled) { |
| oom = !dbus_watch_handle(watch, DBUS_WATCH_ERROR); |
| } |
| |
| if(flags != dbus_watch_get_flags(watch)) { |
| flags = dbus_watch_get_flags(watch); |
| crm_trace("Dispatched client %p: %s (%d)", client, |
| dbus_watch_flags_to_string(flags), flags); |
| } |
| |
| if(oom) { |
| crm_err("DBus encountered OOM while attempting to dispatch %p (%s)", |
| client, dbus_watch_flags_to_string(flags)); |
| |
| } else { |
| pcmk_dbus_connections_dispatch(); |
| } |
| |
| return 0; |
| } |
| |
| static void |
| pcmk_dbus_watch_destroy(gpointer userdata) |
| { |
| mainloop_io_t *client = dbus_watch_get_data(userdata); |
| crm_trace("Destroyed %p", client); |
| } |
| |
| |
| struct mainloop_fd_callbacks pcmk_dbus_cb = { |
| .dispatch = pcmk_dbus_watch_dispatch, |
| .destroy = pcmk_dbus_watch_destroy, |
| }; |
| |
| static dbus_bool_t |
| pcmk_dbus_watch_add(DBusWatch *watch, void *data) |
| { |
| int fd = dbus_watch_get_unix_fd(watch); |
| |
| mainloop_io_t *client = mainloop_add_fd( |
| "dbus", G_PRIORITY_DEFAULT, fd, watch, &pcmk_dbus_cb); |
| |
| crm_trace("Added watch %p with fd=%d to client %p", watch, fd, client); |
| dbus_watch_set_data(watch, client, NULL); |
| return TRUE; |
| } |
| |
| static void |
| pcmk_dbus_watch_toggle(DBusWatch *watch, void *data) |
| { |
| mainloop_io_t *client = dbus_watch_get_data(watch); |
| crm_notice("DBus client %p is now %s", |
| client, (dbus_watch_get_enabled(watch)? "enabled" : "disabled")); |
| } |
| |
| |
| static void |
| pcmk_dbus_watch_remove(DBusWatch *watch, void *data) |
| { |
| mainloop_io_t *client = dbus_watch_get_data(watch); |
| |
| crm_trace("Removed client %p (%p)", client, data); |
| mainloop_del_fd(client); |
| } |
| |
| static gboolean |
| pcmk_dbus_timeout_dispatch(gpointer data) |
| { |
| crm_info("Timeout %p expired", data); |
| dbus_timeout_handle(data); |
| return FALSE; |
| } |
| |
| static dbus_bool_t |
| pcmk_dbus_timeout_add(DBusTimeout *timeout, void *data) |
| { |
| guint id = g_timeout_add(dbus_timeout_get_interval(timeout), |
| pcmk_dbus_timeout_dispatch, timeout); |
| |
| crm_trace("Adding timeout %p (%d)", timeout, dbus_timeout_get_interval(timeout)); |
| |
| if(id) { |
| dbus_timeout_set_data(timeout, GUINT_TO_POINTER(id), NULL); |
| } |
| return TRUE; |
| } |
| |
| static void |
| pcmk_dbus_timeout_remove(DBusTimeout *timeout, void *data) |
| { |
| void *vid = dbus_timeout_get_data(timeout); |
| guint id = GPOINTER_TO_UINT(vid); |
| |
| crm_trace("Removing timeout %p (%p)", timeout, data); |
| |
| if(id) { |
| g_source_remove(id); |
| dbus_timeout_set_data(timeout, 0, NULL); |
| } |
| } |
| |
| static void |
| pcmk_dbus_timeout_toggle(DBusTimeout *timeout, void *data) |
| { |
| bool enabled = dbus_timeout_get_enabled(timeout); |
| |
| crm_trace("Toggling timeout for %p to %s", timeout, enabled?"off":"on"); |
| |
| if(enabled) { |
| pcmk_dbus_timeout_add(timeout, data); |
| } else { |
| pcmk_dbus_timeout_remove(timeout, data); |
| } |
| } |
| |
| /* Inspired by http://www.kolej.mff.cuni.cz/~vesej3am/devel/dbus-select.c */ |
| |
| void |
| pcmk_dbus_connection_setup_with_select(DBusConnection *c) |
| { |
| dbus_connection_set_exit_on_disconnect(c, FALSE); |
| dbus_connection_set_timeout_functions(c, pcmk_dbus_timeout_add, |
| pcmk_dbus_timeout_remove, |
| pcmk_dbus_timeout_toggle, NULL, NULL); |
| dbus_connection_set_watch_functions(c, pcmk_dbus_watch_add, |
| pcmk_dbus_watch_remove, |
| pcmk_dbus_watch_toggle, NULL, NULL); |
| dbus_connection_set_dispatch_status_function(c, pcmk_dbus_connection_dispatch_status, NULL, NULL); |
| pcmk_dbus_connection_dispatch_status(c, dbus_connection_get_dispatch_status(c), NULL); |
| } |
