HGKeeper

/**

* @file gg.c Gadu-Gadu protocol plugin

* purple

* Some parts of the code are adapted or taken from the previous implementation

* of this plugin written by Arkadiusz Miskiewicz <misiek@pld.org.pl>

* Thanks to Google's Summer of Code Program.

* 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 <glib/gi18n-lib.h>

#include <gplugin.h>

#include <gplugin-native.h>

#include <purple.h>

#include "gg.h"

#include "chat.h"

#include "search.h"

#include "blist.h"

#include "utils.h"

#include "resolver-purple.h"

#include "purplew.h"

#include "libgadu-events.h"

#include "multilogon.h"

#include "status.h"

#include "servconn.h"

#include "tcpsocket.h"

#include "pubdir-prpl.h"

#include "message-prpl.h"

#include "html.h"

#include "libgaduw.h"

struct _GGPProtocol {

PurpleProtocol parent;

};

/* ---------------------------------------------------------------------- */

static PurpleProtocol *my_protocol = NULL;

/* ---------------------------------------------------------------------- */

ggp_buddy_data * ggp_buddy_get_data(PurpleBuddy *buddy)

{

ggp_buddy_data *buddy_data = purple_buddy_get_protocol_data(buddy);

if (buddy_data)

return buddy_data;

buddy_data = g_new0(ggp_buddy_data, 1); /* TODO: leak */

purple_buddy_set_protocol_data(buddy, buddy_data);

return buddy_data;

}

static void

ggp_buddy_free(PurpleProtocolClient *client, PurpleBuddy *buddy)

{

ggp_buddy_data *buddy_data = purple_buddy_get_protocol_data(buddy);

if (!buddy_data) {

return;

}

g_free(buddy_data);

purple_buddy_set_protocol_data(buddy, NULL);

}

const gchar * ggp_get_imtoken(PurpleConnection *gc)

{

GGPInfo *accdata = purple_connection_get_protocol_data(gc);

if (accdata->imtoken)

return accdata->imtoken;

if (accdata->imtoken_warned)

return NULL;

accdata->imtoken_warned = TRUE;

purple_notify_error(gc, _("Authentication failed"),

_("IMToken value has not been received."),

_("Some features will be disabled. "

"You may try again after a while."),

purple_request_cpar_from_connection(gc));

return NULL;

}

uin_t ggp_own_uin(PurpleConnection *gc)

{

return ggp_str_to_uin(purple_account_get_username(

purple_connection_get_account(gc)));

}

/* ---------------------------------------------------------------------- */

/* buddy list import/export from/to file */

static void ggp_callback_buddylist_save_ok(PurpleConnection *gc, const char *filename)

{

PurpleAccount *account = purple_connection_get_account(gc);

char *buddylist = ggp_buddylist_dump(account);

purple_debug_info("gg", "Saving...\n");

purple_debug_info("gg", "file = %s\n", filename);

if (buddylist == NULL) {

purple_notify_info(account, _("Save Buddylist..."), _("Your "

"buddylist is empty, nothing was written to the file."),

NULL, purple_request_cpar_from_connection(gc));

return;

}

if (g_file_set_contents(filename, buddylist, -1, NULL)) {

purple_notify_info(account, _("Save Buddylist..."),

_("Buddylist saved successfully!"), NULL,

purple_request_cpar_from_connection(gc));

} else {

gchar *primary = g_strdup_printf(

_("Couldn't write buddy list for %s to %s"),

purple_account_get_username(account), filename);

purple_notify_error(account, _("Save Buddylist..."),

primary, NULL, purple_request_cpar_from_connection(gc));

g_free(primary);

}

g_free(buddylist);

}

static void ggp_callback_buddylist_load_ok(PurpleConnection *gc, gchar *file)

{

PurpleAccount *account = purple_connection_get_account(gc);

GError *error = NULL;

char *buddylist = NULL;

gsize length;

purple_debug_info("gg", "file_name = %s\n", file);

if (!g_file_get_contents(file, &buddylist, &length, &error)) {

purple_notify_error(account, _("Couldn't load buddylist"),

_("Couldn't load buddylist"), error->message,

purple_request_cpar_from_connection(gc));

purple_debug_error("gg",

"Couldn't load buddylist. file = %s; error = %s\n",

file, error->message);

g_error_free(error);

return;

}

ggp_buddylist_load(gc, buddylist);

g_free(buddylist);

purple_notify_info(account, _("Load Buddylist..."),

_("Buddylist loaded successfully!"), NULL,

purple_request_cpar_from_connection(gc));

}

/* }}} */

/* static void ggp_action_buddylist_save(PurpleProtocolAction *action) {{{ */

static void ggp_action_buddylist_save(PurpleProtocolAction *action)

{

PurpleConnection *gc = action->connection;

purple_request_file(action, _("Save buddylist..."), NULL, TRUE,

G_CALLBACK(ggp_callback_buddylist_save_ok), NULL,

purple_request_cpar_from_connection(gc), gc);

}

static void ggp_action_buddylist_load(PurpleProtocolAction *action)

