void
gaim_connection_disconnect(GaimConnection *gc)
{
GaimAccount *account;
GList *wins;
g_return_if_fail(gc != NULL);
account = gaim_connection_get_account(gc);
if (gaim_account_get_connection(account) != NULL) {
gaim_account_disconnect(account);
return;
}
gaim_debug(GAIM_DEBUG_INFO, "connection",
"Disconnecting connection %p\n", gc);
if (gaim_connection_get_state(gc) != GAIM_DISCONNECTED) {
if (gaim_connection_get_state(gc) != GAIM_CONNECTING)
gaim_blist_remove_account(gaim_connection_get_account(gc));
gaim_signal_emit(gaim_connections_get_handle(), "signing-off", gc);
serv_close(gc);
connections = g_list_remove(connections, gc);
gaim_connection_set_state(gc, GAIM_DISCONNECTED);
gaim_signal_emit(gaim_connections_get_handle(), "signed-off", gc);
system_log(log_signoff, gc, NULL,
OPT_LOG_BUDDY_SIGNON | OPT_LOG_MY_SIGNON);
/*
* XXX This is a hack! Remove this and replace it with a better event
* notification system.
*/
for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
GaimWindow *win = (GaimWindow *)wins->data;
gaim_conversation_update(gaim_window_get_conversation_at(win, 0),
GAIM_CONV_ACCOUNT_OFFLINE);
}
gaim_request_close_with_handle(gc);
gaim_notify_close_with_handle(gc);
}
gaim_connection_destroy(gc);
}
static void
update_buddy_idle(GaimBuddy *buddy, GaimPresence *presence,
time_t current_time, gboolean old_idle, gboolean idle)
{
GaimBlistUiOps *ops = gaim_blist_get_ui_ops();
if (!old_idle && idle)
{
if (gaim_prefs_get_bool("/core/logging/log_system"))
{
GaimLog *log = gaim_account_get_log(buddy->account, FALSE);
if (log != NULL)
{
char *tmp = g_strdup_printf(_("%s became idle"),
gaim_buddy_get_alias(buddy));
gaim_log_write(log, GAIM_MESSAGE_SYSTEM,
gaim_buddy_get_alias(buddy), current_time, tmp);
g_free(tmp);
}
}
}
else if (old_idle && !idle)
{
if (gaim_prefs_get_bool("/core/logging/log_system"))
{
GaimLog *log = gaim_account_get_log(buddy->account, FALSE);
if (log != NULL)
{
char *tmp = g_strdup_printf(_("%s became unidle"),
gaim_buddy_get_alias(buddy));
gaim_log_write(log, GAIM_MESSAGE_SYSTEM,
gaim_buddy_get_alias(buddy), current_time, tmp);
g_free(tmp);
}
}
}
if (old_idle != idle)
gaim_signal_emit(gaim_blist_get_handle(), "buddy-idle-changed", buddy,
old_idle, idle);
gaim_contact_invalidate_priority_buddy(gaim_buddy_get_contact(buddy));
/* Should this be done here? It'd perhaps make more sense to
* connect to buddy-[un]idle signals and update from there
*/
if (ops != NULL && ops->update != NULL)
ops->update(gaim_get_blist(), (GaimBlistNode *)buddy);
}
void gaym_fetch_thumbnail_cb(void *user_data, const char *pic_data,
size_t len)
{
if (!user_data)
return;
struct gaym_fetch_thumbnail_data *d = user_data;
if (!pic_data) {
return;
}
if (len && !g_strrstr_len(pic_data, len, "Server Error")) {
char *dir =
g_build_filename(gaim_user_dir(), "icons", "gaym", d->who,
NULL);
char *filename = g_strdup(d->filename);
char *path = g_build_filename(dir, filename, NULL);
gaim_debug_misc("gayminfo", "dir: %s\n", dir);
gaim_debug_misc("gayminfo", "filename: %s\n", filename);
gaim_debug_misc("gayminfo", "path: %s\n", path);
if (!g_file_test(dir, G_FILE_TEST_EXISTS))
gaim_build_dir(dir, S_IRUSR | S_IWUSR | S_IXUSR);
if (path && !g_file_test(path, G_FILE_TEST_EXISTS)) {
FILE *file;
if ((file = g_fopen(path, "wb"))) {
fwrite(pic_data, 1, len, file);
fclose(file);
} else {
gaim_debug_misc("fetch_thumbnail_cb",
"Couldn't write file\n");
}
g_free(filename);
g_free(path);
g_free(dir);
}
}
if (GAIM_CONNECTION_IS_VALID(d->gc) && len) {
gaim_signal_emit(gaim_accounts_get_handle(), "info-updated",
d->gc, NULL, d->who);
if (gaim_find_conversation_with_account(d->who, d->gc->account)) {
//gaim_buddy_icons_set_for_user(gaim_connection_get_account
// (d->gc), d->who,
// (void *) pic_data, len);
}
} else {
gaim_debug_error("gaym", "Fetching buddy icon failed.\n");
}
g_free(d->who);
g_free(d);
}
void gaym_fetch_thumbnail_cb(GaimUtilFetchUrlData *url_data, void *user_data, const gchar *pic_data,
gsize len, const gchar* error_message)
{
if (!user_data)
return;
struct gaym_fetch_thumbnail_data *d = user_data;
if (!pic_data) {
return;
}
if (!d->gc)
return;
if (len && !g_strrstr_len(pic_data, len, "Server Error")) {
gaim_debug_misc("gaym","Setting buddy icon for %s\n",d->who);
if(len<1024) {
void* new_pic_data=NULL;
gaim_debug_misc("gaym","Short icon file, padding to 1024\n");
new_pic_data=g_malloc0(1024);
memcpy(new_pic_data, pic_data, len);
len=1024;
gaim_buddy_icon_new(d->gc->account, d->who, (void*)new_pic_data, len);
g_free(new_pic_data);
}
else {
gaim_buddy_icon_new(d->gc->account, d->who, (void*)pic_data, len);
}
//GaimBuddyIcon *icon=gaim_buddy_icons_find(d->gc->account,d->who);
//guint len;
//const guchar* data=gaim_buddy_icon_get_data(icon, &len);
}
if (GAIM_CONNECTION_IS_VALID(d->gc) && len) {
gaim_signal_emit(gaim_accounts_get_handle(), "info-updated",
d->gc->account, d->who);
/* if (gaim_find_conversation_with_account(d->who, d->gc->account)) {
gaim_debug_misc("fetch_thumbnail_cb","setting buddy icon\n");
gaim_buddy_icons_set_for_user(gaim_connection_get_account
(d->gc), d->who,
(void *) pic_data, len);
}*/
} else {
gaim_debug_error("gaym", "Fetching buddy icon failed.\n");
}
g_free(d->who);
g_free(d);
}
void
gaim_core_quit(void)
{
GaimCoreUiOps *ops;
GaimCore *core = gaim_get_core();
#ifndef GAIM_SMALL_SCREEN
g_return_if_fail(core != NULL);
#else
if(core != NULL){
#endif
/* The self destruct sequence has been initiated */
gaim_signal_emit(gaim_get_core(), "quitting");
/* Transmission ends */
gaim_connections_disconnect_all();
/* Save .xml files, remove signals, etc. */
gaim_ssl_uninit();
gaim_pounces_uninit();
gaim_blist_uninit();
gaim_conversations_uninit();
gaim_connections_uninit();
gaim_buddy_icons_uninit();
gaim_accounts_uninit();
gaim_prefs_uninit();
gaim_debug(GAIM_DEBUG_INFO, "main", "Unloading all plugins\n");
gaim_plugins_destroy_all();
#ifdef GAIM_SMALL_SCREEN
}
#endif
ops = gaim_core_get_ui_ops();
if (ops != NULL && ops->quit != NULL)
ops->quit();
if(core != NULL) gaim_signals_uninit();
if (core != NULL && core->ui != NULL) {
g_free(core->ui);
core->ui = NULL;
}
if(core != NULL) g_free(core);
_core = NULL;
}
void
gaim_connection_register(GaimConnection *gc)
{
GaimAccount *account;
GaimConnectionUiOps *ops;
GaimPluginProtocolInfo *prpl_info = NULL;
g_return_if_fail(gc != NULL);
gaim_debug(GAIM_DEBUG_INFO, "connection",
"Registering. gc = %p\n", gc);
ops = gaim_get_connection_ui_ops();
if (gc->prpl != NULL)
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
else {
gchar *message = g_strdup_printf(_("Missing protocol plugin for %s"),
gaim_account_get_username(gaim_connection_get_account(gc)));
gaim_debug(GAIM_DEBUG_ERROR, "connection",
"Could not get prpl info for %p\n", gc);
gaim_notify_error(NULL, _("Registration Error"),
message, NULL);
g_free(message);
return;
}
account = gaim_connection_get_account(gc);
if (gaim_connection_get_state(gc) != GAIM_DISCONNECTED)
return;
gaim_connection_set_state(gc, GAIM_CONNECTING);
connections = g_list_append(connections, gc);
gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc);
/* set this so we don't auto-reconnect after registering */
gc->wants_to_die = TRUE;
gaim_debug(GAIM_DEBUG_INFO, "connection", "Calling register_user\n");
prpl_info->register_user(account);
}
void *
gaim_notify_userinfo(GaimConnection *gc, const char *who,
GaimNotifyUserInfo *user_info, GaimNotifyCloseCallback cb, gpointer user_data)
{
GaimNotifyUiOps *ops;
g_return_val_if_fail(who != NULL, NULL);
ops = gaim_notify_get_ui_ops();
if (ops != NULL && ops->notify_userinfo != NULL) {
GaimNotifyInfo *info;
info = g_new0(GaimNotifyInfo, 1);
info->type = GAIM_NOTIFY_USERINFO;
info->handle = gc;
gaim_signal_emit(gaim_notify_get_handle(), "displaying-userinfo",
gaim_connection_get_account(gc), who, user_info);
info->ui_handle = ops->notify_userinfo(gc, who, user_info);
info->cb = cb;
info->cb_user_data = user_data;
if (info->ui_handle != NULL) {
handles = g_list_append(handles, info);
return info->ui_handle;
} else {
if (info->cb != NULL)
info->cb(info->cb_user_data);
g_free(info);
return NULL;
}
} else {
if (cb != NULL)
cb(user_data);
}
return NULL;
}
gboolean
gaim_privacy_permit_remove(GaimAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *name;
GaimBuddy *buddy;
char *del;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = gaim_normalize(account, who);
for (l = account->permit; l != NULL; l = l->next) {
if (!gaim_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l == NULL)
return FALSE;
/* We should not free l->data just yet. There can be occasions where
* l->data == who. In such cases, freeing l->data here can cause crashes
* later when who is used. */
del = l->data;
account->permit = g_slist_delete_link(account->permit, l);
if (!local_only && gaim_account_is_connected(account))
serv_rem_permit(gaim_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_removed != NULL)
privacy_ops->permit_removed(account, who);
gaim_blist_schedule_save();
buddy = gaim_find_buddy(account, name);
if (buddy != NULL) {
gaim_signal_emit(gaim_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(del);
return TRUE;
}
gboolean
gaim_privacy_deny_remove(GaimAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *normalized;
char *name;
GaimBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
normalized = gaim_normalize(account, who);
for (l = account->deny; l != NULL; l = l->next) {
if (!gaim_utf8_strcasecmp(normalized, (char *)l->data))
break;
}
buddy = gaim_find_buddy(account, normalized);
if (l == NULL)
return FALSE;
name = l->data;
account->deny = g_slist_delete_link(account->deny, l);
if (!local_only && gaim_account_is_connected(account))
serv_rem_deny(gaim_account_get_connection(account), name);
if (privacy_ops != NULL && privacy_ops->deny_removed != NULL)
privacy_ops->deny_removed(account, who);
if (buddy != NULL) {
gaim_signal_emit(gaim_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(name);
gaim_blist_schedule_save();
return TRUE;
}
gboolean
gaim_privacy_permit_add(GaimAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
char *name;
GaimBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = g_strdup(gaim_normalize(account, who));
for (l = account->permit; l != NULL; l = l->next) {
if (!gaim_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l != NULL)
{
g_free(name);
return FALSE;
}
account->permit = g_slist_append(account->permit, name);
if (!local_only && gaim_account_is_connected(account))
serv_add_permit(gaim_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_added != NULL)
privacy_ops->permit_added(account, who);
gaim_blist_schedule_save();
/* This lets the UI know a buddy has had its privacy setting changed */
buddy = gaim_find_buddy(account, name);
if (buddy != NULL) {
gaim_signal_emit(gaim_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
return TRUE;
}
int irc_send(struct irc_conn *irc, const char *buf)
{
int ret, buflen;
char *tosend= g_strdup(buf);
gaim_signal_emit(_irc_plugin, "irc-sending-text", gaim_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
buflen = strlen(tosend);
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* gaim_debug(GAIM_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
gaim_connection_error(gaim_account_get_connection(irc->account),
_("Server has disconnected"));
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = gaim_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
GAIM_INPUT_WRITE, irc_send_cb, irc);
gaim_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
void
gaim_connection_set_state(GaimConnection *gc, GaimConnectionState state)
{
GaimConnectionUiOps *ops;
g_return_if_fail(gc != NULL);
if (gc->state == state)
return;
gc->state = state;
ops = gaim_get_connection_ui_ops();
if (gc->state == GAIM_CONNECTING) {
connections_connecting = g_list_append(connections_connecting, gc);
}
else {
connections_connecting = g_list_remove(connections_connecting, gc);
}
if (gc->state == GAIM_CONNECTED) {
GaimBlistNode *gnode,*cnode,*bnode;
GList *wins;
GList *add_buds=NULL;
/* Set the time the account came online */
time(&gc->login_time);
if (ops != NULL && ops->connected != NULL)
ops->connected(gc);
gaim_blist_show();
gaim_blist_add_account(gc->account);
/*
* XXX This is a hack! Remove this and replace it with a better event
* notification system.
*/
for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
GaimWindow *win = (GaimWindow *)wins->data;
gaim_conversation_update(gaim_window_get_conversation_at(win, 0),
GAIM_CONV_ACCOUNT_ONLINE);
}
gaim_signal_emit(gaim_connections_get_handle(), "signed-on", gc);
system_log(log_signon, gc, NULL,
OPT_LOG_BUDDY_SIGNON | OPT_LOG_MY_SIGNON);
#if 0
/* away option given? */
if (opt_away) {
away_on_login(opt_away_arg);
/* don't do it again */
opt_away = 0;
} else if (awaymessage) {
serv_set_away(gc, GAIM_AWAY_CUSTOM, awaymessage->message);
}
if (opt_away_arg != NULL) {
g_free(opt_away_arg);
opt_away_arg = NULL;
}
#endif
/* let the prpl know what buddies we pulled out of the local list */
for (gnode = gaim_get_blist()->root; gnode; gnode = gnode->next) {
if(!GAIM_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!GAIM_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
GaimBuddy *b;
if(!GAIM_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (GaimBuddy *)bnode;
if(b->account == gc->account) {
add_buds = g_list_append(add_buds, b->name);
}
}
}
}
if(add_buds) {
serv_add_buddies(gc, add_buds);
g_list_free(add_buds);
}
serv_set_permit_deny(gc);
}
else if (gc->state == GAIM_DISCONNECTED) {
if (ops != NULL && ops->disconnected != NULL)
ops->disconnected(gc);
}
}
void
gaim_connection_connect(GaimConnection *gc)
{
GaimAccount *account;
GaimConnectionUiOps *ops;
GaimPluginProtocolInfo *prpl_info = NULL;
g_return_if_fail(gc != NULL);
gaim_debug(GAIM_DEBUG_INFO, "connection",
"Connecting. gc = %p\n", gc);
ops = gaim_get_connection_ui_ops();
if (gc->prpl != NULL)
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl);
else {
gchar *message = g_strdup_printf(_("Missing protocol plugin for %s"),
gaim_account_get_username(gaim_connection_get_account(gc)));
gaim_debug(GAIM_DEBUG_ERROR, "connection",
"Could not get prpl info for %p\n", gc);
gaim_notify_error(NULL, _("Connection Error"),
message, NULL);
g_free(message);
return;
}
account = gaim_connection_get_account(gc);
if (gaim_connection_get_state(gc) != GAIM_DISCONNECTED)
return;
if (!(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
!(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL) &&
gaim_account_get_password(account) == NULL) {
gchar *primary;
gchar *escaped;
const gchar *username = gaim_account_get_username(account);
gaim_debug(GAIM_DEBUG_INFO, "connection", "Requesting password\n");
gaim_connection_destroy(gc);
escaped = g_markup_escape_text(username, strlen(username));
primary = g_strdup_printf(_("Enter password for %s"), escaped);
gaim_request_input(gc, NULL, primary, NULL, NULL, FALSE, TRUE,
_("OK"), G_CALLBACK(request_pass_ok_cb),
_("Cancel"), NULL, account);
g_free(primary);
g_free(escaped);
return;
}
gaim_connection_set_state(gc, GAIM_CONNECTING);
connections = g_list_append(connections, gc);
gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc);
gaim_debug(GAIM_DEBUG_INFO, "connection", "Calling serv_login\n");
serv_login(account);
}
void
gaim_connection_new(GaimAccount *account, gboolean regist, const char *password)
{
GaimConnection *gc;
GaimPlugin *prpl;
GaimPluginProtocolInfo *prpl_info;
g_return_if_fail(account != NULL);
if (!gaim_account_is_disconnected(account))
return;
prpl = gaim_find_prpl(gaim_account_get_protocol_id(account));
if (prpl != NULL)
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl);
else {
gchar *message;
message = g_strdup_printf(_("Missing protocol plugin for %s"),
gaim_account_get_username(account));
gaim_notify_error(NULL, regist ? _("Registration Error") :
_("Connection Error"), message, NULL);
g_free(message);
return;
}
if (regist)
{
if (prpl_info->register_user == NULL)
return;
}
else
{
if (((password == NULL) || (*password == '\0')) &&
!(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
!(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
{
gaim_debug_error("connection", "Can not connect to account %s without "
"a password.\n", gaim_account_get_username(account));
return;
}
}
gc = g_new0(GaimConnection, 1);
GAIM_DBUS_REGISTER_POINTER(gc, GaimConnection);
gc->prpl = prpl;
if ((password != NULL) && (*password != '\0'))
gc->password = g_strdup(password);
gaim_connection_set_account(gc, account);
gaim_connection_set_state(gc, GAIM_CONNECTING);
connections = g_list_append(connections, gc);
gaim_account_set_connection(account, gc);
gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc);
if (regist)
{
gaim_debug_info("connection", "Registering. gc = %p\n", gc);
/* set this so we don't auto-reconnect after registering */
gc->wants_to_die = TRUE;
prpl_info->register_user(account);
}
else
{
gaim_debug_info("connection", "Connecting. gc = %p\n", gc);
gaim_signal_emit(gaim_accounts_get_handle(), "account-connecting", account);
prpl_info->login(account);
}
}
void
gaim_connection_set_state(GaimConnection *gc, GaimConnectionState state)
{
GaimConnectionUiOps *ops;
g_return_if_fail(gc != NULL);
if (gc->state == state)
return;
gc->state = state;
ops = gaim_connections_get_ui_ops();
if (gc->state == GAIM_CONNECTING) {
connections_connecting = g_list_append(connections_connecting, gc);
}
else {
connections_connecting = g_list_remove(connections_connecting, gc);
}
if (gc->state == GAIM_CONNECTED) {
GaimAccount *account;
GaimPresence *presence;
account = gaim_connection_get_account(gc);
presence = gaim_account_get_presence(account);
/* Set the time the account came online */
gaim_presence_set_login_time(presence, time(NULL));
if (gaim_prefs_get_bool("/core/logging/log_system"))
{
GaimLog *log = gaim_account_get_log(account, TRUE);
if (log != NULL)
{
char *msg = g_strdup_printf(_("+++ %s signed on"),
gaim_account_get_username(account));
gaim_log_write(log, GAIM_MESSAGE_SYSTEM,
gaim_account_get_username(account),
gaim_presence_get_login_time(presence),
msg);
g_free(msg);
}
}
if (ops != NULL && ops->connected != NULL)
ops->connected(gc);
gaim_blist_add_account(account);
gaim_signal_emit(gaim_connections_get_handle(), "signed-on", gc);
serv_set_permit_deny(gc);
update_keepalive(gc, TRUE);
}
else if (gc->state == GAIM_DISCONNECTED) {
GaimAccount *account = gaim_connection_get_account(gc);
if (gaim_prefs_get_bool("/core/logging/log_system"))
{
GaimLog *log = gaim_account_get_log(account, FALSE);
if (log != NULL)
{
char *msg = g_strdup_printf(_("+++ %s signed off"),
gaim_account_get_username(account));
gaim_log_write(log, GAIM_MESSAGE_SYSTEM,
gaim_account_get_username(account), time(NULL),
msg);
g_free(msg);
}
}
gaim_account_destroy_log(account);
if (ops != NULL && ops->disconnected != NULL)
ops->disconnected(gc);
}
}
void
gaim_connection_destroy(GaimConnection *gc)
{
GaimAccount *account;
GSList *buddies, *tmp;
#if 0
GList *wins;
#endif
GaimPluginProtocolInfo *prpl_info = NULL;
gboolean remove = FALSE;
g_return_if_fail(gc != NULL);
account = gaim_connection_get_account(gc);
gaim_debug_info("connection", "Disconnecting connection %p\n", gc);
if (gaim_connection_get_state(gc) != GAIM_CONNECTING)
remove = TRUE;
gaim_signal_emit(gaim_connections_get_handle(), "signing-off", gc);
while (gc->buddy_chats)
{
GaimConversation *b = gc->buddy_chats->data;
gc->buddy_chats = g_slist_remove(gc->buddy_chats, b);
gaim_conv_chat_left(GAIM_CONV_CHAT(b));
}
update_keepalive(gc, FALSE);
gaim_proxy_connect_cancel_with_handle(gc);
prpl_info = GAIM_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 = gaim_find_buddies(account, NULL);
for (tmp = buddies; tmp; tmp = tmp->next) {
GaimBuddy *buddy = tmp->data;
buddy->proto_data = NULL;
}
g_slist_free(buddies);
connections = g_list_remove(connections, gc);
gaim_connection_set_state(gc, GAIM_DISCONNECTED);
if (remove)
gaim_blist_remove_account(account);
gaim_signal_emit(gaim_connections_get_handle(), "signed-off", gc);
#if 0
/* see comment later in file on if 0'd same code */
/*
* XXX This is a hack! Remove this and replace it with a better event
* notification system.
*/
for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
GaimConvWindow *win = (GaimConvWindow *)wins->data;
gaim_conversation_update(gaim_conv_window_get_conversation_at(win, 0),
GAIM_CONV_ACCOUNT_OFFLINE);
}
#endif
gaim_request_close_with_handle(gc);
gaim_notify_close_with_handle(gc);
gaim_debug_info("connection", "Destroying connection %p\n", gc);
gaim_account_set_connection(account, NULL);
g_free(gc->password);
g_free(gc->display_name);
if (gc->disconnect_timeout)
gaim_timeout_remove(gc->disconnect_timeout);
GAIM_DBUS_UNREGISTER_POINTER(gc);
g_free(gc);
}
