static int get_modems(DBusConnection *conn)
{
DBusMessage *msg;
DBusPendingCall *call;
msg = dbus_message_new_method_call(OFONO_SERVICE, "/",
OFONO_MANAGER_INTERFACE, "GetModems");
if (msg == NULL)
return -ENOMEM;
dbus_message_set_auto_start(msg, FALSE);
g_print("getting modems\n");
if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
dbus_message_unref(msg);
return -EIO;
}
dbus_message_unref(msg);
if (call == NULL)
return -EINVAL;
dbus_pending_call_set_notify(call, get_modems_reply, conn, NULL);
dbus_pending_call_unref(call);
return 0;
}
void
hd_utils_open_link (const gchar *link)
{
DBusConnection *conn = NULL;
DBusMessage *msg = NULL;
g_debug ("%s: opening %s", __FUNCTION__, link);
conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
if (!conn)
{
g_critical ("%s: Couldn't connect to session bus", __FUNCTION__);
return;
}
msg = dbus_message_new_method_call (DBUS_BROWSER_SERVICE,
DBUS_BROWSER_PATH,
DBUS_BROWSER_SERVICE,
DBUS_BROWSER_METHOD);
if (!msg)
return;
dbus_message_set_auto_start (msg, TRUE);
dbus_message_set_no_reply (msg, TRUE);
dbus_message_append_args (msg, DBUS_TYPE_STRING, &link, DBUS_TYPE_INVALID);
dbus_connection_send (conn, msg, NULL);
dbus_message_unref (msg);
}
static int disconnect_network(struct supplicant_task *task)
{
DBusMessage *message, *reply;
DBusError error;
_DBG_SUPPLICANT("task %p", task);
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
SUPPLICANT_INTF ".Interface", "disconnect");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection,
message, -1, &error);
if (reply == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Failed to disconnect network");
dbus_message_unref(message);
return -EIO;
}
dbus_message_unref(message);
dbus_message_unref(reply);
return 0;
}
/**
* thunar_dbus_client_terminate:
* @error : Return location for errors or %NULL.
*
* Tells a running Thunar instance, connected to the D-BUS
* session bus, to terminate immediately.
*
* Return value: %TRUE if any instance was terminated, else
* %FALSE and @error is set.
**/
gboolean
thunar_dbus_client_terminate (GError **error)
{
DBusConnection *connection;
DBusMessage *message;
DBusMessage *result;
DBusError derror;
_thunar_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* initialize the DBusError struct */
dbus_error_init (&derror);
/* try to connect to the session bus */
connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
if (G_UNLIKELY (connection == NULL))
{
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* generate the LaunchFiles() method (disable activation!) */
message = dbus_message_new_method_call ("org.xfce.Thunar", "/org/xfce/FileManager", "org.xfce.Thunar", "Terminate");
dbus_message_set_auto_start (message, FALSE);
/* send the message and release our references on connection and message */
result = dbus_connection_send_with_reply_and_block (connection, message, -1, &derror);
dbus_message_unref (message);
/* check if no reply was received */
if (G_UNLIKELY (result == NULL))
{
/* check if there was nothing to terminate */
if (dbus_error_has_name (&derror, DBUS_ERROR_NAME_HAS_NO_OWNER))
{
dbus_error_free (&derror);
return TRUE;
}
/* Looks like there was a real error */
dbus_set_g_error (error, &derror);
dbus_error_free (&derror);
return FALSE;
}
/* but maybe we received an error */
if (dbus_message_get_type (result) == DBUS_MESSAGE_TYPE_ERROR)
{
dbus_set_error_from_message (&derror, result);
dbus_set_g_error (error, &derror);
dbus_message_unref (result);
dbus_error_free (&derror);
return FALSE;
}
/* let's asume that it worked */
dbus_message_unref (result);
return TRUE;
}
vector <string> method_call_wait_reply (const gchar * bus_name, const gchar * object, const gchar * interface, const gchar * method, bool silent)
// This equals: dbus-send --print-reply --dest=bus_name object interface.method
// It calls the method, and returns the reply.
{
// Assemble the method call.
DBusMessage *dbus_message;
dbus_message = dbus_message_new_method_call(bus_name, object, interface, method);
dbus_message_set_auto_start(dbus_message, TRUE);
// Send dbus_message and handle the reply.
DBusError error;
dbus_error_init(&error);
int timeout = 10; // Timeout in milliseconds.
DBusMessage *dbus_reply;
dbus_reply = dbus_connection_send_with_reply_and_block(con, dbus_message, timeout, &error);
if (dbus_error_is_set(&error) && !silent) {
string err(error.name);
err.append(": ");
err.append(error.message);
printf ("%s\n", err.c_str());
fflush (stdout);
}
if (dbus_reply) {
retrieve_message(dbus_reply);
dbus_message_unref(dbus_reply);
}
// Free the message.
dbus_message_unref(dbus_message);
// Return reply.
vector <string> method_reply (string_reply);
string_reply.clear();
return method_reply;
}
static void add_adapter(DBusConnection *conn, const char *path)
{
DBusMessage *message;
DBusPendingCall *call;
DBG("path %s", path);
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_ADAPTER_INTERFACE, GET_PROPERTIES);
if (message == NULL)
return;
dbus_message_set_auto_start(message, FALSE);
if (dbus_connection_send_with_reply(conn, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to get adapter properties for %s", path);
goto done;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
goto done;
}
dbus_pending_call_set_notify(call, adapter_properties_reply,
g_strdup(path), g_free);
done:
dbus_message_unref(message);
}
static int get_calls(struct modem_data *modem)
{
DBusMessage *msg;
DBusPendingCall *call;
msg = dbus_message_new_method_call(OFONO_SERVICE, modem->path,
OFONO_CALLMANAGER_INTERFACE, "GetCalls");
if (msg == NULL)
return -ENOMEM;
dbus_message_set_auto_start(msg, FALSE);
g_print("getting calls (%s)\n", modem->path);
if (dbus_connection_send_with_reply(modem->conn, msg,
&call, -1) == FALSE) {
dbus_message_unref(msg);
return -EIO;
}
dbus_message_unref(msg);
if (call == NULL)
return -EINVAL;
dbus_pending_call_set_notify(call, get_calls_reply, modem, NULL);
dbus_pending_call_unref(call);
return 0;
}
static void add_network(const char *path)
{
DBusMessage *message;
DBusPendingCall *call;
DBG("path %s", path);
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_DEVICE_INTERFACE, GET_PROPERTIES);
if (!message)
return;
dbus_message_set_auto_start(message, FALSE);
if (!dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT)) {
connman_error("Failed to get network properties for %s", path);
goto done;
}
if (!call) {
connman_error("D-Bus connection not available");
goto done;
}
dbus_pending_call_set_notify(call, network_properties_reply,
g_strdup(path), g_free);
done:
dbus_message_unref(message);
}
int bind_dbus_message_set_auto_start( lua_State * const _L)
{
utils_check_nargs( _L, 2);
DBusMessage * const message = cast_to_dbus_message( _L, 1);
int const autostart = lua_toboolean( _L, 2);
dbus_message_set_auto_start( message, autostart);
return 0;
}
static int ldbus_message_set_auto_start(lua_State *L) {
DBusMessage *message = check_DBusMessage(L, 1);
int auto_start = (luaL_checktype(L, 2, LUA_TBOOLEAN), lua_toboolean(L, 2));
dbus_message_set_auto_start(message, auto_start);
return 0;
}
int supplicant_dbus_method_call(const char *path,
const char *interface, const char *method,
supplicant_dbus_setup_function setup,
supplicant_dbus_result_function function,
void *user_data)
{
struct method_call_data *data;
DBusMessage *message;
DBusMessageIter iter;
DBusPendingCall *call;
if (connection == NULL)
return -EINVAL;
if (path == NULL || interface == NULL || method == NULL)
return -EINVAL;
data = dbus_malloc0(sizeof(*data));
if (data == NULL)
return -ENOMEM;
message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
interface, method);
if (message == NULL) {
dbus_free(data);
return -ENOMEM;
}
dbus_message_set_auto_start(message, FALSE);
dbus_message_iter_init_append(message, &iter);
if (setup != NULL)
setup(&iter, user_data);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT) == FALSE) {
dbus_message_unref(message);
dbus_free(data);
return -EIO;
}
if (call == NULL) {
dbus_message_unref(message);
dbus_free(data);
return -EIO;
}
data->function = function;
data->user_data = user_data;
dbus_pending_call_set_notify(call, method_call_reply,
data, dbus_free);
dbus_message_unref(message);
return 0;
}
static int add_network(struct supplicant_task *task)
{
DBusMessage *message, *reply;
DBusError error;
const char *path;
_DBG_SUPPLICANT("task %p", task);
if (task->netpath != NULL)
return -EALREADY;
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
SUPPLICANT_INTF ".Interface", "addNetwork");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection,
message, -1, &error);
if (reply == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Failed to add network");
dbus_message_unref(message);
return -EIO;
}
dbus_message_unref(message);
dbus_error_init(&error);
if (dbus_message_get_args(reply, &error, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID) == FALSE) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Wrong arguments for network");
dbus_message_unref(reply);
return -EIO;
}
_DBG_SUPPLICANT("path %s", path);
task->netpath = g_strdup(path);
dbus_message_unref(reply);
return 0;
}
int supplicant_dbus_property_get(const char *path, const char *interface,
const char *method,
supplicant_dbus_property_function function,
void *user_data)
{
struct property_get_data *data;
DBusMessage *message;
DBusPendingCall *call;
if (connection == NULL)
return -EINVAL;
if (path == NULL || interface == NULL || method == NULL)
return -EINVAL;
data = dbus_malloc0(sizeof(*data));
if (data == NULL)
return -ENOMEM;
message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
DBUS_INTERFACE_PROPERTIES, "Get");
if (message == NULL) {
dbus_free(data);
return -ENOMEM;
}
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &method, NULL);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT) == FALSE) {
dbus_message_unref(message);
dbus_free(data);
return -EIO;
}
if (call == NULL) {
dbus_message_unref(message);
dbus_free(data);
return -EIO;
}
data->function = function;
data->user_data = user_data;
dbus_pending_call_set_notify(call, property_get_reply,
data, dbus_free);
dbus_message_unref(message);
return 0;
}
static void
hd_bookmark_shortcut_activate_service (const gchar *url)
{
DBusMessage *msg = NULL;
DBusError error;
DBusConnection *conn;
if (!url)
{
g_warning ("%s. Cannot open empty URL.", __FUNCTION__);
return;
}
/* FIXME use libosso? */
dbus_error_init (&error);
conn = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error))
{
g_warning ("could not get session D-Bus: %s", error.message);
dbus_error_free (&error);
return;
}
msg = dbus_message_new_method_call (BROWSER_INTERFACE,
BROWSER_PATH,
BROWSER_INTERFACE,
LOAD_URL_METHOD);
if (msg == NULL)
{
g_warning ("failed to create message");
return;
}
dbus_message_set_auto_start (msg, TRUE);
dbus_message_set_no_reply (msg, TRUE);
if (!dbus_message_append_args (msg,
DBUS_TYPE_STRING, &url,
DBUS_TYPE_INVALID))
{
g_warning ("failed to add url argument");
return;
}
if (!dbus_connection_send (conn, msg, NULL))
g_warning ("dbus_connection_send failed");
dbus_message_unref (msg);
}
static int add_interface(struct supplicant_task *task)
{
const char *driver = connman_option_get_string("wifi");
DBusMessage *message;
DBusMessageIter array, dict;
DBusPendingCall *call;
_DBG_SUPPLICANT("task %p", task);
message = dbus_message_new_method_call(SUPPLICANT_NAME, SUPPLICANT_PATH,
SUPPLICANT_INTF, "addInterface");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_iter_init_append(message, &array);
dbus_message_iter_append_basic(&array,
DBUS_TYPE_STRING, &task->ifname);
dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
connman_dbus_dict_append_variant(&dict, "driver",
DBUS_TYPE_STRING, &driver);
dbus_message_iter_close_container(&array, &dict);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to add interface");
dbus_message_unref(message);
return -EIO;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EIO;
}
dbus_pending_call_set_notify(call, add_interface_reply, task, NULL);
dbus_message_unref(message);
return -EINPROGRESS;
}
static void get_properties(struct supplicant_task *task)
{
DBusMessage *message;
char *path;
path = g_slist_nth_data(task->scan_results, 0);
if (path == NULL)
goto noscan;
message = dbus_message_new_method_call(SUPPLICANT_NAME, path,
SUPPLICANT_INTF ".BSSID",
"properties");
task->scan_results = g_slist_remove(task->scan_results, path);
g_free(path);
if (message == NULL)
goto noscan;
dbus_message_set_auto_start(message, FALSE);
if (dbus_connection_send_with_reply(connection, message,
&task->result_call, TIMEOUT) == FALSE) {
connman_error("Failed to get network properties");
dbus_message_unref(message);
goto noscan;
}
if (task->result_call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
goto noscan;
}
dbus_pending_call_set_notify(task->result_call,
properties_reply, task, NULL);
dbus_message_unref(message);
return;
noscan:
task->result_call = NULL;
if (task->scanning == TRUE) {
connman_device_set_scanning(task->device, FALSE);
task->scanning = FALSE;
}
}
static void server_register(const char *path, const char *uuid,
struct connman_technology *technology,
const char *bridge, connman_bool_t enabled)
{
DBusMessage *message;
DBusPendingCall *call;
char *command;
DBG("path %s enabled %d", path, enabled);
command = enabled ? REGISTER : UNREGISTER;
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_NETWORK_SERVER, command);
if (message == NULL)
return;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_STRING, &uuid,
DBUS_TYPE_INVALID);
if (enabled == TRUE)
dbus_message_append_args(message, DBUS_TYPE_STRING, &bridge,
DBUS_TYPE_INVALID);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to enable PAN server");
dbus_message_unref(message);
return;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return;
}
if (enabled == TRUE)
dbus_pending_call_set_notify(call, server_register_reply,
technology, NULL);
else
dbus_pending_call_set_notify(call, server_unregister_reply,
technology, NULL);
dbus_message_unref(message);
}
DBusMessage*
big_dbus_proxy_new_method_call(BigDBusProxy* proxy, const char* method_name)
{
DBusMessage* message;
message = dbus_message_new_method_call(proxy->bus_name, proxy->object_path,
proxy->iface, method_name);
if (message == NULL)
g_error("no memory");
/* We don't want methods to auto-start services... if a service
* needs starting or restarting, we want to do so explicitly so we
* can do it in an orderly and predictable way.
*/
dbus_message_set_auto_start(message, FALSE);
return message;
}
static int clear_user_data(void)
{
const char *dest = ALARMD_SERVICE;
const char *path = ALARMD_PATH;
const char *iface = ALARMD_INTERFACE;
const char *name = "clear_user_data";
dbus_int32_t nak = -1;
DBusConnection *con = 0;
DBusMessage *msg = 0;
DBusMessage *rsp = 0;
DBusError err = DBUS_ERROR_INIT;
if( (con = dbus_bus_get(DBUS_BUS_SYSTEM, &err)) == 0 )
{
goto cleanup;
}
if( (msg = dbus_message_new_method_call(dest, path, iface, name)) == 0 )
{
goto cleanup;
}
dbus_message_set_auto_start(msg, FALSE);
if( !(rsp = dbus_connection_send_with_reply_and_block(con, msg, -1, &err)) )
{
goto cleanup;
}
dbus_message_get_args(rsp, &err,
DBUS_TYPE_INT32, &nak,
DBUS_TYPE_INVALID);
cleanup:
if( rsp != 0 ) dbus_message_unref(rsp);
if( msg != 0 ) dbus_message_unref(msg);
if( con != 0 ) dbus_connection_unref(con);
dbus_error_free(&err);
return (int)nak;
}
gchar*
gkd_dbus_singleton_control (void)
{
DBusError derr = DBUS_ERROR_INIT;
DBusMessage *msg, *reply;
gchar *control = NULL;
const char *path;
/* If tried to aquire the service must have failed */
g_return_val_if_fail (!acquired_service, NULL);
if (!connect_to_session_bus ())
return NULL;
msg = dbus_message_new_method_call (GNOME_KEYRING_DAEMON_SERVICE,
GNOME_KEYRING_DAEMON_PATH,
GNOME_KEYRING_DAEMON_INTERFACE,
"GetControlDirectory");
g_return_val_if_fail (msg, NULL);
dbus_message_set_auto_start (msg, FALSE);
/* Send message and get a handle for a reply */
reply = dbus_connection_send_with_reply_and_block (dbus_conn, msg, 1000, &derr);
dbus_message_unref (msg);
if (!reply) {
if (!dbus_error_has_name (&derr, "org.freedesktop.DBus.Error.NameHasNoOwner"))
g_message ("couldn't communicate with already running daemon: %s", derr.message);
dbus_error_free (&derr);
return NULL;
}
/* Get out our client path */
if (!dbus_message_get_args (reply, &derr, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID)) {
g_message ("couldn't parse response from already running daemon: %s", derr.message);
dbus_error_free (&derr);
control = NULL;
} else {
control = g_strdup (path);
}
dbus_message_unref (reply);
return control;
}
static int pan_disconnect(struct connman_network *network)
{
const char *path = connman_network_get_string(network, "Path");
DBusMessage *message;
DBusPendingCall *call;
DBG("network %p", network);
if (!path)
return -EINVAL;
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_NETWORK_INTERFACE, DISCONNECT);
if (!message)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_INVALID);
if (!dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT)) {
connman_error("Failed to disconnect service");
dbus_message_unref(message);
return -EINVAL;
}
if (!call) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EINVAL;
}
connman_network_ref(network);
connman_network_set_associating(network, false);
dbus_pending_call_set_notify(call, disconnect_reply, g_strdup(path),
g_free);
dbus_message_unref(message);
return 0;
}
static int change_powered(DBusConnection *conn, dbus_bool_t powered)
{
DBG("");
DBusMessage *message = dbus_message_new_method_call(JOLLA_SERVICE, JOLLA_DEVICE_PATH,
FREEDESKTOP_PROPERTIES_INTERFACE,
FREEDESKTOP_PROPERTIES_SET);
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
DBusMessageIter iter;
dbus_message_iter_init_append(message, &iter);
const char *string = JOLLA_DEVICE_INTERFACE;
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &string);
string = POWERED_NAME;
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &string);
DBusMessageIter value;
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, DBUS_TYPE_BOOLEAN_AS_STRING, &value);
dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
dbus_message_iter_close_container(&iter, &value);
DBusPendingCall *call;
if (dbus_connection_send_with_reply(conn, message, &call, TIMEOUT) == FALSE) {
connman_error("Failed to change Powered property");
dbus_message_unref(message);
return -EINVAL;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EINVAL;
}
dbus_pending_call_set_notify(call, powered_reply, 0, 0);
dbus_message_unref(message);
return -EINPROGRESS;
}
static int remove_interface(struct supplicant_task *task)
{
DBusMessage *message;
DBusPendingCall *call;
_DBG_SUPPLICANT("task %p", task);
#if 0
if (task->created == FALSE) {
connman_device_set_powered(task->device, FALSE);
return 0;
}
#endif
message = dbus_message_new_method_call(SUPPLICANT_NAME, SUPPLICANT_PATH,
SUPPLICANT_INTF, "removeInterface");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->path,
DBUS_TYPE_INVALID);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to remove interface");
dbus_message_unref(message);
return -EIO;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EIO;
}
dbus_pending_call_set_notify(call, remove_interface_reply, task, NULL);
dbus_message_unref(message);
return -EINPROGRESS;
}
static int change_powered(DBusConnection *conn, const char *path,
dbus_bool_t powered)
{
DBusMessage *message;
DBusMessageIter iter;
DBusPendingCall *call;
DBG("");
if (path == NULL)
return -EINVAL;
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_ADAPTER_INTERFACE, SET_PROPERTY);
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_iter_init_append(message, &iter);
connman_dbus_property_append_basic(&iter, "Powered",
DBUS_TYPE_BOOLEAN, &powered);
if (dbus_connection_send_with_reply(conn, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to change Powered property");
dbus_message_unref(message);
return -EINVAL;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EINVAL;
}
dbus_pending_call_set_notify(call, powered_reply,
g_strdup(path), g_free);
dbus_message_unref(message);
return -EINPROGRESS;
}
static int remove_network(struct supplicant_task *task)
{
DBusMessage *message, *reply;
DBusError error;
_DBG_SUPPLICANT("task %p", task);
if (task->netpath == NULL)
return -EINVAL;
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
SUPPLICANT_INTF ".Interface", "removeNetwork");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &task->netpath,
DBUS_TYPE_INVALID);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection,
message, -1, &error);
if (reply == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Failed to remove network");
dbus_message_unref(message);
return -EIO;
}
dbus_message_unref(message);
dbus_message_unref(reply);
g_free(task->netpath);
task->netpath = NULL;
return 0;
}
DBusMessage *
HippoDBusIpcProviderImpl::createMethodMessage(const char *name)
{
g_assert(busUniqueName_ != NULL);
DBusMessage *message = dbus_message_new_method_call(busUniqueName_,
HIPPO_DBUS_STACKER_PATH,
HIPPO_DBUS_STACKER_INTERFACE,
name);
if (message == NULL)
g_error("out of memory");
/* we don't want to start a client if none is already there
* (we wouldn't anyway for now since there's no .service file
* for the mugshot client)
*/
dbus_message_set_auto_start(message, FALSE);
return message;
}
static int pan_connect(struct connman_network *network)
{
const char *path = connman_network_get_string(network, "Path");
const char *uuid = "nap";
DBusMessage *message;
DBusPendingCall *call;
DBG("network %p", network);
if (path == NULL)
return -EINVAL;
message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
BLUEZ_NETWORK_INTERFACE, CONNECT);
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_STRING, &uuid,
DBUS_TYPE_INVALID);
if (dbus_connection_send_with_reply(connection, message,
&call, TIMEOUT * 10) == FALSE) {
connman_error("Failed to connect service");
dbus_message_unref(message);
return -EINVAL;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EINVAL;
}
dbus_pending_call_set_notify(call, connect_reply, network, NULL);
dbus_message_unref(message);
return -EINPROGRESS;
}
static void bluetooth_connect(DBusConnection *conn, void *user_data)
{
DBusMessage *message;
DBusPendingCall *call;
DBG("connection %p", conn);
bluetooth_devices = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, unregister_device);
bluetooth_networks = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, remove_network);
pending_networks = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, remove_pending_networks);
message = dbus_message_new_method_call(BLUEZ_SERVICE, "/",
BLUEZ_MANAGER_INTERFACE, LIST_ADAPTERS);
if (message == NULL)
return;
dbus_message_set_auto_start(message, FALSE);
if (dbus_connection_send_with_reply(conn, message,
&call, TIMEOUT) == FALSE) {
connman_error("Failed to get Bluetooth adapters");
goto done;
}
if (call == NULL) {
connman_error("D-Bus connection not available");
goto done;
}
dbus_pending_call_set_notify(call, list_adapters_reply, NULL, NULL);
done:
dbus_message_unref(message);
}
static int initiate_scan(struct supplicant_task *task)
{
DBusMessage *message;
_DBG_SUPPLICANT("task %p", task);
if (task->path == NULL)
return -EINVAL;
if (task->scan_call != NULL)
return -EALREADY;
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
SUPPLICANT_INTF ".Interface", "scan");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
if (dbus_connection_send_with_reply(connection, message,
&task->scan_call, TIMEOUT) == FALSE) {
connman_error("Failed to initiate scan");
dbus_message_unref(message);
return -EIO;
}
if (task->scan_call == NULL) {
connman_error("D-Bus connection not available");
dbus_message_unref(message);
return -EIO;
}
dbus_pending_call_set_notify(task->scan_call, scan_reply, task, NULL);
dbus_message_unref(message);
return -EINPROGRESS;
}
static int set_ap_scan(struct supplicant_task *task)
{
DBusMessage *message, *reply;
DBusError error;
guint32 ap_scan = 1;
_DBG_SUPPLICANT("task %p", task);
message = dbus_message_new_method_call(SUPPLICANT_NAME, task->path,
SUPPLICANT_INTF ".Interface", "setAPScan");
if (message == NULL)
return -ENOMEM;
dbus_message_set_auto_start(message, FALSE);
dbus_message_append_args(message, DBUS_TYPE_UINT32, &ap_scan,
DBUS_TYPE_INVALID);
dbus_error_init(&error);
reply = dbus_connection_send_with_reply_and_block(connection,
message, -1, &error);
if (reply == NULL) {
if (dbus_error_is_set(&error) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
} else
connman_error("Failed to set AP scan");
dbus_message_unref(message);
return -EIO;
}
dbus_message_unref(message);
dbus_message_unref(reply);
return 0;
}