{

PurpleConnection *gc = action->connection;

purple_request_file(action, _("Load buddylist from file..."), NULL,

FALSE, G_CALLBACK(ggp_callback_buddylist_load_ok), NULL,

purple_request_cpar_from_connection(gc), gc);

}

/* ----- BLOCK BUDDIES -------------------------------------------------- */

static void ggp_add_deny(PurpleProtocolPrivacy *privacy, PurpleConnection *gc,

const char *who)

{

GGPInfo *info = purple_connection_get_protocol_data(gc);

uin_t uin = ggp_str_to_uin(who);

purple_debug_info("gg", "ggp_add_deny: %u\n", uin);

gg_remove_notify_ex(info->session, uin, GG_USER_NORMAL);

gg_add_notify_ex(info->session, uin, GG_USER_BLOCKED);

}

static void ggp_remove_deny(PurpleProtocolPrivacy *privacy,

PurpleConnection *gc, const char *who)

{

GGPInfo *info = purple_connection_get_protocol_data(gc);

uin_t uin = ggp_str_to_uin(who);

purple_debug_info("gg", "ggp_rem_deny: %u\n", uin);

gg_remove_notify_ex(info->session, uin, GG_USER_BLOCKED);

gg_add_notify_ex(info->session, uin, GG_USER_NORMAL);

}

/* ---------------------------------------------------------------------- */

/* ----- INTERNAL CALLBACKS --------------------------------------------- */

/* ---------------------------------------------------------------------- */

static void ggp_typing_notification_handler(PurpleConnection *gc, uin_t uin, int length) {

gchar *from;

from = g_strdup_printf("%u", uin);

if (length)

purple_serv_got_typing(gc, from, 0, PURPLE_IM_TYPING);

else

purple_serv_got_typing_stopped(gc, from);

g_free(from);

}

/**

* Handling of XML events.

* @param gc PurpleConnection.

* @param data Raw XML contents.

* @see http://toxygen.net/libgadu/protocol/#ch1.13

* @todo: this may not be necessary anymore

static void ggp_xml_event_handler(PurpleConnection *gc, char *data)

{

PurpleXmlNode *xml = NULL;

PurpleXmlNode *xmlnode_next_event;

xml = purple_xmlnode_from_str(data, -1);

if (xml == NULL) {

purple_debug_error("gg", "ggp_xml_event_handler: "

"invalid xml: [%s]\n", data);

goto out;

}

xmlnode_next_event = purple_xmlnode_get_child(xml, "event");

while (xmlnode_next_event != NULL) {

PurpleXmlNode *xmlnode_current_event = xmlnode_next_event;

PurpleXmlNode *xmlnode_type;

char *event_type_raw;

int event_type = 0;

PurpleXmlNode *xmlnode_sender;

char *event_sender_raw;

uin_t event_sender = 0;

xmlnode_next_event = purple_xmlnode_get_next_twin(xmlnode_next_event);

xmlnode_type = purple_xmlnode_get_child(xmlnode_current_event, "type");

if (xmlnode_type == NULL)

continue;

event_type_raw = purple_xmlnode_get_data(xmlnode_type);

if (event_type_raw != NULL)

event_type = atoi(event_type_raw);

g_free(event_type_raw);

xmlnode_sender = purple_xmlnode_get_child(xmlnode_current_event, "sender");

if (xmlnode_sender != NULL) {

event_sender_raw = purple_xmlnode_get_data(xmlnode_sender);

if (event_sender_raw != NULL)

event_sender = ggp_str_to_uin(event_sender_raw);

g_free(event_sender_raw);

}

switch (event_type)

{

case 28: /* avatar update */

purple_debug_info("gg",

"ggp_xml_event_handler: avatar updated (uid: %u)\n",

event_sender);

break;

default:

purple_debug_error("gg",

"ggp_xml_event_handler: unsupported event type=%d from=%u\n",

event_type, event_sender);

}

out:

if (xml)

purple_xmlnode_free(xml);

}

static void ggp_callback_recv(gpointer _gc, gint fd, PurpleInputCondition cond)

