pidgin/pidgin

Remove documentation for non-public struct fields.

17 months ago, Elliott Sales de Andrade
7a330cab3546
Remove documentation for non-public struct fields.
/* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include "internal.h"
#include "accounts.h"
#include "core.h"
#include "debug.h"
#include "enums.h"
#include "network.h"
#include "pounce.h"
static PurpleAccountUiOps *account_ui_ops = NULL;
static GList *accounts = NULL;
static guint save_timer = 0;
static gboolean accounts_loaded = FALSE;
/*********************************************************************
* Writing to disk *
*********************************************************************/
static PurpleXmlNode *
accounts_to_xmlnode(void)
{
PurpleXmlNode *node, *child;
GList *cur;
node = purple_xmlnode_new("account");
purple_xmlnode_set_attrib(node, "version", "1.0");
for (cur = purple_accounts_get_all(); cur != NULL; cur = cur->next)
{
child = _purple_account_to_xmlnode(cur->data);
purple_xmlnode_insert_child(node, child);
}
return node;
}
static void
sync_accounts(void)
{
PurpleXmlNode *node;
char *data;
if (!accounts_loaded)
{
purple_debug_error("accounts", "Attempted to save accounts before "
"they were read!\n");
return;
}
node = accounts_to_xmlnode();
data = purple_xmlnode_to_formatted_str(node, NULL);
purple_util_write_data_to_config_file("accounts.xml", data, -1);
g_free(data);
purple_xmlnode_free(node);
}
static gboolean
save_cb(gpointer data)
{
sync_accounts();
save_timer = 0;
return FALSE;
}
void
purple_accounts_schedule_save(void)
{
if (save_timer == 0)
save_timer = g_timeout_add_seconds(5, save_cb, NULL);
}
static void
migrate_icq_server(PurpleAccount *account)
{
/* Migrate the login server setting for ICQ accounts. See
* 'mtn log --last 1 --no-graph --from b6d7712e90b68610df3bd2d8cbaf46d94c8b3794'
* for details on the change. */
if(purple_strequal(purple_account_get_protocol_id(account), "prpl-icq")) {
const char *tmp = purple_account_get_string(account, "server", NULL);
/* Non-secure server */
if(purple_strequal(tmp, "login.messaging.aol.com") ||
purple_strequal(tmp, "login.oscar.aol.com"))
purple_account_set_string(account, "server", "login.icq.com");
/* Secure server */
if(purple_strequal(tmp, "slogin.oscar.aol.com"))
purple_account_set_string(account, "server", "slogin.icq.com");
}
}
static void
migrate_xmpp_encryption(PurpleAccount *account)
{
/* When this is removed, nuke the "old_ssl" and "require_tls" settings */
if (g_str_equal(purple_account_get_protocol_id(account), "prpl-jabber")) {
const char *sec = purple_account_get_string(account, "connection_security", "");
if (g_str_equal("", sec)) {
const char *val = "require_tls";
if (purple_account_get_bool(account, "old_ssl", FALSE))
val = "old_ssl";
else if (!purple_account_get_bool(account, "require_tls", TRUE))
val = "opportunistic_tls";
purple_account_set_string(account, "connection_security", val);
}
}
}
static void
parse_settings(PurpleXmlNode *node, PurpleAccount *account)
{
const char *ui;
PurpleXmlNode *child;
/* Get the UI string, if these are UI settings */
ui = purple_xmlnode_get_attrib(node, "ui");
/* Read settings, one by one */
for (child = purple_xmlnode_get_child(node, "setting"); child != NULL;
child = purple_xmlnode_get_next_twin(child))
{
const char *name, *str_type;
PurplePrefType type;
char *data;
name = purple_xmlnode_get_attrib(child, "name");
if (name == NULL)
/* Ignore this setting */
continue;
str_type = purple_xmlnode_get_attrib(child, "type");
if (str_type == NULL)
/* Ignore this setting */
continue;
if (purple_strequal(str_type, "string"))
type = PURPLE_PREF_STRING;
else if (purple_strequal(str_type, "int"))
type = PURPLE_PREF_INT;
else if (purple_strequal(str_type, "bool"))
type = PURPLE_PREF_BOOLEAN;
else
/* Ignore this setting */
continue;
data = purple_xmlnode_get_data(child);
if (data == NULL)
/* Ignore this setting */
continue;
if (ui == NULL)
{
if (type == PURPLE_PREF_STRING)
purple_account_set_string(account, name, data);
else if (type == PURPLE_PREF_INT)
purple_account_set_int(account, name, atoi(data));
else if (type == PURPLE_PREF_BOOLEAN)
purple_account_set_bool(account, name,
(*data == '0' ? FALSE : TRUE));
} else {
if (type == PURPLE_PREF_STRING)
purple_account_set_ui_string(account, ui, name, data);
else if (type == PURPLE_PREF_INT)
purple_account_set_ui_int(account, ui, name, atoi(data));
else if (type == PURPLE_PREF_BOOLEAN)
purple_account_set_ui_bool(account, ui, name,
(*data == '0' ? FALSE : TRUE));
}
g_free(data);
}
/* we do this here because we need access to account settings to determine
* if we can/should migrate an ICQ account's server setting */
migrate_icq_server(account);
/* we do this here because we need to do it before the user views the
* Edit Account dialog. */
migrate_xmpp_encryption(account);
}
static GList *
parse_status_attrs(PurpleXmlNode *node, PurpleStatus *status)
{
GList *list = NULL;
PurpleXmlNode *child;
GValue *attr_value;
for (child = purple_xmlnode_get_child(node, "attribute"); child != NULL;
child = purple_xmlnode_get_next_twin(child))
{
const char *id = purple_xmlnode_get_attrib(child, "id");
const char *value = purple_xmlnode_get_attrib(child, "value");
if (!id || !*id || !value || !*value)
continue;
attr_value = purple_status_get_attr_value(status, id);
if (!attr_value)
continue;
list = g_list_append(list, (char *)id);
switch (G_VALUE_TYPE(attr_value))
{
case G_TYPE_STRING:
list = g_list_append(list, (char *)value);
break;
case G_TYPE_INT:
case G_TYPE_BOOLEAN:
{
int v;
if (sscanf(value, "%d", &v) == 1)
list = g_list_append(list, GINT_TO_POINTER(v));
else
list = g_list_remove(list, id);
break;
}
default:
break;
}
}
return list;
}
static void
parse_status(PurpleXmlNode *node, PurpleAccount *account)
{
gboolean active = FALSE;
const char *data;
const char *type;
PurpleXmlNode *child;
GList *attrs = NULL;
/* Get the active/inactive state */
data = purple_xmlnode_get_attrib(node, "active");
if (data == NULL)
return;
if (g_ascii_strcasecmp(data, "true") == 0)
active = TRUE;
else if (g_ascii_strcasecmp(data, "false") == 0)
active = FALSE;
else
return;
/* Get the type of the status */
type = purple_xmlnode_get_attrib(node, "type");
if (type == NULL)
return;
/* Read attributes into a GList */
child = purple_xmlnode_get_child(node, "attributes");
if (child != NULL)
{
attrs = parse_status_attrs(child,
purple_account_get_status(account, type));
}
purple_account_set_status_list(account, type, active, attrs);
g_list_free(attrs);
}
static void
parse_statuses(PurpleXmlNode *node, PurpleAccount *account)
{
PurpleXmlNode *child;
for (child = purple_xmlnode_get_child(node, "status"); child != NULL;
child = purple_xmlnode_get_next_twin(child))
{
parse_status(child, account);
}
}
static void
parse_proxy_info(PurpleXmlNode *node, PurpleAccount *account)
{
PurpleProxyInfo *proxy_info;
PurpleXmlNode *child;
char *data;
proxy_info = purple_proxy_info_new();
/* Use the global proxy settings, by default */
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_USE_GLOBAL);
/* Read proxy type */
child = purple_xmlnode_get_child(node, "type");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
if (purple_strequal(data, "global"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_USE_GLOBAL);
else if (purple_strequal(data, "none"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_NONE);
else if (purple_strequal(data, "http"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_HTTP);
else if (purple_strequal(data, "socks4"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_SOCKS4);
else if (purple_strequal(data, "socks5"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_SOCKS5);
else if (purple_strequal(data, "tor"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_TOR);
else if (purple_strequal(data, "envvar"))
purple_proxy_info_set_proxy_type(proxy_info, PURPLE_PROXY_USE_ENVVAR);
else
{
purple_debug_error("accounts", "Invalid proxy type found when "
"loading account information for %s\n",
purple_account_get_username(account));
}
g_free(data);
}
/* Read proxy host */
child = purple_xmlnode_get_child(node, "host");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
purple_proxy_info_set_host(proxy_info, data);
g_free(data);
}
/* Read proxy port */
child = purple_xmlnode_get_child(node, "port");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
purple_proxy_info_set_port(proxy_info, atoi(data));
g_free(data);
}
/* Read proxy username */
child = purple_xmlnode_get_child(node, "username");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
purple_proxy_info_set_username(proxy_info, data);
g_free(data);
}
/* Read proxy password */
child = purple_xmlnode_get_child(node, "password");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
purple_proxy_info_set_password(proxy_info, data);
g_free(data);
}
/* If there are no values set then proxy_info NULL */
if ((purple_proxy_info_get_proxy_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL) &&
(purple_proxy_info_get_host(proxy_info) == NULL) &&
(purple_proxy_info_get_port(proxy_info) == 0) &&
(purple_proxy_info_get_username(proxy_info) == NULL) &&
(purple_proxy_info_get_password(proxy_info) == NULL))
{
purple_proxy_info_destroy(proxy_info);
return;
}
purple_account_set_proxy_info(account, proxy_info);
}
static void
parse_current_error(PurpleXmlNode *node, PurpleAccount *account)
{
guint type;
char *type_str = NULL, *description = NULL;
PurpleXmlNode *child;
PurpleConnectionErrorInfo *current_error = NULL;
child = purple_xmlnode_get_child(node, "type");
if (child == NULL || (type_str = purple_xmlnode_get_data(child)) == NULL)
return;
type = atoi(type_str);
g_free(type_str);
if (type > PURPLE_CONNECTION_ERROR_OTHER_ERROR)
{
purple_debug_error("accounts",
"Invalid PurpleConnectionError value %d found when "
"loading account information for %s\n",
type, purple_account_get_username(account));
type = PURPLE_CONNECTION_ERROR_OTHER_ERROR;
}
child = purple_xmlnode_get_child(node, "description");
if (child)
description = purple_xmlnode_get_data(child);
if (description == NULL)
description = g_strdup("");
current_error = g_new0(PurpleConnectionErrorInfo, 1);
current_error->type = type;
current_error->description = description;
_purple_account_set_current_error(account, current_error);
}
static PurpleAccount *
parse_account(PurpleXmlNode *node)
{
PurpleAccount *ret;
PurpleXmlNode *child;
char *protocol_id = NULL;
char *name = NULL;
char *data;
child = purple_xmlnode_get_child(node, "protocol");
if (child != NULL)
protocol_id = purple_xmlnode_get_data(child);
child = purple_xmlnode_get_child(node, "name");
if (child != NULL)
name = purple_xmlnode_get_data(child);
if (name == NULL)
{
/* Do we really need to do this? */
child = purple_xmlnode_get_child(node, "username");
if (child != NULL)
name = purple_xmlnode_get_data(child);
}
if ((protocol_id == NULL) || (name == NULL))
{
g_free(protocol_id);
g_free(name);
return NULL;
}
ret = purple_account_new(name, protocol_id);
g_free(name);
g_free(protocol_id);
/* Read the alias */
child = purple_xmlnode_get_child(node, "alias");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
if (*data != '\0')
purple_account_set_private_alias(ret, data);
g_free(data);
}
/* Read the statuses */
child = purple_xmlnode_get_child(node, "statuses");
if (child != NULL)
{
parse_statuses(child, ret);
}
/* Read the userinfo */
child = purple_xmlnode_get_child(node, "userinfo");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
purple_account_set_user_info(ret, data);
g_free(data);
}
/* Read an old buddyicon */
child = purple_xmlnode_get_child(node, "buddyicon");
if ((child != NULL) && ((data = purple_xmlnode_get_data(child)) != NULL))
{
const char *dirname = purple_buddy_icons_get_cache_dir();
char *filename = g_build_filename(dirname, data, NULL);
gchar *contents;
gsize len;
if (g_file_get_contents(filename, &contents, &len, NULL))
{
purple_buddy_icons_set_account_icon(ret, (guchar *)contents, len);
}
g_free(filename);
g_free(data);
}
/* Read settings (both core and UI) */
for (child = purple_xmlnode_get_child(node, "settings"); child != NULL;
child = purple_xmlnode_get_next_twin(child))
{
parse_settings(child, ret);
}
/* Read proxy */
child = purple_xmlnode_get_child(node, "proxy");
if (child != NULL)
{
parse_proxy_info(child, ret);
}
/* Read current error */
child = purple_xmlnode_get_child(node, "current_error");
if (child != NULL)
{
parse_current_error(child, ret);
}
/* Read the password */
child = purple_xmlnode_get_child(node, "password");
if (child != NULL)
{
const char *keyring_id = purple_xmlnode_get_attrib(child, "keyring_id");
const char *mode = purple_xmlnode_get_attrib(child, "mode");
gboolean result;
data = purple_xmlnode_get_data(child);
result = purple_keyring_import_password(ret, keyring_id, mode, data, NULL);
if (result == TRUE || purple_keyring_get_inuse() == NULL) {
purple_account_set_remember_password(ret, TRUE);
} else {
purple_debug_error("accounts", "Failed to import password.\n");
}
purple_str_wipe(data);
}
return ret;
}
static void
load_accounts(void)
{
PurpleXmlNode *node, *child;
accounts_loaded = TRUE;
node = purple_util_read_xml_from_config_file("accounts.xml", _("accounts"));
if (node == NULL)
return;
for (child = purple_xmlnode_get_child(node, "account"); child != NULL;
child = purple_xmlnode_get_next_twin(child))
{
PurpleAccount *new_acct;
new_acct = parse_account(child);
purple_accounts_add(new_acct);
}
purple_xmlnode_free(node);
_purple_buddy_icons_account_loaded_cb();
}
void
purple_accounts_add(PurpleAccount *account)
{
g_return_if_fail(account != NULL);
if (g_list_find(accounts, account) != NULL)
return;
accounts = g_list_append(accounts, account);
purple_accounts_schedule_save();
purple_signal_emit(purple_accounts_get_handle(), "account-added", account);
}
void
purple_accounts_remove(PurpleAccount *account)
{
g_return_if_fail(account != NULL);
accounts = g_list_remove(accounts, account);
purple_accounts_schedule_save();
/* Clearing the error ensures that account-error-changed is emitted,
* which is the end of the guarantee that the the error's pointer is
* valid.
*/
purple_account_clear_current_error(account);
purple_signal_emit(purple_accounts_get_handle(), "account-removed", account);
}
static void
purple_accounts_delete_set(PurpleAccount *account, GError *error, gpointer data)
{
g_object_unref(G_OBJECT(account));
}
void
purple_accounts_delete(PurpleAccount *account)
{
PurpleBlistNode *gnode, *cnode, *bnode;
GList *iter;
g_return_if_fail(account != NULL);
/*
* Disable the account before blowing it out of the water.
* Conceptually it probably makes more sense to disable the
* account for all UIs rather than the just the current UI,
* but it doesn't really matter.
*/
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);
/* Remove this account's buddies */
for (gnode = purple_blist_get_default_root(); gnode != NULL;
gnode = purple_blist_node_get_sibling_next(gnode)) {
if (!PURPLE_IS_GROUP(gnode))
continue;
cnode = purple_blist_node_get_first_child(gnode);
while (cnode) {
PurpleBlistNode *cnode_next = purple_blist_node_get_sibling_next(cnode);
if(PURPLE_IS_CONTACT(cnode)) {
bnode = purple_blist_node_get_first_child(cnode);
while (bnode) {
PurpleBlistNode *bnode_next = purple_blist_node_get_sibling_next(bnode);
if (PURPLE_IS_BUDDY(bnode)) {
PurpleBuddy *b = (PurpleBuddy *)bnode;
if (purple_buddy_get_account(b) == account)
purple_blist_remove_buddy(b);
}
bnode = bnode_next;
}
} else if (PURPLE_IS_CHAT(cnode)) {
PurpleChat *c = (PurpleChat *)cnode;
if (purple_chat_get_account(c) == account)
purple_blist_remove_chat(c);
}
cnode = cnode_next;
}
}
/* Remove any open conversation for this account */
for (iter = purple_conversations_get_all(); iter; ) {
PurpleConversation *conv = iter->data;
iter = iter->next;
if (purple_conversation_get_account(conv) == account)
g_object_unref(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);
/* This is async because we do not want the
* account being overwritten before we are done.
*/
purple_keyring_set_password(account, NULL,
purple_accounts_delete_set, NULL);
}
void
purple_accounts_reorder(PurpleAccount *account, guint new_index)
{
gint index;
GList *l;
g_return_if_fail(account != NULL);
g_return_if_fail(new_index <= g_list_length(accounts));
index = g_list_index(accounts, account);
if (index < 0) {
purple_debug_error("accounts",
"Unregistered account (%s) discovered during reorder!\n",
purple_account_get_username(account));
return;
}
l = g_list_nth(accounts, index);
if (new_index > (guint)index)
new_index--;
/* Remove the old one. */
accounts = g_list_delete_link(accounts, l);
/* Insert it where it should go. */
accounts = g_list_insert(accounts, account, new_index);
purple_accounts_schedule_save();
}
GList *
purple_accounts_get_all(void)
{
return accounts;
}
GList *
purple_accounts_get_all_active(void)
{
GList *list = NULL;
GList *all = purple_accounts_get_all();
while (all != NULL) {
PurpleAccount *account = all->data;
if (purple_account_get_enabled(account, purple_core_get_ui()))
list = g_list_append(list, account);
all = all->next;
}
return list;
}
PurpleAccount *
purple_accounts_find(const char *name, const char *protocol_id)
{
PurpleAccount *account = NULL;
GList *l;
char *who;
g_return_val_if_fail(name != NULL, NULL);
g_return_val_if_fail(protocol_id != NULL, NULL);
for (l = purple_accounts_get_all(); l != NULL; l = l->next) {
account = (PurpleAccount *)l->data;
if (!purple_strequal(purple_account_get_protocol_id(account), protocol_id))
continue;
who = g_strdup(purple_normalize(account, name));
if (purple_strequal(purple_normalize(account, purple_account_get_username(account)), who)) {
g_free(who);
return account;
}
g_free(who);
}
return NULL;
}
void
purple_accounts_restore_current_statuses()
{
GList *l;
PurpleAccount *account;
/* If we're not connected to the Internet right now, we bail on this */
if (!purple_network_is_available())
{
purple_debug_warning("accounts", "Network not connected; skipping reconnect\n");
return;
}
for (l = purple_accounts_get_all(); l != NULL; l = l->next)
{
account = (PurpleAccount *)l->data;
if (purple_account_get_enabled(account, purple_core_get_ui()) &&
(purple_presence_is_online(purple_account_get_presence(account))))
{
purple_account_connect(account);
}
}
}
static PurpleAccountUiOps *
purple_account_ui_ops_copy(PurpleAccountUiOps *ops)
{
PurpleAccountUiOps *ops_new;
g_return_val_if_fail(ops != NULL, NULL);
ops_new = g_new(PurpleAccountUiOps, 1);
*ops_new = *ops;
return ops_new;
}
GType
purple_account_ui_ops_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleAccountUiOps",
(GBoxedCopyFunc)purple_account_ui_ops_copy,
(GBoxedFreeFunc)g_free);
}
return type;
}
void
purple_accounts_set_ui_ops(PurpleAccountUiOps *ops)
{
account_ui_ops = ops;
}
PurpleAccountUiOps *
purple_accounts_get_ui_ops(void)
{
return account_ui_ops;
}
void *
purple_accounts_get_handle(void)
{
static int handle;
return &handle;
}
static void
signed_on_cb(PurpleConnection *gc,
gpointer unused)
{
PurpleAccount *account = purple_connection_get_account(gc);
purple_account_clear_current_error(account);
purple_signal_emit(purple_accounts_get_handle(), "account-signed-on",
account);
}
static void
signed_off_cb(PurpleConnection *gc,
gpointer unused)
{
PurpleAccount *account = purple_connection_get_account(gc);
purple_signal_emit(purple_accounts_get_handle(), "account-signed-off",
account);
}
static void
connection_error_cb(PurpleConnection *gc,
PurpleConnectionError type,
const gchar *description,
gpointer unused)
{
PurpleAccount *account;
PurpleConnectionErrorInfo *err;
account = purple_connection_get_account(gc);
g_return_if_fail(account != NULL);
err = g_new0(PurpleConnectionErrorInfo, 1);
err->type = type;
err->description = g_strdup(description);
_purple_account_set_current_error(account, err);
purple_signal_emit(purple_accounts_get_handle(), "account-connection-error",
account, type, description);
}
static void
password_migration_cb(PurpleAccount *account)
{
/* account may be NULL (means: all) */
purple_accounts_schedule_save();
}
void
purple_accounts_init(void)
{
void *handle = purple_accounts_get_handle();
void *conn_handle = purple_connections_get_handle();
purple_signal_register(handle, "account-connecting",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-disabled",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-enabled",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-setting-info",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
PURPLE_TYPE_ACCOUNT, G_TYPE_STRING);
purple_signal_register(handle, "account-set-info",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
PURPLE_TYPE_ACCOUNT, G_TYPE_STRING);
purple_signal_register(handle, "account-created",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-destroying",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-added",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-removed",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-status-changing",
purple_marshal_VOID__POINTER_POINTER_POINTER,
G_TYPE_NONE, 3, PURPLE_TYPE_ACCOUNT,
PURPLE_TYPE_STATUS, PURPLE_TYPE_STATUS);
purple_signal_register(handle, "account-status-changed",
purple_marshal_VOID__POINTER_POINTER_POINTER,
G_TYPE_NONE, 3, PURPLE_TYPE_ACCOUNT,
PURPLE_TYPE_STATUS, PURPLE_TYPE_STATUS);
purple_signal_register(handle, "account-actions-changed",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-alias-changed",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
PURPLE_TYPE_ACCOUNT, G_TYPE_STRING);
purple_signal_register(handle, "account-authorization-requested",
purple_marshal_INT__POINTER_POINTER_POINTER,
G_TYPE_INT, 4, PURPLE_TYPE_ACCOUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
purple_signal_register(handle, "account-authorization-denied",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 3,
PURPLE_TYPE_ACCOUNT, G_TYPE_STRING, G_TYPE_STRING);
purple_signal_register(handle, "account-authorization-granted",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 3,
PURPLE_TYPE_ACCOUNT, G_TYPE_STRING, G_TYPE_STRING);
purple_signal_register(handle, "account-error-changed",
purple_marshal_VOID__POINTER_POINTER_POINTER,
G_TYPE_NONE, 3, PURPLE_TYPE_ACCOUNT,
PURPLE_TYPE_CONNECTION_ERROR_INFO,
PURPLE_TYPE_CONNECTION_ERROR_INFO);
purple_signal_register(handle, "account-signed-on",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-signed-off",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_ACCOUNT);
purple_signal_register(handle, "account-connection-error",
purple_marshal_VOID__POINTER_INT_POINTER,
G_TYPE_NONE, 3, PURPLE_TYPE_ACCOUNT,
PURPLE_TYPE_CONNECTION_ERROR, G_TYPE_STRING);
purple_signal_connect(conn_handle, "signed-on", handle,
PURPLE_CALLBACK(signed_on_cb), NULL);
purple_signal_connect(conn_handle, "signed-off", handle,
PURPLE_CALLBACK(signed_off_cb), NULL);
purple_signal_connect(conn_handle, "connection-error", handle,
PURPLE_CALLBACK(connection_error_cb), NULL);
purple_signal_connect(purple_keyring_get_handle(), "password-migration", handle,
PURPLE_CALLBACK(password_migration_cb), NULL);
load_accounts();
}
void
purple_accounts_uninit(void)
{
gpointer handle = purple_accounts_get_handle();
if (save_timer != 0)
{
g_source_remove(save_timer);
save_timer = 0;
sync_accounts();
}
for (; accounts; accounts = g_list_delete_link(accounts, accounts))
g_object_unref(G_OBJECT(accounts->data));
purple_signals_disconnect_by_handle(handle);
purple_signals_unregister_by_instance(handle);
}