Mercurial > pidgin
view libpurple/connection.c @ 26180:b03430dae08e
Add xmlnode_set_attrib_full that enables you to set an attribute with both
a prefix and a namespace. Also, change xmlnode_remove_attribute to remove
all existing attributes that match the name. Otherwise, it would just take
out the first one, and may not do what you want.
Change Bonjour and XMPP to use the new function.
References #7681.
Fixes #8318.
author | Elliott Sales de Andrade <qulogic@pidgin.im> |
---|---|
date | Fri, 13 Mar 2009 04:29:11 +0000 |
parents | 584063555949 |
children | aa2a2eae9c3e |
line wrap: on
line source
/** * @file connection.c Connection API * @ingroup core */ /* 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 */ #define _PURPLE_CONNECTION_C_ #include "internal.h" #include "account.h" #include "blist.h" #include "connection.h" #include "dbus-maybe.h" #include "debug.h" #include "log.h" #include "notify.h" #include "prefs.h" #include "proxy.h" #include "request.h" #include "server.h" #include "signals.h" #include "util.h" #define KEEPALIVE_INTERVAL 30 static GList *connections = NULL; static GList *connections_connecting = NULL; static PurpleConnectionUiOps *connection_ui_ops = NULL; static int connections_handle; static gboolean send_keepalive(gpointer data) { PurpleConnection *gc = data; PurplePluginProtocolInfo *prpl_info = NULL; if (gc == NULL) return TRUE; /* Only send keep-alives if we haven't heard from the * server in a while. */ if ((time(NULL) - gc->last_received) < KEEPALIVE_INTERVAL) return TRUE; if (gc->prpl == NULL) return TRUE; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->keepalive) prpl_info->keepalive(gc); return TRUE; } static void update_keepalive(PurpleConnection *gc, gboolean on) { PurplePluginProtocolInfo *prpl_info = NULL; if (gc != NULL && gc->prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (!prpl_info || !prpl_info->keepalive) return; if (on && !gc->keepalive) { purple_debug_info("connection", "Activating keepalive.\n"); gc->keepalive = purple_timeout_add_seconds(KEEPALIVE_INTERVAL, send_keepalive, gc); } else if (!on && gc->keepalive > 0) { purple_debug_info("connection", "Deactivating keepalive.\n"); purple_timeout_remove(gc->keepalive); gc->keepalive = 0; } } void purple_connection_new(PurpleAccount *account, gboolean regist, const char *password) { _purple_connection_new(account, regist, password); } void _purple_connection_new(PurpleAccount *account, gboolean regist, const char *password) { PurpleConnection *gc; PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info; g_return_if_fail(account != NULL); if (!purple_account_is_disconnected(account)) return; prpl = purple_find_prpl(purple_account_get_protocol_id(account)); if (prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); else { gchar *message; message = g_strdup_printf(_("Missing protocol plugin for %s"), purple_account_get_username(account)); purple_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)) { purple_debug_error("connection", "Can not connect to account %s without " "a password.\n", purple_account_get_username(account)); return; } } gc = g_new0(PurpleConnection, 1); PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection); gc->prpl = prpl; if ((password != NULL) && (*password != '\0')) gc->password = g_strdup(password); purple_connection_set_account(gc, account); purple_connection_set_state(gc, PURPLE_CONNECTING); connections = g_list_append(connections, gc); purple_account_set_connection(account, gc); purple_signal_emit(purple_connections_get_handle(), "signing-on", gc); if (regist) { purple_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 { purple_debug_info("connection", "Connecting. gc = %p\n", gc); purple_signal_emit(purple_accounts_get_handle(), "account-connecting", account); prpl_info->login(account); } } void purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data) { _purple_connection_new_unregister(account, password, cb, user_data); } void _purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data) { /* Lots of copy/pasted code to avoid API changes. You might want to integrate that into the previous function when posssible. */ PurpleConnection *gc; PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info; g_return_if_fail(account != NULL); prpl = purple_find_prpl(purple_account_get_protocol_id(account)); if (prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); else { gchar *message; message = g_strdup_printf(_("Missing protocol plugin for %s"), purple_account_get_username(account)); purple_notify_error(NULL, _("Unregistration Error"), message, NULL); g_free(message); return; } if (!purple_account_is_disconnected(account)) { prpl_info->unregister_user(account, cb, user_data); return; } if (((password == NULL) || (*password == '\0')) && !(prpl_info->options & OPT_PROTO_NO_PASSWORD) && !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL)) { purple_debug_error("connection", "Can not connect to account %s without " "a password.\n", purple_account_get_username(account)); return; } gc = g_new0(PurpleConnection, 1); PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection); gc->prpl = prpl; if ((password != NULL) && (*password != '\0')) gc->password = g_strdup(password); purple_connection_set_account(gc, account); purple_connection_set_state(gc, PURPLE_CONNECTING); connections = g_list_append(connections, gc); purple_account_set_connection(account, gc); purple_signal_emit(purple_connections_get_handle(), "signing-on", gc); purple_debug_info("connection", "Unregistering. gc = %p\n", gc); prpl_info->unregister_user(account, cb, user_data); } void purple_connection_destroy(PurpleConnection *gc) { _purple_connection_destroy(gc); } 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) purple_timeout_remove(gc->disconnect_timeout); PURPLE_DBUS_UNREGISTER_POINTER(gc); g_free(gc); } /* * d:)->-< * * d:O-\-< * * d:D-/-< * * d8D->-< DANCE! */ void purple_connection_set_state(PurpleConnection *gc, PurpleConnectionState state) { PurpleConnectionUiOps *ops; g_return_if_fail(gc != NULL); if (gc->state == state) return; gc->state = state; ops = purple_connections_get_ui_ops(); if (gc->state == PURPLE_CONNECTING) { connections_connecting = g_list_append(connections_connecting, gc); } else { connections_connecting = g_list_remove(connections_connecting, gc); } if (gc->state == PURPLE_CONNECTED) { PurpleAccount *account; PurplePresence *presence; account = purple_connection_get_account(gc); presence = purple_account_get_presence(account); /* Set the time the account came online */ purple_presence_set_login_time(presence, time(NULL)); if (purple_prefs_get_bool("/purple/logging/log_system")) { PurpleLog *log = purple_account_get_log(account, TRUE); if (log != NULL) { char *msg = g_strdup_printf(_("+++ %s signed on"), purple_account_get_username(account)); purple_log_write(log, PURPLE_MESSAGE_SYSTEM, purple_account_get_username(account), purple_presence_get_login_time(presence), msg); g_free(msg); } } if (ops != NULL && ops->connected != NULL) ops->connected(gc); purple_blist_add_account(account); purple_signal_emit(purple_connections_get_handle(), "signed-on", gc); serv_set_permit_deny(gc); update_keepalive(gc, TRUE); } else if (gc->state == PURPLE_DISCONNECTED) { PurpleAccount *account = purple_connection_get_account(gc); if (purple_prefs_get_bool("/purple/logging/log_system")) { PurpleLog *log = purple_account_get_log(account, FALSE); if (log != NULL) { char *msg = g_strdup_printf(_("+++ %s signed off"), purple_account_get_username(account)); purple_log_write(log, PURPLE_MESSAGE_SYSTEM, purple_account_get_username(account), time(NULL), msg); g_free(msg); } } purple_account_destroy_log(account); if (ops != NULL && ops->disconnected != NULL) ops->disconnected(gc); } } void purple_connection_set_account(PurpleConnection *gc, PurpleAccount *account) { g_return_if_fail(gc != NULL); g_return_if_fail(account != NULL); gc->account = account; } void purple_connection_set_display_name(PurpleConnection *gc, const char *name) { g_return_if_fail(gc != NULL); g_free(gc->display_name); gc->display_name = g_strdup(name); } void purple_connection_set_protocol_data(PurpleConnection *connection, void *proto_data) { g_return_if_fail(connection != NULL); connection->proto_data = proto_data; } PurpleConnectionState purple_connection_get_state(const PurpleConnection *gc) { g_return_val_if_fail(gc != NULL, PURPLE_DISCONNECTED); return gc->state; } PurpleAccount * purple_connection_get_account(const PurpleConnection *gc) { g_return_val_if_fail(gc != NULL, NULL); return gc->account; } PurplePlugin * purple_connection_get_prpl(const PurpleConnection *gc) { g_return_val_if_fail(gc != NULL, NULL); return gc->prpl; } const char * purple_connection_get_password(const PurpleConnection *gc) { g_return_val_if_fail(gc != NULL, NULL); return gc->password ? gc->password : gc->account->password; } const char * purple_connection_get_display_name(const PurpleConnection *gc) { g_return_val_if_fail(gc != NULL, NULL); return gc->display_name; } void * purple_connection_get_protocol_data(const PurpleConnection *connection) { g_return_val_if_fail(connection != NULL, NULL); return connection->proto_data; } void purple_connection_update_progress(PurpleConnection *gc, const char *text, size_t step, size_t count) { PurpleConnectionUiOps *ops; g_return_if_fail(gc != NULL); g_return_if_fail(text != NULL); g_return_if_fail(step < count); g_return_if_fail(count > 1); ops = purple_connections_get_ui_ops(); if (ops != NULL && ops->connect_progress != NULL) ops->connect_progress(gc, text, step, count); } void purple_connection_notice(PurpleConnection *gc, const char *text) { PurpleConnectionUiOps *ops; g_return_if_fail(gc != NULL); g_return_if_fail(text != NULL); ops = purple_connections_get_ui_ops(); if (ops != NULL && ops->notice != NULL) ops->notice(gc, text); } static gboolean purple_connection_disconnect_cb(gpointer data) { PurpleAccount *account = data; char *password = g_strdup(purple_account_get_password(account)); purple_account_disconnect(account); purple_account_set_password(account, password); g_free(password); return FALSE; } void purple_connection_error(PurpleConnection *gc, const char *text) { /* prpls that have not been updated to use disconnection reasons will * be setting wants_to_die before calling this function, so choose * PURPLE_CONNECTION_ERROR_OTHER_ERROR (which is fatal) if it's true, * and PURPLE_CONNECTION_ERROR_NETWORK_ERROR (which isn't) if not. See * the documentation in connection.h. */ PurpleConnectionError reason = gc->wants_to_die ? PURPLE_CONNECTION_ERROR_OTHER_ERROR : PURPLE_CONNECTION_ERROR_NETWORK_ERROR; purple_connection_error_reason (gc, reason, text); } void purple_connection_error_reason (PurpleConnection *gc, PurpleConnectionError reason, const char *description) { PurpleConnectionUiOps *ops; g_return_if_fail(gc != NULL); /* This sanity check relies on PURPLE_CONNECTION_ERROR_OTHER_ERROR * being the last member of the PurpleConnectionError enum in * connection.h; if other reasons are added after it, this check should * be updated. */ if (reason > PURPLE_CONNECTION_ERROR_OTHER_ERROR) { purple_debug_error("connection", "purple_connection_error_reason: reason %u isn't a " "valid reason\n", reason); reason = PURPLE_CONNECTION_ERROR_OTHER_ERROR; } if (description == NULL) { purple_debug_error("connection", "purple_connection_error_reason called with NULL description\n"); description = _("Unknown error"); } /* If we've already got one error, we don't need any more */ if (gc->disconnect_timeout) return; gc->wants_to_die = purple_connection_error_is_fatal (reason); ops = purple_connections_get_ui_ops(); if (ops != NULL) { if (ops->report_disconnect_reason != NULL) ops->report_disconnect_reason (gc, reason, description); if (ops->report_disconnect != NULL) ops->report_disconnect (gc, description); } purple_signal_emit(purple_connections_get_handle(), "connection-error", gc, reason, description); gc->disconnect_timeout = purple_timeout_add(0, purple_connection_disconnect_cb, purple_connection_get_account(gc)); } void purple_connection_ssl_error (PurpleConnection *gc, PurpleSslErrorType ssl_error) { PurpleConnectionError reason; switch (ssl_error) { case PURPLE_SSL_HANDSHAKE_FAILED: reason = PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR; break; case PURPLE_SSL_CONNECT_FAILED: reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR; break; case PURPLE_SSL_CERTIFICATE_INVALID: /* TODO: maybe PURPLE_SSL_* should be more specific? */ reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR; break; default: g_assert_not_reached (); reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR; } purple_connection_error_reason (gc, reason, purple_ssl_strerror(ssl_error)); } gboolean purple_connection_error_is_fatal (PurpleConnectionError reason) { switch (reason) { case PURPLE_CONNECTION_ERROR_NETWORK_ERROR: case PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR: return FALSE; case PURPLE_CONNECTION_ERROR_INVALID_USERNAME: case PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED: case PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE: case PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT: case PURPLE_CONNECTION_ERROR_NAME_IN_USE: case PURPLE_CONNECTION_ERROR_INVALID_SETTINGS: case PURPLE_CONNECTION_ERROR_OTHER_ERROR: case PURPLE_CONNECTION_ERROR_CERT_NOT_PROVIDED: case PURPLE_CONNECTION_ERROR_CERT_UNTRUSTED: case PURPLE_CONNECTION_ERROR_CERT_EXPIRED: case PURPLE_CONNECTION_ERROR_CERT_NOT_ACTIVATED: case PURPLE_CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH: case PURPLE_CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH: case PURPLE_CONNECTION_ERROR_CERT_SELF_SIGNED: case PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR: return TRUE; default: g_return_val_if_reached(TRUE); } } void purple_connections_disconnect_all(void) { GList *l; PurpleConnection *gc; while ((l = purple_connections_get_all()) != NULL) { gc = l->data; gc->wants_to_die = TRUE; purple_account_disconnect(gc->account); } } GList * purple_connections_get_all(void) { return connections; } GList * purple_connections_get_connecting(void) { return connections_connecting; } void purple_connections_set_ui_ops(PurpleConnectionUiOps *ops) { connection_ui_ops = ops; } PurpleConnectionUiOps * purple_connections_get_ui_ops(void) { return connection_ui_ops; } void purple_connections_init(void) { void *handle = purple_connections_get_handle(); purple_signal_register(handle, "signing-on", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_CONNECTION)); purple_signal_register(handle, "signed-on", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_CONNECTION)); purple_signal_register(handle, "signing-off", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_CONNECTION)); purple_signal_register(handle, "signed-off", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_CONNECTION)); purple_signal_register(handle, "connection-error", purple_marshal_VOID__POINTER_INT_POINTER, NULL, 3, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_CONNECTION), purple_value_new(PURPLE_TYPE_ENUM), purple_value_new(PURPLE_TYPE_STRING)); } void purple_connections_uninit(void) { purple_signals_unregister_by_instance(purple_connections_get_handle()); } void * purple_connections_get_handle(void) { return &connections_handle; }