{

PurpleConnection *gc = _gc;

GGPInfo *info = purple_connection_get_protocol_data(gc);

struct gg_event *ev;

if (!(ev = gg_watch_fd(info->session))) {

purple_debug_error("gg",

"ggp_callback_recv: gg_watch_fd failed -- CRITICAL!\n");

purple_connection_error (gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Unable to read from socket"));

return;

}

if (purple_debug_is_verbose()) {

purple_debug_misc("gg", "ggp_callback_recv: got event %s",

gg_debug_event(ev->type));

}

purple_input_remove(info->inpa);

info->inpa = purple_input_add(info->session->fd,

ggp_tcpsocket_inputcond_gg_to_purple(info->session->check),

ggp_callback_recv, gc);

switch (ev->type) {

case GG_EVENT_NONE:

/* Nothing happened. */

break;

case GG_EVENT_CONN_FAILED:

purple_connection_error (gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Server disconnected"));

break;

case GG_EVENT_MSG:

ggp_message_got(gc, &ev->event.msg);

break;

case GG_EVENT_ACK:

case GG_EVENT_ACK110:

break;

case GG_EVENT_IMAGE_REPLY:

ggp_image_recv(gc, &ev->event.image_reply);

break;

case GG_EVENT_IMAGE_REQUEST:

ggp_image_send(gc, &ev->event.image_request);

break;

case GG_EVENT_NOTIFY60:

case GG_EVENT_STATUS60:

ggp_status_got_others(gc, ev);

break;

case GG_EVENT_TYPING_NOTIFICATION:

ggp_typing_notification_handler(gc, ev->event.typing_notification.uin,

ev->event.typing_notification.length);

break;

case GG_EVENT_XML_EVENT:

purple_debug_info("gg", "GG_EVENT_XML_EVENT\n");

ggp_xml_event_handler(gc, ev->event.xml_event.data);

break;

case GG_EVENT_USER_DATA:

ggp_events_user_data(gc, &ev->event.user_data);

break;

case GG_EVENT_JSON_EVENT:

ggp_events_json(gc, &ev->event.json_event);

break;

case GG_EVENT_USERLIST100_VERSION:

ggp_roster_version(gc, &ev->event.userlist100_version);

break;

case GG_EVENT_USERLIST100_REPLY:

ggp_roster_reply(gc, &ev->event.userlist100_reply);

break;

case GG_EVENT_MULTILOGON_MSG:

ggp_message_got_multilogon(gc, &ev->event.multilogon_msg);

break;

case GG_EVENT_MULTILOGON_INFO:

ggp_multilogon_info(gc, &ev->event.multilogon_info);

break;

case GG_EVENT_IMTOKEN:

purple_debug_info("gg", "gg11: got IMTOKEN\n");

g_free(info->imtoken);

info->imtoken = g_strdup(ev->event.imtoken.imtoken);

break;

case GG_EVENT_PONG110:

purple_debug_info("gg", "gg11: got PONG110 %lu\n",

(long unsigned)ev->event.pong110.time);

break;

case GG_EVENT_CHAT_INFO:

case GG_EVENT_CHAT_INFO_GOT_ALL:

case GG_EVENT_CHAT_INFO_UPDATE:

case GG_EVENT_CHAT_CREATED:

case GG_EVENT_CHAT_INVITE_ACK:

ggp_chat_got_event(gc, ev);

break;

case GG_EVENT_DISCONNECT:

ggp_servconn_remote_disconnect(gc);

break;

default:

purple_debug_warning("gg",

"unsupported event type=%d\n", ev->type);

break;

}

gg_free_event(ev);

}

void ggp_async_login_handler(gpointer _gc, gint fd, PurpleInputCondition cond)

{

PurpleConnection *gc = _gc;

GGPInfo *info;

struct gg_event *ev;

PURPLE_ASSERT_CONNECTION_IS_VALID(gc);

info = purple_connection_get_protocol_data(gc);

purple_debug_info("gg", "login_handler: session: check = %d; state = %d;\n",

info->session->check, info->session->state);

switch (info->session->state) {

case GG_STATE_ERROR:

purple_debug_info("gg", "GG_STATE_ERROR\n");

break;

case GG_STATE_RESOLVING:

purple_debug_info("gg", "GG_STATE_RESOLVING\n");

break;

case GG_STATE_RESOLVING_GG:

purple_debug_info("gg", "GG_STATE_RESOLVING_GG\n");

break;

case GG_STATE_CONNECTING_HUB:

purple_debug_info("gg", "GG_STATE_CONNECTING_HUB\n");

break;

case GG_STATE_READING_DATA:

purple_debug_info("gg", "GG_STATE_READING_DATA\n");

break;

case GG_STATE_CONNECTING_GG:

purple_debug_info("gg", "GG_STATE_CONNECTING_GG\n");

break;

case GG_STATE_READING_KEY:

purple_debug_info("gg", "GG_STATE_READING_KEY\n");

break;

case GG_STATE_READING_REPLY:

purple_debug_info("gg", "GG_STATE_READING_REPLY\n");

break;

case GG_STATE_TLS_NEGOTIATION:

purple_debug_info("gg", "GG_STATE_TLS_NEGOTIATION\n");

break;

case GG_STATE_RESOLVING_HUB:

purple_debug_info("gg", "GG_STATE_RESOLVING_HUB\n");

break;

case GG_STATE_READING_HUB:

purple_debug_info("gg", "GG_STATE_READING_HUB\n");

break;

default:

purple_debug_error("gg", "unknown state = %d\n",

info->session->state);

break;

}

if (!(ev = gg_watch_fd(info->session))) {

purple_debug_error("gg", "login_handler: gg_watch_fd failed!\n");

purple_connection_error (gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Unable to read from socket"));

return;

}

purple_debug_info("gg", "login_handler: session->fd = %d\n", info->session->fd);

purple_debug_info("gg", "login_handler: session: check = %d; state = %d;\n",

info->session->check, info->session->state);

purple_input_remove(info->inpa);

info->inpa = 0;

/** XXX I think that this shouldn't be done if ev->type is GG_EVENT_CONN_FAILED or GG_EVENT_CONN_SUCCESS -datallah */

if (info->session->fd >= 0)

info->inpa = purple_input_add(info->session->fd,

(info->session->check == 1) ? PURPLE_INPUT_WRITE :

PURPLE_INPUT_READ,

ggp_async_login_handler, gc);

switch (ev->type) {

case GG_EVENT_NONE:

/* Nothing happened. */

purple_debug_info("gg", "GG_EVENT_NONE\n");

break;

case GG_EVENT_CONN_SUCCESS:

{

purple_debug_info("gg", "GG_EVENT_CONN_SUCCESS:"

" successfully connected to %s\n",

info->session->connect_host);

ggp_servconn_add_server(info->session->

connect_host);

purple_input_remove(info->inpa);

info->inpa = purple_input_add(info->session->fd,

PURPLE_INPUT_READ,

ggp_callback_recv, gc);

purple_connection_update_progress(gc, _("Connected"), 1, 2);

purple_connection_set_state(gc, PURPLE_CONNECTION_CONNECTED);

ggp_buddylist_send(gc);

ggp_roster_request_update(gc);

}

break;

case GG_EVENT_CONN_FAILED:

if (info->inpa > 0) {

purple_input_remove(info->inpa);

info->inpa = 0;

}

purple_debug_info("gg", "Connection failure: %d\n",

ev->event.failure);

switch (ev->event.failure) {

case GG_FAILURE_RESOLVING:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Unable to resolve "

"hostname"));

break;

case GG_FAILURE_PASSWORD:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,

_("Incorrect password"));

break;

case GG_FAILURE_TLS:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR,

_("SSL Connection Failed"));

break;

case GG_FAILURE_INTRUDER:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,

_("Your account has been "

"disabled because too many "

"incorrect passwords were "

"entered"));

break;

case GG_FAILURE_UNAVAILABLE:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Service temporarily "

"unavailable"));

