static void
pidgin_media_dispose(GObject *media)
{
PidginMedia *gtkmedia = PIDGIN_MEDIA(media);
purple_debug_info("gtkmedia", "pidgin_media_dispose\n");
if (gtkmedia->priv->media) {
purple_request_close_with_handle(gtkmedia);
purple_media_remove_output_windows(gtkmedia->priv->media);
pidgin_media_disconnect_levels(gtkmedia->priv->media, gtkmedia);
g_object_unref(gtkmedia->priv->media);
gtkmedia->priv->media = NULL;
}
if (gtkmedia->priv->ui) {
g_object_unref(gtkmedia->priv->ui);
gtkmedia->priv->ui = NULL;
}
if (gtkmedia->priv->timeout_id != 0)
g_source_remove(gtkmedia->priv->timeout_id);
if (gtkmedia->priv->recv_progressbars) {
g_hash_table_destroy(gtkmedia->priv->recv_progressbars);
g_hash_table_destroy(gtkmedia->priv->remote_videos);
gtkmedia->priv->recv_progressbars = NULL;
gtkmedia->priv->remote_videos = NULL;
}
G_OBJECT_CLASS(parent_class)->dispose(media);
}
static void
purple_xfer_destroy(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
g_return_if_fail(xfer != NULL);
if (purple_debug_is_verbose())
purple_debug_info("xfer", "destroyed %p [%d]\n", xfer, xfer->ref);
/* Close the file browser, if it's open */
purple_request_close_with_handle(xfer);
if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED)
purple_xfer_cancel_local(xfer);
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->destroy != NULL)
ui_ops->destroy(xfer);
g_free(xfer->who);
g_free(xfer->filename);
g_free(xfer->remote_ip);
g_free(xfer->local_filename);
g_hash_table_remove(xfers_data, xfer);
PURPLE_DBUS_UNREGISTER_POINTER(xfer);
xfers = g_list_remove(xfers, xfer);
g_free(xfer);
}
void
purple_ssl_close(PurpleSslConnection *gsc)
{
PurpleSslOps *ops;
g_return_if_fail(gsc != NULL);
purple_request_close_with_handle(gsc);
purple_notify_close_with_handle(gsc);
ops = purple_ssl_get_ops();
(ops->close)(gsc);
if (gsc->connect_data != NULL)
purple_proxy_connect_cancel(gsc->connect_data);
if (gsc->inpa > 0)
purple_input_remove(gsc->inpa);
if (gsc->fd >= 0)
close(gsc->fd);
g_free(gsc->host);
g_free(gsc);
}
static void
purple_protocol_finalize(GObject *object)
{
PurpleProtocol *protocol = PURPLE_PROTOCOL(object);
GList *accounts, *l;
accounts = purple_accounts_get_all_active();
for (l = accounts; l != NULL; l = l->next) {
PurpleAccount *account = PURPLE_ACCOUNT(l->data);
if (purple_account_is_disconnected(account))
continue;
if (purple_strequal(protocol->id,
purple_account_get_protocol_id(account)))
purple_account_disconnect(account);
}
g_list_free(accounts);
purple_request_close_with_handle(protocol);
purple_notify_close_with_handle(protocol);
purple_signals_disconnect_by_handle(protocol);
purple_signals_unregister_by_instance(protocol);
purple_prefs_disconnect_by_handle(protocol);
user_splits_free(protocol);
account_options_free(protocol);
icon_spec_free(protocol);
PURPLE_DBUS_UNREGISTER_POINTER(protocol);
parent_class->finalize(object);
}
static void info_modify_dialogue(PurpleConnection *gc, gchar **segments, int iclass)
{
qq_data *qd;
PurpleRequestFieldGroup *group;
PurpleRequestFields *fields;
modify_info_request *info_request;
gchar *utf8_title, *utf8_prim;
int index;
qd = (qq_data *) gc->proto_data;
/* Keep one dialog once a time */
purple_request_close_with_handle(gc);
fields = purple_request_fields_new();
group = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, group);
for (index = 1; segments[index] != NULL && index < QQ_INFO_LAST; index++) {
if (field_infos[index].iclass != iclass) {
continue;
}
field_request_new(group, index, segments);
}
switch (iclass) {
case QQ_FIELD_CONTACT:
utf8_title = g_strdup(_("Modify Contact"));
utf8_prim = g_strdup_printf("%s for %s", _("Modify Contact"), segments[0]);
case QQ_FIELD_ADDR:
utf8_title = g_strdup(_("Modify Address"));
utf8_prim = g_strdup_printf("%s for %s", _("Modify Address"), segments[0]);
case QQ_FIELD_EXT:
utf8_title = g_strdup(_("Modify Extended Information"));
utf8_prim = g_strdup_printf("%s for %s", _("Modify Extended Information"), segments[0]);
break;
case QQ_FIELD_BASE:
default:
utf8_title = g_strdup(_("Modify Information"));
utf8_prim = g_strdup_printf("%s for %s", _("Modify Information"), segments[0]);
}
info_request = g_new0(modify_info_request, 1);
info_request->gc = gc;
info_request->iclass = iclass;
info_request->segments = segments;
purple_request_fields(gc,
utf8_title,
utf8_prim,
NULL,
fields,
_("Update"), G_CALLBACK(info_modify_ok_cb),
_("Cancel"), G_CALLBACK(info_modify_cancel_cb),
purple_connection_get_account(gc), NULL, NULL,
info_request);
g_free(utf8_title);
g_free(utf8_prim);
}
static void
pounces_manager_delete_confirm_cb(PurplePounce *pounce)
{
gnt_tree_remove(GNT_TREE(pounces_manager->tree), pounce);
purple_request_close_with_handle(pounce);
purple_pounce_destroy(pounce);
}
/* memo modify dialogue */
static void memo_modify_dialogue(PurpleConnection *gc, guint32 bd_uid, gchar **segments, guint32 action)
{
modify_memo_request *memo_request;
PurpleRequestField *field;
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
int index;
gchar *utf8_title;
gchar *utf8_primary;
g_return_if_fail(NULL != gc && NULL != segments);
switch (action) {
case QQ_BUDDY_MEMO_GET:
memo_free(segments);
break;
case QQ_BUDDY_MEMO_MODIFY:
/* keep one dialog once a time */
purple_request_close_with_handle(gc);
/* show dialog */
fields = purple_request_fields_new();
group = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, group);
for(index = 0; index < QQ_MEMO_SIZE; index++) {
/*
purple_debug_info("QQ", "id:%s txt:%s segment:%s\n",
memo_id[index], memo_txt[index], segments[index]);
*/
field = purple_request_field_string_new(memo_id[index], memo_txt[index],
segments[index], FALSE);
purple_request_field_group_add_field(group, field);
}
/* for upload cb */
memo_request = g_new0(modify_memo_request, 1);
memo_request->gc = gc;
memo_request->bd_uid = bd_uid;
memo_request->segments = segments;
/* callback */
utf8_title = g_strdup(_("Buddy Memo"));
utf8_primary = g_strdup(_("Change his/her memo as you like"));
purple_request_fields(gc, utf8_title, utf8_primary, NULL,
fields,
_("_Modify"), G_CALLBACK(memo_modify_ok_cb),
_("_Cancel"), G_CALLBACK(memo_modify_cancle_cb),
purple_connection_get_account(gc), NULL, NULL,
memo_request);
g_free(utf8_title);
g_free(utf8_primary);
break;
default:
purple_debug_info("QQ", "Error...unknown memo action, please tell us\n");
break;
}
}
static void
silcpurple_wb_request(SilcClient client, const unsigned char *message,
SilcUInt32 message_len, SilcClientEntry sender,
SilcChannelEntry channel)
{
char tmp[256];
SilcPurpleWbRequest req;
PurpleConnection *gc;
SilcPurple sg;
gc = client->application;
sg = gc->proto_data;
/* Open whiteboard automatically if requested */
if (purple_account_get_bool(sg->account, "open-wb", FALSE)) {
PurpleWhiteboard *wb;
if (!channel)
wb = silcpurple_wb_init(sg, sender);
else
wb = silcpurple_wb_init_ch(sg, channel);
silcpurple_wb_parse(wb->proto_data, wb,
(unsigned char *)message,
message_len);
return;
}
/* Close any previous unaccepted requests */
purple_request_close_with_handle(sender);
if (!channel) {
g_snprintf(tmp, sizeof(tmp),
_("%s sent message to whiteboard. Would you like "
"to open the whiteboard?"), sender->nickname);
} else {
g_snprintf(tmp, sizeof(tmp),
_("%s sent message to whiteboard on %s channel. "
"Would you like to open the whiteboard?"),
sender->nickname, channel->channel_name);
}
req = silc_calloc(1, sizeof(*req));
if (!req)
return;
req->message = silc_memdup(message, message_len);
req->message_len = message_len;
req->sender = sender;
req->channel = channel;
req->sg = sg;
purple_request_action(gc, _("Whiteboard"), tmp, NULL, 1,
sg->account, sender->nickname, NULL, req, 2,
_("Yes"), G_CALLBACK(silcpurple_wb_request_cb),
_("No"), G_CALLBACK(silcpurple_wb_request_cb));
}
static void destroy_cb(GtkWidget *w, gint resp, struct log_viewer_hash_t *ht) {
PidginLogViewer *lv = syslog_viewer;
#ifdef _WIN32
if (resp == GTK_RESPONSE_HELP) {
GtkTreeSelection *sel;
GtkTreeIter iter;
GtkTreeModel *model;
PurpleLog *log = NULL;
char *logdir;
if (ht != NULL)
lv = g_hash_table_lookup(log_viewers, ht);
model = GTK_TREE_MODEL(lv->treestore);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(lv->treeview));
if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
GValue val;
val.g_type = 0;
gtk_tree_model_get_value (model, &iter, 1, &val);
log = g_value_get_pointer(&val);
g_value_unset(&val);
}
if (log == NULL)
logdir = g_build_filename(purple_user_dir(), "logs", NULL);
else
logdir = purple_log_get_log_dir(log->type, log->name, log->account);
winpidgin_shell_execute(logdir, "explore", NULL);
g_free(logdir);
return;
}
#endif
if (ht != NULL) {
lv = g_hash_table_lookup(log_viewers, ht);
g_hash_table_remove(log_viewers, ht);
g_free(ht->screenname);
g_free(ht);
} else
syslog_viewer = NULL;
purple_request_close_with_handle(lv);
g_list_foreach(lv->logs, (GFunc)purple_log_free, NULL);
g_list_free(lv->logs);
g_free(lv->search);
g_free(lv);
gtk_widget_destroy(w);
}
static void
install_plugin_cb(GntWidget *w, gpointer null)
{
static int handle;
purple_request_close_with_handle(&handle);
purple_request_file(&handle, _("Select plugin to install"), NULL,
FALSE, G_CALLBACK(install_selected_file_cb), NULL,
NULL, &handle);
g_signal_connect_swapped(G_OBJECT(w), "destroy", G_CALLBACK(purple_request_close_with_handle), &handle);
}
static void
purple_request_close_info(PurpleRequestInfo *info)
{
PurpleRequestUiOps *ops;
ops = purple_request_get_ui_ops();
purple_notify_close_with_handle(info->ui_handle);
purple_request_close_with_handle(info->ui_handle);
if (ops != NULL && ops->close_request != NULL)
ops->close_request(info->type, info->ui_handle);
g_free(info);
}
static gboolean
peer_connection_destroy_cb(gpointer data)
{
PeerConnection *conn;
conn = data;
purple_request_close_with_handle(conn);
peer_connection_close(conn);
if (conn->checksum_data != NULL)
peer_oft_checksum_destroy(conn->checksum_data);
if (conn->xfer != NULL)
{
PurpleXferStatusType status;
conn->xfer->data = NULL;
status = purple_xfer_get_status(conn->xfer);
if ((status != PURPLE_XFER_STATUS_DONE) &&
(status != PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
(status != PURPLE_XFER_STATUS_CANCEL_REMOTE))
{
if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) ||
(conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED))
purple_xfer_cancel_remote(conn->xfer);
else
purple_xfer_cancel_local(conn->xfer);
}
purple_xfer_unref(conn->xfer);
conn->xfer = NULL;
}
g_free(conn->bn);
g_free(conn->error_message);
g_free(conn->proxyip);
g_free(conn->clientip);
g_free(conn->verifiedip);
g_free(conn->xferdata.name);
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn);
g_free(conn);
return FALSE;
}
static void
pidgin_media_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
gchar *sid, gchar *name, gboolean local,
PidginMedia *gtkmedia)
{
if (type == PURPLE_MEDIA_INFO_REJECT) {
pidgin_media_emit_message(gtkmedia,
_("You have rejected the call."));
} else if (type == PURPLE_MEDIA_INFO_ACCEPT) {
if (local == TRUE)
purple_request_close_with_handle(gtkmedia);
pidgin_media_set_state(gtkmedia, PIDGIN_MEDIA_ACCEPTED);
pidgin_media_emit_message(gtkmedia, _("Call in progress."));
gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar),
0, _("Call in progress."));
gtk_widget_show(GTK_WIDGET(gtkmedia));
}
}
static void
pidgin_media_dispose(GObject *media)
{
PidginMedia *gtkmedia = PIDGIN_MEDIA(media);
purple_debug_info("gtkmedia", "pidgin_media_dispose\n");
if (gtkmedia->priv->media) {
purple_request_close_with_handle(gtkmedia);
purple_media_remove_output_windows(gtkmedia->priv->media);
pidgin_media_disconnect_levels(gtkmedia->priv->media, gtkmedia);
g_object_unref(gtkmedia->priv->media);
gtkmedia->priv->media = NULL;
}
if (gtkmedia->priv->ui) {
g_object_unref(gtkmedia->priv->ui);
gtkmedia->priv->ui = NULL;
}
G_OBJECT_CLASS(parent_class)->dispose(media);
}
void AccountCollector::collectNow(PurpleAccount *account, bool remove) {
if (account->ui_data == NULL) {
Log("AccountCollector","freeing account " << purple_account_get_username(account));
if (remove)
g_hash_table_remove(m_accounts, purple_account_get_username(account));
purple_account_set_enabled(account, purple_core_get_ui(), FALSE);
purple_notify_close_with_handle(account);
purple_request_close_with_handle(account);
purple_accounts_remove(account);
GSList *buddies = purple_find_buddies(account, NULL);
while(buddies) {
PurpleBuddy *b = (PurpleBuddy *) buddies->data;
purple_blist_remove_buddy(b);
buddies = g_slist_delete_link(buddies, buddies);
}
/* Remove any open conversation for this account */
for (GList *it = purple_get_conversations(); it; ) {
PurpleConversation *conv = (PurpleConversation *) it->data;
it = it->next;
if (purple_conversation_get_account(conv) == account)
purple_conversation_destroy(conv);
}
/* Remove this account's pounces */
// purple_pounce_destroy_all_by_account(account);
/* This will cause the deletion of an old buddy icon. */
purple_buddy_icons_set_account_icon(account, NULL, 0);
purple_account_destroy(account);
// VALGRIND_DO_LEAK_CHECK;
}
}
void flist_close(PurpleConnection *pc) {
FListAccount *fla = pc->proto_data;
if(!fla) return;
if(fla->gsc) purple_ssl_close(fla->gsc);
if(fla->username) g_free(fla->username);
if(fla->character) g_free(fla->character);
if(fla->password) g_free(fla->password);
if(fla->proper_character) g_free(fla->proper_character);
if(fla->ticket_request) flist_web_request_cancel(fla->ticket_request);
if(fla->ticket_timer) purple_timeout_remove(fla->ticket_timer);
if(fla->fls_cookie) g_free(fla->fls_cookie);
g_free(fla->rx_buf);
if(fla->ping_timeout_handle) purple_timeout_remove(fla->ping_timeout_handle);
g_hash_table_destroy(fla->all_characters);
if(fla->global_ops) g_hash_table_destroy(fla->global_ops);
/* login options */
if(fla->server_address) g_free(fla->server_address);
if(fla->input_request) purple_request_close_with_handle((void*) pc);
flist_friends_unload(fla);
flist_fetch_icon_cancel_all(fla);
flist_global_kinks_unload(pc);
flist_profile_unload(pc);
flist_channel_subsystem_unload(fla);
g_free(fla);
pc->proto_data = NULL;
}
void
purple_xfer_cancel_remote(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
gchar *msg;
PurpleAccount *account;
PurpleBuddy *buddy;
g_return_if_fail(xfer != NULL);
purple_request_close_with_handle(xfer);
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
xfer->end_time = time(NULL);
account = purple_xfer_get_account(xfer);
buddy = purple_find_buddy(account, xfer->who);
if (purple_xfer_get_filename(xfer) != NULL)
{
msg = g_strdup_printf(_("%s cancelled the transfer of %s"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer));
}
else
{
msg = g_strdup_printf(_("%s cancelled the file transfer"),
buddy ? purple_buddy_get_alias(buddy) : xfer->who);
}
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg);
g_free(msg);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND)
{
if (xfer->ops.cancel_send != NULL)
xfer->ops.cancel_send(xfer);
}
else
{
if (xfer->ops.cancel_recv != NULL)
xfer->ops.cancel_recv(xfer);
}
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
if (xfer->fd != -1)
close(xfer->fd);
if (xfer->dest_fp != NULL) {
fclose(xfer->dest_fp);
xfer->dest_fp = NULL;
}
ui_ops = purple_xfer_get_ui_ops(xfer);
if (ui_ops != NULL && ui_ops->cancel_remote != NULL)
ui_ops->cancel_remote(xfer);
xfer->bytes_remaining = 0;
purple_xfer_unref(xfer);
}
gboolean
purple_plugin_unload(PurplePlugin *plugin)
{
#ifdef PURPLE_PLUGINS
GList *l;
GList *ll;
g_return_val_if_fail(plugin != NULL, FALSE);
g_return_val_if_fail(purple_plugin_is_loaded(plugin), FALSE);
purple_debug_info("plugins", "Unloading plugin %s\n", plugin->info->name);
/* Unload all plugins that depend on this plugin. */
for (l = plugin->dependent_plugins; l != NULL; l = ll) {
const char * dep_name = (const char *)l->data;
PurplePlugin *dep_plugin;
/* Store a pointer to the next element in the list.
* This is because we'll be modifying this list in the loop. */
ll = l->next;
dep_plugin = purple_plugins_find_with_id(dep_name);
if (dep_plugin != NULL && purple_plugin_is_loaded(dep_plugin))
{
if (!purple_plugin_unload(dep_plugin))
{
g_free(plugin->error);
plugin->error = g_strdup_printf(_("%s requires %s, but it failed to unload."),
_(plugin->info->name),
_(dep_plugin->info->name));
return FALSE;
}
else
{
#if 0
/* This isn't necessary. This has already been done when unloading dep_plugin. */
plugin->dependent_plugins = g_list_delete_link(plugin->dependent_plugins, l);
#endif
}
}
}
/* Remove this plugin from each dependency's dependent_plugins list. */
for (l = plugin->info->dependencies; l != NULL; l = l->next)
{
const char *dep_name = (const char *)l->data;
PurplePlugin *dependency;
dependency = purple_plugins_find_with_id(dep_name);
if (dependency != NULL)
dependency->dependent_plugins = g_list_remove(dependency->dependent_plugins, plugin->info->id);
else
purple_debug_error("plugins", "Unable to remove from dependency list for %s\n", dep_name);
}
if (plugin->native_plugin) {
if (plugin->info->unload && !plugin->info->unload(plugin))
return FALSE;
if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) {
PurplePluginProtocolInfo *prpl_info;
GList *l;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin);
for (l = prpl_info->user_splits; l != NULL; l = l->next)
purple_account_user_split_destroy(l->data);
for (l = prpl_info->protocol_options; l != NULL; l = l->next)
purple_account_option_destroy(l->data);
if (prpl_info->user_splits != NULL) {
g_list_free(prpl_info->user_splits);
prpl_info->user_splits = NULL;
}
if (prpl_info->protocol_options != NULL) {
g_list_free(prpl_info->protocol_options);
prpl_info->protocol_options = NULL;
}
}
} else {
PurplePlugin *loader;
PurplePluginLoaderInfo *loader_info;
loader = find_loader_for_plugin(plugin);
if (loader == NULL)
return FALSE;
loader_info = PURPLE_PLUGIN_LOADER_INFO(loader);
if (loader_info->unload && !loader_info->unload(plugin))
return FALSE;
}
/* cancel any pending dialogs the plugin has */
purple_request_close_with_handle(plugin);
purple_notify_close_with_handle(plugin);
purple_signals_disconnect_by_handle(plugin);
purple_plugin_ipc_unregister_all(plugin);
loaded_plugins = g_list_remove(loaded_plugins, plugin);
if ((plugin->info != NULL) && PURPLE_IS_PROTOCOL_PLUGIN(plugin))
protocol_plugins = g_list_remove(protocol_plugins, plugin);
plugins_to_disable = g_list_remove(plugins_to_disable, plugin);
plugin->loaded = FALSE;
/* We wouldn't be anywhere near here if the plugin wasn't loaded, so
* if plugin->error is set at all, it had to be from a previous
* unload failure. It's obviously okay now.
*/
g_free(plugin->error);
plugin->error = NULL;
purple_signal_emit(purple_plugins_get_handle(), "plugin-unload", plugin);
purple_prefs_disconnect_by_handle(plugin);
return TRUE;
#else
return TRUE;
#endif /* PURPLE_PLUGINS */
}
void
_purple_connection_destroy(PurpleConnection *gc)
{
PurpleAccount *account;
GSList *buddies;
PurplePluginProtocolInfo *prpl_info = NULL;
gboolean remove = FALSE;
g_return_if_fail(gc != NULL);
account = purple_connection_get_account(gc);
purple_debug_info("connection", "Disconnecting connection %p\n", gc);
if (purple_connection_get_state(gc) != PURPLE_CONNECTING)
remove = TRUE;
purple_signal_emit(purple_connections_get_handle(), "signing-off", gc);
while (gc->buddy_chats)
{
PurpleConversation *b = gc->buddy_chats->data;
gc->buddy_chats = g_slist_remove(gc->buddy_chats, b);
purple_conv_chat_left(PURPLE_CONV_CHAT(b));
}
update_keepalive(gc, FALSE);
purple_proxy_connect_cancel_with_handle(gc);
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info->close)
(prpl_info->close)(gc);
/* Clear out the proto data that was freed in the prpl close method*/
buddies = purple_find_buddies(account, NULL);
while (buddies != NULL) {
PurpleBuddy *buddy = buddies->data;
purple_buddy_set_protocol_data(buddy, NULL);
buddies = g_slist_delete_link(buddies, buddies);
}
connections = g_list_remove(connections, gc);
purple_connection_set_state(gc, PURPLE_DISCONNECTED);
if (remove)
purple_blist_remove_account(account);
purple_signal_emit(purple_connections_get_handle(), "signed-off", gc);
purple_account_request_close_with_account(account);
purple_request_close_with_handle(gc);
purple_notify_close_with_handle(gc);
purple_debug_info("connection", "Destroying connection %p\n", gc);
purple_account_set_connection(account, NULL);
g_free(gc->password);
g_free(gc->display_name);
if (gc->disconnect_timeout > 0)
purple_timeout_remove(gc->disconnect_timeout);
PURPLE_DBUS_UNREGISTER_POINTER(gc);
g_free(gc);
}