pidgin/pidgin

Replace purple_get_host_name by g_get_host_name.

18 months ago, Elliott Sales de Andrade
e353b2390ad8
Replace purple_get_host_name by g_get_host_name.
/*
* 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 "conversation.h"
#include "debug.h"
#include "network.h"
#include "notify.h"
#include "protocol.h"
#include "purpleaccountoption.h"
#include "request.h"
#include "util.h"
static GHashTable *protocols = NULL;
/**************************************************************************
* GBoxed code for PurpleProtocolChatEntry
**************************************************************************/
static PurpleProtocolChatEntry *
purple_protocol_chat_entry_copy(PurpleProtocolChatEntry *pce)
{
PurpleProtocolChatEntry *pce_copy;
g_return_val_if_fail(pce != NULL, NULL);
pce_copy = g_new(PurpleProtocolChatEntry, 1);
*pce_copy = *pce;
return pce_copy;
}
GType
purple_protocol_chat_entry_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleProtocolChatEntry",
(GBoxedCopyFunc)purple_protocol_chat_entry_copy,
(GBoxedFreeFunc)g_free);
}
return type;
}
/**************************************************************************/
/* Protocol API */
/**************************************************************************/
void
purple_protocol_got_account_idle(PurpleAccount *account, gboolean idle,
time_t idle_time)
{
g_return_if_fail(account != NULL);
g_return_if_fail(purple_account_is_connected(account));
purple_presence_set_idle(purple_account_get_presence(account),
idle, idle_time);
}
void
purple_protocol_got_account_login_time(PurpleAccount *account, time_t login_time)
{
PurplePresence *presence;
g_return_if_fail(account != NULL);
g_return_if_fail(purple_account_is_connected(account));
if (login_time == 0)
login_time = time(NULL);
presence = purple_account_get_presence(account);
purple_presence_set_login_time(presence, login_time);
}
void
purple_protocol_got_account_status(PurpleAccount *account, const char *status_id, ...)
{
PurplePresence *presence;
PurpleStatus *status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account));
presence = purple_account_get_presence(account);
status = purple_presence_get_status(presence, status_id);
g_return_if_fail(status != NULL);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
}
void
purple_protocol_got_account_actions(PurpleAccount *account)
{
g_return_if_fail(account != NULL);
g_return_if_fail(purple_account_is_connected(account));
purple_signal_emit(purple_accounts_get_handle(), "account-actions-changed",
account);
}
void
purple_protocol_got_user_idle(PurpleAccount *account, const char *name,
gboolean idle, time_t idle_time)
{
PurplePresence *presence;
GSList *list;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if ((list = purple_blist_find_buddies(account, name)) == NULL)
return;
while (list) {
presence = purple_buddy_get_presence(list->data);
list = g_slist_delete_link(list, list);
purple_presence_set_idle(presence, idle, idle_time);
}
}
void
purple_protocol_got_user_login_time(PurpleAccount *account, const char *name,
time_t login_time)
{
GSList *list;
PurplePresence *presence;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_blist_find_buddies(account, name)) == NULL)
return;
if (login_time == 0)
login_time = time(NULL);
while (list) {
PurpleBuddy *buddy = list->data;
presence = purple_buddy_get_presence(buddy);
list = g_slist_delete_link(list, list);
if (purple_presence_get_login_time(presence) != login_time)
{
purple_presence_set_login_time(presence, login_time);
purple_signal_emit(purple_blist_get_handle(), "buddy-got-login-time", buddy);
}
}
}
void
purple_protocol_got_user_status(PurpleAccount *account, const char *name,
const char *status_id, ...)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
PurpleStatus *old_status;
va_list args;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_blist_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
/*
* TODO: This should never happen, right? We should call
* g_warning() or something.
*/
continue;
old_status = purple_presence_get_active_status(presence);
va_start(args, status_id);
purple_status_set_active_with_attrs(status, TRUE, args);
va_end(args);
purple_buddy_update_status(buddy, old_status);
}
g_slist_free(list);
/* The buddy is no longer online, they are therefore by definition not
* still typing to us. */
if (!purple_status_is_online(status)) {
purple_serv_got_typing_stopped(purple_account_get_connection(account), name);
purple_protocol_got_media_caps(account, name);
}
}
void purple_protocol_got_user_status_deactive(PurpleAccount *account, const char *name,
const char *status_id)
{
GSList *list, *l;
PurpleBuddy *buddy;
PurplePresence *presence;
PurpleStatus *status;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
g_return_if_fail(status_id != NULL);
g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
if((list = purple_blist_find_buddies(account, name)) == NULL)
return;
for(l = list; l != NULL; l = l->next) {
buddy = l->data;
presence = purple_buddy_get_presence(buddy);
status = purple_presence_get_status(presence, status_id);
if(NULL == status)
continue;
if (purple_status_is_active(status)) {
purple_status_set_active(status, FALSE);
purple_buddy_update_status(buddy, status);
}
}
g_slist_free(list);
}
static void
do_protocol_change_account_status(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
PurpleProtocol *protocol;
if (purple_status_is_online(new_status) &&
purple_account_is_disconnected(account) &&
purple_network_is_available())
{
purple_account_connect(account);
return;
}
if (!purple_status_is_online(new_status))
{
if (!purple_account_is_disconnected(account))
purple_account_disconnect(account);
/* Clear out the unsaved password if we switch to offline status */
if (!purple_account_get_remember_password(account))
purple_account_set_password(account, NULL, NULL, NULL);
return;
}
if (purple_account_is_connecting(account))
/*
* We don't need to call the set_status protocol function because
* the protocol will take care of setting its status during the
* connection process.
*/
return;
protocol = purple_protocols_find(purple_account_get_protocol_id(account));
if (protocol == NULL)
return;
if (!purple_account_is_disconnected(account))
purple_protocol_server_iface_set_status(protocol, account, new_status);
}
void
purple_protocol_change_account_status(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
g_return_if_fail(account != NULL);
g_return_if_fail(new_status != NULL);
g_return_if_fail(!purple_status_is_exclusive(new_status) || old_status != NULL);
purple_signal_emit(purple_accounts_get_handle(), "account-status-changing",
account, old_status, new_status);
do_protocol_change_account_status(account, old_status, new_status);
purple_signal_emit(purple_accounts_get_handle(), "account-status-changed",
account, old_status, new_status);
}
GList *
purple_protocol_get_statuses(PurpleAccount *account, PurplePresence *presence)
{
GList *statuses = NULL;
GList *l;
PurpleStatus *status;
g_return_val_if_fail(account != NULL, NULL);
g_return_val_if_fail(presence != NULL, NULL);
for (l = purple_account_get_status_types(account); l != NULL; l = l->next)
{
status = purple_status_new((PurpleStatusType *)l->data, presence);
statuses = g_list_prepend(statuses, status);
}
statuses = g_list_reverse(statuses);
return statuses;
}
static void
purple_protocol_attention(PurpleConversation *conv, const char *who,
guint type, PurpleMessageFlags flags, time_t mtime)
{
PurpleAccount *account = purple_conversation_get_account(conv);
purple_signal_emit(purple_conversations_get_handle(),
flags == PURPLE_MESSAGE_SEND ? "sent-attention" : "got-attention",
account, who, conv, type);
}
void
purple_protocol_send_attention(PurpleConnection *gc, const char *who, guint type_code)
{
PurpleAttentionType *attn;
PurpleProtocol *protocol;
PurpleIMConversation *im;
PurpleBuddy *buddy;
const char *alias;
gchar *description;
g_return_if_fail(gc != NULL);
g_return_if_fail(who != NULL);
protocol = purple_protocols_find(purple_account_get_protocol_id(purple_connection_get_account(gc)));
g_return_if_fail(PURPLE_IS_PROTOCOL_ATTENTION(protocol));
attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
alias = purple_buddy_get_contact_alias(buddy);
else
alias = who;
if (attn && purple_attention_type_get_outgoing_desc(attn)) {
description = g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias);
} else {
description = g_strdup_printf(_("Requesting %s's attention..."), alias);
}
purple_debug_info("server", "serv_send_attention: sending '%s' to %s\n",
description, who);
if (!purple_protocol_attention_send(PURPLE_PROTOCOL_ATTENTION(protocol), gc, who, type_code))
return;
im = purple_im_conversation_new(purple_connection_get_account(gc), who);
purple_conversation_write_system_message(PURPLE_CONVERSATION(im), description, 0);
purple_protocol_attention(PURPLE_CONVERSATION(im), who, type_code, PURPLE_MESSAGE_SEND, time(NULL));
g_free(description);
}
static void
got_attention(PurpleConnection *gc, int id, const char *who, guint type_code)
{
PurpleMessageFlags flags;
PurpleAttentionType *attn;
PurpleBuddy *buddy;
const char *alias;
gchar *description;
time_t mtime;
mtime = time(NULL);
attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
/* PURPLE_MESSAGE_NOTIFY is for attention messages. */
flags = PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_RECV;
/* TODO: if (attn->icon_name) is non-null, use it to lookup an emoticon and display
* it next to the attention command. And if it is null, display a generic icon. */
if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
alias = purple_buddy_get_contact_alias(buddy);
else
alias = who;
if (attn && purple_attention_type_get_incoming_desc(attn)) {
description = g_strdup_printf(purple_attention_type_get_incoming_desc(attn), alias);
} else {
description = g_strdup_printf(_("%s has requested your attention!"), alias);
}
purple_debug_info("server", "got_attention: got '%s' from %s\n",
description, who);
if (id == -1)
purple_serv_got_im(gc, who, description, flags, mtime);
else
purple_serv_got_chat_in(gc, id, who, flags, description, mtime);
/* TODO: sounds (depending on PurpleAttentionType), shaking, etc. */
g_free(description);
}
void
purple_protocol_got_attention(PurpleConnection *gc, const char *who, guint type_code)
{
PurpleConversation *conv = NULL;
PurpleAccount *account = purple_connection_get_account(gc);
got_attention(gc, -1, who, type_code);
conv =
purple_conversations_find_with_account(who, account);
if (conv)
purple_protocol_attention(conv, who, type_code, PURPLE_MESSAGE_RECV,
time(NULL));
}
void
purple_protocol_got_attention_in_chat(PurpleConnection *gc, int id, const char *who, guint type_code)
{
got_attention(gc, id, who, type_code);
}
gboolean
purple_protocol_initiate_media(PurpleAccount *account,
const char *who,
PurpleMediaSessionType type)
{
#ifdef USE_VV
PurpleConnection *gc = NULL;
PurpleProtocol *protocol = NULL;
if (account)
gc = purple_account_get_connection(account);
if (gc)
protocol = purple_connection_get_protocol(gc);
if (protocol) {
/* should check that the protocol supports this media type here? */
return purple_protocol_media_iface_initiate_session(protocol, account, who, type);
} else
#endif
return FALSE;
}
PurpleMediaCaps
purple_protocol_get_media_caps(PurpleAccount *account, const char *who)
{
#ifdef USE_VV
PurpleConnection *gc = NULL;
PurpleProtocol *protocol = NULL;
if (account)
gc = purple_account_get_connection(account);
if (gc)
protocol = purple_connection_get_protocol(gc);
if (protocol)
return purple_protocol_media_iface_get_caps(protocol, account, who);
#endif
return PURPLE_MEDIA_CAPS_NONE;
}
void
purple_protocol_got_media_caps(PurpleAccount *account, const char *name)
{
#ifdef USE_VV
GSList *list;
g_return_if_fail(account != NULL);
g_return_if_fail(name != NULL);
if ((list = purple_blist_find_buddies(account, name)) == NULL)
return;
while (list) {
PurpleBuddy *buddy = list->data;
PurpleMediaCaps oldcaps = purple_buddy_get_media_caps(buddy);
PurpleMediaCaps newcaps = 0;
const gchar *bname = purple_buddy_get_name(buddy);
list = g_slist_delete_link(list, list);
newcaps = purple_protocol_get_media_caps(account, bname);
purple_buddy_set_media_caps(buddy, newcaps);
if (oldcaps == newcaps)
continue;
purple_signal_emit(purple_blist_get_handle(),
"buddy-caps-changed", buddy,
newcaps, oldcaps);
}
#endif
}
gssize
purple_protocol_get_max_message_size(PurpleProtocol *protocol)
{
g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), 0);
return purple_protocol_client_iface_get_max_message_size(protocol, NULL);
}
/**************************************************************************
* Protocols API
**************************************************************************/
/*
* Negative if a before b, 0 if equal, positive if a after b.
*/
static gint
compare_protocol(PurpleProtocol *a, PurpleProtocol *b)
{
const gchar *aname = purple_protocol_get_name(a);
const gchar *bname = purple_protocol_get_name(b);
if (aname) {
if (bname)
return strcmp(aname, bname);
else
return -1;
} else {
if (bname)
return 1;
else
return 0;
}
}
PurpleProtocol *
purple_protocols_find(const char *id)
{
g_return_val_if_fail(protocols != NULL && id != NULL, NULL);
return g_hash_table_lookup(protocols, id);
}
PurpleProtocol *
purple_protocols_add(GType protocol_type, GError **error)
{
PurpleProtocol *protocol;
PurpleProtocolClass *klass;
if (protocol_type == G_TYPE_INVALID) {
g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol type is not registered"));
return NULL;
}
if (!g_type_is_a(protocol_type, PURPLE_TYPE_PROTOCOL)) {
g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol type does not inherit PurpleProtocol"));
return NULL;
}
if (G_TYPE_IS_ABSTRACT(protocol_type)) {
g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol type is abstract"));
return NULL;
}
protocol = g_object_new(protocol_type, NULL);
if (!protocol) {
g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Could not create protocol instance"));
return NULL;
}
if (!purple_protocol_get_id(protocol)) {
g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol does not provide an ID"));
g_object_unref(protocol);
return NULL;
}
if (purple_protocols_find(purple_protocol_get_id(protocol))) {
g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("A protocol with the ID %s is already added."),
purple_protocol_get_id(protocol));
g_object_unref(protocol);
return NULL;
}
/* Make sure the protocol implements the required functions */
klass = PURPLE_PROTOCOL_GET_CLASS(protocol);
if (!klass->login || !klass->close ||
!klass->status_types || !klass->list_icon )
{
g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol %s does not implement all the functions in "
"PurpleProtocolClass"), purple_protocol_get_id(protocol));
g_object_unref(protocol);
return NULL;
}
g_hash_table_insert(protocols, g_strdup(purple_protocol_get_id(protocol)),
protocol);
purple_debug_info("protocols", "Added protocol %s\n",
purple_protocol_get_id(protocol));
purple_signal_emit(purple_protocols_get_handle(), "protocol-added",
protocol);
return protocol;
}
gboolean purple_protocols_remove(PurpleProtocol *protocol, GError **error)
{
g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), FALSE);
g_return_val_if_fail(purple_protocol_get_id(protocol) != NULL, FALSE);
if (purple_protocols_find(purple_protocol_get_id(protocol)) == NULL) {
g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
_("Protocol %s is not added."),
purple_protocol_get_id(protocol));
return FALSE;
}
purple_debug_info("protocols", "Removing protocol %s\n",
purple_protocol_get_id(protocol));
purple_signal_emit(purple_protocols_get_handle(), "protocol-removed",
protocol);
g_hash_table_remove(protocols, purple_protocol_get_id(protocol));
return TRUE;
}
GList *
purple_protocols_get_all(void)
{
GList *ret = NULL;
PurpleProtocol *protocol;
GHashTableIter iter;
g_hash_table_iter_init(&iter, protocols);
while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&protocol))
ret = g_list_insert_sorted(ret, protocol, (GCompareFunc)compare_protocol);
return ret;
}
/**************************************************************************
* Protocols Subsystem API
**************************************************************************/
void
purple_protocols_init(void)
{
void *handle = purple_protocols_get_handle();
protocols = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
(GDestroyNotify)g_object_unref);
purple_signal_register(handle, "protocol-added",
purple_marshal_VOID__POINTER,
G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
purple_signal_register(handle, "protocol-removed",
purple_marshal_VOID__POINTER,
G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
}
void *
purple_protocols_get_handle(void)
{
static int handle;
return &handle;
}
void
purple_protocols_uninit(void)
{
g_hash_table_destroy(protocols);
}