break;

case GG_FAILURE_PROXY:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Error connecting to proxy "

"server"));

break;

case GG_FAILURE_HUB:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Error connecting to master "

"server"));

break;

case GG_FAILURE_INTERNAL:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_OTHER_ERROR,

_("Internal error"));

break;

default:

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Connection failed"));

}

break;

case GG_EVENT_MSG:

if (ev->event.msg.sender == 0) {

if (ev->event.msg.message == NULL)

break;

/* system messages are mostly ads */

purple_debug_info("gg", "System message:\n%s\n",

ev->event.msg.message);

} else {

purple_debug_warning("gg", "GG_EVENT_MSG: message from user %u "

"unexpected while connecting:\n%s\n",

ev->event.msg.sender,

ev->event.msg.message);

}

break;

default:

purple_debug_error("gg", "strange event: %d\n", ev->type);

break;

}

gg_free_event(ev);

}

static gint

gg_uri_handler_find_account(PurpleAccount *account,

G_GNUC_UNUSED gconstpointer data)

{

const gchar *protocol_id;

protocol_id = purple_account_get_protocol_id(account);

if (purple_strequal(protocol_id, "prpl-gg") &&

purple_account_is_connected(account)) {

return 0;

} else {

return -1;

}

static gboolean

gg_uri_handler(const gchar *scheme, const gchar *screenname,

GHashTable *params)

{

GList *accounts;

GList *account_node;

PurpleConversation *im;

g_return_val_if_fail(screenname != NULL, FALSE);

if (!purple_strequal(scheme, "gg")) {

return FALSE;

}

if (screenname[0] == '\0') {

purple_debug_warning("gg", "Invalid empty screenname in URI");

return FALSE;

}

/* Find online Gadu-Gadu account */

accounts = purple_accounts_get_all();

account_node = g_list_find_custom(

accounts, NULL, (GCompareFunc)gg_uri_handler_find_account);

if (account_node == NULL) {

return FALSE;

}

im = purple_im_conversation_new(account_node->data, screenname);

purple_conversation_present(im);

return TRUE;

}

/* ---------------------------------------------------------------------- */

/* ----- PurpleProtocol ----------------------------------------- */

/* ---------------------------------------------------------------------- */

static const char *ggp_list_icon(PurpleAccount *account, PurpleBuddy *buddy)

{

return "gadu-gadu";

}

static PurpleBuddyIconSpec *

ggp_protocol_get_buddy_icon_spec(PurpleProtocol *protocol) {

return purple_buddy_icon_spec_new("png",

1, 1, 200, 200, 0,

PURPLE_ICON_SCALE_DISPLAY |

PURPLE_ICON_SCALE_SEND);

}

static GList *

ggp_protocol_get_account_options(PurpleProtocol *protocol) {

PurpleAccountOption *option = NULL;

PurpleKeyValuePair *kvp = NULL;

GList *encryption_options = NULL;

GList *protocol_version = NULL;

GList *opts = NULL;

option = purple_account_option_string_new(_("GG server"), "gg_server", "");

opts = g_list_append(opts, option);

/* setup encryption options */

kvp = purple_key_value_pair_new(_("Use encryption if available"),

"opportunistic_tls");

encryption_options = g_list_append(encryption_options, kvp);

kvp = purple_key_value_pair_new(_("Require encryption"), "require_tls");

encryption_options = g_list_append(encryption_options, kvp);

kvp = purple_key_value_pair_new(_("Don't use encryption"), "none");

encryption_options = g_list_append(encryption_options, kvp);

option = purple_account_option_list_new(_("Connection security"),

"encryption", encryption_options);

opts = g_list_append(opts, option);

/* setup the protocol version */

kvp = purple_key_value_pair_new(_("Default"), "default");

protocol_version = g_list_append(protocol_version, kvp);

kvp = purple_key_value_pair_new("GG 10", "gg10");

protocol_version = g_list_append(protocol_version, kvp);

kvp = purple_key_value_pair_new("GG 11", "gg11");

protocol_version = g_list_append(protocol_version, kvp);

option = purple_account_option_list_new(_("Protocol version"),

"protocol_version",

protocol_version);

opts = g_list_append(opts, option);

option = purple_account_option_bool_new(_("Show links from strangers"),

"show_links_from_strangers", 1);

opts = g_list_append(opts, option);

return opts;

}

static const char *

ggp_normalize(PurpleProtocolClient *client, PurpleAccount *account,

const char *who)

{

static char normalized[21]; /* maximum unsigned long long int size */

uin_t uin = ggp_str_to_uin(who);

if(uin <= 0) {

return NULL;

}

g_snprintf(normalized, sizeof(normalized), "%u", uin);

return normalized;

}

/* TODO:

* - move to status.c ?

* - add information about not adding to his buddy list (not_a_friend)

static void

ggp_tooltip_text(PurpleProtocolClient *client, PurpleBuddy *b,

PurpleNotifyUserInfo *user_info, gboolean full)

{

PurpleStatus *status;

char *tmp;

const char *name, *alias;

gchar *msg;

g_return_if_fail(b != NULL);

status = purple_presence_get_active_status(purple_buddy_get_presence(b));

name = purple_status_get_name(status);

alias = purple_buddy_get_alias(b);

ggp_status_from_purplestatus(status, &msg);

purple_notify_user_info_add_pair_plaintext(user_info, _("Alias"), alias);

if (msg != NULL) {

if (PURPLE_BUDDY_IS_ONLINE(b)) {

tmp = g_strdup_printf("%s: %s", name, msg);

purple_notify_user_info_add_pair_plaintext(user_info, _("Status"), tmp);

g_free(tmp);

} else {

purple_notify_user_info_add_pair_plaintext(user_info, _("Message"), msg);

}

g_free(msg);

/* We don't want to duplicate 'Status: Offline'. */

} else if (PURPLE_BUDDY_IS_ONLINE(b)) {

purple_notify_user_info_add_pair_plaintext(user_info, _("Status"), name);

}

