static DBusMessage * properties_handler(DBusMessage *message,
struct wpa_dbus_object_desc *obj_dsc)
{
DBusMessageIter iter;
char *interface;
const char *method;
method = dbus_message_get_member(message);
dbus_message_iter_init(message, &iter);
if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
!os_strncmp(WPA_DBUS_PROPERTIES_SET, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) ||
!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
/* First argument: interface name (DBUS_TYPE_STRING) */
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
{
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
NULL);
}
dbus_message_iter_get_basic(&iter, &interface);
if (!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
/* GetAll */
return properties_get_all(message, interface, obj_dsc);
}
/* Get or Set */
return properties_get_or_set(message, &iter, interface,
obj_dsc);
}
return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD,
NULL);
}
static DBusHandlerResult
handle_run_hello_from_self (DBusConnection *connection,
DBusMessage *message)
{
DBusError error;
DBusMessage *reply, *self_message;
DBusPendingCall *pcall;
char *s;
dbus_error_init (&error);
if (!dbus_message_get_args (message,
&error,
DBUS_TYPE_STRING, &s,
DBUS_TYPE_INVALID))
{
reply = dbus_message_new_error (message,
error.name,
error.message);
if (reply == NULL)
die ("No memory\n");
if (!dbus_connection_send (connection, reply, NULL))
die ("No memory\n");
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
printf ("Sending HelloFromSelf\n");
self_message = dbus_message_new_method_call ("org.freedesktop.DBus.GLib.TestEchoService",
"/org/freedesktop/DBus/GLib/TestSuite",
"org.freedesktop.DBus.GLib.TestSuite",
"HelloFromSelf");
if (self_message == NULL)
die ("No memory");
if (!dbus_connection_send_with_reply (connection, self_message, &pcall, -1))
die("No memory");
dbus_message_ref (message);
if (!dbus_pending_call_set_notify (pcall, check_hello_from_self_reply, (void *)message, NULL))
die("No memory");
printf ("Sent HelloFromSelf\n");
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
handle_echo (DBusConnection *connection,
DBusMessage *message)
{
DBusError error;
DBusMessage *reply;
char *s;
_dbus_verbose ("sending reply to Echo method\n");
dbus_error_init (&error);
if (!dbus_message_get_args (message,
&error,
DBUS_TYPE_STRING, &s,
DBUS_TYPE_INVALID))
{
reply = dbus_message_new_error (message,
error.name,
error.message);
if (reply == NULL)
die ("No memory\n");
if (!dbus_connection_send (connection, reply, NULL))
die ("No memory\n");
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
reply = dbus_message_new_method_return (message);
if (reply == NULL)
die ("No memory\n");
if (!dbus_message_append_args (reply,
DBUS_TYPE_STRING, &s,
DBUS_TYPE_INVALID))
die ("No memory");
if (!dbus_connection_send (connection, reply, NULL))
die ("No memory\n");
fprintf (stderr, "Echo service echoed string: \"%s\"\n", s);
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
/**
* wpas_dbus_new_invalid_opts_error - Return a new invalid options error message
* @message: Pointer to incoming dbus message this error refers to
* Returns: a dbus error message
*
* Convenience function to create and return an invalid options error
*/
DBusMessage * wpas_dbus_new_invalid_opts_error(DBusMessage *message,
const char *arg)
{
DBusMessage *reply;
reply = dbus_message_new_error(message, WPAS_ERROR_INVALID_OPTS,
"Did not receive correct message "
"arguments.");
if (arg != NULL)
dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
DBUS_TYPE_INVALID);
return reply;
}
/**
* wpas_dbus_iface_wps_pin - Establish the PIN number of the enrollee
* @message: Pointer to incoming dbus message
* @wpa_s: %wpa_supplicant data structure
* Returns: A dbus message containing a UINT32 indicating success (1) or
* failure (0)
*
* Handler function for "wpsPin" method call
*/
DBusMessage * wpas_dbus_iface_wps_pin(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
char *arg_bssid;
char *pin = NULL;
u8 bssid[ETH_ALEN], *_bssid = NULL;
int ret = 0;
if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg_bssid,
DBUS_TYPE_STRING, &pin, DBUS_TYPE_INVALID))
return wpas_dbus_new_invalid_opts_error(message, NULL);
if (!os_strcmp(arg_bssid, "any"))
_bssid = NULL;
else if (!hwaddr_aton(arg_bssid, bssid))
_bssid = bssid;
else {
return wpas_dbus_new_invalid_opts_error(message,
"Invalid BSSID");
}
if (os_strlen(pin) > 0)
ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0,
DEV_PW_DEFAULT);
else
ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0,
DEV_PW_DEFAULT);
if (ret < 0) {
return dbus_message_new_error(message,
WPAS_ERROR_WPS_PIN_ERROR,
"Could not init PIN");
}
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
if (ret == 0) {
dbus_message_append_args(reply, DBUS_TYPE_STRING, &pin,
DBUS_TYPE_INVALID);
} else {
char npin[9];
os_snprintf(npin, sizeof(npin), "%08d", ret);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &npin,
DBUS_TYPE_INVALID);
}
return reply;
}
DBusHandlerResult error_unknown_method(DBusConnection *conn, DBusMessage *msg)
{
char error[128];
const char *signature = dbus_message_get_signature(msg);
const char *method = dbus_message_get_member(msg);
const char *interface = dbus_message_get_interface(msg);
snprintf(error, 128, "Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist",
method, signature, interface);
return send_message_and_unref(conn,
dbus_message_new_error(msg, ERROR_INTERFACE ".UnknownMethod",
error));
}
static int
message_reply(lua_State *T)
{
DBusConnection *conn = bus_unbox(T, lua_upvalueindex(1));
struct message_object *m;
DBusMessage *msg;
DBusMessage *reply;
if (conn == NULL) /* connection closed */
return 0;
m = lua_touserdata(T, lua_upvalueindex(2));
msg = m->msg;
if (msg == NULL)
return luaL_error(T, "send reply called twice");
m->msg = NULL;
/* check if the method returned an error */
if (lua_gettop(T) > 0 && lua_isnil(T, 1)) {
const char *name = luaL_checkstring(T, 2);
const char *message = luaL_optstring(T, 3, NULL);
if (message && message[0] == '\0')
message = NULL;
reply = dbus_message_new_error(msg, name, message);
dbus_message_unref(msg);
if (reply == NULL)
return 0;
} else {
const char *signature = luaL_optstring(T, 1, NULL);
reply = dbus_message_new_method_return(msg);
dbus_message_unref(msg);
if (reply == NULL)
return 0;
if (signature && signature[0] != '\0' &&
lem_dbus_add_arguments(T, 2, signature, reply)) {
dbus_message_unref(reply);
/* add_arguments() pushes its own error message */
return luaL_error(T, "%s", lua_tostring(T, -1));
}
}
dbus_connection_send(conn, reply, NULL);
dbus_message_unref(reply);
return 0;
}
static DBusMessage * properties_set(DBusMessage *message,
const struct wpa_dbus_property_desc *dsc,
void *user_data)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusError error;
if (os_strcmp(dbus_message_get_signature(message), "ssv")) {
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
NULL);
}
if (dsc->setter == NULL) {
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Property is read-only");
}
dbus_message_iter_init(message, &iter);
/* Skip the interface name and the property name */
dbus_message_iter_next(&iter);
dbus_message_iter_next(&iter);
/* Iter will now point to the property's new value */
dbus_error_init(&error);
if (dsc->setter(&iter, &error, user_data) == TRUE) {
/* Success */
reply = dbus_message_new_method_return(message);
} else {
reply = wpas_dbus_reply_new_from_error(
message, &error, DBUS_ERROR_FAILED,
"Failed to set property");
dbus_error_free(&error);
}
return reply;
}
static DBusMessage * msg_method_handler(DBusMessage *message,
struct wpa_dbus_object_desc *obj_dsc)
{
const struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods;
const char *method;
const char *msg_interface;
method = dbus_message_get_member(message);
msg_interface = dbus_message_get_interface(message);
/* try match call to any registered method */
while (method_dsc && method_dsc->dbus_method) {
/* compare method names and interfaces */
if (!os_strncmp(method_dsc->dbus_method, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) &&
!os_strncmp(method_dsc->dbus_interface, msg_interface,
WPAS_DBUS_INTERFACE_MAX))
break;
method_dsc++;
}
if (method_dsc == NULL || method_dsc->dbus_method == NULL) {
wpa_printf(MSG_DEBUG, "no method handler for %s.%s on %s",
msg_interface, method,
dbus_message_get_path(message));
return dbus_message_new_error(message,
DBUS_ERROR_UNKNOWN_METHOD, NULL);
}
if (!is_signature_correct(message, method_dsc)) {
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
NULL);
}
return method_dsc->method_handler(message,
obj_dsc->user_data);
}
static DBusHandlerResult handle_get(DBusConnection *conn, DBusMessage *msg, pa_dbusobj_server_lookup *sl) {
DBusHandlerResult r = DBUS_HANDLER_RESULT_HANDLED;
const char* interface;
const char* property;
DBusMessage *reply = NULL;
pa_assert(conn);
pa_assert(msg);
pa_assert(sl);
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &property, DBUS_TYPE_INVALID)) {
if (!(reply = dbus_message_new_error(msg, DBUS_ERROR_INVALID_ARGS, "Invalid arguments"))) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!dbus_connection_send(conn, reply, NULL)) {
r = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto finish;
}
r = DBUS_HANDLER_RESULT_HANDLED;
goto finish;
}
if (*interface && !pa_streq(interface, INTERFACE)) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!pa_streq(property, "Address")) {
if (!(reply = dbus_message_new_error_printf(msg, PA_DBUS_ERROR_NO_SUCH_PROPERTY, "%s: No such property", property))) {
r = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
goto finish;
}
if (!dbus_connection_send(conn, reply, NULL)) {
r = DBUS_HANDLER_RESULT_NEED_MEMORY;
goto finish;
}
r = DBUS_HANDLER_RESULT_HANDLED;
goto finish;
}
r = handle_get_address(conn, msg, sl);
finish:
if (reply)
dbus_message_unref(reply);
return r;
}
static DBusMessage*
service_method_unlock_with_master_password (GkdSecretService *self, DBusMessage *message)
{
DBusError derr = DBUS_ERROR_INIT;
GkdSecretSecret *master;
GError *error = NULL;
GckObject *collection;
DBusMessageIter iter;
DBusMessage *reply;
const gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "o(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
dbus_message_iter_get_basic (&iter, &path);
dbus_message_iter_next (&iter);
master = gkd_secret_secret_parse (self, message, &iter, &derr);
if (master == NULL)
return gkd_secret_error_to_reply (message, &derr);
/* Make sure we have such a collection */
collection = gkd_secret_objects_lookup_collection (self->objects,
dbus_message_get_sender (message),
path);
/* No such collection */
if (collection == NULL) {
reply = dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT,
"The collection does not exist");
/* Success */
} else if (gkd_secret_unlock_with_secret (collection, master, &error)) {
reply = dbus_message_new_method_return (message);
gkd_secret_objects_emit_collection_locked (self->objects, collection);
/* Failure */
} else {
reply = gkd_secret_propagate_error (message, "Couldn't unlock collection", error);
}
gkd_secret_secret_free (master);
if (collection)
g_object_unref (collection);
return reply;
}
gboolean g_dbus_send_error_valist(DBusConnection *connection,
DBusMessage *message, const char *name,
const char *format, va_list args)
{
DBusMessage *error;
char str[1024];
vsnprintf(str, sizeof(str), format, args);
error = dbus_message_new_error(message, name, str);
if (error == NULL)
return FALSE;
return g_dbus_send_message(connection, error);
}
/**
* Create a new D-Bus error message, with proper error checking
* will exit the mainloop if an error occurs
*
* @param message The DBusMessage that caused the error message to be sent
* @param error The message to send
* @return A new DBusMessage
*/
static DBusMessage *dbus_new_error(DBusMessage *const message,
const gchar *const error)
{
DBusMessage *error_msg;
if ((error_msg = dbus_message_new_error(message, error,
NULL)) == NULL) {
mce_log(LL_CRIT, "No memory for new D-Bus error message!");
// FIXME: this is not how one should exit from mainloop
mce_quit_mainloop();
exit(EXIT_FAILURE);
}
return error_msg;
}
static DBusMessage*
handle_forget (void *object,
DBusMessage *message,
DBusError *error)
{
const char *notification_path;
const char *resource_id;
DBusMessageIter iter;
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("First argument should be an object path (notification_path)"));
}
dbus_message_iter_get_basic(&iter, ¬ification_path);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Second argument should be a string (resource_id)"));
}
dbus_message_iter_get_basic(&iter, &resource_id);
dbus_message_iter_next (&iter);
if (dbus_message_iter_has_next(&iter))
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Too many arguments"));
/* FIXME: Do the forget; change the NULL return to an ACK if we aren't doing something async */
return NULL;
}
static DBusMessage*
service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message)
{
GckBuilder builder = GCK_BUILDER_INIT;
DBusError derr = DBUS_ERROR_INIT;
DBusMessageIter iter, array;
DBusMessage *reply = NULL;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
GError *error = NULL;
gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, &builder)) {
gck_builder_clear (&builder);
return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
}
dbus_message_iter_next (&iter);
secret = gkd_secret_secret_parse (self, message, &iter, &derr);
if (secret == NULL) {
gck_builder_clear (&builder);
return gkd_secret_error_to_reply (message, &derr);
}
gck_builder_add_boolean (&builder, CKA_TOKEN, TRUE);
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
path = gkd_secret_create_with_secret (attrs, secret, &error);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL)
return gkd_secret_propagate_error (message, "Couldn't create collection", error);
/* Notify the callers that a collection was created */
gkd_secret_service_emit_collection_created (self, path);
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
/* Helper function - internal use only */
DBusHandlerResult error_common_reply(DBusConnection *conn, DBusMessage *msg,
const char *name, const char *descr)
{
DBusMessage *derr;
if (!conn || !msg)
return DBUS_HANDLER_RESULT_HANDLED;
derr = dbus_message_new_error(msg, name, descr);
if (!derr)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
g_dbus_send_message(conn, derr);
return DBUS_HANDLER_RESULT_HANDLED;
}
int bind_dbus_message_new_error( lua_State * const _L)
{
utils_check_nargs( _L, 3);
DBusMessage * const reply_to = cast_to_dbus_message( _L, 1);
char const * const error_name = lua_tostring( _L, 2);
char const * const error_message = lua_tostring( _L, 3);
DBusMessage *message = dbus_message_new_error( reply_to, error_name, error_message);
if( message == 0x0)
{
lua_pushnil( _L);
return 1;
}
else
{
return push_dbus_message( _L, message);
}
}
EAPI Eldbus_Message *
eldbus_message_error_new(const Eldbus_Message *msg, const char *error_name, const char *error_msg)
{
Eldbus_Message *reply;
ELDBUS_MESSAGE_CHECK_RETVAL(msg, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(error_name, NULL);
EINA_SAFETY_ON_NULL_RETURN_VAL(error_msg, NULL);
reply = eldbus_message_new(EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(reply, NULL);
reply->dbus_msg = dbus_message_new_error(msg->dbus_msg,
error_name, error_msg);
dbus_message_iter_init(reply->dbus_msg, &reply->iterator->dbus_iterator);
return reply;
}
static DBusMessage*
handle_show_browser(HippoDBusStacker *dbus,
DBusMessage *message)
{
DBusMessage *reply;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_INVALID)) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Expected no arguments"));
}
hippo_stack_manager_show_browser(hippo_stacker_app_get_stack(hippo_get_stacker_app()),
FALSE);
reply = dbus_message_new_method_return(message);
return reply;
}
gboolean
gconfd_dbus_check_in_shutdown (DBusConnection *connection,
DBusMessage *message)
{
if (gconfd_in_shutdown ())
{
DBusMessage *reply;
reply = dbus_message_new_error (message,
GCONF_DBUS_ERROR_IN_SHUTDOWN,
_("The GConf daemon is currently shutting down."));
dbus_connection_send (connection, reply, NULL);
dbus_message_unref (reply);
return TRUE;
}
else
return FALSE;
}
static DBusMessage*
service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message)
{
DBusError derr = DBUS_ERROR_INIT;
DBusMessageIter iter, array;
DBusMessage *reply = NULL;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gck_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) {
gck_attributes_unref (attrs);
return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
}
dbus_message_iter_next (&iter);
secret = gkd_secret_secret_parse (self, message, &iter, &derr);
if (secret == NULL) {
gck_attributes_unref (attrs);
return gkd_secret_error_to_reply (message, &derr);
}
gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
path = gkd_secret_create_with_secret (attrs, secret, &derr);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL)
return gkd_secret_error_to_reply (message, &derr);
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
/**
* wpas_dbus_iface_add_network - Add a new configured network
* @message: Pointer to incoming dbus message
* @wpa_s: wpa_supplicant structure for a network interface
* Returns: A dbus message containing the object path of the new network
*
* Handler function for "addNetwork" method call of a network interface.
*/
DBusMessage * wpas_dbus_iface_add_network(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
struct wpa_ssid *ssid;
char *path = NULL;
path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (path == NULL) {
perror("wpas_dbus_iface_scan_results[dbus]: out of "
"memory.");
wpa_printf(MSG_ERROR, "dbus control interface: not "
"enough memory to send scan results "
"signal.");
goto out;
}
ssid = wpa_config_add_network(wpa_s->conf);
if (ssid == NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_ADD_NETWORK_ERROR,
"wpa_supplicant could not add "
"a network on this interface.");
goto out;
}
ssid->disabled = 1;
wpa_config_set_network_defaults(ssid);
/* Construct the object path for this network. */
snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
"%s/" WPAS_DBUS_NETWORKS_PART "/%d",
wpa_supplicant_get_dbus_path(wpa_s),
ssid->id);
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
&path, DBUS_TYPE_INVALID);
out:
free(path);
return reply;
}
dboost::dbus_ptr<DBusMessage> timer_adaptor::call_add_timer(dboost_test::timer* t, DBusMessage* m)
{
std::clog << __FUNCTION__ << std::endl;
assert(t && m);
long param0;
dboost::iserializer is(m);
is & param0;
try {
long r = t->add_timer(param0);
dboost::dbus_ptr<DBusMessage> result(DBOOST_CHECK(dbus_message_new_method_return(m)));
dboost::oserializer os(result.get());
os & r ;
return result;
}
catch (const dboost_test::wrong_timeout_exception& e) {
dboost::dbus_ptr<DBusMessage> result(DBOOST_CHECK(dbus_message_new_error(m, "org.dboost.dboost_test.wrong_timeout_exception", e.what())));
return result;
}
}
void pa_dbus_send_error(DBusConnection *c, DBusMessage *in_reply_to, const char *name, const char *format, ...) {
va_list ap;
char *message;
DBusMessage *reply = NULL;
pa_assert(c);
pa_assert(in_reply_to);
pa_assert(name);
pa_assert(format);
va_start(ap, format);
message = pa_vsprintf_malloc(format, ap);
va_end(ap);
pa_assert_se((reply = dbus_message_new_error(in_reply_to, name, message)));
pa_assert_se(dbus_connection_send(c, reply, NULL));
dbus_message_unref(reply);
pa_xfree(message);
}
static DBusMessage*
handle_get_all_preference_names(void *object,
DBusMessage *message,
DBusError *error)
{
HippoSettings *settings;
DBusConnection *dbus_connection;
DBusMessageIter iter, array_iter;
char **names;
int i;
DBusMessage *reply;
dbus_connection = object;
settings = get_and_ref_settings(dbus_connection);
if (!hippo_settings_get_ready(settings)) {
g_object_unref(G_OBJECT(settings));
return dbus_message_new_error(message, HIPPO_DBUS_PREFS_ERROR_NOT_READY,
_("Have not yet connected to server, can't get preference names"));
}
reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s",
&array_iter);
names = hippo_settings_get_all_names(settings);
for (i = 0; names[i] != NULL; ++i) {
dbus_message_iter_append_basic(&array_iter, DBUS_TYPE_STRING, &names[i]);
}
g_strfreev(names);
dbus_message_iter_close_container(&iter, &array_iter);
g_object_unref(settings);
return reply;
}
/**
* get_all_properties - Responds for GetAll properties calls on object
* @message: Message with GetAll call
* @interface: interface name which properties will be returned
* @property_dsc: list of object's properties
* Returns: Message with dict of variants as argument with properties values
*
* Iterates over all properties registered with object and execute getters
* of those, which are readable and which interface matches interface
* specified as argument. Returned message contains one dict argument
* with properties names as keys and theirs values as values.
*/
static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
struct wpa_dbus_object_desc *obj_dsc)
{
DBusMessage *reply;
DBusMessageIter iter, dict_iter;
DBusError error;
reply = dbus_message_new_method_return(message);
if (reply == NULL) {
wpa_printf(MSG_ERROR, "%s: out of memory creating dbus reply",
__func__);
return NULL;
}
dbus_message_iter_init_append(reply, &iter);
if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
wpa_printf(MSG_ERROR, "%s: out of memory creating reply",
__func__);
dbus_message_unref(reply);
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
"out of memory");
return reply;
}
dbus_error_init(&error);
if (!fill_dict_with_properties(&dict_iter, obj_dsc->properties,
interface, obj_dsc->user_data, &error))
{
dbus_message_unref(reply);
reply = wpas_dbus_reply_new_from_error(message, &error,
DBUS_ERROR_INVALID_ARGS,
"No readable properties"
" in this interface");
dbus_error_free(&error);
return reply;
}
wpa_dbus_dict_close_write(&iter, &dict_iter);
return reply;
}
int sbus_request_fail_and_finish(struct sbus_request *dbus_req,
const DBusError *error)
{
DBusMessage *reply;
int ret;
if (error == NULL) {
sbus_request_finish(dbus_req, NULL);
return ENOMEM;
}
reply = dbus_message_new_error(dbus_req->message, error->name, error->message);
if (!reply) {
DEBUG(SSSDBG_CRIT_FAILURE, "Out of memory allocating DBus message\n");
sbus_request_finish(dbus_req, NULL);
return ENOMEM;
}
ret = sbus_request_finish(dbus_req, reply);
dbus_message_unref(reply);
return ret;
}
/* Callback: "a message is received to a registered object path" */
static DBusHandlerResult message_received(DBusConnection* conn, DBusMessage* msg, void* data)
{
const char* member = dbus_message_get_member(msg);
VERB1 log("%s(method:'%s')", __func__, member);
set_client_name(dbus_message_get_sender(msg));
DBusMessage* reply = dbus_message_new_method_return(msg);
int r = -1;
if (strcmp(member, "DeleteDebugDump") == 0)
r = handle_DeleteDebugDump(msg, reply);
// NB: C++ binding also handles "Introspect" method, which returns a string.
// It was sending "dummy" introspection answer whick looks like this:
// "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
// "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
// "<node>\n"
// "</node>\n"
// Apart from a warning from abrt-gui, just sending error back works as well.
// NB2: we may want to handle "Disconnected" here too.
if (r < 0)
{
/* handle_XXX experienced an error (and did not send any reply) */
dbus_message_unref(reply);
if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL)
{
/* Create and send error reply */
reply = dbus_message_new_error(msg, DBUS_ERROR_FAILED, "not supported");
if (!reply)
die_out_of_memory();
send_flush_and_unref(reply);
}
}
set_client_name(NULL);
return DBUS_HANDLER_RESULT_HANDLED;
}
/**
* wpas_dbus_global_get_interface - Get the object path for an interface name
* @message: Pointer to incoming dbus message
* @global: %wpa_supplicant global data structure
* Returns: The object path of the interface object,
* or a dbus error message with more information
*
* Handler function for "getInterface" method call. Handles requests
* by dbus clients for the object path of an specific network interface.
*/
DBusMessage * wpas_dbus_global_get_interface(DBusMessage *message,
struct wpa_global *global)
{
DBusMessage *reply = NULL;
const char *ifname;
const char *path;
struct wpa_supplicant *wpa_s;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &ifname,
DBUS_TYPE_INVALID)) {
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
wpa_s = wpa_supplicant_get_iface(global, ifname);
if (wpa_s == NULL) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
}
path = wpa_supplicant_get_dbus_path(wpa_s);
if (path == NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_INTERNAL_ERROR,
"an internal error occurred "
"getting the interface.");
goto out;
}
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
out:
return reply;
}
static void
cb_pending(DBusPendingCall *dbus_pending, void *user_data)
{
Eldbus_Message *msg;
Eldbus_Pending *pending = user_data;
if (!dbus_pending_call_get_completed(dbus_pending))
{
INF("timeout to pending %p", pending);
dbus_pending_call_cancel(dbus_pending);
msg = eldbus_message_error_new(pending->msg_sent,
ELDBUS_ERROR_PENDING_TIMEOUT,
"This call was not completed in time.");
eldbus_pending_dispatch(pending, msg);
return;
}
msg = eldbus_message_new(EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN(msg);
msg->dbus_msg = dbus_pending_call_steal_reply(dbus_pending);
if (!msg->dbus_msg)
{
EINA_SAFETY_ON_NULL_GOTO(pending->cb, cleanup);
msg->dbus_msg = dbus_message_new_error(NULL,
"org.enlightenment.DBus.NoReply",
"There was no reply to this method call.");
EINA_SAFETY_ON_NULL_GOTO(msg->dbus_msg, cleanup);
}
dbus_message_iter_init(msg->dbus_msg, &msg->iterator->dbus_iterator);
eldbus_pending_dispatch(pending, msg);
return;
cleanup:
eldbus_message_unref(msg);
}