Mercurial > pidgin3 / changeset

--- a/configure.ac	Tue Aug 14 22:05:05 2012 +0200
+++ b/configure.ac	Tue Aug 14 22:26:33 2012 +0200
@@ -816,6 +816,19 @@
 AC_SUBST(LIBXML_LIBS)
 
 dnl #######################################################################
+dnl # Check for zlib (required)
+dnl #######################################################################
+
+PKG_CHECK_MODULES(ZLIB, [zlib >= 1.2.0], , [
+	AC_MSG_RESULT(no)
+	AC_MSG_ERROR([
+You must have zlib >= 1.2.0 development headers installed to build.
+])])
+
+AC_SUBST(ZLIB_CFLAGS)
+AC_SUBST(ZLIB_LIBS)
+
+dnl #######################################################################
 dnl # GConf schemas
 dnl #######################################################################
 AC_PATH_PROG(GCONFTOOL, gconftool-2, no)
@@ -1069,13 +1082,14 @@
 AC_ARG_WITH(gadu-libs, [AC_HELP_STRING([--with-gadu-libs=DIR], [compile the Gadu-Gadu plugin against the libs in DIR])], [ac_gadu_libs="$withval"], [ac_gadu_libs="no"])
 GADU_CFLAGS=""
 GADU_LIBS=""
+GADU_LIBGADU_VERSION=1.11.2
 if test -n "$with_gadu_includes" || test -n "$with_gadu_libs"; then
 	gadu_manual_check="yes"
 else
 	gadu_manual_check="no"
 fi
 if test "x$gadu_manual_check" = "xno"; then
-	PKG_CHECK_MODULES(GADU, [libgadu >= 1.11.0], [
+	PKG_CHECK_MODULES(GADU, [libgadu >= $GADU_LIBGADU_VERSION], [
 		gadu_includes="yes"
 		gadu_libs="yes"
 	], [
@@ -1107,28 +1121,7 @@
 #error "libgadu is not compatible with the GPL when compiled with OpenSSL support."
 #endif
 	]])], [
-		AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <libgadu.h>]], [[
-#if GG_DEFAULT_PROTOCOL_VERSION < 0x2e
-#error "Your libgadu version is too old. libpurple requires 1.11.0 or higher."
-#endif
-		]])], [
-			AC_MSG_RESULT(yes)
-			AC_DEFINE([HAVE_LIBGADU], [1],
-				[Define to 1 if you have libgadu.])
-		], [
-			AC_MSG_RESULT(no)
-			echo
-			echo
-			echo "Your supplied copy of libgadu is too old."
-			echo "Install version 1.11.0 or newer."
-			echo "Then rerun this ./configure"
-			echo
-			echo "Falling back to using our own copy of libgadu"
-			echo
-			GADU_LIBS=""
-			GADU_CFLAGS=""
-			gadu_libs=no
-		])
+		AC_MSG_RESULT(yes)
 	], [
 		AC_MSG_RESULT(no)
 		echo
@@ -1147,6 +1140,35 @@
 	CPPFLAGS="$CPPFLAGS_save"
 fi
 
+if test "x$gadu_libs" = "xyes" -a "x$gadu_manual_check" = "xyes"; then
+	AC_MSG_CHECKING(for supplied libgadu compatibility)
+	CPPFLAGS_save="$CPPFLAGS"
+	CPPFLAGS="$CPPFLAGS $GADU_CFLAGS"
+
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <libgadu.h>]], [[
+#if GG_DEFAULT_PROTOCOL_VERSION < 0x2e
+#error "Your libgadu version is too old."
+#endif
+	]])], [
+		AC_MSG_RESULT(yes)
+	], [
+		AC_MSG_RESULT(no)
+		echo
+		echo "Your supplied copy of libgadu is too old."
+		echo "Install version $GADU_LIBGADU_VERSION or newer."
+		echo "Then rerun this ./configure"
+		echo
+		echo "Falling back to using our own copy of libgadu"
+		echo
+		GADU_LIBS=""
+		GADU_CFLAGS=""
+		gadu_libs=no
+	])
+
+	CPPFLAGS="$CPPFLAGS_save"
+fi
+
+AM_CONDITIONAL(HAVE_LIBGADU, test "x$gadu_libs" = "xyes")
 AM_CONDITIONAL(USE_INTERNAL_LIBGADU, test "x$gadu_libs" != "xyes")
 
 if test "x$gadu_libs" = "x"; then
@@ -1155,6 +1177,7 @@
 
 AC_SUBST(GADU_LIBS)
 AC_SUBST(GADU_CFLAGS)
+AC_SUBST(GADU_LIBGADU_VERSION)
 
 AC_ARG_ENABLE(distrib,,,enable_distrib=no)
 AM_CONDITIONAL(DISTRIB, test "x$enable_distrib" = "xyes")

--- a/libpurple/eventloop.c	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/eventloop.c	Tue Aug 14 22:26:33 2012 +0200
@@ -91,6 +91,16 @@
 	}
 }
 