static void ggp_login(PurpleAccount *account)

{

PurpleConnection *gc = purple_account_get_connection(account);

struct gg_login_params *glp;

GGPInfo *info;

const char *address;

const gchar *encryption_type, *protocol_version;

GProxyResolver *resolver;

GError *error;

purple_connection_set_flags(gc,

PURPLE_CONNECTION_FLAG_HTML |

PURPLE_CONNECTION_FLAG_NO_URLDESC);

resolver = purple_proxy_get_proxy_resolver(account, &error);

if (resolver == NULL) {

purple_debug_error("gg", "Unable to get account proxy resolver: %s",

error->message);

purple_connection_take_error(gc, error);

return;

}

glp = g_new0(struct gg_login_params, 1);

glp->struct_size = sizeof(struct gg_login_params);

info = g_new0(GGPInfo, 1);

purple_connection_set_protocol_data(gc, info);

info->http = soup_session_new_with_options("proxy-resolver", resolver,

NULL);

ggp_tcpsocket_setup(gc, glp);

ggp_image_setup(gc);

ggp_avatar_setup(gc);

ggp_roster_setup(gc);

ggp_multilogon_setup(gc);

ggp_status_setup(gc);

ggp_chat_setup(gc);

ggp_message_setup(gc);

ggp_edisc_setup(gc, resolver);

g_object_unref(resolver);

glp->uin = ggp_str_to_uin(purple_account_get_username(account));

glp->password =

ggp_convert_to_cp1250(purple_connection_get_password(gc));

if (glp->uin == 0) {

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_INVALID_USERNAME,

_("The username specified is invalid."));

purple_str_wipe(glp->password);

g_free(glp);

return;

}

glp->image_size = 255;

glp->status_flags = GG_STATUS_FLAG_UNKNOWN;

if (purple_account_get_bool(account, "show_links_from_strangers", 1))

glp->status_flags |= GG_STATUS_FLAG_SPAM;

glp->encoding = GG_ENCODING_UTF8;

glp->protocol_features = (GG_FEATURE_DND_FFC |

GG_FEATURE_TYPING_NOTIFICATION | GG_FEATURE_MULTILOGON |

GG_FEATURE_USER_DATA);

