void g_dbus_client_unref(GDBusClient *client)
{
unsigned int i;
if (client == NULL)
return;
if (__sync_sub_and_fetch(&client->ref_count, 1) > 0)
return;
if (client->pending_call != NULL) {
dbus_pending_call_cancel(client->pending_call);
dbus_pending_call_unref(client->pending_call);
}
if (client->get_objects_call != NULL) {
dbus_pending_call_cancel(client->get_objects_call);
dbus_pending_call_unref(client->get_objects_call);
}
for (i = 0; i < client->match_rules->len; i++) {
modify_match(client->dbus_conn, "RemoveMatch",
g_ptr_array_index(client->match_rules, i));
}
g_ptr_array_free(client->match_rules, TRUE);
dbus_connection_remove_filter(client->dbus_conn,
message_filter, client);
g_list_free_full(client->proxy_list, proxy_free);
/*
* Don't call disconn_func twice if disconnection
* was previously reported.
*/
if (client->disconn_func && client->connected)
client->disconn_func(client->dbus_conn, client->disconn_data);
g_dbus_remove_watch(client->dbus_conn, client->watch);
g_dbus_remove_watch(client->dbus_conn, client->added_watch);
g_dbus_remove_watch(client->dbus_conn, client->removed_watch);
dbus_connection_unref(client->dbus_conn);
g_free(client->service_name);
g_free(client->base_path);
g_free(client->root_path);
g_free(client);
}
static void wicd_interface_cb(DBusPendingCall *pending, void *user_data)
{
struct connline_context *context = user_data;
char **properties = NULL;
struct wicd_dbus *wicd;
DBusMessageIter arg;
DBusMessage *reply;
const char *iface;
if (dbus_pending_call_get_completed(pending) == FALSE)
return;
wicd = context->backend_data;
wicd->call = NULL;
reply = dbus_pending_call_steal_reply(pending);
if (reply == NULL)
goto error;
if (dbus_message_iter_init(reply, &arg) == FALSE)
goto error;
if (connline_dbus_get_basic(&arg, DBUS_TYPE_STRING, &iface) != 0)
goto error;
properties = insert_into_property_list(properties, "bearer",
connline_bearer_to_string(wicd->bearer));
properties = insert_into_property_list(properties, "interface", iface);
properties = insert_into_property_list(properties,
"address", wicd->ip);
if (properties != NULL)
__connline_call_property_callback(context, properties);
dbus_message_unref(reply);
dbus_pending_call_unref(pending);
return;
error:
if (reply != NULL)
dbus_message_unref(reply);
dbus_pending_call_unref(pending);
wicd_backend_data_cleanup(context);
__connline_call_error_callback(context, false);
}
static gboolean
operation_unref (gpointer data)
{
GkrOperation *op = data;
g_assert (op);
if (!g_atomic_int_dec_and_test (&op->refs))
return FALSE;
if (op->pending) {
dbus_pending_call_cancel (op->pending);
dbus_pending_call_unref (op->pending);
op->pending = NULL;
}
operation_clear_callbacks (op);
if (op->conn) {
dbus_connection_unref (op->conn);
op->conn = NULL;
}
g_slice_free (GkrOperation, op);
return TRUE;
}
/**
* send data for dbus method call
*/
static int networkmanager_dbus_send(DBusMessage** msg, DBusConnection* dbus_connection)
{
DBusPendingCall* pending;
int success;
// send dbus message
// -1 is the default time out. Other time outs can be configured in milli seconds.
success = dbus_connection_send_with_reply(dbus_connection, *msg, &pending, -1);
if(!success)
{
printf("networkmanager_dbus_send dbus send error\n");
return 0;
}
if(pending == NULL)
{
printf ("networkmanager_dbus_send dbus calling error\n");
return 0;
}
dbus_connection_flush(dbus_connection);
dbus_message_unref(*msg);
dbus_pending_call_block(pending);
*msg = dbus_pending_call_steal_reply(pending);
dbus_pending_call_unref(pending);
if(*msg == NULL)
return 0;
return 1;
}
static gboolean modify_match(DBusConnection *conn, const char *member,
const char *rule)
{
DBusMessage *msg;
DBusPendingCall *call;
msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS, member);
if (msg == NULL)
return FALSE;
dbus_message_append_args(msg, DBUS_TYPE_STRING, &rule,
DBUS_TYPE_INVALID);
if (g_dbus_send_message_with_reply(conn, msg, &call, -1) == FALSE) {
dbus_message_unref(msg);
return FALSE;
}
dbus_pending_call_set_notify(call, modify_match_reply, NULL, NULL);
dbus_pending_call_unref(call);
dbus_message_unref(msg);
return TRUE;
}
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;
}
void
nsNetworkManagerListener::RegisterWithConnection(DBusConnection* connection) {
DBusError error;
dbus_error_init(&error);
dbus_bus_add_match(connection,
"type='signal',"
"interface='" NM_DBUS_INTERFACE "',"
"sender='" NM_DBUS_SERVICE "',"
"path='" NM_DBUS_PATH "'", &error);
mOK = !dbus_error_is_set(&error);
dbus_error_free(&error);
if (!mOK)
return;
DBusMessage* msg =
dbus_message_new_method_call(NM_DBUS_SERVICE, NM_DBUS_PATH,
NM_DBUS_INTERFACE, "state");
if (!msg) {
mOK = PR_FALSE;
return;
}
DBusPendingCall* reply = mDBUS->SendWithReply(this, msg);
if (!reply) {
mOK = PR_FALSE;
return;
}
dbus_pending_call_set_notify(reply, NetworkStatusNotify, this, NULL);
dbus_pending_call_unref(reply);
}
/**
* mafw_proxy_renderer_playback_cb:
* @pending_call: A DBusPendingCall that is the reply for a playback call
* @user_data: AsyncParams*
*
* Receives the resulting DBus reply message for a playback call and calls
* the assigned callback function to pass the actual result to the UI layer.
*/
static void mafw_proxy_renderer_playback_cb(DBusPendingCall *pending_call,
gpointer user_data)
{
AsyncParams *ap;
DBusMessage *reply;
GError *error;
ap = (AsyncParams*) user_data;
g_assert(ap != NULL);
reply = dbus_pending_call_steal_reply(pending_call);
error = mafw_dbus_is_error(reply, MAFW_RENDERER_ERROR);
if (error == NULL) {
if (ap->callback)
((MafwRendererPlaybackCB) ap->callback)
(ap->renderer, ap->user_data, NULL);
} else {
if (ap->callback)
((MafwRendererPlaybackCB) ap->callback)
(ap->renderer, ap->user_data, error);
g_error_free(error);
}
dbus_message_unref(reply);
dbus_pending_call_unref(pending_call);
}
static void get_connection_unix_user_reply(DBusPendingCall *call,
void *user_data)
{
struct callback_data *data = user_data;
connman_dbus_get_connection_unix_user_cb_t cb = data->cb;
DBusMessageIter iter;
DBusMessage *reply;
int err = 0;
unsigned int uid;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
DBG("Failed to retrieve UID");
err = -EIO;
goto done;
}
if (!dbus_message_has_signature(reply, "u")) {
DBG("Message signature is wrong");
err = -EINVAL;
goto done;
}
dbus_message_iter_init(reply, &iter);
dbus_message_iter_get_basic(&iter, &uid);
done:
(*cb)(uid, data->user_data, err);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static void property_get_reply(DBusPendingCall *call, void *user_data)
{
struct property_get_data *data = user_data;
DBusMessage *reply;
DBusMessageIter iter;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
goto done;
if (dbus_message_iter_init(reply, &iter) == FALSE)
goto done;
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT) {
DBusMessageIter variant;
dbus_message_iter_recurse(&iter, &variant);
if (data->function != NULL)
data->function(NULL, &variant, data->user_data);
}
done:
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
/** Initiate asynchronous connman properties query
*
* @return TRUE if the method call was initiated, or FALSE in case of errors
*/
static gboolean xconnman_get_properties(void)
{
gboolean res = FALSE;
DBusMessage *req = 0;
DBusPendingCall *pc = 0;
if( !(req = dbus_message_new_method_call(CONNMAN_SERVICE,
CONNMAN_OBJECT_PATH,
CONNMAN_INTERFACE,
CONNMAN_GET_PROPERTIES_REQ)) )
goto EXIT;
if( !dbus_connection_send_with_reply(connman_bus, req, &pc, -1) )
goto EXIT;
if( !dbus_pending_call_set_notify(pc, xconnman_get_properties_cb, 0, 0) )
goto EXIT;
// success
res = TRUE;
EXIT:
if( pc ) dbus_pending_call_unref(pc);
if( req ) dbus_message_unref(req);
return res;
}
static void
_libnm_glib_nm_state_cb (DBusPendingCall *pcall, void *user_data)
{
DBusMessage * reply;
libnm_glib_ctx * ctx = (libnm_glib_ctx *) user_data;
NMState nm_state;
g_return_if_fail (pcall != NULL);
g_return_if_fail (ctx != NULL);
if (!(reply = dbus_pending_call_steal_reply (pcall)))
goto out;
if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
{
DBusError err;
dbus_error_init (&err);
dbus_set_error_from_message (&err, reply);
fprintf (stderr, "%s: dbus returned an error.\n (%s) %s\n", __func__, err.name, err.message);
dbus_error_free (&err);
dbus_message_unref (reply);
goto out;
}
if (dbus_message_get_args (reply, NULL, DBUS_TYPE_UINT32, &nm_state, DBUS_TYPE_INVALID))
_libnm_glib_update_state (ctx, nm_state);
dbus_message_unref (reply);
out:
dbus_pending_call_unref (pcall);
}
static void property_get_all_reply(DBusPendingCall *call, void *user_data)
{
struct property_get_data *data = user_data;
DBusMessage *reply;
DBusMessageIter iter;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
goto done;
if (dbus_message_iter_init(reply, &iter) == FALSE)
goto done;
supplicant_dbus_property_foreach(&iter, data->function,
data->user_data);
if (data->function != NULL)
data->function(NULL, NULL, data->user_data);
done:
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static DBusMessage *excute_method_a(DBusConnection *conn, DBusMessage* msg)
{
DBusPendingCall* pending;
if (NULL == msg) {
printf("Message NULL\n");
return NULL;
}
if (!dbus_connection_send_with_reply(conn, msg, &pending, -1))
{
printf("Out Of Memory!");
return NULL;
}
if (NULL == pending) {
printf("Pending Call Null");
return NULL;
}
dbus_connection_flush(conn);
dbus_message_unref(msg);
dbus_pending_call_block(pending);
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
printf("Reply Null\n");
}
dbus_pending_call_unref(pending);
return msg;
}
static void disconnect_reply(DBusPendingCall *call, void *user_data)
{
DBusMessage *reply;
DBusError error;
if (dbus_pending_call_get_completed(call) == FALSE)
return;
DBG("user %p", user_data);
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply) == TRUE) {
connman_error("%s", error.message);
dbus_error_free(&error);
goto done;
}
done:
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static void remove_connection_reply(DBusPendingCall *call, void *user_data)
{
DBusMessage *reply;
DBusError error;
if (dbus_pending_call_get_completed(call) == FALSE)
return;
DBG("");
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply) == TRUE) {
/*
* If the returned error is NotFound, it means that we
* have actually removed the provider in vpnd already.
*/
if (dbus_error_has_name(&error, CONNMAN_ERROR_INTERFACE
".NotFound") == FALSE)
connman_error("%s", error.message);
dbus_error_free(&error);
}
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
void FcitxNotificationItemRegister(FcitxNotificationItem* notificationitem)
{
if (!notificationitem->serviceName) {
FcitxLog(ERROR, "This should not happen, please report bug.");
return;
}
DBusMessage *message =
dbus_message_new_method_call(NOTIFICATION_WATCHER_DBUS_ADDR,
NOTIFICATION_WATCHER_DBUS_OBJ,
NOTIFICATION_WATCHER_DBUS_IFACE,
"RegisterStatusNotifierItem");
dbus_message_append_args(message,
DBUS_TYPE_STRING, ¬ificationitem->serviceName,
DBUS_TYPE_INVALID);
DBusPendingCall *call = NULL;
dbus_bool_t reply =
dbus_connection_send_with_reply(notificationitem->conn, message,
&call, DBUS_TIMEOUT_USE_DEFAULT);
dbus_message_unref(message);
if (reply == TRUE) {
dbus_pending_call_set_notify(call,
FcitxNotificationItemRegisterSuccess,
notificationitem,
NULL);
dbus_pending_call_unref(call);
}
}
/** Initiate asynchronous connman service name ownership query
*
* @return TRUE if the method call was initiated, or FALSE in case of errors
*/
static gboolean xconnman_check_service(void)
{
gboolean res = FALSE;
DBusMessage *req = 0;
DBusPendingCall *pc = 0;
const char *name = CONNMAN_SERVICE;
if( !(req = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"GetNameOwner")) )
goto EXIT;
if( !dbus_message_append_args(req,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID) )
goto EXIT;
if( !dbus_connection_send_with_reply(connman_bus, req, &pc, -1) )
goto EXIT;
if( !dbus_pending_call_set_notify(pc, xconnman_check_service_cb, 0, 0) )
goto EXIT;
// success
res = TRUE;
EXIT:
if( pc ) dbus_pending_call_unref(pc);
if( req ) dbus_message_unref(req);
return res;
}
static void register_external_service(gpointer a, gpointer b)
{
DBusConnection *conn = b;
const char *path = a;
DBusMessage *msg;
DBusPendingCall *call;
DBusMessageIter iter, dict;
msg = dbus_message_new_method_call("org.bluez", "/org/bluez",
GATT_MGR_IFACE, "RegisterService");
if (!msg) {
printf("Couldn't allocate D-Bus message\n");
return;
}
dbus_message_iter_init_append(msg, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &dict);
/* TODO: Add options dictionary */
dbus_message_iter_close_container(&iter, &dict);
if (!g_dbus_send_message_with_reply(conn, msg, &call, -1)) {
dbus_message_unref(msg);
return;
}
dbus_pending_call_set_notify(call, register_external_service_reply,
NULL, NULL);
dbus_pending_call_unref(call);
}
static void finalize_call(DBusPendingCall *call)
{
if (!dbus_pending_call_get_completed(call))
dbus_pending_call_cancel(call);
dbus_pending_call_unref(call);
}
static void set_get_position_cb(DBusPendingCall *pending_call,
gpointer user_data)
{
AsyncParams *ap;
DBusMessage *reply;
GError *error;
ap = (AsyncParams*) user_data;
g_assert(ap != NULL);
reply = dbus_pending_call_steal_reply(pending_call);
error = mafw_dbus_is_error(reply, MAFW_RENDERER_ERROR);
if (error == NULL) {
guint seconds = 0;
mafw_dbus_parse(reply, DBUS_TYPE_UINT32, &seconds);
if (ap->callback != NULL)
((MafwRendererPositionCB) ap->callback)(ap->renderer,
seconds,
ap->user_data,
NULL);
} else {
if (ap->callback != NULL)
((MafwRendererPositionCB) ap->callback)(ap->renderer,
0,
ap->user_data,
error);
g_error_free(error);
}
dbus_message_unref(reply);
dbus_pending_call_unref(pending_call);
}
static void get_managed_objects_reply(DBusPendingCall *call, void *user_data)
{
GDBusClient *client = user_data;
DBusMessage *reply = dbus_pending_call_steal_reply(call);
DBusError error;
g_dbus_client_ref(client);
dbus_error_init(&error);
if (dbus_set_error_from_message(&error, reply) == TRUE) {
dbus_error_free(&error);
goto done;
}
parse_managed_objects(client, reply);
done:
if (client->ready)
client->ready(client, client->ready_data);
dbus_message_unref(reply);
dbus_pending_call_unref(client->get_objects_call);
client->get_objects_call = NULL;
g_dbus_client_unref(client);
}
static void selinux_get_context_reply(DBusPendingCall *call, void *user_data)
{
struct callback_data *data = user_data;
connman_dbus_get_context_cb_t cb = data->cb;
DBusMessage *reply;
unsigned char *context = NULL;
int err = 0;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
DBG("Failed to retrieve SELinux context");
err = -EIO;
goto done;
}
if (!dbus_message_has_signature(reply, "ay")) {
DBG("Message signature is wrong");
err = -EINVAL;
goto done;
}
context = parse_context(reply);
done:
(*cb)(context, data->user_data, err);
g_free(context);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static void agent_receive_message(DBusPendingCall *call, void *user_data)
{
struct connman_agent *queue_data = user_data;
DBusMessage *reply;
int err;
DBG("waiting for %p received %p", agent_request, queue_data);
if (agent_request != queue_data) {
connman_error("Agent callback expected %p got %p",
agent_request, queue_data);
return;
}
reply = dbus_pending_call_steal_reply(call);
dbus_pending_call_unref(call);
queue_data->call = NULL;
if (dbus_message_is_error(reply,
"org.freedesktop.DBus.Error.Timeout") == TRUE ||
dbus_message_is_error(reply,
"org.freedesktop.DBus.Error.TimedOut") == TRUE) {
agent_send_cancel(queue_data->user_context);
}
queue_data->callback(reply, queue_data->user_data);
dbus_message_unref(reply);
agent_data_free(queue_data);
agent_request = NULL;
err = agent_send_next_request();
if (err < 0)
DBG("send next request failed (%s/%d)", strerror(-err), -err);
}
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 _dbus_reply_notify_handler(DBusPendingCall *pending, void *user_data)
{
bridge_request_t *self = (bridge_request_t*)user_data;
bridge_request_call_dbus_json(self, dbus_pending_call_steal_reply(pending));
dbus_pending_call_unref(pending);
}
static int add_record(const char *path, const char *xml,
struct bluetooth_service *service)
{
DBusMessage *msg;
DBusPendingCall *call;
int ret = 0;
msg = dbus_message_new_method_call("org.bluez", path,
"org.bluez.Service", "AddRecord");
dbus_message_append_args(msg, DBUS_TYPE_STRING, &xml,
DBUS_TYPE_INVALID);
if (dbus_connection_send_with_reply(connection,
msg, &call, -1) == FALSE) {
ret = -1;
goto failed;
}
dbus_pending_call_set_notify(call, add_record_reply, service, NULL);
dbus_pending_call_unref(call);
failed:
dbus_message_unref(msg);
return ret;
}
static void recv_dbus_reply(DBusPendingCall *pending, void *user_data)
{
DBusMessage *msg;
char *reply;
MRP_UNUSED(user_data);
if ((msg = dbus_pending_call_steal_reply(pending)) != NULL) {
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING,
&reply, DBUS_TYPE_INVALID)) {
info("DBUS test: got reply #%d '%s'", dbus_test.nack, reply);
dbus_test.nack++;
}
dbus_message_unref(msg);
}
dbus_pending_call_unref(pending);
if (dbus_test.nack >= cfg.ndbus_method) {
char dummy[256];
cfg.nrunning--;
/* block until the client is done */
if (read(dbus_test.pipe[0], dummy, sizeof(dummy)) < 0) {
/* just ignore it... */
}
}
}
static void
systemd_daemon_reload_complete(DBusPendingCall *pending, void *user_data)
{
DBusError error;
DBusMessage *reply = NULL;
unsigned int reload_count = GPOINTER_TO_UINT(user_data);
dbus_error_init(&error);
if(pending) {
reply = dbus_pending_call_steal_reply(pending);
}
if(pcmk_dbus_find_error("Reload", pending, reply, &error)) {
crm_err("Could not issue systemd reload %d: %s", reload_count, error.message);
} else {
crm_trace("Reload %d complete", reload_count);
}
if(pending) {
dbus_pending_call_unref(pending);
}
if(reply) {
dbus_message_unref(reply);
}
}
static void get_all_properties(GDBusProxy *proxy)
{
GDBusClient *client = proxy->client;
const char *service_name = client->service_name;
DBusMessage *msg;
DBusPendingCall *call;
msg = dbus_message_new_method_call(service_name, proxy->obj_path,
DBUS_INTERFACE_PROPERTIES, "GetAll");
if (msg == NULL)
return;
dbus_message_append_args(msg, DBUS_TYPE_STRING, &proxy->interface,
DBUS_TYPE_INVALID);
if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
&call, -1) == FALSE) {
dbus_message_unref(msg);
return;
}
g_dbus_client_ref(client);
dbus_pending_call_set_notify(call, get_all_properties_reply,
proxy, NULL);
dbus_pending_call_unref(call);
dbus_message_unref(msg);
}