+int
+purple_input_pipe(int pipefd[2])
+{
+#ifdef _WIN32
+	return wpurple_input_pipe(pipefd);
+#else
+	return pipe(pipefd);
+#endif
+}
+
 void
 purple_eventloop_set_ui_ops(PurpleEventLoopUiOps *ops)
 {

--- a/libpurple/eventloop.h	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/eventloop.h	Tue Aug 14 22:26:33 2012 +0200
@@ -240,6 +240,24 @@
 int
 purple_input_get_error(int fd, int *error);
 
+/**
+ * Creates a pipe - an unidirectional data channel that can be used for
+ * interprocess communication.
+ *
+ * File descriptors for both ends of pipe will be written into provided array.
+ * The first one (pipefd[0]) can be used for reading, the second one (pipefd[1])
+ * for writing.
+ *
+ * On Windows it's simulated by creating a pair of connected sockets, on other
+ * systems pipe() is used.
+ *
+ * @param pipefd Array used to return file descriptors for both ends of pipe.
+ *
+ * @return @c 0 on success, @c -1 on error.
+ */
+int
+purple_input_pipe(int pipefd[2]);
+
 
 /*@}*/
 

--- a/libpurple/protocols/gg/Makefile.am	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/Makefile.am	Tue Aug 14 22:26:33 2012 +0200
@@ -1,13 +1,20 @@
+V=0
+
+pkgdir = $(libdir)/purple-$(PURPLE_MAJOR_VERSION)
+
 EXTRA_DIST = \
 	Makefile.mingw \
-	win32-resolver.c \
-	win32-resolver.h \
+	lib/COPYING
+
+if USE_INTERNAL_LIBGADU
+INTGGSOURCES = \
 	lib/common.c \
 	lib/compat.h \
-	lib/COPYING \
+	lib/config.h \
 	lib/dcc.c \
 	lib/dcc7.c \
 	lib/debug.c \
+	lib/debug.h \
 	lib/deflate.c \
 	lib/deflate.h \
 	lib/encoding.c \
@@ -15,11 +22,9 @@
 	lib/events.c \
 	lib/handlers.c \
 	lib/http.c \
-	lib/libgadu.h \
+	lib/internal.h \
 	lib/libgadu.c \
-	lib/libgadu-config.h \
-	lib/libgadu-debug.h \
-	lib/libgadu-internal.h \
+	lib/libgadu.h \
 	lib/message.c \
 	lib/message.h \
 	lib/obsolete.c \
@@ -31,38 +36,11 @@
 	lib/session.h \
 	lib/sha1.c
 
-pkgdir = $(libdir)/purple-$(PURPLE_MAJOR_VERSION)
-
-if USE_INTERNAL_LIBGADU
-INTGGSOURCES = \
-	lib/common.c \
-	lib/compat.h \
-	lib/dcc.c \
-	lib/dcc7.c \
-	lib/debug.c \
-	lib/deflate.c \
-	lib/deflate.h \
-	lib/encoding.c \
-	lib/encoding.h \
-	lib/events.c \
-	lib/handlers.c \
-	lib/http.c \
-	lib/libgadu.h \
-	lib/libgadu.c \
-	lib/libgadu-config.h \
-	lib/libgadu-internal.h \
-	lib/message.c \
-	lib/message.h \
-	lib/obsolete.c \
-	lib/protocol.h \
-	lib/pubdir.c \
-	lib/pubdir50.c \
-	lib/resolver.c \
-	lib/resolver.h \
-	lib/session.h \
-	lib/sha1.c
-
-INTGG_CFLAGS = -I$(top_srcdir)/libpurple/protocols/gg/lib -DGG_IGNORE_DEPRECATED -DUSE_INTERNAL_LIBGADU
+INTGG_CFLAGS = -I$(top_srcdir)/libpurple/protocols/gg/lib \
+	$(ZLIB_CFLAGS) \
+	-DGG_IGNORE_DEPRECATED \
+	-DGG_INTERNAL_LIBGADU_VERSION=$(GADU_LIBGADU_VERSION)
+GADU_LIBS += $(ZLIB_LIBS)
 endif
 
 if USE_GNUTLS
@@ -72,8 +50,8 @@
 
 GGSOURCES = \
 	$(INTGGSOURCES) \
-	gg-utils.h \
-	gg-utils.c \
+	utils.h \
+	utils.c \
 	confer.h \
 	confer.c \
 	search.h \
@@ -81,7 +59,39 @@
 	buddylist.h \
 	buddylist.c \
 	gg.h \
-	gg.c
+	gg.c \
+	resolver-purple.h \
+	resolver-purple.c \
+	image.h \
+	image.c \
+	account.h \
+	account.c \
+	deprecated.h \
+	deprecated.c \
+	purplew.h \
+	purplew.c \
+	libgaduw.h \
+	libgaduw.c \
+	avatar.h \
+	avatar.c \
+	libgadu-events.h \
+	libgadu-events.c \
+	roster.c \
+	roster.h \
+	validator.c \
+	validator.h \
+	xml.c \
+	xml.h \
+	multilogon.c \
+	multilogon.h \
+	status.c \
+	status.h \
+	oauth/oauth.c \
+	oauth/oauth.h \
+	oauth/oauth-parameter.c \
+	oauth/oauth-parameter.h \
+	oauth/oauth-purple.c \
+	oauth/oauth-purple.h
 
 AM_CFLAGS = $(st)
 
@@ -105,9 +115,9 @@
 endif
 
 AM_CPPFLAGS = \
+	-Wall -Wextra -Werror \
 	-I$(top_srcdir)/libpurple \
 	-I$(top_builddir)/libpurple \
 	$(INTGG_CFLAGS) \
 	$(GLIB_CFLAGS) \
 	$(DEBUG_CFLAGS)
-

--- a/libpurple/protocols/gg/Makefile.mingw	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/Makefile.mingw	Tue Aug 14 22:26:33 2012 +0200
@@ -24,14 +24,14 @@
 ##
 ## INCLUDE PATHS
 ##
-INCLUDE_PATHS +=	-I. \
+INCLUDE_PATHS +=\
+			-I$(PIDGIN_TREE_TOP) \
+			-I$(PURPLE_TOP) \
+			-I$(PURPLE_TOP)/win32 \
 			-I./lib \
 			-I$(GTK_TOP)/include \
 			-I$(GTK_TOP)/include/glib-2.0 \
-			-I$(GTK_TOP)/lib/glib-2.0/include \
-			-I$(PURPLE_TOP) \
-			-I$(PURPLE_TOP)/win32 \
-			-I$(PIDGIN_TREE_TOP)
+			-I$(GTK_TOP)/lib/glib-2.0/include
 
 LIB_PATHS +=		-L$(GTK_TOP)/lib \
 			-L$(PURPLE_TOP) \
@@ -60,8 +60,8 @@
 	confer.c \
 	gg.c \
 	search.c \
-	gg-utils.c \
-	win32-resolver.c
+	utils.c \
+	resolver-purple.c
 
 OBJECTS = $(C_SRC:%.c=%.o)
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/account.c	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,620 @@
+#include "account.h"
+
+#include <libgadu.h>
+#include <debug.h>
+
+#include "deprecated.h"
+#include "purplew.h"
+#include "utils.h"
+#include "libgaduw.h"
+#include "validator.h"
+
+/*******************************************************************************
+ * Token requesting.
+ ******************************************************************************/
+
+typedef struct
+{
+	ggp_account_token_cb callback;
+	PurpleConnection *gc;
+	void *user_data;
+} ggp_account_token_reqdata;
+
+static void ggp_account_token_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _reqdata);
+
+/******************************************************************************/
+
+void ggp_account_token_free(ggp_account_token *token)
+{
+	if (!token)
+		return;
+	g_free(token->id);
+	g_free(token->data);
+	g_free(token);
+}
+
+void ggp_account_token_request(PurpleConnection *gc,
+	ggp_account_token_cb callback, void *user_data)
+{
+	struct gg_http *h;
+	ggp_account_token_reqdata *reqdata;
+
+	purple_debug_info("gg", "ggp_account_token_request: "
+		"requesting token...\n");
+
+	if (!ggp_deprecated_setup_proxy(gc))
+	{
+		callback(gc, NULL, user_data);
+		return;
+	}
+	
+	h = gg_token(TRUE);
+	
+	if (!h)
+	{
+		callback(gc, NULL, user_data);
+		return;
+	}
+	
+	reqdata = g_new(ggp_account_token_reqdata, 1);
+	reqdata->callback = callback;
+	reqdata->gc = gc;
+	reqdata->user_data = user_data;
+	ggp_libgaduw_http_watch(gc, h, ggp_account_token_response, reqdata,
+		TRUE);
+}
+
+static void ggp_account_token_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _reqdata)
+{
+	ggp_account_token_reqdata *reqdata = _reqdata;
+	struct gg_token *token_info;
+	ggp_account_token *token = NULL;
+	
+	g_assert(!(success && cancelled));
+	
+	if (cancelled)
+		purple_debug_info("gg", "ggp_account_token_handler: "
+			"cancelled\n");
+	else if (success)
+	{
+		purple_debug_info("gg", "ggp_account_token_handler: "
+			"got token\n");
+	
+		token = g_new(ggp_account_token, 1);
+	
+		token_info = h->data;
+		token->id = g_strdup(token_info->tokenid);
+		token->size = h->body_size;
+		token->data = g_memdup(h->body, token->size);
+		token->length = token_info->length;
+	}
+	else
+	{
+		purple_debug_error("gg", "ggp_account_token_handler: error\n");
+		purple_notify_error(
+			purple_connection_get_account(reqdata->gc),
+			_("Token Error"),
+			_("Unable to fetch the token."), NULL);
+	}
+	
+	reqdata->callback(reqdata->gc, token, reqdata->user_data);
+	g_free(reqdata);
+}
+
+gboolean ggp_account_token_validate(ggp_account_token *token,
+	const gchar *value)
+{
+	if (strlen(value) != token->length)
+		return FALSE;
+	return g_regex_match_simple("^[a-zA-Z0-9]+$", value, 0, 0);
+}
+
+/*******************************************************************************
+ * New account registration.
+ ******************************************************************************/
+
+typedef struct
+{
+	ggp_account_token *token;
+	PurpleConnection *gc;
+	
+	gchar *email;
+	gchar *password;
+	gchar *token_value;
+	gboolean password_remember;
+} ggp_account_register_data;
+
+static void ggp_account_register_dialog(PurpleConnection *gc,
+	ggp_account_token *token, gpointer _register_data);
+static void ggp_account_register_dialog_ok(
+	ggp_account_register_data *register_data, PurpleRequestFields *fields);
+#if 0
+static void ggp_account_register_dialog_invalid(
+	ggp_account_register_data *register_data, const gchar *message);
+#endif
+static void ggp_account_register_dialog_cancel(
+	ggp_account_register_data *register_data, PurpleRequestFields *fields);
+static void ggp_account_register_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _reqdata);
+static void ggp_account_register_completed(
+	ggp_account_register_data *register_data, gboolean success);
+
+#define GGP_ACCOUNT_REGISTER_TITLE _("Register New Gadu-Gadu Account")
+
+/******************************************************************************/
+
+void ggp_account_register(PurpleAccount *account)
+{
+	PurpleConnection *gc = purple_account_get_connection(account);
+	ggp_account_register_data *register_data;
+	
+	purple_debug_info("gg", "ggp_account_register\n");
+	
+	register_data = g_new0(ggp_account_register_data, 1);
+	register_data->gc = gc;
+	register_data->password_remember = TRUE;
+	
+	ggp_account_token_request(gc, ggp_account_register_dialog,
+		register_data);
+}
+
+static void ggp_account_register_dialog(PurpleConnection *gc,
+	ggp_account_token *token, gpointer _register_data)
+{
+	PurpleRequestFields *fields;
+	PurpleRequestFieldGroup *main_group, *password_group, *token_group;
+	PurpleRequestField *field, *field_password;
+	ggp_account_register_data *register_data = _register_data;
+	
+	purple_debug_info("gg", "ggp_account_register_dialog(%x, %x, %x)\n",
+		(unsigned int)gc, (unsigned int)token,
+		(unsigned int)_register_data);
+	if (!token)
+	{
+		ggp_account_register_completed(register_data, FALSE);
+		return;
+	}
+	
+	fields = purple_request_fields_new();
+	main_group = purple_request_field_group_new(NULL);
+	purple_request_fields_add_group(fields, main_group);
+	
+	field = purple_request_field_string_new("email", _("Email"),
+		register_data->email, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_set_validator(field,
+		purple_request_field_email_validator, NULL);
+	purple_request_field_group_add_field(main_group, field);
+
+	password_group = purple_request_field_group_new(_("Password"));
+	purple_request_fields_add_group(fields, password_group);
+
+	field = purple_request_field_string_new("password1", _("Password"),
+		register_data->password, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_string_set_masked(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_password, NULL);
+	purple_request_field_group_add_field(password_group, field);
+	field_password = field;
+	
+	field = purple_request_field_string_new("password2",
+		_("Password (again)"), register_data->password, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_string_set_masked(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_password_equal,
+		field_password);
+	purple_request_field_group_add_field(password_group, field);
+	
+	field = purple_request_field_bool_new("password_remember",
+		_("Remember password"), register_data->password_remember);
+	purple_request_field_group_add_field(password_group, field);
+	
+	token_group = purple_request_field_group_new(_("Captcha"));
+	purple_request_fields_add_group(fields, token_group);
+	
+	field = purple_request_field_string_new("token_value",
+		_("Enter text from image below"), register_data->token_value,
+		FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_token, token);
+	purple_request_field_group_add_field(token_group, field);
+	purple_debug_info("gg", "token set %p\n", register_data->token);
+	
+	field = purple_request_field_image_new("token_image", _("Captcha"),
+		token->data, token->size);
+	purple_request_field_group_add_field(token_group, field);
+
+	register_data->token = token;
+	
+	purple_request_fields(gc,
+		GGP_ACCOUNT_REGISTER_TITLE,
+		GGP_ACCOUNT_REGISTER_TITLE,
+		_("Please, fill in the following fields"), fields,
+		_("OK"), G_CALLBACK(ggp_account_register_dialog_ok),
+		_("Cancel"), G_CALLBACK(ggp_account_register_dialog_cancel),
+		purple_connection_get_account(gc), NULL, NULL, register_data);
+}
+
+static void ggp_account_register_dialog_cancel(
+	ggp_account_register_data *register_data, PurpleRequestFields *fields)
+{
+	purple_debug_info("gg", "ggp_account_register_dialog_cancel(%x, %x)\n",
+		(unsigned int)register_data, (unsigned int)fields);
+
+	ggp_account_register_completed(register_data, FALSE);
+}
+
+static void ggp_account_register_dialog_ok(
+	ggp_account_register_data *register_data, PurpleRequestFields *fields)
+{
+	struct gg_http *h;
+
+	purple_debug_misc("gg", "ggp_account_register_dialog_ok(%x, %x)\n",
+		(unsigned int)register_data, (unsigned int)fields);
+
+	g_free(register_data->email);
+	g_free(register_data->password);
+	g_free(register_data->token_value);
+	
+	register_data->email = g_strdup(
+		purple_request_fields_get_string(fields, "email"));
+	register_data->password = g_strdup(
+		purple_request_fields_get_string(fields, "password1"));
+	register_data->password_remember =
+		purple_request_fields_get_bool(fields, "password_remember");
+	register_data->token_value = g_strdup(
+		purple_request_fields_get_string(fields, "token_value"));
+
+	g_assert(register_data->email != NULL);
+	g_assert(register_data->password != NULL);
+	g_assert(register_data->token_value != NULL);
+
+	h = gg_register3(register_data->email, register_data->password,
+		register_data->token->id, register_data->token_value, TRUE);
+	
+	ggp_libgaduw_http_watch(register_data->gc, h,
+		ggp_account_register_response, register_data, TRUE);
+}
+
+#if 0
+// libgadu 1.12.x: use it for invalid token
+static void ggp_account_register_dialog_invalid(
+	ggp_account_register_data *register_data, const gchar *message)
+{
+	purple_debug_warning("gg", "ggp_account_register_dialog_invalid: %s\n",
+		message);
+	ggp_account_register_dialog(register_data->gc, register_data->token,
+		register_data);
+	purple_notify_error(purple_connection_get_account(register_data->gc),
+		GGP_ACCOUNT_REGISTER_TITLE, message, NULL);
+}
+#endif
+
+static void ggp_account_register_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _register_data)
+{
+	ggp_account_register_data *register_data = _register_data;
+	PurpleAccount *account =
+		purple_connection_get_account(register_data->gc);
+	struct gg_pubdir *register_result = h->data;
+	uin_t uin;
+	gchar *tmp;
+	
+	g_assert(!(success && cancelled));
+	
+	if (cancelled)
+	{
+		purple_debug_info("gg", "ggp_account_register_response: "
+			"cancelled\n");
+		ggp_account_register_completed(register_data, FALSE);
+		return;
+	}
+	if (!success || !register_result->success)
+	{
+		//TODO (libgadu 1.12.x): check register_result->error
+		purple_debug_error("gg", "ggp_account_register_response: "
+			"error\n");
+		purple_notify_error(NULL,
+			GGP_ACCOUNT_REGISTER_TITLE,
+			_("Unable to register new account. "
+			"An unknown error occurred."), NULL);
+		ggp_account_register_completed(register_data, FALSE);
+		return;
+	}
+
+	uin = register_result->uin;
+	purple_debug_info("gg", "ggp_account_register_response: "
+		"registered uin %u\n", uin);
+	
+	purple_account_set_username(account, ggp_uin_to_str(uin));
+	purple_account_set_remember_password(account,
+		register_data->password_remember);
+	purple_account_set_password(account, register_data->password);
+	
+	tmp = g_strdup_printf(_("Your new GG number: %u."), uin);
+	purple_notify_info(account, GGP_ACCOUNT_REGISTER_TITLE,
+		_("Registration completed successfully!"), tmp);
+	g_free(tmp);
+	
+	ggp_account_register_completed(register_data, TRUE);
+}
+
+static void ggp_account_register_completed(
+	ggp_account_register_data *register_data, gboolean success)
+{
+	PurpleAccount *account =
+		purple_connection_get_account(register_data->gc);
+
+	purple_debug_misc("gg", "ggp_account_register_completed: %d\n",
+		success);
+	
+	g_free(register_data->email);
+	g_free(register_data->password);
+	g_free(register_data->token_value);
+	ggp_account_token_free(register_data->token);
+	g_free(register_data);
+	
+	purple_account_disconnect(account);
+	purple_account_register_completed(account, success);
+}
+
+/*******************************************************************************
+ * Password change.
+ ******************************************************************************/
+
+typedef struct
+{
+	ggp_account_token *token;
+	PurpleConnection *gc;
+	
+	gchar *email;
+	gchar *password_current;
+	gchar *password_new;
+	gchar *token_value;
+} ggp_account_chpass_data;
+
+static void ggp_account_chpass_data_free(ggp_account_chpass_data *chpass_data);
+static void ggp_account_chpass_dialog(PurpleConnection *gc,
+	ggp_account_token *token, gpointer _chpass_data);
+static void ggp_account_chpass_dialog_ok(
+	ggp_account_chpass_data *chpass_data, PurpleRequestFields *fields);
+static void ggp_account_chpass_dialog_invalid(
+	ggp_account_chpass_data *chpass_data, const gchar *message);
+static void ggp_account_chpass_dialog_cancel(
+	ggp_account_chpass_data *chpass_data, PurpleRequestFields *fields);
+static void ggp_account_chpass_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _chpass_data);
+
+#define GGP_ACCOUNT_CHPASS_TITLE _("Password change")
+
+/******************************************************************************/
+
+static void ggp_account_chpass_data_free(ggp_account_chpass_data *chpass_data)
+{
+	g_free(chpass_data->email);
+	g_free(chpass_data->password_current);
+	g_free(chpass_data->password_new);
+	g_free(chpass_data->token_value);
+	ggp_account_token_free(chpass_data->token);
+	g_free(chpass_data);
+}
+
+void ggp_account_chpass(PurpleConnection *gc)
+{
+	ggp_account_chpass_data *chpass_data;
+	void ggp_account_change_passwd(PurpleConnection *gc);
+	purple_debug_info("gg", "ggp_account_chpass\n");
+	
+	chpass_data = g_new0(ggp_account_chpass_data, 1);
+	chpass_data->gc = gc;
+	
+	ggp_account_token_request(gc, ggp_account_chpass_dialog, chpass_data);
+}
+
+static void ggp_account_chpass_dialog(PurpleConnection *gc,
+	ggp_account_token *token, gpointer _chpass_data)
+{
+	ggp_account_chpass_data *chpass_data = _chpass_data;
+	PurpleAccount *account = purple_connection_get_account(chpass_data->gc);
+	PurpleRequestFields *fields;
+	PurpleRequestFieldGroup *main_group, *password_group, *token_group;
+	PurpleRequestField *field, *field_password;
+	gchar *primary;
+	
+	purple_debug_info("gg", "ggp_account_chpass_dialog(%p, %p, %p)\n",
+		gc, token, _chpass_data);
+	if (!token)
+	{
+		ggp_account_chpass_data_free(chpass_data);
+		return;
+	}
+	
+	fields = purple_request_fields_new();
+	main_group = purple_request_field_group_new(NULL);
+	purple_request_fields_add_group(fields, main_group);
+	
+	field = purple_request_field_string_new("email",
+		_("New email address"), chpass_data->email, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_set_validator(field,
+		purple_request_field_email_validator, NULL);
+	purple_request_field_group_add_field(main_group, field);
+
+	password_group = purple_request_field_group_new(_("Password"));
+	purple_request_fields_add_group(fields, password_group);
+
+	field = purple_request_field_string_new("password_current",
+		_("Current password"), chpass_data->password_current, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_string_set_masked(field, TRUE);
+	purple_request_field_group_add_field(password_group, field);
+	
+	field = purple_request_field_string_new("password_new1",
+		_("Password"), chpass_data->password_new, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_string_set_masked(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_password, NULL);
+	purple_request_field_group_add_field(password_group, field);
+	field_password = field;
+	
+	field = purple_request_field_string_new("password_new2",
+		_("Password (retype)"), chpass_data->password_new, FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_string_set_masked(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_password_equal,
+		field_password);
+	purple_request_field_group_add_field(password_group, field);
+	
+	token_group = purple_request_field_group_new(_("Captcha"));
+	purple_request_fields_add_group(fields, token_group);
+	
+	field = purple_request_field_string_new("token_value",
+		_("Enter text from image below"), chpass_data->token_value,
+		FALSE);
+	purple_request_field_set_required(field, TRUE);
+	purple_request_field_set_validator(field, ggp_validator_token, token);
+	purple_request_field_group_add_field(token_group, field);
+	
+	field = purple_request_field_image_new("token_image", _("Captcha"),
+		token->data, token->size);
+	purple_request_field_group_add_field(token_group, field);
+	
+	chpass_data->token = token;
+	
+	primary = g_strdup_printf(_("Change password for %s"),
+		purple_account_get_username(account));
+	
+	purple_request_fields(gc, GGP_ACCOUNT_CHPASS_TITLE, primary,
+		_("Please enter your current password and your new password."),
+		fields,
+		_("OK"), G_CALLBACK(ggp_account_chpass_dialog_ok),
+		_("Cancel"), G_CALLBACK(ggp_account_chpass_dialog_cancel),
+		account, NULL, NULL, chpass_data);
+	
+	g_free(primary);
+}
+
+static void ggp_account_chpass_dialog_ok(
+	ggp_account_chpass_data *chpass_data, PurpleRequestFields *fields)
+{
+	PurpleAccount *account = purple_connection_get_account(chpass_data->gc);
+	struct gg_http *h;
+	uin_t uin;
+
+	purple_debug_misc("gg", "ggp_account_chpass_dialog_ok(%p, %p)\n",
+		chpass_data, fields);
+
+	g_free(chpass_data->email);
+	g_free(chpass_data->password_current);
+	g_free(chpass_data->password_new);
+	g_free(chpass_data->token_value);
+	
+	chpass_data->email = g_strdup(
+		purple_request_fields_get_string(fields, "email"));
+	chpass_data->password_current = g_strdup(
+		purple_request_fields_get_string(fields, "password_current"));
+	chpass_data->password_new = g_strdup(
+		purple_request_fields_get_string(fields, "password_new1"));
+	chpass_data->token_value = g_strdup(
+		purple_request_fields_get_string(fields, "token_value"));
+
+	g_assert(chpass_data->email != NULL);
+	g_assert(chpass_data->password_current != NULL);
+	g_assert(chpass_data->password_new != NULL);
+	g_assert(chpass_data->token_value != NULL);
+
+	if (g_utf8_collate(chpass_data->password_current,
+		purple_account_get_password(account)) != 0)
+	{
+		g_free(chpass_data->password_current);
+		chpass_data->password_current = NULL;
+		ggp_account_chpass_dialog_invalid(chpass_data,
+			_("Your current password is different from the one that"
+			" you specified."));
+		return;
+	}
+	if (g_utf8_collate(chpass_data->password_current,
+		chpass_data->password_new) == 0)
+	{
+		g_free(chpass_data->password_new);
+		chpass_data->password_new = NULL;
+		ggp_account_chpass_dialog_invalid(chpass_data,
+			_("New password have to be different from the current "
+			"one."));
+		return;
+	}
+
+	uin = ggp_str_to_uin(purple_account_get_username(account));
+	purple_debug_info("gg", "ggp_account_chpass_dialog_ok: validation ok "
+		"[token id=%s, value=%s]\n",
+		chpass_data->token->id, chpass_data->token_value);
+	h = gg_change_passwd4(uin, chpass_data->email,
+		chpass_data->password_current, chpass_data->password_new,
+		chpass_data->token->id, chpass_data->token_value, TRUE);
+	
+	ggp_libgaduw_http_watch(chpass_data->gc, h,
+		ggp_account_chpass_response, chpass_data, TRUE);
+}
+
+static void ggp_account_chpass_dialog_invalid(
+	ggp_account_chpass_data *chpass_data, const gchar *message)
+{
+	purple_debug_warning("gg", "ggp_account_chpass_dialog_invalid: %s\n",
+		message);
+	ggp_account_chpass_dialog(chpass_data->gc, chpass_data->token,
+		chpass_data);
+	purple_notify_error(purple_connection_get_account(chpass_data->gc),
+		GGP_ACCOUNT_CHPASS_TITLE, message, NULL);
+}
+
+static void ggp_account_chpass_dialog_cancel(
+	ggp_account_chpass_data *chpass_data, PurpleRequestFields *fields)
+{
+	ggp_account_chpass_data_free(chpass_data);
+}
+
+static void ggp_account_chpass_response(struct gg_http *h, gboolean success,
+	gboolean cancelled, gpointer _chpass_data)
+{
+	ggp_account_chpass_data *chpass_data = _chpass_data;
+	PurpleAccount *account =
+		purple_connection_get_account(chpass_data->gc);
+	struct gg_pubdir *chpass_result = h->data;
+	
+	g_assert(!(success && cancelled));
+	
+	if (cancelled)
+	{
+		purple_debug_info("gg", "ggp_account_chpass_response: "
+			"cancelled\n");
+		ggp_account_chpass_data_free(chpass_data);
+		return;
+	}
+	if (!success || !chpass_result->success)
+	{
+		//TODO (libgadu 1.12.x): check chpass_result->error
+		purple_debug_error("gg", "ggp_account_chpass_response: "
+			"error\n");
+		purple_notify_error(NULL,
+			GGP_ACCOUNT_CHPASS_TITLE,
+			_("Unable to change password. "
+			"An unknown error occurred."), NULL);
+		ggp_account_chpass_data_free(chpass_data);
+		return;
+	}
+
+	purple_debug_info("gg", "ggp_account_chpass_response: "
+		"password changed\n");
+	
+	purple_account_set_password(account, chpass_data->password_new);
+
+	purple_notify_info(account, GGP_ACCOUNT_CHPASS_TITLE,
+		_("Your password has been changed."), NULL);
+	
+	ggp_account_chpass_data_free(chpass_data);
+	
+	//TODO: reconnect / check how it is done in original client
+	purple_account_disconnect(account);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/account.h	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,31 @@
+#ifndef _GGP_ACCOUNT_H
+#define _GGP_ACCOUNT_H
+
+#include <internal.h>
+
+typedef struct
+{
+	gchar *id;
+	gpointer data;
+	size_t size;
+	int length;
+} ggp_account_token;
+
+/**
+ * token must be free'd with ggp_account_token_free
+ */
+typedef void (*ggp_account_token_cb)(PurpleConnection *gc,
+	ggp_account_token *token, gpointer user_data);
+
+void ggp_account_token_request(PurpleConnection *gc,
+	ggp_account_token_cb callback, void *user_data);
+gboolean ggp_account_token_validate(ggp_account_token *token,
+	const gchar *value);
+void ggp_account_token_free(ggp_account_token *token);
+
+
+void ggp_account_register(PurpleAccount *account);
+
+void ggp_account_chpass(PurpleConnection *gc);
+
+#endif /* _GGP_ACCOUNT_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/avatar.c	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,363 @@
+#include "avatar.h"
+
+#include <debug.h>
+
+#include "gg.h"
+#include "utils.h"
+#include "oauth/oauth-purple.h"
+
+// Common
+
+static inline ggp_avatar_session_data *
+ggp_avatar_get_avdata(PurpleConnection *gc);
+
+static gboolean ggp_avatar_timer_cb(gpointer _gc);
+
+#define GGP_AVATAR_USERAGENT "GG Client build 11.0.0.7562"
+#define GGP_AVATAR_SIZE_MAX 1048576
+
+// Buddy avatars updating
+
+typedef struct
+{
+	uin_t uin;
+	time_t timestamp;
+	
+	PurpleConnection *gc;
+	PurpleUtilFetchUrlData *request;
+} ggp_avatar_buddy_update_req;
+
+static gboolean ggp_avatar_buddy_update_next(PurpleConnection *gc);
+static void ggp_avatar_buddy_update_received(PurpleUtilFetchUrlData *url_data,
+	gpointer _pending_update, const gchar *url_text, gsize len,
+	const gchar *error_message);
+
+#define GGP_AVATAR_BUDDY_URL "http://avatars.gg.pl/%u/s,big"
+
+// Own avatar setting
+
+typedef struct
+{
+	PurpleStoredImage *img;
+} ggp_avatar_own_data;
+
+static void ggp_avatar_own_got_token(PurpleConnection *gc, const gchar *token,
+	gpointer img);
+static void ggp_avatar_own_sent(PurpleUtilFetchUrlData *url_data,
+	gpointer user_data, const gchar *url_text, gsize len,
+	const gchar *error_message);
+
+#define GGP_AVATAR_RESPONSE_MAX 10240
+
+/*******************************************************************************
+ * Common.
+ ******************************************************************************/
+
+void ggp_avatar_setup(PurpleConnection *gc)
+{
+	ggp_avatar_session_data *avdata = ggp_avatar_get_avdata(gc);
+
+	avdata->pending_updates = NULL;
+	avdata->current_update = NULL;
+	avdata->own_data = g_new0(ggp_avatar_own_data, 1);
+	
+	avdata->timer = purple_timeout_add_seconds(1, ggp_avatar_timer_cb, gc);
+}
+
+void ggp_avatar_cleanup(PurpleConnection *gc)
+{
+	ggp_avatar_session_data *avdata = ggp_avatar_get_avdata(gc);
+
+	purple_timeout_remove(avdata->timer);
+
+	if (avdata->current_update != NULL)
+	{
+		ggp_avatar_buddy_update_req *current_update =
+			avdata->current_update;
+		
+		purple_util_fetch_url_cancel(current_update->request);
+		g_free(current_update);
+	}
+	avdata->current_update = NULL;
+	
+	g_free(avdata->own_data);
+
+	g_list_free_full(avdata->pending_updates, &g_free);
+	avdata->pending_updates = NULL;
+}
+
+static inline ggp_avatar_session_data *
+ggp_avatar_get_avdata(PurpleConnection *gc)
+{
+	GGPInfo *accdata = purple_connection_get_protocol_data(gc);
+	return &accdata->avatar_data;
+}
+
+static gboolean ggp_avatar_timer_cb(gpointer _gc)
+{
+	PurpleConnection *gc = _gc;
+	ggp_avatar_session_data *avdata;
+	
+	g_return_val_if_fail(PURPLE_CONNECTION_IS_VALID(gc), FALSE);
+	
+	avdata = ggp_avatar_get_avdata(gc);
+	if (avdata->current_update != NULL)
+	{
+		//TODO: verbose mode
+		//purple_debug_misc("gg", "ggp_avatar_timer_cb(%p): there is "
+		//	"already an update running\n", gc);
+		return TRUE;
+	}
+	
+	while (!ggp_avatar_buddy_update_next(gc));
+	
+	return TRUE;
+}
+
+/*******************************************************************************
+ * Buddy avatars updating.
+ ******************************************************************************/
+
+void ggp_avatar_buddy_update(PurpleConnection *gc, uin_t uin, time_t timestamp)
+{
+	ggp_avatar_session_data *avdata = ggp_avatar_get_avdata(gc);
+	ggp_avatar_buddy_update_req *pending_update =
+		g_new(ggp_avatar_buddy_update_req, 1);
+
+	purple_debug_misc("gg", "ggp_avatar_buddy_update(%p, %u, %lu)\n", gc,
+		uin, timestamp);
+
+	pending_update->uin = uin;
+	pending_update->timestamp = timestamp;
+
+	avdata->pending_updates = g_list_append(avdata->pending_updates,
+		pending_update);
+}
+
+void ggp_avatar_buddy_remove(PurpleConnection *gc, uin_t uin)
+{
+	purple_debug_info("gg", "ggp_avatar_buddy_remove(%p, %u)\n", gc, uin);
+
+	purple_buddy_icons_set_for_user(purple_connection_get_account(gc),
+		ggp_uin_to_str(uin), NULL, 0, NULL);
+}
+
+/* return TRUE if avatar update was performed or there is no new requests,
+   FALSE if we can request another one immediately */
+static gboolean ggp_avatar_buddy_update_next(PurpleConnection *gc)
+{
+	ggp_avatar_session_data *avdata = ggp_avatar_get_avdata(gc);
+	GList *pending_update_it;
+	ggp_avatar_buddy_update_req *pending_update;
+	PurpleBuddy *buddy;
+	PurpleAccount *account = purple_connection_get_account(gc);
+	time_t old_timestamp;
+	const char *old_timestamp_str;
+	gchar *avatar_url;
+	
+	pending_update_it = g_list_first(avdata->pending_updates);
+	if (pending_update_it == NULL)
+		return TRUE;
+	
+	pending_update = pending_update_it->data;
+	avdata->pending_updates = g_list_remove(avdata->pending_updates,
+		pending_update);
+	buddy = purple_find_buddy(account, ggp_uin_to_str(pending_update->uin));
+	
+	if (!buddy)
+	{
+		if (ggp_str_to_uin(purple_account_get_username(account)) ==
+			pending_update->uin)
+		{
+			purple_debug_misc("gg",
+				"ggp_avatar_buddy_update_next(%p): own "
+				"avatar update requested, but we don't have "
+				"ourselves on buddy list\n", gc);
+		}
+		else
+		{
+			purple_debug_warning("gg",
+				"ggp_avatar_buddy_update_next(%p): "
+				"%u update requested, but he's not on buddy "
+				"list\n", gc, pending_update->uin);
+		}
+		return FALSE;
+	}
+
+	old_timestamp_str = purple_buddy_icons_get_checksum_for_user(buddy);
+	old_timestamp = old_timestamp_str ? g_ascii_strtoull(
+		old_timestamp_str, NULL, 10) : 0;
+	if (old_timestamp == pending_update->timestamp)
+	{
+		purple_debug_misc("gg",
+			"ggp_avatar_buddy_update_next(%p): "
+			"%u have up to date avatar with ts=%lu\n", gc,
+			pending_update->uin, pending_update->timestamp);
+		return FALSE;
+	}
+	if (old_timestamp > pending_update->timestamp)
+	{
+		purple_debug_warning("gg",
+			"ggp_avatar_buddy_update_next(%p): "
+			"saved timestamp for %u is newer than received "
+			"(%lu > %lu)\n", gc, pending_update->uin, old_timestamp,
+			pending_update->timestamp);
+	}
+	
+	purple_debug_info("gg",
+		"ggp_avatar_buddy_update_next(%p): "
+		"updating %u with ts=%lu...\n", gc, pending_update->uin,
+		pending_update->timestamp);
+
+	pending_update->gc = gc;
+	avdata->current_update = pending_update;
+	avatar_url = g_strdup_printf(GGP_AVATAR_BUDDY_URL, pending_update->uin);
+	pending_update->request = purple_util_fetch_url_request(account,
+		avatar_url, FALSE, GGP_AVATAR_USERAGENT, TRUE, NULL, FALSE,
+		GGP_AVATAR_SIZE_MAX, ggp_avatar_buddy_update_received,
+		pending_update);
+	g_free(avatar_url);
+	
+	return TRUE;
+}
+
+static void ggp_avatar_buddy_update_received(PurpleUtilFetchUrlData *url_data,
+	gpointer _pending_update, const gchar *url_text, gsize len,
+	const gchar *error_message)
+{
+	ggp_avatar_buddy_update_req *pending_update = _pending_update;
+	PurpleBuddy *buddy;
+	PurpleAccount *account;
+	PurpleConnection *gc = pending_update->gc;
+	ggp_avatar_session_data *avdata;
+	gchar timestamp_str[20];
+
+	if (!PURPLE_CONNECTION_IS_VALID(gc))
+	{
+		g_free(pending_update);
+		return;
+	}
+
+	avdata = ggp_avatar_get_avdata(gc);
+	g_assert(pending_update == avdata->current_update);
+	avdata->current_update = NULL;
+
+	if (len == 0)
+	{
+		purple_debug_error("gg", "ggp_avatar_buddy_update_received: bad"
+			" response while getting avatar for %u: %s\n",
+			pending_update->uin, error_message);
+		g_free(pending_update);
+		return;
+	}
+
+	account = purple_connection_get_account(gc);
+	buddy = purple_find_buddy(account, ggp_uin_to_str(pending_update->uin));
+
+	if (!buddy)
+	{
+		purple_debug_warning("gg", "ggp_avatar_buddy_update_received: "
+			"buddy %u disappeared\n", pending_update->uin);
+		g_free(pending_update);
+		return;
+	}
+
+	g_snprintf(timestamp_str, sizeof(timestamp_str), "%lu",
+		pending_update->timestamp);
+	purple_buddy_icons_set_for_user(account, purple_buddy_get_name(buddy),
+		g_memdup(url_text, len), len, timestamp_str);
+
+	purple_debug_info("gg", "ggp_avatar_buddy_update_received: "
+		"got avatar for buddy %u [ts=%lu]\n", pending_update->uin,
+		pending_update->timestamp);
+	g_free(pending_update);
+}
+
+/*******************************************************************************
+ * Own avatar setting.
+ ******************************************************************************/
+
+/**
+ * TODO: use new, GG11 method, when IMToken will be provided by libgadu.
+ *
+ * POST https://avatars.mpa.gg.pl/avatars/user,<uin>/0
+ * Authorization: IMToken 0123456789abcdef0123456789abcdef01234567
+ * photo=<avatar content>
+ */
+
+void ggp_avatar_own_set(PurpleConnection *gc, PurpleStoredImage *img)
+{
+	ggp_avatar_own_data *own_data = ggp_avatar_get_avdata(gc)->own_data;
+	
+	purple_debug_info("gg", "ggp_avatar_own_set(%p, %p)", gc, img);
+	
+	if (img == NULL)
+	{
+		purple_debug_warning("gg", "ggp_avatar_own_set: avatar removing"
+			" is probably not possible within old protocol");
+		return;
+	}
+	
+	own_data->img = img;
+	
+	ggp_oauth_request(gc, ggp_avatar_own_got_token, img);
+}
+
+static void ggp_avatar_own_got_token(PurpleConnection *gc, const gchar *token,
+	gpointer img)
+{
+	ggp_avatar_own_data *own_data = ggp_avatar_get_avdata(gc)->own_data;
+	gchar *img_data, *img_data_e, *request, *request_data;
+	PurpleAccount *account = purple_connection_get_account(gc);
+	uin_t uin = ggp_str_to_uin(purple_account_get_username(account));
+	
+	if (img != own_data->img)
+	{
+		purple_debug_warning("gg", "ggp_avatar_own_got_token: "
+			"avatar was changed in meantime\n");
+		return;
+	}
+	own_data->img = NULL;
+	
+	img_data = purple_base64_encode(purple_imgstore_get_data(img),
+		purple_imgstore_get_size(img));
+	img_data_e = g_uri_escape_string(img_data, NULL, FALSE);
+	g_free(img_data);
+	request_data = g_strdup_printf("uin=%d&photo=%s", uin, img_data_e);
+	g_free(img_data_e);
+	
+	request = g_strdup_printf(
+		"POST /upload HTTP/1.1\r\n"
+		"Host: avatars.nowe.gg\r\n"
+		"Authorization: %s\r\n"
+		"From: avatars to avatars\r\n"
+		"Content-Length: %u\r\n"
+		"Content-Type: application/x-www-form-urlencoded\r\n"
+		"\r\n%s",
+		token, strlen(request_data), request_data);
+	g_free(request_data);
+	
+	purple_debug_misc("gg", "ggp_avatar_own_got_token: "
+		"uploading new avatar...\n");
+	purple_util_fetch_url_request(account, "http://avatars.nowe.gg/upload",
+		FALSE, NULL, TRUE, request, FALSE, GGP_AVATAR_RESPONSE_MAX,
+		ggp_avatar_own_sent, gc);
+	
+	g_free(request);
+}
+
+static void ggp_avatar_own_sent(PurpleUtilFetchUrlData *url_data,
+	gpointer user_data, const gchar *url_text, gsize len,
+	const gchar *error_message)
+{
+	PurpleConnection *gc = user_data;
+	
+	if (!PURPLE_CONNECTION_IS_VALID(gc))
+		return;
+	
+	if (len == 0)
+		purple_debug_error("gg", "ggp_avatar_own_sent: "
+			"avatar not sent. %s\n", error_message);
+	else
+		purple_debug_info("gg", "ggp_avatar_own_sent: %s\n", url_text);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/avatar.h	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,24 @@
+#ifndef _GGP_AVATAR_H
+#define _GGP_AVATAR_H
+
+#include <internal.h>
+#include <libgadu.h>
+
+typedef struct
+{
+	guint timer;
+	GList *pending_updates;
+	
+	gpointer current_update;
+	gpointer own_data;
+} ggp_avatar_session_data;
+
+void ggp_avatar_setup(PurpleConnection *gc);
+void ggp_avatar_cleanup(PurpleConnection *gc);
+
+void ggp_avatar_buddy_update(PurpleConnection *gc, uin_t uin, time_t timestamp);
+void ggp_avatar_buddy_remove(PurpleConnection *gc, uin_t uin);
+
+void ggp_avatar_own_set(PurpleConnection *gc, PurpleStoredImage *img);
+
+#endif /* _GGP_AVATAR_H */

--- a/libpurple/protocols/gg/buddylist.c	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/buddylist.c	Tue Aug 14 22:26:33 2012 +0200
@@ -22,9 +22,10 @@
 
 
 #include <libgadu.h>
+#include <debug.h>
 
 #include "gg.h"
-#include "gg-utils.h"
+#include "utils.h"
 #include "buddylist.h"
 
 #define F_FIRSTNAME 0
@@ -36,6 +37,7 @@
 #define F_UIN 6
 
 /* void ggp_buddylist_send(PurpleConnection *gc) {{{ */
+// this is for for notify purposes, not synchronizing buddy list
 void ggp_buddylist_send(PurpleConnection *gc)
 {
 	GGPInfo *info = purple_connection_get_protocol_data(gc);
@@ -81,7 +83,7 @@
 	PurpleGroup *group;
 	gchar **users_tbl;
 	int i;
-	char *utf8buddylist = charset_convert(buddylist, "CP1250", "UTF-8");
+	char *utf8buddylist = ggp_convert_from_cp1250(buddylist);
 
 	/* Don't limit the number of records in a buddylist. */
 	users_tbl = g_strsplit(utf8buddylist, "\r\n", -1);
@@ -94,7 +96,7 @@
 			continue;
 
 		data_tbl = g_strsplit(users_tbl[i], ";", 8);
-		if (ggp_array_size(data_tbl) < 8) {
+		if (g_strv_length(data_tbl) < 8) {
 			purple_debug_warning("gg",
 				"Something is wrong on line %d of the buddylist. Skipping.\n",
 				i + 1);
@@ -127,7 +129,7 @@
 			/* XXX: Probably buddy should be added to all the groups. */
 			/* Hard limit to at most 50 groups */
 			gchar **group_tbl = g_strsplit(data_tbl[F_GROUP], ",", 50);
-			if (ggp_array_size(group_tbl) > 0) {
+			if (g_strv_length(group_tbl) > 0) {
 				g_free(g);
 				g = g_strdup(group_tbl[0]);
 			}
@@ -178,11 +180,22 @@
 				"", gname, bname, "", "");
 	}
 
-	ptr = charset_convert(buddylist->str, "UTF-8", "CP1250");
+	ptr = ggp_convert_to_cp1250(buddylist->str);
 	g_string_free(buddylist, TRUE);
 	return ptr;
 }
 /* }}} */
 
+const char * ggp_buddylist_get_buddy_name(PurpleConnection *gc, const uin_t uin)
+{
+	const char *uin_s = ggp_uin_to_str(uin);
+	PurpleBuddy *buddy = purple_find_buddy(
+		purple_connection_get_account(gc), uin_s);
+	
+	if (buddy != NULL)
+		return purple_buddy_get_alias(buddy);
+	else
+		return uin_s;
+}
 
 /* vim: set ts=8 sts=0 sw=8 noet: */

--- a/libpurple/protocols/gg/buddylist.h	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/buddylist.h	Tue Aug 14 22:26:33 2012 +0200
@@ -50,6 +50,16 @@
 char *
 ggp_buddylist_dump(PurpleAccount *account);
 
+/**
+ * Returns the best name of a buddy from the buddylist.
+ *
+ * @param gc  PurpleConnection instance.
+ * @param uin UIN of the buddy.
+ *
+ * @return Name of the buddy, or UIN converted to string, if there is no such
+ * user on the list.
+ */
+const char * ggp_buddylist_get_buddy_name(PurpleConnection *gc, const uin_t uin);
 
 #endif /* _PURPLE_GG_BUDDYLIST_H */
 

--- a/libpurple/protocols/gg/confer.c	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/confer.c	Tue Aug 14 22:26:33 2012 +0200
@@ -23,7 +23,7 @@
 
 #include <libgadu.h>
 #include "gg.h"
-#include "gg-utils.h"
+#include "utils.h"
 #include "confer.h"
 
 /* PurpleConversation *ggp_confer_find_by_name(PurpleConnection *gc, const gchar *name) {{{ */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/deprecated.c	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,33 @@
+#include "deprecated.h"
+
+#include <libgadu.h>
+
+gboolean ggp_deprecated_setup_proxy(PurpleConnection *gc)
+{
+	PurpleProxyInfo *gpi = purple_proxy_get_setup(purple_connection_get_account(gc));
+	
+	if ((purple_proxy_info_get_type(gpi) != PURPLE_PROXY_NONE) &&
+		(purple_proxy_info_get_host(gpi) == NULL ||
+		purple_proxy_info_get_port(gpi) <= 0))
+	{
+		gg_proxy_enabled = 0;
+		purple_notify_error(NULL, NULL, _("Invalid proxy settings"),
+			_("Either the host name or port number specified for your given proxy type is invalid."));
+		return FALSE;
+	}
+	
+	if (purple_proxy_info_get_type(gpi) == PURPLE_PROXY_NONE)
+	{
+		gg_proxy_enabled = 0;
+		return TRUE;
+	}
+
+	gg_proxy_enabled = 1;
+	//TODO: memleak
+	gg_proxy_host = g_strdup(purple_proxy_info_get_host(gpi));
+	gg_proxy_port = purple_proxy_info_get_port(gpi);
+	gg_proxy_username = g_strdup(purple_proxy_info_get_username(gpi));
+	gg_proxy_password = g_strdup(purple_proxy_info_get_password(gpi));
+	
+	return TRUE;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/deprecated.h	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,8 @@
+#ifndef _GGP_DEPRECATED_H
+#define _GGP_DEPRECATED_H
+
+#include <internal.h>
+
+gboolean ggp_deprecated_setup_proxy(PurpleConnection *gc);
+
+#endif /* _GGP_DEPRECATED_H */

--- a/libpurple/protocols/gg/gg-utils.c	Tue Aug 14 22:05:05 2012 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,160 +0,0 @@
-/**
- * @file gg-utils.c
- *
- * purple
- *
- * Copyright (C) 2005  Bartosz Oler <bartosz@bzimage.us>
- *
- * 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 "gg-utils.h"
-
-
-/* uin_t ggp_str_to_uin(const char *str) {{{ */
-uin_t ggp_str_to_uin(const char *str)
-{
-	char *tmp;
-	long num;
-
-	if (!str)
-		return 0;
-
-	errno = 0;
-	num = strtol(str, &tmp, 10);
-
-	if (*str == '\0' || *tmp != '\0')
-		return 0;
-
-	if ((errno == ERANGE || (num == LONG_MAX || num == LONG_MIN))
-#if (LONG_MAX > UINT_MAX)
-	    || num > (long)UINT_MAX
-#endif
-	    || num < 0)
-		return 0;
-
-	return (uin_t) num;
-}
-/* }}} */
-
-/* unsigned int ggp_array_size(char **array) {{{ */
-unsigned int ggp_array_size(char **array)
-{
-	unsigned int i;
-
-	for (i = 0; array[i] != NULL && i < UINT_MAX; i++)
-	{}
-
-	return i;
-}
-/* }}} */
-
-/* char *charset_convert(const gchar *locstr, const char *encsrc, const char *encdst) {{{ */
-char *charset_convert(const gchar *locstr, const char *encsrc, const char *encdst)
-{
-	gchar *msg;
-	GError *err = NULL;
-
-	if (locstr == NULL)
-		return NULL;
-
-	msg = g_convert_with_fallback(locstr, strlen(locstr), encdst, encsrc,
-				      "?", NULL, NULL, &err);
-	if (err != NULL) {
-		purple_debug_error("gg", "Error converting from %s to %s: %s\n",
-				 encsrc, encdst, err->message);
-		g_error_free(err);
-	}
-
-	/* Just in case? */
-	if (msg == NULL)
-		msg = g_strdup(locstr);
-
-	return msg;
-}
-/* }}} */
-
-/* ggp_get_uin(PurpleAccount *account) {{{ */
-uin_t ggp_get_uin(PurpleAccount *account)
-{
-	return ggp_str_to_uin(purple_account_get_username(account));
-}
-/* }}} */
-
-/* char *ggp_buddy_get_name(PurpleConnection *gc, const uin_t uin) {{{ */
-char *ggp_buddy_get_name(PurpleConnection *gc, const uin_t uin)
-{
-	PurpleBuddy *buddy;
-	gchar *str_uin;
-
-	str_uin = g_strdup_printf("%lu", (unsigned long int)uin);
-
-	buddy = purple_find_buddy(purple_connection_get_account(gc), str_uin);
-	if (buddy != NULL) {
-		g_free(str_uin);
-		return g_strdup(purple_buddy_get_alias(buddy));
-	} else {
-		return str_uin;
-	}
-}
-/* }}} */
-
-void ggp_status_fake_to_self(PurpleAccount *account)
-{
-	PurplePresence *presence;
-	PurpleStatus *status;
-	const char *status_id;
-	const char *msg;
-
-	if (! purple_find_buddy(account, purple_account_get_username(account)))
-		return;
-
-	presence = purple_account_get_presence(account);
-	status = purple_presence_get_active_status(presence);
-	msg = purple_status_get_attr_string(status, "message");
-	if (msg && !*msg)
-		msg = NULL;
-
-	status_id = purple_status_get_id(status);
-	if (strcmp(status_id, "invisible") == 0) {
-		status_id = "offline";
-	}
-
-	if (msg) {
-		if (strlen(msg) > GG_STATUS_DESCR_MAXSIZE) {
-			msg = purple_markup_slice(msg, 0, GG_STATUS_DESCR_MAXSIZE);
-		}
-	}
-	purple_prpl_got_user_status(account, purple_account_get_username(account),
-				    status_id,
-				    msg ? "message" : NULL, msg, NULL);
-}
-
-guint ggp_http_input_add(struct gg_http *http_req, PurpleInputFunction func,
-	gpointer user_data)
-{
-	PurpleInputCondition cond = 0;
-	int check = http_req->check;
-
-	if (check & GG_CHECK_READ)
-		cond |= PURPLE_INPUT_READ;
-	if (check & GG_CHECK_WRITE)
-		cond |= PURPLE_INPUT_WRITE;
-
-	return purple_input_add(http_req->fd, cond, func, user_data);
-}
-
-/* vim: set ts=8 sts=0 sw=8 noet: */

--- a/libpurple/protocols/gg/gg-utils.h	Tue Aug 14 22:05:05 2012 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,121 +0,0 @@
-/**
- * @file gg-utils.h
- *
- * purple
- *
- * Copyright (C) 2005  Bartosz Oler <bartosz@bzimage.us>
- *
- * 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
- */
-
-#ifndef _PURPLE_GG_UTILS_H
-#define _PURPLE_GG_UTILS_H
-
-#include "internal.h"
-
-#include "plugin.h"
-#include "version.h"
-#include "notify.h"
-#include "status.h"
-#include "blist.h"
-#include "accountopt.h"
-#include "debug.h"
-#include "util.h"
-#include "request.h"
-
-#include "gg.h"
-
-
-/**
- * Convert a base 10 string to a UIN.
- *
- * @param str The string to convert
- *
- * @return UIN or 0 if an error occurred.
- */
-uin_t
-ggp_str_to_uin(const char *str);
-
-/**
- * Calculate size of a NULL-terminated array.
- *
- * @param array The array.
- *
- * @return Size of the array.
- */
-unsigned int
-ggp_array_size(char **array);
-
-/**
- * Convert enconding of a given string.
- *
- * @param locstr Input string.
- * @param encsrc Current encoding of the string.
- * @param encdst Target encoding of the string.
- *
- * @return Converted string (it must be g_free()ed when not used. Or NULL if
- * locstr is NULL.
- */
-char *
-charset_convert(const gchar *locstr, const char *encsrc, const char *encdst);
-
-/**
- * Get UIN of a given account.
- *
- * @param account Current account.
- *
- * @return UIN of an account.
- */
-uin_t
-ggp_get_uin(PurpleAccount *account);
-
-/**
- * Returns the best name of a buddy from the buddylist.
- *
- * @param gc  PurpleConnection instance.
- * @param uin UIN of the buddy.
- *
- * @return Name of the buddy, or UIN converted to string.
- */
-char *
-ggp_buddy_get_name(PurpleConnection *gc, const uin_t uin);
-
-/**
- * Manages the display of account's status in the buddylist.
- *
- * @param account Current account.
- */
-void
-ggp_status_fake_to_self(PurpleAccount *account);
-
-
-/**
- * Adds an input handler in purple event loop for http request.
- *
- * @see purple_input_add
- *
- * @param http_req  Http connection to watch.
- * @param func      The callback function for data.
- * @param user_data User-specified data.
- *
- * @return The resulting handle (will be greater than 0).
- */
-guint
-ggp_http_input_add(struct gg_http *http_req, PurpleInputFunction func,
-	gpointer user_data);
-
-#endif /* _PURPLE_GG_UTILS_H */
-
-/* vim: set ts=8 sts=0 sw=8 noet: */

--- a/libpurple/protocols/gg/gg.c	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/gg.c	Tue Aug 14 22:26:33 2012 +0200
@@ -26,12 +26,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 
-#include "internal.h"
+#include <internal.h>
 
 #include "plugin.h"
 #include "version.h"
 #include "notify.h"
-#include "status.h"
 #include "blist.h"
 #include "accountopt.h"
 #include "debug.h"
@@ -43,206 +42,25 @@
 #include "confer.h"
 #include "search.h"
 #include "buddylist.h"
-#include "gg-utils.h"
-
-#ifdef _WIN32
-#  include "win32-resolver.h"
-#endif
-
-static PurplePlugin *my_protocol = NULL;
+#include "utils.h"
+#include "resolver-purple.h"
+#include "account.h"
+#include "deprecated.h"
+#include "purplew.h"
+#include "libgadu-events.h"
+#include "multilogon.h"
+#include "status.h"
 
 /* Prototypes */
-static void ggp_set_status(PurpleAccount *account, PurpleStatus *status);
-static int ggp_to_gg_status(PurpleStatus *status, char **msg);
 
-/* ---------------------------------------------------------------------- */
-/* ----- EXTERNAL CALLBACKS --------------------------------------------- */
-/* ---------------------------------------------------------------------- */
+typedef struct
+{
+	gboolean blocked;
+} ggp_buddy_data;
 
 
-/* ----- HELPERS -------------------------------------------------------- */
-
-/**
- * Set up libgadu's proxy.
- *
- * @param account Account for which to set up the proxy.
- *
- * @return Zero if proxy setup is valid, otherwise -1.
- */
-static int ggp_setup_proxy(PurpleAccount *account)
-{
-	PurpleProxyInfo *gpi;
-
-	gpi = purple_proxy_get_setup(account);
-
-	if ((purple_proxy_info_get_type(gpi) != PURPLE_PROXY_NONE) &&
-	    (purple_proxy_info_get_host(gpi) == NULL ||
-	     purple_proxy_info_get_port(gpi) <= 0)) {
-
-		gg_proxy_enabled = 0;
-		purple_notify_error(NULL, NULL, _("Invalid proxy settings"),
-				  _("Either the host name or port number specified for your given proxy type is invalid."));
-		return -1;
-	} else if (purple_proxy_info_get_type(gpi) != PURPLE_PROXY_NONE) {
-		gg_proxy_enabled = 1;
-		gg_proxy_host = g_strdup(purple_proxy_info_get_host(gpi));
-		gg_proxy_port = purple_proxy_info_get_port(gpi);
-		gg_proxy_username = g_strdup(purple_proxy_info_get_username(gpi));
-		gg_proxy_password = g_strdup(purple_proxy_info_get_password(gpi));
-	} else {
-		gg_proxy_enabled = 0;
-	}
-
-	return 0;
-}
-
-static void ggp_async_token_handler(gpointer _gc, gint fd, PurpleInputCondition cond)
-{
-	PurpleConnection *gc = _gc;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	GGPToken *token = info->token;
-	GGPTokenCallback cb;
-
-	struct gg_token *t = NULL;
-
-	purple_debug_info("gg", "token_handler: token->req: check = %d; state = %d;\n",
-			token->req->check, token->req->state);
-
-	if (gg_token_watch_fd(token->req) == -1 || token->req->state == GG_STATE_ERROR) {
-		purple_debug_error("gg", "token error (1): %d\n", token->req->error);
-		purple_input_remove(token->inpa);
-		gg_token_free(token->req);
-		token->req = NULL;
-
-		purple_notify_error(purple_connection_get_account(gc),
-				  _("Token Error"),
-				  _("Unable to fetch the token.\n"), NULL);
-		return;
-	}
-
-	if (token->req->state != GG_STATE_DONE) {
-		purple_input_remove(token->inpa);
-		token->inpa = purple_input_add(token->req->fd,
-						   (token->req->check == 1)
-						   	? PURPLE_INPUT_WRITE
-							: PURPLE_INPUT_READ,
-						   ggp_async_token_handler, gc);
-		return;
-	}
-
-	if (!(t = token->req->data) || !token->req->body) {
-		purple_debug_error("gg", "token error (2): %d\n", token->req->error);
-		purple_input_remove(token->inpa);
-		gg_token_free(token->req);
-		token->req = NULL;
-
-		purple_notify_error(purple_connection_get_account(gc),
-				  _("Token Error"),
-				  _("Unable to fetch the token.\n"), NULL);
-		return;
-	}
-
-	purple_input_remove(token->inpa);
-
-	token->id = g_strdup(t->tokenid);
-	token->size = token->req->body_size;
-	token->data = g_new0(char, token->size);
-	memcpy(token->data, token->req->body, token->size);
-
-	purple_debug_info("gg", "TOKEN! tokenid = %s; size = %d\n",
-			token->id, token->size);
-
-	gg_token_free(token->req);
-	token->req = NULL;
-	token->inpa = 0;
-
-	cb = token->cb;
-	token->cb = NULL;
-	cb(gc);
-}
-
-static void ggp_token_request(PurpleConnection *gc, GGPTokenCallback cb)
-{
-	PurpleAccount *account;
-	struct gg_http *req;
-	GGPInfo *info;
-
-	account = purple_connection_get_account(gc);
-
-	if (ggp_setup_proxy(account) == -1)
-		return;
-
-	info = purple_connection_get_protocol_data(gc);
-
-	if ((req = gg_token(1)) == NULL) {
-		purple_notify_error(account,
-				  _("Token Error"),
-				  _("Unable to fetch the token.\n"), NULL);
-		return;
-	}
-
-	info->token = g_new(GGPToken, 1);
-	info->token->cb = cb;
-
-	info->token->req = req;
-	info->token->inpa = purple_input_add(req->fd, PURPLE_INPUT_READ,
-					   ggp_async_token_handler, gc);
-}
-/* }}} */
-
 /* ---------------------------------------------------------------------- */
-
-/**
- * Request buddylist from the server.
- * Buddylist is received in the ggp_callback_recv().
- *
- * @param Current action handler.
- */
-static void ggp_action_buddylist_get(PurplePluginAction *action)
-{
-	PurpleConnection *gc = (PurpleConnection *)action->context;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-
-	purple_debug_info("gg", "Downloading...\n");
-
-	gg_userlist_request(info->session, GG_USERLIST_GET, NULL);
-}
-
-/**
- * Upload the buddylist to the server.
- *
- * @param action Current action handler.
- */
-static void ggp_action_buddylist_put(PurplePluginAction *action)
-{
-	PurpleConnection *gc = (PurpleConnection *)action->context;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-
-	char *buddylist = ggp_buddylist_dump(purple_connection_get_account(gc));
-
-	purple_debug_info("gg", "Uploading...\n");
-
-	if (buddylist == NULL)
-		return;
-
-	gg_userlist_request(info->session, GG_USERLIST_PUT, buddylist);
-	g_free(buddylist);
-}
-
-/**
- * Delete buddylist from the server.
- *
- * @param action Current action handler.
- */
-static void ggp_action_buddylist_delete(PurplePluginAction *action)
-{
-	PurpleConnection *gc = (PurpleConnection *)action->context;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-
-	purple_debug_info("gg", "Deleting...\n");
-
-	gg_userlist_request(info->session, GG_USERLIST_PUT, NULL);
-}
+// buddy list import/export from/to file
 
 static void ggp_callback_buddylist_save_ok(PurpleConnection *gc, const char *filename)
 {
@@ -332,154 +150,6 @@
 			gc);
 }
 
-static void ggp_callback_register_account_ok(PurpleConnection *gc,
-					     PurpleRequestFields *fields)
-{
-	PurpleAccount *account;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	struct gg_http *h = NULL;
-	struct gg_pubdir *s;
-	uin_t uin;
-	gchar *email, *p1, *p2, *t;
-	GGPToken *token = info->token;
-
-	email = charset_convert(purple_request_fields_get_string(fields, "email"),
-			     "UTF-8", "CP1250");
-	p1  = charset_convert(purple_request_fields_get_string(fields, "password1"),
-			     "UTF-8", "CP1250");
-	p2  = charset_convert(purple_request_fields_get_string(fields, "password2"),
-			     "UTF-8", "CP1250");
-	t   = charset_convert(purple_request_fields_get_string(fields, "token"),
-			     "UTF-8", "CP1250");
-
-	account = purple_connection_get_account(gc);
-
-	if (email == NULL || p1 == NULL || p2 == NULL || t == NULL ||
-	    *email == '\0' || *p1 == '\0' || *p2 == '\0' || *t == '\0') {
-		purple_connection_error (gc,
-			PURPLE_CONNECTION_ERROR_OTHER_ERROR,
-			_("You must fill in all registration fields"));
-		goto exit_err;
-	}
-
-	if (g_utf8_collate(p1, p2) != 0) {
-		purple_connection_error (gc,
-			PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
-			_("Passwords do not match"));
-		goto exit_err;
-	}
-
-	purple_debug_info("gg", "register_account_ok: token_id = %s; t = %s\n",
-			token->id, t);
-	h = gg_register3(email, p1, token->id, t, 0);
-	if (h == NULL || !(s = h->data) || !s->success) {
-		purple_connection_error (gc,
-			PURPLE_CONNECTION_ERROR_OTHER_ERROR,
-			_("Unable to register new account.  An unknown error occurred."));
-		goto exit_err;
-	}
-
-	uin = s->uin;
-	purple_debug_info("gg", "registered uin: %d\n", uin);
-
-	g_free(t);
-	t = g_strdup_printf("%u", uin);
-	purple_account_set_username(account, t);
-	/* Save the password if remembering passwords for the account */
-	purple_account_set_password(account, p1);
-
-	purple_notify_info(NULL, _("New Gadu-Gadu Account Registered"),
-			 _("Registration completed successfully!"), NULL);
-
-	purple_account_register_completed(account, TRUE);
-
-	/* TODO: the currently open Accounts Window will not be updated withthe
-	 * new username and etc, we need to somehow have it refresh at this
-	 * point
-	 */
-
-	/* Need to disconnect or actually log in. For now, we disconnect. */
-	purple_account_disconnect(account);
-
-exit_err:
-	purple_account_register_completed(account, FALSE);
-
-	gg_register_free(h);
-	g_free(email);
-	g_free(p1);
-	g_free(p2);
-	g_free(t);
-	g_free(token->id);
-	g_free(token);
-}
-
-static void ggp_callback_register_account_cancel(PurpleConnection *gc,
-						 PurpleRequestFields *fields)
-{
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	GGPToken *token = info->token;
-
-	purple_account_disconnect(purple_connection_get_account(gc));
-
-	g_free(token->id);
-	g_free(token->data);
-	g_free(token);
-
-}
-
-static void ggp_register_user_dialog(PurpleConnection *gc)
-{
-	PurpleAccount *account;
-	PurpleRequestFields *fields;
-	PurpleRequestFieldGroup *group;
-	PurpleRequestField *field;
-
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	GGPToken *token = info->token;
-
-
-	account = purple_connection_get_account(gc);
-
-	fields = purple_request_fields_new();
-	group = purple_request_field_group_new(NULL);
-	purple_request_fields_add_group(fields, group);
-
-	field = purple_request_field_string_new("email",
-			_("Email"), "", FALSE);
-	purple_request_field_string_set_masked(field, FALSE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("password1",
-			_("Password"), "", FALSE);
-	purple_request_field_string_set_masked(field, TRUE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("password2",
-			_("Password (again)"), "", FALSE);
-	purple_request_field_string_set_masked(field, TRUE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("token",
-			_("Enter captcha text"), "", FALSE);
-	purple_request_field_string_set_masked(field, FALSE);
-	purple_request_field_group_add_field(group, field);
-
-	/* original size: 60x24 */
-	field = purple_request_field_image_new("token_img",
-			_("Captcha"), token->data, token->size);
-	purple_request_field_group_add_field(group, field);
-
-	purple_request_fields(account,
-		_("Register New Gadu-Gadu Account"),
-		_("Register New Gadu-Gadu Account"),
-		_("Please, fill in the following fields"),
-		fields,
-		_("OK"), G_CALLBACK(ggp_callback_register_account_ok),
-		_("Cancel"), G_CALLBACK(ggp_callback_register_account_cancel),
-		purple_connection_get_account(gc), NULL, NULL,
-		gc);
-}
-
 /* ----- PUBLIC DIRECTORY SEARCH ---------------------------------------- */
 
 static void ggp_callback_show_next(PurpleConnection *gc, GList *row, gpointer user_data)
@@ -617,265 +287,6 @@
 		gc);
 }
 
-/* ----- CHANGE PASSWORD ---------------------------------------------------- */
-
-typedef struct
-{
-	guint inpa;
-	struct gg_http *http_req;
-	gchar *new_password;
-	PurpleAccount *account;
-} ggp_change_passwd_request;
-
-static void ggp_callback_change_passwd_handler(gpointer _req, gint fd,
-	PurpleInputCondition cond)
-{
-	ggp_change_passwd_request *req = _req;
-	const char *messagesTitle =
-		_("Change password for the Gadu-Gadu account");
-
-	purple_input_remove(req->inpa);
-
-	if (gg_change_passwd_watch_fd(req->http_req) == -1 ||
-		req->http_req->state == GG_STATE_ERROR)
-		goto exit_error;
-
-	if (req->http_req->state != GG_STATE_DONE)
-	{
-		req->inpa = ggp_http_input_add(req->http_req,
-			ggp_callback_change_passwd_handler, req);
-		return;
-	}
-
-	if (req->http_req->data != NULL &&
-		((struct gg_pubdir*)req->http_req->data)->success == 1)
-	{
-		purple_account_set_password(req->account, req->new_password);
-		purple_notify_info(req->account, messagesTitle,
-			_("Password was changed successfully!"), NULL);
-		goto exit_cleanup;
-	}
-
-exit_error:
-	purple_notify_error(req->account, messagesTitle,
-		_("Unable to change password. Error occurred.\n"), NULL);
-
-exit_cleanup:
-	gg_change_passwd_free(req->http_req);
-	g_free(req->new_password);
-	g_free(req);
-}
-
-static void ggp_callback_change_passwd_ok(PurpleConnection *gc,
-	PurpleRequestFields *fields)
-{
-	PurpleAccount *account;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	struct gg_http *h;
-	gchar *cur, *p1, *p2, *t, *mail;
-	const char *messagesTitle =
-		_("Change password for the Gadu-Gadu account");
-
-	cur = g_strdup(purple_request_fields_get_string(fields,
-		"password_cur"));
-	p1 = g_strdup(purple_request_fields_get_string(fields, "password1"));
-	p2 = g_strdup(purple_request_fields_get_string(fields, "password2"));
-	t = g_strdup(purple_request_fields_get_string(fields, "token"));
-	mail = g_strdup(purple_request_fields_get_string(fields, "email"));
-
-	account = purple_connection_get_account(gc);
-
-	if (cur == NULL || p1 == NULL || p2 == NULL || t == NULL ||
-		mail == NULL || *cur == '\0' || *p1 == '\0' || *p2 == '\0' ||
-		*t == '\0' || *mail == '\0') {
-		purple_notify_error(account, messagesTitle,
-			_("Fill in the fields."), NULL);
-		goto exit_err;
-	}
-
-	if (g_utf8_collate(p1, p2) != 0) {
-		purple_notify_error(account, messagesTitle,
-			_("New passwords do not match."), NULL);
-		goto exit_err;
-	}
-
-	if (strlen(p1) > 15) {
-		purple_notify_error(account, messagesTitle,
-			_("New password should be at most 15 characters long."),
-			NULL);
-		goto exit_err;
-	}
-
-	if (g_utf8_collate(cur, purple_account_get_password(account)) != 0) {
-		purple_notify_error(account, messagesTitle,
-			_("Your current password is different from the one that"
-			" you specified."), NULL);
-		goto exit_err;
-	}
-
-	if (!purple_email_is_valid(mail)) {
-		purple_notify_error(account, messagesTitle,
-			_("Invalid email address"), NULL);
-		goto exit_err;
-	}
-
-	purple_debug_info("gg", "Changing password with email \"%s\"...\n",
-		mail);
-
-	h = gg_change_passwd4(ggp_get_uin(account), mail,
-		purple_account_get_password(account), p1, info->token->id, t,
-		1);
-
-	if (h == NULL)
-		purple_notify_error(account, messagesTitle,
-			_("Unable to change password. Error occurred.\n"),
-			NULL);
-	else
-	{
-		ggp_change_passwd_request *req =
-			g_new(ggp_change_passwd_request, 1);
-		req->http_req = h;
-		req->new_password = g_strdup(p1);
-		req->account = account;
-		
-		req->inpa = ggp_http_input_add(h,
-			ggp_callback_change_passwd_handler, req);
-	}
-	
-exit_err:
-	g_free(cur);
-	g_free(p1);
-	g_free(p2);
-	g_free(t);
-	g_free(mail);
-	g_free(info->token->id);
-	g_free(info->token->data);
-	g_free(info->token);
-}
-
-static void ggp_change_passwd_dialog(PurpleConnection *gc)
-{
-	PurpleRequestFields *fields;
-	PurpleRequestFieldGroup *group;
-	PurpleRequestField *field;
-
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	GGPToken *token = info->token;
-
-	char *msg;
-
-	fields = purple_request_fields_new();
-	group = purple_request_field_group_new(NULL);
-	purple_request_fields_add_group(fields, group);
-
-	field = purple_request_field_string_new("password_cur",
-			_("Current password"), "", FALSE);
-	purple_request_field_string_set_masked(field, TRUE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("password1",
-			_("Password"), "", FALSE);
-	purple_request_field_string_set_masked(field, TRUE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("password2",
-			_("Password (retype)"), "", FALSE);
-	purple_request_field_string_set_masked(field, TRUE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("email",
-			_("Email Address"), "", FALSE);
-	purple_request_field_string_set_masked(field, FALSE);
-	purple_request_field_group_add_field(group, field);
-
-	field = purple_request_field_string_new("token",
-			_("Enter current token"), "", FALSE);
-	purple_request_field_string_set_masked(field, FALSE);
-	purple_request_field_group_add_field(group, field);
-
-	/* original size: 60x24 */
-	field = purple_request_field_image_new("token_img",
-			_("Current token"), token->data, token->size);
-	purple_request_field_group_add_field(group, field);
-
-	msg = g_strdup_printf("%s %d",
-		_("Please, enter your current password and your new password "
-		"for UIN: "), ggp_get_uin(purple_connection_get_account(gc)));
-
-	purple_request_fields(gc,
-		_("Change Gadu-Gadu Password"),
-		_("Change Gadu-Gadu Password"),
-		msg,
-		fields, _("OK"), G_CALLBACK(ggp_callback_change_passwd_ok),
-		_("Cancel"), NULL,
-		purple_connection_get_account(gc), NULL, NULL,
-		gc);
-
-	g_free(msg);
-}
-
-static void ggp_change_passwd(PurplePluginAction *action)
-{
-	PurpleConnection *gc = (PurpleConnection *)action->context;
-
-	ggp_token_request(gc, ggp_change_passwd_dialog);
-}
-
-/* ----- CHANGE STATUS BROADCASTING ------------------------------------------------ */
-
-static void ggp_action_change_status_broadcasting_ok(PurpleConnection *gc, PurpleRequestFields *fields)
-{
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	int selected_field;
-	PurpleAccount *account = purple_connection_get_account(gc);
-	PurpleStatus *status;
-
-	selected_field = purple_request_fields_get_choice(fields, "status_broadcasting");
-	
-	if (selected_field == 0)
-		info->status_broadcasting = TRUE;
-	else
-		info->status_broadcasting = FALSE;
-	
-	status = purple_account_get_active_status(account);
-	
-	ggp_set_status(account, status);
-}
-
-static void ggp_action_change_status_broadcasting(PurplePluginAction *action)
-{
-	PurpleConnection *gc = (PurpleConnection *)action->context;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	
-	PurpleRequestFields *fields;
-	PurpleRequestFieldGroup *group;
-	PurpleRequestField *field;
-
-	fields = purple_request_fields_new();
-	group = purple_request_field_group_new(NULL);
-	purple_request_fields_add_group(fields, group);
-	
-	field = purple_request_field_choice_new("status_broadcasting", _("Show status to:"), 0);
-	purple_request_field_choice_add(field, _("All people"));
-	purple_request_field_choice_add(field, _("Only buddies"));
-	purple_request_field_group_add_field(group, field);
-
-	if (info->status_broadcasting)
-		purple_request_field_choice_set_default_value(field, 0);
-	else
-		purple_request_field_choice_set_default_value(field, 1);
-
-	purple_request_fields(gc,
-		_("Change status broadcasting"),
-		_("Change status broadcasting"),
-		_("Please, select who can see your status"),
-		fields,
-		_("OK"), G_CALLBACK(ggp_action_change_status_broadcasting_ok),
-		_("Cancel"), NULL,
-		purple_connection_get_account(gc), NULL, NULL,
-		gc);
-}
-
 /* ----- CONFERENCES ---------------------------------------------------- */
 
 static void ggp_callback_add_to_chat_ok(PurpleBuddy *buddy, PurpleRequestFields *fields)
@@ -970,164 +381,6 @@
 /* ----- INTERNAL CALLBACKS --------------------------------------------- */
 /* ---------------------------------------------------------------------- */
 
-struct gg_fetch_avatar_data
-{
-	PurpleConnection *gc;
-	gchar *uin;
-	gchar *avatar_url;
-};
-
-
-static void gg_fetch_avatar_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data,
-               const gchar *data, size_t len, const gchar *error_message) {
-	struct gg_fetch_avatar_data *d = user_data;
-	PurpleAccount *account;
-	PurpleBuddy *buddy;
-	gpointer buddy_icon_data;
-
-	purple_debug_info("gg", "gg_fetch_avatar_cb: got avatar image for %s\n",
-		d->uin);
-
-	/* FIXME: This shouldn't be necessary */
-	if (!PURPLE_CONNECTION_IS_VALID(d->gc)) {
-		g_free(d->uin);
-		g_free(d->avatar_url);
-		g_free(d);
-		g_return_if_reached();
-	}
-
-	account = purple_connection_get_account(d->gc);
-	buddy = purple_find_buddy(account, d->uin);
-
-	if (buddy == NULL)
-		goto out;
-
-	buddy_icon_data = g_memdup(data, len);
-
-	purple_buddy_icons_set_for_user(account, purple_buddy_get_name(buddy),
-			buddy_icon_data, len, d->avatar_url);
-	purple_debug_info("gg", "gg_fetch_avatar_cb: UIN %s should have avatar "
-		"now\n", d->uin);
-
-out:
-	g_free(d->uin);
-	g_free(d->avatar_url);
-	g_free(d);
-}
-
-static void gg_get_avatar_url_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data,
-               const gchar *url_text, size_t len, const gchar *error_message) {
-	struct gg_fetch_avatar_data *data;
-	PurpleConnection *gc = user_data;
-	PurpleAccount *account;
-	PurpleBuddy *buddy;
-	const char *uin;
-	const char *is_blank;
-	const char *checksum;
-
-	gchar *bigavatar = NULL;
-	xmlnode *xml = NULL;
-	xmlnode *xmlnode_users;
-	xmlnode *xmlnode_user;
-	xmlnode *xmlnode_avatars;
-	xmlnode *xmlnode_avatar;
-	xmlnode *xmlnode_bigavatar;
-
-	g_return_if_fail(PURPLE_CONNECTION_IS_VALID(gc));
-	account = purple_connection_get_account(gc);
-
-	if (error_message != NULL)
-		purple_debug_error("gg", "gg_get_avatars_cb error: %s\n", error_message);
-	else if (len > 0 && url_text && *url_text) {
-		xml = xmlnode_from_str(url_text, -1);
-		if (xml == NULL)
-			goto out;
-
-		xmlnode_users = xmlnode_get_child(xml, "users");
-		if (xmlnode_users == NULL)
-			goto out;
-
-		xmlnode_user = xmlnode_get_child(xmlnode_users, "user");
-		if (xmlnode_user == NULL)
-			goto out;
-
-		uin = xmlnode_get_attrib(xmlnode_user, "uin");
-
-		xmlnode_avatars = xmlnode_get_child(xmlnode_user, "avatars");
-		if (xmlnode_avatars == NULL)
-			goto out;
-
-		xmlnode_avatar = xmlnode_get_child(xmlnode_avatars, "avatar");
-		if (xmlnode_avatar == NULL)
-			goto out;
-
-		xmlnode_bigavatar = xmlnode_get_child(xmlnode_avatar, "originBigAvatar");
-		if (xmlnode_bigavatar == NULL)
-			goto out;
-
-		is_blank = xmlnode_get_attrib(xmlnode_avatar, "blank");
-		bigavatar = xmlnode_get_data(xmlnode_bigavatar);
-
-		purple_debug_info("gg", "gg_get_avatar_url_cb: UIN %s, IS_BLANK %s, "
-		                        "URL %s\n",
-		                  uin ? uin : "(null)", is_blank ? is_blank : "(null)",
-		                  bigavatar ? bigavatar : "(null)");
-
-		if (uin != NULL && bigavatar != NULL) {
-			buddy = purple_find_buddy(account, uin);
-			if (buddy == NULL)
-				goto out;
-
-			checksum = purple_buddy_icons_get_checksum_for_user(buddy);
-
-			if (purple_strequal(is_blank, "1")) {
-				purple_buddy_icons_set_for_user(account,
-						purple_buddy_get_name(buddy), NULL, 0, NULL);
-			} else if (!purple_strequal(checksum, bigavatar)) {
-				data = g_new0(struct gg_fetch_avatar_data, 1);
-				data->gc = gc;
-				data->uin = g_strdup(uin);
-				data->avatar_url = g_strdup(bigavatar);
-
-				purple_debug_info("gg", "gg_get_avatar_url_cb: "
-					"requesting avatar for %s\n", uin);
-				/* FIXME: This should be cancelled somewhere if not needed. */
-				url_data = purple_util_fetch_url_request(account,
-						bigavatar, TRUE, "Mozilla/4.0 (compatible; MSIE 5.0)",
-						FALSE, NULL, FALSE, -1, gg_fetch_avatar_cb, data);
-			}
-		}
-	}
-
-out:
-	if (xml)
-		xmlnode_free(xml);
-	g_free(bigavatar);
-}
-
-/**
- * Try to update avatar of the buddy.
- *
- * @param gc     PurpleConnection
- * @param uin    UIN of the buddy.
- */
-static void ggp_update_buddy_avatar(PurpleConnection *gc, uin_t uin)
-{
-	gchar *avatarurl;
-	PurpleUtilFetchUrlData *url_data;
-
-	purple_debug_info("gg", "ggp_update_buddy_avatar(gc, %u)\n", uin);
-
-	avatarurl = g_strdup_printf("http://api.gadu-gadu.pl/avatars/%u/0.xml", uin);
-
-	/* FIXME: This should be cancelled somewhere if not needed. */
-	url_data = purple_util_fetch_url_request(
-			purple_connection_get_account(gc), avatarurl, TRUE,
-			"Mozilla/4.0 (compatible; MSIE 5.5)", FALSE, NULL, FALSE, -1,
-			gg_get_avatar_url_cb, gc);
-
-	g_free(avatarurl);
-}
 
 /**
  * Handle change of the status of the buddy.
@@ -1143,14 +396,17 @@
 	gchar *from;
 	const char *st;
 	char *status_msg = NULL;
-
-	ggp_update_buddy_avatar(gc, uin);
+	ggp_buddy_data *buddy_data;
+	PurpleBuddy *buddy;
+	PurpleAccount *account = purple_connection_get_account(gc);
 
 	from = g_strdup_printf("%u", uin);
+	buddy = purple_find_buddy(purple_connection_get_account(gc), from);
 
 	switch (status) {
 		case GG_STATUS_NOT_AVAIL:
 		case GG_STATUS_NOT_AVAIL_DESCR:
+		case GG_STATUS_BLOCKED:
 			st = purple_primitive_get_id_from_type(PURPLE_STATUS_OFFLINE);
 			break;
 		case GG_STATUS_FFC:
@@ -1173,10 +429,6 @@
 		case GG_STATUS_DND_DESCR:
 			st = purple_primitive_get_id_from_type(PURPLE_STATUS_UNAVAILABLE);
 			break;
-		case GG_STATUS_BLOCKED:
-			/* user is blocking us.... */
-			st = "blocked";
-			break;
 		default:
 			st = purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE);
 			purple_debug_info("gg",
@@ -1193,13 +445,27 @@
 		}
 	}
 
+	buddy_data = purple_buddy_get_protocol_data(buddy);
+	if (!buddy_data)
+	{
+		buddy_data = g_new0(ggp_buddy_data, 1);
+		purple_buddy_set_protocol_data(buddy, buddy_data);
+	}
+	buddy_data->blocked = (status == GG_STATUS_BLOCKED);
+
+	if (uin == ggp_str_to_uin(purple_account_get_username(account)))
+	{
+		purple_debug_info("gg", "own status changed to %s [%s]\n", st,
+			status_msg ? status_msg : "");
+	}
+
 	purple_debug_info("gg", "status of %u is %s [%s]\n", uin, st,
 		status_msg ? status_msg : "");
 	if (status_msg == NULL) {
-		purple_prpl_got_user_status(purple_connection_get_account(gc),
+		purple_prpl_got_user_status(account,
 			from, st, NULL);
 	} else {
-		purple_prpl_got_user_status(purple_connection_get_account(gc),
+		purple_prpl_got_user_status(account,
 			from, st, "message", status_msg, NULL);
 		g_free(status_msg);
 	}
@@ -1461,47 +727,6 @@
 	}
 }
 
-static void ggp_recv_image_handler(PurpleConnection *gc, const struct gg_event *ev)
-{
-	gint imgid = 0;
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	GList *entry = g_list_first(info->pending_richtext_messages);
-	gchar *handlerid = g_strdup_printf("IMGID_HANDLER-%i", ev->event.image_reply.crc32);
-
-	imgid = purple_imgstore_add_with_id(
-		g_memdup(ev->event.image_reply.image, ev->event.image_reply.size),
-		ev->event.image_reply.size,
-		ev->event.image_reply.filename);
-
-	purple_debug_info("gg", "ggp_recv_image_handler: got image with crc32: %u\n", ev->event.image_reply.crc32);
-
-	while(entry) {
-		if (strstr((gchar *)entry->data, handlerid) != NULL) {
-			gchar **split = g_strsplit((gchar *)entry->data, handlerid, 3);
-			gchar *text = g_strdup_printf("%s%i%s", split[0], imgid, split[1]);
-			purple_debug_info("gg", "ggp_recv_image_handler: found message matching crc32: %s\n", (gchar *)entry->data);
-			g_strfreev(split);
-			info->pending_richtext_messages = g_list_remove(info->pending_richtext_messages, entry->data);
-			/* We don't have any more images to download */
-			if (strstr(text, "<IMG ID=\"IMGID_HANDLER") == NULL) {
-				gchar *buf = g_strdup_printf("%lu", (unsigned long int)ev->event.image_reply.sender);
-				serv_got_im(gc, buf, text, PURPLE_MESSAGE_IMAGES, time(NULL));
-				g_free(buf);
-				purple_debug_info("gg", "ggp_recv_image_handler: richtext message: %s\n", text);
-				g_free(text);
-				break;
-			}
-			info->pending_richtext_messages = g_list_append(info->pending_richtext_messages, text);
-			break;
-		}
-		entry = g_list_next(entry);
-	}
-	g_free(handlerid);
-
-	return;
-}
-
-
 /**
  * Dispatch a message received from a buddy.
  *
@@ -1510,7 +735,7 @@
  *
  * Image receiving, some code borrowed from Kadu http://www.kadu.net
  */
-static void ggp_recv_message_handler(PurpleConnection *gc, const struct gg_event *ev)
+void ggp_recv_message_handler(PurpleConnection *gc, const struct gg_event_msg *ev, gboolean multilogon)
 {
 	GGPInfo *info = purple_connection_get_protocol_data(gc);
 	PurpleConversation *conv;
@@ -1518,37 +743,38 @@
 	gchar *msg;
 	gchar *tmp;
 	time_t mtime;
+	uin_t sender = ev->sender;
 
-	if (ev->event.msg.message == NULL)
+	if (ev->message == NULL)
 	{
 		purple_debug_warning("gg", "ggp_recv_message_handler: NULL as message pointer\n");
 		return;
 	}
 
-	from = g_strdup_printf("%lu", (unsigned long int)ev->event.msg.sender);
+	from = g_strdup_printf("%lu", (unsigned long int)ev->sender);
 
-	/*
-	tmp = charset_convert((const char *)ev->event.msg.message,
-			      "CP1250", "UTF-8");
-	*/
-	tmp = g_strdup_printf("%s", ev->event.msg.message);
+	tmp = g_strdup_printf("%s", ev->message);
 	purple_str_strip_char(tmp, '\r');
 	msg = g_markup_escape_text(tmp, -1);
 	g_free(tmp);
 
+	if (ev->msgclass & GG_CLASS_QUEUED)
+		mtime = ev->time;
+	else
+		mtime = time(NULL);
+
 	/* We got richtext message */
-	if (ev->event.msg.formats_length)
+	if (ev->formats_length)
 	{
 		gboolean got_image = FALSE, bold = FALSE, italic = FALSE, under = FALSE;
-		char *cformats = (char *)ev->event.msg.formats;
-		char *cformats_end = cformats + ev->event.msg.formats_length;
+		char *cformats = (char *)ev->formats;
+		char *cformats_end = cformats + ev->formats_length;
 		gint increased_len = 0;
 		struct gg_msg_richtext_format *actformat;
 		struct gg_msg_richtext_image *actimage;
 		GString *message = g_string_new(msg);
-		gchar *handlerid;
 
-		purple_debug_info("gg", "ggp_recv_message_handler: richtext msg from (%s): %s %i formats\n", from, msg, ev->event.msg.formats_length);
+		purple_debug_info("gg", "ggp_recv_message_handler: richtext msg from (%s): %s %i formats\n", from, msg, ev->formats_length);
 
 		while (cformats < cformats_end)
 		{
@@ -1569,7 +795,10 @@
 				(actformat->font & GG_FONT_UNDERLINE) != 0,
 				increased_len);
 
-			if (actformat->font & GG_FONT_IMAGE) {
+			if (actformat->font & GG_FONT_IMAGE)
+			{
+				const char *placeholder;
+			
 				got_image = TRUE;
 				actimage = (struct gg_msg_richtext_image*)(cformats);
 				cformats += sizeof(struct gg_msg_richtext_image);
@@ -1582,13 +811,12 @@
 					continue;
 				}
 
-				gg_image_request(info->session, ev->event.msg.sender,
+				gg_image_request(info->session, ev->sender,
 					actimage->size, actimage->crc32);
 
-				handlerid = g_strdup_printf("<IMG ID=\"IMGID_HANDLER-%i\">", actimage->crc32);
-				g_string_insert(message, byteoffset, handlerid);
-				increased_len += strlen(handlerid);
-				g_free(handlerid);
+				placeholder = ggp_image_pending_placeholder(actimage->crc32);
+				g_string_insert(message, byteoffset, placeholder);
+				increased_len += strlen(placeholder);
 				continue;
 			}
 
@@ -1636,80 +864,61 @@
 		msg = message->str;
 		g_string_free(message, FALSE);
 
-		if (got_image) {
-			info->pending_richtext_messages = g_list_append(info->pending_richtext_messages, msg);
+		if (got_image)
+		{
+			ggp_image_got_im(gc, sender, msg, mtime);
 			return;
 		}
 	}
 
-	purple_debug_info("gg", "ggp_recv_message_handler: msg from (%s): %s (class = %d; rcpt_count = %d)\n",
-			from, msg, ev->event.msg.msgclass,
-			ev->event.msg.recipients_count);
+	purple_debug_info("gg", "ggp_recv_message_handler: msg from (%s): %s (class = %d; rcpt_count = %d; multilogon = %d)\n",
+			from, msg, ev->msgclass,
+			ev->recipients_count,
+			multilogon);
 
-	if (ev->event.msg.msgclass & GG_CLASS_QUEUED)
-		mtime = ev->event.msg.time;
-	else
-		mtime = time(NULL);
-
-	if (ev->event.msg.recipients_count == 0) {
+	if (multilogon && ev->recipients_count != 0) {
+		purple_debug_warning("gg", "ggp_recv_message_handler: conference multilogon messages are not yet handled\n");
+	} else if (multilogon) {
+		PurpleAccount *account = purple_connection_get_account(gc);
+		PurpleConversation *conv;
+		const gchar *who = ggp_uin_to_str(ev->sender); // not really sender
+		conv = purple_find_conversation_with_account(
+			PURPLE_CONV_TYPE_IM, who, account);
+		if (conv == NULL)
+			conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, who);
+		purple_conversation_write(conv, purple_account_get_username(account), msg, PURPLE_MESSAGE_SEND, mtime);
+	} else if (ev->recipients_count == 0) {
 		serv_got_im(gc, from, msg, 0, mtime);
 	} else {
 		const char *chat_name;
 		int chat_id;
-		char *buddy_name;
 
 		chat_name = ggp_confer_find_by_participants(gc,
-				ev->event.msg.recipients,
-				ev->event.msg.recipients_count);
+				ev->recipients,
+				ev->recipients_count);
 
 		if (chat_name == NULL) {
 			chat_name = ggp_confer_add_new(gc, NULL);
 			serv_got_joined_chat(gc, info->chats_count, chat_name);
 
 			ggp_confer_participants_add_uin(gc, chat_name,
-							ev->event.msg.sender);
+							ev->sender);
 
 			ggp_confer_participants_add(gc, chat_name,
-						    ev->event.msg.recipients,
-						    ev->event.msg.recipients_count);
+						    ev->recipients,
+						    ev->recipients_count);
 		}
 		conv = ggp_confer_find_by_name(gc, chat_name);
 		chat_id = purple_conv_chat_get_id(PURPLE_CONV_CHAT(conv));
 
-		buddy_name = ggp_buddy_get_name(gc, ev->event.msg.sender);
-		serv_got_chat_in(gc, chat_id, buddy_name,
-				 PURPLE_MESSAGE_RECV, msg, mtime);
-		g_free(buddy_name);
+		serv_got_chat_in(gc, chat_id,
+			ggp_buddylist_get_buddy_name(gc, ev->sender),
+			PURPLE_MESSAGE_RECV, msg, mtime);
 	}
 	g_free(msg);
 	g_free(from);
 }
 
-static void ggp_send_image_handler(PurpleConnection *gc, const struct gg_event *ev)
-{
-	GGPInfo *info = purple_connection_get_protocol_data(gc);
-	PurpleStoredImage *image;
-	gint imgid = GPOINTER_TO_INT(g_hash_table_lookup(info->pending_images, GINT_TO_POINTER(ev->event.image_request.crc32)));
-
-	purple_debug_info("gg", "ggp_send_image_handler: image request received, crc32: %u, imgid: %d\n", ev->event.image_request.crc32, imgid);
-
-	if(imgid)
-	{
-		if((image = purple_imgstore_find_by_id(imgid))) {
-			gint image_size = purple_imgstore_get_size(image);
-			gconstpointer image_bin = purple_imgstore_get_data(image);
-			const char *image_filename = purple_imgstore_get_filename(image);
-
-			purple_debug_info("gg", "ggp_send_image_handler: sending image imgid: %i, crc: %u\n", imgid, ev->event.image_request.crc32);
-			gg_image_reply(info->session, (unsigned long int)ev->event.image_request.sender, image_filename, image_bin, image_size);
-			purple_imgstore_unref(image);
-		} else {
-			purple_debug_error("gg", "ggp_send_image_handler: image imgid: %i, crc: %u in hash but not found in imgstore!\n", imgid, ev->event.image_request.crc32);
-		}
-		g_hash_table_remove(info->pending_images, GINT_TO_POINTER(ev->event.image_request.crc32));
-	}
-}
-
 static void ggp_typing_notification_handler(PurpleConnection *gc, uin_t uin, int length) {
 	gchar *from;
 
@@ -1728,6 +937,7 @@
  * @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)
 {
@@ -1776,7 +986,6 @@
 				purple_debug_info("gg",
 					"ggp_xml_event_handler: avatar updated (uid: %u)\n",
 					event_sender);
-				ggp_update_buddy_avatar(gc, event_sender);
 				break;
 			default:
 				purple_debug_error("gg",
@@ -1811,7 +1020,7 @@
 			/* Nothing happened. */
 			break;
 		case GG_EVENT_MSG:
-			ggp_recv_message_handler(gc, ev);
+			ggp_recv_message_handler(gc, &ev->event.msg, FALSE);
 			break;
 		case GG_EVENT_ACK:
 			/* Changing %u to %i fixes compiler warning */
@@ -1821,10 +1030,10 @@
 				ev->event.ack.seq);
 			break;
 		case GG_EVENT_IMAGE_REPLY:
-			ggp_recv_image_handler(gc, ev);
+			ggp_image_recv(gc, &ev->event.image_reply);
 			break;
 		case GG_EVENT_IMAGE_REQUEST:
-			ggp_send_image_handler(gc, ev);
+			ggp_image_send(gc, &ev->event.image_request);
 			break;
 		case GG_EVENT_NOTIFY:
 		case GG_EVENT_NOTIFY_DESCR:
@@ -1884,22 +1093,6 @@
 			ggp_generic_status_handler(gc, ev->event.status60.uin,
 				GG_S(ev->event.status60.status), ev->event.status60.descr);
 			break;
-		case GG_EVENT_USERLIST:
-			if (ev->event.userlist.type == GG_USERLIST_GET_REPLY) {
-				purple_debug_info("gg", "GG_USERLIST_GET_REPLY\n");
-				purple_notify_info(gc, NULL,
-					_("Buddy list downloaded"),
-					_("Your buddy list was downloaded from the server."));
-				if (ev->event.userlist.reply != NULL) {
-					ggp_buddylist_load(gc, ev->event.userlist.reply);
-				}
-			} else {
-				purple_debug_info("gg", "GG_USERLIST_PUT_REPLY\n");
-				purple_notify_info(gc, NULL,
-					_("Buddy list uploaded"),
-					_("Your buddy list was stored on the server."));
-			}
-			break;
 		case GG_EVENT_PUBDIR50_SEARCH_REPLY:
 			ggp_pubdir_reply_handler(gc, ev->event.pubdir50);
 			break;
@@ -1911,6 +1104,21 @@
 			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_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_multilogon_msg(gc, &ev->event.multilogon_msg);
+			break;
+		case GG_EVENT_MULTILOGON_INFO:
+			ggp_multilogon_info(gc, &ev->event.multilogon_info);
+			break;
 		default:
 			purple_debug_error("gg",
 				"unsupported event type=%d\n", ev->type);
@@ -1998,9 +1206,11 @@
 							  PURPLE_INPUT_READ,
 							  ggp_callback_recv, gc);
 
-				ggp_buddylist_send(gc);
 				purple_connection_update_progress(gc, _("Connected"), 1, 2);
 				purple_connection_set_state(gc, PURPLE_CONNECTED);
+				
+				ggp_buddylist_send(gc);
+				ggp_roster_request_update(gc);
 			}
 			break;
 		case GG_EVENT_CONN_FAILED:
@@ -2105,14 +1315,19 @@
 
 static char *ggp_status_text(PurpleBuddy *b)
 {
-	PurpleStatus *status;
 	const char *msg;
 	char *text;
 	char *tmp;
+	ggp_buddy_data *buddy_data = purple_buddy_get_protocol_data(b);
 
-	status = purple_presence_get_active_status(
-		purple_buddy_get_presence(b));
-	msg = purple_status_get_attr_string(status, "message");
+	if (buddy_data && buddy_data->blocked)
+		msg = _("Blocked");
+	else
+	{
+		PurpleStatus *status = purple_presence_get_active_status(
+			purple_buddy_get_presence(b));
+		msg = purple_status_get_attr_string(status, "message");
+	}
 
 	if (msg == NULL)
 		return NULL;
@@ -2199,15 +1414,6 @@
 		NULL);
 	types = g_list_append(types, type);
 
-	/*
-	 * This status is necessary to display guys who are blocking *us*.
-	 */
-	type = purple_status_type_new_with_attrs(PURPLE_STATUS_INVISIBLE,
-		"blocked", _("Blocked"), TRUE, FALSE, FALSE,
-		"message", _("Message"), purple_value_new(PURPLE_TYPE_STRING),
-		NULL);
-	types = g_list_append(types, type);
-
 	type = purple_status_type_new_with_attrs(PURPLE_STATUS_OFFLINE,
 		NULL, NULL, TRUE, TRUE, FALSE,
 		"message", _("Message"), purple_value_new(PURPLE_TYPE_STRING),
@@ -2257,18 +1463,15 @@
 
 static void ggp_login(PurpleAccount *account)
 {
-	PurpleConnection *gc;
-	PurplePresence *presence;
-	PurpleStatus *status;
+	PurpleConnection *gc = purple_account_get_connection(account);
 	struct gg_login_params *glp;
 	GGPInfo *info;
 	const char *address;
 	const gchar *encryption_type;
 
-	if (ggp_setup_proxy(account) == -1)
+	if (!ggp_deprecated_setup_proxy(gc))
 		return;
 
-	gc = purple_account_get_connection(account);
 	glp = g_new0(struct gg_login_params, 1);
 	info = g_new0(GGPInfo, 1);
 
@@ -2276,17 +1479,19 @@
 	info->session = NULL;
 	info->chats = NULL;
 	info->chats_count = 0;
-	info->token = NULL;
 	info->searches = ggp_search_new();
-	info->pending_richtext_messages = NULL;
-	info->pending_images = g_hash_table_new(g_direct_hash, g_direct_equal);
-	info->status_broadcasting = purple_account_get_bool(account, "status_broadcasting", TRUE);
 	
 	purple_connection_set_protocol_data(gc, info);
 
-	glp->uin = ggp_get_uin(account);
-	glp->password = charset_convert(purple_account_get_password(account),
-		"UTF-8", "CP1250");
+
+	ggp_image_setup(gc);
+	ggp_avatar_setup(gc);
+	ggp_roster_setup(gc);
+	ggp_multilogon_setup(gc);
+	ggp_status_setup(gc);
+	
+	glp->uin = ggp_str_to_uin(purple_account_get_username(account));
+	glp->password = ggp_convert_to_cp1250(purple_account_get_password(account));
 
 	if (glp->uin == 0) {
 		purple_connection_error(gc,
@@ -2302,15 +1507,12 @@
 	if (purple_account_get_bool(account, "show_links_from_strangers", 1))
 		glp->status_flags |= GG_STATUS_FLAG_SPAM;
 
-	presence = purple_account_get_presence(account);
-	status = purple_presence_get_active_status(presence);
-
 	glp->encoding = GG_ENCODING_UTF8;
-	glp->protocol_features = (GG_FEATURE_STATUS80|GG_FEATURE_DND_FFC
-		|GG_FEATURE_TYPING_NOTIFICATION);
+	glp->protocol_features = (GG_FEATURE_DND_FFC |
+		GG_FEATURE_TYPING_NOTIFICATION | GG_FEATURE_MULTILOGON |
+		GG_FEATURE_USER_DATA);
 
 	glp->async = 1;
-	glp->status = ggp_to_gg_status(status, &glp->status_descr);
 	
 	encryption_type = purple_account_get_string(account, "encryption",
 		"opportunistic_tls");
@@ -2333,28 +1535,22 @@
 		glp->tls = GG_SSL_DISABLED;
 	purple_debug_info("gg", "TLS mode: %d\n", glp->tls);
 
-	if (!info->status_broadcasting)
-		glp->status = glp->status|GG_STATUS_FRIENDS_MASK;
+	ggp_status_set_initial(gc, glp);
 	
 	address = purple_account_get_string(account, "gg_server", "");
-	if (address && *address) {
-		/* TODO: Make this non-blocking */
-		struct in_addr *addr = gg_gethostbyname(address);
-
-		purple_debug_info("gg", "Using gg server given by user (%s)\n", address);
-
-		if (addr == NULL) {
-			gchar *tmp = g_strdup_printf(_("Unable to resolve hostname '%s': %s"),
-					address, g_strerror(errno));
+	if (address && *address)
+	{
+		glp->server_addr = inet_addr(address);
+		glp->server_port = 8074;
+		
+		if (glp->server_addr == INADDR_NONE)
+		{
 			purple_connection_error(gc,
-				PURPLE_CONNECTION_ERROR_NETWORK_ERROR, /* should this be a settings error? */
-				tmp);
-			g_free(tmp);
+				PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
+				_("Provided server IP address is not valid"));
+			g_free(glp);
 			return;
 		}
-
-		glp->server_addr = inet_addr(inet_ntoa(*addr));
-		glp->server_port = 8074;
 	} else
 		purple_debug_info("gg", "Trying to retrieve address from gg appmsg service\n");
 
@@ -2387,22 +1583,43 @@
 	if (info) {
 		PurpleStatus *status = purple_account_get_active_status(account);
 
-		if (info->session != NULL) {
-			ggp_set_status(account, status);
+		if (info->session != NULL)
+		{
+			const gchar *status_msg = purple_status_get_attr_string(status, "message");
+			
+			if (ggp_status_set(account,
+				status_msg ? GG_STATUS_NOT_AVAIL_DESCR : GG_STATUS_NOT_AVAIL,
+				status_msg))
+			{
+				struct gg_event *ev;
+				guint64 wait_start = ggp_microtime(), now;
+				int sleep_time = 5000;
+				while ((ev = gg_watch_fd(info->session)) != NULL)
+				{
+					if (ev->type == GG_EVENT_DISCONNECT_ACK)
+						break;
+					now = ggp_microtime();
+					if (now - wait_start + sleep_time >= 100000)
+						break;
+					usleep(sleep_time);
+					sleep_time *= 2;
+				}
+			}
 			gg_logoff(info->session);
 			gg_free_session(info->session);
 		}
 
-		purple_account_set_bool(account, "status_broadcasting", info->status_broadcasting);
-
 		/* Immediately close any notifications on this handle since that process depends
 		 * upon the contents of info->searches, which we are about to destroy.
 		 */
 		purple_notify_close_with_handle(gc);
 
 		ggp_search_destroy(info->searches);
-		g_list_free(info->pending_richtext_messages);
-		g_hash_table_destroy(info->pending_images);
+		ggp_image_cleanup(gc);
+		ggp_avatar_cleanup(gc);
+		ggp_roster_cleanup(gc);
+		ggp_multilogon_cleanup(gc);
+		ggp_status_cleanup(gc);
 
 		if (info->inpa > 0)
 			purple_input_remove(info->inpa);
@@ -2425,11 +1642,16 @@
 	gint pos = 0;
 	GData *attribs;
 	const char *start, *end = NULL, *last;
+	ggp_buddy_data *buddy_data = purple_buddy_get_protocol_data(
+		purple_find_buddy(purple_connection_get_account(gc), who));
 
 	if (msg == NULL || *msg == '\0') {
 		return 0;
 	}
 
+	if (buddy_data && buddy_data->blocked)
+		return -1;
+
 	last = msg;
 
 	/* Check if the message is richtext */
@@ -2439,53 +1661,58 @@
 		GString *string_buffer = g_string_new(NULL);
 		struct gg_msg_richtext fmt;
 
-		do {
-			PurpleStoredImage *image;
-			const char *id;
+		do
+		{
+			const char *id = g_datalist_get_data(&attribs, "id");
+			struct gg_msg_richtext_format actformat;
+			struct gg_msg_richtext_image actimage;
+			ggp_image_prepare_result prepare_result;
 
 			/* Add text before the image */
-			if(start - last) {
+			if(start - last)
+			{
 				pos = pos + g_utf8_strlen(last, start - last);
-				g_string_append_len(string_buffer, last, start - last);
+				g_string_append_len(string_buffer, last,
+					start - last);
+			}
+			last = end + 1;
+			
+			if (id == NULL)
+			{
+				g_datalist_clear(&attribs);
+				continue;
 			}
 
-			if((id = g_datalist_get_data(&attribs, "id")) && (image = purple_imgstore_find_by_id(atoi(id)))) {
-				struct gg_msg_richtext_format actformat;
-				struct gg_msg_richtext_image actimage;
-				gint image_size = purple_imgstore_get_size(image);
-				gconstpointer image_bin = purple_imgstore_get_data(image);
-				const char *image_filename = purple_imgstore_get_filename(image);
-				uint32_t crc32 = gg_crc32(0, image_bin, image_size);
-
-				g_hash_table_insert(info->pending_images, GINT_TO_POINTER(crc32), GINT_TO_POINTER(atoi(id)));
-				purple_imgstore_ref(image);
-				purple_debug_info("gg", "ggp_send_im_richtext: got crc: %u for imgid: %i\n", crc32, atoi(id));
-
+			/* add the image itself */
+			prepare_result = ggp_image_prepare(
+				gc, atoi(id), who, &actimage);
+			if (prepare_result == GGP_IMAGE_PREPARE_OK)
+			{
 				actformat.font = GG_FONT_IMAGE;
 				actformat.position = pos;
 
-				actimage.unknown1 = 0x0109;
-				actimage.size = gg_fix32(image_size);
-				actimage.crc32 = gg_fix32(crc32);
-
-				if (actimage.size > 255000) {
-					purple_debug_warning("gg", "ggp_send_im_richtext: image over 255kb!\n");
-				} else {
-					purple_debug_info("gg", "ggp_send_im_richtext: adding images to richtext, size: %i, crc32: %u, name: %s\n", actimage.size, actimage.crc32, image_filename);
-
-					memcpy(format + format_length, &actformat, sizeof(actformat));
-					format_length += sizeof(actformat);
-					memcpy(format + format_length, &actimage, sizeof(actimage));
-					format_length += sizeof(actimage);
-				}
-			} else {
-				purple_debug_error("gg", "ggp_send_im_richtext: image not found in the image store!");
+				memcpy(format + format_length, &actformat,
+					sizeof(actformat));
+				format_length += sizeof(actformat);
+				memcpy(format + format_length, &actimage,
+					sizeof(actimage));
+				format_length += sizeof(actimage);
 			}
-
-			last = end + 1;
+			else if (prepare_result == GGP_IMAGE_PREPARE_TOO_BIG)
+			{
+				PurpleConversation *conv =
+					purple_find_conversation_with_account(
+						PURPLE_CONV_TYPE_IM, who,
+						purple_connection_get_account(gc));
+				purple_conversation_write(conv, "",
+					_("Image is too large, please try "
+					"smaller one."), PURPLE_MESSAGE_ERROR,
+					time(NULL));
+			}
+			
 			g_datalist_clear(&attribs);
-
-		} while(purple_markup_find_tag("img", last, &start, &end, &attribs));
+		} while (purple_markup_find_tag("img", last, &start, &end,
+			&attribs));
 
 		/* Add text after the images */
 		if(last && *last) {
@@ -2505,10 +1732,7 @@
 		plain = purple_unescape_html(msg);
 	}
 
-	/*
-	tmp = charset_convert(plain, "UTF-8", "CP1250");
-	*/
-	tmp = g_strdup_printf("%s", plain);
+	tmp = g_strdup(plain);
 
 	if (tmp && (format_length - sizeof(struct gg_msg_richtext))) {
 		if(gg_send_message_richtext(info->session, GG_CLASS_CHAT, ggp_str_to_uin(who), (unsigned char *)tmp, format, format_length) < 0) {
@@ -2570,101 +1794,19 @@
 	purple_debug_info("gg", "ggp_get_info(): Added seq %u", seq);
 }
 
-static int ggp_to_gg_status(PurpleStatus *status, char **msg)
-{
-	const char *status_id = purple_status_get_id(status);
-	int new_status, new_status_descr;
-	const char *new_msg;
-
-	g_return_val_if_fail(msg != NULL, 0);
-
-	purple_debug_info("gg", "ggp_to_gg_status: Requested status = %s\n",
-			status_id);
-
-	if (strcmp(status_id, "available") == 0) {
-		new_status = GG_STATUS_AVAIL;
-		new_status_descr = GG_STATUS_AVAIL_DESCR;
-	} else if (strcmp(status_id, "freeforchat") == 0) {
-		new_status = GG_STATUS_FFC;
-		new_status_descr = GG_STATUS_FFC_DESCR;
-	} else if (strcmp(status_id, "away") == 0) {
-		new_status = GG_STATUS_BUSY;
-		new_status_descr = GG_STATUS_BUSY_DESCR;
-	} else if (strcmp(status_id, "unavailable") == 0) {
-		new_status = GG_STATUS_DND;
-		new_status_descr = GG_STATUS_DND_DESCR;
-	} else if (strcmp(status_id, "invisible") == 0) {
-		new_status = GG_STATUS_INVISIBLE;
-		new_status_descr = GG_STATUS_INVISIBLE_DESCR;
-	} else if (strcmp(status_id, "offline") == 0) {
-		new_status = GG_STATUS_NOT_AVAIL;
-		new_status_descr = GG_STATUS_NOT_AVAIL_DESCR;
-	} else {
-		new_status = GG_STATUS_AVAIL;
-		new_status_descr = GG_STATUS_AVAIL_DESCR;
-		purple_debug_info("gg",
-			"ggp_set_status: unknown status requested (status_id=%s)\n",
-			status_id);
-	}
-
-	new_msg = purple_status_get_attr_string(status, "message");
-
-	if(new_msg) {
-		/*
-		char *tmp = purple_markup_strip_html(new_msg);
-		*msg = charset_convert(tmp, "UTF-8", "CP1250");
-		g_free(tmp);
-		*/
-		*msg = purple_markup_strip_html(new_msg);
-
-		return new_status_descr;
-	} else {
-		*msg = NULL;
-		return new_status;
-	}
-}
-
-static void ggp_set_status(PurpleAccount *account, PurpleStatus *status)
-{
-	PurpleConnection *gc;
-	GGPInfo *info;
-	int new_status;
-	char *new_msg = NULL;
-
-	if (!purple_status_is_active(status))
-		return;
-
-	gc = purple_account_get_connection(account);
-	info = purple_connection_get_protocol_data(gc);
-
-	new_status = ggp_to_gg_status(status, &new_msg);
-
-	if (!info->status_broadcasting)
-		new_status = new_status|GG_STATUS_FRIENDS_MASK;
-	
-	if (new_msg == NULL) {
-		gg_change_status(info->session, new_status);
-	} else {
-		gg_change_status_descr(info->session, new_status, new_msg);
-		g_free(new_msg);
-	}
-
-	ggp_status_fake_to_self(account);
-
-}
-
 static void ggp_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group, const char *message)
 {
-	PurpleAccount *account;
+	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));
 
-	account = purple_connection_get_account(gc);
-	if (strcmp(purple_account_get_username(account), name) == 0) {
-		ggp_status_fake_to_self(account);
-	}
+	// gg server won't tell us our status here
+	if (strcmp(purple_account_get_username(account), name) == 0)
+		ggp_status_fake_to_self(gc);
+	
+	ggp_roster_add_buddy(gc, buddy, group, message);
 }
 
 static void ggp_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
@@ -2673,6 +1815,7 @@
 	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(gc, buddy, group);
 }
 
 static void ggp_join_chat(PurpleConnection *gc, GHashTable *data)
@@ -2750,11 +1893,6 @@
 		uins[count++] = uin;
 	}
 
-	/*
-	plain = purple_unescape_html(message);
-	msg = charset_convert(plain, "UTF-8", "CP1250");
-	g_free(plain);
-	*/
 	msg = purple_unescape_html(message);
 	gg_send_message_confer(info->session, GG_CLASS_CHAT, count, uins,
 				(unsigned char *)msg);
@@ -2783,11 +1921,14 @@
 	}
 }
 
-static void ggp_register_user(PurpleAccount *account)
+static void ggp_action_chpass(PurplePluginAction *action)
 {
-	PurpleConnection *gc = purple_account_get_connection(account);
+	ggp_account_chpass((PurpleConnection *)action->context);
+}
 
-	ggp_token_request(gc, ggp_register_user_dialog);
+static void ggp_action_status_broadcasting(PurplePluginAction *action)
+{
+	ggp_status_broadcasting_dialog((PurpleConnection *)action->context);
 }
 
 static GList *ggp_actions(PurplePlugin *plugin, gpointer context)
@@ -2796,31 +1937,19 @@
 	PurplePluginAction *act;
 
 	act = purple_plugin_action_new(_("Change password..."),
-				     ggp_change_passwd);
+		ggp_action_chpass);
 	m = g_list_append(m, act);
 
 	act = purple_plugin_action_new(_("Find buddies..."),
 				     ggp_find_buddies);
 	m = g_list_append(m, act);
 
-	act = purple_plugin_action_new(_("Change status broadcasting"),
-				     ggp_action_change_status_broadcasting);
+	act = purple_plugin_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_plugin_action_new(_("Upload buddylist to Server"),
-				     ggp_action_buddylist_put);
-	m = g_list_append(m, act);
-
-	act = purple_plugin_action_new(_("Download buddylist from Server"),
-				     ggp_action_buddylist_get);
-	m = g_list_append(m, act);
-
-	act = purple_plugin_action_new(_("Delete buddylist from Server"),
-				     ggp_action_buddylist_delete);
-	m = g_list_append(m, act);
-
 	act = purple_plugin_action_new(_("Save buddylist to file..."),
 				     ggp_action_buddylist_save);
 	m = g_list_append(m, act);
@@ -2832,20 +1961,53 @@
 	return m;
 }
 
+static const char* ggp_list_emblem(PurpleBuddy *buddy)
+{
+	ggp_buddy_data *buddy_data = purple_buddy_get_protocol_data(buddy);
+
+	if (!buddy_data)
+		return NULL;
+
+	if (buddy_data->blocked)
+		return "not-authorized";
+
+	return NULL;
+}
+
+static void ggp_buddy_free(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);
+}
+
 static gboolean ggp_offline_message(const PurpleBuddy *buddy)
 {
 	return TRUE;
 }
 
+static GHashTable * ggp_get_account_text_table(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 PurplePluginProtocolInfo prpl_info =
 {
 	sizeof(PurplePluginProtocolInfo),       /* struct_size */
 	OPT_PROTO_REGISTER_NOSCREENNAME | OPT_PROTO_IM_IMAGE,
 	NULL,				/* user_splits */
 	NULL,				/* protocol_options */
-	{"png", 32, 32, 96, 96, 0, PURPLE_ICON_SCALE_DISPLAY},	/* icon_spec */
+	{"png", 1, 1, 200, 200, 0, PURPLE_ICON_SCALE_DISPLAY | PURPLE_ICON_SCALE_SEND},	/* icon_spec */
 	ggp_list_icon,			/* list_icon */
-	NULL,				/* list_emblem */
+	ggp_list_emblem,		/* list_emblem */
 	ggp_status_text,		/* status_text */
 	ggp_tooltip_text,		/* tooltip_text */
 	ggp_status_types,		/* status_types */
@@ -2858,7 +2020,7 @@
 	NULL,				/* set_info */
 	ggp_send_typing,		/* send_typing */
 	ggp_get_info,			/* get_info */
-	ggp_set_status,			/* set_away */
+	ggp_status_set_purplestatus,	/* set_away */
 	NULL,				/* set_idle */
 	NULL,				/* change_passwd */
 	ggp_add_buddy,			/* add_buddy */
@@ -2878,15 +2040,15 @@
 	NULL,				/* chat_whisper */
 	ggp_chat_send,			/* chat_send */
 	ggp_keepalive,			/* keepalive */
-	ggp_register_user,		/* register_user */
+	ggp_account_register,		/* register_user */
 	NULL,				/* get_cb_info */
-	NULL,				/* alias_buddy */
-	NULL,				/* group_buddy */
-	NULL,				/* rename_group */
-	NULL,				/* buddy_free */
+	ggp_roster_alias_buddy,		/* alias_buddy */
+	ggp_roster_group_buddy,		/* group_buddy */
+	ggp_roster_rename_group,	/* rename_group */
+	ggp_buddy_free,			/* buddy_free */
 	NULL,				/* convo_closed */
 	ggp_normalize,			/* normalize */
-	NULL,				/* set_buddy_icon */
+	ggp_avatar_own_set,		/* set_buddy_icon */
 	NULL,				/* remove_group */
 	NULL,				/* get_cb_real_name */
 	NULL,				/* set_chat_topic */
@@ -2904,7 +2066,7 @@
 	NULL,				/* unregister_user */
 	NULL,				/* send_attention */
 	NULL,				/* get_attention_types */
-	NULL,                           /* get_account_text_table */
+	ggp_get_account_text_table,	/* get_account_text_table */
 	NULL,                           /* initiate_media */
 	NULL,                            /* can_do_media */
 	NULL,				/* get_moods */
@@ -2975,6 +2137,9 @@
 	PurpleAccountOption *option;
 	GList *encryption_options = NULL;
 
+	purple_debug_info("gg", "Loading Gadu-Gadu protocol plugin with "
+		"libgadu %s...\n", gg_libgadu_version());
+
 	option = purple_account_option_string_new(_("GG server"),
 			"gg_server", "");
 	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
@@ -3002,14 +2167,9 @@
 	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
 		option);
 
-	my_protocol = plugin;
-
 	gg_debug_handler = purple_gg_debug_handler;
 	
-#ifdef _WIN32
-	gg_global_set_custom_resolver(ggp_resolver_win32thread_start,
-		ggp_resolver_win32thread_cleanup);
-#endif
+	ggp_resolver_purple_setup();
 }
 
 PURPLE_INIT_PLUGIN(gg, init_plugin, info);

--- a/libpurple/protocols/gg/gg.h	Tue Aug 14 22:05:05 2012 +0200
+++ b/libpurple/protocols/gg/gg.h	Tue Aug 14 22:26:33 2012 +0200
@@ -24,15 +24,22 @@
 #ifndef _PURPLE_GG_H
 #define _PURPLE_GG_H
 
-#undef printf
 #include <libgadu.h>
 #include "internal.h"
 #include "search.h"
 #include "connection.h"
 
+#include "image.h"
+#include "avatar.h"
+#include "account.h"
+#include "roster.h"
+#include "multilogon.h"
+#include "status.h"
 
 #define PUBDIR_RESULTS_MAX 20
 
+#define GGP_UIN_LEN_MAX 10
+
 
 typedef struct
 {
@@ -41,34 +48,21 @@
 
 } GGPChat;
 
-typedef void (*GGPTokenCallback)(PurpleConnection *);
-
-typedef struct
-{
-	char *id;
-	char *data;
-	unsigned int size;
-
-	struct gg_http *req;
-	guint inpa;
-
-	GGPTokenCallback cb;
-
-} GGPToken;
-
 typedef struct {
 
 	struct gg_session *session;
 	guint inpa;
-	GGPToken *token;
 	GList *chats;
 	GGPSearches *searches;
 	int chats_count;
-	GList *pending_richtext_messages;
-	GHashTable *pending_images;
-	gboolean status_broadcasting; //When TRUE status is visible to all, when FALSE status is visible only to friends.
+
+	ggp_image_connection_data image_data;
+	ggp_avatar_session_data avatar_data;
+	ggp_roster_session_data roster_data;
+	ggp_multilogon_session_data *multilogon_data;
+	ggp_status_session_data *status_data;
 } GGPInfo;
 
-#endif /* _PURPLE_GG_H */
+void ggp_recv_message_handler(PurpleConnection *gc, const struct gg_event_msg *ev, gboolean multilogon);
 
-/* vim: set ts=8 sts=0 sw=8 noet: */
+#endif /* _PURPLE_GG_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/libpurple/protocols/gg/image.c	Tue Aug 14 22:26:33 2012 +0200
@@ -0,0 +1,265 @@
+#include "image.h"
+
+#include <debug.h>
+
+#include "gg.h"
+#include "utils.h"
+
+#define GGP_PENDING_IMAGE_ID_PREFIX "gg-pending-image-"
+
+typedef struct
+{
+	uin_t from;
+	gchar *text;
+	time_t mtime;
+} ggp_image_pending_message;
+
+typedef struct
+{
+	int id;
+	gchar *conv_name;
+} ggp_image_pending_image;
+
+static void ggp_image_pending_message_free(gpointer data)
+{
+	ggp_image_pending_message *pending_message =
+		(ggp_image_pending_message*)data;
+	g_free(pending_message->text);
+	g_free(pending_message);
+}
+
+static void ggp_image_pending_image_free(gpointer data)
+{
+	ggp_image_pending_image *pending_image =
+		(ggp_image_pending_image*)data;
+	g_free(pending_image->conv_name);
+	g_free(pending_image);
+}
+
+static inline ggp_image_connection_data *
+ggp_image_get_imgdata(PurpleConnection *gc)
+{
+	GGPInfo *accdata = purple_connection_get_protocol_data(gc);
+	return &accdata->image_data;
+}
+
+void ggp_image_setup(PurpleConnection *gc)
+{
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	
+	imgdata->pending_messages = NULL;
+	imgdata->pending_images = g_hash_table_new_full(NULL, NULL, NULL,
+		ggp_image_pending_image_free);
+}
+
+void ggp_image_cleanup(PurpleConnection *gc)
+{
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	
+	g_list_free_full(imgdata->pending_messages,
+		&ggp_image_pending_message_free);
+	g_hash_table_destroy(imgdata->pending_images);
+}
+
+const char * ggp_image_pending_placeholder(uint32_t id)
+{
+	static char buff[50];
+	
+	g_snprintf(buff, 50, "<img id=\"" GGP_PENDING_IMAGE_ID_PREFIX
+		"%u\">", id);
+	
+	return buff;
+}
+
+void ggp_image_got_im(PurpleConnection *gc, uin_t from, gchar *text,
+	time_t mtime)
+{
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	ggp_image_pending_message *pending_message =
+		g_new(ggp_image_pending_message, 1);
+	
+	purple_debug_info("gg", "ggp_image_got_im: received message with "
+		"images from %u: %s\n", from, text);
+	
+	pending_message->from = from;
+	pending_message->text = text;
+	pending_message->mtime = mtime;
+	
+	imgdata->pending_messages = g_list_append(imgdata->pending_messages,
+		pending_message);
+}
+
+ggp_image_prepare_result ggp_image_prepare(PurpleConnection *gc, const int id,
+	const char *conv_name, struct gg_msg_richtext_image *image_info)
+{
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	PurpleStoredImage *image = purple_imgstore_find_by_id(id);
+	size_t image_size;
+	gconstpointer image_data;
+	const char *image_filename;
+	uint32_t image_crc;
+	ggp_image_pending_image *pending_image;
+	
+	if (!image)
+	{
+		purple_debug_error("gg", "ggp_image_prepare_to_send: image %d "
+			"not found in image store\n", id);
+		return GGP_IMAGE_PREPARE_FAILURE;
+	}
+	
+	image_size = purple_imgstore_get_size(image);
+	
+	if (image_size > GGP_IMAGE_SIZE_MAX)
+	{
+		purple_debug_warning("gg", "ggp_image_prepare_to_send: image "
+			"is too big (max bytes: %d)\n", GGP_IMAGE_SIZE_MAX);
+		return GGP_IMAGE_PREPARE_TOO_BIG;
+	}
+	
+	purple_imgstore_ref(image);
+	image_data = purple_imgstore_get_data(image);
+	image_filename = purple_imgstore_get_filename(image);
+	image_crc = gg_crc32(0, image_data, image_size);
+	
+	purple_debug_info("gg", "ggp_image_prepare_to_send: image prepared "
+		"[id=%d, crc=%u, size=%d, filename=%s]\n",
+		id, image_crc, image_size, image_filename);
+	
+	pending_image = g_new(ggp_image_pending_image, 1);
+	pending_image->id = id;
+	pending_image->conv_name = g_strdup(conv_name);
+	g_hash_table_insert(imgdata->pending_images, GINT_TO_POINTER(image_crc),
+		pending_image);
+	
+	image_info->unknown1 = 0x0109;
+	image_info->size = gg_fix32(image_size);
+	image_info->crc32 = gg_fix32(image_crc);
+	
+	return GGP_IMAGE_PREPARE_OK;
+}
+
+void ggp_image_recv(PurpleConnection *gc,
+	const struct gg_event_image_reply *image_reply)
+{
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	int stored_id;
+	const char *imgtag_search;
+	gchar *imgtag_replace;
+	GList *pending_messages_it;
+	
+	stored_id = purple_imgstore_add_with_id(
+		g_memdup(image_reply->image, image_reply->size),
+		image_reply->size,
+		image_reply->filename);
+	
+	purple_debug_info("gg", "ggp_image_recv: got image "
+		"[id=%d, crc=%u, size=%u, filename=\"%s\"]\n",
+		stored_id,
+		image_reply->crc32,
+		image_reply->size,
+		image_reply->filename);
+
+	imgtag_search = ggp_image_pending_placeholder(image_reply->crc32);
+	imgtag_replace = g_strdup_printf("<img src=\""
+		PURPLE_STORED_IMAGE_PROTOCOL "%u\">", stored_id);
+
+	pending_messages_it = g_list_first(imgdata->pending_messages);
+	while (pending_messages_it)
+	{
+		ggp_image_pending_message *pending_message =
+			(ggp_image_pending_message*)pending_messages_it->data;
+		gchar *newText;
+		
+		if (strstr(pending_message->text, imgtag_search) == NULL)
+		{
+			pending_messages_it = g_list_next(pending_messages_it);
+			continue;
+		}
+		
+		purple_debug_misc("gg", "ggp_image_recv: found message "
+			"containing image: %s\n", pending_message->text);
+		
+		newText = purple_strreplace(pending_message->text,
+			imgtag_search, imgtag_replace);
+		g_free(pending_message->text);
+		pending_message->text = newText;
+
+		if (strstr(pending_message->text,
+			"<img id=\"" GGP_PENDING_IMAGE_ID_PREFIX) == NULL)
+		{
+			purple_debug_info("gg", "ggp_image_recv: "
+				"message is ready to display\n");
+			serv_got_im(gc, ggp_uin_to_str(pending_message->from),
+				pending_message->text,
+				PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_IMAGES,
+				pending_message->mtime);
+			
+			ggp_image_pending_message_free(pending_message);
+			imgdata->pending_messages = g_list_remove(
+				imgdata->pending_messages, pending_message);
+		}
+		
+		pending_messages_it = g_list_next(pending_messages_it);
+	}
+	g_free(imgtag_replace);
+}
+
+void ggp_image_send(PurpleConnection *gc,
+	const struct gg_event_image_request *image_request)
+{
+	GGPInfo *accdata = purple_connection_get_protocol_data(gc);
+	ggp_image_connection_data *imgdata = ggp_image_get_imgdata(gc);
+	ggp_image_pending_image *pending_image;
+	PurpleStoredImage *image;
+	PurpleConversation *conv;
+	
+	purple_debug_info("gg", "ggp_image_send: got image request "
+		"[uin=%u, crc=%u, size=%u]\n",
+		image_request->sender,
+		image_request->crc32,
+		image_request->size);
+	
+	pending_image = g_hash_table_lookup(imgdata->pending_images,
+		GINT_TO_POINTER(image_request->crc32));
+	
+	if (pending_image == NULL)
+	{
+		purple_debug_warning("gg", "ggp_image_send: requested image "
+			"not found\n");
+		return;
+	}
+	
+	purple_debug_misc("gg", "ggp_image_send: requested image found "
+		"[id=%d, conv=%s]\n",
+		pending_image->id,
+		pending_image->conv_name);
+	
+	image = purple_imgstore_find_by_id(pending_image->id);
+	
+	if (!image)
+	{
+		purple_debug_error("gg", "ggp_image_send: requested image "
+			"found, but doesn't exists in image store\n");
+		g_hash_table_remove(imgdata->pending_images,
+			GINT_TO_POINTER(image_request->crc32));
+		return;
+	}
+	
+	//TODO: check allowed recipients
+	gg_image_reply(accdata->session, image_request->sender,
+		purple_imgstore_get_filename(image),
+		purple_imgstore_get_data(image),
+		purple_imgstore_get_size(image));
+	purple_imgstore_unref(image);
+	
+	conv = purple_find_conversation_with_account(
+		PURPLE_CONV_TYPE_IM, pending_image->conv_name,
+		purple_connection_get_account(gc));
+	if (conv != NULL)
+		purple_conversation_write(conv, "", _("Image delivered."),
+			PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_NOTIFY,
+			time(NULL));
+	
+	g_hash_table_remove(imgdata->pending_images,
+		GINT_TO_POINTER(image_request->crc32));
+}