glp->async = 1;

encryption_type = purple_account_get_string(account, "encryption",

"opportunistic_tls");

purple_debug_info("gg", "Requested encryption type: %s\n",

encryption_type);

if (purple_strequal(encryption_type, "opportunistic_tls"))

glp->tls = GG_SSL_ENABLED;

else if (purple_strequal(encryption_type, "require_tls")) {

if (gg_libgadu_check_feature(GG_LIBGADU_FEATURE_SSL))

glp->tls = GG_SSL_REQUIRED;

else {

purple_connection_error(gc,

PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT,

_("SSL support unavailable"));

purple_str_wipe(glp->password);

g_free(glp);

return;

}

else /* encryption_type == "none" */

glp->tls = GG_SSL_DISABLED;

purple_debug_misc("gg", "TLS mode: %d\n", glp->tls);

protocol_version = purple_account_get_string(account,

"protocol_version", "default");

purple_debug_info("gg", "Requested protocol version: %s\n",

protocol_version);

if (purple_strequal(protocol_version, "gg10"))

glp->protocol_version = GG_PROTOCOL_VERSION_100;

else if (purple_strequal(protocol_version, "gg11"))

glp->protocol_version = GG_PROTOCOL_VERSION_110;

glp->compatibility = GG_COMPAT_1_12_0;

ggp_status_set_initial(gc, glp);

address = purple_account_get_string(account, "gg_server", "");

if (address && *address)

glp->connect_host = g_strdup(address);

info->session = gg_login(glp);

g_free(glp->connect_host);

purple_str_wipe(glp->password);

g_free(glp);

purple_connection_update_progress(gc, _("Connecting"), 0, 2);

if (info->session == NULL) {

purple_connection_error (gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Connection failed"));

return;

}

if (info->session->fd > 0) {

info->inpa = purple_input_add(info->session->fd,

PURPLE_INPUT_READ, ggp_async_login_handler, gc);

}

static void ggp_close(PurpleConnection *gc)

{

PurpleAccount *account;

GGPInfo *info;;

g_return_if_fail(gc != NULL);

account = purple_connection_get_account(gc);

info = purple_connection_get_protocol_data(gc);

purple_notify_close_with_handle(gc);

if (info) {

if (info->session != NULL) {

ggp_status_set_disconnected(account);

gg_logoff(info->session);

gg_free_session(info->session);

}

ggp_image_cleanup(gc);

ggp_avatar_cleanup(gc);

ggp_roster_cleanup(gc);

ggp_multilogon_cleanup(gc);

ggp_status_cleanup(gc);

ggp_chat_cleanup(gc);

ggp_message_cleanup(gc);

ggp_edisc_cleanup(gc);

if (info->inpa > 0)

purple_input_remove(info->inpa);

g_free(info->imtoken);

if (info->http) {

soup_session_abort(info->http);

g_object_unref(info->http);

}

purple_connection_set_protocol_data(gc, NULL);

g_free(info);

}

purple_debug_info("gg", "Connection closed.\n");

}

static unsigned int ggp_send_typing(PurpleProtocolIM *im, PurpleConnection *gc, const char *name, PurpleIMTypingState state)

{

GGPInfo *info = purple_connection_get_protocol_data(gc);

int dummy_length; /* we don't send real length of typed message */

if (state == PURPLE_IM_TYPED) /* not supported */

return 1;

if (state == PURPLE_IM_TYPING)

dummy_length = (int)g_random_int();

else /* PURPLE_IM_NOT_TYPING */

dummy_length = 0;

gg_typing_notification(

info->session,

ggp_str_to_uin(name),

dummy_length);

return 1; /* wait 1 second before another notification */

}

static void

ggp_add_buddy(PurpleProtocolServer *protocol_server, PurpleConnection *gc,

PurpleBuddy *buddy, PurpleGroup *group, const gchar *message)

{

PurpleAccount *account = purple_connection_get_account(gc);

GGPInfo *info = purple_connection_get_protocol_data(gc);

const gchar *name = purple_buddy_get_name(buddy);

gg_add_notify(info->session, ggp_str_to_uin(name));

/* gg server won't tell us our status here */

if (purple_strequal(purple_account_get_username(account), name))

ggp_status_fake_to_self(gc);

ggp_roster_add_buddy(protocol_server, gc, buddy, group, message);

ggp_pubdir_request_buddy_alias(gc, buddy);

}

static void

ggp_remove_buddy(PurpleProtocolServer *protocol_server, PurpleConnection *gc,

PurpleBuddy *buddy, PurpleGroup *group)

{

GGPInfo *info = purple_connection_get_protocol_data(gc);

gg_remove_notify(info->session, ggp_str_to_uin(purple_buddy_get_name(buddy)));

ggp_roster_remove_buddy(protocol_server, gc, buddy, group);

}

static void

ggp_keepalive(PurpleProtocolServer *protocol_server, PurpleConnection *gc) {

GGPInfo *info = purple_connection_get_protocol_data(gc);

/* purple_debug_info("gg", "Keeping connection alive....\n"); */

if (gg_ping(info->session) < 0) {

purple_debug_info("gg", "Not connected to the server "

"or gg_session is not correct\n");

purple_connection_error (gc,

PURPLE_CONNECTION_ERROR_NETWORK_ERROR,

_("Not connected to the server"));

}

static void ggp_action_multilogon(PurpleProtocolAction *action)

{

ggp_multilogon_dialog(action->connection);

}

static void ggp_action_status_broadcasting(PurpleProtocolAction *action)

{

ggp_status_broadcasting_dialog(action->connection);

}

static void ggp_action_search(PurpleProtocolAction *action)

{

ggp_pubdir_search(action->connection, NULL);

}

static void ggp_action_set_info(PurpleProtocolAction *action)

{

ggp_pubdir_set_info(action->connection);

}

static GList *

ggp_get_actions(PurpleProtocolClient *client, PurpleConnection *gc) {

GList *m = NULL;

PurpleProtocolAction *act;

act = purple_protocol_action_new(_("Show other sessions"),

ggp_action_multilogon);

m = g_list_append(m, act);

act = purple_protocol_action_new(_("Show status only for buddies"),

ggp_action_status_broadcasting);

m = g_list_append(m, act);

m = g_list_append(m, NULL);

act = purple_protocol_action_new(_("Find buddies..."),

ggp_action_search);

m = g_list_append(m, act);

act = purple_protocol_action_new(_("Set User Info"),

ggp_action_set_info);

m = g_list_append(m, act);

m = g_list_append(m, NULL);

act = purple_protocol_action_new(_("Save buddylist to file..."),

ggp_action_buddylist_save);

m = g_list_append(m, act);

act = purple_protocol_action_new(_("Load buddylist from file..."),

ggp_action_buddylist_load);

m = g_list_append(m, act);

return m;

}

static const char *

ggp_list_emblem(PurpleProtocolClient *client, PurpleBuddy *buddy) {

ggp_buddy_data *buddy_data = ggp_buddy_get_data(buddy);

if (buddy_data->blocked)

return "not-authorized";

if (buddy_data->not_a_friend)

return "unavailable";

return NULL;

}

static gboolean

ggp_offline_message(PurpleProtocolClient *client, PurpleBuddy *buddy) {

return TRUE;

}

static GHashTable *

ggp_get_account_text_table(PurpleProtocolClient *client,

PurpleAccount *account)

{

GHashTable *table;

table = g_hash_table_new(g_str_hash, g_str_equal);

g_hash_table_insert(table, "login_label", (gpointer)_("GG number..."));

return table;

}

static gssize

ggp_get_max_message_size(PurpleProtocolClient *client,

PurpleConversation *conv)

{

/* TODO: it may depend on protocol version or other factors */

return 1200; /* no more than 1232 */

}

static void

ggp_protocol_init(GGPProtocol *self)

{

}

static void

ggp_protocol_class_init(GGPProtocolClass *klass)

{

PurpleProtocolClass *protocol_class = PURPLE_PROTOCOL_CLASS(klass);

protocol_class->login = ggp_login;

protocol_class->close = ggp_close;

protocol_class->status_types = ggp_status_types;

protocol_class->list_icon = ggp_list_icon;

protocol_class->get_account_options = ggp_protocol_get_account_options;

protocol_class->get_buddy_icon_spec = ggp_protocol_get_buddy_icon_spec;

}

static void

ggp_protocol_class_finalize(G_GNUC_UNUSED GGPProtocolClass *klass)

{

}

static void

ggp_protocol_client_iface_init(PurpleProtocolClientInterface *client_iface)

{

client_iface->get_actions = ggp_get_actions;

client_iface->list_emblem = ggp_list_emblem;

client_iface->status_text = ggp_status_buddy_text;

client_iface->tooltip_text = ggp_tooltip_text;

client_iface->buddy_free = ggp_buddy_free;

client_iface->normalize = ggp_normalize;

client_iface->offline_message = ggp_offline_message;

client_iface->get_account_text_table = ggp_get_account_text_table;

client_iface->get_max_message_size = ggp_get_max_message_size;

}

static void

ggp_protocol_server_iface_init(PurpleProtocolServerInterface *server_iface)

{

server_iface->get_info = ggp_pubdir_get_info_protocol;

server_iface->set_status = ggp_status_set_purplestatus;

server_iface->add_buddy = ggp_add_buddy;

server_iface->remove_buddy = ggp_remove_buddy;

server_iface->keepalive = ggp_keepalive;

server_iface->alias_buddy = ggp_roster_alias_buddy;

server_iface->group_buddy = ggp_roster_group_buddy;

server_iface->rename_group = ggp_roster_rename_group;

server_iface->set_buddy_icon = ggp_avatar_own_set;

}

static void

ggp_protocol_im_iface_init(PurpleProtocolIMInterface *im_iface)

{

im_iface->send = ggp_message_send_im;

im_iface->send_typing = ggp_send_typing;

}

static void

ggp_protocol_chat_iface_init(PurpleProtocolChatInterface *chat_iface)

{

chat_iface->info = ggp_chat_info;

chat_iface->info_defaults = ggp_chat_info_defaults;

chat_iface->join = ggp_chat_join;

chat_iface->get_name = ggp_chat_get_name;

chat_iface->invite = ggp_chat_invite;

chat_iface->leave = ggp_chat_leave;

chat_iface->send = ggp_chat_send;

chat_iface->reject = NULL; /* TODO */

}

static void

ggp_protocol_roomlist_iface_init(PurpleProtocolRoomlistInterface *roomlist_iface)

{

roomlist_iface->get_list = ggp_chat_roomlist_get_list;

}

static void

ggp_protocol_privacy_iface_init(PurpleProtocolPrivacyInterface *privacy_iface)

{

privacy_iface->add_deny = ggp_add_deny;

privacy_iface->remove_deny = ggp_remove_deny;

}

static void

ggp_protocol_xfer_iface_init(PurpleProtocolXferInterface *xfer_iface)

{

xfer_iface->can_receive = ggp_edisc_xfer_can_receive_file;

xfer_iface->send_file = ggp_edisc_xfer_send_file;

xfer_iface->new_xfer = ggp_edisc_xfer_send_new;

}

G_DEFINE_DYNAMIC_TYPE_EXTENDED(

GGPProtocol, ggp_protocol, PURPLE_TYPE_PROTOCOL, 0,

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_CLIENT,

ggp_protocol_client_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_SERVER,

ggp_protocol_server_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_IM,

ggp_protocol_im_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_CHAT,

ggp_protocol_chat_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_ROOMLIST,

ggp_protocol_roomlist_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_PRIVACY,

ggp_protocol_privacy_iface_init)

G_IMPLEMENT_INTERFACE_DYNAMIC(PURPLE_TYPE_PROTOCOL_XFER,

ggp_protocol_xfer_iface_init));

static PurpleProtocol *

ggp_protocol_new(void) {

return PURPLE_PROTOCOL(g_object_new(

GGP_TYPE_PROTOCOL,

"id", "prpl-gg",

"name", "Gadu-Gadu",

"description", "Gadu-Gadu is a Polish instant messaging client",

"icon-name", "im-gadu-gadu",

"icon-resource-path", "/im/pidgin/libpurple/gg/icons",

NULL));

}

static gchar *

plugin_extra(PurplePlugin *plugin)

{

return g_strdup_printf("Using libgadu version %s", gg_libgadu_version());

}

static GPluginPluginInfo *

gg_query(GError **error)

{

const gchar * const authors[] = {

"boler@sourceforge.net",

NULL

};

return purple_plugin_info_new(

"id", "prpl-gg",

"name", "Gadu-Gadu Protocol",

"version", DISPLAY_VERSION,

"category", N_("Protocol"),

"summary", N_("Gadu-Gadu Protocol Plugin"),

"description", N_("Polish popular IM"),

"authors", authors,

"website", PURPLE_WEBSITE,

"abi-version", PURPLE_ABI_VERSION,

"extra-cb", plugin_extra,

"flags", PURPLE_PLUGIN_INFO_FLAGS_INTERNAL |

PURPLE_PLUGIN_INFO_FLAGS_AUTO_LOAD,

NULL

);

}

static gboolean

gg_load(GPluginPlugin *plugin, GError **error)

{

PurpleProtocolManager *manager = purple_protocol_manager_get_default();

ggp_protocol_register_type(G_TYPE_MODULE(plugin));

ggp_xfer_register(G_TYPE_MODULE(plugin));

my_protocol = ggp_protocol_new();

if(!purple_protocol_manager_register(manager, my_protocol, error)) {

g_clear_object(&my_protocol);

return FALSE;

}

purple_prefs_add_none("/plugins/prpl/gg");

purple_debug_info("gg", "Loading Gadu-Gadu protocol plugin with "

"libgadu %s...\n", gg_libgadu_version());

ggp_libgaduw_setup();

ggp_resolver_purple_setup();

ggp_servconn_setup(NULL);

ggp_html_setup();

ggp_message_setup_global();

purple_signal_connect(purple_get_core(), "uri-handler", plugin,

PURPLE_CALLBACK(gg_uri_handler), NULL);

return TRUE;

}

static gboolean

gg_unload(GPluginPlugin *plugin, gboolean shutdown, GError **error)

{

PurpleProtocolManager *manager = purple_protocol_manager_get_default();

if(!purple_protocol_manager_unregister(manager, my_protocol, error)) {

return FALSE;

}

purple_signal_disconnect(purple_get_core(), "uri-handler", plugin,

PURPLE_CALLBACK(gg_uri_handler));

ggp_servconn_cleanup();

ggp_html_cleanup();

ggp_message_cleanup_global();

ggp_libgaduw_cleanup();

g_clear_object(&my_protocol);

return TRUE;

}

GPLUGIN_NATIVE_PLUGIN_DECLARE(gg)

/* vim: set ts=8 sts=0 sw=8 noet: */

pidgin/pidgin