void nm_firewall_manager_cancel_call (NMFirewallManager *self, NMFirewallPendingCall call)
{
NMFirewallManagerPrivate *priv = NM_FIREWALL_MANAGER_GET_PRIVATE (self);
GSList *pending;
CBInfo *info;
g_return_if_fail (NM_IS_FIREWALL_MANAGER (self));
if (call == PENDING_CALL_DUMMY)
return;
pending = g_slist_find (priv->pending_calls, call);
if (!pending)
return;
priv->pending_calls = g_slist_remove_link (priv->pending_calls, pending);
info = (CBInfo *) call;
if (info->idle_id)
info->idle_id = 0;
else {
dbus_g_proxy_cancel_call (NM_FIREWALL_MANAGER_GET_PRIVATE (self)->proxy,
info->dbus_call);
}
}
int _bt_opp_client_cancel_push(void)
{
DBusGConnection *g_conn;
DBusGProxy *client_proxy;
retv_if(sending_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
sending_info->is_canceled = TRUE;
if (sending_info->transfer_info) {
dbus_g_proxy_call_no_reply(sending_info->transfer_info->proxy,
"Cancel", G_TYPE_INVALID);
} else {
retv_if(sending_info->sending_proxy == NULL,
BLUETOOTH_ERROR_INTERNAL);
g_conn = _bt_get_session_gconn();
retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
client_proxy = dbus_g_proxy_new_for_name(g_conn, BT_OBEX_SERVICE_NAME,
"/", BT_OBEX_CLIENT_INTERFACE);
retv_if(client_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
dbus_g_proxy_cancel_call(client_proxy,
sending_info->sending_proxy);
g_idle_add(__bt_cancel_push_cb, NULL);
}
return BLUETOOTH_ERROR_NONE;
}
void
nm_secret_agent_cancel_secrets (NMSecretAgent *self, gconstpointer call)
{
NMSecretAgentPrivate *priv;
Request *r;
g_return_if_fail (self != NULL);
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
g_return_if_fail (priv->proxy != NULL);
r = g_hash_table_lookup (priv->requests, call);
g_return_if_fail (r != NULL);
dbus_g_proxy_cancel_call (priv->proxy, (gpointer) call);
dbus_g_proxy_begin_call (priv->proxy,
"CancelGetSecrets",
cancel_done,
g_strdup (nm_secret_agent_get_description (self)),
g_free,
DBUS_TYPE_G_OBJECT_PATH, r->path,
G_TYPE_STRING, r->setting_name,
G_TYPE_INVALID);
g_hash_table_remove (priv->requests, call);
}
static void
dispose (GObject *object)
{
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (object);
GError *error = NULL;
if (priv->scan_call) {
g_set_error_literal (&error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_UNKNOWN,
"Wi-Fi device was destroyed");
if (priv->scan_info) {
if (priv->scan_info->callback)
priv->scan_info->callback (NULL, error, priv->scan_info->user_data);
g_slice_free (RequestScanInfo, priv->scan_info);
priv->scan_info = NULL;
}
g_clear_error (&error);
dbus_g_proxy_cancel_call (priv->proxy, priv->scan_call);
priv->scan_call = NULL;
}
if (priv->aps)
clean_up_aps (NM_DEVICE_WIFI (object), TRUE);
g_clear_object (&priv->proxy);
G_OBJECT_CLASS (nm_device_wifi_parent_class)->dispose (object);
}
static void on_eject_cancelled(GCancellable* cancellable, gpointer user_data)
{
EjectData* data = (EjectData*)user_data;
/* cancel the dbus call if needed */
if(data->call)
dbus_g_proxy_cancel_call(data->proxy, data->call);
}
static void
names_model_reload (NamesModel *names_model)
{
GtkListStore *list_store;
list_store = GTK_LIST_STORE (names_model);
if (names_model->pending_list_names)
{
dbus_g_proxy_cancel_call (names_model->driver_proxy,
names_model->pending_list_names);
names_model->pending_list_names = NULL;
}
gtk_list_store_clear (list_store);
if (names_model->connection == NULL)
return;
names_model->pending_list_names =
dbus_g_proxy_begin_call (names_model->driver_proxy,
"ListNames",
have_names_notify, names_model, NULL,
G_TYPE_INVALID);
}
static gboolean
cancel_all_cb (GObject *object, gpointer call_id, gpointer user_data)
{
dbus_g_proxy_cancel_call (DBUS_G_PROXY (object), (DBusGProxyCall *) call_id);
return TRUE;
}
/* Permet de liberer la memoire prise par le backend.
*/
static void cd_mpris2_stop (void)
{
if (myData.dbus_proxy_player != NULL)
{
if (s_pGetSongInfosCall != NULL)
{
dbus_g_proxy_cancel_call (myData.dbus_proxy_player, s_pGetSongInfosCall);
s_pGetSongInfosCall = NULL;
}
if (s_pGetStatusCall != NULL)
{
dbus_g_proxy_cancel_call (myData.dbus_proxy_player, s_pGetStatusCall);
s_pGetStatusCall = NULL;
}
}
}
void simple_method_reply_handler(DBusGProxy *proxy, DBusGProxyCall *call_id, void *user_data)
{
GError *error = NULL;
gint res1;
dbus_g_proxy_end_call(proxy, call_id, &error, G_TYPE_INT, &res1, G_TYPE_INVALID);
dbus_g_proxy_cancel_call(proxy, call_id);
*(gint *)user_data = res1;
g_main_loop_quit(mainLoop);
}
static void
real_deactivate (NMModem *self, NMDevice *device)
{
NMModemPrivate *priv;
int ifindex;
g_return_if_fail (self != NULL);
g_return_if_fail (NM_IS_MODEM (self));
g_return_if_fail (device != NULL);
g_return_if_fail (NM_IS_DEVICE (device));
priv = NM_MODEM_GET_PRIVATE (self);
priv->secrets_tries = 0;
if (priv->act_request) {
cancel_get_secrets (self);
g_object_unref (priv->act_request);
priv->act_request = NULL;
}
if (priv->call) {
dbus_g_proxy_cancel_call (priv->proxy, priv->call);
priv->call = NULL;
}
priv->in_bytes = priv->out_bytes = 0;
if (priv->ppp_manager) {
g_object_unref (priv->ppp_manager);
priv->ppp_manager = NULL;
}
switch (priv->ip_method) {
case MM_MODEM_IP_METHOD_PPP:
break;
case MM_MODEM_IP_METHOD_STATIC:
case MM_MODEM_IP_METHOD_DHCP:
ifindex = nm_device_get_ip_ifindex (device);
if (ifindex >= 0) {
/* FIXME: use AF_UNSPEC here when we have IPv6 support */
nm_system_iface_flush_routes (ifindex, AF_INET);
nm_system_iface_flush_addresses (ifindex, AF_UNSPEC);
nm_system_iface_set_up (ifindex, FALSE, NULL);
}
break;
default:
nm_log_err (LOGD_MB, "unknown IP method %d", priv->ip_method);
break;
}
}
static void
real_deactivate (NMModem *modem, NMDevice *device)
{
NMModemGsmPrivate *priv = NM_MODEM_GSM_GET_PRIVATE (modem);
if (priv->call) {
DBusGProxy *proxy;
proxy = nm_modem_get_proxy (modem, MM_DBUS_INTERFACE_MODEM_SIMPLE);
dbus_g_proxy_cancel_call (proxy, priv->call);
priv->call = NULL;
}
priv->pin_tries = 0;
NM_MODEM_CLASS (nm_modem_gsm_parent_class)->deactivate (modem, device);
}
/** Cancel request
*/
void
modem_request_cancel (ModemRequest *request)
{
ModemRequestPrivate *priv = request->priv;
GDestroyNotify cancel;
cancel = modem_request_steal_qdata (request, MODEM_REQUEST_CANCEL_QUARK);
if (cancel)
{
cancel (request);
return;
}
if (priv->call)
dbus_g_proxy_cancel_call (priv->proxy, priv->call);
else
_modem_request_destroy_notify (request);
}
static void
deactivate (NMModem *modem, NMDevice *device)
{
NMModemGsmPrivate *priv = NM_MODEM_GSM_GET_PRIVATE (modem);
if (priv->call) {
DBusGProxy *proxy;
proxy = nm_modem_generic_get_proxy (NM_MODEM_GENERIC (modem), MM_OLD_DBUS_INTERFACE_MODEM_SIMPLE);
dbus_g_proxy_cancel_call (proxy, priv->call);
priv->call = NULL;
}
priv->pin_tries = 0;
if (priv->enable_delay_id)
g_source_remove (priv->enable_delay_id);
NM_MODEM_CLASS (nm_modem_gsm_parent_class)->deactivate (modem, device);
}
static void
dispose (GObject *object)
{
BMClientPrivate *priv = BM_CLIENT_GET_PRIVATE (object);
if (priv->disposed) {
G_OBJECT_CLASS (bm_client_parent_class)->dispose (object);
return;
}
if (priv->perm_call)
dbus_g_proxy_cancel_call (priv->client_proxy, priv->perm_call);
g_object_unref (priv->client_proxy);
g_object_unref (priv->bus_proxy);
free_object_array (&priv->devices);
free_object_array (&priv->active_connections);
g_hash_table_destroy (priv->permissions);
G_OBJECT_CLASS (bm_client_parent_class)->dispose (object);
}
static void on_unmount_cancelled(GCancellable* cancellable, gpointer user_data)
{
AsyncData* data = (AsyncData*)user_data;
dbus_g_proxy_cancel_call(data->proxy, data->call);
}
void nm_firewall_manager_cancel_call (NMFirewallManager *self, gpointer call)
{
g_return_if_fail (NM_IS_FIREWALL_MANAGER (self));
dbus_g_proxy_cancel_call (NM_FIREWALL_MANAGER_GET_PRIVATE (self)->proxy,
(DBusGProxyCall *) call);
}
