static gboolean
delayed_abort (gpointer data G_GNUC_UNUSED)
{
g_message ("Aborting by popular request");
mcd_mission_abort ((McdMission *) mcd);
return FALSE;
}
static void
_mcd_channel_request_cancelling_cb (McdRequest *request,
McdChannel *self)
{
McdChannelStatus status = mcd_channel_get_status (self);
g_object_ref (self);
DEBUG ("%p in status %u", self, status);
mcd_channel_take_error (self, g_error_new (TP_ERROR,
TP_ERROR_CANCELLED,
"Cancelled"));
/* If we're coming from state REQUEST, the call to the CM hasn't
* happened yet; now that we're in state FAILED, it never will,
* because mcd_connection_request_channel() now checks that.
*
* If we're coming from state REQUESTED, we need to close the channel
* when the CM tells us where it is, so we can't now.
*
* If we're coming from state DISPATCHING, we need to shoot it down
* now.
*
* Anything else is too late.
*/
if (status == MCD_CHANNEL_STATUS_DISPATCHING)
{
_mcd_channel_close (self);
mcd_mission_abort ((McdMission *) self);
}
g_object_unref (self);
}
static void
copy_status (McdChannel *source, McdChannel *dest)
{
McdChannelPrivate *src_priv, *dst_priv;
src_priv = source->priv;
dst_priv = dest->priv;
if (dst_priv->status != src_priv->status)
{
DEBUG ("source is %d, dest is %d", src_priv->status, dst_priv->status);
if (src_priv->status == MCD_CHANNEL_STATUS_FAILED)
{
const GError *error;
error = mcd_channel_get_error (source);
/* this also takes care of setting the status */
mcd_channel_take_error (dest, g_error_copy (error));
}
else
_mcd_channel_set_status (dest, src_priv->status);
}
if (dst_priv->status == MCD_CHANNEL_STATUS_FAILED ||
dst_priv->status == MCD_CHANNEL_STATUS_DISPATCHED)
{
/* the request is completed, we are not interested in monitor the
* channel anymore */
g_signal_handlers_disconnect_by_func
(source, on_proxied_channel_status_changed, dest);
mcd_mission_abort (MCD_MISSION (dest));
}
}
static void
_mcd_operation_abort (McdOperation * operation)
{
const GList *node;
DEBUG ("Operation abort received, aborting all children");
node = MCD_OPERATION_PRIV (operation)->missions;
while (node)
{
McdMission *mission = MCD_MISSION (node->data);
/* We don't want to hear it ourself so that we still hold the
* final reference to our children.
*/
g_signal_handlers_disconnect_by_func (mission,
G_CALLBACK (on_mission_abort),
operation);
mcd_mission_abort (mission);
/* Restore the handler so that we continue listing for destroy
* notify for our children.
*/
g_signal_connect (mission, "abort",
G_CALLBACK (on_mission_abort), operation);
node = g_list_next (node);
}
}
static void
proxy_destroyed (TpProxy *self, guint domain, gint code, gchar *message,
gpointer user_data)
{
McdChannel *channel = user_data;
DEBUG ("Channel proxy invalidated: %s %d: %s",
g_quark_to_string (domain), code, message);
mcd_mission_abort (MCD_MISSION (channel));
}
static gboolean
_mcd_master_exit_by_timeout (gpointer data)
{
McdMaster *self = MCD_MASTER (data);
McdMasterPrivate *priv = MCD_MASTER_PRIV (self);
priv->shutdown_timeout_id = 0;
/* Notify sucide */
mcd_mission_abort (MCD_MISSION (self));
return FALSE;
}
static DBusHandlerResult
dbus_filter_function (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") &&
!tp_strdiff (dbus_message_get_path (message), DBUS_PATH_LOCAL))
{
/* MC initialization sets exit on disconnect - turn it off again, so we
* get a graceful exit instead (to keep gcov happy) */
dbus_connection_set_exit_on_disconnect (connection, FALSE);
g_message ("Got disconnected from the session bus");
mcd_mission_abort ((McdMission *) mcd);
}
else if (dbus_message_is_method_call (message,
"org.freedesktop.Telepathy.MissionControl5.RegressionTests",
"Abort"))
{
DBusMessage *reply;
g_idle_add (delayed_abort, NULL);
reply = dbus_message_new_method_return (message);
if (reply == NULL || !dbus_connection_send (connection, reply, NULL))
g_error ("Out of memory");
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
else if (dbus_message_is_method_call (message,
"org.freedesktop.Telepathy.MissionControl5.RegressionTests",
"BillyIdle"))
{
/* Used to drive a souped-up version of sync_dbus(), where we need to
* ensure that all idles have fired, on top of the D-Bus queue being
* drained.
*/
DBusMessage *reply = dbus_message_new_method_return (message);
GVariant *variant;
GDBusConnection *system_bus;
if (reply == NULL)
g_error ("Out of memory");
/* Sync GDBus, too, to make sure we have received any pending
* FakeNetworkMonitor messages. */
system_bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
g_assert (system_bus != NULL);
variant = g_dbus_connection_call_sync (system_bus,
"org.freedesktop.DBus", "/org/freedesktop/DBus",
"org.freedesktop.DBus", "ListNames",
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
g_assert (variant != NULL);
g_variant_unref (variant);
g_object_unref (system_bus);
g_idle_add_full (G_PRIORITY_LOW, billy_idle, reply,
(GDestroyNotify) dbus_message_unref);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
