pidgin/pidgin

Increase timeout for initial XDP portal session to 2s
release-2.x.y
2020-04-05, David Woodhouse
87d96850a2d7
Increase timeout for initial XDP portal session to 2s

It should still fail immediately when the portal isn't available, but
in my test VM with systemd automatically activating the portal when it's
first accessed, it can take 800ms or so. Wait for it instead of falling
back after 200ms.
/**
* @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;
/* 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;
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (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", "Cannot 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", "Cannot 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 > 0)
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);
purple_signal_emit_return_1(purple_connections_get_handle(), "autojoin", 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;
PurpleConnection *gc;
char *password;
account = data;
gc = purple_account_get_connection(account);
if (gc != NULL)
gc->disconnect_timeout = 0;
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 > 0)
return;
gc->wants_to_die = purple_connection_error_is_fatal (reason);
purple_debug_info("connection", "Connection error on %p (reason: %u description: %s)\n",
gc, reason, description);
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));
purple_signal_register(handle, "autojoin",
purple_marshal_BOOLEAN__POINTER, NULL, 1,
purple_value_new(PURPLE_TYPE_SUBTYPE,
PURPLE_SUBTYPE_CONNECTION));
}
void
purple_connections_uninit(void)
{
purple_signals_unregister_by_instance(purple_connections_get_handle());
}
void *
purple_connections_get_handle(void)
{
return &connections_handle;
}